Spring中的AOP

最新推荐文章于 2023-12-26 15:07:49 发布
最新推荐文章于 2023-12-26 15:07:49 发布
阅读量94 收藏
点赞数
文章标签： spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44961111/article/details/108788616
版权

Spring中的AOP

1.什么是AOP

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

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

2.AOP的作用及其优势

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

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

3.AOP的底层实现

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

4.AOP的代理技术

JDK 代理 : 基于接口的动态代理技术
cglib 代理：基于父类的动态代理技术

5.AOP的相关术语

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

注：切入点一定是连接点，但连接点不一定是切入点，切入点只是指的是业务方法中那些被增强的方法，不被增强的不是切入点

6.基于XML的AOP开发

开发步骤

  1. ①导入 AOP 相关坐标

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

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

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

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

  6. ⑥测试代码

6.1 导入相关坐标

 <!--spring的依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.2.RELEASE</version>
        </dependency>
        <!--aspectj的织入-->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.7</version>
        </dependency>

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

public class UserServiceImpl implements UserService {
    public void insertUser() {
        System.out.println("业务方法执行成功！");

6.3 创建切面类，里面有增强的方法

public class Logger {

    public void beforeLog(){
        System.out.println("前置通知方法增强.....");
    }

    public void afterLog(){
        System.out.println("后置通知增强.....");
    }

    public void throwLog(){
        System.out.println("异常通知增强....");
    }

    public void finallyLog(){
        System.out.println("最终通知增强....");
    }
}

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

  <!--配置目标类service-->
    <bean id="userService" class="com.feilong.service.impl.UserServiceImpl"></bean>

    <!--配置切面类log-->
    <bean id="log" class="com.feilong.log.Logger"></bean>

6.5 在 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/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd">

配置切点表达式和要进行增强方法的织入关系


    <!--配置AOP-->
    <aop:config>
        <!--配置切入点表达式
           id用于指定表达式的唯一标识
           expression用于指定表达式的内容
           当标签写在<aop:aspect>里面时只能是当前切面使用
           当写在外面时，表示所有切面都可用
        -->
        <aop:pointcut id="pt1" expression="execution(* com.feilong.service.impl.*.*(..))"></aop:pointcut>
        <!--配置切面-->
        <aop:aspect id="logAdvice" ref="log">
            <!--配置通知的类型，并且建立通知方法和切入点之间的关联-->
            <!--配置前置通知：在业务方法执行之前执行-->
            <aop:before method="beforeLog" pointcut-ref="pt1"></aop:before>
            <!--配置后置通知：在业务方法正常执行之后执行,与异常通知只能执行一个-->
            <aop:after-returning method="afterLog" pointcut-ref="pt1"></aop:after-returning>
            <!--配置异常通知：在业务方法产生异常后执行，与后置通知只能执行一个-->
            <aop:after-throwing method="throwLog" pointcut-ref="pt1"></aop:after-throwing>
            <!--配置最终通知:无论切入点方法是否正常执行，它都会最后执行-->
            <aop:after method="finallyLog" pointcut-ref="pt1"></aop:after>
            <!--配置环绕通知-->
            <aop:around method="throundLog" pointcut-ref="pt1"></aop:around>
        </aop:aspect>
    </aop:config>

6.6 测试代码

public class TestMain {
    public static void main(String[] args) {
        ApplicationContext as= new ClassPathXmlApplicationContext("beans.xml");
        UserService userService = as.getBean("userService", UserService.class);
        userService.insertUser();
    }
}

7.XML配置AOP详细介绍

1）通知的类型
在这里插入图片描述
2）切入点表达式详解

  • 关键字：execution(表达式)

  • 表达式：
    访问修饰符 返回值 包名.包名.包名…类名.方法名(参数列表)
    标准的表达式写法：

               public void com.feilong.service.impl.AccountServiceImpl.saveAccount()
       访问修饰符可以省略
           void com.feilong.service.impl.AccountServiceImpl.saveAccount()
       返回值可以使用通配符，表示任意返回值
           * com.feilong.service.impl.AccountServiceImpl.saveAccount()
       包名可以使用通配符，表示任意包。但是有几级包，就需要写几个*.
           * *.*.*.*.AccountServiceImpl.saveAccount())
       包名可以使用..表示当前包及其子包
           * *..AccountServiceImpl.saveAccount()
       类名和方法名都可以使用*来实现通配
           * *..*.*()
       参数列表：
           可以直接写数据类型：
               基本类型直接写名称           int
               引用类型写包名.类名的方式   java.lang.String
           可以使用通配符表示任意类型，但是必须有参数
           可以使用..表示有无参数均可，有参数可以是任意类型
       全通配写法：
           * *..*.*(..)

       实际开发中切入点表达式的通常写法：
           切到业务层实现类下的所有方法
               * com.feilong .service.impl.*.*(..)

3) AOP织入的配置

<aop:config>
 <aop:pointcut id="pt1" expression="execution(* com.feilong.service.impl.*.*(..))"></aop:pointcut>
    <aop:aspect ref=“切面类”>
        <aop:before method=“通知方法名称” pointcut=“切点表达式"></aop:before>
    </aop:aspect>
