二、加深理解Hibernate框架

作者: 明天你好向前奔跑 | 来源:发表于2017-06-30 18:26 被阅读0次

Hibernate_缓存&事务&批量查询概述

一、 Hibernate的持久化类

持久化类是指一个Java类和数据库建立了映射关系，那么这个类就是持久化类。

1. 持久化类的编写规则：

持久化类需要有无参的构造方法。
- 因为Hibernate的底层需要使用反射生成类的实例。
持久化类的属性需要私有,私有的属性需要提供set和get方法。
- 因为Hibernate底层要将查询到的数据进行封装。
持久化类尽量使用包装类的类型。
- 因为包装类与普通类的默认值不同。例：Integer为null,int为0.在数据库表中代表的含义包装类更准确。
持久化类需要有一个唯一标识OID与表的主键对应。
- Hibernate不允许在内存中出现两个相同OID的持久化对象。
持久化类不能使用final修饰。
- 因为Hibernate中有延迟加载机制,这个机制会产生代理对象。而这个代理对象是使用字节码的增强技术完成的，其实就是产生了一个当前类的子类对象实现的。

2. Hibernate的主键生成策略

自然主键
- 把具有业务含义的字段作为主键。
代理主键
- 把不具备业务含义的字段作为主键,与对象本身无关,该字段一般取名"ID".

img08.png

我们在映射文件中设置选择native，根据数据库底层的支持来自动生成策略。

3. 持久化对象的三种状态

瞬时态
- 没有OID，与Hibernate的Session没有任何关联
持久态
- 有OID，与Session有关联
托管态
- 有OID，与Session没有关联

瞬时态：

对象创建时,就是瞬时态。
如： User user = new User();
    user.serUname("悟空");
    user.setUpassword("123");
这里面的user都是瞬时态,没有OID，与Session没有关联。

持久态：

session.save(user);
这里的user与session产生关联，加入到了Session的缓存中,生成了持久化标识OID，是持久态

此外,get/load/find...等方法获取的对象也是持久态对象

托管态：

session.close();
System.out.println(user);
这里的user有了OID,但是与Session没有了关联,是托管态

持久化对象的三种对象之间的互相转换：

img09.png

上图：

1. 一个对象被new出来之后处于瞬时态；当对瞬时态对象执行Session对象的save()/saveOrUpdate()方法后，
该对象会被放入Session的一级缓存,进入持久态；当对持久态对象执行evict()/close()/clear()操作后,
对象进入托管态。

2. Session对象直接执行get()/load()/find()/iterate()等方法从数据库查询对象时,查询到的对象也属于
持久态；

3. 当对托管态对象执行Session的upadte()/saveOrUpadate()方法时,会转为持久态；瞬时态与托管态的对象
不在Session对象的管理范围内，因此一段时间后会被JVM回收。

持久化对象的特点：能够自动更新数据库

持久化对象能够自动更新数据库依赖于Hibernate的一级缓存。

@Test
//Hibernate持久化对象自动更新数据库
public void test() {
    //1. 获取Hibernate配置对象加载配置
    //2. 获取SessionFactory对象
    //3. 获取Session对象
    Session session = HibernateUtils.openSession();
    //4. 开启事务
    Transaction transaction = session.beginTransaction();
    //5. 执行业务逻辑
    User user = session.get(User.class, 2);//获得持久化对象
    user.setUname("外星人");

    //无需手动调用session.save(user);就可以执行数据库更新了

    //6. 提交事务
    transaction.commit();
    //7. 关闭资源
    session.close();
    System.out.println("user:"+user);
}

二、 Hibernate的一级缓存

缓存的概念：介于应用程序与永久性存储的数据源之间，作用是降低应用程序直接读写数据源的频率,从而提高应用的运行性能。缓存中的数据是数据源数据的拷贝。

1. 什么是Hibernate的一级缓存

Hibernate的一级缓存就是指Session缓存,Session缓存就是一块内存空间。
在使用Hibernate查询对象时,首先会拿该对象的OID去Session缓存中查找是否有匹配该OID值的对象。如果有就从Session缓存中取出使用,不再查询数据库。如果没有找到,就会去数据库中查询。
当从数据库查询到数据时,也会在Session缓存区放置一份该对象的数据信息,下次再查询就可以在Session缓存中直接查询到。


    @Test
    //测试一级缓存的存在
    public void test() {
        //首先获取到一个对象,再重复获取该对象,查看会打印几次sql语句
        
        //1. 获取Hibernate配置对象加载配置
        //2. 获取SessionFactory工厂对象
        //3. 获取Session对象
        Session session = HibernateUtils.openSession();
        //4. 开启事务
        Transaction transaction = session.beginTransaction();
        //5. 实现业务逻辑
        
        User user = session.get(User.class, 1);
        System.out.println(user);
        User user2 = session.get(User.class, 1);
        System.out.println(user2);
        User user3 = session.get(User.class, 1);
        System.out.println(user3);
        
        
        //6. 提交事务
        transaction.commit();
        //7. 释放资源
        session.close();
    }

