Hibernate入门

1.Hibernate是什么

Hibernate是一款优秀的持久化ORM框架，解决持久化操作，使得程序员可以从编写繁复的JDBC工作中解放出来，专注于业务，提高程序员开发效率。并且具有可靠的移植性，降低了系统耦合度。

2.Hibernate入门案例

源码地址：https://github.com/zhongyushi-git/hibernate-collection.git。下载代码后，示例代码在hibernate-maven文件夹下。 

1）新建一个普通的maven项目

2）导入依赖，本文采用hibernate5版本进行说明

 <dependencies>
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-agroal</artifactId>
            <version>5.4.30.Final</version>
            <type>pom</type>
        </dependency>
        <!--mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.18</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

3）配置hibernate.cfg.xml

新建一个资源目录resources，在下面新建hibernate.cfg.xml，内容如下

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD//EN"
        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
    <session-factory>
        <property name="connection.url">jdbc:mysql://localhost:3306/hibernate</property>
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="connection.username">root</property>
        <property name="connection.password">zys123456</property>
        <!-- 方言-->
        <property name="dialect">org.hibernate.dialect.MySQL5Dialect</property>

　　　　 <!-- 指定数据库的生成方式，update是当表存在时插入数据，表不存在时先创建表再插入数据-->
　　　　 <property name="hibernate.hbm2ddl.auto">update</property>

</session-factory> </hibernate-configuration>

上述<session-factory>中指定了数据库的基本信息，包括url，driverClass，用户名及密码等。

4）新建实体类User

package com.zxh.entity;

import lombok.Data;

@Data
public class User {
    private Integer id;

    private String name;

    private String password;
}

5）创建数据库及表

create databse hebarnate;

6）在User类同级目录下新建User.hbm.xml用于进行映射

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate mapping DTD//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<!--数据库映射，package指定了实体类所在的包名-->
<hibernate-mapping package="com.zxh.entity">
    <!--表映射，name表示对象名，table表示表名-->
    <class name="User" table="t_user">
        <!--主键，native是自增，assigned是不指定，自定义-->
       <id name="id">
           <generator class="native"></generator>
       </id>
        <!--其他属性映射,name对象的属性，column表示数据库表的字段名称，当name和column时可省略-->
        <property name="name" column="name"></property>
        <property name="password"></property>
    </class>
</hibernate-mapping>

7）在hibernate.cfg.xml指定orm映射，指定hbm.xml位置

<!-- orm映射文件-->
<mapping resource="com/zxh/entity/User.hbm.xml"/>

8）在pom.xml中读取配置文件

<build>
        <!--读取配置文件-->
        <resources>
            <resource>
                <directory>src/main/resources</directory>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering></resource>
        </resources>
    </build>

9）添加测试类并进行测试

 @Test
    public void test1() {
        //初始化注册服务对象
        final StandardServiceRegistry registry = new StandardServiceRegistryBuilder()
                .configure()//默认加载hibernate.cfg .xmL配置文件，如果配置文件名称被修改，configure("修改的名字")
                .build();
        //从元信息获取session工厂
        SessionFactory sessionFactory = new MetadataSources(registry)
                .buildMetadata()
                .buildSessionFactory();
        //从工厂创建session连接
        Session session = sessionFactory.openSession();
        //开启事务
        Transaction tx = session.beginTransaction();
        //创建实例
        User user = new User();
        user.setName("zhangsan");
        user.setPassword("123");
        session.save(user);
        //提交事务
        tx.commit();
        //关闭
        session.close();

    }

执行测试方法成功后查看数据库，发现自动创建了表t_user并插入了一条数据。上述示例是添加数据，另外还有修改、删除和查询。

10）修改数据

添加一个测试方法，来修改上面添加的信息

@Test
    public void test2(){
        //初始化注册服务对象
        final StandardServiceRegistry registry = new StandardServiceRegistryBuilder()
                .configure()//默认加载hibernate.cfg .xmL配置文件，如果配置文件名称被修改，configure("修改的名字")
                .build();
        //从元信息获取session工厂
        SessionFactory sessionFactory = new MetadataSources(registry)
                .buildMetadata()
                .buildSessionFactory();
        //从工厂创建session连接
        Session session = sessionFactory.openSession();
        //获取事务
        Transaction tx = session.beginTransaction();
        //创建实例
        User user = new User();
        user.setId(1);
        user.setName("王海红");
        user.setPassword("9999");
        //提交事务
        session.update(user);
        tx.commit();
        //关闭session
        session.close();
    }

由代码可以看出，修改数据和添加数据是类型的，只是使用的方法不一样。

11）查询数据

添加一个测试方法，来查询上面修改的信息

   @Test
    public void test3(){
        //初始化注册服务对象
        final StandardServiceRegistry registry = new StandardServiceRegistryBuilder()
                .configure()//默认加载hibernate.cfg .xmL配置文件，如果配置文件名称被修改，configure("修改的名字")
                .build();
        //从元信息获取session工厂
        SessionFactory sessionFactory = new MetadataSources(registry)
                .buildMetadata()
                .buildSessionFactory();
        //从工厂创建session连接
        Session session = sessionFactory.openSession();

        User user = session.get(User.class, 1);
        System.out.println(user);

        //关闭session
        session.close();
    }

这里查询是根据主键查询的单挑数据。在 Hibernate 中，除了使用 get() 方法加载数据以外，还可以使用 load() 方法加载数据，它们都能将数据从数据库中取出。两者的区别是使用 get() 方法加载数据时，如果指定的记录不存在，则返回 null；而使用 load() 方法加载数据时，如果指定的记录不存在，则会报出 ObjectNotFoundException 异常。

12）删除数据

添加一个测试方法，来删除上面修改的信息

 @Test
    public void test4(){
        //初始化注册服务对象
        final StandardServiceRegistry registry = new StandardServiceRegistryBuilder()
                .configure()//默认加载hibernate.cfg .xmL配置文件，如果配置文件名称被修改，configure("修改的名字")
                .build();
        //从元信息获取session工厂
        SessionFactory sessionFactory = new MetadataSources(registry)
                .buildMetadata()
                .buildSessionFactory();
        //从工厂创建session连接
        Session session = sessionFactory.openSession();
        //获取事务
        Transaction tx = session.beginTransaction();
        //创建实例进行查询
        User user = session.get(User.class, 1);
        //删除
        session.delete(user);
        //提交事务
        tx.commit();
        //关闭session
        session.close();
    }

由代码可以看出，在删除时先根据条件去查询，查询后根据结果进行删除。

3.hibernate.cfg.xml介绍

3.1Hibernate配置文件

Hibernate中配置主要分为两种：

1）一种包含了Hibernate与数据库的基本连接信息，在Hibernate工作的初始阶段，这些信息被先后加载到Configuration和SessionFactory实例。（如hibernate.cfg.xml，说明见本章节）

