将 AspectJ 与 Spring 应用程序结合使用 (Using AspectJ with Spring Applications) _ Spring Framework 6.0.23-SNAPSHOT 中文文档(官方文档中文翻译) —

此版本仍在开发中，尚未被视为稳定版本。对于最新的稳定版本，请使用 Spring Framework 6.1.10！Spring中文文档

到目前为止，我们在本章中介绍的所有内容都是纯粹的 Spring AOP。在本节中，我们将了解如何使用 AspectJ 编译器或 weaver 而不是 or in 除了 Spring AOP 之外，如果您的需求超出了 Spring AOP 提供的功能独自。Spring中文文档

Spring 附带了一个小型 AspectJ 方面库，该库可在分布为 .您需要按顺序将其添加到类路径中以使用其中的方面。使用 AspectJ 使用 Spring 和 AspectJ 的其他 Spring 方面进行依赖注入域对象，讨论此库的内容以及如何使用它。使用 Spring IoC 配置 AspectJ Aspects 讨论了如何依赖项注入使用 AspectJ 编译器编织的 AspectJ 方面。最后，Spring 框架中使用 AspectJ 的加载时间编织介绍了 Spring 应用程序的加载时间编织使用 AspectJ。spring-aspects.jarSpring中文文档

使用 AspectJ 依赖注入 Spring 的域对象

Spring 容器实例化并配置应用程序中定义的 Bean 上下文。也可以要求 bean 工厂配置预先存在的对象，给定包含要应用的配置的 Bean 定义的名称。包含一个注释驱动的方面，利用了这一点允许对任何对象进行依赖注入的能力。该支持旨在用于在任何容器控制之外创建的对象。域对象通常属于此类别，因为它们通常是使用运算符以编程方式创建的，或者由 ORM 工具作为数据库查询的结果创建的。spring-aspects.jarnewSpring中文文档

注释将类标记为符合 Spring 驱动的条件配置。在最简单的情况下，您可以将其纯粹用作标记注释，因为以下示例显示：@ConfigurableSpring中文文档

JavaSpring中文文档
KotlinSpring中文文档

package com.xyz.domain;

import org.springframework.beans.factory.annotation.Configurable;

@Configurable
public class Account {
	// ...
}

package com.xyz.domain

import org.springframework.beans.factory.annotation.Configurable

@Configurable
class Account {
	// ...
}

当以这种方式用作标记接口时，Spring 会配置注释类型（在本例中）通过使用 Bean 定义（通常 prototype-scoped）与完全限定类型名称同名 ().由于 Bean 的默认名称是其类型的完全限定名称，这是声明原型定义的便捷方式省略该属性，如以下示例所示：Accountcom.xyz.domain.AccountidSpring中文文档

<bean class="com.xyz.domain.Account" scope="prototype">
	<property name="fundsTransferService" ref="fundsTransferService"/>
</bean>

如果要显式指定要使用的原型 Bean 定义的名称，则可以直接在注解中执行此操作，如以下示例所示：Spring中文文档

JavaSpring中文文档
KotlinSpring中文文档

package com.xyz.domain;

import org.springframework.beans.factory.annotation.Configurable;

@Configurable("account")
public class Account {
	// ...
}

package com.xyz.domain

import org.springframework.beans.factory.annotation.Configurable

@Configurable("account")
class Account {
	// ...
}

Spring 现在查找一个名为 Bean 的定义，并将其用作定义以配置新实例。accountAccountSpring中文文档

您还可以使用自动接线来避免在以下位置指定专用 Bean 定义都。要让 Spring 应用自动接线，请使用注释的属性。您可以按类型或名称指定 or 用于自动接线，分别。作为替代方法，最好指定显式的、注释驱动的通过字段或方法级别或在字段或方法级别对 Bean 进行依赖注入（有关详细信息，请参阅基于注释的容器配置）。autowire@Configurable@Configurable(autowire=Autowire.BY_TYPE)@Configurable(autowire=Autowire.BY_NAME)@Configurable@Autowired@InjectSpring中文文档

最后，您可以为新使用属性创建和配置对象（例如，）。如果此属性是设置为，Spring 在配置后验证所有属性（不是基元或集合）已设置。dependencyCheck@Configurable(autowire=Autowire.BY_NAME,dependencyCheck=true)trueSpring中文文档

