spring AOP总结

一、概念

　　AOP面向切面编程，一种编程范式
二、作用

　　在不改动原始设计（原代码不改动）的基础上为方法进行功能增强（即增加功能）
三、核心概念

　　1、代理（Proxy）：SpringAOP的核心本质是采用代理模式实现的
　　2、连接点（JoinPoint）：在SpringAOP中，理解为任意方法的执行
　　3、切入点（Pointcut）：匹配连接点的式子，也是具有共性功能的方法描述
　　4、通知（Advice）：若干个方法的共性功能，在切入点处执行，最终体现为一个方法
　　5、切面（Aspect）：描述通知与切入点的对应关系
　　6、目标对象（Target）：被代理的原始对象成为目标对象
四、快速开始

　　1、导入相关依赖
　　由于导入spring-context时会自动导入spring的AOP包所以，这里只用导入aspectjweaver即可。
　　在pom.xml文件中导入
 

1.     <dependencies><br> 　　
2.         <dependency>
3.             <groupId>org.springframework</groupId>
4.             <artifactId>spring-context</artifactId>
5.             <version>5.3.29</version>
6.         </dependency><br>   
7.         <dependency>
8.             <groupId>org.aspectj</groupId>
9.             <artifactId>aspectjweaver</artifactId>
10.             <version>1.9.19</version>
11.         </dependency>
12.     </dependencies>

复制代码

 
　　2、定义dao接口与实现类
　　在dao下面创建BookDao接口类文件

1. public interface BookDao {
2.     public void save();
3.     public void update();
4. }

复制代码

　　在dao下面创建impl文件夹，里面创建BookDao的实现类BookDaoImpl

1. package com.itheima.dao.impl;
3. import com.itheima.dao.BookDao;
4. import org.springframework.stereotype.Repository;
6. @Repository
7. public class BookDaoImpl implements BookDao {
8.     public void save() {
9.         System.out.println(System.currentTimeMillis());
10.         System.out.println("book dao save ...");
11.     }
12.     public void update(){
13.         System.out.println("book dao update ...");
14.     }
15. }

复制代码

　　3、定义通知类，制作通知方法
　　创建aop文件夹，并在下面创建类MyAdvice。

1. package com.itheima.aop;
3. import org.springframework.stereotype.Component;
5. @Component
6. public class MyAdvice {
7.     public void method() {
8.         System.out.println(System.currentTimeMillis());
9.         System.out.println("进行增强功能");
10.     }
11. }

复制代码

　　4、定义切入点表达式、配置切面（绑定切入点与通知关系）

