程序博客网 > 怎么让淘宝客户加微信

Hibernate3 高级查询

来源：互联网 发布：怎么让淘宝客户加微信 编辑：程序博客网 时间：2024/05/05 04:56
Top

JAVA Hibernate DAY03

  1. 使用多对一关联映射
  2. 关联查询的一些特性
  3. 级联添加/修改
  4. 级联删除
  5. HQL查询，按条件查询
  6. HQL查询，查询一部分字段
  7. HQL查询，分页查询
  8. HQL查询，多表联合查询
  9. Hibernate中的SQL查询
  10. 使用二级缓存
  11. 使用查询缓存

1 使用多对一关联映射

1.1 问题

使用多对一关联映射，在查询业务账号时，自动查询出它对应的账务账号。

1.2 方案

多对一关联映射开发步骤：

  1. 业务账号与账务账号具有多对一关系，他们的关系字段是service.account_id。
  2. 在业务账号中追加Account类型的属性，用于封装它对应的唯一账务账号。
  3. 在业务账号映射关系文件中配置此属性。

1.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：在业务账号实体类中追加属性

在业务账号实体类Service中，追加Account类型的属性，用于封装它对应的唯一账务账号。由于这个属性包含了账务账号的ID，因此accountId属性可以去掉了，实际上这个属性必须去掉，否则会报错。代码如下：

  1. package com.tarena.entity;
  3. import java.sql.Date;
  5. public class Service {
  7.     private Integer id;
  8. //    private Integer accountId;
  9.     private String unixHost;
  10.     private String osUserName;
  11.     private String loginPassword;
  12.     private String status;
  13.     private Date createDate;
  14.     private Date pauseDate;
  15.     private Date closeDate;
  16.     private Integer costId;
  17.     // 追加属性，用于封装对应的Account记录
  18.     private Account account;
  20.     public Integer getId() {
  21.         return id;
  22.     }
  24.     public void setId(Integer id) {
  25.         this.id = id;
  26.     }
  28. //    public Integer getAccountId() {
  29. //        return accountId;
  30. //    }
  31. //
  32. //    public void setAccountId(Integer accountId) {
  33. //        this.accountId = accountId;
  34. //    }
  36.     public Account getAccount() {
  37.         return account;
  38.     }
  40.     public void setAccount(Account account) {
  41.         this.account = account;
  42.     }
  44.     public String getUnixHost() {
  45.         return unixHost;
  46.     }
  48.     public void setUnixHost(String unixHost) {
  49.         this.unixHost = unixHost;
  50.     }
  52.     public String getOsUserName() {
  53.         return osUserName;
  54.     }
  56.     public void setOsUserName(String osUserName) {
  57.         this.osUserName = osUserName;
  58.     }
  60.     public String getLoginPassword() {
  61.         return loginPassword;
  62.     }
  64.     public void setLoginPassword(String loginPassword) {
  65.         this.loginPassword = loginPassword;
  66.     }
  68.     public String getStatus() {
  69.         return status;
  70.     }
  72.     public void setStatus(String status) {
  73.         this.status = status;
  74.     }
  76.     public Date getCreateDate() {
  77.         return createDate;
  78.     }
  80.     public void setCreateDate(Date createDate) {
  81.         this.createDate = createDate;
  82.     }
  84.     public Date getPauseDate() {
  85.         return pauseDate;
  86.     }
  88.     public void setPauseDate(Date pauseDate) {
  89.         this.pauseDate = pauseDate;
  90.     }
  92.     public Date getCloseDate() {
  93.         return closeDate;
  94.     }
  96.     public void setCloseDate(Date closeDate) {
  97.         this.closeDate = closeDate;
  98.     }
  100.     public Integer getCostId() {
  101.         return costId;
  102.     }
  104.     public void setCostId(Integer costId) {
  105.         this.costId = costId;
  106.     }
  108. }

步骤二：在业务账号映射关系文件中配置这个属性

在业务账号映射关系文件service.hbm.xml中，配置这个关联属性，代码如下：

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
  4. <hibernate-mapping>
  5.     <class name="com.tarena.entity.Service" table="SERVICE">
  6.         <id name="id" type="integer" column="id">
  7.             <generator class="sequence">
  8.                 <param name="sequence">SERVICE_SEQ</param>
  9.             </generator>
  10.         </id>
  11.         <!-- 
  12.             由于account属性已经体现了业务账号与账务账号的关系，
  13.             并且account属性可以包含账务账号ID，因此accountId可以去掉，
  14.             实际上这里必须去掉这个属性的配置，否则会报错。
  15.         -->
  16.         <!-- <property name="accountId" 
  17.             type="integer" column="ACCOUNT_ID"/> -->
  18.         <property name="unixHost" 
  19.             type="string" column="UNIX_HOST"/>
  20.         <property name="osUserName" 
  21.             type="string" column="OS_USERNAME"/>
  22.         <property name="loginPassword" 
  23.             type="string" column="LOGIN_PASSWD"/>
  24.         <property name="status" 
  25.             type="string" column="STATUS"/>
  26.         <property name="createDate" 
  27.             type="date" column="CREATE_DATE"/>
  28.         <property name="pauseDate" 
  29.             type="date" column="PAUSE_DATE"/>
  30.         <property name="closeDate" 
  31.             type="date" column="CLOSE_DATE"/>
  32.         <property name="costId" 
  33.             type="integer" column="COST_ID"/>
  34.             
  35.         <!-- 配置account属性，采用多对一关系加载相关的account内容 -->
  36.         <many-to-one name="account" column="ACCOUNT_ID"
  37.             class="com.tarena.entity.Account"/>            
  38.     </class>
  39. </hibernate-mapping>

步骤三：创建测试类

在com.tarena.test包下，创建一个测试类TestManyToOne，并且增加一个测试方法。在方法中查询出一条业务账号数据，然后输出这个业务账号的一些属性，同时输出account属性的值。代码如下：

  1. package com.tarena.test;
  3. import org.hibernate.Session;
  4. import org.junit.Test;
  5. import com.tarena.entity.Service;
  6. import com.tarena.util.HibernateUtil;
  8. public class TestManyToOne {
  9.     
  10.     @Test
  11.     public void test1() {
  12.         Session session = HibernateUtil.getSession();
  13.         Service service = 
  14.             (Service) session.get(Service.class, 2001);
  15.         System.out.println(service.getOsUserName());
  16.         System.out.println("------------------");
  17.         System.out.println(
  18.                 service.getAccount().getId() + " " +
  19.                 service.getAccount().getIdcardNo());
  20.     }
  21.     
  22. }

步骤四：测试

执行这个测试方法，控制台输出结果如下图，可以看出在查询SERVICE的同时，Hibernate自动查询出了它对应的ACCOUNT数据，并且这个关联查询是采用延迟加载机制实现的。

图-1

1.4 完整代码

以下为本案例的完整代码。

其中业务账号实体类完整代码如下：

代码

业务账号映射关系文件代码如下：

代码

测试类代码如下：

代码

2 关联查询的一些特性

2.1 问题

请按照如下的方式使用关联映射：

  1. 不采用延迟加载的方式查询关联属性。
  2. 采用关联查询一次性查出2张表的数据。

2.2 方案

可以按照如下的方式实现上述问题的要求：

  1. 通过lazy=”false”取消延迟加载。
  2. 通过fetch=”join”设置关联查询。

2.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：创建项目

复制项目HibernateDay02，粘贴并修改项目名为HibernateDay03。

步骤二：将一对多关联映射取消延迟加载

修改HibernateDay03项目中的Account.hbm.xml文件，将services属性的配置追加lazy=”false”，代码如下：

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
  4. <hibernate-mapping>
  5.     <class name="com.tarena.entity.Account" table="ACCOUNT">
  6.         <id name="id" type="integer" column="id">
  7.             <generator class="sequence">
  8.                 <param name="sequence">ACCOUNT_SEQ</param>
  9.             </generator>
  10.         </id>
  11.         <property name="recommenderId" 
  12.             type="integer" column="RECOMMENDER_ID"/>
  13.         <property name="loginName" 
  14.             type="string" column="LOGIN_NAME"/>
  15.         <property name="loginPassword" 
  16.             type="string" column="LOGIN_PASSWD"/>
  17.         <property name="status" 
  18.             type="string" column="STATUS"/>
  19.         <property name="createDate" 
  20.             type="date" column="CREATE_DATE"/>
  21.         <property name="pauseDate" 
  22.             type="date" column="PAUSE_DATE"/>
  23.         <property name="closeDate" 
  24.             type="date" column="CLOSE_DATE"/>
  25.         <property name="realName" 
  26.             type="string" column="REAL_NAME"/>
  27.         <property name="idcardNo" 
  28.             type="string" column="IDCARD_NO"/>
  29.         <property name="birthdate" 
  30.             type="date" column="BIRTHDATE"/>
  31.         <property name="gender" 
  32.             type="string" column="GENDER"/>
  33.         <property name="occupation" 
  34.             type="string" column="OCCUPATION"/>
  35.         <property name="telephone" 
  36.             type="string" column="TELEPHONE"/>
  37.         <property name="email" 
  38.             type="string" column="EMAIL"/>
  39.         <property name="mailaddress" 
  40.             type="string" column="MAILADDRESS"/>
  41.         <property name="zipcode" 
  42.             type="string" column="ZIPCODE"/>
  43.         <property name="qq" 
  44.             type="string" column="QQ"/>
  45.         <property name="lastLoginTime" 
  46.             type="date" column="LAST_LOGIN_TIME"/>
  47.         <property name="lastLoginIp" 
  48.             type="string" column="LAST_LOGIN_IP"/>
  49.             
  50.         <!-- 配置services属性，采用一对多的关系 -->
  51.         <set name="services" lazy="false">
  52.             <!-- 用于指定关联条件，写关联条件的外键字段 -->
  53.             <key column="ACCOUNT_ID"/>
  54.             <!-- 用于指定采用哪种关系，加载哪方数据 -->
  55.             <one-to-many class="com.tarena.entity.Service"/>
  56.         </set>
  57.     </class>
  58. </hibernate-mapping>

执行TestOneToMany中的测试方法，控制台输出结果如下图，可以看出在查询账务账号之后Hibernate立刻查询了它对应的业务账号，已经取消了延迟加载。

图-2

步骤三：将多对一关联映射取消延迟加载

修改Service.hbm.xml，将account属性的配置追加lazy=”false”，代码如下：

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
  4. <hibernate-mapping>
  5.     <class name="com.tarena.entity.Service" table="SERVICE">
  6.         <id name="id" type="integer" column="id">
  7.             <generator class="sequence">
  8.                 <param name="sequence">SERVICE_SEQ</param>
  9.             </generator>
  10.         </id>
  11.         <!-- 
  12.             由于account属性已经体现了业务账号与账务账号的关系，
  13.             并且account属性可以包含账务账号ID，因此accountId可以去掉，
  14.             实际上这里必须去掉这个属性的配置，否则会报错。
  15.         -->
  16.         <!-- <property name="accountId" 
  17.             type="integer" column="ACCOUNT_ID"/> -->
  18.         <property name="unixHost" 
  19.             type="string" column="UNIX_HOST"/>
  20.         <property name="osUserName" 
  21.             type="string" column="OS_USERNAME"/>
  22.         <property name="loginPassword" 
  23.             type="string" column="LOGIN_PASSWD"/>
  24.         <property name="status" 
  25.             type="string" column="STATUS"/>
  26.         <property name="createDate" 
  27.             type="date" column="CREATE_DATE"/>
  28.         <property name="pauseDate" 
  29.             type="date" column="PAUSE_DATE"/>
  30.         <property name="closeDate" 
  31.             type="date" column="CLOSE_DATE"/>
  32.         <property name="costId" 
  33.             type="integer" column="COST_ID"/>
  34.             
  35.         <!-- 配置account属性，采用多对一关系加载相关的account内容 -->
  36.         <many-to-one name="account" column="ACCOUNT_ID"
  37.             class="com.tarena.entity.Account"
  38.             lazy="false"/>            
  39.     </class>
  40. </hibernate-mapping>

执行TestManyToOne中的测试方法，控制台输出效果如下图，可以看出在查询业务账号之后Hibernate立刻查询了对应的账务账号，取消了延迟加载。

图-3

步骤四：将一对多关联映射设置为join方式抓取数据

修改Account.hbm.xml，将services属性的配置追加fetch=“join”，代码如下：

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
  4. <hibernate-mapping>
  5.     <class name="com.tarena.entity.Account" table="ACCOUNT">
  6.         <id name="id" type="integer" column="id">
  7.             <generator class="sequence">
  8.                 <param name="sequence">ACCOUNT_SEQ</param>
  9.             </generator>
  10.         </id>
  11.         <property name="recommenderId" 
  12.             type="integer" column="RECOMMENDER_ID"/>
  13.         <property name="loginName" 
  14.             type="string" column="LOGIN_NAME"/>
  15.         <property name="loginPassword" 
  16.             type="string" column="LOGIN_PASSWD"/>
  17.         <property name="status" 
  18.             type="string" column="STATUS"/>
  19.         <property name="createDate" 
  20.             type="date" column="CREATE_DATE"/>
  21.         <property name="pauseDate" 
  22.             type="date" column="PAUSE_DATE"/>
  23.         <property name="closeDate" 
  24.             type="date" column="CLOSE_DATE"/>
  25.         <property name="realName" 
  26.             type="string" column="REAL_NAME"/>
  27.         <property name="idcardNo" 
  28.             type="string" column="IDCARD_NO"/>
  29.         <property name="birthdate" 
  30.             type="date" column="BIRTHDATE"/>
  31.         <property name="gender" 
  32.             type="string" column="GENDER"/>
  33.         <property name="occupation" 
  34.             type="string" column="OCCUPATION"/>
  35.         <property name="telephone" 
  36.             type="string" column="TELEPHONE"/>
  37.         <property name="email" 
  38.             type="string" column="EMAIL"/>
  39.         <property name="mailaddress" 
  40.             type="string" column="MAILADDRESS"/>
  41.         <property name="zipcode" 
  42.             type="string" column="ZIPCODE"/>
  43.         <property name="qq" 
  44.             type="string" column="QQ"/>
  45.         <property name="lastLoginTime" 
  46.             type="date" column="LAST_LOGIN_TIME"/>
  47.         <property name="lastLoginIp" 
  48.             type="string" column="LAST_LOGIN_IP"/>
  49.             
  50.         <!-- 配置services属性，采用一对多的关系 -->
  51.         <set name="services" lazy="false" fetch="join">
  52.             <!-- 用于指定关联条件，写关联条件的外键字段 -->
  53.             <key column="ACCOUNT_ID"/>
  54.             <!-- 用于指定采用哪种关系，加载哪方数据 -->
  55.             <one-to-many class="com.tarena.entity.Service"/>
  56.         </set>
  57.     </class>
  58. </hibernate-mapping>

执行TestOneToMany中的测试方法，控制台输出结果如下图，可以看出查询时采用了join方式查询。

图-4

步骤五：将多对一关联映射设置为join方式抓取数据

修改Service.hbm.xml，将account属性追加fetch=“join”，代码如下：

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
  4. <hibernate-mapping>
  5.     <class name="com.tarena.entity.Service" table="SERVICE">
  6.         <id name="id" type="integer" column="id">
  7.             <generator class="sequence">
  8.                 <param name="sequence">SERVICE_SEQ</param>
  9.             </generator>
  10.         </id>
  11.         <!-- 
  12.             由于account属性已经体现了业务账号与账务账号的关系，
  13.             并且account属性可以包含账务账号ID，因此accountId可以去掉，
  14.             实际上这里必须去掉这个属性的配置，否则会报错。
  15.         -->
  16.         <!-- <property name="accountId" 
  17.             type="integer" column="ACCOUNT_ID"/> -->
  18.         <property name="unixHost" 
  19.             type="string" column="UNIX_HOST"/>
  20.         <property name="osUserName" 
  21.             type="string" column="OS_USERNAME"/>
  22.         <property name="loginPassword" 
  23.             type="string" column="LOGIN_PASSWD"/>
  24.         <property name="status" 
  25.             type="string" column="STATUS"/>
  26.         <property name="createDate" 
  27.             type="date" column="CREATE_DATE"/>
  28.         <property name="pauseDate" 
  29.             type="date" column="PAUSE_DATE"/>
  30.         <property name="closeDate" 
  31.             type="date" column="CLOSE_DATE"/>
  32.         <property name="costId" 
  33.             type="integer" column="COST_ID"/>
  34.             
  35.         <!-- 配置account属性，采用多对一关系加载相关的account内容 -->
  36.         <many-to-one name="account" column="ACCOUNT_ID"
  37.             class="com.tarena.entity.Account"
  38.             lazy="false" fetch="join"/>            
  39.     </class>
  40. </hibernate-mapping>