2）另一种包含了Hibernate的基本映射信息，即系统中每一个类与其对应的数据库表之间的关联信息，在Hibernate工作的初始阶段，这些信息通过hibernate.cfg.xml的mapping节点被加载到Configuration和SessionFactory实例。（如User.hbm.xml，说明见下一章节）

3.2常用配置属性

配置文件在入门案例中，其常用属性说明如下表：

名   称	描   述
hibernate.dialect	操作数据库方言
hibernate.connection.driver_class	连接数据库驱动程序
hibernate.connection.url	连接数据库 URL
hibernate.connection.username	数据库用户名
hibernate.connection.password	数据库密码
hibernate.show_sql	在控制台输出 SQL 语句，true时打印，默认是false
hibernate.format_sql	格式化控制台输出的 SQL 语句，true时格式化，默认是false
hibernate.hbm2ddl.auto	当 SessionFactory 创建时是否根据映射文件自动验证表结构或 自动创建、自动更新数据库表结构。推荐使用update参数
hibernate.connection.autocommit	事务是否自动提交

属性说明后下面进行详细的说明。

3.3数据库更新方式

在入门案例中，hibernate.cfg.xml中配置的hibernate.hbm2ddl.auto是update方式，其参数的作用是用于自动创建表或更新数据等。除此之外还有其他的几种方式，见下表

方式	说明
update	第一次加载时，数据库是没有表的，会先创建表，把数据插入，后面表存在时直接插入数据。推荐使用
create	每次执行前都先把原有数据表删除，然后创建该表，会导致数据库表数据丢失。不使用
create-drop	每次执行前都先把原有数据表删除，然后创建该表。关闭SessionFactory时，将删除掉数据库。不使用
validate	每次加载hibernate时，会验证创建数据库表结构，如果不一致就抛出异常，但是会插入新值。只会和数据库中的表进行比较，不会创建新表。不建议使用

3.4打印sql日志

在进行数据的操作时，我们并没有写sql语句，当想查看其执行的sql时，也是可以开启的。只需要的配置文件中开启sql并格式化sql即可，代码如下：

<!--打印sql-->
<property name="show_sql">true</property>
<!--格式化sql-->
<property name="format_sql">true</property>

截图如下

 再执行测试的方法，又添加了一条数据，控制台打印如下图

4.*.hbm.xml介绍

用于向 Hibernate 提供对象持久化到关系型数据库中的相关信息，每个映射文件的结构基本相同。通常和对象在同一目录下，前缀也一样，如User.hbm.xml，见入门案例配置。其首先进行了 xml 声明，然后定义了映射文件的 dtd 信息，然后后面是Hibernate 映射的具体配置。

4.1<hibernate-mapping> 元素

是映射文件的根元素，它所定义的属性在映射文件的所有节点都有效。其元素所包含的常用属性及其含义说明如下表所示。

属性名	是否必须	说   明
package	否	为映射文件中的类指定一个包前缀，用于非全限定类名
schema	否	指定数据库 schema 名
catalog	否	指定数据库 catalog 名
default-access	否	指定 Hibernate 用于访问属性时所使用的策略，默认为 property。 当 default-access="property" 时，使用 getter 和 setter 方法访问成员变量；当 default-access = "field"时，使用反射访问成员变量
default-cascade	否	指定默认的级联样式，默认为空
default-lazy	否	指定 Hibernate 默认所采用的延迟加载策略，默认为 true

在User.hbm.xml中，使用package指定了实体类所在的包路径。

4.2<class> 元素

主要用于指定持久化类和数据表的映射关系，它是 XML 配置文件中的主要配置内容。其常用属性及其含义说明如下表 所示。

属性名	是否必须	说   明
name	否	持久化类或接口的全限定名。如果未定义该属性，则 Hibernate 将 该映射视为非 POJO 实体的映射
table	否	持久化类对应的数据库表名，默认为持久化类的非限定类名
catalog	否	数据库 catalog 名称，如果指定该属性，则会覆盖 hibernate-mapping 元素中指定的 catalog 属性值
lazy	否	指定是否使用延迟加载

在User.hbm.xml中，使用name指定了实体类是User，table指定了表名是t_user。

4.3<id>元素

用于设定持久化类的主键的映射，其常用属性及其含义说明如下表 所示。

属性名	是否必须	说   明
name	否	标识持久化类主键标识
type	否	持久化类中标识属性的数据类型。如果没有为某个属性显式设定映射类型，Hibernate 会运用反射机制先识别出持久化类的特定属性的 Java 类型，然后自动使用与之对应的默认 Hibernate 映射类型。若指定是引用数据类型，可省略。
column	否	设置标识属性所映射的数据列的列名（主键字段的名字），若列名与对象的属性名称一致，则可省略
access	否	指定 Hibernate 对标识属性的访问策略，默认为 property。若此处指定了该属性，则会覆盖 <hibemate-mapping> 元素中指定的 default-access 属性

除了上面4个元素以外，<id> 元素还可以包含一个子元素 <generator>。<generator> 元素指定了主键的生成方式。

对于不同的关系型数据库和业务应用来说，其主键的生成方式往往也不同，有的是依赖数据库自增字段生成主键，有的是按照具体的应用逻辑决定，通过 <generator> 元素就可以指定这些不同的实现方式。这些实现方式在 Hibernate 中，又称为主键生成策略。常用的策略有两种，一种是native，它是根据不同的数据库实现主键的自增；另一种是assigned，根据用户的需要自定义主键的值，也就是说在插入数据时需要指定主键的值；如果不指定 id 元素的 generator 属性，则默认使用assigned主键生成策略。

在User.hbm.xml中，id使用的是native，即使用数据库的自增特性，这里以mysql为例说明。

4.4<property>元素

<class> 元素内可以包含多个 <property> 子元素，它表示持久化类的其他属性和数据表中非主键字段的映射关系。常用属性及其含义说明如下表所示。

属性名	是否必须	说   明
name	是	持久化类属性的名称，以小写字母开头
column	否	数据表字段名（若列名与对象的属性名称一致，则可省略）
type	否	数据表的字段类型（若指定是引用数据类型，可省略。）
length	否	数据表字段定义的长度（未指定则使用数据库的默认长度）
lazy	否	指定当持久化类的实例首次被访问时，是否对该属性使用延迟加载，其默认值是 false
unique	否	是否对映射列产生一个唯一性约束。常在产生 DDL 语句或创建数据库对象时使用
not-null		是否允许映射列为空

5.整合log4j

当需要根据自己的需求打印日志时，可使用log4j进行自定义。在使用时，需先把配置文件hibernate.cfg.xml中的开启sql打印和格式化sql代码注释。

1）导入依赖

  <!--添加s1f4j依赖-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.25</version>
        </dependency>
        <!--添加s1f4j-log4j转换包-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.25</version>
        </dependency>
        <!--添加log4j依赖-->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>

