AOP 面向切面编程

于 2024-10-15 16:11:17 发布
阅读量985 收藏 19
点赞数 15
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/2301_80220193/article/details/142957060
版权
1.准备工作，创建maven项目

    1. pom.xml  加入依赖

<dependencies>

    <!--spring核心坐标-->

    <dependency>

        <groupId>org.springframework</groupId>

        <artifactId>spring-context</artifactId>

        <version>6.0.6</version>

    </dependency>
<!--测试-->

    <dependency>

        <groupId>org.springframework</groupId>

        <artifactId>spring-test</artifactId>

        <version>6.0.6</version>

    </dependency>

    <!--注解-->

    <dependency>

        <groupId>jakarta.annotation</groupId>

        <artifactId>jakarta.annotation-api</artifactId>

        <version>2.1.1</version>

    </dependency>

    <!--junit5-->

    <dependency>

        <groupId>org.junit.jupiter</groupId>

        <artifactId>junit-jupiter-api</artifactId>

        <version>5.3.1</version>

        <scope>test</scope>

    </dependency>

 </dependencies>

2. 创建配置类

@Configuration

@ComponentScan(basePackages = {"com.bdqn"})

  public class SpringConfig {

  

}

3. 准备计算器接口

package com.bdqn.proxy;
public interface Calculator {

    int add(int i, int j);

    int sub(int i, int j);

    int mul(int i, int j);

    int div(int i, int j);

}

 4.准备纯净计算器的实现类

package com.bdqn.proxy;
/**

 * 实现计算接口,单纯添加 + - * / 实现! 掺杂其他功能!

 */

  @Component

  public class CalculatorImpl implements Calculator {

    @Override

    public int add(int i, int j) {

        int result=i+j;

        System.out.println("结果："+result);

        return result;

    }

  

    @Override

    public int sub(int i, int j) {

        int result=i-j;

        System.out.println("结果："+result);

        return result;

    }

  

    @Override

    public int mul(int i, int j) {

        int result=i*j;

        System.out.println("结果："+result);

        return result;

    }

  

    @Override

    public int div(int i, int j) {

        int result=i/j;

        System.out.println("结果："+result);

        return result;

    }

}
 
 

  5.测试效果
 

 
@SpringJUnitConfig(classes = {SpringConfig.class})

  public class TestAop {

    @Autowired

    Calculator c;

  

    @Test

    public void testCalculator(){

        c.add(10,2);

        System.out.println("----------");

        c.sub(10,2);
 
System.out.println("----------");

        c.mul(10,2);

        System.out.println("----------");

        c.div(10,2);

    }

}
 
 

 
 

 

    2.AOP 面向切面编程思想
 

 
AOP：Aspect Oriented Programming面向切面编程
 
中文：面向切面编程
 
定义：在程序原有的纵向执行流程中，针对某一个或某一些方法添加通知形成横向切面过程，称为面向切面编程。
 
 

 

    3.AOP思想主要的应用场景
 

 
AOP（面向切面编程）是一种编程范式，它通过将通用的横切关注点（如日志、事务、权限控制等）与业务逻辑分离，使得代码更加清晰、简洁、易于维护。AOP可以应用于各种场景，以下是一些常见的AOP应用场景：
 
 
1. 日志记录：在系统中记录日志是非常重要的，可以使用AOP来实现日志记录的功能，可以在方法执行前、执行后或异常抛出时记录日志。
 
2. 事务处理：在数据库操作中使用事务可以保证数据的一致性，可以使用AOP来实现事务处理的功能，可以在方法开始前开启事务，在方法执行完毕后提交或回滚事务。
 
3. 安全控制：在系统中包含某些需要安全控制的操作，如登录、修改密码、授权等，可以使用AOP来实现安全控制的功能。可以在方法执行前进行权限判断，如果用户没有权限，则抛出异常或转向到错误页面，以防止未经授权的访问。
 
4. 性能监控：在系统运行过程中，有时需要对某些方法的性能进行监控，以找到系统的瓶颈并进行优化。可以使用AOP来实现性能监控的功能，可以在方法执行前记录时间戳，在方法执行完毕后计算方法执行时间并输出到日志中。
 