结果只执行了一次查询语句,说明Hibernate只去数据库查询了一次获取到了user对象,然后将该对象的数据信息存入了Session缓存中,在这个Session没有关闭前,都可以从缓存中直接取出与该OID匹配的user对象。

img10.png

Hibernate的一级缓存(Session缓存)的特点：

当应用程序调用Session接口的save()、update()、saveOrUpdate()时，如果缓存区中没有对应的对象,Hibernate会自动的将从数据库查询到的相应的对象信息加入到Session缓存中去。
当调用Session接口的load()、get()、以及Query接口的list()方法时,会判断缓存中是否存在该对象,有则返回，不会查询数据库。如果缓存中没有要查询的对象,就去数据库中查询并放入Session缓存中。
当调用Session对象的close()，Session缓存会被清空。

2. Session缓存的快照区

Hibernate向一级缓存放入数据时,同时会将一份数据放到Hibernate快照中,当事务提交时,
同时会清理Session的一级缓存,这时Hibernate会根据OID比较一级缓存与快照中的对象是否一致,
如果不一致执行update语句。如果一致就不执行。
Hibernate的快照确保了一级缓存中的数据与数据库中数据的一致。

这也是Hibernate中持久化对象自动更新数据库的原理。

三、 Hibernate的事务控制

事务：逻辑上的一组操作,组成这组操作的各个单元,要不全都成功,要不全都失败。

1. 事务的四个特性：(ACID特性)

原子性(Automic)：表示将事务所做的操作捆绑成一个不可分割的单元。对事务所进行的数据修改等操作,要不全都成功,要不全都失败。
一致性(Consistency)：表示事务完成后,必须使所有的数据都保持一致状态。
隔离性(Isolation)：一个事务的执行不能被其他事务干扰,并发执行的事务之间不能互相干扰。
持久性(Durability)：事务一旦提交,它对数据库中数据的修改是永久性的。提交后的其他操作或者故障都不会有任何故障。

2. 事务的并发问题

脏读

 一个事务提交到了另一个事务未提交的数据。这是很严重的并发问题,必须解决。
 例如：
     用户购物,付款尚未成功提交之前，卖家就能读到用户付款的数据,误以为已经付款。

不可重复读

 一个事务读到了另一个事务已经提交后的update的数据,导致在同一个事务中的多次查询结果不一致。

 例如：
     小王在刷卡的同时,家人用他的银行卡进行了网上购物,导致小王刷卡前后两次查询的结果不一致。

虚读

 一个事务都到了另一个事务已经提交的insert的数据,导致在同一个事务中的多次查询结果不一致。

3. 事务的4个隔离级别

为了避免事务并发问题的发生,标准sql规范中定义了4个事务隔离级别,不同的隔离级别对事务的处理不同。

读未提交。(Read Uncommitted,1级),一个事务可以访问其他事务未提交的数据。
读已提交。(Read Commited,2级),一个事务在执行的过程中,可以访问其他事务成功提交的新插入的数据,也可以访问成功修改的数据。但禁止访问未提交的数据。该隔离级别可以有效的防止脏读。
可重复读。(Repeatable Read,4级)，一个事务在执行的过程中,可以访问其他事务成功提交的新插入的数据,但不可以访问成功修改的数据。此隔离级别可以有效的防止脏读与不可重复读。
序列化。(Serializable,8级)，提供严格的事务隔离,事务只能序列化,一个一个的执行，不能并发执行。此隔离级别可以防止脏读，不可重复读以及虚读。

隔离级别越高，安全性越高,性能越低。

mysql的隔离级别默认是可重复读(Repeatable Read)
oracle的隔离级别默认是可重复读(Read Committed)

4. Hibernate的事务管理

<!-- 
    设置隔离级别:
        hibernate.connection.isolation = 4
        1-Read uncommitted isolation
        2-Read committed isolation
        4-Repeatable read isolation
        8-Serializable isolation 
-->
<property name="hibernate.connection.isolation">4</property>

在使用Hibernate进行事务管理时,service层与dao层要保证Session对象的一致,可以采用三种方式确保Session
对象的一致: Session对象传递,使用ThreadLocal存储与当前线程绑定的Session对象,直接使用Hibernate封装好的getCurrentSession()方法。


在这里,前两种方式就省略了,如果有想了解的,可以翻看我以前写的Connection部分JDBCUtils工具类的封装。

直接使用Hibernate封装好的管理Session的方式

在Hibernate的配置文件中,hibernate.current_session_context_class属性用于指定Session的管理方式：

thread ： Session对象的生命周期与当前线程绑定
jta ： Session对象的生命周期与JTA事务绑定
managed ： Hibernate委托程序来管理Session的生命周期

