Spring (4)——AOP

已于 2022-07-28 19:25:56 修改
阅读量232 收藏
点赞数
分类专栏： 框架 笔记 文章标签： spring java 后端
于 2022-07-27 19:32:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_61843013/article/details/126020790
版权
笔记 同时被 2 个专栏收录
111 篇文章 5 订阅
订阅专栏
框架
22 篇文章 0 订阅
订阅专栏

目录

一、Spring的AOP简介

1.1 什么是AOP

1.2 AOP的作用及其优势

1.3 AOP的底层实现

1.4 AOP的动态代理技术

 1.4.1 JDK的动态代理

1.4.2 cglib的动态代理

1.5 AOP相关概念

1.6 AOP开发明确的事项

二、基于XML的AOP开发

2.1 快速入门

2.2 XML配置AOP详解

2.2.1 切点表达式的写法

2.2.2 通知的类型

2.2.3 切点表达式的抽取

2.3 知识要点

三、基于注解的AOP开发

3.1 快速入门

3.2 注解配置AOP详解

3.2.1 注解通知的类型

3.2.2 切点表达式的抽取

3.3 知识要点

一、Spring的AOP简介

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.4.1 JDK的动态代理

① 目标类接口

public interface TargetInterface {
    public void save();
}

② 目标类

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

③ 动态代理代码

public class ProxyTest {

    public static void main(String[] args) {
        //创建目标对象
        final Target target = new Target();
        //获取增强对象
        Advice advice = new Advice();

        TargetInterface proxy = (TargetInterface) Proxy.newProxyInstance(
                target.getClass().getClassLoader(), //目标对象加载器
                target.getClass().getInterfaces(), //目标对象相同的接口字节码对象数组
                new InvocationHandler() {
                    @Override
                    //调用代理对象的任何方法，实质执行的都是invoke方法
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        //前置增强
                        advice.before();
                        method.invoke(target, args);//执行目标方法
                        //后置增强
                        advice.afterReturning();
                        return null;
                    }
                }
        );
        //调用代理对象的方法
        proxy.save();
    }
}

1.4.2 cglib的动态代理

① 目标类

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

② 动态代理代码

public class ProxyTest {

    public static void main(String[] args) {
        //创建目标对象
        final Target target = new Target();
        //获取增强对象
        Advice advice = new Advice();

        //返回值就是动态生成的代理对象，基于cglib
        //1. 创建增强器
        Enhancer enhancer = new Enhancer();
        //2. 设置父类(目标)
        enhancer.setSuperclass(Target.class);
        //3. 设置回调
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                advice.before();//执行前置
                Object invoke = method.invoke(target, args);//执行目标
                advice.afterReturning();//执行后置
                return invoke;
            }
        });
        //4. 创建代理对象
        Target proxy = (Target) enhancer.create();

        proxy.save();

    }
}

1.5 AOP相关概念

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

AOP相关术语：

  • Target(目标对象)：代理的目标对象
  • Proxy(代理)：一个类被AOP织入增强后，就产生了一个结果代理类
  • Joinpoint(连接点)：连接点是指那些被拦截到的点(可以被增强的方法叫连接点)。在Spring中，这些点指的是方法，因为Spring只支持方法类型的连接点
  • Pointcut(切入点)：切入点是指要对哪些Joinpoint 进行拦截的定义(真正被增强的连接点叫切入点)
  • Advice（通知/ 增强）：通知是指拦截到连接点之后所要做的事情就是通知(增强方法)
  • Aspect（切面）：是切入点和通知（引介）的结合
  • Weaving（织入）：是指把增强应用到目标对象来创建新的代理对象的过程(切点和增强结合的过程叫织入)。spring采用动态代理织入，而 AspectJ采用编译期织入和类装载期织入

1.6 AOP开发明确的事项

1. 需要编写的内容

  • 编写核心业务代码(目标类和目标方法)
  • 编写切面类，切面类中由通知(增强功能方法)
  • 在配置文件中，配置织入关系，即将哪些通知与哪些连接点进行结合

2. AOP技术实现的内容

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

3. AOP底层使用哪些代理方式

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

二、基于XML的AOP开发

2.1 快速入门

基于XML的aop开发步骤：

①导入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 save();
}
public class Target implements TargetInterface {
    @Override
    public void save() {
        System.out.println("save running.....");
    }
}

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

