Java动态代理

Java动态代理中所谓的“动态”，是针对使用Java代码实际编写了代理类的“静态”代理而言的，它的优势不在于省去了编写代理类那一点工作量，而是实现了可以在原始类和接口还未知的时候，就确定代理类的代理行为，当代理类与原始类脱离直接联系后，就可以很灵活地重用于不同的应用场景之中。

例子：

定义一个接口Person：

public interface Person {
    void sayHi();

    void sayYes();
}

定义一个Person的实现类Man：

public class Man implements Person {

    @Override
    public void sayHi() {
        System.out.println("Hi Man!");
    }

    @Override
    public void sayYes() {
        System.out.println("Yes Man!");
    }

}

定义代理处理器类MyHandler，实现InvocationHandler接口：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class MyHandler implements InvocationHandler {

    private Object originObj;

    public MyHandler(Object originObj) {
        this.originObj = originObj;
    }

    public Object getProxy() {
        return Proxy.newProxyInstance(originObj.getClass().getClassLoader(), originObj.getClass().getInterfaces(), this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("before!");
        Object obj = method.invoke(originObj, args);
        System.out.println("after!");
        return obj;
    }

    public static void main(String[] args) {
        Man man = new Man();
        MyHandler myHandler = new MyHandler(man);
        Person p = (Person) myHandler.getProxy();
        p.sayHi();
        p.sayYes();
    }
}

控制台输出：

before!
Hi Man!
after!
before!
Yes Man!
after!