看完还不会spring中的面向切面,你来打我

本文主要介绍内容:

面向切面编程的基本原理
通过POJO创建切面
使用@AspectJ注解
为AspectJ切面注入依赖

软件系统的功能需要用到应用程序的多个地方，但是我们又不想在每个点都明确调用它们。日志、安全和事务管理的确都很重要，但它们是否为应用对象主动参与的行为呢？如果让应用对象只关注于自己所针对的业务领域问题，而其他方面的问题由其他应用对象来处理，这会不会更好呢？

在软件开发中，散布于应用中多处的功能被称为横切关注点（cross-cutting concern）。通常来讲，这些横切关注点从概念上是与应用的业务逻辑相分离的（但是往往会直接嵌入到应用的业务逻辑之中）。把这些横切关注点与业务逻辑相分离正是面向切面编程（AOP）所要解决的问题。

AOP能够实现横切关注点和它们所影响的对象之间的解耦。

本文展示了Spring对切面的支持，包括如何把普通类声明为一个切面和如何使用注解创建切面。除此之外，我们还会看到AspectJ——另一种流行的AOP实现——如何补充Spring AOP框架的功能。但是，我们先不管事务、安全和缓存，先看一下Spring是如何实现切面的，就从AOP 的基础知识开始吧。

1.1 什么是面向切面编程

如前所述，切面能帮助我们模块化横切关注点。简而言之，横切关注点可以被描述为影响应用多处的功能。例如，安全就是一个横切关注点，应用中的许多方法都会涉及到安全规则。图1.1直观呈现了横切关注点的概念。
图1.1 切面实现了横切关注点（跨多个应用对象的逻辑）的模块化
图1.1展现了一个被划分为模块的典型应用。每个模块的核心功能都是为特定业务领域提供服务，但是这些模块都需要类似的辅助功能，例如安全和事务管理。

如果要重用通用功能的话，最常见的面向对象技术是继承（inheritance）或委托（delegation）。但是，如果在整个应用中都使用相同的基类，继承往往会导致一个脆弱的对象体系；而使用委托可能需要对委托对象进行复杂的调用。

切面提供了取代继承和委托的另一种可选方案，而且在很多场景下更清晰简洁。在使用面向切面编程时，我们仍然在一个地方定义通用功能，但是可以通过声明的方式定义这个功能要以何种方式在何处应用，而无需修改受影响的类。横切关注点可以被模块化为特殊的类，这些类被称为切面（aspect）。这样做有两个好处：首先，现在每个关注点都集中于一个地方，而不是分散到多处代码中；其次，服务模块更简洁，因为它们只包含主要关注点（或核心功能）的代码，而次要关注点的代码被转移到切面中了。

1.1.1 定义AOP术语

描述切面的常用术语有通知（advice）、切点（pointcut）和连接点（joinpoint）。图1.2展示了这些概念是如何关联到一起的
图1.2 在一个或者多个连接点上,可以把切面的功能织入到程序的执行过程中
通知(Advice)
Spring切面可以应用5种类型的通知：

前置通知（Before）：在目标方法被调用之前调用通知功能；
后置通知（After）：在目标方法完成之后调用通知，此时不会关心方法的输出是什么；
返回通知（After-returning）：在目标方法成功执行之后调用通知；
异常通知（After-throwing）：在目标方法抛出异常后调用通知；
环绕通知（Around）：通知包裹了被通知的方法，在被通知的方法调用之前和调用之后执行自定义的行为。

连接点(Join Point)
我们的应用可能也有不同的时机应用通知。这些时机被称为连接点。连接点是在应用执行过程中能够插入切面的一个点。这个点可以是调用方法时、抛出异常时、甚至修改一个字段时。切面代码可以利用这些点插入到应用的正常流程之中，并添加新的行为。

