Hibernate/JPA 中的id概述

- 日理万妓 2023-09-25 12:44 14阅读 0赞

### **1. 概述** ###

Hibernate中的标识符表示实体的主键。这意味着这些值是唯一的，因此它们可以标识特定实体，它们不为 null，也不会被修改。

Hibernate提供了几种不同的方法来定义标识符。在本文中，我们将回顾使用该库映射实体 ID 的每种方法。

### **2. 简单标识符** ###

定义标识符的最直接方法是使用*@Id*注释。

简单 id 使用以下*@Id*映射到以下类型之一的单个属性：Java 原始和原始包装器类型、*字符串*、*日期*、*BigDecimal 和 BigInteger*。

让我们看一个定义主键类型为*long* 的实体的快速示例：

@Entity
    public class Student {
    
        @Id
        private long studentId;
        
        // standard constructor, getters, setters
    }Copy

### **3. 生成的标识符** ###

如果我们想自动生成主键值，**我们可以添加*@GeneratedValue*注释。**

这可以使用四种生成类型：自动、标识、序列和表。

如果我们没有显式指定值，则生成类型默认为 AUTO。

#### **3.1.*自动生成*** ####

如果我们使用默认生成类型，持久性提供程序将根据主键属性的类型确定值。此类型可以是数字或*UUID。*

对于数值，生成基于序列或表生成器，而*UUID*值将使用*UUIDGenerator*。

让我们首先使用 AUTO 生成策略映射实体主键：

@Entity
    public class Student {
    
        @Id
        @GeneratedValue
        private long studentId;
    
        // ...
    }Copy

在这种情况下，主键值在数据库级别是唯一的。

**现在我们来看看在Hibernate 5中引入的*UUIDGenerator*。**

为了使用此功能，我们只需要声明一个*UUID*类型的 id*，带有@GeneratedValue*注释：

@Entity
    public class Course {
    
        @Id
        @GeneratedValue
        private UUID courseId;
    
        // ...
    }Copy

Hibernate将生成一个形式的id“8dd5f315-9788-4d00-87bb-10eed9eff566”。

#### **3.2.*身份*生成** ####

这种类型的生成依赖于*IdentityGenerator*，它需要由数据库中*的标识*列生成的值。这意味着它们是自动递增的。

要使用这种生成类型，我们只需要设置*策略*参数：

@Entity
    public class Student {
    
        @Id
        @GeneratedValue (strategy = GenerationType.IDENTITY)
        private long studentId;
    
        // ...
    }Copy

需要注意的一点是，标识生成会禁用批处理更新。

#### **3.3.*序列*生成** ####

为了使用基于序列的 id，Hibernate 提供了*SequenceStyleGenerator*类。

如果我们的数据库支持序列，则此生成器使用序列。如果不支持表生成，它将切换到表生成。

为了自定义序列名称，我们可以使用带有*SequenceStyleGenerator 策略*的*@GenericGenerator*注释：

@Entity
    public class User {
        @Id
        @GeneratedValue(generator = "sequence-generator")
        @GenericGenerator(
          name = "sequence-generator",
          strategy = "org.hibernate.id.enhanced.SequenceStyleGenerator",
          parameters = {
            @Parameter(name = "sequence_name", value = "user_sequence"),
            @Parameter(name = "initial_value", value = "4"),
            @Parameter(name = "increment_size", value = "1")
            }
        )
        private long userId;
        
        // ...
    }Copy

在此示例中，我们还为序列设置了一个初始值，这意味着主键生成将从 4 开始。

*SEQUENCE*是 Hibernate 文档推荐的生成类型。

**生成的值对于每个序列都是唯一的。**如果我们不指定序列名称，Hibernate将对不同的类型重用相同的*hibernate\_sequence*。

#### **3.4. 表生成** ####

表*生成器*使用保存标识符生成值段的基础数据库表。

让我们使用*@TableGenerator*注释自定义表名：

@Entity
    public class Department {
        @Id
        @GeneratedValue(strategy = GenerationType.TABLE, 
          generator = "table-generator")
        @TableGenerator(name = "table-generator", 
          table = "dep_ids", 
          pkColumnName = "seq_id", 
          valueColumnName = "seq_value")
        private long depId;
    
        // ...
    }Copy

在这个例子中，我们可以看到我们还可以自定义其他属性，例如*pkColumnName 和 valueColumnName*。

但是，此方法的缺点是它不能很好地扩展，并且可能会对性能产生负面影响。

**总而言之，这四种生成类型将导致生成相似的值，但使用不同的数据库机制。**

#### **3.5. 自定义生成器** ####

假设我们不想使用任何开箱即用的策略。为了做到这一点，**我们可以通过实现*IdentifierGenerator*接口来定义我们的自定义生成器。**

我们将创建一个生成器，用于构建包含*字符串*前缀和数字的标识符：

public class MyGenerator 
      implements IdentifierGenerator, Configurable {
    
        private String prefix;
    
        @Override
        public Serializable generate(
          SharedSessionContractImplementor session, Object obj) 
          throws HibernateException {
    
            String query = String.format("select %s from %s", 
                session.getEntityPersister(obj.getClass().getName(), obj)
                  .getIdentifierPropertyName(),
                obj.getClass().getSimpleName());
    
            Stream ids = session.createQuery(query).stream();
    
            Long max = ids.map(o -> o.replace(prefix + "-", ""))
              .mapToLong(Long::parseLong)
              .max()
              .orElse(0L);
    
            return prefix + "-" + (max + 1);
        }
    
        @Override
        public void configure(Type type, Properties properties, 
          ServiceRegistry serviceRegistry) throws MappingException {
            prefix = properties.getProperty("prefix");
        }
    }Copy

