Spring框架 之 代理模式

在开发过程中，我们常需要在不更改原代码的前提下实现业务的扩展（也就是我们常说的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动态代理。