切点(Poincut)
如果说通知定义了切面的“什么”和“何时”的话，那么切点就定义了“何处”。切点的定义会匹配通知所要织入的一个或多个连接点。我们通常使用明确的类和方法名称，或是利用正则表达式定义所匹配的类和方法名称来指定这些切点。有些AOP框架允许我们创建动态的切点，可以根据运行时的决策（比如方法的参数值）来决定是否应用通知。

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

引入(Introduction)
引入允许我们向现有的类添加新方法或属性。例如，我们可以创建一个Auditable通知类，该类记录了对象最后一次修改时的状态。这很简单，只需一个方法，setLastModified(Date)，和一个实例变量来保存这个状态。然后，这个新方法和实例变量就可以被引入到现有的类中，从而可以在无需修改这些现有的类的情况下，让它们具有新的行为和状态。

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

编译期：切面在目标类编译时被织入。这种方式需要特殊的编译器。AspectJ的织入编译器就是以这种方式织入切面的。
类加载期：切面在目标类加载到JVM时被织入。这种方式需要特殊的类加载器（ClassLoader），它可以在目标类被引入应用之前增
强该目标类的字节码。AspectJ 5的加载时织入（load-time weaving，LTW）就支持以这种方式织入切面
运行期：切面在应用运行的某个时刻被织入。一般情况下，在织入切面时，AOP容器会为目标对象动态地创建一个代理对象。Spring AOP就是以这种方式织入切面的。

1.1.2 Spring对AOP的的支持

Spring提供了4种类型的AOP支持:
基于代理的经典Spring AOP；
纯POJO切面； @AspectJ注解驱动的切面；
注入式AspectJ切面（适用于Spring各版本）。

前三种都是Spring AOP实现的变体，Spring AOP构建在动态代理基础之上，因此，Spring对AOP的支持局限于方法拦截。

如果你的AOP需求超过了简单的方法调用（如构造器或属性拦截），那么你需要考虑使用AspectJ来实现切面。在这种情况下，上文所示的第四种类型能够帮助你将值注入到AspectJ驱动的切面中。

Spring通知是Java编写的
Spring所创建的通知都是用标准的Java类编写的。这样的话，我们就可以使用与普通Java开发一样的集成开发环境（IDE）来开发切面。而且，定义通知所应用的切点通常会使用注解或在Spring配置文件里采用XML来编写，这两种语法对于Java开发者来说都是相当熟悉的。

AspectJ与之相反。虽然AspectJ现在支持基于注解的切面，但AspectJ最初是以Java语言扩展的方式实现的。这种方式有优点也有缺点。通过特有的AOP语言，我们可以获得更强大和细粒度的控制，以及更丰富的AOP工具集，但是我们需要额外学习新的工具和语法。

Sping在运行时通知对象
通过在代理类中包裹切面，Spring在运行期把切面织入到Spring管理的bean中。如图1.3所示，代理类封装了目标类，并拦截被通知方法的调用，再把调用转发给真正的目标bean。当代理拦截到方法调用时，在调用目标bean方法之前，会执行切面逻辑。

Spring的切面由包裹了目标对象的代理类实现。代理类处理方法的调用，执行额外的切面逻辑，并调用目标方法
直到应用需要被代理的bean时，Spring才创建代理对象。如果使用的是ApplicationContext的话，在ApplicationContext从BeanFactory中加载所有bean的时候，Spring才会创建被代理的对象。因为Spring运行时才创建代理对象，所以我们不需要特殊的编译器来织入Spring AOP的切面。

Spring只支持方法级别的连接点
通过使用各种AOP方案可以支持多种连接点模型。因为Spring基于动态代理，所以Spring只支持方法连接点。这与一些其他的AOP框架是不同的，例如AspectJ和JBoss，除了方法切点，它们还提供了字段和构造器接入点。Spring缺少对字段连接点的支持，无法让我们创建细粒度的通知，例如拦截对象字段的修改。而且它不支持构造器连接点，我们就无法在bean创建时应用通知。

