SpringAOP的5种增强类型（基于Spring4、源码分析及使用简介）

最新推荐文章于 2023-02-22 08:27:52 发布
最新推荐文章于 2023-02-22 08:27:52 发布
阅读量219 收藏
点赞数
分类专栏： Java学习 Spring AOP 文章标签： spring aop
Java学习 同时被 3 个专栏收录
79 篇文章 1 订阅
订阅专栏
Spring
9 篇文章 0 订阅
订阅专栏
AOP
2 篇文章 0 订阅
订阅专栏

 

2017年06月05日 16:09:37

 

前言

Spring使用增强类定义横切逻辑，同时由于Spring只支持方法连接点，增强类还包括在方法的哪一点加入横切代码的方位信息，所以增强既包含横切逻辑，又包含部分连接点信息。使用增强前，最好能理解动态代理的知识。本文分别采用继承接口和使用配置文件来实现增强。

这里写图片描述

按照增强在目标类方法中的连接点位置，可以分为5种：

  1. 前置增强：org.springframework.aop.BeforeAdvice是前置增强顶层接口，因为Spring只支持方法的增强，其子接口MethodBeforeAdvice是目前可用的前置增强。表示在目标方法执行前实施增强。
  2. 后置增强：org.springframework.aop.AfterReturningAdvice是目前可用的后置增强，表示在目标方法执行后实施增强。
  3. 环绕增强：org.aopalliance.intercept.MethodInterceptor代表了环绕增强，表示在目标方法执行前后实施增强。直接使用了AOP联盟定义的接口。
  4. 异常抛出增强：org.springframework.aop.ThrowsAdvice代表了异常抛出增强，表示在目标方法抛出异常后实施增强。
  5. 引介增强：org.springframework.aop.IntroductionInterceptor代表引介增强，表示在目标类中添加一些新的方法和属性。

正文

一，前置增强

1，我们先不用配置文件，先使用原始的方法–继承底层接口的形式来实现增强。配置文件或者注解的底层也是使用这些接口来生成代理的。

首先，创建maven工程，利用pom文件自动导入所需的包。
然后，编写目标类和增强类。

package com.jimmy.mvn.a.BeforeAdvice;

/**
 * 目标类(被增强类),say方法将被增强,其中say方法执行前后都可以是切入点(point-cut)
 */
public class Target {
    public void say() {
        System.out.println("我需要被增强!");
    }
}
  •  
package com.jimmy.mvn.a.BeforeAdvice;
import java.lang.reflect.Method;
import org.springframework.aop.MethodBeforeAdvice;

/**
 * 增强类,用于在切入点处进行增强
 * 
 * 该类实现了MethodBeforeAdvice接口，并实现了唯一的before()方法。
 * 
 */
public class Advice implements MethodBeforeAdvice{

    /**
     * method是目标类的方法
     * args是目标类方法的入参
     * target是目标类实例
     * 
     * before()方法会在目标类方法调用前执行。
     */
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println("我是前置增强，很高兴为你服务！");
    }   
}
  •  

最后，编写测试类。

package com.jimmy.mvn.SpringAdvice;

import org.springframework.aop.framework.ProxyFactory;

import com.jimmy.mvn.a.BeforeAdvice.Advice;
import com.jimmy.mvn.a.BeforeAdvice.Target;

public class BeforeAdviceTest {
    public static void main(String[] args) {

        Target target = new Target();  // 目标类对象
        Advice advice = new Advice();  // 增强类对象

        ProxyFactory pf = new ProxyFactory(); // Spring提供的代理工厂
        pf.setTarget(target);  // 设置代理目标
        pf.addAdvice(advice);  // 为代理目标添加增强

        Target target2 = (Target) pf.getProxy(); // 生成代理实例
        target2.say();  // 代理对象再调用say()方法就能产生前置增强
    }
}
  •  

输出结果：

我是前置增强，很高兴为你服务！
我需要被增强!
  •  

