Spring——AOP中5大通知注解的理解与使用

AspectJ与AOP通知
已于 2024-04-24 10:15:48 修改
阅读量8.5k 收藏 10
点赞数 3
CC 4.0 BY-SA版权
分类专栏： # 【Spring】 文章标签： spring log4j java
于 2021-03-11 15:45:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43823808/article/details/114668084
本文介绍如何使用AspectJ框架实现AOP中的五大通知注解，包括前置、后置、环绕、异常及最终通知，并解释如何定义切入点。

文章目录：

1.引子

1.1 大致步骤 

1.2 pom.xml文件中加入maven依赖

1.2.1 spring依赖 

1.2.2 spring-aspects依赖

1.2.3 单元测试依赖 

1.3 在Spring配置文件中声明AspectJ的自动代理生成器

2.AOP中的5大通知注解

2.1 @Before：前置通知

2.2 @AfterReturning：后置通知

2.3 @Around：环绕通知

2.4 @AfterThrowing：异常通知

2.5 @After：最终通知

3.@Pointcut 定义切入点

1.引子

承接了上一篇文章：Spring——AOP基本概念的理解_spring aop概念-CSDN博客

这篇文章中，主要介绍一下通过 AspectJ 框架更好的理解和使用 AOP 的5大通知注解。

在 AspectJ 实现 AOP 时，要引入 AOP 的约束。配置文件中使用的 AOP 约束中的标签，均是 AspectJ 框架使用的，而非 Spring 框架本身在实现 AOP 时使用的。AspectJ 对于 AOP 的实现有注解和配置文件两种方式，常用是注解方式。

1.1 大致步骤 

使用apsectj框架的注解，实现前置通知，步骤如下：
1.新建Maven项目

2.修改pom.xml，加入依赖
    spring-context依赖、spring-aspects依赖、junit

3.创建业务接口和实现类

4.创建一个切面类（普通类）
    1) 在类的上面加入@Aspect
    2) 在类中定义方法，方法表示切面的功能。在方法的上面加入AspectJ框架中的通知注解
       例如：@Before(value="切入点表达式")

5.创建spring配置文件
    1) 声明目标对象
    2) 声明切面类对象
    3) 声明自动代理生成器

6.创建测试类，测试目标方法执行时，增加切面的功能

1.2 pom.xml文件中加入maven依赖

1.2.1 spring依赖 

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

1.2.2 spring-aspects依赖

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-aspects</artifactId>
  <version>5.2.5.RELEASE</version>
</dependency>

1.2.3 单元测试依赖 

<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>4.11</version>
  <scope>test</scope>
</dependency>

1.3 在Spring配置文件中声明AspectJ的自动代理生成器

<?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 https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 声明自动代理生成器，目的是创建目标对象的代理 -->
    <aop:aspectj-autoproxy />
</beans>

2.AOP中的5大通知注解

2.1 @Before：前置通知

/**
 * 前置通知方法的定义
 * 1) 方法是public
 * 2) 返回值是void
 * 3) 方法名称自定义
 * 4) 可以有参数，也可以无参数。如果有，参数是JoinPoint
 *
 * @Before: 前置通知
 *     属性: value 切入点表达式，表示切面的执行位置。在这个方法执行时，会同时执行切面的功能
 *     位置: 放在方法的上面
 *     特点: 1) 执行时间在目标方法之前先执行
 *           2) 不会影响目标方法的执行
 *           3) 不会修改目标方法的执行结果
 *  切面类中的通知方法，可以有参数。必须是JoinPoint
 *  JoinPoint: 表示正在执行的业务方法，相当于反射中的Method
 *   使用要求: 必须是参数列表的第一个
 *       作用: 获取方法执行时的信息，例如方法名称、方法的参数集合
 */
package com.bjpowernode.service;

/**
 *
 */
public interface SomeService {

    void doSome(String name,Integer age);

    void doOther();
}

package com.bjpowernode.service.impl;

import com.bjpowernode.service.SomeService;

public class SomeServiceImpl implements SomeService {
    @Override
    public void doSome(String name, Integer age) {
        System.out.println("业务方法doSome()，创建商品的订单");
    }