执行TestManyToOne中的测试方法，控制台输出结果如下图，可以看出查询时采用了join方式查询。

图-5

2.4 完整代码

以下为本案例的完整代码。

其中账务账号映射关系文件完整代码如下：

代码

业务账号映射关系文件完整代码如下：

代码

3 级联添加/修改

3.1 问题

使用级联添加/修改，在添加/修改账务账号时，自动添加/修改其对应的业务账号。

3.2 方案

通过在映射关系文件中设置cascade=”save-update”，可以支持级联添加/修改。

3.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：在账务账号映射关系文件中设置级联添加/修改

在账务账号映射关系文件Account.hbm.xml中，通过cascade=“save-update”设置支持级联添加/修改，代码如下：

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
  4. <hibernate-mapping>
  5.     <class name="com.tarena.entity.Account" table="ACCOUNT">
  6.         <id name="id" type="integer" column="id">
  7.             <generator class="sequence">
  8.                 <param name="sequence">ACCOUNT_SEQ</param>
  9.             </generator>
  10.         </id>
  11.         <property name="recommenderId" 
  12.             type="integer" column="RECOMMENDER_ID"/>
  13.         <property name="loginName" 
  14.             type="string" column="LOGIN_NAME"/>
  15.         <property name="loginPassword" 
  16.             type="string" column="LOGIN_PASSWD"/>
  17.         <property name="status" 
  18.             type="string" column="STATUS"/>
  19.         <property name="createDate" 
  20.             type="date" column="CREATE_DATE"/>
  21.         <property name="pauseDate" 
  22.             type="date" column="PAUSE_DATE"/>
  23.         <property name="closeDate" 
  24.             type="date" column="CLOSE_DATE"/>
  25.         <property name="realName" 
  26.             type="string" column="REAL_NAME"/>
  27.         <property name="idcardNo" 
  28.             type="string" column="IDCARD_NO"/>
  29.         <property name="birthdate" 
  30.             type="date" column="BIRTHDATE"/>
  31.         <property name="gender" 
  32.             type="string" column="GENDER"/>
  33.         <property name="occupation" 
  34.             type="string" column="OCCUPATION"/>
  35.         <property name="telephone" 
  36.             type="string" column="TELEPHONE"/>
  37.         <property name="email" 
  38.             type="string" column="EMAIL"/>
  39.         <property name="mailaddress" 
  40.             type="string" column="MAILADDRESS"/>
  41.         <property name="zipcode" 
  42.             type="string" column="ZIPCODE"/>
  43.         <property name="qq" 
  44.             type="string" column="QQ"/>
  45.         <property name="lastLoginTime" 
  46.             type="date" column="LAST_LOGIN_TIME"/>
  47.         <property name="lastLoginIp" 
  48.             type="string" column="LAST_LOGIN_IP"/>
  49.             
  50.         <!-- 配置services属性，采用一对多的关系 -->
  51.         <set name="services" 
  52.             lazy="false" fetch="join" 
  53.             cascade="save-update">
  54.             <!-- 用于指定关联条件，写关联条件的外键字段 -->
  55.             <key column="ACCOUNT_ID"/>
  56.             <!-- 用于指定采用哪种关系，加载哪方数据 -->
  57.             <one-to-many 
  58.                 class="com.tarena.entity.Service"/>
  59.         </set>
  60.     </class>
  61. </hibernate-mapping>

步骤二：测试级联添加

在com.tarena.test包下，创建测试类TestCascade，并在类中增加测试级联添加的方法，代码如下：

  1. package com.tarena.test;
  3. import java.util.HashSet;
  4. import java.util.Set;
  6. import org.hibernate.HibernateException;
  7. import org.hibernate.Session;
  8. import org.hibernate.Transaction;
  9. import org.junit.Test;
  10. import com.tarena.entity.Account;
  11. import com.tarena.entity.Service;
  12. import com.tarena.util.HibernateUtil;
  14. public class TestCascade {
  16.     /**
  17.      * 级联添加
  18.      */
  19.     @Test
  20.     public void test1() {
  21.         // 模拟要添加的账务账号
  22.         Account a = new Account();
  23.         a.setLoginName("gg");
  24.         a.setLoginPassword("123");
  25.         a.setRealName("gg");
  26.         a.setIdcardNo("120392198410282549");
  27.         a.setStatus("0");
  28.         a.setTelephone("110");
  30.         // 模拟要添加的业务账号
  31.         Service s1 = new Service();
  32.         s1.setAccount(a);
  33.         s1.setOsUserName("gg1");
  34.         s1.setLoginPassword("123");
  35.         s1.setUnixHost("192.168.1.1");
  36.         s1.setCostId(5);
  37.         s1.setStatus("0");
  39.         Service s2 = new Service();
  40.         s2.setAccount(a);
  41.         s2.setOsUserName("gg2");
  42.         s2.setLoginPassword("123");
  43.         s2.setUnixHost("192.168.1.2");
  44.         s2.setCostId(5);
  45.         s2.setStatus("0");
  47.         // 将业务账号与账务账号关联
  48.         a.setServices(new HashSet<Service>());
  49.         a.getServices().add(s1);
  50.         a.getServices().add(s2);
  52.         Session session = HibernateUtil.getSession();
  53.         Transaction ts = session.beginTransaction();
  54.         try {
  55.             session.save(a);
  56.             ts.commit();
  57.         } catch (HibernateException e) {
  58.             e.printStackTrace();
  59.             ts.rollback();
  60.         } finally {
  61.             session.close();
  62.         }
  64.     }
  65.     
  66. }

执行test1()方法，控制台输出结果如下图，可以看出在新增账务账号之后，Hibernate自动新增了账务账号对应的业务账号数据，这就是级联添加所起到的作用。

图-6

此时，查询账务账号表，数据如下图，其中id=380的行就是刚刚添加的行。

图-7

再查询业务账号表，数据如下图，其中account_id=380的行就是级联添加的行。

图-8

步骤三：测试级联修改

在TestCascade测试类中，增加测试级联修改的方法，代码如下：

  1. package com.tarena.test;
  3. import java.util.HashSet;
  4. import java.util.Set;
  6. import org.hibernate.HibernateException;
  7. import org.hibernate.Session;
  8. import org.hibernate.Transaction;
  9. import org.junit.Test;
  10. import com.tarena.entity.Account;
  11. import com.tarena.entity.Service;
  12. import com.tarena.util.HibernateUtil;
  14. public class TestCascade {
  16.     /**
  17.      * 级联添加
  18.      */
  19.     @Test
  20.     public void test1() {
  21.         // 模拟要添加的账务账号
  22.         Account a = new Account();
  23.         a.setLoginName("gg");
  24.         a.setLoginPassword("123");
  25.         a.setRealName("gg");
  26.         a.setIdcardNo("120392198410282549");
  27.         a.setStatus("0");
  28.         a.setTelephone("110");
  30.         // 模拟要添加的业务账号
  31.         Service s1 = new Service();
  32.         s1.setAccount(a);
  33.         s1.setOsUserName("gg1");
  34.         s1.setLoginPassword("123");
  35.         s1.setUnixHost("192.168.1.1");
  36.         s1.setCostId(5);
  37.         s1.setStatus("0");
  39.         Service s2 = new Service();
  40.         s2.setAccount(a);
  41.         s2.setOsUserName("gg2");
  42.         s2.setLoginPassword("123");
  43.         s2.setUnixHost("192.168.1.2");
  44.         s2.setCostId(5);
  45.         s2.setStatus("0");
  47.         // 将业务账号与账务账号关联
  48.         a.setServices(new HashSet<Service>());
  49.         a.getServices().add(s1);
  50.         a.getServices().add(s2);
  52.         Session session = HibernateUtil.getSession();
  53.         Transaction ts = session.beginTransaction();
  54.         try {
  55.             session.save(a);
  56.             ts.commit();
  57.         } catch (HibernateException e) {
  58.             e.printStackTrace();
  59.             ts.rollback();
  60.         } finally {
  61.             session.close();
  62.         }
  64.     }
  66.     /**
  67.      * 级联修改
  68.      */
  69.     @Test
  70.     public void test2() {
  71.         Session session = HibernateUtil.getSession();
  72.         // 查询出要修改的账务账号
  73.         Account account = 
  74. #cold_bold            (Account) session.get(Account.class, 380);
  75.         // 模拟对账务账号的修改
  76.         account.setLoginName("pp");
  77.         Set<Service> services = account.getServices();
  78.         for (Service service : services) {
  79.             // 模拟对业务账号的修改
  80.             service.setLoginPassword("pp");
  81.         }
  82.         Transaction ts = session.beginTransaction();
  83.         try {
  84.             session.update(account);
  85.             ts.commit();
  86.         } catch (HibernateException e) {
  87.             e.printStackTrace();
  88.             ts.rollback();
  89.         } finally {
  90.             session.close();
  91.         }
  92.     }
  93.     
  94. }

执行test2()方法后，控制台输出的结果如下图，可以看出在修改完账务账号之后，Hibernate自动修改了它对应的业务账号数据。

图-9

此时，查询账务账号表，id=380的行已经发生了改变。

图-10

再查询业务账号表，account_id=380的行也发生了改变。

图-11

3.4 完整代码

以下为本案例的完整代码。

其中Account.hbm.xml完整代码如下：

代码

TestCascade完整代码如下：

代码

4 级联删除

4.1 问题

使用级联删除，在删除账务账号时，自动删除其对应的业务账号。

4.2 方案

通过在映射关系文件中设置cascade=“delete”，可以支持级联删除，如果想全面支持级联添加、修改和删除，可以设置cascade=“all”。

4.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：在账务账号映射关系文件中设置级联删除

在账务账号映射关系文件Account.hbm.xml中，通过cascade=“all”设置支持级联删除，代码如下：

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
  4. <hibernate-mapping>
  5.     <class name="com.tarena.entity.Account" table="ACCOUNT">
  6.         <id name="id" type="integer" column="id">
  7.             <generator class="sequence">
  8.                 <param name="sequence">ACCOUNT_SEQ</param>
  9.             </generator>
  10.         </id>
  11.         <property name="recommenderId" 
  12.             type="integer" column="RECOMMENDER_ID"/>
  13.         <property name="loginName" 
  14.             type="string" column="LOGIN_NAME"/>
  15.         <property name="loginPassword" 
  16.             type="string" column="LOGIN_PASSWD"/>
  17.         <property name="status" 
  18.             type="string" column="STATUS"/>
  19.         <property name="createDate" 
  20.             type="date" column="CREATE_DATE"/>
  21.         <property name="pauseDate" 
  22.             type="date" column="PAUSE_DATE"/>
  23.         <property name="closeDate" 
  24.             type="date" column="CLOSE_DATE"/>
  25.         <property name="realName" 
  26.             type="string" column="REAL_NAME"/>
  27.         <property name="idcardNo" 
  28.             type="string" column="IDCARD_NO"/>
  29.         <property name="birthdate" 
  30.             type="date" column="BIRTHDATE"/>
  31.         <property name="gender" 
  32.             type="string" column="GENDER"/>
  33.         <property name="occupation" 
  34.             type="string" column="OCCUPATION"/>
  35.         <property name="telephone" 
  36.             type="string" column="TELEPHONE"/>
  37.         <property name="email" 
  38.             type="string" column="EMAIL"/>
  39.         <property name="mailaddress" 
  40.             type="string" column="MAILADDRESS"/>
  41.         <property name="zipcode" 
  42.             type="string" column="ZIPCODE"/>
  43.         <property name="qq" 
  44.             type="string" column="QQ"/>
  45.         <property name="lastLoginTime" 
  46.             type="date" column="LAST_LOGIN_TIME"/>
  47.         <property name="lastLoginIp" 
  48.             type="string" column="LAST_LOGIN_IP"/>
  49.             
  50.         <!-- 配置services属性，采用一对多的关系 -->
  51.         <set name="services" 
  52.             lazy="false" fetch="join" 
  53.             cascade="all">
  54.             <!-- 用于指定关联条件，写关联条件的外键字段 -->
  55.             <key column="ACCOUNT_ID"/>
  56.             <!-- 用于指定采用哪种关系，加载哪方数据 -->
  57.             <one-to-many 
  58.                 class="com.tarena.entity.Service"/>
  59.         </set>
  60.     </class>
  61. </hibernate-mapping>

步骤二：测试级联删除

在TestCascade测试类中，增加测试级联删除的方法，代码如下：

  1. package com.tarena.test;
  3. import java.util.HashSet;
  4. import java.util.Set;
  6. import org.hibernate.HibernateException;
  7. import org.hibernate.Session;
  8. import org.hibernate.Transaction;
  9. import org.junit.Test;
  10. import com.tarena.entity.Account;
  11. import com.tarena.entity.Service;
  12. import com.tarena.util.HibernateUtil;
  14. public class TestCascade {
  16.     /**
  17.      * 级联添加
  18.      */
  19.     @Test
  20.     public void test1() {
  21.         // 模拟要添加的账务账号
  22.         Account a = new Account();
  23.         a.setLoginName("gg");
  24.         a.setLoginPassword("123");
  25.         a.setRealName("gg");
  26.         a.setIdcardNo("120392198410282549");
  27.         a.setStatus("0");
  28.         a.setTelephone("110");
  30.         // 模拟要添加的业务账号
  31.         Service s1 = new Service();
  32.         s1.setAccount(a);
  33.         s1.setOsUserName("gg1");
  34.         s1.setLoginPassword("123");
  35.         s1.setUnixHost("192.168.1.1");
  36.         s1.setCostId(5);
  37.         s1.setStatus("0");
  39.         Service s2 = new Service();
  40.         s2.setAccount(a);
  41.         s2.setOsUserName("gg2");
  42.         s2.setLoginPassword("123");
  43.         s2.setUnixHost("192.168.1.2");
  44.         s2.setCostId(5);
  45.         s2.setStatus("0");
  47.         // 将业务账号与账务账号关联
  48.         a.setServices(new HashSet<Service>());
  49.         a.getServices().add(s1);
  50.         a.getServices().add(s2);
  52.         Session session = HibernateUtil.getSession();
  53.         Transaction ts = session.beginTransaction();
  54.         try {
  55.             session.save(a);
  56.             ts.commit();
  57.         } catch (HibernateException e) {
  58.             e.printStackTrace();
  59.             ts.rollback();
  60.         } finally {
  61.             session.close();
  62.         }
  64.     }
  66.     /**
  67.      * 级联修改
  68.      */
  69.     @Test
  70.     public void test2() {
  71.         Session session = HibernateUtil.getSession();
  72.         // 查询出要修改的账务账号
  73.         Account account = 
  74.             (Account) session.get(Account.class, 380);
  75.         // 模拟对账务账号的修改
  76.         account.setLoginName("pp");
  77.         Set<Service> services = account.getServices();
  78.         for (Service service : services) {
  79.             // 模拟对业务账号的修改
  80.             service.setLoginPassword("pp");
  81.         }
  82.         Transaction ts = session.beginTransaction();
  83.         try {
  84.             session.update(account);
  85.             ts.commit();
  86.         } catch (HibernateException e) {
  87.             e.printStackTrace();
  88.             ts.rollback();
  89.         } finally {
  90.             session.close();
  91.         }
  92.     }
  94.     /**
  95.      * 级联删除
  96.      */
  97.     @Test
  98.     public void test3() {
  99.         Session session = HibernateUtil.getSession();
  100.         Account account = (Account) session.get(Account.class, 380);
  101.         Transaction ts = session.beginTransaction();
  102.         try {
  103.             session.delete(account);
  104.             ts.commit();
  105.         } catch (HibernateException e) {
  106.             e.printStackTrace();
  107.             ts.rollback();
  108.         } finally {
  109.             session.close();
  110.         }
  111.     }
  112.     
  113. }

步骤三：测试

执行test3()方法，控制台输出结果如下图，可以看出程序在运行时报错了：

图-12

步骤四：排错

