AOP的核心：代理模式（静态代理、动态代理）

Java知识点总结：想看的可以从这里进入

目录

• • • 13.2、代理模式
    • • 13.2.1、简介
      • 13.2.2、静态代理
      • 13.2.3、JDK动态代理
      • 13.2.4、CGLIB代理

13.2、代理模式

13.2.1、简介

代理模式就是面向切面编程（AOP）的底层，它是常用的java设计模式之一，他的特征是代理类与委托类有同样的接口，通过代理类来为委托类提供：预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等功能。在代理模式中，不会直接访问实际对象，而是访问代理对象，正是这种间接的特性，为我们增加了更多的处理方式。

比如现实中代理也是很常见的，比如我们常见的明星，他们都会有一个专门的经纪人，很多合约等等前期都是由经济人先去洽谈，谈妥后明星签字，然后履行合约即可，很多事情都不需要明星自己去完成，而经纪人这个角色就是一个代理对象。

我们通过代理模式可以对某些方法进行添加新功能，即增强处理，这些增强处理，既可以添加到方法前面，也可以添加到方法后面。

代理模式中主要包含以下几个角色：

• 角色

  

  • 抽象接口：接口或抽象类，表明要做什么？
  • 真实角色(被代理的类)：继承接口或实现抽象类，具体去实现某类功能。
  • 代理角色(代理类)：去代理真实的角色，并增加一些公共的方法，管理真实角色
  • 客户：访问代理角色，通过代理角色，我们即可完成所需功能，不需要去专门的寻找相应的真实角色。

• 优点

  • 真实角色可以独立出来只做自己相关的功能，不需要去重复写一些公共的功能代码
  • 公共的功能只要交给代理角色去实现，通过代理角色去管理真实角色，可以统一的实现公共部分的功能
  • 公共的功能扩展时，只需要找代理角色即可
• 缺点：当项目复杂时，会使代理角色大量增加，导致开发效率变低

13.2.2、静态代理

比方说在 UserService 中有增删改查四个方法，我们想在其中增加日志的功能，在原有的类中增加代码显然不合适，这个时候我们可以增加一个代理层，在代理层中添加日志的功能。

• 通过@Bean设置一个保存User对象的List，模拟从数据库取数据

  @Bean("userList")
  public List<User> getUserList(){
      List<User> userList = new ArrayList<>();
      userList.add(new User(1,"用户1","123456",false));
      userList.add(new User(2,"用户2","234567",false));
      userList.add(new User(3,"用户3","345678",false));
      userList.add(new User(4,"用户4","456789",false));
      userList.add(new User(5,"用户5","567890",false));
      return userList;
  }

• 创建DAO操作userList

  @Repository
  public class ProxyTestUserDao {
      @Resource
      private List<User> userList;
      //改
      public void update(User user) {
          boolean exists = true;
          for (int i=0; i<userList.size(); i++){
              if(user.getUserId().equals(userList.get(i).getUserId())){
                  exists = false;
                  userList.set(i,user);
                  break;
              }
          }
          if(exists){
              System.out.println("没有此用户");
          }
      }
      //删
      public void delete(int id) {
          boolean exists = false;
          for (int i=0; i<userList.size(); i++){
              if(id == userList.get(i).getUserId()){
                  exists = true;
                  userList.remove(i);
                  break;
              }
          }
          if(!exists){
              System.out.println("没有此用户");
          }else {
              System.out.println("删除成功");
          }
      }
      //查
      public User select(int id) {
          for (User user : userList) {
              if (id == user.getUserId()) {
                  return user;
              }
          }
          return null;
      }
      public List<User> selectAll() {
          return userList;
      }
      //增加
      public void insert(User user) {
          int id = userList.get(userList.size()-1).getUserId();
          id += 1;
          user.setUserId(id);
          userList.add(user);
          System.out.println("增加成功");
      }
  }