但是方法拦截可以满足绝大部分的需求。如果需要方法拦截之外的连接点拦截功能，那么我们可以利用Aspect来补充Spring AOP的功能。

1.2 通过切点来选择连接点

切点用于准确定位应该在什么地方应用切面的通知。通知和切点是切面的最基本元素。因此,了解如何编写切点非常重要。

关于Spring AOP的AspectJ切点，最重要的一点就是Spring仅支持AspectJ切点指示器（pointcut designator）的一个子集。Spring是基于代理的，而某些切点表达式是与基于代理的AOP无关的。下表列出了SpringAOP所支持的AspectJ切点指示器

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

在Spring中尝试使用AspectJ其他指示器时，将会抛出IllegalArgument-Exception异常。

当我们查看如上所展示的这些Spring支持的指示器时，注意只有execution指示器是实际执行匹配的，而其他的指示器都是用来限制匹配的。这说明execution指示器是我们在编写切点定义时最主要使用的指示器。在此基础上，我们使用其他指示器来限制所匹配的切点。

1.2.1 编写切点

为了阐述Spring中的切面，我们需要有个主题来定义切面的切点。为此，我们定义一个DoSomething接口：

package com.example.aspect;

public interface DoSomething {
	public void sleeping();
}

DoSomething可以代表任何行为,比如吃饭,睡觉。假设我们编写DoSomething 的sleeping()方法触发的通知。下图展示了一个切点表达式,这个表达式能够设置sleeping()方法执行时触发通知的调用。

使用AspectJ切点表达式来选择DomeSomething的sleeping()方法
我们使用execution()指示器选择DomeSomething的sleeping()方法。方法表达式以“*”号开始，表明了我们不关心方法返回值的类型。然后，我们指定了全限定类名和方法名。对于方法参数列表，我们使用两个点号（…）表明切点要选择任意的perform()方法，无论该方法的入参是什么。

现在假设我们需要配置的切点仅匹配aspect包。在此场景下，可以使用within()指示器来限制匹配
在这里插入图片描述
请注意我们使用了“&&”操作符把execution()和within()指示器连接在一起形成与（and）关系（切点必须匹配所有的指示器）。类似地，我们可以使用“||”操作符来标识或（or）关系，而使用“!”操作符来标识非（not）操作。

1.2.2 在切点中选择bean

除了表中所列的指示器外，Spring还引入了一个新的bean()指示器，它允许我们在切点表达式中使用bean的ID来标识bean。bean()使用 bean ID或bean名称作为参数来限制切点只匹配特定的bean。

execution(* com.example.aspect.DoSomething.sleeping(..)) 
		and bean('dosomething'))

在这里，我们希望在执行DoSomething的sleeping()方法时应用通知，但限定bean的ID为dosomething。

在某些场景下，限定切点为指定的bean或许很有意义，但我们还可以使用非操作为除了特定ID以外的其他bean应用通知：

execution(* com.example.aspect.DoSomething.sleeping(..)) 
		and !bean('dosomething'))

在此场景下，切面的通知会被编织到所有ID不为dosomething的bean中。

1.3 使用注解创建切面

使用注解来创建切面是AspectJ 5所引入的关键特性。AspectJ 5之前，编写AspectJ切面需要学习一种Java语言的扩展，但是AspectJ面向注解的模型可以非常简便地通过少量注解把任意类转变为切面。

1.31. 定义切面

我们已经定义了DoSomething接口，它是切面中切点的目标对象。现在，让我们使用AspecJ注解来定义切面。

/**

/**
 * 程序清单 1.1 睡觉监控 切面
 */
@Aspect
public class MonitorSleep {

	/**
	 * 睡觉前
	 */
	@Before("execution(* com.example.aspect.DoSomething.sleeping(..))")
	public void beforeSleep() {
		System.out.println("睡前擦香香,会变更漂亮");
	}


