设计模式（4）代理模式

谈及设计模式里面的代理模式，不得不说，这个模式在网上有很多的应用场景。例如说，Spring里面的代理机制，dubbo的动态代理模式生成proxy过程等等。
代理模式的概念：
代理模式是指使用代理对象来执行某一个对象所要执行的相应方法。

我们常说的代理模式主要划分为了两种类型：
静态代理
所谓的静态代理我的认识就是一种灵活性较差的代理设计。其基本的设计结构图如下所示：

每次做代理的时候，都需要实现原来的接口方法，然后在构造函数中将相应的代理对象给注入进去。这样子做起来显得有点繁琐。如果说我们不去实现它相应的接口的话，那么这样所带来的效果就不是叫做代理了。（因为只能实现接口中的部分功能，并不够完善）。
例如说以下案例代码：

/**
 * 作者：idea
 * 日期：2018/5/30
 * 描述：
 */
public interface Subject {
    public void request();
}

/**
 * 作者：idea
 * 日期：2018/5/30
 * 描述：代理对象
 */
public class ProxySubject implements Subject{

    public Subject subject;

    public ProxySubject(){
        this.subject=new RealSubject();
    }

    public void before(){
        System.out.println("this is before");
    }


    public void after(){
        System.out.println("this is after");
    }

    @Override
    public void request() {
        this.before();
        this.subject.request();
        this.after();
    }
}

/**
 * 作者：idea
 * 日期：2018/5/30
 * 描述：
 */
public class RealSubject implements Subject{


    @Override
    public void request() {
        System.out.println("请求-------");
    }

}

/**
 * 作者：idea
 * 日期：2018/5/30
 * 描述：
 */
public class Test {
    public static void main(String[] args) {
        Subject subject=new ProxySubject();
        subject.request(); //使用了代理对象之后，相应的请求会被横向拦截
    }
}

动态代理
关于动态代理部分而言，我们常说的几种类型分别就是cglib代理，还有jdk代理了。
举个简单的jdk代理模式代码案例：

/**
 * @author idea
 * @data 2018/11/11
 */
public interface Decode {

    String decode(String content);

}

/**
 * @author idea
 * @data 2018/11/11
 */
public class DecodeImpl implements Decode{


    @Override
    public String decode(String content){
        return content+"decode";
    }

}

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

/**
 * 代理工厂
 *
 * @author idea
 * @data 2018/11/11
 */
public class InvocationFactory implements InvocationHandler {


    private Object target;

    public InvocationFactory(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("代理执行");
        Object value = method.invoke(target, args);
        return value;
    }

    public static void main(String[] args) {
        InvocationHandler invocationHandler = new InvocationFactory(new DecodeImpl());
        Decode decode = (Decode) Proxy.newProxyInstance(DecodeImpl.class.getClassLoader(), DecodeImpl.class.getInterfaces(), invocationHandler);
        System.out.println(decode.decode("asd"));
    }
}

通过上述的一个简单案例可以先大致的了解什么是jdk代理，以及jdk代理的基本实现步骤。使用jdk来进行代理的时候，要求被代理对象有相应的接口和接口实现类。在代理Proxy创建的时候需要获取到相应目标对象的类加载器，以及接口，还有InvocationHandler的实例。在InvocationHandler里面，对于invoke部分可以引用相应的对象句柄，然后进行方法的扩展实现，从而实现代理的效果。

cglib的代理机制代码案例：

/**
 * @author idea
 * @data 2018/11/11
 */
public class Car {

    public void test(){
        System.out.println("this is test");
    }
}

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

import java.lang.reflect.Method;

/**
 * @author idea
 * @data 2018/11/11
 */
public class CarCglib implements MethodInterceptor {

    private Object target;

    public Object getTarget(Object target) {
        this.target = target;
        Enhancer enhancer = new Enhancer();
        //设置它的代理对象
        enhancer.setSuperclass(this.target.getClass());
        //回调对象
        enhancer.setCallback(this);
        return enhancer.create();
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("cglib执行代理");
        Object value = methodProxy.invokeSuper(o, objects);
        return value;
    }

    public static void main(String[] args) {
        Car car=new Car();
        CarCglib carCglib=new CarCglib();
        Car car2= (Car) carCglib.getTarget(car);
        car2.test();
    }
}

对于cglib而言，在执行代理的时候，可以动态地调整相应的返回值：

 public Object getTarget2(Object target) {
        this.target = target;
        Enhancer enhancer = new Enhancer();
        //设置它的代理对象
        enhancer.setSuperclass(this.target.getClass());
        //回调对象
        enhancer.setCallback(new FixedValue() {
            @Override
            public Object loadObject() throws Exception {
                return "使用fixedvalue可以替换掉方法的返回值";
            }
        });
        return enhancer.create();
    }


    public Object getTarget3(Object target) {
        this.target = target;
        Enhancer enhancer = new Enhancer();
        //设置它的代理对象
        enhancer.setSuperclass(this.target.getClass());
        //回调对象
        enhancer.setCallback(new InvocationHandler() {
            @Override
            public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
                if (method.getDeclaringClass() != Object.class && method.getReturnType() == String.class) {
                    return "Hello cglib!";
                } else {
                    return method.invoke(o, objects);
                }
            }
        });
        return enhancer.create();
    }

    public Object getTarget4(Object target) {
        this.target = target;
        Enhancer enhancer = new Enhancer();
        //设置它的代理对象
        enhancer.setSuperclass(this.target.getClass());
        //回调对象
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                if(method.getDeclaringClass() != Object.class && method.getReturnType() == String.class) {
                    return "Hello cglib!";
                } else {
                    return methodProxy.invokeSuper(o, objects);
                }
            }
        });
        return enhancer.create();
    }

这里面尽量少用InvocationHandler来充当回调对象，这样容易产生死循环现象的发生。

来看看下边的一个比较图：

cglib动态代理	jdk动态代理
cglib主要是通过和目标对象使用相同的一个父类，然后来实现相应的代理机制。这种机制并不要求目标对象要实现接口	Jdk的动态代理，是使用反射技术获得类的加载器并且创建实例，根据类执行的方法在执行方法的前后发送通知。

代理模式的应用场景也是蛮多的，例如说Spring里面的AOP,Dubbo里面的RPC调用，都有使用到代理模式的这种思想，因此感觉这块的知识的也是蛮重要的。