2）新建log4j.properties

#控制台处理类
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
#控制台输出源布局layout
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd} %d{ABSOLUTE} %5p %c{1}:%L - %m%n
#文件处理类
log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.File=D:/test/hibernate.log
#文件输出源布局layout
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{yyyy-MM-dd} %d{ABSOLUTE} %5p %c{1}:%L - %m%n
# 记录器 输出源 布局
log4j.rootLogger=warn,stdout,file
#记录hibernate参数
log4j.logger.org.hibernate.SQL=debug
#记录JDBC参数
log4j.logger.org.hibernate.type=info
#记录执行sQL的DDL语句
1og4j.logger.org.hibernate.tool.hbm2ddl=debug

3）测试。再次执行测试方法，看到有打印的信息。

5.Hibernate生命周期

5.1对象的状态

Hibernate中对象有三种状态：瞬时状态(Transient)、持久状态(Persistent)、游离状态(Detached）。

1）瞬时状态：刚刚使用new语句创建，还没有被持久化，不处于Session的缓存中。处于临时状态的Java对象被称为临时对象。Session中没有，数据库中没有。

2）持久化状态：已经被持久化，加入到Session的缓存中。处于持久化状态的Java对象被称为持久化对象。Session中有，数据库中有。

3）游离状态：已经被持久化，但不处于Session的缓存中。处于游离状态的Java对象被称为游离对象。Session中没有，数据库中有。

6.一级缓存

6.1概述

Hibernate 中的缓存分为一级缓存和二级缓存，这两个级别的缓存都位于持久化层，并且存储的都是数据库数据的备份。其中一级缓存是 Hibernate 的内置缓存，也叫做session缓存，属于事务范围的缓存，这一级别的缓存由 Hibernate 管理，一般情况下无须进行干预。其作用是减少数据库的访问次数。

hibernate在查询数据时，首先会使用对象的 OID 值在 Hibernate 的一级缓存中查找，如果找到匹配的对象，则直接将该对象从一级缓存中取出使用；如果没有找到匹配的对象，则会去数据库中查询对应的数据。当从数据库中查询到所需数据时，该数据信息会同步存储到一级缓存中，从而在下次查询同一个OID时就可直接从缓存中获取，不需要再次查询数据库。

6.2特点

1）当调用 Session 接口的 load()、get() 方法，以及 Query 接口的 list()、iterator() 方法时，会判断缓存中是否存在该对象，有则返回，不会查询数据库，如果缓存中没有要查询的对象，则再去数据库中查询对应对象，并添加到一级缓存中。

2）当应用程序调用 Session 接口的 save()、update()、saveOrUpdate() 时，如果 Session 缓存中没有相应的对象，则 Hibernate 就会自动把从数据库中查询到的相应对象信息加入到一级缓存中。

3）当调用 Session 的 close() 方法时，Session 缓存会被清空。

4）Session 能够在某些情况下，按照缓存中对象的变化，执行相关的 SQL 语句同步更新数据库，这一过程被称为刷出缓存（flush）。那么刷出缓存的几种情况如下：

A：当应用程序调用 Transaction 的 commit() 方法时，该方法先刷出缓存（调用 session.flush() 方法），然后再向数据库提交事务（调用 commit() 方法）

B：当应用程序执行一些查询操作时，如果缓存中持久化对象的属性已经发生了变化，会先刷出缓存，以保证查询结果能够反映持久化对象的最新状态。

C：调用 Session 的 flush() 方法。

6.3一级缓存示例

1）为了使用方便即代码的简洁，把创建session的代码封装为一个工具类

package com.zxh.util;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.boot.MetadataSources;
import org.hibernate.boot.registry.StandardServiceRegistry;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;

/**
 * 工具类，用来创建session
 */
public class HibernateUtils {

    public static final StandardServiceRegistry registry;
    public static final SessionFactory sessionFactory;

    static {
        registry = new StandardServiceRegistryBuilder().configure().build();
        sessionFactory = new MetadataSources(registry).buildMetadata().buildSessionFactory();
    }

    public static Session getSession() {
        return sessionFactory.openSession();
    }
}

2）添加一个测试方法，对一条数据进行两次查询

    @Test
    public void test5(){
        Session session = HibernateUtils.getSession();
        User user = session.get(User.class, 2);
        System.out.println(user);
        User user2 = session.get(User.class, 2);
        System.out.println(user2);
        //关闭session
        session.close();
    }

控制台的打印结果如下图，根据下图可以看出，只执行了一次查询，第二次查询直接从缓存中获取了。

6.4快照技术

Hibernate 向一级缓存中存入数据的同时，还会复制一份数据存入 Hibernate 快照中。当调用 commit() 方法时，会清理一级缓存中的数据操作，同时会检测一级缓存中的数据和快照区的数据是否相同。如果不同，则会执行 update() 方法，将一级缓存的数据同步到数据库中，并更新快照区；反之，则不会执行 update() 方法。快照的作用就是保证缓存中的数据与数据库的数据保持一致。

且先看下面的示例：

    @Test
    public void test6() {
        Session session = HibernateUtils.getSession();
        User user = new User();
        user.setName("李焕英");
        user.setPassword("123456");
        //向一级缓存中存入session对象
        session.save(user);
        //重新设置值
        user.setPassword("000000");
        //提交事务
        session.beginTransaction().commit();
        //关闭session
        session.close();
    }

运行的日志如下：

插入的数据查询如下：

从这个sql的执行日志来看，首先把数据插入进去，然后根据id把password进行了修改，最终的数据便是数据库查询到的数据。其实这里就用到了快照技术。当设置对象后调用session.save()时，会把在一级缓存中和快照中各存一份User对象数据，此时两者的数据是一样的；但在提交事务之前，把User对象的password属性修改了，数据会同步到快照中；在提交事务时，先根据一级缓存的数据进行插入操作，于此同时会对比快照中的数据与一级缓存中的数据是否相同，由于两者的数据不同，就会执行update语句把一级缓存的数据更新并修改数据库的数据。

6.5一级缓存常用操作

1）刷出flush

一级缓存刷出功能是指在调用 Session 的 flush() 方法时让Session执行一些必须的SQL语句来把内存中的对象的状态同步到JDBC中，也就会执行update语句。在提交事务前，Hibernate 程序会默认先执行 flush() 方法。

且看代码：

    @Test
    public void test7() {
        Session session = HibernateUtils.getSession();
        session.beginTransaction();
        User user = session.get(User.class, 8);
        //重新设置值
        user.setPassword("9999");
        //执行刷出操作
        session.flush();
        //提交事务
        session.getTransaction().commit();
        //关闭session
        session.close();
    }

2）清除clear

在调用 Session 的 clear() 方法时，会清除缓存中的数据。

且看代码：

    @Test
    public void test8() {
        Session session = HibernateUtils.getSession();
        session.beginTransaction();
        User user = session.get(User.class, 8);
        //重新设置值
        user.setPassword("55555");
        //清除缓存
        session.clear();
        //提交事务
        session.getTransaction().commit();
        //关闭session
        session.close();
    }

执行后发现控制台只打印了查询的语句，并没有执行update语句，数据库的数据也没有发生变化。原因是在提交事务前，清除了缓存中的数据，就不会执行修改操作。

如果将上述方法中的 session.clear() 方法更改为 session.evict（user）方法，也可以实现同样的效果。这两个方法的区别是：clear() 方法是清空一级缓存中所有的数据，而 evict() 方法是清除一级缓存中的某一个对象。

3）刷新refresh

在调用 Session 的 refresh() 方法时，会重新查询数据库，并更新 Hibernate 快照区和一级缓存中的数据，让两者的数据保持一致。

且看代码：

    @Test
    public void test9() {
        Session session = HibernateUtils.getSession();
        session.beginTransaction();
        User user = session.get(User.class, 8);
        //重新设置值
        user.setPassword("55555");
        //清除缓存
        session.refresh(user);
        //提交事务
        session.getTransaction().commit();
        //关闭session
        session.close();
    }

日志打印截图：

可以看出执行了两次的查询。第一次查询是指定的查询，第二次查询是由refresh执行的查询。查询后查看数据库，发现数据并没有发生变化，原因是在执行refresh后，会重新查询数据，并把数据给一级缓存和快照各一份，尽管在此之前快照中的值发生了变化，但此时仍然会被最新查询的数据覆盖，password由55555变成原来的9999。

7.二级缓存

7.1概述

二级缓存是SessionFactory 级别的缓存，它是属于进程范围的缓存，这一级别的缓存可以进行配置和更改，以及动态地加载和卸载，它是由 SessionFactory 负责管理的。

在访问指定的对象时，首先从一级缓存中查找，找到就直接使用，找不到则转到二级缓存中查找（必须配置和启用二级缓存）。如果在二级缓存中找到，就直接使用，否则会查询数据库，并将查询结果根据对象的 ID 放到一级缓存和二级缓存中。

7.2二级缓存分类

外置缓存（二级缓存）的物理介质可以是内存或硬盘，其分类如下表：

名称	说明
Class Cache Region	类级别的缓存。用于存储 PO（实体）对象
Collection Cache Region	集合级别的缓存。用于存储集合数据
Query Cache Region	查询缓存。缓存一些常用查询语句的查询结果
Update Timestamps	更新时间戳缓存。该区域存放了与查询结果相关的表在进行插入、更新或删除操作的时间戳，Hibernate 通过更新时间戳缓存区域判断被缓存的查询结果是否过期

7.3整合EHCache插件实现二级缓存

1）导入依赖

       <!-- 二级缓存 EHcache -->
        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-ehcache</artifactId>
            <version>5.4.30.Final</version>
        </dependency>    

由于本文采用的是hibernate5，那么ehcache也要采用相同的版本才行，否则执行会报错，这是一个大坑！其他版本开启缓存的方式略有差别，请注意！

2）开启二级缓存

在核心配置文件中开启缓存，并指定使用缓存的类

        <!-- 开启二级缓存-->
        <property name="hibernate.cache.use_second_level_cache">true</property>
        <!-- 开启查询缓存-->
        <property name="hibernate.cache.use_query_cache">true</property>
        <property name="hibernate.cache.region.factory_class">
            org.hibernate.cache.ehcache.EhCacheRegionFactory
        </property>
        <!-- orm映射文件-->
        <mapping resource="com/zxh/entity/User.hbm.xml"/>
        <class-cache usage="read-write" class="com.zxh.entity.User"/>

上述标红的配置实际上在起那么已经存在了，这里只是说明其位置。也就是说<mapping>标签必须放到<property>标签后面，<class-cache> 标签必须放在 <mapping> 标签的后面。

<class-cache> 标签用于指定将哪些数据存储到二级缓存中，其中 usage 属性表示指定缓存策略。

3）创建测试类

   @Test
    public void test10() {
        //开启第一个Session对象
        Session session1 = HibernateUtils.getSession();
        // 开启第一个事务
        Transaction tx1 = session1.beginTransaction();
        // 获取对象
        User p1 = session1.get(User.class, 8);
        User p2 = session1.get(User.class, 8);
        // 第一次比较对象是否相同
        System.out.println(p1 == p2);
        // 提交事务
        tx1.commit();
        //session1对象关闭，一级缓存被清理
        session1.close();

        // 开启第二个Session对象
        Session session2 = HibernateUtils.getSession();
        // 开启第二个事务
        Transaction tx2 = session2.beginTransaction();
        // 获取对象
        User p3 = session2.get(User.class, 8);
        // 第二次比较
        System.out.println(p1 == p3);
        User p4 = session2.get(User.class, 8);
        // 第三次比较
        System.out.println(p3 == p4);
        // 提交事务2
        tx2.commit();
        // session2关闭
        session2.close();

    }

执行后控制台只执行了一次查询，打印的结果分别是true，false，true。

4）代码执行分析

第一步：从第一个 Session 中获取 p1 对象时，由于一级缓存和二级缓存中没有相应的数据，需要从数据库中查询，所以执行了一次查询。

第二步：查询出 p1 对象后，p1 对象会保存到一级缓存和二级缓存中。在获取p2对象时，Session 并没有关闭，由于一级缓存中已存在对应的数据，则直接从缓存中获取，并不会去数据库查询；由于 p1 和 p2 对象都保存在一级缓存中，而且指向的是同一实体对象，所以p1和p2是一样的。

第三步：提交事务 tx1并关闭 session1，此时一级缓存中的数据会被清除。

第四步：开启第二个 Session 和事务，获取 p3 对象，此时 p3 对象是从二级缓存中获取的。取出后，二级缓存会将数据同步到一级缓存中，这时 p3 对象又在一级缓存中存在了。

第五步：二级缓存中存储的都是对象的散装数据，它们会重新 new 出一个新的对象，所以p1和p3指向的地址不同。

第六步：获取 p4 对象时，Session 并没有关闭，由于一级缓存中已存在对应的数据，则直接从缓存中获取，故p3和p4是一样的，其原理同p1与p2。

8.Hibernate多表操作

在前面的操作中，都是对单表进行操作。除此之外，还有多表的关联关系，它们的关系分别有一对一、一对多、多对多。

8.1一对多映射

8.1.1一对多关系

一对多映射关系是由“多”的一方指向“一”的一方。在表示“多”的一方的数据表中增加一个外键，指向“一”的一方的数据表的主键，“一”的一方称为主表，而“多”的一方称为从表。

比如班级和学生关系，一个班级中有多个学生，但是一个学生只属于一个班级，就属于一对多的关系（一个班级对应多个学生）

8.1.2 实战演练

1）新建班级类Clazz

package com.zxh.entity;

import lombok.Data;
import lombok.experimental.Accessors;

import java.util.HashSet;
import java.util.Set;

@Data
@Accessors(chain = true)
public class Clazz {

    private Integer id;

    private String name;

    private Set<Student> students = new HashSet<>();

}

其中 students 是一个集合对象，用于存储一个班级的学生。

2）新建学生类Student

package com.zxh.entity;

import lombok.Data;
import lombok.experimental.Accessors;

@Data
@Accessors(chain = true)
public class Student {

    private Integer id;

    private String name;

    private Clazz clazz;


}

其中 clazz是一个 Clazz类型的对象，用于表示该学生属于某一个班级。

3）新建Clazz.hbm.xml

在Clazz同级目录下新建Clazz.hbm.xml，内容如下：

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate mapping DTD//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<!--数据库映射，package指定了实体类所在的包名-->
<hibernate-mapping package="com.zxh.entity">
    <!--表映射，name表示对象名，table表示表名-->
    <class name="Clazz" table="t_clazz">
        <!--主键自增-->
       <id name="id">
           <generator class="native"></generator>
       </id>
        <property name="name" length="100"></property>
        <!-- 一对多的关系使用set集合映射 -->
        <set name="students">
            <!-- 指定映外键的列名 -->
            <key column="cid" foreign-key="cid"/>
            <!-- 指定映射的类，指向多的一方 -->
            <one-to-many class="Student"/>
        </set>
    </class>
</hibernate-mapping>

在一对多的关系中，使用<set>标签进行关系的映射。其name表示对象的属性名，里面包含两个标签。<key>用于指定外键，colmun指定外键的列名，foreign-key指定外键名称（若不指定，则使用默认策略生成外键名称，若指定，主键名称 不能重复）。<one-to-many> 标签描述持久化类的一对多关联，指向多的一方的类。

4）新建Student.hbm.xml

在Student同级目录下新建Student.hbm.xml，内容如下：

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate mapping DTD//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<!--数据库映射，package指定了实体类所在的包名-->
<hibernate-mapping package="com.zxh.entity">
    <!--表映射，name表示对象名，table表示表名-->
    <class name="Student" table="t_student">
        <!--主键自增-->
       <id name="id">
           <generator class="native"></generator>
       </id>
        <property name="name" length="50"></property>
        <!-- 多对一关系映射,指向一的一方 -->
        <many-to-one name="clazz" class="Clazz" column="cid"></many-to-one>
    </class>
</hibernate-mapping>

<many-to-one> 标签定义了三个属性，分别是 name、class 和 column 属性。其中，name 属性表示 Student 类中的 clazz属性名称，class 属性表示指定映射的类，column 属性表示表中的外键类名。需要注意的是，该 column 属性与 Clazz.hbm.xml 映射文件的 <key> 标签的 column 属性要保持一致。

5）核心配置文件指定xml位置

在hibernate.cfg.xml配置

<mapping resource="com/zxh/entity/Clazz.hbm.xml"/>
<mapping resource="com/zxh/entity/Student.hbm.xml"/>

6）创建测试方法

为了代码的结构清晰，这里再新建一个测试类MyTest2，添加一个测试方法

   @Test
    public void test1() {
        Session session = HibernateUtils.getSession();
        session.beginTransaction();
        Clazz clazz = new Clazz();
        clazz.setName("计算机1班");
        //学生属于某个班级
        Student student1 = new Student().setName("蔡敏敏").setClazz(clazz);
        Student student2 = new Student().setName("李明").setClazz(clazz);
        //班级里有多个学生
        clazz.getStudents().add(student1);
        clazz.getStudents().add(student2);
        //保存数据
        session.save(clazz);
        session.save(student1);
        session.save(student2);
        //提交事务
        session.getTransaction().commit();
        //关闭session
        session.close();
    }

运行测试方法，会发现发生了异常，如下图：

根据打印的结果来看，表已经创建成功了，在插入数据时出现的异常。这也是一个坑，原因是在实体类上使用了lombok的@Data注解，其toString()方法会去调用本类属性的其他对象的toString()方法。Clazz调用Student的toString()，Studen又调用Clazz的toString()，这样就陷入了死循环，导致栈溢出。解决办法是不使用@Data注解，改使用@Getter和@Setter注解。当两个实体都注解修改后，删除两个表，再次运行，发现执行成功，如下图：

数据库的数据如下图：

            

 如果需要使用上述两个对象的toString()方法，那么只需要给其加上@toString注解即可。这样使用三个注解来替换@Data可以完美的解决上述的异常。

8.2多对多映射

8.2.1多对多关系

多对多的关系都会产生一张中间表。比如学生和学科关系，一个学生可以选择多个学科，一个学科可以被多个学生选择。

8.2.2 实战演练

1）新建学生类Stud

为了和一对多的代码进行区分，这里学生类使用Stud

package com.zxh.entity;

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
import lombok.experimental.Accessors;

import java.util.HashSet;
import java.util.Set;

@Setter
@Getter
@ToString
@Accessors(chain = true)
public class Stud {

    private Integer id;

    private String name;

    private Set<Course> courses = new HashSet<>();
}

其中 courses是一个集合对象，用于存储选择的学科。

2）新建学科类Course

package com.zxh.entity;

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
import lombok.experimental.Accessors;

import java.util.HashSet;
import java.util.Set;

@Setter
@Getter
@ToString
@Accessors(chain = true)
public class Course {

    private Integer id;

    private String name;

    private Set<Stud> students = new HashSet<>();
}

其中 students是一个集合对象，用于存储选择学科的学生。

3）新建Stud.hbm.xml

在Stud同级目录下新建Stud.hbm.xml，内容如下：

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate mapping DTD//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<!--数据库映射，package指定了实体类所在的包名-->
<hibernate-mapping package="com.zxh.entity">
    <!--表映射，name表示对象名，table表示表名-->
    <class name="Stud" table="t_stud">
        <!--主键自增-->
       <id name="id">
           <generator class="native"></generator>
       </id>
        <property name="name" ></property>
        <!-- 多对多的关系使用set集合映射 -->
        <set name="courses" table="stu_course">
            <!-- 指定映外键的列名 -->
            <key column="sid"/>
            <!-- 指定映射的类，指向指向对方 -->
            <many-to-many class="Course" column="cid"/>
        </set>
    </class>
</hibernate-mapping>

对比一对多的关系，<set>标签中多了一个table属性，用来指定中间表的表名称。<many-to-many> 标签表示两个持久化类多对多的关联关系，其中 column 属性指定 course 表在中间表中的外键名称。Stud指向Course类，其在中间表的列名是cid。

4）新建Course.hbm.xml

在Course同级目录下新建Course.hbm.xml，内容如下：

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate mapping DTD//EN"
        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<!--数据库映射，package指定了实体类所在的包名-->
<hibernate-mapping package="com.zxh.entity">
    <!--表映射，name表示对象名，table表示表名-->
    <class name="Course" table="t_course">
        <!--主键自增-->
       <id name="id">
           <generator class="native"></generator>
       </id>
        <property name="name" ></property>
        <!-- 多对多的关系使用set集合映射 -->
        <set name="students" table="stu_course">
            <!-- 指定映外键的列名 -->
            <key column="cid"/>
            <!-- 指定映射的类，指向对方 -->
            <many-to-many class="Stud" column="sid"/>
        </set>
    </class>
</hibernate-mapping>

<set>标签中table属性用来指定中间表的表名称。<many-to-many> 标签表示两个持久化类多对多的关联关系，其中 column 属性指定 Stud表在中间表中的外键名称。Course指向Stud类，其在中间表的列名是sid。

5）核心配置文件指定xml位置

在hibernate.cfg.xml配置

<mapping resource="com/zxh/entity/Stud.hbm.xml"/>
<mapping resource="com/zxh/entity/Course.hbm.xml"/>

6）创建测试方法

在测试类MyTest2中添加一个测试方法

 @Test
    public void test2() {
        Session session = HibernateUtils.getSession();
        session.beginTransaction();

        //学生
        Stud student1 = new Stud().setName("蔡敏敏");
        Stud student2 = new Stud().setName("李明");
        //学科
        Course course = new Course().setName("java 基础");
        Course course2 = new Course().setName("NySQL 基础");

        //学生关联科目
        student1.getCourses().add(course);
        student1.getCourses().add(course2);

        student2.getCourses().add(course);
        student2.getCourses().add(course2);
        //保存数据
        session.save(course);
        session.save(course2);
        session.save(student1);
        session.save(student2);
        //提交事务
        session.getTransaction().commit();
        //关闭session
        session.close();
    }

运行测试方法，执行成功，如下图

 数据库数据如下图：

                 

 上述测试代码中，首先创建两个学生对象和两门课程对象，然后用学生对科目进行关联，这是多对多的单向关联。

8.3反转（inverse）

8.3.1概述

在映射文件的 <set> 标签中，inverse（反转）属性的作用是控制关联的双方由哪一方管理关联关系。

inverse 属性值是 boolean 类型的，当取值为 false（默认值）时，表示由当前这一方管理双方的关联关系，如果双方 inverse 属性都为 false 时，双方将同时管理关联关系；取值为 true 时，表示当前一方放弃控制权，由对方管理双方的关联关系。

通常情况下，在一对多关联关系中，会将“一”的一方的 inverse 属性取值为 true，即由“多”的一方维护关联关系，否则会产生多余的 SQL 语句；而在多对多的关联关系中，任意设置一方的 inverse 属性为 true 即可。

8.3.2实战演练

1）新建一个测试方法test3，对test2方法添加课程对学生的关联

  @Test
    public void test3() {
        Session session = HibernateUtils.getSession();
        session.beginTransaction();

        //学生
        Stud student1 = new Stud().setName("张三丰");
        Stud student2 = new Stud().setName("赵虎义");
        //学科
        Course course = new Course().setName("redis 基础");
        Course course2 = new Course().setName("java框架");

        //学生关联科目
        student1.getCourses().add(course);
        student1.getCourses().add(course2);

        student2.getCourses().add(course);
        student2.getCourses().add(course2);

        //科目关联学生
        course.getStudents().add(student1);
        course.getStudents().add(student2);

        course2.getStudents().add(student1);
        course2.getStudents().add(student2);

        //保存数据
        session.save(course);
        session.save(course2);
        session.save(student1);
        session.save(student2);
        //提交事务
        session.getTransaction().commit();
        //关闭session
        session.close();
    }

2）执行后代码报错，显示主键重复。这是因为在双向关联中会产生一张中间表，关联双方都向中间表插入了数据。

通常情况下，这种问题有两种解决方案：第一种是进行单向关联（即最初的代码test2方法中的代码），第二种是在一方的映射文件中，将 <set> 标签的 inverse 属性设置为 true。

3）在 Course.hbm.xml 映射文件的 <set> 标签中，添加 inverse 属性，并将其属性值设置为 true

再次执行test3方法，运行成功，数据正常插入进去。

4）注意点：inverse 只对 <set>、<one-to-many> 和 <many-to-many> 标签有效，对 <many-to-one> 和 <one-to-one> 标签无效。

8.4级联（cascade）

8.4.1概述

级联操作是指当主控方执行任意操作时，其关联对象也执行相同的操作，保持同步。在映射文件的 <set> 标签中有个 cascade 属性，该属性用于设置是否对关联对象采用级联操作。其常用属性如下表所示：

属性值	描   述
save-update	在执行 save、update 或 saveOrUpdate 吋进行关联操作
delete	在执行 delete 时进行关联操作
delete-orphan	删除所有和当前解除关联关系的对象
all	所有情况下均进行关联操作，但不包含 delete-orphan 的操作
all-delete-orphan	所有情况下均进行关联操作
none	所有情况下均不进行关联操作，这是默认值

一对多的关系还是以班级和学生进行说明，新建一个测试类MyTest3，下面的级联操作均在此测试类进行。

8.4.2一对多级联添加

1）新建一个方法test1

    @Test
    public void test1(){
        Session session = HibernateUtils.getSession();
        session.beginTransaction();
        // 创建一个班级
        Clazz clazz = new Clazz();
        clazz.setName("计算机二班");
        // 创建一个学生
        Student student = new Student();
        student.setName("王五");
        clazz.getStudents().add(student);
        // 班级关联学生
        session.save(clazz);
        session.getTransaction().commit();
        session.close();
    }

2）修改Clazz.hbm.xml

把<set>标签的cascade 的属性值设置为 save-update

3）运行测试方法，日志截图

查看数据库，数据如下：

            

对比上述8.1.2小节的代码可以看出，这里的测试方法并没有写保存学生的代码，由级联操作自动去执行。

8.4.3一对多级联删除

在班级和学生的关联关系中，如果使用级联删除了班级，那么该班级对应的学生也会被删除。

1）先看不使用级联删除班级信息的效果。新建test2，用于删除班级信息

    @Test
    public void test2(){
        Session session = HibernateUtils.getSession();
        session.beginTransaction();
        Clazz clazz = session.get(Clazz.class,3);
        session.delete(clazz);
        session.getTransaction().commit();
        session.close();
    }

2）执行后日志截图如下。从日志可以看出，在删除时，先修改了学生的外键值为null，再删除了班级信息。数据库查询也是如此，也就是说删除看班级信息，但对应的学生信息并没有删除，只是将其班级id置为null而已。

3）如果需要在删除班级的同时删除学生信息，就需要使用级联操作。只需要在 Clazz.hbm.xml 映射文件的 <set> 标签中，将 cascade 属性值设置为 delete 即可。在设置之前，先执行test1方法把数据再次插入进去，然后把cascade 值设置为delete，

4）在插入数据后，根据id修改test2方法中的查询条件（现在插入的班级id是4），再次执行test2方法，日志截图：

执行后对应的数据已经删除成功了。看到日志发现，它还是先把学生的外键置为null，然后根据主键id进行删除。

8.4.4孤儿删除

孤儿的意思是如果解除了外键的关联关系，那么没有外键的一方就是孤儿。要想删除这些数据，也是可以的，那么这种删除就叫孤儿删除。

1）先修改cascade="save-update"执行test1方法把数据再次插入进去

2）新建测试方法test3，先查询数据，然后解除关联关系，再删除班级信息

   @Test
    public void test3() {
        Session session = HibernateUtils.getSession();
        session.beginTransaction();
        Clazz clazz = session.get(Clazz.class, 6);
        Student student = session.get(Student.class, 3);
        //解除关联关系
        clazz.getStudents().remove(student);
        session.delete(clazz);
        session.getTransaction().commit();
        session.close();
    }

3）在 Clazz.hbm.xml 映射文件的 <set> 标签中，将 cascade 属性值设置为 delete-orphan

4）运行test3方法，日志截图如下：

数据也正常被删除了，达到了预定的效果。

8.4.5多对多级联添加

前面已经熟悉了一对多的级联添加，那么多对多的级添加也是同样的道理，直接贴代码。

1）测试方法test4

    @Test
    public void test4() {
        Session session = HibernateUtils.getSession();
        session.beginTransaction();

        //学生
        Stud student1 = new Stud().setName("蔡敏敏");
        Stud student2 = new Stud().setName("李明");
        //学科
        Course course = new Course().setName("java 基础");
        Course course2 = new Course().setName("NySQL 基础");

        //学生关联科目
        student1.getCourses().add(course);
        student1.getCourses().add(course2);

        student2.getCourses().add(course);
        student2.getCourses().add(course2);
        //保存数据
        session.save(student1);
        session.save(student2);

        //提交事务
        session.getTransaction().commit();
        //关闭session
        session.close();
    }

2）修改Stud.hbm.xml的属性cascade="save-update"

3）运行测试方法，日志截图如下，数据添加成功：

8.4.6多对多级联删除

多对多级联删除和一对多的级联删除类似，直接贴代码：

1）测试方法test5

    @Test
    public void test5() {
        Session session = HibernateUtils.getSession();
        session.beginTransaction();
        Stud stud = session.get(Stud.class, 2);
        session.delete(stud);
        session.getTransaction().commit();
        session.close();
    }

2）修改Stud.hbm.xml的属性cascade="delete"

3）运行测试方法，日志截图如下，数据删除成功：

9.Hibernate的5种检索方式

9.1导航对象图检索

导航对象图检索方式是根据已经加载的对象，导航到其他对象，利用的是类与类之间的关系检索对象。

Student student = session.get(Student.class, 4);
Clazz clazz = student.getClazz();

这种方式不常用。

9.2 OID 检索

OID 检索方式是指按照对象的 OID 检索对象。它使用 Session 对象的 get() 和 load() 方法加载某一条记录所对应的对象，其使用的前提是需要事先知道 OID 的值。

Student student = session.get(Student.class, 4);

9.3 HQL 检索

HQL（Hibernate Query Language）是 Hibernate 查询语言的简称，它是一种面向对象的查询语言，与 SQL 查询语言有些类似，但它使用的是类、对象和属性的概念，而没有表和字段的概念。

9.3.1 HQL 检索语法

select/update/delete...]from...[where...][group by...][having...][order by...][asc/desc]

