Spring 面向切面编程详解

最新推荐文章于 2024-08-26 14:37:18 发布
最新推荐文章于 2024-08-26 14:37:18 发布
阅读量285 收藏
点赞数 4
分类专栏： Spring 文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41770283/article/details/134811760
版权

一、面向切面的基本原理

在软件开发中，散布于应用中多处的功能被称为横切关注点。通常来说，这些个横切关注点从概念上是与应用的业务逻辑相分离的，但往往会直接嵌入到应用的业务逻辑之中。因此，面向切面编程(AOP)核心在于把这些横切关注点与业务逻辑相分离。日志是应用切面的常见范例，但是切面所适用的场景很多，包括声明式事务、安全和缓存。

1. AOP术语

  1. 通知(Advice)

    在AOP中，切面的工作被称为通知。通知定义了切面是什么以及何时使用。Spring切面可以应用5种类型的通知：

    • 前置通知 Before —— 在方法被调用之前调用通知。
    • 后置通知 After —— 在方法完成之后调用通知，无论方法是否执行成功。
    • 返回通知 After-returning —— 在方法成功执行之后调用通知。
    • 异常通知 After-throwing —— 在方法抛出异常以后调用通知。
    • 环绕通知 Around —— 通知包裹了被通知的方法，在被通知的方法调用之前和调用之后执行自定义的行为。

  2. 连接点(Joinpoint)

    连接点是在应用执行过程中能够插入切面的一个点。这个点可以是调用方法时，抛出异常时，甚至是修改一个字段时。切面代码可以利用这些点插入到应用的正常流程之中，并添加新的行为。

  3. 切点(Pointcut)

    切点的定义会匹配通知所要织入的一个或多个连接点。我们通常使用明确的类和方法名称来指定这些切点，或是利用正则表达式定义匹配的类和方法名称模式来指定这些切点。

  4. 切面(Aspect)

    切面是通知和切点的结合。通知和切点共同定义了关于切面的全部内容 —— 它是什么，在何时和何处完成其功能。

  5. 引入(Introduction)

    引入允许我们向现有的类添加新的方法和属性。

  6. 织入(Weaving)

    织入是将切面应用到目标对象来创建新的代理对象的过程。切面在指定的连接点被织入到目标对象中。在目标对象的生命周期里有多个点可以进行织入：

    • 编译器 —— 切面在目标类编译时被织入。
    • 类加载期 —— 切面在目标类加载到JVM时被织入。
    • 运行期 —— 切面在应用运行的某个时候被织入。Spring AOP就是以这种方式织入切面的。

二、在Spring XML中声明切面

1. AspectJ切点指示器

AspectJ指示器描述
arg()限制连接点匹配参数为指定类型的执行方法
@args()限制连接点匹配参数由指定注解标注的执行方法
execution()用于匹配是连接点的执行方法
this()限制连接点匹配AOP代理的Bean引用的指定类型的类
target()限制连接点匹配目标对象为执行类型的类
@target()限制连接点匹配特定的执行对象，这些对象对应的类要具备指定类型的注解
within()限制连接点匹配指定的类型
@within()限制连接点匹配指定注解所标注的类型(当使用Spring AOP时，方法定义在由指定的注解所标注的类里)
@annotation()限制匹配带有指定注解连接点

2. 步骤

1）基本数据
public interface Performance {
    public void perform();
}

@Component
public class Audience {
    // 表演之前
    public void takeSeats(){
        System.out.println("观众入座");
    }

    // 表演之前
    public void turnOffCellPhones(){
        System.out.println("关闭手机");
    }

    // 表演之后
    public void applaud(){
        System.out.println("鼓掌: 啪啪啪啪啪");
    }

    // 表演失败后
    public void failure(){
        System.out.println("坑爹，退钱！");
    }
}
2）编写切点
execution(* com.shiftycat.concert.Performance.perform(..))
// 或者使用bean，在执行Instrument的`play()`方法时应用通知，并且Bean的ID为eddie。
execution(* com.shiftycat.concert.Performance.perform()) and bean(rocketStar)
3）XML中配置AOP

在Spring XML中配置AOP使用元素，下表概述了AOP配置元素。

