spring框架学习笔记04（AOP）

已于 2023-02-27 15:06:05 修改
阅读量666 收藏 3
点赞数 1
分类专栏： SSM框架相关学习记录 文章标签： spring java aop
于 2020-08-03 11:00:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45583303/article/details/106664932
版权

目录

Spring 中的 AOP

spring 的 aop就是通过配置的方式实现动态代理

01.AOP相关术语

Joinpoint(连接点)：

  • 所谓连接点是指那些可以被拦截到的点。在 spring 中，这些点指的是方法，因为 spring 只支持方法类型的连接点。
  • 通俗的说就是被代理类中的所有方法。

Pointcut(切入点)：

  • 所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义。
  • 通俗的说就是被代理类中的被代理的方法，因为被代理类中并不是所有的方法都被代理了。

Advice(通知/增强)：

  • 所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知。
  • 通俗的说就是对被代理的方法进行增强的代码。
  • 通知的类型：前置通知，后置通知，异常通知，最终通知，环绕通知
    • 前置通知：在被代理方法执行之前执行
    • 后置通知：在被代理方法执行之后执行
    • 异常通知：在被代理方法执行出错的时候执行
    • 最终通知：无论怎样都会执行
  • 注意：后置通知和异常通知只能有一个会被执行，因为发生异常执行异常通知，然后就不会继续向下执行，自然后置通知也就不会被执行，反之亦然。

Introduction(引介)：

  • 引介是一种特殊的通知在不修改类代码的前提下， Introduction 可以在运行期为类动态地添加一些方法或属性。

Target(目标对象)：

  • 代理的目标对象
  • 通俗的说就是被代理的对象

Weaving(织入)：

  • 是指把增强应用到目标对象来创建新的代理对象的过程，spring 采用动态代理织入，而 AspectJ 采用编译期织入和类装载期织入。
  • 通俗的说就是让增强的代码（通知）植入到待增强的方法（切入点）中。

Proxy（代理） :

  • 一个类被 AOP 织入增强后，就产生一个结果代理类。

Aspect(切面):

  • 是切入点和通知（引介）的结合
  • 通俗的说就是建立切入点和通知方法在创建时的对应关系

02.spring 的 AOP 要干什么事

开发阶段（我们做的）

  • 1.编写核心业务代码（前期）,
  • 2.把公用代码抽取出来，制作成通知（后期）（把公共的代码通过增强的的方式织入到方法中）
  • 3.在配置文件中，声明切入点与通知间的关系，即切面（重点）

运行阶段（ Spring 框架完成的）

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

03.关于代理的选择

看过动态代理就知道动态代理分为两种：基于接口的动态代理和基于子类的动态代理（cglib）

  • 当代理类实现了某个接口的时候：使用基于接口的动态代理
  • 当代理类没有实现任何接口的时候：使用基于子类的动态代理（cglib）

04.基于 XML 的 AOP 配置

大致步骤为：

  • 1.导入依赖jar包或者坐标
  • 2.创建 spring 的配置文件（bean.xml）并导入约束（AOP约束）
  • 3.在配置文件中配置 spring 的 ioc（IOC内容）
  • 4.抽取公共代码制作成通知（Transaction事务）

下面是aop配置

  • 5.把通知类用 bean 标签配置起来
  • 6.使用 aop:config 声明 aop 配置
  • 7.使用 aop:aspect 配置切面
  • 8.使用 aop:pointcut 配置切入点表达式
  • 9.使用 aop:xxx 配置对应的通知类型

05.AOP配置标签详解

5.1.aop:config标签

aop:config标签：表明开始AOP的配置

<aop:config>
	<!-- 添加内容-->
</aop:config>

5.2.aop:aspect标签

aop:aspect标签：表明配置切面

  • 标签位置：aop:config标签内部
  • id属性：是给切面提供一个唯一标识（可随意指定，一般都只指定有意义的名字）
  • ref属性：是指定通知类bean的Id
    <aop:config>
        <!--配置切面 -->
        <aop:aspect id="  " ref="  ">
           
        </aop:aspect>
</aop:config>

5.3.aop:xxx 标签

标签位置：aop:aspect标签内部

在aop:aspect标签的内部使用对应标签来配置通知的类型

在说以下通知类型：前置通知，后置通知。异常通知，最终通知

  • aop:before：表示配置前置通知
    • method属性：用于指定通知类中哪个方法是前置通知
    • pointcut属性：用于指定切入点表达式，该表达式的含义指的是对哪些方法进行增强
    • 联系起来就是：使用通知类中的那个方法，对待增强的方法进行增强，且增强的方法在待增强方法之前执行

