AOP

最新推荐文章于 2025-06-23 14:31:10 发布
原创 最新推荐文章于 2025-06-23 14:31:10 发布 · 1k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

    AOP相关概念

【场景描述】

         结合前面的编码实操，已经解决了最初需求，推而广之，我们将纵向的从上到下的主要业务逻辑成为主线关注，如上面对User的CRUD操作；将增加日志记录、安全检查等横向性的问题，可以喝主线业务分离分开的称为(参考代理模式篇)

横切性关注点

AOP编程也就是基于上述描述推演开来。

1)       横切性关注点

我们加在主线业务前后的这些内容称为“横切性关注点”。根据OOP编程的原则，提供给多个地方调用的内容需要将它封装为一个方法，方法也不可能单独存在，需要存在一个类中，有此引出了后续概念。

 

2)       通知(advice)

将横向业务内容也即横切性关注点的内容封装为一个方法，这个方法称为“通知”advice

,它可以放在主方法的前面(比如User里面的add方法是主方法而checkSecurity可以放在add方法前面后面等，均可)也可以放在后面。除此外还有异常通知、环绕通知和最终通知。

即被方法化的横切性关注点称为通知，它可以放在前后等多个地方。

 

3)       连接点(joinpoint)

就是那些被拦截到的点，spring这些点就是方法。也就是主线业务中的主要方法，每一

方法就是一个连接点，比如User类的CRUD四个方法，就是4个连接点。

 

4)       切入点(pointcut)

就是要对那些方法进行拦截，是对需要拦截的jonitpoint的定义。

 

5)       切面(aspect)

一个个封装了的方法称为advice，每一个方法均应该封装在一个类中；此外，在

这些advice上也需要定义将这些通知用于那些方法前面或者后面，这些定义也封装在这个类中，称为切入点，它们以后就作用于joinpoint将这些统一封装起来的类称为切面。公式表达：aspect=pointcut+advice

 

6)       织入(weave)

将aspect运用到代理的目标对象上并导致proxy创建的过程称为织入。

 

1.2       使用Spring进行AOP编程

1.2.1   用注解配置方式进行AOP开发

1)      首先启动对@AspectJ注解的支持以及XML的配置文件

<?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"

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

    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd

http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd

http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd

http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

    <!-- 首先启动对@AspectJ注解的支持 -->

<aop:aspectj-autoproxy/>

<bean id="myAspect" class="com.ailk.test.MyAspect"/>

<bean id="userServiceImpl" class="com.ailk.service.impl.UserServiceImpl"/>

</beans>

2)      进行Aspect内部通知和切入点的配置

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;

 

@Aspect

publicclass MyAspect

{

    //声明一个切入点并配置,UserServiceImpl类中的delete方法进行拦截

    @Pointcut("execution (* com.ailk.service.impl.UserServiceImpl.delete(..))")

    privatevoid anyMethod() {}

   

   

    @Before("anyMethod()")

    publicvoid checkSecurity()

    {

       System.out.println(" 前置通知，安全检查---------");

    }

    @AfterReturning("anyMethod()")

    publicvoid checkSecurityAfterReturning()

    {

       System.out.println(" 后置通知，安全检查---------");

    }

    @After("anyMethod()")

    publicvoid checkSecurityAfter()

    {

       System.out.println(" 最终通知，安全检查---------");

    }

    @AfterThrowing("anyMethod()")

    publicvoid checkSecurityAfterThrowing()

    {

       System.out.println(" 例外通知，安全检查---------");

    }  

    @Around("anyMethod()")

    public Object checkSecurityAround(ProceedingJoinPoint pjp) throws Throwable

    {

       System.out.println(" 环绕通知进入**************************");

       Object obj = pjp.proceed();

       System.out.println(" 环绕通知结束**************************");

       return obj;

    }  

/* 【方法输入参数的精细化定义,按照输入参数匹配】

     * 最上面的pointcut定义了对com.ailk.service.impl.UserServiceImpl.delete类包下的

     * delete方法有效它可以接受任何参数，下面是更精细化的配置，要求输入

     * 参数还要有long uuid,String name两个才行，可以当做是delete(long uuid,String name)

     * 这样的方法才起效。

     * */

    @Before("anyMethod() && args(uuid,name)")

    publicvoid checkSecurity(long uuid,String name)

    {

       System.out.println(" 前置通知，安全检查有参数---------");

    }  

    /* 【方法输入参数的精细化定义，通过切面获得方法的返回值】

     * 最上面的pointcut定义了对com.ailk.service.impl.UserServiceImpl.delete类包下的

     * delete方法有效它可以接受任何参数，下面是更精细化的配置，要求方法返回值的必须是String类型

     * 的才起效且可以捕捉到方法调用时的返回值。

     * */ 

    @AfterReturning(pointcut="anyMethod()",returning="retValue")

    publicvoid checkSecurityAfterReturning(String retValue)

    {

       System.out.println(" 后置通知，安全检查---------"+retValue);

    }

}

 

 

 

