• spring Aop

    1.1 什么是动态代理

    动态代理利用Java的反射技术(Java Reflection)生成字节码，在运行时创建一个实现某些给定接口的新类（也称"动态代理类"）及其实例。

    1.2 动态代理的优势

    动态代理的优势是实现无侵入式的代码扩展，也就是方法的增强；让你可以在不用修改源码的情况下，增强一些方法；在方法的前后你可以做你任何想做的事情（甚至不去执行这个方法就可以） spring中的AOP是动态代理使用的经典场景。

    1.3 基于JDK动态代理实现

    在基于JDK的动态代理的实现中有两个重要的类：InvocationHandler, Proxy

    • InvocationHandler 是代理实例的调用处理程序实现的接口。每个代理实例都具有一个关联的调用处理程序。对代理实例调用方法时，将对方法调用进行编码并将其指派到它的调用处理程序的 invoke 方法。

    • Proxy JDK中动态生成代理类的工具类

    一个动态代理的示例：

    定义一个接口（基于JDK的动态代理只能使用接口）

    1. public interface ISubject {
    2.     void hello(String param);
    3. }

    为接口定义实现类

    1. public class SubjectImpl implements ISubject {
    2. ​
    3.     @Override
    4.     public void hello(String param) {
    5.         System.out.println("hello  " + param);
    6.     }
    7. }

    实现一个代理类：

    1. public class JDKProxy implements InvocationHandler {
    2. ​
    3.     private Object target;
    4.      //调用时传入对象的目标对象（需要实现代理的具体类）
    5.     public JDKProxy(Object target) {
    6.         this.target = target;
    7.     }
    8. ​
    9.     //创建代理
    10.     public Object newProxy() {
    11.       /**
    12.          * newProxyInstance，方法有三个参数：
    13.          *
    14.          * loader: 用哪个类加载器去加载代理对象
    15.          *
    16.          * interfaces:动态代理类需要实现的接口必须是加载器继承的接口
    17.          *
    18.          * h:动态代理方法在执行时，会调用h里面的invoke方法去执行 this就相当于调用本类中的
    19.           invoke 也可以写别的地方
    20.          */
    21.      return (ISubject)Proxy.newProxyInstance(
    22.              target.getClass().getClassLoader(),
    23.              target.getClass().getInterfaces(),
    24.              this);
    25.     }
    26. ​
    27.     @Override   
    28.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    29. ​
    30.        System.out.println("---------- 在业务方法调用之前可以进行前置增强   ------------");
    31. ​
    32.         //利用反射机制调用方法，invoke为返回值，如果没有返回null
    33.         Object invoke = method.invoke(target, args);
    34. ​
    35.         System.out.println("---------- 在业务方法调用之前可以进行后置增强   ------------");
    36.         return invoke;
    37.     }
    38. ​
    39. }
    40. 编写代理类实际的调用，利用Proxy类创建代理之后的Subject类
    41.  
    42. public class JDKProxyDemo {
    43. ​
    44.     public static void main(String[] args) {
    45. ​
    46.         ISubject subject = new SubjectImpl();
    47.         //将具体类赋值给目标对象
    48.         JDKProxy subjectProxy = new JDKProxy(subject);
    49. ​
    50.         ISubject proxyInstance = (ISubject)subjectProxy.newProxy();
    51. ​
    52.         proxyInstance.hello("world");
    53. ​
    54.     }
    55.     
    56. }

    运行结果：

    ---------- 在业务方法调用之前可以进行前置增强   ------------
