SpringAOP介绍与使用

article/2025/9/14 9:36:26

目录

1.Spring 的 AOP 简介

动态代理
在这里插入图片描述

package proxy;public class MyServiceImpl implements MyService {@Overridepublic void method1() {System.out.println("******method1*******");}@Overridepublic void method2() {System.out.println("******method2*******");}}
package proxy;public interface MyService {//定义我们的业务方法public void method1();public void method2();
}
package proxy;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;public class TestMain {public static void main(String[] args) {// 创建对象（真正的对象）MyService obj = new MyServiceImpl();
//		obj.method1();
//		obj.method2();//在不修改源码的情况下，重写method2的实现//创建obj对象的代理对象/** Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)* 第一个参数 classload：类加载器* 第二个参数 Class<?>[] interfaces：真正对象实现的接口* 第三个参数 InvocationHandler h：如何处理客户端的调用*/MyService proxy = (MyService)Proxy.newProxyInstance(TestMain.class.getClassLoader(), obj.getClass().getInterfaces(), new InvocationHandler() {@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {// 如何处理客户端的调用if(method.getName().equals("method2")) {//重写逻辑System.out.println("In Proxy Method2");return null;}else {//对于其他方法，直接调用真正的对象完成return method.invoke(obj, args);}}});//通过代理对象去调用proxy.method1();proxy.method2();}
}

请添加图片描述

1.1 什么是 AOP

AOP 为 Aspect Oriented Programming 的缩写，意思为面向切面编程，是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。

AOP 是 OOP 的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

1.2 AOP 的作用及其优势

作用：在程序运行期间，在不修改源码的情况下对方法进行功能增强

优势：减少重复代码，提高开发效率，并且便于维护

1.3 AOP 的底层实现

实际上，AOP 的底层是通过 Spring 提供的的动态代理技术实现的。在运行期间，Spring通过动态代理技术动态的生成代理对象，代理对象方法执行时进行增强功能的介入，在去调用目标对象的方法，从而完成功能的增强。

1.4 AOP 的动态代理技术

常用的动态代理技术

JDK 代理 : 基于接口的动态代理技术

cglib 代理：基于父类的动态代理技术

在这里插入图片描述

1.5 JDK 的动态代理

①目标类接口

public interface TargetInterface {public void method();
}

②目标类

public class Target implements TargetInterface {@Overridepublic void method() {System.out.println("Target running....");}
}

③动态代理代码

Target target = new Target(); //创建目标对象
//创建代理对象
TargetInterface proxy = (TargetInterface) Proxy.newProxyInstance(target.getClass()
.getClassLoader(),target.getClass().getInterfaces(),new InvocationHandler() {@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println("前置增强代码...");Object invoke = method.invoke(target, args);System.out.println("后置增强代码...");return invoke;}}
);

④ 调用代理对象的方法测试

// 测试,当调用接口的任何方法时，代理对象的代码都无序修改
proxy.method();

在这里插入图片描述

1.6 cglib 的动态代理

①目标类

public class Target {public void method() {System.out.println("Target running....");}
}

②动态代理代码

Target target = new Target(); //创建目标对象
Enhancer enhancer = new Enhancer();   //创建增强器
enhancer.setSuperclass(Target.class); //设置父类
enhancer.setCallback(new MethodInterceptor() { //设置回调@Overridepublic Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {System.out.println("前置代码增强....");Object invoke = method.invoke(target, objects);System.out.println("后置代码增强....");return invoke;}
});
Target proxy = (Target) enhancer.create(); //创建代理对象

③调用代理对象的方法测试

//测试,当调用接口的任何方法时，代理对象的代码都无序修改
proxy.method();

在这里插入图片描述

1.7 AOP 相关概念

Spring 的 AOP 实现底层就是对上面的动态代理的代码进行了封装，封装后我们只需要对需要关注的部分进行代码编写，并通过配置的方式完成指定目标的方法增强。

在正式讲解 AOP 的操作之前，我们必须理解 AOP 的相关术语，常用的术语如下：

  • Target（目标对象）：代理的目标对象

  • Proxy （代理）：一个类被 AOP 织入增强后，就产生一个结果代理类

  • Joinpoint（连接点）：所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法，因为spring只支持方法类型的连接点

  • Pointcut（切入点）：所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义

  • Advice（通知/ 增强）：所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知

  • Aspect（切面）：是切入点和通知（引介）的结合

  • Weaving（织入）：是指把增强应用到目标对象来创建新的代理对象的过程。spring采用动态代理织入，而AspectJ采用编译期织入和类装载期织入

