Spring框架汇总（理论篇——代理模式）

    在开发过程中，我们常需要在不更改原代码的前提下实现业务的扩展（也就是我们常说的OCP原则），为此，就需要用到代理模式来进行开发。

    常用的代理模式有两种，静态代理和动态代理，而常用的动态代理技术又包括JDK动态代理和CGLIB动态代理。

一、静态代理

    我们先来编写一个业务接口：

package proxy.part01;
/**
 * 核心业务接口
 * @author Elio
 */
public interface HelloService {
	 void sayHello(String msg);
}

    编写实现类：

package proxy.part01;
/**
 * 核心业务的实现类
 * @author Elio
 */
public class HelloServiceImpl implements HelloService{
	//核心业务
	public void sayHello(String msg) {
		System.out.println("hello "+msg);
	};
}

    现在，我们要在不修改HelloServiceImpl的前提下添加新的业务，例如，要在核心业务的前后输出当前时间。很容易想到，我们可以再写一个新的实现类，这个新实现类也实现HelloService接口，并且实现sayHello方法，在新的实现方法中添加新的业务，并且调用HelloServiceImpl类的sayHello方法，这个新的实现类就是我们说的“代理类（代理对象）”。

package proxy.part01;
/**
 * 代理对象
 * @author Elio
 */
public class HelloServiceProxy implements HelloService{
	//创建依赖关系
	private HelloService helloService;
	public HelloServiceProxy(HelloService helloService) {
		this.helloService=helloService;
	}
	//重新实现业务方法
	public void sayHello(String msg) {
		//添加扩展业务
		System.out.println("method.start:"+System.nanoTime());
		//核心业务
		helloService.sayHello(msg);
		//添加拓展业务
	    System.out.println("method.down:"+System.nanoTime());	
	}
}

    测试代理类：

package proxy.part01;
/**
 * 测试代理
 * @author Elio
 */
public class TestProxy01 {
	public static void main(String[] args) {
		//目标对象
		HelloService helloService;
		//目标对象（被代理类）
		helloService=new HelloServiceImpl();
		//代理对象(扩展的类)
		helloService=new HelloServiceProxy(helloService);
		//调用业务方法
		helloService.sayHello("我是核心业务");
	}
}

    输出结果：

    method.start:1838981357912485
    hello 我是核心业务
    method.down:1838981358133359

    输出结果显示我们在不修改原实现类的情况下，成功为核心业务添加了扩展业务。但是，如果我们要为很多个类或者方法添加扩展业务，例如输出日志、权限检查等，我们就要为所有类都创建一个代理对象，这无疑会造成大量重复的代码片段，并且维护难度也很大。所以我们希望能够实现动态地为不同的类创建代理对象，这是便要用到动态代理技术。

二、动态代理

    动态代理技术有两种常用的实现方式：基于反射机制实现的JDK动态代理和直接生成字节码文件的CGLIB动态代理。

    1.JDK动态代理

    先写一个核心业务接口：

package proxy.part02;
/**
 * 核心业务接口
 * @author Elio
 */
public interface OrgSerivce {
	//保存一个组织
	void saveOrg(String org);
	//根据ID更新一个组织
	int updateOrg(Integer id);
}

    实现核心业务接口：

package proxy.part02;
/**
 * 实现核心业务接口
 * @author Elio
 */
public class OrgServiceImpl implements OrgSerivce {
	@Override
	public void saveOrg(String org){
		System.out.println("save org "+org);
	}
	@Override
	public int updateOrg(Integer id) {
		System.out.println("update org which`s id is "+id);
		return 1;
	}
}

    我们还需要再编写一个用于处理扩展业务的类：

package proxy.part02;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
/**
 * 扩展业务的处理对象，要实现Java反射包中的InvocationHandler接口
 * @author Elio
 */
class ServiceHandler implements InvocationHandler{
	//定义目标对象的引用，并建立联系
	private Object target;
	public ServiceHandler(Object target) {
		this.target=target;
	}
	/**执行代理对象的业务方法时,会自动执行这个handler对象的invoke方法
	 * @param proxy 指向代理对象
	 * @param method 指向接口中的方法对象
	 * @param args 指向method对象执行时需要的实际参数
	 * */
	@Override
	public Object invoke(Object proxy,Method method,Object[] args) throws Throwable {
		System.out.println("begin transaction");
		//执行目标对象的method(核心业务)方法,参数为args
		Object result=method.invoke(target,args);
		System.out.println("end transaction");
		return result;
	}
}

    测试JDK动态代理：

package proxy.part02;

import java.lang.reflect.Proxy;
/**
 * 测试JDK动态代理
 * @author Elio
 */
