Spring AOP

已于 2023-02-21 14:09:50 修改
阅读量232 收藏
点赞数
文章标签： spring java 后端
于 2022-11-29 21:16:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jklaaxasdas/article/details/128102754
版权

目录

一、AOP

1. AOP简介和作用

2. AOP中的核心概念

3. AOP入门案例实现

【第一步】导入aop相关坐标

【第二步】定义dao接口与实现类

【第三步】定义通知类，制作通知方法

【第四步】定义切入点表达式、配置切面(绑定切入点与通知关系)

【第五步】在配置类中进行Spring注解包扫描和开启AOP功能 

4. AOP通知详解  

1. 前置通知

2. 后置通知

3. 返回后通知

4. 抛出异常后通知

5. 环绕通知

4. 案例-测量业务层接口万次执行效率

【第一步】编写通知类

【第二步】在SpringConfig配置类上开启AOP注解功能

【第三步】运行测试类，查看结果

获取参数

获取返回值

获取异常

5 案例-百度网盘密码数据兼容处理

【前置工作】环境准备 

【第一步】编写通知类

【第二步】在SpringConfig配置类上开启AOP注解功能

【第三步】运行测试类，查看结果

6 AOP开发总结

AOP的核心概念

一、AOP

1. AOP简介和作用

  AOP(Aspect Oriented Programming)面向切面编程，一种编程范式，指导开发者如
何组织程序结构
  OOP(Object Oriented Programming)面向对象编程
  作用：在不惊动原始设计的基础上为其进行功能增强。简单的说就是在不改变方法
源代码的基础上对方法进行功能增强。
  Spring理念：无入侵式/无侵入式

2. AOP中的核心概念

连接点（JoinPoint）：正在执行的方法，例如：update()、delete()、select()等都
是连接点。
切入点（Pointcut）：进行功能 增强了的方法 ，例如:update()、delete()方法，
select()方法没有被增强所以不是切入点，但是是连接点。
  在SpringAOP中，一个切入点可以只描述一个具体方法，也可以匹配多个方法
  一个具体方法：com.itheima.dao包下的BookDao接口中的无形参无返回值的save方
法
  匹配多个方法：所有的save方法，所有的get开头的方法，所有以Dao结尾的接口中的
任意方法，所有带有一个参数的方法
  通知（Advice）：在切入点前后执行的操作，也就是增强的共性功能
  在SpringAOP中，功能最终以方法的形式呈现
  通知类：通知方法所在的类叫做通知类
  切面（Aspect）：描述通知与切入点的对应关系，也就是哪些通知方法对应哪些切
入点方法。

3. AOP入门案例实现

【第一步】导入aop相关坐标 

<dependencies>
2 <!--spring核心依赖，会将spring-aop传递进来-->
3 <dependency>
4 <groupId>org.springframework</groupId>
5 <artifactId>spring-context</artifactId>
6 <version>5.2.10.RELEASE</version>
7 </dependency>
8 <!--切入点表达式依赖，目的是找到切入点方法，也就是找到要增强的方法-->
<dependency>
 <groupId>org.aspectj</groupId>
 <artifactId>aspectjweaver</artifactId>
 <version>1.9.4</version>
 </dependency>
 </dependencies>

【第二步】定义dao接口与实现类

public interface BookDao {
 public void save();
 public void update();
 }
 @Repository
 public class BookDaoImpl implements BookDao {

 public void save() {
 System.out.println(System.currentTimeMillis());
 System.out.println("book dao save ...");
 }
 public void update(){
 System.out.println("book dao update ...");
 }
 }

【第三步】定义通知类，制作通知方法 

//通知类必须配置成Spring管理的bean
 @Component
 public class MyAdvice {
 public void method(){
 System.out.println(System.currentTimeMillis());
 }
 }

【第四步】定义切入点表达式、配置切面(绑定切入点与通知关系)

//通知类必须配置成Spring管理的bean
 @Component
 //设置当前类为切面类类
 @Aspect
 public class MyAdvice {
 //设置切入点，@Pointcut注解要求配置在方法上方
 @Pointcut("execution(void com.itheima.dao.BookDao.update())")
 private void pt(){}

 //设置在切入点pt()的前面运行当前操作(前置通知)
 @Before("pt()")
 public void method(){
 System.out.println(System.currentTimeMillis());
 }
 }

【第五步】在配置类中进行Spring注解包扫描和开启AOP功能 

@Configuration
 @ComponentScan("com.itheima")
 //开启注解开发AOP功能
 @EnableAspectJAutoProxy
 public class SpringConfig {
 }
测试类和运行结果 
public class App {
 public static void main(String[] args) {
 ApplicationContext ctx = new AnnotationConfigApplicationContext(Sp
ringConfig.class);
 BookDao bookDao = ctx.getBean(BookDao.class);
 bookDao.update();
 }
 }