HQL 查询与 SQL 查询非常类似，通常情况下，当检索表中的所有数据时，查询语句中可以省略 select 关键字。这种查询使用createQuery()执行，数据使用list()方法获取。

String hql="from User";

需要注意的是，语句中 User 表示类名，而不是表名，因此需要区分大小写。新建测试类HQLQuery，本小节的测试方法在里面创建。

9.3.2指定别名

指定别名和sql中的as一样，对字段或表名指定别名。下面的案例对表名指定别名：

@Test
public void test1(){
    Session session = HibernateUtils.getSession();
    String sql ="from User t where t.name='lisi'";
    Query query = session.createQuery(sql);
    List<User> list = query.list();
    System.out.println(list);
    session.close();
}

这里查询出了所有的字段信息，有时候想只查询部分字段信息，就需要使用投影查询。

9.3.3投影查询

投影查询就是只查询一部分字段，把数据库的字段与实体类的字段进行投影。

    @Test
    public void test2(){
        Session session = HibernateUtils.getSession();
        String sql ="select t.id,t.name from User t";
        Query query = session.createQuery(sql);
        List<Object[]> list = query.list();
        Iterator<Object[]> iter = list.iterator();
        while (iter.hasNext()) {
            Object[] objs = iter.next();
            System.out.println(objs[0] + " 	" + objs[1]);
        }
        session.close();
    }

