详解Spring实现AOP的多种方式

最新推荐文章于 2025-08-20 15:04:37 发布
最新推荐文章于 2025-08-20 15:04:37 发布
阅读量90 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： java netty runtime
原文链接：https://juejin.im/post/5b9e326e6fb9a05ce37ae6d2

AOP（Aspect Oriented Programming）面向切面编程，通过预编译方式和运行期动态代理实现程序功能的横向多模块统一控制的一种技术。AOP是OOP的补充，是Spring框架中的一个重要内容。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。AOP可以分为静态织入与动态织入，静态织入即在编译前将需织入内容写入目标模块中，这样成本非常高。动态织入则不需要改变目标模块。Spring框架实现了AOP，使用注解配置完成AOP比使用XML配置要更加方便与直观。上一篇随笔中已经详细讲了代理模式。

详解Spring实现AOP的多种方式

  一、基于XML配置的Spring AOP

  在讲注解实现AOP功能前先用前面学习过的使用xml配置Spring AOP功能，这样是为了对比以便更好的理解。

  1.1、新建一个Maven项目，添加引用，项目的pom.xml文件如下：

详解Spring实现AOP的多种方式

XML/HTML代码


4.0.0

com.zhangguo
Spring052
0.0.1-SNAPSHOT
jar

Spring052
maven.apache.org

UTF-8 4.3.0.RELEASE junit junit test 4.10 org.springframework spring-context ${spring.version} org.aspectj aspectjweaver 1.8.9 cglib cglib 3.2.4   1.2、创建要被代理的Math类，代码如下：

Java代码

package com.zhangguo.Spring052.aop01;

/**

  • 被代理的目标类 */
    public class Math{
    //加
    public int add(int n1,int n2){
    int result=n1+n2;
    System.out.println(n1+"+"+n2+"="+result);
    return result;
    }

    //减
    public int sub(int n1,int n2){
    int result=n1-n2;
    System.out.println(n1+"-"+n2+"="+result);
    return result;
    }

    //乘
    public int mut(int n1,int n2){
    int result=n1*n2;
    System.out.println(n1+"X"+n2+"="+result);
    return result;
    }

    //除
    public int div(int n1,int n2){
    int result=n1/n2;
    System.out.println(n1+"/"+n2+"="+result);
    return result;
    }
    }
      1.3、编辑AOP中需要使用到的通知类Advices.java代码如下：

Java代码

package com.zhangguo.Spring052.aop01;

import org.aspectj.lang.JoinPoint;

/**

  • 通知类，横切逻辑

*/
public class Advices {

public void before(JoinPoint jp){  
    System.out.println("----------前置通知----------");  
    System.out.println(jp.getSignature().getName());  
}  
  
public void after(JoinPoint jp){  
    System.out.println("----------最终通知----------");  
}  
复制代码

}
  1.4、配置容器初始化时需要的XML文件，aop01.xml文件内容如下：

XML/HTML代码

<!-- 被代理对象 -->  
<bean id="math" class="com.zhangguo.Spring052.aop01.Math"></bean>  
  
<!-- 通知 -->  
<bean id="advices" class="com.zhangguo.Spring052.aop01.Advices"></bean>  
  
<!-- aop配置 -->  
<aop:config proxy-target-class="true">  
    <!--切面 -->  
    <aop:aspect ref="advices">  
        <!-- 切点 -->  
        <aop:pointcut expression="execution(* com.zhangguo.Spring052.aop01.Math.*(..))" id="pointcut1"/>  
        <!--连接通知方法与切点 -->  
        <aop:before method="before" pointcut-ref="pointcut1"/>  
        <aop:after method="after" pointcut-ref="pointcut1"/>  
    </aop:aspect>  
</aop:config>  
复制代码
  1.5、测试代码Test.java如下：

Java代码