上述错误是执行第二个SQL时产生的，这个SQL的目的是维护关系字段，将其置为null，而这个外键字段存在非空约束，因此报错。类似的事情在级联添加时也看到过，参考图-6，不同的是级联添加时要将关联字段设置为新生成的账务账号ID。然而，在级联新增或删除时业务账号时，业务账号本身已经维护好了关联字段，因此这个额外的操作是多余的，可以去掉，我们可以在关联属性上通过inverse=“true“去掉这个行为，代码如下：

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
  4. <hibernate-mapping>
  5.     <class name="com.tarena.entity.Account" table="ACCOUNT">
  6.         <id name="id" type="integer" column="id">
  7.             <generator class="sequence">
  8.                 <param name="sequence">ACCOUNT_SEQ</param>
  9.             </generator>
  10.         </id>
  11.         <property name="recommenderId" 
  12.             type="integer" column="RECOMMENDER_ID"/>
  13.         <property name="loginName" 
  14.             type="string" column="LOGIN_NAME"/>
  15.         <property name="loginPassword" 
  16.             type="string" column="LOGIN_PASSWD"/>
  17.         <property name="status" 
  18.             type="string" column="STATUS"/>
  19.         <property name="createDate" 
  20.             type="date" column="CREATE_DATE"/>
  21.         <property name="pauseDate" 
  22.             type="date" column="PAUSE_DATE"/>
  23.         <property name="closeDate" 
  24.             type="date" column="CLOSE_DATE"/>
  25.         <property name="realName" 
  26.             type="string" column="REAL_NAME"/>
  27.         <property name="idcardNo" 
  28.             type="string" column="IDCARD_NO"/>
  29.         <property name="birthdate" 
  30.             type="date" column="BIRTHDATE"/>
  31.         <property name="gender" 
  32.             type="string" column="GENDER"/>
  33.         <property name="occupation" 
  34.             type="string" column="OCCUPATION"/>
  35.         <property name="telephone" 
  36.             type="string" column="TELEPHONE"/>
  37.         <property name="email" 
  38.             type="string" column="EMAIL"/>
  39.         <property name="mailaddress" 
  40.             type="string" column="MAILADDRESS"/>
  41.         <property name="zipcode" 
  42.             type="string" column="ZIPCODE"/>
  43.         <property name="qq" 
  44.             type="string" column="QQ"/>
  45.         <property name="lastLoginTime" 
  46.             type="date" column="LAST_LOGIN_TIME"/>
  47.         <property name="lastLoginIp" 
  48.             type="string" column="LAST_LOGIN_IP"/>
  49.             
  50.         <!-- 配置services属性，采用一对多的关系 -->
  51.         <set name="services" 
  52.             lazy="false" fetch="join" 
  53.             cascade="all" inverse="true">
  54.             <!-- 用于指定关联条件，写关联条件的外键字段 -->
  55.             <key column="ACCOUNT_ID"/>
  56.             <!-- 用于指定采用哪种关系，加载哪方数据 -->
  57.             <one-to-many 
  58.                 class="com.tarena.entity.Service"/>
  59.         </set>
  60.     </class>
  61. </hibernate-mapping>

步骤五：测试

再次执行test3()方法，控制台输出结果如下图，可以看出本次删除成功了，不但删除了账务账号数据，在此之前还删除了它所对应的所有业务账号。

图-13

4.4 完整代码

以下为本案例的完整代码。

其中Account.hbm.xml完整代码如下：

代码

TestCascade完整代码如下：

代码

5 HQL查询，按条件查询

5.1 问题

使用带条件的HQL 查询业务账号数据。

5.2 方案

在HQL中拼入条件，如name=?，然后在查询之前使用query给参数赋值。

5.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：编写按条件查询方法

在com.tarena.test包下创建测试类TestHQL，并在类中增加按条件查询的测试方法，代码如下：

  1. package com.tarena.test;
  3. import java.util.List;
  4. import org.hibernate.Query;
  5. import org.hibernate.Session;
  6. import org.junit.Test;
  7. import com.tarena.entity.Service;
  8. import com.tarena.util.HibernateUtil;
  10. public class TestHQL {
  11.     
  12.     /**
  13.      * 按条件查询
  14.      */
  15.     @Test
  16.     public void test1() {
  17.         String hql = "from Service where unixHost=?";
  18.         Session session = HibernateUtil.getSession();
  19.         Query query = session.createQuery(hql);
  20.         query.setString(0, "192.168.0.20");
  21.         List<Service> services = query.list();
  22.         for(Service service : services){
  23.             System.out.println(service.getId()
  24.                     + " " + service.getUnixHost()
  25.                     + " " + service.getOsUserName());
  26.         }
  27.         session.close();
  28.     }
  29.     
  30. }

步骤二：测试

执行test1()方法，控制台输出效果如下图，可以看到按条件查询出的结果：

图-14

5.4 完整代码

以下为本案例的完整代码。

其中TestHQL完整代码如下：

代码

6 HQL查询，查询一部分字段

6.1 问题

使用HQL查询，要求只查询一部分字段。

6.2 方案

可以通过select子句明确指定要返回的字段，注意HQL中select子句中写的是属性，而不是表中的字段。

6.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：编写查询一部分字段方法

在TestHQL中增加查询一部分字段的方法，代码如下：

  1. package com.tarena.test;
  3. import java.util.List;
  4. import org.hibernate.Query;
  5. import org.hibernate.Session;
  6. import org.junit.Test;
  7. import com.tarena.entity.Service;
  8. import com.tarena.util.HibernateUtil;
  10. public class TestHQL {
  11.     
  12. // 其他查询方法略
  13.     /**
  14.      * 查询一部分字段
  15.      */
  16.     @Test
  17.     public void test2() {
  18.         String hql = "select id,unixHost,osUserName " +
  19.                 "from Service where unixHost=?";
  20.         Session session = HibernateUtil.getSession();
  21.         Query query = session.createQuery(hql);
  22.         query.setString(0, "192.168.0.20");
  23.         List<Object[]> services = query.list();
  24.         for(Object[] service : services) {
  25.             System.out.println(service[0]
  26.                     + " " + service[1]
  27.                     + " " + service[2]);
  28.         }
  29.         session.close();
  30.     }
  31.     
  32. }

步骤二：测试

执行test2()，控制台输出结果如下图，可以看到查询出来的这些字段的值。

图-15

6.4 完整代码

以下为本案例的完整代码。

其中TestHQL完整代码如下：

代码

7 HQL查询，分页查询

7.1 问题

按照每页显示3条数据，查询第1页的条件，查询出业务账号表中满足条件的记录，并且查询出总页数。

7.2 方案

  1. 分页查询时，在执行查询之前可以通过query对象设置分页参数值，query.setFirstResult(起点)，以及query.setMaxResults(页容量)。
  2. 查询总页数，只需要通过hql查询出总行数，再根据总行数计算总页数即可，而查询总行数的hql格式为select count(*) from 对象。

7.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：编写分页查询的方法

在TestHQL中，增加分页查询的方法，代码如下：

  1. package com.tarena.test;
  3. import java.util.List;
  4. import org.hibernate.Query;
  5. import org.hibernate.Session;
  6. import org.junit.Test;
  7. import com.tarena.entity.Service;
  8. import com.tarena.util.HibernateUtil;
  10. public class TestHQL {
  11.     
  12.     // 其他查询方法略
  13.     
  14.     /**
  15.      * 分页查询
  16.      */
  17.     @Test
  18.     public void test3() {
  19.         int page = 1;
  20.         int pageSize = 3;
  22.         String hql = "from Service order by id";
  23.         Session session = HibernateUtil.getSession();
  24.         Query query = session.createQuery(hql);
  25.         // 追加分页参数设置
  26.         int from = (page - 1) * pageSize;
  27.         query.setFirstResult(from);// 设置起点，从0开始
  28.         query.setMaxResults(pageSize);// 设置页容量
  29.         List<Service> services = query.list();
  30.         for (Service service : services) {
  31.             System.out.println(
  32.                 service.getId() + " " 
  33.                 + service.getUnixHost() + " " 
  34.                 + service.getOsUserName());
  35.         }
  36.         session.close();
  37.     }
  38.     
  39. }

步骤二：测试

执行test3()，控制台输出结果如下图，输出了第1页的3条数据。

图-16

步骤三：编写查询总页数的方法

在TestHQL中，增加查询总页数的方法，代码如下：

  1. package com.tarena.test;
  3. import java.util.List;
  4. import org.hibernate.Query;
  5. import org.hibernate.Session;
  6. import org.junit.Test;
  7. import com.tarena.entity.Service;
  8. import com.tarena.util.HibernateUtil;
  10. public class TestHQL {
  11.     
  12. // 其他查询方法略
  13.     /**
  14.      * 查询总页数
  15.      */
  16.     @Test
  17.     public void test4() {
  18.         int pageSize=3;
  19.         String hql = "select count(*) from Service";
  20.         Session session = HibernateUtil.getSession();
  21.         Query query = session.createQuery(hql);
  22.         int rows = Integer.parseInt(query.uniqueResult().toString());
  23.         int totalPages = 0;
  24.         if(rows%pageSize == 0) {
  25.             totalPages = rows/pageSize;
  26.         } else {
  27.             totalPages = rows/pageSize+1;
  28.         }
  29.         System.out.println(totalPages);
  30.         session.close();
  31.     }
  32.     
  33. }

步骤四：测试

执行test4()，控制台输出结果如下图，输出了总页数。

图-17

7.4 完整代码

以下为本案例的完整代码。

其中TestHQL完整代码如下：

代码

8 HQL查询，多表联合查询

8.1 问题

使用HQL，联合查询出业务账号与账务账号的数据。

8.2 方案

HQL中多表联合查询的方式有3种，分别是

  1. 对象方式关联
  2. join方式关联
  3. select子句关联

使用这三种方式来做业务账号与账务账号的联合查询。

8.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：编写对象方式关联的方法

在TestHQL中，增加对象方式关联的查询方法，代码如下：

  1. package com.tarena.test;
  3. import java.util.List;
  4. import org.hibernate.Query;
  5. import org.hibernate.Session;
  6. import org.junit.Test;
  7. import com.tarena.entity.Service;
  8. import com.tarena.util.HibernateUtil;
  10. public class TestHQL {
  11.     
  12.     // 其他查询方法略
  13.     
  14.     /**
  15.      * 多表联合查询-对象方式关联
  16.      */
  17.     @Test
  18.     public void test5() {
  19.         String hql = "select " +
  20.                 "s.id," +
  21.                 "s.osUserName," +
  22.                 "s.unixHost, " +
  23.                 "a.id,a.realName," +
  24.                 "a.idcardNo " +
  25.                 "from Service s,Account a " +
  26.                 "where s.account.id=a.id ";
  27.         Session session = HibernateUtil.getSession();
  28.         Query query = session.createQuery(hql);
  29.         List<Object[]> list = query.list();
  30.         for (Object[] objs : list) {
  31.             System.out.println(
  32.                     objs[0] + " " +
  33.                     objs[1] + " " +
  34.                     objs[2] + " " +
  35.                     objs[3] + " " +
  36.                     objs[4] + " " +
  37.                     objs[5]);
  38.         }
  39.         session.close();
  40.     }
  41.     
  42. }

步骤二：测试

执行test5()，控制台输出结果如下图，可以查询出关联的数据。

图-18

步骤三：编写join方式关联的方法

在TestHQL中，增加join方式关联的查询方法，代码如下：

  1. package com.tarena.test;
  3. import java.util.List;
  4. import org.hibernate.Query;
  5. import org.hibernate.Session;
  6. import org.junit.Test;
  7. import com.tarena.entity.Service;
  8. import com.tarena.util.HibernateUtil;
  10. public class TestHQL {
  11.     
  12.     // 其他查询方法略
  13.     
  14.     /**
  15.      * 多表联合查询-join方式关联
  16.      */
  17.     @Test
  18.     public void test6() {
  19.         String hql = "select " +
  20.                 "s.id,s.osUserName," +
  21.                 "s.unixHost, " +
  22.                 "a.id," +
  23.                 "a.realName," +
  24.                 "a.idcardNo " +
  25.                 "from Service s join s.account a ";
  26.         Session session = HibernateUtil.getSession();
  27.         Query query = session.createQuery(hql);
  28.         List<Object[]> list = query.list();
  29.         for (Object[] objs : list) {
  30.             System.out.println(
  31.                     objs[0] + " " +
  32.                     objs[1] + " " +
  33.                     objs[2] + " " +
  34.                     objs[3] + " " +
  35.                     objs[4] + " " +
  36.                     objs[5]);
  37.         }
  38.         session.close();
  39.     }
  40.     
  41. }

步骤四：测试

执行test6()，控制台输出结果如下图，可以查询出关联的数据。

图-19

步骤五：编写select子句关联的方法

在TestHQL中，增加select子句关联的查询方法，代码如下：

  1. package com.tarena.test;
  3. import java.util.List;
  4. import org.hibernate.Query;
  5. import org.hibernate.Session;
  6. import org.junit.Test;
  7. import com.tarena.entity.Service;
  8. import com.tarena.util.HibernateUtil;
  10. public class TestHQL {
  11.     
  12. // 其他查询方法略    
  13.     /**
  14.      * 多表联合查询-select子句关联
  15.      */
  16.     @Test
  17.     public void test7() {
  18.         String hql = "select " +
  19.                 "id," +
  20.                 "osUserName," +
  21.                 "unixHost, " +
  22.                 "account.id," +
  23.                 "account.realName," +
  24.                 "account.idcardNo " +
  25.                 "from Service ";
  26.         Session session = HibernateUtil.getSession();
  27.         Query query = session.createQuery(hql);
  28.         List<Object[]> list = query.list();
  29.         for (Object[] objs : list) {
  30.             System.out.println(
  31.                     objs[0] + " " +
  32.                     objs[1] + " " +
  33.                     objs[2] + " " +
  34.                     objs[3] + " " +
  35.                     objs[4] + " " +
  36.                     objs[5]);
  37.         }
  38.         session.close();
  39.     }
  40.     
  41. }

步骤六：测试

执行test7()，控制台输出结果如下，可以查询出关联的数据。

图-20

8.4 完整代码

以下为本案例的完整代码。

其中TestHQL完整代码如下：

代码

9 Hibernate中的SQL查询

9.1 问题

在Hibernate中直接使用SQL查询业务账号数据。

9.2 方案

Hibernate中可以通过SQLQuery对象来执行原始的SQL。

9.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：编写使用SQL查询的方法

在com.tarena.test包下，创建测试类TestOtherQuery，并在类中增加使用SQL查询的方法，代码如下：

  1. package com.tarena.test;
  3. import java.util.List;
  4. import org.hibernate.SQLQuery;
  5. import org.hibernate.Session;
  6. import org.junit.Test;
  7. import com.tarena.entity.Service;
  8. import com.tarena.util.HibernateUtil;
  10. public class TestOtherQuery {
  11.     
  12.     /**
  13.      * 使用SQL查询
  14.      */
  15.     @Test
  16.     public void test1() {
  17.         String sql = "select * " +
  18.                 "from SERVICE where unix_host=?";
  19.         Session session = HibernateUtil.getSession();
  20.         SQLQuery query = session.createSQLQuery(sql);
  21.         query.setString(0, "192.168.0.20");
  22.         query.addEntity(Service.class);
  23.         //采用Service类型封装一条数据
  24.         List<Service> list = query.list();
  25.         for(Service service : list){
  26.             System.out.println(
  27.                 service.getId() + " " +
  28.                 service.getOsUserName() + " " +
  29.                 service.getUnixHost() + " " 
  30.             );
  31.         }
  32.         session.close();
  33.     }
  34.     
  35. }

步骤二：测试

执行test1()，控制台输出结果如下图，是直接执行SQL所查询到的内容：

图-21

9.4 完整代码

以下为本案例的完整代码。

其中TestOtherQuery完整代码如下：

代码

10 使用二级缓存

10.1 问题

在查询员工时，使用二级缓存，使得不同的session可以共享这些员工数据。

10.2 方案

使用ehcache缓存组件来支持二级缓存，二级缓存的使用步骤为

  1. 导入二级缓存驱动包
  2. 引入二级缓存配置文件
  3. 在hibernate.cfg.xml中开启二级缓存并指定二级缓存驱动类
  4. 在映射关系文件中设置缓存策略
  5. 执行查询

10.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：导入二级缓存驱动包

导入二级缓存驱动包ehcache-1.2.3.jar，导入后项目中包结构如下图：

