hiberate学习二 缓存

最新推荐文章于 2020-04-05 17:27:05 发布
最新推荐文章于 2020-04-05 17:27:05 发布
阅读量273 收藏
点赞数
Top

JAVA Hibernate DAY02

  1. 验证一级缓存
  2. 管理一级缓存
  3. 验证持久态对象的特性
  4. 验证延迟加载
  5. 在NETCTOSS中使用延迟加载
  6. 使用一对多关联映射

1 验证一级缓存

1.1 问题

设计几个测试案例，以验证一级缓存的存在及特性。

1.2 方案

  1. 用同一个Session查询同一条数据2次，如果只查询一次数据库，则验证了一级缓存的存在。
  2. 用2个不同的Session，分别查询同一条数据，如果查询2次数据库，则验证了一级缓存是Session独享的。

1.3 步骤

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

步骤一：创建项目

复制项目HibernateDay01，粘贴并将项目名改为HibernateDay02。

步骤二：写测试案例代码

在com.tarena.test包下创建测试类TestFirstCache，在这个测试类中分别写出方案中提到的2个测试方法，用以验证一级缓存的存在及特性，代码如下：


    
    
  1. package com.tarena.test;
  3. import org.hibernate.Session;
  4. import org.junit.Test;
  5. import com.tarena.entity.Emp;
  6. import com.tarena.util.HibernateUtil;
  8. public class TestFirstCache {
  9.     
  10.     /**
  11.      * 用同一个Session查询同一条数据2次，
  12.      * 如果只查询一次数据库，则验证了一级缓存的存在。
  13.      */
  14.     @Test
  15.     public void test1() {
  16.         Session session = HibernateUtil.getSession();
  17.         Emp e1 = (Emp) session.get(Emp.class, 321);
  18.         System.out.println(e1.getName());
  19.         System.out.println("----------------");
  20.         Emp e2 = (Emp) session.get(Emp.class, 321);
  21.         System.out.println(e2.getName());
  22.         session.close();
  23.     }
  25.     /**
  26.      * 用2个不同的Session，分别查询同一条数据，
  27.      * 如果查询2次数据库，则验证了一级缓存是Session独享的。
  28.      */
  29.     @Test
  30.     public void test2() {
  31.         Session session1 = HibernateUtil.getSession();
  32.         Emp e1 = (Emp) session1.get(Emp.class, 321);
  33.         System.out.println(e1.getName());
  35.         Session session2 = HibernateUtil.getSession();
  36.         Emp e2 = (Emp) session2.get(Emp.class, 321);
  37.         System.out.println(e2.getName());
  39.         session1.close();
  40.         session2.close();
  41.     }
  42.     
  43. }

步骤三：测试

分别执行以上2个方法，根据控制台输出的结果，根据其SQL语句数量可以判断出查询执行的次数，进而验证一级缓存的存在及特性。

test1()执行后，控制台输出结果如下图，可以看出第二次查询并没有真正访问数据库，验证了一级缓存的存在：

图-1

test2()执行后，控制台输出结果如下图，可以看出第二次查询访问了数据库，验证了一级缓存是Session独享的。

图-2

1.4 完整代码

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

其中TestFirstCache完整代码如下：

代码

2 管理一级缓存

2.1 问题

掌握一级缓存管理的2种方式：

  1. 使用evict方法，从一级缓存中移除一个对象。
  2. 使用clear方法，将一级缓存中的对象全部移除。

设计出案例，来使用并验证一级缓存管理方法。

2.2 方案

设计2个案例，使用同一个Session查询同一条数据2次，由于一级缓存的存在，第二次查询时将从一级缓存中取数，而不会查询数据库。

那么，如果在第二次查询之前将数据从缓存中移除，第二次查询时就会访问数据库。在这两个案例中，我们分别使用evict和clear方法将数据从缓存中移除。

2.3 步骤

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

步骤一：在TestFirstCache中增加测试案例代码

在TestFirstCache中增加2个方法，均使用同一个Session查询同一条数据2次，在第二次查询之前，分别使用evice和clear方法移除缓存数据，代码如下：


    
    
  1. package com.tarena.test;
  3. import org.hibernate.Session;
  4. import org.junit.Test;
  5. import com.tarena.entity.Emp;
  6. import com.tarena.util.HibernateUtil;
  8. public class TestFirstCache {
  9.     
  10.     /**
  11.      * 用同一个Session查询同一条数据2次，
  12.      * 如果只查询一次数据库，则验证了一级缓存的存在。
  13.      */
  14.     @Test
  15.     public void test1() {
  16.         Session session = HibernateUtil.getSession();
  17.         Emp e1 = (Emp) session.get(Emp.class, 321);
  18.         System.out.println(e1.getName());
  19.         System.out.println("----------------");
  20.         Emp e2 = (Emp) session.get(Emp.class, 321);
  21.         System.out.println(e2.getName());
  22.         session.close();
  23.     }
  25.     /**
  26.      * 用2个不同的Session，分别查询同一条数据，
  27.      * 如果查询2次数据库，则验证了一级缓存是Session独享的。
  28.      */
  29.     @Test
  30.     public void test2() {
  31.         Session session1 = HibernateUtil.getSession();
  32.         Emp e1 = (Emp) session1.get(Emp.class, 321);
  33.         System.out.println(e1.getName());
  35.         Session session2 = HibernateUtil.getSession();
  36.         Emp e2 = (Emp) session2.get(Emp.class, 321);
  37.         System.out.println(e2.getName());
  39.         session1.close();
  40.         session2.close();
  41.     }
  42.     
  43.     /**
  44.      * 验证缓存管理的方法evict
  45.      */
  46.     @Test
  47.     public void test3() {
  48.         Session session = HibernateUtil.getSession();
  49.         Emp e1 = (Emp) session.get(Emp.class, 321);
  50.         System.out.println(e1.getName());
  51.         session.evict(e1);
  52.         Emp e2 = (Emp) session.get(Emp.class, 321);
  53.         System.out.println(e2.getName());
  54.         session.close();
  55.     }
  56.     
  57.     /**
  58.      * 验证缓存管理的方法clear
  59.      */
  60.     @Test
  61.     public void test4() {
  62.         Session session = HibernateUtil.getSession();
  63.         Emp e1 = (Emp) session.get(Emp.class, 321);
  64.         System.out.println(e1.getName());
  65.         session.clear();
  66.         Emp e2 = (Emp) session.get(Emp.class, 321);
  67.         System.out.println(e2.getName());
  68.         session.close();
  69.     }
  70.     
  71. }