4. AOP通知详解  

1. 前置通知

  名称：@Before
 类型： ==方法注解==
  位置：通知方法定义上方
作用 ：设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方
法前运行
范例： 
 @Before("pt()")
 public void before() {
 System.out.println("before advice ...");
 }

2. 后置通知

名称：@After
  类型:== 方法注解 ==
  位置：通知方法定义上方
 作用：设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方
法后运行
 范例： 
@After("pt()")
 public void after() {
 System.out.println("after advice ...");
 }

3. 返回后通知

  名称：@AfterReturning（了解）
  类型： ==方法注解==
  位置：通知方法定义上方
  作用：设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方
法正常执行完毕后运行
 范例： 
 @AfterReturning("pt()")
public void afterReturning() {
 System.out.println("afterReturning advice ...");
 }

4. 抛出异常后通知

名称：@AfterThrowing（了解）
 类型： ==方法注解==
  位置：通知方法定义上方
  作用：设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方
法运行抛出异常后执行
 范例： 
@AfterThrowing("pt()")
 public void afterThrowing() {
 System.out.println("afterThrowing advice ...");
 }

5. 环绕通知

 名称：@Around @Around@Around（重点，常用）@Around（重点，常用）@Around（重点，常用）
 类型： ==方法注解==
  位置：通知方法定义上方
  作用：设置当前通知方法与切入点之间的绑定关系，当前通知方法在原始切入点方
法前后运行
范例： 
 @Around("pt()")
 public Object around(ProceedingJoinPoint pjp) throws Throwable {
 System.out.println("around before advice ...");
 Object ret = pjp.proceed();
 System.out.println("around after advice ...");
 return ret;
 }

4. 案例-测量业务层接口万次执行效率

【第一步】编写通知类 

@Component
@Aspect
 public class ProjectAdvice {
 //匹配业务层的所有方法
 @Pointcut("execution(* com.itheima.service.*Service.*(..))")
 private void servicePt(){}

 //设置环绕通知，在原始操作的运行前后记录执行时间
@Around("ProjectAdvice.servicePt()") //本类类名可以省略不写
 public void runSpeed(ProceedingJoinPoint pjp) throws Throwable {
 //获取执行的签名对象
 Signature signature = pjp.getSignature();
 //获取接口/类全限定名
 String className = signature.getDeclaringTypeName();
 //获取方法名
 String methodName = signature.getName();
 //记录开始时间
 long start = System.currentTimeMillis();
 //执行万次操作
 for (int i = 0; i < 10000; i++) {
 pjp.proceed();
 }
 //记录结束时间
 long end = System.currentTimeMillis();
 //打印执行结果
 System.out.println("万次执行："+ className+"."+methodName+"---->" +
(end-start) + "ms");
 }
}

【第二步】在SpringConfig配置类上开启AOP注解功能

@Configuration
 @ComponentScan("com.ucloud")
 @PropertySource("classpath:jdbc.properties")
 @Import({JdbcConfig.class,MybatisConfig.class})
 @EnableAspectJAutoProxy //开启AOP注解功能
 public class SpringConfig {
 }

【第三步】运行测试类，查看结果

@RunWith(SpringJUnit4ClassRunner.class)
 @ContextConfiguration(classes = SpringConfig.class)
 public class AccountServiceTestCase {
 @Autowired
 private AccountService accountService;
 @Test
 public void testFindById(){
 Account account = accountService.findById(2);
 }
 @Test
 public void testFindAll(){
 List<Account> list = accountService.findAll();
 }
 }

获取参数

JoinPoint对象描述了连接点方法的运行状态，可以获取到原始方法的调用参数 
@Before("pt()")
public void before(JoinPoint jp) {
 Object[] args = jp.getArgs(); //获取连接点方法的参数们
 System.out.println(Arrays.toString(args));
 }
ProccedJointPoint是JoinPoint的子类 
@Around("pt()")
 public Object around(ProceedingJoinPoint pjp) throws Throwable {
 Object[] args = pjp.getArgs(); //获取连接点方法的参数们
 System.out.println(Arrays.toString(args));
 Object ret = pjp.proceed();
 return ret;
 }

获取返回值

抛出异常后通知可以获取切入点方法中出现的异常信息，使用形参可以接收对应的
异常对象 
@AfterReturning(value = "pt()",returning = "ret")
 public void afterReturning(String ret) { //变量名要和returning="ret"的属性值
一致
 System.out.println("afterReturning advice ..."+ret);
 }
环绕通知中可以手工书写对原始方法的调用，得到的结果即为原始方法的返回值 
@Around("pt()")
 public Object around(ProceedingJoinPoint pjp) throws Throwable {
 // 手动调用连接点方法，返回值就是连接点方法的返回值
 Object ret = pjp.proceed();
 return ret;
 }

