リバースエンジニアリング

リバースエンジニアリングは、データベーススキーマに基づいて JPA エンティティクラスをスキャフォールディングするプロセスです。

データベースから JPA エンティティを生成する

データベース接続が確立されていない場合は、接続を作成します。
Spring、Micronaut、Quarkus プロジェクトでは、ガターのをクリックすることで、 application.properties または application.yml ファイルからデータベース接続をすばやく作成できます。
データベースツールウィンドウで、 JPA ノードを展開し、データベースまたは特定のテーブルを右クリックして、新規 | DB からの JPA エンティティを選択します。
マップするデータベース接続、テーブル、属性を選択します。詳細については、 DB ウィザードからのエンティティを参照してください。

IDE が開いている間、データベースは他のクライアントによって変更される可能性があります。データベースから最新のデータを取得するには、 DB からのエンティティウィンドウまたはデータベースツールウィンドウのいずれかでをクリックします。

DB ウィザードからのエンティティ

構成

ウィンドウの上部にあるメニューでは、次の設定を行うことができます。

DB 接続
生成されたエンティティが保存されるソースルートとパッケージ
インデックスと制約を移行する必要があるかどうか
@Table アノテーションでスキーマ名を指定するかどうか

また、その他の設定ドロップダウンリストから、エンティティ宣言とリバースエンジニアリング設定に移動できます。

マップされたリレーション、テーブル、ビュー

ウィンドウの左側に次のものが表示されます。

マップされた関係: JPA エンティティにマップされたテーブルとビュー
テーブル: DB 内に存在するがエンティティにマップされていないテーブル
ビュー: DB 内に存在するがエンティティにマップされていないビュー

ツリーから任意の要素を選択すると、列から属性を移行するためのパネルが表示されます。また、対応するフィールドにクラス名を定義することもできます。

属性の移行

ウィンドウのメイン部分では、属性に関連するすべての設定を行うことができます。追加する属性を選択し、列名を除くすべてのパラメーターを変更できます。マッピングタイプと属性 / コンバーター / 休止状態のタイプは、ドロップダウンリストとして表されます。

すべての属性は 3 つのカテゴリに分類されます。

移行された列 - エンティティ内にすでに存在する列 (マップされたリレーションでのみ使用可能)
列 - エンティティまたは親 @MappedSuperclass にまだマップされていない新しい列
リファレンス - 観察されたテーブルの列として表されないオプションの関連付け

親エンティティ

IntelliJ IDEA では、親ドロップダウンボックスから @MappedSuperclass でアノテーションが付けられたクラスを選択して親エンティティを定義することができます。これにより、生成されたエンティティは親クラスから拡張され、同じ名前とタイプを持つすべての属性を自動的に継承できます。

@MappedSuperclass の列名が子エンティティのテーブルと一致しない場合でも、 @AttributeOverride アノテーションを使用して属性を継承できます。属性名を選択し、オーバーライドするものを選択するだけで、IntelliJ IDEA が継承の管理を支援します。

エンティティ生成中に、 @MappedSuperclass から継承された属性がデータベースにない場合、IntelliJ IDEA によって警告が表示されます。モデルをデータベースに合わせるには、JPA 構造メニューのエンティティ別の DDL を生成アクションにアクセスし、既存 DB 更新オプションを選択します。

列挙型の作成

String または 整数 タイプに一致する属性の場合、マッピングタイプを Basic から Enum に変更すると、IntelliJ IDEA によってプロジェクト内に対応する Enum クラスが作成されます。 enum に適切な値を手動で入力する必要があります。

未知の型への対処

一部の SQL タイプでは、Java クラスと完全に一致するものはありません。この場合、IntelliJ IDEA は、機能しないコードが生成されないようにタイプを設定しません。属性タイプは自分で選択する必要があります。設定で各 DBMS のデフォルトのタイプマッピングを構成することもできます。

プロジェクトの依存関係リストに HibernateTypes ライブラリがある場合、IntelliJ IDEA はリバースエンジニアリング中にサポートされていない SQL タイプに対してライブラリから適切なタイプを自動的に提案できます。

// TODO Comments

特定の列の属性作成を延期したい場合は、マッピングタイプとして //todo コメントを選択できます。 IntelliJ IDEA は、列タイプに応じて、対応するクイックフィックスアクションを含む //todo コメントを生成します。これらのアクションは、 Ctrl+B を押すことで呼び出すことができます。

