Hibernate配置文件和映射元素解释

 

2012-02-06 13:34 ysynlm ysynlm的博客 字号：T | T
一键收藏，随时查看，分享好友！

对象关系的映射是用一个XML文档来说明的。映射文档可以使用工具来生成，如XDoclet，Middlegen和AndroMDA等。下面从一个映射的例子开始讲解映射元素。

AD：51CTO 网+ 第十二期沙龙：大话数据之美_如何用数据驱动用户体验

 

  1. <!--标准的XML文件的起始行，version='1.0'表明XML的版本，encoding='gb2312'表明XML文件的编码方式--> 
  2.                  <?xml version='1.0' encoding='gb2312'?> 
  3. <!--表明解析本XML文件的DTD文档位置，DTD是Document Type Definition 的缩写,即文档类型的定义,XML解析器使用DTD文档来检查XML文件的合法性。hibernate.sourceforge.net/hibernate-configuration-3.0dtd可以在Hibernate3.1.3软件包中的src/org/hibernate目录中找到此文件--> 
  4. <!DOCTYPE hibernate-configuration PUBLIC  
  5.           "-//Hibernate/Hibernate Configuration DTD 3.0//EN"  
  6.           "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd"> 
  7.     <!--声明Hibernate配置文件的开始-->        
  8.     <hibernate-configuration> 
  9.     <!--表明以下的配置是针对session-factory配置的，SessionFactory是Hibernate中的一个类，这个类主要负责保存HIbernate的配置信息，以及对Session的操作--> 
  10.        <session-factory>      
  11.       <!--配置数据库的驱动程序，Hibernate在连接数据库时，需要用到数据库的驱动程序--> 
  12.            <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>   
  13.        <!--设置数据库的连接url:jdbc:mysql://localhost/hibernate,其中localhost表示mysql服务器名称，此处为本机，     hibernate是数据库名-->    
  14.             <property name="hibernate.connection.url">jdbc:mysql://localhost/hibernate</hibernate> 
  15.     <!--连接数据库是用户名--> 
  16.            <property name="hibernate.connection.username">root</property>   
  17.           <!--连接数据库是密码--> 
  18.            <property name="hibernate.connection.password">123456</property>           
  19.           <!--数据库连接池的大小--> 
  20.            <property name="hibernate.connection.pool.size">20</property>          
  21.          <!--是否在后台显示Hibernate用到的SQL语句，开发时设置为true，便于差错，程序运行时可以在Eclipse的控制台显示Hibernate的执行Sql语句。项目部署后可以设置为false，提高运行效率--> 
  22.          <property name="hibernate.show_sql">true</property> 
  23.          <!--jdbc.fetch_size是指Hibernate每次从数据库中取出并放到JDBC的Statement中的记录条数。Fetch Size设的越大，读数据库的次数越少，速度越快，Fetch Size越小，读数据库的次数越多，速度越慢--> 
  24.          <property name="jdbc.fetch_size">50</property> 
  25.          <!--jdbc.batch_size是指Hibernate批量插入,删除和更新时每次操作的记录数。Batch Size越大，批量操作的向数据库发送Sql的次数越少，速度就越快，同样耗用内存就越大--> 
  26.          <property name="jdbc.batch_size">23</property> 
  27.          <!--jdbc.use_scrollable_resultset是否允许Hibernate用JDBC的可滚动的结果集。对分页的结果集。对分页时的设置非常有帮助--> 
  28.          <property name="jdbc.use_scrollable_resultset">false</property> 
  29.          <!--connection.useUnicode连接数据库时是否使用Unicode编码--> 
  30.          <property name="Connection.useUnicode">true</property> 
  31.          <!--connection.characterEncoding连接数据库时数据的传输字符集编码方式，最好设置为gbk，用gb2312有的字符不全--> 
  32.     <property name="connection.characterEncoding">gbk</property>        
  33.            
  34.          <!--hibernate.dialect 只是Hibernate使用的数据库方言,就是要用Hibernate连接那种类型的数据库服务器。--> 
  35.            <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property> 
  36.          <!--指定映射文件为“hibernate/ch1/UserInfo.hbm.xml”-->           
  37.            <mapping resource="org/mxg/UserInfo.hbm.xml"> 
  38.   </session-factory> 
  39.   </hibernate-configuration> 

 配置文件中映射元素详解

