Spring整合AspectJ基于注解实现AOP

怼烎@ 2022-02-05 01:57 375阅读 0赞

### 文章目录 ###

*   *  Spring整合AspectJ基于注解实现AOP
     *   *  替换bean
         *  替换AOP
         *  声明切面
         *  替换前置通知
         *  替换公共切入点
         *  替换后置
         *  替换环绕
         *  替换抛出异常
     *  AOP注解总结

## Spring整合AspectJ基于注解实现AOP ##

我们把上一篇Spring整合AspectJ基于XML实现AOP进行改造成基于注解实现。

首先是pom文件

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.cc.study</groupId>
        <artifactId>spring-study</artifactId>
        <version>1.0-SNAPSHOT</version>
    
    
        <dependencies>
            
            
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>4.2.0.RELEASE</version>
            </dependency>
            
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-beans</artifactId>
                <version>4.2.0.RELEASE</version>
            </dependency>
            
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-core</artifactId>
                <version>4.2.0.RELEASE</version>
            </dependency>
            
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-expression</artifactId>
                <version>4.2.0.RELEASE</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-aop</artifactId>
                <version>4.2.0.RELEASE</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-aspects</artifactId>
                <version>4.2.0.RELEASE</version>
            </dependency>
            
            <dependency>
                <groupId>org.aspectj</groupId>
                <artifactId>aspectjweaver</artifactId>
                <version>1.9.3</version>
            </dependency>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.7</version>
            </dependency>
        </dependencies>
        <build>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <configuration>
                        <source>1.8</source>
                        <target>1.8</target>
                    </configuration>
                </plugin>
            </plugins>
        </build>
    
    </project>

### 替换bean ###

<bean id="userServiceId" class="com.cc.study.aspectj.UserServiceImpl"></bean>
        
        <bean id="myAspectId" class="com.cc.study.aspectj.MyAspect"></bean>

*  MyAspect

import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.springframework.stereotype.Component;
    
    /**
     * 切面类，含有多个通知
     */
    @Component
    public class MyAspect {
    
        public void myBefore(JoinPoint joinPoint){
    		System.out.println("前置通知 ： " + joinPoint.getSignature().getName());
    	}
    	
    	public void myAfterReturning(JoinPoint joinPoint,Object ret){
    		System.out.println("后置通知 ： " + joinPoint.getSignature().getName() + " , -->" + ret);
    	}
    	
    	public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable{
    		System.out.println("前");
    		//手动执行目标方法
    		Object obj = joinPoint.proceed();
    		
    		System.out.println("后");
    		return obj;
    	}
    	
    	public void myAfterThrowing(JoinPoint joinPoint,Throwable e){
    		System.out.println("抛出异常通知 ： " + e.getMessage());
    	}
    	
    	public void myAfter(JoinPoint joinPoint){
    		System.out.println("最终通知");
    	}
    
    }

*  UserServiceImpl

@Service("userServiceId")
    public class UserServiceImpl implements UserService {
        @Override
        public void addUser() {
            System.out.println("addUser()");
        }
    
        @Override
        public void updateUser() {
    //        int i = 1 / 0;
            System.out.println("updateUser()");
        }
    
        @Override
        public void deleteUser() {
            System.out.println("deleteUser()");
        }
    }

然后我们配置要开启扫描注解

### 替换AOP ###

*  必须进行aspectj 自动代理

### 声明切面 ###

原先我们是在xml中进行配置

现在我们利用注解@Aspect进行配置

/**
     * 切面类，含有多个通知
     */
    @Component
    @Aspect
    public class MyAspect {
    
        public void myBefore(JoinPoint joinPoint){
    		System.out.println("前置通知 ： " + joinPoint.getSignature().getName());
    	}
    	
    	public void myAfterReturning(JoinPoint joinPoint,Object ret){
    		System.out.println("后置通知 ： " + joinPoint.getSignature().getName() + " , -->" + ret);
    	}
    	
    	public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable{
    		System.out.println("前");
    		//手动执行目标方法
    		Object obj = joinPoint.proceed();
    		
    		System.out.println("后");
    		return obj;
    	}
    	
    	public void myAfterThrowing(JoinPoint joinPoint,Throwable e){
    		System.out.println("抛出异常通知 ： " + e.getMessage());
    	}
    	
    	public void myAfter(JoinPoint joinPoint){
    		System.out.println("最终通知");
    	}
    
    }

### 替换前置通知 ###

之前我们在XML中可以这么配置

<aop:before method="myBefore" pointcut="execution(* com.cc.study.aspectj.UserServiceImpl.*(..))"/>

或者

<aop:pointcut expression="execution(* com.cc.study.aspectj.UserServiceImpl.*(..))" id="myPointCut"/>
    <aop:before method="myBefore" pointcut-ref="myPointCut"/>

现在我们利用注解@Before配置MyAspect类