步骤二：测试

分别执行这两个方法，并观察控制台，会发现都只输出了一次SQL，验证了这2个方法可以有效的管理一级缓存。

test3()执行后，控制台输出结果如下图，可以看出第二次查询访问了数据库，验证了evice管理一级缓存是有效的。

图-3

test4()执行后，控制台输出结果如下图，可以看出第二次查询访问了数据库，验证了clear管理一级缓存是有效的。

图-4

2.4 完整代码

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

其中TestFirstCache完整代码如下：

代码

3 验证持久态对象的特性

3.1 问题

设计出案例，验证持久态对象的特性：

  1. 持久态对象存在于一级缓存中。
  2. 持久态对象可以自动更新至数据库。
  3. 持久态对象自动更新数据库的时机是session.flush()。

3.2 方案

设计3个案例，分别验证持久态对象的3个特性：

  1. 新增一条数据，在新增后该数据对象为持久态的，然后根据对象的ID再次查询数据。执行时如果控制台不重新输出SQL则验证了持久态对象存在于一级缓存。
  2. 新增一条数据，在新增后该对象为持久态的，然后修改这个对象的任意属性值，并提交事务。在执行时，如果发现数据库中的数据是修改后的内容，则验证了持久态对象可以自动更新至数据库。
  3. 查询一条数据，该数据对象为持久态的，然后修改对象的任意属性值，再调用session.flush()方法，并且不提交事务。如果执行时控制台输出更新的SQL，则验证了一级缓存对象更新至数据库的时机为session.flush()。

3.3 步骤

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

步骤一：创建验证对象持久性测试类

在com.tarena.test包下，创建一个测试类TestPersistent，在其中写出验证对象持久性的3个测试方法，用以验证对象持久性的3个特性，代码如下：


    
    
  1. package com.tarena.test;
  3. import java.sql.Date;
  4. import java.sql.Timestamp;
  5. import org.hibernate.HibernateException;
  6. import org.hibernate.Session;
  7. import org.hibernate.Transaction;
  8. import org.junit.Test;
  9. import com.tarena.entity.Emp;
  10. import com.tarena.util.HibernateUtil;
  12. public class TestPersistent {
  13.     
  14.     /**
  15.      * 持久态对象存在于一级缓存中
  16.      */
  17.     @Test
  18.     public void test1() {
  19.         Emp e = new Emp();
  20.         e.setName("唐僧");
  21.         e.setAge(29);
  22.         e.setMarry(false);
  23.         e.setSalary(12000.00);
  24.         e.setBirthday(
  25.             Date.valueOf("1983-10-20"));
  26.         e.setLastLoginTime(
  27.             new Timestamp(System.currentTimeMillis()));
  29.         Session session = HibernateUtil.getSession();
  30.         Transaction ts = session.beginTransaction();
  31.         try {
  32.             session.save(e);
  33.             ts.commit();
  34.         } catch (HibernateException e1) {
  35.             e1.printStackTrace();
  36.             ts.rollback();
  37.         }
  38.         
  39.         Emp emp = (Emp) session.get(Emp.class, e.getId());
  40.         System.out.println(emp.getId() + " " + emp.getName());
  41.         
  42.         session.close();
  43.     }
  45.     /**
  46.      * 持久态对象可以自动更新至数据库
  47.      */
  48.     @Test
  49.     public void test2() {
  50.         Emp e = new Emp();
  51.         e.setName("孙悟空");
  52.         e.setAge(29);
  53.         e.setMarry(false);
  54.         e.setSalary(12000.00);
  55.         e.setBirthday(
  56.             Date.valueOf("1983-10-20"));
  57.         e.setLastLoginTime(
  58.             new Timestamp(System.currentTimeMillis()));
  60.         Session session = HibernateUtil.getSession();
  61.         Transaction ts = session.beginTransaction();
  62.         try {
  63.             session.save(e);
  64.             e.setName("猪八戒");
  65.             ts.commit();
  66.         } catch (HibernateException e1) {
  67.             e1.printStackTrace();
  68.             ts.rollback();
  69.         }
  70.         session.close();
  71.     }    
  72.     /**
  73.      * 持久态对象自动更新数据库的时机
  74.      */
  75.     @Test
  76.     public void test3() {
  77.         Session session = HibernateUtil.getSession();
  78.         Emp e = (Emp) session.load(Emp.class, 201);
  79.         e.setName("太上老君");
  80.         session.flush(); //同步但未提交事务
  81.         session.close();
  82.     }
  83.     
  84. }

步骤二：测试

分别执行上述3个测试方法，观察控制台输出的SQL，看是否与方案中描述的一致。

test1()执行后，控制台输出结果如下图，可以看出后面的查询并没有再次访问数据库，验证了持久态对象是存在于一级缓存中的。

图-5

test2()执行后，控制台输出结果如下图，可以看出Hibernate自动执行了一次更新，验证了持久态对象会自动更新至数据库。

图-6

EMP表查询结果如下图，可以看出最后一条数据的名称的确被更新为猪八戒。

图-7

test3()执行后，控制台输出结果如下图，可以看出Hibernate自动执行了一次更新，验证了自动更新的时机是session.flush()。

图-8

EMP表查询结果如下图，可以看出最后一条数据的名称并没有更新为太上老君，说明session.flush只是触发更新，并没有提交事务。

图-9

3.4 完整代码

本案例的完整代码如下所示：

TestPersistent完整代码如下：

代码

4 验证延迟加载

4.1 问题

设计案例，验证session.load()方法和query.iterate()方法在查询时是采用延迟加载机制的。

4.2 方案

  1. 验证session.load()的延迟加载，可以先查询某条EMP数据，然后输出一个分割线，在分割线的后面再使用这个对象，输出它的一些属性值。在运行时，如果查询EMP的SQL输出在分割线的后面，则验证了该方法是采用延迟加载机制的。
  2. 验证query.iterate()的延迟加载，可以先查询出全部的EMP数据，然后输出一个分割线，在分割线的后面再遍历查询结果并输出每个对象的一些属性值。在运行时，如果查询EMP的SQL输出在分割线的后面，则验证了该方法是采用延迟加载机制的。

