Javaアノテーションとは？意味と使い方を初心者向けに解説

Javaのアノテーションとは、@Overrideや@Autowiredのように「@」で始まるメタデータ（付加情報）のことです。コンパイラやフレームワークへの指示を、ソースコードに直接書き込める仕組みです。

「@の記号は見かけるけど、何をしているかわからない」「フレームワークで使っているが仕組みを理解したい」。

そんな方に向けて、10年以上のJava開発経験をもとに解説します。

この記事では、標準アノテーション一覧（@Override・@Deprecated等）の使い方から、@interfaceによる自作方法まで扱います。

さらにSpring Frameworkでの活用例まで、コード付きで体系的に学べます。

この記事でわかること

Javaアノテーションの定義とコメント・XMLとの違い
標準アノテーション（@Override等）の使い方
@interfaceによる独自アノテーションの自作方法
リフレクション・Spring Frameworkでの活用例

Javaのアノテーションとは？基本的な仕組みを解説

アノテーションの役割と目的

Javaのアノテーションは、一言でいえば「メタデータ（付加情報）」です。プログラムのコード本体の動作を直接変えるものではありません。

では何をするかというと、ソースコードに「タグ」や「ラベル」を付けるような役割を果たします。

付与されたアノテーションの情報を、コンパイラやフレームワークなどのツールが読み取ります。

読み取った情報に基づいて、特別な処理を行ったり、設定として利用したりするのです。

アノテーションの主な目的は3つあります。

目的

コンパイラへの指示: @Overrideのように、コンパイラにコードのチェック方法を指示
ツールによる処理: @Test（JUnit）のように、ビルドツールや外部ライブラリが特定の処理（テスト実行など）を行う目印
実行時の動作変更: @Autowired（Spring）のように、プログラムの実行中にフレームワークが動作を動的に変更する

Javaでアノテーションが登場した背景（Java 5以降の進化）

Javaアノテーションは、Java 5 (JDK 1.5) というバージョンから正式に導入されました。

Java 5以前の大規模開発（EJBなど）では、設定情報の多くをXMLファイルに記述するのが一般的でした。

プログラムの動作（例えば「このURLにアクセスしたら、このクラスを動かす」といった設定）を、Javaのソースコードとは別のファイルで管理していました。

この方法には、「設定を一箇所で管理できる」という利点がありました。しかし、開発規模が大きくなると、XMLファイルが肥大化し、非常に複雑になります。

「このクラスは、あのXMLファイルのどこで設定されているのか？」を探すのが困難になり、保守性が著しく低下する「XML地獄」と呼ばれる問題を引き起こしました。

筆者がStruts 1系のプロジェクトに携わっていた頃は、1つの画面を追加するだけで struts-config.xml に数十行の設定を書く必要がありました。

設定ファイルが3,000行を超えると、目的の設定を探すだけで数分かかる状態でした。

この問題を解決するために、Javaアノテーションが導入されたのです。

設定情報をソースコード内に直接記述できるようにし、コードと設定の一体性を高めました。

これにより、開発者はコードを見るだけで、そのクラスやメソッドがどのように扱われるべきかを、すぐに理解できるようになったのです。

その後もJava 8で@FunctionalInterfaceや@Repeatableが追加されるなど、アノテーション機能は着実に拡張されてきました。

2026年8月時点の最新LTSであるJava 25でも、アノテーションはJava開発の基盤技術として変わらず重要な位置を占めています。

: Javaの歴史を年表で解説｜30年生き残った3つの理由
Javaは1995年5月にSun Microsystemsが正式発表してから30年以上、世界で最も使われるプログラミング言語の一つであり続けています。しかし「なぜJavaはこれほど長く生き残れたのか ...

あわせて読む

コメント・XMLとの違い

アノテーションはメタデータの一種ですが、「コメント」とは決定的に異なります。