请注意，单独使用注释不会执行任何操作。它是作用于存在注释。从本质上讲，该方面说，“从初始化返回后一个类型的新对象，配置新创建的对象根据注释的属性使用 Spring“。在这种情况下， “初始化”是指新实例化的对象（例如，实例化的对象与操作员）以及正在经历的对象反序列化（例如，通过 readResolve（））。AnnotationBeanConfigurerAspectspring-aspects.jar@ConfigurablenewSerializableSpring中文文档

上一段中的一个关键词是“实质上”。在大多数情况下， “从新对象的初始化返回后”的确切语义是好。在此上下文中，“初始化后”意味着依赖项是在对象构建完成后注入。这意味着依赖项不可用于类的构造函数主体。如果想要在构造函数主体运行之前注入的依赖项，因此是可用于构造函数的正文，您需要在声明中定义它，如下所示：@ConfigurableSpring中文文档

JavaSpring中文文档
KotlinSpring中文文档

@Configurable(preConstruction = true)

@Configurable(preConstruction = true)

您可以找到有关各种切入点的语言语义的详细信息在 AspectJ 中键入 AspectJ 的附录编程指南。Spring中文文档

为此，必须使用 AspectJ 织布机编织带注释的类型。您可以使用构建时 Ant 或 Maven 任务来执行此操作（例如，参见 AspectJ 开发环境指南）或加载时编织（请参阅 Spring 框架中使用 AspectJ 的加载时编织）。本身需要通过 Spring 进行配置（为了获得对用于配置新对象的 Bean 工厂的引用）。如果你使用基于 Java 的配置，可以添加到任何类中，如下所示：AnnotationBeanConfigurerAspect@EnableSpringConfigured@ConfigurationSpring中文文档

JavaSpring中文文档
KotlinSpring中文文档

@Configuration
@EnableSpringConfigured
public class AppConfig {
}

@Configuration
@EnableSpringConfigured
class AppConfig {
}

如果您更喜欢基于 XML 的配置，Spring 上下文命名空间定义了一个方便的元素，您可以按如下方式使用它：context:spring-configuredSpring中文文档

<context:spring-configured/>

在配置方面之前创建的对象的实例导致向调试日志发出一条消息，并且没有配置对象正在发生。一个示例可能是 Spring 配置中的 bean，它创建 domain 对象，当它被 Spring 初始化时。在这种情况下，您可以使用 bean 属性手动指定 Bean 依赖于配置方面。下面的示例演示如何使用该属性：@Configurabledepends-ondepends-onSpring中文文档

<bean id="myService"
		class="com.xyz.service.MyService"
		depends-on="org.springframework.beans.factory.aspectj.AnnotationBeanConfigurerAspect">

	<!-- ... -->

</bean>

不要通过 bean configurer 方面激活处理，除非您真的意味着在运行时依赖它的语义。特别是，请确保您这样做不适用于注册为常规 Spring Bean 的 Bean 类与容器。这样做会导致双重初始化，一次通过容器和一次通过方面。@Configurable@Configurable

单元测试对象`@Configurable`

支持的目标之一是启用独立的单元测试域对象，而没有与硬编码查找相关的困难。如果类型不是由 AspectJ 编织的，则注释没有影响在单元测试期间。您可以在测试并照常进行。如果类型是由 AspectJ 编织的，您仍然可以像往常一样在容器外部进行单元测试，但您会看到一条警告每次构造对象时的消息，指示它具有 Spring 未配置。@Configurable@Configurable@Configurable@ConfigurableSpring中文文档

使用多个应用程序上下文

用于实现支持的是 AspectJ 单例方面。单例方面的范围与范围相同成员数：每个方面有一个定义类型的方面实例。这意味着，如果在同一层次结构中定义多个应用程序上下文，则需要考虑在何处定义 Bean 和在类路径上放置的位置。AnnotationBeanConfigurerAspect@ConfigurablestaticClassLoaderClassLoader@EnableSpringConfiguredspring-aspects.jarSpring中文文档

考虑具有共享父应用程序的典型 Spring Web 应用程序配置定义常见业务服务的上下文，支持这些服务所需的一切，以及每个 Servlet 的一个子应用程序上下文（其中包含特定的定义到该 servlet）。所有这些上下文都共存于同一层次结构中，因此，只能保留对其中一个的引用。在这种情况下，我们建议在共享中定义 Bean （父）应用程序上下文。这定义了您可能想要的服务注入到域对象中。结果是无法配置域对象引用在子（特定于 servlet）上下文中定义的 Bean，方法是使用 @Configurable机制（这可能不是你想做的事情）。ClassLoaderAnnotationBeanConfigurerAspect@EnableSpringConfiguredSpring中文文档