package com.zhangguo.Spring052.aop01;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {

public static void main(String[] args) {  
    ApplicationContext ctx = new ClassPathXmlApplicationContext("aop01.xml");  
    Math math = ctx.getBean("math", Math.class);  
    int n1 = 100, n2 = 5;  
    math.add(n1, n2);  
    math.sub(n1, n2);  
    math.mut(n1, n2);  
    math.div(n1, n2);  
}  
复制代码

}
  运行结果：

详解Spring实现AOP的多种方式

  二、使用注解配置AOP

详解Spring实现AOP的多种方式

  2.1、在上一个示例中修改被代理的类Math,为了实现IOC扫描在Math类上注解了@Service并命名bean为math。相当于上一个示例中在xml配置文件中增加了一个bean，，Math类的代码如下：

Java代码

package com.zhangguo.Spring052.aop02;

import org.springframework.stereotype.Service;

/**

  • 被代理的目标类 */
    @Service("math")
    public class Math{
    //加
    public int add(int n1,int n2){
    int result=n1+n2;
    System.out.println(n1+"+"+n2+"="+result);
    return result;
    }

    //减
    public int sub(int n1,int n2){
    int result=n1-n2;
    System.out.println(n1+"-"+n2+"="+result);
    return result;
    }

    //乘
    public int mut(int n1,int n2){
    int result=n1*n2;
    System.out.println(n1+"X"+n2+"="+result);
    return result;
    }

    //除
    public int div(int n1,int n2){
    int result=n1/n2;
    System.out.println(n1+"/"+n2+"="+result);
    return result;
    }
    }
      2.2、修改通知类Advices，代码中有3个注解，@Component表示该类的实例会被Spring IOC容器管理；@Aspect表示声明一个切面；@Before表示before为前置通知，通过参数execution声明一个切点，Advices.java代码如下所示：

Java代码

package com.zhangguo.Spring052.aop02;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

