リフレクションの基本概念

Javaプログラムにおけるすべてのオブジェクトには、コンパイル時の型と実行時の型という2つの型があります。多くの場合、これらの型は一致しません。例えば：

Object obj = new String("hello");

このような場合、変数の宣言型はObjectですが、実行時にはStringのメソッドを呼び出す必要があるかもしれません。この問題を解決するには、リフレクションを使用します。

リフレクション（Reflection）は、動的言語の重要な要素です。リフレクションメカニズムにより、プログラムは実行時にReflection APIを使用して任意のクラスの内部情報を取得し、任意のオブジェクトの内部プロパティやメソッドを直接操作できます。

クラスがロードされると、ヒープメモリのメソッド領域にClass型のオブジェクトが生成されます（1つのクラスには1つのClassオブジェクトのみ）。このオブジェクトにはクラスの完全な構造情報が含まれています。このオブジェクトを通じてクラスの構造を確認できます。このオブジェクトは鏡のように、クラスの構造を映し出すため、リフレクション（反射）と呼ばれます。

Classクラスの理解と取得

クラスを解剖するには、まずそのクラスのClassオブジェクトを取得する必要があります。リフレクションを使用して具体的な問題を解決するには、以下のAPIを使用します：

• java.lang.Class
• java.lang.reflect.*

したがって、Classオブジェクトはリフレクションの根源です。

Classオブジェクトの取得方法

方法1：コンパイル時に型が既知の場合

前提：具体的なクラスが既知の場合、クラスのclass属性を使用して取得します。この方法が最も安全で信頼性が高く、パフォーマンスも最適です。

Class clazz = String.class;

方法2：オブジェクトの実行時型を取得する場合

前提：特定のクラスのインスタンスが既知の場合、そのインスタンスのgetClass()メソッドを呼び出してClassオブジェクトを取得します。

Class clazz = "www.example.com".getClass();

方法3：コンパイル時に未知の型を取得する場合

前提：クラスの完全修飾名が既知で、そのクラスがクラスパス上にある場合、Classクラスの静的メソッドforName()を使用して取得できます。ClassNotFoundExceptionがスローされる可能性があります。

Class clazz = Class.forName("java.lang.String");

方法4：その他の方法

前提：システムクラスローダーまたはカスタムクラスローダーオブジェクトを使用して、指定されたパスの型をロードできます。

ClassLoader cl = this.getClass().getClassLoader();
Class clazz4 = cl.loadClass("クラスの完全修飾名");

Classオブジェクトを持つことができる型

簡単に言えば、すべてのJava型です！

• class：外部クラス、メンバー（メンバー内部クラス、静的内部クラス）、ローカル内部クラス、匿名内部クラス
• interface：インターフェース
• []：配列
• enum：列挙
• annotation：アノテーション@interface
• primitive type：基本データ型
• void

クラスのロードとClassLoaderの理解

クラスのライフサイクル

メモリ内のクラスの完全なライフサイクル：ロード→使用→アンロード。ロードプロセスは、ロード、リンク、初期化の3つの段階に分けられます。

クラスのロードプロセス

プログラムが特定のクラスをアクティブに使用する場合、そのクラスがまだメモリにロードされていない場合、システムはロード、リンク、初期化の3つのステップでクラスを初期化します。予期せぬ事態がない限り、JVMはこれら3つのステップを連続して完了するため、これら3つのステップをまとめてクラスロードと呼ぶことがあります。

クラスのロードは3つの段階に分けられます：

（1）ローディング（Loading）

クラスのclassファイルをメモリに読み込み、java.lang.Classオブジェクトを作成します。このプロセスはクラスローダーによって実行されます。

（2）リンキング（Linking）

• 検証（Verify）：ロードされたクラス情報がJVM仕様に準拠していることを確認します。例：cafebabeで始まること、セキュリティ上の問題がないことなど。
• 準備（Prepare）：クラス変数（static）にメモリを正式に割り当て、クラス変数のデフォルト初期値を設定する段階です。これらのメモリはメソッド領域に割り当てられます。
• 解決（Resolve）：仮想マシンの定数プール内のシンボリック参照（定数名）を直接参照（アドレス）に置き換えるプロセスです。

（3）初期化（Initialization）

• クラスコンストラクタ<clinit>()メソッドを実行するプロセスです。クラスコンストラクタ<clinit>()メソッドは、コンパイラがクラス内のすべてのクラス変数の代入アクションと静的コードブロック内の文を自動的に収集して生成したものです（クラスコンストラクタはクラス情報を構築するものであり、クラスオブジェクトを構築するコンストラクタではありません）。
• クラスを初期化する際、その親クラスがまだ初期化されていないことが判明した場合、まず親クラスの初期化をトリガーする必要があります。
• 仮想マシンは、クラスの<clinit>()メソッドがマルチスレッド環境で正しくロックおよび同期されることを保証します。