既知の基本タイプと関連付けタイプについては、次のことができます。
- そのままコメント解除
- 列マッピングの除去
不明な列タイプの場合は、次のことができます。
- ターゲット Java 型の定義
- そのままコメント解除
- 列マッピングの除去

以下は、不明な列タイプを持つ属性に対して生成された //todo コメントの例です。

                  /*
                    TODO [Reverse Engineering] create field to map the 'description' column
                     Available actions: Define target Java type | Uncomment as is | Remove column mapping
                    @Column(name = "description", columnDefinition = "jsonb")
                    private java.lang.Object description;
                  */
                
    

ターゲット Java 型の定義アクションを呼び出すと、次のウィンドウが表示されます。

IntelliJ IDEA は、後続のリバースエンジニアリングアクションのためにデータマッピングを記憶します。設定でいつでも変更できます。

DB ビューを JPA エンティティにマップする

IntelliJ IDEA は、リバースエンジニアリング中に DB ビューの最も効率的なマッピングを提供するすべてのベストプラクティスに従います。

DB ビューには主キーがないため、IntelliJ IDEA では、ターゲットエンティティの識別子として使用するフィールドまたはフィールドセットを選択できます。
ほとんどの DB ビューは不変です。そのため、IntelliJ IDEA はエンティティに @Immutable アノテーションを追加し、getter のみを生成します。これにより、アプリケーションのパフォーマンスが向上します。
IntelliJ IDEA は、JPA 仕様に従って、DB ビューにマップされたエンティティに対して引数なしの protected コンストラクターのみを生成し、開発者がビジネスロジックコードでそのようなエンティティの新しいインスタンスを作成することを防ぎます。

列のリバースエンジニアリング

一部の開発者は、DB ファーストのアプリケーション開発アプローチを好みます。まず、データベースに列を直接追加し、次に JPA モデルを更新します。 IntelliJ IDEA はこのプロセスを自動化できます。

データベースから属性を生成する

データベース接続が確立されていない場合は、接続を作成します。
永続化ツールウィンドウで、 JPA ノードを展開し、エンティティを右クリックして新規 | DB からの JPA エンティティを選択します。
または、エンティティソースコードで、ガターのエンティティアイコンをクリックし、 DB からエンティティ属性を作成するを選択します。
データベース接続、テーブルまたはビュー、マップする列を選択します。属性の移行フローは、 DB ウィザードからのエンティティセクションで説明されているものと同じです。

スマートな参照検出

IntelliJ IDEA はモデルを深く理解します。場合によっては、カーディナリティ @OneToOne、 @OneToMany、 @ManyToOne、 @ManyToMany を適切に検出できます。最も素晴らしいのは、現在のテーブルに対応する列がない場合でも、IntelliJ IDEA が参照を表示できることです。

これらのそれぞれのケースを詳しく見てみましょう。

@OneToOne

リレーションのカーディナリティを @OneToOne として自信を持って仮定できる状況が 2 つあります。

テーブルには、別のテーブルの主キーを参照する一意制約が設定された列があります
テーブルの主キーは外部キーです

ケース 1:

                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);
            
   

IntelliJ IDEA は、User エンティティに @JoinColumn アノテーションを含む @OneToOne 関連付けを生成し、Profile エンティティに mappedBy パラメーターを含む @OneToOne 関連付けを生成します。

                @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:

                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);
            
   

@Id は永続エンティティではないため、IntelliJ IDEA は次を生成します。

基本タイプの id 属性に @Id アノテーションを付ける
users@OneToOne の関連付けと @MapsId アノテーションのマーク付け

                @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 として検出します。

                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);
            
   

IntelliJ IDEA は次のコードを生成します。

                @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

2 つのテーブル間に多対多の関係を確立するには、ジャンクションテーブルを使用する必要があります。この場合、ジャンクションテーブルには 2 つの列 (外部キー) のみが含まれます。 IntelliJ IDEA は、このようなテーブルを自動的に検出し、ジャンクションテーブルで外部キーとして ID が @ManyToMany として表される 2 つのテーブル間の関係カーディナリティを識別できます。

                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);
            
   

この関連付けがいずれのエンティティにも存在しない場合、IntelliJ IDEA はリバースエンジニアリングアクションが呼び出されたエンティティにそれを生成します。

                @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<>();

                   //...
                }
            
   

