Class オブジェクトを取得する4つの方法#

これらの情報を動的に取得するには Class オブジェクトに依存します。Classオブジェクトはクラスのメソッドや変数などの情報を実行時のプログラムに伝えます。Java には Class オブジェクトを取得する4つの方法が用意されています：

1. 具体的なクラスが分かっている場合に使用：

   1
   Class alunbarClass = TargetObject.class;

   ただし私たちは通常、具体的なクラスが分からないので、パッケージ内のクラスを走査してClassオブジェクトを取得します。この方法で取得したClassオブジェクトは初期化を行いません。

2. Class.forName() を用いて、クラスの全パスを渡して取得：

1
Class alunbarClass1 = Class.forName("cn.javaguide.TargetObject");

1. オブジェクトのインスタンスから取得：instance.getClass()

1
TargetObject o = new TargetObject();
2
Class alunbarClass2 = o.getClass();

1. クラスローダーを介して xxxClassLoader.loadClass() を用いてクラスパスを渡して取得：

1
ClassLoader.getSystemClassLoader().loadClass("cn.javaguide.TargetObject");

クラスローダーを介して Class オブジェクトを取得しても初期化は行われません。つまり初期化を含む一連の手順は実行されず、静的コードブロックや静的オブジェクトは実行されません。

リフレクションの基本操作#

1. リフレクションで操作する対象のクラス TargetObject を作成します。

1
package cn.javaguide;
2

3
public class TargetObject {
4
    private String value;
5

6
    public TargetObject() {
7
        value = "JavaGuide";
8
    }
9

10
    public void publicMethod(String s) {
11
        System.out.println("I love " + s);
12
    }
13

14
    private void privateMethod() {
15
        System.out.println("value is " + value);
16
    }
17
}

2. このクラスのメソッドとパラメータをリフレクションで操作する

1
package cn.javaguide;
2

3
import java.lang.reflect.Field;
4
import java.lang.reflect.InvocationTargetException;
5
import java.lang.reflect.Method;
6

7
public class Main {
8
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException, NoSuchFieldException {
9
        /**
10
         * 获取 TargetObject 类的 Class 对象并且创建 TargetObject 类实例
11
         */
12
        Class<?> targetClass = Class.forName("cn.javaguide.TargetObject");
13
        TargetObject targetObject = (TargetObject) targetClass.newInstance();
14
        /**
15
         * 获取 TargetObject 类中定义的所有方法
16
         */
17
        Method[] methods = targetClass.getDeclaredMethods();
18
        for (Method method : methods) {
19
            System.out.println(method.getName());
20
        }
21

22
        /**
23
         * 获取指定方法并调用
24
         */
25
        Method publicMethod = targetClass.getDeclaredMethod("publicMethod",
26
                String.class);
27

28
        publicMethod.invoke(targetObject, "JavaGuide");
29

30
        /**
31
         * 获取指定参数并对参数进行修改
32
         */
33
        Field field = targetClass.getDeclaredField("value");
34
        //为了对类中的参数进行修改我们取消安全检查
35
        field.setAccessible(true);
36
        field.set(targetObject, "JavaGuide");
37

38
        /**
39
         * 调用 private 方法
40
         */
41
        Method privateMethod = targetClass.getDeclaredMethod("privateMethod");
42
        //为了调用private方法我们取消安全检查
43
        privateMethod.setAccessible(true);
44
        privateMethod.invoke(targetObject);
45
    }
46
}

JDK 動的プロキシ機構#

Java の動的プロキシ機構では InvocationHandler インターフェースと Proxy クラスがコアです。

Proxy クラスで最も頻繁に使われるメソッドは：newProxyInstance() で、このメソッドは主に代理オブジェクトを生成します。

1
public static Object newProxyInstance(ClassLoader loader,
2
                                          Class<?>[] interfaces,
3
                                          InvocationHandler h)
4
        throws IllegalArgumentException
5
    {
6
        ......
7
    }

このメソッドは3つのパラメータがあります：

1. loader <クラスローダー>。代理オブジェクトをロードします。
2. interfaces : 代理されるクラスが実装するいくつかのインターフェース；
3. h : InvocationHandler インターフェースを実装したオブジェクト；

動的プロキシを実現するには、InvocationHandler を実装して独自の処理ロジックを定義する必要があります。動的プロキシのオブジェクトがメソッドを呼び出すと、その呼び出しは実装された InvocationHandler の invoke メソッドへ転送されて呼び出されます。

1
public interface InvocationHandler {
2

3
    /**
4
     * 当你使用代理对象调用方法的时候实际会调用到这个方法
5
     */
6
    public Object invoke(Object proxy, Method method, Object[] args)
7
        throws Throwable;
8
}