对象关系的映射是用一个XML文档来说明的。映射文档可以使用工具来生成，如XDoclet，Middlegen和AndroMDA等。下面从一个映射的例子开始讲解映射元素，映射文件的代码如下。

  1. ＜?xml version="1.0"?＞  
  2. ＜!--  
  3. 所有的XML映射文件都需要定义如下所示的DOCTYPE。  
  4. Hibernate会先在它的类路径（classptah）中搜索DTD文件。  
  5. --＞  
  6. ＜!DOCTYPE hibernate-mapping PUBLIC  
  7. "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  8. "http：//hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"＞  
  9. ＜!--  
  10. hibernate-mapping有几个可选的属性：  
  11. schema属性指明了这个映射的表所在的schema名称。  
  12. default-cascade属性指定了默认的级联风格 可取值有 none、save、update。  
  13. auto-import属性默认让我们在查询语言中可以使用非全限定名的类名 可取值有 true、false。  
  14. package属性指定一个包前缀。  
  15. --＞  
  16. ＜hibernate-mapping schema="schemaName" default-cascade="none" 
  17. auto-import="true" package="test"＞  
  18. ＜!--用class元素来定义一个持久化类 --＞  
  19. ＜class name="People" table="person"＞  
  20. ＜!-- id元素定义了属性到数据库表主键字段的映射。--＞  
  21. ＜id name="id"＞  
  22. ＜!-- 用来为该持久化类的实例生成唯一的标识 --＞  
  23. ＜generator class="native"/＞  
  24. ＜/id＞  
  25. ＜!-- discriminator识别器 是一种定义继承关系的映射方法--＞  
  26. ＜discriminator column="subclass" type="character"/＞  
  27. ＜!-- property元素为类声明了一个持久化的，JavaBean风格的属性--＞  
  28. ＜property name="name" type="string"＞  
  29. ＜column name="name" length="64" not-null="true" /＞  
  30. ＜/property＞  
  31. ＜property name="sex" 
  32. not-null="true" 
  33. update="false"/＞  
  34. ＜!--多对一映射关系--＞  
  35. ＜many-to-one name="friend" 
  36. column="friend_id" 
  37. update="false"/＞  
  38. ＜!--设置关联关系--＞  
  39. ＜set name="friends" inverse="true" order-by="id"＞  
  40. ＜key column="friend_id"/＞  
  41. ＜!—一对多映射--＞  
  42. ＜one-to-many class="Cat"/＞  
  43. ＜/set＞  
  44. ＜/class＞  
  45. ＜/hibernate-mapping＞ 

组件应用的方法

组件有两种类型，即组件（component）和动态组件（dynamic-component）。在配置文件中，component元素为子对象的元素与父类对应表的字段建立起映射关系。然后组件可以声明它们自己的属性、组件或者集合。component元素的定义如下所示：

  1. ＜component name="propertyName" class="className" insert="true|false" 
  2. upate="true|false" access="field|property|ClassName"＞  
  3. ＜property ...../＞  
  4. ＜many-to-one .... /＞  
  5. ........  
  6. ＜/component＞  

在这段代码中，name是指属性名，class是类的名字，insert指的是被映射的字段是否出现在SQL的INSERT语句中，upate指出被映射的字段是否出现在SQL的UPDATE语句中，access指出访问属性的策略。

Hiebernate的基本配置

Hibernate的数据库连接信息是从配置文件中加载的。Hibernate的配置文件有两种形式：一种是XML格式的文件，一种是properties属性文件。properties形式的配置文件默认文件名是hibernate.properties，一个properties形式的配置文件内容如下所示：

  1. #指定数据库使用的驱动类  
  2. hibernate.connection.driver_class = com.mysql.jdbc.Driver r  
  3. #指定数据库连接串  
  4. hibernate.connection.url = jdbc:mysql://localhost:3306/db  
  5. #指定数据库连接的用户名  
  6. hibernate.connection.username = user 
  7. #指定数据库连接的密码  
  8. hibernate.connection.password = password 
  9. #指定数据库使用的方言  
  10. hibernate.dialect = net.sf.hibernate.dialect.MySQLDialect  
  11. #指定是否打印SQL语句  
  12. hibernate.show_sql=true 