上述语句只查询了用户的id和姓名，这就属于只查询部分字段。那么对于这种情况，查询返回的一个数组类型的集合，集合的大小代表查询的数据条数，数组的大小代表查询的字段个数。数组中的元素都是按照查询的语句字段的顺序来的，不同的字段对应不同的位置。如上述objs[0]代表字段id，objs[1]代表字段name，这是因为在select后id是第一位，name是第二位。

查询的结果如下图：

使用这种查询，麻烦之处在于对查询结果的处理，必须按照顺序进行一一处理。

9.3.4动态实例查询

动态实例查询将检索出来的数据重新封装到一个实体的实例中，提高了检索效率。

    @Test
    public void test3(){
        Session session = HibernateUtils.getSession();
        String sql ="select new User (t.id,t.name) from User t";
        Query query = session.createQuery(sql);
        List<User> list = query.list();
        System.out.println(list);
        session.close();
    }

由于这里创建了对象User，那么就需要给User对象添加部分参数构造函数（无参构造默认已存在），否则会报错：

执行测试方法，数据查询成功，已经被封装到User对象中。需要注意的就是要给对应的类添加部分参数构造。也就是说，要查询哪几个参数，就需要用这几个参数创建一个有参构造。

9.3.5条件查询

Hibernate条件查询分为按参数位置查询和按参数名称查询。

