静态/动态代理模式

代理， 顾名思义就是让别人替你完成或处理事情。

在Java设计模式中，代理模式又可分为静态代理和动态代理模式。静态代理模式是通过构建各种xxxProxy来实现代理模式，这样会导致项目中到处都是xxxProxy类；而动态模式相对较为灵活，通过反射机制进行灵活的构建代理类。

1）静态代理模式

先创建一个接口：

    public interface Hello{
        void say(String name);
    }

为接口创建一个实现类：

public class void HelloImpl implements Hello {
    public void say(String name) {
        System.out.println("Hello!" + name);
    }
}

为了实现在输出hello！+ name 前后输出提示信息，我们创建一个代理类：

public class HelloProxy implements Hello {
    private Hello hello;
    public HelloProxy() {
    hello = new HelloImpl();
}

public void say(String name) {
    before();
    hello.say(name);
    after();
}

private void before() {
    System.out.println("Before");
}
private void after() {
    System.out.println("After");
}
}

最后通过main函数来进行调用：

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

2）动态代理模式

动态代理模式则是通过Object类型的target变量，作为被代理的目标对象，将其通过注入的方式（构造函数注入）进行初始化。

构造如下动态代理类：

public class DynamicProxy implements InvocationHandler{

    private Object target;

    public DynamicProxy(Object target) {
        this.target = target;
    }
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        Object result = method.invoke(target, args);
        after();
        return result;
    }

    public <T> T getProxy() {
        return (T) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }

    private void before() {
        System.out.println("Before");
    }

    private void after() {
        System.out.println("After");
    }
  }

在main方法中调用

public static void main(String[] args) {

        Hello hello = new HelloImpl();

        DynamicProxy dynamicProxy = new DynamicProxy(hello);

        Hello helloProxy = (Hello) dynamicProxy.getProxy();
        helloProxy.say("Mike");
    }

source code: https://github.com/Vekaco/proxy-static-dynamic