この関連付けがすでにエンティティの 1 つに存在する場合、IntelliJ IDEA は mappedBy パラメーターを使用して @ManyToMany 属性を生成します。

                @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 リバースエンジニアリング設定

JPA リバースエンジニアリング設定では、リバースエンジニアリング時に IntelliJ IDEA がデータベースのテーブルやカラムをエンティティやエンティティフィールドへどうマップするかを設定できます。

基本設定

項目	説明
@OneToOne と @ManyToOne の関連に FetchType.LAZY を使用する	フェッチ戦略を `FetchType.LAZY` に設定し、 `@OneToOne` および `@ManyToOne` 関連付けに適用します。
バリデーションアノテーションを使用する (NotNull、Size など…)	カラムのメタデータから推測される Jakarta Bean Validation 制約（`@NotNull` または `@Size` など）でエンティティフィールドをアノテートします。
クラス名を生成するためにテーブル名を単数形に変換する	エンティティクラスの命名時は、複数形のテーブルお名前を単数形へ変換します。たとえば、テーブルのお名前が `users` の場合、生成されるエンティティクラスのお名前は `Users` ではなく `ユーザー` になります。
ORM の参照を基本型の属性に置換する	外部キーカラムをリレーションフィールドではなく基本属性としてマップします。たとえば、外部キーのカラムお名前が `customer_id` の場合、 `@ManyToOne Customer customer` リレーションフィールドではなく `Long customerId` 属性が生成されます。

テーブル＆カラムのコメント

テーブル＆カラムのコメント設定では、テーブルやカラムのコメントをどのように処理するかを選択できます：

@Comment アノテーション: Hibernate の @Comment アノテーション内にコメントを挿入します。
将来的にコードから DDL スクリプトを生成するプランがある場合、スクリプトに含めることができる唯一のコメント種別です。
Java ドキュメント: Javadoc コメントとして挿入します。
無視: コメントを全くコードに挿入しません。

命名規則

命名ルール設定では、テーブルお名前やカラムお名前をエンティティクラスやフィールドお名前へどのように変換するかを設定できます。これは、データベースが特定の命名規則に従っていて、生成されるコードにプリフィックスやサフィックス等を引き継ぎたくない場合に役立ちます。

次のいずれかの戦略を選択できます：

構成：プレフィックスやサフィックスに関する設定を行います：

項目	説明
テーブル名でスキップする接頭辞	エンティティクラスの命名時にテーブルお名前から除去するプレフィックスを指定します。たとえば、このフィールドに `sys_` と入力し、テーブルのお名前が `sys_users` の場合、生成されるエンティティクラスのお名前は `SysUser` ではなく `ユーザー` になります。複数の値を入力する場合は、コンマで区切ってください。
列名でスキップする接頭辞	エンティティフィールドの命名時にカラムお名前から除去するプレフィックスを指定します。複数の値を入力する場合は、コンマで区切ってください。
テーブル名でスキップする接尾辞	エンティティクラスの命名時にテーブルお名前から除去するサフィックスを指定します。複数の値を入力する場合は、コンマで区切ってください。
列名でスキップする接尾辞	エンティティフィールドの命名時にカラムお名前から除去するサフィックスを指定します。複数の値を入力する場合は、コンマで区切ってください。
予約語の接尾辞	エンティティフィールドお名前が予約済 Java キーワードと競合する場合に付与するサフィックスを指定します。たとえば、このサフィックスを `Field` に設定し、カラムお名前が `class` の場合、生成されるエンティティフィールドお名前は `classField` になります。

アルゴリズム: Java で独自の命名ロジックを記述します。このオプションを選択すると、コードエディターが表示されます。メソッドスタブが含まれているので、データベースの命名規則に合わせて調整できます。

マッピングタイプ

マッピングタイプ設定では、デフォルトの SQL から Java への型マッピングをオーバーライドできます。必要に応じて、SQL 型を Java 属性型、JPA 属性コンバーター、または Hibernate カスタム型にマッピングできます。これは、アプリケーションがデータベース固有型を扱う場合や、データを暗号化したり、異なる SQL 型を使う複数のデータベース管理システムをサポートする場合に役立ちます。

以下のデータベース管理システムについて型マッピングのオーバーライドが可能です：

次の動画は、Hibernate の @JavaType アノテーションを使った型マッピングのオーバーライド方法を示しています：

2026 年 7 月 14 日