在hibernate.cfg.xml进行如下配置：

<property name="hibernate.current_session_context_class">thread</property>

配置后,Hibernate提供了getCurrentThread()方法来创建一个与当前线程绑定的Session对象。

在HibernateUtils工具类中添加getCurrentSession方法：

// 获得当前线程中的绑定的Session
// 注意：必须配置
// return
public static Session getCurrentSession() {
    return sf.getCurrentSession();
}

需要注意的是：必须先在配置中进行配置,而且使用后无需手动关闭Session对象,事务提交后会自动关闭Session对象


    Sercice层：

    //用户转账的业务
    public void transfer(String sender, String receiver, String amount) throws Exception {
        Transaction transaction = null;
        try {
            //调用dao层
            TransferDAO dao = new TransferDAOImpl();
            
            //由于这里操作了两条sql语句因此应该开启事务
            Session session = HibernateUtils.getCurrentSession();
            transaction = session.beginTransaction();
            
            //转出
            dao.out(sender,amount);
            //转入
            dao.in(receiver,amount);
            
            //没有异常就提交
            transaction.commit();
        } catch (Exception e) {
            //回滚事务
            transaction.rollback();
            e.printStackTrace();
            throw e;
        }
    }


    dao 层：

    // 转出
    public void out(String sender, String amount) throws SQLException {
        Session session = HibernateUtils.getCurrentSession();
        // 转出
        User user = session.get(User.class, 1);
        double amount2 = Double.parseDouble(amount);
        user.setAcount(user.getAcount() - amount2);
    }

    @Override
    // 转入
    public void in(String receiver, String amount) throws SQLException {
        Session session = HibernateUtils.getCurrentSession();
        // 转入
        User user = session.get(User.class, 2);
        double amount2 = Double.parseDouble(amount);
        user.setAcount(user.getAcount() + amount2);
    }

四、 Hibernate的批量查询(概述)

1. HQL查询 : Hibernate Query Language

HQL : Hibernate Query Language。Hibernate的独家查询语言,属于面向对象的查询语言。

适用于：多表查询,但不是很复杂时使用。

setXxx : 如果HQL语句中有参数,根据参数的不同类型设置参数的值。
setParameter ：上面方法的万金油版本。可以根据参数自动选择参数的类型设置。
uniqueResult ：结果只有一条记录的时候使用,用于获取唯一的结果。
list ：获取多条记录存储在List集合中。
setFirstResult ：分页查询设置第一条记录的位置。表示从第几条数据查询,默认从0开始。
setMaxResult ：分页查询设置结果集的最大记录数。即每页显示的最大数据数量。

使用HQL的步骤：

获取Session对象,开启事务
编写HQL语句
使用Session对象获取查询对象Query
如果HQL语句包含参数,使用query.setXxx()设置参数。
- 这里有一个万金油的设置参数的方法. query.setParameter()；
执行HQL查询语句