5. 异常处理：系统中可能出现各种异常情况，如空指针异常、数据库连接异常等，可以使用AOP来实现异常处理的功能，在方法执行过程中，如果出现异常，则进行异常处理（如记录日志、发送邮件等）。
 
6. 缓存控制：在系统中有些数据可以缓存起来以提高访问速度，可以使用AOP来实现缓存控制的功能，可以在方法执行前查询缓存中是否有数据，如果有则返回，否则执行方法并将方法返回值存入缓存中。
 
7. 动态代理：AOP的实现方式之一是通过动态代理，可以代理某个类的所有方法，用于实现各种功能。
 
 
综上所述，AOP可以应用于各种场景，它的作用是将通用的横切关注点与业务逻辑分离，使得代码更加清晰、简洁、易于维护。
 
 

 

  4.AOP术语名词介绍
 

 
切点： 原有功能。           Pointcut   如：sub()方法
 
通知： 在切点前后执行。     Advice
 
--前置通知：在切点前执行 
 
--正常返回后置通知：在切点成功结束后执行（**寿终正寝**）
 
--异常后置通知：在切点出现异常后执行（**死于非命**）
 
--后置通知：在切点最终结束后执行（**盖棺定论**）
 
--环绕通知：使用try...catch...finally结构围绕整个被代理的目标方法，包括上面四种通知对应的所有位置]
 
    切面： 所有功能统称。
 
    织入： 将通知切面嵌入到切点生成代理对象的过程。
 
 

 

 

 5.Spring Aop基于注解方式实现
 

   1.Spring Aop 底层技术组成
 

动态代理（InvocationHandler）：JDK原生的实现方式，需要被代理的目标类必须实现接口。因为这个技术要求代理对象和目标对象实现同样的接口（兄弟两个拜把子模式）。
 
cglib：通过继承被代理的目标类（认干爹模式）实现代理，所以不需要目标类实现接口
 
AspectJ：早期的AOP实现的框架，SpringAOP借用了AspectJ中的AOP注解。
 
 

   2. 实现步骤
 

     1. pom.xml  加入AOP相关的依赖
 

 
<!--spring核心坐标，引入AOP坐标-->

    <dependency>

        <groupId>org.springframework</groupId>

        <artifactId>spring-context</artifactId>

        <version>6.0.6</version>

    </dependency>

    <!--spring-aop依赖的aspectjweaver-->

    <dependency>

        <groupId>org.springframework</groupId>

        <artifactId>spring-aspects</artifactId>

        <version>6.0.6</version>

    </dependency>
 
 

       2. 声明切面类
 

 
package com.bdqn.advice;

  

  import org.aspectj.lang.annotation.*;

  import org.springframework.stereotype.Component;

  

  //@Aspect表示这个类是一个切面类

  @Aspect

  //@Component注解保证这个切面类能够放入IOC容器

  @Component

  public class LogAdvice {

    /**

     * 前置通知

     * @Before注解：声明当前方法是前置通知方法

     * value属性：指定切入点表达式，由切入点表达式控制当前通知方法要作用在哪一个目标方法上

     */

    @Before(value = "execution(* com.bdqn.proxy.CalculatorImpl.*(..))")

    public void logBefore() {

        System.out.println("[AOP前置通知] 方法开始了");

    }

  

    /**

     * 正常后置通知：只有切点正常返回，才会执行

     */

    @AfterReturning(value = "execution(* com.bdqn.proxy.CalculatorImpl.*(..))")

    public void logAfterSuccess() {

        System.out.println("[AOP返回通知] 方法成功返回了");

    }

  

    /**

     * 异常通知：只有切点出现异常，才会执行

     */

    @AfterThrowing(value = "execution(* com.bdqn.proxy.CalculatorImpl.*(..))")

    public void logAfterException() {

        System.out.println("[AOP异常通知] 方法抛异常了");

    }

  

    /**

     * finally后置通知：不管是否出现异常，都会执行

     */

    @After(value = "execution(* com.bdqn.proxy.CalculatorImpl.*(..))")

    public void logFinally() {

        System.out.println("[AOP后置通知] 方法最终结束了");

    }
 
}
 
 

   3. 配置类方式,开启aspectj注解支持
 

 