在配置文件中包含了一系列属性的配置，Hibernate将根据这些属性来连接数据库。

在XML格式的配置文件中，除了基本的Hibernate配置信息，还可以指定具体的持久化类的映射文件，这可以避免将持久化类的配置文件硬编码在程序中。XML格式的配置文件的默认文件名为hibernate.cfg.xml，一个XML配置文件的示例如下所示：

  1. ＜?xml version=''1.0'' encoding=''UTF-8''?＞  
  2. ＜!DOCTYPE hibernate-configuration PUBLIC  
  3. "-//Hibernate/Hibernate Configuration DTD 3.0//EN"  
  4. "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd"＞  
  5. ＜hibernate-configuration＞  
  6. ＜session-factory＞  
  7. ＜!--显示执行的SQL语句--＞  
  8. ＜property name="show_sql"＞true＜/property＞  
  9. ＜!--连接字符串--＞  
  10. ＜property name="connection.url"＞jdbc:mysql://localhost:3306/STU＜/property＞  
  11. ＜!--连接数据库的用户名--＞  
  12. ＜property name="connection.username"＞root＜/property＞  
  13. ＜!--数据库用户密码--＞  
  14. ＜property name="connection.password"＞root＜/property＞  
  15. ＜!--数据库驱动--＞  
  16. ＜property name="connection.driver_class"＞com.mysql.jdbc.Driver＜/property＞  
  17. ＜!--选择使用的方言--＞  
  18. ＜property name="dialect"＞org.hibernate.dialect.MySQLDialect＜/property＞  
  19. ＜!--映射文件 --＞  
  20. ＜mapping resource="com/stuman/domain/Admin.hbm.xml" /＞  
  21. ＜!--映射文件--＞  
  22. ＜mapping resource="com/stuman/domain/Student.hbm.xml" /＞  
  23. ＜/session-factory＞  
  24. ＜/hibernate-configuration＞  

properties形式的配置文件和XML格式的配置文件可以同时使用。当同时使用两种类型的配置文件时，XML配置文件中的设置会覆盖properties配置文件的相同的属性。

对象标识符号

在关系数据库表中，主键（Primary Key）用来识别记录，并保证每条记录的唯一性。在Java语言中，通过比较两个变量所引用对象的内存地址是否相同，或者比较两个变量引用的对象值是否相同来判断两对象是否相等。Hibernate为了解决两者之间的不同，使用对象标识符（OID）来标识对象的唯一性。OID是关系数据库中主键在Java对象模型中的等价物。在运行时，Hibernate根据OID来维持Java对象和数据库表中记录的对应关系。如下代码所示，三次调用了Session的load()方法，分别加载OID为1或3的User对象。

  1. Transaction tx = session.beginTransaction();  
  2. User user1 = (User)session.load(User.class,new Long(1));  
  3. User user2 = (User)session.load(User.class,new Long(1));  
  4. User user3 = (User)session.load(User.class,new Long(3));  
  5. System.out.println( user1 == user2 );  
  6. System.out.println( user1 == user3 );  

应用程序在执行上述代码时，第一次加载OID为1的User对象，从数据库中查找ID为1的记录，然后创建相应的User实例，并把它保存在Session缓存中，最后将该实例的引用赋值给变量user1。第二次加载OID为1的对象时，直接把Session缓存中OID为1的实例的引用赋值给变量user2。因此，表达式user1==user2的结果为true。

标识的生成可以使用不同的策略，表1为Hibernate内置的标识生成策略。

表1：Hibernate标识生成策略

标识符生成器

描述

increment

适用于代理主键。由Hibernate自动以递增方式生成。

identity

适用于代理主键。由底层数据库生成标识符。

sequence

适用于代理主键。Hibernate根据底层数据库的序列生成标识符，这要求底层数据库支持序列。

hilo

适用于代理主键。Hibernate分局high/low算法生成标识符。

seqhilo

适用于代理主键。使用一个高/低位算法来高效的生成long，short或者int类型的标识符。

native