HQL查询测试：


    /**
     * Hibernate的HQL语句练习
     */
    public class HibernateTest {
    
        @Test
        // HQL基本查询
        public void test() {
            // 1. 获取Session对象
            Session session = HibernateUtils.getCurrentSession();
            // 2.开启事务
            Transaction transaction = session.beginTransaction();
            // -----------------------------------------
            // 3. 业务逻辑:HQL的基本查询
    
            // 3.1 创建HQL查询语句。HQL语句格式为：select * from 全类名.
            // HQL语句格式为：select * from 全类名.
            // 在查询所有字段时可以省略select *
            // String hql = "select * from com.itdream.domain.Customer";
            String hql = "from Customer";
            // 3.2 创建查询对象Query
            Query query = session.createQuery(hql);
            // 3.3 执行查询
            List<Customer> list = query.list();
            // 如果确定结果为一条结果,可以使用uniqeResult()
            // Customer customer = (Customer) query.uniqueResult();
    
            System.out.println(list);
    
            // -----------------------------------------
            // 4.提交事务
            transaction.commit();
            // getCurrentSession无需手动关闭
        }
    
        @Test
        // HQL条件查询:问号占位符
        public void test2() {
            // 1. 获取Session对象
            Session session = HibernateUtils.getCurrentSession();
            // 2.开启事务
            Transaction transaction = session.beginTransaction();
            // -----------------------------------------
            // 3. 业务逻辑:HQL条件查询：问号占位符
            // 3.1 编写HQL查询语句,注意：HQL语句中出现的是类中的属性而不是表中的字段
            String hql = "from Customer where cid = ?";
            //3.2 获取HQL的查询对象Query
            Query query = session.createQuery(hql);
            //设置问号占位符处的参数.Hibernate的问号占位付默认从0开始
            //query.setInteger(0, 2);
            //万金油的设置参数方法
            query.setParameter(0, 2);
            //3.3 执行查询
            Customer customer = (Customer) query.uniqueResult();
            
            System.out.println(customer);
            // -----------------------------------------
            // 4.提交事务
            transaction.commit();
            // getCurrentSession无需手动关闭
        }
        
        @Test
        // HQL条件查询:命名占位符
        public void test3() {
            // 1. 获取Session对象
            Session session = HibernateUtils.getCurrentSession();
            // 2.开启事务
            Transaction transaction = session.beginTransaction();
            // -----------------------------------------
            // 3. 业务逻辑:HQL条件查询：命名占位符(冒号:+命名)
            // 3.1 编写HQL查询语句,注意：HQL语句中出现的是类中的属性而不是表中的字段
            String hql = "from Customer where cid = :cid";
            //3.2 获取HQL的查询对象Query
            Query query = session.createQuery(hql);
            //设置问号占位符处的参数.Hibernate的问号占位付默认从0开始
            //万金油的设置参数方法
            query.setParameter("cid", 2);
            //3.3 执行查询
            Customer customer = (Customer) query.uniqueResult();
            
            System.out.println(customer);
            // -----------------------------------------
            // 4.提交事务
            transaction.commit();
            // getCurrentSession无需手动关闭
        }
        
        
        @Test
        // HQL分页查询
        public void test4() {
            // 1. 获取Session对象
            Session session = HibernateUtils.getCurrentSession();
            // 2.开启事务
            Transaction transaction = session.beginTransaction();
            // -----------------------------------------
            // 3. 业务逻辑:HQL条件查询：命名占位符(冒号:+命名)
            // 3.1 编写HQL查询语句,注意：HQL语句中出现的是类中的属性而不是表中的字段
            String hql = "from Customer";
            //3.2 获取查询对象Query
            Query query = session.createQuery(hql);
            
            //3.3 设置分页的参数
            query.setFirstResult(4);//从第(4+1)条数据开始,Hibernate默认从0开始
            query.setMaxResults(2);//每页显示两条数据
            
            //3.4执行hql语句
            List<Customer> list = query.list();
            System.out.println(list);
            // -----------------------------------------
            // 4.提交事务
            transaction.commit();
            // getCurrentSession无需手动关闭
        }
    }

分页查询结果：

img11.png

2. Critiria查询

Criteria查询是Hibernate的核心查询对象。它是完全面向对象的无语句查询。在Criteria查询方式中,是绝对不会出现sql语句的。Criteria查询又称为QBC查询(Query By Criteria)。

适用于单表的条件查询。

常用API

//获取Criteria查询对象
Criteria criteria = session.createCriteria(Customer.class); //传入的参数是持久化类对象

//设置查询条件
// 参数1：持久化类中的属性 。 参数2：对应的值
Criterion eq = Restrictions.eq("cid", 1);

//设置分页参数
criteria.setFirstResult(4);//这里的4代表的是索引,第五条记录开始
criteria.setMaxResults(2);//每页显示2条数据

//查询总记录数
criteria.setProjection(Projections.rowCount());

//执行查询
List<Customer> list = criteria.list();
Customer customer = (Customer) criteria.uniqueResult();

Criteria查询的步骤：

获取Session对象,开启事务
获取查询对象Criteria
如果有限制条件使用Restrictions添加限制条件
如果是分页查询使用criteria.setFirstResult或setMaxResult方法设置分页参数
将Restrictions设置的限制条件添加到查询对象Criteria中
执行查询

