Hibernate入门教程：ORM 框架原理，实体类映射​

在计算机编程的世界里，对象关系映射（ORM）是一项非常重要的技术，而 Hibernate 作为一款优秀的 ORM 框架，在 Java 开发中有着广泛的应用。下面，咱们就来深入了解一下 Hibernate 的相关知识，包括 ORM 框架原理以及实体类映射。

一、ORM 框架原理

1.1 什么是 ORM

在传统的数据库操作中，我们需要编写大量的 SQL 语句来实现数据的增删改查。而 ORM（Object Relational Mapping），也就是对象关系映射，它的出现就是为了解决这个问题。简单来说，ORM 是一种将数据库中的表与编程语言中的对象进行映射的技术。通过 ORM，我们可以使用面向对象的方式来操作数据库，而不需要直接编写 SQL 语句。

1.2 ORM 的工作原理

ORM 的工作原理主要分为以下几个步骤：

• 对象与表的映射：将数据库中的表映射为编程语言中的类，表中的字段映射为类的属性。
• 对象的持久化：当我们创建一个对象并对其进行操作时，ORM 框架会将对象的状态持久化到数据库中。
• 对象的查询：当我们需要从数据库中查询数据时，ORM 框架会将查询条件转换为 SQL 语句，并将查询结果封装成对象返回。

1.3 ORM 的优势

• 提高开发效率：使用 ORM 可以避免编写大量的 SQL 语句，减少了开发时间和工作量。
• 提高代码的可维护性：将数据库操作封装在对象中，使代码更加清晰和易于维护。
• 跨数据库支持：ORM 框架可以支持多种数据库，方便我们在不同的数据库之间进行切换。

二、Hibernate 简介

2.1 Hibernate 是什么

Hibernate 是一个开源的 Java ORM 框架，它提供了一种简单而强大的方式来将 Java 对象映射到数据库表中。Hibernate 可以帮助我们处理数据库的连接、事务管理、SQL 生成等复杂的任务，让我们可以专注于业务逻辑的开发。

2.2 Hibernate 的特点

• 功能强大：Hibernate 支持多种数据库，包括 MySQL、Oracle、SQL Server 等。
• 性能优化：Hibernate 提供了多种性能优化策略，如缓存机制、延迟加载等。
• 易于集成：Hibernate 可以与 Spring、Struts 等 Java 框架集成，方便我们进行企业级应用开发。

三、Hibernate 的环境搭建

3.1 下载 Hibernate

首先，我们需要从 Hibernate 的官方网站（https://hibernate.org/orm/downloads/）下载 Hibernate 的最新版本。下载完成后，将解压后的文件夹中的相关 JAR 文件添加到我们的项目中。

3.2 配置 Hibernate

在项目中创建一个名为 hibernate.cfg.xml 的配置文件，用于配置 Hibernate 的相关信息。以下是一个简单的 hibernate.cfg.xml 配置文件示例：

<?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>
        <!-- 数据库连接信息 -->
        <property name="hibernate.connection.driver_class">com.mysql.cj.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/testdb</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">password</property>

        <!-- 数据库方言 -->
        <property name="hibernate.dialect">org.hibernate.dialect.MySQL8Dialect</property>

        <!-- 显示 SQL 语句 -->
        <property name="hibernate.show_sql">true</property>

        <!-- 自动创建数据库表 -->
        <property name="hibernate.hbm2ddl.auto">update</property>

        <!-- 映射文件 -->
        <mapping resource="com/example/model/User.hbm.xml"/>
    </session-factory>
</hibernate-configuration>

3.3 创建实体类

在 Java 项目中创建一个实体类，用于映射数据库中的表。以下是一个简单的 User 实体类示例：

package com.example.model;

// 用户实体类
public class User {
    private int id;
    private String name;
    private int age;

    // 无参构造函数
    public User() {
    }

    // 有参构造函数
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Getter 和 Setter 方法
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

3.4 创建映射文件

创建一个 User.hbm.xml 映射文件，用于将 User 实体类映射到数据库中的 users 表。以下是一个简单的 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>
    <class name="com.example.model.User" table="users">
        <id name="id" column="id">
            <generator class="native"/>
        </id>
        <property name="name" column="name"/>
        <property name="age" column="age"/>
    </class>
</hibernate-mapping>

四、实体类映射

4.1 主键映射

在 Hibernate 中，主键映射是非常重要的。我们可以使用 <id> 标签来映射实体类的主键。以下是几种常见的主键生成策略：

• native：根据数据库的不同，自动选择合适的主键生成策略，如 MySQL 的自增长主键。
• assigned：由应用程序手动指定主键的值。
• uuid：使用 UUID 作为主键。

4.2 属性映射

使用 <property> 标签来映射实体类的属性。以下是一个简单的属性映射示例：

<property name="name" column="name"/>

4.3 关联映射

在实际开发中，我们经常会遇到表与表之间的关联关系，如一对一、一对多、多对多等。Hibernate 提供了丰富的关联映射机制，帮助我们处理这些关联关系。

4.3.1 一对一关联映射

以下是一个简单的一对一关联映射示例：

// 主实体类
public class Person {
    private int id;
    private String name;
    private Address address;

    // Getter 和 Setter 方法
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }
}

// 关联实体类
public class Address {
    private int id;
    private String street;
    private Person person;

    // Getter 和 Setter 方法
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getStreet() {
        return street;
    }

    public void setStreet(String street) {
        this.street = street;
    }

    public Person getPerson() {
        return person;
    }

    public void setPerson(Person person) {
        this.person = person;
    }
}