在同一容器中部署多个 Web 应用程序时，请确保每个 Web 应用程序使用自己的类型加载类型（例如，通过放置）。如果仅添加到容器范围的类路径（因此由共享父级加载），则所有 Web 应用程序共享相同的方面实例（可能是不是你想要的）。spring-aspects.jarClassLoaderspring-aspects.jarWEB-INF/libspring-aspects.jarClassLoaderSpring中文文档

JavaSpring中文文档
KotlinSpring中文文档

@Configurable(preConstruction = true)

@Configurable(preConstruction = true)

您可以找到有关各种切入点的语言语义的详细信息在 AspectJ 中键入 AspectJ 的附录编程指南。Spring中文文档

AspectJ 的其他 Spring 方面

除了 aspect 之外，还包含一个 AspectJ 可用于驱动 Spring 的类型和方法事务管理的方面用注释进行注释。这主要适用于以下用户想要在 Spring 容器之外使用 Spring Framework 的事务支持。@Configurablespring-aspects.jar@TransactionalSpring中文文档

解释注释的方面是。当你使用这个方面时，你必须注释实现类（或该类中的方法或两者），而不是接口（如果 any）实现。AspectJ 遵循 Java 的规则，即对接口不会被继承。@TransactionalAnnotationTransactionAspectSpring中文文档

类的注释指定了类中任何公共操作的执行。@TransactionalSpring中文文档

类中方法的注释将覆盖缺省值由类注解（如果存在）给出的事务语义。任何方法可以对可见性进行注释，包括私有方法。注释非公共方法直接是获取交易划分以执行此类方法的唯一方法。@TransactionalSpring中文文档

由于 Spring Framework 4.2 提供了一个类似的方面，它提供了与标准注释完全相同的功能。查看更多详细信息。spring-aspectsjakarta.transaction.TransactionalJtaAnnotationTransactionAspect

对于想要使用 Spring 配置和事务的 AspectJ 程序员管理支持，但不想（或不能）使用注释，还包含可以扩展以提供自己的切入点的方面定义。有关详细信息，请参阅和方面的源代码。例如，以下内容摘录显示了如何编写一个方面来配置对象的所有实例在领域模型中使用与完全限定的类名：spring-aspects.jarabstractAbstractBeanConfigurerAspectAbstractTransactionAspectSpring中文文档

public aspect DomainObjectConfiguration extends AbstractBeanConfigurerAspect {

	public DomainObjectConfiguration() {
		setBeanWiringInfoResolver(new ClassNameBeanWiringInfoResolver());
	}

	// the creation of a new bean (any object in the domain model)
	protected pointcut beanCreation(Object beanInstance) :
		initialization(new(..)) &&
		CommonPointcuts.inDomainModel() &&
		this(beanInstance);
}

使用 Spring IoC 配置 AspectJ Aspects

当您在 Spring 应用程序中使用 AspectJ 方面时，很自然地想要和期望能够使用 Spring 配置这些方面。AspectJ 运行时本身是负责方面创建，以及配置 AspectJ 创建的方法通过 Spring 的方面取决于 AspectJ 实例化模型（子句）由方面使用。per-xxxSpring中文文档

大多数 AspectJ 方面都是单例方面。这些的配置方面很容易。您可以创建一个 Bean 定义，该定义将 aspect 类型引用为 normal 并包含 bean 属性。这确保了 Spring 通过向 AspectJ 请求 aspect 实例来获取它，而不是尝试创建实例本身。下面的示例演示如何使用该属性：factory-method="aspectOf"factory-method="aspectOf"Spring中文文档

<bean id="profiler" class="com.xyz.profiler.Profiler"
		factory-method="aspectOf"> (1)

	<property name="profilingStrategy" ref="jamonProfilingStrategy"/>
</bean>

1	注意属性`factory-method="aspectOf"`

非单一实例方面更难配置。但是，可以通过以下方式做到这一点创建原型 Bean 定义，并在 ASPECT 实例创建 Bean 后，使用 FROM 支持来配置 ASPECT 实例 AspectJ 运行时。@Configurablespring-aspects.jarSpring中文文档