1）按参数位置查询

按参数位置查询时，需要在 HQL 语句中使用“?”定义参数的位置，然后通过 Query 对象的 setXxx() 方法为其赋值，为参数赋值的常用方法如下表

方法名	说   明
setString()	给映射类型为 String 的参数赋值
setDate()	给映射类型为 Date 的参数赋值
setTime()	给映射类型为 Date 的参数赋值
setDouble()	给映射类型为 double 的参数赋值
setBoolean()	给映射类型为 boolean 的参数赋值
setInteger()	给映射类型为 int 的参数赋值
setParameter()	给任意类型的参数赋值

新建一个测试方法test4，使用like关键字进行模糊查询：

@Test
public void test4(){
    Session session = HibernateUtils.getSession();
    //使用？作为占位符，后面需要指定所在的位置索引
    String sql ="from User t where t.name like ?0 and t.password like ?1";
    Query query = session.createQuery(sql);
    //根据位置设置查询条件,位置表示的是？所在的索引位置，如第一个后面是0
    query.setString(0,"%zhang%").setString(1,"%12%");
    List<User> list = query.list();
    System.out.println(list);
    session.close();
}

在设置占位符时，使用？作为占位符，后面需要指定所在的位置索引，如第一个位置就是"?0"。设置参数时，要根据索引指定参数的位置。这种方式必须指定索引，只要一个索引写错了，就无法查询成功。