クラスローダー（ClassLoader）

クラスローダーの役割

classファイルのバイトコード内容をメモリにロードし、これらの静的データをメソッド領域の実行時データ構造に変換し、次にヒープ内にこのクラスを表すjava.lang.Classオブジェクトを生成して、メソッド領域のクラスデータへのアクセスエントリとします。

クラスキャッシュ：標準のJavaSEクラスローダーは要求に応じてクラスを検索できますが、一度クラスがクラスローダーにロードされると、一定期間ロード（キャッシュ）された状態を維持します。ただし、JVMのガベージコレクションメカニズムはこれらのClassオブジェクトをリサイクルできます。

クラスローダーの分類（JDK8の場合）

JVMは、ブートストラップクラスローダー（Bootstrap ClassLoader）とカスタムクラスローダー（User-Defined ClassLoader）の2種類のクラスローダーをサポートしています。

（1）ブートストラップクラスローダー（Bootstrap ClassLoader）

• このクラスローダーはC/C++言語で実装されており、JVM内部に組み込まれています。そのオブジェクトを取得するときは、多くの場合nullを返します。
• Javaのコアライブラリ（JAVA_HOME/jre/lib/rt.jarまたはsun.boot.class.pathパスの内容）をロードするために使用されます。JVM自体が必要とするクラスを提供します。
• java.lang.ClassLoaderを継承しておらず、親ローダーがありません。
• セキュリティ上の理由から、Bootstrapクラスローダーはjava、javax、sunなどで始まるパッケージのクラスのみをロードします。
• 拡張クラスローダーとアプリケーションクラスローダーをロードし、それらの親クラスローダーとして指定します。

（2）拡張クラスローダー（Extension ClassLoader）

• Java言語で記述され、sun.misc.Launcher$ExtClassLoaderによって実装されています。
• ClassLoaderクラスを継承しています。
• 親クラスローダーはブートストラップクラスローダーです。
• java.ext.dirsシステムプロパティで指定されたディレクトリからクラスライブラリをロードするか、JDKのインストールディレクトリのjre/lib/extサブディレクトリからクラスライブラリをロードします。ユーザーが作成したJARがこのディレクトリに配置されている場合、拡張クラスローダーによって自動的にロードされます。

（3）アプリケーションクラスローダー（システムクラスローダー、AppClassLoader）

• Java言語で記述され、sun.misc.Launcher$AppClassLoaderによって実装されています。
• ClassLoaderクラスを継承しています。
• 親クラスローダーは拡張クラスローダーです。
• 環境変数classpathまたはシステムプロパティjava.class.pathで指定されたパスからクラスライブラリをロードする責任があります。
• アプリケーションのクラスローダーはデフォルトでシステムクラスローダーです。
• ユーザー定義クラスローダーのデフォルトの親ローダーです。
• ClassLoaderのgetSystemClassLoader()メソッドを通じてこのクラスローダーを取得できます。

リフレクションの基本的な応用

Classオブジェクトを取得すると、何ができるでしょうか？

応用1：実行時クラスのオブジェクトを作成する

これがリフレクションメカニズムの最も一般的な応用です。実行時クラスのオブジェクトを作成するには2つの方法があります。

方法1：ClassオブジェクトのnewInstance()メソッドを直接呼び出す

要件：1）クラスに引数なしのコンストラクタがあること。2）クラスのコンストラクタのアクセス権が十分であること。

方法2：コンストラクタオブジェクトを取得してインスタンス化する

方法1の手順：

1. その型のClassオブジェクトを取得する
2. ClassオブジェクトのnewInstance()メソッドを呼び出してオブジェクトを作成する

方法2の手順：

1. ClassクラスのgetDeclaredConstructor(Class … parameterTypes)を使用して、指定されたパラメータ型のコンストラクタを取得する
2. コンストラクタのパラメータにオブジェクト配列を渡し、コンストラクタに必要な各パラメータを含める
3. Constructorインスタンスを通じてオブジェクトをインスタンス化する

コンストラクタのアクセス修飾子の範囲が不可視の場合、setAccessible(true)を呼び出すこともできます

package com.example.reflect;

import org.junit.Test;
import java.lang.reflect.Constructor;