如果您有一些@AspectJ方面想要与 AspectJ 一起编织（例如，对域模型类型使用加载时编织）以及所需的其他@AspectJ方面与Spring AOP一起使用，而这些方面都是在Spring中配置的，你需要告诉 Spring AOP @AspectJ 自动代理支持哪个确切的子集配置中定义@AspectJ方面应用于自动代理。您可以为此，请在声明中使用一个或多个元素。每个元素都指定一个名称模式，并且只有 bean 与至少一种模式匹配的名称用于 Spring AOP 自动代理配置。下面的示例演示如何使用元素：<include/><aop:aspectj-autoproxy/><include/><include/>Spring中文文档

<aop:aspectj-autoproxy>
	<aop:include name="thisBean"/>
	<aop:include name="thatBean"/>
</aop:aspectj-autoproxy>

不要被元素的名称所误导。使用它导致创建 Spring AOP 代理。@AspectJ风格的方面这里使用声明，但不涉及 AspectJ 运行时。<aop:aspectj-autoproxy/>

1	注意属性`factory-method="aspectOf"`

不要被元素的名称所误导。使用它导致创建 Spring AOP 代理。@AspectJ风格的方面这里使用声明，但不涉及 AspectJ 运行时。<aop:aspectj-autoproxy/>

在 Spring 框架中使用 AspectJ 进行加载时编织

加载时间编织（LTW）是指将 AspectJ 方面编织成应用程序的类文件，因为它们正在加载到 Java 虚拟机（JVM）中。本节的重点是在特定上下文中配置和使用 LTW Spring 框架。本节不是对 LTW 的一般介绍。有关以下内容的完整详细信息 LTW 的细节和仅使用 AspectJ 配置 LTW（Spring 不是完全涉及），请参阅 AspectJ 的 LTW 部分开发环境指南。Spring中文文档

Spring 框架为 AspectJ LTW 带来的价值在于实现很多对织造过程进行更精细的控制。'Vanilla' AspectJ LTW 通过使用 Java （5+）代理，通过在启动 JVM。因此，它是 JVM 范围的设置，在某些情况下可能很好，但通常是有点太粗糙了。启用 Spring 的 LTW 允许您在每个基数，哪个更细粒度，哪个可以做得更多在“单 JVM-多应用程序”环境中（例如在典型的应用程序服务器环境）。ClassLoaderSpring中文文档

此外，在某些环境中，这种支持可以加载时编织，无需对应用程序服务器的启动进行任何修改添加 OR 所需的脚本（如我们所述本节后面）。开发人员配置用于启用加载时编织而不是依赖管理员的应用程序上下文谁通常负责部署配置，例如启动脚本。-javaagent:path/to/aspectjweaver.jar-javaagent:path/to/spring-instrument.jarSpring中文文档

现在推销已经结束，让我们先来看看 AspectJ 的一个快速示例使用 Spring 的 LTW，然后是有关例。有关完整示例，请参阅 Petclinic 示例应用程序。Spring中文文档

第一个例子

假设您是一名应用程序开发人员，其任务是诊断系统中某些性能问题的原因。与其爆发一个分析工具，我们将打开一个简单的分析方面，让我们快速获取一些性能指标。然后，我们可以应用更细粒度的分析工具之后立即到该特定区域。Spring中文文档

此处提供的示例使用 XML 配置。您还可以配置和将 @AspectJ 与 Java 配置一起使用。具体来说，您可以使用注释作为替代（有关详细信息，请参见下文）。@EnableLoadTimeWeaving<context:load-time-weaver/>

下面的示例显示了分析方面，这并不花哨。它是一个基于时间的探查器，它使用@AspectJ样式的方面声明：Spring中文文档

JavaSpring中文文档
KotlinSpring中文文档

package com.xyz;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.util.StopWatch;
import org.springframework.core.annotation.Order;

@Aspect
public class ProfilingAspect {

	@Around("methodsToBeProfiled()")
	public Object profile(ProceedingJoinPoint pjp) throws Throwable {
		StopWatch sw = new StopWatch(getClass().getSimpleName());
		try {
			sw.start(pjp.getSignature().getName());
			return pjp.proceed();
		} finally {
			sw.stop();
			System.out.println(sw.prettyPrint());
		}
	}