图-22

步骤二：引入二级缓存配置文件

引入二级缓存配置文件ehcache.xml，并配置缓存参数，代码如下：

  1. <ehcache>
  3. <!-- 
  4.     缓存到硬盘时的缓存路径,java.io.tmpdir表示
  5.     系统默认缓存路径。
  6.      -->
  7. <diskStore path="java.io.tmpdir"/>
  9. <!-- 
  10.     默认缓存配置。
  11.     maxElementsInMemory：
  12.         二级缓存可容纳最大对象数。
  13.     eternal：
  14.         是否保持二级缓存中对象不变。
  15.     timeToIdleSeconds：
  16.         允许对象空闲的时间，即对象最后一次访问起，超过该时间即失效。
  17.     timeToLiveSeconds：
  18.         允许对象存活的时间，即对象创建起，超过该时间即失效。
  19.     overflowToDisk：
  20.         内存不足时，是否允许使用硬盘缓存，写入路径参见diskStore。
  21.      -->
  22. <defaultCache
  23.         maxElementsInMemory="300"
  24.         eternal="false"
  25.         timeToIdleSeconds="120"
  26.         timeToLiveSeconds="300"
  27.         overflowToDisk="true"
  28.         />
  30.     <!-- 自定义缓存配置 -->
  31. <cache name="myCache"
  32.         maxElementsInMemory="2000"
  33.         eternal="false"
  34.         timeToIdleSeconds="300"
  35.         timeToLiveSeconds="600"
  36.         overflowToDisk="true"
  37.         />
  39. </ehcache>

步骤三：开启二级缓存、指定二级缓存驱动类

在hibernate.cfg.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.         <!-- 数据库连接信息，根据自己的数据库进行配置 -->
  8.         <property name="connection.url">
  9.             jdbc:oracle:thin:@localhost:1521:xe
  10.         </property>
  11.         <property name="connection.username">lhh</property>
  12.         <property name="connection.password">123456</property>
  13.         <property name="connection.driver_class">
  14.             oracle.jdbc.OracleDriver
  15.         </property>
  16.         
  17.         <!-- Hibernate配置信息 -->
  18.         <!-- dialect方言，用于配置生成针对哪个数据库的SQL语句 -->
  19.         <property name="dialect">
  20.             <!-- 方言类，Hibernate提供的，用于封装某种特定数据库的方言 -->
  21.             org.hibernate.dialect.OracleDialect
  22.         </property>
  23.         <!-- Hibernate生成的SQL是否输出到控制台 -->
  24.         <property name="show_sql">true</property>
  25.         <!-- 将SQL输出时是否格式化。为了方便截图,我将其设置为false -->
  26.         <property name="format_sql">false</property>
  27.         
  28.         <!-- 开启二级缓存 -->
  29.         <property name="hibernate.cache.use_second_level_cache">
  30.             true
  31.         </property>
  32.         <!-- 指定所采用的二级缓存驱动类 -->
  33.         <property name="hibernate.cache.provider_class">
  34.             org.hibernate.cache.EhCacheProvider
  35.         </property>        
  36.         
  37.         <!-- 声明映射关系文件 -->
  38.         <mapping resource="com/tarena/entity/Emp.hbm.xml" />
  39.         <mapping resource="com/tarena/entity/Account.hbm.xml" />
  40.         <mapping resource="com/tarena/entity/Service.hbm.xml" />        
  41.     </session-factory>
  42. </hibernate-configuration>

步骤四：设置缓存策略

在Emp.hbm.xml中，指定二级缓存策略为只读的，代码如下：

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC
  3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  4.     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
  5. <hibernate-mapping>
  6.     <!-- 配置实体类和表的关系 -->
  7.     <class name="com.tarena.entity.Emp" table="emp">
  8.         <!-- 
  9.             开启二级缓存，指定二级缓存策略。
  10.             可以用region属性指定自定义的缓存设置。
  11.         -->
  12.         <cache usage="read-only" />
  13.         
  14.         <!-- 配置主键属性和字段的关系 -->
  15.         <id name="id" type="integer" column="id">
  16.             <!-- 用来指明主键的生成方式 -->
  17.             <generator class="sequence">
  18.                 <!-- 指定用于生成主键的sequence -->
  19.                 <param name="sequence">emp_seq</param>
  20.             </generator>
  21.         </id>
  22.         
  23.         <!-- 配置实体类中属性与表中字段的关系 -->
  24.         <property name="name" 
  25.             type="string" column="name"/>
  26.         <property name="age" 
  27.             type="integer" column="age"/>
  28.         <property name="salary" 
  29.             type="double" column="salary"/>
  30.         <property name="birthday" 
  31.             type="date" column="birthday"/>
  32.         <property name="lastLoginTime" 
  33.             type="timestamp" column="last_login_time"/>
  34.         <property name="marry"
  35.             type="yes_no" column="marry"/>
  36.     </class>
  37. </hibernate-mapping>

步骤五：编写查询方法，测试二级缓存

在com.tarena.test包下，创建一个测试类TestSecondCache，增加一个测试二级缓存的方法，代码如下：

  1. package com.tarena.test;
  3. import java.util.List;
  4. import org.hibernate.Query;
  5. import org.hibernate.Session;
  6. import org.junit.Test;
  7. import com.tarena.entity.Emp;
  8. import com.tarena.util.HibernateUtil;
  10. public class TestSecondCache {
  12.     /**
  13.      * 二级缓存
  14.      */
  15.     @Test
  16.     public void test1() {
  17.         Session session1 = HibernateUtil.getSession();
  18.         Emp e1 = (Emp) session1.get(Emp.class, 321);
  19.         System.out.println(e1.getName());
  20.         
  21.         System.out.println("-----------------");
  22.         
  23.         Session session2 = HibernateUtil.getSession();
  24.         Emp e2 = (Emp) session2.get(Emp.class, 321);
  25.         System.out.println(e2.getName());
  26.         
  27.         session1.close();
  28.         session2.close();
  29.     }
  30.     
  31. }

步骤六：测试

执行test1()，控制台输出结果如下图，可见第二次查询没有访问数据库，是二级缓存存在的缘故：

图-23

步骤七：管理二级缓存

二级缓存是SessionFactory级缓存，由它负责管理，因此需要获取到SessionFactory才能管理二级缓存，我们先在HibernateUtil中增加获取SessionFactory的方法，代码如下：

  1. package com.tarena.util;
  3. import org.hibernate.Session;
  4. import org.hibernate.SessionFactory;
  5. import org.hibernate.cfg.Configuration;
  7. public class HibernateUtil {
  9.     private static SessionFactory sessionFactory;
  10.     
  11.     static {
  12.         // 加载Hibernate主配置文件
  13.         Configuration conf = new Configuration();
  14.         conf.configure("/hibernate.cfg.xml");
  15.         sessionFactory = conf.buildSessionFactory();
  16.     }
  18.     /**
  19.      * 创建session
  20.      */
  21.     public static Session getSession() {
  22.         return sessionFactory.openSession();
  23.     }
  24.     
  25.     /**
  26.      * 返回SessionFactory
  27.      */
  28.     public static SessionFactory getSessionFactory() {
  29.         return sessionFactory;
  30.     }
  31.     
  32.     public static void main(String[] args) {
  33.         System.out.println(getSession());
  34.     }
  36. }

修改test1()方法，在第二次查询前清理二级缓存，代码如下：

  1. package com.tarena.test;
  3. import java.util.List;
  4. import org.hibernate.Query;
  5. import org.hibernate.Session;
  6. import org.junit.Test;
  7. import com.tarena.entity.Emp;
  8. import com.tarena.util.HibernateUtil;
  10. public class TestSecondCache {
  12.     /**
  13.      * 二级缓存
  14.      */
  15.     @Test
  16.     public void test1() {
  17.         Session session1 = HibernateUtil.getSession();
  18.         Emp e1 = (Emp) session1.get(Emp.class, 321);
  19.         System.out.println(e1.getName());
  20.         
  21.         System.out.println("-----------------");
  22.         HibernateUtil.getSessionFactory().evict(Emp.class);
  23.         
  24.         Session session2 = HibernateUtil.getSession();
  25.         Emp e2 = (Emp) session2.get(Emp.class, 321);
  26.         System.out.println(e2.getName());
  27.         
  28.         session1.close();
  29.         session2.close();
  30.     }
  31.     
  32. }

再次执行test1()，控制台输出结果如下图，由于清理了二级缓存，因此第二次查询时访问了数据库。

图-24

10.4 完整代码

以下是本案例的完整代码。

其中缓存配置文件ehcache.xml完整代码如下：

代码

hibernate.cfg.xml完整代码如下：

代码

emp.hbm.xml完整代码如下：

代码

TestSecondCache完整代码如下：

代码

11 使用查询缓存

11.1 问题

在查询多条员工数据时，使用查询缓存，缓存查询的HQL，使得再次使用同样HQL查询时不必重新访问数据库。

11.2 方案

查询缓存的使用步骤是

  1. 开启二级缓存
  2. 在hibernate.cfg.xml中开启查询缓存
  3. 在查询之前，开启查询缓存

11.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：开启二级缓存

开启二级缓存，由于上个案例已经完成，这一步就可以省略。但是要注意，查询缓存是基于二级缓存的，使用查询缓存的前提是开启二级缓存。

步骤二：开启查询缓存

在hibernate.cfg.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.         <!-- 数据库连接信息，根据自己的数据库进行配置 -->
  8.         <property name="connection.url">
  9.             jdbc:oracle:thin:@localhost:1521:xe
  10.         </property>
  11.         <property name="connection.username">lhh</property>
  12.         <property name="connection.password">123456</property>
  13.         <property name="connection.driver_class">
  14.             oracle.jdbc.OracleDriver
  15.         </property>
  16.         
  17.         <!-- Hibernate配置信息 -->
  18.         <!-- dialect方言，用于配置生成针对哪个数据库的SQL语句 -->
  19.         <property name="dialect">
  20.             <!-- 方言类，Hibernate提供的，用于封装某种特定数据库的方言 -->
  21.             org.hibernate.dialect.OracleDialect
  22.         </property>
  23.         <!-- Hibernate生成的SQL是否输出到控制台 -->
  24.         <property name="show_sql">true</property>
  25.         <!-- 将SQL输出时是否格式化。为了方便截图,我将其设置为false -->
  26.         <property name="format_sql">false</property>
  27.         
  28.         <!-- 开启二级缓存 -->
  29.         <property name="hibernate.cache.use_second_level_cache">
  30.             true
  31.         </property>
  32.         <!-- 指定所采用的二级缓存驱动 -->
  33.         <property name="hibernate.cache.provider_class">
  34.             org.hibernate.cache.EhCacheProvider
  35.         </property>        
  36.         <!-- 开启查询缓存 -->
  37.         <property name="hibernate.cache.use_query_cache">
  38.             true
  39.         </property>
  40.                 
  41.         <!-- 声明映射关系文件 -->
  42.         <mapping resource="com/tarena/entity/Emp.hbm.xml" />
  43.         <mapping resource="com/tarena/entity/Account.hbm.xml" />
  44.         <mapping resource="com/tarena/entity/Service.hbm.xml" />        
  45.     </session-factory>
  46. </hibernate-configuration>

步骤三：查询前开启查询缓存

在TestSecondCache中，增加测试查询缓存的方法，使用相同的HQL执行2次查询，每次查询前都设置开启查询缓存，代码如下：

  1. package com.tarena.test;
  3. import java.util.List;
  4. import org.hibernate.Query;
  5. import org.hibernate.Session;
  6. import org.junit.Test;
  7. import com.tarena.entity.Emp;
  8. import com.tarena.util.HibernateUtil;
  10. public class TestSecondCache {
  12.     /**
  13.      * 二级缓存
  14.      */
  15.     @Test
  16.     public void test1() {
  17.         Session session1 = HibernateUtil.getSession();
  18.         Emp e1 = (Emp) session1.get(Emp.class, 321);
  19.         System.out.println(e1.getName());
  20.         
  21.         System.out.println("-----------------");
  22.         HibernateUtil.getSessionFactory().evict(Emp.class);
  23.         
  24.         Session session2 = HibernateUtil.getSession();
  25.         Emp e2 = (Emp) session2.get(Emp.class, 321);
  26.         System.out.println(e2.getName());
  27.         
  28.         session1.close();
  29.         session2.close();
  30.     }
  31.     
  32.     /**
  33.      * 查询缓存
  34.      */
  35.     @Test
  36.     public void test2() {
  37.         Session session = HibernateUtil.getSession();
  38.         
  39.         String hql = "from Emp";
  40.         Query query = session.createQuery(hql);
  41.         // 开启查询缓存
  42.         query.setCacheable(true);
  43.         List<Emp> emps = query.list();
  44.         for(Emp e : emps) {
  45.             System.out.println(e.getId() + " " + e.getName());
  46.         }
  47.         
  48.         System.out.println("---------------");
  49.         
  50.         hql = "from Emp";
  51.         query = session.createQuery(hql);
  52.         // 开启查询缓存
  53.         query.setCacheable(true);
  54.         emps = query.list();
  55.         for(Emp e : emps) {
  56.             System.out.println(e.getId() + " " + e.getName());
  57.         }
  58.         
  59.         session.close();
  60.     }
  61.     
  62. }

步骤四：测试

执行test2()，控制台输出结果如下图，可见在使用相同HQL查询时，第二次查询不必再次访问数据库。

图-25

步骤五：管理查询缓存

修改test2()，在第二次查询之前清理查询缓存，代码如下：

  1. package com.tarena.test;
  3. import java.util.List;
  4. import org.hibernate.Query;
  5. import org.hibernate.Session;
  6. import org.junit.Test;
  7. import com.tarena.entity.Emp;
  8. import com.tarena.util.HibernateUtil;
  10. public class TestSecondCache {
  12.     /**
  13.      * 二级缓存
  14.      */
  15.     @Test
  16.     public void test1() {
  17.         Session session1 = HibernateUtil.getSession();
  18.         Emp e1 = (Emp) session1.get(Emp.class, 321);
  19.         System.out.println(e1.getName());
  20.         
  21.         System.out.println("-----------------");
  22.         HibernateUtil.getSessionFactory().evict(Emp.class);
  23.         
  24.         Session session2 = HibernateUtil.getSession();
  25.         Emp e2 = (Emp) session2.get(Emp.class, 321);
  26.         System.out.println(e2.getName());
  27.         
  28.         session1.close();
  29.         session2.close();
  30.     }
  31.     
  32.     /**
  33.      * 查询缓存
  34.      */
  35.     @Test
  36.     public void test2() {
  37.         Session session = HibernateUtil.getSession();
  38.         
  39.         String hql = "from Emp";
  40.         Query query = session.createQuery(hql);
  41.         // 开启查询缓存
  42.         query.setCacheable(true);
  43.         List<Emp> emps = query.list();
  44.         for(Emp e : emps) {
  45.             System.out.println(e.getId() + " " + e.getName());
  46.         }
  47.         
  48.         System.out.println("---------------");
  49.         HibernateUtil.getSessionFactory().evictQueries();
  50.         
  51.         hql = "from Emp";
  52.         query = session.createQuery(hql);
  53.         // 开启查询缓存
  54.         query.setCacheable(true);
  55.         emps = query.list();
  56.         for(Emp e : emps) {
  57.             System.out.println(e.getId() + " " + e.getName());
  58.         }
  59.         
  60.         session.close();
  61.     }
  62.     
  63. }

再次执行test2()，控制台输出结果如下图，可见第二次查询也访问了数据库，主要是清理了查询缓存中数据的缘故。

图-26

11.4 完整代码

以下为本案例的完整代码。

其中Hibernate.cfg.xml完整代码如下：

代码

TestSecondCache完整代码如下：

代码
Top

JAVA Hibernate DAY03

  1. 使用多对一关联映射
  2. 关联查询的一些特性
  3. 级联添加/修改
  4. 级联删除
  5. HQL查询，按条件查询
  6. HQL查询，查询一部分字段
  7. HQL查询，分页查询
  8. HQL查询，多表联合查询
  9. Hibernate中的SQL查询
  10. 使用二级缓存
  11. 使用查询缓存

1 使用多对一关联映射

1.1 问题

使用多对一关联映射，在查询业务账号时，自动查询出它对应的账务账号。

1.2 方案