2，我们来看如何使用xml配置文件进行增强

首先，还是先创建maven工程，自动导入需要的包。
然后，创建目标类和增强类。

package com.jimmy.mvn.a.BeforeAdviceXML;

/**
 * 目标类。同上，很普通的一个类，实际开发中往往是一个业务类 
 */
public class Target {
    public void say() {
        System.out.println("我需要被增强！");
    }
}
  •  
package com.jimmy.mvn.a.BeforeAdviceXML;

/**
 * 增强类，该类不再继承任何接口，就是个普通的POJO类
 * 
 * 从外观上看，根本看不出来这个类要干嘛 
 */
public class Advice {   
    public void beforeAdvice() {
        System.out.println("我是前置增强，很高兴为你服务！");
    }
}
  •  

再然后，写配置文件

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

    <bean id="target" class="com.jimmy.mvn.a.BeforeAdviceXML.Target"></bean>
    <bean id="advice" class="com.jimmy.mvn.a.BeforeAdviceXML.Advice"></bean>

    <aop:config>
        <aop:aspect ref="advice">           
            <aop:before method="beforeAdvice" pointcut="execution(* com.jimmy.mvn.a.BeforeAdviceXML.*.*(..))"/>         
        </aop:aspect>
    </aop:config>     
</beans>
  •  

解读上面的配置文件：
1，定义2个bean，target是增强后的bean，而advice是为了在文件中被切面引用。
2，aop:config，AOP设置的最外层元素，一个文件可以有多个aop:config，不同的aop:config可以采用不同的代理技术。
3，aop:aspect，改元素定义一个切面，其ref属性用来引用增强类的bean。
4，aop:before，定义一个前置增强，method属性是增强类bean中的方法名；pointcut属性是一个“切点表达式”，该表达式用于匹配“切入点”，即需要被增强的bean的方法。

最后，写测试代码：

package com.jimmy.mvn.SpringAdvice;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.jimmy.mvn.a.BeforeAdviceXML.Target;

public class BeforeAdviceXMLTest {
    public static void main(String[] args) {

        String path = "com/jimmy/mvn/a/BeforeAdviceXML/smart-context.xml";
        ApplicationContext app1 = new ClassPathXmlApplicationContext(path);
        Target target = (Target) app1.getBean("target");
        target.say();
    }
}
  •  

输出结果为：

我是前置增强，很高兴为你服务！
我需要被增强！
  •  

注：配置文件配置AOP时，有很多种写法，还可以将“切点表达式”单独命名，如下：

<bean id="target" class="com.jimmy.mvn.a.BeforeAdviceXML.Target"></bean>
<bean id="advice" class="com.jimmy.mvn.a.BeforeAdviceXML.Advice"></bean>

<aop:config>
    <aop:aspect ref="advice">
        <aop:pointcut id="pointcut" expression="execution(* com.jimmy.mvn.a.BeforeAdviceXML.*.*(..))"/>
        <aop:before method="beforeAdvice" pointcut-ref="pointcut"/>
    </aop:aspect>
</aop:config>
  •  

当然，还可以将aop:pointcut提取出来，单独写，可以供很多切面aop:aspect引用：

    <bean id="target" class="com.jimmy.mvn.a.BeforeAdviceXML.Target"></bean>
    <bean id="advice" class="com.jimmy.mvn.a.BeforeAdviceXML.Advice"></bean>

    <aop:config>
        <aop:pointcut id="pointcut" expression="execution(* com.jimmy.mvn.a.BeforeAdviceXML.*.*(..))"/>

        <aop:aspect ref="advice">
            <aop:before method="beforeAdvice" pointcut-ref="pointcut"/>
        </aop:aspect>
        <aop:aspect ref="advice">
            <aop:before method="beforeAdvice" pointcut-ref="pointcut"/>
        </aop:aspect>
    </aop:config>
  •  

上面这个配置，对切入点进行了2次增强，输出如下：