在这个例子中，**我们从*IdentifierGenerator*接口覆盖*generate（）* 方法。**

首先，我们要从形式*前缀 XX* 的现有主键中找到最大数字。然后，我们将找到的最大数量加 1，并附加*前缀*属性以获取新生成的 id 值。

我们的类还实现了*可配置*接口，以便我们可以在*configure（）* 方法中设置*前缀*属性值。

接下来，让我们将此自定义生成器添加到实体。

为此，**我们可以将 *@GenericGenerator*注释与包含生成器类的完整类名的策略参数一起使用**：

@Entity
    public class Product {
    
        @Id
        @GeneratedValue(generator = "prod-generator")
        @GenericGenerator(name = "prod-generator", 
          parameters = @Parameter(name = "prefix", value = "prod"), 
          strategy = "com.baeldung.hibernate.pojo.generator.MyGenerator")
        private String prodId;
    
        // ...
    }Copy

另外，请注意，我们已将前缀参数设置为“prod”。

让我们看一个快速的 JUnit 测试，以便更清楚地了解生成的 id 值：

@Test
    public void whenSaveCustomGeneratedId_thenOk() {
        Product product = new Product();
        session.save(product);
        Product product2 = new Product();
        session.save(product2);
    
        assertThat(product2.getProdId()).isEqualTo("prod-2");
    }Copy

此处，使用 “prod” 前缀生成的第一个值是 “prod-1”，后跟 “prod-2”。

### **4. 复合标识符** ###

除了我们目前看到的简单标识符之外，Hibernate还允许我们定义复合标识符。

复合 ID 由具有一个或多个持久属性的主键类表示。

**主键类必须满足以下几个条件**：

*  它应该使用*@EmbeddedId*或*@IdClass*注释来定义。
 *  它应该是公共的、可序列化的，并且有一个公共的无参数构造函数。
 *  最后，它应该实现*equals（*） 和*hashCode（）* 方法。

类的属性可以是基本、复合或多对一，同时避免集合和*一对一*属性。

#### **4.1. *@EmbeddedId*** ####

现在让我们看看如何使用*@EmbeddedId*定义 id。

首先，我们需要一个主键类，注释如下*@Embeddable*：

@Embeddable
    public class OrderEntryPK implements Serializable {
    
        private long orderId;
        private long productId;
    
        // standard constructor, getters, setters
        // equals() and hashCode() 
    }Copy

接下来，我们可以使用 @*EmbeddedId* 将*OrderEntryPK*类型的 id 添加到实体：

@Entity
    public class OrderEntry {
    
        @EmbeddedId
        private OrderEntryPK entryId;
    
        // ...
    }Copy

让我们看看如何使用这种类型的复合 id 来设置实体的主键：

@Test
    public void whenSaveCompositeIdEntity_thenOk() {
        OrderEntryPK entryPK = new OrderEntryPK();
        entryPK.setOrderId(1L);
        entryPK.setProductId(30L);
            
        OrderEntry entry = new OrderEntry();
        entry.setEntryId(entryPK);
        session.save(entry);
    
        assertThat(entry.getEntryId().getOrderId()).isEqualTo(1L);
    }Copy

在这里，*OrderEntry*对象有一个由两个属性组成的*OrderEntryPK*主 ID：*orderId*和*productId*。

#### **4.2. *@IdClass*** ####

*@IdClass*注释类似于*@EmbeddedId*。与*@IdClass*的区别在于，属性是在主实体类中使用*@Id*为每个属性定义的。主键类看起来与以前相同。

让我们用 *@IdClass* 重写*OrderEntry*示例：

@Entity
    @IdClass(OrderEntryPK.class)
    public class OrderEntry {
        @Id
        private long orderId;
        @Id
        private long productId;
        
        // ...
    }Copy

然后我们可以直接在*OrderEntry*对象上设置 id 值：

@Test
    public void whenSaveIdClassEntity_thenOk() {        
        OrderEntry entry = new OrderEntry();
        entry.setOrderId(1L);
        entry.setProductId(30L);
        session.save(entry);
    
        assertThat(entry.getOrderId()).isEqualTo(1L);
    }Copy

请注意，对于这两种类型的复合 ID，主键类还可以包含*@ManyToOne*属性。

Hibernate还允许定义由*@ManyToOne*关联与*@Id*注释组成的主键。在这种情况下，实体类还应满足主键类的条件。

但是，此方法的缺点是实体对象和标识符之间没有分离。

### **5. 派生标识符** ###

派生标识符是使用 *@MapsId*注释从实体的关联中获取的。

首先，让我们创建一个*UserProfile*实体，该实体从与*User*实体的一对一关联中派生其 id：

@Entity
    public class UserProfile {
    
        @Id
        private long profileId;
        
        @OneToOne
        @MapsId
        private User user;
    
        // ...
    }Copy

接下来，让我们验证*用户配置文件*实例是否与其关联的*用户*实例具有相同的 ID：

@Test
    public void whenSaveDerivedIdEntity_thenOk() {        
        User user = new User();
        session.save(user);
           
        UserProfile profile = new UserProfile();
        profile.setUser(user);
        session.save(profile);
    
        assertThat(profile.getProfileId()).isEqualTo(user.getUserId());
    }Copy

### **6. 结论** ###

在本文中，我们已经了解了在 Hibernate 中定义标识符的多种方法。

这些示例的完整源代码可以在[GitHub 上][GitHub]找到。

[GitHub]: https://github.com/eugenp/tutorials/tree/master/persistence-modules/hibernate5