	/**
	 * 睡觉前
	 */
	@Before("execution(* com.example.aspect.DoSomething.sleeping(..))")
	public void beforeSleep2() {
		System.out.println("睡前先关灯.....");
	}


	/**
	 * 睡觉后
	 */
	@AfterReturning("execution(* com.example.aspect.DoSomething.sleeping(..))")
	public void afterSleeping() {
		System.out.println("睡完觉了.....");
	}


	/**
	 * 睡觉失败后
	 */
	@AfterThrowing("execution(* com.example.aspect.DoSomething.sleeping(..))")
	public void failSleeping() {
		System.out.println("爷失眠了.....");
	}
}

MonitorSleep类使用@AspectJ注解进行了标注。该注解表明MonitorSleep不仅仅是一个POJO，还是一个切面。MonitorSleep类中的方法都使用注解来定义切面的具体行为

MonitorSleep有四个方法，定义了一个人睡觉过程中可能会做的事情。在睡觉前,睡完觉和睡觉失败三种情况。

可以看到，这些方法都使用了通知注解来表明它们应该在什么时候调用。AspectJ提供了五个注解来定义通知,如下表所示:

注解	通知
@After	通知方法会在目标方法返回或抛出异常后调用
@AfterReturning	通知方法会在目标方法返回后调用
@AfterThrowing	通知方法会在目标方法抛出异常后调用
@Around	通知方法会将目标方法封装起来
@Before	通知方法会在目标方法调用之前执行

你可能已经注意到了，所有的这些注解都给定了一个切点表达式作为它的值，同时，这四个方法的切点表达式都是相同的。其实，它们可以设置成不同的切点表达式，但是在这里，这个切点表达式就能满足所有通知方法的需求。让我们近距离看一下这个设置给通知注解的切点表达式，我们发现它会在DoSomething的sleeping()方法执行时触发。

相同的切点表达式出现了四次,这样的重复让人很不爽。如果可以值定义这个切点一次,然后每次需要的时候引用它,这应该会是个很好地方案

我们完全可以这样做：@Pointcut注解能够在一个@AspectJ切面内定义可重用的切点。接下来的程序清单1.2展现了新的MonitorSleep，现在它使用了@Pointcut。

/**
 * 程序清单 1.2 睡觉监控 切面 改造后
 * 通过@Pointcut注解声明频繁使用的切点表达式
 */
@Aspect
public class MonitorSleep {
	@Pointcut("execution(* com.example.aspect.DoSomething.sleeping(..))")
	public void sleep(){

	}


	/**
	 * 睡觉前
	 */
	@Before("sleep()")
	public void beforeSleep() {
		System.out.println("睡前擦香香,会变更漂亮");
	}


	/**
	 * 睡觉前
	 */
	@Before("sleep()")
	public void beforeSleep2() {
		System.out.println("睡前先关灯.....");
	}


	/**
	 * 睡觉后
	 */
	@AfterReturning("sleep()")
	public void afterSleeping() {
		System.out.println("睡完觉了.....");
	}


	/**
	 * 睡觉失败后
	 */
	@AfterThrowing("sleep()")
	public void failSleeping() {
		System.out.println("爷失眠了.....");
	}
}

sleep()方法的实际内容并不重要，在这里它实际上应该是空的。其实该方法本身只是一个标识，供@Pointcut注解依附。

需要注意的是，除了注解和没有实际操作的sleep()方法，MonitorSleep 类依然是一个POJO。我们能够像使用其他的Java类那样调用它的方法，它的方法也能够独立地进行单元测试，这与其他的Java类并没有什么区别。MonitorSleep 只是一个Java类，只不过它通过注解表明会作为切面使用而已。

像其他的Java类一样，它可以装配为Spring中的bean：

@Bean
	public MonitorSleep monitorSleep(){
		return new MonitorSleep();
	}

如果你就此止步的话，MonitorSleep 只会是Spring容器中的一个bean。即便使用了AspectJ注解，但它并不会被视为切面，这些注解不会解析，也不会创建将其转换为切面的代理。