切入点表达式的写法：

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

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

<aop:config>
        <!--配置切面 -->
        <aop:aspect id="  " ref="  ">
            <aop:before method="  " pointcut="execution(* com.aismall.service.impl.*.*(..))"></aop:before>
        </aop:aspect>
</aop:config>
  • aop:after-returning：表示配置后置通知
  • aop:after-throwing：表示配置异常通知
  • aop:after ：表示配置最终通知
  • 注意：这几种通知里面的写法都是相同的，配置完之后通知出现的顺序不同。

5.4.aop:pointcut 标签

作用：结合aop:XXX使用，简化配置

位置：可以再aop:aspect标签内部使用，与aop:XXX标签同级，这样就只当前切面可用也可以在aop:config标签内使用，与aop:aspect标签同级，这样aop:config标签内的所有切面都可以使用，例如：

<!--配置AOP-->
 <aop:config>
      <aop:pointcut id="pt1" expression="execution(* com.aismall.service.impl.*.*(..))"></aop:pointcut>
      <!--配置切面 -->
      <aop:aspect id="advice" ref="Advice">
      
          <!-- 配置前置通知：在切入点方法执行之前执行-->
          <aop:before method="beforeAdvice" pointcut-ref="pt1" ></aop:before>
          
          <!-- 配置后置通知：在切入点方法正常执行之后值。它和异常通知永远只能执行一个-->
          <aop:after-returning method="afterReturningAdvice" pointcut-ref="pt1"></aop:after-returning>

          <!-- 配置异常通知：在切入点方法执行产生异常之后执行。它和后置通知永远只能执行一个-->
          <aop:after-throwing method="afterThrowingAdvice" pointcut-ref="pt1"></aop:after-throwing>

          <!-- 配置最终通知：无论切入点方法是否正常执行它都会在其后面执行-->
          <aop:after method="afterAdvice" pointcut-ref="pt1"></aop:after>      
      </aop:aspect>
  </aop:config>

5.5.aop:around标签（环绕通知）

在spring的通知（Advice）中 一共有五种通知，之前已经介绍了四种，为什么不把环绕通知和他们放在一起说，因为环绕通知可以把前面的四种通知都表示出来，而且环绕通知一般单独使用。
在这里插入图片描述

环绕通知的使用：

  • 环绕通知使用会出现的问题?：
    • 当我们配置了环绕通知之后，切入点方法没有执行，而通知方法执行了。
  • 分析：
    • 通过对比动态代理中的环绕通知代码，发现动态代理的环绕通知有明确的切入点方法调用，而我们的代码中没有。
  • 解决：
    • Spring框架为我们提供了一个接口：ProceedingJoinPoint。该接口有一个方法proceed()，此方法就相当于明确调用切入点方法。
      该接口可以作为环绕通知的方法参数，在程序执行时，spring框架会为我们提供该接口的实现类供我们使用。
  • 注意：增强代码写在调用proceed()方法之前为前置通知，之后为后置通知，写在catch中为异常通知，写在finally中为最终通知

spring中的环绕通知：它是spring框架为我们提供的一种可以在代码中手动控制增强方法何时执行的方式，使用步骤如下：

  • 1.先写通知类中内容
 public Object aroundAdvice(ProceedingJoinPoint pjp){
        Object rtValue = null;
        try{
            Object[] args = pjp.getArgs();//得到方法执行所需的参数
            
            System.out.println("通知类中的aroundAdvice方法执行了。。前置");

            rtValue = pjp.proceed(args);//明确调用业务层方法（切入点方法）

            System.out.println("通知类中的aroundAdvice方法执行了。。后置");

            return rtValue;
        }catch (Throwable t){
           System.out.println("通知类中的aroundAdvice方法执行了。。异常");
            throw new RuntimeException(t);
        }finally {
           System.out.println("通知类中的aroundAdvice方法执行了。。最终");
        }
    }
  • 2.在配置中配置环绕通知
<!--配置AOP-->
<aop:config>
      <aop:pointcut id="pt1" expression="execution(* com.aismall.service.impl.*.*(..))"></aop:pointcut>
      <!--配置切面 -->
      <aop:aspect id="aroundAdvice" ref="Advice">
          <!-- 配置环绕通知 详细的注释请看Logger类中-->
          <aop:around method="aroundAdvice" pointcut-ref="pt1"></aop:around>
      </aop:aspect>
  </aop:config>