4.3 步骤

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

步骤一：创建验证延迟加载的测试类

在com.tarena.test包下，创建一个测试类TestLazy，并在这个类中写2个测试方法，分别验证session.load()和query.iterate()方法是采用延迟加载机制的，代码如下：


    
    
  1. package com.tarena.test;
  3. import java.util.Iterator;
  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 TestLazy {
  11.     
  12.     /**
  13.      * 验证load方法是延迟加载的
  14.      */
  15.     @Test
  16.     public void test1() {
  17.         Session session = HibernateUtil.getSession();
  18.         // load方法并没有触发访问数据库
  19.         Emp emp = (Emp) session.load(Emp.class, 321);
  20.         System.out.println("-----------------");
  21.         // 使用emp对象时才真正访问数据库
  22.         System.out.println(emp.getName());
  23.         session.close();
  24.     }
  26.     /**
  27.      * 验证iterate方法是延迟加载的
  28.      */
  29.     @Test
  30.     public void test2() {
  31.         String hql = "from Emp";
  32.         Session session = HibernateUtil.getSession();
  33.         Query query = session.createQuery(hql);
  34.         // iterate方法访问了数据库，但只查询了ID列
  35.         Iterator<Emp> it = query.iterate();
  36.         System.out.println("-----------------");
  37.         while (it.hasNext()) {
  38.             Emp emp = it.next();
  39.             // 使用emp对象时才将其他列全部加载
  40.             System.out.println(emp.getName());
  41.         }
  42.         session.close();
  43.     }
  44.     
  45. }

步骤二：测试

分别执行上面的2个测试方法，根据控制台输出的结果，判断session.load()和query.iterate()方法是否采用延迟加载机制。

test1()方法执行后，控制台输出结果如下图，可以看出查询SQL是输出在分割线后面的，也就是在使用emp对象时才触发了数据库的访问，验证了延迟加载的存在。

图-10

test2()方法执行后，控制台输出结果如下图，可以看出查询EMP表全部内容的SQL输出在分割线的后面，也就是在使用emp对象时才触发的数据库访问，验证了延迟加载的存在。

图-11

4.4 完整代码

本案例的完整代码如下所示：

代码

5 在NETCTOSS中使用延迟加载

5.1 问题

请将NETCTOSS中资费模块DAO的实现，改用Hibernate中延迟加载的方法。

5.2 方案

将CostDaoImpl中的findById方法的实现，改为session.load()。

为了避免session提前关闭导致延迟加载出现问题，需要在findById方法中不关闭session，而是自定义拦截器，在拦截器中调用完action之后关闭session。自然地，资费模块的action都应该引用这个拦截器。

5.3 步骤

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

步骤一：使用延迟加载方法

将CostDaoImpl中的findById方法中，session.get()改为session.load()，代码如下：


    
    
  1. package com.netctoss.dao;
  3. import java.util.List;
  4. import org.hibernate.HibernateException;
  5. import org.hibernate.Query;
  6. import org.hibernate.Session;
  7. import org.hibernate.Transaction;
  8. import com.netctoss.entity.Cost;
  9. import com.netctoss.util.HibernateUtil;
  11. /**
  12.  *    当前阶段学习重点是Struts2，对于DAO的实现就模拟实现了。
  13.  *    同学们可以使用JDBC/MyBatis自行实现该DAO。
  14.  */
  15. public class CostDaoImpl implements ICostDao {
  17.     @Override
  18.     public List<Cost> findAll() {
  19.         String hql = "from Cost";
  20.         Session session = HibernateUtil.getSession();
  21.         Query query = session.createQuery(hql);
  22.         List<Cost> list = query.list();
  23.         session.close();
  24.         return list;
  25.     }
  27.     @Override
  28.     public void delete(int id) {
  29.         Cost cost = new Cost();
  30.         cost.setId(id);
  32.         Session session = HibernateUtil.getSession();
  33.         Transaction ts = session.beginTransaction();
  34.         try {
  35.             session.delete(cost);
  36.             ts.commit();
  37.         } catch (HibernateException e) {
  38.             e.printStackTrace();
  39.             ts.rollback();
  40.         } finally {
  41.             session.close();
  42.         }
  43.     }
  45.     @Override
  46.     public Cost findByName(String name) {
  47.         // 模拟根据名称查询资费数据，假设资费表中只有一条名为tarena的数据
  48.         if("tarena".equals(name)) {
  49.             Cost c = new Cost();
  50.             c.setId(97);
  51.             c.setName("tarena");
  52.             c.setBaseDuration(99);
  53.             c.setBaseCost(9.9);
  54.             c.setUnitCost(0.9);
  55.             c.setDescr("tarena套餐");
  56.             c.setStatus("0");
  57.             c.setCostType("2");
  58.             return c;
  59.         }
  60.         return null;
  61.     }
  63.     @Override
  64.     public Cost findById(int id) {
  65.         Session session = HibernateUtil.getSession();
  66.         Cost cost = (Cost) session.load(Cost.class, id);
  67.         session.close();
  68.         return cost;
  69.     }
  71. }

步骤二：测试

重新部署项目，并重启tomcat，访问资费修改页面，效果如下图：

图-12

可以看出要修改的数据，只有ID显示正确，其他字段都为空。原因是我们的findById方法中直接关闭了session，而该方法返回的对象是在JSP中使用的，在使用时session已经关闭，由于延迟加载机制的存在，导致了这个问题的发生。要想解决这个问题，我们需要继续如下的步骤。

步骤三：重构HibernateUtil，使用ThreadLocal管理Session

重构HibernateUtil，引入ThreadLocal来管理Session。ThreadLocal对象是与线程有关的工具类，它的目的是将管理的对象按照线程进行隔离，以保证一个线程只对应一个对象。

由于后面我们要在拦截器中关闭连接，因此需要准确的取出DAO中使用的连接对象，为了便于实现在一个线程（一次客户端请求，就是一个线程）中，不同的代码位置获取同一个连接，那么使用ThreadLocal来管理session就再合适不过了。

注意，引入ThreadLocal管理session，不仅仅是在创建session时将其加入到ThreadLocal中，在关闭session时也需要将其从ThreadLocal中移除，因此HibernateUtil中还需要提供一个关闭session的方法。

