hibernate

Hibernate是一款重量级的持久层框架，目前市面上的我很少见还有项目在开发时候使用他，之所以要学习这个，因为公司最近有一个系统升级的项目，之前的老系统用到了Hibernate。

同样还是老套路，学习一个新技术或者新知识，首先去他的官网看

【官网】：https://hibernate.org/orm/
【官方教程】：https://hibernate.org/orm/documentation/getting-started/
【github地址】：https://github.com/hibernate

---

目前hibernate已经更新到了6的版本，这里使用的5的版本

注意： Hibernate5.1；5.2官方推荐使用JDK1.8以及JDBC4

前言

在学习Hibernate之前，我们需要回顾下ORM，我们都肯定用过或者熟悉Mybatis的，(或者有看过我之前的MyBatis的博客)。我们都知道Mybatis是一款半自动的ORM框架

ORM

ORM(Object/Relation Mapping)：对象关系映射

• ORM主要解决对象对象-关系的映射🔥🔥

• ORM思想：程序员可以把对数据库的操作转化为对对象的操作
• ORM采用元数据来描述对象-关系映射细节，元数据通常采用XML格式

ORM思想的好处：

1. Java开发人员可以轻松的操作对象，间接的操作关系数据库
2. 可以更加方便封装数据
3. 不用编写SQL语句

---

一、HelloWorld入门程序

1.1 环境准备

• 使用JDK1.8
• 开发工具：Idea2022.2
• 数据库：Mysql8.30
• ORM框架：Hibernate5.2.11

数据库脚本：

CREATE TABLE `t_customer` (
	`c_id` INT(10) NOT NULL AUTO_INCREMENT COMMENT '主键id',
	`c_name` VARCHAR(20) NOT NULL DEFAULT '' COLLATE 'utf8mb4_general_ci',
	`c_gender` CHAR(1) NOT NULL DEFAULT '' COMMENT '1:男 0：女' COLLATE 'utf8mb4_general_ci',
	`c_age` INT(10) NOT NULL DEFAULT '0',
	`c_level` VARCHAR(20) NOT NULL DEFAULT '0' COLLATE 'utf8mb4_general_ci',
	PRIMARY KEY (`c_id`) USING BTREE
)
COLLATE='utf8mb4_general_ci'
ENGINE=InnoDB;
1
2
3
4
5
6
7
8
9
10

开发所需要的jar包：

说明：geronimo-jta_1.1_spec-1.1.1.jar必须要有，否则可能会报出java.lang.NoClassDefFoundError: javax/transaction/Synchronization的异常

1.2 准备实体类

public class Customer implements Serializable {

    private static final long serialVersionUID = 1L;

    private Integer id;
    private String name;
    private String gender;
    private Integer age;
    private String level;

	// getter、setter...
}
1
2
3
4
5
6
7
8
9
10
11
12

1.3 准备Hibernate实体映射文件*.hbm.xml🔥🔥

【建议规则要求】：

• 文件名称：实体类名称.hbm.xml
• 文件存放位置：和实体类存放在一个目录下

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.wei.domain.Customer" table="t_customer">
        <id name="id" column="c_id">
            <generator class="native">generator>
        id>
        <property name="name" column="c_name">property>
        <property name="age" column="c_age">property>
        <property name="gender" column="c_gender">property>
        <property name="level" column="c_level">property>
    class>
hibernate-mapping>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

1.3.1 【hibernate实体映射文件参数详解】

• hibernate-mapping ： ORM元数据，实体与表的对应关系
  • 属性：
    • packing：配置文件中类的所在包
• class： 配置是体育表的关系
  • 属性：
    • name：填写尸体的完整类名（如果没有配置packing）
    • table：与实体类对应的表名称
    • dynamic-insert：动态插入 默认值是false ，true=>如果字段值为null,不参与insert语句
    • dynamic-update：动态更新 默认值"false"，true=> 没改动过的属性,将不会生成到update语句中
• id：配置实体中与表中id对应关系
  • name：Java实体对象中标识主键的属性名称
  • column：数据库中的主键字段名称（列名）
  • length：列的数据长度
  • unsaved-value（不常用）：指定主键为什么值时，当作null处理
  • access（强烈建议不要用）
  • generator： 主键增长生成策略
    • increment 数据库自己生成主键. 先从数据库中查询最大的ID值,将ID值加1作为新的主键
    • identity 依赖于数据的主键自增功能
    • sequence 序列,依赖于数据中的序列功能(Oracle).
    • hilo(纯了解,永远用不到) : Hibernate自己实现序列的算法,自己生成主键. (hilo算法 )
      - native 自动根据数据库判断,三选一. identity|sequence|hilo
      - uuid 生成32位的不重复随机字符串当做主键
      - assigned 自己指定主键值. 表的主键是自然主键时使用