import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    import org.springframework.stereotype.Component;
    
    /**
     * 切面类，含有多个通知
     */
    @Component
    @Aspect
    public class MyAspect {
    	//切入点当前有效
    	@Before("execution(* com.cc.study.aspectj.annotation.UserServiceImpl.*(..))")
        public void myBefore(JoinPoint joinPoint){
    		System.out.println("前置通知 ： " + joinPoint.getSignature().getName());
    	}
    	
    	public void myAfterReturning(JoinPoint joinPoint,Object ret){
    		System.out.println("后置通知 ： " + joinPoint.getSignature().getName() + " , -->" + ret);
    	}
    	
    	public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable{
    		System.out.println("前");
    		//手动执行目标方法
    		Object obj = joinPoint.proceed();
    		
    		System.out.println("后");
    		return obj;
    	}
    	
    	public void myAfterThrowing(JoinPoint joinPoint,Throwable e){
    		System.out.println("抛出异常通知 ： " + e.getMessage());
    	}
    	
    	public void myAfter(JoinPoint joinPoint){
    		System.out.println("最终通知");
    	}
    
    }

测试

@Test
        public void demo01(){
            String xmlPath = "aspectj2.xml";
            AbstractApplicationContext applicationContext = new ClassPathXmlApplicationContext(xmlPath);
            UserService userService = (UserService) applicationContext.getBean("userServiceId");
            userService.addUser();
            userService.updateUser();
            userService.deleteUser();
        }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Nja2V2aW5jeWg_size_16_color_FFFFFF_t_70]

### 替换公共切入点 ###

相当于我们在XML中配置的：

<aop:pointcut expression="execution(* com.cc.study.aspectj.UserServiceImpl.*(..))" id="myPointCut"/>
    <aop:before method="myBefore" pointcut-ref="myPointCut"/>

替代`<aop:pointcut expression="execution(* com.cc.study.aspectj.UserServiceImpl.*(..))" id="myPointCut"/>`这一部分

我们利用注解@Pointcut进行替换

import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    import org.aspectj.lang.annotation.Pointcut;
    import org.springframework.stereotype.Component;
    
    /**
     * 切面类，含有多个通知
     */
    @Component
    @Aspect
    public class MyAspect {
    	//切入点当前有效
    	@Before("execution(* com.cc.study.aspectj.annotation.UserServiceImpl.*(..))")
        public void myBefore(JoinPoint joinPoint){
    		System.out.println("前置通知 ： " + joinPoint.getSignature().getName());
    	}
    	
    	public void myAfterReturning(JoinPoint joinPoint,Object ret){
    		System.out.println("后置通知 ： " + joinPoint.getSignature().getName() + " , -->" + ret);
    	}
    	
    	public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable{
    		System.out.println("前");
    		//手动执行目标方法
    		Object obj = joinPoint.proceed();
    		
    		System.out.println("后");
    		return obj;
    	}
    	
    	public void myAfterThrowing(JoinPoint joinPoint,Throwable e){
    		System.out.println("抛出异常通知 ： " + e.getMessage());
    	}
    	
    	public void myAfter(JoinPoint joinPoint){
    		System.out.println("最终通知");
    	}
    
    
    	//声明公共切入点
    	@Pointcut("execution(* com.cc.study.aspectj.annotation.UserServiceImpl.*(..))")
    	private void myPointCut(){
    	}
    
    }

### 替换后置 ###

之前我们在xml中是如下配置

<aop:after-returning method="myAfterReturning" pointcut-ref="myPointCut" returning="ret" />

然后我们可以利用如下注解进行替换，这里使用value=“myPointCut()”,来指定我们上面配置的公共切入点

@AfterReturning(value="myPointCut()" ,returning="ret")

import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.AfterReturning;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    import org.aspectj.lang.annotation.Pointcut;
    import org.springframework.stereotype.Component;
    
    /**
     * 切面类，含有多个通知
     */
    @Component
    @Aspect
    public class MyAspect {
    	//切入点当前有效
    	@Before("execution(* com.cc.study.aspectj.annotation.UserServiceImpl.*(..))")
        public void myBefore(JoinPoint joinPoint){
    		System.out.println("前置通知 ： " + joinPoint.getSignature().getName());
    	}
    
    	@AfterReturning(value="myPointCut()" ,returning="ret")
    	public void myAfterReturning(JoinPoint joinPoint,Object ret){
    		System.out.println("后置通知 ： " + joinPoint.getSignature().getName() + " , -->" + ret);
    	}
    	
    	public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable{
    		System.out.println("前");
    		//手动执行目标方法
    		Object obj = joinPoint.proceed();
    		
    		System.out.println("后");
    		return obj;
    	}
    	
    	public void myAfterThrowing(JoinPoint joinPoint,Throwable e){
    		System.out.println("抛出异常通知 ： " + e.getMessage());
    	}
    	
    	public void myAfter(JoinPoint joinPoint){
    		System.out.println("最终通知");
    	}
    
    
    	//声明公共切入点
    	@Pointcut("execution(* com.cc.study.aspectj.annotation.UserServiceImpl.*(..))")
    	private void myPointCut(){
    	}
    
    }