	@Pointcut("execution(public * com.xyz..*.*(..))")
	public void methodsToBeProfiled(){}
}

package com.xyz

import org.aspectj.lang.ProceedingJoinPoint
import org.aspectj.lang.annotation.Aspect
import org.aspectj.lang.annotation.Around
import org.aspectj.lang.annotation.Pointcut
import org.springframework.util.StopWatch
import org.springframework.core.annotation.Order

@Aspect
class ProfilingAspect {

	@Around("methodsToBeProfiled()")
	fun profile(pjp: ProceedingJoinPoint): Any? {
		val sw = StopWatch(javaClass.simpleName)
		try {
			sw.start(pjp.getSignature().getName())
			return pjp.proceed()
		} finally {
			sw.stop()
			println(sw.prettyPrint())
		}
	}

	@Pointcut("execution(public * com.xyz..*.*(..))")
	fun methodsToBeProfiled() {
	}
}

我们还需要创建一个文件，以通知 AspectJ weaver 我们想把我们的融入到我们的课堂上。本文件约定，即 Java 类路径上存在一个名为标准方面J。以下示例显示了该文件：META-INF/aop.xmlProfilingAspectMETA-INF/aop.xmlaop.xmlSpring中文文档

<!DOCTYPE aspectj PUBLIC "-//AspectJ//DTD//EN" "https://www.eclipse.org/aspectj/dtd/aspectj.dtd">
<aspectj>

	<weaver>
		<!-- only weave classes in our application-specific packages -->
		<include within="com.xyz.*"/>
	</weaver>

	<aspects>
		<!-- weave in just this aspect -->
		<aspect name="com.xyz.ProfilingAspect"/>
	</aspects>

</aspectj>

现在，我们可以继续讨论配置中特定于 Spring 的部分。我们需要配置 A（稍后解释）。这个加载时织机是负责将方面配置编织成一个或将更多文件添加到应用程序的类中。好的问题是它不需要很多配置（还有更多您可以指定的选项，但这些选项将在后面详细介绍），如以下示例：LoadTimeWeaverMETA-INF/aop.xmlSpring中文文档

<?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:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="
		http://www.springframework.org/schema/beans
		https://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context
		https://www.springframework.org/schema/context/spring-context.xsd">

	<!-- a service object; we will be profiling its methods -->
	<bean id="entitlementCalculationService"
			class="com.xyz.StubEntitlementCalculationService"/>

	<!-- this switches on the load-time weaving -->
	<context:load-time-weaver/>
</beans>

现在，所有必需的工件（方面、文件和 Spring 配置）都已就绪，我们可以创建以下内容驱动程序类，其中包含演示 LTW 实际操作的方法：META-INF/aop.xmlmain(..)Spring中文文档

JavaSpring中文文档
KotlinSpring中文文档

package com.xyz;

// imports

public class Main {

	public static void main(String[] args) {
		ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");

		EntitlementCalculationService service =
				ctx.getBean(EntitlementCalculationService.class);

		// the profiling aspect is 'woven' around this method execution
		service.calculateEntitlement();
	}
}

package com.xyz

// imports

fun main() {
	val ctx = ClassPathXmlApplicationContext("beans.xml")

	val service = ctx.getBean(EntitlementCalculationService.class)

	// the profiling aspect is 'woven' around this method execution
	service.calculateEntitlement()
}

我们还有最后一件事要做。本节的引言确实说过，人们可以使用 Spring 有选择地打开 LTW，这是真的。但是，在此示例中，我们使用 Java 代理（随 Spring 提供）来打开 LTW。我们使用以下命令来运行前面所示的类：ClassLoaderMainSpring中文文档

java -javaagent:C:/projects/xyz/lib/spring-instrument.jar com.xyz.Main

是用于指定和启用代理的标志检测在 JVM 上运行的程序。Spring 框架附带了这样的 agent，它被打包在 that 中，作为前面的示例。-javaagentInstrumentationSavingAgentspring-instrument.jar-javaagentSpring中文文档

程序执行的输出类似于下一个示例。（我在实现中引入了一个语句，以便探查器实际捕获 0 以外的内容毫秒（毫秒不是 AOP 引入的开销）。以下列表显示了我们在运行探查器时得到的输出：MainThread.sleep(..)calculateEntitlement()01234Spring中文文档

Calculating entitlement