重构以后，HibernateUtil代码如下：


    
    
  1. package com.netctoss.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.      * 使用ThreadLocal管理Session，可以保证一个线程中只有唯一的一个连接。
  12.      * 并且我们在获取连接时，它会自动的给我们返回当前线程对应的连接。
  13.      */
  14.     private static ThreadLocal<Session> tl = 
  15.             new ThreadLocal<Session>();
  16.     
  17.     static {
  18.         // 加载Hibernate主配置文件
  19.         Configuration conf = new Configuration();
  20.         conf.configure("/hibernate.cfg.xml");
  21.         sessionFactory = conf.buildSessionFactory();
  22.     }
  24.     /**
  25.      * 创建session
  26.      */
  27.     public static Session getSession() {
  28.         // ThreadLocal会以当前线程名为key获取连接
  29.         Session session = tl.get();
  30.         // 如果取到的当前线程的连接为空
  31.         if(session == null) {
  32.             // 使用工厂创建连接
  33.             session = sessionFactory.openSession();
  34.             // ThreadLocal会以当前线程名为key保存session
  35.             tl.set(session);
  36.         }
  37.         return session;
  38.     }
  39.     
  40.     /**
  41.      * 关闭session
  42.      */
  43.     public static void close() {
  44.         // ThreadLocal会以当前线程名为key获取连接
  45.         Session session = tl.get();
  46.         // 如果取到的当前线程的连接不为空
  47.         if(session != null) {
  48.             // 关闭session
  49.             session.close();
  50.             // 将当前线程对应的连接从ThreadLocal中移除
  51.             tl.remove();
  52.         }
  53.     }
  54.     
  55.     public static void main(String[] args) {
  56.         System.out.println(getSession());
  57.         close();
  58.     }
  60. }

步骤四：创建保持session在视图层开启的拦截器

在com.netctoss.interceptor包下，创建一个拦截器OpenSessionInViewInterceptor，在拦截方法中，先调用action和result，之后再关闭本次访问线程对应的session，代码如下：


    
    
  1. package com.netctoss.interceptor;
  3. import com.netctoss.util.HibernateUtil;
  4. import com.opensymphony.xwork2.ActionInvocation;
  5. import com.opensymphony.xwork2.interceptor.Interceptor;
  7. /**
  8.  *    保持Session在视图层开启的拦截器，主要作用
  9.  *    是在执行完JSP之后再统一关闭session。
  10.  */
  11. public class OpenSessionInViewInterceptor 
  12.     implements Interceptor {
  14.     @Override
  15.     public void destroy() {
  17.     }
  19.     @Override
  20.     public void init() {
  22.     }
  24.     @Override
  25.     public String intercept(ActionInvocation ai) 
  26.             throws Exception {
  27.         // 调用action和result
  28.         ai.invoke();
  29.         /*
  30.          * result会把请求转发到页面，因此调用result，
  31.          * 就相当于调用JSP，因此此处的代码是在JSP之后执行。
  32.          * */
  33.         HibernateUtil.close();
  34.         return null;
  35.     }
  37. }

步骤五：注册并引用拦截器

在struts.xml中，注册并引用这个拦截器，代码如下：


    
    
  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE struts PUBLIC
  3.     "-//Apache Software Foundation//DTD Struts Configuration 2.1.7//EN"
  4.     "http://struts.apache.org/dtds/struts-2.1.7.dtd">
  5. <struts>
  6.     
  7.     <!-- 公共的包，封装了通用的拦截器、通用的result -->
  8.     <package name="netctoss" extends="json-default">
  9.         <interceptors>
  10.             <!-- 登录检查拦截器 -->
  11.             <interceptor name="loginInterceptor"
  12.                 class="com.netctoss.interceptor.LoginInterceptor"/>
  13.             <!-- 保持session开启拦截器 -->
  14.             <interceptor name="openSessionInterceptor"
  15.                 class="com.netctoss.interceptor.OpenSessionInViewInterceptor"/>
  16.             <!-- 登录检查拦截器栈 -->
  17.             <interceptor-stack name="loginStack">
  18.                 <interceptor-ref name="loginInterceptor"/>
  19.                 <interceptor-ref name="openSessionInterceptor"/>
  20.                 <!-- 不要丢掉默认的拦截器栈，里面有很多Struts2依赖的拦截器 -->
  21.                 <interceptor-ref name="defaultStack"/>
  22.             </interceptor-stack>
  23.         </interceptors>
  24.         <!-- 设置action默认引用的拦截器 -->
  25.         <default-interceptor-ref name="loginStack"/>
  26.         <!-- 全局的result，包下所有的action都可以共用 -->
  27.         <global-results>
  28.             <!-- 跳转到登录页面的result -->
  29.             <result name="login" type="redirectAction">
  30.                 <param name="namespace">/login</param>
  31.                 <param name="actionName">toLogin</param>
  32.             </result>
  33.         </global-results>
  34.     </package>
  35.     
  36.     <!-- 
  37.         资费模块配置信息：
  38.         一般情况下，一个模块的配置单独封装在一个package下，
  39.         并且以模块名来命名package的name和namespace。
  40.      -->
  41.     <package name="cost" namespace="/cost" extends="netctoss">
  42.         <!-- 查询资费数据 -->
  43.         <action name="findCost" class="com.netctoss.action.FindCostAction">
  44.             <!-- 
  45.                 正常情况下跳转到资费列表页面。
  46.                 一般一个模块的页面要打包在一个文件夹下，并且文件夹以模块名命名。
  47.              -->
  48.             <result name="success">
  49.                 /WEB-INF/cost/find_cost.jsp
  50.             </result>
  51.             <!-- 
  52.                 错误情况下，跳转到错误页面。
  53.                 错误页面可以被所有模块复用，因此放在main下，
  54.                 该文件夹用于存放公用的页面。
  55.              -->
  56.             <result name="error">
  57.                 /WEB-INF/main/error.jsp
  58.             </result>
  59.         </action>
  60.         <!-- 删除资费 -->
  61.         <action name="deleteCost" 
  62.             class="com.netctoss.action.DeleteCostAction">
  63.             <!-- 删除完之后，重定向到查询action -->
  64.             <result name="success" type="redirectAction">
  65.                 findCost
  66.             </result>
  67.             <result name="error">
  68.                 /WEB-INF/main/error.jsp
  69.             </result>
  70.         </action>
  71.         <!-- 打开资费新增页 -->
  72.         <action name="toAddCost">
  73.             <result name="success">
  74.                 /WEB-INF/cost/add_cost.jsp
  75.             </result>
  76.         </action>
  77.         <!-- 资费名唯一性校验 -->
  78.         <action name="checkCostName" 
  79.             class="com.netctoss.action.CheckCostNameAction">
  80.             <!-- 使用json类型的result把结果输出给回调函数 -->
  81.             <result name="success" type="json">
  82.                 <param name="root">info</param>
  83.             </result>
  84.         </action>
  85.         <!--  打开修改页面 -->
  86.         <action name="toUpdateCost" 
  87.             class="com.netctoss.action.ToUpdateCostAction">
  88.             <result name="success">
  89.                 /WEB-INF/cost/update_cost.jsp
  90.             </result>
  91.             <result name="error">
  92.                 /WEB-INF/main/error.jsp
  93.             </result>
  94.         </action>
  95.     </package>
  96.     
  97.     <!-- 登录模块 -->
  98.     <package name="login" namespace="/login" extends="struts-default">
  99.         <!-- 
  100.             打开登录页面：
  101.             1、action的class属性可以省略，省略时Struts2
  102.             会自动实例化默认的Action类ActionSupport,
  103.             该类中有默认业务方法execute，返回success。
  104.             2、action的method属性可以省略，省略时Struts2
  105.             会自动调用execute方法。
  106.         -->
  107.         <action name="toLogin">
  108.             <result name="success">
  109.                 /WEB-INF/main/login.jsp
  110.             </result>
  111.         </action>
  112.         <!-- 登录校验 -->
  113.         <action name="login" class="com.netctoss.action.LoginAction">
  114.             <!-- 校验成功，跳转到系统首页 -->
  115.             <result name="success">
  116.                 /WEB-INF/main/index.jsp
  117.             </result>
  118.             <!-- 登录失败，跳转回登录页面 -->
  119.             <result name="fail">
  120.                 /WEB-INF/main/login.jsp
  121.             </result>
  122.             <!-- 报错，跳转到错误页面 -->
  123.             <result name="error">
  124.                 /WEB-INF/main/error.jsp
  125.             </result>
  126.         </action>
  127.         <!-- 生成验证码 -->
  128.         <action name="createImage" class="com.netctoss.action.CreateImageAction">
  129.             <!-- 使用stream类型的result -->
  130.             <result name="success" type="stream">
  131.                 <!-- 指定输出的内容 -->
  132.                 <param name="inputName">imageStream</param>
  133.             </result>
  134.         </action>
  135.     </package>
  136.     
  137. </struts>