import com.ailk.interfaces.UserService;

import com.ailk.po.User;

 

publicclass UserServiceImpl implements UserService {

    publicvoid add(User user){

       System.out.println("add用户成功");

    }

    publicvoid delete(long uuid){

        //int number = 10/0;

       System.out.println("delete用户成功");

    }

    publicvoid update(long uuid){

       System.out.println("update用户成功");

    }

    publicvoid getUserInfo(long uuid){

       System.out.println("getUserInfo用户成功");

    }

}

 

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

 

import com.ailk.interfaces.UserService;

import com.ailk.po.User;

 

publicclass Test4

{

    publicstaticvoid main(String[] args) {

       User user = new User();

       user.setName("张三");

       user.setPassword("1234");

      

       ApplicationContext ac = new ClassPathXmlApplicationContext("AOP.xml");

       UserService service = (UserService) ac.getBean("userServiceImpl");

       service.add(user);

       System.out.println();

       service.delete(1);

       System.out.println();

       service.update(1);

       service.getUserInfo(1);

    }

}

 

 

1.2.2   用XML配置方式进行AOP开发

【切面类，里面无任何注解】

import org.aspectj.lang.ProceedingJoinPoint;

 

publicclass MyAspectByXML {

    publicvoid checkSecurityBefore(){

       System.out.println(" 前置通知MyAspectByXML，安全检查---------");

    }

    publicvoid checkSecurityAfterReturning(){

       System.out.println(" 后置通知MyAspectByXML，安全检查---------");

    }

    publicvoid checkSecurityAfter(){

       System.out.println(" 最终通知MyAspectByXML，安全检查---------");

    }

    publicvoid checkSecurityAfterThrowing(){

       System.out.println(" 例外通知MyAspectByXML，安全检查---------");

    }  

    public Object checkSecurityAround(ProceedingJoinPoint pjp) throws Throwable{

       System.out.println("  环绕通知MyAspectByXML进入**************************");

       Object obj = pjp.proceed();

       System.out.println("  环绕通知MyAspectByXML结束**************************");

       return obj;

    }

}

 

 

【XML配置文件配置切面，结合前面的MyAspectByXML类】

<?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"

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

        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd

              http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd

              http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd

              http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

 

    <!-- 首先启动对@AspectJ注解的支持 -->

    <aop:aspectj-autoproxy/>

   

    <!-- 注解方式的切面 -->

    <bean id="myAspect" class="com.ailk.test.MyAspect"/>

   

    <!-- XML配置文件方式的切面 -->

    <bean id="myAspectByXML" class="com.ailk.test.MyAspectByXML"/>

    <aop:config>

       <aop:aspect id="AspectByXML" ref="myAspectByXML">

           <aop:pointcut id="mycut" expression="execution (* com.ailk.service.impl.UserServiceImpl.add(..))"/>

           <aop:before pointcut-ref="mycut" method="checkSecurityBefore"/>

           <aop:after-returning pointcut-ref="mycut" method="checkSecurityAfterReturning"/>

           <aop:after-throwing pointcut-ref="mycut" method="checkSecurityAfterThrowing"/>

           <aop:after pointcut-ref="mycut" method="checkSecurityAfter"/>

           <aop:around pointcut-ref="mycut" method="checkSecurityAround"/>

       </aop:aspect>

    </aop:config>

    <bean id="userServiceImpl" class="com.ailk.service.impl.UserServiceImpl"/>

</beans>

【备注】

表达式如何写：

Ø  execution (* com.ailk.service.impl.UserServiceImpl.add(..))

表示任意返回值com.ailk.service.impl.UserServiceImpl这个类里面的add方法，该方法输入参数不限；如果add方法修改为*，该类里面的任意方法。

 

Ø  execution (java.lang.String com.ailk.service.impl.UserServiceImpl.add(..))

返回值是String的方法才起效，其它同上

 

Ø  execution (*com.ailk.service.impl.UserServiceImpl.add(java.lang.String,..))

表示该add方法的第一个入参必须是String型，后面的其它参数不管，其它同上。

 

Ø  execution (!void com.ailk.service.impl.UserServiceImpl.add(..))

返回值只要不是void的都处理。

 

Ø  execution (* com.ailk.service.impl..*.add(..))

impl包下面的全部都起效


