在开发过程中，我们常需要在不更改原代码的前提下实现业务的扩展（也就是我们常说的OCP原则），为此，就需要用到代理模式来进行开发。
常用的代理模式有两种，静态代理和动态代理，而常用的动态代理技术又包括JDK动态代理和CGLIB动态代理。
一、静态代理
我们先来编写一个业务接口：
package proxy.part01;
/**
- 核心业务接口
/
public interface HelloService {
void sayHello(String msg);
}
编写实现类：
package proxy.part01;
/* - 核心业务的实现类
/
public class HelloServiceImpl implements HelloService{
//核心业务
public void sayHello(String msg) {
System.out.println("hello "+msg);
};
}
现在，我们要在不修改HelloServiceImpl的前提下添加新的业务，例如，要在核心业务的前后输出当前时间。很容易想到，我们可以再写一个新的实现类，这个新实现类也实现HelloService接口，并且实现sayHello方法，在新的实现方法中添加新的业务，并且调用HelloServiceImpl类的sayHello方法，这个新的实现类就是我们说的“代理类（代理对象）”。
package proxy.part01;
/* - 代理对象
/
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;
/* - 测试代理
/
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;
/* - 核心业务接口
/
public interface OrgSerivce {
//保存一个组织
void saveOrg(String org);
//根据ID更新一个组织
int updateOrg(Integer id);
}
实现核心业务接口：
package proxy.part02;
/* - 实现核心业务接口
*/
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接口
/
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动态代理
/
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;
/**
- 定义核心业务接口（或父类）
/
abstract class MessageService{
abstract void sendMsg(String msg);
}
/* - 实现核心业务（或继承父类）
/
class MessageServiceImpl extends MessageService{
public void sendMsg(String msg){
System.out.println(msg);
}
}
/* - 定义管理事务的非核心业务类
/
class TxManager{
//核心业务前执行
public void begin(){
System.out.println("begin transaction");
}
//核心业务后执行
public void end(){
System.out.println("end transaction");
}
}
/* - 测试CGLIB动态代理
*/
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动态代理。