适用于代理主键。根据底层数据库对自动生成标识符的方式，自动选择identity、sequence或hilo。

uuid.hex

适用于代理主键。Hibernate采用128位的UUID算法生成标识符。

uuid.string

适用于代理主键。UUID被编码成一个16字符长的字符串。

assigned

适用于自然主键。由Java应用程序负责生成标识符。

foreign

适用于代理主键。使用另外一个相关联的对象的标识符。

Hibernate映射类型

在对象/关系映射文件中，Hibernate采用映射类型作为Java类型和SQL类型的桥梁。Hibernate映射类型分为2种：内置映射类型和自定义映射类型。

1、内置映射类型

Hibernate对所有的Java原生类型、常用的Java类型如String、Date等都定义了内置的映射类型。表2列出了Hibernate映射类型、对应的Java类型以及对应的标准SQL类型。

表2：Hibernate内置映射类型

Hibernate映射类型 Java类型 标准SQL类型 大小
integer/int java.lang.Integer/int INTEGER 4字节
long java.lang.Long/long BIGINT 8字节
short java.lang.Short/short SMALLINT 2字节
byte java.lang.Byte/byte TINYINT 1字节
float java.lang.Float/float FLOAT 4字节
double java.lang.Double/double DOUBLE 8字节
big_decimal java.math.BigDecimal NUMERIC  
character java.lang.Character/java.lang.String/char CHAR(1) 定长字符
string java.lang.String VARCHAR 变长字符
boolean/ yes_no/true_false java.lang.Boolean/Boolean BIT 布尔类型
date java.util.Date/java.sql.Date DATE 日期
timestamp java.util.Date/java.util.Timestamp TIMESTAMP 日期
calendar java.util.Calendar TIMESTAMP 日期
calendar_date java.util.Calendar DATE 日期
binary byte[] BLOB

 BLOB
text java.lang.String TEXT CLOB
serializable 实现java.io.Serializablej接口的任意Java类 BLOB BLOB
clob java.sql.Clob CLOB CLOB
blob java.sql.Blob BLOB BLOB
class java.lang.Class VARCHAR 定长字符
locale java.util.Locale VARCHAR 定长字符
timezone java.util.TimeZone VARCHAR 定长字符
currency java.util.Currency VARCHAR 定长字符

hibernate-mapping

这个元素包括三个可选的属性。schema属性，指明了这个映射所引用的表所在的schema名称。假若指定了这个属性，表名会加上所指定的schema的名字扩展为全限定名。假若没有指定，表名就不会使用全限定名。default-cascade指定了未明确注明cascade属性的Java属性和集合类Java会采取什么样的默认级联风格。auto-import属性默认让我们在查询语言中可以使用非全限定名的类名。

  1. <hibernate-mapping  
  2.          schema="schemaName"                           
  3.          default-cascade="none|save-update"            
  4.          auto-import="true|false"                      
  5.          package="package.name"                        
  6.  /> 

schema (可选): 数据库schema名称。

default-cascade (可选 - 默认为 none): 默认的级联风格。

auto-import (可选 - 默认为 true): 指定是否我们可以在查询语言中使用非全限定的类名（仅限于本映射文件中的类）。

package (可选): 指定一个包前缀，如果在映射文档中没有指定全限定名，就使用这个包名。

假若你有两个持久化类，它们的非全限定名是一样的（就是在不同的包里面--译者注），你应该设置auto-import="false"。假若说你把一个“import过”的名字同时对应两个类， Hibernate会抛出一个异常。

5.1.3. class

你可以使用class元素来定义一个持久化类：

  1. <class 
  2.         name="ClassName"                               
  3.         table="tableName"                              
  4.         discriminator-value="discriminator_value"      
  5.         mutable="true|false"                           
  6.         schema="owner"                                 
  7.         proxy="ProxyInterface"                         
  8.         dynamic-update="true|false"                    
  9.         dynamic-insert="true|false"                    
  10.         select-before-update="true|false"              
  11.         polymorphism="implicit|explicit"               
  12.         where="arbitrary sql where condition"         (11)  
  13.         persister="PersisterClass"                    (12)  
  14.         batch-size="N"                                (13)  
  15.         optimistic-lock="none|version|dirty|all"      (14)  
  16.         lazy="true|false"                             (15)  
  17. /> 

