Hibernate（12）什么是Hibernate的实体类？

Hibernate的实体类（Entity Class）是与数据库表映射的Java类。每个实体类对应数据库中的一个表，类中的每个属性对应表中的一列。实体类使用Java持久化API (JPA)的注解或者Hibernate特有的注解来标注，定义类和表之间的映射关系。

主要特点

1. 类-表映射：实体类与数据库表的映射。
2. 属性-列映射：类的属性与表的列的映射。
3. 主键标识：使用注解标识主键。
4. 关系映射：支持一对一、一对多、多对一和多对多等关联关系。

示例项目结构

为了深入理解Hibernate的实体类，下面是一个完整的示例，包括如何配置Hibernate文件、定义实体类、以及简单的CRUD操作。

配置文件 hibernate.cfg.xml

<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://hibernate.sourceforge.net/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/your_database</property>
        <property name="hibernate.connection.username">your_username</property>
        <property name="hibernate.connection.password">your_password</property>

        <!-- Hibernate 属性配置 -->
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
        <property name="hibernate.show_sql">true</property>
        <property name="hibernate.format_sql">true</property>
        <property name="hibernate.hbm2ddl.auto">update</property>

        <!-- 映射类配置 -->
        <mapping class="com.example.domain.Student"/>
    </session-factory>
</hibernate-configuration>

HibernateUtil 类

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

public class HibernateUtil {
    private static final SessionFactory sessionFactory;

    static {
        try {
            // 从配置文件创建SessionFactory
            sessionFactory = new Configuration().configure("hibernate.cfg.xml").buildSessionFactory();
        } catch (Throwable ex) {
            // 记录启动失败的错误
            System.err.println("Initial SessionFactory creation failed." + ex);
            throw new ExceptionInInitializerError(ex);
        }
    }

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

实体类 Student

package com.example.domain;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Student {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    private String name;
    private int age;

    public Student() {}

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // getters 和 setters
    public Long getId() {
        return id;
    }

    public void setId(Long 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;
    }
}

使用实体类进行CRUD操作

下面是一个示例，演示如何使用Hibernate的实体类进行CRUD操作。

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;

public class HibernateCRUDExample {
    public static void main(String[] args) {
        // 获取SessionFactory
        SessionFactory sessionFactory = HibernateUtil.getSessionFactory();
        Session session = null;
        Transaction transaction = null;

        // 创建对象并保存到数据库
        try {
            session = sessionFactory.openSession();
            transaction = session.beginTransaction();

            Student student = new Student("John Doe", 20);
            session.save(student); // 持久化对象

            transaction.commit();
        } catch (Exception e) {
            if (transaction != null) {
                transaction.rollback();
            }
            e.printStackTrace();
        } finally {
            if (session != null) {
                session.close();
            }
        }

        // 读取对象
        try {
            session = sessionFactory.openSession();
            Student student = session.get(Student.class, 1L);
            System.out.println("Student: " + student.getName() + ", Age: " + student.getAge());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (session != null) {
                session.close();
            }
        }

        // 更新对象
        try {
            session = sessionFactory.openSession();
            transaction = session.beginTransaction();

            Student student = session.get(Student.class, 1L);
            if (student != null) {
                student.setAge(21);
                session.update(student); // 更新对象
            }

            transaction.commit();
        } catch (Exception e) {
            if (transaction != null) {
                transaction.rollback();
            }
            e.printStackTrace();
        } finally {
            if (session != null) {
                session.close();
            }
        }

        // 删除对象
        try {
            session = sessionFactory.openSession();
            transaction = session.beginTransaction();

            Student student = session.get(Student.class, 1L);
            if (student != null) {
                session.delete(student); // 删除对象
            }

            transaction.commit();
        } catch (Exception e) {
            if (transaction != null) {
                transaction.rollback();
            }
            e.printStackTrace();
        } finally {
            if (session != null) {
                session.close();
            }
        }

        // 关闭SessionFactory
        sessionFactory.close();
    }
}

详细解释

1. 实体类定义 ：通过@Entity注解将类标识为Hibernate的实体类。@Id注解标识主键，@GeneratedValue注解指定主键生成策略。

   @Entity
   public class Student {
       @Id
       @GeneratedValue(strategy = GenerationType.IDENTITY)
       private Long id;
       private String name;
       private int age;
   }

2. 创建并保存对象 ：使用session.save(student)方法将实体对象持久化到数据库中。

   Student student = new Student("John Doe", 20);
   session.save(student);

3. 读取对象 ：使用session.get(Student.class, 1L)方法从数据库中读取实体对象。

   Student student = session.get(Student.class, 1L);

4. 更新对象 ：先从数据库中读取对象，然后修改对象属性，最后使用session.update(student)方法同步修改到数据库。

   Student student = session.get(Student.class, 1L);
   student.setAge(21);
   session.update(student);

5. 删除对象 ：先从数据库中读取对象，然后使用session.delete(student)方法删除对象。

   Student student = session.get(Student.class, 1L);
   session.delete(student);

事务管理

在进行增删改操作时，需要开启事务，并在操作完成后提交事务。如果操作失败，则回滚事务以确保数据一致性。

Transaction transaction = session.beginTransaction();
try {
    // 持久化操作
    transaction.commit();
} catch (Exception e) {
    if (transaction != null) {
        transaction.rollback();
    }
    e.printStackTrace();
}

总结

Hibernate的实体类是Java类与数据库表结构映射的核心。通过JPA注解，实体类定义了持久化对象的属性和行为，并与数据库表的结构紧密结合。通过Hibernate提供的API，可以方便地对实体类进行CRUD操作，实现数据的持久化管理。理解Hibernate的实体类及其使用方法，对于高效地管理数据库和实现数据持久化具有重要意义。