Criteria查询测试：


    @Test
    // Criteria基本查询 ：查询所有数据
    public void test() {
        // 1. 获取Session对象
        Session session = HibernateUtils.getCurrentSession();
        // 2.开启事务
        Transaction transaction = session.beginTransaction();
        // -----------------------------------------
        // 3. 业务逻辑:Criteria的基本查询
        // 3.1 获取Criteria查询对象
        Criteria criteria = session.createCriteria(Customer.class);
        // 3.2 执行查询
        List<Customer> list = criteria.list();
        // Customer customer = (Customer) criteria.uniqueResult();

        System.out.println(list);
        // -----------------------------------------
        // 4.提交事务
        transaction.commit();
        // getCurrentSession无需手动关闭
    }

    @Test
    // Criteria条查询
    public void test2() {
        // 1. 获取Session对象
        Session session = HibernateUtils.getCurrentSession();
        // 2.开启事务
        Transaction transaction = session.beginTransaction();
        // -----------------------------------------
        // 3. 业务逻辑:Criteria的条件查询
        // 3.1 获取Criteria查询对象
        Criteria criteria = session.createCriteria(Customer.class);
        // 3.2 设置查询限制条件
        // 参数1：持久化类中的属性 。 参数2：对应的值
        Criterion eq = Restrictions.eq("cid", 1);
        Criterion eq2 = Restrictions.eq("cname", "唐嫣");

        // 添加限制条件到查询对象中(可以添加多个限制条件)
        criteria.add(eq);
        criteria.add(eq2);

        // 3.3 执行查询操作
        // List<Customer> list = criteria.list();
        Customer customer = (Customer) criteria.uniqueResult();
        System.out.println(customer);
        // -----------------------------------------
        // 4.提交事务
        transaction.commit();
        // getCurrentSession无需手动关闭
    }

    @Test
    // Criteria分页查询
    public void test3() {
        // 1. 获取Session对象
        Session session = HibernateUtils.getCurrentSession();
        // 2.开启事务
        Transaction transaction = session.beginTransaction();
        // -----------------------------------------
        // 3. 业务逻辑:Criteria的分页查询
        // 3.1 获取Criteria查询对象
        Criteria criteria = session.createCriteria(Customer.class);
        //3.2 设置分页参数
        criteria.setFirstResult(4);//这里的4代表的是索引,第五条记录开始
        criteria.setMaxResults(2);//每页显示2条数据
        //3.3 执行查询
        List<Customer> list = criteria.list();
        System.out.println(list);
        // -----------------------------------------
        // 4.提交事务
        transaction.commit();
        // getCurrentSession无需手动关闭
    }


    @Test
    // Criteria查询总记录数
    public void test4() {
        // 1. 获取Session对象
        Session session = HibernateUtils.getCurrentSession();
        // 2.开启事务
        Transaction transaction = session.beginTransaction();
        // -----------------------------------------
        // 3. 业务逻辑:Criteria的分页查询
        // 3.1 获取Criteria查询对象
        Criteria criteria = session.createCriteria(Customer.class);
        // 3.2 获取总记录数
        criteria.setProjection(Projections.rowCount());
        //3.3 执行查询操作获取总记录数
        Long rows = (Long) criteria.uniqueResult();
        
        System.out.println(rows);
        // -----------------------------------------
        // 4.提交事务
        transaction.commit();
        // getCurrentSession无需手动关闭
    }

附常用Restrictions的静态方法：

常见的Restrictions的静态方法
    方法                  说明
    Restrictions.eq         ＝
    Restrictions.allEq      利用Map来进行多个等于的限制
    Restrictions.gt         ＞(greater than)
    Restrictions.ge         ＞＝(greater than or equal)
    Restrictions.lt         ＜ (less than)
    Restrictions.le         ＜＝(less than or equal)
    Restrictions.between    BETWEEN
    Restrictions.like       LIKE
    Restrictions.in         in
    Restrictions.and        and
    Restrictions.or         or
    Restrictions.sqlRestriction 用SQL限定查询

3. SQLQuery查询(原生的SQL语句查询)

适用于复杂的多表业务查询

常用API：

//创建SQLQuery查询对象
SQLQuery query = session.createSQLQuery(sql);

//指定将结果集封装到某个对象中
query.addEntity(Customer.class);

//执行sql语句
List<Customer> list = query.list();
Customer customer = (Long)query.uniqueResult();

SQLQuery查询测试：


    @Test
    // SQLQuery基本查询 ：查询所有数据(返回Object数组的List)
    public void test() {
        // 1. 获取Session对象
        Session session = HibernateUtils.getCurrentSession();
        // 2.开启事务
        Transaction transaction = session.beginTransaction();
        // -----------------------------------------

        // 3. 业务逻辑:SQLQuery的基本查询：查询所有数据
        // 3.1 编写sql语句
        String sql = "select * from customer";

        // 3.2 获取SQLQuery查询对象
        SQLQuery query = session.createSQLQuery(sql);

        // 3.3 执行查询,返回的结果是一个List集合
        // 每条记录的查询结果作为Object数组的元素。将所有的记录Object数组存入List集合
        List<Object[]> list = query.list();

        for (Object[] objects : list) {
            System.out.println(Arrays.toString(objects));
        }

        // -----------------------------------------
        // 4.提交事务
        transaction.commit();
        // getCurrentSession无需手动关闭
    }

img12.png


    @Test
    // SQLQuery基本查询 ：查询所有数据(返回Customer的List)
    public void test2() {
        // 1. 获取Session对象
        Session session = HibernateUtils.getCurrentSession();
        // 2.开启事务
        Transaction transaction = session.beginTransaction();
        // -----------------------------------------

        // 3. 业务逻辑:SQLQuery的基本查询：查询所有数据
        // 3.1 编写sql语句
        String sql = "select * from customer";
        // 3.2 创建SQLQuery查询对象
        SQLQuery query = session.createSQLQuery(sql);
        // 3.3 指定将结果集封装到某个对象中
        query.addEntity(Customer.class);
        // 3.4 执行sql语句
        List<Customer> list = query.list();

        System.out.println(list);

        // -----------------------------------------
        // 4.提交事务
        transaction.commit();
        // getCurrentSession无需手动关闭
    }