获取异常

抛出异常后通知可以获取切入点方法中出现的异常信息，使用形参可以接收对应的
异常对象 
@AfterThrowing(value = "pt()",throwing = "t")
 public void afterThrowing(Throwable t) {//变量名要和throwing = "t"的属性值一
致
 System.out.println("afterThrowing advice ..."+ t);
 }
抛出异常后通知可以获取切入点方法运行的异常信息，使用形参可以接收运行时抛
出的异常对象 
@Around("pt()")
 public Object around(ProceedingJoinPoint pjp) {
 Object ret = null;
 //此处需要try...catch处理，catch中捕获到的异常就是连接点方法中抛出的异常
 try {
 ret = pjp.proceed();
 } catch (Throwable t) {
 t.printStackTrace();
 }
 return ret;
 }

5 案例-百度网盘密码数据兼容处理

【前置工作】环境准备 

//-------------service层代码-----------------------
 public interface ResourcesService {
 public boolean openURL(String url ,String password);
 }
 @Service
 public class ResourcesServiceImpl implements ResourcesService {
 @Autowired
 private ResourcesDao resourcesDao;

 public boolean openURL(String url, String password) {
 return resourcesDao.readResources(url,password);
 }
 }
 //-------------dao层代码-----------------------
 public interface ResourcesDao {
 boolean readResources(String url, String password);
 }
 @Repository
 public class ResourcesDaoImpl implements ResourcesDao {
 public boolean readResources(String url, String password) {
 System.out.println(password.length());
 //模拟校验
 return password.equals("root");
 }
 }

【第一步】编写通知类 

@Component
 @Aspect
 public class DataAdvice {

 @Pointcut("execution(boolean com.ucloud.service.*Service.*(*,*))")
 private void servicePt(){}

 @Around("DataAdvice.servicePt()")
 public Object trimStr(ProceedingJoinPoint pjp) throws Throwable {
 Object[] args = pjp.getArgs();
 for (int i = 0; i < args.length; i++) {
 //判断参数是不是字符串
 if(args[i].getClass().equals(String.class)){
 args[i] = args[i].toString().trim();
 }
 }
 Object ret = pjp.proceed(args);
 return ret;
 }
 }
【第二步】在SpringConfig配置类上开启AOP注解功能
 @Configuration
 @ComponentScan("com.itheima")
 @EnableAspectJAutoProxy
 public class SpringConfig {
 }

【第二步】在SpringConfig配置类上开启AOP注解功能 

@Configuration
 @ComponentScan("com.itheima")
@EnableAspectJAutoProxy
public class SpringConfig {
 }

【第三步】运行测试类，查看结果 

public class App {
 public static void main(String[] args) {
 ApplicationContext ctx = new AnnotationConfigApplicationContext(Sp
ringConfig.class);
 ResourcesService resourcesService = ctx.getBean(ResourcesService.c
lass);
 boolean flag = resourcesService.openURL("http://pan.baidu.com/hah
a", "root ");
 System.out.println(flag);
 }
 }

6 AOP开发总结

AOP的核心概念