public class TestDynamicProxy {
	public static void main(String[] args) {
		//创建一个目标对象
		OrgSerivce orgService=new OrgServiceImpl();
		//获得这个目标对象的类加载器对象
		ClassLoader loader=orgService.getClass().getClassLoader();
		//获得目标对象所实现的接口的Class对象
		Class[] interfaces=orgService.getClass().getInterfaces();
		//创建一个Handler对象，处理扩展业务
		ServiceHandler handler=new ServiceHandler(orgService);
		/**
		 * 通过Proxy.newProxyInstance方法获得代理对象
		 * @param loader 目标对象的类加载器对象
		 * @param interfaces 目标对象实现的所有接口的Class对象数组
		 * @param handler 处理扩展业务的对象
		 */
		orgService=(OrgSerivce)Proxy.newProxyInstance(loader,interfaces,handler);
		//执行代理对象业务方法
		orgService.saveOrg("软件开发部");
		orgService.updateOrg(1);
	}
}

    运行结果：

    begin transaction
    save org 软件开发部
    end transaction
    begin transaction
    update org which`s id is 1
    end transaction

    这样我们便可以通过Proxy.newProxyInstance方法获取不同类的代理对象，通过调用代理对象的相应方法，底层会自动帮我们完成扩展业务类的invoke方法的调用，并且返回结果。

2.CGLIB动态代理

    同样的套路我们来测试CGLIB动态代理。

package proxy.part03;

import java.lang.reflect.Method;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.InvocationHandler;
/**
 * 定义核心业务接口（或父类）
 * @author Elio
 */
abstract class MessageService{
	abstract void sendMsg(String msg);
}
/**
 * 实现核心业务（或继承父类）
 * @author Elio
 */
class MessageServiceImpl extends MessageService{
	public void sendMsg(String msg){
		System.out.println(msg);
	}
}
/**
 * 定义管理事务的非核心业务类
 * @author Elio
 */
class TxManager{
	//核心业务前执行
	public void begin(){
		System.out.println("begin transaction");
	}
	//核心业务后执行
	public void end(){
		System.out.println("end transaction");
	}
}
/**
 * 测试CGLIB动态代理
 * @author Elio
 */
public class TestCGLIBProxy01 {
	public static void main(String[] args) {
		//1.创建目标对象
		MessageService msgService=new MessageServiceImpl();
		//2.创建代理对象
		//2.1创建一个代理增强器负责创建代理
		Enhancer enhancer=new Enhancer();
		//2.2设置增强器对应的类加载器
		enhancer.setClassLoader(msgService.getClass().getClassLoader());
		//2.3设置代理对象要实现的接口或继承的父类
		//当目标对象实现了接口就用这个方法
		enhancer.setInterfaces(msgService.getClass().getInterfaces());
		//当目标对象没有实现接口就用这个方法，这两个方法可根据情况决定用哪一个，也可以都是用
		enhancer.setSuperclass(msgService.getClass());
		//2.4指定回调函数
		enhancer.setCallback(new InvocationHandler() {
			//关联非核心业务对象
			TxManager txManager=new TxManager();
			@Override
			public Object invoke(Object proxy,Method method,Object[] args) throws Throwable {
				txManager.begin();
				Object result=method.invoke(msgService, args);
				txManager.end();
				return result;
			}
		});
		//2.5创建代理对象
		MessageService proxy=(MessageService)enhancer.create();
		//3.执行代理对象业务
		//在执行业务方法时会回调Enhancer指定的callback接口中的函数
		proxy.sendMsg("hello");
	}
}

    输出结果：

    begin transaction
    hello
    end transaction

    这样就实现了CGLIB动态代理。

总结：

    代理模式是一种解决方案，也是一项技术，使用代理模式，我们可以在不修改原代码的情况下，完成业务的拓展，并且保证了代码的复用率和可维护性。

    博主编写的这两种动态代理的实现方式略有不同，这也是博主故意为大家挖的坑，如果你仔细理解上面的两个案例，会发现其实JDK动态代理与CGLIB动态代理的实现方式只有增强代理器对象（Enhancer）的setSuperclass方法不同，其他步骤逻辑上完全相同，都需要被代理对象的类加载器、被代理对象实现的接口的Classd对象（或者所继承的父类的Class对象，也可以是本类的Class对象）、一个处理扩展业务的对象（扩展业务代码可以单独写到其他类中，也可以直接写在InvocationHandler接口的实现类中），交由API后，我们就可以获得代理对象。

    这两种动态代理各有优缺点：

JDK动态代理：优点是，生成动态代理对象的速度快，适合频繁创建代理对象的程序；

                       缺点是，执行速度慢，且不能为未实现接口的类创建代理。

CGLIB动态代理：优点是，执行速度快，且能够为未实现接口的类创建代理；

                           缺点是，不能代理final修饰的方法，且生成代理对象的速度慢，不适合频繁创建代理对象的程序。

在Spring中，默认使用JDK动态代理，如果目标对象没有实现接口，会转而使用CGLIB动态代理。

最后，再挖一个坑，23种设计模式包括代理模式和装饰者模式，对设计模式感兴趣的同学可以了解下这两者的区别。