hibernate入门项目（一）

hibernate入门项目：IDEAMaven

星空彼岸007

767人浏览 · 2023-05-18 17:19:28

星空彼岸007 · 2023-05-18 17:19:28 发布

本节我们将演示如何搭建一个 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();
    }
}