测试：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Nja2V2aW5jeWg_size_16_color_FFFFFF_t_70 1]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Nja2V2aW5jeWg_size_16_color_FFFFFF_t_70 2]

### 替换环绕 ###

<aop:around method="myAround" pointcut-ref="myPointCut"/>

可以利用注解@Around(value = “myPointCut()”)进行替换

/**
     * 切面类，含有多个通知
     */
    @Component
    @Aspect
    public class MyAspect {
    	//切入点当前有效
    //	@Before("execution(* com.cc.study.aspectj.annotation.UserServiceImpl.*(..))")
        public void myBefore(JoinPoint joinPoint){
    		System.out.println("前置通知 ： " + joinPoint.getSignature().getName());
    	}
    
    	//@AfterReturning(value="myPointCut()" ,returning="ret")
    	public void myAfterReturning(JoinPoint joinPoint,Object ret){
    		System.out.println("后置通知 ： " + joinPoint.getSignature().getName() + " , -->" + ret);
    	}
    	@Around(value = "myPointCut()")
    	public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable{
    		System.out.println("前");
    		//手动执行目标方法
    		Object obj = joinPoint.proceed();
    		
    		System.out.println("后");
    		return obj;
    	}
    	
    	public void myAfterThrowing(JoinPoint joinPoint,Throwable e){
    		System.out.println("抛出异常通知 ： " + e.getMessage());
    	}
    	
    	public void myAfter(JoinPoint joinPoint){
    		System.out.println("最终通知");
    	}
    
    
    	//声明公共切入点
    	@Pointcut("execution(* com.cc.study.aspectj.annotation.UserServiceImpl.*(..))")
    	private void myPointCut(){
    	}
    
    }

把其他的注解进行注释掉测试  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Nja2V2aW5jeWg_size_16_color_FFFFFF_t_70 3]

### 替换抛出异常 ###

<aop:after-throwing method="myAfterThrowing" pointcut="execution(*com.cc.study.aspectj.annotation.UserServiceImpl.*(..))" throwing="e"/>

利用注解@AfterThrowing进行替换

import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.*;
    import org.springframework.stereotype.Component;
    
    /**
     * 切面类，含有多个通知
     */
    @Component
    @Aspect
    public class MyAspect {
    	//切入点当前有效
    //	@Before("execution(* com.cc.study.aspectj.annotation.UserServiceImpl.*(..))")
        public void myBefore(JoinPoint joinPoint){
    		System.out.println("前置通知 ： " + joinPoint.getSignature().getName());
    	}
    
    //	@AfterReturning(value="myPointCut()" ,returning="ret")
    	public void myAfterReturning(JoinPoint joinPoint,Object ret){
    		System.out.println("后置通知 ： " + joinPoint.getSignature().getName() + " , -->" + ret);
    	}
    //	@Around(value = "myPointCut()")
    	public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable{
    		System.out.println("前");
    		//手动执行目标方法
    		Object obj = joinPoint.proceed();
    		
    		System.out.println("后");
    		return obj;
    	}
    	@AfterThrowing(value="execution(* com.cc.study.aspectj.annotation.UserServiceImpl.*(..))" ,throwing="e")
    	public void myAfterThrowing(JoinPoint joinPoint,Throwable e){
    		System.out.println("抛出异常通知 ： " + e.getMessage());
    	}
    	
    	public void myAfter(JoinPoint joinPoint){
    		System.out.println("最终通知");
    	}
    
    
    	//声明公共切入点
    	@Pointcut("execution(* com.cc.study.aspectj.annotation.UserServiceImpl.*(..))")
    	private void myPointCut(){
    	}
    
    }

测试

@Override
        public void updateUser() {
            int i = 1 / 0;
            System.out.println("updateUser()");
        }

![在这里插入代码片][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Nja2V2aW5jeWg_size_16_color_FFFFFF_t_70 4]

## AOP注解总结 ##

*  @Aspect 声明切面，修饰切面类，从而获得 通知。
 *  通知
    
     *  @Before 前置
     *  @AfterReturning 后置
     *  @Around 环绕
     *  @AfterThrowing 抛出异常
     *  @After 最终
 *  切入点  
    @PointCut ，修饰方法 private void xxx()\{\} 之后通过“方法名”获得切入点引用

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Nja2V2aW5jeWg_size_16_color_FFFFFF_t_70]: /images/20220205/4a5a41d432914f2db29b9eca3d64a686.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Nja2V2aW5jeWg_size_16_color_FFFFFF_t_70 1]: /images/20220205/2a5c4ff8bb274fddbd952efc8c086691.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Nja2V2aW5jeWg_size_16_color_FFFFFF_t_70 2]: /images/20220205/5fb830e9662b4233bbc3f4225fe2c77a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Nja2V2aW5jeWg_size_16_color_FFFFFF_t_70 3]: /images/20220205/03cfb0c490634a5cb0916d792c51dd14.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Nja2V2aW5jeWg_size_16_color_FFFFFF_t_70 4]: /images/20220205/4ac0e2b54f6441809bf832938851d806.png