JDK动态代理&CGLIB动态代理

动态代理

动态代理的意义在于生成一个代理对象来代理真实对象，从而控制真实对象的访问。

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

        显然客户是通过商务去访问软件工程师的，那么商务(代理对象)的意义在于什么呢？ 商务可以谈判，比如项目启动前的商务谈判，软件的价格、交付、进度的时间节点等，或者项目完成后的商务追讨应收账款等。商务也可能在软件开发之间谈判失败，此时商务就会根据公司规则去结束和客户的合作关系，这些都不用软件工程师来处理。因此，代理的作用就是，在真实对象访问之前或者之后加入对应的逻辑，或者根据其他规则控制是否使用真实对象，显然在这个例子里商务控制了客户对软件工程师的访问。
        经过上面的论述，我们知道商务和软件工程师是代理和被代理的关系，客户是经过商务去访问软件工程师的。此时客户就是程序中的调用者，商务就是代理对象，软件工程师就是真实对象。我们需要在调用者调用对象之前产生一个代理对象，而这个代理对象需要和真实对象建立代理关系，所以代理分为以下两个步骤：
1.代理对象和真实对象建立代理关系。
2.实现代理对象的代理逻辑方法。

在Java中有多种动态代理技术，比如JDK、CGLIB、Javassist、ASM，其中最常用的动态代理技术有两种：一种是JDK动态代理，这是JDK自带的功能；另一种是CGLIB，这是第三方提供的一个技术。目前Spring常用JDK和CGLIB，而MyBatis还使用了Javassist。

JDK动态代理

JDK动态代理是java.lang.reflect.*包提供的方式，它必须借助一个接口才能产生代理对象，所以定义如下接口及其实现类：
接口：

public interface HelloWorld {

	public void sayHelloWorld1();

	public String sayHelloWorld2();
}

实现类：

public class HelloWorldImpl implements HelloWorld{
	@Override
	public void sayHelloWorld1() {
		System.out.println("Hello");
		
	}
	@Override
	public String sayHelloWorld2() {
		System.out.println("World");
		return "OK";
	}
}

接下来开始动态代理了，按照之前的分析，代理分为两个步骤：
1.代理对象和真实对象建立代理关系。这里用bind方法完成。
2.实现代理对象的代理逻辑方法。
在JDK动态代理中，要实现代理逻辑类必须去实现java.lang.reflect.InvocationHandler接口，它里面定义了一个invoke方法，并提供接口数组用于下挂代理对象。

//实现方法逻辑的代理类
public class JdkProxyExample implements InvocationHandler{
	//真实对象
	private Object target = null;
	
	/**
	 * 建立代理对象和真实对象的代理关系，并返回代理对象
	 * @param 真实对象
	 * @return 代理对象
	 */
	public Object bind(Object target) {
		this.target = target;
		return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
	}
	
	
	/**
	 * public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)
			参数：
            loader-定义代理类的类加载器
			interfaces-代理类要实现的接口列表，即把生成的代理对象挂在哪些接口下
			h-定义实现方法逻辑的代理类，这个类必须实现InvocationHandler接口的
			   invoke方法，它就是代理逻辑的现实方法。              
	 */
	
	/**
	 * 代理方法逻辑
	 * @param proxy 代理对象
	 * @param method 当前调度方法
	 * @param args 当前方法参数
	 * @return 代理结果返回 
	 * @throws Throwable 异常
	 */
	@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;	//方法调用的返回值
	}
}

接下来进行测试：

	public static void main(String[] args) {
		//创建实现方法逻辑的代理对象:jdk
		JdkProxyExample jdk = new JdkProxyExample();	
		//传入真实对象，建立代理对象和真实对象的代理关系，返回代理对象:proxy
		HelloWorld proxy = (HelloWorld)jdk.bind(new HelloWorldImpl());
		//proxy是一个代理对象，在调用方法时会进入代理的逻辑方法invoke里，并执行其中的代理逻辑代码
		proxy.sayHelloWorld1();  //方法一，没有返回值
		System.out.println("--------------------------");
		
		String s = (String)proxy.sayHelloWorld2();	//方法二，有返回值，并知道是String类型，所以强制类型转换为String类型
		System.out.println(s);
	}

结果：

为了明白其中的代理过程，打断点进行流程分析：

对其上边的逻辑代理类，还可以用匿名内部内代替，简化----结果都是一样的：

public static void main(String[] args) {
		HelloWorldImpl target = new HelloWorldImpl();	//真实对象
		HelloWorld proxy = (HelloWorld)Proxy.newProxyInstance(target.getClass().getClassLoader(),
							target.getClass().getInterfaces(),new InvocationHandler() {	
			@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;	//方法调用的返回值
			}
		});
		
		proxy.sayHelloWorld1();  //方法一，没有返回值
		System.out.println("--------------------------------");
		
		String s = (String)proxy.sayHelloWorld2();	//方法二，有返回值，并知道是String类型，所以强制类型转换为String类型
		System.out.println(s);	
	}

CGLIB动态代理

在看过JDK动态代理后，再看CGLIB动态代理就比较容易了，CGLIB动态代理的优势，不需要提供接口，只需提供一个非抽象类就可以。
代理步骤和JDK动态代理也一样分两步：
1.代理对象和真实对象建立代理关系。这里用getProxy()方法完成。
2.实现代理对象的代理逻辑方法。

提供一个非抽象类：

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

接着实现代理逻辑类，实现MethodInterceptor接口：

public class CglibPeoxyExample implements MethodInterceptor{

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

测试：

public static void main(String[] args) {
		CglibPeoxyExample cglib = new CglibPeoxyExample();
		//获取代理对象
		SayHelloWorldImpl proxy = (SayHelloWorldImpl)cglib.getProxy(SayHelloWorldImpl.class);
		proxy.sayHelloWorld("Wolrd");
		
	}

结果：

用到的jar：

参考自《JavaEE互联网轻量级框架整合开发》