Java 静态代理、动态代理的使用

总结自：Java 动态代理、《Java 编程的逻辑》- 马俊昌

静态代理

创建一个接口，然后创建被代理的类实现该接口并且实现该接口中的抽象方法。之后再创建一个代理类，同时使其也实现这个接口。在代理类中持有一个被代理对象的引用，而后在代理类方法中调用该对象的方法。

接口：

public interface HelloInterface {
    void sayHello();
}

被代理类：

public class Hello implements HelloInterface{
    @Override
    public void sayHello() {
        System.out.println("Hello!");
    }
}

代理类：

public class HelloProxy implements HelloInterface{
    private HelloInterface helloInterface = null;
    public HelloInterface(HelloInterface o) {
        // 代理类 HelloProxy 接受被代理类
        helloInterface = o;
    }
    @Override
    public void sayHello() {
        System.out.println("Before invoke sayHello" );
        // 代理类在执行具体方法时通过所持有的被代理类完成调用
        helloInterface.sayHello();
        System.out.println("After invoke sayHello");
    }
}

代理类调用：

public static void main(String[] args) {
    HelloProxy helloProxy = new HelloProxy(new Hello());
    helloProxy.sayHello();
}

Before invoke sayHello
Hello!
After invoke sayHello

使用静态代理很容易就完成了对一个类的代理操作。但是静态代理的缺点也暴露了出来：由于代理只能为一个类服务，如果需要代理的类很多，那么就需要编写大量的代理类，比较繁琐。

动态代理

使用动态代理，可以编写通用的代理逻辑，用于各种类型的被代理对象，而不需要为每个被代理的类型都创建一个静态代理类。

接口、被代理类不变，我们构建一个 handler 类来实现 InvocationHandler 接口。

public class ProxyHandler implements InvocationHandler{
    private Object object;
    public ProxyHandler(Object object){
        this.object = object;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before invoke "  + method.getName());
        method.invoke(object, args);
        System.out.println("After invoke " + method.getName());
        return null;
    }
}

ProxyHandler 实现了 InvocationHandler，它的构造方法接受一个参数 object 表示被代理的对象，invoke 方法处理所有的接口调用，它有三个参数：

• proxy 表示代理对象本身，需要注意，它不是被代理的对象，这个参数一般用处不大。
• method 表示正在被调用的方法。
• args 表示方法的参数。

使用动态代理：

public static void main(String[] args) {
    HelloInterface hello = new Hello();
 
    InvocationHandler handler = new ProxyHandler(hello);
 
    HelloInterface proxyHello = (HelloInterface) Proxy.newProxyInstance(
        hello.getClass().getClassLoader(), hello.getClass().getInterfaces(), handler);
 
    proxyHello.sayHello();
}

Before invoke sayHello
Hello!
After invoke sayHello

通过 Proxy 类的静态方法 newProxyInstance 返回一个接口的代理实例。针对不同的代理类，传入相应的代理程序控制器 InvocationHandler。它有三个参数，具体如下：

• loader 表示类加载器。
• interfaces 表示代理类要实现的接口列表，是一个数组，元素的类型只能是接口，不能是普通的类。
• h 的类型为 InvocationHandler，它是一个接口，也定义在 java.lang.reflect 包中，它只定义了一个方法 invoke，对代理接口所有方法的调用都会转给该方法。

如果新来一个被代理类 Bye，如：

public interface ByeInterface {
    void sayBye();
}
public class Bye implements ByeInterface {
    @Override
    public void sayBye() {
        System.out.println("Bye!");
    }
}

那么执行过程：

public static void main(String[] args) {
    HelloInterface hello = new Hello();
    ByeInterface bye = new Bye();
 
    InvocationHandler handler = new ProxyHandler(hello);
    InvocationHandler handler1 = new ProxyHandler(bye);
 
    HelloInterface proxyHello = (HelloInterface) Proxy.newProxyInstance(
        hello.getClass().getClassLoader(), hello.getClass().getInterfaces(), handler);
 
    ByeInterface proxyBye = (ByeInterface) Proxy.newProxyInstance(
        bye.getClass().getClassLoader(), bye.getClass().getInterfaces(), handler1);
    
    proxyHello.sayHello();
    proxyBye.sayBye();
}

Before invoke sayHello
Hello!
After invoke sayHello
Before invoke sayBye
Bye!
After invoke sayBye

对于 Hello 和 Bye，能够使用同一个代理处理器 ProxyHandler 实现代理，是因为 ProxyHandler 不直接代理指定接口的实现类，也就是说 ProxyHandler 不依赖于指定接口，这意味着它对被代理类实现了哪些接口一无所知，也不能直接调用某个接口实现类中的方法实现，所以要有一个 Proxy 类，来告知 ProxyHandler 被代理类实现了哪些接口，并间接调用 ProxyHandler 中的代理方法，因为 Proxy 本身也不知道被代理类实现了哪些接口，所以需要在构造函数中传入 object.getClass().getInterfaces() 的结果。

动态代理是实现面向切面的编程 AOP（Aspect Oriented Programming）的基础。切面的例子有日志、性能监控、权限检查、数据库事务等。