Spring 框架的核心技术(五）

标签：框架示例核心技术 Spring springframework 使用 org AspectJ

Spring 框架的核心技术(五）_应用程序

5.6. 选择要使用的 AOP 声明样式

一旦你确定一个方面是实现给定的最佳方法要求，您如何决定在使用Spring AOP或AspectJ之间以及在方面语言（代码）样式，@AspectJ注释样式，还是Spring XML样式？这些决策受许多因素的影响，包括应用程序要求，开发工具，以及团队对 AOP 的熟悉程度。

5.6.1. 弹簧 AOP 还是全方面 J？

使用最简单的方法。Spring AOP比使用完整的AspectJ更简单，因为无需将 AspectJ 编译器/编织者引入您的开发中和构建流程。如果您只需要建议在 Spring 上执行操作豆，春季AOP是正确的选择。如果您需要建议未由 Spring 容器（例如域对象，通常），您需要使用方面J.如果您希望建议除简单的方法执行（例如，字段获取或设置连接点等）。

当您使用 AspectJ 时，您可以选择 AspectJ 语言语法（也称为 “代码样式”）或@AspectJ注释样式。显然，如果你不使用Java。 5+，已经为您做出了选择：使用代码样式。如果方面发挥很大在您的设计中的角色，并且您可以使用AspectJ Eclipse的开发工具（AJDT）插件，AspectJ语言语法是首选选项。它更干净，更简单，因为语言是有目的地的专为写作方面而设计。如果您不使用 Eclipse 或只有几个方面在您的应用程序中不发挥重要作用，您可能需要考虑使用 @AspectJ风格，坚持在 IDE 中进行常规 Java 编译，并添加构建脚本的方面编织阶段。

5.6.2. Spring AOP 的@AspectJ或 XML？

如果您选择使用 Spring AOP，则可以选择@AspectJ或 XML 样式。需要考虑各种权衡。

XML风格可能是现有Spring用户最熟悉的，它由真正的支持。波约。当使用 AOP 作为配置企业服务的工具时，XML 可能是一个很好的选择（一个好的测试是你是否认为切入点表达式是你的一部分您可能希望单独更改的配置）。使用 XML 样式，它是可以说，从您的配置中可以更清楚地了解系统中存在哪些方面。

XML 样式有两个缺点。首先，它没有完全封装在一个地方实现它所解决的需求。干燥原则说任何部分都应该有一个单一的、明确的、权威的表示系统内的知识。使用 XML 样式时，了解如何要求实现在支持Bean类和XML的声明中被拆分配置文件。使用@AspectJ样式时，将封装此信息在单个模块中：方面。其次，XML 样式在以下方面受到更多限制它可以表达比@AspectJ样式：只有“单例”方面实例化模型受支持，并且无法组合在 XML 中声明的命名切入点。例如，在@AspectJ样式中，您可以编写如下内容：

@Pointcut("execution(* get*())")
public void propertyAccess() {}

@Pointcut("execution(org.xyz.Account+ *(..))")
public void operationReturningAnAccount() {}

@Pointcut("propertyAccess() && operationReturningAnAccount()")
public void accountPropertyAccess() {}

在 XML 样式中，可以声明前两个切入点：

<aop:pointcut id="propertyAccess"
        expression="execution(* get*())"/>

<aop:pointcut id="operationReturningAnAccount"
        expression="execution(org.xyz.Account+ *(..))"/>

XML 方法的缺点是无法通过组合这些定义来定义点切。accountPropertyAccess

@AspectJ样式支持其他实例化模型和更丰富的切入点组成。它的优点是将方面保留为模块化单元。它还具有 @AspectJ方面的优点是可以理解（从而消耗）两者春季AOP和AspectJ。因此，如果您后来决定需要AspectJ的功能要实现其他要求，您可以轻松迁移到经典的 AspectJ 设置。总的来说，Spring 团队更喜欢自定义方面的@AspectJ风格，而不仅仅是简单企业服务的配置。

5.7. 混合宽高比类型

完全可以通过使用自动代理支持混合@AspectJ样式方面，模式定义的方面，声明的顾问，甚至代理以及相同配置中其他样式的拦截器。所有这些都已实现通过使用相同的底层支持机制，可以毫无困难地共存。<aop:aspect><aop:advisor>

5.8. 代理机制

Spring AOP 使用 JDK 动态代理或 CGLIB 为给定的代理创建代理目标对象。JDK 动态代理内置于 JDK 中，而 CGLIB 是常见的开源类定义库（重新打包到）。spring-core

如果要代理的目标对象实现至少一个接口，则 JDK 动态使用代理。目标类型实现的所有接口都是代理的。如果目标对象未实现任何接口，则会创建 CGLIB 代理。

如果要强制使用 CGLIB 代理（例如，代理每个方法为目标对象定义，而不仅仅是由其接口实现的对象），你可以这样做。但是，您应该考虑以下问题：

使用 CGLIB，不能建议使用方法，因为它们不能在运行时生成的子类。final
从 Spring 4.0 开始，代理对象的构造函数不再被调用两次，因为 CGLIB 代理实例是通过 Objenesis 创建的。仅当您的 JVM 这样做时不允许绕过构造函数，您可能会看到双重调用和来自 Spring AOP 支持的相应调试日志条目。

要强制使用 CGLIB 代理，请设置属性的值元素为 true，如下所示：proxy-target-class<aop:config>

<aop:config proxy-target-class="true">
    <!-- other beans defined here... -->
</aop:config>

要在使用 @AspectJ 自动代理支持时强制 CGLIB 代理，请将元素的属性设置为如下：proxy-target-class<aop:aspectj-autoproxy>true

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

5.8.1. 了解 AOP 代理

Spring AOP 是基于代理的。掌握在你写自己的方面或使用任何方面之前，最后一句话实际上意味着什么 Spring 框架提供的基于 Spring AOP 的方面。

首先考虑以下情况：您有一个普通的、未代理的、没有什么特别的，直接的对象引用，如下所示代码片段显示：

public class SimplePojo implements Pojo {

    public void foo() {
        // this next method invocation is a direct call on the 'this' reference
        this.bar();
    }

    public void bar() {
        // some logic...
    }
}

如果在对象引用上调用方法，则直接在该对象引用，如下图所示和列表所示：

Spring 框架的核心技术(五）_应用程序_02

public class Main {

    public static void main(String[] args) {
        Pojo pojo = new SimplePojo();
        // this is a direct method call on the 'pojo' reference
        pojo.foo();
    }
}

当客户端代码具有的引用是代理时，情况会略有变化。考虑下图和代码片段：

Spring 框架的核心技术(五）_xml_03

public class Main {

    public static void main(String[] args) {
        ProxyFactory factory = new ProxyFactory(new SimplePojo());
        factory.addInterface(Pojo.class);
        factory.addAdvice(new RetryAdvice());

        Pojo pojo = (Pojo) factory.getProxy();
        // this is a method call on the proxy!
        pojo.foo();
    }
}

这里要了解的关键是方法中的客户端代码的类具有对代理的引用。这意味着该方法调用对象引用是对代理的调用。因此，代理可以委派给所有与该特定方法调用相关的拦截器（建议）。然而一旦调用最终到达目标对象（引用在这种情况下），它可能对自身进行的任何方法调用（例如 asor）都将针对引用而不是代理调用。这具有重要意义。这意味着不会产生自调用在与方法调用相关的建议中，获得运行的机会。main(..)MainSimplePojothis.bar()this.foo()this

好的，那么该怎么办呢？最佳方法（使用术语“最佳” 松散地在这里）是重构你的代码，这样就不会发生自调用。这确实需要您做一些工作，但这是最好的、侵入性最小的方法。下一个方法绝对是可怕的，我们犹豫是否要指出它，确切地说因为它太可怕了。你可以（对我们来说很痛苦）完全将逻辑联系起来在您的类中到 Spring AOP，如以下示例所示：

public class SimplePojo implements Pojo {

    public void foo() {
        // this works, but... gah!
        ((Pojo) AopContext.currentProxy()).bar();
    }

    public void bar() {
        // some logic...
    }
}

这完全将你的代码与Spring AOP耦合，它使类本身知道它被用于 AOP 上下文的事实，这与 AOP 背道而驰。它创建代理时还需要一些额外的配置，因为以下示例显示：

public class Main {

    public static void main(String[] args) {
        ProxyFactory factory = new ProxyFactory(new SimplePojo());
        factory.addInterface(Pojo.class);
        factory.addAdvice(new RetryAdvice());
        factory.setExposeProxy(true);

        Pojo pojo = (Pojo) factory.getProxy();
        // this is a method call on the proxy!
        pojo.foo();
    }
}

最后，必须注意的是，AspectJ 没有这个自调用问题，因为它不是基于代理的AOP框架。

5.9. @AspectJ代理的程序化创建

除了使用 anyor 声明配置中的方面外，还可以以编程方式创建代理建议目标对象。有关 Spring 的 AOP API 的完整详细信息，请参阅下一章。在这里，我们要关注的是自动的能力使用@AspectJ方面创建代理。<aop:config><aop:aspectj-autoproxy>

您可以使用类为目标对象创建由一个或多个@AspectJ方面建议的代理。此类的基本用法非常简单，如以下示例所示：org.springframework.aop.aspectj.annotation.AspectJProxyFactory

// create a factory that can generate a proxy for the given target object
AspectJProxyFactory factory = new AspectJProxyFactory(targetObject);

// add an aspect, the class must be an @AspectJ aspect
// you can call this as many times as you need with different aspects
factory.addAspect(SecurityManager.class);

// you can also add existing aspect instances, the type of the object supplied must be an @AspectJ aspect
factory.addAspect(usageTracker);

// now get the proxy object...
MyInterfaceType proxy = factory.getProxy();

有关更多信息，请参阅javadoc。

5.10. 将 AspectJ 与弹簧应用程序一起使用

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

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

5.10.1. 使用 AspectJ 通过 Spring 依赖注入域对象

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

注释将类标记为符合弹簧驱动的条件配置。在最简单的情况下，您可以纯粹将其用作标记注释，如以下示例显示：@Configurable

package com.xyz.myapp.domain;

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

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

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

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

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

package com.xyz.myapp.domain;

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

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

Spring 现在寻找一个名为 bean 定义并将其用作定义以配置新实例。accountAccount

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

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

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

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

@Configuration
@EnableSpringConfigured
public class AppConfig {
}

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

<context:spring-configured/>

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

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

    <!-- ... -->

</bean>

单元测试对象`@Configurable`

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

使用多个应用程序上下文

用于实现支持是一个方面J单例方面。单例方面的范围与范围相同 ofmembers：每个类加载器都有一个方面实例来定义类型。这意味着，如果在同一类装入器中定义多个应用程序上下文层次结构，您需要考虑在哪里定义 thebean 和类路径的放置位置。AnnotationBeanConfigurerAspect@Configurablestatic@EnableSpringConfiguredspring-aspects.jar

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

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

5.10.2. AspectJ 的其他弹簧方面

除了方面，还包含一个方面J 可用于驱动 Spring 类型和方法事务管理的方面用注释注释。这主要适用于以下用户：想要在 Spring 容器之外使用 Spring 框架的事务支持。@Configurablespring-aspects.jar@Transactional

解释注释的方面是。使用此方面时，必须注释实现类（或该类中的方法或两者），而不是接口（如果任何）类实现的。AspectJ遵循Java的规则，即注释接口不是继承的。@TransactionalAnnotationTransactionAspect

类上的注释指定执行类中的任何公共操作。@Transactional

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

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

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);
}

5.10.3. 使用 Spring IoC 配置 AspectJ 方面

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

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

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

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

非单一实例方面更难配置。但是，可以通过创建原型 Bean 定义并使用 Support From 在创建 Bean 后配置方面实例 AspectJ 运行时。@Configurablespring-aspects.jar

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

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

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

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

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

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

现在销售宣传已经结束，让我们首先通过AspectJ的快速示例使用 Spring 的 LTW，然后是有关例。有关完整示例，请参阅Petclinic 示例应用程序。

第一个例子

假设您是负责诊断的应用程序开发人员系统中某些性能问题的原因。而不是爆发分析工具，我们将打开一个简单的分析方面，让我们快速获取一些性能指标。然后，我们可以应用更细粒度的分析工具紧接着到该特定区域。

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

package foo;

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 * foo..*.*(..))")
    public void methodsToBeProfiled(){}
}

我们还需要创建一个文件，以通知 AspectJ 编织者我们想把我们的东西编织到我们的课堂上。此文件约定，即在调用的 Java 类路径上存在一个或多个文件是标准方面J。以下示例显示该文件：META-INF/aop.xmlProfilingAspectMETA-INF/aop.xmlaop.xml

<!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="foo.*"/>
    </weaver>

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

</aspectj>

现在我们可以转到配置的 Spring 特定部分。我们需要配置（稍后解释）。这个加载时间编织者是负责将方面配置编织在一个或更多文件到应用程序中的类中。好的问题是它不需要很多配置（还有一些您可以指定的选项，但稍后会详细介绍这些选项），如以下示例：LoadTimeWeaverMETA-INF/aop.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: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="foo.StubEntitlementCalculationService"/>

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

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