StopWatch 'ProfilingAspect': running time (millis) = 1234
------ ----- ----------------------------
ms     %     Task name
------ ----- ----------------------------
01234  100%  calculateEntitlement

由于此 LTW 是通过使用成熟的 AspectJ 来实现的，因此我们不仅限于提供建议春豆。以下程序的细微变化会产生相同的结果结果：MainSpring中文文档

JavaSpring中文文档
KotlinSpring中文文档

package com.xyz;

// imports

public class Main {

	public static void main(String[] args) {
		new ClassPathXmlApplicationContext("beans.xml");

		EntitlementCalculationService service =
				new StubEntitlementCalculationService();

		// the profiling aspect will be 'woven' around this method execution
		service.calculateEntitlement();
	}
}

package com.xyz

// imports

fun main(args: Array<String>) {
	ClassPathXmlApplicationContext("beans.xml")

	val service = StubEntitlementCalculationService()

	// the profiling aspect will be 'woven' around this method execution
	service.calculateEntitlement()
}

请注意，在前面的程序中，我们如何引导 Spring 容器和然后创建一个完全外部的新实例 Spring的背景。分析建议仍然被编织在一起。StubEntitlementCalculationServiceSpring中文文档

诚然，这个例子过于简单化。但是，Spring 中 LTW 支持的基础知识在前面的示例中都介绍了这些内容，本节的其余部分将进行说明详细介绍每个配置和用法背后的“原因”。Spring中文文档

此示例中使用的可能是基本的，但它非常有用。这是一个开发人员在开发过程中可以使用的开发时方面的一个很好的例子然后轻松地从正在部署的应用程序的构建中排除进入UAT或生产。ProfilingAspect

方面

在 LTW 中使用的方面必须是 AspectJ 方面。你可以把它们写进去要么是 AspectJ 语言本身，要么你可以用 @AspectJ 风格来编写你的方面。然后，您的方面既是有效的 AspectJ 方面，也是 Spring AOP 方面。此外，编译的方面类需要在类路径上可用。Spring中文文档

“元-INF/aop.xml”

AspectJ LTW 基础结构是通过使用 Java 类路径上的一个或多个文件（直接或更典型的 jar 文件）来配置的。META-INF/aop.xmlSpring中文文档

此文件的结构和内容在 AspectJ 参考的 LTW 部分进行了详细介绍文档。由于该文件是 100% AspectJ，因此我们在这里不再进一步描述。aop.xmlSpring中文文档

必需的库（JARS）

至少需要以下库才能使用 Spring Framework 的支持对于 AspectJ LTW：Spring中文文档

spring-aop.jarSpring中文文档
aspectjweaver.jarSpring中文文档

如果使用 Spring 提供的代理来启用检测，则还需要：Spring中文文档

spring-instrument.jarSpring中文文档

Spring 配置

Spring 的 LTW 支持的关键组件是接口（在包中）和众多的实现其中随 Spring 发行版一起发布。A 负责向 AT 添加一个或多个运行时，它为各种有趣的应用程序打开了大门，其中之一恰好是方面的 LTW。LoadTimeWeaverorg.springframework.instrument.classloadingLoadTimeWeaverjava.lang.instrument.ClassFileTransformersClassLoaderSpring中文文档

如果您不熟悉运行时类文件转换的概念，请参阅在继续之前，包的 javadoc API 文档。虽然该文档并不全面，但至少您可以看到关键界面和类（供您阅读本节时参考）。java.lang.instrument

为特定配置可以像添加一行。（请注意，您几乎肯定需要使用 an 作为 Spring 容器——通常，a 不是足够了，因为 LTW 支持使用 .）LoadTimeWeaverApplicationContextApplicationContextBeanFactoryBeanFactoryPostProcessorsSpring中文文档

要启用 Spring Framework 的 LTW 支持，您需要配置一个，这通常是通过使用注释来完成的，如下所示：LoadTimeWeaver@EnableLoadTimeWeavingSpring中文文档

JavaSpring中文文档
KotlinSpring中文文档

@Configuration
@EnableLoadTimeWeaving
public class AppConfig {
}

@Configuration
@EnableLoadTimeWeaving
class AppConfig {
}

或者，如果您更喜欢基于 XML 的配置，请使用该元素。请注意，该元素是在命名空间中定义的。以下示例演示如何使用：<context:load-time-weaver/>context<context:load-time-weaver/>Spring中文文档