• property： 实体中其余属性字段与表中列的对应关系
  • name：实体中的属性名称
  • column：数据库中的列名
  • length：数据长度
  • precision：小数点后精度
  • scale：有效位数
  • insert：是否加入插入的语句
  • update：是否加入更新的语句
  • unique：指定属性的约束是否唯一约束
  • not-null：指定属性的约束是否是非空约束
  • type：表达该属性的类型
    • java类型：java.lang.String
    • 数据库类型：VARCHAR
    • Hibernate类型：string

1.4 准备Hibernate核心配置文件hibernate.cfg.xml🔥🔥

核心配置文件主要用于配置数据库的相关链接操作

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="hibernate.connection.driver_class">com.mysql.cj.jdbc.Driverproperty>
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate_db?useUnicode=true&characterEncoding=UTF-8&useSSL=false&serverTimezone=UTCproperty>
        <property name="hibernate.connection.username">rootproperty>
        <property name="hibernate.connection.password">123456property>

        
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialectproperty>

        
        <mapping resource="com/wei/domain/Customer.hbm.xml">mapping>
    session-factory>
hibernate-configuration>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

1.4.1【核心配置文件详解参数】

一共分为三个部分：

1. 数据库连接参数
2. hibernate扩展参数
3. 映射信息

1.4.1.1 数据库连接参数

1. Hibernate.connection.driver_class：数据库驱动
2. Hibernate.connection.url：连接url
3. Hibernate.connection.password：连接数据库密码
4. Hibernate.connection.username：连接数据库用户名

1.4.1.2 hibernate扩展参数🔥

1. show_sql：显示sql语句
2. format_sql：格式化sql
3. hibernate.hbm2ddl.auto：
   • create：每次操作hibernate都会创建一张新表，
   • update：每次操作Hibernate只是维护更新，如果说有表的话。

1.4.1.3 映射信息

使用标签，多个实体映射文件就用多个mapping标签配置

1.5 编写测试类测试

要想进行Hibernate的测试，需要以下几步

1. 读取Hibernate.cfg.xml核心配置文件
2. 创建SqlSessionFactory工厂
3. 创建Session对象
4. 开启事务
5. 执行相应的CRUD操作
6. 事务提交与回滚
7. 释放资源

public class MyTest {