invoke() メソッドには以下の3つのパラメータがあります：

1. proxy <動的に生成されたプロキシクラス>
2. method : プロキシクラスのオブジェクトが呼び出すメソッドに対応
3. args : 現在の method のパラメータ

つまり：あなたが Proxy クラスの newProxyInstance() で作成した代理オブジェクトがメソッドを呼び出すとき、実際には InvocationHandler を実装したクラスの invoke() メソッドが呼び出されます。invoke() メソッド内で処理をカスタマイズできます。例えばメソッドの実行前後に何をするか。

• JDK 動的プロキシクラスの使用手順

  1. インターフェースとその実装クラスを定義する；
  2. カスタム InvocationHandler を定義し、invoke メソッドをオーバーライドします。invoke メソッド内で元のメソッド（被代理クラスのメソッド）を呼び出して、独自の処理を追加します；
  3. Proxy.newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h) メソッドで代理オブジェクトを作成します；

• コード例

  1. SMS送信のインターフェースを定義

     1
     public interface SmsService {
     2
         String send(String message);
     3
     }

  2. SMS送信のインターフェースを実装

     1
     public class SmsServiceImpl implements SmsService {
     2
         public String send(String message) {
     3
             System.out.println("send message:" + message);
     4
             return message;
     5
         }
     6
     }

  3. JDK 動的プロキシクラスを定義

     1
     import java.lang.reflect.InvocationHandler;
     2
     import java.lang.reflect.InvocationTargetException;
     3
     import java.lang.reflect.Method;
     4
     
     5
     /**
     6
      * @author shuang.kou
     7
      * @createTime 2020年05月11日 11:23:00
     8
      */
     9
     public class DebugInvocationHandler implements InvocationHandler {
     10
         /**
     11
          * 代理类中的真实对象
     12
          */
     13
         private final Object target;
     14
     
     15
         public DebugInvocationHandler(Object target) {
     16
             this.target = target;
     17
         }
     18
     
     19
         @Override
     20
         public Object invoke(Object proxy, Method method, Object[] args) throws InvocationTargetException, IllegalAccessException {
     21
             //调用方法之前，我们可以添加自己的操作
     22
             System.out.println("before method " + method.getName());
     23
             Object result = method.invoke(target, args);
     24
             //调用方法之后，我们同样可以添加自己的操作
     25
             System.out.println("after method " + method.getName());
     26
             return result;
     27
         }
     28
     }

     invoke() メソッド: 動的プロキシオブジェクトが元のメソッドを呼び出すと、最終的に invoke() メソッドが呼び出され、invoke() が代理対象の元のメソッドを呼び出します。

  4. 代理オブジェクトのファクトリークラスを取得

     1
     public class JdkProxyFactory {
     2
         public static Object getProxy(Object target) {
     3
             return Proxy.newProxyInstance(
     4
                     target.getClass().getClassLoader(), // 目標クラスのクラスローダー
     5
                     target.getClass().getInterfaces(),  // 代理が実装するインターフェース、複数指定可能
     6
                     new DebugInvocationHandler(target)   // 代理オブジェクトに対応するカスタム InvocationHandler
     7
             );
     8
         }
     9
     }

     getProxy()：主に Proxy.newProxyInstance（） メソッドによって特定のクラスの代理オブジェクトを取得します。

  5. 実際の使用

     1
     SmsService smsService = (SmsService) JdkProxyFactory.getProxy(new SmsServiceImpl());
     2
     smsService.send("java");

  実行すると、コンソールには次のように表示されます：

  1
  before method send
  2
  send message:java
  3
  after method send

CGLIB 動的プロキシ機構#

JDK 動的プロキシには最も致命的な問題があり、それはインターフェースを実装したクラスのみを代理できることです。

この問題を解決するために、CGLIB動的プロキシ機構を用いて回避することができます。

CGLIB(Code Generation Library)は、ASM に基づくバイトコード生成ライブラリで、実行時にバイトコードを変更したり動的生成したりすることを可能にします。CGLIB は継承によって代理を実現します。多くの有名なオープンソースフレームワークが CGLIB を使用しています。例えば Spring の AOP モジュールでは、ターゲットオブジェクトがインターフェースを実装している場合はデフォルトで JDK 動的プロキシを使用し、そうでなければ CGLIB 動的プロキシを使用します。

在 CGLIB 动态代理机制中 MethodInterceptor 接口和 Enhancer 类は核心です。