步骤六：重构资费DAO实现类，去掉关闭session

重构CostDaoImpl，将session关闭的代码注释掉，统一由拦截器关闭。重构后代码如下：


    
    
  1. package com.netctoss.dao;
  3. import java.util.List;
  4. import org.hibernate.HibernateException;
  5. import org.hibernate.Query;
  6. import org.hibernate.Session;
  7. import org.hibernate.Transaction;
  8. import com.netctoss.entity.Cost;
  9. import com.netctoss.util.HibernateUtil;
  11. /**
  12.  *    当前阶段学习重点是Struts2，对于DAO的实现就模拟实现了。
  13.  *    同学们可以使用JDBC/MyBatis自行实现该DAO。
  14.  */
  15. public class CostDaoImpl implements ICostDao {
  17.     @Override
  18.     public List<Cost> findAll() {
  19.         String hql = "from Cost";
  20.         Session session = HibernateUtil.getSession();
  21.         Query query = session.createQuery(hql);
  22.         List<Cost> list = query.list();
  23. //        session.close();
  24.         return list;
  25.     }
  27.     @Override
  28.     public void delete(int id) {
  29.         Cost cost = new Cost();
  30.         cost.setId(id);
  32.         Session session = HibernateUtil.getSession();
  33.         Transaction ts = session.beginTransaction();
  34.         try {
  35.             session.delete(cost);
  36.             ts.commit();
  37.         } catch (HibernateException e) {
  38.             e.printStackTrace();
  39.             ts.rollback();
  40.         } finally {
  41. //            session.close();
  42.         }
  43.     }
  45.     @Override
  46.     public Cost findByName(String name) {
  47.         // 模拟根据名称查询资费数据，假设资费表中只有一条名为tarena的数据
  48.         if("tarena".equals(name)) {
  49.             Cost c = new Cost();
  50.             c.setId(97);
  51.             c.setName("tarena");
  52.             c.setBaseDuration(99);
  53.             c.setBaseCost(9.9);
  54.             c.setUnitCost(0.9);
  55.             c.setDescr("tarena套餐");
  56.             c.setStatus("0");
  57.             c.setCostType("2");
  58.             return c;
  59.         }
  60.         return null;
  61.     }
  63.     @Override
  64.     public Cost findById(int id) {
  65.         Session session = HibernateUtil.getSession();
  66.         Cost cost = (Cost) session.load(Cost.class, id);
  67. //        session.close();
  68.         return cost;
  69.     }
  71. }

步骤七：测试

重新部署项目，并启动tomcat，访问资费修改功能，效果如下图，可以看出使用了OpenSessionInViewInterceptor之后，的确解决了session提前关闭引发的延迟加载问题：

图-13

5.4 完整代码

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

其中CostDaoImpl完整代码如下：

代码

HibernateUtil完整代码如下：

代码

OpenSessionInViewInterceptor完整代码如下：

代码

struts.xml完整代码如下：

代码

6 使用一对多关联映射

6.1 问题

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

6.2 方案

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

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

6.3 步骤

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

步骤一：创建账务账号实体类