@Configuration

@ComponentScan(basePackages = {"com.bdqn"})

  //作用等于 <aop:aspectj-autoproxy /> 配置类上开启 Aspectj注解支持!

  @EnableAspectJAutoProxy

  public class SpringConfig{

  

}
 
 

  4.测试效果
 

 
@SpringJUnitConfig(classes = {SpringConfig.class})

  public class TestAop {

    @Autowired

    Calculator c;

  

    @Test

    public void testCalculator(){

        c.add(10,20);

        System.out.println("----------");

        c.div(10,5);

        System.out.println("----------");

        c.div(10,0);

    }

}
 
 

     5. 输出结果
 

 

 

 6.获取通知细节信息
 

   1.JointPoint接口
 

     需要获取方法签名、传入的实参等信息时，可以在通知方法声明JoinPoint类型的形参。
 

      要点1：JoinPoint 接口通过 getSignature() 方法获取目标方法的签名（方法声明时的完整信息）
 

      要点2：通过目标方法签名对象获取方法名
 

      要点3：通过 JoinPoint 对象获取外界调用目标方法时传入的实参列表组成的数组
 

 
   /**

 * 前置通知

 * @Before注解：声明当前方法是前置通知方法

 * value属性：指定切入点表达式，由切入点表达式控制当前通知方法要作用在哪一个目标方法上

 * 在方法形参位置声明一个JoinPoint类型的参数，Spring就会将这个对象传入根据JoinPoint对象就可以获取目标方法名称、实际参数列表

 */

  @Before(value = "execution(* com.bdqn.proxy.CalculatorImpl.*(..))")

  public void logBefore(JoinPoint joinPoint) {

    // 1.通过JoinPoint对象获取目标方法签名对象

    // 方法的签名：一个方法的全部声明信息

    Signature signature = joinPoint.getSignature();

    // 2.通过方法的签名对象获取目标方法的详细信息

    //获取目标方法名

    String methodName = signature.getName();

    System.out.println("methodName = " + methodName);

    //获取目标方法修饰符

    int modifiers = signature.getModifiers();

    System.out.println("modifiers = " + modifiers);

    //获取目标获取带修饰符的类路径

    String declaringTypeName = signature.getDeclaringTypeName();

    System.out.println("declaringTypeName = " + declaringTypeName);

    // 3.通过JoinPoint对象获取外界调用目标方法时传入的实参列表

    Object[] args = joinPoint.getArgs();

    System.out.println("[AOP前置通知] " + methodName + "方法开始了，参数列表：" + Arrays.toString(args));

}
 
 

   2.方法返回值
 

     在返回通知中，通过@AfterReturning注解的returning属性获取目标方法的返回值！
 

 
/**

 * 正常后置通知：只有切点正常返回，才会执行

 * 在返回通知中获取目标方法返回值分两步：

 *  第一步：在@AfterReturning注解中通过returning属性设置一个名称

 *  第二步：使用returning属性设置的名称在通知方法中声明一个对应的形参

 */

  @AfterReturning(value = "execution(* com.bdqn.proxy.CalculatorImpl.*(..))",returning = "targetMethodReturnValue")

  public void logAfterSuccess(JoinPoint joinPoint, Object targetMethodReturnValue) {

    String methodName = joinPoint.getSignature().getName();

    System.out.println("[AOP返回通知] "+methodName+"方法成功结束了，返回值是：" + targetMethodReturnValue);

}
 
 
 

   3.异常对象捕捉
 

     在异常通知中，通过@AfterThrowing注解的throwing属性获取目标方法抛出的异常对象
 

 