    @Override
    public void doOther() {
        System.out.println("业务方法doOther()");
    }
}

package com.bjpowernode.handle;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

import java.util.Date;

/**
 *  @Aspect: 切面类的注解
 *      位置: 放在某个类的上面
 *      作用: 表示当前类是切面类
 */
@Aspect
public class MyAspect {

    @Before(value = "execution(public void com.bjpowernode.service.impl.SomeServiceImpl.do*(..))")
    public void myBefore(JoinPoint joinPoint) {
        //获取方法的完整定义
        System.out.println("前置通知，获取目标方法的定义: " + joinPoint.getSignature());
        //获取方法的名称
        System.out.println("前置通知，获取目标方法的名称: " + joinPoint.getSignature().getName());
        //获取方法执行时的参数
        Object[] args=joinPoint.getArgs();
        for(Object obj : args) {
            System.out.println("前置通知，获取目标方法的参数: " + obj);
        }
        String methodName=joinPoint.getSignature().getName();
        if(methodName.equals("doSome")) {
            //切面的代码
            System.out.println("doSome输出日志=========前置通知，切面的功能，在目标方法之前先执行: " + new Date());
        }else if(methodName.equals("doOther")) {
            //切面的代码
            System.out.println("doOther输出日志========前置通知，作为方法名称、参数的记录");
        }
    }
}

    <!-- 声明目标对象 -->
    <bean id="someService" class="com.bjpowernode.service.impl.SomeServiceImpl"/>

    <!-- 声明切面类对象 -->
    <bean id="myAspect" class="com.bjpowernode.handle.MyAspect"/>

    <!-- 声明自动代理生成器，目的是创建目标对象的代理 -->
    <aop:aspectj-autoproxy />
    @Test
    public void test01() {
        String config="applicationContext.xml";
        ApplicationContext ctx=new ClassPathXmlApplicationContext(config);
        SomeService service= (SomeService) ctx.getBean("someService");
        System.out.println("service === " + service.getClass().getName());
        service.doSome("张起灵",20);
        //service.doOther();
    }

2.2 @AfterReturning：后置通知

/**
 *  后置通知方法的定义
 *  1) 方法是public
 *  2) 返回值是void
 *  3) 方法名称自定义
 *  4) 方法有参数，推荐使用Object
 *
 *  @AfterReturning: 后置通知
 *  属性: value 切入点表达式
 *       returning 自定义的变量，表示目标方法的返回值的返回值。
 *                 自定义变量的名称必须和通知方法的形参名一样
 *  位置: 放在方法的上面
 *  特点: 1) 在目标方法之后执行
 *        2) 能获取到目标方法的执行结果
 *        3) 不会影响目标方法的执行
 *  方法的参数Object res，表示目标方法的返回值，使用res接收doOther的调用结果
 */
package com.bjpowernode.service;

/**
 *
 */
public interface SomeService {

    String doOther(String name,Integer age);
}

package com.bjpowernode.service.impl;

import com.bjpowernode.service.SomeService;

public class SomeServiceImpl implements SomeService {

    @Override
    public String doOther(String name, Integer age) {
        System.out.println("执行业务方法doOther()，处理库存");
        return "abcd";
    }
}

package com.bjpowernode.handle;

import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;

/**
 *  @Aspect: 切面类的注解
 *      位置: 放在某个类的上面
 *      作用: 表示当前类是切面类
 */
@Aspect
public class MyAspect {

    @AfterReturning(value = "execution(* *..SomeServiceImpl.doOther(..))",
                    returning = "res")
    public void myAfterReturning(Object res) {
        System.out.println("后置通知，在目标方法之后执行的，可以拿到执行结果" + res);
    }
}

    <!-- 声明目标对象 -->
    <bean id="someService" class="com.bjpowernode.service.impl.SomeServiceImpl"/>

    <!-- 声明切面类对象 -->
    <bean id="myAspect" class="com.bjpowernode.handle.MyAspect"/>

    <!-- 声明自动代理生成器，目的是创建目标对象的代理 -->
    <aop:aspectj-autoproxy />
    @Test
    public void test01() {
        String config="applicationContext.xml";
        ApplicationContext ctx=new ClassPathXmlApplicationContext(config);
        SomeService service= (SomeService) ctx.getBean("someService");
        System.out.println("service === " + service.getClass().getName());
        service.doOther("张三",25);
    }