我是前置增强，很高兴为你服务！
我是前置增强，很高兴为你服务！
我需要被增强！
  •  

3，最后我们再来用注解Annotation开发

首先，创建maven工程，自动导入所需要的包
然后，编写目标类和增强类。

package com.jimmy.mvn.a.BeforeAdviceAnnotation;

/**
 * 目标类。同上，很普通的一个类，实际开发中往往是一个业务类 
 */
public class Target {
    public void say() {
        System.out.println("我还要被增强！");
    }
}
  •  
package com.jimmy.mvn.a.BeforeAdviceAnnotation;

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

/**
 * 增强类，使用注解开发，该类同样不再继承任何接口
 * 
 * @Aspect用于将类标识为一个切面
 * @Before("execution(...)")用于将方法标识为增强方法，"切入点表达式"用于定位被切入方法。
 */
@Aspect
public class Advice {   

    @Before("execution(* *..Target.*(..))")
    public void beforeAdvice() {
        System.out.println("我是前置增强，很高兴为你服务！");
    }
}
  •  

再然后，我们仍然需要配置一点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" 
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
                           http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
                           http://www.springframework.org/schema/aop
                           http://www.springframework.org/schema/aop/spring-aop-4.0.xsd">

    <aop:aspectj-autoproxy/>
    <bean id="target" class="com.jimmy.mvn.a.BeforeAdviceAnnotation.Target"></bean>
    <bean id="advice" class="com.jimmy.mvn.a.BeforeAdviceAnnotation.Advice"></bean>       
</beans>
  •  

解读上述配置文件，文件中只有短短的3行配置。
1，aop:aspectj-autoproxy自动为Spring容器中那些匹配@Aspect切面的bean创建代理，完成切面织入。
2，两个bean，其中target供测试时getBean方法调用；advice可以没有id，其为自动创建代理时使用。

最后，编写测试类

package com.jimmy.mvn.SpringAdvice;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.jimmy.mvn.a.BeforeAdviceAnnotation.Target;

public class BeforeAdviceAnnotationTest1 {
    public static void main(String[] args) {        
        String path = "com/jimmy/mvn/a/BeforeAdviceAnnotation/smart-context.xml";
        ApplicationContext app1 = new ClassPathXmlApplicationContext(path);
        Target target = (Target) app1.getBean("target");
        target.say();
    }
}
  •  

这里的输出结果是：

我是前置增强，很高兴为你服务！
我还要被增强！
  •  

二，后置增强

跟前置增强的使用一样一样的。

三，环绕增强

1，还是先使用继承底层接口的形式。

首先，创建maven工程，自动导入jar包。
然后，创建目标类和增强类。

package com.jimmy.mvn.b.AroundAdvice;

/**
 * 目标类，普通POJO类，其say方法被增强。
 */
public class Target {
    public void say(){
        System.out.println("我需要前后都增强！");
    }
}
  •  
package com.jimmy.mvn.b.AroundAdvice;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

/**
 * 增强类实现了MethodInterceptor接口，并实现了其中的invoke方法
 */
public class AroundAdvice implements MethodInterceptor{

    /**
     * 该方法截获目标类方法的执行，并在前后加上横断逻辑
     */
    public Object invoke(MethodInvocation invocation) throws Throwable {

        System.out.println("我是前置增强，很高兴为你服务！"); // 前置增强
        Object obj = invocation.proceed(); // 通过反射机制调用目标方法
        System.out.println("我是前置增强，很高兴为你服务！"); // 后置增强
        return obj;
    }
}
  •  

最后，编写测试类，该测试类跟前置增强时用的一样。

package com.jimmy.mvn.SpringAdvice;

import org.springframework.aop.framework.ProxyFactory;

import com.jimmy.mvn.b.AroundAdvice.AroundAdvice;
import com.jimmy.mvn.b.AroundAdvice.Target;