创建账务账号实体类Account，代码如下：


    
    
  1. package com.tarena.entity;
  3. import java.sql.Date;
  5. public class Account {
  7.     private Integer id;
  8.     private Integer recommenderId;
  9.     private String loginName;
  10.     private String loginPassword;
  11.     private String status;
  12.     private Date createDate;
  13.     private Date pauseDate;
  14.     private Date closeDate;
  15.     private String realName;
  16.     private String idcardNo;
  17.     private Date birthdate;
  18.     private String gender;
  19.     private String occupation;
  20.     private String telephone;
  21.     private String email;
  22.     private String mailaddress;
  23.     private String zipcode;
  24.     private String qq;
  25.     private Date lastLoginTime;
  26.     private String lastLoginIp;
  27.     
  28.     public Integer getId() {
  29.         return id;
  30.     }
  32.     public void setId(Integer id) {
  33.         this.id = id;
  34.     }
  36.     public Integer getRecommenderId() {
  37.         return recommenderId;
  38.     }
  40.     public void setRecommenderId(Integer recommenderId) {
  41.         this.recommenderId = recommenderId;
  42.     }
  44.     public String getLoginName() {
  45.         return loginName;
  46.     }
  48.     public void setLoginName(String loginName) {
  49.         this.loginName = loginName;
  50.     }
  52.     public String getLoginPassword() {
  53.         return loginPassword;
  54.     }
  56.     public void setLoginPassword(String loginPassword) {
  57.         this.loginPassword = loginPassword;
  58.     }
  60.     public String getStatus() {
  61.         return status;
  62.     }
  64.     public void setStatus(String status) {
  65.         this.status = status;
  66.     }
  68.     public Date getCreateDate() {
  69.         return createDate;
  70.     }
  72.     public void setCreateDate(Date createDate) {
  73.         this.createDate = createDate;
  74.     }
  76.     public Date getPauseDate() {
  77.         return pauseDate;
  78.     }
  80.     public void setPauseDate(Date pauseDate) {
  81.         this.pauseDate = pauseDate;
  82.     }
  84.     public Date getCloseDate() {
  85.         return closeDate;
  86.     }
  88.     public void setCloseDate(Date closeDate) {
  89.         this.closeDate = closeDate;
  90.     }
  92.     public String getRealName() {
  93.         return realName;
  94.     }
  96.     public void setRealName(String realName) {
  97.         this.realName = realName;
  98.     }
  100.     public String getIdcardNo() {
  101.         return idcardNo;
  102.     }
  104.     public void setIdcardNo(String idcardNo) {
  105.         this.idcardNo = idcardNo;
  106.     }
  108.     public Date getBirthdate() {
  109.         return birthdate;
  110.     }
  112.     public void setBirthdate(Date birthdate) {
  113.         this.birthdate = birthdate;
  114.     }
  116.     public String getGender() {
  117.         return gender;
  118.     }
  120.     public void setGender(String gender) {
  121.         this.gender = gender;
  122.     }
  124.     public String getOccupation() {
  125.         return occupation;
  126.     }
  128.     public void setOccupation(String occupation) {
  129.         this.occupation = occupation;
  130.     }
  132.     public String getTelephone() {
  133.         return telephone;
  134.     }
  136.     public void setTelephone(String telephone) {
  137.         this.telephone = telephone;
  138.     }
  140.     public String getEmail() {
  141.         return email;
  142.     }
  144.     public void setEmail(String email) {
  145.         this.email = email;
  146.     }
  148.     public String getMailaddress() {
  149.         return mailaddress;
  150.     }
  152.     public void setMailaddress(String mailaddress) {
  153.         this.mailaddress = mailaddress;
  154.     }
  156.     public String getZipcode() {
  157.         return zipcode;
  158.     }
  160.     public void setZipcode(String zipcode) {
  161.         this.zipcode = zipcode;
  162.     }
  164.     public String getQq() {
  165.         return qq;
  166.     }
  168.     public void setQq(String qq) {
  169.         this.qq = qq;
  170.     }
  172.     public Date getLastLoginTime() {
  173.         return lastLoginTime;
  174.     }
  176.     public void setLastLoginTime(Date lastLoginTime) {
  177.         this.lastLoginTime = lastLoginTime;
  178.     }
  180.     public String getLastLoginIp() {
  181.         return lastLoginIp;
  182.     }
  184.     public void setLastLoginIp(String lastLoginIp) {
  185.         this.lastLoginIp = lastLoginIp;
  186.     }
  188. }

步骤二：创建账务账号映射关系文件

创建账务账号映射关系文件Account.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.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.     </class>
  51. </hibernate-mapping>

步骤三：创建业务账号实体类

创建业务账号实体类Service，代码如下：


    
    
  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;
  18.     public Integer getId() {
  19.         return id;
  20.     }
  22.     public void setId(Integer id) {
  23.         this.id = id;
  24.     }
  26.     public Integer getAccountId() {
  27.         return accountId;
  28.     }
  30.     public void setAccountId(Integer accountId) {
  31.         this.accountId = accountId;
  32.     }
  34.     public String getUnixHost() {
  35.         return unixHost;
  36.     }
  38.     public void setUnixHost(String unixHost) {
  39.         this.unixHost = unixHost;
  40.     }
  42.     public String getOsUserName() {
  43.         return osUserName;
  44.     }
  46.     public void setOsUserName(String osUserName) {
  47.         this.osUserName = osUserName;
  48.     }
  50.     public String getLoginPassword() {
  51.         return loginPassword;
  52.     }
  54.     public void setLoginPassword(String loginPassword) {
  55.         this.loginPassword = loginPassword;
  56.     }
  58.     public String getStatus() {
  59.         return status;
  60.     }
  62.     public void setStatus(String status) {
  63.         this.status = status;
  64.     }
  66.     public Date getCreateDate() {
  67.         return createDate;
  68.     }
  70.     public void setCreateDate(Date createDate) {
  71.         this.createDate = createDate;
  72.     }
  74.     public Date getPauseDate() {
  75.         return pauseDate;
  76.     }
  78.     public void setPauseDate(Date pauseDate) {
  79.         this.pauseDate = pauseDate;
  80.     }
  82.     public Date getCloseDate() {
  83.         return closeDate;
  84.     }
  86.     public void setCloseDate(Date closeDate) {
  87.         this.closeDate = closeDate;
  88.     }
  90.     public Integer getCostId() {
  91.         return costId;
  92.     }
  94.     public void setCostId(Integer costId) {
  95.         this.costId = costId;
  96.     }
  98. }

步骤四：创建业务账号映射关系文件