name: 持久化类（或者接口）的Java全限定名。

table: 对应的数据库表名。

discriminator-value（辨别值） （可选 - 默认和类名一样）：一个用于区分不同的子类的值，在多态行为时使用。

mutable（可变） (可选, 默认值为 true): 表明该类的实例可变（不可变）。

schema (可选): 覆盖在根<hibernate-mapping>元素中指定的schema名字。

proxy (可选): 指定一个接口，在延迟装载时作为代理使用。你可以在这里使用该类自己的名字。

dynamic-update（动态更新） (可选，默认为false): 指定用于UPDATE 的SQL将会在运行时动态生成，并且只更新那些改变过的字段。

dynamic-insert（动态插入） (可选, 默认为false): 指定用于INSERT的 SQL 将会在运行时动态生成，并且只包含那些非空值字段。

select-before-update (可选，默认值为false): 指定Hibernate除非确定对象的确被修改了，不会执行SQL UPDATE操作。在特定场合（实际上，只会发生在一个临时对象关联到一个新的session中去，执行update()的时候），这说明Hibernate会在UPDATE之前执行一次额外的SQL SELECT操作，来决定是否应该进行UPDATE。

polymorphism（多形，多态） (可选, 默认值为 implicit (隐式)): 界定是隐式还是显式的使用查询多态。

(11) where (可选) 指定一个附加的SQLWHERE 条件，在抓取这个类的对象时会一直增加这个条件。

(12) persister (可选): 指定一个定制的ClassPersister。

(13) batch-size (可选,默认是1) 指定一个用于根据标识符抓取实例时使用的"batch size"（批次抓取数量）。

(14) optimistic-lock（乐观锁定） (可选，默认是version): 决定乐观锁定的策略。

(15) lazy（延迟） (可选): 假若设置 lazy="true"，就是设置这个类自己的名字作为proxy接口的一种等价快捷形式。

若指明的持久化类实际上是一个接口，也可以被完美地接受。其后你可以用<subclass>来指定该接口的实际实现类名。你可以持久化任何static（静态的）内部类。记得应该使用标准的类名格式，就是说比如：Foo$Bar。

不可变类，mutable="false"不可以被应用程序更新或者删除。这可以让Hibernate做一些小小的性能优化。

可选的proxy属性可以允许延迟加载类的持久化实例。Hibernate开始会返回实现了这个命名接口的CGLIB代理。当代理的某个方法被实际调用的时候，真实的持久化对象才会被装载。参见下面的“用于延迟装载的代理”。

Implicit (隐式)的多态是指，如果查询中给出的是任何超类、该类实现的接口或者该类的名字，都会返回这个类的实例；如果查询中给出的是子类的名字，则会返回子类的实例。 Explicit （显式）的多态是指，只有在查询中给出的明确是该类的名字时才会返回这个类的实例；同时只有当在这个<class>的定义中作为<subclass>或者<joined-subclass>出现的子类，才会可能返回。大多数情况下，默认的polymorphism="implicit"都是合适的。显式的多态在有两个不同的类映射到同一个表的时候很有用。（允许一个“轻型”的类，只包含部分表字段）。

persister属性可以让你定制这个类使用的持久化策略。你可以指定你自己实现的net.sf.hibernate.persister.EntityPersister的子类，你甚至可以完全从头开始编写一个net.sf.hibernate.persister.ClassPersister接口的实现，可能是用储存过程调用、序列化到文件或者LDAP数据库来实现的。参阅net.sf.hibernate.test.CustomPersister，这是一个简单的例子（“持久化”到一个Hashtable）。

请注意dynamic-update和dynamic-insert的设置并不会继承到子类，所以在<subclass>或者<joined-subclass>元素中可能需要再次设置。这些设置是否能够提高效率要视情形而定。请用你的智慧决定是否使用。

使用select-before-update通常会降低性能.当是在防止数据库不必要的触发update触发器，这就很有用了。

如果你打开了dynamic-update，你可以选择几种乐观锁定的策略：

version（版本检查）检查version/timestamp字段

all（全部） 检查全部字段

dirty（脏检查）只检察修改过的字段

