本节我们将演示如何搭建一个 Hibernate 工程。
搭建 Hibernate 工程需要以下 7 步：
下载 Hibernate 开发包
新建工程
创建数据库表
创建实体类
创建映射文件
创建 Hibernate 核心配置文件
测试
1. 下载 Hibernate 开发包
浏览器访问 Hibernate 官网 下载 Hibernate（以 hibernate-release-5.5.3.Final 为例）开发包。
目录介绍
下载完成后，解压 hibernate-release-5.5.3.Final.zip，可得到以下目录结构。
Hibernate 文件夹中，包含以下 3 个目录：
documentation：Hibernate 的开发文档；
lib：Hibernate 相关的依赖；
project：Hibernate 官方给出的示例工程。
在 lib 目录下有一个 required 文件夹，其中包含了 Hibernate 5 必须依赖的 jar 包，如下图。
2. 新建工程
1. 以 IntelliJ IDEA 为例，新建一个名为 hibernate-demo 的 Java 工程
换成自己本机maven
2 分别在main和test中创建ressources包
2 依赖文件pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.hibernate</groupId>
<artifactId>hibernate-demo2</artifactId>
<version>1.0-SNAPSHOT</version>
<name>hibernate-demo2</name>
<!-- FIXME change it to the project's website -->
<url>http://www.example.com</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13.2</version>
<scope>test</scope>
</dependency>
<!--hibernate依赖-->
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>5.3.7.Final</version>
</dependency>
<!--mysql依赖-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.32</version>
</dependency>
</dependencies>
<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>
</project>
3. 创建数据库表
执行以下 SQL 语句，在 bianchengbang_jdbc 数据库中创建 user 表，并向该表中添加测试数据。
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
`id` int NOT NULL AUTO_INCREMENT,
`user_id` varchar(255) DEFAULT NULL,
`user_name` varchar(255) DEFAULT NULL,
`password` varchar(255) DEFAULT NULL,
`email` varchar(255) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=MyISAM AUTO_INCREMENT=3 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;
INSERT INTO `user` VALUES ('1', '001', 'admin', 'admin', '12345678@qq.com');
INSERT INTO `user` VALUES ('2', '002', 'user', '123456', '98765432@qq.com');
4. 创建实体类
在 hibernate-demo 工程的 net.biancheng.www.po 包下，创建一个与 user 表对应的实体类 User，代码如下。
package net.biancheng.www.po;
public class User {
private int id;
private String userId;
private String userName;
private String password;
private String email;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getUserId() {
return userId;
}
public void setUserId(String userId) {
this.userId = userId;
}
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;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
@Override
public String toString() {
return "net.biancheng.www.po.User{" +
"id=" + id +
", userId='" + userId + '\'' +
", userName='" + userName + '\'' +
", password='" + password + '\'' +
", email='" + email + '\'' +
'}';
}
}
5. 创建映射文件
单单一个实体类 User 是不具备持久化操作的能力的，为了使该类具备这种能力，就需要将 User 实体类映射到数据库的某一张表中，并将实体类中的属性与数据表的字段相对应，这些都需要在映射文件中配置。
Hibernate 的映射文件的命名规则如下：
[实体类名].hbm.xml
例如，实体类 User 的映射文件就可以命名为 User.hbm.xml。
在 net.biancheng.www.mapping 包下，创建 User 的映射文件 User.hbm.xml，配置如下。
<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<!-- name:类的全路径:-->
<!-- table:表的名称:(可以省略的.使用类的名称作为表名.)-->
<class name="net.biancheng.www.po.User" table="user" schema="bianchengbang_jdbc">
<!-- 主键-->
<id name="id" column="id">
<!--主键生成策略-->
<generator class="native"></generator>
</id>
<!--type:三种写法-->
<!--Java类型 :java.lang.String-->
<!--Hibernate类型:string-->
<!--SQL类型 :不能直接使用type属性,需要子标签<column>-->
<!--<column name="name" sql-type="varchar(20)"/>-->
<property name="userId" column="user_id" type="java.lang.String"/>
<property name="userName" column="user_name"/>
<property name="password" column="password"/>
<property name="email" column="email"/>
</class>
</hibernate-mapping>
6. 创建 Hibernate 核心配置文件
Hibernate 框架是对 JDBC 的封装，也需要对 JDBC 连接数据库所需的 url、driver、username 和 password 等 4 个基本参数进行配置，Hibernate 一般是通过配置文件 hibernate.cfg.xml 来指定的，该文件被称为 Hibernate 的核心配置文件。
在 Hibernate 工程的 src 目录下，新建一个 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>
<!--使用 Hibernate 自带的连接池配置-->
<property name="connection.url">jdbc:mysql://localhost:3306/bianchengbang_jdbc</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password">root</property>
<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
<!--hibernate 方言-->
<property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property>
<!--打印sql语句-->
<property name="hibernate.show_sql">true</property>
<!--格式化sql-->
<property name="hibernate.format_sql">true</property>
<!-- 加载映射文件 -->
<mapping resource="net/biancheng/www/mapping/User.hbm.xml"/>
</session-factory>
</hibernate-configuration>
7. 测试
在 net.biancheng.www.test 包下，创建一个名为 AppTest 的测试类，并在该测试类中创建一个测试方法 testQuery()，使用 Hibernate 实现对数据库的查询，代码如下。
package com.hibernate;
import com.hibernate.entity.User;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.boot.MetadataSources;
import org.hibernate.boot.registry.StandardServiceRegistry;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.junit.Test;
/**
* Unit test for simple App.
*/
public class AppTest {
@Test
public void testInit() {
StandardServiceRegistry registry = null;
SessionFactory sessionFactory = null;
Session session = null;
Transaction transaction = null;
try {
//初始化注册服务对象
registry = new StandardServiceRegistryBuilder()
.configure()//默认加载hibernate.cfg.xml,如果配置文件名称被修改：configure("被修改的名字")
.build();
//获取Session工厂
sessionFactory = new MetadataSources(registry)
.buildMetadata()
.buildSessionFactory();
//从工厂创建Session连接
session = sessionFactory.openSession();
//开启事务
transaction = session.beginTransaction();
//创建事例
User user = new User();
user.setUserName("zhang");
user.setPassword("123");
session.save(user);
//提交事务
transaction.commit();
} catch (HibernateException e) {
e.printStackTrace();
//回滚事务
transaction.rollback();
} finally {
if(session!=null && session.isOpen())
//关闭session
session.close();
}
}
}
8 Hibernate连接封装成工具类
package com.hibernate.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;
/**
* @author ZCL
* @Description
* @date 2023/5/18 18:12
*/
public class HibernateUtil {
//使用ThreadLocal模式初始化Session
private static ThreadLocal<Session> threadLocal = new ThreadLocal<>();
private static StandardServiceRegistry registry;
private static SessionFactory sessionFactory;
//静态模块初始化Session工厂
static{
//初始化注册服务对象
registry = new StandardServiceRegistryBuilder()
.configure()//默认加载hibernate.cfg.xml,如果配置文件名称被修改：configure("被修改的名字")
.build();
//获取Session工厂
sessionFactory = new MetadataSources(registry)
.buildMetadata()
.buildSessionFactory();
}
//获取Session的方式
public static Session getSession(){
//从线程中获取session
Session session= threadLocal.get();
//判断session是否存在
if(null==session || !session.isOpen()){
//不存在从工厂中获取session
//判断工厂是否存在，不存在重新加载
if(null==sessionFactory)
buildSessionFactory();
//从工厂获取session
session=(null!=sessionFactory)? sessionFactory.openSession() : null;
//放入线程
threadLocal.set(session);
}
return session;
}
//加载session工厂
private static void buildSessionFactory(){
//初始化注册服务对象
registry = new StandardServiceRegistryBuilder()
.configure()//默认加载hibernate.cfg.xml,如果配置文件名称被修改：configure("被修改的名字")
.build();
//获取Session工厂
sessionFactory = new MetadataSources(registry)
.buildMetadata()
.buildSessionFactory();
}
//关闭session
public static void closeSession(Session session){
if(null != session && session.isOpen())
session.close();
}
}
![[学习笔记]解决因C#8.0的语言特性导致EFCore实体类型映射的错误](https://img-blog.csdnimg.cn/091446b0bf6e427992498c4b6b605b40.png)