public class MyAspect {
    public void before(){
        System.out.println("前置增强.....");
    }
}

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

    <!--目标对象-->
    <bean id="target" class="com.learn.aop.Target"/>
    <!--切面对象-->
    <bean id="myAspect" class="com.learn.aop.MyAspect"/>

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

     导入aop命名空间

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

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

    <!--配置织入：告诉Spring框架哪些方法(切点)需要进行哪些增强(前置、后置...)-->
    <aop:config>
        <!--声明切面-->
        <aop:aspect ref="myAspect">
            <!--切面：切点+通知-->
<!--            <aop:before method="before" pointcut="execution(public void com.learn.aop.Target.save())"/>-->
            <aop:before method="before" pointcut="execution( * com.learn.aop.*.*(..))"/>
        </aop:aspect>
    </aop:config>

⑥ 测试代码

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AopTest {

    @Autowired
    private TargetInterface target;

    @Test
    public void test1(){
        target.save();
    }
}

2.2 XML配置AOP详解

2.2.1 切点表达式的写法

表达式语法：

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

  • 访问修饰符可以省略
  • 返回值类型、包名、类名、方法名可以使用星号*  代表任意
  • 包名与类名之间一个点 . 代表当前报下的类，两个点 .. 表示当前包及其子包下的类
  • 参数列表可以使用两个点 .. 表示任意个数，任意类型的参数列表

2.2.2 通知的类型

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

名称标签说明
前置通知<aop：before>用于配置前置通知。指定增强的方法在切入点方法之前执行
后置通知<aop：after-returning>用于配置后置通知。指定增强的方法在切入点方法之后执行
环绕通知<aop：around>用于配置环绕通知。指定增强的方法在切入点方法之前和之后都 执行
异常抛出通知<aop：throwing>用于配置异常抛出通知。指定增强的方法在出现异常时执行
最终通知<aop：after>用于配置最终通知。无论增强方式执行是否有异常都会执行

2.2.3 切点表达式的抽取

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

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

2.3 知识要点

三、基于注解的AOP开发

3.1 快速入门

基于注解的aop开发步骤：

①创建目标接口和目标类(内部有切点)

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

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

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

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

⑥测试

代码实现

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

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

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

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

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

@Component("target")
public class Target implements TargetInterface {
    @Override
    public void save() {
        System.out.println("save running.....");
    }
}

@Component("myAspect")
public class MyAspect {
    public void before(){
        System.out.println("前置代码增强.....");
    }
}

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

@Component("myAspect")
@Aspect //标注当前MyAspect是一个切面类
public class MyAspect {

    //配置前置增强
    @Before("execution( * com.learn.anno.*.*(..))")
    public void before(){
        System.out.println("前置增强.....");
    }

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

    <!--组件扫描-->
    <context:component-scan base-package="com.learn.anno"/>

    <!--自动代理-->
    <aop:aspectj-autoproxy/>

⑥ 测试代码

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext-anno.xml")
public class AnnoTest {

    @Autowired
    private TargetInterface target;