<?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:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="
		http://www.springframework.org/schema/beans
		https://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context
		https://www.springframework.org/schema/context/spring-context.xsd">

	<context:load-time-weaver/>

</beans>

上述配置会自动定义并注册许多特定于 LTW 的基础结构 Bean，例如 A 和 An 。默认值是类，它尝试装饰自动检测到的 .“自动检测”的确切类型取决于您的运行时环境。下表总结了各种实现：LoadTimeWeaverAspectJWeavingEnablerLoadTimeWeaverDefaultContextLoadTimeWeaverLoadTimeWeaverLoadTimeWeaverLoadTimeWeaverSpring中文文档

表 1.DefaultContextLoadTimeWeaver LoadTimeWeavers
运行时环境	`LoadTimeWeaver`实现
在 Apache Tomcat 中运行Spring中文文档	`TomcatLoadTimeWeaver`Spring中文文档
在 GlassFish 中运行（仅限于 EAR 部署）Spring中文文档	`GlassFishLoadTimeWeaver`Spring中文文档
在 Red Hat 的 JBoss AS 或 WildFly 中运行Spring中文文档	`JBossLoadTimeWeaver`Spring中文文档
JVM 从 Spring 开始`InstrumentationSavingAgent` (`java -javaagent:path/to/spring-instrument.jar`)Spring中文文档	`InstrumentationLoadTimeWeaver`Spring中文文档
回退，期望基础 ClassLoader 遵循常见约定（即和可选的方法）`addTransformergetThrowawayClassLoader`Spring中文文档	`ReflectiveLoadTimeWeaver`Spring中文文档

请注意，该表仅列出了以下情况下自动检测到的使用 .您可以准确指定要使用的实现。LoadTimeWeaversDefaultContextLoadTimeWeaverLoadTimeWeaverSpring中文文档

要指定特定的 Java 配置，请实现接口并重写该方法。以下示例指定一个：LoadTimeWeaverLoadTimeWeavingConfigurergetLoadTimeWeaver()ReflectiveLoadTimeWeaverSpring中文文档

JavaSpring中文文档
KotlinSpring中文文档

@Configuration
@EnableLoadTimeWeaving
public class AppConfig implements LoadTimeWeavingConfigurer {

	@Override
	public LoadTimeWeaver getLoadTimeWeaver() {
		return new ReflectiveLoadTimeWeaver();
	}
}

@Configuration
@EnableLoadTimeWeaving
class AppConfig : LoadTimeWeavingConfigurer {

	override fun getLoadTimeWeaver(): LoadTimeWeaver {
		return ReflectiveLoadTimeWeaver()
	}
}

如果使用基于 XML 的配置，则可以指定完全限定的类名作为元素上属性的值。同样，以下示例指定：weaver-class<context:load-time-weaver/>ReflectiveLoadTimeWeaverSpring中文文档

<?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:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="
		http://www.springframework.org/schema/beans
		https://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context
		https://www.springframework.org/schema/context/spring-context.xsd">

	<context:load-time-weaver
			weaver-class="org.springframework.instrument.classloading.ReflectiveLoadTimeWeaver"/>

</beans>

由配置定义和注册的可以稍后使用众所周知的名称从 Spring 容器中检索。请记住，它仅作为 Spring 的 LTW 机制存在基础结构来添加一个或多个 .执行 LTW 的实际值是（从 package）类。有关更多详细信息，请参阅该类的类级 javadoc，因为织造实际影响超出了本文档的范围。LoadTimeWeaverloadTimeWeaverLoadTimeWeaverClassFileTransformersClassFileTransformerClassPreProcessorAgentAdapterorg.aspectj.weaver.loadtimeClassPreProcessorAgentAdapterSpring中文文档

还有最后一个配置属性需要讨论：属性（或者如果使用 XML）。此属性控制 LTW 是否是否启用。它接受三个可能的值之一，默认值为属性不存在时的值。下表总结了这三个可能的值：aspectjWeavingaspectj-weavingautodetectSpring中文文档

