代理模式

静态代理

public interface Subject{
    void doSomething();
}

public class RealSubject implements Subject{
    @Override
    public void doSomething() {
        System.out.println( "call doSomething()" );
    }
}

public class AnotherRealSubject implements Subject{
    @Override
    public void doSomething() {
        System.out.println("call another doSomething().");
    }
}

public class TestProxy {
    public static void main(String[] args) {
        // static proxy
        new SubjectProxy().doSomething();
    }
}
// output:
// call doSomething()

动态代理

// 动态代理的核心，将代理类抽象出来，作为独立逻辑
public class ProxyHandler implements InvocationHandler{

    private Object target;

    /**
     *  绑定委托对象，并返回代理类
     */
    public Object bind(Object target){
        this.target = target;
        //绑定该类实现的所有接口，取得代理类
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = null;
        //这里就可以进行所谓的AOP编程了
        //在调用具体函数方法前，执行功能处理
        result= method.invoke(target, args);
        //在调用具体函数方法后，执行功能处理

        return result;
    }
}

public class TestProxy {
    public static void main(String[] args) {
        // dynamical proxy
        ProxyHandler proxyHandler = new ProxyHandler();
        // Object 1
        Subject subject = (Subject) proxyHandler.bind(new RealSubject());
        subject.doSomething();
        // Object 2
        Subject mocked = (Subject) proxyHandler.bind(new AnotherRealSubject());
        mocked.doSomething();
    }
}

// output:
// call doSomething()
// call doSomething()
// call another doSomething().

由上图代码可看到，proxy逻辑被抽象到ProxyHandler中，与业务完全解耦，业务中只需要动态绑定委托对象，即可对委托对象的中的方法增强处理。