AOP配置元素描述
aop:advisor定义AOP通知器
aop:after定义AOP后置通知(不管被通知的方法是否执行成功)
aop:after-returning定义AOP after-returning通知
aop:after-throwing定义AOP after-throwing通知
aop:around定义AOP环绕通知
aop:aspect定义切面
aop:aspectj-autoproxy启用@AspectJ注解驱动切面
aop:before定义AOP前置通知
aop:config顶层的AOP配置元素
aop:declare-parents为被通知的对象引入额外的接口，并透明的实现
aop:pointcut定义切点

为了演示Spring AOP，现在定义一个观众类 Audience：

public class Audience {
    // 表演之前
    public void takeSeats(){
        System.out.println("观众入座");
    }

    // 表演之前
    public void turnOffCellPhones(){
        System.out.println("关闭手机");
    }

    // 表演之后
    public void applaud(){
        System.out.println("鼓掌: 啪啪啪啪啪");
    }

    // 表演失败后
    public void failure(){
        System.out.println("坑爹，退钱！");
    }
}

在Spring XML中配置该Bean：

<bean id="rocketStar" class="com.shiftycat.concert.RocketStar" />
<bean id="audience" class="com.shiftycat.concert.Audience" />
4）声明相关通知
<aop:config>
    <aop:aspect ref="audience">
        <aop:pointcut
                id="performance"
                expression="execution(* com.shiftycat.concert.Performance.perform(..)) and bean(rocketStar)"/>
        <aop:before
                pointcut-ref="performance"
                method="takeSeats"/>
        <aop:before
                pointcut-ref="performance"
                method="turnOffCellPhones"/>
        <aop:after-returning
                pointcut-ref="performance"
                method="applaud"/>
        <aop:after-throwing
                pointcut-ref="performance"
                method="failure"/>
    </aop:aspect>
</aop:config>
5）进行测试
@Test
public void performXMLTest() {
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("concert-config.xml");
    Performance performance = context.getBean(Performance.class);
    performance.perform();
}
6）测试结果
观众入座
关闭手机
梁博演唱《出现又离开》
鼓掌: 啪啪啪啪啪

3. 声明环绕通知

如果不使用成员变量，那么在前置通知和后置通知之间共享信息是非常麻烦的。可以使用环绕通知代替前置通知和后置通知，现在在Audience类里添加一个新的方法：

public void watchPerformance(ProceedingJoinPoint joinPoint) {
    try {
        System.out.println("观众入座了");
        System.out.println("关闭手机了");
        joinPoint.proceed();
        System.out.println("鼓掌了: 啪啪啪啪啪");
        joinPoint.proceed();
        System.out.println("鼓掌了: 啪啪啪啪啪");
    } catch (Throwable e) {
        System.out.println("坑爹，退钱！");
    }
}

对于新的方法，我们使用了ProceedingJoinPoint作为参数，这个对象可以在通知里调用被通知的方法！！我们要把控制转给被通知的方法时，必须调用ProceedingJoinPoint的proceed()方法。

修改<aop:config>元素：

<aop:config>
    <aop:aspect ref="audience">
        <aop:pointcut
                id="performance"
                expression="execution(* com.shiftycat.concert.Performance.perform(..)) and bean(rocketStar)"/>
        <aop:around pointcut-ref="performance"
                    method="watchPerformance"/>
    </aop:aspect>
</aop:config>

观众入座了
关闭手机了
梁博演唱《出现又离开》
鼓掌了: 啪啪啪啪啪
梁博演唱《出现又离开》
鼓掌了: 啪啪啪啪啪

4. 为通知传递参数

1）基本数据

定义一个新的参赛者，他是一个读心者，由MindReader接口所定义：

public interface MindReader {
    void interceptThoughts(String thoughts);
    String getThoughts();
}

魔术师Magician实现该接口：

public class Magician implements MindReader{
    private String thoughts;
    public void interceptThoughts(String thoughts) {
        System.out.println("侦听志愿者的心声");
        this.thoughts=thoughts;
    }
    public String getThoughts() {
        return thoughts;
    }
}

再定义一个Magician所要侦听的志愿者，首先定义一个思考者接口：

public interface Thinker {
    void thinkOfSomething(String thoughts);
}

志愿者Volunteer实现该接口：