/**

  • 通知类，横切逻辑

/
@Component
@Aspect
public class Advices {
@Before("execution( com.zhangguo.Spring052.aop02.Math.*(..))")
public void before(JoinPoint jp){
System.out.println("----------前置通知----------");
System.out.println(jp.getSignature().getName());
}

@After("execution(* com.zhangguo.Spring052.aop02.Math.*(..))")  
public void after(JoinPoint jp){  
    System.out.println("----------最终通知----------");  
}  
复制代码

}
  上面的代码与下面的配置基本等同

XML/HTML代码

<aop:config proxy-target-class="true">

<aop:aspect ref="advices">

<aop:pointcut expression="execution(* com.zhangguo.Spring052.aop01.Math.*(..))" id="pointcut1"/>

<aop:before method="before" pointcut-ref="pointcut1"/>
<aop:after method="after" pointcut-ref="pointcut1"/>
</aop:aspect>
</aop:config>   2.3、新增配置文件aop02.xml，在配置IOC的基础上增加了aop:aspectj-autoproxy节点，Spring框架会自动为与AspectJ切面配置的Bean创建代理，proxy-target-class="true"属性表示被代理的目标对象是一个类，而非实现了接口的类，主要是为了选择不同的代理方式。

XML/HTML代码


<context:component-scan base-package="com.zhangguo.Spring052.aop02">
</context:component-scan>
<aop:aspectj-autoproxy proxy-target-class="true"></aop:aspectj-autoproxy>

  2.4、测试运行代码Test.java如下：

Java代码

package com.zhangguo.Spring052.aop02;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {

public static void main(String[] args) {  
    ApplicationContext ctx = new ClassPathXmlApplicationContext("aop02.xml");  
    Math math = ctx.getBean("math", Math.class);  
    int n1 = 100, n2 = 5;  
    math.add(n1, n2);  
    math.sub(n1, n2);  
    math.mut(n1, n2);  
    math.div(n1, n2);  
}  
复制代码

}
  运行结果：

详解Spring实现AOP的多种方式

  三、AspectJ切点函数

  切点函数可以定位到准确的横切逻辑位置，在前面的示例中我们只使用过execution(* com.zhangguo.Spring052.aop02.Math.*(..))，execution就是一个切点函数，但该函数只什么方法一级，如果我们要织入的范围是类或某个注解则execution就不那么好用了，其实一共有9个切点函数，有不同的针对性。

  @AspectJ使用AspectJ专门的切点表达式描述切面，Spring所支持的AspectJ表达式可分为四类:

  方法切点函数：通过描述目标类方法信息定义连接点。

  方法参数切点函数：通过描述目标类方法入参信息定义连接点。

  目标类切点函数：通过描述目标类类型信息定义连接点。

  代理类切点函数：通过描述代理类信息定义连接点。

  常见的AspectJ表达式函数：

  execution()：满足匹配模式字符串的所有目标类方法的连接点

  @annotation()：任何标注了指定注解的目标方法链接点

  args()：目标类方法运行时参数的类型指定连接点

  @args()：目标类方法参数中是否有指定特定注解的连接点

  within()：匹配指定的包的所有连接点

  target()：匹配指定目标类的所有方法

  @within()：匹配目标对象拥有指定注解的类的所有方法

  @target()：匹配当前目标对象类型的执行方法，其中目标对象持有指定的注解

  this()：匹配当前AOP代理对象类型的所有执行方法

  最常用的是：execution(<修饰符模式>?<返回类型模式><方法名模式>(<参数模式>)<异常模式>?)切点函数，可以满足多数需求。

  为了展示各切点函数的功能现在新增一个类StrUtil，类如下：

Java代码

package com.zhangguo.Spring052.aop03;

import org.springframework.stereotype.Component;

@Component("strUtil")
public class StrUtil {
public void show(){
System.out.println("Hello StrUtil!");
}
}
  测试代码如下：

Java代码

package com.zhangguo.Spring052.aop03;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {

public static void main(String[] args) {  
    ApplicationContext ctx = new ClassPathXmlApplicationContext("aop03.xml");  
    IMath math = ctx.getBean("math", Math.class);  
    int n1 = 100, n2 = 5;  
    math.add(n1, n2);  
    math.sub(n1, n2);  
    math.mut(n1, n2);  
    math.div(n1, n2);  
      
    StrUtil strUtil=ctx.getBean("strUtil",StrUtil.class);  
    strUtil.show();  
}  
复制代码

}
  3.1、切点函数execution，通知与切面的定义如下：

Java代码

package com.zhangguo.Spring052.aop03;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

/**

  • 通知类，横切逻辑

/
@Component
@Aspect
public class Advices {
@Before("execution( com.zhangguo.Spring052.aop03.Math.*(..))")
public void before(JoinPoint jp){
System.out.println("----------前置通知----------");
System.out.println(jp.getSignature().getName());
}

//execution切点函数  
//com.zhangguo.Spring052.aop03包下所有类的所有方法被切入  
@After("execution(* com.zhangguo.Spring052.aop03.*.*(..))")  
public void after(JoinPoint jp){  
    System.out.println("----------最终通知----------");  
}  
复制代码

}
  运行结果如下：

详解Spring实现AOP的多种方式

  execution(<修饰符模式>?<返回类型模式><方法名模式>(<参数模式>)<异常模式>?)

  3.2、切点函数within

Java代码

//within切点函数
//com.zhangguo.Spring052.aop03包下所有类的所有方法被切入
@After("within(com.zhangguo.Spring052.aop03.*)")
public void after(JoinPoint jp){
System.out.println("----------最终通知----------");
}
详解Spring实现AOP的多种方式

  3.3、this切点函数

Java代码

//this切点函数
//实现了IMath接口的代理对象的任意连接点
@After("this(com.zhangguo.Spring052.aop03.IMath)")
public void after(JoinPoint jp){
System.out.println("----------最终通知----------");
}
详解Spring实现AOP的多种方式

 3.4、args切点函数

Java代码

//args切点函数
//要求方法有两个int类型的参考才会被织入横切逻辑
@After("args(int,int)")
public void after(JoinPoint jp){
System.out.println("----------最终通知----------");
}
详解Spring实现AOP的多种方式

  如果参数类型不是基本数据类型则需要包名。

  3.5、@annotation切点函数

  先自定义一个可以注解在方法上的注解

Java代码

package com.zhangguo.Spring052.aop03;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyAnno {
}
Java代码

//@annotation切点函数
//要求方法必须被注解com.zhangguo.Spring052.aop03.MyAnno才会被织入横切逻辑
@After("@annotation(com.zhangguo.Spring052.aop03.MyAnno)")
public void after(JoinPoint jp){
System.out.println("----------最终通知----------");
}
Java代码

package com.zhangguo.Spring052.aop03;

import org.springframework.stereotype.Component;

@Component("strUtil")
public class StrUtil {
@MyAnno
public void show(){
System.out.println("Hello StrUtil!");
}
}
  运行结果：

详解Spring实现AOP的多种方式

  其它带@的切点函数都是针对注解的

  四、AspectJ通知注解

  AspectJ通知注解共有6个，常用5个，引介少用一些。

  先解决定义切点复用的问题，如下代码所示，切点函数的内容完全一样：

Java代码

package com.zhangguo.Spring052.aop04;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

/**

  • 通知类，横切逻辑

/
@Component
@Aspect
public class Advices {
@Before("execution( com.zhangguo.Spring052.aop04.Math.*(..))")
public void before(JoinPoint jp){
System.out.println("----------前置通知----------");
System.out.println(jp.getSignature().getName());
}

@After("execution(* com.zhangguo.Spring052.aop04.Math.*(..))")  
public void after(JoinPoint jp){  
    System.out.println("----------最终通知----------");  
}  
复制代码

}
  可以先定义一个切点然后复用，如下所示：

Java代码

package com.zhangguo.Spring052.aop04;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

/**

  • 通知类，横切逻辑 /
    @Component
    @Aspect
    public class Advices {
    //切点
    @Pointcut("execution(     com.zhangguo.Spring052.aop04.Math.*(..))")
    public void pointcut(){
    }

    @Before("pointcut()")
    public void before(JoinPoint jp){
    System.out.println("----------前置通知----------");
    System.out.println(jp.getSignature().getName());
    }

    @After("pointcut()")
    public void after(JoinPoint jp){
    System.out.println("----------最终通知----------");
    }
    }
      修改Advices.java文件，增加各种通知类型如下：

Java代码

package com.zhangguo.Spring052.aop04;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

/**

  • 通知类，横切逻辑 /
    @Component
    @Aspect
    public class Advices {
    //切点
    @Pointcut("execution(     com.zhangguo.Spring052.aop04.Math.a*(..))")
    public void pointcut(){
    }

    //前置通知
    @Before("pointcut()")
    public void before(JoinPoint jp){
    System.out.println(jp.getSignature().getName());
    System.out.println("----------前置通知----------");
    }

    //最终通知
    @After("pointcut()")
    public void after(JoinPoint jp){
    System.out.println("----------最终通知----------");
    }

    //环绕通知
    @Around("execution(* com.zhangguo.Spring052.aop04.Math.s*(..))")
    public Object around(ProceedingJoinPoint pjp) throws Throwable{
    System.out.println(pjp.getSignature().getName());
    System.out.println("----------环绕前置----------");
    Object result=pjp.proceed();
    System.out.println("----------环绕后置----------");
    return result;
    }

    //返回结果通知
    @AfterReturning(pointcut="execution(* com.zhangguo.Spring052.aop04.Math.m*(..))",returning="result")
    public void afterReturning(JoinPoint jp,Object result){
    System.out.println(jp.getSignature().getName());
    System.out.println("结果是："+result);
    System.out.println("----------返回结果----------");
    }

    //异常后通知
    @AfterThrowing(pointcut="execution(* com.zhangguo.Spring052.aop04.Math.d*(..))",throwing="exp")
    public void afterThrowing(JoinPoint jp,Exception exp){
    System.out.println(jp.getSignature().getName());
    System.out.println("异常消息："+exp.getMessage());
    System.out.println("----------异常通知----------");
    }
    }
      运行结果：

详解Spring实现AOP的多种方式

  五、零配置实现Spring IoC与AOP

  为了实现零配置在原有示例的基础上我们新增一个类User，如下所示：

Java代码

package com.zhangguo.Spring052.aop05;

public class User {
public void show(){
System.out.println("一个用户对象");
}
}
  该类并未注解，容器不会自动管理。因为没有xml配置文件，则使用一个作为配置信息，ApplicationCfg.java文件如下：

Java代码

package com.zhangguo.Spring052.aop05;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration //用于表示当前类为容器的配置类，类似
@ComponentScan(basePackages="com.zhangguo.Spring052.aop05") //扫描的范围，相当于xml配置的结点context:component-scan/
@EnableAspectJAutoProxy(proxyTargetClass=true) //自动代理，相当于<aop:aspectj-autoproxy proxy-target-class="true"></aop:aspectj-autoproxy>
public class ApplicationCfg {
//在配置中声明一个bean，相当于
@Bean
public User getUser(){
return new User();
}
}
  该类的每一部分内容基本都与xml 配置有一对一的关系，请看注释，这样做要比写xml方便，但不便发布后修改。测试代码如下：

Java代码

package com.zhangguo.Spring052.aop05;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {

public static void main(String[] args) {  
    // 通过类初始化容器  
    ApplicationContext ctx = new AnnotationConfigApplicationContext(ApplicationCfg.class);  
    Math math = ctx.getBean("math", Math.class);  
    int n1 = 100, n2 = 0;  
    math.add(n1, n2);  
    math.sub(n1, n2);  
    math.mut(n1, n2);  
    try {  
        math.div(n1, n2);  
    } catch (Exception e) {  
    }  
      
    User user=ctx.getBean("getUser",User.class);  
    user.show();  
}  
复制代码

}
  advices.java 同上，没有任何变化，运行结果如下：

详解Spring实现AOP的多种方式

如果想学习Java工程化、高性能及分布式、深入浅出。性能调优、Spring，MyBatis，Netty源码分析的朋友可以加我的Java高级架构进阶群：180705916，群里有阿里大牛直播讲解技术，以及Java大型互联网技术的视频免费分享给大家

Spring AOP的三种实现方式
02-09 1万+
一、浅析AOP参考：https://docs.spring.io/spring/docs/current/spring-framework-reference/core.html#aop-apiAOP意味面向切面编程，是通过预编译方式和运行期动态代理，实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。1、方面（Aspect）：一个关注点的模块化，这个关注点实现可能另外横切多个对象。事务管...
Spring AOP 实现原理
热门推荐
KevinJom的专栏
09-24 57万+
什么是AOP AOP（Aspect-OrientedProgramming，面向方面编程），可以说是OOP（Object-Oriented Programing，面向对象编程）的补充和完善。OOP引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一个集合。当我们需要为分散的对象引入公共行为的时候，OOP则显得无能为力。也就是说，OOP允许你定义从上到下的关系，但并不适合定义从
Spring实现AOP的多种方式 切点函数
07-26
里面包括4个例子：（1）Spring实现AOP方式之一：基于XML配置的Spring AOP (2)Spring实现AOP方式之二：使用注解配置 Spring AOP (3)Spring AOP : AspectJ Pointcut 切点 (4)Spring AOP : Advice 声明 （通知注解）
spring中AOP的两种实现方式
liyang_com的博客
10-04 510
1.方法一:注解实现 接口类 public interface User { public void work();} 具体实现类 public class IUser implements User { public void work() { System.out.println(...
Spring AOP 详解
2301_80035594的博客
10-19 6276
Spring AOP（Aspect-Oriented Programming，面向切面编程）是Spring框架提供的一种编程范式，它允许开发者将横切关注点（如日志、事务管理、权限检查等）与业务逻辑分离，从而提高代码的模块化和可维护性。Spring AOP 基于代理机制实现，它为Spring应用提供了声明式事务管理等功能。
Spring实现AOP之四种方式详解
LittleByte1的博客
06-22 3369
AOP:Aspect Oriented Programming 面向切面编程 在不改变业务方法的同时可以对方法进行功能增强,Spring的两大特色IOC(Inversion of Controler控制反转)和AOP之一. Spring中提供了四种实现AOP的方式:实现Spring提供的AOP接口   1.使用JDK提供的代理方式(又分为静态和动态)   2.使用原生Spring API接口   3.使用Spring纯配置实现   4.使用Spring注解 一.使用JDK提供的代理方式(此种方式不依赖于Sp
详解在Spring中如何使用AspectJ来实现AOP
08-27
使用AspectJ实现AOP在Spring中的详解 标题：详解在Spring中如何使用AspectJ来实现AOP 描述：使用AspectJ来实现AOP（Aspect-Oriented Programming）在Spring框架中，通过AspectJ来描述切点和增强，实现AOP编程。 ...
spring实现aop的几种方式
ustcerbob的博客
03-27 1051
https://blog.youkuaiyun.com/u014206695/article/details/61618034
Spring提供了4种实现AOP的方式
douxingpeng1的博客
08-16 1712
1.经典的基于代理的AOP     2.@AspectJ注解驱动的切面     3.纯POJO切面     4.注入式AspectJ切面                     首先看经典的基于代理的AOP:         Spring支持五种类型的通知：         Before(前)  org.apringframework.aop.MethodBeforeAdvice         ...
spring 实现AOP的四种方式
格色情调的博客
09-25 7550
一、什么是AOP        AOP（Aspect-OrientedProgramming，面向方面编程），可以说是OOP（Object-Oriented Programing，面向对象编程）的补充和完善。OOP引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一个集合。当我们需要为分散的对象引入公共行为的时候，OOP则显得无能为力。也就是说，OOP允许你定义从上到下的
Spring AOP四种实现方式
Summer_YuXia的博客
07-14 1万+
二、AOP相关概念 （1）AOP是什么？AOP与拦截器的区别？ 太抽象的不说，如果你知道Struts2的拦截器，拦截器就是应用的AOP的思想，它用于拦截Action以进行一些预处理或结果处理。而spring的AOP是一种更通用的模式，可以拦截Spring管理的Bean，功能更强大，适用范围也更广，它是通过动态代理与反射机制实现的。（更详细的解释可参看博客 http://blog.csd
Spring实现AOP的4种方式
08-27 2530
Spring实现AOP的4种方式
Spring中实现AOP的三种方式
七一
08-16 1674
1、什么是AOP AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 2、AOP在Spring中的作用 横切关注点：跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无
JAVA AOP 实现 注解使用请求参数值使用
不二有恒 的博客
03-01 1866
1.请求示例 //通过用户ID获取用户信息 @DoSomething(key="#id" , cacheName=CACHE_NAME,needLog=true) public TUser getUserById(String id) { return tUserDao.queryById(Integer.parseInt(id));//核心代码 ...
深入理解 Spring 的 @ControllerAdvice
最新发布
Roc的博客
08-20 438
简单来说，是一个组件注解（被@Component元注解标注），它允许你将一个类声明为一个全局的、跨多个控制器的增强器（Advice）。你可以把它理解为 Spring MVC 版本的AOP（面向切面编程），但它不是基于代理，而是专门为控制器层设计的。全局异常处理全局数据绑定全局数据预处理命名清晰：类名如，明确其职责。区分使用场景开发，优先使用，专注于返回统一的 JSON 异常响应。开发传统多页应用，使用，可以混合处理异常、绑定模型等。避免过度使用。
Spring AOP 实现方式详解
"本文总结了Spring AOP的几种实现方式，包括核心概念的解析以及具体的实现技术，如Java动态代理和AspectJ编织等。" 在软件开发中，Spring AOP（面向切面编程）是一种强大的工具，它允许程序员将关注点分离，使代码...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值