1. package com.itheima.aop;<br><br>import org.aspectj.lang.annotation.Aspect;<br>import org.aspectj.lang.annotation.Before;<br>import org.aspectj.lang.annotation.Pointcut;<br>import org.springframework.stereotype.Component;<br><br>@Component<br>@Aspect<br>public class MyAdvice {<br>    //设置切入点，@Pointcut注解要求配置在方法上方<br>    @Pointcut("execution(void com.itheima.dao.BookDao.update())")<br>    private void pt(){}<br>    //设置在切入点pt()的前面运行当前操作(前置通知)<br>    @Before("pt()")<br>    public void method() {<br>        System.out.println(System.currentTimeMillis());<br>        System.out.println("进行增强功能");<br>    }<br>}

复制代码

　　5、在配置类中进行Spring注解包扫描和开启AOP功能　　
　　创建config文件夹，创建Spring的配置文件。

1. package com.itheima.config;
3. import org.springframework.context.annotation.ComponentScan;
4. import org.springframework.context.annotation.Configuration;
5. import org.springframework.context.annotation.EnableAspectJAutoProxy;
7. // 告知spring这是个配置类
8. @Configuration
9. // 扫描指定包
10. @ComponentScan(basePackages = {"com.itheima"})
11. // 开启aop,告知spring开启使用注解的方式开启aop
12. @EnableAspectJAutoProxy
13. public class SpringConfig {
15. }

复制代码

　　6、创建启动文件
　　在项目目录下创建启动类文件，App文件

1. package com.itheima;
3. import com.itheima.config.SpringConfig;
4. import com.itheima.dao.BookDao;
5. import org.springframework.context.annotation.AnnotationConfigApplicationContext;
7. public class App {
8.     public static void main(String[] args) {
9.         // 1. 创建容器对象, 传入配置类
10.         AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
11.         // 2. 从容器中获取对象
12.         BookDao bookDao = context.getBean(BookDao.class);
13.         // 3. 执行方法
14. //        bookDao.save();
15.         bookDao.update();
16.     }
17. }

复制代码

　　7、最终项目目录结构

 
五、切入点表达式

　　1、切入点：要进行增强的方法
　　2、切入点表达式：要进行增强的方法的描述方式
　　　　切入点表达式标准格式：动作关键字（访问修饰符   返回值   包名.类/接口名.方法名（参数）异常名）

1. execution(* com.testweb.service.*Service.*(..))

复制代码

　　切入点表达式描述通配符
　　　　作用：用于快速描述，范围描述
　　　　* ：匹配任意符号（常用）
　　　　..：匹配多个连续的任意符号（常用）
　　　　+：匹配子类型
　　切入点表达式书写技巧
　　　　1、按标准规范开发
　　　　2、查询操作的返回值建议使用*匹配
　　　　3、减少使用 .. 的形式描述包
　　　　4、对接口进行描述，使用 * 表示模块名，例如UserService的匹配描述为 *Service 
　　　　5、方法名书写保留动词，例如get，使用 * 表示名词，例如getById匹配描述为 getBy*
　　　　6、参数根据实际情况灵活调整
 六、通知类型

　　1、通知类型
　　　　1、前置通知
　　　　2、后置通知
　　　　3、环绕通知（重点）
　　　　　　*  环绕通知依赖形参ProceedingJoinPoint才能实现对原始方法的调用
　　　　　　*  环绕通知可以隔离原始方法的调用执行
　　　　　　*  环绕通知返回值设置为object类型
　　　　　　*  环绕通知中可以对原始方法调用过程中出现的异常进行处理
　　　　4、返回后通知
　　　　5、抛出异常后通知
　　2、AOP通知获取数据
　　　　1、获取切入点方法的参数
　　　　　　*  JoinPoint：适用于前置（@Before）、后置（@after）、返回后（@AfterReturning）、抛出异常后通知(@AfterThrowing)

1. package com.itheima.aop;
3. import org.aspectj.lang.JoinPoint;
4. import org.aspectj.lang.annotation.Aspect;
5. import org.aspectj.lang.annotation.Before;
6. import org.aspectj.lang.annotation.Pointcut;
7. import org.springframework.stereotype.Component;
9. @Component
10. @Aspect
11. public class MyAdvice {
12.     //设置切入点，@Pointcut注解要求配置在方法上方
13.     @Pointcut("execution(* com.itheima.dao.BookDao.findName(..))")
14.     private void pt(){}
15.     //设置在切入点pt()的前面运行当前操作(前置通知)
16.     @Before("pt()")
17.     public void method(JoinPoint jp) {
18.         // 获取参数
19.         for (Object o : jp.getArgs()) {
20.             System.out.println(o);
21.         }
22.         System.out.println(System.currentTimeMillis());
23.         System.out.println("进行增强功能");
24.     }
25. }

复制代码

　　　　　　* ProceedJointPoint：适用于环绕通知

1. package com.itheima.aop;
3. import org.aspectj.lang.ProceedingJoinPoint;
4. import org.aspectj.lang.annotation.*;
5. import org.springframework.stereotype.Component;
7. @Component
8. @Aspect
9. public class MyAdvice {
10.     //设置切入点，@Pointcut注解要求配置在方法上方
11.     @Pointcut("execution(* com.itheima.dao.BookDao.findName(..))")
12.     private void pt() {
13.     }
15.     //设置在切入点pt()的前面运行当前操作(前置通知)
16.     @Around("pt()")
17.     public Object method(ProceedingJoinPoint pjp) throws Throwable {
18.         // 获取参数
19.         Object[] args = pjp.getArgs();
20.         // 修改原先的参数
21.         args[0] = 666;
22.         // 执行原方法,并传入参数
23.         Object ret = pjp.proceed(args);
24.         System.out.println("进行增强功能");
25.         return ret;
26.     }
27. }

复制代码

　　　　2、获取切入点方法返回值
　　　　　　*  返回后通知

1. package com.itheima.aop;
3. import org.aspectj.lang.JoinPoint;
4. import org.aspectj.lang.ProceedingJoinPoint;
5. import org.aspectj.lang.annotation.*;
6. import org.springframework.stereotype.Component;
8. import java.util.Arrays;
10. @Component
11. @Aspect
12. public class MyAdvice {
13.     //设置切入点，@Pointcut注解要求配置在方法上方
14.     @Pointcut("execution(* com.itheima.dao.BookDao.findName(..))")
15.     private void pt() {
16.     }
17.     // 设置在原函数执行后执行当前操作(后置通知）
18.     // 如果有返回值，则可以写成afterReturning(value = "pt()", returning = "ret"),使用ret接收原方法返回值
19.     // 如果有参数，则public void afterReturning(JoinPoint jp, Object ret)，且JoinPoint jp，一定要在前面
20.     @AfterReturning(value = "pt()", returning = "ret")
21.     public void afterReturning(JoinPoint jp, Object ret) {
22.         // 获取参数
23.         Object[] args = jp.getArgs();
24.         System.out.println("参数：" + Arrays.toString(args));
25.         System.out.println("返回值：" + ret);
26.         System.out.println("执行后置通知");
27.     }
28. }

复制代码

　　　　　　* 环绕通知

1. package com.itheima.aop;
3. import org.aspectj.lang.ProceedingJoinPoint;
4. import org.aspectj.lang.annotation.*;
5. import org.springframework.stereotype.Component;
7. @Component
8. @Aspect
9. public class MyAdvice {
10.     //设置切入点，@Pointcut注解要求配置在方法上方
11.     @Pointcut("execution(* com.itheima.dao.BookDao.findName(..))")
12.     private void pt() {
13.     }
15.     //设置在切入点pt()的前面运行当前操作(前置通知)
16.     @Around("pt()")
17.     public Object method(ProceedingJoinPoint pjp) throws Throwable {
18.         // 获取参数
19.         Object[] args = pjp.getArgs();
20.         // 修改原先的参数
21.         args[0] = 666;
22.         // 执行原方法,并传入参数，并用ret接收原方法返回值
23.         Object ret = pjp.proceed(args);
24.         System.out.println("进行增强功能");
25.         return ret;
26.     }
27. }

复制代码

　　　　3、获取切入点方法运行异常信息
　　　　　　* 抛出异常后通知

1. package com.itheima.aop;
3. import org.aspectj.lang.JoinPoint;import org.aspectj.lang.annotation.*;
4. import org.springframework.stereotype.Component;
6. import java.util.Arrays;
8. @Component
9. @Aspect
10. public class MyAdvice {
11.     //设置切入点，@Pointcut注解要求配置在方法上方
12.     @Pointcut("execution(* com.itheima.dao.BookDao.findName(..))")
13.     private void pt() {
14.     }<br><br>
15.     @AfterThrowing(value = "pt()", throwing = "e")
16.     public void afterThrowing(JoinPoint jp, Exception e) {
17.         // 获取参数
18.         Object[] args = jp.getArgs();
19.         System.out.println("参数：" + Arrays.toString(args));
20.         System.out.println("异常：" + e);
21.         System.out.println("执行异常后置通知");
22.     }
23. }

复制代码

　　　　　　* 环绕通知

1. package com.itheima.aop;
2. import org.aspectj.lang.ProceedingJoinPoint;
3. import org.aspectj.lang.annotation.*;
4. import org.springframework.stereotype.Component;
6. @Component
7. @Aspect
8. public class MyAdvice {
9.     //设置切入点，@Pointcut注解要求配置在方法上方
10.     @Pointcut("execution(* com.itheima.dao.BookDao.findName(..))")
11.     private void pt() {
12.     }//设置在切入点pt()的前面运行当前操作(前置通知)
13.     @Around("pt()")
14.     public Object method(ProceedingJoinPoint pjp) {
15.         // 获取参数
16.         Object[] args = pjp.getArgs();
17.         // 修改原先的参数
18.         args[0] = 666;
19.         // 执行原方法,并传入参数
20.         Object ret = null;<br>　　　　　// 获取异常
21.         try {
22.             ret = pjp.proceed(args);
23.         }catch (Throwable e) {
24.             e.printStackTrace();
25.         }
26.         System.out.println("进行增强功能");
27.         return ret;
28.     }
30. }

复制代码

 

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！