Lombokアノテーション一覧｜展開後コードと使い分け早見表

Lombokとは、アノテーションを付けるだけでgetter・setter・コンストラクタ・equals/hashCode・toString・ビルダーなどの定型コードをコンパイル時に自動生成するJavaライブラリです。 ソースには @Data の1行しか書かなくても、コンパイル後のクラスにはメソッドが追加されています。手で書くと数十行になるコードを減らし、クラスの意図を読み取りやすくできます。

この記事では、最新の Lombok 1.18.48（2026年9月1日リリース、@SuperBuilder が正式機能に昇格）に合わせて、安定版アノテーションの生成物・付与先・推奨度を一覧にしました。さらに主要アノテーションについて「Lombok版」と「展開後のプレーンJava」を並べ、展開後のコードを Java 21.0.10 で実際にコンパイル・実行した出力を載せています。この環境ではLombokのjarを取得できないため、delombok（Lombokが生成するコードを書き出すツール）自体は未実行です。展開後コードはLombok公式ドキュメントの「Vanilla Java」例に沿って書いています。

Lombokアノテーションの早見表

推奨度は「◎よく使う／○場面を選んで使う／△使う前にチームで合意」の目安です。

迷ったら「エンティティは @Getter＋必要な @Setter、DTOは record か @Value、DIは @RequiredArgsConstructor、生成は @Builder、ログは @Slf4j」の組み合わせから始めると扱いやすくなります。

最新版（1.18.48）で押さえる変更点

公式の changelog で確認した、直近のリリースの主な内容です。

@SuperBuilder は 1.18.48 から本体パッケージの機能になりました。以前のバージョンでは lombok.experimental.SuperBuilder をimportしていたため、バージョンを上げるときはimportと lombok.config の設定キーを確認します。新しいJDKを使う場合は、そのJDKに対応したLombokのバージョンに上げるのが基本です（Lombokはコンパイラの内部に入り込んで動くため）。

導入設定（Maven・Gradle）

Maven

<dependencies>
  <dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.48</version>
    <scope>provided</scope>
  </dependency>
</dependencies>

<build>
  <plugins>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-compiler-plugin</artifactId>
      <configuration>
        <annotationProcessorPaths>
          <path>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.48</version>
          </path>
        </annotationProcessorPaths>
      </configuration>
    </plugin>
  </plugins>
</build>

JDK 23以降のjavacは、注釈プロセッサを明示しないと注釈処理を行わない仕様に変わりました。annotationProcessorPaths を書いておくと、JDKのバージョンにかかわらずLombokが確実に動きます。MapStructなど他の注釈プロセッサと併用する場合も、同じ annotationProcessorPaths に並べます。

Gradle

dependencies {
    compileOnly 'org.projectlombok:lombok:1.18.48'
    annotationProcessor 'org.projectlombok:lombok:1.18.48'

    testCompileOnly 'org.projectlombok:lombok:1.18.48'
    testAnnotationProcessor 'org.projectlombok:lombok:1.18.48'
}

compileOnly だけでは生成されず、annotationProcessor が必要です。テストコードでLombokを使う場合は test 側も追加します。IDE（IntelliJ IDEA、Eclipse、VS Code）ではLombokのプラグイン・注釈処理の有効化も確認します。

Lombok版と展開後コードの比較（実行結果つき）

以下の展開後コードは、1つのファイル（Expanded.java）にまとめて java Expanded.java で実行しました。

$ java -Dstdout.encoding=UTF-8 Expanded.java
java.version=21.0.10

@Data：5つのアノテーションのまとめ

import lombok.Data;

@Data
public class Member {
    private final String email;
    private String name;
    private int age;
}

展開後（getter・setter・コンストラクタ・equals/hashCode・toString）です。

public class Member {
    private final String email;
    private String name;
    private int age;

    public Member(final String email) {         // @RequiredArgsConstructor：finalだけ
        this.email = email;
    }
    public String getEmail() { return this.email; }
    public String getName() { return this.name; }
    public int getAge() { return this.age; }
    public void setName(final String name) { this.name = name; }  // finalにはsetterなし
    public void setAge(final int age) { this.age = age; }

    @Override public boolean equals(final Object o) {
        if (o == this) return true;
        if (!(o instanceof Member)) return false;
        final Member other = (Member) o;
        if (!other.canEqual((Object) this)) return false;
        if (this.getAge() != other.getAge()) return false;
        final Object this$email = this.getEmail();
        final Object other$email = other.getEmail();
        if (this$email == null ? other$email != null : !this$email.equals(other$email)) return false;
        final Object this$name = this.getName();
        final Object other$name = other.getName();
        if (this$name == null ? other$name != null : !this$name.equals(other$name)) return false;
        return true;
    }
    protected boolean canEqual(final Object other) { return other instanceof Member; }