</aop:config>

8.基于注解的AOP开发

基于注解的aop开发步骤
①创建目标接口和目标类（内部有切点）

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

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

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

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

⑥测试

1.创建目标接口和目标类，并将此对象的创建权交给spring来管理

@Service("userService")
public class UserServiceImpl implements UserService {
    public void insertUser() {
        System.out.println("业务方法执行成功！");
    }

2.创建切面类，并将此对象的创建权交给spring来管理

@Component("logger")
@Aspect  //表示当前类是一个切面类
public class Logger

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

 /**
     * 配置切入点表达式
     */
    @Pointcut("execution(* com.feilong.service.impl.*.*(..))")
    private void pt1() {
    }

    /**
     * 前置通知
     */
    @Before("pt1()")
    public void beforeLog() {
        System.out.println("前置通知方法执行.....");
    }

    /**
     * 后置通知
     */
    @AfterReturning("pt1()")
    public void afterLog() {
        System.out.println("后置通知执行了.....");
    }

    /**
     * 异常通知
     */
    @AfterThrowing("pt1()")
    public void throwLog() {
        System.out.println("异常通知执行了....");
    }

    /**
     * 最终通知
     */
    @After("pt1()")
    public void finallyLog() {
        System.out.println("最终通知执行了....");
    }

    /**
     * 环绕通知
     * 问题：
     * 当我们配置了环绕通知之后，切入点方法没有执行，而通知方法执行了。
     * 分析：
     * 通过对比动态代理中的环绕通知代码，发现动态代理的环绕通知有明确的切入点方法调用，而我们的代码中没有。
     * 解决：
     * Spring框架为我们提供了一个接口：ProceedingJoinPoint。该接口有一个方法proceed()，此方法就相当于明确调用切入点方法。
     * 该接口可以作为环绕通知的方法参数，在程序执行时，spring框架会为我们提供该接口的实现类供我们使用。
     * <p>
     * spring中的环绕通知：
     * 它是spring框架为我们提供的一种可以在代码中手动控制增强方法何时执行的方式。
     */
    @Around("pt1()")
    public Object throundLog(ProceedingJoinPoint pjp) {
        Object rtValue = null;
        try {
            //得到方法执行所需的参数
            Object[] args = pjp.getArgs();

            System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。前置");
            //明确调用业务层方法（切入点方法）
            rtValue = pjp.proceed(args);

            System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。后置");

            return rtValue;
        } catch (Throwable t) {
            System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。异常");
            throw new RuntimeException(t);
        } finally {
            System.out.println("Logger类中的aroundPringLog方法开始记录日志了。。。最终");
        }
    }
}

4.在配置文件中开启组件扫描和 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"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

    <!--开启注解扫描所需的包-->
    <context:component-scan base-package="com.feilong"></context:component-scan>
    <!--开启注解AOP的支持-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

5.测试