public class Volunteer implements Thinker{
    private String thoughts;
    public void thinkOfSomething(String thoughts) {
        this.thoughts=thoughts;
    }
    public String getThoughts(){
        return thoughts;
    }
}
2）XML文件配置AOP

接下来使用Spring AOP传递Volunteer的thoughts参数，以此实现Magician的侦听:

<bean id="magician" class="com.shiftycat.concert.Magician"/>
<bean id="volunteer" class="com.shiftycat.concert.Volunteer"/>

<aop:config proxy-target-class="true">
        <aop:aspect ref="magician">
                <aop:pointcut id="thinking" expression="
    execution(* com.shiftycat.concert.Volunteer.thinkOfSomething(String))
    and args(thoughts)"/>
                <!-- `arg-names`属性传递了参数给`interceptThoughts()`方法。 -->
                <aop:before pointcut-ref="thinking"
                            method="interceptThoughts"
                arg-names="thoughts"/>
        </aop:aspect>
</aop:config>

输出：

侦听志愿者的心声
志愿者心里想的是：演出真精彩！

5. 通过切面引入新的方法

现在假设要给Performer派生类添加一个新的方法，传统做法是找到所有派生类，让后逐个增加新的方法或者实现。这不但很累而且假设第三方实现没有源码的话，这个过程会变得很困难。幸好，通过Spring AOP可以不必入侵性地改变原有地实现。比如，现在要给所有演出者添加一个receiveAward()方法：

新增一个接口Contestant：

public interface Contestant {
    void receiveAward();
}

由OutstandingContestant实现：

public class OutstandingContestant implements Contestant{
    public void receiveAward() {
        System.out.println("参加颁奖典礼");
    }
}

XML：

<aop:config proxy-target-class="true">
    <aop:aspect>
        <aop:declare-parents
                types-matching="com.shiftycat.concert.Performance+"
                implement-interface="com.shiftycat.concert.Contestant"
                default-impl="com.shiftycat.concert.OutstandingContestant"/>
    </aop:aspect>
</aop:config>

或者：

<bean id="contestantDelegate" class="com.shiftycat.concert.OutstandingContestant"/>
<aop:config proxy-target-class="true">
    <aop:aspect>
        <aop:declare-parents
                types-matching="com.shiftycat.concert.Performance+"
                implement-interface="com.shiftycat.concert.Contestant"
                delegate-ref="contestantDelegate"/>
    </aop:aspect>
</aop:config>
  • types-matching指定所要添加新方法的派生类实现的接口
  • implement-interface指定要实现新的接口
  • default-impl指定这个接口的实现类。

测试：

@Test
public void performXMLTest() {
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("concert-config.xml");
    Performance performance = (Performance) context.getBean("rocketStar");
    performance.perform();
    Contestant contestant = (Contestant) context.getBean("rocketStar");
    contestant.receiveAward();
}

输出：

观众入座了
关闭手机了
梁博演唱《出现又离开》
鼓掌了: 啪啪啪啪啪
梁博演唱《出现又离开》
鼓掌了: 啪啪啪啪啪
参加颁奖典礼

三、使用注解配置AOP切面

1. 注解切面

除了使用XML配置AOP切面，我们还可以使用更简洁的注解配置。现使用注解修改Audience类：

@Aspect
public class Audience {
    // 声明切点
    @Pointcut("execution(* com.shiftycat.concert.Performance.perform(..))")
    public void performance(){

    }
    // 表演之前
    @Before("performance()")
    public void takeSeats(){
        System.out.println("观众入座");
    }

    // 表演之前
    @Before("performance()")
    public void turnOffCellPhones(){
        System.out.println("关闭手机");
    }

    // 表演之后
    @After("performance()")
    public void applaud(){
        System.out.println("鼓掌: 啪啪啪啪啪");
    }

    // 表演失败后
    @AfterThrowing("performance()")
    public void failure(){
        System.out.println("坑爹，退钱！");
    }
}

@Aspect使得Audience成为了切面。

为了让Spring识别改注解，我们还需在XML中添加<aop:aspectj-autoproxy/>。<aop:aspectj-autoproxy/>将在Spring应用上下文中创建一个AnnotationAwareAspectJAutoProxyCreator类，它会自动代理@Aspect标注的Bean：

<aop:aspectj-autoproxy proxy-target-class="true" />