1.8 AOP 开发明确的事项

1.8 AOP 开发明确的事项

1.8 AOP 开发明确的事项

1)需要编写的内容

  • 编写核心业务代码（目标类的目标方法）

  • 编写切面类，切面类中有通知(增强功能方法)

  • 在配置文件中，配置织入关系，即将哪些通知与哪些连接点进行结合

2）AOP 技术实现的内容

Spring 框架监控切入点方法的执行。一旦监控到切入点方法被运行，使用代理机制，动态创建目标对象的代理对象，根据通知类别，在代理对象的对应位置，将通知对应的功能织入，完成完整的代码逻辑运行。

3）AOP 底层使用哪种代理方式

在 spring 中，框架会根据目标类是否实现了接口来决定采用哪种动态代理的方式。

1.9 知识要点

  • aop：面向切面编程

  • aop底层实现：基于JDK的动态代理 和 基于Cglib的动态代理

  • aop的重点概念：

      Pointcut（切入点）：被增强的方法Advice（通知/ 增强）：封装增强业务逻辑的方法Aspect（切面）：切点+通知Weaving（织入）：将切点与通知结合的过程

  • 开发明确事项：

      谁是切点（切点表达式配置）谁是通知（切面类中的增强方法）将切点和通知进行织入配置

2. 基于 XML 的 AOP 开发

2.1 快速入门

①导入 AOP 相关坐标

②创建目标接口和目标类（内部有切点）

③创建切面类（内部有增强方法）

④将目标类和切面类的对象创建权交给 spring

⑤在 applicationContext.xml 中配置织入关系

⑥测试代码

①导入 AOP 相关坐标

<!--导入spring的context坐标，context依赖aop-->
<dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.0.5.RELEASE</version>
</dependency>
<!-- aspectj的织入 -->
<dependency><groupId>org.aspectj</groupId><artifactId>aspectjweaver</artifactId><version>1.8.13</version>
</dependency>

②创建目标接口和目标类（内部有切点）

public interface TargetInterface {public void method();
}public class Target implements TargetInterface {@Overridepublic void method() {System.out.println("Target running....");}
}

③创建切面类（内部有增强方法）

public class MyAspect {//前置增强方法public void before(){System.out.println("前置代码增强.....");}
}

④将目标类和切面类的对象创建权交给 spring

<!--配置目标类-->
<bean id="target" class="com.zgl.aop.Target"></bean>
<!--配置切面类-->
<bean id="myAspect" class="com.zgl.aop.MyAspect"></bean>

⑤在 applicationContext.xml 中配置织入关系

导入aop命名空间

<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"xsi:schemaLocation="http://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context.xsdhttp://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop.xsdhttp://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd">

⑤在 applicationContext.xml 中配置织入关系

配置切点表达式和前置增强的织入关系

<aop:config><!--引用myAspect的Bean为切面对象--><aop:aspect ref="myAspect"><!--配置Target的method方法执行时要进行myAspect的before方法前置增强--><aop:before method="before" pointcut="execution(public void com.zgl.aop.Target.method())"></aop:before></aop:aspect>
</aop:config>

⑥测试代码

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AopTest {@Autowiredprivate TargetInterface target;@Testpublic void test1(){target.method();}
}

⑦测试结果

在这里插入图片描述

2.2 XML 配置 AOP 详解

1) 切点表达式的写法

表达式语法：

execution([修饰符] 返回值类型 包名.类名.方法名(参数))

  • 访问修饰符可以省略

  • 返回值类型、包名、类名、方法名可以使用星号* 代表任意

  • 包名与类名之间一个点 . 代表当前包下的类，两个点 … 表示当前包及其子包下的类

  • 参数列表可以使用两个点 … 表示任意个数，任意类型的参数列表

例如：

execution(public void com.zgl.aop.Target.method())	
execution(void com.zgl.aop.Target.*(..))
execution(* com.zgl.aop.*.*(..))
execution(* com.zgl.aop..*.*(..))
execution(* *..*.*(..))
2) 通知的类型