• 创建service层

  @Service
  public class ProxyTestUserServiceImpl implements ProxyTestUserService {
      @Autowired
      private ProxyTestUserDao proxyTestUserDao;
      @Override
      public void update(User user) {
          proxyTestUserDao.update(user);
      }
      @Override
      public void delete(int id) {
          proxyTestUserDao.delete(id);
      }
      @Override
      public User select(int id) {
          return proxyTestUserDao.select(id);
      }
      @Override
      public List<User> selectAll() {
          return proxyTestUserDao.selectAll();
      }
      @Override
      public void insert(User user) {
          proxyTestUserDao.insert(user);
      }
  }

• 测试一下

  

现在我想在上面的service中的几个操作中添加一些日志的功能，能打印出来我在做什么操作，首先要符合 开闭原则，不能直接修改源代码，那我们可以通过添加一个代理层来实现。

• 添加代理角色

  public class ProxyTestUserServiceProxyImpl implements ProxyTestUserService {
      @Resource(name = "proxyTestUserServiceImpl")
      private ProxyTestUserService userService;
      @Override
      public void update(User user) {
          System.out.println("修改id为"+user.getUserId()+"的用户信息");
          userService.update(user);
          System.out.println("操作完成");
      }
      @Override
      public void delete(int id) {
          System.out.println("删除id为"+id+"的用户信息");
          userService.delete(id);
          System.out.println("操作完成");
      }
      @Override
      public User select(int id) {
          System.out.println("获取id为"+id+"的用户信息");
          User user = userService.select(id);
          System.out.println("操作完成");
          return user;
      }
      @Override
      public List<User> selectAll() {
          System.out.println("查询所有用户");
          return userService.selectAll();
      }
      @Override
      public void insert(User user) {
          System.out.println("新增用户");
          userService.insert(user);
          System.out.println("操作完成");
      }
  }

• 再测试一下

  

这样就通过添加了一层代理，在不改变原有service的基础上，添加了一些其他的信息。但是这种代理在service很多时，每一个service都需要添加一个代理类，实际使用起来还是挺麻烦的。

13.2.3、JDK动态代理

在测试了静态代理后，我们这种方式需要手动添加一个代理对象，当被代理对象很多时，就需要添加很多代理对象，使代码量大大增加。

所以Java提供了一种JDK动态代理，它使用的反射机制，在 java.lang.reflect 包下提供了一个 Proxy 类和一个InvocationHandler接口，通过一个类和一个接口就可以实现动态代理。

1. InvocationHandler接口：通过实现这个接口，定义横切逻辑，然后通过invoke方法调用目标类的代码。可以添加一些前置后置等处理。

2. Proxy 类：提利用InvocationHandler动态创建一个符合目标类实现的接口的实例，生成目标类的代理对象。

   • newProxyInstance：用于创建一个代理实例。

     @CallerSensitive
     public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h) {
         Objects.requireNonNull(h);
         final Class<?> caller = System.getSecurityManager() == null? null: Reflection.getCallerClass();
         /*
          * 查找或生成指定的代理类及其构造函数。
          */
         Constructor<?> cons = getProxyConstructor(caller, loader, interfaces);
         return newProxyInstance(caller, cons, h);
     }

   • getProxyClass：用于获取代理类的Class对象，再通过调用构造函数创建代理实例。

通过 Proxy 类 newProxyInstance方法创建了一个动态代理对象，它生成了一个叫 $Proxy0（0是编号，多个代理类会进行递增）的代理类，这个类文件时放在内存中的，我们在创建代理对象时，就是通过反射获得这个类的构造方法，然后创建的代理实例。

InvocationHandler接口的实现类就像是一个中介，它持有被代理对象，被我们调用代理对象自身方法时，它会跳转到 invoke方法，并将方法传递进来，在invoke 中调用了被代理对象的相应方法，而在调用前后均可以进行其他的处理。

我们将上面的静态代理通过JDK动态代理实现一下：

• User类、dao类、service类不变