    @Test
    public void test1() throws HibernateException {
        Customer customer = new Customer();
        customer.setAge(21);
        customer.setName("丽丽");
        customer.setGender("女");
        customer.setLevel("VIP一姐");
        //1、读取hibernate.cfg.xml文件
        Configuration cfg = new Configuration();
        cfg.configure();
        //2、创建SessionFactory工厂
        SessionFactory factory = cfg.buildSessionFactory();

        //3、创建Session对象
        Session session = factory.openSession();

        //4、开启事务
        Transaction tx = session.beginTransaction();

        //5、执行添加操作
        session.save(customer);

        //6、提交事务
        tx.commit();

        //7、关闭资源
        session.close();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

二、 Hibernate核心API接口

【hibernate核心接口有】：

1. Configuration
2. SessionFactory
3. Session
4. Transaction
5. Query
6. Criteria

2.1 Configuration接口

• Configuration 接口负责管理Hibernate 的配置信息。它包括如下内容：

  • Hibernate运行的底层信息：数据库的URL、用户名、密码、JDBC驱动类，数据库Dialect,数据库连接池等。

  • Hibernate映射文件（*.hbm.xml）。

  • 作用就是加载Hibernate的核心配置文件。

注意事项：Configuration对象是一个单例的

• Hibernate配置的两种方法：
  • 方法1：属性文件（Hibernate.properties）。
    调用代码：Configuration config = new Configuration();
  • 方法2：Xml文件（Hibernate.cfg.xml）。
    调用代码：Configuration config = new Configuration().configure();

2.2 SessionFactory接口

• 创建SessionFactory

Configuration config=new Configuration().configure();
SessionFactory sessionFactory = config.buildSessionFactory();
1
2

• SessionFactory接口
  • 重量级对象，系统开销大。
  • 用来产生和管理 Session ：应用程序从SessionFactory（会话工厂）里获得 Session(会话)实例。
  • 通常情况下每个应用只需要一个SessionFactory（单例）
  • 除非要访问多个数据库的情况
  • 关注两个方法即：openSession、getCurrentsession
  • openSession 每次都是新的，需要close
  • getCurrentsession 从上下文找，如果有，用旧的，如果没有，建新的

注意事项：SessionFactory也是单例的，一个项目只需要创建一个sessionFactory对象

2.3 Session接口

Session接口用于操作对象，有一些CRUD的方法

• Session是Hibernate持久化操作的基础，与Web层的HttpSession没什么关系。
• Hibernate Session相当于JDBC Connection。
• Session接口是应用程序与hibernate连接的核心API
• Session 对象是轻量级的，每次实例化都需要与数据库交互。
• 管理一个数据库的任务单元（增 删 改 查）

创建Session的方式有二：

1. getCurrentSession()

Session session = sessionFactory.getCurrentSession();//获取当前线程中的session对象
1

2. openSession()

Session session = sessionFactory.openSession();//创建一个新的session对象
1

从这里就可看出Session是一个非线程安全的对象

2.3.1 session中的常用方法

CURD(增删查改)

• save()/persist()：添加对象
• delete()：删除对象
• update()：修改对象
• saveOrUpdate()：添加或修改对象
• load()/get()：根据主键查询
• clear()
• flush()

2.4 Transaction接口

Transaction接口的作用是用于执行事务的操作

Transaction的方法：

1. commit()：事务提交
2. rollback()：事务回滚

2.5 Query接口

用于执行Hibernate’的HQL查询

三、抽取Hibernate的工具类

---

【HibernateUtil工具类的抽取】

public class HibernateUtil {
    private static Configuration cfg = null;
    private static SessionFactory factory  =null;

    // 使用动态代码块来实现之家再一次的效果
    static {
        cfg = new Configuration();
        cfg.configure();
        factory = cfg.buildSessionFactory();
    }

    /**
     * 获取Session
     * @return
     */
    public static Session getConnection(){
        //3、创建Session对象
        Session session = factory.openSession();
        return session;
    }

    /**
     * 释放资源
     * @param session
     */
    public static void closeSession(Session session){
        session.close();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

四、使用Session实现CRUD

回顾上面介绍的Session的常用方法：save保存，update更新，get查找，delete删除

4.1 save(Object obj)添加

 /**
     * 增加save方法
     * @throws HibernateException
     */
    @Test
    public void test1() throws HibernateException {
        Customer customer = new Customer();
        customer.setAge(78);
        customer.setName("李老头");
        customer.setGender("男");
        customer.setLevel("农民");

        Session session = HibernateUtil.getConnection();

        //4、开启事务
        Transaction tx = session.beginTransaction();

        //5、执行添加操作
        session.save(customer);
        //6、提交事务
        tx.commit();

        //7、关闭资源
        HibernateUtil.closeSession(session);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

4.2 update(Object obj)更新方法

    /**
     * 更新update方法
     * @throws HibernateException
     */
    @Test
    public void test2() throws HibernateException {
        Customer customer = new Customer();
        customer.setId(3);
        customer.setAge(78);
        customer.setName("李老头");
        customer.setGender("1");
        customer.setLevel("农民");

        Session session = HibernateUtil.getConnection();

        //4、开启事务
        Transaction tx = session.beginTransaction();

        //5、执行添加操作
        session.update(customer);
        //6、提交事务
        tx.commit();

        //7、关闭资源
        HibernateUtil.closeSession(session);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

注意：更新必须要传入一个id往实体类里

4.3 delete(Object obj)删除方法

    /**
     * 删除delete方法
     * @throws HibernateException
     */
    @Test
    public void test3() throws HibernateException {
        Customer customer = new Customer();
        customer.setId(3);
        customer.setAge(78);
        customer.setName("李老头");
        customer.setGender("1");
        customer.setLevel("农民");

        Session session = HibernateUtil.getConnection();

        //4、开启事务
        Transaction tx = session.beginTransaction();

        //5、执行添加操作
        session.delete(customer);
        //6、提交事务
        tx.commit();

        //7、关闭资源
        HibernateUtil.closeSession(session);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

注意：删除也是要传入Id

4.4 查询get(Class c,Object id) | load(Class c,Object id)方法

get和load方法都可以实现查询的操作，但是区别在于load有一个延迟加载的概念

   /**
     * 查询get/load方法
     * @throws HibernateException
     */
    @Test
    public void test4() throws HibernateException {

        Session session = HibernateUtil.getConnection();

        //4、开启事务
        Transaction tx = session.beginTransaction();

        //5、执行添加操作
//        Customer customer1 = session.get(Customer.class, 2);
        Customer customer1 = session.load(Customer.class, 2);

        System.out.println(customer1);
        //6、提交事务
        tx.commit();

        //7、关闭资源
        HibernateUtil.closeSession(session);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23