多对一关联映射开发步骤：

  1. 业务账号与账务账号具有多对一关系，他们的关系字段是service.account_id。
  2. 在业务账号中追加Account类型的属性，用于封装它对应的唯一账务账号。
  3. 在业务账号映射关系文件中配置此属性。

1.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：在业务账号实体类中追加属性

在业务账号实体类Service中，追加Account类型的属性，用于封装它对应的唯一账务账号。由于这个属性包含了账务账号的ID，因此accountId属性可以去掉了，实际上这个属性必须去掉，否则会报错。代码如下：

  1. package com.tarena.entity;
  3. import java.sql.Date;
  5. public class Service {
  7.     private Integer id;
  8. //    private Integer accountId;
  9.     private String unixHost;
  10.     private String osUserName;
  11.     private String loginPassword;
  12.     private String status;
  13.     private Date createDate;
  14.     private Date pauseDate;
  15.     private Date closeDate;
  16.     private Integer costId;
  17.     // 追加属性，用于封装对应的Account记录
  18.     private Account account;
  20.     public Integer getId() {
  21.         return id;
  22.     }
  24.     public void setId(Integer id) {
  25.         this.id = id;
  26.     }
  28. //    public Integer getAccountId() {
  29. //        return accountId;
  30. //    }
  31. //
  32. //    public void setAccountId(Integer accountId) {
  33. //        this.accountId = accountId;
  34. //    }
  36.     public Account getAccount() {
  37.         return account;
  38.     }
  40.     public void setAccount(Account account) {
  41.         this.account = account;
  42.     }
  44.     public String getUnixHost() {
  45.         return unixHost;
  46.     }
  48.     public void setUnixHost(String unixHost) {
  49.         this.unixHost = unixHost;
  50.     }
  52.     public String getOsUserName() {
  53.         return osUserName;
  54.     }
  56.     public void setOsUserName(String osUserName) {
  57.         this.osUserName = osUserName;
  58.     }
  60.     public String getLoginPassword() {
  61.         return loginPassword;
  62.     }
  64.     public void setLoginPassword(String loginPassword) {
  65.         this.loginPassword = loginPassword;
  66.     }
  68.     public String getStatus() {
  69.         return status;
  70.     }
  72.     public void setStatus(String status) {
  73.         this.status = status;
  74.     }
  76.     public Date getCreateDate() {
  77.         return createDate;
  78.     }
  80.     public void setCreateDate(Date createDate) {
  81.         this.createDate = createDate;
  82.     }
  84.     public Date getPauseDate() {
  85.         return pauseDate;
  86.     }
  88.     public void setPauseDate(Date pauseDate) {
  89.         this.pauseDate = pauseDate;
  90.     }
  92.     public Date getCloseDate() {
  93.         return closeDate;
  94.     }
  96.     public void setCloseDate(Date closeDate) {
  97.         this.closeDate = closeDate;
  98.     }
  100.     public Integer getCostId() {
  101.         return costId;
  102.     }
  104.     public void setCostId(Integer costId) {
  105.         this.costId = costId;
  106.     }
  108. }

步骤二：在业务账号映射关系文件中配置这个属性

在业务账号映射关系文件service.hbm.xml中，配置这个关联属性，代码如下：

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
  4. <hibernate-mapping>
  5.     <class name="com.tarena.entity.Service" table="SERVICE">
  6.         <id name="id" type="integer" column="id">
  7.             <generator class="sequence">
  8.                 <param name="sequence">SERVICE_SEQ</param>
  9.             </generator>
  10.         </id>
  11.         <!-- 
  12.             由于account属性已经体现了业务账号与账务账号的关系，
  13.             并且account属性可以包含账务账号ID，因此accountId可以去掉，
  14.             实际上这里必须去掉这个属性的配置，否则会报错。
  15.         -->
  16.         <!-- <property name="accountId" 
  17.             type="integer" column="ACCOUNT_ID"/> -->
  18.         <property name="unixHost" 
  19.             type="string" column="UNIX_HOST"/>
  20.         <property name="osUserName" 
  21.             type="string" column="OS_USERNAME"/>
  22.         <property name="loginPassword" 
  23.             type="string" column="LOGIN_PASSWD"/>
  24.         <property name="status" 
  25.             type="string" column="STATUS"/>
  26.         <property name="createDate" 
  27.             type="date" column="CREATE_DATE"/>
  28.         <property name="pauseDate" 
  29.             type="date" column="PAUSE_DATE"/>
  30.         <property name="closeDate" 
  31.             type="date" column="CLOSE_DATE"/>
  32.         <property name="costId" 
  33.             type="integer" column="COST_ID"/>
  34.             
  35.         <!-- 配置account属性，采用多对一关系加载相关的account内容 -->
  36.         <many-to-one name="account" column="ACCOUNT_ID"
  37.             class="com.tarena.entity.Account"/>            
  38.     </class>
  39. </hibernate-mapping>

步骤三：创建测试类

在com.tarena.test包下，创建一个测试类TestManyToOne，并且增加一个测试方法。在方法中查询出一条业务账号数据，然后输出这个业务账号的一些属性，同时输出account属性的值。代码如下：

  1. package com.tarena.test;
  3. import org.hibernate.Session;
  4. import org.junit.Test;
  5. import com.tarena.entity.Service;
  6. import com.tarena.util.HibernateUtil;
  8. public class TestManyToOne {
  9.     
  10.     @Test
  11.     public void test1() {
  12.         Session session = HibernateUtil.getSession();
  13.         Service service = 
  14.             (Service) session.get(Service.class, 2001);
  15.         System.out.println(service.getOsUserName());
  16.         System.out.println("------------------");
  17.         System.out.println(
  18.                 service.getAccount().getId() + " " +
  19.                 service.getAccount().getIdcardNo());
  20.     }
  21.     
  22. }

步骤四：测试

执行这个测试方法，控制台输出结果如下图，可以看出在查询SERVICE的同时，Hibernate自动查询出了它对应的ACCOUNT数据，并且这个关联查询是采用延迟加载机制实现的。

图-1

1.4 完整代码

以下为本案例的完整代码。

其中业务账号实体类完整代码如下：

代码

业务账号映射关系文件代码如下：

代码

测试类代码如下：

代码

2 关联查询的一些特性

2.1 问题

请按照如下的方式使用关联映射：

  1. 不采用延迟加载的方式查询关联属性。
  2. 采用关联查询一次性查出2张表的数据。

2.2 方案

可以按照如下的方式实现上述问题的要求：

  1. 通过lazy=”false”取消延迟加载。
  2. 通过fetch=”join”设置关联查询。

2.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：创建项目

复制项目HibernateDay02，粘贴并修改项目名为HibernateDay03。

步骤二：将一对多关联映射取消延迟加载

修改HibernateDay03项目中的Account.hbm.xml文件，将services属性的配置追加lazy=”false”，代码如下：

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
  4. <hibernate-mapping>
  5.     <class name="com.tarena.entity.Account" table="ACCOUNT">
  6.         <id name="id" type="integer" column="id">
  7.             <generator class="sequence">
  8.                 <param name="sequence">ACCOUNT_SEQ</param>
  9.             </generator>
  10.         </id>
  11.         <property name="recommenderId" 
  12.             type="integer" column="RECOMMENDER_ID"/>
  13.         <property name="loginName" 
  14.             type="string" column="LOGIN_NAME"/>
  15.         <property name="loginPassword" 
  16.             type="string" column="LOGIN_PASSWD"/>
  17.         <property name="status" 
  18.             type="string" column="STATUS"/>
  19.         <property name="createDate" 
  20.             type="date" column="CREATE_DATE"/>
  21.         <property name="pauseDate" 
  22.             type="date" column="PAUSE_DATE"/>
  23.         <property name="closeDate" 
  24.             type="date" column="CLOSE_DATE"/>
  25.         <property name="realName" 
  26.             type="string" column="REAL_NAME"/>
  27.         <property name="idcardNo" 
  28.             type="string" column="IDCARD_NO"/>
  29.         <property name="birthdate" 
  30.             type="date" column="BIRTHDATE"/>
  31.         <property name="gender" 
  32.             type="string" column="GENDER"/>
  33.         <property name="occupation" 
  34.             type="string" column="OCCUPATION"/>
  35.         <property name="telephone" 
  36.             type="string" column="TELEPHONE"/>
  37.         <property name="email" 
  38.             type="string" column="EMAIL"/>
  39.         <property name="mailaddress" 
  40.             type="string" column="MAILADDRESS"/>
  41.         <property name="zipcode" 
  42.             type="string" column="ZIPCODE"/>
  43.         <property name="qq" 
  44.             type="string" column="QQ"/>
  45.         <property name="lastLoginTime" 
  46.             type="date" column="LAST_LOGIN_TIME"/>
  47.         <property name="lastLoginIp" 
  48.             type="string" column="LAST_LOGIN_IP"/>
  49.             
  50.         <!-- 配置services属性，采用一对多的关系 -->
  51.         <set name="services" lazy="false">
  52.             <!-- 用于指定关联条件，写关联条件的外键字段 -->
  53.             <key column="ACCOUNT_ID"/>
  54.             <!-- 用于指定采用哪种关系，加载哪方数据 -->
  55.             <one-to-many class="com.tarena.entity.Service"/>
  56.         </set>
  57.     </class>
  58. </hibernate-mapping>

执行TestOneToMany中的测试方法，控制台输出结果如下图，可以看出在查询账务账号之后Hibernate立刻查询了它对应的业务账号，已经取消了延迟加载。

图-2

步骤三：将多对一关联映射取消延迟加载

修改Service.hbm.xml，将account属性的配置追加lazy=”false”，代码如下：

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
  4. <hibernate-mapping>
  5.     <class name="com.tarena.entity.Service" table="SERVICE">
  6.         <id name="id" type="integer" column="id">
  7.             <generator class="sequence">
  8.                 <param name="sequence">SERVICE_SEQ</param>
  9.             </generator>
  10.         </id>
  11.         <!-- 
  12.             由于account属性已经体现了业务账号与账务账号的关系，
  13.             并且account属性可以包含账务账号ID，因此accountId可以去掉，
  14.             实际上这里必须去掉这个属性的配置，否则会报错。
  15.         -->
  16.         <!-- <property name="accountId" 
  17.             type="integer" column="ACCOUNT_ID"/> -->
  18.         <property name="unixHost" 
  19.             type="string" column="UNIX_HOST"/>
  20.         <property name="osUserName" 
  21.             type="string" column="OS_USERNAME"/>
  22.         <property name="loginPassword" 
  23.             type="string" column="LOGIN_PASSWD"/>
  24.         <property name="status" 
  25.             type="string" column="STATUS"/>
  26.         <property name="createDate" 
  27.             type="date" column="CREATE_DATE"/>
  28.         <property name="pauseDate" 
  29.             type="date" column="PAUSE_DATE"/>
  30.         <property name="closeDate" 
  31.             type="date" column="CLOSE_DATE"/>
  32.         <property name="costId" 
  33.             type="integer" column="COST_ID"/>
  34.             
  35.         <!-- 配置account属性，采用多对一关系加载相关的account内容 -->
  36.         <many-to-one name="account" column="ACCOUNT_ID"
  37.             class="com.tarena.entity.Account"
  38.             lazy="false"/>            
  39.     </class>
  40. </hibernate-mapping>

执行TestManyToOne中的测试方法，控制台输出效果如下图，可以看出在查询业务账号之后Hibernate立刻查询了对应的账务账号，取消了延迟加载。

图-3

步骤四：将一对多关联映射设置为join方式抓取数据

修改Account.hbm.xml，将services属性的配置追加fetch=“join”，代码如下：

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
  4. <hibernate-mapping>
  5.     <class name="com.tarena.entity.Account" table="ACCOUNT">
  6.         <id name="id" type="integer" column="id">
  7.             <generator class="sequence">
  8.                 <param name="sequence">ACCOUNT_SEQ</param>
  9.             </generator>
  10.         </id>
  11.         <property name="recommenderId" 
  12.             type="integer" column="RECOMMENDER_ID"/>
  13.         <property name="loginName" 
  14.             type="string" column="LOGIN_NAME"/>
  15.         <property name="loginPassword" 
  16.             type="string" column="LOGIN_PASSWD"/>
  17.         <property name="status" 
  18.             type="string" column="STATUS"/>
  19.         <property name="createDate" 
  20.             type="date" column="CREATE_DATE"/>
  21.         <property name="pauseDate" 
  22.             type="date" column="PAUSE_DATE"/>
  23.         <property name="closeDate" 
  24.             type="date" column="CLOSE_DATE"/>
  25.         <property name="realName" 
  26.             type="string" column="REAL_NAME"/>
  27.         <property name="idcardNo" 
  28.             type="string" column="IDCARD_NO"/>
  29.         <property name="birthdate" 
  30.             type="date" column="BIRTHDATE"/>
  31.         <property name="gender" 
  32.             type="string" column="GENDER"/>
  33.         <property name="occupation" 
  34.             type="string" column="OCCUPATION"/>
  35.         <property name="telephone" 
  36.             type="string" column="TELEPHONE"/>
  37.         <property name="email" 
  38.             type="string" column="EMAIL"/>
  39.         <property name="mailaddress" 
  40.             type="string" column="MAILADDRESS"/>
  41.         <property name="zipcode" 
  42.             type="string" column="ZIPCODE"/>
  43.         <property name="qq" 
  44.             type="string" column="QQ"/>
  45.         <property name="lastLoginTime" 
  46.             type="date" column="LAST_LOGIN_TIME"/>
  47.         <property name="lastLoginIp" 
  48.             type="string" column="LAST_LOGIN_IP"/>
  49.             
  50.         <!-- 配置services属性，采用一对多的关系 -->
  51.         <set name="services" lazy="false" fetch="join">
  52.             <!-- 用于指定关联条件，写关联条件的外键字段 -->
  53.             <key column="ACCOUNT_ID"/>
  54.             <!-- 用于指定采用哪种关系，加载哪方数据 -->
  55.             <one-to-many class="com.tarena.entity.Service"/>
  56.         </set>
  57.     </class>
  58. </hibernate-mapping>

执行TestOneToMany中的测试方法，控制台输出结果如下图，可以看出查询时采用了join方式查询。

图-4

步骤五：将多对一关联映射设置为join方式抓取数据

修改Service.hbm.xml，将account属性追加fetch=“join”，代码如下：

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
  4. <hibernate-mapping>
  5.     <class name="com.tarena.entity.Service" table="SERVICE">
  6.         <id name="id" type="integer" column="id">
  7.             <generator class="sequence">
  8.                 <param name="sequence">SERVICE_SEQ</param>
  9.             </generator>
  10.         </id>
  11.         <!-- 
  12.             由于account属性已经体现了业务账号与账务账号的关系，
  13.             并且account属性可以包含账务账号ID，因此accountId可以去掉，
  14.             实际上这里必须去掉这个属性的配置，否则会报错。
  15.         -->
  16.         <!-- <property name="accountId" 
  17.             type="integer" column="ACCOUNT_ID"/> -->
  18.         <property name="unixHost" 
  19.             type="string" column="UNIX_HOST"/>
  20.         <property name="osUserName" 
  21.             type="string" column="OS_USERNAME"/>
  22.         <property name="loginPassword" 
  23.             type="string" column="LOGIN_PASSWD"/>
  24.         <property name="status" 
  25.             type="string" column="STATUS"/>
  26.         <property name="createDate" 
  27.             type="date" column="CREATE_DATE"/>
  28.         <property name="pauseDate" 
  29.             type="date" column="PAUSE_DATE"/>
  30.         <property name="closeDate" 
  31.             type="date" column="CLOSE_DATE"/>
  32.         <property name="costId" 
  33.             type="integer" column="COST_ID"/>
  34.             
  35.         <!-- 配置account属性，采用多对一关系加载相关的account内容 -->
  36.         <many-to-one name="account" column="ACCOUNT_ID"
  37.             class="com.tarena.entity.Account"
  38.             lazy="false" fetch="join"/>            
  39.     </class>
  40. </hibernate-mapping>

执行TestManyToOne中的测试方法，控制台输出结果如下图，可以看出查询时采用了join方式查询。

图-5

2.4 完整代码

以下为本案例的完整代码。

其中账务账号映射关系文件完整代码如下：

代码

业务账号映射关系文件完整代码如下：

代码

3 级联添加/修改

3.1 问题

使用级联添加/修改，在添加/修改账务账号时，自动添加/修改其对应的业务账号。

3.2 方案