    @Override public int hashCode() {
        final int PRIME = 59;
        int result = 1;
        result = result * PRIME + this.getAge();
        final Object $email = this.getEmail();
        result = result * PRIME + ($email == null ? 43 : $email.hashCode());
        final Object $name = this.getName();
        result = result * PRIME + ($name == null ? 43 : $name.hashCode());
        return result;
    }
    @Override public String toString() {
        return "Member(email=" + this.getEmail() + ", name=" + this.getName() + ", age=" + this.getAge() + ")";
    }
}

Member a = new Member("a@example.com"); a.setName("佐藤"); a.setAge(30);
Member b = new Member("a@example.com"); b.setName("佐藤"); b.setAge(30);
System.out.println(a);
System.out.println("a.equals(b)=" + a.equals(b) + ", hash同じ=" + (a.hashCode() == b.hashCode()));
Set<Member> set = new HashSet<>(); set.add(a);
a.setAge(31);
System.out.println("age変更後 set.contains(a)=" + set.contains(a) + ", set.size()=" + set.size());

--- @Data
Member(email=a@example.com, name=佐藤, age=30)
a.equals(b)=true, hash同じ=true
age変更後 set.contains(a)=false, set.size()=1

@Dataのequals/hashCodeは全フィールドを使うため、HashSetに入れた後で値を変えると contains が false になります。 要素は1件残っているのに見つけられない状態です。可変オブジェクトをSetやMapのキーに使う場合は、比較に使う項目を変えない設計にするか、@EqualsAndHashCode で比較対象を変わらない項目に絞ります。

canEqual は、サブクラスと親クラスの比較で対称性（a.equals(b) と b.equals(a) が同じ結果）を保つための補助メソッドです。

@Value と @With：不変クラス

import lombok.Value;
import lombok.With;

@Value
public class Point {
    @With int x;
    int y;
}

public final class Point {                       // final class になる
    private final int x;                         // private final が自動で付く
    private final int y;
    public Point(final int x, final int y) { this.x = x; this.y = y; }
    public int getX() { return this.x; }
    public int getY() { return this.y; }
    // equals / hashCode / toString は @Data と同じ形（final classなので canEqual は不要）
    public Point withX(final int x) {
        return this.x == x ? this : new Point(x, this.y);
    }
}

--- @Value / @With
Point(x=1, y=2) -> Point(x=5, y=2), 同じ値なら同じ参照: true

@Withは「1項目だけ変えたコピー」を返し、値が同じなら自分自身を返します。 元のオブジェクトは変わりません。

@Builder：ビルダーパターン

import lombok.Builder;
import java.util.List;

@Builder
public class Item {
    private final String name;
    private final int price;
    private final List<String> tags;
}

public class Item {
    private final String name;
    private final int price;
    private final List<String> tags;

    Item(final String name, final int price, final List<String> tags) {   // パッケージプライベート
        this.name = name; this.price = price; this.tags = tags;
    }
    public static ItemBuilder builder() { return new ItemBuilder(); }

    public static class ItemBuilder {
        private String name;
        private int price;
        private List<String> tags;
        ItemBuilder() { }
        public ItemBuilder name(final String name) { this.name = name; return this; }
        public ItemBuilder price(final int price) { this.price = price; return this; }
        public ItemBuilder tags(final List<String> tags) { this.tags = tags; return this; }
        public Item build() { return new Item(this.name, this.price, this.tags); }
        @Override public String toString() {
            return "Item.ItemBuilder(name=" + this.name + ", price=" + this.price + ", tags=" + this.tags + ")";
        }
    }
}

Item.ItemBuilder ib = Item.builder().name("ノート").price(300);
System.out.println(ib);
System.out.println(ib.tags(List.of("文具")).build());   // Item側に @ToString を付けた場合

--- @Builder
Item.ItemBuilder(name=ノート, price=300, tags=null)
Item(name=ノート, price=300, tags=[文具])

指定しなかった項目はJavaの既定値（参照型は null、int は 0）になります。 フィールドに書いた初期値（= new ArrayList<>() など）はビルダーでは使われないため、初期値を残したいときは @Builder.Default を付けます。リストに1件ずつ追加したいときは @Singular を付けると tag("文具") のようなメソッドが生成されます。

@SuperBuilder：継承したクラスのビルダー

import lombok.SuperBuilder;   // 1.18.48 から本体パッケージ（以前は lombok.experimental）

@SuperBuilder
public class BaseItem {
    private final String name;
}

@SuperBuilder
public class Book extends BaseItem {
    private final String isbn;
}

Book book = Book.builder().name("Java入門").isbn("978-0-00-000000-0").build();