public class AroundAdviceTest {
    public static void main(String[] args) {
        Target target = new Target();
        AroundAdvice advice = new AroundAdvice();

        ProxyFactory pf = new ProxyFactory();
        pf.setTarget(target);
        pf.addAdvice(advice);

        Target target2 = (Target) pf.getProxy();
        target2.say();
    }
}
  •  

输出结果：

我是前置增强，很高兴为你服务！
我需要前后都增强！
我是后置增强，很高兴为你服务！
  •  

2，我们再来使用XML配置文件配置环绕增强AOP

首先，创建maven工程，自动导入jar包。
然后，创建目标类和增强类。

package com.jimmy.mvn.b.AroundAdviceXML;

/**
 * 目标类，跟上面是一样一样的。
 */
public class Target {
    public void say() {
        System.out.println("我还要前后增强！");
    }
}
  •  
package com.jimmy.mvn.b.AroundAdviceXML;

import org.aspectj.lang.ProceedingJoinPoint;

/**
 * 增强类，普通POJO类，不再继承任何接口。
 * 自定义环绕增强方法，由于是要在切入点前后横插入逻辑，所以将ProceedingJoinPoint接口对象pjp作为方法的入参。
 * pjp.proceed()方法通过反射机制调用目标方法。
 * 在pjp.proceed()前后加上横断逻辑。
 */
public class AroundAdvice {

    public void myAroundAdvice(ProceedingJoinPoint pjp) throws Throwable{
        System.out.println("我是前置增强，很高兴为你服务!");
        pjp.proceed();
        System.out.println("我是后置增强，很高兴为你服务!");
    }
}
  •  

再然后，编写配置文件，smart-context.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" 
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
                           http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
                           http://www.springframework.org/schema/aop
                           http://www.springframework.org/schema/aop/spring-aop-4.0.xsd">

    <bean id="target" class="com.jimmy.mvn.b.AroundAdviceXML.Target"></bean>
    <bean id="advice" class="com.jimmy.mvn.b.AroundAdviceXML.AroundAdvice"></bean>

    <aop:config>
        <aop:aspect ref="advice">           
            <aop:around method="myAroundAdvice" pointcut="execution(* *..Target.*(..))"/>           
        </aop:aspect>
    </aop:config>     
</beans>
  •  

我们看到，配置文件跟前置增强的差别不大，无非是把aop:before换成了aop:around。

最后，编写测试类。

package com.jimmy.mvn.SpringAdvice;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.jimmy.mvn.b.AroundAdviceXML.Target;

public class AroundAdviceXMLTest {
    public static void main(String[] args) {
        String path = "com/jimmy/mvn/b/AroundAdviceXML/smart-context.xml";
        ApplicationContext app1 = new ClassPathXmlApplicationContext(path);
        Target target = (Target) app1.getBean("target");
        target.say();
    }
}
  •  

输出结果：

我是前置增强，很高兴为你服务!
我还要前后增强！
我是后置增强，很高兴为你服务!
  •  

3，最后我们用注解（Annotation）写代码

首先，创建maven工程，自动导入jar包。
然后，创建目标类和增强类。

package com.jimmy.mvn.b.AroundAdviceAnnotation;

public class Target {
    public void say() {
        System.out.println("我还要前后增强！");
    }
}
  •  
package com.jimmy.mvn.b.AroundAdviceAnnotation;

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

@Aspect
public class AroundAdvice {

    @Around(value = "execution(* *..Target.*(..))")
    public void myAroundAdvice(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("我是前置增强，很高兴为你服务!");
        pjp.proceed();
        System.out.println("我是后置增强，很高兴为你服务!");
    }
}
  •  

再然后，编写配置文件，smart-context.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" 
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
                           http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
                           http://www.springframework.org/schema/aop
                           http://www.springframework.org/schema/aop/spring-aop-4.0.xsd">

    <aop:aspectj-autoproxy/>
    <bean id="target" class="com.jimmy.mvn.b.AroundAdviceAnnotation.Target"></bean>
    <bean id="advice" class="com.jimmy.mvn.b.AroundAdviceAnnotation.AroundAdvice"></bean>  
