原文： https://howtodoinjava.com/hibernate/hibernate-3-introduction-and-writing-hello-world-application/

Hibernate 由 Gavin King 在 2001 年启动，它是使用 EJB2 样式实体 bean 的替代方法。 当时，它的任务是通过简化复杂性并允许缺少功能来为 EJB2 提供更好的持久化。

Hibernate 使用其映射文件和配置文件来实现其目标。 随着 JDK 1.5 在 Java 社区中引入注解，Hibernate 社区开始致力于支持注解的 Hibernate 3。 Hiberate 的当前版本是Hiberate 5。

在带有注解的 Hiberate 示例中，我们将学习有关 Hiberate 的更多信息，并逐步为初学者构建第一个正在运行的示例应用。

  1. Table of Contents
  3. What is hibernate
  4. How hibernate works
  5. Relation of hibernate with JPA
  6. Hibernate HelloWorld example

什么是 Hibernate

Hibernate 是 Java 的开源对象关系映射工具。 它提供了一个框架，用于将面向对象的域模型映射到传统的关系数据库。 Hibernate 不仅负责从 Java 类到数据库表（以及从 Java 数据类型到 SQL 数据类型）的映射，而且还提供数据查询和检索功能，并且可以显着减少开发时间，否则将花费大量时间在 SQL 和 JDBC 中进行手动数据处理 。

通过配置 XML 文件或使用 Java 注解将 Java 类映射到数据库表。 提供了用于安排类之间的一对多和多对多关系的设施。

除了管理对象之间的关联之外，Hibernate 还可以管理自反关联，其中对象与自己类型的其他实例具有一对多关系。

Hibernate 如何运作

Hiberate 不会妨碍我们； 也不会迫使我们改变对象的行为方式。 这些对象无需实现任何神奇的接口即可拥有持久的能力。 我们要做的全部工作是将一些元数据放入注解的形式，这些注解告诉 hibernate 在与数据库映射时如何使用它们。 在运行时，hibernate 读取这些注解并使用此信息来构建查询以发送到某些关系数据库。

Hibernate 中有一个简单直观的 API，可以对数据库表示的对象执行查询，以更改我们通常在程序中与它们正常交互的那些对象，然后告诉 Hibernate 保存更改。 创建新对象也同样简单。 我们只是以常规方式创建它们，并使用注解将它们告知 Hibernate，以便它们可以存储到数据库中。

Hiberate 与 JPA 的关系

JPA（Java 持久化 API）是持久化供应器要实现的规范。 Hibernate 就是这样的 JPA 规范的实现。 我们可以使用 JPA 注解对注解进行尽可能多的注解，但是如果没有实现，将不会发生任何事情。

可以将 JPA 视为必须遵循的准则/规范或接口，而 Hibernate JPA 实现是符合 JPA 定义的 API 并提供底层功能的代码。

当我们将 Hibernate 与 JPA 一起使用时，实际上是在使用 Hibernate JPA 实现。 这样做的好处是我们可以将 JPA 的 Hiberate 实现换成 JPA 规范的另一种实现。

当我们使用直接 Hiberate 时，由于其他 ORM 可能使用不同的方法/配置和注解，因此您将锁定到实现中，因此我们不能仅切换到另一个 ORM。

Java Hibernate HelloWorld 示例

让我们逐步创建一个 Hiberate 的 HelloWorld 示例。 在此示例中，我创建了一个Employee类并声明了四个属性id，email，firstname和lastname。

我希望id属性应自动生成，以便应用代码不存储员工 ID 的本地缓存。

到目前为止，我们的目标是要在第一个应用中进行制作。 让我们确定需要创建的文件。

  1. hibernate.cfg.xml - 此配置文件将用于存储数据库连接信息和架构级别设置。
  2. EmployeeEntity.java - 此类将引用具有 Hiberate 注解的 Java POJO。
  3. HibernateUtil.java – 此类将具有工具方法，这些方法将用于创建会话工厂和会话对象。
  4. TestHibernate.java - 此类将用于测试我们的配置设置和Emplyee实体注解。

在进入代码之前，让我们看一下项目的设置并添加 maven 依赖项，这些依赖项需要添加到pom.xml以包括所有编译时间和运行时依赖项。

1. 创建一个 Maven 项目

Hibernate 示例 – HelloWorld 示例逐步简介 - 图1

2. 使项目支持 Eclipse

Hibernate 示例 – HelloWorld 示例逐步简介 - 图2

3. 将 Java 项目导入到 Eclipse 工作区

Hibernate 示例 – HelloWorld 示例逐步简介 - 图3

以上步骤将创建最小设置。 现在该添加 Hiberate 依赖项了。

4. Hiberate Maven 依赖项

  1. <dependency>
  2.     <groupid>org.hibernate</groupid>
  3.     <artifactid>hibernate-commons-annotations</artifactid>
  4.     <version>3.0.0.ga</version>
  5. </dependency>
  6. <dependency>
  7.     <groupid>org.hibernate</groupid>
  8.     <artifactid>hibernate-annotations</artifactid>
  9.     <version>3.3.0.ga</version>
  10. </dependency>
  11. <dependency>
  12.     <groupid>mysql</groupid>
  13.     <artifactid>mysql-connector-java</artifactid>
  14.     <version>5.1.6</version>
  15. </dependency>
  16. <dependency>
  17.     <groupid>antlr</groupid>
  18.     <artifactid>antlr</artifactid>
  19.     <version>2.7.6</version>
  20. </dependency>
  21. <dependency>
  22.     <groupid>commons-collections</groupid>
  23.     <artifactid>commons-collections</artifactid>
  24.     <version>3.1</version>
  25. </dependency>
  26. <dependency>
  27.     <groupid>dom4j</groupid>
  28.     <artifactid>dom4j</artifactid>
  29.     <version>1.6.1</version>
  30. </dependency>
  31. <dependency>
  32.     <groupid>javassist</groupid>
  33.     <artifactid>javassist</artifactid>
  34.     <version>3.4.GA</version>
  35. </dependency>
  36. <dependency>
  37.     <groupid>javax.transaction</groupid>
  38.     <artifactid>jta</artifactid>
  39.     <version>1.1</version>
  40. </dependency>
  41. <dependency>
  42.     <groupid>org.slf4j</groupid>
  43.     <artifactid>slf4j-api</artifactid>
  44.     <version>1.5.6</version>
  45. </dependency>
  46. <dependency>
  47.     <groupid>org.slf4j</groupid>
  48.     <artifactid>slf4j-log4j12</artifactid>
  49.     <version>1.5.6</version>
  50. </dependency>

