Java JDK 动态代理（AOP）使用

创建一个接口

Subject.java

/**
 * 需要动态代理的接口
 */
public interface Subject {

    public abstract String sayHello(String name);
    public abstract String sayGoodBye();
}

创建一个接口的实现类

RealSubject.java

/**
 * 需要实际代理的对象
 */
public class RealSubject implements Subject{
    @Override
    public String sayHello(String name) {
        return "hello " + name;
    }

    @Override
    public String sayGoodBye() {
        return " good bye ";
    }
}

实现InvocationHandler接口

InvocationHandlerImpl.java

/**
 * 调用处理器(InvocationHandler)的实现类
 * 每次生成动态代理类对象时都需要指定一个实现了InvocationHandler接口的对象
 */
public class InvocationHandlerImpl implements InvocationHandler {

    private Object subject;

    public InvocationHandlerImpl(Object subject) {
        this.subject = subject;
    }

    /**
     * 该方法负责集中处理动态代理类上的所有方法调用。
     * 调用处理器根据这三个参数进行预处理或分派到委托类实例上反射执行
     *
     * @param proxy  代理类实例
     * @param method 被调用的方法对象
     * @param args   方法的参数
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //在代理真实对象前我们可以添加一些自己的操作
        System.out.println("在调用之前，我要干点啥呢？");
        System.out.println("Method:" + method);

        Object returnValue = method.invoke(subject, args);

        //在代理真实对象后我们也可以添加一些自己的操作
        System.out.println("在调用之后，我要干点啥呢？");
        return returnValue;
    }
}

该类中的invoke方法在代理类对象调用接口实现类中的方法时会被调用

创建代理对象，通过代理对象调用接口实现类中的方法

public class DynamicProxyDemonstration {

    public static void main(String[] args) {
        // 代理的真实对象
        Subject realSubject = new RealSubject();
        // 调用处理器对象
        InvocationHandlerImpl handler = new InvocationHandlerImpl(realSubject);
        // 获取该类的类加载器
        ClassLoader classLoader = realSubject.getClass().getClassLoader();
        // 获取该类所实现的接口信息
        Class[] interfaces = realSubject.getClass().getInterfaces();
        System.out.println("动态代理对象的类型："+realSubject.getClass().getName());
        // 创建代理对象
        Subject subject = (Subject)Proxy.newProxyInstance(classLoader, interfaces, handler);
        // 通过代理类对象调用接口实现类中的方法，首先会调用调用处理器中的invoke方法
        String result = subject.sayHello("haha");
        System.out.println(result);
    }
}

通过Proxy.newProxyInstance()方法生成的代理类如下：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
import jiankunking.Subject;
 
// 继承了代理类Proxy，实现了自己的Subject接口
public final class ProxySubject
  extends Proxy
  implements Subject
{
  
  public ProxySubject(InvocationHandler paramInvocationHandler)
  {
    super(paramInvocationHandler);
  }
  ......
  
  // 重写了sayGoodBye方法
  public final String sayGoodBye()
  {
    try
    {
      return (String)this.h.invoke(this, m3, null);
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }
  
  // 重写了sayHello方法
  public final String sayHello(String paramString)
  {
    try
    {
      return (String)this.h.invoke(this, m4, new Object[] { paramString });
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }
  ......
}

参考博客：https://blog.csdn.net/jiankunking/article/details/52143504