コメント (// や /* ... */)
- 「人間」が読むためのもの
- コードの意図を説明したり、メモを残したりするために使われる
- コンパイラはコメントを完全に無視します。プログラムの動作には一切影響しない
アノテーション (@...)
- 「プログラム（コンパイラやツール）」が読むためのもの
- コードに意味付けを行う
- コンパイラがチェックに使ったり、フレームワークが実行時の動作を変えたりするために使われる

例えるなら、コメントは「料理レシピの横に書く『ここは焦げやすいので注意』という手書きメモ」です。

一方、アノテーションは「レシピに貼る『★3つ星シェフ認定』『アレルギー注意：卵使用』という公式シール」のようなものです。

手書きメモ（コメント）は料理人（開発者）しか見ません。

しかし、公式シール（アノテーション）は、レストランの審査機関（プログラム）が評価に使ったり、お客様（実行時）への警告に使ったりします。

Javaの標準アノテーション一覧【@Override等】

Java標準アノテーション（@Override・@Deprecated等）の一覧を示す図

Javaには、最初から組み込まれている「標準アノテーション」がいくつかあります。これらは主にコンパイラに対する指示として機能します。

@Override・@Deprecated・@SuppressWarningsの使い方

特に重要な3つの標準Javaアノテーションを紹介します。

@Override (オーバーライド)

これは、最も目にするアノテーションかもしれません。

目的: 親クラス（スーパークラス）やインターフェースのメソッドを、正しく上書き（オーバーライド）していることをコンパイラに宣言します。
使い方: 子クラスで、上書きするメソッドの直前に記述します。
メリット: もしこのアノテーションを付けたのに、親クラスに同じ名前・同じ引数のメソッドが存在しない場合（例えばタイプミス）、コンパイルエラーとして検出できます。toString() を toStrng() と書き間違えるような、ありがちなミスを確実に防いでくれます。

class Animal {
    void speak() {
        System.out.println("...");
    }
}

class Dog extends Animal {
    @Override // 正しく上書きしているかコンパイラがチェック
    void speak() {
        System.out.println("ワン！");
    }
}

筆者の経験では、レガシーなJavaプロジェクトの保守で @Override を付けずにメソッドをオーバーライドしていたコードに遭遇したことがあります。

メソッド名の微妙なスペルミスが原因で意図した動作にならず、バグの調査に半日費やしました。

それ以来、IDEの設定で @Override の付け忘れを警告として表示するようにしています。

@Deprecated (非推奨)

目的: そのメソッドやクラスが「古い」または「バグがある」ため、使用を推奨しないことを示します。
使い方: 非推奨にしたいクラスやメソッドの直前に記述します。
メリット: このアノテーションが付いた要素を他の場所で使うと、IntelliJ IDEAやEclipse、VS CodeなどのIDE（統合開発環境）が取り消し線を表示し、開発者に警告してくれます。

@SuppressWarnings (警告抑制)

目的: コンパイラが出す特定の警告を、意図的に無視させます。
使い方: () の中に、抑制したい警告の種類を指定します。例えば SuppressWarnings("unchecked") は、ジェネリクス（型）関連の安全でないキャストに関する警告を抑えます。
注意点: 警告には理由があります。このアノテーションは、なぜ警告が出るかを開発者が理解し、「安全であることを確認済み」の場合にのみ限定して使うべきです。むやみに使うと、バグの原因を見逃すことになります。

実務では、コードレビューで @SuppressWarnings が出てきたら「なぜこの警告を抑制しているのか」をコメントで残すルールにしているチームも多いです。

抑制理由が説明できないなら、警告に従ってコードを修正すべきです。

@FunctionalInterfaceや@SafeVarargsなどの補助アノテーション

Java 8以降、さらに便利なアノテーションが追加されました。

@FunctionalInterface (関数型インターフェース)

目的: Java 8で導入されたラムダ式に関連します。そのインターフェースが「抽象メソッドを1つだけ持つ」こと（＝関数型インターフェースであること）をコンパイラに示します。
メリット: もしこのアノテーションが付いたインターフェースに、誤って抽象メソッドを2つ以上定義しようとすると、コンパイルエラーになります。ラムダ式として使えることを保証するチェック機能です。

@FunctionalInterface
interface MyRunnable {
    void run(); // 抽象メソッドはこれ1つだけ
    // void stop(); // これを追加するとコンパイルエラーになる
}

@SafeVarargs (安全な可変長引数)

目的: 可変長引数（String... args のような引数）とジェネリクスを組み合わせた際に発生する、潜在的な型安全性の警告を抑制します。
使い方: メソッド開発者が「この可変長引数の使い方は安全である」と確信している場合に、メソッドに付けます。

標準アノテーションを使うときの注意点

標準アノテーションは、単なる「印」ではありません。その多くが、コンパイラの動作に直接影響を与えます。

@Override を付け忘れると、タイプミスに気づかず、意図しない動作（オーバーライドしたつもりが、新しいメソッドを定義していた）につながります。

@SuppressWarnings を乱用すれば、コードの品質チェック機能を自ら無効にしてしまうことになります。

それぞれのアノテーションが「なぜ存在するのか」「どんなチェックを行うのか」という背景を理解し、適切に使うことが大切です。

: Java抽象クラスとは？インターフェースとの違いを解説
Javaの学習を進めていると、「抽象クラス」という言葉に出会うと思います。「普通のクラスと何が違うの？」「インターフェースと似ているけど、どう使い分けるの？」「そもそも、なぜ抽象クラスなんてもの ...

あわせて読む

Javaでアノテーションを自作する方法

Javaアノテーションは、自分で新しく定義できます。これにより、独自のルールを設けたり、フレームワークのような機能を作ったりできます。

@interfaceでアノテーションを定義する

独自アノテーションの定義は、インターフェースの定義（interface）と似ていますが、@ を付けた @interface というキーワードを使います。

: Java extendsの使い方｜継承の基本をわかりやすく解説
Javaの学習を進める中で、多くの方が「継承」の壁にぶつかります。私自身、10年以上前にJavaを学び始めたとき、この継承の概念を理解するのに苦労した経験があります。しかし、実務でコードを書く中で ...

あわせて読む

public @interface MyAnnotation {
    // この中に「要素」を定義していく
}

これだけで、@MyAnnotation というアノテーションが使えるようになります。

要素（属性）の指定とデフォルト値

アノテーションに情報を持たせたい場合、「要素（属性）」を定義します。これは、インターフェースのメソッド定義のような形式で書きます。

public @interface ExecuteLog {
    String value(); // "value" という名前の要素
    int level() default 1; // "level" という要素。デフォルト値は1
}

使い方: @ExecuteLog(value = "Test", level = 2) のように指定します。
デフォルト値: default キーワードでデフォルト値を指定できます。デフォルト値がある要素は、使う側で省略可能です（例: @ExecuteLog(value = "Test") とすると level は 1 になります）。
value要素: 要素名が value の場合、かつ value だけを指定する場合は、value = を省略できます（例: @ExecuteLog("Test")）。

メタアノテーション5種の役割と使い方

独自アノテーションを定義する際、そのアノテーション自体に「メタアノテーション」を付けることが一般的です。

メタアノテーションは、自作アノテーションの「振る舞い」を定義します。

@Retention (保持ポリシー)

アノテーションの情報が「いつまで」保持されるかを指定します。

RetentionPolicy.SOURCE:ソースコード上のみ。コンパイルされると情報は破棄されます。@Override や @SuppressWarnings など、コンパイラへの指示だけに使われます。
RetentionPolicy.CLASS:クラスファイル（.class）には記録されます。しかし、実行時にプログラム（JVM）から読み取ることはできません。これがデフォルトの動作です。
RetentionPolicy.RUNTIME:クラスファイルに記録され、かつ実行時にも読み取れます。Springフレームワークのように、実行時にアノテーション情報を使って動作を変えたい場合に必須です。

RetentionPolicyをRUNTIMEにし忘れると、リフレクションで読み取れません。

「アノテーションを付けたのに動かない」というハマりどころになるため注意が必要です。

@Target (適用対象)

アノテーションを「どこに」付けられるかを限定します。

ElementType.METHOD: メソッドのみに付けられます。
ElementType.TYPE: クラス、インターフェース、Enumに付けられます。
ElementType.FIELD: フィールド（メンバ変数）に付けられます。
ElementType.PARAMETER: メソッドの引数に付けられます。

複数指定することも可能です（例: @Target({ElementType.METHOD, ElementType.FIELD})）。

@Documented (ドキュメント化)

このアノテーションを付けたクラスのJavadoc（APIドキュメント）を生成する際に、このアノテーション情報もドキュメントに含めるよう指示します。

@Inherited (継承)

親クラスに付けたアノテーションを、子クラスにも自動的に引き継がせます。

通常、アノテーションはクラスを継承しても引き継がれませんが、@Inherited を付けた自作アノテーションは子クラスにも有効になります。

@Repeatable (繰り返し)

Java 8で追加されたメタアノテーションです。同じアノテーションを1つの要素に複数回付けられるようにします。

たとえば、複数のスケジュールを指定する @Schedule を同じメソッドに2回付ける、といった使い方が可能になります。

自作アノテーションを使って動作を確認してみよう

では、「実行時に読み取れる」「メソッド専用」の簡単なアノテーションを作ってみます。

1. アノテーションの定義 (@interface)

メタアノテーション @Retention と @Target を使います。

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

// 実行時(RUNTIME)まで情報を保持する
@Retention(RetentionPolicy.RUNTIME)
// メソッド(METHOD)にのみ付与できる
@Target(ElementType.METHOD)
public @interface Loggable {
    // ログのレベルを指定する要素 (デフォルトは "INFO")
    String logLevel() default "INFO";
}

2. アノテーションの使用

作成した @Loggable をクラスのメソッドに使ってみます。

public class MySampleService {

    @Loggable(logLevel = "DEBUG")
    public void executeTaskA() {
        System.out.println("タスクAを実行しました。");
    }

    @Loggable // デフォルト値の "INFO" が使われる
    public void executeTaskB() {
        System.out.println("タスクBを実行しました。");
    }

    public void executeTaskC() {
        // @Loggable が付いていない
        System.out.println("タスクCを実行しました。");
    }
}

この時点では、@Loggable を付けても、まだ何も特別なことは起きません。これは単なる「印」が付いただけの状態だからです。

この印を「読み取って処理する」仕組みが次に必要になります。

Javaリフレクションを使ったアノテーションの活用例

アノテーションは、それ単体では意味を持ちません。「アノテーションを読み取って、それに応じた処理を行うプログラム」とセットになって初めて機能します。

その読み取る仕組みの代表が「リフレクション」です。

リフレクションでアノテーション情報を取得する方法

Javaリフレクションとは、プログラムの実行中に、クラスやメソッド、フィールドの情報を動的に取得したり、操作したりする機能です。

: JavaのAPIとは？基本と使い方を初心者向けに解説
Javaプログラミングの学習を始めると、必ず「API」という言葉に出会います。私自身、Javaを学び始めたころ、「APIってライブラリと何が違うの？」と混乱した経験があります。しかし、多くの実務プ ...

あわせて読む

@Retention(RetentionPolicy.RUNTIME) を指定したアノテーションは、実行時に「読み出す」ことができます。

このリフレクション機能を使うことで実現します。

先ほど作った MySampleService クラスのアノテーション情報を、リフレクションで読み出してみましょう。

import java.lang.reflect.Method;

public class AnnotationProcessor {

    public static void main(String[] args) {
        // 検査対象のクラス情報を取得
        Class<?> clazz = MySampleService.class;

        // クラスが持つ全てのメソッドを調べる
        for (Method method : clazz.getDeclaredMethods()) {
            
            // メソッドに @Loggable アノテーションが付いているか判定
            if (method.isAnnotationPresent(Loggable.class)) {
                
                // アノテーションのインスタンスを取得
                Loggable logAnnotation = method.getAnnotation(Loggable.class);
                
                // アノテーションの要素（logLevel）を取得
                String level = logAnnotation.logLevel();

                System.out.println(
                    "メソッド名: " + method.getName() + 
                    " / ログレベル: " + level
                );

            } else {
                System.out.println(
                    "メソッド名: " + method.getName() + 
                    " / アノテーション無し"
                );
            }
        }
    }
}

実行結果:

メソッド名: executeTaskA / ログレベル: DEBUG
メソッド名: executeTaskB / ログレベル: INFO
メソッド名: executeTaskC / アノテーション無し

リフレクションを使うと「どのメソッドに」「どのアノテーションが」「どんな値で」付いているかを実行時に調べられます。

フレームワークは、リフレクションの仕組みを利用しています。

「@Loggable が付いていたら、そのログレベルでログを出力する」といった共通処理を自動的に実行しています。

: Javaリフレクションとは？禁止場面も解説
Javaリフレクションは、実行時にクラスやメソッド、フィールドの情報を取得・操作できる強力な機能です。 SpringのDI（依存性注入）やJUnitのテスト実行など、普段使っているフレームワークの裏側 ...

あわせて読む

アノテーションを使ったバリデーションの仕組み

リフレクションの具体的な応用例が、バリデーションです。

Jakarta Bean Validation（旧JSR 303 / Hibernate Validator が参照実装）という標準仕様があります。

@NotNull (nullはダメ)、@Size(min=2, max=10) (文字長は2～10文字) といったアノテーションが用意されています。

class UserForm {
    @NotNull
    @Size(min = 1, max = 50)
    private String username;
}

バリデーションを実行するライブラリは、リフレクションを使って UserForm クラスの全フィールドを走査します。

そして「@NotNull が付いているのに username フィールドが null だったら、エラーにする」という処理を動的に行います。

Spring Frameworkでのアノテーション活用例

Javaアノテーション活用の「お手本」とも言えるのが、Spring Frameworkです（2026年8月時点の最新はSpring Boot 4系 / Spring Framework 7系）。

Springは、Javaアノテーションとリフレクション（やAOPという別の技術）を駆使して、開発を劇的に効率化します。

@Component, @Service, @Repository:これらのアノテーションがクラスに付いていると、Springは起動時にリフレクション（クラスパススキャン）でそれらを見つけ出します。そして、DIコンテナ（部品を管理する箱）に自動的に登録（インスタンス化）します。
@Autowired (自動注入):フィールドやコンストラクタにこのアノテーションが付いていると、SpringはDIコンテナから適切な部品（Bean）を探し出し、自動的に代入（注入）します。
@Transactional (トランザクション管理):メソッドに @Transactional を付けると、Springはそのメソッドの実行前後に割り込みます（AOPプロキシ）。メソッド開始前にデータベースのトランザクションを開始し、メソッドが正常終了すればコミット、例外が発生すればロールバックする、という処理を「自動的に」差し込んでくれます。

開発者は「@Transactional」と書くだけで、複雑なトランザクション管理コードを書かなくてよくなります。

このトランザクション自動管理も、Springが実行時にアノテーションを読み取っているからこそ可能な機能です。

: Java AOPとは？Spring実装で解説
AOP（アスペクト指向プログラミング）とは、ログ出力やトランザクション管理など「あちこちに散らばる共通処理」を一箇所にまとめて管理する手法です。この記事では、Advice・Pointcut・Aspe ...

あわせて読む

: JavaBeansとは？3つの基本ルールと実務での使い方を解説
JavaBeans（ジャバビーンズ）とは、Javaで再利用可能なクラスを作るための設計規約です。「引数なしコンストラクタ」「private フィールド＋getter/setter」「Serializ ...

あわせて読む

Javaアノテーションの実践テクニックと設計指針

アノテーションは便利ですが、無計画に使うと、かえって分かりにくいコードになることもあります。

コードの保守性と可読性を高めるアノテーション設計

もし独自アノテーションを作る場合は、以下の点に気をつけると良いでしょう。

目的を明確にする: 1つのアノテーションに、複数の異なる機能を持たせるのは避けます。「これはログ用」「これは認証用」のように、関心を分離することが重要です。
適切な名前を付ける: アノテーションの名前は、その「役割」や「機能」が一目でわかるようにします。
@Target を厳密にする: アノテーションを付けられる場所を @Target で厳密に限定します。メソッド専用のアノテーションが、誤ってクラスに付けられるのを防ぐだけでも、保守性は向上します。
@Retention を正しく選ぶ: 実行時に不要なアノテーション（コンパイル時チェック用など）を RUNTIME にすると、無駄なリソースを使ってしまいます。目的に応じた保持ポリシーを選びます。

: Javaコーディング規約入門｜命名・例外処理の基本
「Javaのコーディング規約って、何から守ればいいの？」は、チーム開発や実務を始めたばかりのエンジニアが最初にぶつかる壁です。この記事では、Javaの現場で最低限押さえておきたいコーディング規約を「 ...

あわせて読む

アノテーション処理ツール（APT）とコンパイル時チェック

これまで説明したリフレクションは「実行時」にアノテーションを読み取る技術でした。

これには「実行コストがかかる」「実行するまでエラーが分からない」という側面があります。

これに対し、「コンパイル時」にアノテーションを処理する仕組みが APT (Annotation Processing Tool) です。

APTは、Javaコンパイラ (javac) の一部として動作します。

@Retention(RetentionPolicy.SOURCE) のアノテーションをコンパイル中に読み取ります。

それに基づいて警告を出したり、エラー（コンパイル失敗）にしたりできます。

リフレクションが「実行時の動的な処理」であるのに対し、APTは「コンパイル時の静的な処理」と言えます。

Annotation Processorを使った自動コード生成

APTの最も強力な機能は、コードの自動生成 (Code Generation) です。

コンパイル時にアノテーションを読み取り、それを元にして新しいJavaのソースコードファイル（.java）を自動的に生成し、一緒にコンパイルさせることができます。

この技術を使った最も有名なライブラリが Lombok (ロンボック) です。

2026年8月時点でもJavaプロジェクトで広く使われており、Java 21以降のrecord型と使い分けるケースも増えています。

Lombokの @Getter / @Setter / @Data:開発者がクラスのフィールドに @Getter と付けると、LombokのAnnotation Processorがコンパイル時にそれを検知します。そして、public String getXxx() というメソッドのソースコードを自動生成し、コンパイル対象に加えます。

開発者は定型的なゲッターやセッターを書く手間から解放されます。

リフレクションとは異なり、コンパイル後には「実際に getXxx() メソッドが存在するクラスファイル」が完成しているため、実行時のコストもかかりません。

他にも、DTOとEntity（2つの異なるオブジェクト）間の値詰め替えコードを自動生成する MapStruct などがあります。

多くのライブラリがAPTによるコード自動生成を採用しています（2026年8月時点）。

イミュータブルなデータの受け渡しにはrecord型、既存のミュータブルなEntity/DTOにはLombokを使う、という使い分けが実務では一般的です。

: Lombokとは？Java開発のコード量を激減させる使い方入門
Lombokとは、Javaの冗長なGetter・Setter・toString・コンストラクタなどを、アノテーション1つで自動生成してくれるライブラリです。導入するだけでクラスの記述量が60%以上削 ...

あわせて読む

Javaアノテーションに関するよくある質問

Q1. Javaのアノテーションとは簡単に言うと何ですか？

A1. コンパイラやフレームワークへの「指示書」です。「@」で始まる記号で、コードの動作自体は変えずに、コンパイラやツールに対する付加情報（メタデータ）を伝えます。

Q2. アノテーションとコメントの違いは何ですか？

A2. コメントは人間が読むためのもので、コンパイラは無視します。アノテーションはプログラム（コンパイラやツール）が読み取り、実際の処理に使われる点が異なります。

Q3. よく使われる標準アノテーションには何がありますか？

A3. 代表的なものは@Override（オーバーライドの明示）、@Deprecated（非推奨の明示）、@SuppressWarnings（警告抑制）の3つです。Java 8以降は@FunctionalInterfaceや@SafeVarargsも追加されています。

Q4. 独自のアノテーションはどうやって自作しますか？

A4. @interfaceキーワードを使って定義します。あわせて@Retentionと@Targetというメタアノテーションで、アノテーションがいつまで保持されるか・どこに付けられるかを指定するのが一般的です。

Q5. アノテーションはどうやって実行時に読み取りますか？

A5. リフレクションという仕組みを使います。@Retention(RetentionPolicy.RUNTIME)を指定したアノテーションは、実行時にmethod.isAnnotationPresent()等のメソッドで読み取れます。

Q6. SpringのようなフレームワークはなぜアノテーションでDIができるのですか？

A6. Springは起動時にクラスパスをスキャンし、リフレクションで@Component等のアノテーションが付いたクラスを見つけ出します。それをDIコンテナに自動登録することで、@Autowiredによる自動注入を実現しています。

まとめ：アノテーションは「見えない設定ファイル」

Javaアノテーションは、コードの中に埋め込まれた「設定ファイル」であり、プログラムに対する「指示書」です。

XML設定からアノテーション中心へ

Java 5でアノテーションが登場して以降、Java開発は大きく変わりました。

かつて開発者を悩ませた「XML地獄」は鳴りを潜め、設定の多くはコード内に記述されるようになりました。

特にSpring Boot 4のような現行フレームワークでは、アノテーションが設定の主役です。

「コードを見れば、設定がわかる」という状態（CoC: Convention over Configuration, 設定より規約）が実現されました。

これにより、開発効率は飛躍的に向上しました。

開発効率を高めるための使い分け方

Javaアノテーションの活用方法は、大きく分けて2つあります。

実行時に処理する（リフレクション）:
- 特徴: 柔軟性が高い。実行時の状態に応じて動作を変えられる。
- 例: SpringのDI (@Autowired), バリデーション (@NotNull)
- アノテーション: @Retention(RetentionPolicy.RUNTIME) が必須。
コンパイル時に処理する（APT）:
- 特徴: 実行時コストがゼロ。定型コードを自動生成できる。
- 例: Lombok (@Data), MapStruct (@Mapper)
- アノテーション: @Retention(RetentionPolicy.SOURCE) または CLASS を使う。

Javaアノテーションは、単なる「@」記号ではありません。Javaの柔軟性と生産性を支える、非常に強力な仕組みです。