创建业务账号映射关系文件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.         <property name="accountId" 
  12.             type="integer" column="ACCOUNT_ID"/>
  13.         <property name="unixHost" 
  14.             type="string" column="UNIX_HOST"/>
  15.         <property name="osUserName" 
  16.             type="string" column="OS_USERNAME"/>
  17.         <property name="loginPassword" 
  18.             type="string" column="LOGIN_PASSWD"/>
  19.         <property name="status" 
  20.             type="string" column="STATUS"/>
  21.         <property name="createDate" 
  22.             type="date" column="CREATE_DATE"/>
  23.         <property name="pauseDate" 
  24.             type="date" column="PAUSE_DATE"/>
  25.         <property name="closeDate" 
  26.             type="date" column="CLOSE_DATE"/>
  27.         <property name="costId" 
  28.             type="integer" column="COST_ID"/>
  29.     </class>
  30. </hibernate-mapping>

步骤五：声明映射关系文件

在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.         <mapping resource="com/tarena/entity/Emp.hbm.xml" />
  30.         <mapping resource="com/tarena/entity/Account.hbm.xml" />
  31.         <mapping resource="com/tarena/entity/Service.hbm.xml" />        
  32.     </session-factory>
  33. </hibernate-configuration>

步骤六：在账务账号实体类中追加集合属性

在账务账号实体类Account中，追加集合属性，用于封装它对应的所有业务账号，代码如下：


    
    
  1. package com.tarena.entity;
  3. import java.sql.Date;
  4. import java.util.Set;
  6. public class Account {
  8.     private Integer id;
  9.     private Integer recommenderId;
  10.     private String loginName;
  11.     private String loginPassword;
  12.     private String status;
  13.     private Date createDate;
  14.     private Date pauseDate;
  15.     private Date closeDate;
  16.     private String realName;
  17.     private String idcardNo;
  18.     private Date birthdate;
  19.     private String gender;
  20.     private String occupation;
  21.     private String telephone;
  22.     private String email;
  23.     private String mailaddress;
  24.     private String zipcode;
  25.     private String qq;
  26.     private Date lastLoginTime;
  27.     private String lastLoginIp;
  28.     // 追加关联属性，用于存储相关的Service信息
  29.     private Set<Service> services;
  31.     public Set<Service> getServices() {
  32.         return services;
  33.     }
  35.     public void setServices(Set<Service> services) {
  36.         this.services = services;
  37.     }
  39.     public Integer getId() {
  40.         return id;
  41.     }
  43.     public void setId(Integer id) {
  44.         this.id = id;
  45.     }
  47.     public Integer getRecommenderId() {
  48.         return recommenderId;
  49.     }
  51.     public void setRecommenderId(Integer recommenderId) {
  52.         this.recommenderId = recommenderId;
  53.     }
  55.     public String getLoginName() {
  56.         return loginName;
  57.     }
  59.     public void setLoginName(String loginName) {
  60.         this.loginName = loginName;
  61.     }
  63.     public String getLoginPassword() {
  64.         return loginPassword;
  65.     }
  67.     public void setLoginPassword(String loginPassword) {
  68.         this.loginPassword = loginPassword;
  69.     }
  71.     public String getStatus() {
  72.         return status;
  73.     }
  75.     public void setStatus(String status) {
  76.         this.status = status;
  77.     }
  79.     public Date getCreateDate() {
  80.         return createDate;
  81.     }
  83.     public void setCreateDate(Date createDate) {
  84.         this.createDate = createDate;
  85.     }
  87.     public Date getPauseDate() {
  88.         return pauseDate;
  89.     }
  91.     public void setPauseDate(Date pauseDate) {
  92.         this.pauseDate = pauseDate;
  93.     }
  95.     public Date getCloseDate() {
  96.         return closeDate;
  97.     }
  99.     public void setCloseDate(Date closeDate) {
  100.         this.closeDate = closeDate;
  101.     }
  103.     public String getRealName() {
  104.         return realName;
  105.     }
  107.     public void setRealName(String realName) {
  108.         this.realName = realName;
  109.     }
  111.     public String getIdcardNo() {
  112.         return idcardNo;
  113.     }
  115.     public void setIdcardNo(String idcardNo) {
  116.         this.idcardNo = idcardNo;
  117.     }
  119.     public Date getBirthdate() {
  120.         return birthdate;
  121.     }
  123.     public void setBirthdate(Date birthdate) {
  124.         this.birthdate = birthdate;
  125.     }
  127.     public String getGender() {
  128.         return gender;
  129.     }
  131.     public void setGender(String gender) {
  132.         this.gender = gender;
  133.     }
  135.     public String getOccupation() {
  136.         return occupation;
  137.     }
  139.     public void setOccupation(String occupation) {
  140.         this.occupation = occupation;
  141.     }
  143.     public String getTelephone() {
  144.         return telephone;
  145.     }
  147.     public void setTelephone(String telephone) {
  148.         this.telephone = telephone;
  149.     }
  151.     public String getEmail() {
  152.         return email;
  153.     }
  155.     public void setEmail(String email) {
  156.         this.email = email;
  157.     }
  159.     public String getMailaddress() {
  160.         return mailaddress;
  161.     }
  163.     public void setMailaddress(String mailaddress) {
  164.         this.mailaddress = mailaddress;
  165.     }
  167.     public String getZipcode() {
  168.         return zipcode;
  169.     }
  171.     public void setZipcode(String zipcode) {
  172.         this.zipcode = zipcode;
  173.     }
  175.     public String getQq() {
  176.         return qq;
  177.     }
  179.     public void setQq(String qq) {
  180.         this.qq = qq;
  181.     }
  183.     public Date getLastLoginTime() {
  184.         return lastLoginTime;
  185.     }
  187.     public void setLastLoginTime(Date lastLoginTime) {
  188.         this.lastLoginTime = lastLoginTime;
  189.     }
  191.     public String getLastLoginIp() {
  192.         return lastLoginIp;
  193.     }
  195.     public void setLastLoginIp(String lastLoginIp) {
  196.         this.lastLoginIp = lastLoginIp;
  197.     }
  199. }

步骤七：在账务账号映射关系文件中配置集合属性

在账务账号映射关系文件Account.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.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.             <!-- 用于指定关联条件，写关联条件的外键字段 -->
  53.             <key column="ACCOUNT_ID"/>
  54.             <!-- 用于指定采用哪种关系，加载哪方数据 -->
  55.             <one-to-many class="com.tarena.entity.Service"/>
  56.         </set>
  57.     </class>
  58. </hibernate-mapping>