如果你使用JavaConfig的话，可以在配置类的类级别上通过使用EnableAspectJ-AutoProxy注解启用自动代理功能。程序清单1.3展现了如何在JavaConfig中启用自动代理。

/**
 * 在JavaConfig中启用AspectJ注解的自动代理
 * 程序清单1.3
 */
@Configuration
@EnableAspectJAutoProxy  //启用AspectJ自动代理
@ComponentScan
public class JavaConfig {

	//声明bean
	@Bean
	public MonitorSleep monitorSleep(){
		return new MonitorSleep();
	}
}

假如你在Spring中要使用XML来装配bean的话，那么需要使用Spring aop命名空间中的aop:aspectj-autoproxy元素。这里就不做详细介绍了,读者可以自行尝试。

不管你是使用JavaConfig还是XML，AspectJ自动代理都会为使用@Aspect注解的bean创建一个代理，这个代理会围绕着所有该切面的切点所匹配的bean。在这种情况下，将会为bean创建一个代理，MonitorSleep 类中的通知方法将会在sleeping()调用前后执行。

我们需要记住的是，Spring的AspectJ自动代理仅仅使用@AspectJ作为创建切面的指导，切面依然是基于代理的。在本质上，它依然是Spring 基于代理的切面。这一点非常重要，因为这意味着尽管使用的是@AspectJ注解，但我们仍然限于代理方法的调用。如果想利用AspectJ的所有能力，我们必须在运行时使用AspectJ并且不依赖Spring来创建基于代理的切面。

到现在为止，我们的切面在定义时，使用了不同的通知方法来实现前置通知和后置通知。但是表中还提到了另外的一种通知：环绕通知（around advice）。环绕通知与其他类型的通知有所不同，因此值得花点时间来介绍如何进行编写。

1.3.2 创建环绕通知

环绕通知是最为强大的通知类型。它能够让你所编写的逻辑将被通知的目标方法完全包装起来。实际上就像在一个通知方法中同时编写前置通知和后置通知。

为了阐述环绕通知，我们重写MonitorSleep切面。这次，我们使用一个环绕通知来代替之前多个不同的前置通知和后置通知

**
 * 程序清单 1.5 使用环绕通知重新实现MonitorSleep切面
 */
@Aspect
public class MonitorSleep {
	@Pointcut("execution(* com.example.aspect.DoSomething.sleeping(..))")
	public void sleep(){

	}

	@Around("sleep()")
	public void withSleeping(ProceedingJoinPoint joinPoint){
		try{
			System.out.println("睡前擦香香,会变更漂亮");
			System.out.println("睡前先关灯.....");
			joinPoint.proceed();
			System.out.println("睡完觉了.....");
		}catch (Throwable t){
			System.out.println("爷失眠了.....");
		}
	}
}

在这里，@Around注解表明withSleeping()方法会作为sleeping()切点的环绕通知。
在这个通知中，人会执行睡前擦香香,然后关灯睡觉,睡觉成功会睡完觉,失败了会失眠。

可以看到，这个通知所达到的效果与之前的前置通知和后置通知是一样的。但是，现在它们位于同一个方法中，不像之前那样分散在四个不同的通知方法里面。

关于这个新的通知方法，你首先注意到的可能是它接受ProceedingJoinPoint作为参数。这个对象是必须要有的，因为你要在通知中通过它来调用被通知的方法。通知方法中可以做任何的事情，当要将控制权交给被通知的方法时，它需要调用ProceedingJoinPoint的proceed()方法。

需要注意的是，别忘记调用proceed()方法。如果不调这个方法的话，那么你的通知实际上会阻塞对被通知方法的调用。有可能这就是你想要的效果，但更多的情况是你希望在某个点上执行被通知的方法。