 概念：AOP(Aspect Oriented Programming)面向切面编程，一种编程范式
 作用：在不惊动原始设计的基础上为方法进行功能增强
 核心概念
 代理（Proxy）：SpringAOP的核心本质是采用代理模式实现的
 连接点（JoinPoint）： 在SpringAOP中，理解为任意方法的执行
 切入点（Pointcut）：匹配连接点的式子，也是具有共性功能的方法描述
 通知（Advice）：若干个方法的共性功能，在切入点处执行，最终体现为一个方法
 切面（Aspect）：描述通知与切入点的对应关系
 目标对象（Target）：被代理的原始对象成为目标对象

Proxy）：SpringAOP的核心本质是采用代理模式实现的
连接点（
JoinPoint）： 在SpringAOP中，理解为任意方法的执行
切入点（
Pointcut）：匹配连接点的式子，也是具有共性功能的方法描述
通知（
Advice）：若干个方法的共性功能，在切入点处执行，最终体现为一个方法
切面（
Aspect）：描述通知与切入点的对应关系
目标对象（
Target）：被代理的原始对象成为目标对象
猩星星
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
AOP中使用的注解 @Service @Aspect @component
zzu_wlan的博客
02-06 2436
@Service标注将这个类在扫描时注册到Spring容器管理 @Aspect是将该类声明为切面类 @component把该类实例化放入到spring容器中， @五种增强("execution(public 返回值 地址.*(..))") AOP实现的大致流程即为 将目标方法的类通过@Service注册到Spring容器管理，以便之后生成代理对象 通过@Aspect声明切面类，然后@c...
Spring对使用@Configuration @Component的类中 “内部类的特殊处理”
Brucelwl的博客
12-20 3233
Spring对使用@Configuration @Component的类中 “内部类的特殊处理”
@Component@Import@Bean加载顺序解析
最新发布
yytree123的博客
02-24 4958
@Component@Import@Bean加载顺序解析
java aop拦截配置_Spring AOP：如何拦截内部类？
weixin_39736650的博客
03-01 622
@Aspectpublic class ServiceAspect {@Before("execution(public * com.test.server.support.service.*.Client.*(..))")public void before(JoinPoint joinPoint) {System.out.println("....");}}春天-config.xml中内容只有...
Spring AOP教程
12-07
Spring框架的关键组件之一是面向方面编程(AOP)框架。 面向方面的编程需要将程序逻辑分解成不同的部分。 此教程将通过简单实用的方法来学习Spring框架提供的AOP/面向方面编程。
Spring aop失效的几种解决方案
08-19
Spring AOP失效解决方案详解 作为一名IT行业大师，我将从给定的文件中生成相关知识点，主要介绍Spring AOP失效的几种解决方案。 标题解释 Spring AOP失效的几种解决方案是指在使用Spring框架时，Aspect Oriented ...
spring aop
03-28
Spring AOP，全称为Aspect-Oriented Programming（面向切面编程），是Spring框架的重要组成部分，它为Java应用程序提供了声明式的企业级服务，如事务管理、日志记录等。AOP的核心概念是切面（Aspect）和通知（Advice...
spring aop jar 包
07-26
Spring AOP(Aspect Oriented Programming，面向切面编程)是Spring框架的重要组成部分，它提供了一种在不修改源代码的情况下，对程序进行功能增强的技术。这个"spring aop jar 包"包含了实现这一功能所需的类和接口，...
Spring AOP 16道面试题及答案.docx
06-29
Spring AOP，全称为Aspect Oriented Programming，是面向切面编程的一种编程范式，它是对传统的面向对象编程（OOP）的一种补充。在OOP中，核心是对象，而在AOP中，核心则是切面。切面是关注点的模块化，即程序中的...
springboot的注解aop使用教程
Mint6的博客
07-07 2238
1.springboot中使用注解很容易开启一个aop @Aspect @Order(1) @Component @Aspect：开启aop，@Component：需要被扫描到，启用这个类，@Order：启动的aop有好多个，这个可以协调配置它们的先后顺序 2.涉及到六个常用注解 @Pointcut("") 定义切入点：定义一个方法，代替需要做切面的方法。 比如现在想aop在A方法周...
spring aop类内部调用不拦截原因及解决方案
热门推荐
夢の殇
06-08 1万+
spring对应java web开发的同学来说，都不陌生，其中事务@Transactional在service层更是常常使用。 1.aop类内部调用不拦截原因 细心的同学也许早就发现当service中的某个没标注@Transactional的方法调用另一个标注了@Transactional的方法时，居然没开启事务。例如 @Service public class UserService {
spring 中四种注解@controller,@service,@repository,@component的区别
陈俊的马蹄印
03-15 4284
spring 中四种注解@controller,@service,@repository,@component的区别
【Spring源代码阅读之五】解析配置类的内部类、@PropertySource、@ComponentScan，处理@ImportResource注解
weixin_42997554的博客
02-23 958
解析配置类的内部类、@PropertySource、@ComponentScan导图ConfigurationClassParser#processMemberClassesConfigurationClassParser#processPropertySourceConfigurationClassParser#addPropertySourceMutablePropertySources#ad...
Spring源码之@Component注解解析
千里之行，始于足下
01-27 1303
Spring中@Component的使用以及对@Component的源码解析流程
@Component Spring注解解读以及内部原理
qq_29078779的博客
09-26 3409
1. Component @Component 使用此注解会被Spring加载到IOC容器中 2. ComponentScan @ComponentScan 扫描带 @Component 注解 3 注解的派生性 @Service @Target({ElementType.TYPE}) @Retention(RetentionPolicy.RUNTIME) @Documented...
全面掌握 Java 内部类
yhao的博客
05-24 3435
一直以来以为自己对 java 基础甚是清楚，然而面试时却连内部类和静态内部类的区别都无法回答圆满，so~重新学习一遍，彻底掌握内部类。内部类是一种非常有用的特性，它可以把一些逻辑相关的类组织在一起，并控制位于内部的类的可视性，下文中内部类均指非静态内部类。内部类的学习分为以下10个知识点： 1.创建内部类与连接外部类 2.内部类与向上转型 3.局部内部类 4.匿名内部类
@component使用案例
小爷欣欣
11-13 2108
@component的作用是将一个java类加入到spring容器中管理，省去了这句配置，取而代之的是，负责扫描改包下的所有包名。 案例： <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop=
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值