测试输出：

观众入座
关闭手机
梁博演唱《出现又离开》
鼓掌: 啪啪啪啪啪

2. 注解环绕通知

使用@Around注解环绕通知：

@Aspect
public class Audience {
    // 声明切点
    @Pointcut("execution(* com.shiftycat.concert.Performance.perform(..))")
    public void performance(){

    }
    @Around("performance()")
    public void watchPerformance(ProceedingJoinPoint joinPoint) {
        try {
            System.out.println("观众入座了");
            System.out.println("关闭手机了");
            joinPoint.proceed();
            System.out.println("鼓掌了: 啪啪啪啪啪");
            joinPoint.proceed();
            System.out.println("鼓掌了: 啪啪啪啪啪");
        } catch (Throwable e) {
            System.out.println("坑爹，退钱！");
        }
    }
}

观众入座了
关闭手机了
梁博演唱《出现又离开》
鼓掌了: 啪啪啪啪啪
梁博演唱《出现又离开》
鼓掌了: 啪啪啪啪啪

3. 注解传递参数

@Aspect
public class Magician implements MindReader{
    private String thoughts;

    // 声明参数化切点
    @Pointcut("execution(* com.shiftycat.concert."
            + "Thinker.thinkOfSomething(String)) && args(thoughts)")
    public void thinking(String thoughts) {

    }
    // 把参数传递给通知
    @Before("thinking(thoughts)")
    public void interceptThoughts(String thoughts) {
        System.out.println("侦听志愿者的心声");
        this.thoughts=thoughts;
    }
    public String getThoughts() {
        return thoughts;
    }
}

<aop:pointcut>变为@Pointcut注解，<aop:before>变为@Before注解。

测试：

@Test
public void TestIntercept() {
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("concert-config.xml");
    Volunteer volunteer = context.getBean(Volunteer.class);
    volunteer.thinkOfSomething("演出真精彩！");
    Magician magician = (Magician) context.getBean("magician");
    System.out.println("志愿者心里想的是："+magician.getThoughts());
}

输出：

侦听志愿者的心声
志愿者心里想的是：演出真精彩！

4. 通过注解引入新的方法

之前通过在XML中配置AOP切面的方法为Bean引入新的方法，现在改用注解的方式来实现：

新建一个ContestantIntroducer类：

@Aspect
public class ContestantIntroducer {
    @DeclareParents(
            value = "com.shiftycat.concert.Performance+",
            defaultImpl = OutstandingContestant.class)
    public static Contestant contestant;
}

@DeclareParents注解代替了之前的<aop:declare-parents>标签。 @DeclareParents注解由三个部分组成：

  1. value属性等同于<aop:declare-parents>的types-matching属性。它标识应该被引入指定接口的Bean。

  2. defaultImpl属性等同于<aop:declare-parents>的default-impl属性。它标识该类所引入接口的实现。

  3. 由@DeclareParents注解所标注的static属性制订了将被引入的接口。

<bean class="com.shiftycat.concert.ContestantIntroducer" />

测试：

@Test
public void performXMLTest() {
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("concert-config.xml");
    Performance performance = (Performance) context.getBean("rocketStar");
    performance.perform();
    Contestant contestant = (Contestant) context.getBean("rocketStar");
    contestant.receiveAward();
}

输出：

观众入座了
关闭手机了
梁博演唱《出现又离开》
鼓掌了: 啪啪啪啪啪
梁博演唱《出现又离开》
鼓掌了: 啪啪啪啪啪
参加颁奖典礼

《Spring实战（第四版）》