通知的配置语法：

<aop:通知类型 method=“切面类中方法名” pointcut=“切点表达式"></aop:通知类型>

在这里插入图片描述

3) 切点表达式的抽取

当多个增强的切点表达式相同时，可以将切点表达式进行抽取，在增强中使用 pointcut-ref 属性代替 pointcut 属性来引用抽取后的切点表达式。

<aop:config><!--引用myAspect的Bean为切面对象--><aop:aspect ref="myAspect"><aop:pointcut id="myPointcut" expression="execution(* com.zgl.aop.*.*(..))"/><aop:before method="before" pointcut-ref="myPointcut"></aop:before></aop:aspect>
</aop:config>

2.3 知识要点

  • aop织入的配置
<aop:config><aop:aspect ref=“切面类”><aop:before method=“通知方法名称” pointcut=“切点表达式"></aop:before></aop:aspect>
</aop:config>
  • 通知的类型：前置通知、后置通知、环绕通知、异常抛出通知、最终通知
  • 切点表达式的写法：
execution([修饰符] 返回值类型 包名.类名.方法名(参数))

3.基于注解的 AOP 开发

3.1 快速入门

基于注解的aop开发步骤：

①创建目标接口和目标类（内部有切点）

②创建切面类（内部有增强方法）

③将目标类和切面类的对象创建权交给 spring

④在切面类中使用注解配置织入关系

⑤在配置文件中开启组件扫描和 AOP 的自动代理

⑥测试

①创建目标接口和目标类（内部有切点）

public interface TargetInterface {public void method();
}public class Target implements TargetInterface {@Overridepublic void method() {System.out.println("Target running....");}
}

②创建切面类（内部有增强方法)

public class MyAspect {//前置增强方法public void before(){System.out.println("前置代码增强.....");}
}

③将目标类和切面类的对象创建权交给 spring

@Component("target")
public class Target implements TargetInterface {@Overridepublic void method() {System.out.println("Target running....");}
}
@Component("myAspect")
public class MyAspect {public void before(){System.out.println("前置代码增强.....");}
}

④在切面类中使用注解配置织入关系

@Component("myAspect")
@Aspect
public class MyAspect {@Before("execution(* com.zgl.aop.*.*(..))")public void before(){System.out.println("前置代码增强.....");}
}

⑤在配置文件中开启组件扫描和 AOP 的自动代理

<!--组件扫描-->
<context:component-scan base-package="com.zgl.aop"/><!--aop的自动代理-->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

⑥测试代码

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AopTest {@Autowiredprivate TargetInterface target;@Testpublic void test1(){target.method();}
}

⑦测试结果

在这里插入图片描述

3.2 注解配置 AOP 详解

1) 注解通知的类型

通知的配置语法：@通知注解(“切点表达式")

在这里插入图片描述

2) 切点表达式的抽取

同 xml配置
aop 一样，我们可以将切点表达式抽取。抽取方式是在切面内定义方法，在该方法上使用@Pointcut注解定义切点表达式，然后在在增强注解中进行引用。具体如下：

@@Component("myAspect")
@Aspect
public class MyAspect {@Before("MyAspect.myPoint()")public void before(){System.out.println("前置代码增强.....");}@Pointcut("execution(* com.zgl.aop.*.*(..))")public void myPoint(){}
}

3.3 知识要点

  • 注解aop开发步骤

①使用@Aspect标注切面类

②使用@通知注解标注通知方法

③在配置文件中配置aop自动代理aop:aspectj-autoproxy/

  • 通知注解类型

在这里插入图片描述

​


http://chatgpt.dhexx.cn/article/4USw0wMT.shtml

相关文章

SpringAOP详解，使用SpringAop实现统一日志处理，异常处理

SpringAOP详解，使用SpringAop实现统一日志处理，异常处理

阅读本文内容之前需要先了解java动态代理的实现。java动态代理实例 以下内容为本人原创>>>>>>>>>>> Spring AOP的主要概念&#xff1a; 目标代码&#xff08;或称目标方法、被代理类、被代理方法&#xff09;&#xff1a;原本的业务代码。…
阅读更多...
SpringAop学习（一）