请注意，在此 Hiberate 示例中，我们并没有使用所有的 Maven 依赖项，但是当我们开始扩展应用时将使用它们。

5. Hiberate 配置

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <!DOCTYPE hibernate-configuration PUBLIC
  3. "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
  4. "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
  5. <hibernate-configuration>
  6.     <session-factory>
  7.         <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
  8.         <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernatetest</property>
  9.         <property name="hibernate.connection.password">lg225295</property>
  10.         <property name="hibernate.connection.username">root</property>
  11.         <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
  12.         <property name="show_sql">true</property>
  13.         <property name="hbm2ddl.auto">update</property>
  14.         <mapping class="hibernate.test.dto.EmployeeEntity"></mapping>
  15.     </session-factory>
  16. </hibernate-configuration>

运行此 Hiberate 示例之前，请不要忘记设置正确的密码。

6. Hiberate 实体类

  1. package hibernate.test.dto;
  3. import java.io.Serializable;
  5. import javax.persistence.Column;
  6. import javax.persistence.Entity;
  7. import javax.persistence.GeneratedValue;
  8. import javax.persistence.GenerationType;
  9. import javax.persistence.Id;
  10. import javax.persistence.Table;
  11. import javax.persistence.UniqueConstraint;
  13. import org.hibernate.annotations.OptimisticLockType;
  15. @Entity
  16. @org.hibernate.annotations.Entity(optimisticLock = OptimisticLockType.ALL)
  17. @Table(name = "Employee", uniqueConstraints = {
  18.         @UniqueConstraint(columnNames = "ID"),
  19.         @UniqueConstraint(columnNames = "EMAIL") })
  20. public class EmployeeEntity implements Serializable {
  22.     private static final long serialVersionUID = -1798070786993154676L;
  24.     @Id
  25.     @GeneratedValue(strategy = GenerationType.IDENTITY)
  26.     @Column(name = "ID", unique = true, nullable = false)
  27.     private Integer employeeId;
  29.     @Column(name = "EMAIL", unique = true, nullable = false, length = 100)
  30.     private String email;
  32.     @Column(name = "FIRST_NAME", unique = false, nullable = false, length = 100)
  33.     private String firstName;
  35.     @Column(name = "LAST_NAME", unique = false, nullable = false, length = 100)
  36.     private String lastName;
  38.     // Accessors and mutators for all four fields
  39. }

7. Hiberate 会话工厂

  1. package hibernate.test;
  3. import java.io.File;
  5. import org.hibernate.SessionFactory;
  6. import org.hibernate.cfg.AnnotationConfiguration;
  8. public class HibernateUtil 
  9. {
  10.     private static final SessionFactory sessionFactory = buildSessionFactory();
  12.     private static SessionFactory buildSessionFactory() 
  13.     {
  14.         try {
  15.             // Create the SessionFactory from hibernate.cfg.xml
  16.             return new AnnotationConfiguration().configure(
  17.                     new File("hibernate.cgf.xml")).buildSessionFactory();
  19.         } catch (Throwable ex) {
  20.             // Make sure you log the exception, as it might be swallowed
  21.             System.err.println("Initial SessionFactory creation failed." + ex);
  22.             throw new ExceptionInInitializerError(ex);
  23.         }
  24.     }
  26.     public static SessionFactory getSessionFactory() {
  27.         return sessionFactory;
  28.     }
  30.     public static void shutdown() {
  31.         // Close caches and connection pools
  32.         getSessionFactory().close();
  33.     }
  34. }

请不要忘记使用hibernate.cgf.xml的正确路径。

8. 演示

  1. package hibernate.test;
  3. import hibernate.test.dto.EmployeeEntity;
  4. import org.hibernate.Session;
  6. public class TestHibernate {
  8.     public static void main(String[] args) {
  9.         Session session = HibernateUtil.getSessionFactory().openSession();
  10.         session.beginTransaction();
  12.         // Add new Employee object
  13.         EmployeeEntity emp = new EmployeeEntity();
  14.         emp.setEmail("demo-user@mail.com");
  15.         emp.setFirstName("demo");
  16.         emp.setLastName("user");
  18.         session.save(emp);
  20.         session.getTransaction().commit();
  21.         HibernateUtil.shutdown();
  22.     }
  23. }

上面的代码将在数据库中创建一个新的表Employee，并在此表中插入一行。 在日志中，您可以验证已执行的插入语句。

  1. Hibernate: insert into Employee (EMAIL, FIRST_NAME, LAST_NAME) values (?, ?, ?)

如果您在运行 Hiberate 的 HelloWorld 示例时遇到问题，请给我评论，我将很高兴与您讨论问题。

学习愉快！

下载源码

参考文献：

Hiberate 首页