06.案例演示（基于XML）

演示spring中的AOP，具体看看spring是如何通过配置来实现动态代理的，在业务层演示如何通过配置的方式将业务代码进行增强。
在这里插入图片描述

6.1.新建一个maven项目（spring）

导入坐标

<packaging>jar</packaging>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.7</version>
        </dependency>
    </dependencies>

6.2.编写IAccountService接口和AccountServiceImpl.java实现类

IAccountService

/**
 * 账户的业务层接口
 */
public interface IAccountService {

    /**
     * 模拟保存账户
     */
   void saveAccount();
}
  • AccountServiceImpl.java
/**
 * 账户的业务层实现类
 */
public class AccountServiceImpl implements IAccountService{

    @Override
    public void saveAccount() {
        System.out.println("执行了保存");
//        int i=1/0;
    }
}

6.3.编写工具类Advice（通知类）

/**
 * 通知类，它里面提供了公共的代码
 */
public class Advice {

    /**
     * 前置通知
     */
    public  void beforeAdvice(){
        System.out.println("前置通知Advice类中的beforeAdvice方法执行了。。。");
    }

    /**
     * 后置通知
     */
    public  void afterReturningAdvice(){
        System.out.println("后置通知Advice类中的afterReturningAdvice方法开执行了。。。");
    }
    /**
     * 异常通知
     */
    public  void afterThrowingAdvice(){
        System.out.println("异常通知Advice类中的afterThrowingAdvice方法执行了。。。");
    }

    /**
     * 最终通知
     */
    public  void afterAdvice(){
        System.out.println("最终通知Advice类中的afterAdvice方法执行了。。。");
    }
     /**
     * 环绕通知
     */
    public Object aroundAdvice(ProceedingJoinPoint pjp){
        Object rtValue = null;
        try{
            Object[] args = pjp.getArgs();//得到方法执行所需的参数

            System.out.println("通知类中的aroundAdvice方法执行了。。前置");

            rtValue = pjp.proceed(args);//明确调用业务层方法（切入点方法）

            System.out.println("通知类中的aroundAdvice方法执行了。。后置");

            return rtValue;
        }catch (Throwable t){
            System.out.println("通知类中的aroundAdvice方法执行了。。异常");
            throw new RuntimeException(t);
        }finally {
            System.out.println("通知类中的aroundAdvice方法执行了。。最终");
        }
    }
}

6.4.bean.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">

    <!-- 配置srping的Ioc,把service对象配置进来-->
    <bean id="accountService" class="com.aismall.service.impl.AccountServiceImpl"></bean>

    <!-- 配置advice通知类 -->
    <bean id="advice" class="com.aismall.utils.Advice"></bean>

    <!--配置AOP-->
    <aop:config>
        <!--为了使所有切面都可以使用，此标签配置在外面-->
        <aop:pointcut id="pt1" expression="execution(* com.aismall.service.impl.*.*(..))"></aop:pointcut>
        <!--配置切面 -->
        <aop:aspect id="advice" ref="advice">
            <!-- 配置前置通知：在切入点方法执行之前执行-->
            <aop:before method="beforeAdvice" pointcut-ref="pt1"></aop:before>

            <!-- 配置后置通知：在切入点方法正常执行之后值。它和异常通知永远只能执行一个-->
            <aop:after-returning method="afterReturningAdvice" pointcut-ref="pt1"></aop:after-returning>

            <!-- 配置异常通知：在切入点方法执行产生异常之后执行。它和后置通知永远只能执行一个-->
            <aop:after-throwing method="afterThrowingAdvice" pointcut-ref="pt1"></aop:after-throwing>

            <!-- 配置最终通知：无论切入点方法是否正常执行它都会在其后面执行-->
            <aop:after method="afterAdvice" pointcut-ref="pt1"></aop:after>
            <!-- 配置环绕通知-->
            <!--<aop:around method="aroundAdvice" pointcut-ref="pt1"></aop:around>-->
        </aop:aspect>
    </aop:config>
</beans>

6.5.编写测试类AOPTest.java

/**
 * 测试AOP的配置
 */
public class AOPTest {

    public static void main(String[] args) {
        //1.获取容器
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        //2.获取对象
        IAccountService as = (IAccountService)ac.getBean("accountService");
        //3.执行方法
        as.saveAccount();
    }
}

6.6.运行结果

前置通知Advice类中的beforeAdvice方法执行了。。。
执行了保存
后置通知Advice类中的afterReturningAdvice方法开执行了。。。
最终通知Advice类中的afterAdvice方法执行了。。。