</beans>
  •  

同样，使用了注解，只有3句配置信息。

最后，编写测试代码

package com.jimmy.mvn.SpringAdvice;

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

import com.jimmy.mvn.b.AroundAdviceAnnotation.Target;

public class AroundAdviceAnnotationTest {
    public static void main(String[] args) {
        String path = "com/jimmy/mvn/b/AroundAdviceAnnotation/smart-context.xml";
        ApplicationContext app1 = new ClassPathXmlApplicationContext(path);
        Target target = (Target) app1.getBean("target");
        target.say();
    }
}
  •  

输出结果为：

我是前置增强，很高兴为你服务!
我还要前后增强！
我是后置增强，很高兴为你服务!
  •  

总结

SpringAOP的概念一开始不容易接受，一旦接受了，结合Spring提供的AOP框架使用起来就会很方便。

Golden_soft
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring学习（5）：SpringAOP的5种增强类型
欢迎来到Jimmy的博客
06-05 1万+
前言Spring使用增强类定义横切逻辑，同时由于Spring只支持方法连接点，增强类还包括在方法的哪一点加入横切代码的方位信息，所以增强既包含横切逻辑，又包含部分连接点信息。本文分别采用继承接口和使用配置文件来实现增强。按照增强在目标类方法中的连接点位置，可以分为5种： 前置增强：org.springframework.aop.BeforeAdvice是前置增强顶层接口，因为Spring只支持方法的
Spring AOP 增强类型
何冠勋的博客
07-16 1409
AOP联盟为了增强定义了org.framework,aop.Adivce接口，Spring 支持5种类型的增强，下面是增强接口的关系图 Spring支持5种类型的增强： 1.前置增强：org.springframework.aop.BeforeAdvice代表前置增强，因为Spring只支持 方法级的增强，所以MethodBeforeAdvice是目前可的的前置增强，表示在目标方法执
SpringAOP的5种增强类型应用讲解
m0_73875939的博客
01-03 451
spring框架中为我们提供的增强包括针对切面的增强和针对切入点的增强，对一个方法的增强底层使用的是动态代理，所以在学习springAop增强之前大家有必要先了解一下动态代理相关内容； 本文分别采用继承接口和使用配置文件来实现增强。 1.前置增强：org.springframework.aop.BeforeAdvice是前置增强顶层接口，因为Spring只持方法的增强，其子接口MethodBeforeAdvice是目前可用的前置增强。表示在目标方法执行前实施增强。 2.后置增强：org.springfr
spring aop 增强类型
weixin_34268843的博客
10-20 92
2019独角兽企业重金招聘Python工程师标准>>> ...
Spring AOP的五种增强处理
qq_51649461的博客
08-22 3855
一、基于注解的Spring AOP的五种增强处理 1. 前置增强处 //定义增强处理 /** * 1、定义前置增强处理 * @Before注解表示该方法是一个前置增强处理 在目标方法执行之前调用 * 属性value：定义该增强处理切入的位置（切入点） * execution(* com.cxsw.spring.service.impl.UserServiceImpl.*(..)) * UserServiceImpl实现类下的所有方法 * execution(* c
SpringAOP介绍及源码分析
03-02
前者是为了提高开发效率，而后者则使用了归纳法，把具有共性的东西进行归类并使之模块化，达到便于维护和扩展的目的；如果说面向对象编程可以对业务需求进行很好的分解使之模块化；那么面向切面编程AOP（Aspect-...
Spring AOP源码分析.mmap
08-18
有关于Spring，我们最常用的两个功能就是IOC和AOP，前几篇文章从源码级别介绍了Spring容器如何为我们生成bean及bean之间的依赖关系 下面我们接着来看AOP的源码实现。 有关于AOP，我们在面试中也被无数次问到...
如何使用Spring AOP的通知类型及创建通知
08-25
主要给大家介绍了关于如何使用Spring AOP的通知类型及创建通知的相关资料，文中通过示例代码介绍的非常详细，对大家学习或者使用Spring AOP具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
浅谈spring aop的五种通知类型
08-28
主要介绍了浅谈spring aop的五种通知类型，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Spring-AOP 的四种增强方式（前置增强、后置增强、异常增强、环绕增强）
ERA___的博客
04-29 2647
Spring-AOP 的四种增强方式（前置增强、后置增强、异常增强、环绕增强） 1.前置增强，在核心功能之前执行的额外功能 public class MyBeforeAdvice implements MethodBeforeAdvice{ @Override public void before(Method arg0, Object[] arg1, Object arg2) throws...
Spring 源码分析衍生篇十二 ：AOP 中的引介增强
猫吻鱼的博客
08-25 1308
引介增强是一种比较特殊的增强类型，它不是在目标方法周围织入增强，而是为目标创建新的方法和属性，所以它的连接点是类级别的而非方法级别的。 通过引介增强我们可以为目标类添加一个接口的实现即原来目标类未实现某个接口,那么通过引介增强可以为目标类创建实现某接口的代理。
SpringAOP之引介增强 IntroductionInterceptor
wangyan199366的博客
11-13 2909
SpringAOP常见的有前置、后置、环绕、异常处理等技术，今天介绍AOP中的引介增强。这个技术是类级别的。 定义Monitor package com.augmentum.introductionInterceptor; public interface Monitor { void setMonitorActive(boolean bool); } 实现类继
Spring Aop五种增强方法
weixin_42870054的博客
07-17 1944
在前一篇配置Spring Aop的博客中提到过两种增强方法：before(JoinPoint jd)和 after(JoinPoint jd) 下面具体介绍五种增强方法，代码如下： @Aspect @Component public class Calculator { //前置增强 @Before("execution(int mul(int, int))") public void bef...
Spring AOP的五种增强方式
Hey_Book的博客
02-06 2032
增强方法也称为通知方法，指标注有@Before、@AfterRunning、@AfterThrowing、@After或@Around注解的Java方法。其中，有前置增强、后置增强、返回增强、异常增强和环绕增强五种增强方式。 前置增强 前置增强（@Before，又称前置通知）：在目标方法执行之前执行。 @Pointcut("execution(public int com.jd.calculato...
AOP常用的几种增强方式，各自的特点
Pursuit_li的博客
12-06 1330
1. 前置增强，在核心功能之前执行的额外功能 2. 后置增强，在核心功能之后执行的额外功能 3.异常增强，在核心功能发生异常时执行的额外功能，先捕获，后抛出 4. 环绕增强，在核心功能之前以及之后执行的额外功能
Spring-aop的四种增强方式
weixin_66187554的博客
02-22 150
java
Spring AOP增强类型
灯塔的CSDN博客
09-08 4305
增强类型 Spring支持5种类型的增强，按照增强在目标类方法的连接点位置，可以分为以下5类。 前置增强： 后置增强： 环绕增强： 异常抛出增强： 前置增强 场景：实习服务生，对客户的问候： 以上就是我们的业务类； 下面编写我们的切面，实现类 测试类实现，采用TestNG:   采用XMLApplication
Spring的AOP介绍和使用
weixin_60719453的博客
08-10 2114
AOP为Aspect Oriented Programming的缩写，意思为面向切面编程，是通过预编译方式和运行期动态代理实现程序功能的同一维护的一种技术。AOP是OOP（面向对象编程）的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型，利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的课重用性，同时提高了开发的效率。......
spring aop 源码分析
最新发布
04-06
2. AOP 的实现方式：Spring AOP 的实现方式有两种，一种是基于动态代理，另一种是基于字节码增强。了解这两种实现方式的优缺点、适用场景以及实现细节是深入理解 Spring AOP 的必要前提。 3. AOP 的实现细节：...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值