<!-- Person.hbm.xml -->
<hibernate-mapping>
    <class name="com.example.model.Person" table="persons">
        <id name="id" column="id">
            <generator class="native"/>
        </id>
        <property name="name" column="name"/>
        <one-to-one name="address" class="com.example.model.Address" cascade="all"/>
    </class>
</hibernate-mapping>

<!-- Address.hbm.xml -->
<hibernate-mapping>
    <class name="com.example.model.Address" table="addresses">
        <id name="id" column="id">
            <generator class="foreign">
                <param name="property">person</param>
            </generator>
        </id>
        <property name="street" column="street"/>
        <one-to-one name="person" class="com.example.model.Person" constrained="true"/>
    </class>
</hibernate-mapping>

4.3.2 一对多关联映射

以下是一个简单的一对多关联映射示例：

// 主实体类
public class Department {
    private int id;
    private String name;
    private List<Employee> employees;

    // Getter 和 Setter 方法
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public List<Employee> getEmployees() {
        return employees;
    }

    public void setEmployees(List<Employee> employees) {
        this.employees = employees;
    }
}

// 关联实体类
public class Employee {
    private int id;
    private String name;
    private Department department;

    // Getter 和 Setter 方法
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Department getDepartment() {
        return department;
    }

    public void setDepartment(Department department) {
        this.department = department;
    }
}

<!-- Department.hbm.xml -->
<hibernate-mapping>
    <class name="com.example.model.Department" table="departments">
        <id name="id" column="id">
            <generator class="native"/>
        </id>
        <property name="name" column="name"/>
        <set name="employees" cascade="all">
            <key column="department_id"/>
            <one-to-many class="com.example.model.Employee"/>
        </set>
    </class>
</hibernate-mapping>

<!-- Employee.hbm.xml -->
<hibernate-mapping>
    <class name="com.example.model.Employee" table="employees">
        <id name="id" column="id">
            <generator class="native"/>
        </id>
        <property name="name" column="name"/>
        <many-to-one name="department" class="com.example.model.Department" column="department_id"/>
    </class>
</hibernate-mapping>

4.3.3 多对多关联映射

以下是一个简单的多对多关联映射示例：

// 主实体类
public class Student {
    private int id;
    private String name;
    private List<Course> courses;

    // Getter 和 Setter 方法
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public List<Course> getCourses() {
        return courses;
    }

    public void setCourses(List<Course> courses) {
        this.courses = courses;
    }
}

// 关联实体类
public class Course {
    private int id;
    private String name;
    private List<Student> students;

    // Getter 和 Setter 方法
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public List<Student> getStudents() {
        return students;
    }

    public void setStudents(List<Student> students) {
        this.students = students;
    }
}

<!-- Student.hbm.xml -->
<hibernate-mapping>
    <class name="com.example.model.Student" table="students">
        <id name="id" column="id">
            <generator class="native"/>
        </id>
        <property name="name" column="name"/>
        <set name="courses" table="student_course" cascade="all">
            <key column="student_id"/>
            <many-to-many class="com.example.model.Course" column="course_id"/>
        </set>
    </class>
</hibernate-mapping>

<!-- Course.hbm.xml -->
<hibernate-mapping>
    <class name="com.example.model.Course" table="courses">
        <id name="id" column="id">
            <generator class="native"/>
        </id>
        <property name="name" column="name"/>
        <set name="students" table="student_course" inverse="true">
            <key column="course_id"/>
            <many-to-many class="com.example.model.Student" column="student_id"/>
        </set>
    </class>
</hibernate-mapping>

五、Hibernate 的基本操作

5.1 创建 SessionFactory

在 Hibernate 中，SessionFactory 是一个重量级的对象，它负责创建 Session 对象。以下是创建 SessionFactory 的示例代码：

import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

// 创建 SessionFactory
public class HibernateUtil {
    private static final SessionFactory sessionFactory;

    static {
        try {
            // 加载配置文件
            Configuration configuration = new Configuration().configure();
            // 创建 SessionFactory
            sessionFactory = configuration.buildSessionFactory();
        } catch (Throwable ex) {
            throw new ExceptionInInitializerError(ex);
        }
    }

    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }
}

5.2 保存数据

以下是使用 Hibernate 保存数据的示例代码：

import org.hibernate.Session;
import org.hibernate.Transaction;
import com.example.model.User;

// 保存数据
public class SaveDataExample {
    public static void main(String[] args) {
        // 获取 Session
        Session session = HibernateUtil.getSessionFactory().openSession();
        Transaction transaction = null;

        try {
            // 开始事务
            transaction = session.beginTransaction();

            // 创建 User 对象
            User user = new User("John", 25);

            // 保存 User 对象
            session.save(user);

            // 提交事务
            transaction.commit();
        } catch (Exception e) {
            if (transaction != null) {
                // 回滚事务
                transaction.rollback();
            }
            e.printStackTrace();
        } finally {
            // 关闭 Session
            session.close();
        }
    }
}

5.3 查询数据

以下是使用 Hibernate 查询数据的示例代码：

import org.hibernate.Session;
import com.example.model.User;
import java.util.List;

// 查询数据
public class QueryDataExample {
    public static void main(String[] args) {
        // 获取 Session
        Session session = HibernateUtil.getSessionFactory().openSession();

        try {
            // 查询所有 User 对象
            List<User> users = session.createQuery("from User", User.class).list();

            // 遍历 User 对象
            for (User user : users) {
                System.out.println("ID: " + user.getId() + ", Name: " + user.getName() + ", Age: " + user.getAge());
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 关闭 Session
            session.close();
        }
    }
}