Hibernate框架——框架的使用及简单配置讲解

发表于

Hibernate 框架简介

ORM 框架

​ 对象关系映射，对象和表字段进行对应，是一种程序技术，用于实现面向对象编程语言里不用类型系统的数据之间的转换

Hibernate 框架

​ Hibernate 是一个开放源码的对象关系映射框架，它对 JDBC 进行了非常轻量级的对象封装，它将 POJO（简单的 JAVA 对象）与数据库表建立映射关系，是一个全自动的 ORM 框架

​ Hibernate 可以自动生成 SQL 语句，自动执行，可以应用在任何使用 JDBC 的场合

优点：

​ 对 JDBC 访问数据库的代码做了封装，大大简化了数据访问层繁琐重复性代码

​ 是一个基于 jdbc 的主流持久化框架，是一个优秀的 orm 实现，有很大程度的简化了 dao 层编码工作

​ Hibernate 使用了 JAVA 的反射机制

​ Hibernate 性能好，是一个轻量级框架，映射灵活性出色，它支持很多关系型数据库，有一对一到多对多的各种复杂关系映射

Hibernate 框架使用

核心配置文件 hibernate.cfg.xml

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
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
	<session-factory>
		<!-- 1、配置数据库连接的4个参数 -->
		<property name="hibernate.connection.driver_class">com.mysql.cj.jdbc.Driver</property>
		<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate_day1?useSSL=false&amp;serverTimezone=Hongkong&amp;characterEncoding=utf-8&amp;autoReconnect=true</property>
		<property name="hibernate.connection.username">root</property>
		<property name="hibernate.connection.password">lmh12358</property>
		
		<!-- 开启与当前线程绑定 session 的功能 -->
		<property name="hibernate.current_session_context_class">thread</property>
		
		<property name="javax.persistence.validation.mode">none</property>
		
		<!--  是否显示sql语句 -->
		<property name="hibernate.show_sql">true</property>
		
		<!--  是否格式化sql语句 -->
		<property name="hibernate.format_sql">true</property>
		
		<!--  是否自动提交事务 -->
		<property name="hibernate.connection.autocommit">true</property>
		
		<!-- 2、配置JavaBean与表的映射文件 -->
		<mapping resource="com/lmh/hibernate/domain/User.hbm.xml"/>
	</session-factory>
</hibernate-configuration>

Java Bean 对象映射文件 Class.hbm.xml

User.java：

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
package com.lmh.hibernate.domain;

public class User {
	
	private int uid;
	private String username;
	private String password;
	
	public int getUid() {
		return uid;
	}
	public void setUid(int uid) {
		this.uid = uid;
	}
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	
}

User.hbm.xml：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<!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.lmh.hibernate.domain.User" table="t_user">
		<!-- name：模型中的属性名 -->
		<id name="uid" column="id">
			<!-- id 的生成策略 -->
			<generator class="native"></generator>
		</id>
		<!-- 如果表中类中字段名相同不用写 column -->
		<property name="username"></property>
		<property name="password"></property>
	</class>
</hibernate-mapping>

所用 jar 包

antlr-2.7.6.jar

commons-collections-3.1.jar

dom4j-1.6.1.jar

hibernate-jpa-2.0-api-1.0.1.Final.jar

hibernate3.jar

javassist-3.12.0.GA.jar

jta-1.1.jar

mysql-connector-java-8.0.16.jar

slf4j-api-1.6.1.jar

测试类：

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
package com.lmh.hibernate.test;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.junit.Test;

import com.lmh.hibernate.domain.User;

public class testDemo {
	@Test
	public void test1(){
		//保存用户数据
		//1.获取核心配置文件对象，configure()无参数默认是加载 src 的 hibernate.cfg.xml 文件
		Configuration cfg = new Configuration().configure();
        
		//2.创建会话工厂
		SessionFactory factory = cfg.buildSessionFactory();
		
		//3.创建会话【相当于连接 Connect】
		//openSession()获取一个全新的 session
		//factory.getCurrentSession获取一个与当前线程绑定的 session
		Session session1 = factory.openSession();
		
		//开启事务
		Transaction trans = session1.getTransaction();
		trans.begin();
		
		//保存【直接把对象保存到数据库】
		User user = new User();
		user.setUsername("skw");
		user.setPassword("123");
		session1.save(user);
		
		//提交事务
		trans.commit();
		
		//4.关闭会话
		session1.close();
		
		//5.关闭工厂
		factory.close();
	}
}