@SuperBuilder は親クラスと子クラスのすべてに付ける必要があり、@Builder とは同時に使えません。 toBuilder = true を使う場合も、親子すべてに指定します。

@NonNull：nullチェック

public class Tag {
    private final String label;
    public Tag(@NonNull String label) { this.label = label; }
}

public Tag(final String label) {
    if (label == null) {
        throw new NullPointerException("label is marked non-null but is null");
    }
    this.label = label;
}

--- @NonNull
NPE: label is marked non-null but is null

メッセージに引数名が入るため、どの値が null だったかがすぐわかります。 例外の種類は lombok.nonNull.exceptionType で IllegalArgumentException などに変えられます。

@Synchronized と @Locked：ロック

@Synchronized public void inc()  { count++; }
@Locked       public void inc2() { count2++; }

private final Object $lock = new Object[0];          // @Synchronized 用
public void inc() { synchronized (this.$lock) { count++; } }

private final Lock $lock = new ReentrantLock();       // @Locked 用（実際の名前も $lock）
public void inc2() { this.$lock.lock(); try { count2++; } finally { this.$lock.unlock(); } }

4スレッドで各1万回ずつ呼んだ結果です。

--- @Synchronized / @Locked
@Synchronized count=40000, @Locked count=40000（期待値 各40000）

synchronized (this) ではなく外から見えない専用オブジェクトでロックするため、他のコードが同じロックを取り合うことを防げます。@Locked は ReentrantLock を使うので、仮想スレッドを使うコードでも扱いやすい形です。

@SneakyThrows と @Cleanup

@SneakyThrows
static String readFirstLine(String path) {
    try (BufferedReader r = new BufferedReader(new FileReader(path))) { return r.readLine(); }
}

展開後は catch (Throwable $ex) { throw Lombok.sneakyThrow($ex); } の形になり、throws IOException を宣言せずに検査例外がそのまま呼び出し元へ届きます。同等の処理を標準Javaで書いて実行しました。

--- @SneakyThrows
java.io.FileNotFoundException: /no/such/file.txt (No such file or directory)

@Cleanup Res res = new Res();
System.out.println("リソースを使用中");

Res res = new Res();
try {
    System.out.println("リソースを使用中");
} finally {
    if (java.util.Collections.singletonList(res).get(0) != null) {
        res.close();
    }
}

--- @Cleanup
リソースを使用中
Res.close() が呼ばれた

Java 7以降は try-with-resources が標準で同じことをできるため、@Cleanup は既存コードで見かけたときに読めれば十分です。@SneakyThrows は呼び出し側から例外が見えにくくなるので、ラムダ内など範囲を限って使うと読みやすさを保てます。

ログ系アノテーション

Spring Boot では SLF4J が標準なので @Slf4j が定番です。フィールド名は lombok.log.fieldName で変えられます。

recordとLombokの使い分け

Java 16以降の record は、不変のデータ入れ物をLombokなしで書ける標準機能です。同じ Point を record で書いて実行しました。

record Point(int x, int y) {
    Point withX(int x) { return new Point(x, y); }   // @With 相当は自分で書く
}

Point[x=1, y=2] x()=1 equals=true -> Point[x=5, y=2]

新しく書く不変のDTOは record、getter形式が必要なライブラリ連携や可変クラスはLombokという分け方が選びやすくなります（recordの詳しい使い方は別記事で扱っています）。

JPAエンティティに@Dataを付けると起きること

JPAの双方向関連（カテゴリ⇔商品）に @Data 相当の toString／hashCode を付けた状態を再現して実行しました。

class Category { Long id; String name; List<Product> products; /* @Data相当の toString・hashCode */ }
class Product  { Long id; String name; Category category;     /* @Data相当の toString・hashCode */ }

Category c = new Category(); c.id = 1L; c.name = "文具";
Product pr = new Product(); pr.id = 10L; pr.name = "ノート"; pr.category = c; c.products.add(pr);
System.out.println(c);           // Category → products → Product → category → ...
System.out.println(c.hashCode());

--- JPA双方向 + @Data
toString: java.lang.StackOverflowError
hashCode: java.lang.StackOverflowError

お互いを参照するフィールドが toString・hashCode に含まれるため、呼び出しが循環して StackOverflowError になります。 さらにJPAでは、遅延ロードの関連をtoStringが読みに行くことで予期しないSQLが発行されたり、保存時に採番されるIDが変わることでhashCodeが変わったりします。

推奨構成

import jakarta.persistence.*;
import lombok.*;

@Entity
@Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)   // JPA用、外からは使わせない
@ToString(onlyExplicitlyIncluded = true)
public class Product {

    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    @ToString.Include
    private Long id;

    @ToString.Include
    private String name;