• 自定义一个拦截器，用于织入一些前置、后置通知

  public interface Interceptor {
      public void before(Object obj);
      public void after(Object obj);
      public void afterReturning(Object obj);
      public void afterThrowing(Object obj);
  }
  public class UserServiceInterceptor implements Interceptor{
      @Override
      public void before(Object obj) {
          System.out.println("方法前置处理");
      }
      @Override
      public void after(Object obj) {
          System.out.println("方法后置处理");
      }
      @Override
      public void afterReturning(Object obj) {
          System.out.println("操作成功！！！");
      }
      @Override
      public void afterThrowing(Object obj) {
          System.out.println("出现了异常");
      }

• 创建态代理工厂 ProxyFactory

  public class ProxyFactory implements InvocationHandler{

        // 传递一个真实的对象
        private Object target;
        //拦截器（前置、后置通知）
        private Interceptor interceptor;
        //传递一个拦截器，传递一个被代理的对象，自动生成代理对象
        public static <T> Object getBean(T target, Interceptor interceptor) {
            ProxyFactory proxyFactory = new ProxyFactory();
            proxyFactory.target = target;
            proxyFactory.interceptor = interceptor;
            //生成代理对象。newProxyInstance方法参数
            //参数：被代理类类加载器、被代理对象实现的接口、ProxyBeanUtilHandler对象
            return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),proxyFactory);
        }
        //被代理对象执行方法时，都会跳转到这里进行过统一的处理，添加了处理前，处理后等一些操作
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("代理执行" +method.getName() + "方法");
            Object retobj = null;
            //调用方法前的处理（可以设置一个拦截器，在此处调用）
            interceptor.before(target);
            //是否有异常
            boolean exceptionFlag = false;
            try {
                retobj = method.invoke(target,args);
            } catch (IllegalAccessException e) {
                exceptionFlag = true;
            } finally {
                //调用方法前的处理（可以设置一个拦截器，在此处调用）
                interceptor.after(target);
            }
            //判断是否有异常
            if(exceptionFlag){
                interceptor.afterThrowing(target);
            }else {
                interceptor.afterReturning(target);
            }
            return retobj;
        }
    }

• 创建一个工厂，用来返回生成的代理对象

  public class ProxyBeanFactory {
      public static <T>T getBean(T obj, Interceptor interceptor){
          //通过代理类添加以上逻辑所需要实现的方法
          return (T)ProxyFactory.getBean(obj,interceptor);
      }
  }

• 测试

  

13.2.4、CGLIB代理

使用JDK技术必须要在接口环境中（被代理对象实现某个接口），如果某些环境中无法提供接口，那么JDK动态代理是不能使用的。这时候可以借助第三方技术，而CGLIB动态代理就是第三方提供的技术。

添加cglib的依赖

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

CGLIB不需要提供接口，只需要一个非抽象类就可以实现代理。它是一个接口：org.springframework.cglib.proxy.MethodInterceptor，除此之外需要创建一个 org.springframework.cglib.proxy.Enhancer 的工具类，此类用来生成代理对象。

• 创建一个类（不实现接口），作为被代理对象

  public class ClgbTest {
      public void test(){
          System.out.println("测试CLGB动态代理");
      }
  }

• 创建CglbProxy 实现 org.springframework.cglib.proxy.MethodInterceptor（不要导错包）

  public class CglbProxy implements MethodInterceptor {
       //为目标对象生成代理对象
      public static <T> Object getBean(Class<T> obj) {
          //Cglb的enhancer增强对象
          Enhancer enhancer = new Enhancer();
          //增强类型
          enhancer.setSuperclass(obj);
          //设置代理逻辑对象为CglbProxy类的实例
          enhancer.setCallback(new CglbProxy());
          return enhancer.create();
      }
      @Override
      public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {

            Object retobj = null;
            System.out.println("代理执行" +method.getName() + "方法");
            //调用方法前的处理（可以设置一个拦截器，在此处调用）
            System.out.println("方法前置处理");
            retobj = methodProxy.invokeSuper(o,objects);
            //调用方法前的处理（可以设置一个拦截器，在此处调用）
            System.out.println("方法后置处理");
            return retobj;
        }
    }

• 创建一个工厂，用来返回生成的代理对象

  public class ProxyBeanFactory {
      public static <T>T getClibBean(Class<T> obj){
          //通过代理类添加以上逻辑所需要实现的方法
          return (T)CglbProxy.getBean(obj);
      }
  }

• 测试