img13.png


    @Test
    // SQLQuery条件查询
    public void test3() {
        // 1. 获取Session对象
        Session session = HibernateUtils.getCurrentSession();
        // 2.开启事务
        Transaction transaction = session.beginTransaction();
        // -----------------------------------------

        // 3. 业务逻辑:SQLQuery的基本查询：查询所有数据
        // 3.1 编写sql语句
        String sql = "select * from customer where cid = ?";
        // 3.2 创建SQLQuery查询对象
        SQLQuery query = session.createSQLQuery(sql);
        // 设置参数的值。参数1：第几个数据。参数2：对应的值
        query.setParameter(0, 1);
        // 3.3 指定将结果集封装到某个对象中
        query.addEntity(Customer.class);
        // 3.4 执行sql语句
        Customer customer = (Customer) query.uniqueResult();

        System.out.println(customer);

        // -----------------------------------------
        // 4.提交事务
        transaction.commit();
        // getCurrentSession无需手动关闭
    }


    @Test
    // SQLQuery分页查询：方式1：传统sql语句
    public void test4() {
        // 1. 获取Session对象
        Session session = HibernateUtils.getCurrentSession();
        // 2.开启事务
        Transaction transaction = session.beginTransaction();
        // -----------------------------------------

        // 3. 业务逻辑:SQLQuery的基本查询：查询所有数据
        // 3.1 编写sql语句
        String sql = "select * from customer limit ?,?";
        // 3.2 创建SQLQuery查询对象
        SQLQuery query = session.createSQLQuery(sql);

        // 设置分页查询的参数
        query.setParameter(0, 4);
        query.setParameter(1, 2);

        // 3.3 指定将结果集封装到某个对象中
        query.addEntity(Customer.class);
        // 3.4 执行sql语句
        List<Customer> list = query.list();

        System.out.println(list);

        // -----------------------------------------
        // 4.提交事务
        transaction.commit();
        // getCurrentSession无需手动关闭
    }


    @Test
    // SQLQuery分页查询:方式2:setFirstResult()方法
    public void test5() {
        // 1. 获取Session对象
        Session session = HibernateUtils.getCurrentSession();
        // 2.开启事务
        Transaction transaction = session.beginTransaction();
        // -----------------------------------------

        // 3. 业务逻辑:SQLQuery的基本查询：查询所有数据
        // 3.1 编写sql语句
        String sql = "select * from customer";
        // 3.2 创建SQLQuery查询对象
        SQLQuery query = session.createSQLQuery(sql);

        // 设置分页查询的参数
        query.setFirstResult(4);// 设置从第几个数据开始查询,默认从0开始
        query.setMaxResults(2);// 设置每页显示的数据条数

        // 3.3 指定将结果集封装到某个对象中
        query.addEntity(Customer.class);
        // 3.4 执行sql语句
        List<Customer> list = query.list();

        System.out.println(list);

        // -----------------------------------------
        // 4.提交事务
        transaction.commit();
        // getCurrentSession无需手动关闭
    }

4. 简单的CRM查询案例

步骤：

1. 搭建工程环境

1. 创建工程,导入jar包,拷贝页面等文件

2. 创建数据库表cst_customer

3. 创建持久化类Customer

4. 创建持久化类和数据库表的映射文件Customer.hbm.xml

5. 创建Hibernate的核心配置文件hibernate.cfg.xml

6. 完成核心配置文件中c3p0的配置,创建log4j.properties配置文件

7. 编写工具类HibernateUtils，环境搭建完毕

1.1.导入jar包

包含有：

数据库驱动
Hibernate必需包下的所有jar包
Hibernate的c3p0中的3个jar包
日志集成slf4j和log4j的3个jar包
jstl.jar与standard.jar的jstl标签库jar包

img14.png

1.2 创建数据库表


    CREATE DATABASE hibernate_crm;
    
    USE hibernate_crm;
    
    CREATE TABLE `cst_customer` (
      `cust_id` BIGINT(32) NOT NULL AUTO_INCREMENT COMMENT '客户编号(主键)',
      `cust_name` VARCHAR(32) NOT NULL COMMENT '客户名称(公司名称)',
      `cust_user_id` BIGINT(32) DEFAULT NULL COMMENT '负责人id',
      `cust_create_id` BIGINT(32) DEFAULT NULL COMMENT '创建人id',
      `cust_source` VARCHAR(32) DEFAULT NULL COMMENT '客户信息来源',
      `cust_industry` VARCHAR(32) DEFAULT NULL COMMENT '客户所属行业',
      `cust_level` VARCHAR(32) DEFAULT NULL COMMENT '客户级别',
      `cust_linkman` VARCHAR(64) DEFAULT NULL COMMENT '联系人',
      `cust_phone` VARCHAR(64) DEFAULT NULL COMMENT '固定电话',
      `cust_mobile` VARCHAR(16) DEFAULT NULL COMMENT '移动电话',
      PRIMARY KEY (`cust_id`)
    ) ENGINE=INNODB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;
    
    INSERT INTO cst_customer(cust_id,cust_name) 
    VALUES(NULL,'唐嫣'),(NULL,'钟汉良'),(NULL,'林心如'),
    (NULL,'霍建华'),(NULL,'杨幂'),(NULL,'刘恺威'),
    (NULL,'高圆圆'),(NULL,'赵又廷');