hello  world
---------- 在业务方法调用之前可以进行后置增强   ------------

    2. AOP

    2.1 基本概念

    • 连接点 (Joinpoint) 程序执行过程中明确的点，如方法的调用，或者异常的抛出.

    • 目标(Target) 被通知(被代理)的对象，如上例中的SubjectImpl

    • 通知(Advice) 在某个特定的连接点上执行的动作，同时Advice也是程序代码的具体实现，例如一个实现日志记录的代码(通知有些书上也称为处理)，可以理解为AOP真正要实现的功能

    • 代理(Proxy) 将通知应用到目标对象后创建的对象(代理=目标+通知),请注意：只有代理对象才有AOP功能，而AOP的代码是写在通知的方法里面的，如上例中的JDKProxy

    • 切入点(Pointcut) 多个连接点的集合，定义了通知应该应用到那些连接点。也将Pointcut理解成一个条件 ，此条件决定了容器在什么情况下将通知和目标组合成代理返回给外部程序

    • 适配器(Advisor) 适配器=通知(Advice)+切入点(Pointcut)

    AOP运行原理：目标对象只负责业务逻辑，通知只负责AOP增强逻辑（如日志，数据验证等），而代理对象则将业务逻辑而AOP增强代码组织起来（组织者）

    2.2 AOP带来的好处

    AOP是公用的框架代码放置的理想地方，将公共代码与业务代码分离，使我们在处理业务时可以专心的处理业务。 伪代码：

    1. public void doSameBusiness (long lParam,String sParam){
    2.      // 记录日志
    3.      log.info("调用 doSameBusiness方法，参数是："+lParam);
    4.      // 输入合法性验证
    5.      if (lParam<=0){
    6.           throws new IllegalArgumentException("xx应该大于0");
    7.      }
    8.      if (sParam==null || sParam.trim().equals("")){
    9.           throws new IllegalArgumentException("xx不能为空");
    10.      }
    11.      // 异常处理
    12.      try{ 
    13.         真正的业务处理
    14.      }catch(...){
    15.      }catch(...){
    16.      }
    17.      // 事务控制
    18.      tx.commit();
    19.  }

    通过使用AOP我们可以将日志记录，数据合法性验证，异常处理等功能放入AOP中，那么在编写业务时就可以专心实现真正的业务逻辑代码。

    3. Spring AOP

    在spring中org.springframework.aop.framework.ProxyFactoryBean用来创建代理对象，在一般情况下它需要注入一下三个属性：

    • proxyInterfaces 代理应该实现的接口列表(List)

    • interceptorNames 需要应用到目标对象上的通知Bean的名字

    • target 目标对象 (Object)

    准备工作：创建一个IBookService接口及其实现类，用于演示spring AOP开发示例：

    1. package com.badu.service;
    2. ​
    3. import com.badu.model.Book;
    4. ​
    5. import java.util.List;
    6. ​
    7. public interface IBookService {
    8.     List<Book> listBOoks();
    9. ​
    10.     /**
    11.      *
    12.      * 购买 书本
    13.      * @param userName
    14.      * @param bookName
    15.      * @param price
    16.      * @return
    17.      */
    18.     boolean buy(String userName, String bookName, Double price);
    19. ​
    20.     /**
    21.      * 评论
    22.      * @param userName
    23.      * @param comments
    24.      */
    25.     void comment(String userName, String comments);
    26. }
    27. ​
    28. 在定义 实现类 不适用注解 实现通知
    29.  
    30. package com.badu.service;
    31. ​
    32. import com.badu.aop.PriceException;
    33. import com.badu.dao.IBookDao;
    34. import com.badu.model.Book;
    35. import org.springframework.beans.factory.annotation.Autowired;
    36. import org.springframework.stereotype.Service;
    37. ​
    38. import java.util.List;
    39. //@Service(bookservice) 与下面 结果一个 没有指定id 则就是本内名第一个字母小写
    40. //@Service
    41. public class BookService implements IBookService{
    42.     /**
    43.      * spring 会根据类型进行 赋值 但  注意 如果又两个实现类则需要指定 否则会直接报错
    44.      */
    45.     @Autowired  
    46.    private  IBookDao book;
    47.     
    48.   public void setBook(IBookDao book) {
    49.         this.book = book;
    50.     }
    51.     @Override
    52.     public List<Book> listBOoks() {
    53.        /* String i=null;
    54.         System.out.println(i.length());*/
    55.         return book.listBOoks();
    56.     }
    57. ​
    58. ​
    59.    @Override
    60.     public boolean buy(String userName, String bookName, Double price) {
    61.         //logger.info("userName={},bookName={},price={}", userName, bookName, price);
    62.         // 通过控制台的输出方式模拟购书
    63.         System.out.println(userName + " buy " + bookName + ", spend " + price);
    64. ​
    65.         //抛出自定义异常
    66.        // throw new PriceException();
    67.         return true;
    68.     }
    69.     @Override
    70.     public void comment(String userName, String comments) {
    71.         System.out.println(userName + " say:" + comments);
    72.     }
    73. ​
    74. }
    75. ​

    将service配置到spring配置文件中，以便于被spring管理，按自己的实际情况配置

    

     <bean id="bookServiceTarget" class="com.badu.service.BookService"/>

    3.1 前置通知

    前置通知需要实现org.springframework.aop.MethodBeforeAdvice，前置通知将在目标对象调用前调用。示例实现购书系统AOP方式实现日志，简单打印调用的方法及参数

    1）首先实现一个前置通知类，实现接口MethodBeforeAdvice，并实现接口中的before方法

    1. package com.badu.aop;
    2. ​
    3. import org.springframework.aop.MethodBeforeAdvice;
    4. ​
    5. import java.lang.reflect.Method;
    6. import java.util.Arrays;
    7. ​
    8. /**
    9.  * 前置通知
    10.  */
    11. public class MyMEthodBeforeAdvice implements MethodBeforeAdvice {
    12.     @Override
    13.     public void before(Method method, Object[] args, Object target) throws Throwable {
    14.         String s = "[前置通知]: "
    15.                 + this.getClass() + "."
    16.                 + method.getName()
    17.                 + "将被调用，参数为:"
    18.                 + Arrays.toString(args);
    19. ​
    20.         System.out.println(s);
    21.     }
    22. }
    23. ​
    24. 2）将实现的前置通知配置到Spring.xml中，一遍与被spring管理。需要根据自己的实际情况配置。
    25.  
    26.   <bean id="methodBeforeAdvice" class="com.badu.aop.MyMEthodBeforeAdvice"/>
    27. 3）现在需要解决如何将通知和目标联系起来，需要一个组织者 - 代理 固定参数 不可改动
    28.  
    29. <bean id="bookService" class="org.springframework.aop.framework.ProxyFactoryBean">
    30.         <!-- 配置代理目标 -->
    31.         <property name="target" ref="bookServiceTarget"/>
    32.        
    33.         <!-- 配置拦截器列表，拦截器就是通知 -->
    34.         <property name="interceptorNames">
    35.             <list>
    36.                 <value>methodBeforeAdvice</value>
    37.             </list>
    38.         </property>
    39.         
    40.         <!-- 代理要实现的接口，代理类与被代理类需要实现相同接口 -->
    41.         <property name="proxyInterfaces">
    42.             <list>
    43.                 <value>com.badu.service.IBookService</value>
    44.             </list>
    45.         </property>
    46.     </bean>

    写一个测试类，测试前置通知

    1. public class Demo {
    2.     
    3.     public static void main(String[] args) {
    4. ​
    5.         ApplicationContext <u>cxt</u> = new ClassPathXmlApplicationContext("/spring.xml");
    6.         IBookService bookService = (IBookService)cxt.getBean("bookService");
    7.         
    8.         System.out.println(bookService.getClass().getName());        
    9.         bookService.buy("zs", "hlm", 10D);
    10.     }
    11.     
    12. }

    3.2 后置通知

    在连接点正常完成后执行的通知。定义的后置通知类需要实org.springframework.aop.AfterReturningAdvice

    示例:在线购书系统中，要求不修改BookServiceImpl代码的情况下增加如下功能：对买书的用户进行返利：每买本书返利10元，简单打印类似于“[后置通知] 返利10元”即可。开发步骤与前置通知类似

    1） 编写一个后置通知实现类

    1. package com.badu.aop;
    2. ​
    3. import org.springframework.aop.AfterReturningAdvice;
    4. ​
    5. import java.lang.reflect.Method;
    6. ​
    7. /**
    8.  * 后置通知
    9.  */
    10. public class MyAfterReturnAdvice implements AfterReturningAdvice {
    11.     @Override
    12.     public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
    13.         System.out.println("后置通知"+method.getName());
    14.     }
    15. }
    2） 将后置通知实现类配置到spring配置文件中，以便于spring管理
     <bean id="methodReturnAdvice" class="com.badu.aop.MyAfterReturnAdvice"/>

    3）解决如何将通知和目标联系起来，在实现前置通知时已经配置了代理对象，现在只要将后置通知也配置到拦截器列表当中即可。

    1.  
    2.         <property name="interceptorNames">
    3.             <list>
    4.                  
    5.                 <value>methodBeforeAdvicevalue>
    6.                 
    7.                 <value>methodReturnAdvicevalue>
    8.             list>
    9.         property>

    运行上例已经实现的测试类，查看后置通知的运行效果。

    3.3 环绕通知

    包围一个连接点的通知，最大特点是可以修改返回值，由于它在方法前后都加入了自己的逻辑代码，因此功能很强大。自定义的环绕通知需要实现org.aopalliance.intercept.MethodInterceptor接口。 示例：在环绕通知中输出日志和返回值

    1）实现一个环绕通知，该类要实现MethodInterceptor接口

    1. package com.badu.aop;
    2. ​
    3. ​
    4. ​
    5. import org.aopalliance.intercept.MethodInterceptor;
    6. import org.aopalliance.intercept.MethodInvocation;
    7. ​
    8. import java.lang.reflect.Method;
    9. import java.util.Arrays;
    10. ​
    11. /**
    12.  * 环绕通知i
    13.  */
    14. public class MyMethodInterceptor implements MethodInterceptor {
    15. ​
    16.     @Override
    17.     public Object invoke(MethodInvocation invocation) throws Throwable {
    18. ​
    19.         //获取目标对象
    20.         Object target = invocation.getThis();
    21.         //获取参数
    22.         Object[] args = invocation.getArguments();
    23.         //获取方法
    24.         Method method = invocation.getMethod();
    25.         System.out.println("[环绕通知] 前：将调用"+target.getClass()+"."+  method.getName()+"方法，参数为"+Arrays.toString(args)+""
    26.               );
    27. ​
    28.         //调用目标对象上的方法
    29.         Object val = invocation.proceed();
    30.         System.out.println("[环绕通知] 前：将调用"+target.getClass()+"."+  method.getName()+"方法，返回值为"+val+""
    31.         );
    32. ​
    33.         return val;
    34.     }
    35. }
    ​2）在spring的配置文件中配置环绕通知，以便于spring管理

    3）解决如何将通知和目标联系起来，在实现前置通知时已经配置了代理对象，现在只要将环绕通知也配置到拦截器列表当中即可。

    1.   
    2.         <property name="interceptorNames">
    3.             <list>
    4.                  
    5.                 <value>methodBeforeAdvicevalue>
    6.                 
    7.                 <value>methodReturnAdvicevalue>
    8.                 
    9.                 <value>methodInterceptorvalue>
    10.             list>
    11.         property>

    运行上例已经实现的测试类，查看后置通知的运行效果。

    3.4 异常通知

    异常通知需要实现ThrowsAdvice接口，这个通知会在方法抛出异常退出时执行，与以上演示的前置、后置、环绕通知不同，主要有一下特点：

    • 这个接口里面没有定义方法，要求我们的类必须实现afterThrows这个方法

    • 以异常类型作为参数，无返回值

    示例 1）定义一个自定义异常，继承RuntimeException运行时异常

    1. public class PriceException extends RuntimeException {
    2. ​
    3.     public PriceException() {
    4.         super();
    5.     }
    6. ​
    7.     public PriceException(String message, Throwable cause) {
    8.         super(message, cause);
    9.     }
    10. ​
    11.     public PriceException(String message) {
    12.         super(message);
    13.     }
    14. ​
    15.     public PriceException(Throwable cause) {
    16.         super(cause);
    17.     }
    18. }

    2）创建异常通知类，该类实现ThrowsAdvice接口，并实现afterThrowing方法

    1. package com.badu.aop;
    2. ​
    3. import org.springframework.aop.ThrowsAdvice;
    4. ​
    5. /**
    6.  * 异常通知类
    7.  */
    8. public class MyThrowsAdvice implements ThrowsAdvice {
    9.     /**
    10.      * 约定  方法名 不可一定要是 afterThrowing
    11.      * @param e
    12.      */
    13.     //以异常类型作为参数，无返回值
    14.     public void afterThrowing(PriceException e) {
    15.         System.out.println("程序发生了PriceException异常");
    16.     }
    17. }
    ​剩下的步骤是将异常通知配置到spring配置文件中，及在代理配置中加入异常通知的配置，可参考上面的环绕通知等示例。

    3.5 适配器

    适配器, 通过正则表达式来定义方法切入点，也就是说定义哪些方法将被拦截器处理。适配器=通知(Advice)+切入点(Pointcut)。 在配置适配器时需要使用org.springframework.aop.support.RegexpMethodPointcutAdvisor

    配置适配器示例：

      <
    1. !-- 配置适配器 -->
    2.     <bean id="myAdisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
    3. ​
    4.         <!-- 定义正则表达式，定义需要拦截的方法名 ，本例定义了所有以buy结尾的方法  -->
    5.         <property name="patterns">
    6.             <list>
    7.                 <value>.*buy</value>
    8.             </list>
    9.         </property>
    10. ​
    11.         <!-- 定义由那个通知(或者叫拦截器)来处理匹配的方法 -->
    12.         <property name="advice">
    13.             <ref bean="methodReturnAdvice"/>
    14.         </property>
    15.     </bean>

    在代理中使用刚刚配置的适配器

    3.                 
    5. <value>myAdisorvalue>

    修改代理中的拦截器列表（spring配置文件，代理部分），将配置器直接配置在拦截器列表中即可。

    xml 的完整配置代码

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
    4.        xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
    5.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
    6.         http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
    7.         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
    8.         http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd">
    9. ​
    10.     <bean id="bookDao" class="com.badu.dao.BookDao">
    11.     </bean>
    12.     <bean id="bookServiceTarget" class="com.badu.service.BookService">
    13.         <property name="book" ref="bookDao"/>
    14.     </bean>
    15.     <!--定义通知-->
    16.     <bean id="methodBeforeAdvice" class="com.badu.aop.MyMEthodBeforeAdvice"/>
    17.     <bean id="methodReturnAdvice" class="com.badu.aop.MyAfterReturnAdvice"/>
    18.     <bean id="methodInterceptor" class="com.badu.aop.MyMethodInterceptor"/>
    19.     <bean id="myThrowsAdvice" class="com.badu.aop.MyThrowsAdvice"/>
    20.     <!--定义aop-->
    21.     <bean id="bookService" class="org.springframework.aop.framework.ProxyFactoryBean">
    22.         <!--配置目标对象-->
    23.         <property name="target" ref="bookServiceTarget"/>
    24.         <!-- 配置通知 -->
    25.         <property name="interceptorNames">
    26.             <list>
    27.                 <value>methodBeforeAdvice</value>
    28.                 <value>myAdisor</value>
    29.                 <value>methodInterceptor</value>
    30.                 <value>myThrowsAdvice</value>
    31.             </list>
    32.         </property>
    33. ​
    34. ​
    35.         <!-- 代理要实现的接口，代理类与被代理类需要实现相同接口 -->
    36.         <property name="proxyInterfaces">
    37.             <list>
    38.                 <value>com.badu.service.IBookService</value>
    39.             </list>
    40.         </property>
    41. ​
    42. ​
    43.     </bean>
    44.     <!-- 配置适配器 -->
    45.     <bean id="myAdisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
    46. ​
    47.         <!-- 定义正则表达式，定义需要拦截的方法名 ，本例定义了所有以buy结尾的方法  -->
    48.         <property name="patterns">
    49.             <list>
    50.                 <value>.*buy</value>
    51.             </list>
    52.         </property>
    53. ​
    54.         <!-- 定义由那个通知(或者叫拦截器)来处理匹配的方法 -->
    55.         <property name="advice">
    56.             <ref bean="methodReturnAdvice"/>
    57.         </property>
    58.     </bean>
    59. ​
    60. </beans>

    最后运行结果

    实例 spring 中定义的异常的使用

    在会调用的方法中 抛出我们定义的异常 在前置通知后者后置通知中抛出也可以

     

     演示效果

     

  • 相关阅读:
    【Ubuntu-MySQL8安装与主从复制】
    举一反三刷穿字符串加减法类型题目：牛客BM86 大数加法、LeetCode-445. 两数相加 II、LeetCode-2. 两数相加
    基于Android的地图服务系统设计与实现
    力扣（103、236、104）
    微信小程序navigateTo进入页面后返回原来的页面需要携带数据回来
    06【对象的扩展】
    聊天机器人语料在开发中的重要性
    ASIC-WORLD Verilog（11）过程时序控制
    opencv实现图像的融合
    2023年腾讯云2核4G配置服务器性价比怎么样?
  • 原文地址：https://blog.csdn.net/qq_62898618/article/details/126392813