spring_6_AOP实现

目录

• 1. AOP 概念
• 2. AOP 编程的开发步骤
• 3. 切面的名词解释
• 4. AOP 的底层实现原理
  • 4.1 动态代理类的创建
  • 4.2 总结
• 5. Spring 工厂如何加工原始对象

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"/>