谈及设计模式里面的代理模式，不得不说，这个模式在网上有很多的应用场景。例如说，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调用，都有使用到代理模式的这种思想，因此感觉这块的知识的也是蛮重要的。
