动态代理模式 -必须要掌握

动态代理模式 -必须要掌握

   点关注不迷路，欢迎再访！		

精简博客内容，尽量已行业术语来分享。
努力做到对每一位认可自己的读者负责。
帮助别人的同时更是丰富自己的良机。

此文章参考于：《JavaEE互联网轻量级框架整合开发》

动态代理的意义在于生成一个占位(又称代理对象),来代理真实对象，从而控制真实对象的访问。

一.代理基本概念
先来谈谈什么是代理模式。假设场景，你是一位软件工程师。客户带着需求去找公司显然不会直接和你谈，而是去找商务谈，此时客户会认为商务就代表公司。
让我们用一张图来表示代理模式的含义，如图

代理的作用就是，在真实对象访问之前或之后加入对应的逻辑，或者根据其他规则控制是否使用真实对象。显然如图例子里商务控制了客户对软件工程师的访问。
经过上面的论述，我们知道商务和软件工程师是代理和被代理的关系，客户是通过商务去访问软件工程师的。此时客户就是程序中的调用者，商务就是代理对象，软件工程师就是真实对象。我们需要在调用者调用对象之前产生一个代理对象，而这个代理对象需要和真实对象建立代理关系，所以代理必须分为两步骤：
1.代理对象和真实对象建立代理关系。
2.实现代理对象的代理逻辑方法。

二.代理基本概念

JAVA中有多种动态代理技术，不如JDK、CGLIB、Javassist、ASM，目前Spring常用的动态代理技术为JDK和CGLIB,而Mybitas还使用了Javassist，无论哪种代理其技术，它们的理念都是相似的。

2.1JDK动态代理
JDK动态代理是java,lang.reflect.*包提供的方式，它必须借助一个接口才能产生代理对象，所以先定义接口，如代码：

public interface HelloWorld{
   public  void  sayHelloWorld();
}

public class HelloWorldImpl implements HelloWorld{

	@Override
	public void sayHelloWorld() {
		System.out.println("Hello World");
	}
}

上面提供了简单的java接口和实现关系，此时可以开始动态代理了。按照之前的分析，先要建立起代理对象和真实对象的关系，然后实现代理逻辑，所以一共分为两步。在JDK动态代理中，要实现代理逻辑类必须去实现java.lang.reflect.InvocationHandler接口，它里面定义了一个invoke方法，并提供接口数组用于下挂代理对象，如下代码：

public class HelloWorldImpl implements HelloWorld{

	@Override
	public void sayHelloWorld() {
		System.out.println("Hello World");
	}
}

动态代理绑定和代理逻辑实现

public class JdkProxyExample implements InvocationHandler{
	
	//真实对象
	private Object target = null;
	
	/**
	 * 建立代理对象和真实对象的代理关系，并返回代理对象
	 * @param target 真实对象
	 * @return 代理对象
	 */
	public Object bind(Object target) {
		this.target = target;
		return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(), this);
	}
	
	
	/**
	  * 代理方法逻辑
	  * @param proxy 代理对象
	  * @param method 当前调度方法
	  * @param args 当前方法参数
	  * @return 代理结果返回
	 */
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		System.out.println("进入代理逻辑方法");
		System.out.println("在调度真实对象之前的服务");
		Object obj = method.invoke(target, args);  //相当与调用sayHelloWorld()
		System.out.println("在调度真实对象之后的服务");
		return obj;
	}
}

第一步，建立代理对象和真实对象的关系。这里使用了bind方法去完成的，方法里面首先用类的属性target保存了真实对象。
其中newProxyInstance方法包含3个参数：
1.类加载器，采用了target本身的类加载器。
2.把生成的动态代理对象下挂在哪些接口下，以上写法就是放在target实现的接口下。
3.定义实现方法逻辑的代理类，this代表当前对象，它必须实现InvocationHandler接口的invoke。

第二步，实现代理逻辑方法。invoke可以实现代理逻辑，invoke方法的3个参数的含义如下所示：
1.proxy，代理对象，就是bind方法生成的对象。
2.method， 当前调度的方法。
3.args，调度方法的参数。
当我们使用了代理对象调度方法后，它就会进入到invoke方法里面。
Object obj = method.invoke(target, args);
这行代码相当于调度真实对象的方法，只是通过反射实现而已。