SpringAop学习（一）

Aop面向切面编程 AOP是Spring提供的关键特性之一。AOP即面向切面编程&#xff0c;是OOP编程的有效补充。使用AOP技术&#xff0c;可以将一些系统性相关的编程工作&#xff0c;独立提取出来&#xff0c;独立实现&#xff0c;然后通过切面切入进系统。从而避免了在业务逻辑的代码…
阅读更多...
【Spring】SpringAOP切面类

【Spring】SpringAOP切面类

切面类是什么 简单的来说&#xff0c;就是动态的在方法的指定位置添加指定的代码。 为什么需要切面类? 在软件开发的过程中&#xff0c;有很多业务&#xff0c;特别是在编写核心业务的时候&#xff0c;往往需要很多其他的辅助业务&#xff0c;比如说身份验证&#xff08;银…
阅读更多...
SpringAOP超详解！！！！

SpringAOP超详解！！！！

文章目录 一、什么是SpringAOP二、SpringAOP的应用场景三、Aop在 Spring 中的作用四、AOP的实现方式1、方式一&#xff1a;使用原生Spring API接口2、方式二&#xff1a;自定义类方式三&#xff1a;注解 一、什么是SpringAOP SpringAOP的全称是&#xff08;Aspect Oriented Pr…
阅读更多...
springAOP的原理解析

springAOP的原理解析

一、缘起 因为springAOP原理其实是使用jdk动态代理和cglib动态代理&#xff0c; 在深入了解springAOP的原理之前&#xff0c;我们需要先补充一点有关动态代理的相关的知识&#xff0c;然后我们对于springAOP的理解才会更透彻。所谓动态代理技术是程序在动态运行期间动态的增强某…
阅读更多...
SpringAOP简单案例

SpringAOP简单案例

简介 本文是一个老师在学校给学生上课的简单案例&#xff0c;介绍了AOP的五个通知的使用&#xff0c;以及通知的执行顺序。通过自定义注解来充当切入点&#xff0c;获取注解的类型分别对不同的老师做对应的业务处理。代码中的消息响应体&#xff08;Result&#xff09;大家可以…
阅读更多...
springAOP面试题

springAOP面试题

1.什么是SpringAop? 一般称为面向切面编程&#xff0c;用于将那些与业务无关&#xff0c;但却对多个对象产生影响的公共行为和逻辑&#xff0c;抽取并封装为一个可重用的模块&#xff0c;这个模块被命名为“切面”&#xff08;Aspect&#xff09;&#xff0c;减少系统中的重复…
阅读更多...
SpringAOP复习

SpringAOP复习

作业1 目录 作业1一.单选题二.填空题三.判断题 一.单选题 1、以下不属于ProxyFactoryBean类中的常用可配置属性的是&#xff08;&#xff09;。 A、target B、proxyInterfaces C、targetClass D、interceptorNames 答案&#xff1a;C ProxyFactoryBean 是FactoryBean 接口的…
阅读更多...
04、SpringAOP详解

04、SpringAOP详解

1、Spring AOP简介 1、什么是AOP 1、定义阐述 AOP的全称是 Aspect Oriented Programming&#xff0c;是面向切面编程的技术&#xff0c;把一个个的横切关注点放到某个模块中去&#xff0c;称之为切面。那么每一个的切面都能影响业务的某一种功能&#xff0c;切面的目的就是功…
阅读更多...
SpringAop之joinPoint讲解

SpringAop之joinPoint讲解

一、学习背景 摸鱼的时候继续复刻demo&#xff0c;没错&#xff0c;同之前一篇文章&#xff0c;在写aop时又发现自己对aop只停留在面试阶段&#xff0c;甚至还不如&#xff0c;完全不会实践&#xff0c;所以在此记录复刻aop用到的的一些且自己已经遗忘的知识。 那么复刻的一个…
阅读更多...
SpringAOP详细配置与使用

SpringAOP详细配置与使用

目录 SpringAOP简介 AOP概念 Spring AOP简单流程图 Spring AOP之Annotation 前置通知(Before advice) 返回后通知(After reurning advice) 抛出异常后通知(After throwing advice) 后置通知(After (finally) advice) 环绕通知(Around advice) 引入(Introduction) Sp…
阅读更多...
SpringAOP的注解形式

