设计模式3-代理模式

Proxy 那点事儿
反射实现 AOP 动态代理模式(Spring AOP 的实现 原理)

代理模式是指自己不做一些事，让他人代为处理，经常是增加或去掉一些功能。

代理模式的类最好把要代理的类传入当做成员。
Private car; 这样的聚合更好（尤其是当功能叠加的时候套用更好，代理之间互相传递）

静态代理：代理和被代理对象在代理之前是确定的。他们都实现相同的接口或者继承相同的抽象类

运行时间、日志
为了实现对多种类型的代理，动态代理
1. jdk动态代理只能代理实现了接口的类
2. cglib动态代理可以直接代理类，通过产生一个被代理类的子类来拦截父类方法的调用

具体的大家可以看我发的参考。
这里的动态代理就是使用java中反射提供的一个功能。
继承InvocationHandler 接口，则该类中的方法在执行时，会通过invoke 进入。
Loader()：要代理的函数名
interfaces:要代理的函数的参数,是接口
h(handler)：实现了InvocationHandler接口的对象，该类中要实现invoke（）方法

下面这个用了泛型，避免了强制类型转换的麻烦。

package AOP;

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

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class ProxyClass implements InvocationHandler,MethodInterceptor {
    /**
     * Proxy.newProxyInstance 调用
     * 动态生成方法被处理过后的对象 (写法固定)
     * Loader()：要代理的函数名 
     *interfaces:要代理的函数的参数,是接口 
     *h(handler) 实现了InvocationHandler接口的对象，该类中要实现invoke（）方法 
     */
    private Object proxy;
    private Object delegate;
    //@SuppressWarnings("unchecked")
    public <T> T bind(Object delegate,Object proxy){
        this.delegate = delegate;
        this.proxy = proxy;
        return (T) Proxy.newProxyInstance(delegate.getClass().getClassLoader(), delegate.getClass().getInterfaces(), this);
    }
    @Override
    //proxy这个参数是被代理的类
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // TODO Auto-generated method stub
        System.out.println(delegate == this.proxy);
        Object result = method.invoke(this.delegate, args);
        return result;
    }

    public <T> T getProxy(Class clz){
        return (T) Enhancer.create(clz, this);
    }
    @Override
    public Object intercept(Object arg0, Method arg1, Object[] arg2, MethodProxy arg3) throws Throwable {
        // TODO Auto-generated method stub
        Object result = arg3.invokeSuper(arg0, arg2);
        return result;
    }

    public static void main(String[] args) {
        ProxyClass pc = new ProxyClass();
        Original o = pc.bind(new OriginalImpl(), new AddMethodImpl());
        o.sayHello("I‘m king");
        o = new ProxyClass().getProxy(OriginalImpl.class);
        System.out.println(o.sayHello("you are wrong"));
    }
}