代理模式

代理模式：为其他对象提供一种代理以控制对这个对象的访问。
这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能。
代理模式有三种写法：

• 静态代理
  首先，我们需要一个代理接口

public interface Something {
    public void doSthing();
}

然后代理对象的实现类。

public class SomethingImpl implements Something {

    @Override
    public void doSthing() {
        System.out.println("I wanted to do something");
    }
}

静态代理实现代码，以及客户端调用接口

public class Porxy implements Something{
    private SomethingImpl si = new SomethingImpl();
    @Override
    public void doSthing() {
        before();
        si.doSthing();
        end();
    }
    private void end() {
        System.out.println("我代理后要做什么");
    }
    private void before() {
        System.out.println("我代理前要做什么");
    }
    //client
    public static void main(String[] args) {
        Porxy p = new Porxy();
        p.doSthing();
    }

}

明显这样写一定不是最优的，不然也不会有下面的写法了。虽然这可以实现代理模式，但是代理对象需要与目标对象实现一样的接口,所以会有很多代理类,类太多.同时,一旦接口增加方法,目标对象与代理对象都要维护。

因此延伸出了动态代理来拟补这一不足。

• 动态代理

  静态代理实现代码，以及客户端调用接口

public class DynamicProxy implements InvocationHandler{
    private Object tar;
    public  DynamicProxy(Object tar) {
        this.tar = tar;
    }
    @SuppressWarnings("unchecked")
    public <T> T getProxy() {
        return (T) Proxy.newProxyInstance(
            tar.getClass().getClassLoader(),
            tar.getClass().getInterfaces(),
            this
        );
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        Object re = method.invoke(tar, args);
        end();
        return re;
    }
    private void end() {
        System.out.println("我代理后要做什么");
    }
    private void before() {
        System.out.println("我代理前要做什么");
    }
    //client
    public static void main(String[] args) {
        DynamicProxy dp = new DynamicProxy( new SomethingImpl());
        Something st = dp.getProxy();
        st.doSthing();
    }
}

这种写法一般情况已经完美了，但是不足的是不能够代理一个没有任何接口的类，这是 JDK 给我们提供的动态代理。

• CGLib代理

public class CGLibProxy implements MethodInterceptor{
    private static CGLibProxy instance = new CGLibProxy();
    public static CGLibProxy getInstance() {
        return instance;
    }
    @SuppressWarnings("unchecked")
    public <T> T getProxy(Class<T> cls) {
        return (T) Enhancer.create(cls, this);
    }

    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy)
            throws Throwable {
        before();
        Object result = proxy.invokeSuper(obj, args);
        end();
        return result;
    }
    private void end() {
        System.out.println("我代理后要做什么");
    }
    private void before() {
        System.out.println("我代理前要做什么");
    }

    public static void main(String[] args) {
        Something st = CGLibProxy.getInstance().getProxy(SomethingImpl.class);
        st.doSthing();
    }
}

值得注意的是：CGLib 给我们提供的是方法级别的代理，也可以理解为对方法的拦截。

在Spring的AOP编程中:
如果加入容器的目标对象有实现接口,用JDK代理
如果目标对象没有实现接口,用Cglib代理