1.3 创建持久化类

与数据库表基本保持一致，按照持久化类的编写规则编写。

img15.png

1.4 创建持久化类和数据库表的映射文件Customer.hbm.xml

步骤：

在持久化类的同级目录下,创建xml文件,取名类名.hbm.xml。这里名字为:Customer.hbm.xml
导入DTD约束。从jar包中可以找到DTD的约束描述,copy过来
创建持久化类与数据库表的映射
创建持久化类中标识符OID与数据库表的主键的映射
创建类中普通属性与数据库表的字段的映射


    <?xml version="1.0" encoding="UTF-8"?>
    
    <!-- 建立持久化类Customer与数据库表customer的映射关系的配置文件 -->
    
    <!-- 引入DTD约束 -->
    <!DOCTYPE hibernate-mapping PUBLIC 
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
        
     <hibernate-mapping>
        <!-- 建立持久化类与表的映射关系 -->
        <class name="com.itdream.domain.Customer" table="cst_customer">
            <!-- 配置持久化类OID与表的主键的映射 -->
            <id name="cust_id" column="cust_id">
                <!-- 配置主键生成策略 -->
                <generator class="native"></generator>
            </id>
            
            <!-- 配置普通字段的映射关系 -->    
            <property name="cust_name" column="cust_name"></property>
        </class>
     </hibernate-mapping>

1.5 创建Hibernate的核心配置文件hibernate.cfg.xml

步骤:

在src目录下创建文件名为hibernate.cfg.xml的配置文件
导入DTD约束
配置Hibernate连接数据库的基本配置
配置Session与当前线程绑定
配置Hibernate基本属性，包括：
1. Hibernate方言,根据这个配置Hiberante使用对应的sql语句,实现了跨数据库
2. 显示SQL语句
3. 格式化SQL语句
4. 配置Hibernate对应数据库表的生成方式hbm2ddl
5. 配置数据库的隔离级别
6. c3p0连接池的配置
加载映射文件


    <?xml version="1.0" encoding="UTF-8"?>
    
    <!-- 导入Hibernate核心配置文件的DTD约束 -->
    <!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
    
    <!-- 配置Hibernate的核心配置文件 -->
    <hibernate-configuration>
        <session-factory>
            <!--1. Hibernate连接数据库的基本配置 -->
            <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
            <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate_crm</property>
            <property name="hibernate.connection.username">root</property>
            <property name="hibernate.connection.password">root</property>
    
            <!--2. Session与本地线程绑定 -->
            <property name="hibernate.current_session_context_class">thread</property>
    
            <!--3. Hibernate的基本属性配置 -->
            <!-- Hibernate的方言配置,Hibernate根据这个配置生成对应的SQL语句,从而实现跨数据库 -->
            <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
    
            <!-- 显示SQL语句 -->
            <property name="hibernate.show_sql">true</property>
            <!-- 格式化SQL语句 -->
            <property name="hibernate.format_sql">true</property>
            <!-- Hibernate对数据库表的生成方式,hbm2ddl -->
            <property name="hibernate.hbm2ddl.auto">none</property>
    
            <!-- 配置隔离级别 :4 读可重复(Repeatable read) -->
            <property name="hibernate.connection.isolation">4</property>
    
            <!-- C3P0连接池的配置 -->
            <property name="hibernate.connection.provider_class">org.hibernate.c3p0.internal.C3P0ConnectionProvider</property>
            <!-- 最小连接 -->
            <property name="hibernate.c3p0.min_size">5</property>
            <!-- 最大连接数 -->
            <property name="hibernate.c3p0.max_size">20</property>
            <!-- 连接超时时长 -->
            <property name="hibernate.c3p0.timeout">120</property>
            <!-- 每120秒检查空闲连接 -->
            <property name="hibernate.c3p0.idle_test_period">120</property>
            <!-- 最大statments数量 -->
            <property name="hibernate.c3p0.max_statements">120</property>
            <!-- 连接用完后，每次增加的连接数 -->
            <property name="hibernate.c3p0.acquire_increment">2</property>
            <!-- 每次都验证连接是否可用 -->
            <property name="hibernate.c3p0.validate">false</property>
    
            <!--4. 加载映射文件 -->
            <mapping resource="com/itdream/domain/Customer.hbm.xml" />
        </session-factory>
    </hibernate-configuration>

1.6 完成核心配置文件中c3p0的配置,创建log4j.properties配置文件

1. c3p0的配置见上一条1.5中核心配置文件.