2.3 @Around：环绕通知

/**
 *  环绕通知方法的定义
 *  1) 方法是public
 *  2) 必须有返回值，推荐使用Object类型
 *  3) 方法名称自定义
 *  4) 必须有ProceedingJoinPoint参数
 *
 *  @Around: 环绕通知
 *      属性: value 切入点表达式
 *      位置: 在方法定义的上面
 *  测试方法中，调用目标方法doFirst(String name)去执行，
 *  实际上目标方法doFirst(String name)并未执行，而是执行了myAround(ProceedingJoinPoint proceedingJoinPoint)
 *  特点: 1) 在目标方法的前和后都能增强功能
 *        2) 控制目标方法是否执行
 *        3) 修改目标方法的执行结果
 */
package com.bjpowernode.service;

/**
 *
 */
public interface SomeService {

    String doFirst(String name);
}

package com.bjpowernode.service.impl;

import com.bjpowernode.service.SomeService;

public class SomeServiceImpl implements SomeService {

    @Override
    public String doFirst(String name) {
        System.out.println("执行业务方法doFirst()，处理库存");
        return "doFirst";
    }
}

package com.bjpowernode.handle;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;

import java.util.Date;

/**
 *  @Aspect: 切面类的注解
 *      位置: 放在某个类的上面
 *      作用: 表示当前类是切面类
 */
@Aspect
public class MyAspect {

    @Around(value = "execution(* *..SomeServiceImpl.doFirst(..))")
    public Object myAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        //获取方法执行时的参数值
        String name="";
        Object[] args=proceedingJoinPoint.getArgs();
        if(args!=null && args.length>0) {
            Object arg=args[0];
            if(arg!=null) {
                name=(String)arg;
            }
        }
        System.out.println("执行了环绕通知，在目标方法之前，输出日志时间=== " + new Date());
        Object methodReturn=null;
        if(name.equals("李四")) {
            //相当于执行目标方法doFirst(String name)
            methodReturn = proceedingJoinPoint.proceed();
        }
        System.out.println("执行了环绕通知，在目标方法之后，增加了事务功能");
        return methodReturn;
    }
}

    <!-- 声明目标对象 -->
    <bean id="someService" class="com.bjpowernode.service.impl.SomeServiceImpl"/>

    <!-- 声明切面类对象 -->
    <bean id="myAspect" class="com.bjpowernode.handle.MyAspect"/>

    <!-- 声明自动代理生成器，目的是创建目标对象的代理 -->
    <aop:aspectj-autoproxy />
    @Test
    public void test01() {
        String config="applicationContext.xml";
        ApplicationContext ctx=new ClassPathXmlApplicationContext(config);
        SomeService service= (SomeService) ctx.getBean("someService");
        System.out.println("service === " + service.getClass().getName());
        String ret=service.doFirst("李四");
        System.out.println("ret调用目标方法的结果 === " + ret);
    }

2.4 @AfterThrowing：异常通知

/**
 *  异常通知方法的定义
 *  1) 方法是public
 *  2) 返回值是void
 *  3) 方法名称自定义
 *  4) 方法有参数Exception
 *
 *  @AfterThrowing: 异常通知
 *  属性: value 切入点表达式
 *       throwing 自定义变量，表示目标方法抛出的异常。变量名必须和通知方法的形参名一样
 *  位置: 在方法上面
 *  特点: 1) 在目标方法抛出异常之后执行的，若没有异常 则不执行
 *        2) 能获取到目标方法的异常信息
 *        3) 不是异常处理程序，可以得到发生异常的通知，可以发送邮件、短信通知开发人员
 *           可以看作是目标方法的监控程序
 *  可以看作以下语句块:
 *  try {
 *      SomeServiceImpl.doSecond(..)
 *  }catch(Exception ex) {
 *      myAfterThrowing(Exception ex)
 *  }
 */