07.案例演示（基于注解）

在这里插入图片描述

  • 案例的总体实现功能和上面那个案例是一样的，只不过是使用注解的方式
  • 创建工程后需要导入的坐标，测试方法AOPTest.java和IAccount接口都和之前的一样。

在AccountServiceImpl.java中添加注解：@Service("accountService")

/**
 * 账户的业务层实现类
 */
@Service("accountService")
public class AccountServiceImpl implements IAccountService{

    @Override
    public void saveAccount() {
        System.out.println("执行了保存");
        //int i=1/0;
    }
}

bean.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:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       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
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- 配置spring创建容器时要扫描的包-->
    <context:component-scan base-package="com.aismall"></context:component-scan>

    <!-- 配置spring开启注解AOP的支持 -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

通知类使用注解进行配置（重点）

/**
 * 通知类，它里面提供了公共的代码
 */
@Component("advice")
@Aspect//表示当前类是一个切面类
public class Advice {

    @Pointcut("execution(* com.aismall.service.impl.*.*(..))")
    private void pt1(){}

    /**
     * 前置通知
     */
     @Before("pt1()")
    public  void beforePrintLog(){
         System.out.println("前置通知Advice类中的beforeAdvice方法执行了。。。");
    }

    /**
     * 后置通知
     */
    @AfterReturning("pt1()")
    public  void afterReturningPrintLog(){
        System.out.println("后置通知Advice类中的afterReturningAdvice方法开执行了。。。");
    }
    /**
     * 异常通知
     */
    @AfterThrowing("pt1()")
    public  void afterThrowingPrintLog(){
        System.out.println("异常通知Advice类中的afterThrowingAdvice方法执行了。。。");
    }

    /**
     * 最终通知
     */
    @After("pt1()")
    public  void afterPrintLog(){
        System.out.println("最终通知Advice类中的afterAdvice方法执行了。。。");
    }

    //@Around("pt1()")
    public Object aroundAdvice(ProceedingJoinPoint pjp){
        Object rtValue = null;
        try{
            Object[] args = pjp.getArgs();//得到方法执行所需的参数

            System.out.println("通知类中的aroundAdvice方法执行了。。前置");

            rtValue = pjp.proceed(args);//明确调用业务层方法（切入点方法）

            System.out.println("通知类中的aroundAdvice方法执行了。。后置");

            return rtValue;
        }catch (Throwable t){
            System.out.println("通知类中的aroundAdvice方法执行了。。异常");
            throw new RuntimeException(t);
        }finally {
            System.out.println("通知类中的aroundAdvice方法执行了。。最终");
        }
    }
}

08.AOP中使用基于注解和XML的注意事项

AOP中使用注解进行配置时选用：环绕通知

  • 原因：使用（前置通知，后置通知，异常通知，最终通知）时，执行顺序有问题，先执行前置通知，然后执行最终通知，再执行后置通知或者异常通知

AOP中使用XML进行配置时选用环绕通知或者使用这一组通知（前置通知，后置通知，异常通知，最终通知）都可以，优先使用（前置通知，后置通知，异常通知，最终通知），因为简单。