表 2.AspectJ 编织属性值
注释值	XML 值	解释
`ENABLED`Spring中文文档	`on`Spring中文文档	AspectJ 织造已开启，并根据需要在加载时织造方面。Spring中文文档
`DISABLED`Spring中文文档	`off`Spring中文文档	LTW 已关闭。在加载时不会编织任何方面。Spring中文文档
`AUTODETECT`Spring中文文档	`autodetect`Spring中文文档	如果 Spring LTW 基础结构至少可以找到一个文件，然后 AspectJ 编织开启。否则，它将关闭。这是默认值。`META-INF/aop.xml`Spring中文文档

特定于环境的配置

最后一部分包含所需的任何其他设置和配置当您在应用程序服务器和 Web 等环境中使用 Spring 的 LTW 支持时器皿。Spring中文文档

Tomcat、JBoss、WildFly

Tomcat 和 JBoss/WildFly 提供了一个通用的应用程序，它能够本地仪表。Spring 的原生 LTW 可能会利用这些 ClassLoader 实现提供 AspectJ 编织。如前所述，您可以简单地启用加载时编织。具体来说，您无需修改 JVM 启动脚本即可添加 .ClassLoader-javaagent:path/to/spring-instrument.jarSpring中文文档

请注意，在 JBoss 上，您可能需要禁用应用程序服务器扫描以防止它在应用程序实际启动之前加载类。一个快速的解决方法是添加到您的工件中，使用以下内容命名的文件：WEB-INF/jboss-scanning.xmlSpring中文文档

<scanning xmlns="urn:jboss:scanning:1.0"/>

通用 Java 应用程序

在不受具体实现，JVM 代理是通用解决方案。对于这种情况，Spring 提供了需要特定于 Spring（但非常通用）的 JVM 代理，自动检测通过通用和设置。LoadTimeWeaverInstrumentationLoadTimeWeaverspring-instrument.jar@EnableLoadTimeWeaving<context:load-time-weaver/>Spring中文文档

要使用它，您必须通过提供 Spring 代理来启动虚拟机以下 JVM 选项：Spring中文文档

-javaagent:/path/to/spring-instrument.jar

请注意，这需要修改 JVM 启动脚本，这可能会阻止您从在应用程序服务器环境中使用它（取决于您的服务器和操作策略）。也就是说，对于每个 JVM 一个应用程序的部署，例如独立部署 Spring Boot 应用程序，在任何情况下，您通常都可以控制整个 JVM 设置。Spring中文文档

表 1.DefaultContextLoadTimeWeaver LoadTimeWeavers
运行时环境	`LoadTimeWeaver`实现
在 Apache Tomcat 中运行Spring中文文档	`TomcatLoadTimeWeaver`Spring中文文档
在 GlassFish 中运行（仅限于 EAR 部署）Spring中文文档	`GlassFishLoadTimeWeaver`Spring中文文档
在 Red Hat 的 JBoss AS 或 WildFly 中运行Spring中文文档	`JBossLoadTimeWeaver`Spring中文文档
JVM 从 Spring 开始`InstrumentationSavingAgent` (`java -javaagent:path/to/spring-instrument.jar`)Spring中文文档	`InstrumentationLoadTimeWeaver`Spring中文文档
回退，期望基础 ClassLoader 遵循常见约定（即和可选的方法）`addTransformergetThrowawayClassLoader`Spring中文文档	`ReflectiveLoadTimeWeaver`Spring中文文档

表 2.AspectJ 编织属性值
注释值	XML 值	解释
`ENABLED`Spring中文文档	`on`Spring中文文档	AspectJ 织造已开启，并根据需要在加载时织造方面。Spring中文文档
`DISABLED`Spring中文文档	`off`Spring中文文档	LTW 已关闭。在加载时不会编织任何方面。Spring中文文档
`AUTODETECT`Spring中文文档	`autodetect`Spring中文文档	如果 Spring LTW 基础结构至少可以找到一个文件，然后 AspectJ 编织开启。否则，它将关闭。这是默认值。`META-INF/aop.xml`Spring中文文档

使用 AspectJ 依赖注入 Spring 的域对象

单元测试对象@Configurable

使用多个应用程序上下文

AspectJ 的其他 Spring 方面

使用 Spring IoC 配置 AspectJ Aspects

在 Spring 框架中使用 AspectJ 进行加载时编织

第一个例子

方面

“元-INF/aop.xml”

必需的库 （JARS）

Spring 配置

特定于环境的配置

Tomcat、JBoss、WildFly

通用 Java 应用程序

单元测试对象`@Configurable`

必需的库（JARS）