# 逆向工程

> For the complete documentation index, see [llms.txt](https://www.jetbrains.com.cn/help/idea/llms.txt).

> **TL;DR**
> 必需插件： [Reverse Engineering](https://plugins.jetbrains.com/plugin/23738-reverse-engineering)（捆绑）

逆向工程是基于数据库模式搭建 JPA 实体类的过程。

[Video](https://www.youtube.com/v/Lr_zg_uhWW4)

Procedure: 从数据库生成实体

1. 确保 IntelliJ IDEA 已 [连接到数据库](managing-data-sources.html#create_a_data_source)。

> **Tip:**
> 如果项目使用 [Spring](spring-support.html)、 [Micronaut](micronaut.html) 或 [Quarkus](quarkus.html)，可以直接从配置文件（  `application.properties`  或  `application.yml` ）快速创建数据库连接。
>
>
>
> 为此，请在编辑器中打开该文件，然后在编辑器装订区域中点击 ![数据库连接图标](https://resources.jetbrains.com.cn/help/img/idea/2026.3/javaee-persistence-impl.icons.expui.add-db-from-config.svg)   从现有属性创建新数据源  。

2. 打开 [Database](database-tool-window.html) 工具窗口，右键点击数据库，然后选择 ![带蓝色表的数据库图标](https://resources.jetbrains.com.cn/help/img/idea/2026.3/intellij.platform.ide.expui.javaee.persistenceEntity.svg)   从数据库创建实体……  。

![从数据库创建 JPA 实体操作](https://resources.jetbrains.com.cn/help/img/idea/2026.3/reverse_engineering_create_entity_action.png)

* 或者，打开 [Persistence](persistence-tool-window.html) 工具窗口，右键点击持久化单元或映射上下文，然后选择 `![加号图标](https://resources.jetbrains.com.cn/help/img/idea/2026.3/intellij.platform.ide.expui.general.add.svg) 新建 | ![带蓝色表的数据库图标](https://resources.jetbrains.com.cn/help/img/idea/2026.3/intellij.platform.ide.expui.javaee.persistenceEntity.svg) 来自数据库的实体……` 。

3. 在打开的 [从数据库获取实体对话框](#entities-from-db-dialog)中，配置实体映射并点击   OK  。

## 逆向工程列

一些开发者更喜欢 DB-first 应用程序开发方法。 首先， 他们直接向数据库添加列，然后更新 JPA 模型。 IntelliJ IDEA 可以自动化此过程。

Procedure: 从数据库生成实体特性

1. 确保 IntelliJ IDEA 已 [连接到数据库](managing-data-sources.html#create_a_data_source)。

2. 打开 [数据库](database-tool-window.html)工具窗口，右键点击一个表，然后选择 ![带蓝色表的数据库图标](https://resources.jetbrains.com.cn/help/img/idea/2026.3/intellij.platform.ide.expui.javaee.persistenceEntity.svg)   从数据库创建实体特性…  。

![从数据库创建实体特性操作](https://resources.jetbrains.com.cn/help/img/idea/2026.3/create_entity_attributes_action.png)

* 或者，打开 [Persistence](persistence-tool-window.html) 工具窗口，右键点击实体，然后选择 `![加号图标](https://resources.jetbrains.com.cn/help/img/idea/2026.3/intellij.platform.ide.expui.general.add.svg) 新建 | ![带蓝色表的数据库图标](https://resources.jetbrains.com.cn/help/img/idea/2026.3/intellij.platform.ide.expui.javaee.persistenceEntity.svg) 来自数据库的实体特性` 。

> **Tip:**
> 也可以从任何实体类调用此操作。 为此，请转到其声明，并在编辑器装订区域中选择  `![带蓝色表的数据库图标](https://resources.jetbrains.com.cn/help/img/idea/2026.3/intellij.platform.ide.expui.javaee.persistenceEntity.svg) 显示实体操作 | ![带蓝色表的数据库图标](https://resources.jetbrains.com.cn/help/img/idea/2026.3/intellij.platform.ide.expui.javaee.persistenceEntity.svg) 从数据库创建实体特性……` 。

3. 在打开的 [从数据库获取实体对话框](#entities-from-db-dialog)中，配置实体映射并点击   OK  。

## 智能引用检测

IntelliJ IDEA 深刻理解您的模型。 在某些情况下，可以正确检测基数：  `@OneToOne` 、  `@OneToMany` 、  `@ManyToOne` 、  `@ManyToMany` 。 最酷的是，IntelliJ IDEA 即使在当前表格中没有相应列的情况下也能显示引用。

[Video](https://www.youtube.com/v/VYdpesbhND4)

让我们更仔细地看看这些情况。

### @OneToOne

在两种情况下，我们可以自信地假设关系的基数为  `@OneToOne` ：

1.  表中有一列带有唯一约束，引用了另一个表的主键

2.  表的主键是外键

情况 1：

```SQL
CREATE TABLE profiles
  (
      id        BIGINT GENERATED BY DEFAULT AS IDENTITY NOT NULL,
      join_date date,
      user_id BIGINT,
      status    VARCHAR(255),
      bio       VARCHAR(255),
      CONSTRAINT pk_profiles PRIMARY KEY (id)
  );

  CREATE TABLE users
  (
      id         BIGINT GENERATED BY DEFAULT AS IDENTITY NOT NULL,
      last_name  VARCHAR(255),
      first_name VARCHAR(255),
      CONSTRAINT pk_users PRIMARY KEY (id)
  );

  ALTER TABLE profiles
      ADD CONSTRAINT uc_profiles_user UNIQUE (user_id);

  ALTER TABLE profiles
      ADD CONSTRAINT FK_PROFILES_ON_USER FOREIGN KEY (user_id) REFERENCES users (id);

```

![one-to-one-uc-diagram.jpeg](https://resources.jetbrains.com.cn/help/img/idea/2026.3/one-to-one-uc-diagram.png)

![one-to-one-uc-wizard](https://resources.jetbrains.com.cn/help/img/idea/2026.3/one-to-one-uc-wizard.jpeg)

IntelliJ IDEA将在 User 实体中生成一个  `@OneToOne` 关联，具有一个  `@JoinColumn` 注解，并在 Profile 实体中生成一个  `@OneToOne` 关联，具有一个  `mappedBy` 参数：

```JAVA
@Entity
@Table(name = "users")
public class User {
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  @Column(name = "id", nullable = false)
  private Long id;

  @OneToOne(fetch = FetchType.LAZY)
  @JoinColumn(name = "profile_id")
  private Profile profile;
}

@Entity
@Table(name = "profiles")
public class Profile {
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  @Column(name = "id", nullable = false)
  private Long id;

  @OneToOne(fetch = FetchType.LAZY, mappedBy = "profile")
  private User users;
}

```

案例编号 2：

```SQL
CREATE TABLE users
(
    id BIGINT GENERATED BY DEFAULT AS IDENTITY NOT NULL,
    last_name VARCHAR(255),
    first_name VARCHAR(255),
    CONSTRAINT pk_users PRIMARY KEY (id)
);

CREATE TABLE profiles
(
    user_id BIGINT NOT NULL,
    status VARCHAR(255),
    bio VARCHAR(255),
    join_date date,
    CONSTRAINT pk_profiles PRIMARY KEY (user_id)
);

ALTER TABLE profiles
    ADD CONSTRAINT FK_PROFILES_ON_USER FOREIGN KEY (user_id) REFERENCES users (id);

```

![one-to-one-pk-fk-diagram.jpeg](https://resources.jetbrains.com.cn/help/img/idea/2026.3/one-to-one-pk-fk-diagram.png)

![one-to-one-pk-fk-wizard.jpeg](https://resources.jetbrains.com.cn/help/img/idea/2026.3/one-to-one-pk-fk-wizard.jpeg)

由于  `@Id`  不应是持久化实体，IntelliJ IDEA 将生成：

* 基本类型的 `id` 属性并使用 `@Id` 注解对其进行标记

* `users` `@OneToOne` 关联并使用 `@MapsId` 注解标记

```JAVA
@Entity
@Table(name = "profiles")
public class Profile {
  @Id
  @Column(name = "user_id", nullable = false)
  private Long id;

  @MapsId
  @OneToOne(fetch = FetchType.LAZY, optional = false)
  @JoinColumn(name = "user_id", nullable = false)
  private User users;

  //...
}

@Entity
@Table(name = "users")
public class User {
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  @Column(name = "id", nullable = false)
  private Long id;

  @OneToOne(fetch = FetchType.LAZY, mappedBy = "user")
  private Profile profiles;

  //...
}

```

### @OneToMany & @ManyToOne

如果一个表具有指向另一个表的主键的列，则很可能是一个  `@ManyToOne` 关联。 但是您也可以根据需要将基数更改为  `@OneToOne` 。 因此，取决于您在哪个表上调用反向工程操作，IntelliJ IDEA 将检测映射类型为  `@OneToMany`  或  `@ManyToOne` ：

```SQL
CREATE TABLE users
(
    id BIGINT GENERATED BY DEFAULT AS IDENTITY NOT NULL,
    last_name VARCHAR(255),
    first_name VARCHAR(255),
    CONSTRAINT pk_users PRIMARY KEY (id)
);

CREATE TABLE profiles
(
    id BIGINT GENERATED BY DEFAULT AS IDENTITY NOT NULL,
    join_date date,
    status VARCHAR(255),
    bio VARCHAR(255),
    user_id BIGINT,
    CONSTRAINT pk_profiles PRIMARY KEY (id)
);

ALTER TABLE profiles
    ADD CONSTRAINT FK_PROFILES_ON_USER FOREIGN KEY (user_id) REFERENCES users (id);

```

![one-to-many-many-to-one-diagram](https://resources.jetbrains.com.cn/help/img/idea/2026.3/one-to-many-many-to-one-diagram.png)

![one-to-many-many-to-one-wizard](https://resources.jetbrains.com.cn/help/img/idea/2026.3/one-to-many-many-to-one-wizard.jpeg)

IntelliJ IDEA 将生成以下代码：

```JAVA
@Entity
@Table(name = "users")
public class User {
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  @Column(name = "id", nullable = false)
  private Long id;

  @OneToMany(mappedBy = "user")
  private Set<Profile> profiles = new LinkedHashSet<>();

  //...
}

@Entity
@Table(name = "profiles")
public class Profile {
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  @Column(name = "id", nullable = false)
  private Long id;

  @ManyToOne(fetch = FetchType.LAZY)
  @JoinColumn(name = "user_id")
  private User user;

  //...
}

```

### @ManyToMany

要在两张表之间建立多对多关系，您需要使用连接表。 在这种情况下，连接表只包含两列——外键。 IntelliJ IDEA 能够自动检测这样的表，并识别两个表之间的关系基数，这两个表的 ids 在连接表中表示为外键，如  `@ManyToMany` 。

```SQL
CREATE TABLE users
(
    id BIGINT GENERATED BY DEFAULT AS IDENTITY NOT NULL,
    last_name VARCHAR(255),
    first_name VARCHAR(255),
    CONSTRAINT pk_users PRIMARY KEY (id)
);

CREATE TABLE profiles
(
    id BIGINT GENERATED BY DEFAULT AS IDENTITY NOT NULL,
    join_date date,
    status VARCHAR(255),
    bio VARCHAR(255),
    CONSTRAINT pk_profiles PRIMARY KEY (id)
);

CREATE TABLE profiles_users
(
    profile_id BIGINT NOT NULL,
    users_id BIGINT NOT NULL,
    CONSTRAINT pk_profiles_users PRIMARY KEY (profile_id, users_id)
);

ALTER TABLE profiles_users
    ADD CONSTRAINT fk_prouse_on_profile FOREIGN KEY (profile_id) REFERENCES profiles (id);

ALTER TABLE profiles_users
    ADD CONSTRAINT fk_prouse_on_user FOREIGN KEY (users_id) REFERENCES users (id);

```

![many-to-many-diagram](https://resources.jetbrains.com.cn/help/img/idea/2026.3/many-to-many-diagram.png)

![many-to-many-wizard](https://resources.jetbrains.com.cn/help/img/idea/2026.3/many-to-many-wizard.jpeg)

如果任何实体中不存在此关联，IntelliJ IDEA 将在调用反向工程操作的实体中生成该关联。

```JAVA
@Entity
@Table(name = "users")
public class User {
   @Id
   @GeneratedValue(strategy = GenerationType.IDENTITY)
   @Column(name = "id", nullable = false)
   private Long id;

   @ManyToMany
   @JoinTable(name = "profiles_users",
      joinColumns = @JoinColumn(name = "users_id"),
      inverseJoinColumns = @JoinColumn(name = "profile_id"))
   private Set<Profile> profiles = new LinkedHashSet<>();

   //...
}

```

如果此关联已经存在于其中一个实体中，那么 IntelliJ IDEA 将生成带有  `@ManyToMany`  属性和  `mappedBy`  参数的属性。

```JAVA
@Entity
@Table(name = "profiles")
public class Profile {
   @Id
   @GeneratedValue(strategy = GenerationType.IDENTITY)
   @Column(name = "id", nullable = false)
   private Long id;

   @ManyToMany(mappedBy = "profiles")
   private Set<User> users = new LinkedHashSet<>();

   //...
}

```

## 视频教程

以下视频演示了在映射需要一些额外配置时如何对数据库架构进行逆向工程。

对 JPA 实体进行逆向工程并使其继承自父类
: IntelliJ IDEA 提供通过从  `@MappedSuperclass` 注释的类中选择一个类以定义父实体的功能，这可以在   父项  下拉框中完成。 这允许生成的实体扩展自父类，并自动继承所有具有相同名称和类型的属性。
:
:
:
: 在  `@MappedSuperclass`  中的列名与子实体的表不匹配的情况下，我们仍然可以使用  `@AttributeOverride`  注解继承该属性。 只需选择特性名称并选择要重写的项，IntelliJ IDEA 即可帮助管理继承。
:
:
:
: ![在“从数据库创建 JPA 实体”对话框中继承特性](https://resources.jetbrains.com.cn/help/img/idea/2026.3/re_field_inheritance.png)
:
: 在生成实体期间，IntelliJ IDEA 如果检测到数据库中缺少来自  `@MappedSuperclass`  的任何继承属性，会发出警报。 要使模型与数据库对齐，请访问 JPA Structure 菜单中的   通过实体生成 DDL   操作并选择   现有数据库更新   选项。
:
:
:
: [Video](https://www.youtube.com/v/a-K-53_8Pcg)

将数据库特定的列类型映射到实体特性
: 对于某些 SQL 类型，没有与 Java 类完全匹配的对应关系。 在这种情况下，IntelliJ IDEA 不会设置类型，以防生成无法工作的编码。 您需要自己选择属性类型。 也可以在 [参考：JPA 逆向工程设置](#settings) 中为每个 DBMS 配置默认类型映射。
:
:
:
: 如果项目依赖项列表中包含 [HibernateTypes 库](https://github.com/vladmihalcea/hibernate-types)，IntelliJ IDEA 可以在逆向工程期间自动从该库为不支持的 SQL 类型建议合适的类型：
:
:
:
: [Video](https://www.youtube.com/v/uBjxdAmVDuI)

将数据库视图映射到实体
: IntelliJ IDEA 遵循所有最佳做法，在逆向工程时为 DB 视图提供最高效的映射：
:
:
:
: 1.  由于数据库视图没有主键，IntelliJ IDEA 允许您选择一个字段或一组字段作为目标实体的标识符。
:
: 2.  大多数 DB 视图是不可变的。 因此，IntelliJ IDEA 会向实体添加  `@Immutable`  注解，并且仅生成 getter。 这有助于提高应用程序性能。
:
: 3.  IntelliJ IDEA 仅为映射到数据库视图的实体生成无参 protected 构造函数，符合 JPA 规范，这可防止开发者在业务逻辑编码中创建此类实体的新实例。
:
:
:
: [Video](https://www.youtube.com/v/QUXgJSkBJO8)

## 参考：从数据库创建实体对话框

JPA / Spring Data JPA:

来自数据库的 JPA 实体   对话框可让你将数据库表和视图映射到 JPA 或 Spring Data JPA 实体。

![从数据库创建 JPA 实体对话框](https://resources.jetbrains.com.cn/help/img/idea/2026.3/jpa_entities_from_db_dialog.png)

Spring Data JDBC:

来自数据库的 JDBC 实体   对话框可让你将数据库表映射到 Spring Data JDBC 实体。

![从数据库创建 JDBC 实体对话框](https://resources.jetbrains.com.cn/help/img/idea/2026.3/jdbc_entities_from_db_dialog.png)

### 常规选项

JPA / Spring Data JPA:

对话框顶部显示适用于所有生成的实体类的选项：

|  条目  |  描述  |
| --- | --- |
|    数据库连接    |     选择要进行逆向工程的数据库架构。       需从   数据库   工具窗口选择现有 [数据源](managing-data-sources.html)，或点击 ![](https://resources.jetbrains.com.cn/help/img/idea/2026.3/app-client.expui.general.add.svg) 新建。      > **Tip:** > 要将 IDE 与数据库同步，请点击 ![](https://resources.jetbrains.com.cn/help/img/idea/2026.3/intellij.platform.ide.expui.inline.refresh.svg)   刷新 IDEA 数据源  。    |
|    源根    |  选择一个 [源根](content-roots.html#sources-root)，用于保存生成的实体类。  |
|    选项    |     选择要包含在生成的实体类中的其他数据：        * 迁移索引和约束 : 在 [@Table 注解](https://jakarta.ee/specifications/persistence/3.2/apidocs/jakarta.persistence/jakarta/persistence/table)中包含表中的 [索引](indexes.html)和唯一约束。    * 迁移默认值 ：在 [@ColumnDefault 注解](https://docs.hibernate.org/orm/7.4/userguide/html_single/#schema-generation-column-default-value)中包含默认列值。    * 使用表架构 ：在 [@Table 注解](https://jakarta.ee/specifications/persistence/3.2/apidocs/jakarta.persistence/jakarta/persistence/table)中显式指定数据库架构。    |
|    目标软件包    |     选择一个  软件包 ，用于保存生成的实体类。      > **Tip:** > 如果项目中没有软件包，请点击 ![三 DOTS 图标](https://resources.jetbrains.com.cn/help/img/idea/2026.3/intellij.platform.ide.general.ellipsis.svg)，然后点击 ![右下角带加号的文件夹图标](https://resources.jetbrains.com.cn/help/img/idea/2026.3/intellij.platform.ide.expui.actions.newFolder.svg)   新建包  。 在打开的对话框中，指定软件包名称并点击   OK  。    |
|    其他设置   ![向下箭头](https://resources.jetbrains.com.cn/help/img/idea/2026.3/intellij.platform.ide.expui.general.chevronDown.svg)  |  打开 [JPA 逆向工程设置](#settings)。  |
|    语言    |    > **Note:** > 仅当项目支持 Kotlin 时才会显示此选项。      选择应使用 Java 还是 Kotlin 生成实体类。     |

Spring Data JDBC:

对话框顶部显示适用于所有生成的实体类的选项：

|  条目  |  描述  |
| --- | --- |
|    数据库连接    |     选择要进行逆向工程的数据库架构。       需从   数据库   工具窗口选择现有 [数据源](managing-data-sources.html)，或点击 ![](https://resources.jetbrains.com.cn/help/img/idea/2026.3/app-client.expui.general.add.svg) 新建。      > **Tip:** > 要将 IDE 与数据库同步，请点击 ![](https://resources.jetbrains.com.cn/help/img/idea/2026.3/intellij.platform.ide.expui.inline.refresh.svg)   刷新 IDEA 数据源  。    |
|    源根    |  选择一个 [源根](content-roots.html#sources-root)，用于保存生成的实体类。  |
|    选项    |     选择要包含在生成的实体类中的其他数据：        * 使用表架构 ：在 [@Table 注解](https://docs.spring.io/spring-data/jdbc/docs/current/api/org/springframework/data/relational/core/mapping/Table.html)中显式指定数据库架构。    |
|    目标软件包    |     选择一个  软件包 ，用于保存生成的实体类。      > **Tip:** > 如果项目中没有软件包，请点击 ![三 DOTS 图标](https://resources.jetbrains.com.cn/help/img/idea/2026.3/intellij.platform.ide.general.ellipsis.svg)，然后点击 ![右下角带加号的文件夹图标](https://resources.jetbrains.com.cn/help/img/idea/2026.3/intellij.platform.ide.expui.actions.newFolder.svg)   新建包  。 在打开的对话框中，指定软件包名称并点击   OK  。    |
|    语言    |    > **Note:** > 仅当项目支持 Kotlin 时才会显示此选项。      选择应使用 Java 还是 Kotlin 生成实体类。     |

### 实体映射选项

JPA / Spring Data JPA:

对话框左下方列出所选数据库中的表和视图，并按类型和当前映射状态分组：

* 映射的关系 ：已映射到实体的表和视图。 未完全映射的项带有 未映射的列 标签。

* 表 ：未映射到任何实体的表。

* 视图 ：未映射到任何实体的视图。

选择表、视图或关系时，对话框右下方会列出其可映射元素，并同样按状态分组：

* 映射的列 ：已映射到实体特性的列。

* 列 ：未映射到任何实体特性的列。

* 引用 : 其他表中指向此表且未映射到此表实体中任何特性的外部密钥。

对于每个可映射项，对话框会显示以下选项：

|  条目  |  描述  |
| --- | --- |
|    类名    |     指定生成的实体类的名称。       IntelliJ IDEA 会根据表名称和 [JPA 逆向工程设置](#settings)自动填充此值。     |
|    父项    |     选择一个 [映射超类](https://jakarta.ee/specifications/persistence/3.2/jakarta-persistence-spec-3.2#mapped-superclasses)，作为生成的实体类的父类。     |
|    ID 生成    |    > **Note:** > 仅对于主密钥为 UUID、Short、Integer 或 Long 类型的表，才会显示此选项。      选择主密钥的 ID 生成策略:        * 无 ：无自动化策略；应用程序必须在实体持久化之前分配 ID。    * 序列 ：ID 由所选数据库序列生成，并在实体持久化时由持久化提供程序分配（在 `INSERT` 语句之前）。    * 标识 ：实体持久化时，ID 由数据库使用自动递增列、serial 列或 identity 列生成并分配（在 `INSERT` 语句期间）。    * UUID ：ID 在实体持久化时由持久化提供程序生成并分配（在 `INSERT` 语句之前）。      从 [官方 Hibernate 文档](https://docs.hibernate.org/orm/7.4/userguide/html_single/#identifiers-generators)详细了解 ID 生成策略。     |
|    ID 列    |    > **Note:** > 仅对于没有主密钥的视图和表，才会显示此选项。      选择哪些列应被视为主键列。     |
|    列/引用名    |     所选表或视图中的列名称以及其他表中对其的引用，均为只读。       使用复选框选择要进行逆向工程的列和引用。     |
|    特性    |     为生成的实体字段指定名称。       IntelliJ IDEA 会根据列名称以及适用时的 [JPA 逆向工程设置](#settings)自动填充这些值。       如果指定了父类，可以针对每个匹配的列决定是从父类继承其特性，还是生成新的特性。      ![名称特性，带有下拉菜单列表，显示从父项继承或创建新特性的选项](https://resources.jetbrains.com.cn/help/img/idea/2026.3/re_field_inheritance.png)    如果继承的特性不是完全匹配，实体将使用 [@AttributeOverride 注解](https://jakarta.ee/specifications/persistence/3.2/jakarta-persistence-spec-3.2#a14084)。     |
|    映射类型    |     选择如何将列或引用映射到实体特性。       有关所有可用值的描述，请参阅 [可用的映射类型](#re-mapping-types)。     |
|    特性/转换器/Hibernate 类型    |  选择用于生成的实体字段的特性类型、JPA 特性转换器或 Hibernate 自定义类型。  |

Spring Data JDBC:

对话框左下方列出所选数据库中的表，并按类型和当前映射状态分组：

* 映射的关系 ：已映射到实体的表。 未完全映射的项带有 未映射的列 标签。

* 表 ：未映射到任何实体的表。

选择表或关系时，对话框右下方会列出其可映射元素，并同样按状态分组：

* 映射的列 ：已映射到实体特性的列。

* 列 ：未映射到任何实体特性的列。

* 引用 : 其他表中指向此表且未映射到此表实体中任何特性的外部密钥。

对于每个可映射项，对话框会显示以下选项：

|  条目  |  描述  |
| --- | --- |
|    类名    |     指定生成的实体类的名称。       IntelliJ IDEA 会根据表名称和 [JPA 逆向工程设置](#settings)自动填充此值。     |
|    ID 生成    |    > **Note:** > 仅对于主密钥为 Short、Integer 或 Long 类型的表，才会显示此选项。      选择主密钥的 ID 生成策略:        * 无 ：无自动化策略；保存实体时，ID 由数据库使用自动递增列、serial 列或 identity 列生成并分配（在 `INSERT` 语句期间）。    * 序列 ：ID 由所选数据库序列生成，并在保存实体时由 Spring Data JDBC 分配（在 `INSERT` 语句之前）。    |
|    ID 列    |    > **Note:** > 仅对于没有主密钥的表，才会显示此选项。      选择哪些列应被视为主键列。     |
|    列/引用名    |     所选表中的列名称以及其他表中对其的引用，均为只读。       使用复选框选择要进行逆向工程的列和引用。     |
|    特性    |     为生成的实体字段指定名称。       IntelliJ IDEA 会根据列名称以及适用时的 [JPA 逆向工程设置](#settings)自动填充这些值。     |
|    映射类型    |     选择如何将列或引用映射到实体特性。       有关所有可用值的描述，请参阅 [可用的映射类型](#re-mapping-types)。     |
|    特性类型    |  选择用于生成的实体字段的特性类型。  |

### 可用的映射类型

JPA / Spring Data JPA:

映射类型   下拉菜单列表可用于选择在逆向工程期间如何将列或引用映射到实体特性。 可用值取决于该项表示普通数据、数据库密钥还是来自另一个表的引用。

#### 普通列

|  值  |  描述  |  编码示例  |
| --- | --- | --- |
|    基本    |  将列映射到基本类型的字段。  |     ```JAVA @Column(name = "status", nullable = false, length = 20) private String status;  ```    |
|    枚举    |  将列映射到单独的枚举类，然后使用  `@Enumerated`  注解引用它。  |     ```JAVA Book.java @Enumerated(EnumType.STRING) @Column(name = "status", nullable = false, length = 20) private StatusType status;  StatusType.java public enum StatusType { }  ```    |
|    待办事项    |     将列映射到基本类型的字段，但用  `待办事项`  注释将其已包装。       将文本光标放在操作处并按 `Ctrl+B` (Windows), `⌘ B` (macOS), `⌘ B` (IntelliJ IDEA Classic (macOS)), `⌘ B` (macOS System Shortcuts), `Ctrl+B` (XWin), `Ctrl+B` (GNOME), `Ctrl+B` (KDE), `Ctrl+Alt+G` (Emacs), `F12` (Sublime Text), `F12` (Sublime Text (macOS)), `F12` (Visual Studio), `F12` (Visual Studio (macOS)), `Ctrl+B` (NetBeans), `F3` (Eclipse), `F3` (Eclipse (macOS))，即可从  `待办事项`  注释调用操作。     |     ```JAVA /*  TODO [Reverse Engineering] create field to map the 'status' column  Available actions: Uncomment as is \| Remove column mapping     @Column(name = "status", nullable = false, length = 20)     private java.lang.String status; */  ```    |

#### 主键

|  值  |  描述  |  编码示例  |
| --- | --- | --- |
|    基本    |  将列映射到基本类型的字段，并使用  `@Id`  对其进行注解。  |     ```JAVA @Id @Column(name = "isbn", nullable = false, length = 13) private String isbn;  ```    |

#### 复合密钥

|  值  |  描述  |  编码示例  |
| --- | --- | --- |
|    嵌入式 ID    |  将列映射到单独的可嵌入类，然后使用 [@EmbeddedId 注解](https://jakarta.ee/specifications/persistence/3.2/jakarta-persistence-spec-3.2#a14687)引用它。  |     ```JAVA BookAuthor.java @EmbeddedId private BookAuthorId id;  BookAuthorId.java @Embeddable public class BookAuthorId implements Serializable {     @Serial     private static final long serialVersionUID = -8507207156423735624L;     @Column(name = "book_isbn", nullable = false, length = 13)     private String bookIsbn;      @Column(name = "author_id", nullable = false)     private Long authorId; }  ```    |
|    ID 类    |  将列映射到单独的类，然后使用 [@IdClass 注解](https://jakarta.ee/specifications/persistence/3.2/jakarta-persistence-spec-3.2#a14836)和  `@Id`  注解引用它。  |     ```JAVA BookAuthor.java @IdClass(BookAuthorId.class) public class BookAuthor {     @Id     @Column(name = "book_isbn", nullable = false, length = 13)     private String bookIsbn;     @Id     @Column(name = "author_id", nullable = false)     private Long authorId; }  BookAuthorId.java public class BookAuthorId implements Serializable {     private String bookIsbn;     private Long authorId; }  ```    |

#### 外键

|  值  |  描述  |  编码示例  |
| --- | --- | --- |
|    基本    |  将列映射到基本类型的字段。  |     ```JAVA @Column(name = "publisher_id") private Long publisher;  ```    |
|    多对一    |  将列映射到带有  `@ManyToOne`  注解的引用字段。  |     ```JAVA @ManyToOne(fetch = FetchType.LAZY) @JoinColumn(name = "publisher_id") private Publisher publisher;  ```    |
|    一对一    |  将列映射到带有  `@OneToOne`  注解的引用字段。  |     ```JAVA @OneToOne(fetch = FetchType.LAZY) @JoinColumn(name = "publisher_id") private Publisher publisher;  ```    |
|    待办事项    |     将列映射到带有关系注解的引用字段，但用  `待办事项`  注释将其已包装。       将文本光标放在操作处并按 `Ctrl+B` (Windows), `⌘ B` (macOS), `⌘ B` (IntelliJ IDEA Classic (macOS)), `⌘ B` (macOS System Shortcuts), `Ctrl+B` (XWin), `Ctrl+B` (GNOME), `Ctrl+B` (KDE), `Ctrl+Alt+G` (Emacs), `F12` (Sublime Text), `F12` (Sublime Text (macOS)), `F12` (Visual Studio), `F12` (Visual Studio (macOS)), `Ctrl+B` (NetBeans), `F3` (Eclipse), `F3` (Eclipse (macOS))，即可从  `待办事项`  注释调用操作。     |     ```JAVA /*  TODO [Reverse Engineering] create field to map the 'publisher_id' column  Available actions: Uncomment as is \| Remove column mapping     @ManyToOne(fetch = FetchType.LAZY)     @JoinColumn(name = "publisher_id")     private Publisher publisher; */  ```    |

#### 其他表中的引用

|  值  |  描述  |  编码示例  |
| --- | --- | --- |
|    多对多    |  将引用映射到设置，并使用  `@ManyToMany`  和  `@JoinTable`  注解对其进行注解。  |     ```JAVA @ManyToMany @JoinTable(name = "book_authors", joinColumns = {@JoinColumn(name = "book_isbn")}, inverseJoinColumns = {@JoinColumn(name = "author_id")}) private Set<Author> authors = new LinkedHashSet<>();  ```    |
|    一对多    |  将引用映射到设置，并在  `@OneToMany`  注解中指向其外部密钥特性。  |     ```JAVA @OneToMany(mappedBy = "bookIsbn") private Set<Review> reviews = new LinkedHashSet<>();  ```    |
|    一对一    |  将引用映射到单个字段，并在  `@OneToOne`  注解中指向其外键特性。  |     ```JAVA @OneToOne(mappedBy = "bookIsbn") private Review reviews;  ```    |

Spring Data JDBC:

映射类型   下拉菜单列表可用于选择在逆向工程期间如何将列或引用映射到实体特性。 可用值取决于该项表示普通数据、数据库密钥还是来自另一个表的引用。

#### 普通列

|  值  |  描述  |  编码示例  |
| --- | --- | --- |
|    基本    |  将列映射到基本类型的字段。  |     ```JAVA private String status = "";  ```    |
|    枚举    |  将列映射到单独的枚举类，然后引用它。  |     ```JAVA Book.java @Nullable private StatusType status;  StatusType.java public enum StatusType { }  ```    |
|    待办事项    |     将列映射到基本类型的字段，但用  `待办事项`  注释将其已包装。       将文本光标放在操作处并按 `Ctrl+B` (Windows), `⌘ B` (macOS), `⌘ B` (IntelliJ IDEA Classic (macOS)), `⌘ B` (macOS System Shortcuts), `Ctrl+B` (XWin), `Ctrl+B` (GNOME), `Ctrl+B` (KDE), `Ctrl+Alt+G` (Emacs), `F12` (Sublime Text), `F12` (Sublime Text (macOS)), `F12` (Visual Studio), `F12` (Visual Studio (macOS)), `Ctrl+B` (NetBeans), `F3` (Eclipse), `F3` (Eclipse (macOS))，即可从  `待办事项`  注释调用操作。     |     ```JAVA /*  TODO [Reverse Engineering] create field to map the 'status' column  Available actions: Uncomment as is \| Remove column mapping     private java.lang.String status = ""; */  ```    |

#### 主键

|  值  |  描述  |  编码示例  |
| --- | --- | --- |
|    基本    |  将列映射到基本类型的字段，并使用  `@Id`  对其进行注解。  |     ```JAVA @Id private String isbn = "";  ```    |

#### 复合密钥

|  值  |  描述  |  编码示例  |
| --- | --- | --- |
|    嵌入式 ID    |  将列映射到单独的可嵌入类，然后引用它。  |     ```JAVA BookAuthor.java @Nullable @Id @Embedded.Nullable private BookAuthorId id;  BookAuthorId.java @NullMarked public class BookAuthorId {     private String bookIsbn = "";     private Long authorId = 0L; }  ```    |

#### 外键

|  值  |  描述  |  编码示例  |
| --- | --- | --- |
|    基本    |  将列映射到基本类型的字段。  |     ```JAVA @Nullable @Column("publisher_id") private Long publisher;  ```    |
|    参考    |  将列映射到 [AggregateReference](https://docs.spring.io/spring-data/jdbc/docs/current/api/org/springframework/data/jdbc/core/mapping/AggregateReference.html) 字段。  |     ```JAVA @Nullable @Column("publisher_id") private AggregateReference<Publisher, Long> publisher;  ```    |
|    待办事项    |     将该列映射到  `AggregateReference`  字段，但用  `待办事项`  注释将其已包装。       将文本光标放在操作处并按 `Ctrl+B` (Windows), `⌘ B` (macOS), `⌘ B` (IntelliJ IDEA Classic (macOS)), `⌘ B` (macOS System Shortcuts), `Ctrl+B` (XWin), `Ctrl+B` (GNOME), `Ctrl+B` (KDE), `Ctrl+Alt+G` (Emacs), `F12` (Sublime Text), `F12` (Sublime Text (macOS)), `F12` (Visual Studio), `F12` (Visual Studio (macOS)), `Ctrl+B` (NetBeans), `F3` (Eclipse), `F3` (Eclipse (macOS))，即可从  `待办事项`  注释调用操作。     |     ```JAVA /* TODO [Reverse Engineering] create field to map the 'publisher_id' column Available actions: Uncomment as is \| Remove column mapping    @Nullable    @Column("publisher_id")    private AggregateReference<Publisher, Long> publisher;  */  ```    |

#### 其他表中的引用

|  值  |  描述  |  编码示例  |
| --- | --- | --- |
|    设置    |  将该引用映射到设置，并在 [@MappedCollection 注解](https://docs.spring.io/spring-data/jdbc/docs/current/api/org/springframework/data/relational/core/mapping/MappedCollection.html)中指向其外部密钥列。  |     ```JAVA @Nullable @MappedCollection(idColumn = "book_isbn") private Set<Review> reviews;  ```    |
|    单引号    |  将该引用映射到单个字段，并在 [@MappedCollection 注解](https://docs.spring.io/spring-data/jdbc/docs/current/api/org/springframework/data/relational/core/mapping/MappedCollection.html)中指向其外键列。  |     ```JAVA @Nullable @MappedCollection(idColumn = "book_isbn") private Review reviews;  ```    |

## 参考：JPA 逆向工程设置

> **TL;DR**
> Windows 和 Linux：  `文件 | 设置 | 工具 | JPA 逆向工程`
>
>
>
> macOS：  `%instance% | 设置 | 工具 | JPA 逆向工程`

JPA 逆向工程   设置允许配置 IntelliJ IDEA 在逆向工程期间如何将数据库表和列映射为实体及实体字段。

![JPA 逆向工程设置](https://resources.jetbrains.com.cn/help/img/idea/2026.3/reverse_engineering_settings.png)

### 基础设置

|  条目  |  描述  |
| --- | --- |
|    为 @OneToOne 和 @ManyToOne 关联使用 FetchType.LAZY    |  将 [获取策略](https://jakarta.ee/specifications/persistence/4.0/apidocs/jakarta.persistence/jakarta/persistence/manytoone#fetch()) 设置为  `FetchType.LAZY` ，用于  `@OneToOne`  和  `@ManyToOne`  关联。  |
|    使用验证注解(NotNull、Size 等…)    |  使用根据列元数据推断的 [Jakarta Bean Validation 约束](https://jakarta.ee/learn/docs/jakartaee-tutorial/current/beanvalidation/bean-validation/bean-validation.html#_using_jakarta_bean_validation_constraints)（如  `@NotNull`  或  `@Size` ）为实体字段添加注解。  |
|    将表名转换为单数形式以生成类名    |     为实体类命名时，将复数表名称转换为单数形式。       例如，如果表名称为  `users` ，生成的实体类名称将为  `用户` ，而不是  `用户` 。     |
|    将 ORM 引用替换为基本类型特性    |     将外键列映射为基础特性，而不是关系字段。       例如，对于名称为  `customer_id`  的外键列，将会生成  `Long customerId`  特性，而不是  `@ManyToOne Customer customer`  关系字段。     |

### 表和列评论。

表和列评论。   设置允许您选择如何处理表和列的注释：

* @Comment 注解 ：将其插入 Hibernate `@注释` 注解中。 > **Note:** > 如果计划将来从代码生成 [DDL 脚本](database-versioning.html)，这是唯一可以包含在脚本中的注释类型。

* Java 文档 ：将其插入 [Javadoc 注释](javadocs.html)。

* 忽略 ：完全不要插入到编码中。

### 命名规则

命名规则   设置允许您配置如何将表和列名转换为实体类和字段的名称。 当数据库遵循特定命名约定并且不希望其延续到生成的编码时（如前缀或后缀），此设置非常有用。

您可以选择以下策略之一：

* 配置 ：配置与前缀和后缀相关的设置：

|  条目  |  描述  |
| --- | --- |
|    表名中要跳过的前缀    |     指定在为实体类命名时应从表名称中去除哪些前缀。       例如，若在该字段中输入  `sys_` ，并且表名称为  `sys_users` ，则生成的实体类名称为  `用户` ，而不是  `SysUser` 。       如需输入多个值，用逗号分隔。     |
|    列名中要跳过的前缀    |     指定在为实体字段命名时应从列名称中去除哪些前缀。       如需输入多个值，用逗号分隔。     |
|    表名中要跳过的后缀    |     指定在为实体类命名时应从表名称中去除哪些后缀。       如需输入多个值，用逗号分隔。     |
|    列名中要跳过的后缀    |     指定在为实体字段命名时应从列名称中去除哪些后缀。       如需输入多个值，用逗号分隔。     |
|    保留关键字字段后缀    |     如遇与 [保留 Java 关键字](https://docs.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html) 冲突时，请指定应添加到实体字段名称的后缀。       例如，如果将该后缀设置为  `Field`  并且某列名称为  `class` ，则生成的实体字段名称为  `classField` 。     |

* 算法 ：用 Java 编写自定义命名逻辑。 选择此选项后，会显示代码编辑器。 其中包含可根据数据库命名约定调整的方法存根。

### 映射类型

映射类型   设置允许您重写默认的 SQL 到 Java 类型映射。 可根据需要将 SQL 类型映射为 Java 特性类型、JPA 特性转换器或 Hibernate 自定义类型。 当应用程序需处理特定数据库类型、加密数据或支持使用不同 SQL 类型的多种数据库管理系统时，此设置十分有用。

可为以下数据库管理系统重写类型映射：

* [H2](h2.html)

* [HSQLDB](hsqldb.html)

* [IBM Db2 LUW](ibm-db2-luw.html)

* [MariaDB](mariadb.html)

* [Microsoft SQL 服务器](microsoft-sql-server.html)

* [MySQL](mysql.html)

* [甲骨文](oracle.html)

* [PostgreSQL](postgresql.html)

下方视频演示如何重写类型映射并使用 Hibernate  `@JavaType`  注解：

[Video](https://www.youtube.com/v/7vGgBHwm_Ck?t=89)