2）按参数名称查询

按参数名字查询时，需要在 HQL 语句中定义命名参数，命名参数是“：”和自定义参数名的组合。

新建一个测试方法test5，使用like关键字进行模糊查询：

    @Test
    public void test5(){
        Session session = HibernateUtils.getSession();
        //使用:命名参数
        String sql ="from User t where t.name like :name1 and t.password like :pwd";
        Query query = session.createQuery(sql);
        //根据参数名称设置参数
        query.setParameter("name1","%zhang%").setParameter("pwd","%12%");
        List<User> list = query.list();
        System.out.println(list);
        session.close();
    }

这种方式和上面按照参数位置查询的结果是一样的。

3）Hibernate支持的常用运算符 

类   型	HQL 运算符
比较运算	>，<，=，>=，<=，<>，!=
逻辑运算	and，or，not
模式匹配	like
范围运算	in，not in，between，not between
其他运算符	is null，is not null，is empty，is not empty等

9.3.6分页查询

Hibernate的分页查询使用Query接口，使用setFirstResult(int index)表示查询的起始索引值，使用setMaxResult(int size)表示每次查询的条数。

    @Test
    public void test6(){
        Session session = HibernateUtils.getSession();
        String sql ="from User";
        Query query = session.createQuery(sql);
        //设置查询的起始索引
        query.setFirstResult(2);
        //设置查询的条数
        query.setMaxResults(10);
        List<User> list = query.list();
        System.out.println(list);
        session.close();
    }