shiftyCat
关注
专栏目录
Spring AOP面向切面编程:理解篇（一看就明白）
healer的博客
09-28 7万+
一直想着怎么去通俗的讲解AOP，看了一篇文章受到了启发（https://blog.csdn.net/qukaiwei/article/details/50367761），下面我加入自己的理解，咱们来说说AOP! 一、到底什么是AOP（面向切面编程）？ 无论在学习或者面试的时候，大家都会张口说spring的特性AOP和IOC(控制反转咱们下一篇讲)，有些大神理解的很到位，但是对于大多数初中级工程...
使用Spring进行面向切面编程
02-09 1万+
Chapter 6. 使用Spring进行面向切面编程（AOP） 6.1. 简介 面向切面编程（AOP）通过提供另外一种思考程序结构的途经来弥补面向对象编程（OOP）的不足。在OOP中模块化的关键单元是类（classes），而在AOP中模块化的单元则是切面。切面能对关注点进行模块化，例如横切多个类型和对象的事务管理。（在AOP术语中通常称作横切（crosscutti
Spring源码分析之AOP（基础篇）
最新发布
2301_78976656的博客
08-26 874
AOP作为一种编程范式，弥补OOP很难优雅处理横跨在程序多个模块的公共行为，其将这些行为从业务逻辑中分离，降低了代码的耦合度，使得业务层能专注于业务的实现。其核心概念有切面、连接点、通知、切点、织入。Spring AOP作为AOP的实现框架之一，通过代理模式实现了AOP，其代理对象的创建方式有两种：①JDK动态代理；②CGLIB。其核心组成为Advisor、Advice、Pointcut，通过这三个接口的实现，完成了切面相关概念的抽象，方便了与AspectJ的结合。
Spring中的面向切面编程
05-06 2万+
Spring中的面向切面编程
Spring AOP 实现原理
热门推荐
KevinJom的专栏
09-24 57万+
什么是AOP AOP（Aspect-OrientedProgramming，面向方面编程），可以说是OOP（Object-Oriented Programing，面向对象编程）的补充和完善。OOP引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一个集合。当我们需要为分散的对象引入公共行为的时候，OOP则显得无能为力。也就是说，OOP允许你定义从上到下的关系，但并不适合定义从
Spring详解（五）------AOP
IT可乐
09-07 213
　　这章我们接着讲 Spring 的核心概念---AOP，这也是 Spring 框架中最为核心的一个概念。 　　PS：本篇博客源码下载链接：http://pan.baidu.com/s/1skZjg7r 密码：dn42 1、AOP 什么？ 　　AOP（Aspect Oriented Programming），通常称为面向切面编程。它利用一种称为"横切"的技术，剖解开封装的对象内部，...
Spring AOP——Spring 中面向切面编程
杜海的博客
09-14 216
一、AOP——另一种编程思想 1.1 什么是 AOP AOP （Aspect Orient Programming）,直译过来就是 面向切面编程。AOP 是一种编程思想，是面向对象编程（OOP）的一种补充。面向对象编程将程序抽象成各个层次的对象，而面向切面编程是将程序抽象成各个切面。 从《Spring实战（第4版）》图书中扒了一张图： 从该图可以很形象地看出，所谓切面，相当于应用对象间的横切点，我们可以将其单独抽象为单独的模块。 1.2 为什么需要 AOP 想象下面的场景，开发中在多个模块间有某段
Spring 面向切面编程AOP实现详解
08-25
Spring 面向切面编程AOP实现详解 面向切面编程（AOP）是一种编程技术，旨在将横切关注点从业务逻辑中分离出来，提高系统的可扩展性和可维护性。Spring 作为一个流行的 Java 框架，提供了完备的 AOP 实现机制。 1. ...
Spring AOP面向切面编程实现原理方法详解
08-18
Spring AOP面向切面编程实现原理方法详解 面向切面编程（AOP）是Spring框架中的一个重要内容，通过预编译方式和运行期动态代理实现，在不修改源代码的情况下，给程序动态统一添加功能的一种技术。AOP可以对业务逻辑...
SpringBoot整合aop面向切面编程过程解析
08-24
SpringBoot整合AOP面向切面编程过程解析 AOP（Aspect Oriented Programming），即面向切面编程，是一种编程技术，通过预编译方式和运行期动态代理实现程序功能的统一维护。AOP是Spring框架中的一个重要内容，它通过...
详解spring面向切面aop拦截器
08-31
AOP（Aspect-Oriented Programming）是面向切面编程，指的是在软件开发中，通过预编译方式和运行期动态代理实现程序功能的增强。AOP 的主要思想是将散落的关注点（Cross-Cutting Concerns）集中起来，提高代码的可...
springAOP，面向切面编程详解，通俗易懂
秃头的博客
04-19 202
这里写目录标题一级目录二级目录三级目录aop实现AOP的方式案例环绕通知指定切点的问题各个通知的参数是什么意思底层代理切换Aspectj后置使用标签这种，在传参的时候异常麻烦 一级目录 二级目录 三级目录 aop aop面向切面 oop面向对象 模式跟动态代理差不多 实现AOP的方式 案例 需要导入aop和aop命名空间依赖的包 在xml中命名空间依赖 前置后置都一样的 环绕通知 异常通知 ## 异常通知不生效的方法 指定切点的问题 各个通知的参数是什么意思 首先后置通知比前置通知.
Spring之面向切面编程（AOP）
旭日的芬芳
10-29 7334
1. 面向切面编程 以下内容来自百度百科： 定义：面向切面编程（AOP，Aspect Oriented Programming）是通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。 作用：利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 主要功能：日志记录、性能统计、安全控制、事务处理、异常处理等。 总结：面向切面编程是希望能够将通用需求功能从不相关的类当中分离出来，能够使得很多类共享一个行为，一旦发生
Spring实战——面向切面的Spring
Zerohuan的专栏
09-27 3562
面向切面是Spring又一大核心，本章我们就来详细了解下：面向切面编程的基本原理以及创建使用切面的常用方法，如何为POJO创建切面，使用@AspectJ注释，为AspectJ切面注入依赖。 为什么要AOP： 日志、安全和事物管理是软件中很重要的组成部分，但是如果每个应用对象都需要自己处理这些问题，不仅开发者会十分厌烦，而且也不利于维护、复用以及扩展。这些分布于应用多处的功能
Spring之面向切面（AOP）
weixin_74352229的博客
08-17 1821
切点（Pointcut）：切点指定了在应用程序中哪些连接点应该被拦截和处理。连接点可以是方法的执行、方法的调用、对象的创建与初始化等。切点可以使用表达式或模式进行定义，以匹配特定的连接点。通知（Advice）：通知指定了在切点上要执行的逻辑。通知可以是在切点之前、之后或周围执行。在Spring中，常见的通知类型有前置通知、后置通知、返回通知和异常通知。切面（Aspect）：切面是通知和切点的组合。它是代码模块化的单元，它封装了特定关注点的逻辑和行为。切面定义了在哪些切点上应该执行特定的通知。
SpringAOP(面向切面原理)
weixin_45067120的博客
04-15 359
AOP中关键性概念 1. AOP2. AOP带来的好处3 工具类org.springframework.aop.framework.ProxyFactoryBean用来创建一个代理对象,在一般情况下它需要注入以下三个属性：4. 前置通知(org.springframework.aop.MethodBeforeAdvice)：在连接点之前执行的通知()5. 后置通知(org.springframew...
Spring的面向切面
weixin_33755847的博客
10-22 109
Spring的面向切面 　　在应用开发中，有很多类似日志、安全和事务管理的功能。这些功能都有一个共同点，那就是很多个对象都需要这些功能。复用这些通用的功能的最简单的方法就是继承或者委托。但是当应用规模达到一定程度时，使用继承或委托将会使应用的结构非常复杂。 　　面向切面便是解决上面问题的最佳办法。我们把这些通用的功能（横切关注点）放在专门的类中（这种类又叫切面），然后在程序运行后通过动态代理，...
Spring基础：切面
水知道答案
03-01 1万+
前言在之前的文章中总结了 AOP 在 Spring 中的作用及地位，在分析 AOP 时涉及到切面的内容，这一节详细的分析切面的知识点。正题在开始文章前，有几个问题需要思考一下：切面到底是神马切面的构成切面有哪些实现类切面有哪些类型1. 切面到底是神马在 AOP 一文中提到什么是 AOP？ AOP 可以使用 “面向切面编程”的译法。那切面就是把非业务逻辑相关的代码抽取出来定位到具体的连接点上的一种实...
Spring——面向切面编程(AOP)
行者无疆的博客
06-05 3772
本文介绍了切向切面编程(AOP)中的各个概念，并用两个案例分别讲解了如何通过注解和XML配置的方式使用AOP。
Spring AOP：面向切面编程详解与实战
本章节深入探讨了面向切面编程(AOP)这一强大的软件设计模式，它是软件开发中的一种热点技术，特别在Spring框架中占有重要地位。AOP旨在通过预先编译或运行时动态代理，实现对程序功能的集中管理和维护，从而提高代码...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值