Spring AOP技术（基于AspectJ）的Annotation开发

我会带着你远行 2022-07-12 02:24 217阅读 0赞

# Spring AOP技术（基于AspectJ）的Annotation开发 #

@(Spring)\[aop, spring, xml, Spring, annotation, aspectJ\]

*  Spring AOP技术基于AspectJ的Annotation开发
    
     *  Spring AOP的Annotation的开发
        
         *  Spring的基于AspectJ的AOP的Annotation开发
            
             *  第一步引入jar包
             *  第二步创建配置文件
             *  第三步创建需增强包和类
             *  第四步将类交给Spring管理
             *  第五步编写测试
             *  第六步编写切面类和通知
             *  第七步 配置切面类
             *  第八步开启AOP的自动代理
             *  第九步通过注解实现AOP
             *  第九步执行测试
         *  通知类型
            
             *  前置通知
                
                 *  配置切面和通知
                 *  单元测试
             *  后置通知
                
                 *  配置切面和通知
                 *  单元测试
             *  环绕通知
                
                 *  配置切面和通知
                 *  单元测试
             *  异常抛出通知
                
                 *  配置切面和通知
                 *  单元测试
             *  最终通知
                
                 *  配置切面和通知
                 *  单元测试
         *  切入点的注解
         *  Spring AOP小项目

## Spring AOP的Annotation的开发 ##

### Spring的基于AspectJ的AOP的Annotation开发 ###

#### 第一步引入jar包 ####

![这里写图片描述][SouthEast]

#### 第二步创建配置文件 ####

*  引入AOP的约束

#### 第三步创建需增强包和类 ####

*  创建接口

package com.pc.aop.dao;
    
    /** * 客户持久层接口 * * @author Switch * @data 2016年11月23日 * @version V1.0 */
    public interface CustomerDao { 
        /** * 保存用户 */
        public void save();
    }

*  创建实现类

package com.pc.aop.dao.impl;
    
    import com.pc.aop.dao.CustomerDao;
    
    /** * 用户持久层实现类 * * @author Switch * @data 2016年11月23日 * @version V1.0 */
    public class CustomerDaoImpl implements CustomerDao { 
        @Override
        public void save() {
            System.out.println("保存用户了。。。");
        }
    }

#### 第四步将类交给Spring管理 ####

#### 第五步编写测试 ####

package com.pc.test;
    
    import javax.annotation.Resource;
    
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.test.context.ContextConfiguration;
    import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
    
    import com.pc.aop.dao.CustomerDao;
    
    /** * 面向切面编程测试类 * * @author Switch * @data 2016年11月23日 * @version V1.0 */
    // 配置Spring单元测试环境
    @RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration("classpath:applicationContext.xml")
    public class SpringAOPTest { 
        // 注入依赖
        @Resource(name = "customerDao")
        private CustomerDao customerDao;
    
        // 测试Spring单元测试集成
        @Test
        public void testSpring() {
            customerDao.save();
        }
    }

输出

保存用户了。。。

PS：这时候没用使用AOP进行任何增强

#### 第六步编写切面类和通知 ####

package com.pc.aop.advice;
    import org.aspectj.lang.ProceedingJoinPoint;
    /** * 切面类 * * @author Switch * @data 2016年11月23日 * @version V1.0 */
    public class MyAspect { 
        // 通知：校验权限
        public void check() {
            System.out.println("校验权限。。。。。。");
        }
    }

#### 第七步 配置切面类 ####

<bean id="myAspect" class="com.pc.aop.advice.MyAspect"/>

#### 第八步开启AOP的自动代理 ####

<aop:aspectj-autoproxy/>

#### 第九步通过注解实现AOP ####

// 配置了自动AOP代理的，需要在类上配置该注解，不然无法被识别为切面
    @Aspect
    public class MyAspect { 
        // 前置通知
        @Before("execution(* com.pc.aop.dao.impl.CustomerDaoImpl.save(..))")
        // 通知：校验权限
        public void check() {
            System.out.println("校验权限。。。。。。");
        }
    }

#### 第九步执行测试 ####

输出