/**

 * 异常通知：只有切点出现异常，才会执行

 * 在异常通知中获取目标方法抛出的异常分两步：

 * 第一步：在@AfterThrowing注解中声明一个throwing属性设定形参名称

 * 第二步：使用throwing属性指定的名称在通知方法声明形参，Spring会将目标方法抛出的异常对象从这里传给我们

 */

  @AfterThrowing(value = "execution(* com.bdqn.proxy.CalculatorImpl.*(..))",throwing = "e")

  public void logAfterException(JoinPoint joinPoint,Throwable e) {

    String methodName = joinPoint.getSignature().getName();

  

    System.out.println("[AOP异常通知] "+methodName+"方法抛异常了，异常类型是：" + e.getClass().getName());

}
 
 
 

 

   4.切点表达式语法
 

     1.切点表达式作用
 

       AOP切点表达式（Pointcut Expression）是一种用于指定切点的语言，它可以通过定义匹配规则，来选择需要被切入的目标对象。
 

 

     2. 切点表达式语法
 

 

 

  5.重用(提取)切点表达式
 

    1. 重用切点表达式优点
 

 
    @Before(value = "execution(* com.bdqn.proxy.CalculatorImpl.*(..))")

    public void logBefore() {

        System.out.println("[AOP前置通知] 方法开始了");

    }

  

    /**

     * 正常后置通知：只有切点正常返回，才会执行

     */

    @AfterReturning(value = "execution(* com.bdqn.proxy.CalculatorImpl.*(..))")

    public void logAfterSuccess() {

        System.out.println("[AOP返回通知] 方法成功返回了");

    }

  

    /**

     * 异常通知：只有切点出现异常，才会执行

     */

    @AfterThrowing(value = "execution(* com.bdqn.proxy.CalculatorImpl.*(..))")

    public void logAfterException() {

        System.out.println("[AOP异常通知] 方法抛异常了");

    }

  

    /**

     * finally后置通知：不管是否出现异常，都会执行

     */

    @After(value = "execution(* com.bdqn.proxy.CalculatorImpl.*(..))")

    public void logFinally() {

        System.out.println("[AOP后置通知] 方法最终结束了");

    }
 
 

  上面案例，是我们之前编写切点表达式的方式，发现， 所有增强方法的切点表达式相同！
 

出现了冗余，如果需要切换也不方便统一维护！
 

我们可以将切点提取，在增强上进行引用即可！
 

 

  2.内部引用
 

     2.1 提取
 

 
/**

 * 提取切点:切入点表达式重用

 */

  @Pointcut("execution(* com.bdqn.proxy.CalculatorImpl.*(..))")

  public void pointcut() {}
 
 

     2.2 同一类引用
 

 