自分で MethodInterceptor を定義し、intercept メソッドをオーバーライドします。intercept は、代理されたクラスのメソッドを拡張する際の処理を挟むために使われます。

1
public interface MethodInterceptor
2
extends Callback{
3
    // 拦截被代理类中的方法
4
    public Object intercept(Object obj, java.lang.reflect.Method method, Object[] args,MethodProxy proxy) throws Throwable;
5
}

1. obj : 被代理のオブジェクト（拡張が必要なオブジェクト）
2. method : 拦截するメソッド（拡張が必要なメソッド）
3. args : メソッドの引数
4. proxy : 元のメソッドを呼び出すため

Enhancer クラスを通じて動的に被代理クラスを取得します。代理クラスのメソッド呼び出し時には、実際には MethodInterceptor の intercept メソッドが呼び出されます。

• CGLIB 動的プロキシクラスの使用手順

  1. クラスを定義する；
  2. 自作の MethodInterceptor を定義し、intercept メソッドを上書きします。intercept は拡張される被代理クラスのメソッドを拡張するのに使用され、JDK 動的プロキシの invoke メソッドと同様です；
  3. Enhancer クラスの create() でプロキシクラスを作成します；

• コード例

  静的な JDK 動的プロキシとは異なり、追加の依存関係は不要です。CGLIB(Code Generation Library) は実際にはオープンソースプロジェクトで、もし使用する場合は関連依存関係を手動で追加する必要があります。

  1
  <dependency>
  2
    <groupId>cglib</groupId>
  3
    <artifactId>cglib</artifactId>
  4
    <version>3.3.0</version>
  5
  </dependency>

  1. AliSmsService のクラスを実装

     1
     package github.javaguide.dynamicProxy.cglibDynamicProxy;
     2
     
     3
     public class AliSmsService {
     4
         public String send(String message) {
     5
             System.out.println("send message:" + message);
     6
             return message;
     7
         }
     8
     }

  2. 自作の MethodInterceptor （メソッドインターセプター）

     1
     import net.sf.cglib.proxy.MethodInterceptor;
     2
     import net.sf.cglib.proxy.MethodProxy;
     3
     
     4
     import java.lang.reflect.Method;
     5
     
     6
     /**
     7
      * 自定义MethodInterceptor
     8
      */
     9
     public class DebugMethodInterceptor implements MethodInterceptor {
     10
     
     11
         /**
     12
          * @param o           被代理的对象（需要增强的对象）
     13
          * @param method      被拦截的方法（需要增强的方法）
     14
          * @param args        方法入参
     15
          * @param methodProxy 用于调用原始方法
     16
          */
     17
         @Override
     18
         public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
     19
             //调用方法之前，我们可以添加自己的操作
     20
             System.out.println("before method " + method.getName());
     21
             Object object = methodProxy.invokeSuper(o, args);
     22
             //调用方法之后，我们同样可以添加自己的操作
     23
             System.out.println("after method " + method.getName());
     24
             return object;
     25
         }
     26
     
     27
     }

  3. 代理クラスを取得

     1
     import net.sf.cglib.proxy.Enhancer;
     2
     
     3
     public class CglibProxyFactory {
     4
     
     5
         public static Object getProxy(Class<?> clazz) {
     6
             // 创建动态代理增强类
     7
             Enhancer enhancer = new Enhancer();
     8
             // 设置类加载器
     9
             enhancer.setClassLoader(clazz.getClassLoader());
     10
             // 设置被代理类
     11
             enhancer.setSuperclass(clazz);
     12
             // 设置方法拦截器
     13
             enhancer.setCallback(new DebugMethodInterceptor());
     14
             // 创建代理クラス
     15
             return enhancer.create();
     16
         }
     17
     }

  4. 実際の使用

     1
     AliSmsService aliSmsService = (AliSmsService) CglibProxyFactory.getProxy(AliSmsService.class);
     2
     aliSmsService.send("java");

  実行すると、コンソールには次のように表示されます：

  1
  before method send
  2
  send message:java
  3
  after method send

JDK 動的プロキシと CGLIB 動的プロキシの比較#

1. JDK 動的プロキシは、インターフェースを実装したクラスを代理するか、直接インターフェースを代理することしかできません。 一方、CGLIB はインターフェースを実装していないクラスも代理できます。 また、CGLIB 動的プロキシは代理クラスのサブクラスを生成して被代理クラスのメソッド呼び出しをインターセプトするため、final として宣言されたクラスやメソッドを代理することはできません。
2. それぞれの効率性については、多くの状況で JDK 動的プロキシのほうが優れており、JDK のバージョンが上がるにつれてこの利点はより顕著になります。