2. log4j日志集成的配置文件log4j.properties

在src目录下创建log4j.properties：


    ### direct log messages to stdout ###
    log4j.appender.stdout=org.apache.log4j.ConsoleAppender
    log4j.appender.stdout.Target=System.err
    log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
    log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
    
    ### direct messages to file mylog.log ###
    log4j.appender.file=org.apache.log4j.FileAppender
    log4j.appender.file.File=d:\\mylog.log
    log4j.appender.file.layout=org.apache.log4j.PatternLayout
    log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
    
    ### set log levels - for more verbose logging change 'info' to 'debug' ###
    log4j.rootLogger=info, stdout,file

1.7 编写工具类HibernateUtils


    /**
     * 初始化SessionFactory,提供Session对象的Hibernate工具类
     */
    public class HibernateUtils {
    
        private static SessionFactory sf = null;
    
        static {
            // 创建Hibernate配置对象,加载src目录下默认的hibernate.cfg.xml配置文件
            Configuration configuration = new Configuration().configure();
            // 创建SessionFactory工厂对象
            sf = configuration.buildSessionFactory();
    
            // 程序关闭销毁SessionFactory对象
            Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {
    
                @Override
                public void run() {
                    System.out.println("程序关闭销毁SessionFactory对象");
                    sf.close();
                }
            }));
        }
    
        /**
         * 获取Session对象的方法
         */
        public static Session openSession() {
            return sf.openSession();
        }
    
        /**
         * 获取与当前线程绑定的Session对象
         */
        public static Session getCurrentSession() {
            return sf.getCurrentSession();
        }
    }

2. 代码实现,使用Hibernate的查询语句查询所有Customer

2.1 mennu.jsp修改a标签跳转

    <TD class=menuSmall><A class=style2 href="customer?method=list"target=main>－ 客户列表</A></TD>

2.2 创建Servlet,映射url-pattern为servlet


    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {

        // 获取传递过来的method参数
        String method = request.getParameter("method");

        if ("list".equals(method)) { // 如果是list,就查询所有Customer客户

            try {
                // 调用service层
                CustomerService service = new CustomerServiceImpl();
                List<Customer> list = service.findAllCustomers();

                // 存入request域
                request.setAttribute("list", list);
                System.out.println(list);
                
                // 转发
                request.getRequestDispatcher("/jsp/customer/list.jsp").forward(request, response);;
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

    }

2.3 CustomerService层,调用dao层查询所有Customer


    @Override
    public List<Customer> findAllCustomers() throws SQLException {
        //调用dao层查询所有Customer用户
        CustomerDAO dao = new CustomerDAOImpl();
        return dao.findAllCustomers();
    }

2.4 CustomerDAO层,查询所有Customer返回

使用Criteria与HQL两种查询方式,单表查询推荐使用Criteria查询


    @Override
    // 方式1：显示所有Customer的方法:Criteria查询(单表查询简单)
    public List<Customer> findAllCustomers() throws SQLException {
        // 1. 获取配置对象加载配置文件
        // 2. 获取SessionFactory对象
        // 3. 获取Session对象
        Session session = HibernateUtils.getCurrentSession();
        // 4. 开启事务
        Transaction transaction = session.beginTransaction();
        // 5. 业务逻辑 ：查询所有Customer对象,单表查询使用Criteria较为简单
        // 5.1 创建Criteria查询对象
        Criteria criteria = session.createCriteria(Customer.class);
        // 5.2 如果有条件就添加限制条件Restrictions,然后添加到查询对象中
        // 5.3 执行查询
        List<Customer> list = criteria.list();

        // 6. 提交事务
        transaction.commit();
        // 7. getCurrentSession()无需手动关闭Session对象
        return list;
    }
     

    /*@Override
    // 方式2：显示所有Customer的方法:HQL查询(常用于不是很复杂的多表查询)
    public List<Customer> findAllCustomers() throws SQLException {

        // 1. 获取配置对象加载配置文件
        // 2. 获取SessionFactory对象
        // 3. 获取Session对象
        Session session = HibernateUtils.getCurrentSession();
        // 4. 开启事务
        Transaction transaction = session.beginTransaction();
        // 5. 业务逻辑 ： 查询所有Customer对象,单表查询使用Criteria较为简单
        // 5.1  编写HQL语句,HQL语句中出现的都是持久化类中的属性,而不是数据库表中的字段
        String hql = "from Customer";
        // 5.2 创建HQL的Query对象
        Query query = session.createQuery(hql);
        // 5.3  如果hql语句中有参数使用setParameter()设置参数
        // 5.4  执行hql语句
        List<Customer> list = query.list();
        // 6. 提交事务
        transaction.commit();
        // 7. getCurrentSession()无需手动关闭Session对象
        return list;
    }*/

2.5 查询结果，list页面解析(这里省略)

查询结果图：

img16.png