步骤八：创建测试类

在com.tarena.test包下创建一个测试类TestOneToMany，并在这个类中增加一个测试方法，查询出某条账务账号的数据，然后输出账务账号以及账务账号中追加的集合属性值，代码如下：


    
    
  1. package com.tarena.test;
  3. import java.util.Set;
  4. import org.hibernate.Session;
  5. import org.junit.Test;
  6. import com.tarena.entity.Account;
  7. import com.tarena.entity.Service;
  8. import com.tarena.util.HibernateUtil;
  10. public class TestOneToMany {
  11.     
  12.     @Test
  13.     public void test1() {
  14.         Session session = HibernateUtil.getSession();
  15.         Account account = 
  16.                 (Account) session.get(Account.class, 1011);
  17.         System.out.println(
  18.                 account.getIdcardNo() + " , "
  19.                 + account.getRealName() + " , " 
  20.                 + account.getBirthdate());
  21.         
  22.         System.out.println("------------------");
  23.         
  24.         Set<Service> services = account.getServices();
  25.         System.out.println(services.getClass().getName());
  26.         for (Service service : services) {
  27.             System.out.println(service.getOsUserName());
  28.         }
  30.         session.close();
  31.     }
  32.     
  33. }

步骤九：测试

执行这个方法，控制台输出结果如下图，可以看出查询账务账号之后，Hibernate自动查询出了SERVICE数据并封装到了services属性中，并且对于SERVICE的查询是采用延迟加载机制的。

图-14

6.4 完整代码

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

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

代码

账务账号映射关系文件Account.hbm.xml完整代码如下：

代码

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

代码

业务账号实体类Service.hbm.xml完整代码如下：

代码

主配置文件hibernate.cfg.xml完整代码如下：

代码

测试类TestOneToMany完整代码如下：

代码
csq123
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
hibernate二级缓存java包下载
05-21
Hibernate 是一个非常流行的开源对象关系映射（ORM）框架，它允许 Java 开发人员将数据库操作转换...通过学习这些内容，开发者可以更好地理解并掌握如何在实际项目中有效利用 Hibernate 的二级缓存功能，提升系统性能。
关于hibernate的generator标签中<param name="sequence">xxx</param>用了还是默认的hibernate_sequence的问题
tiankong150的博客
12-06 955
在hibernate5.0之后&lt;param name="sequence"&gt;你定义的序列名称&lt;/param&gt; 中的sequence要改成 sequence_name
Hibenate的单向关联映射（注解版）
qq_38777614的博客
04-05 208
一:单向1-1关联 以老夫老妻为例子来说明一下，在中国以前是以丈夫主导地位，所以我这里以t_husband作为主表，t_wife作为从表 1.1：无连接表的 （1）首先创建实体类，然后使用注解表示出来两者的关联关系 import javax.persistence.Column; import javax.persistence.Entity; import javax.persistence....
hibernate二级缓存实例
09-30
总的来说，"hibernate二级缓存实例"是一个很好的学习资源，它可以帮助我们理解二级缓存的工作机制，掌握如何在项目中配置和使用，以及注意潜在的问题和优化策略。通过实践，我们可以更好地运用这一技术，提升Java...
hibernate二级缓存 SSH
06-02
SSH（Struts2、Spring、Hibernate）是一种...通过部署到Tomcat服务器，初学者可以了解和学习如何在实际环境中配置和使用Hibernate二级缓存。这将是一个不错的实践项目，有助于理解SSH框架和Hibernate缓存的工作原理。
Hibernate二级缓存配置与分析
02-07
学习hibernate的必备，提供一个简易的流程图，方便记忆和查找
hibernate二级缓存示例源码
05-13
综上所述，通过学习`hibernate二级缓存示例源码`，我们可以了解到如何在实际项目中配置和使用Hibernate二级缓存，从而提升系统的性能。在实际应用中，应结合具体场景选择合适的缓存策略，以达到最佳的性能优化效果。
励志2024龙年筑梦前行共创未来PPT模板，适用于工作计划，工作总结
07-15
【作品名称】：励志2024龙年筑梦前行共创未来PPT模板，适用于工作计划，工作总结 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
内蒙古医科大学考研17个学院，57个专业课历年考试真题及答案汇总，备考资料题库笔记，专业课调剂信息查询.pdf
07-15
内蒙古医科大学考研17个学院，57个专业课历年考试真题及答案汇总，备考资料题库笔记，专业课调剂信息查询.pdf
齐齐哈尔医学院考研，57个专业课历年考试真题及答案汇总整理，备考资料题库视频.pdf
07-15
齐齐哈尔医学院考研，57个专业课历年考试真题及答案汇总整理，备考资料题库视频.pdf
长三角城市及各区县数据集.txt
07-15
因文件较多，数据存放网盘，txt文件内包含下载链接及提取码，永久有效。失效会第一时间进行补充。样例数据及详细介绍参见文章：https://blog.csdn.net/m0_65541699/article/details/140428710
简约工作述职PPT模板
07-15
【作品名称】：简约工作述职PPT模板 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
山东师范大学考研，55个专业课历年考试真题及答案汇总，备考资料题库笔记，专业课调剂信息查询.pdf
最新发布
07-15
山东师范大学考研，55个专业课历年考试真题及答案汇总，备考资料题库笔记，专业课调剂信息查询.pdf
数据库技术(SQLServer)习题与参考答案.doc
07-15
数据库
用友erp常用SQL语句.doc
07-15
数据库
PICMG-ATCA-3-0R3-0.pdf PICMG ATCA 以太网的标准
07-15
PICMG标准，ATCA， 别人的都太贵，官网都哦能下载的东西，没必要上积分，我上传一个给找不到的人用。
南方科技大学考研18个学院，59个专业课历年考试真题及答案汇总整理，备考资料题库视频.pdf
07-15
南方科技大学考研18个学院，59个专业课历年考试真题及答案汇总整理，备考资料题库视频.pdf
龙年贺龙年祥云红色中国风PPT模板，适用于工作总结，工作计划
07-15
【作品名称】：龙年贺龙年祥云红色中国风PPT模板，适用于工作总结，工作计划 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
Win10系统上如何安装SQl2005程序.doc
07-15
数据库

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值