public class ReflectionDemo {
    @Test
    public void testCreateInstance() throws Exception {
        // 方法1：newInstance()を使用
        Class<?> clazz = Class.forName("com.example.model.Sample");
        Object instance = clazz.newInstance();
        System.out.println("方法1で作成したインスタンス: " + instance);
        
        // 方法2：コンストラクタを取得してインスタンス化
        Constructor<?> constructor = clazz.getDeclaredConstructor(String.class, int.class);
        Object paramInstance = constructor.newInstance("テスト", 100);
        System.out.println("方法2で作成したインスタンス: " + paramInstance);
    }
}

応用2：実行時クラスの完全な構造を取得する

以下の情報を取得できます：パッケージ、修飾子、型名、親クラス（ジェネリック親クラスを含む）、親インターフェース（ジェネリック親インターフェースを含む）、メンバー（プロパティ、コンストラクタ、メソッド）、アノテーション（クラス上、メソッド上、プロパティ上）。

package com.example.reflect;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

public class StructureAnalyzer {
    public static void analyzeClass(Class<?> clazz) {
        System.out.println("===== クラス情報 =====");
        System.out.println("クラス名: " + clazz.getName());
        System.out.println("修飾子: " + Modifier.toString(clazz.getModifiers()));
        
        // 親クラス情報
        Class<?> superClass = clazz.getSuperclass();
        if (superClass != null) {
            System.out.println("親クラス: " + superClass.getName());
        }
        
        // フィールド情報
        System.out.println("\n===== フィールド情報 =====");
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            System.out.println(Modifier.toString(field.getModifiers()) + " " + 
                              field.getType().getSimpleName() + " " + 
                              field.getName());
        }
        
        // メソッド情報
        System.out.println("\n===== メソッド情報 =====");
        Method[] methods = clazz.getDeclaredMethods();
        for (Method method : methods) {
            System.out.print(Modifier.toString(method.getModifiers()) + " " + 
                           method.getReturnType().getSimpleName() + " " + 
                           method.getName() + "(");
            
            Class<?>[] paramTypes = method.getParameterTypes();
            for (int i = 0; i < paramTypes.length; i++) {
                if (i > 0) System.out.print(", ");
                System.out.print(paramTypes[i].getSimpleName());
            }
            System.out.println(")");
        }
    }
}

応用3：実行時クラスの指定された構造を呼び出す

指定されたプロパティを呼び出す

リフレクションメカニズムでは、Fieldクラスを通じてクラス内のプロパティを直接操作できます。Fieldクラスが提供するset()メソッドとget()メソッドを使用して、プロパティ内容の設定と取得を完了できます。

package com.example.reflect;

import java.lang.reflect.Field;

public class FieldAccessDemo {
    public static void accessField(Object obj, String fieldName, Object value) throws Exception {
        Class<?> clazz = obj.getClass();
        
        // フィールドオブジェクトを取得
        Field field = clazz.getDeclaredField(fieldName);
        
        // 非publicフィールドの場合はアクセス可能に設定
        if (!field.isAccessible()) {
            field.setAccessible(true);
        }
        
        // 値を設定
        field.set(obj, value);
        
        // 値を取得して表示
        Object result = field.get(obj);
        System.out.println(fieldName + " = " + result);
    }
    
    public static void main(String[] args) throws Exception {
        Sample sample = new Sample();
        
        // privateフィールドにアクセス
        accessField(sample, "privateField", "新しい値");
        
        // publicフィールドにアクセス
        accessField(sample, "publicField", 42);
    }
}

class Sample {
    private String privateField = "初期値";
    public int publicField = 0;
}

指定されたメソッドを呼び出す

package com.example.reflect;

import java.lang.reflect.Method;

public class MethodInvokeDemo {
    public static Object invokeMethod(Object obj, String methodName, Object... args) throws Exception {
        Class<?> clazz = obj.getClass();
        
        // メソッドのパラメータ型を取得
        Class<?>[] paramTypes = new Class<?>[args.length];
        for (int i = 0; i < args.length; i++) {
            paramTypes[i] = args[i].getClass();
        }
        
        // メソッドオブジェクトを取得
        Method method = clazz.getDeclaredMethod(methodName, paramTypes);
        
        // 非publicメソッドの場合はアクセス可能に設定
        if (!method.isAccessible()) {
            method.setAccessible(true);
        }
        
        // メソッドを呼び出して結果を返す
        return method.invoke(obj, args);
    }
    
    public static void main(String[] args) throws Exception {
        Sample sample = new Sample();
        
        // 引数なしのメソッドを呼び出し
        invokeMethod(sample, "publicMethod");
        
        // 引数ありのメソッドを呼び出し
        String result = (String) invokeMethod(sample, "methodWithParam", "テストパラメータ");
        System.out.println("メソッドの戻り値: " + result);
    }
}