package com.bjpowernode.service;

/**
 *
 */
public interface SomeService {

    void doSecond(String name);
}

package com.bjpowernode.service.impl;

import com.bjpowernode.service.SomeService;

public class SomeServiceImpl implements SomeService {

    @Override
    public void doSecond(String name) {
        System.out.println("执行业务方法doSecond()，处理库存" + (10/0));
    }
}

package com.bjpowernode.handle;

import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;

/**
 *  @Aspect: 切面类的注解
 *      位置: 放在某个类的上面
 *      作用: 表示当前类是切面类
 */
@Aspect
public class MyAspect {

    @AfterThrowing(value = "execution(* *..SomeServiceImpl.doSecond(..))",throwing = "ex")
    public void myAfterThrowing(Exception ex) {
        System.out.println("异常通知，在目标方法抛出异常时执行的，异常原因是：" + ex.getMessage());
    }
}

    <!-- 声明目标对象 -->
    <bean id="someService" class="com.bjpowernode.service.impl.SomeServiceImpl"/>

    <!-- 声明切面类对象 -->
    <bean id="myAspect" class="com.bjpowernode.handle.MyAspect"/>

    <!-- 声明自动代理生成器，目的是创建目标对象的代理 -->
    <aop:aspectj-autoproxy />

2.5 @After：最终通知

/**
 *  最终通知方法的定义
 *  1) 方法是public
 *  2) 返回值是void
 *  3) 方法名称自定义
 *  4) 方法无参数
 *
 *  @After: 最终通知
 *  属性: value 切入点表达式
 *  位置: 在方法上面
 *  特点: 1) 在目标方法之后执行的
 *        2) 总是会被执行
 *        3) 可以用来做程序最后的收尾工作，例如清除临时数据、变量，清理内存
 *  可以看作如下语句块:
 *  try {
 *      SomeServiceImpl.doThird(..)
 *  }finally {
 *      myAfter()
 *  }
 */
package com.bjpowernode.service;

/**
 *
 */
public interface SomeService {

    void doThird();
}

package com.bjpowernode.service.impl;

import com.bjpowernode.service.SomeService;

public class SomeServiceImpl implements SomeService {

    @Override
    public void doThird() {
        System.out.println("执行业务方法doThird()");
    }
}

package com.bjpowernode.handle;

import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;

/**
 *  @Aspect: 切面类的注解
 *      位置: 放在某个类的上面
 *      作用: 表示当前类是切面类
 */
@Aspect
public class MyAspect {

    @After(value = "execution(* *..SomeServiceImpl.doThird(..))")
    public void myAfter() {
        System.out.println("最终通知，总是会被执行的");
    }
}

    <!-- 声明目标对象 -->
    <bean id="someService" class="com.bjpowernode.service.impl.SomeServiceImpl"/>

    <!-- 声明切面类对象 -->
    <bean id="myAspect" class="com.bjpowernode.handle.MyAspect"/>

    <!-- 声明自动代理生成器，目的是创建目标对象的代理 -->
    <aop:aspectj-autoproxy />
    @Test
    public void test01() {
        String config="applicationContext.xml";
        ApplicationContext ctx=new ClassPathXmlApplicationContext(config);
        SomeService service= (SomeService) ctx.getBean("someService");
        System.out.println("service === " + service.getClass().getName());
        service.doThird();
    }

3.@Pointcut 定义切入点

当较多的通知增强方法使用相同的 execution 切入点表达式时，编写、维护均较为麻烦。AspectJ 提供了 @Pointcut 注解，用于定义 execution 切入点表达式。

其用法是，将 @Pointcut 注解在一个方法之上，以后所有的 execution 的 value 属性值均可使用该方法名作为切入点。代表的就是@Pointcut 定义的切入点。这个使用 @Pointcut 注解的方法一般使用 private 的标识方法，即没有实际作用的方法。

下面的代码只给出切面类：👇👇👇

package com.bjpowernode.handle;

import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;

