spring_6_AOP实现

Posted Oliver_Ren

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了spring_6_AOP实现相关的知识,希望对你有一定的参考价值。

1. AOP 概念

POP (Producer Oriented Programing)

  • 面向过程(方法、函数)编程 —— C
  • 以过程为基本单位的程序开发,通过过程间的彼此协同,相互调用,完成程序的构建。

OOP (Object Oritened Programing)

  • 面向对象编程 —— Java
  • 以对象为基本单位的程序开发,通过对象间的彼此协同,相互调用,完成程序的构建。

AOP (Aspect Oriented Programing)

  • 面向切面编程 = Spring动态代理开发
  • 以切面为基本单位的程序开发,通过切面间的彼此协同,相互调用,完成程序的构建。
  • 切面 = 切入点 + 额外功能

AOP 的概念:

  • 本质就是 Spring 的动态代理开发,通过代理类为原始类增加额外功能。
  • 好处:利于原始类的维护
  • 注意:AOP 编程不可能取代 OOP,AOP 是 OOP 编程的补充。

2. AOP 编程的开发步骤

  1. 原始对象
  2. 额外功能 (MethodInterceptor)
  3. 切入点
  4. 组装切面 (额外功能+切入点)

3. 切面的名词解释

切面 = 切入点 + 额外功能
几何学:面 = 点 + 相同的性质

img1

4. AOP 的底层实现原理

核心问题:

  1. AOP 如何创建动态代理类?
    动态字节码技术
  2. Spring 工厂如何加工创建代理对象?
    通过原始对象的 id 值,获得的是代理对象

4.1 动态代理类的创建

  1. JDK 的动态代理(原理 + 编码)
    • Proxy.newPorxyInstance 方法参数详解
      img2


      img3

    • 编码

      public class TestJDKProxy {
          /**
             1. 借⽤类加载器  TestJDKProxy 或 UserServiceImpl 都可以
             2. JDK8.x 前必须加 final
             final UserService userService = new UserServiceImpl();
          */
          public static void main(String[] args) {
              // 1. 创建原始对象
              UserService userService = new UserServiceImpl();
      
              // 2. JDK 动态代理
              InvocationHandler handler = new InvocationHandler() {
                      @Override
                      public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                          System.out.println("---- proxy log ----");
                          // 原始方法运行
                          Object ret = method.invoke(userService, args);
                          return ret;
                      }
                  };
              UserService userServiceProxy = (UserService) Proxy.
                  newProxyInstance(TestJDKProxy.class.getClassLoader(),
                                   userService.getClass().getInterfaces(),
                                   handler);
              userServiceProxy.login("zhenyu", "123456");
      
              userServiceProxy.register(new User());
          }
      }
      
  2. CGlib 的动态代理 CGlib 创建动态代理的原理:通过父子继承关系创建代理对象,原始类作为父类,
    代理类作为子类,这样既可以保证 2 者方法?致,同时在代理类中可以提供新的实现(额外功能+原始方法)。 img4

    • CGlib 编码

      public class TestCglib {
          public static void main(String[] args) {
              // 1. 创建原始对象
              UserService userService = new UserService();
      
              /*
               2. 通过 cglib 方式创建动态代理对象
               对比 jdk 动态代理 ---> Proxy.newProxyInstance(classLoader, interface, invocationHandler);
      
               Enhancer.setClassLoader()
               Enhancer.setSuperClass()
               Enhancer.setCallBack() ---> MethodInterceptor(cglib)
               Enhancer.createProxy() ---> 创建代理对象
               */
              Enhancer enhancer = new Enhancer();
      
              enhancer.setClassLoader(TestCglib.class.getClassLoader());
              enhancer.setSuperclass(userService.getClass());
      
              MethodInterceptor interceptor = new MethodInterceptor() {
                  @Override
                  public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
                      System.out.println("--- cglib log ----");
                      Object ret = method.invoke(userService, args); // 执行原始方法
                      return ret;
                  }
              };
      
              enhancer.setCallback(interceptor);
              UserService userServiceProxy = (UserService) enhancer.create();
              userServiceProxy.login("zhenyu", "123456");
              userServiceProxy.register(new User());
          }
      }
      

4.2 总结

  1. JDK 动态代理
    Proxy.newProxyInstance:通过接口创建代理的实现类
  2. Cglib 动态代理
    Enhancer:通过继承?类创建的代理类

5. Spring 工厂如何加工原始对象

  • 思路分析:主要通过 BeanPostProcessor 将原始对象加工为代理对象 img5

  • 编码

    public class ProxyBeanPostProcessor implements BeanPostProcessor {
        @Override
        public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
            return bean;
        }
    
        @Override
        public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
    
            InvocationHandler handler = new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("--- new log ---");
                        Object ret = method.invoke(bean, args);
                        return ret;
                    }
                };
            return Proxy.newProxyInstance(ProxyBeanPostProcessor.class.getClassLoader(), bean.getClass().getInterfaces(), handler);
        }
    }
    
    <bean id="userService" class="com.yusael.factory.UserServiceImpl"/>
    <!--1. 实现 BeanPostProcessor 进行加工-->
    <!--2. 配置文件中对 BeanPostProcessor 进行配置-->
    <bean id="proxyBeanPostProcessor" class="com.yusael.factory.ProxyBeanPostProcessor"/>
    

以上是关于spring_6_AOP实现的主要内容,如果未能解决你的问题,请参考以下文章

Spring_11-Spring5总结

spring的学习____8 spring_AoP的实现方式一:使用spring API实现

spring_03AOP编程

spring的学习____12 声明式事务(AoP的横向织入)

阶段3 2.Spring_08.面向切面编程 AOP_9 spring基于注解的AOP配置

Spring之AOP(面向切面编程)_入门Demo