    @Test
    public void test1(){
        target.save();
    }
}

3.2 注解配置AOP详解

3.2.1 注解通知的类型

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

名称标签说明
前置通知@Before用于配置前置通知。指定增强的方法在切入点方法之前执行
后置通知@AfterReturning用于配置后置通知。指定增强的方法在切入点方法之后执行
环绕通知@Around用于配置环绕通知。指定增强的方法在切入点方法之前和之后都 执行
异常抛出通知@AfterThrowing用于配置异常抛出通知。指定增强的方法在出现异常时执行
最终通知@After用于配置最终通知。无论增强方式执行是否有异常都会执行

3.2.2 切点表达式的抽取

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

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

3.3 知识要点

 

咕咕猫_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring4 AOP 面向切面编程@Aspect
08-10
NULL 博文链接：https://zw7534313.iteye.com/blog/2221200
Spring 入门案例——AOP
08-19
4. **织入（Weaving）**：织入是将切面应用到目标对象的过程，Spring支持三种织入方式： - 编译时织入：使用AspectJ编译器将切面代码与目标类合并。 - 类加载时织入：使用特殊的类加载器，在目标类被加载到内存时...
Spring Aop
muzililee的博客
08-22 254
1.Spring 的 AOP 简介 1.1 什么是 AOP AOP 为 Aspect Oriented Programming 的缩写，意思为面向切面编程，是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。 AOP 是 OOP 的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 1.2 AOP 的作用及其优势 作用：在程
Spring AOP详解
最新发布
这河里吗l的博客
06-17 1087
AOP(Aspect-Oriented Programming)面向切面编程，作为面向对象的一种补充，将公共逻辑（事务管理、日志、缓存等）封装成切面，跟业务代码进行分离，可以减少系统的重复代码和降低模块之间的耦合度，并有利于未来的可拓展性和可维护性。
Spring-4-AOP
SevenSongyun的博客
01-19 247
一、AOP概念 AOP 的全称是“Aspect Oriented Programming”，即面向切面编程，它将业务逻辑的各个部分进行隔离，使开发人员在编写业务逻辑时可以专心于核心业务，从而提高了开发效率。 面向切面编程，即在不修改源代码的基础上对原有功能的增强。 AOP使用了横向抽取机制，取代了传统纵向继承体系的重复性代码，其应用主要体现在事务处理、日志管理、权限控制、异常处理等方面。 二、...
Spring 4 - AOP
m0_51945098的博客
12-11 495
Spring - AOP
【Spring】AOP：基本概念及aop示例（包括xml、注解）
A minor
12-05 2546
1.AOP简介 1.1 定义 面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。 1.2 优点 利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 1.3 原理 aop底层将采用代理机制进行实现。 接口 + 实现类：spring 默认采用 jdk 的动态代理 Proxy。 实现类：spring 默认采用 cglib 字节码增强。 1.4 基本概念 target：目标类，需要被代理的类。例如：Use
Spring——aop
12-23
**Spring AOP 知识详解** 在Java开发领域，Spring框架是不可或缺的一部分，它提供了许多强大的功能，其中AOP（面向切面编程）是其重要特性之一。AOP允许开发者将关注点分离，使得业务逻辑代码与系统服务如日志、...
征服Spring AOP—— Schema
04-04
本文将深入探讨“Spring AOP——Schema”，这是Spring AOP的一种配置方式，通过XML schema定义切面和通知。 首先，我们需要理解AOP的基本概念。面向切面编程是一种编程范式，旨在提高软件的模块化程度，将关注点...
Spring注解驱动开发第33讲——AOP原理总结
08-06
Spring注解驱动开发第33讲——AOP原理总结
五、Spring源码分析——Spring Aop
08-11
《Spring AOP 源码分析》 在深入探讨Spring AOP之前，我们先要理解AOP（面向切面编程）的基本概念。AOP是一种编程范式，它将关注点分离，使得我们可以将横切关注点（如日志、事务管理、安全检查等）与业务逻辑解耦...
SSM-Spring-4-AOP
weixin_43541094的博客
07-15 141
文章目录1 AOP概念2 AOP的底层实现2.1 基于JDK的动态代理2.2 基于cglib的动态代理3 AOP相关概念3.1 AOP相关术语3.2 AOP开发有关事项4 AOP快速入门4.1 切点表达式的写法4.2 增强(通知)的种类4.3 切点表达式的抽取5 基于注解的AOP开发5.1 快速入门5.2 注解增强种类&抽取切点表达式 1 AOP概念 AOP为Aspect Oriented Programming的缩写，意为面向切面编程，是通过预编译方式和运行期动态代理实现程序功能的统一维护的
Spring4-AOP(三)
有点想法的专栏
02-01 171
文章目录1.AOP1.1 `代理`1.2 `AOP简介`1.3 `AspectJ`1.4 `通知`1.4.1 前置通知1.4.2 后置通知1.4.3 返回通知1.4.5 异常通知1.4.6 环绕通知1.5 `切面优先级设置`1.6 `重用切入点定义`1.7 `引入通知`2.基于XML配置2.1 `声明切面`2.2 `声明切点`2.3 `声明通知`2.4 `声明引用` 1.AOP 背景： 1.1 ...
Spring4实现AOP
weixin_30367945的博客
01-18 94
AOP又称面向切面编程，可以不变改变原有业务的基础上进行功能的扩展，例如我们声明一个service类来处理servlet传过来的数据，每一次调用service中的验证登录信息方法的时候的都要进行日志的记录，在不改变该验证方法的基础上，我们可以利用AOP思想借助spring的提供的类，进行面向切面编程，将该方法当作切点，配置前置通知和后置通...
Spring实现AOP的4种方式
08-27 2345
Spring实现AOP的4种方式
Spring AOP
山海可平的博客
12-21 83
简介 AOP：Aspect Oriented Programming 面向切面编程 优点： 降低模块之间的耦合度 使系统更加容易拓展 更好的代码复用 非业务代码更加集中，便于统一管理 业务代码更加简洁纯粹 AOP是对面向队形编程的一个补充，在运行时，动态的将代码切入到累的制定方法，指定位置上的编程思想就是面向切面编程，将不同方法的同一位置抽象成一个切面对象，对该切面对象进行编程就是AOP。 使用示例 创建maven工程，pom.xml添加依赖 <dependency>
Spring(4)--AOP详解
SpringKakashi
03-02 195
AOP详解 AOP理解： AOP–aspect oriented programing 面向切面编程 将业务进行分离，或者说将可变的部分剥离出来，降低耦合，能够在调用某个对象的方法前、中、后回调监听类的方法。 4.1、添加依赖/引入jar包 jar包：aopalliance.jar、aspectj.weaver.jar 和 spring-aspects.jar pom添加依赖： <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjwea
Spring(4)--AOP(面向切面编程)
wuzj1314的博客
03-08 320
1. Spring AOP 简介 SpringAOP 是基于 AOP 编程模式的一个框架，它的使用有效减少了系统间的重复代码，达到了模块间的耦合目的。 AOP 的全称是“Aspect Oriented Programming”，即面向切面编程，它将业务逻辑的各个部分进行隔离，使开发人员在编写业务逻辑时可以专心于核心业务，从而提高了开发效率。 程序需要------1.业务需求------需要实现程序的具体核心功能----添加用户 2.系统需求------...
Spring4---AOP简介
青椒盖饭的博客
03-03 188
什么是AOP? 举个栗子┗|-_-|┛ 现在定义一个简单计算功能程序,假设计算的数为两个数"x",“y”,功能要求 实现两个数的加减乘除的基本运算 每次进行计算时都要想控制台打印日志信息,格式为"调用的方法----(x = x的值,y = y的值) " 要求每次计算时需要验证操作的x或y是否为正数,如果是负数,则不进行计算 定义一个CalcUtil接口,该接口使用泛型描述"x"和"y...
Spring AOP——基于注解的AOP实现
05-18
Spring AOP是Spring框架中的一个重要模块，它提供了面向切面编程（AOP）的支持。AOP是一种编程思想，它可以在不改变原有代码的情况下，通过在程序运行时动态地将代码“织入”到现有代码中，从而实现对原有代码的增强。 Spring AOP提供了基于注解的AOP实现，使得开发者可以通过注解的方式来定义切面、切点和通知等相关内容，从而简化了AOP的使用。 下面是一个基于注解的AOP实现的例子： 1. 定义切面类 ```java @Aspect @Component public class LogAspect { @Pointcut("@annotation(Log)") public void logPointcut() {} @Before("logPointcut()") public void beforeLog(JoinPoint joinPoint) { // 前置通知 System.out.println("执行方法：" + joinPoint.getSignature().getName()); } @AfterReturning("logPointcut()") public void afterLog(JoinPoint joinPoint) { // 后置通知 System.out.println("方法执行完成：" + joinPoint.getSignature().getName()); } @AfterThrowing(pointcut = "logPointcut()", throwing = "ex") public void afterThrowingLog(JoinPoint joinPoint, Exception ex) { // 异常通知 System.out.println("方法执行异常：" + joinPoint.getSignature().getName() + "，异常信息：" + ex.getMessage()); } } ``` 2. 定义业务逻辑类 ```java @Service public class UserService { @Log public void addUser(User user) { // 添加用户 System.out.println("添加用户：" + user.getName()); } @Log public void deleteUser(String userId) { // 删除用户 System.out.println("删除用户：" + userId); throw new RuntimeException("删除用户异常"); } } ``` 3. 在配置文件中开启AOP ```xml <aop:aspectj-autoproxy/> <context:component-scan base-package="com.example"/> ``` 在这个例子中，我们定义了一个切面类LogAspect，其中通过@Aspect注解定义了一个切面，通过@Pointcut注解定义了一个切点，通过@Before、@AfterReturning和@AfterThrowing注解分别定义了前置通知、后置通知和异常通知。 在业务逻辑类中，我们通过@Log注解标注了需要增强的方法。 最后，在配置文件中，我们通过<aop:aspectj-autoproxy/>开启了AOP功能，并通过<context:component-scan>扫描了指定包下的所有组件。 这样，当我们调用UserService中的方法时，就会触发LogAspect中定义的通知，从而实现对原有代码的增强。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值