彤彤的小跟班
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
SpringAOP学习笔记
01-27
AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性...
Spring学习(9)-AOP之使用aop:config标签
此成非彼诚博客
05-04 4936
AOP之使用aop:config标签
12.AOP的专属标签——aop:config
weixin_44137201的博客
09-08 856
主要表现是使用AspectJ的expression的操作: execution(modifiers-pattern ret-type-pattern declaring-type-pattern name-pattern(param-pattern) throws-pattern) 除了返回类型模式,名字模式和参数模式以外,所有的部分都是可选的。 返回类型模式决定了方法的返回类型必须依次匹配一个连接点。 你会使用的最频繁的返回类型模式是∗,它代表了匹配任意的返回类型。 一个全称限定的类型名将只会匹配返回给定
Spring(五)——【面向切面编程AOP】，2024年最新java面试笔记
最新发布
2401_84104577的博客
04-20 621
引领完成Docker的安装、部署、管理和扩展，让其经历从测试到生产的整个开发生命周期，深入了解Docker适用于什么场景。并且这本Docker的学习权威指南介绍了其组件的基础知识，然后用Docker构建容器和服务来完成各种任务：利用Docker为新项目建立测试环境，演示如何使用持续集成的工作流集成Docker，如何构建应用程序服务和平台，如何使用Docker的API，如何扩展Docker。
Spring 9：aop:config标签
ZJLOVE的博客
10-25 9089
aop:config标签    使用aop的专用标签来完成相关的配置.（AOP标签库）    其中主要表现是使用AspectJ的expression的操作:    execution(modifiers-pattern ret-type-pattern declaring-type-pattern name-pattern(param-pattern)      thro...
Spring-AOP配置(XML)
汤键的博客
09-17 3184
Spring-AOP配置(XML)
AOP简单相关配置
qq_40432598的博客
11-14 944
AOP简单相关配置
Spring框架学习笔记文档
10-30
Spring框架的学习笔记，包括了springIOC，spirng注入，springAoP，SpringJdbc模板的使用，Spring声明式事务。
spring框架整体学习笔记
08-05
spring框架整体知识点整理，代码样例
轻量级框架Spring学习笔记
01-25
非常详细的Spring框架其中包括Spring关于IOC、DI、AOP 和事务的相关模块。仅供参考。
spring框架学习笔记
11-04
Spring框架是Java应用开发中广泛使用的轻量级框架，它以IoC（Inversion of Control，控制反转）和DI（Dependency Injection，依赖注入）为核心，提供了丰富的功能，包括但不限于组件管理、AOP（Aspect Oriented ...
spring-aop 之 aop:config
悟已往之不谏，知来者之可追
10-10 846
开头 aop部分的解析器由AopNamespaceHandler注册，其init方法: @Override public void init() { registerBeanDefinitionParser("config", new ConfigBeanDefinitionParser()); registerBeanDefinitionParser("aspectj-autoproxy", new AspectJAutoProxyBeanDefinitionParser());
<aop:config>
二进制的专栏
03-17 3129
6.3. Schema-based AOP support 如果你无法使用Java 5，或者你比较喜欢使用XML格式，Spring2.0也提供了使用新的"aop"命名空间来定义一个切面。 和使用@AspectJ风格完全一样，切入点表达式和通知类型同样得到了支持，因此在这一节中我们将着重介绍新的语法 和回顾前面我们所讨论的如何写一个切入点表达式和通知参数的绑定（Section 6.2,
SpringAOP
huanghai_fu的博客
07-18 177
AOP 一，AOP概念及作用 1,概念作用 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SDFvsXFd-1595069781332)(E:\每日讲课笔记\Spring\img\1594862540226.png)] [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-90WZbO4P-1595069781334)(E:\每日讲课笔记\Spring\img\1594862623416.png)] AOP概念(不修改源代码进行功能增强)
Spring AOP笔记
m0_61864330的博客
05-31 119
对Spring中的aop概念进行总结，仅供学习
spring AOP中的<aop:config>配置
onpwerb的博客
09-01 2701
aop:config配置一个application可以包含多个“aop:config”,一个”aop:config”要按顺序配置pointcut, advisor 和aspect。切面aspect, 用aop:aspect声明，比如：<aop:config> <aop:aspect id = "aspect" ref = "myBean"> .... </aop:aspect><
Spring AOP 标签形式及Around增强处理
Du_ZiLin的博客
03-02 995
上一篇文章介绍了下Spring中的AOP xml配置方式。想了解的同学可以点击这里查看。 这次写一下标签形式。 首先要在spring配置文件中加入上面的标签，类似于 自动扫面相关的标签。 切面类：package com.du; import org.aspectj.lang.annotation.After; import org.aspectj.lang.annotation
Spring5框架（AOP）
weixin_44742328的博客
03-17 186
1、什么是 AOP （1）面向切面编程（方面），利用 AOP 可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 （2）通俗描述：不通过修改源代码方式，在主干功能里面添加新功能 （3）使用登录例子说明 AOP AOP（底层原理） 1、AOP 底层使用动态代理 （1）有两种情况动态代理 第一种 有接口情况，使用 JDK 动态代理 创建接口实现类代理对象，增强类的方法 第二种 没有接口情况，使用 CGLIB 动态代理 创建子类的代理对象
Spring AOP之aop:config
小9的专栏
09-15 2772
Spring在某个版本之后开始支持一组新的xml标签用来简化配置，如context，aop，mvc等，下面我们来看看aop标签的配置方法。
spring框架学习
09-14
1. 基本概念：首先，了解Spring框架的基本概念和核心特性，例如控制反转（IoC）和面向切面编程（AOP）。可以阅读官方文档或者参考一些教程来获得更多的了解。 2. Spring Boot：学习使用Spring Boot，它是Spring框架...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

彤彤的小跟班

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值