下面就让我们进入测试JDK动态代理。代码如下：

public class jdkProxyTest {
	public static void main(String[] args) {
		JdkProxyExample jdk = new JdkProxyExample();
		//绑定关系，因为挂在接口HelloWorld下，所以声明代理对象proxy
		HelloWorld proxy=(HelloWorld) jdk.bind(new HelloWorldImpl());
		//注意,此时HelloWorld对象已经是一个代理对象，它会进入代理的逻辑方法invoke里
		proxy.sayHelloWorld();
	}
}

首先通过bind方法绑定了代理关系，然后在代理对象调度sayHelloWorld方法是进入了代理的逻辑，测试结果如下：

---

进入代理逻辑方法
在调度真实对象之前的服务
Hello World
在调度真实对象之后的服务

---

此时，在调度打印Hello World之前和之后都可以加入相关的逻辑。
以上就是JDK动态代理，他是一直最为常用的动态代理，十分重要，后面会以JDK动态代理为主讨论框架的实现。代理模式掌握不易，起初可以通过打断点，一步步验证执行步骤，就一定能够掌握好它。

2.2CGLIB动态代理
JDK动态代理必须通过接口才能使用，在一些不能提供接口的环境中，只能采用其他第三方技术，比如CGLIB动态代理。他的优势在于不需要提供接口，只要一个非抽象类就能实现动态代理。

首先，我们需要在工程的POM文件中引入cglib的dependency，这里我们使用的是2.2.2版本

		<dependency>
           <groupId>cglib</groupId>
           <artifactId>cglib</artifactId>
           <version>2.2.2</version>
        </dependency>

以ReflectServiceImpl为例，不存在实现任何接口，所以不可以使用JDK动态代理，这里采用CGLIB动态代理。

public class ReflectServiceImpl {
	public void sayHello(String name) {
		System.out.println("Hello "+name);
	}
}

CGLIB动态代理

public class CglibProxyExample implements MethodInterceptor{

	/**
	   * 生成CGLIB代理对象
	 * @param cls  -Class类
	 * @return  Class类的CGLIB代理对象
	 */
	public Object getProxy(Class cls) {
		//增强类对象
		Enhancer enhancer=new Enhancer();
		//设置增强类型
		enhancer.setSuperclass(cls);
		//定义代理逻辑对象为当前对象，要求当前对象实现MethodInterceptor()
		enhancer.setCallback(this);
		//生成并返回代理对象
		return enhancer.create();
	}
	
	
	/**
	       * 代理逻辑方法
	   * @param proxy 代理对象
	   * @param method 方法
	   * @param args  方法参数
	   * @param methodProxy 方法代理
	   * @return 代理逻辑返回
	 */
	@Override
	public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
		System.out.println("在调度真实对象之前");
		//CGLIB反射调用真实对象方法
		Object result = methodProxy.invokeSuper(proxy, args);
		System.out.println("在调度真实对象之后");
		return result;
	}
}

这里用了CGLIB的加强者Enhancer，通过设置超类的方法（setSuperclass），然后通过setCallback方法设置哪个类为它的代理类。其中，参数为this就意味着是当前对象，那就要求用this这个对象实现接口MethodInterceptor的方法——intercept，
然后返回代理对象。

下面测试一下CGLIB动态代理，如代码：

public class testCGLIBProxy {	
   public static void main(String[] args) {
	   CglibProxyExample cpe = new CglibProxyExample();
	   ReflectServiceImpl obj = (ReflectServiceImpl) cpe.getProxy(ReflectServiceImpl.class);
	   obj.sayHello("andy");
   }
}

---

在调度真实对象之前
Hello andy
在调度真实对象之后

---

掌握了JDK动态代理就很容易掌握CGLIB动态代理，因为二者都是通过getProxy()生成代理对象，制定代理的逻辑。而代理逻辑类要实现一个接口的一个方法，那么这个接口定义方法就是代理逻辑方法，它可以控制真实对象的方法。