有意思的是，你可以不调用proceed()方法，从而阻塞对被通知方法的访问，与之类似，你也可以在通知中对它进行多次调用。要这样做的一个场景就是实现重试逻辑，也就是在被通知方法失败后，进行重复尝试。

1.3.3 处理通知中的参数

到目前为止，我们的切面都很简单，没有任何参数。唯一的例外是我们为环绕通知所编写的withSleeping()示例方法中使用了ProceedingJoinPoint作为参数。除了环绕通知，我们编写的其他通知不需要关注传递给被通知方法的任意参数。这很正常，因为我们所通知的sleeping()方法本身没有任何参数。

但是，如果切面所通知的方法确实有参数该怎么办呢？切面能访问和使用传递给被通知方法的参数吗？

为了解释这个问题,我们定义一个Music样例。play()方法播放音乐,我们怎么样去记录播放次数呢?一种是去修改play()方法,每次调用时候记录这个数量。但是播放次数和播放本身就是不同的关注点,因此应该不属于play()方法。这应该是切面所需要处理的。

/**
 * 程序清单 1.6
 * 使用参数化通知记录音乐播放次数
 */
@Aspect
public class MusicCounter {
	private Map<Integer, Integer> counts = new HashMap<>();

	//通知play()方法
	@Pointcut("execution(* com.example.aspect.Music.play(..))" +
			"&& args(playNum)")
	public void playMusic(int playNum) {

	}

	@Before("playMusic(playNum)")
	public void counts(int playNum) {
		int count = getCount(playNum);
		counts.put(playNum, count + 1);

	}

	private int getCount(int playNum) {
		return counts.containsKey(playNum) ? counts.get(playNum) : 0;
	}
}

像之前所创建的切面一样，这个切面使用@Pointcut注解定义命名的切点，并使用@Before将一个方法声明为前置通知。但是，这里的不同点在于切点还声明了要提供给通知方法的参数。

我们需要关注的是切点表达式中的args(playNum)限定符。它表明传递给传递给play()方法的int类型参数也会传递到通知中去,这样就完成了从命名切点到通知方法的参数转移。

我们可以在Spring配置中将MusicCounter 定义为bean,并且启用AspectJ自动代理,

/**
 * 在MusicCountConfig中启用AspectJ注解的自动代理
 * 程序清单1.7
 */
@Configuration
@EnableAspectJAutoProxy  //启用AspectJ自动代理
@ComponentScan
public class MusicCountConfig {

	//声明bean
	@Bean
	public MusicCounter musicCounter(){
		return new MusicCounter();
	}
	
    @Bean
	public Music music(){
		return new Music();
	}

}

为了证明它可以工作,简单的写几个测试

/**
 * 代码清单1.8 测试
 */
@SpringBootTest(classes = MusicCountConfig.class)
@RunWith(SpringRunner.class)
public class TestAspect {
	@Autowired
	MusicCounter counter;

	@Autowired
	Music music;

	@Test
	public void testPlay(){
		music.play(1);
		music.play(2);
		music.play(3);
		music.play(3);
		music.play(3);
		music.play(3);
		music.play(7);
		music.play(7);
		Assert.assertEquals(1,counter.getCount(1));
		Assert.assertEquals(1,counter.getCount(2));
		Assert.assertEquals(4,counter.getCount(3));
		Assert.assertEquals(0,counter.getCount(4));
		Assert.assertEquals(0,counter.getCount(5));
		Assert.assertEquals(0,counter.getCount(6));
		Assert.assertEquals(2,counter.getCount(7));
	}
}

到目前为止，在我们所使用的切面中，所包装的都是被通知对象的已有方法。但是，方法包装仅仅是切面所能实现的功能之一。让我们看一下如何通过编写切面，为被通知的对象引入全新的功能。

1.3.4 通过注解引入新功能

一些编程语言，例如Ruby和Groovy，有开放类的理念。它们可以不用直接修改对象或类的定义就能够为对象或类增加新的方法。不过，Java并不是动态语言。一旦类编译完成了，我们就很难再为该类添加新的功能了。