校验权限。。。。。。
    保存用户了。。。

### 通知类型 ###

![这里写图片描述][SouthEast 1]

PS：因为在XML中已经给出了各个通知的完整测试代码，所以这里只给出通知代码和测试代码及其结果，如果想查看其他代码，请查找《Spring AOP技术（基于AspectJ）的XML开发》

#### 前置通知 ####

前置通知：在目标方法执行之前完成的增强。获得切入点信息。  
注解：`@Before`  
PS：接入点信息，其他类型的增强也可以通过这种方法使用。

##### 配置切面和通知 #####

// 配置了自动AOP代理的，需要在类上配置该注解，不然无法被识别为切面
    @Aspect
    public class MyAspect { 
        // 前置通知
        @Before("execution(* com.pc.aop.dao.impl.CustomerDaoImpl.save(..))")
        // 通知：校验权限
        public void check(JoinPoint joinPoint) {
            System.out.println("校验权限。。。。。。");
            // 输出接入点信息
            System.out.println(joinPoint.toString());
        }
    }

##### 单元测试 #####

@RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration("classpath:applicationContext.xml")
    public class SpringAOPTest { 
        // 注入依赖
        @Resource(name = "customerDao")
        private CustomerDao customerDao;
        // 测试前置通知
        @Test
        public void testBefore() {
            customerDao.save();
        }
    }

输出

校验权限。。。。。。
    execution(void com.pc.aop.dao.CustomerDao.save())
    保存用户了。。。

#### 后置通知 ####

后置通知：在目标方法执行之后完成的增强。获得方法的返回值。  
注解：`@AfterReturning`

##### 配置切面和通知 #####

// 配置了自动AOP代理的，需要在类上配置该注解，不然无法被识别为切面
    @Aspect
    public class MyAspect { 
        // 后置通知
        @AfterReturning(value = "execution(* com.pc.aop.dao.impl.CustomerDaoImpl.delete(..))", returning = "retVal")
        // 通知：打印日志
        public void printLog(String retVal) {
            System.out.println("打印日志。。。。。");
            System.out.println("返回值为：" + retVal);
        }
    }

##### 单元测试 #####

@RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration("classpath:applicationContext.xml")
    public class SpringAOPTest { 
        // 注入依赖
        @Resource(name = "customerDao")
        private CustomerDao customerDao;
        // 测试后置通知
        @Test
        public void testAfterRunning() {
            String delete = customerDao.delete();
            System.out.println(delete);
        }
    }

输出

删除用户了。。。
    打印日志。。。。。
    返回值为：delete
    delete

#### 环绕通知 ####

环绕通知：在目标方法执行前和执行后完成的增强。阻止目标方法的执行，获得方法参数。  
注解：`@Around`

##### 配置切面和通知 #####

// 配置了自动AOP代理的，需要在类上配置该注解，不然无法被识别为切面
    @Aspect
    public class MyAspect { 
        // 环绕通知
        @Around("execution(* com.pc.aop.dao.impl.CustomerDaoImpl.update(..))")
        // 通知：计算方法耗时
        public void calTime(ProceedingJoinPoint joinPoint) throws Throwable {
            System.out.println("方法执行前。。。。。。");
            // 打印参数
            System.out.println("参数为：" + joinPoint.getArgs()[0]);
            // 执行目标方法
            joinPoint.proceed();
            System.out.println("方法执行后。。。。。。");
        }
    }

##### 单元测试 #####

@RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration("classpath:applicationContext.xml")
    public class SpringAOPTest { 
        // 注入依赖
        @Resource(name = "customerDao")
        private CustomerDao customerDao;
        // 测试环绕通知
        @Test
        public void testAround() {
            customerDao.update(6166);
        }
    }

输出

方法执行前。。。。。。
    参数为：6166
    更新用户了。。。
    方法执行后。。。。。。

#### 异常抛出通知 ####

异常抛出通知：在目标方法执行出现异常的时候完成的增强。获得异常的信息。  
注解：`@AfterThrowing`

##### 配置切面和通知 #####