Configuration 配置对象

​ Configuration 对象用来加载配置文件，new Configuration 构造方法加载的时 hibernate.properties，configure 方法加载的是 hibernate.cfg.xml，通常这两种配置文件都会被放在 src 目录下

1
2
3
4
5
//保存用户数据
//1.获取核心配置文件对象，configure()无参数默认是加载 src 的 hibernate.cfg.xml 文件
//2.直接 new 出来的对象默认调用 hibernate.properties
Configuration cfg = new Configuration().configure();
Configuration cfg = new Configuration();

加载 Class.hbm.xml 映射文件的方式

hibernate.cfg.xml中：

1
2
<!-- 1.在 hibernate.cfg.xml 中配置JavaBean与表的映射文件 -->
<mapping resource="com/lmh/hibernate/domain/User.hbm.xml"/>

测试类中：

1
2
3
4
//2.调用 Configuration 对象的 addResource
cfg.addResource("com/lmh/hibernate/domain/User.hbm.xml");
//3.调用 Configuration 对象的 addClass 方法
cfg.addClass(User.class);

SessionFactory 工厂

​ SessionFactory 相当于 Java Web 连接池，用于管理所有的 session，通过调用 Configuration 对象的 buildSessionFactory 方法来获得 SessionFactory，它还用于缓存配置信息（数据库配置信息、映射文件、预定义 HQL 语句等），SessionFactory 线程安全，多个线程同时访问时不会出现线程并发访问问题

Session 会话

​ 创建一个 Session 就相当于建立了一个 Connection，建立后可以通过 Session 来对数据库中的表进行操作

Session 会话的获取

​ SessionFactory 提供了两个方法来获取 Session：

​ 1.factory.openSession()：获取一个全新的 Session

​ 2.factory.getCurrentSession()：获取一个与当前线程绑定的 Session

1
2
3
4
5
6
7
8
9
Session session1 = factory.openSession();
Session session2 = factory.openSession();
System.out.println(session1.hashCode());
System.out.println(session2.hashCode());

Session session3 = factory.getCurrentSession();
Session session4 = factory.getCurrentSession();
System.out.println(session3.hashCode());
System.out.println(session4.hashCode());

​ 要使用 2 方法，必须在 hibernate.cfg.xml 中配置：

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

Session 的 api

save：

1
2
3
4
User user = new User();
user.setUsername("lxq");
user.setPassword("123");
session1.save(user);

get：

1
2
User u1 = (User)session1.get(User.class, 3);
//通过 id 查询，没有事返回 null，获取的是 object 对象，需要强制转换

load：

1
2
User u2 = (User)session1.load(User.class, 3);
//同样通过 id 查修，但没有时报错

delete：

1
2
3
4
5
6
7
8
//1.先获取要删除的对象，再调用 delete 方法
User u1 = (User)session1.get(User.class, 3);
session1.delete(u1);

//2.创建一个 user，设置 id，然后调用 delete 方法
User u2 = new User();
u2.setUid(2);
session1.delete(u2);

update：

1
2
3
4
5
//session 使用 update 更新数据
//1.通过 get 获取数据，调用 set 方法，事务提交自动执行 update 语句
//2.自己封装 User 对象，设置 id，这个时候，需要调用 update 方法
u1.setPassword("abc");
session1.update(u1);

get 和 load 方法的区别（面试）：

​ get 方法是直接加载数据库

​ load 方法的设计是懒加载，用到是才会访问数据库，调用 load 方法时返回的是一个代理对象（javassist）

Transaction 事务

​ 这里不需要仔细看。因为后期的事务会交给 Spring 管理，直接上代码吧

1
2
3
4
5
6
7
8
9
10
Transaction trans = session1.getTransaction();
//开启事务
trans.begin();

User u1 = (User)session1.get(User.class, 3);
u1.setPassword("abc");
session1.update(u1);

//提交事务
trans.commit();
-------------本文结束感谢您的阅读-------------