none（不检查）不使用乐观锁定

我们非常强烈建议你在Hibernate中使用version/timestamp字段来进行乐观锁定。对性能来说，这是最好的选择，并且这也是唯一能够处理在session外进行操作的策略（就是说，当使用Session.update()的时候）。

5.1.4. id

被映射的类必须声明对应数据库表主键字段。大多数类有一个JavaBeans风格的属性，为每一个实例包含唯一的标识。<id> 元素定义了该属性到数据库表主键字段的映射。

  1. <id  
  2. name="propertyName"   
  3. type="typename"   
  4. column="column_name"   
  5. unsaved-value="any|none|null|id_value"   
  6. access="field|property|ClassName">   
  7.  
  8. <generator class="generatorClass"/>  
  9. </id> 

name (可选): 标识属性的名字。

type (可选): 标识Hibernate类型的名字。

column (可选 - 默认为属性名): 主键字段的名字。

unsaved-value (可选 - 默认为null): 一个特定的标识属性值，用来标志该实例是刚刚创建的，尚未保存。这可以把这种实例和从以前的session中装载过（可能又做过修改--译者注）但未再次持久化的实例区分开来。

access (可选 - 默认为property): Hibernate用来访问属性值的策略。

如果 name属性不存在，会认为这个类没有标识属性。

unsaved-value 属性很重要！如果你的类的标识属性不是默认为null的，你应该指定正确的默认值。

还有一个另外的<composite-id>声明可以访问旧式的多主键数据。我们强烈不鼓励使用这种方式。

5.1.4.1. generator

必须声明的<generator>子元素是一个Java类的名字，用来为该持久化类的实例生成唯一的标识。如果这个生成器实例需要某些配置值或者初始化参数，用<param>元素来传递。

  1. <id name="id" type="long" column="uid" unsaved-value="0"> 
  2. <generator class="net.sf.hibernate.id.TableHiLoGenerator"> 
  3. <param name="table">uid_table</param> 
  4. <param name="column">next_hi_value_column</param> 
  5. </generator> 
  6. </id> 

所有的生成器都实现net.sf.hibernate.id.IdentifierGenerator接口。这是一个非常简单的接口；某些应用程序可以选择提供他们自己特定的实现。当然，Hibernate提供了很多内置的实现。下面是一些内置生成器的快捷名字：

increment（递增）

用于为long, short或者int类型生成唯一标识。只有在没有其他进程往同一张表中插入数据时才能使用。在集群下不要使用。

identity

对DB2,MySQL, MS SQL Server, Sybase和HypersonicSQL的内置标识字段提供支持。返回的标识符是long, short 或者int类型的。

sequence （序列）

在DB2,PostgreSQL, Oracle, SAP DB, McKoi中使用序列（sequence)，而在Interbase中使用生成器(generator)。返回的标识符是long, short或者 int类型的。

hilo （高低位）

使用一个高/低位算法来高效的生成long, short或者 int类型的标识符。给定一个表和字段（默认分别是是hibernate_unique_key 和next）作为高位值得来源。高/低位算法生成的标识符只在一个特定的数据库中是唯一的。在使用JTA获得的连接或者用户自行提供的连接中，不要使用这种生成器。

seqhilo（使用序列的高低位）

使用一个高/低位算法来高效的生成long, short或者 int类型的标识符，给定一个数据库序列（sequence)的名字。

uuid.hex

用一个128-bit的UUID算法生成字符串类型的标识符。在一个网络中唯一（使用了IP地址）。UUID被编码为一个32位16进制数字的字符串。

uuid.string

使用同样的UUID算法。UUID被编码为一个16个字符长的任意ASCII字符组成的字符串。不能使用在PostgreSQL数据库中

native（本地）

根据底层数据库的能力选择identity, sequence 或者hilo中的一个。

assigned（程序设置）

让应用程序在save()之前为对象分配一个标示符。

foreign（外部引用）

使用另外一个相关联的对象的标识符。和<one-to-one>联合一起使用。

原文链接：http://blog.csdn.net/ysynlm/article/details/2766281

posted on 2016-06-01 15:14  浔浔~  阅读(227)  评论(0)  编辑  收藏  举报

导航