// 配置了自动AOP代理的，需要在类上配置该注解，不然无法被识别为切面
    @Aspect
    public class MyAspect { 
        // 异常通知
        @AfterThrowing(value = "execution(* com.pc.aop.dao.impl.CustomerDaoImpl.find(..))", throwing = "ex")
        // 通知：异常处理
        public void throwHandler(Throwable ex) {
            System.out.println("异常处理。。。。。。" + ex.getMessage());
        }
    }

##### 单元测试 #####

@RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration("classpath:applicationContext.xml")
    public class SpringAOPTest { 
        // 注入依赖
        @Resource(name = "customerDao")
        private CustomerDao customerDao;
        // 测试异常通知
        @Test
        public void testAfterThrowing() {
            customerDao.find();
        }
    }

输出

查询用户了。。。
    异常处理。。。。。。/ by zero

#### 最终通知 ####

最终通知：无论目标方法是否出现异常总是执行的增强。  
注解：`@After`

PS：该案例和异常测试案例对同一个target进行增强。

##### 配置切面和通知 #####

// 配置了自动AOP代理的，需要在类上配置该注解，不然无法被识别为切面
    @Aspect
    public class MyAspect { 
        // 最终通知
        @After("execution(* com.pc.aop.dao.impl.CustomerDaoImpl.find(..))")
        // 通知：关闭资源
        public void close() {
            System.out.println("关闭资源。。。。。。");
        }
    }

##### 单元测试 #####

@RunWith(SpringJUnit4ClassRunner.class)
    @ContextConfiguration("classpath:applicationContext.xml")
    public class SpringAOPTest { 
        // 注入依赖
        @Resource(name = "customerDao")
        private CustomerDao customerDao;
        // 测试最终通知
        @Test
        public void testFinally() {
            customerDao.find();
        }
    }

输出

查询用户了。。。
    关闭资源。。。。。。
    异常处理。。。。。。/ by zero

### 切入点的注解 ###

在上面的案例中，都是在通知上面直接定义切入点。这样有一个比较麻烦的问题，也就是如果我们需要修改多个通知相同的切入点，那么需要改大量的切入点代码。

上面的问题，可以通过使用切入点注解`@Pointcut`解决。

案例：

package com.pc.aop.advice;
    
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.After;
    import org.aspectj.lang.annotation.AfterReturning;
    import org.aspectj.lang.annotation.AfterThrowing;
    import org.aspectj.lang.annotation.Around;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    import org.aspectj.lang.annotation.Pointcut;
    
    /** * 切面类 * * @author Switch * @data 2016年11月23日 * @version V1.0 */
    // 配置了自动AOP代理的，需要在类上配置该注解，不然无法被识别为切面
    @Aspect
    public class MyAspect { 
        // 异常通知
        @AfterThrowing(value = "com.pc.aop.advice.MyAspect.pointcut1()", throwing = "ex")
        // 通知：异常处理
        public void throwHandler(Throwable ex) {
            System.out.println("异常处理。。。。。。" + ex.getMessage());
        }
    
        // 最终通知
        @After("com.pc.aop.advice.MyAspect.pointcut1()")
        // 通知：关闭资源
        public void close() {
            System.out.println("关闭资源。。。。。。");
        }
    
        // 配置切入点
        @Pointcut("execution(* com.pc.aop.dao.impl.CustomerDaoImpl.find(..))")
        public void pointcut1() {}
    }

PS：切入点的注解需要定义在方法上，切入点方法一般是无意义的。如果需要使用切入点方法，只需要在通知声明中写入`包名.类型.方法名()`，如果通知和切入点在一个类中，那么也可以直接写入`方法名()`

### Spring AOP小项目 ###

GitHub：[Spring AOP小项目][Spring AOP]  
GitHub：[MyStore-netease][]

[SouthEast]: /images/20220711/0a150dd4350e4965b7bc490a36d8f561.png
[SouthEast 1]: /images/20220711/9e7e9f206a7e439c8ff7a1f118f8b132.png
[Spring AOP]: https://github.com/Switch-vov/SpringAopTest
[MyStore-netease]: https://github.com/Switch-vov/MyStore-netease