public class TestMain {
    public static void main(String[] args) {
        ApplicationContext as= new ClassPathXmlApplicationContext("beans.xml");
        UserService userService = as.getBean("userService", UserService.class);
        userService.insertUser();
    }
}
weixin_44961111
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
# spring-aop 切入点 target 表达式
A_com_Z的博客
08-19 734
# spring aop target表达式 基本的格式：@PointCut（"target(包名.接口名)"） 具体如下例子实现： 1.PersonDao接口： package com.Aop.Expression; public interface PersonDao { //测试这个target 表达式 public void personsay(String ...
»Spring 之AOP AspectJ切入点语法详解（最全了，不需要再去其他地找了）
jinnianshilongnian的专栏
02-21 6781
6.5  AspectJ切入点语法详解 6.5.1  Spring AOP支持的AspectJ切入点指示符        切入点指示符用来指示切入点表达式目的，，在Spring AOP中目前只有执行方法这一个连接点，Spring AOP支持的AspectJ切入点指示符如下：          execution：用于匹配方法执行的连接点；          wi...
spring——AOP术语（Target(目标对象，目标类)，Joinpoint(连接点)，Pointcut(切入点)，Advice(通知/增强)，Aspect(切面)，Proxy（代理），织入）
Harden_zsc的博客
10-07 1651
Target(目标对象，目标类):代理的目标对象。例如：UserServiceImpl Joinpoint(连接点):程序的某个特定位置，比如类开始初始化前，初始化后，方法调用前后，抛出异常前后等。例如：eat方法调用前后 Pointcut(切入点):基于连接点，链接点描述的可以增强的点，如果真的在这个点增强了，那这个点就叫做切入点。例如：eat方法调用之前如果进行了增强，那这个点就叫做切入点 Advice(通知/增强):需要添加的那段增强功能的逻辑代码，通知的类型：前置通知,后置通知,异常通知,最终通知.
spring-aop组件详解——TargetSource目标源
stevenxyy的博客
03-12 916
spring aop
SpringAOP源码解析之TargetSource(四)
于琦海
10-26 455
在Spring框架中，TargetSource是一个接口，用于封装获取目标对象（也就是被代理的对象）的逻辑。它的主要作用是提供代理对象使用的目标对象，并且允许在运行时动态地切换目标对象。TargetSource在Spring的AOP（面向切面编程）中非常重要，它定义了代理对象的目标是谁以及在何时获取目标对象。具体来说，TargetSource接口定义了以下两个方法：getTarget()：这个方法用于获取目标对象。
详解spring中aop不生效的几种解决办法
08-19
在Spring框架中，AOP（Aspect-Oriented Programming）是一种非常有用的技术，可以帮助开发者在不修改源代码的情况下实现一些公共功能的实现。但是在实际开发中，AOP不生效的问题经常会出现在开发者的面前。本文将...
spring中AOP个人总结
01-21
spring中AOP个人总结 简介 aop（aspect oriented programming）面向切面编程是spring当中一个重要内容，在学习之后感觉这个思想挺不错的，做个总结 AOP讲解 一、面向切面编程 ​ 听说过面向对象编程（oop），但是...
spring中aop的xml配置方法实例详解
08-29
Spring中的AOP（面向切面编程）是一种编程范式，旨在将关注点分离，以便更好地管理系统的横切关注点，如日志、事务管理和权限控制等。AOP通过定义切面（Aspect）来封装这些关注点，使得核心业务逻辑与系统服务相互...
Spring 入门AOP材料
02-13
1. **导入依赖**：确保你的项目中已经引入了Spring AOP相关的依赖，例如`spring-aop`和`aspectjrt`。 2. **定义切面**：创建一个类，并使用`@Aspect`注解标记为切面。在这个类中，你可以定义切入点表达式和通知。 ...
spring-aop
03-17
Spring AOP，全称为Aspect...在`section6-AOP`这个压缩包中，可能包含了演示Spring AOP使用的代码示例，可以直接导入项目进行学习和实践。通过深入理解和运用这些示例，可以更好地掌握Spring AOP的核心概念和实际应用。
spring aop this、target说明
weixin_43931625的博客
04-24 822
spring aop this、target说明
spring aop 002: target && this
一步一步走
09-15 332
package com.thereisnospon.spring.demo.course.imp.c004_aop; import org.aspectj.lang.annotation.After; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Before; import org.a...
Spring Aop之Target Source详解
爱宝贝丶的博客
08-08 3786
【推荐】2019 Java 开发者跳槽指南.pdf(吐血整理) >>> ...
Aop（Aspect Oriented Programming，面向切面编程）
Luckydogs3036的博客
07-19 291
Advisor其实它就是Pointcut与Advice的组合，Advice是要增强的逻辑，而增强的逻辑要在什么地方执行是通过Pointcut来指定的所以Advice必需与Pointcut组合在一起，这就诞生了Advisor这个类，springAop中提供了一个Advisor接口将Pointcut与Advice的组合起来。AOP中会通过代理的方式，对目标对象生成一个代理对象，代理对象中会加入需要增强功能，通过代理对象来间接的方式目标对象，起到增强目标对象的效果。...
AOP（面向切面编程）学习笔记
qq_44865654的博客
11-01 191
AOP（面向切面编程）学习笔记 通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 AOP相关术语 Joinpoint(连接点): 被拦截到...
AOP之this与target区别分析
abel004的专栏
05-20 2127
AOP之this与target区别分析 官方文档： this - limits matching to join points (the execution of methods when using Spring AOP) where the bean reference (Spring AOP proxy) is an instance of the given type target ...
spring aop中this和target区别
04-24 1603
前置条件 其实考虑这个问题的时候必须知道springaop 中存在2中代理，一个是jdk代理，一个cglib代理，并且这两者是有区别的，首先知道的一点，jdk代理是目标对象实现接口，也就是说jdk代码是基于接口的方式 同样一个问题：jdk代理，目标对象能继承一个父类，而不实现接口吗？为什么？ jdk代理生成代理对象 这里我们编写一生成的代码片段如下截图 public class Test { public static void main(String[] args) throws IOExcept
Spring AOP 中定义切入点 @target 与 @within 的区别
最新发布
小单的博客专栏
12-26 678
另外需要注意的是，它俩是用于匹配类的，不适用在接口上标注注解的场景。匹配被设定注解标注的类，以及它的所有子类。仅匹配被设定注解标注的类，不包含其子类。不仅匹配该类，所有继承自。
springAOP中的target、this、within的区别
菜到怀疑人生的博客
09-03 7633
前言 关于这三者的区别，在网上找到的资料不多，大多是AspectJ的资料，并且大量的copy，查阅官方文档后，自己又做了一些实验，最终有了这篇博客，因为是自己摸索的结果，并且没有阅读相应源码，如有错误，欢迎指出（有空还是把markdown给看了，csdn的排版不是很喜欢...........   target target匹配目标对象的类型，即被代理对象的类型，例如A继承了B接口，则使用t...
spring中AOP
10-13
Spring中的AOP（面向切面编程）是一种编程范式，它允许开发人员在不改变原有代码的情况下，通过横向切割关注点（cross-cutting concerns）来实现对系统的增强。AOP的核心是切面（Aspect），切面定义了在哪些连接点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值