上述代码查询的是从索引2开始的10条数据。那么在实际情况中，会传入当前页码和分页条数，需要对其进行转换。例如查询第m页的n条数据，那么分页条件设置如下：

query.setFirstResult((m-1)*n);
query.setMaxResults(n);

9.4 QBC 检索

QBC（Query By Criteria），它主要由 Criteria 接口、Criterion 接口和 Expression 类组成，并且支持在运行时动态生成查询语句。

新建测试类QBCQuery，本小节的测试方法在里面创建。

9.4.1组合查询

组合查询是指通过 Restrictions 工具类的相应方法动态地构造查询条件，并将查询条件加入 Criteria 对象，从而实现查询功能。

新建测试方法test1：

    @Test
    public void test1(){
        Session session = HibernateUtils.getSession();
        Criteria criteria = session.createCriteria(User.class);
        // 设定查询条件
        LogicalExpression expression = Restrictions.or(Restrictions.like("name", "%li%"), Restrictions.eq("id", 3));
        // 添加查询条件
        criteria.add(expression);
        // 执行查询，返回查询结果
        List<User> list = criteria.list();
        System.out.println(list);
        session.close();
    }

上述代码查询的条件是：查询name包含"li"或id=3的用户信息。先设置查询的条件，把查询的条件放到Criteria 中去执行，获取查询的结果。条件的设置上述用到了or、eq和like，其常用的条件如下表：

方法名	说   明
Restrictions.eq	等于
Restrictions.like	对应 SQL 的 like 子句
Restrictions.or	or关系
Restrictions.and	and 关系
Restrictions.allEq	使用 Map 和 key/value 进行多个等于的比较
Restrictions.gt	大于 >
Restrictions.ge	大于等于 >=
Restrictions.lt	小于
Restrictions.le	小于等于 <=
Restrictions.between	对应 SQL 的 between 子句
Restrictions.in	对应 SQL 的 IN 子句
Restrictions.sqlRestriction	SQL 限定查询

 9.4.2分页查询

QBC也可以实现分页查询。在 Criteria 对象中，通过设置setFirstResult(int index)和setMaxResult(int size)进行分页查询。

    @Test
    public void test2(){
        Session session = HibernateUtils.getSession();
        Criteria criteria = session.createCriteria(User.class);
        // 设定分页条件
        criteria.setFirstResult(2);
        criteria.setMaxResults(10);
        // 执行查询，返回查询结果
        List<User> list = criteria.list();
        System.out.println(list);
        session.close();
    }

设置的参数和HQL的参数说明是一样的，就不多说。

9.5本地 SQL 检索

本地 SQL 检索方式就是使用本地数据库的 SQL 查询语句进行查询。

新建测试类LocalQuery，本小节的测试方法在里面创建。

9.5.1不指定类型查询（查询结果类型是Object）

    @Test
    public void test1() {
        Session session = HibernateUtils.getSession();
        SQLQuery sqlQuery = session.createSQLQuery("select * from t_user");
        List queryList = sqlQuery.list();
        System.out.println(queryList);
        session.close();
    }

通过这种查询得到的只是对象的地址，无法得到具体的数据。不推荐使用！

9.5.2将查询结果封装为对象

在查询时添加要封装的对象即可

    @Test
    public void test2() {
        Session session = HibernateUtils.getSession();
        SQLQuery sqlQuery = session.createSQLQuery("select * from t_user");
        sqlQuery.addEntity(User.class);
        List<Object> queryList = sqlQuery.list();
        System.out.println(queryList);
        session.close();
    }

这样查询出来的数据就是对象类型，可以看到具体的内容，方便使用。

9.5.3动态参数查询

本身sql检索也可以使用动态参数的格式进行查询，用法和HQL的动态参数查询类似，这里只举例说明

    @Test
    public void test3() {
        Session session = HibernateUtils.getSession();
        SQLQuery sqlQuery = session.createSQLQuery("select * from t_user where name=:name");
        //设置封装对象
        sqlQuery.addEntity(User.class);
        //指定参数
        sqlQuery.setString("name","zhangsan111");
        List<Object> queryList = sqlQuery.list();
        System.out.println(queryList);
        session.close();
    }

10.Hibernate事务操作

10.1事务配置

Hibernate事务配置有两种方式，推荐使用第二种方式。

1）使用代码操作管理事务

开启事务：Transaction tx = session.beginTransaction()；

提交事务：tx.commit()；

回滚事务：tx.rollback()；

2）在核心配置文件中配置事务

<!--使用本地事务-->
<property name= "hibernate.current_session_context_class"> thread</property>
<!--设置事务隔离级别-->
<property name= "hibernate.connection.isolation">2</property>