class Sample {
    public void publicMethod() {
        System.out.println("publicMethodが呼び出されました");
    }
    
    private String methodWithParam(String param) {
        System.out.println("methodWithParamが呼び出されました: " + param);
        return "処理完了";
    }
}

応用4：アノテーション情報を読み取る

完全なアノテーションは、（1）宣言、（2）使用、（3）読み取りの3つの部分を含む必要があります。

カスタムアノテーションの宣言

package com.example.annotation;

import java.lang.annotation.*;

@Inherited
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Entity {
    String tableName();
}

@Inherited
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Column {
    String name();
    String type();
}

カスタムアノテーションの使用

package com.example.annotation;

@Entity(tableName = "users")
public class User {
    @Column(name = "id", type = "int")
    private int userId;
    
    @Column(name = "name", type = "varchar(50)")
    private String username;
    
    // ゲッターとセッター
    public int getUserId() {
        return userId;
    }
    
    public void setUserId(int userId) {
        this.userId = userId;
    }
    
    public String getUsername() {
        return username;
    }
    
    public void setUsername(String username) {
        this.username = username;
    }
}

カスタムアノテーションの読み取りと処理

package com.example.annotation;

import java.lang.reflect.Field;

public class AnnotationProcessor {
    public static void processEntity(Class<?> clazz) {
        // クラスレベルのアノテーションを取得
        Entity entityAnnotation = clazz.getAnnotation(Entity.class);
        if (entityAnnotation != null) {
            String tableName = entityAnnotation.tableName();
            System.out.println("テーブル名: " + tableName);
            
            // フィールドレベルのアノテーションを処理
            Field[] fields = clazz.getDeclaredFields();
            for (Field field : fields) {
                Column columnAnnotation = field.getAnnotation(Column.class);
                if (columnAnnotation != null) {
                    System.out.println("カラム: " + columnAnnotation.name() + 
                                      ", 型: " + columnAnnotation.type());
                }
            }
        }
    }
    
    public static void main(String[] args) {
        processEntity(User.class);
    }
}

リフレクションの動的性の体験

動的オブジェクト作成の例

package com.example.dynamic;

import java.lang.reflect.Constructor;

public class DynamicCreator {
    public static <T> T createInstance(String className) throws Exception {
        Class<?> clazz = Class.forName(className);
        Constructor<?> constructor = clazz.getDeclaredConstructor();
        constructor.setAccessible(true);
        @SuppressWarnings("unchecked")
        T instance = (T) constructor.newInstance();
        return instance;
    }
    
    public static void main(String[] args) throws Exception {
        String className = "com.example.model.Sample";
        Sample sample = createInstance(className);
        System.out.println("動的に作成されたインスタンス: " + sample);
    }
}

動的メソッド呼び出しの例

package com.example.dynamic;

import java.lang.reflect.Method;

public class DynamicInvoker {
    public static Object invokeMethod(String className, String methodName) throws Exception {
        Class<?> clazz = Class.forName(className);
        Object instance = clazz.getDeclaredConstructor().newInstance();
        
        Method method = clazz.getDeclaredMethod(methodName);
        method.setAccessible(true);
        return method.invoke(instance);
    }
    
    public static void main(String[] args) throws Exception {
        String result = (String) invokeMethod("com.example.model.Sample", "toString");
        System.out.println("メソッド呼び出し結果: " + result);
    }
}

設定ファイルに基づく動的処理の例

package com.example.dynamic;

import java.io.InputStream;
import java.util.Properties;

public class ConfigDrivenProcessor {
    public static void processFromConfig() throws Exception {
        // 設定ファイルをロード
        Properties props = new Properties();
        InputStream is = ClassLoader.getSystemClassLoader()
                                   .getResourceAsStream("config.properties");
        props.load(is);
        
        // 設定からクラス名とメソッド名を取得
        String className = props.getProperty("className");
        String methodName = props.getProperty("methodName");
        
        // クラスをロードしてインスタンスを作成
        Class<?> clazz = Class.forName(className);
        Object instance = clazz.getDeclaredConstructor().newInstance();
        
        // メソッドを取得して実行
        Method method = clazz.getMethod(methodName);
        method.invoke(instance);
    }
    
    public static void main(String[] args) throws Exception {
        processFromConfig();
    }
}

// サンプルインターフェースと実装クラス
interface Processor {
    void execute();
}

class TextProcessor implements Processor {
    public void execute() {
        System.out.println("テキスト処理を実行中");
    }
}

class DataProcessor implements Processor {
    public void execute() {
        System.out.println("データ処理を実行中");
    }
}

設定ファイル（config.properties）の例：

className=com.example.dynamic.DataProcessor
methodName=execute