但是如果仔细想想，我们在本文中不是一直在使用切面这样做吗？当然，我们还没有为对象增加任何新的方法，但是已经为对象拥有的方法添加了新功能。如果切面能够为现有的方法增加额外的功能，为什么不能为一个对象增加新的方法呢？实际上，利用被称为引入的AOP概念，切面可以为Spring bean添加新方法。

回顾一下，在Spring中，切面只是实现了它们所包装bean相同接口的代理。如果除了实现这些接口，代理也能暴露新接口的话，会怎么样呢？那样的话，切面所通知的bean看起来像是实现了新的接口，即便底层实现类并没有实现这些接口也无所谓。下图展示了它们是如何工作的。
在这里插入图片描述

我们需要注意的是，当引入接口的方法被调用时，代理会把此调用委托给实现了新接口的某个其他对象。实际上，一个bean的实现被拆分到了多个类中。

为了验证该主意能行得通，我们为示例中的所有的DoSomething实现引入下面的Encoreable接口：

public interface Encoreable {
	public void doSomethingEncore();
}

我们需要有一种方式将这个接口应用到DoSomething实现中。我们现在假设你能够访问DoSomething的所有实现，并对其进行修改，让它们都实现Encoreable接口。但是，从设计的角度来看，这并不是最好的做法，并不是所有的DoSomething都是具有Encoreable特性的。另外一方面，有可能无法修改所有的DoSomething实现，当使用第三方实现并且没有源码的时候更是如此。

值得庆幸的是，借助于AOP的引入功能，我们可以不必在设计上妥协或者侵入性地改变现有的实现。为了实现该功能，我们要创建一个新的切面：

@Aspect
public class EncoreableIntroducer {
	
	@DeclareParents(value = "com.example.aspect.DoSomething+",defaultImpl = EncoreableImpl.class)
	public static Encoreable encoreable;
}

可以看到，EncoreableIntroducer 是一个切面。但是，它与我们之前所创建的切面不同，它并没有提供前置、后置或环绕通知，而是通过@DeclareParents注解，将Encoreable接口引入到DoSomething bean中。

@DeclareParents注解由三部分组成：

value属性指定了哪种类型的bean要引入该接口。在本例中，也就是所有实现DoSomething 的类型。（标记符后面的加号表示是DoSomething 的所有子类型，而不是DoSomething 本身。)
defaultImpl属性指定了为引入功能提供实现的类。在这里，我们指定的是EncoreableImpl提供实现。
@DeclareParents注解所标注的静态属性指明了要引入了接口。在这里，我们所引入的是Encoreable接口。

和其他的切面一样，我们需要在Spring应用中将EncoreableIntroducer声明为一个bean

Spring的自动代理机制将会获取到它的声明，当Spring发现一个bean使用了@Aspect注解时，Spring就会创建一个代理，然后将调用委托给被代理的bean或被引入的实现，这取决于调用的方法属于被代理的bean还是属于被引入的接口。

1.4 总结

AOP是面向对象编程的一个强大补充。通过AspectJ，我们现在可以把之前分散在应用各处的行为放入可重用的模块中。我们显示地声明在何处如何应用该行为。这有效减少了代码冗余，并让我们的类关注自身的主要功能。

Spring提供了一个AOP框架，让我们把切面插入到方法执行的周围。现在我们已经学会如何把通知织入前置、后置和环绕方法的调用中，以及为处理异常增加自定义的行为。

关于在Spring应用中如何使用切面，我们可以有多种选择。通过使用@AspectJ注解和简化的配置命名空间，在Spring中装配通知和切点变得非常简单。

最后，当Spring AOP不能满足需求时，我们必须转向更为强大的AspectJ。对于这些场景，我们了解了如何使用Spring为AspectJ切面注入依赖

原文链接：https://blog.csdn.net/weixin_42116559/article/details/106337234