/**
 *  @Aspect: 切面类的注解
 *      位置: 放在某个类的上面
 *      作用: 表示当前类是切面类
 */
@Aspect
public class MyAspect {

    @Before(value = "mypt()")
    public void myBefore() {
        System.out.println("前置通知，在目标方法之前先执行的");
    }

    @After(value = "mypt()")
    public void myAfter() {
        System.out.println("最终通知，总是会被执行的");
    }

    /**
     * @Pointcut: 定义和管理切入点，不是通知注解
     *       属性: value 切入点表达式
     *       位置: 在一个自定义方法的上面，此方法被看作是切入点表达式的别名
     *            在其他通知注解中，可以使用此方法名称，表示使用这个切入点表达式
     */
    @Pointcut(value = "execution(* *..SomeServiceImpl.doThird(..))")
    private void mypt() {
        //无需代码
    }
}

Spring框架——AOP前置、后置、环绕、异常通知
2401_84047990的博客
04-17 1282
System.out.println(“前置通知，记录日志…”+method.getName());System.out.println(“出异常了…”+e.getMessage());System.out.println(“环绕通知，调用环绕方法前…System.out.println(“环绕通知，调用环绕方法后…后置通知类：MyAfterReturningAdvice.java。System.out.println(“后置通知，关闭资源…前置通知类：MyMethodBeforeAdvice.java。
一文带你搞懂环绕通知@Around与最终通知@After的实现
weixin_48826996的博客
07-26 3384
它是通过拦截目标方法的方式,在目标方法前后增强功能的通知.它是功能最强大的通知,一般事务使用此通知.它可以轻易的改变目标方法的返回值。
SpringAOP面向切面编程
最新发布
2401_87497889的博客
07-07 641
Spring AOP 摘要（149字） Spring AOP是面向切面编程的实现，通过@EnableAspectJAutoProxy启用。提供五种通知类型：@Before（前置）、@After（后置）、@AfterThrowing（异常）、@AfterReturning（返回）和@Around（环绕）。切点表达式可通过@Pointcut定义，支持execution、within和annotation匹配方式。底层采用动态代理机制：JDK代理要求接口实现，CGLIB可代理普通类（final类除外）。JDK8+
Javaweb之SpringBootWeb案例之AOP通知类型的详细解析
qq_69748833的博客
02-16 1337
此时我们的代码当中就存在了大量的重复性的切入点表达式，假如此时切入点表达式需要变动，就需要将所有的切入点表达式一个一个的来改动，就变得非常繁琐了。@Around环绕通知方法的返回值，必须指定为Object，来接收原始方法的返回值，否则原始方法执行完毕，是获取不到返回值的。@Around环绕通知中原始方法调用时有异常，通知中的环绕后的代码逻辑也不会在执行了 （因为原始方法调用已经出异常了）@AfterReturning ： 返回后通知，此注解标注的通知方法在目标方法后被执行，有异常不会执行。
Spring Aop--通知注解
Alphamilk的博客
09-01 926
一、环绕注解 二、优先级注解
AOP的常用注解
Kato_op的博客
05-08 8936
AOP的常用注解 @Aspect： 作用：把当前类声明为切面类。 @Before： 作用：把当前方法看成是前置通知。 属性： value：用于指定切入点表达式，还可以指定切入点表达式的引用。 讲师：陈飞 @AfterReturning 作用：把当前方法看成是后置通知。 属性： value：用于指定切入点表达式，还可以...
Spring——AOP原理及流程详解
热门推荐
共勉
11-28 1万+
基于5.3.9 版本的Spring源码，对AOP原理及流程详解，AOP是在Bean生成流程中什么位置介入处理的？各个通知方法又是怎么组装的？AOP真的只是动态代理这么简单吗？
Spring——aop
12-23
- **基于注解的AOP**：在Spring 2.5之后引入，无需编写XML配置，直接在方法上使用注解如`@Before`, `@After`, `@Around`, `@AfterThrowing`等定义通知。 ### 3. Spring AOP的核心组件 - **`@Aspect`**：标记一个类...
Spring注解驱动开发第33讲——AOP原理总结
08-06
Spring注解驱动开发第33讲——AOP原理总结
Spring5框架——AOP操作：通过Aspectj注解方式和配置文件方式来实现
m0_52479012的博客
10-04 763
spring5框架——AOP：通过注解的方式去实现Aop操作
解析Spring AOP技术的通知类型、顺序与应用
02-10
内容概要：本文详细介绍了Spring中AOP(面向切面编程)的基础知识，重点讲述了五种常见的通知类型：环绕通知(@Around)，前置通知(@Before)，后置通知(@After)，返回后通知(@AfterReturning)以及异常后通知(@...
注解实现AOP通知
04-25
在AOP注解中一共分为五中类型的通知注解，接下来，我们通过实例，对这五种AOP注解进行讲解
Spring——AOP的5大通知注解使用
莫得感情得码农
08-05 2181
1.使用AOP通知注解的步骤 使用apsectj框架的注解，实现前置通知，步骤如下： 1.新建Maven项目 2.修改pom.xml，加入依赖 spring-context依赖、spring-aspects依赖、junit 3.创建业务接口和实现类 4.创建一个切面类（普通类） 1) 在类的上面加入@Aspect 2) 在类中定义方法，方法表示切面的功能。在方法的上面加入AspectJ框架中的通知注解 例如：@Before(value="切入点表达式") 5...
AOP的理解及五种通知演示
Yaoao_的博客
05-09 1592
AOP(（Aspect-Oriented Programming)即面向切面编程,它是一种编程范式,是一种思想.它是Spring框架的重要组成部分Spring整体架构图。
Spring的AOP五大通知注解
weixin_45737309的博客
01-23 787
通知注解 ：声明方法，在方法前加入通知注解,指定要拦截的对象信息注意：* 代表任意修饰符号 任意值AOP五大通知注解:@Before 前置通知，在方法执行之前执行@Af...
AOP常用注解
dfay89490的博客
06-30 241
1、@Aspect 配置切面Bean，和<bean.../>元素进行配置无区别，一样支持依赖注入来配置属性值； 如果启动了Spring的“零配置”特性，一样可以让Spring自动搜索，并加载指定路径下的切面Bean 使用@Aspect修饰的类（切面类）和其他类一样可以有方法、成员变量定义，还可能包括切入点、增强处理定义 使用@Aspect修饰类，Spring将不会把该Bea...
Spring AOP : Advice 声明 （通知注解）
爱莲说的博客
07-26 761
Advice 的类型 before advice：在 join point 前被执行的 advice. 虽然 before advice 是在 join point 前被执行, 但是它并不能够阻止 join point 的执行, 除非发生了异常(即我们在 before advice 代码中, 不能人为地决定是否继续执行 join point 中的代码) after return advice：
来理解AOP中的"通知"
carterslam的专栏
03-29 694
首先解释一下概念:    AOP:面向方面编程    通知：分为 前置通知，后置通知，环绕通知，异常通知              此处以前置通知为例，它的意思 就是在业务代码执行前要执行的方法  这个理解很含糊，此处待编辑......            看实例：             1.定义一个接口       public interface BookService {        
SpringAop注解版1 - 四种通知
stone的博客
02-01 501
什么是Aop aop被称为面向切面编程，使用动态代理的方式在执行前后或出现异常后做相关逻辑. aop 是oop的一种延续通过预编译方式和运行时期动态代理实现程序功能的一种技术，利用aop可以对业务逻辑的各个部分进行分离，从而使得业务逻辑部分之间的耦合度降低，提高程序的可重用性，同时提高代码的开发效率。在程序运行期间，不修改源码的对已有的方法进行增强 ...
Spring注解AOP编程示例教程
-- 在applicationContext.xml中开启AOP注解 --> <aop:aspectj-autoproxy /> ``` 或者在Java配置类中添加相应的注解。 ```java @Configuration @EnableAspectJAutoProxy public class AppConfig { // ... } ``` #...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

贝尔摩德苦艾酒

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

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

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

打赏作者

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

抵扣说明：

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

余额充值