通过在映射关系文件中设置cascade=”save-update”，可以支持级联添加/修改。

3.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：在账务账号映射关系文件中设置级联添加/修改

在账务账号映射关系文件Account.hbm.xml中，通过cascade=“save-update”设置支持级联添加/修改，代码如下：

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
  4. <hibernate-mapping>
  5.     <class name="com.tarena.entity.Account" table="ACCOUNT">
  6.         <id name="id" type="integer" column="id">
  7.             <generator class="sequence">
  8.                 <param name="sequence">ACCOUNT_SEQ</param>
  9.             </generator>
  10.         </id>
  11.         <property name="recommenderId" 
  12.             type="integer" column="RECOMMENDER_ID"/>
  13.         <property name="loginName" 
  14.             type="string" column="LOGIN_NAME"/>
  15.         <property name="loginPassword" 
  16.             type="string" column="LOGIN_PASSWD"/>
  17.         <property name="status" 
  18.             type="string" column="STATUS"/>
  19.         <property name="createDate" 
  20.             type="date" column="CREATE_DATE"/>
  21.         <property name="pauseDate" 
  22.             type="date" column="PAUSE_DATE"/>
  23.         <property name="closeDate" 
  24.             type="date" column="CLOSE_DATE"/>
  25.         <property name="realName" 
  26.             type="string" column="REAL_NAME"/>
  27.         <property name="idcardNo" 
  28.             type="string" column="IDCARD_NO"/>
  29.         <property name="birthdate" 
  30.             type="date" column="BIRTHDATE"/>
  31.         <property name="gender" 
  32.             type="string" column="GENDER"/>
  33.         <property name="occupation" 
  34.             type="string" column="OCCUPATION"/>
  35.         <property name="telephone" 
  36.             type="string" column="TELEPHONE"/>
  37.         <property name="email" 
  38.             type="string" column="EMAIL"/>
  39.         <property name="mailaddress" 
  40.             type="string" column="MAILADDRESS"/>
  41.         <property name="zipcode" 
  42.             type="string" column="ZIPCODE"/>
  43.         <property name="qq" 
  44.             type="string" column="QQ"/>
  45.         <property name="lastLoginTime" 
  46.             type="date" column="LAST_LOGIN_TIME"/>
  47.         <property name="lastLoginIp" 
  48.             type="string" column="LAST_LOGIN_IP"/>
  49.             
  50.         <!-- 配置services属性，采用一对多的关系 -->
  51.         <set name="services" 
  52.             lazy="false" fetch="join" 
  53.             cascade="save-update">
  54.             <!-- 用于指定关联条件，写关联条件的外键字段 -->
  55.             <key column="ACCOUNT_ID"/>
  56.             <!-- 用于指定采用哪种关系，加载哪方数据 -->
  57.             <one-to-many 
  58.                 class="com.tarena.entity.Service"/>
  59.         </set>
  60.     </class>
  61. </hibernate-mapping>

步骤二：测试级联添加

在com.tarena.test包下，创建测试类TestCascade，并在类中增加测试级联添加的方法，代码如下：

  1. package com.tarena.test;
  3. import java.util.HashSet;
  4. import java.util.Set;
  6. import org.hibernate.HibernateException;
  7. import org.hibernate.Session;
  8. import org.hibernate.Transaction;
  9. import org.junit.Test;
  10. import com.tarena.entity.Account;
  11. import com.tarena.entity.Service;
  12. import com.tarena.util.HibernateUtil;
  14. public class TestCascade {
  16.     /**
  17.      * 级联添加
  18.      */
  19.     @Test
  20.     public void test1() {
  21.         // 模拟要添加的账务账号
  22.         Account a = new Account();
  23.         a.setLoginName("gg");
  24.         a.setLoginPassword("123");
  25.         a.setRealName("gg");
  26.         a.setIdcardNo("120392198410282549");
  27.         a.setStatus("0");
  28.         a.setTelephone("110");
  30.         // 模拟要添加的业务账号
  31.         Service s1 = new Service();
  32.         s1.setAccount(a);
  33.         s1.setOsUserName("gg1");
  34.         s1.setLoginPassword("123");
  35.         s1.setUnixHost("192.168.1.1");
  36.         s1.setCostId(5);
  37.         s1.setStatus("0");
  39.         Service s2 = new Service();
  40.         s2.setAccount(a);
  41.         s2.setOsUserName("gg2");
  42.         s2.setLoginPassword("123");
  43.         s2.setUnixHost("192.168.1.2");
  44.         s2.setCostId(5);
  45.         s2.setStatus("0");
  47.         // 将业务账号与账务账号关联
  48.         a.setServices(new HashSet<Service>());
  49.         a.getServices().add(s1);
  50.         a.getServices().add(s2);
  52.         Session session = HibernateUtil.getSession();
  53.         Transaction ts = session.beginTransaction();
  54.         try {
  55.             session.save(a);
  56.             ts.commit();
  57.         } catch (HibernateException e) {
  58.             e.printStackTrace();
  59.             ts.rollback();
  60.         } finally {
  61.             session.close();
  62.         }
  64.     }
  65.     
  66. }

执行test1()方法，控制台输出结果如下图，可以看出在新增账务账号之后，Hibernate自动新增了账务账号对应的业务账号数据，这就是级联添加所起到的作用。

图-6

此时，查询账务账号表，数据如下图，其中id=380的行就是刚刚添加的行。

图-7

再查询业务账号表，数据如下图，其中account_id=380的行就是级联添加的行。

图-8

步骤三：测试级联修改

在TestCascade测试类中，增加测试级联修改的方法，代码如下：

  1. package com.tarena.test;
  3. import java.util.HashSet;
  4. import java.util.Set;
  6. import org.hibernate.HibernateException;
  7. import org.hibernate.Session;
  8. import org.hibernate.Transaction;
  9. import org.junit.Test;
  10. import com.tarena.entity.Account;
  11. import com.tarena.entity.Service;
  12. import com.tarena.util.HibernateUtil;
  14. public class TestCascade {
  16.     /**
  17.      * 级联添加
  18.      */
  19.     @Test
  20.     public void test1() {
  21.         // 模拟要添加的账务账号
  22.         Account a = new Account();
  23.         a.setLoginName("gg");
  24.         a.setLoginPassword("123");
  25.         a.setRealName("gg");
  26.         a.setIdcardNo("120392198410282549");
  27.         a.setStatus("0");
  28.         a.setTelephone("110");
  30.         // 模拟要添加的业务账号
  31.         Service s1 = new Service();
  32.         s1.setAccount(a);
  33.         s1.setOsUserName("gg1");
  34.         s1.setLoginPassword("123");
  35.         s1.setUnixHost("192.168.1.1");
  36.         s1.setCostId(5);
  37.         s1.setStatus("0");
  39.         Service s2 = new Service();
  40.         s2.setAccount(a);
  41.         s2.setOsUserName("gg2");
  42.         s2.setLoginPassword("123");
  43.         s2.setUnixHost("192.168.1.2");
  44.         s2.setCostId(5);
  45.         s2.setStatus("0");
  47.         // 将业务账号与账务账号关联
  48.         a.setServices(new HashSet<Service>());
  49.         a.getServices().add(s1);
  50.         a.getServices().add(s2);
  52.         Session session = HibernateUtil.getSession();
  53.         Transaction ts = session.beginTransaction();
  54.         try {
  55.             session.save(a);
  56.             ts.commit();
  57.         } catch (HibernateException e) {
  58.             e.printStackTrace();
  59.             ts.rollback();
  60.         } finally {
  61.             session.close();
  62.         }
  64.     }
  66.     /**
  67.      * 级联修改
  68.      */
  69.     @Test
  70.     public void test2() {
  71.         Session session = HibernateUtil.getSession();
  72.         // 查询出要修改的账务账号
  73.         Account account = 
  74. #cold_bold            (Account) session.get(Account.class, 380);
  75.         // 模拟对账务账号的修改
  76.         account.setLoginName("pp");
  77.         Set<Service> services = account.getServices();
  78.         for (Service service : services) {
  79.             // 模拟对业务账号的修改
  80.             service.setLoginPassword("pp");
  81.         }
  82.         Transaction ts = session.beginTransaction();
  83.         try {
  84.             session.update(account);
  85.             ts.commit();
  86.         } catch (HibernateException e) {
  87.             e.printStackTrace();
  88.             ts.rollback();
  89.         } finally {
  90.             session.close();
  91.         }
  92.     }
  93.     
  94. }

执行test2()方法后，控制台输出的结果如下图，可以看出在修改完账务账号之后，Hibernate自动修改了它对应的业务账号数据。

图-9

此时，查询账务账号表，id=380的行已经发生了改变。

图-10

再查询业务账号表，account_id=380的行也发生了改变。

图-11

3.4 完整代码

以下为本案例的完整代码。

其中Account.hbm.xml完整代码如下：

代码

TestCascade完整代码如下：

代码

4 级联删除

4.1 问题

使用级联删除，在删除账务账号时，自动删除其对应的业务账号。

4.2 方案

通过在映射关系文件中设置cascade=“delete”，可以支持级联删除，如果想全面支持级联添加、修改和删除，可以设置cascade=“all”。

4.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：在账务账号映射关系文件中设置级联删除

在账务账号映射关系文件Account.hbm.xml中，通过cascade=“all”设置支持级联删除，代码如下：

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
  4. <hibernate-mapping>
  5.     <class name="com.tarena.entity.Account" table="ACCOUNT">
  6.         <id name="id" type="integer" column="id">
  7.             <generator class="sequence">
  8.                 <param name="sequence">ACCOUNT_SEQ</param>
  9.             </generator>
  10.         </id>
  11.         <property name="recommenderId" 
  12.             type="integer" column="RECOMMENDER_ID"/>
  13.         <property name="loginName" 
  14.             type="string" column="LOGIN_NAME"/>
  15.         <property name="loginPassword" 
  16.             type="string" column="LOGIN_PASSWD"/>
  17.         <property name="status" 
  18.             type="string" column="STATUS"/>
  19.         <property name="createDate" 
  20.             type="date" column="CREATE_DATE"/>
  21.         <property name="pauseDate" 
  22.             type="date" column="PAUSE_DATE"/>
  23.         <property name="closeDate" 
  24.             type="date" column="CLOSE_DATE"/>
  25.         <property name="realName" 
  26.             type="string" column="REAL_NAME"/>
  27.         <property name="idcardNo" 
  28.             type="string" column="IDCARD_NO"/>
  29.         <property name="birthdate" 
  30.             type="date" column="BIRTHDATE"/>
  31.         <property name="gender" 
  32.             type="string" column="GENDER"/>
  33.         <property name="occupation" 
  34.             type="string" column="OCCUPATION"/>
  35.         <property name="telephone" 
  36.             type="string" column="TELEPHONE"/>
  37.         <property name="email" 
  38.             type="string" column="EMAIL"/>
  39.         <property name="mailaddress" 
  40.             type="string" column="MAILADDRESS"/>
  41.         <property name="zipcode" 
  42.             type="string" column="ZIPCODE"/>
  43.         <property name="qq" 
  44.             type="string" column="QQ"/>
  45.         <property name="lastLoginTime" 
  46.             type="date" column="LAST_LOGIN_TIME"/>
  47.         <property name="lastLoginIp" 
  48.             type="string" column="LAST_LOGIN_IP"/>
  49.             
  50.         <!-- 配置services属性，采用一对多的关系 -->
  51.         <set name="services" 
  52.             lazy="false" fetch="join" 
  53.             cascade="all">
  54.             <!-- 用于指定关联条件，写关联条件的外键字段 -->
  55.             <key column="ACCOUNT_ID"/>
  56.             <!-- 用于指定采用哪种关系，加载哪方数据 -->
  57.             <one-to-many 
  58.                 class="com.tarena.entity.Service"/>
  59.         </set>
  60.     </class>
  61. </hibernate-mapping>

步骤二：测试级联删除

在TestCascade测试类中，增加测试级联删除的方法，代码如下：

  1. package com.tarena.test;
  3. import java.util.HashSet;
  4. import java.util.Set;
  6. import org.hibernate.HibernateException;
  7. import org.hibernate.Session;
  8. import org.hibernate.Transaction;
  9. import org.junit.Test;
  10. import com.tarena.entity.Account;
  11. import com.tarena.entity.Service;
  12. import com.tarena.util.HibernateUtil;
  14. public class TestCascade {
  16.     /**
  17.      * 级联添加
  18.      */
  19.     @Test
  20.     public void test1() {
  21.         // 模拟要添加的账务账号
  22.         Account a = new Account();
  23.         a.setLoginName("gg");
  24.         a.setLoginPassword("123");
  25.         a.setRealName("gg");
  26.         a.setIdcardNo("120392198410282549");
  27.         a.setStatus("0");
  28.         a.setTelephone("110");
  30.         // 模拟要添加的业务账号
  31.         Service s1 = new Service();
  32.         s1.setAccount(a);
  33.         s1.setOsUserName("gg1");
  34.         s1.setLoginPassword("123");
  35.         s1.setUnixHost("192.168.1.1");
  36.         s1.setCostId(5);
  37.         s1.setStatus("0");
  39.         Service s2 = new Service();
  40.         s2.setAccount(a);
  41.         s2.setOsUserName("gg2");
  42.         s2.setLoginPassword("123");
  43.         s2.setUnixHost("192.168.1.2");
  44.         s2.setCostId(5);
  45.         s2.setStatus("0");
  47.         // 将业务账号与账务账号关联
  48.         a.setServices(new HashSet<Service>());
  49.         a.getServices().add(s1);
  50.         a.getServices().add(s2);
  52.         Session session = HibernateUtil.getSession();
  53.         Transaction ts = session.beginTransaction();
  54.         try {
  55.             session.save(a);
  56.             ts.commit();
  57.         } catch (HibernateException e) {
  58.             e.printStackTrace();
  59.             ts.rollback();
  60.         } finally {
  61.             session.close();
  62.         }
  64.     }
  66.     /**
  67.      * 级联修改
  68.      */
  69.     @Test
  70.     public void test2() {
  71.         Session session = HibernateUtil.getSession();
  72.         // 查询出要修改的账务账号
  73.         Account account = 
  74.             (Account) session.get(Account.class, 380);
  75.         // 模拟对账务账号的修改
  76.         account.setLoginName("pp");
  77.         Set<Service> services = account.getServices();
  78.         for (Service service : services) {
  79.             // 模拟对业务账号的修改
  80.             service.setLoginPassword("pp");
  81.         }
  82.         Transaction ts = session.beginTransaction();
  83.         try {
  84.             session.update(account);
  85.             ts.commit();
  86.         } catch (HibernateException e) {
  87.             e.printStackTrace();
  88.             ts.rollback();
  89.         } finally {
  90.             session.close();
  91.         }
  92.     }
  94.     /**
  95.      * 级联删除
  96.      */
  97.     @Test
  98.     public void test3() {
  99.         Session session = HibernateUtil.getSession();
  100.         Account account = (Account) session.get(Account.class, 380);
  101.         Transaction ts = session.beginTransaction();
  102.         try {
  103.             session.delete(account);
  104.             ts.commit();
  105.         } catch (HibernateException e) {
  106.             e.printStackTrace();
  107.             ts.rollback();
  108.         } finally {
  109.             session.close();
  110.         }
  111.     }
  112.     
  113. }

步骤三：测试

执行test3()方法，控制台输出结果如下图，可以看出程序在运行时报错了：

图-12

步骤四：排错