package foo;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public final class Main {

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

        EntitlementCalculationService entitlementCalculationService =
                (EntitlementCalculationService) ctx.getBean("entitlementCalculationService");

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

我们还有最后一件事要做。本节的介绍确实说可以使用 Spring 有选择地打开 LTW，这是真的。但是，对于此示例，我们使用Java代理（随Spring一起提供）来打开LTW。我们使用以下命令运行前面显示的类：ClassLoaderMain

java -javaagent:C:/projects/foo/lib/global/spring-instrument.jar foo.Main

这是用于指定和启用代理的标志来检测在 JVM 上运行的程序。Spring 框架附带了这样的代理，的，它被打包在那作为参数的值提供前面的示例。-javaagentInstrumentationSavingAgentspring-instrument.jar-javaagent

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

Calculating entitlement

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

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

package foo;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public final class Main {

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

        EntitlementCalculationService entitlementCalculationService =
                new StubEntitlementCalculationService();

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

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

诚然，这个例子太简单了。但是，春季LTW支持的基础知识在前面的示例中都进行了介绍，本节的其余部分将解释详细介绍了配置和使用背后的“原因”。

方面

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

“元信息/AOP.xml”

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

该文件的结构和内容在AspectJ参考的LTW部分中有详细说明文档。因为该文件是 100% AspectJ，所以我们在这里不再进一步描述它。aop.xml

所需库（罐）

至少，您需要以下库才能使用 Spring 框架的支持。对于AspectJ LTW：

spring-aop.jar
aspectjweaver.jar

如果您使用Spring 提供的代理启用检测，您还需要：

spring-instrument.jar

弹簧配置

Spring 的 LTW 支持的关键组件是接口（在包中）和众多实现它与弹簧发行版一起发货。艾斯负责添加一个或多个到 AAT 运行时，它为各种有趣的应用程序打开了大门，其中之一是恰好是各方面的LTW。LoadTimeWeaverorg.springframework.instrument.classloadingLoadTimeWeaverjava.lang.instrument.ClassFileTransformersClassLoader

为特定配置 a可以像添加一行。（请注意，您几乎肯定需要使用 anas 您的 Spring 容器 — 通常，ais 不是足够了，因为 LTW 支持使用。LoadTimeWeaverApplicationContextApplicationContextBeanFactoryBeanFactoryPostProcessors

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

@Configuration
@EnableLoadTimeWeaving
public class AppConfig {
}

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

<?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 的基础设施豆，如 Aand An，为你。默认值是类，它尝试来装饰自动检测。“自动检测”的确切类型取决于您的运行时环境。下表总结了各种实现：LoadTimeWeaverAspectJWeavingEnablerLoadTimeWeaverDefaultContextLoadTimeWeaverLoadTimeWeaverLoadTimeWeaverLoadTimeWeaver

Table 13. DefaultContextLoadTimeWeaver LoadTimeWeavers

运行时环境	`LoadTimeWeaver`实现
在阿帕奇雄猫中运行	`TomcatLoadTimeWeaver`
在GlassFish 中运行（仅限于 EAR 部署）	`GlassFishLoadTimeWeaver`
在Red Hat的JBoss AS或WildFly中运行	`JBossLoadTimeWeaver`
在IBM的WebSphere中运行	`WebSphereLoadTimeWeaver`
在Oracle的WebLogic中运行	`WebLogicLoadTimeWeaver`
JVM从Spring开始`InstrumentationSavingAgent` (`java -javaagent:path/to/spring-instrument.jar`)	`InstrumentationLoadTimeWeaver`
回退，期望底层类加载器遵循通用约定（即和可选的方法）`addTransformer``getThrowawayClassLoader`	`ReflectiveLoadTimeWeaver`

请注意，该表仅列出了当您自动检测到的使用。您可以准确指定要使用的实现。LoadTimeWeaversDefaultContextLoadTimeWeaverLoadTimeWeaver

要指定特定的 Java 配置，请实现接口并覆盖该方法。以下示例指定：LoadTimeWeaverLoadTimeWeavingConfigurergetLoadTimeWeaver()ReflectiveLoadTimeWeaver

@Configuration
@EnableLoadTimeWeaving
public class AppConfig implements LoadTimeWeavingConfigurer {

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

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

<?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 容器中检索。请记住，它仅作为弹簧LTW的一种机制而存在要添加一个或多个的基础结构。实际做 LTW 是（从包）类。有关更多详细信息，请参阅类的类级javadoc，因为具体如何实际进行的编织超出了本文档的范围。LoadTimeWeaverloadTimeWeaverLoadTimeWeaverClassFileTransformersClassFileTransformerClassPreProcessorAgentAdapterorg.aspectj.weaver.loadtimeClassPreProcessorAgentAdapter

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

Table 14. AspectJ weaving attribute values

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

特定于环境的配置

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

Tomcat， JBoss， WebSphere， WebLogic

Tomcat、JBoss/WildFly、IBM WebSphere Application Server 和 Oracle WebLogic Server 全部提供能够进行本地检测的常规应用。春天的本机 LTW 可以利用这些 ClassLoader 实现来提供 AspectJ 编织。您可以简单地启用加载时编织，如前所述。具体来说，您不需要修改要添加的 JVM 启动脚本。ClassLoader-javaagent:path/to/spring-instrument.jar

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

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

通用 Java 应用程序

当在不支持的环境中需要类检测时具体实现，JVM代理是通用解决方案。对于这种情况，Spring 提供这需要特定于弹簧（但非常通用）的 JVM 代理，自动检测通过共同设置。LoadTimeWeaverInstrumentationLoadTimeWeaverspring-instrument.jar@EnableLoadTimeWeaving<context:load-time-weaver/>

要使用它，您必须使用 Spring 代理启动虚拟机，方法是提供以下 JVM 选项：

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

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

5.11. 更多资源

有关AspectJ的更多信息，请访问AspectJ网站。

Eclipse AspectJ by AdrianColyer等（Addison-Wesley， 2005）提供了一个 AspectJ语言的全面介绍和参考。

AspectJ in Action，Ramnivas Laddad（Manning，2009）的第二版高度推荐推荐。本书的重点是AspectJ，但很多一般的AOP主题是探索（在一定深度）。

6. 春季 AOP API

上一章描述了 Spring 对 AOP 的支持，具有@AspectJ和基于模式方面定义。在本章中，我们将讨论较低级别的Spring AOP API。对于普通在应用中，我们建议使用带有AspectJ切入点的Spring AOP，如上一章。

6.1. 春季切入点 API

本节介绍 Spring 如何处理关键切入点概念。

6.1.1. 概念

Spring 的切入点模型可实现独立于建议类型的切入点重用。您可以用相同的切入点定位不同的建议。

该接口是中央接口，用于针对特定类别和方法的建议。完整的界面如下：org.springframework.aop.Pointcut

public interface Pointcut {

    ClassFilter getClassFilter();

    MethodMatcher getMethodMatcher();
}

将接口拆分为两部分允许重用类和方法匹配零件和细粒度组合操作（例如执行“联合” 使用另一个方法匹配器）。Pointcut

该接口用于将切入点限制为一组给定的目标类。如果该方法始终返回 true，则所有目标类都是匹配。以下清单显示了接口定义：ClassFiltermatches()ClassFilter

public interface ClassFilter {

    boolean matches(Class clazz);
}

界面通常更重要。完整的界面如下：MethodMatcher

public interface MethodMatcher {

    boolean matches(Method m, Class<?> targetClass);

    boolean isRuntime();

    boolean matches(Method m, Class<?> targetClass, Object... args);
}

该方法用于测试此切入点是否曾经匹配目标类上的给定方法。当 AOP 创建代理是为了避免对每个方法调用进行测试。如果双参数方法返回给定方法，方法匹配器返回的方法，三参数匹配方法是在每个方法调用时调用。这让我们可以切入点查看传递的参数到目标建议开始之前的方法调用。matches(Method, Class)matchestrueisRuntime()true

大多数实现是静态的，这意味着他们的方法返回。在这种情况下，永远不会调用三参数方法。MethodMatcherisRuntime()falsematches

6.1.2. 切入点的操作

弹簧支持切入点的操作（特别是并集和交叉）。

联合是指任一切入点匹配的方法。交集是指两个切入点匹配的方法。联合通常更有用。可以通过在类中使用静态方法或在同一包中使用类来组合切入点。但是，使用AspectJ切入点表达式通常是一种更简单的方法。org.springframework.aop.support.PointcutsComposablePointcut

6.1.3. 方面J 表达式切入点

从 2.0 开始，Spring 使用的最重要的切入点类型是。这是一个切入点使用 AspectJ 提供的库来解析 AspectJ 切入点表达式字符串。org.springframework.aop.aspectj.AspectJExpressionPointcut

有关支持的 AspectJ 切入点基元的讨论，请参阅上一章。

6.1.4. 便利切入点实现

Spring 提供了几个方便的切入点实现。您可以使用其中的一些径直;其他的则打算在特定于应用程序的切入点中进行子类化。

静态切入点

静态切入点基于方法和目标类，不能考虑方法的参数。静态切入点足以满足大多数用途，而且是最好的。 Spring 只能在首次调用方法时评估一次静态切入点。之后，无需在每次方法调用时再次评估切入点。

本节的其余部分介绍一些静态切入点实现，这些实现是包含在弹簧中。

正则表达式切入点

指定静态切入点的一种明显方法是正则表达式。几个AOP 除了 Spring 之外的框架使这个 possible.is 成为一个通用的常规使用 JDK 中的正则表达式支持的表达式切入点。org.springframework.aop.support.JdkRegexpMethodPointcut

使用 theclass，您可以提供模式字符串列表。如果其中任何一个是匹配项，则切入点的计算结果为。（因此，生成的切入点实际上是指定模式的并集。JdkRegexpMethodPointcuttrue

以下示例演示如何使用：JdkRegexpMethodPointcut

<bean id="settersAndAbsquatulatePointcut"
        class="org.springframework.aop.support.JdkRegexpMethodPointcut">
    <property name="patterns">
        <list>
            <value>.*set.*</value>
            <value>.*absquatulate</value>
        </list>
    </property>
</bean>

Spring 提供了一个名为 Convenience 的类，它让我们还参考 an（请记住，ANCAN 是一个拦截器，在建议之前，抛出建议等）。在幕后，春天使用了一个。使用简化了布线，因为一个豆子封装了两者切入点和建议，如以下示例所示：RegexpMethodPointcutAdvisorAdviceAdviceJdkRegexpMethodPointcutRegexpMethodPointcutAdvisor

<bean id="settersAndAbsquatulateAdvisor"
        class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
    <property name="advice">
        <ref bean="beanNameOfAopAllianceInterceptor"/>
    </property>
    <property name="patterns">
        <list>
            <value>.*set.*</value>
            <value>.*absquatulate</value>
        </list>
    </property>
</bean>

您可以与任何类型一起使用。RegexpMethodPointcutAdvisorAdvice

属性驱动的切入点

静态切入点的一个重要类型是元数据驱动的切入点。这使用元数据属性的值（通常是源级元数据）。

动态切入点

动态切入点的评估成本高于静态切入点。他们考虑到方法参数以及静态信息。这意味着它们必须是使用每个方法调用进行评估，并且结果无法缓存，因为参数将不同。

主要的例子是点切。control flow

控制流切入点

弹簧控制流切口在概念上类似于AspectJpointcuts，虽然没有那么强大。（目前无法指定切入点运行在与另一个切入点匹配的连接点下方。控制流切入点与当前调用堆栈。例如，如果连接点由方法调用，则可能会触发在包装中或按类。控制流切入点通过使用类指定。cflowcom.mycompany.webSomeCallerorg.springframework.aop.support.ControlFlowPointcut

6.1.5. 切入点超类

Spring 提供了有用的切入点超类来帮助您实现自己的切入点。

因为静态切入点最有用，所以你应该进行子类。这只需要实现一个抽象方法（尽管您可以重写其他方法来自定义行为）。这以下示例演示如何进行子类化：StaticMethodMatcherPointcutStaticMethodMatcherPointcut

class TestStaticPointcut extends StaticMethodMatcherPointcut {

    public boolean matches(Method m, Class targetClass) {
        // return true if custom criteria match
    }
}

还有用于动态切入点的超类。您可以将自定义切入点与任何建议类型一起使用。

6.1.6. 自定义切入点

因为Spring AOP中的切入点是Java类而不是语言功能（如 AspectJ），您可以声明自定义切入点，无论是静态的还是动态的。习惯春季的切入点可以任意复杂。但是，我们建议使用 AspectJ 切入点表达语言，如果可以的话。

6.2. 春季的建议 API

现在我们可以检查Spring AOP如何处理建议。

6.2.1. 建议生命周期

每个建议都是一个春豆。建议实例可以在所有建议之间共享对象或对于每个建议对象是唯一的。这对应于每个类或每个实例的建议。

每类建议最常使用。它适用于一般性建议，例如交易顾问。这些不依赖于代理对象的状态或添加新对象州。他们只是根据方法和参数行事。

每个实例的建议适用于介绍，以支持混合。在这种情况下，该建议将状态添加到代理对象。

您可以在同一 AOP 代理中混合使用共享建议和每实例建议。

6.2.2. 春季的建议类型

Spring 提供了多种建议类型，并且可以扩展以支持任意建议类型。本节介绍基本概念和标准建议类型。

拦截周围的建议

Spring中最基本的建议类型是围绕建议的拦截。

弹簧符合AOP接口，用于使用方法的周围建议拦截。实现和围绕建议实现的类也应该实现以下界面：AllianceMethodInterceptor

public interface MethodInterceptor extends Interceptor {

    Object invoke(MethodInvocation invocation) throws Throwable;
}

方法的参数公开了方法调用、目标连接点、AOP 代理和方法的参数。该方法应返回调用的结果：连接的返回值点。MethodInvocationinvoke()invoke()

以下示例显示了一个简单实现：MethodInterceptor

public class DebugInterceptor implements MethodInterceptor {

    public Object invoke(MethodInvocation invocation) throws Throwable {
        System.out.println("Before: invocation=[" + invocation + "]");
        Object rval = invocation.proceed();
        System.out.println("Invocation returned");
        return rval;
    }
}

请注意对方法的调用。这沿着拦截器链朝向连接点。大多数调用此方法和返回其返回值。但是，像周围的任何建议一样，可以返回不同的值或引发异常，而不是调用 Proceed 方法。但是，您不想在没有充分理由的情况下执行此操作。proceed()MethodInvocationMethodInterceptor

建议前

更简单的建议类型是建议之前。这不需要对象，因为它仅在输入方法之前被调用。MethodInvocation

之前建议的主要优点是不需要调用该方法，因此，不可能无意中无法继续拦截器链。proceed()

以下清单显示了界面：MethodBeforeAdvice

public interface MethodBeforeAdvice extends BeforeAdvice {

    void before(Method m, Object[] args, Object target) throws Throwable;
}

（Spring的API设计将允许建议之前的字段，尽管通常的对象适用于字段拦截，并且它是春天不太可能实现它。

请注意，返回类型为。在建议之前可以在联接之前插入自定义行为点运行，但无法更改返回值。如果之前的建议抛出异常，它会停止拦截器链的进一步执行。例外沿拦截器链向上传播。如果未选中或在签名上调用的方法，它直接传递给客户端。否则，它是由 AOP 代理包装在未经检查的异常中。void

以下示例显示了 Spring 中的 before 建议，它计算所有方法调用：

public class CountingBeforeAdvice implements MethodBeforeAdvice {

    private int count;

    public void before(Method m, Object[] args, Object target) throws Throwable {
        ++count;
    }

    public int getCount() {
        return count;
    }
}

投掷建议

如果连接点抛出异常。春天提供打字投掷建议。请注意，这意味着接口不包含任何方法。这是一个标记接口，标识给定对象实现一个或多个类型化抛出建议方法。这些应采用以下形式：org.springframework.aop.ThrowsAdvice

afterThrowing([Method, args, target], subclassOfThrowable)

只需要最后一个参数。方法签名可以有一个或四个参数，取决于建议方法是否对该方法感兴趣，以及参数。接下来的两个列表显示了作为投掷建议示例的类。

如果抛出 ais（包括从子类），则调用以下建议：RemoteException

public class RemoteThrowsAdvice implements ThrowsAdvice {

    public void afterThrowing(RemoteException ex) throws Throwable {
        // Do something with remote exception
    }
}

与前面不同建议，下一个示例声明了四个参数，以便它有权访问调用的方法，方法参数和目标对象。如果抛出 ais 将调用以下建议：ServletException

public class ServletThrowsAdviceWithArguments implements ThrowsAdvice {

    public void afterThrowing(Method m, Object[] args, Object target, ServletException ex) {
        // Do something with all arguments
    }
}

最后一个示例说明了如何在单个类中使用这两种方法处理两者。任意数量的投掷建议方法可以组合在单个类中。下面的清单显示了最后一个示例：RemoteExceptionServletException

public static class CombinedThrowsAdvice implements ThrowsAdvice {

    public void afterThrowing(RemoteException ex) throws Throwable {
        // Do something with remote exception
    }

    public void afterThrowing(Method m, Object[] args, Object target, ServletException ex) {
        // Do something with all arguments
    }
}

返回建议后

Spring 中的返回建议后必须实现接口，以下清单显示：org.springframework.aop.AfterReturningAdvice

public interface AfterReturningAdvice extends Advice {

    void afterReturning(Object returnValue, Method m, Object[] args, Object target)
            throws Throwable;
}

返回后通知可以访问返回值（它无法修改），调用的方法、方法的参数和目标。

返回建议后的以下内容将计算所有成功的方法调用，这些方法调用具有未引发异常：

public class CountingAfterReturningAdvice implements AfterReturningAdvice {

    private int count;

    public void afterReturning(Object returnValue, Method m, Object[] args, Object target)
            throws Throwable {
        ++count;
    }

    public int getCount() {
        return count;
    }
}

此建议不会更改执行路径。如果它引发异常，则为抛出拦截器链而不是返回值。

介绍建议

春天把介绍建议当作一种特殊的拦截建议。

引言需要阿南德· 实现以下接口：IntroductionAdvisorIntroductionInterceptor

public interface IntroductionInterceptor extends MethodInterceptor {

    boolean implementsInterface(Class intf);
}

从 AOP 联盟接口继承的方法必须实施介绍。也就是说，如果调用的方法位于引入的接口，引入拦截器负责处理方法调用 — 它无法调用。invoke()MethodInterceptorproceed()

介绍建议不能与任何切入点一起使用，因为它仅适用于课堂，而不是方法，水平。您只能使用介绍建议，它具有以下方法：IntroductionAdvisor

public interface IntroductionAdvisor extends Advisor, IntroductionInfo {

    ClassFilter getClassFilter();

    void validateInterfaces() throws IllegalArgumentException;
}

public interface IntroductionInfo {

    Class<?>[] getInterfaces();
}

因此，没有与介绍有关建议。只有类过滤是合乎逻辑的。MethodMatcherPointcut

该方法返回此顾问程序引入的接口。getInterfaces()

该方法在内部用于查看是否引入的接口可以由配置的实现。validateInterfaces()IntroductionInterceptor

考虑 Spring 测试套件中的一个例子，假设我们想要将以下接口引入一个或多个对象：

public interface Lockable {
    void lock();
    void unlock();
    boolean locked();
}

这说明了一个混合。我们希望能够将建议的对象投射到，无论他们的类型和呼叫锁定和解锁方法是什么。如果我们调用该方法，我们希望所有 setter 方法都抛出 a。因此，我们可以添加一个方面提供使对象不可变的能力，而无需它们对此一无所知： AOP的一个很好的例子。Lockablelock()LockedException

首先，我们需要一个繁重的工作。在此案例，我们扩展了便利类。我们可以直接实现，但在大多数情况下使用是最好的。IntroductionInterceptororg.springframework.aop.support.DelegatingIntroductionInterceptorIntroductionInterceptorDelegatingIntroductionInterceptor

Theis 旨在将介绍委托给实际实现引入的接口，隐蔽使用拦截这样做。可以使用构造函数参数将委托设置为任何对象。这默认委托（使用无参数构造函数时）为。因此，在下一个示例中，委托是的子类。给定一个委托（默认情况下，它本身），一个实例查找委托实现的所有接口（除外），并支持针对其中任何一个接口的引入。子类（如can）调用该方法来抑制不应公开的接口。但是，无论多少准备支持的接口 ANIS，用于控制实际公开哪些接口。一引入的接口隐藏了目标对同一接口的任何实现。DelegatingIntroductionInterceptorthisLockMixinDelegatingIntroductionInterceptorDelegatingIntroductionInterceptorIntroductionInterceptorLockMixinsuppressInterface(Class intf)IntroductionInterceptorIntroductionAdvisor

因此，扩展和实现自己。超类自动拾取可以支持的简介，所以我们不需要指定。我们可以介绍任意数量的以这种方式进行接口。LockMixinDelegatingIntroductionInterceptorLockableLockable

请注意实例变量的使用。这有效地增加了额外的状态到目标对象中保存的那个。locked

以下示例显示了示例类：LockMixin

public class LockMixin extends DelegatingIntroductionInterceptor implements Lockable {

    private boolean locked;

    public void lock() {
        this.locked = true;
    }

    public void unlock() {
        this.locked = false;
    }

    public boolean locked() {
        return this.locked;
    }

    public Object invoke(MethodInvocation invocation) throws Throwable {
        if (locked() && invocation.getMethod().getName().indexOf("set") == 0) {
            throw new LockedException();
        }
        return super.invoke(invocation);
    }

}

通常，您不需要重写该方法。实现（调用方法 if 引入该方法，否则继续向连接点前进）够。在本例中，我们需要添加一个检查：不能调用 setter 方法如果在锁定模式下。invoke()DelegatingIntroductionInterceptordelegate

所需的引入只需要保留一个不同的实例并指定引入的接口（在本例中，仅）。一个更复杂的例子可以参考引言拦截器（将被定义为原型）。在这种情况下，没有与 A 相关的配置，因此我们使用它创建它。以下示例显示了我们的类：LockMixinLockableLockMixinnewLockMixinAdvisor

public class LockMixinAdvisor extends DefaultIntroductionAdvisor {

    public LockMixinAdvisor() {
        super(new LockMixin(), Lockable.class);
    }
}

我们可以非常简单地应用此顾问，因为它不需要配置。（但是，它是不可能使用没有安。像往常一样，介绍顾问必须是每个实例，因为它是有状态的。我们需要一个不同的实例，因此，对于每个建议的对象。顾问包括建议对象的一部分州。IntroductionInterceptorIntroductionAdvisorLockMixinAdvisorLockMixin

我们可以通过使用方法或以编程方式应用此顾问（推荐的方法）在 XML 配置中，与任何其他顾问一样。所有代理创建下面讨论的选项（包括“自动代理创建者”）正确处理介绍和有状态的混合。Advised.addAdvisor()

6.3. 春季的顾问 API

在春季，顾问是一个方面，它只包含一个相关的建议对象用切入点的表达。

除了介绍的特殊情况外，任何顾问都可以与任何最常用的 advice.is 一起使用顾问类。它可以与 a、、or 一起使用。org.springframework.aop.support.DefaultPointcutAdvisorMethodInterceptorBeforeAdviceThrowsAdvice

可以在同一个AOP代理中混合使用Spring中的顾问和建议类型。为例如，您可以在建议周围、抛出建议和在建议之前使用拦截一个代理配置。弹簧自动创建必要的拦截器链。

6.4. 使用创建 AOP 代理`ProxyFactoryBean`

如果您将 Spring IoC 容器（anor）用于业务对象（你应该是！），你想使用Spring 的 AOP 实现之一。（请记住，工厂 bean 引入了一层间接层，让它创建不同类型的对象。ApplicationContextBeanFactoryFactoryBean

在 Spring 中创建 AOP 代理的基本方法是使用。这样可以完全控制切入点，任何适用的建议及其顺序。但是，有更简单的如果您不需要此类控制，则最好选择这些选项。org.springframework.aop.framework.ProxyFactoryBean

6.4.1. 基础知识

与其他 Spring 实现一样，它引入了一个间接级别。如果定义 anamed，则对象引用看不到实例本身，而是一个对象由方法的实现创建。这方法创建包装目标对象的 AOP 代理。ProxyFactoryBeanFactoryBeanProxyFactoryBeanfoofooProxyFactoryBeangetObject()ProxyFactoryBean

使用 aor 另一个 IoC 感知的最重要好处之一创建 AOP 代理的类是建议和切入点也可以由国际奥委会管理。这是一个强大的功能，支持某些难以实现的方法与其他 AOP 框架一起实现。例如，建议本身可以参考应用程序对象（除了目标，它应该在任何 AOP 中可用框架），受益于依赖注入提供的所有可插拔性。ProxyFactoryBean

6.4.2. JavaBean 属性

与 Spring 提供的大多数实现一样，该类本身就是一个 JavaBean。其属性用于：FactoryBeanProxyFactoryBean

指定要代理的目标。
指定是否使用 CGLIB（稍后将介绍，另请参阅基于 JDK 和 CGLIB 的代理）。

一些关键属性继承自（Spring 中所有 AOP 代理工厂的超类）。这些关键属性包括以下内容：org.springframework.aop.framework.ProxyConfig

proxyTargetClass：如果要代理目标类，而不是目标类的接口。如果此属性值设置为 CGLIB 代理创建（但另请参阅基于 JDK 和 CGLIB 的代理）。truetrue
optimize：控制是否将主动优化应用于代理通过CGLIB创建。您不应随意使用此设置，除非您完全了解相关 AOP 代理如何处理优化。这是当前使用的仅适用于 CGLIB 代理。它对 JDK 动态代理没有影响。
frozen：如果是代理配置，则对配置的更改是不再允许。这既可以作为轻微的优化，也可以用于这些情况当您不希望调用方能够在创建代理后（通过接口）操作代理时。此属性的默认值为，因此允许更改（例如添加其他建议）。frozenAdvisedfalse
exposeProxy：确定是否应在 a中公开当前代理，以便目标可以访问它。如果目标需要获取将代理和属性设置为，目标可以使用该方法。ThreadLocalexposeProxytrueAopContext.currentProxy()

特定于的其他属性包括：ProxyFactoryBean

proxyInterfaces：接口名称数组。如果未提供，则 CGLIB 使用目标类的代理（但另请参阅基于 JDK 和 CGLIB 的代理）。String
interceptorNames：一组、拦截器或其他建议名称应用。订购量很大，先到先得。也就是说，列表中的第一个拦截器是第一个能够拦截调用。StringAdvisor

这些名称是当前工厂中的豆名，包括来自祖先的豆名工厂。您不能在此处提及 bean 引用，因为这样做会导致忽略建议的单例设置。ProxyFactoryBean

可以在拦截器名称后附加星号（）。这样做会导致应用名称以星号前部分开头的所有顾问 Bean 待应用。您可以在使用“全局”顾问中找到使用此功能的示例。*
单例：工厂是否应该返回单个对象，无论如何通常称为该方法。几个实现提供这样的方法。默认值为。如果您想使用有状态的建议 - 对于例如，对于有状态混合 - 使用原型建议以及单例值。getObject()FactoryBeantruefalse

6.4.3. 基于 JDK 和 CGLIB 的代理

本节作为有关如何选择为特定目标创建基于 JDK 的代理或基于 CGLIB 的代理的权威文档对象（要代理）。ProxyFactoryBean

如果要代理的目标对象的类（以下简称为目标类）不实现任何接口，基于 CGLIB 的代理是创建。这是最简单的方案，因为 JDK 代理是基于接口的，并且没有接口意味着 JDK 代理甚至是不可能的。您可以插入目标 bean 并通过设置属性指定拦截器列表。请注意，a 即使属性已设置为，也会创建基于 CGLIB 的代理。（这样做毫无意义，最好从 Bean 定义中删除，因为它充其量是多余的，最坏的情况是令人困惑。interceptorNamesproxyTargetClassProxyFactoryBeanfalse

如果目标类实现一个（或多个）接口，则代理的类型为创建取决于配置。ProxyFactoryBean

如果的属性已设置为，将创建基于 CGLIB 的代理。这是有道理的，并且符合最小惊喜原则。即使的属性已被设置为一个或多个完全限定的接口名称，事实该属性设置为导致基于 CGLIB 代理生效。proxyTargetClassProxyFactoryBeantrueproxyInterfacesProxyFactoryBeanproxyTargetClasstrue

如果的属性已设置为一个或多个完全限定的接口名称，将创建基于 JDK 的代理。创建的代理实现属性中指定的所有接口。如果目标类碰巧实现的接口比那些在属性中指定的，一切都很好，但是那些返回的代理不实现其他接口。proxyInterfacesProxyFactoryBeanproxyInterfacesproxyInterfaces

如果尚未设置的属性，但是目标类确实实现了一个或多个接口，自动检测目标类实际上确实实现了实现至少一个接口，并创建一个基于 JDK 的代理。接口实际代理的是目标类的所有接口实现。实际上，这与提供每个列表相同目标类实现到属性的接口。然而它大大减少了工作量，并且不易出现印刷错误。proxyInterfacesProxyFactoryBeanProxyFactoryBeanproxyInterfaces

6.4.4. 代理接口

考虑一个简单的操作示例。此示例涉及：ProxyFactoryBean

代理的目标 Bean。这是憨豆的定义示例。personTarget
阿南德提供建议。AdvisorInterceptor
用于指定目标对象（thebean）的 AOP 代理 Bean 定义，代理接口和应用建议。personTarget

下面的清单显示了该示例：

<bean id="personTarget" class="com.mycompany.PersonImpl">
    <property name="name" value="Tony"/>
    <property name="age" value="51"/>
</bean>

<bean id="myAdvisor" class="com.mycompany.MyAdvisor">
    <property name="someProperty" value="Custom string property value"/>
</bean>

<bean id="debugInterceptor" class="org.springframework.aop.interceptor.DebugInterceptor">
</bean>

<bean id="person"
    class="org.springframework.aop.framework.ProxyFactoryBean">
    <property name="proxyInterfaces" value="com.mycompany.Person"/>

    <property name="target" ref="personTarget"/>
    <property name="interceptorNames">
        <list>
            <value>myAdvisor</value>
            <value>debugInterceptor</value>
        </list>
    </property>
</bean>

请注意，该属性采用一个列表，其中包含当前工厂中的拦截器或顾问。您可以使用顾问，拦截器，之前，之后返回，并抛出建议对象。顾问的顺序很重要。interceptorNamesString

前面显示的 Thebean 定义可用于代替实现，如遵循：personPerson

爪哇岛

科特林

Person person = (Person) factory.getBean("person");

同一 IoC 上下文中的其他 Bean 可以表达对它的强类型依赖关系，如使用普通的 Java 对象。以下示例演示如何执行此操作：

<bean id="personUser" class="com.mycompany.PersonUser">
    <property name="person"><ref bean="person"/></property>
</bean>

此示例中的类公开类型的属性。至于值得关注的是，AOP代理可以透明地代替“真实”的人使用。实现。但是，它的类将是动态代理类。这是可能的将其强制转换为接口（稍后讨论）。PersonUserPersonAdvised

您可以使用匿名隐藏目标和代理之间的区别内豆。只是定义不同。这仅出于完整性而包含建议。以下示例演示如何使用匿名内豆：ProxyFactoryBean

<bean id="myAdvisor" class="com.mycompany.MyAdvisor">
    <property name="someProperty" value="Custom string property value"/>
</bean>

<bean id="debugInterceptor" class="org.springframework.aop.interceptor.DebugInterceptor"/>

<bean id="person" class="org.springframework.aop.framework.ProxyFactoryBean">
    <property name="proxyInterfaces" value="com.mycompany.Person"/>
    <!-- Use inner bean, not local reference to target -->
    <property name="target">
        <bean class="com.mycompany.PersonImpl">
            <property name="name" value="Tony"/>
            <property name="age" value="51"/>
        </bean>
    </property>
    <property name="interceptorNames">
        <list>
            <value>myAdvisor</value>
            <value>debugInterceptor</value>
        </list>
    </property>
</bean>

使用匿名内 Bean 的优点是只有一个类型对象。如果我们想要，这很有用防止应用程序上下文的用户获取对 UnAdvice 的引用反对或需要避免与 Spring IoC 自动接线的任何歧义。还有，可以说，该定义的优势是自成一体的。但是，有时能够从工厂实际上可能是一个优势（例如，在某些测试场景中）。PersonProxyFactoryBean

6.4.5. 代理类

如果您需要代理一个类，而不是一个或多个接口，该怎么办？

想象一下，在我们前面的示例中，没有接口。我们需要建议名为 That 的类未实现任何业务接口。在这种情况下，您可以将 Spring 配置为使用 CGLIB 代理而不是动态代理。为此，请将前面显示的属性设置为。虽然最好编程到接口而不是类，能够建议不实现接口在使用旧代码时可能很有用。（一般来说，春天不是规定性的。虽然它使应用良好做法变得容易，但它避免了强制特定方法。PersonPersonproxyTargetClassProxyFactoryBeantrue

如果你愿意，你可以在任何情况下强制使用CGLIB，即使你有接口。

CGLIB 代理的工作原理是在运行时生成目标类的子类。春天配置此生成的子类以将方法调用委托给原始目标。这子类用于实现装饰器模式，编织在建议中。

CGLIB 代理通常应该对用户透明。但是，存在一些问题要考虑：

Final不能建议使用方法，因为它们不能被覆盖。
无需将 CGLIB 添加到类路径中。从Spring 3.2开始，CGLIB被重新打包并包含在弹簧芯 JAR 中。换句话说，基于 CGLIB 的 AOP 工作“不在盒子“，JDK 动态代理也是如此。

CGLIB 代理和动态代理之间的性能差异很小。在这种情况下，性能不应是决定性的考虑因素。

6.4.6. 使用“全局”顾问

通过在拦截器名称后附加星号，所有具有 Bean 名称匹配的顾问星号前面的部分将添加到顾问链中。这可以派上用场如果您需要添加一组标准的“全局”顾问。以下示例定义两位全球顾问：

<bean id="proxy" class="org.springframework.aop.framework.ProxyFactoryBean">
    <property name="target" ref="service"/>
    <property name="interceptorNames">
        <list>
            <value>global*</value>
        </list>
    </property>
</bean>

<bean id="global_debug" class="org.springframework.aop.interceptor.DebugInterceptor"/>
<bean id="global_performance" class="org.springframework.aop.interceptor.PerformanceMonitorInterceptor"/>

6.5. 简明的代理定义

特别是在定义事务代理时，您最终可能会得到许多类似的代理定义。使用父 Bean 和子 Bean 定义以及内部 Bean 定义可以产生更清晰、更简洁的代理定义。

首先，我们为代理创建父、模板、Bean 定义，如下所示：

<bean id="txProxyTemplate" abstract="true"
        class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
    <property name="transactionManager" ref="transactionManager"/>
    <property name="transactionAttributes">
        <props>
            <prop key="*">PROPAGATION_REQUIRED</prop>
        </props>
    </property>
</bean>

这本身永远不会实例化，因此它实际上可能是不完整的。然后，每个代理需要创建的是一个子 Bean 定义，它包装了代理作为内部 Bean 定义，因为无论如何都不会单独使用目标。以下示例显示了这样一个子 Bean：

<bean id="myService" parent="txProxyTemplate">
    <property name="target">
        <bean class="org.springframework.samples.MyServiceImpl">
        </bean>
    </property>
</bean>

您可以覆盖父模板中的属性。在以下示例中，我们覆盖事务传播设置：

<bean id="mySpecialService" parent="txProxyTemplate">
    <property name="target">
        <bean class="org.springframework.samples.MySpecialServiceImpl">
        </bean>
    </property>
    <property name="transactionAttributes">
        <props>
            <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
            <prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>
            <prop key="load*">PROPAGATION_REQUIRED,readOnly</prop>
            <prop key="store*">PROPAGATION_REQUIRED</prop>
        </props>
    </property>
</bean>

请注意，在父 Bean 示例中，我们显式地将父 Bean 定义标记为如前所述，通过将属性设置为抽象，因此它实际上可能永远不会实例。默认情况下，应用程序上下文（但不是简单的 Bean 工厂），预实例化所有单例。因此，这很重要（至少对于单例豆）如果您有一个仅打算用作模板的（父）Bean 定义，并且此定义指定了一个类，您必须确保将属性设置为。否则，应用程序上下文实际上会尝试预实例化它。abstracttrueabstracttrue

6.6. 使用`ProxyFactory`

使用 Spring 以编程方式创建 AOP 代理很容易。这使您可以使用 Spring AOP 不依赖于 Spring IoC。

目标对象实现的接口是自动代理。下面的清单显示了为目标对象创建代理，其中包含一个拦截器和一名顾问：

ProxyFactory factory = new ProxyFactory(myBusinessInterfaceImpl);
factory.addAdvice(myMethodInterceptor);
factory.addAdvisor(myAdvisor);
MyBusinessInterface tb = (MyBusinessInterface) factory.getProxy();

第一步是构造类型对象。您可以使用目标创建它对象，如前面的示例所示，或指定要在备用中代理的接口构造函数。org.springframework.aop.framework.ProxyFactory

您可以添加建议（使用拦截器作为专门的建议）、顾问或两者兼而有之并终生操纵它们。如果添加，则可以使代理实现其他接口。ProxyFactoryIntroductionInterceptionAroundAdvisor

也有方便的方法（继承自）这使您可以添加其他建议类型，例如 befores 和 throws advice.is bothand 的超类。ProxyFactoryAdvisedSupportAdvisedSupportProxyFactoryProxyFactoryBean

6.7. 操作建议对象

无论您创建 AOP 代理如何，都可以使用接口操作它们。任何 AOP 代理都可以强制转换为此接口，无论它实现哪些其他接口。此接口包括以下方法：org.springframework.aop.framework.Advised

Advisor[] getAdvisors();

void addAdvice(Advice advice) throws AopConfigException;

void addAdvice(int pos, Advice advice) throws AopConfigException;

void addAdvisor(Advisor advisor) throws AopConfigException;

void addAdvisor(int pos, Advisor advisor) throws AopConfigException;

int indexOf(Advisor advisor);

boolean removeAdvisor(Advisor advisor) throws AopConfigException;

void removeAdvisor(int index) throws AopConfigException;

boolean replaceAdvisor(Advisor a, Advisor b) throws AopConfigException;

boolean isFrozen();

该方法为每个顾问、拦截器或已添加到工厂的其他建议类型。如果添加了此索引处返回的顾问是您添加的对象。如果您添加了拦截器或其他建议类型，Spring 将其包装在带有总是返回的切入点。因此，如果您添加了 a，则顾问为此索引返回的是 A，它返回与所有类和方法匹配的切入点。getAdvisors()AdvisorAdvisortrueMethodInterceptorDefaultPointcutAdvisorMethodInterceptor

这些方法可用于添加任何方法。通常，顾问持有切入点和建议是通用的，您可以使用任何建议或切入点（但不用于介绍）。addAdvisor()AdvisorDefaultPointcutAdvisor

默认情况下，甚至可以添加或删除顾问或拦截器，即使是代理已创建。唯一的限制是无法添加或删除介绍顾问，因为工厂的现有代理不显示界面改变。（您可以从工厂获取新的代理以避免此问题。

以下示例演示如何将 AOP 代理强制转换为接口并检查和操纵其建议：Advised

Advised advised = (Advised) myObject;
Advisor[] advisors = advised.getAdvisors();
int oldAdvisorCount = advisors.length;
System.out.println(oldAdvisorCount + " advisors");

// Add an advice like an interceptor without a pointcut
// Will match all proxied methods
// Can use for interceptors, before, after returning or throws advice
advised.addAdvice(new DebugInterceptor());

// Add selective advice using a pointcut
advised.addAdvisor(new DefaultPointcutAdvisor(mySpecialPointcut, myAdvice));

assertEquals("Added two advisors", oldAdvisorCount + 2, advised.getAdvisors().length);

根据您创建代理的方式，您通常可以设置标志。在那大小写，方法返回，以及任何修改的尝试通过添加或删除结果的建议。能力在某些情况下，冻结建议对象的状态很有用（例如，防止调用代码删除安全拦截器）。frozenAdvisedisFrozen()trueAopConfigException

6.8. 使用“自动代理”工具

到目前为止，我们已经考虑使用 aor 显式创建 AOP 代理类似的工厂豆。ProxyFactoryBean

Spring 还允许我们使用“自动代理”的 bean 定义，它可以自动代理选定的 Bean 定义。这是建立在Spring的“bean后处理器”之上的。基础结构，允许在容器加载时修改任何 Bean 定义。

在此模型中，您在 XML Bean 定义文件中设置了一些特殊的 Bean 定义以配置自动代理基础结构。这允许您声明目标符合自动代理的条件。你不需要使用。ProxyFactoryBean

有两种方法可以执行此操作：

通过使用引用当前上下文中特定 Bean 的自动代理创建器。
值得单独考虑的自动代理创建特例：由源级元数据属性驱动的自动代理创建。

6.8.1. 自动代理 Bean 定义

本节介绍包提供的自动代理创建者。org.springframework.aop.framework.autoproxy

`BeanNameAutoProxyCreator`

该类是一个自动创建的名称与文字值或通配符匹配的 Bean 的 AOP 代理。以下示例演示如何创建 Abean：BeanNameAutoProxyCreatorBeanPostProcessorBeanNameAutoProxyCreator

<bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
    <property name="beanNames" value="jdk*,onlyJdk"/>
    <property name="interceptorNames">
        <list>
            <value>myInterceptor</value>
        </list>
    </property>
</bean>

与属性一样，有一个属性而不是一个列表拦截器，以允许原型顾问的正确行为。命名为“拦截器” 可以是顾问或任何建议类型。ProxyFactoryBeaninterceptorNames

与一般的自动代理一样，使用的主要点是将相同的配置一致地应用于多个对象，并且体积最小配置。它是将声明性事务应用于多个事务的常用选择对象。BeanNameAutoProxyCreator

名称匹配的 Bean 定义，例如前面的 andin 例如，是带有目标类的普通旧 Bean 定义。AOP 代理是由自动创建。应用相同的建议到所有匹配的豆子。请注意，如果使用顾问（而不是拦截器前面的示例），切入点可能以不同的方式应用于不同的 bean。jdkMyBeanonlyJdkBeanNameAutoProxyCreator

`DefaultAdvisorAutoProxyCreator`

一个更通用且非常强大的自动代理创建者是。这会自动在当前上下文，无需在自动代理中包含特定的 Bean 名称顾问的 Bean 定义。它提供了一致的配置和避免重复作为。DefaultAdvisorAutoProxyCreatorBeanNameAutoProxyCreator

使用此机制涉及：

指定 abean 定义。DefaultAdvisorAutoProxyCreator
在相同或相关的上下文中指定任意数量的顾问。请注意，这些必须是顾问，而不是拦截器或其他建议。这是必要的，因为必须有一个切入点进行评估，以检查每个建议的资格到候选 Bean 定义。

自动评估包含的切入点在每个顾问中，查看它应该应用于每个业务对象的建议（如果有）（如示例中的桑丁）。DefaultAdvisorAutoProxyCreatorbusinessObject1businessObject2

这意味着可以自动将任意数量的顾问应用于每个业务对象。如果任何顾问中没有与业务对象中的任何方法匹配的切入点，对象未代理。为新的业务对象添加 Bean 定义时，如有必要，它们会自动代理。

通常，自动代理的优点是使呼叫者无法或依赖项以获取不建议的对象。调用 this 返回 AOP 代理，而不是目标业务对象。（“内”内前面显示的“豆”成语也提供了这个好处。getBean("businessObject1")ApplicationContext

以下示例创建 abean 和另一个本节中讨论的元素：DefaultAdvisorAutoProxyCreator

<bean class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"/>

<bean class="org.springframework.transaction.interceptor.TransactionAttributeSourceAdvisor">
    <property name="transactionInterceptor" ref="transactionInterceptor"/>
</bean>

<bean id="customAdvisor" class="com.mycompany.MyAdvisor"/>

<bean id="businessObject1" class="com.mycompany.BusinessObject1">
    <!-- Properties omitted -->
</bean>

<bean id="businessObject2" class="com.mycompany.BusinessObject2"/>

如果您想应用相同的建议，这是非常有用的一致地支持许多业务对象。一旦基础结构定义到位，您可以添加新的业务对象，而无需包含特定的代理配置。您还可以轻松放入其他方面（例如，跟踪或性能监控方面），只需对配置进行最少的更改。DefaultAdvisorAutoProxyCreator

提供对筛选的支持（通过使用命名约定，以便仅评估某些顾问，这允许使用多个，不同的配置，顾问自动代理创建者在同一工厂）和订购。顾问可以实现接口以确保如果这是一个问题，请正确订购。用于前面的示例具有可配置的订单值。默认设置为无序。DefaultAdvisorAutoProxyCreatororg.springframework.core.OrderedTransactionAttributeSourceAdvisor

6.9. 使用实现`TargetSource`

弹簧提供了a的概念，在界面中表达。此接口负责返回实现连接点的“目标对象”。每次 AOP 代理处理方法时，都会要求实现提供目标实例调用。TargetSourceorg.springframework.aop.TargetSourceTargetSource

使用 Spring AOP 的开发人员通常不需要直接使用实现，但是这为支持池化、热插拔和其他复杂的目标。例如，池化可以返回不同的目标每个调用的实例，通过使用池来管理实例。TargetSourceTargetSource

如果未指定 a，则使用默认实现来包装本地对象。每次调用都会返回相同的目标（如您所料）。TargetSource

本节的其余部分描述了 Spring 提供的标准目标源以及如何使用它们。

6.9.1. 热插拔目标源

存在让目标的 AOP 代理被切换，同时让呼叫者保留对它的引用。org.springframework.aop.target.HotSwappableTargetSource

更改目标源的目标会立即生效。这是线程安全的。HotSwappableTargetSource

您可以使用 HotSwappableTargetSource 上的方法更改目标，如以下示例所示：swap()

HotSwappableTargetSource swapper = (HotSwappableTargetSource) beanFactory.getBean("swapper");
Object oldTarget = swapper.swap(newTarget);

以下示例显示了所需的 XML 定义：

<bean id="initialTarget" class="mycompany.OldTarget"/>

<bean id="swapper" class="org.springframework.aop.target.HotSwappableTargetSource">
    <constructor-arg ref="initialTarget"/>
</bean>

<bean id="swappable" class="org.springframework.aop.framework.ProxyFactoryBean">
    <property name="targetSource" ref="swapper"/>
</bean>

前面的调用更改了可交换 Bean 的目标。持有引用该豆子不知道更改，但立即开始点击新目标。swap()

虽然此示例没有添加任何建议（没有必要向使用 a），任何可以与武断的建议。TargetSourceTargetSource

6.9.2. 池化目标源

使用池化目标源可提供与无状态会话类似的编程模型 EJB，其中维护一个相同实例池，并带有方法调用转到释放池中的对象。

春季池和SLSB池之间的关键区别是，春季池可以应用于任何 POJO。与一般的 Spring 一样，此服务可以应用于非侵入性方式。

Spring 为 Commons Pool 2.2 提供支持，它提供了一个相当有效的池化实现。你需要罐子在你的应用程序的类路径以使用此功能。您还可以子类以支持任何其他池化 API。commons-poolorg.springframework.aop.target.AbstractPoolingTargetSource

以下清单显示了一个示例配置：

<bean id="businessObjectTarget" class="com.mycompany.MyBusinessObject"
        scope="prototype">
    ... properties omitted
</bean>

<bean id="poolTargetSource" class="org.springframework.aop.target.CommonsPool2TargetSource">
    <property name="targetBeanName" value="businessObjectTarget"/>
    <property name="maxSize" value="25"/>
</bean>

<bean id="businessObject" class="org.springframework.aop.framework.ProxyFactoryBean">
    <property name="targetSource" ref="poolTargetSource"/>
    <property name="interceptorNames" value="myInterceptor"/>
</bean>

请注意，目标对象（在前面的示例中）必须是原型。这允许实现创建新实例根据需要扩大池的目标。有关信息，请参阅AbstractPoolingTargetSource的 javadoc和您希望使用的具体子类关于它的 properties.is 最基本的，并且始终保证存在。businessObjectTargetPoolingTargetSourcemaxSize

在这种情况下，是需要的拦截器的名称在同一 IoC 上下文中定义。但是，您不需要指定拦截器使用池化。如果您只想池化而没有其他建议，则根本不要设置该属性。myInterceptorinterceptorNames

您可以将 Spring 配置为能够将任何池化对象投射到接口，从而公开信息通过介绍来介绍池的配置和当前大小。你需要定义类似于以下内容的顾问：org.springframework.aop.target.PoolingConfig

<bean id="poolConfigAdvisor" class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">
    <property name="targetObject" ref="poolTargetSource"/>
    <property name="targetMethod" value="getPoolingConfigMixin"/>
</bean>

该顾问器是通过在类上调用一个方便的方法获得的，因此使用。这顾问的姓名（此处）必须在拦截器名称列表中公开池化对象。AbstractPoolingTargetSourceMethodInvokingFactoryBeanpoolConfigAdvisorProxyFactoryBean

演员阵容定义如下：

PoolingConfig conf = (PoolingConfig) beanFactory.getBean("businessObject");
System.out.println("Max pool size is " + conf.getMaxSize());

使用自动代理可以简化池化。您可以设置实现由任何自动代理创建者使用。TargetSource

6.9.3. 原型目标源

设置“原型”目标源类似于设置池化。在此在这种情况下，每次方法调用时都会创建一个目标的新实例。虽然在现代 JVM 中创建新对象的成本并不高，连接新对象（满足其 IoC 依赖项）可能更昂贵。因此，您不应该在没有充分理由的情况下使用此方法。TargetSource

为此，您可以修改前面显示的定义，如下所示（为了清楚起见，我们还更改了名称）：poolTargetSource

<bean id="prototypeTargetSource" class="org.springframework.aop.target.PrototypeTargetSource">
    <property name="targetBeanName" ref="businessObjectTarget"/>
</bean>

唯一的属性是目标 Bean 的名称。在实现中使用继承以确保命名的一致性。与池化目标一样源，目标 Bean 必须是原型 Bean 定义。TargetSource

6.9.4.目标来源`ThreadLocal`

ThreadLocal如果需要为每个对象创建一个对象，则目标源非常有用传入请求（即每个线程）。的概念提供了一个 JDK 范围将资源透明地存储在线程旁边的工具。设置 ais 与其他类型解释的几乎相同的目标源，如以下示例所示：ThreadLocalThreadLocalTargetSource

<bean id="threadlocalTargetSource" class="org.springframework.aop.target.ThreadLocalTargetSource">
    <property name="targetBeanName" value="businessObjectTarget"/>
</bean>

6.10. 定义新的建议类型

Spring AOP被设计为可扩展的。虽然拦截实施策略目前在内部使用，可以支持任意建议类型除了拦截周围的建议，之前，抛出建议，和在返回建议后。

该软件包是一个SPI软件包，允许在不更改核心框架的情况下添加新的自定义建议类型的支持。自定义类型的唯一约束是它必须实现标记接口。org.springframework.aop.framework.adapterAdviceorg.aopalliance.aop.Advice

有关更多信息，请参阅org.springframework.aop.framework.adapterjavadoc。

7. 零安全

虽然Java不允许你用它的类型系统来表达null-safety，但Spring Framework。现在在包中提供了以下注释，让您声明 API 和字段的可空性：org.springframework.lang

@Nullable：用于指示特定参数、返回值或字段可以是。null
@NonNull：用于指示特定参数、返回值或字段不能（参数/返回值不需要）和适用字段）。null@NonNullApi@NonNullFields
@NonNullApi：包级别的注释将 non-null 声明为参数和返回值的默认语义。
@NonNullFields：包上的注释将非 null 声明为字段的默认语义的级别。

Spring 框架本身利用了这些注释，但它们也可以用于任何基于 Spring 的 Java 项目，用于声明空安全 API 和可选的空安全字段。尚不支持泛型类型参数、varargs 和数组元素 nullability 但应该在即将发布的版本中，有关最新信息，请参阅SPR-15942。预计可空性声明将在 Spring 框架版本，包括次要版本。方法内部使用的类型的可空性正文不在此功能的范围之内。

7.1. 用例

除了为 Spring Framework API 可空性提供显式声明外， IDE（如IDEA或Eclipse）可以使用这些注释来提供有用的与空安全相关的警告，以避免在运行时。NullPointerException

它们还用于在 Kotlin 项目中使 Spring API 对 null 安全，因为 Kotlin 原生支持零安全。更多详情可在Kotlin 支持文档中找到。

7.2. JSR-305 元注释

Spring 注解是用 JSR305注解（一种休眠但广泛传播的 JSR）进行元注解的。JSR-305元注释让工具供应商像 IDEA 或 Kotlin 一样以通用方式提供零安全支持，而不必对 Spring 注释的硬编码支持。

没有必要也不建议将 JSR-305 依赖项添加到项目类路径中利用 Spring 空安全 API。仅使用的项目，例如基于 Spring 的库代码库中的空安全注释应添加 Gradle 配置或 Mavenscope 以避免编译警告。com.google.code.findbugs:jsr305:3.0.2compileOnlyprovided

8. 数据缓冲区和编解码器

Java NIO 提供但许多库在上面构建自己的字节缓冲区 API，特别是对于重用缓冲区和/或使用直接缓冲区的网络操作有利于性能。例如Netty有层次结构，Undertow使用。 XNIO，Jetty使用池字节缓冲区，并带有要释放的回调，等等。该模块提供了一组抽象来处理各种字节缓冲区接口如下：ByteBufferByteBufspring-core

DataBufferFactory抽象化了数据缓冲区的创建。
DataBuffer表示一个字节缓冲区，该缓冲区可以池化。
DataBufferUtils为数据缓冲区提供了实用工具方法。
编解码器将数据缓冲流解码或编码为更高级别的对象。

8.1. `DataBufferFactory`

DataBufferFactory用于通过以下两种方式之一创建数据缓冲区：

分配新的数据缓冲区，可以选择预先指定容量（如果已知），即更高效，即使实现可以按需增长和缩小。DataBuffer
包装一个现有函数，它用 a实施，这不涉及分配。byte[]java.nio.ByteBufferDataBuffer

请注意，WebFlux 应用程序不会直接创建，而是创建通过客户端访问它。工厂的类型取决于底层客户端或服务器，例如对于 Reactor Netty，对于其他客户端或服务器。DataBufferFactoryServerHttpResponseClientHttpRequestNettyDataBufferFactoryDefaultDataBufferFactory

8.2. `DataBuffer`

该接口提供类似的操作，但也带来了一些额外的好处，其中一些是受Netty启发的。以下是部分好处列表：DataBufferjava.nio.ByteBufferByteBuf

以独立位置读写，即不需要调用 toto 在读取和写入之间交替。flip()
容量随需求扩展。java.lang.StringBuilder
通过PooledDataBuffer 进行池化缓冲区和引用计数。
将缓冲区查看为、或。java.nio.ByteBufferInputStreamOutputStream
确定给定字节的索引或最后一个索引。

8.3. `PooledDataBuffer`

正如Javadoc for ByteBuffer 中所解释的，字节缓冲区可以是直接的，也可以是非直接的。直接缓冲区可能驻留在 Java 堆之外这消除了对本机 I/O 操作进行复制的需要。这使得直接缓冲区对于通过套接字接收和发送数据特别有用，但它们也更多创建和发布成本很高，这导致了池化缓冲区的想法。

PooledDataBuffer是它的扩展，有助于引用计数对于字节缓冲池至关重要。它是如何工作的？当 ais 分配的引用计数为 1。调用以递增计数，而调用以递减它。只要计数大于 0，缓冲区就保证不被释放。当计数减少到 0 时，池化缓冲区可以是释放，这实际上可能意味着缓冲区的保留内存返回到内存池。DataBufferPooledDataBufferretain()release()

请注意，在大多数情况下，与其直接操作，不如使用方便的方法，如果它是的实例，则仅将发布或保留到 a。PooledDataBufferDataBufferUtilsDataBufferPooledDataBuffer

8.4. `DataBufferUtils`

DataBufferUtils提供了许多在数据缓冲区上运行的实用程序方法：

将数据缓冲区流连接到单个缓冲区中，可能具有零拷贝，例如通过复合缓冲区（如果基础字节缓冲区 API 支持）。
Turnor NIOinto，反之亦然。InputStreamChannelFlux<DataBuffer>Publisher<DataBuffer>OutputStreamChannel
释放或保留 aif 缓冲区是的实例的方法。DataBufferPooledDataBuffer
跳过或从字节流中获取，直到特定的字节计数。

8.5. 编解码器

该软件包提供以下策略接口：org.springframework.core.codec

Encoder以编码到数据缓冲区流中。Publisher<T>
Decoder解码为更高级别对象的流。Publisher<DataBuffer>

该模块提供,,,,编码器和解码器实现。该模块添加了杰克逊 JSON， Jackson Smile，JAXB2，Protocol Buffers和其他编码器和解码器。请参阅 WebFlux 部分中的编解码器。spring-corebyte[]ByteBufferDataBufferResourceStringspring-web

8.6. 使用`DataBuffer`

使用数据缓冲区时，必须特别注意确保释放缓冲区因为它们可能被汇集在一起。我们将使用编解码器来说明这是如何工作的，但这些概念更普遍地适用。让我们看看编解码器必须做什么在内部管理数据缓冲区。

在创建更高级别之前，A是最后一个读取输入数据缓冲区的人对象，因此它必须按如下方式释放它们：Decoder

如果简单地读取每个输入缓冲区并准备好立即释放它，它可以通过以下方式做到这一点。DecoderDataBufferUtils.release(dataBuffer)
如果 ais 使用或运算符，例如、和其他在内部预取和缓存数据项，或使用运算符（如，）的其他人，以及省略项目的其他项，则必须添加到组合链，以确保此类缓冲液在被丢弃之前被释放，可能也是由于错误或取消信号。DecoderFluxMonoflatMapreducefilterskipdoOnDiscard(PooledDataBuffer.class, DataBufferUtils::release)
如果以任何其他方式保留一个或多个数据缓冲区，则必须确保在完全读取时释放它们，或者在出现错误或取消信号的情况下释放它们在读取和释放缓存的数据缓冲区之前发生。Decoder

请注意，提供了一种安全有效的方法来聚合数据缓冲流到单个数据缓冲区中。同样，解码器可以使用其他安全方法。DataBufferUtils#joinskipUntilByteCounttakeUntilByteCount

解析其他人必须读取（和释放）的数据缓冲区。所以安没有太多事情可做。但是，如果出现以下情况，则必须注意释放数据缓冲区使用数据填充缓冲区时发生序列化错误。例如：EncoderEncoderEncoder

DataBuffer buffer = factory.allocateBuffer();
boolean release = true;
try {
    // serialize and populate buffer..
    release = false;
}
finally {
    if (release) {
        DataBufferUtils.release(buffer);
    }
}
return buffer;

anis 的使用者负责释放它接收的数据缓冲区。在WebFlux应用程序中，输出用于写入HTTP服务器响应，或客户端 HTTP 请求，在这种情况下，释放数据缓冲区是编写给服务器响应或客户端请求的代码的责任。EncoderEncoder

请注意，在 Netty 上运行时，有一些调试选项可用于解决缓冲区泄漏问题。

9. 日志记录

从 Spring Framework 5.0 开始，Spring 自带了自己的 Commons Logging 桥接器。在模块中。该实现检查是否存在 Log4j 2.x 类路径中的 API 和 SLF4J 1.7 API，并使用找到的第一个作为日志记录实现，回退到 Java 平台的核心日志记录工具（也称为JUL或）如果 Log4j 2.x 和 SLF4J 都不可用。spring-jcljava.util.logging

将 Log4j 2.x 或 Logback（或其他 SLF4J 提供程序）放在类路径中，无需任何额外的内容桥接，让框架自动适应您的选择。欲了解更多信息，请参阅春季引导日志记录参考文档。

可以通过以下方式检索实现以下示例。Logorg.apache.commons.logging.LogFactory

public class MyBean {
    private final Log log = LogFactory.getLog(getClass());
    // ...
}

10. 附录

10.1.XML 模式

附录的这一部分列出了与核心容器相关的 XML 架构。

10.1.1. 模式`util`

顾名思义，标签处理常见的实用程序配置问题，例如配置集合、引用常量等。要在架构中使用标记，您需要在顶部显示以下前导码的 Spring XML 配置文件（代码片段中的文本引用了正确的架构，以便命名空间中的标签可供您使用）：utilutilutil

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

        <!-- bean definitions here -->

</beans>

用`<util:constant/>`

请考虑以下 Bean 定义：

<bean id="..." class="...">
    <property name="isolation">
        <bean id="java.sql.Connection.TRANSACTION_SERIALIZABLE"
                class="org.springframework.beans.factory.config.FieldRetrievingFactoryBean" />
    </property>
</bean>

前面的配置使用 Spring实现（the）在 bean 上设置属性的值到常量的值。这是一切都很好，但它很冗长，并且（不必要地）暴露了春天的内部为最终用户提供管道。FactoryBeanFieldRetrievingFactoryBeanisolationjava.sql.Connection.TRANSACTION_SERIALIZABLE

以下基于 XML 架构的版本更简洁，清楚地表达了开发人员的意图（“注入此常量值”），它读起来更好：

<bean id="..." class="...">
    <property name="isolation">
        <util:constant static-field="java.sql.Connection.TRANSACTION_SERIALIZABLE"/>
    </property>
</bean>

从字段值设置 Bean 属性或构造函数参数

FieldReretrieveingFactoryBean是一个检索非静态字段值的字段。它通常是用于检索常量，然后可用于设置另一个 Bean 的属性值或构造函数参数。FactoryBeanstaticpublicstaticfinal

下面的示例演示如何使用staticField属性公开 afield：static

<bean id="myField"
        class="org.springframework.beans.factory.config.FieldRetrievingFactoryBean">
    <property name="staticField" value="java.sql.Connection.TRANSACTION_SERIALIZABLE"/>
</bean>

还有一个方便的使用形式，其中字段被指定为 bean 名称，如以下示例所示：static

<bean id="java.sql.Connection.TRANSACTION_SERIALIZABLE"
        class="org.springframework.beans.factory.config.FieldRetrievingFactoryBean"/>

这确实意味着豆子不再有任何选择（所以任何其他引用它的豆子也必须使用这个较长的名称），但这种形式非常定义简洁，非常方便用作内豆，因为没有为 Bean 引用指定，如以下示例所示：idid

<bean id="..." class="...">
    <property name="isolation">
        <bean id="java.sql.Connection.TRANSACTION_SERIALIZABLE"
                class="org.springframework.beans.factory.config.FieldRetrievingFactoryBean" />
    </property>
</bean>

您还可以访问另一个 Bean 的非静态（实例）字段，如在FieldReretrieveevingFactoryBean类的 API 文档中进行了描述。

将枚举值作为属性或构造函数参数注入到 bean 中是在春天很容易做到。你实际上不需要做任何事情或知道任何事情弹簧内部（甚至关于类，如）。以下示例枚举显示了注入枚举值的难易程度：FieldRetrievingFactoryBean

package javax.persistence;

public enum PersistenceContextType {

    TRANSACTION,
    EXTENDED
}

现在考虑以下类型资源库和相应的 bean 定义：PersistenceContextType

package example;

public class Client {

    private PersistenceContextType persistenceContextType;

    public void setPersistenceContextType(PersistenceContextType type) {
        this.persistenceContextType = type;
    }
}

<bean class="example.Client">
    <property name="persistenceContextType" value="TRANSACTION"/>
</bean>

用`<util:property-path/>`

请考虑以下示例：

<!-- target bean to be referenced by name -->
<bean id="testBean" class="org.springframework.beans.TestBean" scope="prototype">
    <property name="age" value="10"/>
    <property name="spouse">
        <bean class="org.springframework.beans.TestBean">
            <property name="age" value="11"/>
        </bean>
    </property>
</bean>

<!-- results in 10, which is the value of property 'age' of bean 'testBean' -->
<bean id="testBean.age" class="org.springframework.beans.factory.config.PropertyPathFactoryBean"/>

前面的配置使用 Spring实现（the）创建一个 bean（类型），名为具有等于该属性的值。FactoryBeanPropertyPathFactoryBeaninttestBean.ageagetestBean

现在考虑以下示例，它添加了 aelement：<util:property-path/>

<!-- target bean to be referenced by name -->
<bean id="testBean" class="org.springframework.beans.TestBean" scope="prototype">
    <property name="age" value="10"/>
    <property name="spouse">
        <bean class="org.springframework.beans.TestBean">
            <property name="age" value="11"/>
        </bean>
    </property>
</bean>

<!-- results in 10, which is the value of property 'age' of bean 'testBean' -->
<util:property-path id="name" path="testBean.age"/>

元素的属性值遵循的形式。在这种情况下，它选取名为 bean 的属性。该属性的值是。path<property-path/>beanName.beanPropertyagetestBeanage10

用于设置 Bean 属性或构造函数参数`<util:property-path/>`

PropertyPathFactoryBean是计算给定属性路径的目标对象。目标对象可以直接指定，也可以通过 Bean 名称指定。然后你可以使用它另一个 Bean 定义中的值作为属性值或构造函数论点。FactoryBean

以下示例按名称显示了对另一个 Bean 使用的路径：

<!-- target bean to be referenced by name -->
<bean id="person" class="org.springframework.beans.TestBean" scope="prototype">
    <property name="age" value="10"/>
    <property name="spouse">
        <bean class="org.springframework.beans.TestBean">
            <property name="age" value="11"/>
        </bean>
    </property>
</bean>

<!-- results in 11, which is the value of property 'spouse.age' of bean 'person' -->
<bean id="theAge"
        class="org.springframework.beans.factory.config.PropertyPathFactoryBean">
    <property name="targetBeanName" value="person"/>
    <property name="propertyPath" value="spouse.age"/>
</bean>

在以下示例中，根据内部 Bean 评估路径：

<!-- results in 12, which is the value of property 'age' of the inner bean -->
<bean id="theAge"
        class="org.springframework.beans.factory.config.PropertyPathFactoryBean">
    <property name="targetObject">
        <bean class="org.springframework.beans.TestBean">
            <property name="age" value="12"/>
        </bean>
    </property>
    <property name="propertyPath" value="age"/>
</bean>

还有一个快捷方式窗体，其中 Bean 名称是属性路径。下面的示例演示快捷方式窗体：

<!-- results in 10, which is the value of property 'age' of bean 'person' -->
<bean id="person.age"
        class="org.springframework.beans.factory.config.PropertyPathFactoryBean"/>

这种形式确实意味着在豆子的名称中没有选择。对它的任何引用还必须使用相同的，即路径。如果用作内部 Bean，根本不需要引用它，如下例所示：id

<bean id="..." class="...">
    <property name="age">
        <bean id="person.age"
                class="org.springframework.beans.factory.config.PropertyPathFactoryBean"/>
    </property>
</bean>

您可以在实际定义中专门设置结果类型。这不是必需的对于大多数用例，但它有时可能很有用。请参阅 javadoc 以获取有关以下内容的更多信息此功能。

用`<util:properties/>`

请考虑以下示例：

<!-- creates a java.util.Properties instance with values loaded from the supplied location -->
<bean id="jdbcConfiguration" class="org.springframework.beans.factory.config.PropertiesFactoryBean">
    <property name="location" value="classpath:com/foo/jdbc-production.properties"/>
</bean>

前面的配置使用 Spring实现（the）来实例化一个带有值的实例从提供的资源位置加载）。FactoryBeanPropertiesFactoryBeanjava.util.Properties

下面的示例使用 aelement 进行更简洁的表示：util:properties

<!-- creates a java.util.Properties instance with values loaded from the supplied location -->
<util:properties id="jdbcConfiguration" location="classpath:com/foo/jdbc-production.properties"/>

用`<util:list/>`

请考虑以下示例：

<!-- creates a java.util.List instance with values loaded from the supplied 'sourceList' -->
<bean id="emails" class="org.springframework.beans.factory.config.ListFactoryBean">
    <property name="sourceList">
        <list>
            <value>[email protected]</value>
            <value>[email protected]</value>
            <value>[email protected]</value>
            <value>[email protected]</value>
        </list>
    </property>
</bean>

前面的配置使用 Spring实现（the）创建一个实例并使用取值对其进行初始化从供应。FactoryBeanListFactoryBeanjava.util.ListsourceList

下面的示例使用 aelement 进行更简洁的表示：<util:list/>

<!-- creates a java.util.List instance with the supplied values -->
<util:list id="emails">
    <value>[email protected]</value>
    <value>[email protected]</value>
    <value>[email protected]</value>
    <value>[email protected]</value>
</util:list>

您还可以显式控制实例化的确切类型，以及通过使用元素上的属性填充。为例如，如果我们真的需要实例化 ato，我们可以使用以下配置：Listlist-class<util:list/>java.util.LinkedList

<util:list id="emails" list-class="java.util.LinkedList">
    <value>[email protected]</value>
    <value>[email protected]</value>
    <value>[email protected]</value>
    <value>d'[email protected]</value>
</util:list>

如果提供了 noattribute，则容器选择实现。list-classList

用`<util:map/>`

请考虑以下示例：

<!-- creates a java.util.Map instance with values loaded from the supplied 'sourceMap' -->
<bean id="emails" class="org.springframework.beans.factory.config.MapFactoryBean">
    <property name="sourceMap">
        <map>
            <entry key="pechorin" value="[email protected]"/>
            <entry key="raskolnikov" value="[email protected]"/>
            <entry key="stavrogin" value="[email protected]"/>
            <entry key="porfiry" value="[email protected]"/>
        </map>
    </property>
</bean>

前面的配置使用 Spring实现（the）来创建使用键值对初始化的实例取自供应。FactoryBeanMapFactoryBeanjava.util.Map'sourceMap'

下面的示例使用 aelement 进行更简洁的表示：<util:map/>

<!-- creates a java.util.Map instance with the supplied key-value pairs -->
<util:map id="emails">
    <entry key="pechorin" value="[email protected]"/>
    <entry key="raskolnikov" value="[email protected]"/>
    <entry key="stavrogin" value="[email protected]"/>
    <entry key="porfiry" value="[email protected]"/>
</util:map>

您还可以显式控制实例化的确切类型，以及通过使用元素上的属性填充。为例如，如果我们真的需要实例化 ato，我们可以使用以下配置：Map'map-class'<util:map/>java.util.TreeMap

<util:map id="emails" map-class="java.util.TreeMap">
    <entry key="pechorin" value="[email protected]"/>
    <entry key="raskolnikov" value="[email protected]"/>
    <entry key="stavrogin" value="[email protected]"/>
    <entry key="porfiry" value="[email protected]"/>
</util:map>

如果提供了 noattribute，则容器选择实现。'map-class'Map

用`<util:set/>`

请考虑以下示例：

<!-- creates a java.util.Set instance with values loaded from the supplied 'sourceSet' -->
<bean id="emails" class="org.springframework.beans.factory.config.SetFactoryBean">
    <property name="sourceSet">
        <set>
            <value>[email protected]</value>
            <value>[email protected]</value>
            <value>[email protected]</value>
            <value>[email protected]</value>
        </set>
    </property>
</bean>

前面的配置使用 Spring实现（the）创建一个实例，该实例使用所取值进行初始化从供应。FactoryBeanSetFactoryBeanjava.util.SetsourceSet

下面的示例使用 aelement 进行更简洁的表示：<util:set/>

<!-- creates a java.util.Set instance with the supplied values -->
<util:set id="emails">
    <value>[email protected]</value>
    <value>[email protected]</value>
    <value>[email protected]</value>
    <value>[email protected]</value>
</util:set>

您还可以显式控制实例化的确切类型，以及通过使用元素上的属性填充。为例如，如果我们真的需要实例化 ato，我们可以使用以下配置：Setset-class<util:set/>java.util.TreeSet

<util:set id="emails" set-class="java.util.TreeSet">
    <value>[email protected]</value>
    <value>[email protected]</value>
    <value>[email protected]</value>
    <value>[email protected]</value>
</util:set>

如果提供了 noattribute，则容器选择实现。set-classSet

10.1.2. 模式`aop`

标签处理在 Spring 中配置 AOP 的所有内容，包括 Spring 的拥有基于代理的AOP框架以及Spring与AspectJ AOP框架的集成。这些标签在标题为“面向方面编程与弹簧”的章节中进行了全面介绍。aop

为了完整起见，要使用架构中的标记，您需要具有 Spring XML 配置文件顶部的以下序言（文本代码段引用正确的架构，以便命名空间中的标记可供您使用）：aopaop

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

    <!-- bean definitions here -->

</beans>

10.1.3. 模式`context`

标签处理与管道相关的配置 — 也就是说，通常不是对最终用户很重要的 bean，而是对春天的很多“咕噜咕噜”的工作，比如。以下代码段引用正确的架构，以便命名空间中的元素可供您使用：contextApplicationContextBeanfactoryPostProcessorscontext

<?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">

    <!-- bean definitions here -->

</beans>

用`<property-placeholder/>`

此元素激活占位符的替换，这些占位符针对指定的属性文件（作为Spring 资源位置）。此元素是一种方便的机制，可为您设置PropertySourcesPlaceholderConfigurer。如果您需要对特定设置进行更多控制，您可以自己将其显式定义为 Bean。${…}PropertySourcesPlaceholderConfigurer

用`<annotation-config/>`

此元素激活 Spring 基础结构以检测 Bean 类中的注释：

弹簧@Configuration模型
@Autowired/@Inject，和@Value@Lookup
JSR-250的，和（如果可用）@Resource@PostConstruct@PreDestroy
JAX-WS's's和EJB 3's（如果可用）@WebServiceRef@EJB
JPA'sand（如果有）@PersistenceContext@PersistenceUnit
春天的@EventListener

或者，您可以选择显式激活个人以获取这些批注。BeanPostProcessors

用`<component-scan/>`

有关基于注释的容器配置一节中详细介绍了此元素。

用`<load-time-weaver/>`

这个元素在Spring 框架中关于使用 AspectJ 进行加载时编织的部分中有详细说明。

用`<spring-configured/>`

这个元素在关于使用 AspectJ 通过 Spring 依赖注入域对象的部分中有详细说明。

用`<mbean-export/>`

有关配置基于注释的 MBean 导出的部分中详细介绍了此元素。

10.1.4. Bean 模式

最后但并非最不重要的一点是，我们在模式中有元素。这些元素从框架的曙光开始就一直在春天。各种元素的示例在模式中不显示在这里，因为它们被非常全面地覆盖在依赖关系和配置方面（实际上，在整个章节中）。beansbeans

请注意，您可以向 XML 定义添加零个或多个键值对。使用此额外元数据（如果有的话）完成的操作完全取决于您自己的自定义逻辑（因此通常仅在编写自己的自定义元素时使用，如前所述在标题为“XML 架构创作”的附录中）。<bean/>

下面的示例显示了周围环境中的元素（请注意，没有任何逻辑来解释它，元数据实际上是无用的就目前而言）。<meta/><bean/>

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="foo" class="x.y.Foo">
        <meta key="cacheName" value="foo"/> 
        <property name="name" value="Rick"/>
    </bean>

</beans>

在前面的示例中，您可以假设存在一些消耗 Bean 定义并设置一些使用提供的元数据的高速缓存基础结构。

10.2.XML 架构创作

从 2.0 版开始，Spring 具有一种机制，用于将基于模式的扩展添加到用于定义和配置 bean 的基本 Spring XML 格式。本节涵盖如何编写自己的自定义 XML Bean 定义解析器以及将此类解析器集成到Spring IoC容器中。

为了便于创作使用架构感知 XML 编辑器的配置文件， Spring 的可扩展 XML 配置机制基于 XML Schema。如果你不是熟悉 Spring 当前随标准一起提供的 XML 配置扩展 Spring 发行版，您应该首先阅读上一节关于XML 模式。

创建新的 XML 配置扩展：

创作XML 架构来描述自定义元素。
编写自定义实现代码。NamespaceHandler
编写一个或多个实现代码（这是完成真正工作的地方）。BeanDefinitionParser
向 Spring 注册您的新工件。

对于一个统一的例子，我们创建了一个 XML扩展（一个自定义XML元素），允许我们配置类型的对象（从包）。当我们完成后，我们将能够定义 Bean 定义 typeas：SimpleDateFormatjava.textSimpleDateFormat

<myns:dateformat id="dateFormat"
    pattern="yyyy-MM-dd HH:mm"
    lenient="true"/>

（我们包括更详细的内容本附录后面将提供示例。第一个简单示例的目的是引导您通过创建自定义扩展的基本步骤。

10.2.1. 创作模式

创建用于 Spring 的 IoC 容器的 XML 配置扩展始于创作 XML 架构以描述扩展。对于我们的示例，我们使用以下架构要配置对象：SimpleDateFormat

<!-- myns.xsd (inside package org/springframework/samples/xml) -->

<?xml version="1.0" encoding="UTF-8"?>
<xsd:schema xmlns="http://www.mycompany.example/schema/myns"
        xmlns:xsd="http://www.w3.org/2001/XMLSchema"
        xmlns:beans="http://www.springframework.org/schema/beans"
        targetNamespace="http://www.mycompany.example/schema/myns"
        elementFormDefault="qualified"
        attributeFormDefault="unqualified">

    <xsd:import namespace="http://www.springframework.org/schema/beans"/>

    <xsd:element name="dateformat">
        <xsd:complexType>
            <xsd:complexContent>
                <xsd:extension base="beans:identifiedType"> 
                    <xsd:attribute name="lenient" type="xsd:boolean"/>
                    <xsd:attribute name="pattern" type="xsd:string" use="required"/>
                </xsd:extension>
            </xsd:complexContent>
        </xsd:complexType>
    </xsd:element>
</xsd:schema>

前面的架构允许我们直接在 XML 应用程序上下文文件通过使用元素，如下所示示例显示：SimpleDateFormat<myns:dateformat/>

<myns:dateformat id="dateFormat"
    pattern="yyyy-MM-dd HH:mm"
    lenient="true"/>

请注意，在我们创建基础结构类之后，前面的 XML 代码段是与以下 XML 代码段基本相同：

<bean id="dateFormat" class="java.text.SimpleDateFormat">
    <constructor-arg value="yyyy-MM-dd HH:mm"/>
    <property name="lenient" value="true"/>
</bean>

前面两个代码片段中的第二个在容器中创建一个 Bean（由 NameOf 类型标识），并设置了几个属性。dateFormatSimpleDateFormat

10.2.2. 编码`NamespaceHandler`

除了模式之外，我们还需要 ato 解析 Spring 在解析配置文件时遇到的这个特定命名空间。对于此示例，应负责元素的解析。NamespaceHandlerNamespaceHandlermyns:dateformat

该接口具有三种方法：NamespaceHandler

init()：允许初始化和由调用使用处理程序之前的弹簧。NamespaceHandler
BeanDefinition parse(Element, ParserContext)：当春天遇到一个顶级元素（不嵌套在 Bean 定义或其他命名空间中）。此方法本身可以注册 Bean 定义、返回 Bean 定义或两者兼而有之。
BeanDefinitionHolder decorate(Node, BeanDefinitionHolder, ParserContext)：叫当 Spring 遇到不同命名空间的属性或嵌套元素时。例如，一个或多个 Bean 定义的修饰与Spring 支持的作用域一起使用。我们首先重点介绍一个简单的例子，不使用装饰，之后我们在一个更高级的例子中展示了装饰。

虽然你可以自己编码整个命名空间（因此提供解析命名空间中每个元素的代码），通常情况下，Spring XML 配置文件中的每个顶级 XML 元素导致单个 Bean 定义（如本例所示，单个元素生成单个 Bean 定义）。弹簧具有支持此方案的便利类数。在以下示例中，我们使用类：NamespaceHandler<myns:dateformat/>SimpleDateFormatNamespaceHandlerSupport

package org.springframework.samples.xml;

import org.springframework.beans.factory.xml.NamespaceHandlerSupport;

public class MyNamespaceHandler extends NamespaceHandlerSupport {

    public void init() {
        registerBeanDefinitionParser("dateformat", new SimpleDateFormatBeanDefinitionParser());
    }
}

您可能会注意到，实际上并没有很多解析逻辑在本课程中。事实上，该类有一个内置的概念代表团。它支持注册任意数量的实例，当它需要解析其中的元素时，它委托给这些实例命名空间。这种清晰的关注点分离可以处理编排其命名空间中所有自定义元素的分析，同时委托 toto 做 XML 解析的繁重工作。这表示每个仅包含用于解析单个的逻辑自定义元素，正如我们在下一步中看到的。NamespaceHandlerSupportBeanDefinitionParserNamespaceHandlerBeanDefinitionParsersBeanDefinitionParser

10.2.3. 使用`BeanDefinitionParser`

如果遇到 XML，则使用 Ais 已映射到特定 Bean 定义解析器的类型的元素（在这种情况下）。换句话说，泰斯负责分析架构中定义的一个不同的顶级 XML 元素。在解析器，我们可以访问 XML 元素（因此也可以访问其子元素），以便我们可以解析自定义 XML 内容，如以下示例所示：BeanDefinitionParserNamespaceHandlerdateformatBeanDefinitionParser

package org.springframework.samples.xml;

import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.xml.AbstractSingleBeanDefinitionParser;
import org.springframework.util.StringUtils;
import org.w3c.dom.Element;

import java.text.SimpleDateFormat;

public class SimpleDateFormatBeanDefinitionParser extends AbstractSingleBeanDefinitionParser { 

    protected Class getBeanClass(Element element) {
        return SimpleDateFormat.class; 
    }

    protected void doParse(Element element, BeanDefinitionBuilder bean) {
        // this will never be null since the schema explicitly requires that a value be supplied
        String pattern = element.getAttribute("pattern");
        bean.addConstructorArgValue(pattern);

        // this however is an optional property
        String lenient = element.getAttribute("lenient");
        if (StringUtils.hasText(lenient)) {
            bean.addPropertyValue("lenient", Boolean.valueOf(lenient));
        }
    }

}

在这个简单的情况下，这就是我们需要做的。我们的单身的创建由超类处理，作为是 Bean 定义的唯一标识符的提取和设置。BeanDefinitionAbstractSingleBeanDefinitionParser

10.2.4. 注册处理程序和模式

编码完成。剩下的就是制作Spring XML。解析了解自定义元素的基础结构。为此，我们将自定义和自定义 XSD 文件注册到两个特殊用途的属性文件中。这些属性文件都放置在应用程序的目录中，并且例如，可以与 JAR 文件中的二进制类一起分发。春天 XML 分析基础结构通过使用这些特殊属性文件，其格式将在接下来的两节中详细介绍。namespaceHandlerMETA-INF

写作`META-INF/spring.handlers`

调用的属性文件包含 XML 架构 URI 到的映射命名空间处理程序类。对于我们的示例，我们需要编写以下内容：spring.handlers

http\://www.mycompany.example/schema/myns=org.springframework.samples.xml.MyNamespaceHandler

（字符是 Java 属性格式中的有效分隔符，因此 URI 中的字符需要使用反斜杠进行转义。::

键值对的第一部分（键）是与自定义关联的 URI 命名空间扩展名，并且需要与自定义 XSD 架构中指定的属性值完全匹配。targetNamespace

编写“META-INF/spring.schemas”

调用的属性文件包含 XML 架构位置的映射（与架构声明一起在将架构用作一部分的 XML 文件中引用的属性）到类路径资源。需要此文件防止 Spring 绝对必须使用默认值这需要互联网访问以检索架构文件。如果在此指定映射属性文件，Spring 在类路径上搜索模式（在本例中为包中）。以下代码片段显示了我们需要为自定义架构添加的行：spring.schemasxsi:schemaLocationEntityResolvermyns.xsdorg.springframework.samples.xml

http\://www.mycompany.example/schema/myns/myns.xsd=org/springframework/samples/xml/myns.xsd

（请记住，必须转义该字符。:

我们鼓励您同时部署 XSD 文件（或多个文件）类路径上的类。NamespaceHandlerBeanDefinitionParser

10.2.5. 在 Spring XML 配置中使用自定义扩展

使用您自己实现的自定义扩展与使用 Spring 提供的“自定义”扩展之一。以下示例使用在前面步骤中开发的自定义元素在 Spring XML 配置文件中：<dateformat/>

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

    <!-- as a top-level bean -->
    <myns:dateformat id="defaultDateFormat" pattern="yyyy-MM-dd HH:mm" lenient="true"/> 

    <bean id="jobDetailTemplate" abstract="true">
        <property name="dateFormat">
            <!-- as an inner bean -->
            <myns:dateformat pattern="HH:mm MM-dd-yyyy"/>
        </property>
    </bean>

</beans>

10.2.6. 更详细的示例

本节提供自定义 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:foo="http://www.foo.example/schema/component"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.foo.example/schema/component http://www.foo.example/schema/component/component.xsd">

    <foo:component id="bionic-family" name="Bionic-1">
        <foo:component name="Mother-1">
            <foo:component name="Karate-1"/>
            <foo:component name="Sport-1"/>
        </foo:component>
        <foo:component name="Rock-1"/>
    </foo:component>

</beans>

上述配置将自定义扩展相互嵌套。该类实际上由元素配置的是类（在下一个示例中显示）。请注意该类如何不公开属性的二传手方法。这使得它很难（或者更确切地说是不可能的）使用资源库注入为类配置 Bean 定义。以下清单显示了类：<foo:component/>ComponentComponentcomponentsComponentComponent

package com.foo;

import java.util.ArrayList;
import java.util.List;

public class Component {

    private String name;
    private List<Component> components = new ArrayList<Component> ();

    // mmm, there is no setter method for the 'components'
    public void addComponent(Component component) {
        this.components.add(component);
    }

    public List<Component> getComponents() {
        return components;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

此问题的典型解决方案是创建一个公开属性的二传手属性。以下清单显示了此类自定义：FactoryBeancomponentsFactoryBean

package com.foo;

import org.springframework.beans.factory.FactoryBean;

import java.util.List;

public class ComponentFactoryBean implements FactoryBean<Component> {

    private Component parent;
    private List<Component> children;

    public void setParent(Component parent) {
        this.parent = parent;
    }

    public void setChildren(List<Component> children) {
        this.children = children;
    }

    public Component getObject() throws Exception {
        if (this.children != null && this.children.size() > 0) {
            for (Component child : children) {
                this.parent.addComponent(child);
            }
        }
        return this.parent;
    }

    public Class<Component> getObjectType() {
        return Component.class;
    }

    public boolean isSingleton() {
        return true;
    }
}

这很好用，但它向最终用户暴露了很多 Spring 管道。我们是什么要做的是编写一个自定义扩展，隐藏所有这些春季管道。如果我们坚持前面描述的步骤，我们开始通过创建 XSD 架构来定义自定义标记的结构，如下所示房源显示：

<?xml version="1.0" encoding="UTF-8" standalone="no"?>

<xsd:schema xmlns="http://www.foo.example/schema/component"
        xmlns:xsd="http://www.w3.org/2001/XMLSchema"
        targetNamespace="http://www.foo.example/schema/component"
        elementFormDefault="qualified"
        attributeFormDefault="unqualified">

    <xsd:element name="component">
        <xsd:complexType>
            <xsd:choice minOccurs="0" maxOccurs="unbounded">
                <xsd:element ref="component"/>
            </xsd:choice>
            <xsd:attribute name="id" type="xsd:ID"/>
            <xsd:attribute name="name" use="required" type="xsd:string"/>
        </xsd:complexType>
    </xsd:element>

</xsd:schema>

再次按照前面描述的过程，然后我们创建一个自定义：NamespaceHandler

package com.foo;

import org.springframework.beans.factory.xml.NamespaceHandlerSupport;

public class ComponentNamespaceHandler extends NamespaceHandlerSupport {

    public void init() {
        registerBeanDefinitionParser("component", new ComponentBeanDefinitionParser());
    }
}

接下来是习俗。请记住，我们正在创造 a那描述一个。以下列表显示了我们的自定义实现：BeanDefinitionParserBeanDefinitionComponentFactoryBeanBeanDefinitionParser

package com.foo;

import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.ManagedList;
import org.springframework.beans.factory.xml.AbstractBeanDefinitionParser;
import org.springframework.beans.factory.xml.ParserContext;
import org.springframework.util.xml.DomUtils;
import org.w3c.dom.Element;

import java.util.List;

public class ComponentBeanDefinitionParser extends AbstractBeanDefinitionParser {

    protected AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
        return parseComponentElement(element);
    }

    private static AbstractBeanDefinition parseComponentElement(Element element) {
        BeanDefinitionBuilder factory = BeanDefinitionBuilder.rootBeanDefinition(ComponentFactoryBean.class);
        factory.addPropertyValue("parent", parseComponent(element));

        List<Element> childElements = DomUtils.getChildElementsByTagName(element, "component");
        if (childElements != null && childElements.size() > 0) {
            parseChildComponents(childElements, factory);
        }

        return factory.getBeanDefinition();
    }

    private static BeanDefinition parseComponent(Element element) {
        BeanDefinitionBuilder component = BeanDefinitionBuilder.rootBeanDefinition(Component.class);
        component.addPropertyValue("name", element.getAttribute("name"));
        return component.getBeanDefinition();
    }

    private static void parseChildComponents(List<Element> childElements, BeanDefinitionBuilder factory) {
        ManagedList<BeanDefinition> children = new ManagedList<BeanDefinition>(childElements.size());
        for (Element element : childElements) {
            children.add(parseComponentElement(element));
        }
        factory.addPropertyValue("children", children);
    }
}

最后，各种工件需要注册到 Spring XML 基础结构，通过修改文件，如下所示：META-INF/spring.handlersMETA-INF/spring.schemas

# in 'META-INF/spring.handlers'
http\://www.foo.example/schema/component=com.foo.ComponentNamespaceHandler

# in 'META-INF/spring.schemas'
http\://www.foo.example/schema/component/component.xsd=com/foo/component.xsd

“普通”元素上的自定义属性

编写自己的自定义分析器和关联的项目并不难。然而有时这不是正确的做法。考虑需要将元数据添加到现有的 Bean 定义中。在这种情况下，你当然不想编写自己的整个自定义扩展。相反，你只是想要向现有 Bean 定义元素添加附加属性。

通过另一个示例，假设您为访问集群JCache 的服务对象（它不知道），并且您希望确保命名的 JCache 实例在周围的集群中急切地启动。下面的清单显示了这样的定义：

<bean id="checkingAccountService" class="com.foo.DefaultCheckingAccountService"
        jcache:cache-name="checking.account">
    <!-- other dependencies here... -->
</bean>

然后我们可以在解析属性时创建另一个。然后初始化为我们命名的JCache。我们还可以修改现有的 for 这样它就依赖于这个新的 JCache-initializing.以下列表显示了我们的：BeanDefinition'jcache:cache-name'BeanDefinitionBeanDefinition'checkingAccountService'BeanDefinitionJCacheInitializer

package com.foo;

public class JCacheInitializer {

    private String name;

    public JCacheInitializer(String name) {
        this.name = name;
    }

    public void initialize() {
        // lots of JCache API calls to initialize the named cache...
    }
}

现在我们可以转到自定义扩展。首先，我们需要作者描述自定义属性的 XSD 架构，如下所示：

<?xml version="1.0" encoding="UTF-8" standalone="no"?>

<xsd:schema xmlns="http://www.foo.example/schema/jcache"
        xmlns:xsd="http://www.w3.org/2001/XMLSchema"
        targetNamespace="http://www.foo.example/schema/jcache"
        elementFormDefault="qualified">

    <xsd:attribute name="cache-name" type="xsd:string"/>

</xsd:schema>

接下来，我们需要创建关联的，如下所示：NamespaceHandler

package com.foo;

import org.springframework.beans.factory.xml.NamespaceHandlerSupport;

public class JCacheNamespaceHandler extends NamespaceHandlerSupport {

    public void init() {
        super.registerBeanDefinitionDecoratorForAttribute("cache-name",
            new JCacheInitializingBeanDefinitionDecorator());
    }

}

接下来，我们需要创建解析器。请注意，在这种情况下，因为我们要解析一个XML属性，我们写a而不是a。以下列表显示了我们的实现：BeanDefinitionDecoratorBeanDefinitionParserBeanDefinitionDecorator

package com.foo;

import org.springframework.beans.factory.config.BeanDefinitionHolder;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.xml.BeanDefinitionDecorator;
import org.springframework.beans.factory.xml.ParserContext;
import org.w3c.dom.Attr;
import org.w3c.dom.Node;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class JCacheInitializingBeanDefinitionDecorator implements BeanDefinitionDecorator {

    private static final String[] EMPTY_STRING_ARRAY = new String[0];

    public BeanDefinitionHolder decorate(Node source, BeanDefinitionHolder holder,
            ParserContext ctx) {
        String initializerBeanName = registerJCacheInitializer(source, ctx);
        createDependencyOnJCacheInitializer(holder, initializerBeanName);
        return holder;
    }

    private void createDependencyOnJCacheInitializer(BeanDefinitionHolder holder,
            String initializerBeanName) {
        AbstractBeanDefinition definition = ((AbstractBeanDefinition) holder.getBeanDefinition());
        String[] dependsOn = definition.getDependsOn();
        if (dependsOn == null) {
            dependsOn = new String[]{initializerBeanName};
        } else {
            List dependencies = new ArrayList(Arrays.asList(dependsOn));
            dependencies.add(initializerBeanName);
            dependsOn = (String[]) dependencies.toArray(EMPTY_STRING_ARRAY);
        }
        definition.setDependsOn(dependsOn);
    }

    private String registerJCacheInitializer(Node source, ParserContext ctx) {
        String cacheName = ((Attr) source).getValue();
        String beanName = cacheName + "-initializer";
        if (!ctx.getRegistry().containsBeanDefinition(beanName)) {
            BeanDefinitionBuilder initializer = BeanDefinitionBuilder.rootBeanDefinition(JCacheInitializer.class);
            initializer.addConstructorArg(cacheName);
            ctx.getRegistry().registerBeanDefinition(beanName, initializer.getBeanDefinition());
        }
        return beanName;
    }
}

最后，我们需要将各种工件注册到 Spring XML 基础结构中。通过修改文件，如下所示：META-INF/spring.handlersMETA-INF/spring.schemas

# in 'META-INF/spring.handlers'
http\://www.foo.example/schema/jcache=com.foo.JCacheNamespaceHandler

# in 'META-INF/spring.schemas'
http\://www.foo.example/schema/jcache/jcache.xsd=com/foo/jcache.xsd

10.3. 应用程序启动步骤

附录的这一部分列出了检测核心容器的现有内容。StartupSteps

Table 15. Application startup steps defined in the core container

名字	描述	标签
`spring.beans.instantiate`	Bean 及其依赖项的实例化。	`beanName`Bean的名称，注射点所需的类型。`beanType`
`spring.beans.smart-initialize`	初始化豆子。`SmartInitializingSingleton`	`beanName`豆子的名称。
`spring.context.annotated-bean-reader.create`	的创建。`AnnotatedBeanDefinitionReader`
`spring.context.base-packages.scan`	扫描基本包。	`packages`用于扫描的基本软件包数组。
`spring.context.beans.post-process`	豆子后处理阶段。
`spring.context.bean-factory.post-process`	调用 thebeans。`BeanFactoryPostProcessor`	`postProcessor`当前后处理器。
`spring.context.beandef-registry.post-process`	调用 thebeans。`BeanDefinitionRegistryPostProcessor`	`postProcessor`当前后处理器。
`spring.context.component-classes.register`	通过注册组件类。`AnnotationConfigApplicationContext#register`	`classes`用于注册的给定类的数组。
`spring.context.config-classes.enhance`	使用 CGLIB 代理增强配置类。	`classCount`增强类的计数。
`spring.context.config-classes.parse`	配置类解析阶段与。`ConfigurationClassPostProcessor`	`classCount`已处理类的计数。
`spring.context.refresh`	应用程序上下文刷新阶段。

版本 5.3.23

标签：框架,示例,核心技术,Spring,springframework,使用,org,AspectJ
From： https://blog.51cto.com/u_15326439/5856382

Spring 框架的核心技术(五）

5.6. 选择要使用的 AOP 声明样式

5.6.1. 弹簧 AOP 还是全方面 J？

5.6.2. Spring AOP 的@AspectJ或 XML？

5.7. 混合宽高比类型

5.8. 代理机制

5.8.1. 了解 AOP 代理

5.9. @AspectJ代理的程序化创建

5.10. 将 AspectJ 与弹簧应用程序一起使用

5.10.1. 使用 AspectJ 通过 Spring 依赖注入域对象

单元测试对象​​@Configurable​​

使用多个应用程序上下文

5.10.2. AspectJ 的其他弹簧方面

5.10.3. 使用 Spring IoC 配置 AspectJ 方面

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

第一个例子

方面

“元信息/AOP.xml”

所需库 （罐）

弹簧配置

特定于环境的配置

Tomcat， JBoss， WebSphere， WebLogic

通用 Java 应用程序

5.11. 更多资源

6. 春季 AOP API

6.1. 春季切入点 API

6.1.1. 概念

6.1.2. 切入点的操作

6.1.3. 方面J 表达式切入点

6.1.4. 便利切入点实现

静态切入点

正则表达式切入点

属性驱动的切入点

动态切入点

控制流切入点

6.1.5. 切入点超类

6.1.6. 自定义切入点

6.2. 春季的建议 API

6.2.1. 建议生命周期

6.2.2. 春季的建议类型

拦截周围的建议

建议前

投掷建议

返回建议后

介绍建议

6.3. 春季的顾问 API

6.4. 使用创建 AOP 代理​​ProxyFactoryBean​​

6.4.1. 基础知识

6.4.2. JavaBean 属性

6.4.3. 基于 JDK 和 CGLIB 的代理

6.4.4. 代理接口

6.4.5. 代理类

6.4.6. 使用“全局”顾问

6.5. 简明的代理定义

6.6. 使用​​ProxyFactory​​

6.7. 操作建议对象

6.8. 使用“自动代理”工具

6.8.1. 自动代理 Bean 定义

​​BeanNameAutoProxyCreator​​

​​DefaultAdvisorAutoProxyCreator​​

6.9. 使用实现​​TargetSource​​

6.9.1. 热插拔目标源

6.9.2. 池化目标源

6.9.3. 原型目标源

6.9.4.目标来源​​ThreadLocal​​

6.10. 定义新的建议类型

7. 零安全

7.1. 用例

7.2. JSR-305 元注释

8. 数据缓冲区和编解码器

8.1. ​​DataBufferFactory​​

8.2. ​​DataBuffer​​

8.3. ​​PooledDataBuffer​​

8.4. ​​DataBufferUtils​​

8.5. 编解码器

8.6. 使用​​DataBuffer​​

9. 日志记录

10. 附录

10.1.XML 模式

10.1.1. 模式​​util​​

单元测试对象`@Configurable`

所需库（罐）

6.4. 使用创建 AOP 代理`ProxyFactoryBean`

6.6. 使用`ProxyFactory`

`BeanNameAutoProxyCreator`

`DefaultAdvisorAutoProxyCreator`

6.9. 使用实现`TargetSource`

6.9.4.目标来源`ThreadLocal`

8.1. `DataBufferFactory`

8.2. `DataBuffer`

8.3. `PooledDataBuffer`

8.4. `DataBufferUtils`

8.6. 使用`DataBuffer`

10.1.1. 模式`util`

用`<util:constant/>`

用`<util:property-path/>`

用于设置 Bean 属性或构造函数参数`<util:property-path/>`

用`<util:properties/>`

用`<util:list/>`

用`<util:map/>`

用`<util:set/>`

10.1.2. 模式`aop`

10.1.3. 模式`context`

用`<property-placeholder/>`

用`<annotation-config/>`

用`<component-scan/>`

用`<load-time-weaver/>`

用`<spring-configured/>`

用`<mbean-export/>`

10.2.2. 编码`NamespaceHandler`

10.2.3. 使用`BeanDefinitionParser`

写作`META-INF/spring.handlers`