    @ManyToOne(fetch = FetchType.LAZY)
    private Category category;                        // toString に含めない

    public Product(String name, Category category) {  // 生成用のコンストラクタは明示
        this.name = name; this.category = category;
    }

    public void rename(String name) { this.name = name; }   // setterの代わりに意図のある変更メソッド

    @Override public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Product other)) return false;
        return id != null && id.equals(other.id);           // 未保存（id=null）同士は別物
    }
    @Override public int hashCode() { return getClass().hashCode(); }  // IDが採番されても変わらない
}

ID比較・関連除外にした形を、保存前にHashSetへ入れ、その後IDが採番された想定で実行しました。

--- 推奨形（ID比較・関連除外）
SafeProduct(id=10, name=ノート) / 採番後 contains=true

エンティティは「@Getter＋protectedの@NoArgsConstructor＋関連を除いた@ToString＋手書きのequals/hashCode」にすると、循環や値の変化に強い形になります。@EqualsAndHashCode(onlyExplicitlyIncluded = true) でIDだけを含める方法もありますが、その場合は未保存（ID が null）のインスタンス同士が等しいと判定される点に注意します。

lombok.configの主要設定

lombok.config はソースツリーのルート（またはパッケージのディレクトリ）に置く設定ファイルで、下の階層に引き継がれます。

# これより上のディレクトリの lombok.config を読まない
config.stopBubbling = true

# 生成コードに @lombok.Generated を付ける（カバレッジ計測から除外しやすくなる）
lombok.addLombokGeneratedAnnotation = true

# 継承クラスで @EqualsAndHashCode / @ToString が親を呼ぶか
lombok.equalsAndHashCode.callSuper = call
lombok.toString.callSuper = call

# @NonNull の例外を IllegalArgumentException に
lombok.nonNull.exceptionType = IllegalArgumentException

# Spring の @Qualifier / @Value をコンストラクタ引数へコピー（@RequiredArgsConstructor でDIするとき）
lombok.copyableAnnotations += org.springframework.beans.factory.annotation.Qualifier
lombok.copyableAnnotations += org.springframework.beans.factory.annotation.Value

# チームで使わないと決めた機能を警告・エラーにする
lombok.data.flagUsage = warning
lombok.sneakyThrows.flagUsage = error

# ロガーのフィールド名
lombok.log.fieldName = log

lombok.copyableAnnotations に @Qualifier を加えておくと、@RequiredArgsConstructor でのDIでもBeanの指定が効きます。 Spring と組み合わせるときに便利な設定です。

よくある質問

Q. getterが見つからないとコンパイルエラーになります。 A. 注釈処理が動いていないことが多い原因です。Mavenなら annotationProcessorPaths、Gradleなら annotationProcessor の設定を確認し、IDEでは注釈処理（Annotation Processing）を有効にします。JDKを上げた直後なら、そのJDKに対応したLombokのバージョンかも確認します。

Q. Lombokが生成したコードを見る方法はありますか？ A. delombok（java -jar lombok.jar delombok src -d src-delomboked）で展開後のソースを書き出せます。IntelliJ IDEAでは Refactor メニューの Delombok からも実行できます。コンパイル済みクラスなら javap -p クラス名 でメソッドの一覧を確認できます。

Q. @Data と @Value はどちらを使えばよいですか？ A. 値を後から変えるなら @Data、変えないなら @Value（さらに record が使えるなら record）です。迷ったら不変側を選ぶと、意図しない変更を防げます。

Q. Spring のDIで @RequiredArgsConstructor を使ってよいですか？ A. はい。final フィールドを並べて @RequiredArgsConstructor を付けると、コンストラクタインジェクションの定型コードを省けます。 コンストラクタが1つだけなら @Autowired も不要です。

まとめ

• 最新は Lombok 1.18.48。@SuperBuilder が本体パッケージに昇格し、JDK 27に対応
• @Data は5つの機能のまとめ。equals/hashCode は全フィールドを使う
• HashSetに入れた後の値変更で contains が falseになることを実行結果で確認
• 不変のDTOは record、getter形式が必要なら @Value、生成には @Builder
• JPAエンティティに @Data は使わず、@Getter・protectedコンストラクタ・関連を除いた @ToString・ID比較の equals にする
• JDK 23以降は annotationProcessorPaths／annotationProcessor の設定で確実に動かす
• チームの方針は lombok.config の flagUsage や copyableAnnotations で共有する

株式会社RJCでは、Lombokのように日々のコードを読みやすくする道具の使い方を仲間と学び合っています。こうした知識を共有しながら、日々技術を磨いています。

株式会社RJC ― SI事業・SES事業・AI駆動開発。RJCは一緒に成長を楽しめる会社です。