SpringAOP的注解形式

铁子们&#xff0c;快扫码关注啦&#xff01;或 wx搜索&#xff1a;“聊5毛钱的java”&#xff0c;关注可领取博主的Java学习视频资料&#xff0c;保证都是干货 上一篇讲了配置文件形式的SpringAOP&#xff1a;Spring中的AOP以及切入点表达式和各种通知 本篇继续看一下注解形…
阅读更多...
Spring AOP超详细解析

Spring AOP超详细解析

AOP - 面向切面编程&#xff08;Aspect Oriented Programming&#xff09; Spring早期版本的核心功能&#xff1a;管理对象生命周期与对象分配。 即Bean本身的管理创建&#xff0c;以及它整个生命周期里跟其他对象相互之间引用装配 为了更好的实现管理和装配&#xff0c;一个…
阅读更多...
Spring学习：AOP概述

Spring学习：AOP概述

一、AOP概念 AOP是指面向切面编程&#xff0c;利用 AOP 可以对业务逻辑的各个部分进行隔离&#xff0c;从而使得业务逻辑各部分之间的耦合度降低&#xff0c;提高程序的可重用性&#xff0c;同时提高了开发的效率。 通俗描述&#xff1a;不通过修改源代码方式&#xff0c;在主干…
阅读更多...
SpringAOP学习--SpringAOP简介及原理

SpringAOP学习--SpringAOP简介及原理

前文对AOP做了介绍&#xff0c;实际项目中&#xff0c;一般不会直接上手手动实现aop&#xff0c;而是使用一些高级封装的aop实现&#xff0c;如SpringAOP。 Spring是一个广泛应用的框架&#xff0c;SpringAOP则是Spring提供的一个标准易用的aop框架&#xff0c;依托Spring的IOC…
阅读更多...
图文详解Spring AOP，你学会了吗？

图文详解Spring AOP，你学会了吗？

如果说 IOC 是 Spring 的核心&#xff0c;那么面向切面编程AOP就是 Spring 另外一个最为重要的核心&#xff0c;需要重点掌握mikechen 本篇主要会详解以下六点&#xff1a; 1.AOP的定义 2.AOP的作用 3.AOP的应用场景 4.Spring AOP的术语 AOP核心概念Spring AOP 通知分类S…
阅读更多...
Spring AOP全面详解(超级详细)

Spring AOP全面详解(超级详细)

如果说IOC 是 Spring 的核心&#xff0c;那么面向切面编程AOP就是 Spring 另外一个最为重要的核心mikechen AOP的定义 AOP &#xff08;Aspect Orient Programming&#xff09;,直译过来就是 面向切面编程,AOP 是一种编程思想&#xff0c;是面向对象编程&#xff08;OOP&…
阅读更多...
mysql执行SQL脚本

mysql执行SQL脚本

方法一 【Mysql的bin目录】\mysql –u用户名 –p密码 –D数据库<【sql脚本文件路径全名】 示例&#xff1a; 如果mysql配了全局变量&#xff0c;就不需要到Mysql的bin目录下执行&#xff0c;可以在任何地方使用用户名、密码、指定数据库等参数值与参数名不需要隔空格 不…
阅读更多...
SpringBoot 实现SQL脚本自动执行

SpringBoot 实现SQL脚本自动执行

SpringBoot 实现配置SQL脚本自动执行 一. 背景 我们可能遇到过这种情况: 在公网开发时, 新增数据表非常容易, 直接登录到对应服务器的mysql / 使用Navicat访问mysql服务器. 然后去执行sql语句或脚本即可在内网开发时, 由于都在一个网段, 所以操作也比较方便但是在公网开发, 部…
阅读更多...
flink-sql-client提交sql脚本文件

flink-sql-client提交sql脚本文件

标题: flink-sql-client提交sql脚本文件 日期: 2021-10-22 22:11:34 标签: [flink,sql-client] 分类: flink 我们知道&#xff0c;sql-client.sh可以提供给我们一个sql交互界面&#xff0c;让我们没执行一个sql&#xff0c;就可以看到执行结果&#xff0c;也可以交互式查询表的…
阅读更多...
推荐文章

Copyright @ 2022~2023