hibernate笔记

  Hibernate初始了解笔记汇集 收藏

一个User 属性id的类型定义错（定义为String）出项了错误，应为int，在many2one的工程中出项了异常，且数据库操作也发生了异常。
String做主键用uuid整数做主键用native

下面介绍一下hibernate的配置问题：
第一个hibernate项目

1、新建java项目

2、创建User Library,加入如下jar
 * HIBERNATE_HOME/hibernate3.jar
 * HIBERNATE_HOME/lib/*.jar
 * MySql jdbc驱动
 
3、创建hibernate配置文件hibernate.cfg.xml，为了便于调试最好加入log4j配置文件
如果不加入log4j的话，会出现异常。
下面是hibernate.cfg.xml文件的内容。

<!DOCTYPE hibernate-configuration PUBLIC
 "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
 "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
<session-factory>
 <property name="hibernate.connection.url">
  jdbc:mysql://localhost/hibernate_first
 </property>
 <property name="hibernate.connection.driver_class">
  com.mysql.jdbc.Driver
 </property>
 <property name="hibernate.connection.username">root</property>
 <property name="hibernate.connection.password">sunyuan</property>
 <property name="hibernate.dialect">
  org.hibernate.dialect.MySQLDialect
 </property>
 <property name="hibernate.show_sql">true</property>
 

 <mapping resource="com/bjsxt/hibernate/User.hbm.xml" />
</session-factory>
</hibernate-configuration>

4、定义实体类

5、定义User类的映射文件User.hbm.xml

6、将User.hbml.xml文件加入到
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
 "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
 <class name="com.sy.hibernate.User">
  <id name="id">
   <generator class="uuid"/><!-- 主键设置方式，String类型的为uuid Int的是native-->
  </id>
  <property name="name"/>
  <property name="password"/>
  <property name="createTime"/>
  <property name="expireTime"/>
 </class>
</hibernate-mapping>hibernate.cfg.xml文件中其实就是<mapping resource="com/sy/hibernate/User.hbm.xml" />

7、编写hbm2ddl工具类，将实体类生成数据库表
主要代码：

  //读取hibernate.cfg.xml文件
  Configuration cfg = new Configuration().configure();
  
  SchemaExport export = new SchemaExport(cfg);
  
  export.create(true, true);

8、开发客户端
 
为了方便跟踪sql执行，在hibernate.cfg.xml文件中加入<property name="hibernate.show_sql">true</property>

测试实体对象的生命周期

junit简介：
 * 编写测试类xxxTest，需要继承TestCase即，junit.framework.TestCase
 * 编写单元测试方法，测试方法必须以test开头，测试方法不能含有参数和返回值，如：
   public void testHello1() {}
 * 最好单元测试的代码单独建立一个目录，解决这个问题可以采用新建一个SourceFolder，然后再建一个和源文件一样的名字的包即可。

 
了解Hibernate中CRUD操作

了解get和load的区别？
 * get不支持lazy，load支持lazy
就是说，//马上发出查询sql，加载User对象
   User user = (User)session.get(User.class, "402880d01b9bf210011b9bf2a2ff0001");

//不会发出查询sql，因为load方法实现了lazy（懒加载或延迟加载）
   //延迟加载：只有真正使用这个对象的时候，才加载（发出sql语句）如：System.out.println("user.name=" + user.getName());才加载。
   //hibernate延迟加载实现原理是代理方式
   User user = (User)session.load(User.class, "402880d01b9bf210011b9bf2a2ff0001");
 * 采用get加载数据，如果没有匹配的数据，返回null，而load则抛出异常
 
transient状态的特征？
 * 在数据库中没有与之匹配的数据
 * 没有纳入session的管理
 
persistent状态的特征？
 * persistent状态的对象在数据库中有与之匹配的数据
 * 纳入了session的管理
 * 在清理缓存（脏数据检查）的时候,会和数据库同步
 
detached状态的特征？
 * 在数据库中有与之匹配的数据
 * 没有纳入session的管理    
//手动构造的detached状态的对象即将id设为数据库中存在的即可。
User user = new User();
user.setId("43553545");//这里的id必须在数据库中存在。否则抛出org.hibernate.StaleObjectStateException

 
hibernate基本映射

实体类---表
实体类中的普通属性---表字段

采用<class>标签映射成数据库表，通过<property>标签将普通属性映射成表字段
所谓普通属性指不包括自定义类、集合和数组等

注意：如果实体类和实体类中的属性和sql中的关键字重复，必须采用table或column重新命名

实体类的设计原则：
 * 实现一个默认的（即无参数的）构造方法（constructor）
 * 提供一个标识属性（identifier property）（可选）
 * 使用非final的类 (可选)
 * 为持久化字段声明访问器(accessors) 

主键生成策略：
 uuid、native和assigned

hibernate一对一主键关联映射（单向关联Person---->IdCard）

一对一主键关联映射:让两个实体对象的id保持相同，这样可以避免多余的字段被创建

具体映射：

 <id name="id">
  <!-- person的主键来源idCard，也就是共享idCard的主键 -->
  <generator class="foreign">
   <param name="property">idCard</param>
  </generator>
 </id>
 <property name="name"/>
 <!-- one-to-one标签的含义，指示hibernate怎么加载它的关联对象，默认根据主键加载，
 constrained="true"， 表明当前主键上存在一个约束，person的主键作为外键参照了idCard 
  -->
 <one-to-one name="idCard" constrained="true"/>

hibernate一对一主键关联映射（双向关联Person<---->IdCard）

需要在idcard映射文件中加入<one-to-one>标签指向person，指示hibernate如何加载person
默认根据主键加载
如：IdCard.hbm.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
 "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
 <class name="com.bjsxt.hibernate.IdCard" table="t_idcard">
  <id name="id">
   <generator class="native"/>
  </id>
  <property name="cardNo"/>
  <one-to-one name="person"/>
 </class>
</hibernate-mapping>

Person.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
 "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
 <class name="com.bjsxt.hibernate.Person" table="t_person">
  <id name="id">
   <generator class="foreign">
    <param name="property">idCard</param>
   </generator>
  </id>
  <property name="name"/>
  <one-to-one name="idCard" constrained="true"/>
 </class>
</hibernate-mapping>
如果为双向的映射，其实就是在原来单项映射的基础上，在idcard映射文件中加入<one-to-one>标签指向person，指示hibernate如何加载即：<one-to-one name="person"/>，其实两个相关联的实体相关的.hbm.xml文件，是相互的，无论哪一个写的具体，哪一个写的简单，都是可以的。就是所谓的此消彼长吧。

hibernate一对一唯一外键关联映射（单向关联Person---->IdCard）

一对唯一外键关联映射是多对一关联映射的特例

可以采用<many-to-one>标签，指定多的一端的unique=true，这样就限制了多的一端的

多重性为一。
<class name="Person" table="t_person">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<many-to-one name="idCard" unique="true"/>
</class>

主要是unique属性的设置。

其中IdCard.hbm.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
 "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
 <class name="com.bjsxt.hibernate.IdCard" table="t_idcard">
  <id name="id">
   <generator class="native"/>
  </id>
  <property name="cardNo"/>
 </class>
</hibernate-mapping>

Person.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
 "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
 <class name="com.bjsxt.hibernate.Person" table="t_person">
  <id name="id">
   <generator class="native"/>
  </id>
  <property name="name"/>
  <many-to-one name="idCard" unique="true" column="asd"/>
 </class>
</hibernate-mapping>

hibernate一对一唯一外键关联映射（双向关联Person<---->IdCard）

一对一唯一外键关联双向，需要在另一端（idcard），添加<one-to-one>标签，指示hibernate如何加载
其关联对象，默认根据主键加载person，外键关联映射中，因为两个实体采用的是person的外键维护的关系，
所以不能指定主键加载person，而要根据person的外键加载，所以采用如下映射方式：
<one-to-one name="person" property-ref="idCard"/>

Person.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
 "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
 <class name="com.bjsxt.hibernate.Person" table="t_person">
  <id name="id">
   <generator class="native"/>
  </id>
  <property name="name"/>
  <many-to-one name="idCard" unique="true"/>
 </class>
</hibernate-mapping>

IdCard.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
 "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
 <class name="com.bjsxt.hibernate.IdCard" table="t_idcard">
  <id name="id">
   <generator class="native"/>
  </id>
  <property name="cardNo"/>
  <one-to-one name="person" property-ref="idCard"/>
 </class>
</hibernate-mapping>

session flush测试：

session flush方法主要做了两件事：
 * 清理缓存
 * 执行sql
 
session在什么情况下执行flush
 * 默认在事务提交时
 * 显示的调用flush
 * 在执行查询前，如：iterate
 
hibernate按照save(insert),update、delete顺序提交相关操作 

   //因为user的主键生成侧路采用的是uuid，所以调用完成save后，只是将user纳入到了session的管理
   //不会发出insert语句，但是id已经生成，session中existsInDatebase状态为false
   session.save(user);
   
   //调用flush，hibernate会清理缓存，执行sql
   //如果数据库的隔离级别设置为为提交读，那么我们可以看到flush过的数据
   //并且session中existsInDatebase状态为true
   session.flush();
   
   //提交事务
   //默认情况下commit操作会先执行flush清理缓存，所以不用显示的调用flush
   //commit后数据是无法回滚的
   tx.commit();

//因为user的主键生成策略为native,所以调用session.save后，将执行insert语句，返回有数据库生成的id
   //纳入了session的管理，修改了session中existsInDatebase状态为true
   //如果数据库的隔离级别设置为为提交读，那么我们可以看到save过的数据
   session.save(user);
   tx.commit();

//因为user的主键生成侧路采用的是uuid，所以调用完成save后，只是将user纳入到了session的管理
   //不会发出insert语句，但是id已经生成，session中existsInDatebase状态为false
   session.save(user);
   
   //将user对象从session中逐出，即session的EntityEntries属性中逐出
   session.evict(user);
   
   //无法成功提交，因为hibernate在清理缓存时，在session的insertions集合中取出user对象进行insert操作后
   //需要更新entityEntries属性中的existsInDatabase为true，而我们采用evict已经将user从session的entityEntries
   //中逐出了，所以找不到相关数据，无法更新，抛出异常
   tx.commit();

//因为user的主键生成侧路采用的是uuid，所以调用完成save后，只是将user纳入到了session的管理
   //不会发出insert语句，但是id已经生成，session中existsInDatebase状态为false
   session.save(user);
   
   //flush后hibernate会清理缓存，会将user对象保存到数据库中，将session中的insertions中的user对象
   //清除，并且设置session中existsInDatebase的状态为true
   session.flush();
   
   //将user对象从session中逐出，即session的EntityEntries属性中逐出
   session.evict(user);
   
   //可以成功提交，因为hibernate在清理缓存时，在session的insertions集合中无法找到user对象
   //所以就不会发出insert语句，也不会更新session中的existsInDatabase的状态
   tx.commit();

   //因为user的主键生成策略为native,所以调用session.save后，将执行insert语句，返回有数据库生成的id
   //纳入了session的管理，修改了session中existsInDatebase状态为true
   //如果数据库的隔离级别设置为为提交读，那么我们可以看到save过的数据
   session.save(user);
   
   //将user对象从session中逐出，即session的EntityEntries属性中逐出
   session.evict(user);
   
   //可以成功提交，因为hibernate在清理缓存时，在session的insertions集合中无法找到user对象
   //所以就不会发出insert语句，也不会更新session中的existsInDatabase的状态
   tx.commit();

////////////////////////////////////////

 User3 user = new User3();
   user.setId("001");
   user.setName("张三");
   
   session.save(user);
   
   user.setName("王五");
   session.update(user);
   
   User3 user3 = new User3();
   user3.setId("002");
   user3.setName("李四");
   session.save(user3);
//////////////////////////////////////   
   //Hibernate: insert into t_user3 (name, password, create_time, expire_time, user_id) values (?, ?, ?, ?, ?)
   //Hibernate: insert into t_user3 (name, password, create_time, expire_time, user_id) values (?, ?, ?, ?, ?)
   //Hibernate: update t_user3 set name=?, password=?, create_time=?, expire_time=? where user_id=?
   //hibernate按照save(insert),update、delete顺序提交相关操作,意思是无论上述的顺序怎么样，即使update在save前面，始终hibernate按照save(insert) ,update,delete的顺序执行。最后是delete

///////////////////////////////////////////////////////////////////////////////

   User3 user = new User3();
   user.setId("003");
   user.setName("张三");
   
   session.save(user);
   
   user.setName("王五");
   session.update(user);
   
   session.flush();
   
   User3 user3 = new User3();
   user3.setId("004");
   user3.setName("李四");
   session.save(user3);
   
   //Hibernate: insert into t_user3 (name, password, create_time, expire_time, user_id) values (?, ?, ?, ?, ?)
   //Hibernate: update t_user3 set name=?, password=?, create_time=?, expire_time=? where user_id=?
   //Hibernate: insert into t_user3 (name, password, create_time, expire_time, user_id) values (?, ?, ?, ?, ?)
   //因为我们在session.udpate(user)后执行了flush，所以在清理缓存时执行flush前的sql不会生成
   //sql会按照我们的意愿执行
   tx.commit();
这时，会执行按顺序。主要在于flush方法的执行。

//////////////////////////////////////////\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
hihernate一对多关联映射（单向Classes----->Student）
/////////////////////////////////
public class Classes {
 
 private int id;
 
 private String name;
 
 private Set students; 
//////////////////////////////////
public class Student {
 
 private int id;
 
 private String name;

//////////////////////////////////
Classes.hbm.xml
///////////////////////////////////
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
 "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.bjsxt.hibernate">
 <class name="Classes" table="t_classes">
  <id name="id">
   <generator class="native"/>
  </id>
  <property name="name"/>
  <set name="students">
   <key column="classesid"/>
   <one-to-many class="Student"/>
  </set>
 </class>
</hibernate-mapping>

////////////////////////////
Student.hbm.xml
/////////////////////////////
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
 "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
 <class name="com.bjsxt.hibernate.Student" table="t_student">
  <id name="id">
   <generator class="native"/>
  </id>
  <property name="name"/>
 </class>
</hibernate-mapping>

////////////////////////////////
生成的表为Student和Classes两个表，其中Student表中包含属性有name id classid
Classes表中包含属性有name id
这是怎么做到的映射呢？下面主要介绍一下文件的配置。在Classes.hbm.xml中怎么将class的id映射到Student表中呢？
主要用到<set name="students">
<key column="classesid"/>
<one-to-many class="Student">
</set>这里的students是Classes类的属性。
而在Student.hbm.xml中实际要三个属性标签，而只写了两个属性，而classesid在Classes.hbm.xml中已经关联了。
改天再把hibernate映射的源码看看。

//////////////////////////////////
一对多关联映射利用了多对一关联映射原理

多对一关联映射：在多的一端加入一个外键指向一的一端，它维护的关系是多指向一
一对多关联映射：在多的一端加入一个外键指向一的一端，它维护的关系是一指向多

也就是说一对多和多对一的映射策略是一样的，只是站的角度不同。

在一一端维护关系的缺点：
 * 如果将t_student表里的classesid字段设置为非空，则无法保存

 * 因为不是在student这一端维护关系，所以student不知道是哪个班的，

   所以需要发出多余的update语句来更新关系
////////////////////////////////////////////////////////////////////////////////

hihernate一对多关联映射（双向Classes<----->Student）

一对多双向关联映射：
 * 在一一端的集合上使用<key>，在对方表中加入一个外键指向一一端
 * 在多一端采用<many-to-one>
 
注意：<key>标签指定的外键字段必须和<many-to-one>指定的外键字段一致，否则引用字段的错误
 
如果在”一“一端维护一对多关联关系，hibernate会发出多余的udpate语句，所以我们一般在多
的一端来维护关联关系

inverse的值有两种，“true”和“false”。inverse="false"是默认的值
inverse的作用：在hibernate中是通过inverse的设置来决定是有谁来维护表和表之间的关系的。

我们说inverse设立不当会导致性能低下，其实是说inverse设立不当，会产生多余重复的SQL语句甚至致使JDBC exception的throw。这是我们在建立实体类关系时必须需要关注的地方。一般来说，inverse＝true是推荐使用，双向关联中双方都设置 inverse＝false的话，必会导致双方都重复更新同一个关系。但是如果双方都设立inverse＝true的话，双方都不维护关系的更新，这也是 不行的，好在一对多中的一端:many-to-one默认是inverse＝false，避免了这种错误的产生。但是多对多就没有这个默认设置了，所以很 多人经常在多对多的两端都使用inverse＝true，结果导致连接表的数据根本没有记录，就是因为他们双分都没有责任维护关系。所以说，双向关联中最 好的设置是一端为inverse＝true，一端为inverse＝false。一般inverse＝false会放在多的一端，那么有人提问了， many－to－many两边都是多的，inverse到底放在哪儿？其实hibernate建立多对多关系也是将他们分离成两个一对多关系，中间连接一个连接表。所以通用存在一对多的关系，也可以这样说：一对多是多对多的基本组成部分。

关于inverse属性：
 inverse主要用在一对多和多对多双向关联上，inverse可以被设置到集合标签<set>上，
 默认inverse为false，所以我们可以从”一“一端和”多“一端维护关联关系，
 如果设置成inverse为true，则我们只能从多一端来维护关联关系
 
 注意：inverse属性，只影响数据的存储，也就是持久化
  
inverse和cascade
 * inverse是关联关系的控制方向

 * cascade操作上的连锁反应

双向关联：

Student.hbm.xml
////////////////////////////////////////

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
 "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
 <class name="com.bjsxt.hibernate.Student" table="t_student">
  <id name="id">
   <generator class="native"/>
  </id>
  <property name="name"/>
  <many-to-one name="classes" column="classesid"/>
 </class>
</hibernate-mapping>
////////////////////////////////////////
Class.hbm.xml
////////////////////////////////////////
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
 "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.bjsxt.hibernate">
 <class name="Classes" table="t_classes">
  <id name="id">
   <generator class="native"/>
  </id>
  <property name="name"/>
  <set name="students" inverse="true" cascade="all">
   <key column="classesid"/>
   <one-to-many class="Student"/>
  </set>
 </class>
</hibernate-mapping>

////////////////////////////////////////
hibernate多对多关联映射(单向User---->Role)
///////////////////////////////////////
User.hbm.xml
////////////////////////////////////////
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
 "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
 <class name="com.bjsxt.hibernate.User" table="t_user">
  <id name="id">
   <generator class="native"/>
  </id>
  <property name="name"/>
  <set name="roles" table="t_user_role">
   <key column="userid"/>
   <many-to-many class="com.bjsxt.hibernate.Role" column="roleid"/>
  </set>
 </class>
</hibernate-mapping>
////////////////////////////////////////Role.hbm.xml
////////////////////////////////////////
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
 "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
 <class name="com.bjsxt.hibernate.Role" table="t_role">
  <id name="id">
   <generator class="native"/>
  </id>
  <property name="name"/>
 </class>
</hibernate-mapping>
////////////////////////////////////////
hibernate多对多关联映射(双向User<---->Role)
////////////////////////////////////////

User.hbm.xml
////////////////////////////////////////
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
 "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
 <class name="com.bjsxt.hibernate.User" table="t_user">
  <id name="id">
   <generator class="native"/>
  </id>
  <property name="name"/>
  <set name="roles" table="t_user_role">
   <key column="userid"/>
   <many-to-many class="com.bjsxt.hibernate.Role" column="roleid"/>
  </set>
 </class>
</hibernate-mapping>
////////////////////////////////////////
Role.hbm.xml
////////////////////////////////////////
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
 "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
 <class name="com.bjsxt.hibernate.Role" table="t_role">
  <id name="id">
   <generator class="native"/>
  </id>
  <property name="name"/>
  <set name="users" table="t_user_role" order-by="userid">
   <key column="roleid"/>
   <many-to-many class="com.bjsxt.hibernate.User" column="userid"/>
  </set>
 </class>
</hibernate-mapping>

////////////////////////////////////////映射方法：
  <set name="roles" table="t_user_role">
   <key column="userid"/>
   <many-to-many class="com.bjsxt.hibernate.Role" column="roleid"/>
  </set>
table属性值必须和单向关联中的table属性值一致
<key>中column属性值要与单向关联中的<many-to-many>标签中的column属性值一致
在<many-to-many>中的column属性值要与单向关联中<key>标签的column属性值一致
////////////////////////////////////////

hibernate lazy策略可以使用在：
 * <class>标签上，可以取值：true/false
 * <property>标签上，可以取值：true/false需要类增强工具
 * <set><list>标签上，可以取值：true/false/extra
 * <one-to-one><many-to-one>单端关联上，可以取值：false/proxy/noproxy
 
lazy概念：只有真正使用该对象时，才会创建，对于hibernate而言，正真使用的时候才会发出sql

hibernate支持lazy策略只有在session打开状态下有效
例如：
Session session = null;
  Group group = null;
  try {
   session = HibernateUtils.getSession();
   session.beginTransaction();
   
   group = (Group)session.load(Group.class, 1);
   
   session.getTransaction().commit();
  }catch(Exception e) {
   e.printStackTrace();
   session.getTransaction().rollback();
  }finally {
   HibernateUtils.closeSession(session);
  }
  
  //不能正确输出，抛出LazyInitializationException 异常，因为session已经关闭
  //hibernate支持lazy策略只有在session打开状态下有效
  System.out.println("group.name=" + group.getName());
////////////////////////////////////////

<class>标签上的lazy特性只对普通属性起作用

////////////////////////////////////////
class Classes
int id;String name;Set students;

class Student 
int id;String name;Classes classes;

class.hbf.xml
<hibernate-mapping package="com.bjsxt.hibernate">
<class name="Classes" table="t_classes">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<set name="students" inverse="true" cascade="all" >
<key column="classesid"/>
<one-to-many class="Student"/>
</set>
</class>
</hibernate-mapping>

设置<class>标签上的lazy=true，或者默认TRUE。其它默认
<class name="Classes" table="t_classes" lazy="true">

test1   
//不发sql
Classes classes = (Classes)session.load(Classes.class, 1);
//发sql，查询class
System.out.println("classes.name=" + classes.getName());
//不发sql
Set students = classes.getStudents();
//发sql，查询全部符合条件student的语句
for (Iterator iter=students.iterator(); iter.hasNext();) {
Student student = (Student)iter.next();
System.out.println("student.name=" + student.getName());
}

test2
//不发sql
Classes classes = (Classes)session.load(Classes.class, 1);
//发sql，查询class
System.out.println("classes.name=" + classes.getName());
//不发sql
Set students = classes.getStudents();
//发sql，查询全部符合条件student的语句
System.out.println("student.count=" + students.size());

设置<class>标签上的lazy=false,集合的lazy为默认(true)
<class name="Classes" table="t_classes" lazy="false">

test3
//发sql，查询student
Classes classes = (Classes)session.load(Classes.class, 1);
//不发sql
System.out.println("classes.name=" + classes.getName());
//不发sql
Set students = classes.getStudents();
//发sql，查询符合条件的student语句
for (Iterator iter=students.iterator(); iter.hasNext();) {
Student student = (Student)iter.next();
System.out.println("student.name=" + student.getName());
}

设置集合上的lazy=false,其它默认
<set name="students" inverse="true" cascade="all" lazy="false">
<key column="classesid"/>
<one-to-many class="Student"/>
</set>

test4
//不发sql
Classes classes = (Classes)session.load(Classes.class, 1);
//不发sql
System.out.println("classes.name=" + classes.getName());
//发sql，分别查询出classes和student
Set students = classes.getStudents();
//不发sql
for (Iterator iter=students.iterator(); iter.hasNext();) {
Student student = (Student)iter.next();
System.out.println("student.name=" + student.getName());
}

test5
Classes classes = (Classes)session.load(Classes.class, 1);
//不发sql
System.out.println("classes.name=" + classes.getName());
//发sql，分别查询出classes和student
Set students = classes.getStudents();
//不发sql
System.out.println("student.count=" + students.size());

设置集合上的lazy=extra,其它默认
<set name="students" inverse="true" cascade="all" lazy="extra">
<key column="classesid"/>
<one-to-many class="Student"/>
</set>

test6
//不发sql
Classes classes = (Classes)session.load(Classes.class, 1);
//发sql，查询出classes
System.out.println("classes.name=" + classes.getName());
//不发sql
Set students = classes.getStudents();
//发sql，查询出student
for (Iterator iter=students.iterator(); iter.hasNext();) {
Student student = (Student)iter.next();
System.out.println("student.name=" + student.getName());
}

test7   
//不发sql
Classes classes = (Classes)session.load(Classes.class, 1);
//发sql，查询出classes
System.out.println("classes.name=" + classes.getName());
//不发sql
Set students = classes.getStudents();
//发sql，智能的sql语句，查询出数目
System.out.println("student.count=" + students.size());

 
 ////////////////////////////////////////
hibernate在单端关联上的lazy策略，可以取值：false/proxy/noproxy

<class>标签上的lazy不会影响到单端关联上的lazy特性
////////////////////////////////////////
下面的User.hbm.xml
/.//////////////////////////////////////
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
 "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
 <class name="com.bjsxt.hibernate.User" table="t_user" lazy="false">
  <id name="id">
   <generator class="native"/>
  </id>
  <property name="name"/>
  <!-- 
  <many-to-one name="group" column="groupid" cascade="all"/>
   -->
   <many-to-one name="group" column="groupid" />
 </class>
</hibernate-mapping>
则这里的 <many-to-one name="group" column="groupid" lazy=""/>中lazy不受class中lazy的关联，就是说class中lazy的属性值与many-to-one中的lazy无关。如果，lazy设为false，那么在执行//不会发出sql
   User user = (User)session.load(User.class, 1);
   
   //会发出sql，发出两条sql分别加载User和Group
   System.out.println("user.name=" + user.getName());
时，会发出两条sql语句。lazy的延迟机制在这里不做解释了。
////////////////////////////////////////　原先看到在Hibernate3之后可以在Many to one 的关系映射中设置lazy属性， 
　　<many-to-one name="brother" cascade="none" lazy="no-proxy" insert="true" column="brotherId" outer-join="false" update="false"> 
　　还以为和one to many一样，只要将lazy设为true就可以在不加载关联的对象呢，结果这个lazy的属性值只有proxy no-proxy 和false，试了其中任何一个值，结果都还是加载了关联的对象，后来想起class可以设置lazy的属性，就把关联的brother对象的类的lazy属性设为true，然后many to one中的lazy设为no-proxy后就实现了延迟加载，如果将many to one中的lazy属性设为false，系统还是会自动初始化brother对象。 
　　</many-to-one><class name="com.demo.bean.Brother" lazy="true" table="brother"> 
//////////////////////////////////////////
总之，class中的lazy只会对普通属性相关联，与集合，many-to-one one-to-many 都无关。//////////////////////////////////////

每棵继承树映射成一张表

1、理解如何映射
  因为类继承树肯定是对应多个类，要把多个类的信息存放在一张表中，必须有某种机制来区分哪些记录是属于哪个类的。
 这种机制就是，在表中添加一个字段，用这个字段的值来进行区分。用hibernate实现这种策略的时候，有如下步骤：
 父类用普通的<class>标签定义
 在父类中定义一个discriminator，即指定这个区分的字段的名称和类型
 如：<discriminator column=”XXX” type=”string”/>
 子类使用<subclass>标签定义，在定义subclass的时候，需要注意如下几点：
 Subclass标签的name属性是子类的全路径名
 在Subclass标签中，用discriminator-value属性来标明本子类的discriminator字段（用来区分不同类的字段）
 的值Subclass标签，既可以被class标签所包含（这种包含关系正是表明了类之间的继承关系），也可以与class标
 签平行。 当subclass标签的定义与class标签平行的时候，需要在subclass标签中，添加extends属性，里面的值
 是父类的全路径名称。子类的其它属性，像普通类一样，定义在subclass标签的内部。

2、理解如何存储
 存储的时候hibernate会自动将鉴别字段值插入到数据库中，在加载数据的时候，hibernate能根据这个鉴别值
 正确的加载对象
 
多态查询：在hibernate加载数据的时候能鉴别出正真的类型（instanceOf）

get支持多态查询
load只有在lazy=false，才支持多态查询 
hql支持多态查询 
////////////////////////////////////////
在这个试验中，有三个类Animal、Bird、Pig，它们的关系是，Animal是基类，其他两个是子类，Brid除了Animal的属性外，还有一个属性height，Pig有weight，在hibernate中生成一个表t_animal
对应的xml文件为：
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
 "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.bjsxt.hibernate">
 <class name="Animal" table="t_animal" lazy="false">
  <id name="id">
   <generator class="native"/>
  </id>
  <discriminator column="type" type="string"/><!--这里type="string"是hibernate自带的，与Java中的String没有关系。且该标签必须紧跟在标签<id>后-->
  <property name="name"/>
  <property name="sex"/>
  <subclass name="Pig" discriminator-value="P">
   <property name="weight"/>
  </subclass>
  <subclass name="Bird" discriminator-value="B">
   <property name="height"/>
  </subclass>
 </class>
</hibernate-mapping>
//////////////////////////////////////// 
部分代码：
////////////////////////////////////////
session = HibernateUtils.getSession();
   session.beginTransaction();
   
   Animal animal = (Animal)session.load(Animal.class, 1);
   
   //因为load默认只是lazy，因为我们看到的是Animal的代理对象
   //所以通过instanceof是反应不出正真的对象类型的
   //因此load在默认情况下是不支持多态查询的
   if (animal instanceof Pig) {
    System.out.println(animal.getName());
   }else {
    System.out.println("不是猪");
   }
   session.getTransaction().commit();
////////////////////////////////////////

上述中，介绍了怎么生成一张表，但是每个类都生成一个表，包括Animal类对应的表。类的关联和上述一样。
////////////////////////////////////////对应的xml文件
////////////////////////////////////////<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
 "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.bjsxt.hibernate">
 <class name="Animal" table="t_animal">
  <id name="id">
   <generator class="native"/>
  </id>
  <property name="name"/>
  <property name="sex"/>
  <joined-subclass name="Pig" table="t_pig">
   <key column="pid"/>
   <property name="weight"/>
  </joined-subclass>
  <joined-subclass name="Bird" table="t_bird">
   <key column="bid"/>
   <property name="height"/>
  </joined-subclass>
 </class>
</hibernate-mapping>
////////////////////////////////////////
这和生成一张表的区别是：前者用到<joined-subclass>而一张表的是<subclass>其他的细节这里不再叙述。
////////////////////////////////////////
get支持多态查询，load不支持多态查询。只有将lazy设置为false，才支持多态查询，否则实行的是代理proxy
////////////////////////////////////////

那么，将每个具体类都映射成一张表，即生成t_bird和t_pig表分别含有字段
id name sex height
id name sex weight
而父类Animal不映射成表。
///////////////////////////////////////
对应的xml文件：
////////////////////////////////////////
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
 "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.bjsxt.hibernate">

 <class name="Animal" abstract="true">
  <id>
   <generator class="assigned"/>
  </id>
  <property name="name"/>
  <property name="sex"/>
  <union-subclass  name="Pig" table="t_pig">
   <property name="weight"/>
  </union-subclass>
  <union-subclass name="Bird" table="t_bird">
   <property name="height"/>
  </union-subclass>
 </class>
</hibernate-mapping>
////////////////////////////////////////

margin-top: 1em; margin-right: 0px; margin-bottom: 0.5em; margin-left: 0px; p

分享到：

网线的制作(图文) | spring的对象绑定机制

• 2010-09-01 17:02
• 浏览 878
• 评论(0)
• 分类:企业架构
• 查看更多