上述错误是执行第二个SQL时产生的，这个SQL的目的是维护关系字段，将其置为null，而这个外键字段存在非空约束，因此报错。类似的事情在级联添加时也看到过，参考图-6，不同的是级联添加时要将关联字段设置为新生成的账务账号ID。然而，在级联新增或删除时业务账号时，业务账号本身已经维护好了关联字段，因此这个额外的操作是多余的，可以去掉，我们可以在关联属性上通过inverse=“true“去掉这个行为，代码如下：

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
  4. <hibernate-mapping>
  5.     <class name="com.tarena.entity.Account" table="ACCOUNT">
  6.         <id name="id" type="integer" column="id">
  7.             <generator class="sequence">
  8.                 <param name="sequence">ACCOUNT_SEQ</param>
  9.             </generator>
  10.         </id>
  11.         <property name="recommenderId" 
  12.             type="integer" column="RECOMMENDER_ID"/>
  13.         <property name="loginName" 
  14.             type="string" column="LOGIN_NAME"/>
  15.         <property name="loginPassword" 
  16.             type="string" column="LOGIN_PASSWD"/>
  17.         <property name="status" 
  18.             type="string" column="STATUS"/>
  19.         <property name="createDate" 
  20.             type="date" column="CREATE_DATE"/>
  21.         <property name="pauseDate" 
  22.             type="date" column="PAUSE_DATE"/>
  23.         <property name="closeDate" 
  24.             type="date" column="CLOSE_DATE"/>
  25.         <property name="realName" 
  26.             type="string" column="REAL_NAME"/>
  27.         <property name="idcardNo" 
  28.             type="string" column="IDCARD_NO"/>
  29.         <property name="birthdate" 
  30.             type="date" column="BIRTHDATE"/>
  31.         <property name="gender" 
  32.             type="string" column="GENDER"/>
  33.         <property name="occupation" 
  34.             type="string" column="OCCUPATION"/>
  35.         <property name="telephone" 
  36.             type="string" column="TELEPHONE"/>
  37.         <property name="email" 
  38.             type="string" column="EMAIL"/>
  39.         <property name="mailaddress" 
  40.             type="string" column="MAILADDRESS"/>
  41.         <property name="zipcode" 
  42.             type="string" column="ZIPCODE"/>
  43.         <property name="qq" 
  44.             type="string" column="QQ"/>
  45.         <property name="lastLoginTime" 
  46.             type="date" column="LAST_LOGIN_TIME"/>
  47.         <property name="lastLoginIp" 
  48.             type="string" column="LAST_LOGIN_IP"/>
  49.             
  50.         <!-- 配置services属性，采用一对多的关系 -->
  51.         <set name="services" 
  52.             lazy="false" fetch="join" 
  53.             cascade="all" inverse="true">
  54.             <!-- 用于指定关联条件，写关联条件的外键字段 -->
  55.             <key column="ACCOUNT_ID"/>
  56.             <!-- 用于指定采用哪种关系，加载哪方数据 -->
  57.             <one-to-many 
  58.                 class="com.tarena.entity.Service"/>
  59.         </set>
  60.     </class>
  61. </hibernate-mapping>

步骤五：测试

再次执行test3()方法，控制台输出结果如下图，可以看出本次删除成功了，不但删除了账务账号数据，在此之前还删除了它所对应的所有业务账号。

图-13

4.4 完整代码

以下为本案例的完整代码。

其中Account.hbm.xml完整代码如下：

代码

TestCascade完整代码如下：

代码

5 HQL查询，按条件查询

5.1 问题

使用带条件的HQL 查询业务账号数据。

5.2 方案

在HQL中拼入条件，如name=?，然后在查询之前使用query给参数赋值。

5.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：编写按条件查询方法

在com.tarena.test包下创建测试类TestHQL，并在类中增加按条件查询的测试方法，代码如下：

  1. package com.tarena.test;
  3. import java.util.List;
  4. import org.hibernate.Query;
  5. import org.hibernate.Session;
  6. import org.junit.Test;
  7. import com.tarena.entity.Service;
  8. import com.tarena.util.HibernateUtil;
  10. public class TestHQL {
  11.     
  12.     /**
  13.      * 按条件查询
  14.      */
  15.     @Test
  16.     public void test1() {
  17.         String hql = "from Service where unixHost=?";
  18.         Session session = HibernateUtil.getSession();
  19.         Query query = session.createQuery(hql);
  20.         query.setString(0, "192.168.0.20");
  21.         List<Service> services = query.list();
  22.         for(Service service : services){
  23.             System.out.println(service.getId()
  24.                     + " " + service.getUnixHost()
  25.                     + " " + service.getOsUserName());
  26.         }
  27.         session.close();
  28.     }
  29.     
  30. }

步骤二：测试

执行test1()方法，控制台输出效果如下图，可以看到按条件查询出的结果：

图-14

5.4 完整代码

以下为本案例的完整代码。

其中TestHQL完整代码如下：

代码

6 HQL查询，查询一部分字段

6.1 问题

使用HQL查询，要求只查询一部分字段。

6.2 方案

可以通过select子句明确指定要返回的字段，注意HQL中select子句中写的是属性，而不是表中的字段。

6.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：编写查询一部分字段方法

在TestHQL中增加查询一部分字段的方法，代码如下：

  1. package com.tarena.test;
  3. import java.util.List;
  4. import org.hibernate.Query;
  5. import org.hibernate.Session;
  6. import org.junit.Test;
  7. import com.tarena.entity.Service;
  8. import com.tarena.util.HibernateUtil;
  10. public class TestHQL {
  11.     
  12. // 其他查询方法略
  13.     /**
  14.      * 查询一部分字段
  15.      */
  16.     @Test
  17.     public void test2() {
  18.         String hql = "select id,unixHost,osUserName " +
  19.                 "from Service where unixHost=?";
  20.         Session session = HibernateUtil.getSession();
  21.         Query query = session.createQuery(hql);
  22.         query.setString(0, "192.168.0.20");
  23.         List<Object[]> services = query.list();
  24.         for(Object[] service : services) {
  25.             System.out.println(service[0]
  26.                     + " " + service[1]
  27.                     + " " + service[2]);
  28.         }
  29.         session.close();
  30.     }
  31.     
  32. }

步骤二：测试

执行test2()，控制台输出结果如下图，可以看到查询出来的这些字段的值。

图-15

6.4 完整代码

以下为本案例的完整代码。

其中TestHQL完整代码如下：

代码

7 HQL查询，分页查询

7.1 问题

按照每页显示3条数据，查询第1页的条件，查询出业务账号表中满足条件的记录，并且查询出总页数。

7.2 方案

  1. 分页查询时，在执行查询之前可以通过query对象设置分页参数值，query.setFirstResult(起点)，以及query.setMaxResults(页容量)。
  2. 查询总页数，只需要通过hql查询出总行数，再根据总行数计算总页数即可，而查询总行数的hql格式为select count(*) from 对象。

7.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：编写分页查询的方法

在TestHQL中，增加分页查询的方法，代码如下：

  1. package com.tarena.test;
  3. import java.util.List;
  4. import org.hibernate.Query;
  5. import org.hibernate.Session;
  6. import org.junit.Test;
  7. import com.tarena.entity.Service;
  8. import com.tarena.util.HibernateUtil;
  10. public class TestHQL {
  11.     
  12.     // 其他查询方法略
  13.     
  14.     /**
  15.      * 分页查询
  16.      */
  17.     @Test
  18.     public void test3() {
  19.         int page = 1;
  20.         int pageSize = 3;
  22.         String hql = "from Service order by id";
  23.         Session session = HibernateUtil.getSession();
  24.         Query query = session.createQuery(hql);
  25.         // 追加分页参数设置
  26.         int from = (page - 1) * pageSize;
  27.         query.setFirstResult(from);// 设置起点，从0开始
  28.         query.setMaxResults(pageSize);// 设置页容量
  29.         List<Service> services = query.list();
  30.         for (Service service : services) {
  31.             System.out.println(
  32.                 service.getId() + " " 
  33.                 + service.getUnixHost() + " " 
  34.                 + service.getOsUserName());
  35.         }
  36.         session.close();
  37.     }
  38.     
  39. }

步骤二：测试

执行test3()，控制台输出结果如下图，输出了第1页的3条数据。

图-16

步骤三：编写查询总页数的方法

在TestHQL中，增加查询总页数的方法，代码如下：

  1. package com.tarena.test;
  3. import java.util.List;
  4. import org.hibernate.Query;
  5. import org.hibernate.Session;
  6. import org.junit.Test;
  7. import com.tarena.entity.Service;
  8. import com.tarena.util.HibernateUtil;
  10. public class TestHQL {
  11.     
  12. // 其他查询方法略
  13.     /**
  14.      * 查询总页数
  15.      */
  16.     @Test
  17.     public void test4() {
  18.         int pageSize=3;
  19.         String hql = "select count(*) from Service";
  20.         Session session = HibernateUtil.getSession();
  21.         Query query = session.createQuery(hql);
  22.         int rows = Integer.parseInt(query.uniqueResult().toString());
  23.         int totalPages = 0;
  24.         if(rows%pageSize == 0) {
  25.             totalPages = rows/pageSize;
  26.         } else {
  27.             totalPages = rows/pageSize+1;
  28.         }
  29.         System.out.println(totalPages);
  30.         session.close();
  31.     }
  32.     
  33. }

步骤四：测试

执行test4()，控制台输出结果如下图，输出了总页数。

图-17

7.4 完整代码

以下为本案例的完整代码。

其中TestHQL完整代码如下：

代码

8 HQL查询，多表联合查询

8.1 问题

使用HQL，联合查询出业务账号与账务账号的数据。

8.2 方案

HQL中多表联合查询的方式有3种，分别是

  1. 对象方式关联
  2. join方式关联
  3. select子句关联

使用这三种方式来做业务账号与账务账号的联合查询。

8.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：编写对象方式关联的方法

在TestHQL中，增加对象方式关联的查询方法，代码如下：

  1. package com.tarena.test;
  3. import java.util.List;
  4. import org.hibernate.Query;
  5. import org.hibernate.Session;
  6. import org.junit.Test;
  7. import com.tarena.entity.Service;
  8. import com.tarena.util.HibernateUtil;
  10. public class TestHQL {
  11.     
  12.     // 其他查询方法略
  13.     
  14.     /**
  15.      * 多表联合查询-对象方式关联
  16.      */
  17.     @Test
  18.     public void test5() {
  19.         String hql = "select " +
  20.                 "s.id," +
  21.                 "s.osUserName," +
  22.                 "s.unixHost, " +
  23.                 "a.id,a.realName," +
  24.                 "a.idcardNo " +
  25.                 "from Service s,Account a " +
  26.                 "where s.account.id=a.id ";
  27.         Session session = HibernateUtil.getSession();
  28.         Query query = session.createQuery(hql);
  29.         List<Object[]> list = query.list();
  30.         for (Object[] objs : list) {
  31.             System.out.println(
  32.                     objs[0] + " " +
  33.                     objs[1] + " " +
  34.                     objs[2] + " " +
  35.                     objs[3] + " " +
  36.                     objs[4] + " " +
  37.                     objs[5]);
  38.         }
  39.         session.close();
  40.     }
  41.     
  42. }

步骤二：测试

执行test5()，控制台输出结果如下图，可以查询出关联的数据。

图-18

步骤三：编写join方式关联的方法

在TestHQL中，增加join方式关联的查询方法，代码如下：

  1. package com.tarena.test;
  3. import java.util.List;
  4. import org.hibernate.Query;
  5. import org.hibernate.Session;
  6. import org.junit.Test;
  7. import com.tarena.entity.Service;
  8. import com.tarena.util.HibernateUtil;
  10. public class TestHQL {
  11.     
  12.     // 其他查询方法略
  13.     
  14.     /**
  15.      * 多表联合查询-join方式关联
  16.      */
  17.     @Test
  18.     public void test6() {
  19.         String hql = "select " +
  20.                 "s.id,s.osUserName," +
  21.                 "s.unixHost, " +
  22.                 "a.id," +
  23.                 "a.realName," +
  24.                 "a.idcardNo " +
  25.                 "from Service s join s.account a ";
  26.         Session session = HibernateUtil.getSession();
  27.         Query query = session.createQuery(hql);
  28.         List<Object[]> list = query.list();
  29.         for (Object[] objs : list) {
  30.             System.out.println(
  31.                     objs[0] + " " +
  32.                     objs[1] + " " +
  33.                     objs[2] + " " +
  34.                     objs[3] + " " +
  35.                     objs[4] + " " +
  36.                     objs[5]);
  37.         }
  38.         session.close();
  39.     }
  40.     
  41. }

步骤四：测试

执行test6()，控制台输出结果如下图，可以查询出关联的数据。

图-19

步骤五：编写select子句关联的方法

在TestHQL中，增加select子句关联的查询方法，代码如下：

  1. package com.tarena.test;
  3. import java.util.List;
  4. import org.hibernate.Query;
  5. import org.hibernate.Session;
  6. import org.junit.Test;
  7. import com.tarena.entity.Service;
  8. import com.tarena.util.HibernateUtil;
  10. public class TestHQL {
  11.     
  12. // 其他查询方法略    
  13.     /**
  14.      * 多表联合查询-select子句关联
  15.      */
  16.     @Test
  17.     public void test7() {
  18.         String hql = "select " +
  19.                 "id," +
  20.                 "osUserName," +
  21.                 "unixHost, " +
  22.                 "account.id," +
  23.                 "account.realName," +
  24.                 "account.idcardNo " +
  25.                 "from Service ";
  26.         Session session = HibernateUtil.getSession();
  27.         Query query = session.createQuery(hql);
  28.         List<Object[]> list = query.list();
  29.         for (Object[] objs : list) {
  30.             System.out.println(
  31.                     objs[0] + " " +
  32.                     objs[1] + " " +
  33.                     objs[2] + " " +
  34.                     objs[3] + " " +
  35.                     objs[4] + " " +
  36.                     objs[5]);
  37.         }
  38.         session.close();
  39.     }
  40.     
  41. }

步骤六：测试

执行test7()，控制台输出结果如下，可以查询出关联的数据。

图-20

8.4 完整代码

以下为本案例的完整代码。

其中TestHQL完整代码如下：

代码

9 Hibernate中的SQL查询

9.1 问题

在Hibernate中直接使用SQL查询业务账号数据。

9.2 方案

Hibernate中可以通过SQLQuery对象来执行原始的SQL。

9.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：编写使用SQL查询的方法

在com.tarena.test包下，创建测试类TestOtherQuery，并在类中增加使用SQL查询的方法，代码如下：

  1. package com.tarena.test;
  3. import java.util.List;
  4. import org.hibernate.SQLQuery;
  5. import org.hibernate.Session;
  6. import org.junit.Test;
  7. import com.tarena.entity.Service;
  8. import com.tarena.util.HibernateUtil;
  10. public class TestOtherQuery {
  11.     
  12.     /**
  13.      * 使用SQL查询
  14.      */
  15.     @Test
  16.     public void test1() {
  17.         String sql = "select * " +
  18.                 "from SERVICE where unix_host=?";
  19.         Session session = HibernateUtil.getSession();
  20.         SQLQuery query = session.createSQLQuery(sql);
  21.         query.setString(0, "192.168.0.20");
  22.         query.addEntity(Service.class);
  23.         //采用Service类型封装一条数据
  24.         List<Service> list = query.list();
  25.         for(Service service : list){
  26.             System.out.println(
  27.                 service.getId() + " " +
  28.                 service.getOsUserName() + " " +
  29.                 service.getUnixHost() + " " 
  30.             );
  31.         }
  32.         session.close();
  33.     }
  34.     
  35. }

步骤二：测试

执行test1()，控制台输出结果如下图，是直接执行SQL所查询到的内容：

图-21

9.4 完整代码

以下为本案例的完整代码。

其中TestOtherQuery完整代码如下：

代码

10 使用二级缓存

10.1 问题

在查询员工时，使用二级缓存，使得不同的session可以共享这些员工数据。

10.2 方案

使用ehcache缓存组件来支持二级缓存，二级缓存的使用步骤为

  1. 导入二级缓存驱动包
  2. 引入二级缓存配置文件
  3. 在hibernate.cfg.xml中开启二级缓存并指定二级缓存驱动类
  4. 在映射关系文件中设置缓存策略
  5. 执行查询

10.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：导入二级缓存驱动包

导入二级缓存驱动包ehcache-1.2.3.jar，导入后项目中包结构如下图：

图-22

步骤二：引入二级缓存配置文件

引入二级缓存配置文件ehcache.xml，并配置缓存参数，代码如下：

  1. <ehcache>
  3. <!-- 
  4.     缓存到硬盘时的缓存路径,java.io.tmpdir表示
  5.     系统默认缓存路径。
  6.      -->
  7. <diskStore path="java.io.tmpdir"/>
  9. <!-- 
  10.     默认缓存配置。
  11.     maxElementsInMemory：
  12.         二级缓存可容纳最大对象数。
  13.     eternal：
  14.         是否保持二级缓存中对象不变。
  15.     timeToIdleSeconds：
  16.         允许对象空闲的时间，即对象最后一次访问起，超过该时间即失效。
  17.     timeToLiveSeconds：
  18.         允许对象存活的时间，即对象创建起，超过该时间即失效。
  19.     overflowToDisk：
  20.         内存不足时，是否允许使用硬盘缓存，写入路径参见diskStore。
  21.      -->
  22. <defaultCache
  23.         maxElementsInMemory="300"
  24.         eternal="false"
  25.         timeToIdleSeconds="120"
  26.         timeToLiveSeconds="300"
  27.         overflowToDisk="true"
  28.         />
  30.     <!-- 自定义缓存配置 -->
  31. <cache name="myCache"
  32.         maxElementsInMemory="2000"
  33.         eternal="false"
  34.         timeToIdleSeconds="300"
  35.         timeToLiveSeconds="600"
  36.         overflowToDisk="true"
  37.         />
  39. </ehcache>