掌握Spring AOP：开发中的切面编程与案例分析
张彦峰的博客
05-12 168万+
本文介绍了 Spring AOP（面向切面编程） 的基本理论和实际应用。首先，详细解释了 AOP 中的关键概念，如连接点、切点、通知等，并通过切点表达式和正则规则的使用，展示了如何在不同场景下灵活应用 AOP。接着，结合多个实际开发案例，讲解了如何使用 AOP 实现方法自动打印、mock 赋能干预、业务处理和异步操作等功能。最后，文章总结了 AOP 的开发注意事项及最佳实践，帮助开发者避免常见的陷阱并提高代码的可维护性和扩展性。
spring boot aop记录修改前后的值demo
11-22
在当今软件开发领域，AOP（面向切面编程）是提升代码质量与维护效率的重要技术之一。Spring Boot作为Java平台上的全栈开发框架，提供了对AOP的良好支持。本文旨在深入探讨如何通过Spring Boot实现AOP在记录数据修改...
aop
05-07
AOP是对OOP的补充和完善，它允许开发人员动态修改OOP定义的静态对象模型--- 开发者可以不用修改原始的OOP对象模型，甚至无须修改OOP代码本身，就能够 解决“多个不具有继承层次的对象引入同一公共行为”的问题
彻底征服 Spring AOP 之 理论篇
weixin_34014277的博客
11-13 320
基本知识 其实, 接触了这么久的 AOP, 我感觉, AOP 给人难以理解的一个关键点是它的概念比较多, 而且坑爹的是, 这些概念经过了中文翻译后, 变得面目全非, 相同的一个术语, 在不同的翻译下, 含义总有着各种莫名其妙的差别. 鉴于此, 我在本章的开头, 着重为为大家介绍一个 Spring AOP 的各项术语的基本含义. 为了术语传...
说说你对AOP的理解
最新发布
tschen的博客
06-23 644
特性JDK动态代理CGLIB动态代理实现基础目标类的接口目标类的子类继承依赖需实现至少一个接口无依赖（可代理任意类）性能调用时反射开销较大生成代理慢，但调用效率高增强限制只能拦截接口方法可拦截所有非final方法AOP 的本质是通过动态代理在运行时“包装”目标对象JDK代理利用接口实现代理，通过插入横切逻辑；CGLIB代理通过继承重写方法，由MethodInterceptor控制增强流程。
Java Spring AOP用法
weixin_30617737的博客
09-04 284
Java Spring AOP用法 Spring AOP Java web 环境搭建 Java web 项目搭建 Java Spring IOC用法 spring提供了两个核心功能，一个是IoC(控制反转)，另外一个便是Aop(面向切面编程)，IoC有助于应用对象之间的解耦，AOP则可以实现横切关注点（如日志、安全、缓存和事务管理）与他们所影响的对象之间的解耦。 1.简介 AOP主要包含...
Spring的AOP面向切面编程
Smile2you的博客
08-09 260
什么是AOP？ 1.AOP概念介绍 　　所谓AOP，即Aspect orientied program,就是面向方面(切面)的编程。 　　　功能： 让关注点代码与业务代码分离！ 关注点:          　重复代码就叫做关注点； 业务代码： 　　　　核心业务的代码 业务代码与关注点代码分离，好处？             　　 --&gt; 关注点代码写一次即可；      ...
AWR6843aop开箱例程
03-08
AWR6843AOP是一款高性能的毫米波雷达芯片，由意法半导体（STMicroelectronics）制造，常用于嵌入式系统中的环境感知和物体检测应用。开箱例程（Out-of-box routine）是为了帮助开发者快速理解和启动对硬件的初步操作...
Java利用spring aop进行监测方法执行耗时
05-25
使用 Spring AOP 进行方法耗时监测的好处有以下几点： 1. 代码实现简单，易于维护：使用 Spring AOP 可以将耗时监测的逻辑与业务逻辑进行解耦，避免业务逻辑代码的冗余和代码维护难度的提高。 2. 安全性高：使用 ...
AndroidAop:aop aop样本
05-16
AndroidAop aop 小栗子 为什么要用Aop 简化我们的代码，对于公用的逻辑我们可以抽取出来统一处理。比如对于很多地方我们 都需要判断网络是否连接，如果连接，那么页面上的一些按钮点击之后是可以成功发出 请求与后台...
什么是AOP
weixin_30306905的博客
09-14 131
AOP（Aspect-Oriented Programming，面向方面编程），可以说是OOP（Object-Oriented Programing，面向对象编程）的补充和完善。OOP引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一个集合。当我们需 要为分散的对象引入公共行为的时候，OOP则显得无能为力。也就是说，OOP允许你定义从上到下的关系，但并不适合定义从左到右的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值