@Before(value = "pointcut()")

  public void logBefore(JoinPoint joinPoint) {
 
 

2.3 不同类中引用
 

 
@Before(value = "com.bdqn.advice.LogAdvice.pointcut()")

  public void logBefore(JoinPoint joinPoint) {
 
 

 

  3.切点统一管理
 

 
@Component
 
public class AtguiguPointCut {
 
   
 
    @Pointcut(value = "execution(public int *..Calculator.sub(int,int))")
 
    public void atguiguGlobalPointCut(){}
 
   
 
    @Pointcut(value = "execution(public int *..Calculator.add(int,int))")
 
    public void atguiguSecondPointCut(){}
 
   
 
    @Pointcut(value = "execution(* *..*Service.*(..))")
 
    public void transactionPointCut(){}
 
}
 
 

 

  6. 环绕通知
 

 环绕通知对应整个 try...catch...finally 结构，包括前面四种通知的所有功能。
 

 
/**

 * 环绕通知=前置+后置通知+异常通知

 * 通过在通知方法形参位置声明ProceedingJoinPoint类型的形参，Spring会将这个类型的对象传给我们

 */

  @Around(value = "pointcut()")

  public Object txArroud(ProceedingJoinPoint joinPoint) {

    // 通过ProceedingJoinPoint对象获取外界调用目标方法时传入的实参数组

    Object[] args = joinPoint.getArgs();

    // 通过ProceedingJoinPoint对象获取目标方法的签名对象

    Signature signature = joinPoint.getSignature();

    // 通过签名对象获取目标方法的方法名

    String methodName = signature.getName();

    // 声明变量用来存储目标方法的返回值

    Object result = null;

    try {

        // 在目标方法执行前：开启事务（模拟）

        System.out.println("[AOP 环绕通知] 开启事务，方法名：" + methodName + "，参数列表：" + Arrays.asList(args));

        // 过ProceedingJoinPoint对象调用目标方法目标方法的返回值一定要返回给外界调用者

        result = joinPoint.proceed(args);

        // 在目标方法成功返回后：提交事务（模拟）

        System.out.println("[AOP 环绕通知] 提交事务，方法名：" + methodName + "，方法返回值：" + result);

    }catch (Throwable e){

        // 在目标方法抛异常后：回滚事务（模拟）

        System.out.println("[AOP 环绕通知] 回滚事务，方法名：" + methodName + "，异常：" + e.getClass().getName());

    }finally {

        // 在目标方法最终结束后：释放数据库连接

        System.out.println("[AOP 环绕通知] 释放数据库连接，方法名：" + methodName);

    }

    return result;

}
 
 

 

7. Spring AOP的jdk 和Cglib动态代理生效
 

   在目标类没有实现任何接口的情况下，Spring会自动使用cglib技术实现代理。
 

   总结：
 

 
a.  如果目标类有接口,选择使用jdk动态代理
 
b.  如果目标类没有接口,选择cglib动态代理
 
c.  如果有接口,接口接值
 
d.  如果没有接口,类进行接值
 
 

 

8. 注解实现总结
 

 

 

 9.Spring Aop基于XML方式实现 (了解)
 

   1. 准备工作
 

 
      加入依赖：和基于注解的 AOP 时一样
 
      准备代码:把测试基于注解功能时的Java类复制到新module中，去除所有注解。
 
 

    2. 配置Spring配置文件
 

 
<?xml version="1.0" encoding="UTF-8"?>

  <beans xmlns="http://www.springframework.org/schema/beans"

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

       xmlns:context="http://www.springframework.org/schema/context"

       xmlns:aop="http://www.springframework.org/schema/aop"

       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 开启aspectj框架注解支持-->

    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

  

    <!-- 配置目标类的bean -->

    <bean id="calculator" class="com.bdqn.proxy.CalculatorImpl"/>

    <!-- 配置切面类的bean -->

    <bean id="logAdvice" class="com.bdqn.advice.LogAdvice"/>

    <!-- 配置AOP -->

    <aop:config>

        <!-- 配置切入点表达式 -->

        <aop:pointcut id="logPointCut" expression="execution(* com.bdqn.proxy.CalculatorImpl.*(..))"/>

        <!-- aop:aspect标签：配置切面  ref属性：关联切面类的bean -->

        <aop:aspect ref="logAdvice">

            <!-- aop:before标签：配置前置通知 -->

            <!-- method属性：指定前置通知的方法名 -->

            <!-- pointcut-ref属性：引用切入点表达式 -->

            <aop:before method="logBefore" pointcut-ref="logPointCut"/>

            <!-- aop:after-returning标签：配置返回通知 -->

            <!-- returning属性：指定通知方法中用来接收目标方法返回值的参数名 -->

            <aop:after-returning method="logAfterSuccess" pointcut-ref="logPointCut" returning="targetMethodReturnValue"/>

            <!-- aop:after-throwing标签：配置异常通知 -->

            <!-- throwing属性：指定通知方法中用来接收目标方法抛出异常的异常对象的参数名 -->

            <aop:after-throwing method="logAfterException" pointcut-ref="logPointCut" throwing="e"/>

            <!-- aop:after标签：配置后置通知 -->

            <aop:after method="logFinally" pointcut-ref="logPointCut"/>

            <!-- aop:around标签：配置环绕通知 -->

            <aop:around method="logArroud" pointcut-ref="logPointCut"/>

        </aop:aspect>

  

    </aop:config>

  

</beans>
 
 

    3. 测试
 

 
@SpringJUnitConfig(locations = "classpath:applicationContext.xml")

  public class TestAop {

    @Autowired

    Calculator c;

  

    @Test

    public void testCalculator(){

        c.add(10,20);

        System.out.println("----------");

        c.div(10,0);

    }

}
 
 

 


                

        

    

  



    



            

  



          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值