步骤三：开启二级缓存、指定二级缓存驱动类

在hibernate.cfg.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.         <!-- 数据库连接信息，根据自己的数据库进行配置 -->
  8.         <property name="connection.url">
  9.             jdbc:oracle:thin:@localhost:1521:xe
  10.         </property>
  11.         <property name="connection.username">lhh</property>
  12.         <property name="connection.password">123456</property>
  13.         <property name="connection.driver_class">
  14.             oracle.jdbc.OracleDriver
  15.         </property>
  16.         
  17.         <!-- Hibernate配置信息 -->
  18.         <!-- dialect方言，用于配置生成针对哪个数据库的SQL语句 -->
  19.         <property name="dialect">
  20.             <!-- 方言类，Hibernate提供的，用于封装某种特定数据库的方言 -->
  21.             org.hibernate.dialect.OracleDialect
  22.         </property>
  23.         <!-- Hibernate生成的SQL是否输出到控制台 -->
  24.         <property name="show_sql">true</property>
  25.         <!-- 将SQL输出时是否格式化。为了方便截图,我将其设置为false -->
  26.         <property name="format_sql">false</property>
  27.         
  28.         <!-- 开启二级缓存 -->
  29.         <property name="hibernate.cache.use_second_level_cache">
  30.             true
  31.         </property>
  32.         <!-- 指定所采用的二级缓存驱动类 -->
  33.         <property name="hibernate.cache.provider_class">
  34.             org.hibernate.cache.EhCacheProvider
  35.         </property>        
  36.         
  37.         <!-- 声明映射关系文件 -->
  38.         <mapping resource="com/tarena/entity/Emp.hbm.xml" />
  39.         <mapping resource="com/tarena/entity/Account.hbm.xml" />
  40.         <mapping resource="com/tarena/entity/Service.hbm.xml" />        
  41.     </session-factory>
  42. </hibernate-configuration>

步骤四：设置缓存策略

在Emp.hbm.xml中，指定二级缓存策略为只读的，代码如下：

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC
  3.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  4.     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
  5. <hibernate-mapping>
  6.     <!-- 配置实体类和表的关系 -->
  7.     <class name="com.tarena.entity.Emp" table="emp">
  8.         <!-- 
  9.             开启二级缓存，指定二级缓存策略。
  10.             可以用region属性指定自定义的缓存设置。
  11.         -->
  12.         <cache usage="read-only" />
  13.         
  14.         <!-- 配置主键属性和字段的关系 -->
  15.         <id name="id" type="integer" column="id">
  16.             <!-- 用来指明主键的生成方式 -->
  17.             <generator class="sequence">
  18.                 <!-- 指定用于生成主键的sequence -->
  19.                 <param name="sequence">emp_seq</param>
  20.             </generator>
  21.         </id>
  22.         
  23.         <!-- 配置实体类中属性与表中字段的关系 -->
  24.         <property name="name" 
  25.             type="string" column="name"/>
  26.         <property name="age" 
  27.             type="integer" column="age"/>
  28.         <property name="salary" 
  29.             type="double" column="salary"/>
  30.         <property name="birthday" 
  31.             type="date" column="birthday"/>
  32.         <property name="lastLoginTime" 
  33.             type="timestamp" column="last_login_time"/>
  34.         <property name="marry"
  35.             type="yes_no" column="marry"/>
  36.     </class>
  37. </hibernate-mapping>

步骤五：编写查询方法，测试二级缓存

在com.tarena.test包下，创建一个测试类TestSecondCache，增加一个测试二级缓存的方法，代码如下：

  1. package com.tarena.test;
  3. import java.util.List;
  4. import org.hibernate.Query;
  5. import org.hibernate.Session;
  6. import org.junit.Test;
  7. import com.tarena.entity.Emp;
  8. import com.tarena.util.HibernateUtil;
  10. public class TestSecondCache {
  12.     /**
  13.      * 二级缓存
  14.      */
  15.     @Test
  16.     public void test1() {
  17.         Session session1 = HibernateUtil.getSession();
  18.         Emp e1 = (Emp) session1.get(Emp.class, 321);
  19.         System.out.println(e1.getName());
  20.         
  21.         System.out.println("-----------------");
  22.         
  23.         Session session2 = HibernateUtil.getSession();
  24.         Emp e2 = (Emp) session2.get(Emp.class, 321);
  25.         System.out.println(e2.getName());
  26.         
  27.         session1.close();
  28.         session2.close();
  29.     }
  30.     
  31. }

步骤六：测试

执行test1()，控制台输出结果如下图，可见第二次查询没有访问数据库，是二级缓存存在的缘故：

图-23

步骤七：管理二级缓存

二级缓存是SessionFactory级缓存，由它负责管理，因此需要获取到SessionFactory才能管理二级缓存，我们先在HibernateUtil中增加获取SessionFactory的方法，代码如下：

  1. package com.tarena.util;
  3. import org.hibernate.Session;
  4. import org.hibernate.SessionFactory;
  5. import org.hibernate.cfg.Configuration;
  7. public class HibernateUtil {
  9.     private static SessionFactory sessionFactory;
  10.     
  11.     static {
  12.         // 加载Hibernate主配置文件
  13.         Configuration conf = new Configuration();
  14.         conf.configure("/hibernate.cfg.xml");
  15.         sessionFactory = conf.buildSessionFactory();
  16.     }
  18.     /**
  19.      * 创建session
  20.      */
  21.     public static Session getSession() {
  22.         return sessionFactory.openSession();
  23.     }
  24.     
  25.     /**
  26.      * 返回SessionFactory
  27.      */
  28.     public static SessionFactory getSessionFactory() {
  29.         return sessionFactory;
  30.     }
  31.     
  32.     public static void main(String[] args) {
  33.         System.out.println(getSession());
  34.     }
  36. }

修改test1()方法，在第二次查询前清理二级缓存，代码如下：

  1. package com.tarena.test;
  3. import java.util.List;
  4. import org.hibernate.Query;
  5. import org.hibernate.Session;
  6. import org.junit.Test;
  7. import com.tarena.entity.Emp;
  8. import com.tarena.util.HibernateUtil;
  10. public class TestSecondCache {
  12.     /**
  13.      * 二级缓存
  14.      */
  15.     @Test
  16.     public void test1() {
  17.         Session session1 = HibernateUtil.getSession();
  18.         Emp e1 = (Emp) session1.get(Emp.class, 321);
  19.         System.out.println(e1.getName());
  20.         
  21.         System.out.println("-----------------");
  22.         HibernateUtil.getSessionFactory().evict(Emp.class);
  23.         
  24.         Session session2 = HibernateUtil.getSession();
  25.         Emp e2 = (Emp) session2.get(Emp.class, 321);
  26.         System.out.println(e2.getName());
  27.         
  28.         session1.close();
  29.         session2.close();
  30.     }
  31.     
  32. }

再次执行test1()，控制台输出结果如下图，由于清理了二级缓存，因此第二次查询时访问了数据库。

图-24

10.4 完整代码

以下是本案例的完整代码。

其中缓存配置文件ehcache.xml完整代码如下：

代码

hibernate.cfg.xml完整代码如下：

代码

emp.hbm.xml完整代码如下：

代码

TestSecondCache完整代码如下：

代码

11 使用查询缓存

11.1 问题

在查询多条员工数据时，使用查询缓存，缓存查询的HQL，使得再次使用同样HQL查询时不必重新访问数据库。

11.2 方案

查询缓存的使用步骤是

  1. 开启二级缓存
  2. 在hibernate.cfg.xml中开启查询缓存
  3. 在查询之前，开启查询缓存

11.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：开启二级缓存

开启二级缓存，由于上个案例已经完成，这一步就可以省略。但是要注意，查询缓存是基于二级缓存的，使用查询缓存的前提是开启二级缓存。

步骤二：开启查询缓存

在hibernate.cfg.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.         <!-- 数据库连接信息，根据自己的数据库进行配置 -->
  8.         <property name="connection.url">
  9.             jdbc:oracle:thin:@localhost:1521:xe
  10.         </property>
  11.         <property name="connection.username">lhh</property>
  12.         <property name="connection.password">123456</property>
  13.         <property name="connection.driver_class">
  14.             oracle.jdbc.OracleDriver
  15.         </property>
  16.         
  17.         <!-- Hibernate配置信息 -->
  18.         <!-- dialect方言，用于配置生成针对哪个数据库的SQL语句 -->
  19.         <property name="dialect">
  20.             <!-- 方言类，Hibernate提供的，用于封装某种特定数据库的方言 -->
  21.             org.hibernate.dialect.OracleDialect
  22.         </property>
  23.         <!-- Hibernate生成的SQL是否输出到控制台 -->
  24.         <property name="show_sql">true</property>
  25.         <!-- 将SQL输出时是否格式化。为了方便截图,我将其设置为false -->
  26.         <property name="format_sql">false</property>
  27.         
  28.         <!-- 开启二级缓存 -->
  29.         <property name="hibernate.cache.use_second_level_cache">
  30.             true
  31.         </property>
  32.         <!-- 指定所采用的二级缓存驱动 -->
  33.         <property name="hibernate.cache.provider_class">
  34.             org.hibernate.cache.EhCacheProvider
  35.         </property>        
  36.         <!-- 开启查询缓存 -->
  37.         <property name="hibernate.cache.use_query_cache">
  38.             true
  39.         </property>
  40.                 
  41.         <!-- 声明映射关系文件 -->
  42.         <mapping resource="com/tarena/entity/Emp.hbm.xml" />
  43.         <mapping resource="com/tarena/entity/Account.hbm.xml" />
  44.         <mapping resource="com/tarena/entity/Service.hbm.xml" />        
  45.     </session-factory>
  46. </hibernate-configuration>

步骤三：查询前开启查询缓存

在TestSecondCache中，增加测试查询缓存的方法，使用相同的HQL执行2次查询，每次查询前都设置开启查询缓存，代码如下：

  1. package com.tarena.test;
  3. import java.util.List;
  4. import org.hibernate.Query;
  5. import org.hibernate.Session;
  6. import org.junit.Test;
  7. import com.tarena.entity.Emp;
  8. import com.tarena.util.HibernateUtil;
  10. public class TestSecondCache {
  12.     /**
  13.      * 二级缓存
  14.      */
  15.     @Test
  16.     public void test1() {
  17.         Session session1 = HibernateUtil.getSession();
  18.         Emp e1 = (Emp) session1.get(Emp.class, 321);
  19.         System.out.println(e1.getName());
  20.         
  21.         System.out.println("-----------------");
  22.         HibernateUtil.getSessionFactory().evict(Emp.class);
  23.         
  24.         Session session2 = HibernateUtil.getSession();
  25.         Emp e2 = (Emp) session2.get(Emp.class, 321);
  26.         System.out.println(e2.getName());
  27.         
  28.         session1.close();
  29.         session2.close();
  30.     }
  31.     
  32.     /**
  33.      * 查询缓存
  34.      */
  35.     @Test
  36.     public void test2() {
  37.         Session session = HibernateUtil.getSession();
  38.         
  39.         String hql = "from Emp";
  40.         Query query = session.createQuery(hql);
  41.         // 开启查询缓存
  42.         query.setCacheable(true);
  43.         List<Emp> emps = query.list();
  44.         for(Emp e : emps) {
  45.             System.out.println(e.getId() + " " + e.getName());
  46.         }
  47.         
  48.         System.out.println("---------------");
  49.         
  50.         hql = "from Emp";
  51.         query = session.createQuery(hql);
  52.         // 开启查询缓存
  53.         query.setCacheable(true);
  54.         emps = query.list();
  55.         for(Emp e : emps) {
  56.             System.out.println(e.getId() + " " + e.getName());
  57.         }
  58.         
  59.         session.close();
  60.     }
  61.     
  62. }

步骤四：测试

执行test2()，控制台输出结果如下图，可见在使用相同HQL查询时，第二次查询不必再次访问数据库。

图-25

步骤五：管理查询缓存

修改test2()，在第二次查询之前清理查询缓存，代码如下：

  1. package com.tarena.test;
  3. import java.util.List;
  4. import org.hibernate.Query;
  5. import org.hibernate.Session;
  6. import org.junit.Test;
  7. import com.tarena.entity.Emp;
  8. import com.tarena.util.HibernateUtil;
  10. public class TestSecondCache {
  12.     /**
  13.      * 二级缓存
  14.      */
  15.     @Test
  16.     public void test1() {
  17.         Session session1 = HibernateUtil.getSession();
  18.         Emp e1 = (Emp) session1.get(Emp.class, 321);
  19.         System.out.println(e1.getName());
  20.         
  21.         System.out.println("-----------------");
  22.         HibernateUtil.getSessionFactory().evict(Emp.class);
  23.         
  24.         Session session2 = HibernateUtil.getSession();
  25.         Emp e2 = (Emp) session2.get(Emp.class, 321);
  26.         System.out.println(e2.getName());
  27.         
  28.         session1.close();
  29.         session2.close();
  30.     }
  31.     
  32.     /**
  33.      * 查询缓存
  34.      */
  35.     @Test
  36.     public void test2() {
  37.         Session session = HibernateUtil.getSession();
  38.         
  39.         String hql = "from Emp";
  40.         Query query = session.createQuery(hql);
  41.         // 开启查询缓存
  42.         query.setCacheable(true);
  43.         List<Emp> emps = query.list();
  44.         for(Emp e : emps) {
  45.             System.out.println(e.getId() + " " + e.getName());
  46.         }
  47.         
  48.         System.out.println("---------------");
  49.         HibernateUtil.getSessionFactory().evictQueries();
  50.         
  51.         hql = "from Emp";
  52.         query = session.createQuery(hql);
  53.         // 开启查询缓存
  54.         query.setCacheable(true);
  55.         emps = query.list();
  56.         for(Emp e : emps) {
  57.             System.out.println(e.getId() + " " + e.getName());
  58.         }
  59.         
  60.         session.close();
  61.     }
  62.     
  63. }

再次执行test2()，控制台输出结果如下图，可见第二次查询也访问了数据库，主要是清理了查询缓存中数据的缘故。

图-26

11.4 完整代码

以下为本案例的完整代码。

其中Hibernate.cfg.xml完整代码如下：

代码

TestSecondCache完整代码如下：

代码
0 0
怎么让淘宝客户加微信 怎么让淘宝客户加微信
原创粉丝点击
热门IT博客
linux jdk环境变量配置linux jdk环境变量配置
梦幻手游mac版梦幻手游mac版
网络微拍大尺度红人
淘宝1920全屏轮播图片
js 数组对象去重
python 写入txt文件
印度火箭 知乎
minimax算法
高数解题软件
电脑报淘宝店怎么样
数据不可信的 英文
java开发年度工作总结
对网络语言的看法
怎么执行php图片木马
ubuntu系统可以干什么
mac 查看剩余空间
java web 线程池
网络电视台直播网
mysql 生成连续数字
mac系统word下载地址
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 霸道老公深度爱 霸道老公深度 初次被迫深度宫 烈日灼心深度解析 深度索爱女人别喊 老公深度索欢 霸道老公深度爱紫琼 霸道总裁深度宠 深度索爱老公生猛 深度是什么意思 deepin系统 深之度 隐婚99天战少深度宠妻 中深建装饰设计工程有限公司 返影入深林 云母屏风烛影深下一句 深德技校 深圳深德技校 德深鼠标输入法下载 深德技工学校怎么样 深圳市深德技工学校 妻子的深情 深情触摸 深情时见鱼 深情 深情共白首 深情密码 深情地什么 深情的什么 深情网 深情的意思 深情图片 深情款款 深情守候 深情并茂 许你一世深情 以我深情与你白首 赠你一世深情 爱你深情已入骨 深情不及久伴 陆先生深情不负

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里