集成

1. 远程处理和 Web 服务

Spring 通过各种技术提供对远程处理的支持。远程支持简化了已实施的远程支持服务的开发通过 Java 接口和对象作为输入和输出。目前， Spring 支持以下远程处理技术：spring-doc.cn

远程方法调用（RMI）：通过使用 and ，Spring 支持传统的 RMI（带有接口和）和通过 RMI 的透明远程处理调用程序（具有任何 Java 接口）。RmiProxyFactoryBeanRmiServiceExporterjava.rmi.Remotejava.rmi.RemoteExceptionspring-doc.cn
Spring HTTP 调用程序： Spring 提供了一种特殊的远程处理策略，允许通过 HTTP 进行 Java 序列化，支持任何 Java 接口（如 RMI Invoker 会）。相应的支持类是和。HttpInvokerProxyFactoryBeanHttpInvokerServiceExporterspring-doc.cn
Hessian：通过使用 Spring 和，您可以通过由 Caucho 提供的基于 HTTP 的轻量级二进制协议。HessianProxyFactoryBeanHessianServiceExporterspring-doc.cn
Java Web 服务：Spring 通过 JAX-WS 为 Web 服务提供远程支持。spring-doc.cn
JMS：通过模块中的 and 类支持通过 JMS 作为底层协议进行远程处理。JmsInvokerServiceExporterJmsInvokerProxyFactoryBeanspring-jmsspring-doc.cn
AMQP：通过 AMQP 作为底层协议进行远程处理受单独的 Spring AMQP 项目。spring-doc.cn

在讨论 Spring 的远程处理功能时，我们使用以下域型号及相应服务：spring-doc.cn

public class Account implements Serializable{

    private String name;

    public String getName(){
        return name;
    }

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

public interface AccountService {

    public void insertAccount(Account account);

    public List<Account> getAccounts(String name);
}

// the implementation doing nothing at the moment
public class AccountServiceImpl implements AccountService {

    public void insertAccount(Account acc) {
        // do something...
    }

    public List<Account> getAccounts(String name) {
        // do something...
    }
}

本节首先使用 RMI 向远程客户端公开服务，并进行一些讨论关于使用 RMI 的缺点。然后，它继续介绍一个使用 Hessian 作为协议。spring-doc.cn

1.1. RMI

通过使用 Spring 对 RMI 的支持，您可以通过 RMI 基础设施。完成此设置后，您基本上会有一个类似的配置到远程 EJB 中，除了没有对安全性的标准支持上下文传播或远程事务传播。Spring 确实为 such additional invocation context，因此您可以，例如，插入安全框架或自定义安全凭证。spring-doc.cn

1.1.1. 使用 Export Service`RmiServiceExporter`

使用，我们可以公开 AccountService 对象的接口作为 RMI 对象。可以使用或通过普通 RMI（对于传统 RMI 服务）。显式的支持通过 RMI 调用程序公开任何非 RMI 服务。RmiServiceExporterRmiProxyFactoryBeanRmiServiceExporterspring-doc.cn

我们首先必须在 Spring 容器中设置我们的服务。以下示例显示了如何执行此操作：spring-doc.cn

<bean id="accountService" class="example.AccountServiceImpl">
    <!-- any additional properties, maybe a DAO? -->
</bean>

接下来，我们必须使用 . 以下示例显示了如何执行此操作：RmiServiceExporterspring-doc.cn

<bean class="org.springframework.remoting.rmi.RmiServiceExporter">
    <!-- does not necessarily have to be the same name as the bean to be exported -->
    <property name="serviceName" value="AccountService"/>
    <property name="service" ref="accountService"/>
    <property name="serviceInterface" value="example.AccountService"/>
    <!-- defaults to 1099 -->
    <property name="registryPort" value="1199"/>
</bean>

在前面的示例中，我们覆盖 RMI 注册表的端口。通常，您的应用程序 server 还维护着一个 RMI 注册表，明智的做法是不要干扰该注册表。此外，服务名称还用于绑定服务。因此，在前面的示例中， service 的绑定。我们稍后使用此 URL 进行链接客户端的服务。'rmi://HOST:1199/AccountService'spring-doc.cn

该属性已被省略（默认为 0）。这意味着匿名端口用于与服务通信。servicePort

1.1.2. 在客户端的服务中链接

我们的客户端是一个简单的对象，它使用来管理账户、如下例所示：AccountServicespring-doc.cn

public class SimpleObject {

    private AccountService accountService;

    public void setAccountService(AccountService accountService) {
        this.accountService = accountService;
    }

    // additional methods using the accountService
}

为了在客户端上链接服务，我们创建了一个单独的 Spring 容器包含以下简单对象和服务链接配置位：spring-doc.cn

<bean class="example.SimpleObject">
    <property name="accountService" ref="accountService"/>
</bean>

<bean id="accountService" class="org.springframework.remoting.rmi.RmiProxyFactoryBean">
    <property name="serviceUrl" value="rmi://HOST:1199/AccountService"/>
    <property name="serviceInterface" value="example.AccountService"/>
</bean>

这就是我们在客户端上支持远程账户服务所需要做的全部工作。Spring 透明地创建一个调用程序，并通过 .在客户端，我们使用 .RmiServiceExporterRmiProxyFactoryBeanspring-doc.cn

1.2. 使用 Hessian 通过 HTTP 远程调用服务

Hessian 提供基于二进制 HTTP 的远程处理协议。它由 Caucho 开发，您可以在 https://www.caucho.com/ 上找到有关 Hessian 本身的更多信息。spring-doc.cn

1.2.1. 黑森州

Hessian 通过 HTTP 进行通信，并使用自定义 servlet 进行通信。通过使用 Spring 的原则（参见 webmvc.html），我们可以将这样的 servlet 来公开您的服务。首先，我们必须在应用程序中创建一个新的 servlet 如以下摘录所示：DispatcherServletweb.xmlspring-doc.cn

<servlet>
    <servlet-name>remoting</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
    <servlet-name>remoting</servlet-name>
    <url-pattern>/remoting/*</url-pattern>
</servlet-mapping>

如果您熟悉 Spring 的原则，您可能知道现在您必须在目录中创建一个名为（以 Servlet 的名称命名）的 Spring 容器配置资源。下一节将使用应用程序上下文。DispatcherServletremoting-servlet.xmlWEB-INFspring-doc.cn

或者，考虑使用 Spring 的 simpler .这样做允许您将远程导出器定义嵌入到根应用程序上下文中（通过 default， in ），具有单独的 servlet 定义指向特定的导出器 bean。在这种情况下，每个 servlet 名称都需要与其目标出口商。HttpRequestHandlerServletWEB-INF/applicationContext.xmlspring-doc.cn

1.2.2. 使用`HessianServiceExporter`

在新创建的名为的应用程序上下文中，我们创建一个来导出我们的服务，如下例所示：remoting-servlet.xmlHessianServiceExporterspring-doc.cn

<bean id="accountService" class="example.AccountServiceImpl">
    <!-- any additional properties, maybe a DAO? -->
</bean>

<bean name="/AccountService" class="org.springframework.remoting.caucho.HessianServiceExporter">
    <property name="service" ref="accountService"/>
    <property name="serviceInterface" value="example.AccountService"/>
</bean>

现在，我们已准备好在客户端链接服务。没有显式处理程序映射指定（将请求 URL 映射到服务），因此我们使用 used.因此，该服务将导出到通过其 Bean 名称指示的 URL 处在包含实例的映射中（如前所述）：.BeanNameUrlHandlerMappingDispatcherServlethttps://HOST:8080/remoting/AccountServicespring-doc.cn

或者，您可以在根应用程序上下文中创建一个（例如 in ），如下例所示：HessianServiceExporterWEB-INF/applicationContext.xmlspring-doc.cn

<bean name="accountExporter" class="org.springframework.remoting.caucho.HessianServiceExporter">
    <property name="service" ref="accountService"/>
    <property name="serviceInterface" value="example.AccountService"/>
</bean>

在后一种情况下，您应该在中为此导出器定义相应的 servlet 。具有相同的最终结果：导出器映射到处的请求路径。请注意，Servlet 名称需要与目标导出器。以下示例显示了如何执行此操作：web.xml/remoting/AccountServicespring-doc.cn

<servlet>
    <servlet-name>accountExporter</servlet-name>
    <servlet-class>org.springframework.web.context.support.HttpRequestHandlerServlet</servlet-class>
</servlet>

<servlet-mapping>
    <servlet-name>accountExporter</servlet-name>
    <url-pattern>/remoting/AccountService</url-pattern>
</servlet-mapping>

1.2.3. 在客户端的服务中链接

通过使用，我们可以在客户端链接服务。一样原则与 RMI 示例一样适用。我们创建一个单独的 bean factory，或者 application context 并提及以下 bean，其中 is 通过使用的 To Manage accounts，如下例所示：HessianProxyFactoryBeanSimpleObjectAccountServicespring-doc.cn

<bean class="example.SimpleObject">
    <property name="accountService" ref="accountService"/>
</bean>

<bean id="accountService" class="org.springframework.remoting.caucho.HessianProxyFactoryBean">
    <property name="serviceUrl" value="https://remotehost:8080/remoting/AccountService"/>
    <property name="serviceInterface" value="example.AccountService"/>
</bean>

1.2.4. 将 HTTP 基本身份验证应用于通过 Hessian 公开的服务

Hessian 的优势之一就是我们可以很容易地应用 HTTP 基本认证，因为这两种协议都是基于 HTTP 的。您的常规 HTTP 服务器安全机制可以例如，通过使用安全功能来应用。通常您无需在此处使用每用户安全凭证。相反，您可以使用您定义的共享凭证在级别（类似于 JDBC ），如下例所示：web.xmlHessianProxyFactoryBeanDataSourcespring-doc.cn

<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping">
    <property name="interceptors" ref="authorizationInterceptor"/>
</bean>

<bean id="authorizationInterceptor"
        class="org.springframework.web.servlet.handler.UserRoleAuthorizationInterceptor">
    <property name="authorizedRoles" value="administrator,operator"/>
</bean>

在前面的示例中，我们显式提到了和 set 拦截器，仅允许管理员和操作员调用此应用程序上下文。BeanNameUrlHandlerMappingspring-doc.cn

前面的示例没有显示一种灵活的安全基础设施。为就安全性而言，更多选项，请查看 Spring Security 项目在 https://projects.spring.io/spring-security/。

1.3. Spring HTTP 调用程序

与 Hessian 相反，Spring HTTP 调用程序都是使用自己的 slim 的轻量级协议序列化机制并使用标准的 Java 序列化机制来通过 HTTP 公开服务。如果您的论点和返回类型是无法使用序列化进行序列化的复杂类型 Hessian 使用的机制（有关以下情况下的更多注意事项，请参阅下一节您选择远程处理技术）。spring-doc.cn

在后台，Spring 使用 JDK 提供的标准工具或 Apache 执行 HTTP 调用。如果您需要更多高级且易于使用的功能，请使用后者。有关更多信息，请参阅 hc.apache.org/httpcomponents-client-ga/。HttpComponentsspring-doc.cn

请注意由于不安全的 Java 反序列化而导致的漏洞：纵的输入流可能会导致在服务器上执行不需要的代码在反序列化步骤中。因此，不要公开 HTTP 调用程序 endpoints 连接到不受信任的客户端。相反，仅在您自己的服务之间公开它们。通常，我们强烈建议改用任何其他消息格式（如 JSON）。spring-doc.cn

如果您担心 Java 序列化导致的安全漏洞，考虑核心 JVM 级别的通用序列化过滤器机制，最初为 JDK 9 开发，但同时向后移植到 JDK 8、7 和 6。请参阅 https://blogs.oracle.com/java-platform-group/entry/incoming_filter_serialization_data_a 和 https://openjdk.java.net/jeps/290。spring-doc.cn

1.3.1. 公开 Service 对象

为服务对象设置 HTTP 调用程序基础设施与方式，使用 Hessian 也会执行相同的操作。正如 Hessian 支持提供的那样，Spring 的 HttpInvoker 支持提供了。HessianServiceExporterorg.springframework.remoting.httpinvoker.HttpInvokerServiceExporterspring-doc.cn

要在 Spring Web MVC 中公开（前面提到的），需要在 Dispatcher 的应用程序上下文，如下例所示：AccountServiceDispatcherServletspring-doc.cn

<bean name="/AccountService" class="org.springframework.remoting.httpinvoker.HttpInvokerServiceExporter">
    <property name="service" ref="accountService"/>
    <property name="serviceInterface" value="example.AccountService"/>
</bean>

这样的导出器定义通过实例的标准制图设施，如 Hessian 一节所述。DispatcherServletspring-doc.cn

或者，您可以在根应用程序上下文中创建一个（例如，in ），如下例所示：HttpInvokerServiceExporter'WEB-INF/applicationContext.xml'spring-doc.cn

<bean name="accountExporter" class="org.springframework.remoting.httpinvoker.HttpInvokerServiceExporter">
    <property name="service" ref="accountService"/>
    <property name="serviceInterface" value="example.AccountService"/>
</bean>

此外，您可以在中为此导出器定义相应的 Servlet，使用 Servlet 名称与目标导出器的 Bean 名称匹配，如下例所示：web.xmlspring-doc.cn

<servlet>
    <servlet-name>accountExporter</servlet-name>
    <servlet-class>org.springframework.web.context.support.HttpRequestHandlerServlet</servlet-class>
</servlet>

<servlet-mapping>
    <servlet-name>accountExporter</servlet-name>
    <url-pattern>/remoting/AccountService</url-pattern>
</servlet-mapping>

1.3.2. 在客户端链接服务

同样，从客户端链接服务的方式与你的操作方式非常相似当您使用 Hessian 时。通过使用代理， Spring 可以将你的调用转换为 HTTP POST 请求发送到指向导出服务的 URL。以下示例演示如何配置此安排：spring-doc.cn

<bean id="httpInvokerProxy" class="org.springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean">
    <property name="serviceUrl" value="https://remotehost:8080/remoting/AccountService"/>
    <property name="serviceInterface" value="example.AccountService"/>
</bean>

如前所述，您可以选择要使用的 HTTP 客户端。默认情况下，使用 JDK 的 HTTP 功能，但您也可以通过设置该属性来使用 Apache 客户端。以下示例显示了如何执行此操作：HttpInvokerProxyHttpComponentshttpInvokerRequestExecutorspring-doc.cn

<property name="httpInvokerRequestExecutor">
    <bean class="org.springframework.remoting.httpinvoker.HttpComponentsHttpInvokerRequestExecutor"/>
</property>

1.4. Java Web 服务

Spring 为标准 Java Web 服务 API 提供完全支持：spring-doc.cn

使用 JAX-WS 公开 Web 服务spring-doc.cn
使用 JAX-WS 访问 Web Servicespring-doc.cn

除了 Spring Core 中对 JAX-WS 的 stock 支持外，Spring portfolio 还具有 Spring Web Services，它是合同优先、文档驱动的 Web 服务 — 强烈推荐用于构建现代、面向未来的 Web 服务。spring-doc.cn

1.4.1. 使用 JAX-WS 公开基于 Servlet 的 Web 服务

Spring 为 JAX-WS servlet 端点实现提供了一个方便的基类：.为了公开我们的，我们扩展了 Spring 的类并在此处实现我们的业务逻辑，通常将调用委托给业务层。我们使用 Spring 的 Comments 来表达对 Spring 托管 bean 的这种依赖关系。以下示例显示了我们的类 extends ：SpringBeanAutowiringSupportAccountServiceSpringBeanAutowiringSupport@AutowiredSpringBeanAutowiringSupportspring-doc.cn

/**
 * JAX-WS compliant AccountService implementation that simply delegates
 * to the AccountService implementation in the root web application context.
 *
 * This wrapper class is necessary because JAX-WS requires working with dedicated
 * endpoint classes. If an existing service needs to be exported, a wrapper that
 * extends SpringBeanAutowiringSupport for simple Spring bean autowiring (through
 * the @Autowired annotation) is the simplest JAX-WS compliant way.
 *
 * This is the class registered with the server-side JAX-WS implementation.
 * In the case of a Java EE server, this would simply be defined as a servlet
 * in web.xml, with the server detecting that this is a JAX-WS endpoint and reacting
 * accordingly. The servlet name usually needs to match the specified WS service name.
 *
 * The web service engine manages the lifecycle of instances of this class.
 * Spring bean references will just be wired in here.
 */
import org.springframework.web.context.support.SpringBeanAutowiringSupport;

@WebService(serviceName="AccountService")
public class AccountServiceEndpoint extends SpringBeanAutowiringSupport {

    @Autowired
    private AccountService biz;

    @WebMethod
    public void insertAccount(Account acc) {
        biz.insertAccount(acc);
    }

    @WebMethod
    public Account[] getAccounts(String name) {
        return biz.getAccounts(name);
    }
}

我们需要在与 Spring 相同的 Web 应用程序中运行 context 以允许访问 Spring 的工具。在 Java 中，默认情况下是这种情况 EE 环境，使用 JAX-WS servlet 端点部署的标准协定。有关详细信息，请参阅各种 Java EE Web 服务教程。AccountServiceEndpointspring-doc.cn

1.4.2. 使用 JAX-WS 导出独立 Web 服务

Oracle JDK 附带的内置 JAX-WS 提供程序支持 Web 的公开服务。Spring 的 bean 在 Spring 中检测所有带 --注解的 bean 应用程序上下文，并通过默认的 JAX-WS 服务器（JDK HTTP 服务器）。SimpleJaxWsServiceExporter@WebServicespring-doc.cn

在此方案中，端点实例被定义为 Spring bean 并进行管理他们自己。它们已向 JAX-WS 引擎注册，但其生命周期最长可达 Spring 应用程序上下文。这意味着您可以应用 Spring 功能（例如显式依赖项注入）添加到终端节点实例。注释驱动注入 through 也有效。以下示例说明如何定义这些 bean：@Autowiredspring-doc.cn

<bean class="org.springframework.remoting.jaxws.SimpleJaxWsServiceExporter">
    <property name="baseAddress" value="http://localhost:8080/"/>
</bean>

<bean id="accountServiceEndpoint" class="example.AccountServiceEndpoint">
    ...
</bean>

...

可以但不必从 Spring 的，因为这个例子中的端点是一个完全由 Spring 管理的 bean。这意味着端点实现可以如下（没有声明任何超类 - 并且仍然遵循 Spring 的配置注释）：AccountServiceEndpointSpringBeanAutowiringSupport@Autowiredspring-doc.cn

@WebService(serviceName="AccountService")
public class AccountServiceEndpoint {

    @Autowired
    private AccountService biz;

    @WebMethod
    public void insertAccount(Account acc) {
        biz.insertAccount(acc);
    }

    @WebMethod
    public List<Account> getAccounts(String name) {
        return biz.getAccounts(name);
    }
}

1.4.3. 使用 JAX-WS RI 的 Spring 支持导出 Web 服务

作为 GlassFish 项目的一部分开发的 Oracle JAX-WS RI 提供 Spring 支持作为其 JAX-WS Commons 项目的一部分。这允许将 JAX-WS 端点定义为 Spring Management 的 bean，类似于上一节中讨论的独立模式——但这次是在 Servlet 环境中。spring-doc.cn

这在 Java EE 环境中是不可移植的。它主要用于非 EE 将 JAX-WS RI 嵌入为 Web 应用程序一部分的环境，例如 Tomcat。

与导出基于 servlet 的端点的标准样式的区别在于端点实例本身的生命周期由 Spring 管理，并且只是中定义的一个 JAX-WS Servlet。使用标准的 Java EE 样式（如前面所示），每个服务端点都有一个 servlet 定义，每个端点通常委托给 Spring bean（通过使用，如前所述）。web.xml@Autowiredspring-doc.cn

有关设置和使用方式的详细信息，请参阅 https://jax-ws-commons.java.net/spring/。spring-doc.cn

1.4.4. 使用 JAX-WS 访问 Web 服务

Spring 提供了两个工厂 bean 来创建 JAX-WS Web 服务代理，即和。前者可以仅返回一个 JAX-WS 服务类供我们使用。后者是成熟的 version 中，该版本可以返回实现我们的业务服务接口的代理。在以下示例中，我们用于为终端节点创建代理（再次）：LocalJaxWsServiceFactoryBeanJaxWsPortProxyFactoryBeanJaxWsPortProxyFactoryBeanAccountServicespring-doc.cn

<bean id="accountWebService" class="org.springframework.remoting.jaxws.JaxWsPortProxyFactoryBean">
    <property name="serviceInterface" value="example.AccountService"/> (1)
    <property name="wsdlDocumentUrl" value="http://localhost:8888/AccountServiceEndpoint?WSDL"/>
    <property name="namespaceUri" value="https://example/"/>
    <property name="serviceName" value="AccountService"/>
    <property name="portName" value="AccountServiceEndpointPort"/>
</bean>

1	客户使用的业务界面在哪里。`serviceInterface`

wsdlDocumentUrl是 WSDL 文件的 URL。Spring 在启动时需要 this 来创建 JAX-WS 服务。对应于 .wsdl 文件。对应于 .wsdl 文件中的服务名称。对应于 .wsdl 文件中的端口名称。namespaceUritargetNamespaceserviceNameportNamespring-doc.cn

访问 Web 服务很容易，因为我们有一个 bean 工厂，它将其公开为一个名为 .下面的示例展示了我们如何连接在 Spring 中：AccountServicespring-doc.cn

<bean id="client" class="example.AccountClientImpl">
    ...
    <property name="service" ref="accountWebService"/>
</bean>

从客户端代码中，我们可以像访问普通类一样访问 Web 服务。如下例所示：spring-doc.cn

public class AccountClientImpl {

    private AccountService service;

    public void setService(AccountService service) {
        this.service = service;
    }

    public void foo() {
        service.insertAccount(...);
    }
}

以上内容略微简化，因为 JAX-WS 需要端点接口和要注释的实现类，等等附注。这意味着您不能（轻松）使用普通的 Java 接口和实现类作为 JAX-WS 端点工件;您需要对它们进行注释因此首先。查看 JAX-WS 文档以了解有关这些要求的详细信息。@WebService@SOAPBinding

1.5. JMS

您还可以使用 JMS 作为底层通信来透明地公开服务协议。Spring Framework 中的 JMS 远程支持非常基本。它发送并在和上接收在和在同一个非交易 . 因此，吞吐量取决于实现。请注意，这些单线程非事务性约束仅适用于 Spring 的 JMS 远程处理支持。有关 Spring 对基于 JMS 的消息传递的丰富支持的信息，请参见 JMS（Java 消息服务）。same threadSessionspring-doc.cn

服务端和客户端都使用如下接口：spring-doc.cn

package com.foo;

public interface CheckingAccountService {

    public void cancelAccount(Long accountId);
}

在服务器端使用了上述接口的以下简单实现：spring-doc.cn

package com.foo;

public class SimpleCheckingAccountService implements CheckingAccountService {

    public void cancelAccount(Long accountId) {
        System.out.println("Cancelling account [" + accountId + "]");
    }
}

以下配置文件包含共享的 JMS 基础结构 bean 在客户端和服务器上：spring-doc.cn

<?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="connectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
        <property name="brokerURL" value="tcp://ep-t43:61616"/>
    </bean>

    <bean id="queue" class="org.apache.activemq.command.ActiveMQQueue">
        <constructor-arg value="mmm"/>
    </bean>

</beans>

1.5.1. 服务器端配置

在服务器上，您需要公开使用的服务对象，如下例所示：JmsInvokerServiceExporterspring-doc.cn

<?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="checkingAccountService"
            class="org.springframework.jms.remoting.JmsInvokerServiceExporter">
        <property name="serviceInterface" value="com.foo.CheckingAccountService"/>
        <property name="service">
            <bean class="com.foo.SimpleCheckingAccountService"/>
        </property>
    </bean>

    <bean class="org.springframework.jms.listener.SimpleMessageListenerContainer">
        <property name="connectionFactory" ref="connectionFactory"/>
        <property name="destination" ref="queue"/>
        <property name="concurrentConsumers" value="3"/>
        <property name="messageListener" ref="checkingAccountService"/>
    </bean>

</beans>

package com.foo;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Server {

    public static void main(String[] args) throws Exception {
        new ClassPathXmlApplicationContext("com/foo/server.xml", "com/foo/jms.xml");
    }
}

1.5.2. 客户端配置

客户端只需要创建一个客户端代理来实现商定的 interface （）的 API API 中。CheckingAccountServicespring-doc.cn

下面的示例定义了可以注入到其他客户端对象的 bean （代理负责通过 JMS 将调用转发到服务器端对象）：spring-doc.cn

<?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="checkingAccountService"
            class="org.springframework.jms.remoting.JmsInvokerProxyFactoryBean">
        <property name="serviceInterface" value="com.foo.CheckingAccountService"/>
        <property name="connectionFactory" ref="connectionFactory"/>
        <property name="queue" ref="queue"/>
    </bean>

</beans>

package com.foo;

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

public class Client {

    public static void main(String[] args) throws Exception {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("com/foo/client.xml", "com/foo/jms.xml");
        CheckingAccountService service = (CheckingAccountService) ctx.getBean("checkingAccountService");
        service.cancelAccount(new Long(10));
    }
}

1.6. AMQP

Spring AMQP 项目支持通过 AMQP 作为底层协议进行远程处理。有关更多详细信息，请访问 Spring AMQP 参考的 Spring Remoting 部分。spring-doc.cn

不为远程接口实施自动检测spring-doc.cn

远程未自动检测已实现的接口的主要原因 interfaces 是为了避免向远程调用者打开太多门。目标对象可能实现内部回调接口，例如 OR 哪个接口不想向调用方公开。InitializingBeanDisposableBeanspring-doc.cn

提供具有目标实现的所有接口的代理通常无关紧要在本地案例中。但是，在导出远程服务时，您应该公开一个特定的 service 接口，其中包含用于远程使用的特定操作。除了内部 callback interfaces 时，Target 可能会实现多个业务接口，其中只有其中一个用于远程曝光。出于这些原因，我们需要这样一个服务接口。spring-doc.cn

这是配置便利性和意外风险之间的权衡内部方法的曝光。始终指定服务接口并不过分努力，并使您在特定方法的受控暴露方面处于安全状态。spring-doc.cn

1.7. 选择技术时的注意事项

这里介绍的每一项技术都有其缺点。选择技术时，您应该仔细考虑您的需求、您公开的服务以及您的对象通过电报发送。spring-doc.cn

使用 RMI 时，您无法通过 HTTP 协议访问对象。除非您通过隧道传输 RMI 流量。RMI 是一个相当重量级的协议，因为它支持全对象序列化，这在使用复杂数据模型时非常重要这需要通过网络进行序列化。但是，RMI-JRMP 与 Java 客户端相关联。是的 Java 到 Java 远程处理解决方案。spring-doc.cn

Spring 的 HTTP 调用程序是一个不错的选择，如果你需要基于 HTTP 的远程处理，但也依赖于 Java 序列化。它与 RMI 调用程序共享基本基础设施，但使用 HTTP 作为传输。请注意，HTTP 调用程序不仅限于 Java 到 Java 的远程处理但也对 Spring 的客户端和服务器端。（后者也适用于 Spring 的非 RMI 接口的 RMI 调用程序。spring-doc.cn

在异构环境中运行时，Hessian 可能会提供重要的价值，因为它们明确允许非 Java 客户端。但是，非 Java 支持仍然存在有限。已知问题包括 Hibernate 对象的序列化以及延迟初始化的集合。如果您有这样的数据模型，请考虑使用 RMI 或 HTTP 调用程序而不是 Hessian 调用程序。spring-doc.cn

JMS 可用于提供服务集群并让 JMS 代理接受负责负载平衡、发现和自动故障转移。默认情况下，Java 序列化为用于 JMS 远程处理，但 JMS 提供程序可以使用线路格式化，例如 XStream，以允许服务器在其他技术。spring-doc.cn

最后但并非最不重要的一点是，EJB 比 RMI 具有优势，因为它支持标准的基于角色的身份验证和授权以及远程事务传播。是的可以获取 RMI 调用程序或 HTTP 调用程序以支持安全上下文传播嗯，虽然这不是由 core Spring 提供的。Spring 仅提供合适的 hook 用于插入第三方或自定义解决方案。spring-doc.cn

1.8. REST 端点

Spring Framework 提供了两种调用 REST 端点的选择：spring-doc.cn

RestTemplate：带有同步模板的原始 Spring REST 客户端方法 API 的 API 中。spring-doc.cn
WebClient：非阻塞、反应式替代方案它支持同步和异步以及流式处理方案。spring-doc.cn

从 5.0 开始，它处于维护模式，只有对今后将接受更改和错误。请考虑使用 WebClient，它提供更现代的 API 和支持同步、异步和流式处理方案。RestTemplate

1.8.1.`RestTemplate`

它通过 HTTP 客户端库提供更高级别的 API。它使它易于在单行中调用 REST 端点。它公开了以下几组重载方法：RestTemplatespring-doc.cn

表 1.RestTemplate 方法
“方法”组	描述
`getForObject`spring-doc.cn	通过 GET 检索表示形式。spring-doc.cn
`getForEntity`spring-doc.cn	使用 GET 检索（即 status、headers 和 body）。`ResponseEntity`spring-doc.cn
`headForHeaders`spring-doc.cn	使用 HEAD 检索资源的所有标头。spring-doc.cn
`postForLocation`spring-doc.cn	使用 POST 创建新资源，并从响应中返回标头。`Location`spring-doc.cn
`postForObject`spring-doc.cn	使用 POST 创建新资源，并从响应中返回表示形式。spring-doc.cn
`postForEntity`spring-doc.cn	使用 POST 创建新资源，并从响应中返回表示形式。spring-doc.cn
`put`spring-doc.cn	使用 PUT 创建或更新资源。spring-doc.cn
`patchForObject`spring-doc.cn	使用 PATCH 更新资源并从响应中返回表示形式。请注意，JDK 不支持，但 Apache HttpComponents 和其他组件可以。`HttpURLConnectionPATCH`spring-doc.cn
`delete`spring-doc.cn	使用 DELETE 删除指定 URI 处的资源。spring-doc.cn
`optionsForAllow`spring-doc.cn	使用 ALLOW 检索资源允许的 HTTP 方法。spring-doc.cn
`exchange`spring-doc.cn	上述方法的更通用（且不那么固执己见）版本，它提供额外的需要时灵活。它接受一个（包括 HTTP 方法、URL、标头、和 body 作为输入）并返回一个 .`RequestEntityResponseEntity`spring-doc.cn 这些方法允许使用 of 而不是来指定具有泛型的响应类型。`ParameterizedTypeReferenceClass`spring-doc.cn
`execute`spring-doc.cn	执行请求的最通用方式，可完全控制请求通过回调接口进行准备和响应提取。spring-doc.cn

初始化

默认构造函数用于执行请求。您可以切换到具有 . 内置了对以下内容的支持：java.net.HttpURLConnectionClientHttpRequestFactoryspring-doc.cn

Apache HttpComponentsspring-doc.cn
网spring-doc.cn
OkHttpspring-doc.cn

例如，要切换到 Apache HttpComponents，您可以使用以下内容：spring-doc.cn

RestTemplate template = new RestTemplate(new HttpComponentsClientHttpRequestFactory());

每个都公开了特定于底层的配置选项 HTTP 客户端库 — 例如，用于凭证、连接池和其他详细信息。ClientHttpRequestFactoryspring-doc.cn

请注意，HTTP 请求的实现可能会在以下情况下引发异常访问表示错误的响应的状态（如 401）。如果这是一个问题，请切换到另一个 HTTP 客户端库。java.net

URI

许多方法接受 URI 模板和 URI 模板变量。作为变量参数，或作为 .RestTemplateStringMap<String,String>spring-doc.cn

以下示例使用 variable 参数：Stringspring-doc.cn

String result = restTemplate.getForObject(
        "https://example.com/hotels/{hotel}/bookings/{booking}", String.class, "42", "21");

以下示例使用：Map<String, String>spring-doc.cn

Map<String, String> vars = Collections.singletonMap("hotel", "42");

String result = restTemplate.getForObject(
        "https://example.com/hotels/{hotel}/rooms/{hotel}", String.class, vars);

请记住，URI 模板是自动编码的，如下例所示：spring-doc.cn

restTemplate.getForObject("https://example.com/hotel list", String.class);

// Results in request to "https://example.com/hotel%20list"

您可以使用的属性来自定义 URI 的方式进行编码。或者，您可以准备 a 并将其传递到接受 .uriTemplateHandlerRestTemplatejava.net.URIRestTemplateURIspring-doc.cn

有关使用 URI 和编码 URI 的更多详细信息，请参阅 URI 链接。spring-doc.cn

头

您可以使用这些方法指定请求标头，如下例所示：exchange()spring-doc.cn

String uriTemplate = "https://example.com/hotels/{hotel}";
URI uri = UriComponentsBuilder.fromUriString(uriTemplate).build(42);

RequestEntity<Void> requestEntity = RequestEntity.get(uri)
        .header(("MyRequestHeader", "MyValue")
        .build();

ResponseEntity<String> response = template.exchange(requestEntity, String.class);

String responseHeader = response.getHeaders().getFirst("MyResponseHeader");
String body = response.getBody();

您可以通过返回 .RestTemplateResponseEntityspring-doc.cn

身体

传入方法和从方法返回的对象将与原始对象相互转换 content 在 .RestTemplateHttpMessageConverterspring-doc.cn

在 POST 上，输入对象将序列化为请求正文，如下例所示：spring-doc.cn

URI location = template.postForLocation("https://example.com/people", person);

您无需显式设置请求的 Content-Type 标头。在大多数情况下，您可以根据源类型和所选的 Message Converter 会相应地设置内容类型。如有必要，您可以使用这些方法显式提供请求标头，并在 turn 影响选择的消息转换器。ObjectexchangeContent-Typespring-doc.cn

在 GET 上，响应的主体被反序列化为 output ，如下例所示：Objectspring-doc.cn

Person person = restTemplate.getForObject("https://example.com/people/{id}", Person.class, 42);

不需要显式设置请求的标头。在大多数情况下，可以根据预期的响应类型找到兼容的消息转换器，该然后帮助填充标题。如有必要，您可以使用这些方法显式提供标头。AcceptAcceptexchangeAcceptspring-doc.cn

默认情况下，注册所有内置的消息转换器，具体取决于有帮助的 Classpath 检查来确定存在哪些可选的转换库。您还可以设置消息转换器来显式使用。RestTemplatespring-doc.cn

消息转换

WebFlux的spring-doc.cn

该模块包含用于读取和通过和编写 HTTP 请求和响应的正文。实例在客户端使用（例如，在）和在服务器端（例如，在 Spring MVC REST 控制器中）。spring-webHttpMessageConverterInputStreamOutputStreamHttpMessageConverterRestTemplatespring-doc.cn

框架中提供了主媒体（MIME）类型的具体实现，并且默认情况下，分别在 Client 端和 Server 端注册（请参阅配置消息转换器）。RestTemplateRequestMethodHandlerAdapterspring-doc.cn

的实现在以下各节中介绍。对于所有转换器，都使用默认媒体类型，但您可以通过设置 bean 属性来覆盖它。下表描述了每种实现：HttpMessageConvertersupportedMediaTypesspring-doc.cn

表 2.HttpMessageConverter 实现
消息转换器	描述
`StringHttpMessageConverter`spring-doc.cn	可以从 HTTP 读取和写入实例的实现请求和响应。默认情况下，此转换器支持所有文本媒体类型（）并使用的 a 进行写入。`HttpMessageConverterStringtext/*Content-Typetext/plain`spring-doc.cn
`FormHttpMessageConverter`spring-doc.cn	可以从 HTTP 读取和写入表单数据的实现请求和响应。默认情况下，此转换器读取和写入媒体类型。表单数据从 .转换器还可以写入（但不能读取）multipart 从 .默认情况下，是支持。从 Spring Framework 5.2 开始，可以支持其他多部分子类型写入表单数据。有关更多详细信息，请参阅 javadoc。`HttpMessageConverterapplication/x-www-form-urlencodedMultiValueMap<String, String>MultiValueMap<String, Object>multipart/form-dataFormHttpMessageConverter`spring-doc.cn
`ByteArrayHttpMessageConverter`spring-doc.cn	可以从 HTTP 请求和响应。默认情况下，此转换器支持所有媒体类型（）并使用的 a 写入。您可以覆盖此通过设置属性并覆盖 .`HttpMessageConverter/Content-Typeapplication/octet-streamsupportedMediaTypesgetContentType(byte[])`spring-doc.cn
`MarshallingHttpMessageConverter`spring-doc.cn	可以使用 Spring 和包中的抽象来读取和写入 XML 的实现。此转换器需要 and 才能使用。您可以注入这些通过 constructor 或 bean 属性。默认情况下，此转换器支持和。`HttpMessageConverterMarshallerUnmarshallerorg.springframework.oxmMarshallerUnmarshallertext/xmlapplication/xml`spring-doc.cn
`MappingJackson2HttpMessageConverter`spring-doc.cn	可以使用 Jackson 的 .您可以根据需要使用 Jackson 的提供的注释。当您需要进一步控制时（对于自定义 JSON 需要为特定类型提供序列化器/反序列化器），你可以通过 property 注入自定义。默认情况下，此转换器支持 .`HttpMessageConverterObjectMapperObjectMapperObjectMapperapplication/json`spring-doc.cn
`MappingJackson2XmlHttpMessageConverter`spring-doc.cn	一种可以使用 Jackson XML 扩展的 .您可以根据需要通过使用 JAXB 来自定义 XML 映射或 Jackson 提供的注释。当您需要进一步控制时（对于自定义 XML 需要为特定类型提供序列化器/反序列化器），你可以通过 property 注入自定义。默认情况下，此转换器支持 .`HttpMessageConverterXmlMapperXmlMapperObjectMapperapplication/xml`spring-doc.cn
`SourceHttpMessageConverter`spring-doc.cn	可以从 HTTP 请求和响应中读取和写入的实现。仅支持、和。默认情况下，此转换器支持和。`HttpMessageConverterjavax.xml.transform.SourceDOMSourceSAXSourceStreamSourcetext/xmlapplication/xml`spring-doc.cn
`BufferedImageHttpMessageConverter`spring-doc.cn	可以从 HTTP 请求和响应中读取和写入的实现。此转换器读取并写入 Java I/O API 支持的媒体类型。`HttpMessageConverterjava.awt.image.BufferedImage`spring-doc.cn

Jackson JSON 视图

您可以指定 Jackson JSON 视图以仅序列化对象属性的子集，如下例所示：spring-doc.cn

MappingJacksonValue value = new MappingJacksonValue(new User("eric", "7!jd#h23"));
value.setSerializationView(User.WithoutPasswordView.class);

RequestEntity<MappingJacksonValue> requestEntity =
    RequestEntity.post(new URI("https://example.com/user")).body(value);

ResponseEntity<String> response = template.exchange(requestEntity, String.class);

多部分

要发送多部分数据，您需要提供其值可以是 for part 内容、for file part 或 for 带有标题的 part 内容。例如：MultiValueMap<String, Object>ObjectResourceHttpEntityspring-doc.cn

MultiValueMap<String, Object> parts = new LinkedMultiValueMap<>();

parts.add("fieldPart", "fieldValue");
parts.add("filePart", new FileSystemResource("...logo.png"));
parts.add("jsonPart", new Person("Jason"));

HttpHeaders headers = new HttpHeaders();
headers.setContentType(MediaType.APPLICATION_XML);
parts.add("xmlPart", new HttpEntity<>(myBean, headers));

在大多数情况下，您不必为每个部分指定。内容 type 根据选择要序列化的 it 或者，在 a 的情况下基于文件扩展名。如有必要，您可以显式提供 with 包装器。Content-TypeHttpMessageConverterResourceMediaTypeHttpEntityspring-doc.cn

一旦准备好了，你可以把它传递给，如下所示：MultiValueMapRestTemplatespring-doc.cn

MultiValueMap<String, Object> parts = ...;
template.postForObject("https://example.com/upload", parts, Void.class);

如果包含至少一个非值，则设置到由 .如果 has 值，则默认为。如有必要，也可以显式设置。MultiValueMapStringContent-Typemultipart/form-dataFormHttpMessageConverterMultiValueMapStringContent-Typeapplication/x-www-form-urlencodedContent-Typespring-doc.cn

1.8.2. 使用（已弃用）`AsyncRestTemplate`

已弃用。对于您可能考虑使用的所有用例，请改用 WebClient。AsyncRestTemplateAsyncRestTemplatespring-doc.cn

2. Enterprise JavaBeans （EJB）集成

作为轻量级容器， Spring 通常被认为是 EJB 的替代品。我们确实相信对于许多（如果不是大多数）应用程序和用例，Spring 作为容器相结合凭借其在事务、ORM 和 JDBC 访问领域的丰富支持功能，比通过 EJB 容器实现等效功能更好和 EJB 的spring-doc.cn

但是，请务必注意，使用 Spring 并不妨碍您使用 EJB。事实上， Spring 使访问 EJB 和实现 EJB 和功能变得更加容易在他们内部。此外，使用 Spring 访问 EJB 提供的服务允许实现这些服务，以便以后在本地 EJB 之间透明地切换，远程 EJB 或 POJO（普通旧 Java 对象）变体，而无需客户端代码被更改。spring-doc.cn

在本章中，我们将了解 Spring 如何帮助您访问和实现 EJB。Spring 在访问无状态会话 Bean （SLSB）时提供特定值，因此我们开始通过讨论这个话题。spring-doc.cn

2.1. 访问 EJB

本节介绍如何访问 EJB。spring-doc.cn

2.1.1. 概念

要在本地或远程无状态会话 Bean 上调用方法，客户端代码必须通常执行 JNDI 查找以获取（本地或远程）EJB 主对象，然后使用对该对象进行方法调用，以获取实际的（本地或远程）EJB 对象。然后在 EJB 上调用一个或多个方法。createspring-doc.cn

为了避免重复的低级代码，许多 EJB 应用程序使用 Service Locator 和业务代表模式。这些比在整个过程中喷涂 JNDI 查找要好 client 代码，但它们通常的实现有明显的缺点：spring-doc.cn

通常，使用 EJB 的代码取决于 Service Locator 或 Business Delegate 单例。使其难以测试。spring-doc.cn
如果使用 Service Locator 模式，则应用程序代码最终仍然必须在 EJB 主目录上调用该方法并处理生成的异常。因此，它仍然与 EJB API 相关联，并且 EJB 编程模型的复杂性。create()spring-doc.cn
实现 Business Delegate 模式通常会产生大量代码 duplication，其中我们必须编写许多调用相同方法的方法在 EJB 上。spring-doc.cn

Spring 的方法是允许创建和使用代理对象（通常配置在 Spring 容器中），它们充当无代码业务委托。你需要不要在一个手动编码的 Business Delegate，除非你真的在这样的代码中添加了真正的价值。spring-doc.cn

2.1.2. 访问本地 SLSB

假设我们有一个需要使用本地 EJB 的 Web 控制器。我们最好跟随实践并使用 EJB Business Methods Interface 模式，以便 EJB 的本地 interface 扩展了非特定于 EJB 的业务方法接口。我们称之为业务方法界面。以下示例显示了这样的接口：MyComponentspring-doc.cn

public interface MyComponent {
    ...
}

使用 Business Methods Interface 模式的主要原因之一是确保本地接口和 Bean 实现中的方法签名之间的同步类是自动的。另一个原因是它后来使我们更容易如果有意义，请切换到服务的 POJO（普通旧 Java 对象）实现执行此操作。我们还需要实现本地 home 接口，并提供一个 implementation 类实现和业务 methods 接口。现在，我们唯一需要做的 Java 编码来挂接我们的 Web 层 controller 添加到 EJB 实现中，就是在 controller 上公开一个 setter 类型的方法。这会将引用保存为控制器。以下示例显示了如何执行此操作：SessionBeanMyComponentMyComponentspring-doc.cn

private MyComponent myComponent;

public void setMyComponent(MyComponent myComponent) {
    this.myComponent = myComponent;
}

我们随后可以在控制器的任何业务方法中使用这个实例变量。现在，假设我们从 Spring 容器中获取控制器对象，我们可以（在同一上下文中）配置一个实例，它是 EJB 代理对象。我们配置代理并使用以下配置条目设置控制器的属性：LocalStatelessSessionProxyFactoryBeanmyComponentspring-doc.cn

<bean id="myComponent"
        class="org.springframework.ejb.access.LocalStatelessSessionProxyFactoryBean">
    <property name="jndiName" value="ejb/myBean"/>
    <property name="businessInterface" value="com.mycom.MyComponent"/>
</bean>

<bean id="myController" class="com.mycom.myController">
    <property name="myComponent" ref="myComponent"/>
</bean>

很多工作都在幕后进行，这要归功于 Spring AOP 框架。尽管您不必被迫使用 AOP 概念来享受结果。Bean 定义为 EJB 创建一个代理，该代理实现了 method 接口。EJB 本地主目录在启动时缓存，因此只有一个 JNDI 查找。每次调用 EJB 时，代理都会调用 local EJB 并在 EJB 上调用相应的业务方法。myComponentclassnamespring-doc.cn

Bean 定义设置控制器的属性类传递给 EJB 代理。myControllermyComponentspring-doc.cn

或者（最好在许多此类代理定义的情况下），考虑使用 Spring 的 “jee” 命名空间中的 configuration 元素。以下示例显示了如何执行此操作：<jee:local-slsb>spring-doc.cn

<jee:local-slsb id="myComponent" jndi-name="ejb/myBean"
        business-interface="com.mycom.MyComponent"/>

<bean id="myController" class="com.mycom.myController">
    <property name="myComponent" ref="myComponent"/>
</bean>

这种 EJB 访问机制极大地简化了应用程序代码。Web 层代码（或其他 EJB 客户端代码）不依赖于 EJB 的使用。自用 POJO 或 mock 对象或其他测试存根替换这个 EJB 引用，我们可以更改 bean 定义，而不更改一行 Java 代码。此外，我们不必编写任何一行 JNDI 查找或其他 EJB 管道代码作为我们应用程序的一部分。myComponentspring-doc.cn

基准测试和实际应用程序的经验表明，这种方法（涉及目标 EJB 的反射调用）是最小的，并且在典型使用中无法检测到。请记住，我们不想让无论如何，对 EJB 的细粒度调用，因为存在与 EJB 相关的成本基础结构。spring-doc.cn

关于 JNDI 查找，有一个警告。在 Bean 容器中，此类是通常最好用作 singleton （没有理由将其作为 prototype）。但是，如果该 Bean 容器预先实例化了单例（就像各种 XML 变体一样），那么如果加载了 Bean 容器，则可能会出现问题在 EJB 容器装入目标 EJB 之前。这是因为 JNDI 查找是在此类的方法中执行，然后缓存，但 EJB 没有已在目标位置绑定。解决方案是不要预先实例化 this Factory 对象，但让它在第一次使用时创建。在 XML 容器中，您可以对此进行控制通过使用 attribute.ApplicationContextinit()lazy-initspring-doc.cn

尽管大多数 Spring 用户对此不感兴趣，但那些使用 EJB 的编程 AOP 工作可能需要查看。LocalSlsbInvokerInterceptorspring-doc.cn

2.1.3. 访问远程 SLSB

访问远程 EJB 与访问本地 EJB 基本相同，只是 or 配置元素。当然，无论有没有 Spring，远程调用语义都适用：一个调用另一台计算机中另一个 VM 中的对象的方法有时必须在使用场景和故障处理方面受到不同的对待。SimpleRemoteStatelessSessionProxyFactoryBean<jee:remote-slsb>spring-doc.cn

Spring 的 EJB 客户端支持比非 Spring 方法增加了另一个优势。通常，EJB 客户端代码很容易来回切换是有问题的在本地或远程调用 EJB 之间。这是因为远程接口方法必须声明它们抛出，并且客户端代码必须处理这个，而本地接口方法则不需要。为需要移动到远程 EJB 时，通常必须修改以添加对远程异常，以及为需要移动到本地的远程 EJB 编写的客户端代码 EJB 可以保持不变，但对远程进行大量不必要的处理 exceptions 进行修改以删除该代码。使用 Spring 远程 EJB proxy，则不能在 Business Method 中声明 any thrown 接口和实现 EJB 代码具有相同的远程接口（除了它确实会抛出），并依赖 proxy 动态处理这两个接口，就好像它们是相同的一样。也就是说，客户端代码不必处理 checked 类。在 EJB 调用作为非检查类重新抛出，该类是的子类。然后，您可以随意切换目标服务在本地 EJB 或远程 EJB（甚至普通 Java 对象）实现之间，没有客户代码知道或关心。当然，这是可选的：Nothing 阻止您在业务界面中声明。RemoteExceptionRemoteExceptionRemoteExceptionRemoteExceptionRemoteExceptionRemoteAccessExceptionRuntimeExceptionRemoteExceptionspring-doc.cn

2.1.4. 访问 EJB 2.x SLSB 与 EJB 3 SLSB

通过 Spring 访问 EJB 2.x 会话 Bean 和 EJB 3 会话 Bean 主要是透明。Spring 的 EJB 访问器（包括 and 工具）在运行时透明地适应实际组件。如果找到，它们会处理 home 接口（EJB 2.x 样式）或执行直接组件如果没有可用的 Home 界面（EJB 3 样式），则调用<jee:local-slsb><jee:remote-slsb>spring-doc.cn

注意：对于 EJB 3 会话 Bean，您也可以有效地使用 /，因为完全可用的组件引用是为普通的 JNDI 查找。定义显式或查找可提供一致且更显式的 EJB 访问配置。JndiObjectFactoryBean<jee:jndi-lookup><jee:local-slsb><jee:remote-slsb>spring-doc.cn

3. JMS（Java 消息服务）

Spring 提供了一个 JMS 集成框架，该框架在很大程度上简化了 JMS API 的使用。与 Spring 对 JDBC API 的集成方式相同。spring-doc.cn

JMS 大致可以分为两个功能领域，即生产和消息的消费。该类用于消息生成，同步消息接收。对于类似于 Java EE 的消息驱动的 bean 样式，Spring 提供了许多消息侦听器容器，这些容器可用于创建消息驱动的 POJO （MDP）。Spring 还提供了一种声明性方式创建消息侦听器。JmsTemplatespring-doc.cn

该软件包提供了使用 JMS 的。它包含 JMS 模板类，这些类通过处理创建和释放资源，与 JDBC 非常相似。这 Spring 模板类的共同设计原则是提供辅助方法，以执行常见操作，对于更复杂的用法，委托处理任务分配给用户实现的回调接口。JMS 模板遵循相同的设计。这些类提供了各种方便的方法来发送消息，同步使用消息，并将 JMS 会话和消息生成者公开给用户。org.springframework.jms.coreJdbcTemplatespring-doc.cn

该软件包提供翻译功能性。转换会将选中的层次结构转换为未检查异常的镜像层次结构。如果任何特定于提供程序的子类中，此异常包装在猖獗。org.springframework.jms.supportJMSExceptionJMSExceptionjavax.jms.JMSExceptionUncategorizedJmsExceptionspring-doc.cn

该软件包提供了一个抽象，用于在 Java 对象和 JMS 消息之间进行转换。org.springframework.jms.support.converterMessageConverterspring-doc.cn

该软件包提供了各种策略用于管理 JMS 目标，例如为目标提供服务定位器存储在 JNDI 中。org.springframework.jms.support.destinationspring-doc.cn

该软件包提供了必要的基础设施通过使用 .org.springframework.jms.annotation@JmsListenerspring-doc.cn

该软件包为命名空间提供了解析器实现，以及用于配置侦听器容器和创建侦听器终端节点。org.springframework.jms.configjmsspring-doc.cn

最后，该软件包提供了适合在独立应用程序中使用。它还包含一个 Spring 的 JMS 实现（巧妙地命名为）。这允许将 JMS 无缝集成为事务资源导入到 Spring 的事务管理机制中。org.springframework.jms.connectionConnectionFactoryPlatformTransactionManagerJmsTransactionManagerspring-doc.cn

从 Spring Framework 5 开始，Spring 的 JMS 包完全支持 JMS 2.0，并且需要 JMS 2.0 API 的运行。我们建议使用与 JMS 2.0 兼容的提供程序。spring-doc.cn

如果您碰巧在系统中使用了较旧的消息代理，则可以尝试升级到适用于现有代理代的 JMS 2.0 兼容驱动程序。或者，您也可以尝试针对基于 JMS 1.1 的驱动程序运行，只需将 JMS 2.0 API jar 放在 classpath 的 API 中，但仅使用与 JMS 1.1 兼容的 API 来对付您的驱动程序。Spring 的 JMS 支持默认情况下遵循 JMS 1.1 约定，因此使用相应的配置时，它确实支持这样的场景。但是，请仅针对过渡方案考虑这一点。spring-doc.cn

3.1. 使用 Spring JMS

本节介绍如何使用 Spring 的 JMS 组件。spring-doc.cn

3.1.1. 使用`JmsTemplate`

该类是 JMS 核心包中的中心类。它简化了使用 JMS，因为它在发送或同步接收消息。JmsTemplatespring-doc.cn

使用 the 的代码只需要实现提供它们的回调接口明确定义的高级合同。回调接口会创建一个消息。自允许对 JMS API 进行更复杂的使用，提供 JMS 会话，并公开 and 对。JmsTemplateMessageCreatorSessionJmsTemplateSessionCallbackProducerCallbackSessionMessageProducerspring-doc.cn

JMS API 公开了两种类型的 send 方法，一种采用 delivery mode、priority 和和 time to live 作为服务质量（QOS）参数，并且不采用 QOS 参数并使用默认值。由于 send 方法很多，设置 QOS 参数已作为 Bean 属性公开给避免 send 方法的数量重复。同样，的同步接收调用是使用 property 设置的。JmsTemplatesetReceiveTimeoutspring-doc.cn

某些 JMS 提供程序允许通过的配置 .这具有对实例的 method （）的调用使用的 QOS 默认值与 JMS 规范中指定的值不同。挨次因此，为了提供对 QOS 值的一致管理，必须通过将 boolean 属性设置为 .ConnectionFactoryMessageProducersendsend(Destination destination, Message message)JmsTemplateisExplicitQosEnabledtruespring-doc.cn

为方便起见，还公开了一个基本的请求-回复操作，该操作允许发送消息并等待临时队列的回复，该队列是作为的一部分创建的操作。JmsTemplatespring-doc.cn

类的实例一旦配置，就是线程安全的。这是重要，因为这意味着您可以配置单个 A 实例，然后将此共享引用安全地注入多个协作者。成为 clear，它是有状态的，因为它维护对 a 的引用，但此状态不是会话状态。JmsTemplateJmsTemplateJmsTemplateConnectionFactory

从 Spring Framework 4.1 开始，它构建在消息传递抽象之上并提供与消息传递抽象的集成，即 .这样，您就可以将消息创建到以通用方式发送。JmsMessagingTemplateJmsTemplateorg.springframework.messaging.Messagespring-doc.cn

3.1.2. 连接

这需要对 .它是 JMS 规范的一部分，用作使用 JMS 的入口点。它被客户端应用程序用作工厂来创建与 JMS 的连接 provider 并封装各种配置参数，其中许多是特定于供应商的，例如 SSL 配置选项。JmsTemplateConnectionFactoryConnectionFactoryspring-doc.cn

在 EJB 中使用 JMS 时，供应商提供 JMS 接口的实现以便它们可以参与声明式事务管理并执行池化连接和会话。为了使用此实现，Java EE 容器通常要求您将 JMS 连接工厂声明为 inside EJB 或 Servlet 部署描述符。为了确保在 EJB 内部使用这些功能，客户端应用程序应确保它引用的 managed 实现。resource-refJmsTemplateConnectionFactoryspring-doc.cn

缓存消息收发资源

标准 API 涉及创建许多中间对象。要发送消息，执行以下 'API' 遍历：spring-doc.cn

ConnectionFactory->Connection->Session->MessageProducer->send

在和操作之间，三个中间对象被创建和销毁。优化资源使用并提高性能，Spring 提供了 .ConnectionFactorySendConnectionFactoryspring-doc.cn

用`SingleConnectionFactory`

Spring 提供了接口的实现，该接口在所有调用中返回相同的值，并忽略对 .这对于测试和独立环境，以便同一连接可用于可能跨越任意数量的事务的多个调用。引用通常来自 JNDI 的标准。ConnectionFactorySingleConnectionFactoryConnectioncreateConnection()close()JmsTemplateSingleConnectionFactoryConnectionFactoryspring-doc.cn

用`CachingConnectionFactory`

扩展了、和实例的功能并添加了、和实例的缓存。初始缓存大小设置为。您可以使用该属性来增加 cached sessions 的 Sessions 中。请注意，实际缓存的会话数不止于此 number，因为会话是根据其确认模式缓存的，因此最多可以有四个缓存的会话实例（每个 1 个确认模式）设置为 1 时。实例缓存在其拥有会话，并考虑生产者的独特属性和 consumers 的 Consumers 进行缓存。MessageProducers 根据其目标进行缓存。 MessageConsumers 基于由目标、选择器、 noLocal delivery 标志和持久订阅名称（如果创建持久使用者）。CachingConnectionFactorySingleConnectionFactorySessionMessageProducerMessageConsumer1sessionCacheSizesessionCacheSizeMessageProducerMessageConsumerspring-doc.cn

3.1.3. 目的地管理

作为实例，目标是可以存储的 JMS 管理对象并在 JNDI 中检索。在配置 Spring 应用程序上下文时，您可以使用 JNDI 工厂类或执行依赖项注入对象对 JMS 目标的引用。但是，此策略如果应用程序中有大量目标，或者存在是 JMS 提供程序独有的高级目标管理功能。示例此类高级目标管理包括创建动态目标或支持目标的分层命名空间。委托将目标名称解析为实现接口的 JMS 目标对象。是默认值 implementation used by and accommodate 解析动态目标。还提供了 A 作为 destinations 包含在 JNDI 中，并且可以选择回退到 .ConnectionFactoryJndiObjectFactoryBean<jee:jndi-lookup>JmsTemplateDestinationResolverDynamicDestinationResolverJmsTemplateJndiDestinationResolverDynamicDestinationResolverspring-doc.cn

通常，JMS 应用程序中使用的目的地仅在运行时才知道，并且因此，在部署应用程序时无法以管理方式创建。这是通常是因为交互的系统组件之间存在共享的应用程序逻辑，它们根据众所周知的命名约定在运行时创建目标。甚至尽管创建动态目标不是 JMS 规范的一部分，但大多数供应商已提供此功能。动态目标是使用用户定义的名称创建的。这使它们与临时目的地区分开来，并且通常是未在 JNDI 中注册。用于创建动态目标的 API 因提供商而异 to provider，因为与目标关联的属性是特定于供应商的。但是，供应商有时会做出一个简单的实现选择，即忽略 JMS 规范中的警告，并使用 method 或 method 创建具有 default destination 属性的新目标。取决于在 vendor 实现上，还可以创建一个 physical destination 而不是仅解析一个。TopicSessioncreateTopic(String topicName)QueueSessioncreateQueue(String queueName)DynamicDestinationResolverspring-doc.cn

boolean 属性用于配置了解正在使用的 JMS 域。默认情况下，此属性的值为 false，则表示使用点对点域。此属性（使用者）通过以下方式确定动态目标解析的行为接口的实现。pubSubDomainJmsTemplateQueuesJmsTemplateDestinationResolverspring-doc.cn

您还可以通过财产。默认目标是发送和接收不引用特定目标的操作。JmsTemplatedefaultDestinationspring-doc.cn

3.1.4. 消息侦听器容器

在 EJB 世界中，JMS 消息最常见的用途之一是驱动消息驱动的 Beans （MDB）。Spring 提供了一种解决方案，以某种方式创建消息驱动的 POJO （MDP）不会将用户绑定到 EJB 容器。（有关详细信息，请参阅异步接收：消息驱动的 POJO Spring 的 MDP 支持覆盖率。从 Spring Framework 4.1 开始，端点方法可以 annotated with — 有关更多详细信息，请参阅 Annotation-driven Listener Endpoints。@JmsListenerspring-doc.cn

消息侦听器容器用于从 JMS 消息队列接收消息，并且驱动注入其中的 That。侦听器容器是负责将消息接收和 dispatch 的所有线程处理到侦听器中加工。消息侦听器容器是 MDP 和消息传递提供商，并负责注册以接收消息、参与事务、资源获取和释放、异常转换等。这允许您编写（可能很复杂的）业务逻辑与接收消息（并可能响应消息）相关联，并委托框架的样板 JMS 基础设施问题。MessageListenerspring-doc.cn

有两个与 Spring 打包在一起的标准 JMS 消息侦听器容器，每个容器都带有它的专业功能集。spring-doc.cn

用`SimpleMessageListenerContainer`

此消息侦听器容器是两种标准风格中较简单的一种。它创建启动时固定数量的 JMS 会话和使用者，使用标准 JMS 方法，并将其留给 JMS provider 执行侦听器回调。此变体不允许动态适应运行时需求或参与外部管理的事务。在兼容性方面，它非常接近独立 JMS 的精神规范，但通常与 Java EE 的 JMS 限制不兼容。MessageConsumer.setMessageListener()spring-doc.cn

虽然不允许外部参与 managed transactions，它确实支持本机 JMS 事务。要启用此功能，您可以将标志切换到 XML，或者在 XML 命名空间中将属性设置为。从侦听器引发的异常然后引导进行回滚，并重新传递消息。或者，考虑使用 mode，它在出现异常时也提供重新传递，但不使用事务处理实例，因此，在事务协议中不包括任何其他操作（例如发送响应消息）。SimpleMessageListenerContainersessionTransactedtrueacknowledgetransactedCLIENT_ACKNOWLEDGESessionSession

默认模式不提供适当的可靠性保证。当侦听器执行失败时，消息可能会丢失（因为提供程序会自动在侦听器调用后确认每条消息，没有要传播到的异常提供程序）或侦听器容器关闭时（您可以通过设置标志）。请确保在以下情况下使用事务处理会话可靠性需求（例如，用于可靠的队列处理和持久主题订阅）。AUTO_ACKNOWLEDGEacceptMessagesWhileStopping

用`DefaultMessageListenerContainer`

此消息侦听器容器在大多数情况下使用。与相反，此容器变体允许动态适应满足运行时需求，并能够参与外部管理的事务。当配置了 .因此，处理可能会利用 XA 事务语义学。这个侦听器容器在 JMS 提供程序、高级功能（例如参与外部管理的事务）以及与 Java EE 环境的兼容性。SimpleMessageListenerContainerJtaTransactionManagerspring-doc.cn

您可以自定义容器的缓存级别。请注意，当未启用缓存时，将为每个消息接收创建一个新连接和一个新会话。结合这个对于具有高负载的非持久订阅，可能会导致消息丢失。请确保在这种情况下，请使用适当的缓存级别。spring-doc.cn

当代理出现故障时，此容器还具有可恢复功能。默认情况下，简单实现每 5 秒重试一次。您可以指定用于更精细恢复选项的自定义实现。看 api-spring-framework/util/backoff/ExponentialBackOff.html[] 作为示例。BackOffBackOffExponentialBackOffspring-doc.cn

与它的兄弟姐妹（SimpleMessageListenerContainer）一样，支持原生 JMS 事务并允许自定义 acknowledgment 模式。如果对您的方案可行，则 This is strongly 推荐而不是外部管理的交易 — 也就是说，如果您能忍受在 JVM 死亡的情况下偶尔出现重复消息。自定义重复消息业务逻辑中的检测步骤可以涵盖此类情况 — 例如，以业务实体存在检查或协议表检查的形式。任何此类安排都比替代方案更有效：使用 XA 事务包装整个处理（通过使用配置）以覆盖接收 JMS 消息以及在您的消息侦听器（包括数据库操作等）。DefaultMessageListenerContainerDefaultMessageListenerContainerJtaTransactionManager

3.1.5. 事务管理

Spring 提供了一个 Management 单个 JMS 的事务。这允许 JMS 应用程序利用托管事务 Spring 的功能，如 Data Access 一章的 Transaction Management 部分所述。执行本地资源事务，绑定 JMS 从指定到线程的 Connection/Session 对。自动检测此类事务性资源并运行相应地对他们。JmsTransactionManagerConnectionFactoryJmsTransactionManagerConnectionFactoryJmsTemplatespring-doc.cn

在 Java EE 环境中，池 Connection 和 Session 实例因此，这些资源可以在事务中有效地重用。在独立环境中，在共享的 JMS 中使用 Spring 的结果，其中每个事务都有自己独立的 .或者，考虑使用特定于提供程序的池适配器，例如 ActiveMQ 的类。ConnectionFactorySingleConnectionFactoryConnectionSessionPooledConnectionFactoryspring-doc.cn

您还可以与支持 XA 的 JMS 一起使用来执行分布式事务。请注意，这需要使用 JTA 事务管理器以及正确配置的 XA ConnectionFactory。（请查看 Java EE 服务器或 JMS 提供程序的文档。JmsTemplateJtaTransactionManagerConnectionFactoryspring-doc.cn

在托管和非托管事务环境中重用代码可能会令人困惑使用 JMS API 从 .这是因为 JMS API 只有一个工厂方法来创建一个，并且它需要 transaction 和 acknowledgment 模式。在托管环境中，设置这些值为环境的事务性基础设施的责任，因此这些值被供应商的 JMS Connection 包装器忽略。在非托管环境中使用时，可以通过使用 properties 和 .当您使用 with 时，模板始终会得到一个事务性 JMS 。SessionConnectionSessionJmsTemplatesessionTransactedsessionAcknowledgeModePlatformTransactionManagerJmsTemplateSessionspring-doc.cn

3.2. 发送消息

这包含许多发送消息的便捷方法。发送 methods 使用对象指定目的地，其他通过在 JNDI 查找中使用来指定目标。方法，则不设 destination 参数使用默认 destination。JmsTemplatejavax.jms.DestinationStringsendspring-doc.cn

以下示例使用回调从提供的对象：MessageCreatorSessionspring-doc.cn

import javax.jms.ConnectionFactory;
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.Queue;
import javax.jms.Session;

import org.springframework.jms.core.MessageCreator;
import org.springframework.jms.core.JmsTemplate;

public class JmsQueueSender {

    private JmsTemplate jmsTemplate;
    private Queue queue;

    public void setConnectionFactory(ConnectionFactory cf) {
        this.jmsTemplate = new JmsTemplate(cf);
    }

    public void setQueue(Queue queue) {
        this.queue = queue;
    }

    public void simpleSend() {
        this.jmsTemplate.send(this.queue, new MessageCreator() {
            public Message createMessage(Session session) throws JMSException {
                return session.createTextMessage("hello queue world");
            }
        });
    }
}

在前面的示例中， the 是通过传递对 .作为替代方案，提供了一个零参数构造函数 and，可用于在 JavaBean 样式（使用或纯 Java 代码）。或者，考虑派生自 Spring 的 convenience 基类，该基类提供用于 JMS 配置的预构建 Bean 属性。JmsTemplateConnectionFactoryconnectionFactoryBeanFactoryJmsGatewaySupportspring-doc.cn

该方法允许您发送 message 使用目标的字符串名称。如果这些名称已在 JNDI 中注册，则您应该将模板的属性设置为 .send(String destinationName, MessageCreator creator)destinationResolverJndiDestinationResolverspring-doc.cn

如果您创建并指定了默认目标，则会向该目标发送消息。JmsTemplatesend(MessageCreator c)spring-doc.cn

3.2.1. 使用消息转换器

为了方便发送域模型对象，具有各种 send 方法，这些方法将 Java 对象作为消息数据的参数内容。中的重载方法和方法将转换过程委托给接口的实例。此接口定义了一个简单的协定，用于在 Java 对象和 JMS 消息。默认实现（）支持转换介于和、和、和之间。通过使用转换器，您和您的应用程序代码可以专注于业务对象，而不关心有关如何将其表示为 JMS 消息的详细信息。JmsTemplateconvertAndSend()receiveAndConvert()JmsTemplateMessageConverterSimpleMessageConverterStringTextMessagebyte[]BytesMesssagejava.util.MapMapMessagespring-doc.cn

沙箱当前包括一个，它使用反射来转换在 JavaBean 和 .您可能的其他常用实施选择实现自己的方法是使用现有 XML 封送包（例如 JAXB 或 XStream）创建表示对象的 API。MapMessageConverterMapMessageTextMessagespring-doc.cn

为了适应消息的属性、标头和正文的设置，这些设置不能是通常封装在 Converter 类中，接口允许您在消息转换之后但在发送之前访问消息。这以下示例演示如何在将 a 转换为 Message 后修改 Message 标头和属性：MessagePostProcessorjava.util.Mapspring-doc.cn

public void sendWithConversion() {
    Map map = new HashMap();
    map.put("Name", "Mark");
    map.put("Age", new Integer(47));
    jmsTemplate.convertAndSend("testQueue", map, new MessagePostProcessor() {
        public Message postProcessMessage(Message message) throws JMSException {
            message.setIntProperty("AccountID", 1234);
            message.setJMSCorrelationID("123-00001");
            return message;
        }
    });
}

这将生成以下形式的消息：spring-doc.cn

MapMessage={
    Header={
        ... standard headers ...
        CorrelationID={123-00001}
    }
    Properties={
        AccountID={Integer:1234}
    }
    Fields={
        Name={String:Mark}
        Age={Integer:47}
    }
}

3.2.2. 使用和`SessionCallbackProducerCallback`

虽然 send 操作涵盖了许多常见的使用场景，但有时您可能会想要对 JMS 执行多个操作或 .和分别公开 JMS 和 / 对。运行的方法这些回调方法。SessionMessageProducerSessionCallbackProducerCallbackSessionSessionMessageProducerexecute()JmsTemplatespring-doc.cn

3.3. 接收消息

这描述了如何在 Spring 中使用 JMS 接收消息。spring-doc.cn

3.3.1. 同步接收

虽然 JMS 通常与异步处理相关联，但您可以同步消费消息。重载方法提供了这个功能性。在同步接收期间，调用线程会阻塞，直到出现一条消息变为可用。这可能是一个危险的操作，因为调用线程可以可能会无限期阻止。该属性指定多长时间接收方应该在放弃等待消息之前等待。receive(..)receiveTimeoutspring-doc.cn

3.3.2. 异步接收：消息驱动的 POJO

Spring 还通过使用 Comments 来支持 annotated-listener 端点，并提供了一个开放的基础设施来以编程方式注册端点。到目前为止，这是设置 asynchronous receiver 最方便的方法。有关更多详细信息，请参阅启用侦听器终端节点注释。@JmsListener

与EJB世界中的消息驱动Bean （MDB）类似，消息驱动的 POJO （MDP）充当 JMS 消息的接收方。MDP 上的一个限制（但请参阅使用 MessageListenerAdapter）是它必须实现界面。请注意，如果您的 POJO 收到消息在多个线程上，确保您的实现是线程安全的非常重要。javax.jms.MessageListenerspring-doc.cn

以下示例显示了 MDP 的简单实现：spring-doc.cn

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.TextMessage;

public class ExampleListener implements MessageListener {

    public void onMessage(Message message) {
        if (message instanceof TextMessage) {
            try {
                System.out.println(((TextMessage) message).getText());
            }
            catch (JMSException ex) {
                throw new RuntimeException(ex);
            }
        }
        else {
            throw new IllegalArgumentException("Message must be of type TextMessage");
        }
    }
}

实现后，就可以创建消息侦听器容器。MessageListenerspring-doc.cn

以下示例说明如何定义和配置其中一个消息侦听器随 Spring 一起提供的容器（在本例中为）：DefaultMessageListenerContainerspring-doc.cn

<!-- this is the Message Driven POJO (MDP) -->
<bean id="messageListener" class="jmsexample.ExampleListener"/>

<!-- and this is the message listener container -->
<bean id="jmsContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
    <property name="connectionFactory" ref="connectionFactory"/>
    <property name="destination" ref="destination"/>
    <property name="messageListener" ref="messageListener"/>
</bean>

请参阅各种消息侦听器容器（所有这些容器都实现了MessageListenerContainer）的 Spring javadoc ，了解每种实施所支持的功能的完整描述。spring-doc.cn

3.3.3. 使用界面`SessionAwareMessageListener`

该接口是特定于 Spring 的接口，它提供与 JMS 接口类似的契约，但也提供了消息处理方法访问从中接收的 JMS。下面的清单显示了接口的定义：SessionAwareMessageListenerMessageListenerSessionMessageSessionAwareMessageListenerspring-doc.cn

package org.springframework.jms.listener;

public interface SessionAwareMessageListener {

    void onMessage(Message message, Session session) throws JMSException;
}

您可以选择让您的 MDP 实现此接口（优先于标准 JMS 接口），如果您希望 MDP 能够响应任何 received messages （通过使用方法中提供的）。Spring 附带的所有消息侦听器容器实现支持实现 OR 接口的 MDP。实现 the 的类需要注意的是，它们随后会绑定到 Spring 通过界面。是否使用它的选择完全取决于您作为应用程序开发人员或架构师。MessageListenerSessiononMessage(Message, Session)MessageListenerSessionAwareMessageListenerSessionAwareMessageListenerspring-doc.cn

请注意，接口的方法会引发 .与标准 JMS 接口相比，使用该接口时，它是客户端代码负责处理任何引发的异常。onMessage(..)SessionAwareMessageListenerJMSExceptionMessageListenerSessionAwareMessageListenerspring-doc.cn

3.3.4. 使用`MessageListenerAdapter`

该类是 Spring 的 asynchronous 中的最后一个组件消息支持。简而言之，它允许您将几乎任何类公开为 MDP （尽管有一些限制）。MessageListenerAdapterspring-doc.cn

请考虑以下接口定义：spring-doc.cn

public interface MessageDelegate {

    void handleMessage(String message);

    void handleMessage(Map message);

    void handleMessage(byte[] message);

    void handleMessage(Serializable message);
}

请注意，尽管该接口既不扩展 the 也不扩展 interface，但您仍然可以通过使用类将其用作 MDP。还要注意各种消息处理方法的根据他们可以的各种类型的内容进行强类型接收和处理。MessageListenerSessionAwareMessageListenerMessageListenerAdapterMessagespring-doc.cn

现在考虑接口的以下实现：MessageDelegatespring-doc.cn

public class DefaultMessageDelegate implements MessageDelegate {
    // implementation elided for clarity...
}

特别要注意的是，前面的接口实现（类）根本没有 JMS 依赖项。它确实是一个 POJO 中，我们可以通过以下配置将其制作成 MDP：MessageDelegateDefaultMessageDelegatespring-doc.cn

<!-- this is the Message Driven POJO (MDP) -->
<bean id="messageListener" class="org.springframework.jms.listener.adapter.MessageListenerAdapter">
    <constructor-arg>
        <bean class="jmsexample.DefaultMessageDelegate"/>
    </constructor-arg>
</bean>

<!-- and this is the message listener container... -->
<bean id="jmsContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
    <property name="connectionFactory" ref="connectionFactory"/>
    <property name="destination" ref="destination"/>
    <property name="messageListener" ref="messageListener"/>
</bean>

下一个示例显示了另一个只能处理接收 JMS 消息的 MDP。请注意消息处理方法的实际调用方式（消息处理方法的名称默认为），但它是可配置的（如本节后面所示）。通知以及如何对方法进行强类型化以仅接收和响应 JMS 消息。下面的清单显示了接口的定义：TextMessagereceiveMessageListenerAdapterhandleMessagereceive(..)TextMessageTextMessageDelegatespring-doc.cn

public interface TextMessageDelegate {

    void receive(TextMessage message);
}

下面的清单显示了实现该接口的类：TextMessageDelegatespring-doc.cn

public class DefaultTextMessageDelegate implements TextMessageDelegate {
    // implementation elided for clarity...
}

然后，attendant 的配置将如下所示：MessageListenerAdapterspring-doc.cn

<bean id="messageListener" class="org.springframework.jms.listener.adapter.MessageListenerAdapter">
    <constructor-arg>
        <bean class="jmsexample.DefaultTextMessageDelegate"/>
    </constructor-arg>
    <property name="defaultListenerMethod" value="receive"/>
    <!-- we don't want automatic message context extraction -->
    <property name="messageConverter">
        <null/>
    </property>
</bean>

请注意，如果接收到类型为除了之外，还会抛出 an （然后吞下）。该类的另一个功能是能够在处理程序方法返回 non-void 值。请考虑以下接口和类：messageListenerMessageTextMessageIllegalStateExceptionMessageListenerAdapterMessagespring-doc.cn

public interface ResponsiveTextMessageDelegate {

    // notice the return type...
    String receive(TextMessage message);
}

public class DefaultResponsiveTextMessageDelegate implements ResponsiveTextMessageDelegate {
    // implementation elided for clarity...
}

如果将与结合使用，则从执行该方法（在默认配置中）转换为 .然后，结果将发送到（如果一个存在）定义在原始 API 的 JMS 属性中定义，或者 default set on （如果已配置）。如果未找到，则抛出（请注意，此异常不会被吞噬，而是会向上传播 call 堆栈）。DefaultResponsiveTextMessageDelegateMessageListenerAdapter'receive(..)'TextMessageTextMessageDestinationReply-ToMessageDestinationMessageListenerAdapterDestinationInvalidDestinationExceptionspring-doc.cn

3.3.5. 在 Transactions 中处理消息

在事务中调用消息侦听器只需要重新配置 listener 容器。spring-doc.cn

您可以通过标志激活本地资源事务在侦听器容器定义上。然后，每个消息侦听器调用都会运行在活动的 JMS 事务中，如果侦听器，则回滚消息接收执行失败。发送响应消息（通过）是部分，但任何其他资源操作（例如数据库访问）独立运行。这通常需要重复的消息 detection 来覆盖数据库处理已提交，但消息处理无法提交。sessionTransactedSessionAwareMessageListenerspring-doc.cn

考虑以下 bean 定义：spring-doc.cn

<bean id="jmsContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
    <property name="connectionFactory" ref="connectionFactory"/>
    <property name="destination" ref="destination"/>
    <property name="messageListener" ref="messageListener"/>
    <property name="sessionTransacted" value="true"/>
</bean>

要参与外部管理的事务，您需要配置事务管理器，并使用支持外部管理的侦听器容器 transactions （通常为）。DefaultMessageListenerContainerspring-doc.cn

要为 XA 事务参与配置消息侦听器容器，您需要配置一个（默认情况下，委托给 Java EE 服务器的事务子系统）。请注意，底层 JMS 需要支持 XA 并已正确注册到 JTA 事务协调器。（检查您的 Java EE 服务器的 JNDI 资源的配置。这也允许消息接收因为（例如）数据库访问是同一事务的一部分（使用统一提交语义，但代价是 XA 事务日志开销）。JtaTransactionManagerConnectionFactoryspring-doc.cn

以下 bean 定义创建一个事务管理器：spring-doc.cn

<bean id="transactionManager" class="org.springframework.transaction.jta.JtaTransactionManager"/>

然后我们需要将其添加到我们之前的容器配置中。容器负责其余的事情。以下示例显示了如何执行此操作：spring-doc.cn

<bean id="jmsContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
    <property name="connectionFactory" ref="connectionFactory"/>
    <property name="destination" ref="destination"/>
    <property name="messageListener" ref="messageListener"/>
    <property name="transactionManager" ref="transactionManager"/> (1)
</bean>

我们的交易管理器。

3.4. 支持 JCA 消息端点

从版本 2.5 开始， Spring 还提供了对基于 JCA 的容器的支持。尝试从提供程序的类名中自动确定类名。因此，通常可以提供 Spring 的 generic ，如下例所示：MessageListenerJmsMessageEndpointManagerActivationSpecResourceAdapterJmsActivationSpecConfigspring-doc.cn

<bean class="org.springframework.jms.listener.endpoint.JmsMessageEndpointManager">
    <property name="resourceAdapter" ref="resourceAdapter"/>
    <property name="activationSpecConfig">
        <bean class="org.springframework.jms.listener.endpoint.JmsActivationSpecConfig">
            <property name="destinationName" value="myQueue"/>
        </bean>
    </property>
    <property name="messageListener" ref="myMessageListener"/>
</bean>

或者，您也可以使用给定对象设置 a。该对象也可能来自 JNDI 查找（使用）。以下示例显示了如何执行此操作：JmsMessageEndpointManagerActivationSpecActivationSpec<jee:jndi-lookup>spring-doc.cn

<bean class="org.springframework.jms.listener.endpoint.JmsMessageEndpointManager">
    <property name="resourceAdapter" ref="resourceAdapter"/>
    <property name="activationSpec">
        <bean class="org.apache.activemq.ra.ActiveMQActivationSpec">
            <property name="destination" value="myQueue"/>
            <property name="destinationType" value="javax.jms.Queue"/>
        </bean>
    </property>
    <property name="messageListener" ref="myMessageListener"/>
</bean>

使用 Spring 的，您可以在本地配置目标，如下例所示：ResourceAdapterFactoryBeanResourceAdapterspring-doc.cn

<bean id="resourceAdapter" class="org.springframework.jca.support.ResourceAdapterFactoryBean">
    <property name="resourceAdapter">
        <bean class="org.apache.activemq.ra.ActiveMQResourceAdapter">
            <property name="serverUrl" value="tcp://localhost:61616"/>
        </bean>
    </property>
    <property name="workManager">
        <bean class="org.springframework.jca.work.SimpleTaskWorkManager"/>
    </property>
</bean>

specified 还可以指向特定于环境的线程池 — 通常通过实例的属性。考虑为所有实例定义共享线程池（如果您碰巧使用多个适配器。WorkManagerSimpleTaskWorkManagerasyncTaskExecutorResourceAdapterspring-doc.cn

在某些环境（例如 WebLogic 9 或更高版本）中，您可以改为获取整个对象来自 JNDI（通过使用）。基于 Spring 的消息然后，侦听器可以与 server-hosted 进行交互，后者也使用服务器的内置 .ResourceAdapter<jee:jndi-lookup>ResourceAdapterWorkManagerspring-doc.cn

参见JmsMessageEndpointManager的 javadoc，JmsActivationSpecConfig，和 ResourceAdapterFactoryBean 了解更多详细信息。spring-doc.cn

Spring 还提供了一个不绑定到 JMS 的通用 JCA 消息端点管理器：。此组件允许使用任何消息侦听器类型（例如 CCI ）和任何提供程序特定的对象。请参阅 JCA 提供商的文档，以便了解连接器的实际功能，并参阅GenericMessageEndpointManager javadoc以了解特定于 Spring 的配置详细信息。org.springframework.jca.endpoint.GenericMessageEndpointManagerMessageListenerActivationSpecspring-doc.cn

基于 JCA 的消息端点管理与 EJB 2.1 消息驱动的 Bean 非常相似。它使用相同的基础资源提供程序协定。与 EJB 2.1 MDB 一样，您可以使用任何消息侦听器接口，您的 JCA 提供程序在 Spring 上下文中也支持。尽管如此，Spring 还是为 JMS 提供了明确的 “便利” 支持，因为 JMS 是与 JCA Endpoint Management 合同一起使用的最常见端点 API。

3.5. 注解驱动的侦听器端点

异步接收消息的最简单方法是使用带 Comments 的侦听器端点基础设施。简而言之，它允许您公开托管 bean 作为 JMS 侦听器端点。以下示例演示如何使用它：spring-doc.cn

@Component
public class MyService {

    @JmsListener(destination = "myDestination")
    public void processOrder(String data) { ... }
}

前面示例的思路是，只要上有消息可用，就会调用该方法因此（在本例中，使用 JMS 消息的内容，类似于 MessageListenerAdapter 提供的内容）。javax.jms.DestinationmyDestinationprocessOrderspring-doc.cn

带注释的终端节点基础设施会创建一个消息侦听器容器每个带注释的方法的幕后，通过使用 . 这样的容器不是针对应用程序上下文注册的，但可以很容易地使用 Bean 进行管理。JmsListenerContainerFactoryJmsListenerEndpointRegistryspring-doc.cn

@JmsListener是 Java 8 上的可重复注释，因此您可以将多个 JMS 目标。@JmsListener

3.5.1. 启用 Listener 端点注解

要启用对注释的支持，您可以添加到以下您的类，如下例所示：@JmsListener@EnableJms@Configurationspring-doc.cn

@Configuration
@EnableJms
public class AppConfig {

    @Bean
    public DefaultJmsListenerContainerFactory jmsListenerContainerFactory() {
        DefaultJmsListenerContainerFactory factory = new DefaultJmsListenerContainerFactory();
        factory.setConnectionFactory(connectionFactory());
        factory.setDestinationResolver(destinationResolver());
        factory.setSessionTransacted(true);
        factory.setConcurrency("3-10");
        return factory;
    }
}

默认情况下，基础结构会查找名为 Bean 的 Bean，作为工厂的源，以用于创建消息侦听器容器。在这个的情况下（并忽略 JMS 基础设施设置），您可以调用核心轮询大小为 3 个线程且最大池大小为 10 个线程的方法。jmsListenerContainerFactoryprocessOrderspring-doc.cn

您可以自定义侦听器容器工厂以用于每个注释，也可以通过实现接口来配置显式默认值。仅当至少注册了一个端点而没有特定的集装箱工厂。有关详细信息和示例，请参阅实现JmsListenerConfigurer的类的 javadoc。JmsListenerConfigurerspring-doc.cn

如果您更喜欢 XML 配置，则可以使用该元素，如下例所示：<jms:annotation-driven>spring-doc.cn

<jms:annotation-driven/>

<bean id="jmsListenerContainerFactory"
        class="org.springframework.jms.config.DefaultJmsListenerContainerFactory">
    <property name="connectionFactory" ref="connectionFactory"/>
    <property name="destinationResolver" ref="destinationResolver"/>
    <property name="sessionTransacted" value="true"/>
    <property name="concurrency" value="3-10"/>
</bean>

3.5.2. 编程端点注册

JmsListenerEndpoint提供 JMS 终端节点的模型，并负责配置该模型的容器。基础设施允许您以编程方式配置终端节点除了 Annotation 检测到的 None 之外。以下示例显示了如何执行此操作：JmsListenerspring-doc.cn

@Configuration
@EnableJms
public class AppConfig implements JmsListenerConfigurer {

    @Override
    public void configureJmsListeners(JmsListenerEndpointRegistrar registrar) {
        SimpleJmsListenerEndpoint endpoint = new SimpleJmsListenerEndpoint();
        endpoint.setId("myJmsEndpoint");
        endpoint.setDestination("anotherQueue");
        endpoint.setMessageListener(message -> {
            // processing
        });
        registrar.registerEndpoint(endpoint);
    }
}

在前面的示例中，我们使用了，它提供了要调用的实际值。但是，您也可以构建自己的终端节点变体来描述自定义调用机制。SimpleJmsListenerEndpointMessageListenerspring-doc.cn

请注意，您可以完全跳过并通过 .@JmsListenerJmsListenerConfigurerspring-doc.cn

3.5.3. 带注释的端点方法签名

到目前为止，我们一直在端点中注入一个 simple，但它实际上可以具有非常灵活的方法签名。在下面的示例中，我们重写它以将自定义标头：StringOrderspring-doc.cn

@Component
public class MyService {

    @JmsListener(destination = "myDestination")
    public void processOrder(Order order, @Header("order_type") String orderType) {
        ...
    }
}

您可以在 JMS 侦听器终端节点中注入的主要元素如下：spring-doc.cn

raw 或其任何子类（前提是它匹配传入消息类型）。javax.jms.Messagespring-doc.cn
用于对本机 JMS API 的可选访问（例如，用于发送自定义回复）。javax.jms.Sessionspring-doc.cn
表示传入 JMS 消息的 that。请注意，此消息同时包含自定义和标准标头（如定义由）。org.springframework.messaging.MessageJmsHeadersspring-doc.cn
@Header-annotated 方法参数来提取特定的标头值，包括标准 JMS 标头。spring-doc.cn
一个带 -注释的参数，也必须分配给 for 获取对所有标头的访问权限。@Headersjava.util.Mapspring-doc.cn
不是受支持类型（或）之一的未注释元素被视为有效负载。您可以通过注释带有 .您还可以通过添加额外的 .MessageSession@Payload@Validspring-doc.cn

注入 Spring 抽象的能力特别有用从特定于传输的消息中存储的所有信息中，而无需依赖特定于传输的 API。以下示例显示了如何执行此操作：Messagespring-doc.cn

@JmsListener(destination = "myDestination")
public void processOrder(Message<Order> order) { ... }

方法参数的处理由提供，你可以进一步自定义以支持其他方法参数。您可以自定义转换和验证那里也有支持。DefaultMessageHandlerMethodFactoryspring-doc.cn

例如，如果我们想在处理之前确保 our 是有效的，我们可以使用必要的 Validator 注释有效负载并配置必要的 Validator，如下例所示：Order@Validspring-doc.cn

@Configuration
@EnableJms
public class AppConfig implements JmsListenerConfigurer {

    @Override
    public void configureJmsListeners(JmsListenerEndpointRegistrar registrar) {
        registrar.setMessageHandlerMethodFactory(myJmsHandlerMethodFactory());
    }

    @Bean
    public DefaultMessageHandlerMethodFactory myHandlerMethodFactory() {
        DefaultMessageHandlerMethodFactory factory = new DefaultMessageHandlerMethodFactory();
        factory.setValidator(myValidator());
        return factory;
    }
}

3.5.4. 响应管理

MessageListenerAdapter 中的现有支持已经允许你的方法具有非 return 类型。在这种情况下，将调用封装在，在指定的目标中发送在原始消息的报头中或在侦听器。现在，您可以使用消息传递抽象。voidjavax.jms.MessageJMSReplyTo@SendTospring-doc.cn

假设我们的方法现在应该返回一个，我们可以编写它自动发送响应，如下例所示：processOrderOrderStatusspring-doc.cn

@JmsListener(destination = "myDestination")
@SendTo("status")
public OrderStatus processOrder(Order order) {
    // order processing
    return status;
}

如果有多个 -annotated 方法，则还可以将 annotation 放在类级别以共享默认回复目标。@JmsListener@SendTo

如果需要以与传输无关的方式设置其他标头，则可以使用类似于以下的方法返回 a：Messagespring-doc.cn

@JmsListener(destination = "myDestination")
@SendTo("status")
public Message<OrderStatus> processOrder(Order order) {
    // order processing
    return MessageBuilder
            .withPayload(status)
            .setHeader("code", 1234)
            .build();
}

如果您需要在运行时计算响应目标，则可以封装您的响应在还提供要在运行时使用的目标的实例中。我们可以重写之前的示例如下：JmsResponsespring-doc.cn

@JmsListener(destination = "myDestination")
public JmsResponse<Message<OrderStatus>> processOrder(Order order) {
    // order processing
    Message<OrderStatus> response = MessageBuilder
            .withPayload(status)
            .setHeader("code", 1234)
            .build();
    return JmsResponse.forQueue(response, "status");
}

最后，如果您需要为响应指定一些 QoS 值，例如优先级或生存时间，您可以相应地配置，如下例所示：JmsListenerContainerFactoryspring-doc.cn

@Configuration
@EnableJms
public class AppConfig {

    @Bean
    public DefaultJmsListenerContainerFactory jmsListenerContainerFactory() {
        DefaultJmsListenerContainerFactory factory = new DefaultJmsListenerContainerFactory();
        factory.setConnectionFactory(connectionFactory());
        QosSettings replyQosSettings = new QosSettings();
        replyQosSettings.setPriority(2);
        replyQosSettings.setTimeToLive(10000);
        factory.setReplyQosSettings(replyQosSettings);
        return factory;
    }
}

3.6. JMS 命名空间支持

Spring 提供了一个 XML 名称空间来简化 JMS 配置。使用 JMS namespace 元素，您需要引用 JMS 架构，如下例所示：spring-doc.cn

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

    <!-- bean definitions here -->

</beans>

1	引用 JMS 架构。

命名空间由三个顶级元素组成：，和 . 允许使用注释驱动的侦听器端点。并定义共享侦听器容器配置，并且可以包含子元素。以下示例显示了两个侦听器的基本配置：<annotation-driven/><listener-container/><jca-listener-container/><annotation-driven/><listener-container/><jca-listener-container/><listener/>spring-doc.cn

<jms:listener-container>

    <jms:listener destination="queue.orders" ref="orderService" method="placeOrder"/>

    <jms:listener destination="queue.confirmations" ref="confirmationLogger" method="log"/>

</jms:listener-container>

前面的示例等效于创建两个不同的侦听器容器 Bean 定义和两个不同的 bean 定义，如下所示在使用 MessageListenerAdapter 中。除了显示的属性在前面的示例中，元素可以包含多个可选 Element。下表描述了所有可用属性：MessageListenerAdapterlistenerspring-doc.cn

表 3.JMS <listener> 元素的属性
属性	描述
`id`spring-doc.cn	托管侦听器容器的 Bean 名称。如果未指定，则 Bean 名称为自动生成。spring-doc.cn
`destination`（必填）spring-doc.cn	此侦听器的目标名称，通过策略解析。`DestinationResolver`spring-doc.cn
`ref`（必填）spring-doc.cn	处理程序对象的 bean 名称。spring-doc.cn
`method`spring-doc.cn	要调用的处理程序方法的名称。如果属性指向或 Spring ，则可以省略此属性。`refMessageListenerSessionAwareMessageListener`spring-doc.cn
`response-destination`spring-doc.cn	将响应消息发送到的默认响应目标的名称。这是在请求消息不带字段的情况下应用。这 type 由侦听器容器的属性确定。请注意，这仅适用于具有 return 值，每个 Result 对象都转换为响应消息。`JMSReplyToresponse-destination-type`spring-doc.cn
`subscription`spring-doc.cn	长期订阅的名称（如果有）。spring-doc.cn
`selector`spring-doc.cn	此侦听器的可选消息选择器。spring-doc.cn
`concurrency`spring-doc.cn	要为此侦听器启动的并发会话数或使用者数。该值可以是表示最大数字（例如，）的简单数字或表示下限以及上限（例如）。请注意，指定的最小值只是一个提示，并且在运行时可能会被忽略。默认值是容器提供的值。`53-5`spring-doc.cn

该元素还接受多个可选属性。这允许自定义各种策略（例如和）以及基本的 JMS 设置和资源引用。通过使用这些属性，您可以定义高度自定义的侦听器容器，而仍然受益于命名空间的便利性。<listener-container/>taskExecutordestinationResolverspring-doc.cn

您可以自动将此类设置公开为指定要通过属性公开的 bean，如下例所示：JmsListenerContainerFactoryidfactory-idspring-doc.cn

<jms:listener-container connection-factory="myConnectionFactory"
        task-executor="myTaskExecutor"
        destination-resolver="myDestinationResolver"
        transaction-manager="myTransactionManager"
        concurrency="10">

    <jms:listener destination="queue.orders" ref="orderService" method="placeOrder"/>

    <jms:listener destination="queue.confirmations" ref="confirmationLogger" method="log"/>

</jms:listener-container>

下表描述了所有可用属性。请参阅类级 javadoc AbstractMessageListenerContainer 及其具体子类，以获取有关各个属性的更多详细信息。javadoc 还讨论了事务选择和消息重新传递方案。spring-doc.cn

表 4.JMS <listener-container> 元素的属性
属性	描述
`container-type`spring-doc.cn	此侦听器容器的类型。可用选项包括、、、或（默认选项为）。`defaultsimpledefault102simple102default`spring-doc.cn
`container-class`spring-doc.cn	作为完全限定类名的自定义侦听器容器实现类。根据属性，默认值为 Spring 的标准或。`DefaultMessageListenerContainerSimpleMessageListenerContainercontainer-type`spring-doc.cn
`factory-id`spring-doc.cn	将此元素定义的设置公开为具有指定值的设置，以便它们可以与其他端点重复使用。`JmsListenerContainerFactoryid`spring-doc.cn
`connection-factory`spring-doc.cn	对 JMS Bean 的引用（默认 Bean 名称为）。`ConnectionFactoryconnectionFactory`spring-doc.cn
`task-executor`spring-doc.cn	对 JMS 侦听器调用程序的 Spring 的引用。`TaskExecutor`spring-doc.cn
`destination-resolver`spring-doc.cn	对解析 JMS 实例的策略的引用。`DestinationResolverDestination`spring-doc.cn
`message-converter`spring-doc.cn	对将 JMS 消息转换为侦听器的策略的引用 method 参数。默认值为 .`MessageConverterSimpleMessageConverter`spring-doc.cn
`error-handler`spring-doc.cn	对用于处理任何未捕获异常的策略的引用，该异常可能会在执行 .`ErrorHandlerMessageListener`spring-doc.cn
`destination-type`spring-doc.cn	此侦听器的 JMS 目标类型：、、、、或。这可能会启用容器的和属性。默认值为（它禁用这三个属性）。`queuetopicdurableTopicsharedTopicsharedDurableTopicpubSubDomainsubscriptionDurablesubscriptionSharedqueue`spring-doc.cn
`response-destination-type`spring-doc.cn	响应的 JMS 目标类型：或 .默认值是 attribute 的值。`queuetopicdestination-type`spring-doc.cn
`client-id`spring-doc.cn	此侦听器容器的 JMS 客户端 ID。您必须在使用 Durable Subscriptions 的 Durable Subscriptions 中。spring-doc.cn
`cache`spring-doc.cn	JMS 资源的缓存级别：、、、、或 .默认情况下（），缓存级别实际上是，除非已指定外部事务管理器 — 在这种情况下，有效的 default 将为（假设 Java EE 样式的事务管理，其中给定的 ConnectionFactory 是 XA 感知池）。`noneconnectionsessionconsumerautoautoconsumernone`spring-doc.cn
`acknowledge`spring-doc.cn	本机 JMS 确认模式：、、、或 .一个值 of 激活本地事务处理的 .作为替代方法，您可以指定属性，在后面的表中进行了介绍。默认值为 .`autoclientdups-oktransactedtransactedSessiontransaction-managerauto`spring-doc.cn
`transaction-manager`spring-doc.cn	对外部（通常是基于 XA 的事务协调器，例如 Spring 的）。如果未指定，则使用 native acknowledgeledging （参见 attribute ）。`PlatformTransactionManagerJtaTransactionManageracknowledge`spring-doc.cn
`concurrency`spring-doc.cn	每个侦听器要启动的并发会话或使用者的数量。它可以是表示最大数字（例如）的简单数字或表示下限以及上限（例如，）。请注意，指定的最小值只是一个提示，并且可能会在运行时被忽略。默认值为 .您应该将并发性限制为主题侦听器的大小，或者队列排序很重要。考虑将其提高为通用队列。`53-511`spring-doc.cn
`prefetch`spring-doc.cn	要加载到单个会话中的最大消息数。请注意，引发此 number 可能会导致并发使用者不足。spring-doc.cn
`receive-timeout`spring-doc.cn	用于接收调用的超时（以毫秒为单位）。默认值为（one second）。表示无超时。`1000-1`spring-doc.cn
`back-off`spring-doc.cn	指定用于计算恢复间隔的实例尝试。如果 implementation 返回，侦听器容器不会进一步尝试恢复。设置此属性时，将忽略该值。默认值为间隔为 5000 毫秒（即 5 秒）。`BackOffBackOffExecutionBackOffExecution#STOPrecovery-intervalFixedBackOff`spring-doc.cn
`recovery-interval`spring-doc.cn	指定恢复尝试之间的间隔（以毫秒为单位）。它提供了一个方便的方式创建具有指定间隔的 A。为了更多的恢复选项，请考虑改为指定实例。默认值为 5000 毫秒（即 5 秒）。`FixedBackOffBackOff`spring-doc.cn
`phase`spring-doc.cn	此容器应在其中启动和停止的生命周期阶段。较低的值，则此容器启动得越早，停止得越晚。默认值为，这意味着容器会尽可能晚地启动，并在尽快。`Integer.MAX_VALUE`spring-doc.cn

使用架构支持配置基于 JCA 的侦听器容器非常相似，如下例所示：jmsspring-doc.cn

<jms:jca-listener-container resource-adapter="myResourceAdapter"
        destination-resolver="myDestinationResolver"
        transaction-manager="myTransactionManager"
        concurrency="10">

    <jms:listener destination="queue.orders" ref="myMessageListener"/>

</jms:jca-listener-container>

下表介绍了 JCA 变体的可用配置选项：spring-doc.cn

表 5.JMS <jca-listener-container/> 元素的属性
属性	描述
`factory-id`spring-doc.cn	将此元素定义的设置公开为具有指定值的设置，以便它们可以与其他端点重复使用。`JmsListenerContainerFactoryid`spring-doc.cn
`resource-adapter`spring-doc.cn	对 JCA Bean 的引用（默认 Bean 名称为）。`ResourceAdapterresourceAdapter`spring-doc.cn
`activation-spec-factory`spring-doc.cn	对 .默认值是自动检测 JMS provider 及其类（参见`DefaultJmsActivationSpecFactory`）。`JmsActivationSpecFactoryActivationSpec`spring-doc.cn
`destination-resolver`spring-doc.cn	对解析 JMS 的策略的引用。`DestinationResolverDestinations`spring-doc.cn
`message-converter`spring-doc.cn	对将 JMS 消息转换为侦听器的策略的引用 method 参数。默认值为 .`MessageConverterSimpleMessageConverter`spring-doc.cn
`destination-type`spring-doc.cn	此侦听器的 JMS 目标类型：、、、、. 或。这可能会启用，，和容器的属性。默认值为（它禁用这三个属性）。`queuetopicdurableTopicsharedTopicsharedDurableTopicpubSubDomainsubscriptionDurablesubscriptionSharedqueue`spring-doc.cn
`response-destination-type`spring-doc.cn	响应的 JMS 目标类型：或 .默认值是 attribute 的值。`queuetopicdestination-type`spring-doc.cn
`client-id`spring-doc.cn	此侦听器容器的 JMS 客户端 ID。使用 Durable Subscriptions 的 Durable Subscriptions 中。spring-doc.cn
`acknowledge`spring-doc.cn	本机 JMS 确认模式：、、、或 .一个值 of 激活本地事务处理的 .作为替代方法，您可以指定稍后描述的属性。默认值为 .`autoclientdups-oktransactedtransactedSessiontransaction-managerauto`spring-doc.cn
`transaction-manager`spring-doc.cn	对 Spring 或 a 的引用，用于为每个 Spring 启动 XA 事务 incoming message 的 intent 语句。如果未指定，则使用 native acknowledgeledging （请参阅 attribute ）。`JtaTransactionManagerjavax.transaction.TransactionManageracknowledge`spring-doc.cn
`concurrency`spring-doc.cn	每个侦听器要启动的并发会话或使用者的数量。它可以是表示最大数字（例如）的简单数字或表示下限以及上限（例如，）。请注意，指定的最小值只是一个 hint 中，当您使用 JCA 侦听器容器时，通常会在运行时忽略该 Hint 的 TRICK 容器。默认值为 1。`53-5`spring-doc.cn
`prefetch`spring-doc.cn	要加载到单个会话中的最大消息数。请注意，引发此 number 可能会导致并发使用者不足。spring-doc.cn

4. JMX

Spring 中的 JMX（Java 管理扩展）支持提供了一些功能，这些功能允许您轻松透明地将您的 Spring 应用程序集成到 JMX 基础架构中。spring-doc.cn

JMX？

本章不是 JMX 的介绍。它不会试图解释为什么你可能想要以使用 JMX。如果您不熟悉 JMX，请参阅本章末尾的更多资源。spring-doc.cn

具体来说， Spring 的 JMX 支持提供了四个核心功能：spring-doc.cn

将任何 Spring bean 自动注册为 JMX MBean。spring-doc.cn
一种用于控制 bean 的 Management 界面的灵活机制。spring-doc.cn
MBean 在远程 JSR-160 连接器上的声明性公开。spring-doc.cn
本地和远程 MBean 资源的简单代理。spring-doc.cn

这些功能旨在在不将应用程序组件耦合到 Spring 或 JMX 接口和类。事实上，在大多数情况下，您的应用程序类不需要知道 Spring 或 JMX 即可利用 Spring JMX 功能。spring-doc.cn

4.1. 将 bean 导出到 JMX

Spring 的 JMX 框架中的核心类是 .这个类是负责获取您的 Spring bean 并将其注册到 JMX 中。例如，请考虑以下类：MBeanExporterMBeanServerspring-doc.cn

package org.springframework.jmx;

public class JmxTestBean implements IJmxTestBean {

    private String name;
    private int age;
    private boolean isSuperman;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

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

    public String getName() {
        return name;
    }

    public int add(int x, int y) {
        return x + y;
    }

    public void dontExposeMe() {
        throw new RuntimeException();
    }
}

要将此 Bean 的属性和方法公开为 MBean 中，您可以在配置文件并传入 Bean，如下例所示：MBeanExporterspring-doc.cn

<beans>
    <!-- this bean must not be lazily initialized if the exporting is to happen -->
    <bean id="exporter" class="org.springframework.jmx.export.MBeanExporter" lazy-init="false">
        <property name="beans">
            <map>
                <entry key="bean:name=testBean1" value-ref="testBean"/>
            </map>
        </property>
    </bean>
    <bean id="testBean" class="org.springframework.jmx.JmxTestBean">
        <property name="name" value="TEST"/>
        <property name="age" value="100"/>
    </bean>
</beans>

前面配置代码段中的相关 Bean 定义是 Bean。该属性准确地告诉您的 bean 必须是哪个导出到 JMX 。在默认配置中，每个条目的 key 在中用作 bean 引用的相应的 entry 值。您可以更改此行为，如控制 Bean 的 ObjectName 实例中所述。exporterbeansMBeanExporterMBeanServerbeansMapObjectNamespring-doc.cn

使用此配置，Bean 在 .默认情况下，Bean 的所有属性作为属性公开，所有方法（从类继承的方法除外）都作为操作公开。testBeanObjectNamebean:name=testBean1publicpublicObjectspring-doc.cn

MBeanExporter是一个 Bean（请参见Startup and Shutdown Callbacks）。默认情况下，MBean 在应用程序生命周期。您可以配置在发生导出或通过设置标志来禁用自动注册。LifecyclephaseautoStartup

4.1.1. 创建 MBeanServer

上一节中所示的配置假定应用程序在已运行一个（且只有一个）的环境中运行。在这种情况下， Spring 会尝试找到正在运行的向该服务器注册您的 bean（如果有）。当您的应用程序在容器（例如 Tomcat 或 IBM WebSphere）中运行，该容器具有有。MBeanServerMBeanServerMBeanServerspring-doc.cn

但是，这种方法在独立环境中或在不提供 .要解决此问题，您可以通过将类的实例添加到您的配置中来以声明方式创建实例。您还可以通过将实例属性的值设置为返回的值 an 来确保使用 specific，如下例所示：MBeanServerMBeanServerorg.springframework.jmx.support.MBeanServerFactoryBeanMBeanServerMBeanExporterserverMBeanServerMBeanServerFactoryBeanspring-doc.cn

<beans>

    <bean id="mbeanServer" class="org.springframework.jmx.support.MBeanServerFactoryBean"/>

    <!--
    this bean needs to be eagerly pre-instantiated in order for the exporting to occur;
    this means that it must not be marked as lazily initialized
    -->
    <bean id="exporter" class="org.springframework.jmx.export.MBeanExporter">
        <property name="beans">
            <map>
                <entry key="bean:name=testBean1" value-ref="testBean"/>
            </map>
        </property>
        <property name="server" ref="mbeanServer"/>
    </bean>

    <bean id="testBean" class="org.springframework.jmx.JmxTestBean">
        <property name="name" value="TEST"/>
        <property name="age" value="100"/>
    </bean>

</beans>

在前面的示例中，由和创建的实例通过物业供应给。当您提供自己的实例时，它不会尝试查找正在运行的实例，而是使用提供的实例。要使它起作用正确地，您的 Classpath 上必须有一个 JMX 实现。MBeanServerMBeanServerFactoryBeanMBeanExporterserverMBeanServerMBeanExporterMBeanServerMBeanServerspring-doc.cn

4.1.2. 重用现有的`MBeanServer`

如果未指定服务器，则会尝试自动检测正在运行的 .这在大多数环境中都有效，其中只有一个实例使用。但是，当存在多个实例时，导出程序可能会选择错误的服务器。在这种情况下，您应该使用来指示要，如下例所示：MBeanExporterMBeanServerMBeanServerMBeanServeragentIdspring-doc.cn

<beans>
    <bean id="mbeanServer" class="org.springframework.jmx.support.MBeanServerFactoryBean">
        <!-- indicate to first look for a server -->
        <property name="locateExistingServerIfPossible" value="true"/>
        <!-- search for the MBeanServer instance with the given agentId -->
        <property name="agentId" value="MBeanServer_instance_agentId>"/>
    </bean>
    <bean id="exporter" class="org.springframework.jmx.export.MBeanExporter">
        <property name="server" ref="mbeanServer"/>
        ...
    </bean>
</beans>

对于现有具有通过查找方法检索的动态（或未知）的平台或情况，您应该使用 factory-method，如下例所示：MBeanServeragentIdspring-doc.cn

<beans>
    <bean id="exporter" class="org.springframework.jmx.export.MBeanExporter">
        <property name="server">
            <!-- Custom MBeanServerLocator -->
            <bean class="platform.package.MBeanServerLocator" factory-method="locateMBeanServer"/>
        </property>
    </bean>

    <!-- other beans here -->

</beans>

4.1.3. 延迟初始化的 MBean

如果将 Bean 配置为 Lazy 初始化时，它不会破坏此 Contract 并避免实例化 Bean。相反，它使用和将从容器中获取 Bean 推迟到代理上的第一次调用发生。MBeanExporterMBeanExporterMBeanServerspring-doc.cn

4.1.4. 自动注册 MBean

通过导出且已经有效的 MBean 的任何 bean 都是按原样注册，无需 Spring 的进一步干预。您可以导致 MBean ，通过将属性设置为，自动检测到，如下例所示：MBeanExporterMBeanServerMBeanExporterautodetecttruespring-doc.cn

<bean id="exporter" class="org.springframework.jmx.export.MBeanExporter">
    <property name="autodetect" value="true"/>
</bean>

<bean name="spring:mbean=true" class="org.springframework.jmx.export.TestDynamicMBean"/>

在前面的示例中，调用的 Bean 已经是有效的 JMX MBean 并由 Spring 自动注册。默认情况下，为 JMX 自动检测的 bean registration 的 bean 名称用作 .您可以覆盖此行为，如控制 Bean 的 ObjectName 实例中所述。spring:mbean=trueObjectNamespring-doc.cn

4.1.5. 控制注册行为

考虑 Spring 尝试使用 .如果已在 same 下注册实例，则默认行为是失败的（并抛出一个）。MBeanExporterMBeanMBeanServerObjectNamebean:name=testBean1MBeanObjectNameInstanceAlreadyExistsExceptionspring-doc.cn

您可以精确控制已注册 .Spring 的 JMX 支持允许三种不同的注册行为控制注册时进程发现已在同一下注册。下表总结了这些注册行为：MBeanMBeanServerMBeanObjectNamespring-doc.cn

表 6.注册行为
注册行为	解释
`FAIL_ON_EXISTING`spring-doc.cn	这是默认的注册行为。如果实例已经在同一项下注册的，正在注册的不是 registered，并引发 an。现有不受影响。`MBeanObjectNameMBeanInstanceAlreadyExistsExceptionMBean`spring-doc.cn
`IGNORE_EXISTING`spring-doc.cn	如果已在同一下注册实例，则不会注册正在注册的实例。现有的是 unaffected，并且 no 被抛出。这在多个应用程序希望在共享的 .`MBeanObjectNameMBeanMBeanExceptionMBeanMBeanServer`spring-doc.cn
`REPLACE_EXISTING`spring-doc.cn	如果实例已在同一、 existing 的 existing 将取消注册，并且 new 将在其位置上注册（new 实际上替换了 previous 实例）。`MBeanObjectNameMBeanMBeanMBean`spring-doc.cn

上表中的值定义为类的枚举。如果要更改默认注册行为，则需要将定义上的属性值设置为以下值之一值。RegistrationPolicyregistrationPolicyMBeanExporterspring-doc.cn

以下示例显示如何从默认注册进行更改 behavior 更改为 behavior：REPLACE_EXISTINGspring-doc.cn

<beans>

    <bean id="exporter" class="org.springframework.jmx.export.MBeanExporter">
        <property name="beans">
            <map>
                <entry key="bean:name=testBean1" value-ref="testBean"/>
            </map>
        </property>
        <property name="registrationPolicy" value="REPLACE_EXISTING"/>
    </bean>

    <bean id="testBean" class="org.springframework.jmx.JmxTestBean">
        <property name="name" value="TEST"/>
        <property name="age" value="100"/>
    </bean>

</beans>

4.2. 控制 bean 的管理接口

在上一节的示例中，您对 Bean 的 Management Interface 几乎没有控制权。每个导出的 bean 的所有属性和方法都作为 JMX 属性和操作。要对具体内容进行更精细的控制导出的 bean 的属性和方法实际上作为 JMX 属性公开和操作，Spring JMX 为控制 bean 的 Management 接口。publicspring-doc.cn

4.2.1. 使用界面`MBeanInfoAssembler`

在后台，委托给接口的实现，即负责定义每个公开的 bean 的 Management 接口。默认实现，定义公开所有公共属性和方法的管理接口（如您在前面部分的示例中看到的那样）。Spring 提供两个接口的其他实现，可让您使用源级元数据控制生成的管理界面或任何任意接口。MBeanExporterorg.springframework.jmx.export.assembler.MBeanInfoAssemblerorg.springframework.jmx.export.assembler.SimpleReflectiveMBeanInfoAssemblerMBeanInfoAssemblerspring-doc.cn

4.2.2. 使用源级元数据：Java 注解

通过使用，您可以定义管理接口用于 bean。元数据的读取是封装的通过界面。 Spring JMX 提供了一个使用 Java 注解的默认实现，即 . 您必须使用使其正常运行的接口（没有默认值）。MetadataMBeanInfoAssemblerorg.springframework.jmx.export.metadata.JmxAttributeSourceorg.springframework.jmx.export.annotation.AnnotationJmxAttributeSourceMetadataMBeanInfoAssemblerJmxAttributeSourcespring-doc.cn

要标记要导出到 JMX 的 Bean，您应该使用注释对 Bean 类进行注释。您必须将要公开的每个方法标记为操作并标记要公开的每个属性替换为注释。标记属性时，可以省略 getter 或 setter 的注解，用于创建 write-only 或 read-only 属性。ManagedResourceManagedOperationManagedAttributespring-doc.cn

带 -ancomments 的 bean 必须是 public 的，公开操作或属性。ManagedResource

下面的示例显示了类的注释版本，我们用于创建 MBeanServer：JmxTestBeanspring-doc.cn

package org.springframework.jmx;

import org.springframework.jmx.export.annotation.ManagedResource;
import org.springframework.jmx.export.annotation.ManagedOperation;
import org.springframework.jmx.export.annotation.ManagedAttribute;

@ManagedResource(
        objectName="bean:name=testBean4",
        description="My Managed Bean",
        log=true,
        logFile="jmx.log",
        currencyTimeLimit=15,
        persistPolicy="OnUpdate",
        persistPeriod=200,
        persistLocation="foo",
        persistName="bar")
public class AnnotationTestBean implements IJmxTestBean {

    private String name;
    private int age;

    @ManagedAttribute(description="The Age Attribute", currencyTimeLimit=15)
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @ManagedAttribute(description="The Name Attribute",
            currencyTimeLimit=20,
            defaultValue="bar",
            persistPolicy="OnUpdate")
    public void setName(String name) {
        this.name = name;
    }

    @ManagedAttribute(defaultValue="foo", persistPeriod=300)
    public String getName() {
        return name;
    }

    @ManagedOperation(description="Add two numbers")
    @ManagedOperationParameters({
        @ManagedOperationParameter(name = "x", description = "The first number"),
        @ManagedOperationParameter(name = "y", description = "The second number")})
    public int add(int x, int y) {
        return x + y;
    }

    public void dontExposeMe() {
        throw new RuntimeException();
    }

}

在前面的示例中，您可以看到该类标有 annotation，并且此 annotation 已配置具有一组属性。这些属性可用于配置各个方面由生成的 MBean 和在 greater 中解释稍后在 Source-level Metadata Types 中详细介绍。JmxTestBeanManagedResourceManagedResourceMBeanExporterspring-doc.cn

和属性都使用注释进行注释，但在属性的情况下，仅标记 getter。这会导致这两个属性都包含在管理界面中作为属性，但该属性是只读的。agenameManagedAttributeageagespring-doc.cn

最后，该方法使用属性而 method 则不是。这会导致管理界面仅包含一个操作（）时。add(int, int)ManagedOperationdontExposeMe()add(int, int)MetadataMBeanInfoAssemblerspring-doc.cn

以下配置显示了如何配置以使用：MBeanExporterMetadataMBeanInfoAssemblerspring-doc.cn

<beans>
    <bean id="exporter" class="org.springframework.jmx.export.MBeanExporter">
        <property name="assembler" ref="assembler"/>
        <property name="namingStrategy" ref="namingStrategy"/>
        <property name="autodetect" value="true"/>
    </bean>

    <bean id="jmxAttributeSource"
            class="org.springframework.jmx.export.annotation.AnnotationJmxAttributeSource"/>

    <!-- will create management interface using annotation metadata -->
    <bean id="assembler"
            class="org.springframework.jmx.export.assembler.MetadataMBeanInfoAssembler">
        <property name="attributeSource" ref="jmxAttributeSource"/>
    </bean>

    <!-- will pick up the ObjectName from the annotation -->
    <bean id="namingStrategy"
            class="org.springframework.jmx.export.naming.MetadataNamingStrategy">
        <property name="attributeSource" ref="jmxAttributeSource"/>
    </bean>

    <bean id="testBean" class="org.springframework.jmx.AnnotationTestBean">
        <property name="name" value="TEST"/>
        <property name="age" value="100"/>
    </bean>
</beans>

在前面的示例中，Bean 配置了实例，并通过 assembler 属性传递给。这就是利用所需的全部内容元数据驱动的管理接口，用于 Spring 公开的 MBean。MetadataMBeanInfoAssemblerAnnotationJmxAttributeSourceMBeanExporterspring-doc.cn

4.2.3. 源级元数据类型

下表描述了可在 Spring JMX 中使用的源级元数据类型：spring-doc.cn

表 7.源级元数据类型
目的	注解	注释类型
将的所有实例标记为 JMX 托管资源。`Class`spring-doc.cn	`@ManagedResource`spring-doc.cn	类spring-doc.cn
将方法标记为 JMX 操作。spring-doc.cn	`@ManagedOperation`spring-doc.cn	方法spring-doc.cn
将 getter 或 setter 标记为 JMX 属性的一半。spring-doc.cn	`@ManagedAttribute`spring-doc.cn	方法（仅限 getter 和 setter）spring-doc.cn
定义操作参数的描述。spring-doc.cn	`@ManagedOperationParameter`和`@ManagedOperationParameters`spring-doc.cn	方法spring-doc.cn

下表描述了可用于这些源级别的配置参数元数据类型：spring-doc.cn

表 8.源级元数据参数
参数	描述	适用于
`ObjectName`spring-doc.cn	用于确定托管资源的。`MetadataNamingStrategyObjectName`spring-doc.cn	`ManagedResource`spring-doc.cn
`description`spring-doc.cn	设置资源、属性或操作的友好描述。spring-doc.cn	`ManagedResource`或`ManagedAttributeManagedOperationManagedOperationParameter`spring-doc.cn
`currencyTimeLimit`spring-doc.cn	设置 descriptor 字段的值。`currencyTimeLimit`spring-doc.cn	`ManagedResource`或`ManagedAttribute`spring-doc.cn
`defaultValue`spring-doc.cn	设置 descriptor 字段的值。`defaultValue`spring-doc.cn	`ManagedAttribute`spring-doc.cn
`log`spring-doc.cn	设置 descriptor 字段的值。`log`spring-doc.cn	`ManagedResource`spring-doc.cn
`logFile`spring-doc.cn	设置 descriptor 字段的值。`logFile`spring-doc.cn	`ManagedResource`spring-doc.cn
`persistPolicy`spring-doc.cn	设置 descriptor 字段的值。`persistPolicy`spring-doc.cn	`ManagedResource`spring-doc.cn
`persistPeriod`spring-doc.cn	设置 descriptor 字段的值。`persistPeriod`spring-doc.cn	`ManagedResource`spring-doc.cn
`persistLocation`spring-doc.cn	设置 descriptor 字段的值。`persistLocation`spring-doc.cn	`ManagedResource`spring-doc.cn
`persistName`spring-doc.cn	设置 descriptor 字段的值。`persistName`spring-doc.cn	`ManagedResource`spring-doc.cn
`name`spring-doc.cn	设置操作参数的显示名称。spring-doc.cn	`ManagedOperationParameter`spring-doc.cn
`index`spring-doc.cn	设置操作参数的索引。spring-doc.cn	`ManagedOperationParameter`spring-doc.cn

4.2.4. 使用界面`AutodetectCapableMBeanInfoAssembler`

为了进一步简化配置， Spring 包括了接口，该接口扩展了接口以添加对 MBean 资源的自动检测的支持。如果使用的实例配置，则为允许 “投票” 包含用于 JMX 的 bean。AutodetectCapableMBeanInfoAssemblerMBeanInfoAssemblerMBeanExporterAutodetectCapableMBeanInfoAssemblerspring-doc.cn

接口的唯一实现是，它投票以包括任何标记为替换为属性。在这种情况下，默认方法是使用 bean name 指定为，这将产生类似于以下内容的配置：AutodetectCapableMBeanInfoMetadataMBeanInfoAssemblerManagedResourceObjectNamespring-doc.cn

<beans>

    <bean id="exporter" class="org.springframework.jmx.export.MBeanExporter">
        <!-- notice how no 'beans' are explicitly configured here -->
        <property name="autodetect" value="true"/>
        <property name="assembler" ref="assembler"/>
    </bean>

    <bean id="testBean" class="org.springframework.jmx.JmxTestBean">
        <property name="name" value="TEST"/>
        <property name="age" value="100"/>
    </bean>

    <bean id="assembler" class="org.springframework.jmx.export.assembler.MetadataMBeanInfoAssembler">
        <property name="attributeSource">
            <bean class="org.springframework.jmx.export.annotation.AnnotationJmxAttributeSource"/>
        </property>
    </bean>

</beans>

请注意，在前面的配置中，没有 bean 传递给 . 但是，它仍然被注册，因为它标有属性，并且检测到这一点并投票将其包含在内。这种方法的唯一问题是 name of the now 有业务意义。您可以通过更改 Controlling ObjectName Instances for Your Bean 中定义的创建的默认行为来解决此问题。MBeanExporterJmxTestBeanManagedResourceMetadataMBeanInfoAssemblerJmxTestBeanObjectNamespring-doc.cn

4.2.5. 使用 Java 接口定义管理接口

除了之外，Spring 还包括，它允许您约束 methods 和属性，这些属性根据接口。MetadataMBeanInfoAssemblerInterfaceBasedMBeanInfoAssemblerspring-doc.cn

尽管公开 MBean 的标准机制是使用接口和简单的命名方案，通过以下方式扩展此功能无需命名约定，让您使用多个接口以及消除 bean 实现 MBean 接口的需要。InterfaceBasedMBeanInfoAssemblerspring-doc.cn

请考虑以下接口，该接口用于定义我们前面展示的类的管理接口：JmxTestBeanspring-doc.cn

public interface IJmxTestBean {

    public int add(int x, int y);

    public long myOperation();

    public int getAge();

    public void setAge(int age);

    public void setName(String name);

    public String getName();

}

此接口定义作为操作公开的方法和属性，并且属性。以下代码显示了如何配置 Spring JMX 以使用此接口作为 Management Interface 的定义：spring-doc.cn

<beans>

    <bean id="exporter" class="org.springframework.jmx.export.MBeanExporter">
        <property name="beans">
            <map>
                <entry key="bean:name=testBean5" value-ref="testBean"/>
            </map>
        </property>
        <property name="assembler">
            <bean class="org.springframework.jmx.export.assembler.InterfaceBasedMBeanInfoAssembler">
                <property name="managedInterfaces">
                    <value>org.springframework.jmx.IJmxTestBean</value>
                </property>
            </bean>
        </property>
    </bean>

    <bean id="testBean" class="org.springframework.jmx.JmxTestBean">
        <property name="name" value="TEST"/>
        <property name="age" value="100"/>
    </bean>

</beans>

在前面的示例中，配置为在为任何 bean 构造 Management 接口时使用该接口。是的重要的是要了解由处理的 bean 不需要实现用于生成 JMX 管理的接口接口。InterfaceBasedMBeanInfoAssemblerIJmxTestBeanInterfaceBasedMBeanInfoAssemblerspring-doc.cn

在上述情况下，该接口用于构造所有管理所有 bean 的接口。在许多情况下，这不是所需的行为，您可能会希望对不同的 bean 使用不同的接口。在这种情况下，您可以通过属性传递实例，其中每个条目的键是 Bean 名称，每个条目的值是用于该 bean 的接口名称的逗号分隔列表。IJmxTestBeanInterfaceBasedMBeanInfoAssemblerPropertiesinterfaceMappingsspring-doc.cn

如果未通过或属性指定管理接口，则在 Bean 上，并使用该 Bean 实现的所有接口来创建管理界面。managedInterfacesinterfaceMappingsInterfaceBasedMBeanInfoAssemblerspring-doc.cn

4.2.6. 使用`MethodNameBasedMBeanInfoAssembler`

MethodNameBasedMBeanInfoAssembler用于指定方法名称列表作为属性和操作向 JMX 公开。下面的代码显示了一个示例配置：spring-doc.cn

<bean id="exporter" class="org.springframework.jmx.export.MBeanExporter">
    <property name="beans">
        <map>
            <entry key="bean:name=testBean5" value-ref="testBean"/>
        </map>
    </property>
    <property name="assembler">
        <bean class="org.springframework.jmx.export.assembler.MethodNameBasedMBeanInfoAssembler">
            <property name="managedMethods">
                <value>add,myOperation,getName,setName,getAge</value>
            </property>
        </bean>
    </property>
</bean>

在前面的示例中，您可以看到 and 方法作为 JMX 公开操作、、和以及作为适当的 JMX 属性的一半。在上面的代码中，方法映射适用于向 JMX 公开的 bean。要逐个 bean 控制方法公开，可以使用将 bean 名称映射到的属性方法名称列表。addmyOperationgetName()setName(String)getAge()methodMappingsMethodNameMBeanInfoAssemblerspring-doc.cn

4.3. 控制 bean 的实例`ObjectName`

在幕后，委托给的实现以获取它注册的每个 bean 的实例。默认情况下，默认实现使用的键作为 .此外，还可以映射 key 的添加到文件（或文件）中的条目中，以解析 .除了之外，Spring 还提供了两个额外的实现：（基于 Bean 的 JVM 标识构建一个）和（它使用源级元数据来获取）。MBeanExporterObjectNamingStrategyObjectNameKeyNamingStrategybeansMapObjectNameKeyNamingStrategybeansMapPropertiesObjectNameKeyNamingStrategyObjectNamingStrategyIdentityNamingStrategyObjectNameMetadataNamingStrategyObjectNamespring-doc.cn

4.3.1. 从属性中读取实例`ObjectName`

您可以配置自己的实例，并将其配置为从实例读取实例，而不是使用 Bean 密钥。尝试在带有键的对应于 Bean 键。如果未找到条目或实例为，则使用 Bean 键本身。KeyNamingStrategyObjectNamePropertiesKeyNamingStrategyPropertiesPropertiesnullspring-doc.cn

以下代码显示了的示例配置：KeyNamingStrategyspring-doc.cn

<beans>

    <bean id="exporter" class="org.springframework.jmx.export.MBeanExporter">
        <property name="beans">
            <map>
                <entry key="testBean" value-ref="testBean"/>
            </map>
        </property>
        <property name="namingStrategy" ref="namingStrategy"/>
    </bean>

    <bean id="testBean" class="org.springframework.jmx.JmxTestBean">
        <property name="name" value="TEST"/>
        <property name="age" value="100"/>
    </bean>

    <bean id="namingStrategy" class="org.springframework.jmx.export.naming.KeyNamingStrategy">
        <property name="mappings">
            <props>
                <prop key="testBean">bean:name=testBean1</prop>
            </props>
        </property>
        <property name="mappingLocations">
            <value>names1.properties,names2.properties</value>
        </property>
    </bean>

</beans>

前面的示例将的实例配置为的实例，该实例从映射属性定义的实例合并，并且 properties 文件位于 mappings 属性定义的路径中。在这个 configuration 时，bean 被赋予一个 of ，由于这是实例中具有对应于 Bean 键。KeyNamingStrategyPropertiesPropertiestestBeanObjectNamebean:name=testBean1Propertiesspring-doc.cn

如果在实例中找不到任何条目，则 Bean 键名用作这。PropertiesObjectNamespring-doc.cn

4.3.2. 使用`MetadataNamingStrategy`

MetadataNamingStrategy使用每个 Bean 上的属性来创建 .以下代码显示了的配置：objectNameManagedResourceObjectNameMetadataNamingStrategyspring-doc.cn

<beans>

    <bean id="exporter" class="org.springframework.jmx.export.MBeanExporter">
        <property name="beans">
            <map>
                <entry key="testBean" value-ref="testBean"/>
            </map>
        </property>
        <property name="namingStrategy" ref="namingStrategy"/>
    </bean>

    <bean id="testBean" class="org.springframework.jmx.JmxTestBean">
        <property name="name" value="TEST"/>
        <property name="age" value="100"/>
    </bean>

    <bean id="namingStrategy" class="org.springframework.jmx.export.naming.MetadataNamingStrategy">
        <property name="attributeSource" ref="attributeSource"/>
    </bean>

    <bean id="attributeSource"
            class="org.springframework.jmx.export.annotation.AnnotationJmxAttributeSource"/>

</beans>

如果尚未为属性提供 no，则使用以下命令创建一个格式：[fully-qualified-package-name]：type=[short-classname]，name=[bean-name]。为例如，为以下 bean 生成的将是：objectNameManagedResourceObjectNameObjectNamecom.example:type=MyClass,name=myBeanspring-doc.cn

<bean id="myBean" class="com.example.MyClass"/>

4.3.3. 配置基于 Annotation 的 MBean 导出

如果您更喜欢使用基于注释的方法来定义您的 Management 接口中，可以使用方便的子类：。定义此子类的实例时，您不再需要、和配置由于它始终使用基于 Java 注释的标准元数据（autodetection 为也始终启用）。事实上，与其定义 bean，不如定义偶数注解支持 simpler 语法，如下例所示：MBeanExporterAnnotationMBeanExporternamingStrategyassemblerattributeSourceMBeanExporter@EnableMBeanExport@Configurationspring-doc.cn

@Configuration
@EnableMBeanExport
public class AppConfig {

}

如果您更喜欢基于 XML 的配置，则该元素为相同的目的，如下面的清单所示：<context:mbean-export/>spring-doc.cn

<context:mbean-export/>

如有必要，您可以提供对特定 MBean 的引用，并且该属性（的属性）接受替代值。这用于代替完全限定的包名称，如上一节所述 MetadataNamingStrategy，如下例所示：serverdefaultDomainAnnotationMBeanExporterObjectNamespring-doc.cn

@EnableMBeanExport(server="myMBeanServer", defaultDomain="myDomain")
@Configuration
ContextConfiguration {

}

以下示例显示了前面基于注释的示例的 XML 等效项：spring-doc.cn

<context:mbean-export server="myMBeanServer" default-domain="myDomain"/>

不要将基于接口的 AOP 代理与 JMX 的自动检测结合使用 Bean 类中的注解。基于接口的代理 “隐藏” 目标类，该类还会隐藏 JMX 托管的资源注释。因此，您应该在该 case （通过在上设置 'proxy-target-class' 标志，依此类推）。否则，您的 JMX bean 可能会在启动。<aop:config/><tx:annotation-driven/>

4.4. 使用 JSR-160 连接器

对于远程访问， Spring JMX 模块在包内提供了两种实现，用于创建服务器端和客户端连接。FactoryBeanorg.springframework.jmx.supportspring-doc.cn

4.4.1. 服务器端连接器

要让 Spring JMX 创建、启动和公开 JSR-160 ，您可以使用以下配置：JMXConnectorServerspring-doc.cn

<bean id="serverConnector" class="org.springframework.jmx.support.ConnectorServerFactoryBean"/>

默认情况下，会创建一个绑定到 .因此，该 bean 公开了通过 localhost 上的 JMXMP 协议，端口 9875 本地到客户端。注意 JMXMP 协议被 JSR 160 规范标记为可选。现在主要的开源 JMX 实现 MX4J 和 JDK 随附的实现不支持 JMXMP。ConnectorServerFactoryBeanJMXConnectorServerservice:jmx:jmxmp://localhost:9875serverConnectorMBeanServerspring-doc.cn

要指定另一个 URL 并向注册自身，您可以分别使用和属性，如下例所示：JMXConnectorServerMBeanServerserviceUrlObjectNamespring-doc.cn

<bean id="serverConnector"
        class="org.springframework.jmx.support.ConnectorServerFactoryBean">
    <property name="objectName" value="connector:name=rmi"/>
    <property name="serviceUrl"
            value="service:jmx:rmi://localhost/jndi/rmi://localhost:1099/myconnector"/>
</bean>

如果设置了该属性，Spring 会自动注册您的连接器与下那 .以下示例显示了完整的在创建时可以传递给的参数：ObjectNameMBeanServerObjectNameConnectorServerFactoryBeanJMXConnectorspring-doc.cn

<bean id="serverConnector"
        class="org.springframework.jmx.support.ConnectorServerFactoryBean">
    <property name="objectName" value="connector:name=iiop"/>
    <property name="serviceUrl"
        value="service:jmx:iiop://localhost/jndi/iiop://localhost:900/myconnector"/>
    <property name="threaded" value="true"/>
    <property name="daemon" value="true"/>
    <property name="environment">
        <map>
            <entry key="someKey" value="someValue"/>
        </map>
    </property>
</bean>

请注意，当您使用基于 RMI 的连接器时，需要启动查找服务（或）才能完成名称注册。如果你使用 Spring 通过 RMI 为你导出远程服务，Spring 已经构建了一个 RMI 注册表。如果没有，您可以使用以下方法轻松启动注册表配置片段：tnameservrmiregistryspring-doc.cn

<bean id="registry" class="org.springframework.remoting.rmi.RmiRegistryFactoryBean">
    <property name="port" value="1099"/>
</bean>

4.4.2. 客户端连接器

要创建远程 JSR-160-enabled ，可以使用，如下例所示：MBeanServerConnectionMBeanServerMBeanServerConnectionFactoryBeanspring-doc.cn

<bean id="clientConnector" class="org.springframework.jmx.support.MBeanServerConnectionFactoryBean">
    <property name="serviceUrl" value="service:jmx:rmi://localhost/jndi/rmi://localhost:1099/jmxrmi"/>
</bean>

4.4.3. 基于 Hessian 或 SOAP 的 JMX

JSR-160 允许扩展客户端之间的通信方式和服务器。前面各节中显示的示例使用基于 RMI 的强制实现 JSR-160 规范（IIOP 和 JRMP）和（可选）JMXMP 要求。通过使用其他提供程序或 JMX 实现（例如 MX4J）您可以利用 SOAP 或 Hessian 等协议，而不是简单的 HTTP 或 SSL 等，如下例所示：spring-doc.cn

<bean id="serverConnector" class="org.springframework.jmx.support.ConnectorServerFactoryBean">
    <property name="objectName" value="connector:name=burlap"/>
    <property name="serviceUrl" value="service:jmx:burlap://localhost:9874"/>
</bean>

在前面的示例中，我们使用了 MX4J 3.0.0。查看官方 MX4J 文档了解更多信息。spring-doc.cn

4.5. 通过代理访问 MBean

Spring JMX 允许您创建代理，将调用重新路由到在本地或远程 .这些代理为您提供了一个标准的 Java 接口通过它与 MBean 进行交互。以下代码演示如何配置在本地中运行的 MBean 的代理。MBeanServerMBeanServerspring-doc.cn

<bean id="proxy" class="org.springframework.jmx.access.MBeanProxyFactoryBean">
    <property name="objectName" value="bean:name=testBean"/>
    <property name="proxyInterface" value="org.springframework.jmx.IJmxTestBean"/>
</bean>

在前面的示例中，您可以看到为在 of 下注册的 MBean 创建了一个代理。代理实现的接口集由属性控制，映射方法和这些接口上的属性和 MBean 上的属性是相同的使用的规则。ObjectNamebean:name=testBeanproxyInterfacesInterfaceBasedMBeanInfoAssemblerspring-doc.cn

可以创建任何可通过 .默认情况下，本地（local）被定位并使用，但你可以覆盖它并提供一个指向远程的代理，以满足指向远程 MBean 的代理的需求：MBeanProxyFactoryBeanMBeanServerConnectionMBeanServerMBeanServerConnectionMBeanServerspring-doc.cn

<bean id="clientConnector"
        class="org.springframework.jmx.support.MBeanServerConnectionFactoryBean">
    <property name="serviceUrl" value="service:jmx:rmi://remotehost:9875"/>
</bean>

<bean id="proxy" class="org.springframework.jmx.access.MBeanProxyFactoryBean">
    <property name="objectName" value="bean:name=testBean"/>
    <property name="proxyInterface" value="org.springframework.jmx.IJmxTestBean"/>
    <property name="server" ref="clientConnector"/>
</bean>

在前面的示例中，我们创建了一个指向远程机器的使用 .然后传递给通过属性。代理是 created 将所有调用转发到通过 this 。MBeanServerConnectionMBeanServerConnectionFactoryBeanMBeanServerConnectionMBeanProxyFactoryBeanserverMBeanServerMBeanServerConnectionspring-doc.cn

4.6. 通知

Spring 的 JMX 产品包括对 JMX 通知的全面支持。spring-doc.cn

4.6.1. 为通知注册侦听器

Spring 的 JMX 支持使得向任意数量的 MBean 注册任意数量的变得容易（这包括由 Spring 的 MBean 通过其他机制注册）。为例如，考虑这样一个场景：每次目标 MBean 的属性发生更改时，都希望收到通知（通过）。以下内容示例将通知写入控制台：NotificationListenersMBeanExporterNotificationspring-doc.cn

package com.example;

import javax.management.AttributeChangeNotification;
import javax.management.Notification;
import javax.management.NotificationFilter;
import javax.management.NotificationListener;

public class ConsoleLoggingNotificationListener
        implements NotificationListener, NotificationFilter {

    public void handleNotification(Notification notification, Object handback) {
        System.out.println(notification);
        System.out.println(handback);
    }

    public boolean isNotificationEnabled(Notification notification) {
        return AttributeChangeNotification.class.isAssignableFrom(notification.getClass());
    }

}

下面的示例添加（在前面的 example）设置为：ConsoleLoggingNotificationListenernotificationListenerMappingsspring-doc.cn

<beans>

    <bean id="exporter" class="org.springframework.jmx.export.MBeanExporter">
        <property name="beans">
            <map>
                <entry key="bean:name=testBean1" value-ref="testBean"/>
            </map>
        </property>
        <property name="notificationListenerMappings">
            <map>
                <entry key="bean:name=testBean1">
                    <bean class="com.example.ConsoleLoggingNotificationListener"/>
                </entry>
            </map>
        </property>
    </bean>

    <bean id="testBean" class="org.springframework.jmx.JmxTestBean">
        <property name="name" value="TEST"/>
        <property name="age" value="100"/>
    </bean>

</beans>

有了前面的配置，每次从目标 MBean （）中，bean 通过属性注册为侦听器的通知。然后，Bean 可以执行任何操作它认为回应 .Notificationbean:name=testBean1ConsoleLoggingNotificationListenernotificationListenerMappingsConsoleLoggingNotificationListenerNotificationspring-doc.cn

你也可以使用直接的 bean 名称作为导出的 bean 和侦听器之间的链接。如下例所示：spring-doc.cn

<beans>

    <bean id="exporter" class="org.springframework.jmx.export.MBeanExporter">
        <property name="beans">
            <map>
                <entry key="bean:name=testBean1" value-ref="testBean"/>
            </map>
        </property>
        <property name="notificationListenerMappings">
            <map>
                <entry key="testBean">
                    <bean class="com.example.ConsoleLoggingNotificationListener"/>
                </entry>
            </map>
        </property>
    </bean>

    <bean id="testBean" class="org.springframework.jmx.JmxTestBean">
        <property name="name" value="TEST"/>
        <property name="age" value="100"/>
    </bean>

</beans>

如果要为所有 bean 注册单个实例，你可以使用特殊的通配符（）作为属性中某个项的键 map，如下例所示：NotificationListenerMBeanExporter*notificationListenerMappingsspring-doc.cn

<property name="notificationListenerMappings">
    <map>
        <entry key="*">
            <bean class="com.example.ConsoleLoggingNotificationListener"/>
        </entry>
    </map>
</property>

如果需要执行相反的操作（即，针对一个 MBean），则必须改用 list 属性（在 preference 添加到属性中）。这一次，不是配置 a 对于单个 MBean，我们配置实例。A 封装了 a 和它要成为的（或）在中注册。还封装了许多其他属性，例如 a 和任意 handback 对象。notificationListenersnotificationListenerMappingsNotificationListenerNotificationListenerBeanNotificationListenerBeanNotificationListenerObjectNameObjectNamesMBeanServerNotificationListenerBeanNotificationFilterspring-doc.cn

使用实例时的配置不是与前面介绍的内容不同，如下例所示：NotificationListenerBeanspring-doc.cn

<beans>

    <bean id="exporter" class="org.springframework.jmx.export.MBeanExporter">
        <property name="beans">
            <map>
                <entry key="bean:name=testBean1" value-ref="testBean"/>
            </map>
        </property>
        <property name="notificationListeners">
            <list>
                <bean class="org.springframework.jmx.export.NotificationListenerBean">
                    <constructor-arg>
                        <bean class="com.example.ConsoleLoggingNotificationListener"/>
                    </constructor-arg>
                    <property name="mappedObjectNames">
                        <list>
                            <value>bean:name=testBean1</value>
                        </list>
                    </property>
                </bean>
            </list>
        </property>
    </bean>

    <bean id="testBean" class="org.springframework.jmx.JmxTestBean">
        <property name="name" value="TEST"/>
        <property name="age" value="100"/>
    </bean>

</beans>

前面的示例等效于第一个通知示例。那么，假设我们希望每次引发 a 时都得到一个 handback 对象，并且我们还希望通过提供 .以下示例可实现这些目标：NotificationNotificationsNotificationFilterspring-doc.cn

<beans>

    <bean id="exporter" class="org.springframework.jmx.export.MBeanExporter">
        <property name="beans">
            <map>
                <entry key="bean:name=testBean1" value-ref="testBean1"/>
                <entry key="bean:name=testBean2" value-ref="testBean2"/>
            </map>
        </property>
        <property name="notificationListeners">
            <list>
                <bean class="org.springframework.jmx.export.NotificationListenerBean">
                    <constructor-arg ref="customerNotificationListener"/>
                    <property name="mappedObjectNames">
                        <list>
                            <!-- handles notifications from two distinct MBeans -->
                            <value>bean:name=testBean1</value>
                            <value>bean:name=testBean2</value>
                        </list>
                    </property>
                    <property name="handback">
                        <bean class="java.lang.String">
                            <constructor-arg value="This could be anything..."/>
                        </bean>
                    </property>
                    <property name="notificationFilter" ref="customerNotificationListener"/>
                </bean>
            </list>
        </property>
    </bean>

    <!-- implements both the NotificationListener and NotificationFilter interfaces -->
    <bean id="customerNotificationListener" class="com.example.ConsoleLoggingNotificationListener"/>

    <bean id="testBean1" class="org.springframework.jmx.JmxTestBean">
        <property name="name" value="TEST"/>
        <property name="age" value="100"/>
    </bean>

    <bean id="testBean2" class="org.springframework.jmx.JmxTestBean">
        <property name="name" value="ANOTHER TEST"/>
        <property name="age" value="200"/>
    </bean>

</beans>

（有关什么是 handback 对象的完整讨论，以及确实，什么是 A 是什么，请参阅 JMX 的部分规范（1.2）标题为“JMX 通知模型”。NotificationFilterspring-doc.cn

4.6.2. 发布通知

Spring 不仅支持注册接收，还支持用于发布 .NotificationsNotificationsspring-doc.cn

本节实际上仅与 Spring 管理的 bean 相关，这些 bean 具有通过 .任何现有的用户定义的 MBean 都应该使用标准 JMX API 发布通知。MBeanExporter

Spring 的 JMX 通知发布支持中的关键接口是接口（在包中定义）。任何将要通过实例导出为 MBean 可以实现相关接口来获取对实例的访问权。该接口通过一个简单的 setter 方法向实现 bean 提供 a 的实例，然后 Bean 可以使用它来发布。NotificationPublisherorg.springframework.jmx.export.notificationMBeanExporterNotificationPublisherAwareNotificationPublisherNotificationPublisherAwareNotificationPublisherNotificationsspring-doc.cn

如 NotificationPublisher 接口的 javadoc 中所述，通过该机制发布事件的受管 bean 不负责通知侦听器的状态管理。 Spring 的 JMX 支持负责处理所有 JMX 基础结构问题。作为应用程序开发人员，您需要做的就是实现接口并开始使用提供的实例。请注意，这是在托管 Bean 注册到 .NotificationPublisherNotificationPublisherAwareNotificationPublisherNotificationPublisherMBeanServerspring-doc.cn

使用实例非常简单。您创建一个 JMX 实例（或适当子类的实例），使用与要发生的事件相关的数据填充通知 published，并在实例上调用，传入 .NotificationPublisherNotificationNotificationsendNotification(Notification)NotificationPublisherNotificationspring-doc.cn

在以下示例中，每次调用该操作时，都会导出 publish a 的实例：JmxTestBeanNotificationEventadd(int, int)spring-doc.cn

package org.springframework.jmx;

import org.springframework.jmx.export.notification.NotificationPublisherAware;
import org.springframework.jmx.export.notification.NotificationPublisher;
import javax.management.Notification;

public class JmxTestBean implements IJmxTestBean, NotificationPublisherAware {

    private String name;
    private int age;
    private boolean isSuperman;
    private NotificationPublisher publisher;

    // other getters and setters omitted for clarity

    public int add(int x, int y) {
        int answer = x + y;
        this.publisher.sendNotification(new Notification("add", this, 0));
        return answer;
    }

    public void dontExposeMe() {
        throw new RuntimeException();
    }

    public void setNotificationPublisher(NotificationPublisher notificationPublisher) {
        this.publisher = notificationPublisher;
    }

}

界面和使其正常工作的机制是其中之一 Spring 的 JMX 支持的更好功能。然而，它的价格标签确实是将你的类耦合到 Spring 和 JMX。一如既往，这里的建议是务实。如果您需要和你可以接受到 Spring 和 JMX 的耦合，然后这样做。NotificationPublisherNotificationPublisherspring-doc.cn

4.7. 更多资源

本节包含指向有关 JMX 的更多资源的链接：spring-doc.cn

JMX Oracle 主页。spring-doc.cn
JMX 规范（JSR-000003）。spring-doc.cn
JMX 远程 API 规范（JSR-000160）。spring-doc.cn
MX4J 主页。（MX4J 是各种 JMX 规格。spring-doc.cn

5. JCA CCI

Java EE 提供了标准化对企业信息系统访问的规范（EIS）：JCA （Java EE 连接器架构）。本规范分为两个不同的部分：spring-doc.cn

连接器提供商必须实现的 SPI（服务提供商接口）。这些接口构成了可以部署在 Java EE 上的资源适配器应用程序服务器。在这种情况下，服务器管理连接池，事务和安全性（托管模式）。应用程序服务器还负责用于管理配置，该配置保存在客户端应用程序外部。一个连接器也可以在没有应用程序服务器的情况下使用。在这种情况下，应用程序必须直接配置它（非托管模式）。spring-doc.cn
应用程序可用于与连接器，从而与 EIS 通信。用于本地事务划分的 API 。spring-doc.cn

Spring CCI 支持的目的是提供类来访问 CCI 连接器典型的 Spring 风格，使用 Spring 框架的通用资源和事务管理设施。spring-doc.cn

连接器的客户端并不总是使用 CCI。一些连接器公开了自己的 API，提供 JCA 资源适配器以使用 Java EE 容器的系统协定（连接池、全局事务和安全性）。Spring 不提供特别支持此类特定于连接器的 API。

5.1. 配置 CCI

本节介绍如何配置通用客户端接口（CCI）。它包括以下主题：spring-doc.cn

5.1.1. 连接器配置

使用 JCA CCI 的基本资源是接口。连接器您必须提供此接口的实现。ConnectionFactoryspring-doc.cn

要使用连接器，您可以将其部署在应用程序服务器上，并从服务器的 JNDI 环境（托管模式）获取连接器。连接器必须打包为 RAR 文件（资源适配器存档）并包含一个文件描述其部署特征。指定资源的实际名称部署它时。要在 Spring 中访问它，你可以使用 Spring 的 or 通过其 JNDI 名称获取工厂。ConnectionFactoryra.xmlJndiObjectFactoryBean<jee:jndi-lookup>spring-doc.cn

使用连接器的另一种方法是将其嵌入到应用程序中（非托管模式）和不使用应用程序服务器来部署和配置它。Spring 提供了可以通过名为 ().这样，您只需要类路径（无需 RAR 文件，也不需要 Descriptors）。库必须是如有必要，从连接器的 RAR 文件中提取。FactoryBeanLocalConnectionFactoryBeanra.xmlspring-doc.cn

一旦您有权访问您的实例，您可以将其注入到您的组件。这些组件可以根据普通 CCI API 进行编码，或者使用 Spring 的支持类进行 CCI 访问（例如）。ConnectionFactoryCciTemplatespring-doc.cn

在非托管模式下使用连接器时，无法使用全局事务，因为资源永远不会在当前线程。资源不知道任何全局 Java EE 事务可能正在运行。

5.1.2. Spring 中的配置`ConnectionFactory`

要连接到 EIS，您需要从应用程序服务器（如果您处于托管模式）或直接从 Spring （如果您处于托管模式）在非托管模式下）。ConnectionFactoryspring-doc.cn

在托管模式下，您可以从 JNDI 访问 a。它的属性是在 Application Server 中配置。以下示例显示了如何执行此操作：ConnectionFactoryspring-doc.cn

<jee:jndi-lookup id="eciConnectionFactory" jndi-name="eis/cicseci"/>

在非托管模式下，您必须配置要在将 Spring 配置为 JavaBean。该课程提供这个设置样式，传入连接器，公开应用程序级 CCI 。以下示例演示如何执行此操作：ConnectionFactoryLocalConnectionFactoryBeanManagedConnectionFactoryConnectionFactoryspring-doc.cn

<bean id="eciManagedConnectionFactory" class="com.ibm.connector2.cics.ECIManagedConnectionFactory">
    <property name="serverName" value="TXSERIES"/>
    <property name="connectionURL" value="tcp://localhost/"/>
    <property name="portNumber" value="2006"/>
</bean>

<bean id="eciConnectionFactory" class="org.springframework.jca.support.LocalConnectionFactoryBean">
    <property name="managedConnectionFactory" ref="eciManagedConnectionFactory"/>
</bean>

您不能直接实例化特定的 .你需要通过接口的相应实现连接器。此接口是 JCA SPI 规范的一部分。ConnectionFactoryManagedConnectionFactory

5.1.3. 配置 CCI 连接

JCA CCI 允许您使用连接器的实施来配置与 EIS 的连接。要配置其属性，请执行以下操作：您需要使用专用适配器 .您可以使用属性（作为内部 Bean）配置 dedicated。ConnectionSpecConnectionSpecConnectionFactoryAdapterConnectionSpecconnectionSpecspring-doc.cn

此属性不是必需的，因为 CCI 接口定义了两个获取 CCI 连接的不同方法。您通常可以配置一些属性在 Application Server（在托管模式下）或相应的本地实现。以下清单显示了接口定义的相关部分：ConnectionFactoryConnectionSpecManagedConnectionFactoryConnectionFactoryspring-doc.cn

public interface ConnectionFactory implements Serializable, Referenceable {
    ...
    Connection getConnection() throws ResourceException;
    Connection getConnection(ConnectionSpec connectionSpec) throws ResourceException;
    ...
}

Spring 提供了一个，允许你指定一个实例来用于给定工厂上的所有操作。如果指定了适配器的属性，则适配器使用 variant 替换为参数。否则，适配器将使用不带该参数的变体。以下示例显示如何配置：ConnectionSpecConnectionFactoryAdapterConnectionSpecconnectionSpecgetConnectionConnectionSpecConnectionSpecConnectionFactoryAdapterspring-doc.cn

<bean id="managedConnectionFactory"
        class="com.sun.connector.cciblackbox.CciLocalTxManagedConnectionFactory">
    <property name="connectionURL" value="jdbc:hsqldb:hsql://localhost:9001"/>
    <property name="driverName" value="org.hsqldb.jdbcDriver"/>
</bean>

<bean id="targetConnectionFactory"
        class="org.springframework.jca.support.LocalConnectionFactoryBean">
    <property name="managedConnectionFactory" ref="managedConnectionFactory"/>
</bean>

<bean id="connectionFactory"
        class="org.springframework.jca.cci.connection.ConnectionSpecConnectionFactoryAdapter">
    <property name="targetConnectionFactory" ref="targetConnectionFactory"/>
    <property name="connectionSpec">
        <bean class="com.sun.connector.cciblackbox.CciConnectionSpec">
            <property name="user" value="sa"/>
            <property name="password" value=""/>
        </bean>
    </property>
</bean>

5.1.4. 使用单个 CCI 连接

如果要使用单个 CCI 连接， Spring 提供了另一个适配器来管理它。adapter 类懒惰地打开一个连接，并在此 bean 在应用程序关闭。此类公开行为因此，所有 Al S 都共享相同的底层物理连接。以下示例演示如何使用 Adapter 类：ConnectionFactorySingleConnectionFactoryConnectionSingleConnectionFactoryspring-doc.cn

<bean id="eciManagedConnectionFactory"
        class="com.ibm.connector2.cics.ECIManagedConnectionFactory">
    <property name="serverName" value="TEST"/>
    <property name="connectionURL" value="tcp://localhost/"/>
    <property name="portNumber" value="2006"/>
</bean>

<bean id="targetEciConnectionFactory"
        class="org.springframework.jca.support.LocalConnectionFactoryBean">
    <property name="managedConnectionFactory" ref="eciManagedConnectionFactory"/>
</bean>

<bean id="eciConnectionFactory"
        class="org.springframework.jca.cci.connection.SingleConnectionFactory">
    <property name="targetConnectionFactory" ref="targetEciConnectionFactory"/>
</bean>

此适配器不能直接配置 . 如果您需要特定 .ConnectionFactoryConnectionSpecConnectionSpecConnectionFactoryAdapterSingleConnectionFactoryConnectionSpec

5.2. 使用 Spring 的 CCI Access 支持

本节介绍如何使用 Spring 对 CCI 的支持来实现各种目的。它包括以下主题：spring-doc.cn

5.2.1. 记录转换

Spring 的 JCA CCI 支持的目标之一是为操作 CCI 记录。您可以指定策略来创建记录并提取 data from records 的 .中描述的接口如果您不想，此部分将策略配置为使用输入和输出记录直接在应用程序中使用记录。CciTemplatespring-doc.cn

要创建 input ，您可以使用接口的专用实现。下面的清单显示了接口定义：RecordRecordCreatorRecordCreatorspring-doc.cn

public interface RecordCreator {

    Record createRecord(RecordFactory recordFactory) throws ResourceException, DataAccessException;

}

该方法接收实例作为参数，该参数对应于 used. 您可以使用此引用来创建或实例。这以下示例演示如何使用接口和 indexed 或 mapped 记录：createRecord(..)RecordFactoryRecordFactoryConnectionFactoryIndexedRecordMappedRecordRecordCreatorspring-doc.cn

public class MyRecordCreator implements RecordCreator {

    public Record createRecord(RecordFactory recordFactory) throws ResourceException {
        IndexedRecord input = recordFactory.createIndexedRecord("input");
        input.add(new Integer(id));
        return input;
    }

}

您可以使用输出从 EIS 接收回数据。因此，您可以传递一个特定的实现 Spring 的接口以从 output 中提取数据。下面的清单显示了接口定义：RecordRecordExtractorCciTemplateRecordRecordExtractorspring-doc.cn

public interface RecordExtractor {

    Object extractData(Record record) throws ResourceException, SQLException, DataAccessException;

}

以下示例演示如何使用该接口：RecordExtractorspring-doc.cn

public class MyRecordExtractor implements RecordExtractor {

    public Object extractData(Record record) throws ResourceException {
        CommAreaRecord commAreaRecord = (CommAreaRecord) record;
        String str = new String(commAreaRecord.toByteArray());
        String field1 = string.substring(0,6);
        String field2 = string.substring(6,1);
        return new OutputObject(Long.parseLong(field1), field2);
    }

}

5.2.2. 使用`CciTemplate`

是核心 CCI 支持包（）的中心类。它简化了 CCI 的使用，因为它处理资源的创建和释放。这有助于避免常见错误，例如忘记始终关闭连接。它关心连接和交互的生命周期对象，让应用程序代码专注于从应用程序生成输入记录 data 和从输出记录中提取应用程序数据。CciTemplateorg.springframework.jca.cci.corespring-doc.cn

JCA CCI 规范定义了在 EIS 上调用操作的两种不同方法。这 CCI 接口提供了两种 execute 方法签名，如下所示列表显示：Interactionspring-doc.cn

public interface javax.resource.cci.Interaction {

    ...

    boolean execute(InteractionSpec spec, Record input, Record output) throws ResourceException;

    Record execute(InteractionSpec spec, Record input) throws ResourceException;

    ...

}

根据调用的模板方法，知道哪个方法调用交互。在任何情况下，正确初始化的实例都是必需的。CciTemplateexecuteInteractionSpecspring-doc.cn

您可以通过两种方式使用：CciTemplate.execute(..)spring-doc.cn

使用直接参数。在这种情况下，您需要传入 CCI 输入 record，返回的对象是对应的 CCI 输出记录。Recordspring-doc.cn
对于应用程序对象，通过使用记录映射。在这种情况下，您需要提供相应的和实例。RecordCreatorRecordExtractorspring-doc.cn

对于第一种方法，使用模板的以下方法（直接对应于界面上的方法）：Interactionspring-doc.cn

public class CciTemplate implements CciOperations {

    public Record execute(InteractionSpec spec, Record inputRecord)
            throws DataAccessException { ... }

    public void execute(InteractionSpec spec, Record inputRecord, Record outputRecord)
            throws DataAccessException { ... }

}

使用第二种方法，我们需要指定记录创建和记录提取策略作为参数。使用的接口是上一节记录转换中描述的接口。以下内容清单显示了相应的方法：CciTemplatespring-doc.cn

public class CciTemplate implements CciOperations {

    public Record execute(InteractionSpec spec,
            RecordCreator inputCreator) throws DataAccessException {
        // ...
    }

    public Object execute(InteractionSpec spec, Record inputRecord,
            RecordExtractor outputExtractor) throws DataAccessException {
        // ...
    }

    public Object execute(InteractionSpec spec, RecordCreator creator,
            RecordExtractor extractor) throws DataAccessException {
        // ...
    }

}

除非在模板上设置了该属性（请参阅以下内容部分），每个方法都使用两个参数调用 CCI 的相应方法：和一个 input 。它接收一个 output 作为其返回值。outputRecordCreatorexecuteInteractionInteractionSpecRecordRecordspring-doc.cn

CciTemplate还提供了通过 ITS AND 方法在实现之外创建和运行的方法。您可以在 DAO 实现中使用它来创建实例以传递到相应的方法。下面的清单显示了接口定义：IndexRecordMappedRecordRecordCreatorcreateIndexRecord(..)createMappedRecord(..)RecordCciTemplate.execute(..)CciTemplatespring-doc.cn

public class CciTemplate implements CciOperations {

    public IndexedRecord createIndexedRecord(String name) throws DataAccessException { ... }

    public MappedRecord createMappedRecord(String name) throws DataAccessException { ... }

}

5.2.3. 使用 DAO 支持

Spring 的 CCI 支持为 DAO 提供了一个抽象类，支持注入 a 或 a 实例。类的名称为。它提供了简单和方法。在内部，此类为 passed-in 创建一个实例，将其公开给子类中的具体数据访问实现。以下示例演示如何使用：ConnectionFactoryCciTemplateCciDaoSupportsetConnectionFactorysetCciTemplateCciTemplateConnectionFactoryCciDaoSupportspring-doc.cn

public abstract class CciDaoSupport {

    public void setConnectionFactory(ConnectionFactory connectionFactory) {
        // ...
    }

    public ConnectionFactory getConnectionFactory() {
        // ...
    }

    public void setCciTemplate(CciTemplate cciTemplate) {
        // ...
    }

    public CciTemplate getCciTemplate() {
        // ...
    }

}

5.2.4. 自动生成输出记录

如果您使用的连接器仅支持带有 input 和 output records 作为参数（即，它需要传递所需的 output record） in 而不是返回适当的输出记录），则可以设置的属性以自动生成要由 JCA 连接器。然后，此记录将返回给调用方的模板。Interaction.execute(..)outputRecordCreatorCciTemplatespring-doc.cn

此属性包含 RecordCreator 接口用于该目的。您必须直接在这。以下示例显示了如何执行此操作：outputRecordCreatorCciTemplatespring-doc.cn

cciTemplate.setOutputRecordCreator(new EciOutputRecordCreator());

或者（我们推荐这种方法），在 Spring 配置中，如果被配置为专用 bean 实例，你可以在追随时尚：CciTemplatespring-doc.cn

<bean id="eciOutputRecordCreator" class="eci.EciOutputRecordCreator"/>

<bean id="cciTemplate" class="org.springframework.jca.cci.core.CciTemplate">
    <property name="connectionFactory" ref="eciConnectionFactory"/>
    <property name="outputRecordCreator" ref="eciOutputRecordCreator"/>
</bean>

由于该类是线程安全的，因此它通常配置为共享的实例。CciTemplate

5.2.5. 小结`CciTemplateInteraction`

下表总结了该类的机制，而在 CCI 接口上调用的相应方法：CciTemplateInteractionspring-doc.cn

表 9.Interaction 执行方法的使用
`CciTemplate`方法签名	`CciTemplate` `outputRecordCreator`财产	`execute`在 CCI 交互上调用的方法
`Record execute(InteractionSpec, Record)`spring-doc.cn	未设置spring-doc.cn	`Record execute(InteractionSpec, Record)`spring-doc.cn
`Record execute(InteractionSpec, Record)`spring-doc.cn	设置spring-doc.cn	`boolean execute(InteractionSpec, Record, Record)`spring-doc.cn
无效执行（交互规范、记录、记录）spring-doc.cn	未设置spring-doc.cn	无效执行（交互规范、记录、记录）spring-doc.cn
`void execute(InteractionSpec, Record, Record)`spring-doc.cn	设置spring-doc.cn	`void execute(InteractionSpec, Record, Record)`spring-doc.cn
`Record execute(InteractionSpec, RecordCreator)`spring-doc.cn	未设置spring-doc.cn	`Record execute(InteractionSpec, Record)`spring-doc.cn
`Record execute(InteractionSpec, RecordCreator)`spring-doc.cn	设置spring-doc.cn	`void execute(InteractionSpec, Record, Record)`spring-doc.cn
`Record execute(InteractionSpec, Record, RecordExtractor)`spring-doc.cn	未设置spring-doc.cn	`Record execute(InteractionSpec, Record)`spring-doc.cn
`Record execute(InteractionSpec, Record, RecordExtractor)`spring-doc.cn	设置spring-doc.cn	`void execute(InteractionSpec, Record, Record)`spring-doc.cn
`Record execute(InteractionSpec, RecordCreator, RecordExtractor)`spring-doc.cn	未设置spring-doc.cn	`Record execute(InteractionSpec, Record)`spring-doc.cn
`Record execute(InteractionSpec, RecordCreator, RecordExtractor)`spring-doc.cn	设置spring-doc.cn	`void execute(InteractionSpec, Record, Record)`spring-doc.cn

5.2.6. 直接使用 CCI 连接和交互

CciTemplate还允许您直接使用 CCI 连接和交互，方式与和相同。这很有用当您想对 CCI 连接或交互执行多个操作时，对于例。JdbcTemplateJmsTemplatespring-doc.cn

该接口提供 CCI 作为参数（将对其执行自定义操作）以及用于创建的 CCI。后者可能很有用（例如，获取关联的实例并创建索引/映射记录）。下面的清单显示了接口定义：ConnectionCallbackConnectionConnectionFactoryConnectionRecordFactoryConnectionCallbackspring-doc.cn

public interface ConnectionCallback {

    Object doInConnection(Connection connection, ConnectionFactory connectionFactory)
            throws ResourceException, SQLException, DataAccessException;

}

该接口提供 CCI（以执行自定义操作）加上相应的 CCI 。下面的清单显示了接口定义：InteractionCallbackInteractionConnectionFactoryInteractionCallbackspring-doc.cn

public interface InteractionCallback {

    Object doInInteraction(Interaction interaction, ConnectionFactory connectionFactory)
        throws ResourceException, SQLException, DataAccessException;

}

InteractionSpec对象可以在多个模板调用之间共享，也可以是新的在每个回调方法中创建。这完全取决于 DAO 实现。

5.2.7. 使用示例`CciTemplate`

在本节中，我们将展示的用法来访问 CICS，其中包含 ECI 模式，使用 IBM CICS ECI 连接器。CciTemplatespring-doc.cn

首先，我们必须对 CCI 进行一些初始化，以指定 CICS 程序来访问以及如何与之交互，如下例所示：InteractionSpecspring-doc.cn

ECIInteractionSpec interactionSpec = new ECIInteractionSpec();
interactionSpec.setFunctionName("MYPROG");
interactionSpec.setInteractionVerb(ECIInteractionSpec.SYNC_SEND_RECEIVE);

然后程序可以通过 Spring 的模板使用 CCI，并指定自定义 objects 和 CCI ，如下例所示：Recordsspring-doc.cn

public class MyDaoImpl extends CciDaoSupport implements MyDao {

    public OutputObject getData(InputObject input) {
        ECIInteractionSpec interactionSpec = ...;

    OutputObject output = (ObjectOutput) getCciTemplate().execute(interactionSpec,
        new RecordCreator() {
            public Record createRecord(RecordFactory recordFactory) throws ResourceException {
                return new CommAreaRecord(input.toString().getBytes());
            }
        },
        new RecordExtractor() {
            public Object extractData(Record record) throws ResourceException {
                CommAreaRecord commAreaRecord = (CommAreaRecord)record;
                String str = new String(commAreaRecord.toByteArray());
                String field1 = string.substring(0,6);
                String field2 = string.substring(6,1);
                return new OutputObject(Long.parseLong(field1), field2);
            }
        });

        return output;
    }
}

如前所述，您可以使用回调直接处理 CCI 连接或相互作用。以下示例显示了如何执行此操作：spring-doc.cn

public class MyDaoImpl extends CciDaoSupport implements MyDao {

    public OutputObject getData(InputObject input) {
        ObjectOutput output = (ObjectOutput) getCciTemplate().execute(
            new ConnectionCallback() {
                public Object doInConnection(Connection connection,
                        ConnectionFactory factory) throws ResourceException {

                    // do something...

                }
            });
        }
        return output;
    }

}

使用，used 由管理和关闭，但回调实现必须管理在连接。ConnectionCallbackConnectionCciTemplate

对于更具体的回调，您可以实现 .如果这样做，则传入的 .以下示例显示了如何执行此操作：InteractionCallbackInteractionCciTemplatespring-doc.cn

public class MyDaoImpl extends CciDaoSupport implements MyDao {

    public String getData(String input) {
        ECIInteractionSpec interactionSpec = ...;
        String output = (String) getCciTemplate().execute(interactionSpec,
            new InteractionCallback() {
                public Object doInInteraction(Interaction interaction,
                        ConnectionFactory factory) throws ResourceException {
                    Record input = new CommAreaRecord(inputString.getBytes());
                    Record output = new CommAreaRecord();
                    interaction.execute(holder.getInteractionSpec(), input, output);
                    return new String(output.toByteArray());
                }
            });
        return output;
    }

}

对于前面的示例，所涉及的 Spring bean 的相应配置在非托管模式下可能类似于以下示例：spring-doc.cn

<bean id="managedConnectionFactory" class="com.ibm.connector2.cics.ECIManagedConnectionFactory">
    <property name="serverName" value="TXSERIES"/>
    <property name="connectionURL" value="local:"/>
    <property name="userName" value="CICSUSER"/>
    <property name="password" value="CICS"/>
</bean>

<bean id="connectionFactory" class="org.springframework.jca.support.LocalConnectionFactoryBean">
    <property name="managedConnectionFactory" ref="managedConnectionFactory"/>
</bean>

<bean id="component" class="mypackage.MyDaoImpl">
    <property name="connectionFactory" ref="connectionFactory"/>
</bean>

在托管模式（即在 Java EE 环境中）下，配置可能类似于以下示例：spring-doc.cn

<jee:jndi-lookup id="connectionFactory" jndi-name="eis/cicseci"/>

<bean id="component" class="MyDaoImpl">
    <property name="connectionFactory" ref="connectionFactory"/>
</bean>

5.3. 将 CCI 访问建模为操作对象

该软件包包含支持类，允许您以不同的样式访问 EIS：通过可重用的操作对象，类似于 Spring 的 JDBC 操作对象（参见 Data Access 章节）。这通常封装了 CCI API。应用程序级 input 对象传递给 Operation 对象，因此它可以构造 input record，并且然后将接收到的记录数据转换为应用程序级输出对象并返回。org.springframework.jca.cci.objectspring-doc.cn

这种方法在内部基于 class 和 or 接口，重用了 Spring 的核心 CCI 支持的机制。CciTemplateRecordCreatorRecordExtractor

5.3.1. 使用`MappingRecordOperation`

MappingRecordOperation本质上执行与 but 相同的工作将特定的预配置操作表示为对象。它提供了两个模板指定如何将输入对象转换为输入记录以及如何转换的方法将输出记录转换为输出对象（记录映射）：CciTemplatespring-doc.cn

createInputRecord(..)：指定如何将输入对象转换为输入Recordspring-doc.cn
extractOutputData(..)：指定如何从输出中提取输出对象Recordspring-doc.cn

下面的清单显示了这些方法的签名：spring-doc.cn

public abstract class MappingRecordOperation extends EisOperation {

    ...

    protected abstract Record createInputRecord(RecordFactory recordFactory,
            Object inputObject) throws ResourceException, DataAccessException {
        // ...
    }

    protected abstract Object extractOutputData(Record outputRecord)
            throws ResourceException, SQLException, DataAccessException {
        // ...
    }

    ...

}

此后，要执行 EIS 操作，您需要使用单个方法，传入应用程序级输入对象并接收应用程序级 output 对象作为结果。以下示例显示了如何执行此操作：executespring-doc.cn

public abstract class MappingRecordOperation extends EisOperation {

    ...

    public Object execute(Object inputObject) throws DataAccessException {
    }

    ...
}

与类相反，此方法不会有一个 as 参数。相反，它是操作。您必须使用以下构造函数来实例化 operation 对象使用特定的 .以下示例显示了如何执行此操作：CciTemplateexecute(..)InteractionSpecInteractionSpecInteractionSpecspring-doc.cn

InteractionSpec spec = ...;
MyMappingRecordOperation eisOperation = new MyMappingRecordOperation(getConnectionFactory(), spec);
...

5.3.2. 使用`MappingCommAreaOperation`

某些连接器使用基于 COMMAREA 的记录，COMMAREA 表示字节数组其中包含要发送到 EIS 的参数及其返回的数据。Spring 提供了一个 special 操作类，用于直接处理 COMMAREA 而不是记录。该类扩展了类以提供这个特殊的 COMMAREA 支持。它隐式地使用类作为输入和 output record 类型，并提供两种新方法将 Input 对象转换为输入 COMMAREA 并将输出 COMMAREA 转换为输出对象。以下内容清单显示了相关的方法签名：MappingCommAreaOperationMappingRecordOperationCommAreaRecordspring-doc.cn

public abstract class MappingCommAreaOperation extends MappingRecordOperation {

    ...

    protected abstract byte[] objectToBytes(Object inObject)
            throws IOException, DataAccessException;

    protected abstract Object bytesToObject(byte[] bytes)
        throws IOException, DataAccessException;

    ...

}

5.3.3. 自动生成输出记录

由于每个子类内部都基于 CciTemplate，因此相同的自动生成输出记录的方法。每个操作对象都提供相应的方法。有关更多信息，请参阅自动生成输出记录。MappingRecordOperationCciTemplatesetOutputRecordCreator(..)spring-doc.cn

5.3.4. 小结

操作对象方法以与类相同的方式使用记录。CciTemplatespring-doc.cn

表 10.Interaction 执行方法的使用
`MappingRecordOperation`方法签名	`MappingRecordOperation` `outputRecordCreator`财产	`execute`在 CCI 交互上调用的方法
`Object execute(Object)`spring-doc.cn	未设置spring-doc.cn	`Record execute(InteractionSpec, Record)`spring-doc.cn
`Object execute(Object)`spring-doc.cn	设置spring-doc.cn	`boolean execute(InteractionSpec, Record, Record)`spring-doc.cn

5.3.5. 使用示例`MappingRecordOperation`

在本节中，我们将展示如何使用来访问数据库。MappingRecordOperationspring-doc.cn

此连接器的原始版本由 Java EE SDK（版本 1.3）提供。可从 Oracle 获得。

首先，您必须对 CCI 进行一些初始化，以指定要执行的 SQL 请求。在下面的示例中，我们直接定义了将对 CCI 记录的请求参数以及转换 CCI 结果记录的方法添加到类的实例中：InteractionSpecPersonspring-doc.cn

public class PersonMappingOperation extends MappingRecordOperation {

    public PersonMappingOperation(ConnectionFactory connectionFactory) {
        setConnectionFactory(connectionFactory);
        CciInteractionSpec interactionSpec = new CciConnectionSpec();
        interactionSpec.setSql("select * from person where person_id=?");
        setInteractionSpec(interactionSpec);
    }

    protected Record createInputRecord(RecordFactory recordFactory,
            Object inputObject) throws ResourceException {
        Integer id = (Integer) inputObject;
        IndexedRecord input = recordFactory.createIndexedRecord("input");
        input.add(new Integer(id));
        return input;
    }

    protected Object extractOutputData(Record outputRecord)
            throws ResourceException, SQLException {
        ResultSet rs = (ResultSet) outputRecord;
        Person person = null;
        if (rs.next()) {
            Person person = new Person();
            person.setId(rs.getInt("person_id"));
            person.setLastName(rs.getString("person_last_name"));
            person.setFirstName(rs.getString("person_first_name"));
        }
        return person;
    }
}

然后，应用程序可以执行操作对象，并将人员标识符作为论点。请注意，您可以将 operation 对象设置为共享实例，因为它是线程安全。下面以 person 标识符作为论点：spring-doc.cn

public class MyDaoImpl extends CciDaoSupport implements MyDao {

    public Person getPerson(int id) {
        PersonMappingOperation query = new PersonMappingOperation(getConnectionFactory());
        Person person = (Person) query.execute(new Integer(id));
        return person;
    }
}

在非 managed 模式下，Spring bean 的相应配置可能如下所示：spring-doc.cn

<bean id="managedConnectionFactory"
        class="com.sun.connector.cciblackbox.CciLocalTxManagedConnectionFactory">
    <property name="connectionURL" value="jdbc:hsqldb:hsql://localhost:9001"/>
    <property name="driverName" value="org.hsqldb.jdbcDriver"/>
</bean>

<bean id="targetConnectionFactory"
        class="org.springframework.jca.support.LocalConnectionFactoryBean">
    <property name="managedConnectionFactory" ref="managedConnectionFactory"/>
</bean>

<bean id="connectionFactory"
        class="org.springframework.jca.cci.connection.ConnectionSpecConnectionFactoryAdapter">
    <property name="targetConnectionFactory" ref="targetConnectionFactory"/>
    <property name="connectionSpec">
        <bean class="com.sun.connector.cciblackbox.CciConnectionSpec">
            <property name="user" value="sa"/>
            <property name="password" value=""/>
        </bean>
    </property>
</bean>

<bean id="component" class="MyDaoImpl">
    <property name="connectionFactory" ref="connectionFactory"/>
</bean>

在托管模式（即在 Java EE 环境中）中，配置可以是遵循：spring-doc.cn

<jee:jndi-lookup id="targetConnectionFactory" jndi-name="eis/blackbox"/>

<bean id="connectionFactory"
        class="org.springframework.jca.cci.connection.ConnectionSpecConnectionFactoryAdapter">
    <property name="targetConnectionFactory" ref="targetConnectionFactory"/>
    <property name="connectionSpec">
        <bean class="com.sun.connector.cciblackbox.CciConnectionSpec">
            <property name="user" value="sa"/>
            <property name="password" value=""/>
        </bean>
    </property>
</bean>

<bean id="component" class="MyDaoImpl">
    <property name="connectionFactory" ref="connectionFactory"/>
</bean>

5.3.6. 使用示例`MappingCommAreaOperation`

在本节中，我们将展示如何使用 the 的用法来访问具有 IBM CICS ECI 连接器的 ECI 模式的 CICS。MappingCommAreaOperationspring-doc.cn

首先，我们需要初始化 CCI 以指定哪个 CICS 程序访问以及如何与之交互，如下例所示：InteractionSpecspring-doc.cn

public abstract class EciMappingOperation extends MappingCommAreaOperation {

    public EciMappingOperation(ConnectionFactory connectionFactory, String programName) {
        setConnectionFactory(connectionFactory);
        ECIInteractionSpec interactionSpec = new ECIInteractionSpec(),
        interactionSpec.setFunctionName(programName);
        interactionSpec.setInteractionVerb(ECIInteractionSpec.SYNC_SEND_RECEIVE);
        interactionSpec.setCommareaLength(30);
        setInteractionSpec(interactionSpec);
        setOutputRecordCreator(new EciOutputRecordCreator());
    }

    private static class EciOutputRecordCreator implements RecordCreator {
        public Record createRecord(RecordFactory recordFactory) throws ResourceException {
            return new CommAreaRecord();
        }
    }

}

然后我们可以子类化抽象类来指定映射在自定义对象和之间，如下例所示：EciMappingOperationRecordsspring-doc.cn

public class MyDaoImpl extends CciDaoSupport implements MyDao {

    public OutputObject getData(Integer id) {
        EciMappingOperation query = new EciMappingOperation(getConnectionFactory(), "MYPROG") {

            protected abstract byte[] objectToBytes(Object inObject) throws IOException {
                Integer id = (Integer) inObject;
                return String.valueOf(id);
            }

            protected abstract Object bytesToObject(byte[] bytes) throws IOException;
                String str = new String(bytes);
                String field1 = str.substring(0,6);
                String field2 = str.substring(6,1);
                String field3 = str.substring(7,1);
                return new OutputObject(field1, field2, field3);
            }
        });

        return (OutputObject) query.execute(new Integer(id));
    }

}

在非 managed 模式下，Spring bean 的相应配置可能如下所示：spring-doc.cn

<bean id="managedConnectionFactory" class="com.ibm.connector2.cics.ECIManagedConnectionFactory">
    <property name="serverName" value="TXSERIES"/>
    <property name="connectionURL" value="local:"/>
    <property name="userName" value="CICSUSER"/>
    <property name="password" value="CICS"/>
</bean>

<bean id="connectionFactory" class="org.springframework.jca.support.LocalConnectionFactoryBean">
    <property name="managedConnectionFactory" ref="managedConnectionFactory"/>
</bean>

<bean id="component" class="MyDaoImpl">
    <property name="connectionFactory" ref="connectionFactory"/>
</bean>

在托管模式（即在 Java EE 环境中）中，配置可以是遵循：spring-doc.cn

<jee:jndi-lookup id="connectionFactory" jndi-name="eis/cicseci"/>

<bean id="component" class="MyDaoImpl">
    <property name="connectionFactory" ref="connectionFactory"/>
</bean>

5.4. 交易

JCA 为资源适配器指定了多个级别的事务支持。的种类资源适配器支持的事务在其文件中指定。基本上有三个选项：无（例如，使用 CICS EPI 连接器）、本地事务（例如，使用 CICS ECI 连接器）和全局事务（例如，与 IMS 连接器一起使用）。以下示例配置 global 选项：ra.xmlspring-doc.cn

<connector>
    <resourceadapter>
        <!-- <transaction-support>NoTransaction</transaction-support> -->
        <!-- <transaction-support>LocalTransaction</transaction-support> -->
        <transaction-support>XATransaction</transaction-support>
    <resourceadapter>
<connector>

对于全局事务，您可以使用 Spring 的通用事务基础结构来划分事务，作为后端（委托给 Java EE 服务器的分布式事务协调器）。JtaTransactionManagerspring-doc.cn

对于单个 CCI 上的本地事务，Spring 提供了一个特定的 CCI 的事务管理策略，类似于 JDBC 的。CCI API 定义本地事务对象和相应的本地交易划分方法。Spring 的执行如下 local CCI 事务以完全符合 Spring 的泛型抽象的方式进行。以下示例配置了一个：ConnectionFactoryDataSourceTransactionManagerCciLocalTransactionManagerPlatformTransactionManagerCciLocalTransactionManagerspring-doc.cn

<jee:jndi-lookup id="eciConnectionFactory" jndi-name="eis/cicseci"/>

<bean id="eciTransactionManager"
        class="org.springframework.jca.cci.connection.CciLocalTransactionManager">
    <property name="connectionFactory" ref="eciConnectionFactory"/>
</bean>

您可以将这两种事务策略与 Spring 的任何事务划分一起使用设施，无论是声明式的还是编程式的。这是 Spring 的泛型抽象的结果，它将事务划分与实际执行策略。您可以根据需要在和之间切换，保持交易划分原样。PlatformTransactionManagerJtaTransactionManagerCciLocalTransactionManagerspring-doc.cn

有关 Spring 的事务工具的更多信息，请参见事务管理。spring-doc.cn

6. 电子邮件

本节介绍如何使用 Spring Framework 发送电子邮件。spring-doc.cn

库依赖项

以下 JAR 需要位于应用程序的类路径上，以便使用 Spring Framework 的电子邮件库：spring-doc.cn

JavaMail 库spring-doc.cn

此库在 Web 上免费提供 — 例如，在 Maven Central 中为 .com.sun.mail:javax.mailspring-doc.cn

Spring Framework 提供了一个有用的实用程序库，用于发送电子邮件，该库屏蔽了您从底层邮件系统的具体情况中了解，并负责代表客户端进行低级资源处理。spring-doc.cn

该包是 Spring 的根级包 Framework 的电子邮件支持。发送电子邮件的中心界面是界面。一个简单值对象，它封装了简单邮件的属性，例如 as 和（以及许多其他）是类。此软件包还包含已检查异常的层次结构，这些异常提供更高级别的对较低级别的 Mail System 异常进行抽象，根异常是。请参阅 javadoc 以了解有关富邮件异常层次结构的更多信息。org.springframework.mailMailSenderfromtoSimpleMailMessageMailExceptionspring-doc.cn

该界面添加了专门的 JavaMail 功能，例如对接口的 MIME 消息支持（它从中继承）。还提供了一个回调接口，用于准备一个 .org.springframework.mail.javamail.JavaMailSenderMailSenderJavaMailSenderorg.springframework.mail.javamail.MimeMessagePreparatorMimeMessagespring-doc.cn

6.1. 用法

假设我们有一个名为的业务接口，如下例所示：OrderManagerspring-doc.cn

public interface OrderManager {

    void placeOrder(Order order);

}

进一步假设我们有一个要求，声明带有需要生成订单号并将其发送给下达相关订单的客户。spring-doc.cn

6.1.1. 基本和用法`MailSenderSimpleMailMessage`

以下示例演示如何使用和发送电子邮件（当有人下订单时）：MailSenderSimpleMailMessagespring-doc.cn

import org.springframework.mail.MailException;
import org.springframework.mail.MailSender;
import org.springframework.mail.SimpleMailMessage;

public class SimpleOrderManager implements OrderManager {

    private MailSender mailSender;
    private SimpleMailMessage templateMessage;

    public void setMailSender(MailSender mailSender) {
        this.mailSender = mailSender;
    }

    public void setTemplateMessage(SimpleMailMessage templateMessage) {
        this.templateMessage = templateMessage;
    }

    public void placeOrder(Order order) {

        // Do the business calculations...

        // Call the collaborators to persist the order...

        // Create a thread safe "copy" of the template message and customize it
        SimpleMailMessage msg = new SimpleMailMessage(this.templateMessage);
        msg.setTo(order.getCustomer().getEmailAddress());
        msg.setText(
            "Dear " + order.getCustomer().getFirstName()
                + order.getCustomer().getLastName()
                + ", thank you for placing order. Your order number is "
                + order.getOrderNumber());
        try{
            this.mailSender.send(msg);
        }
        catch (MailException ex) {
            // simply log it and go on...
            System.err.println(ex.getMessage());
        }
    }

}

以下示例显示了上述代码的 Bean 定义：spring-doc.cn

<bean id="mailSender" class="org.springframework.mail.javamail.JavaMailSenderImpl">
    <property name="host" value="mail.mycompany.example"/>
</bean>

<!-- this is a template message that we can pre-load with default state -->
<bean id="templateMessage" class="org.springframework.mail.SimpleMailMessage">
    <property name="from" value="[email protected]"/>
    <property name="subject" value="Your order"/>
</bean>

<bean id="orderManager" class="com.mycompany.businessapp.support.SimpleOrderManager">
    <property name="mailSender" ref="mailSender"/>
    <property name="templateMessage" ref="templateMessage"/>
</bean>

6.1.2. 使用和`JavaMailSenderMimeMessagePreparator`

本节介绍使用 callback interface 的另一种实现。在下面的示例中，该属性是 type 的，以便我们能够使用 JavaMail 类：OrderManagerMimeMessagePreparatormailSenderJavaMailSenderMimeMessagespring-doc.cn

import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;

import javax.mail.internet.MimeMessage;
import org.springframework.mail.MailException;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.mail.javamail.MimeMessagePreparator;

public class SimpleOrderManager implements OrderManager {

    private JavaMailSender mailSender;

    public void setMailSender(JavaMailSender mailSender) {
        this.mailSender = mailSender;
    }

    public void placeOrder(final Order order) {
        // Do the business calculations...
        // Call the collaborators to persist the order...

        MimeMessagePreparator preparator = new MimeMessagePreparator() {
            public void prepare(MimeMessage mimeMessage) throws Exception {
                mimeMessage.setRecipient(Message.RecipientType.TO,
                        new InternetAddress(order.getCustomer().getEmailAddress()));
                mimeMessage.setFrom(new InternetAddress("[email protected]"));
                mimeMessage.setText("Dear " + order.getCustomer().getFirstName() + " " +
                        order.getCustomer().getLastName() + ", thanks for your order. " +
                        "Your order number is " + order.getOrderNumber() + ".");
            }
        };

        try {
            this.mailSender.send(preparator);
        }
        catch (MailException ex) {
            // simply log it and go on...
            System.err.println(ex.getMessage());
        }
    }

}

MAIL 代码是一个横切关注点，很可能是重构为自定义的 Spring AOP 方面，然后可以在目标上的适当连接点运行。OrderManager

Spring Framework 的邮件支持随标准 JavaMail 实现一起提供。有关更多信息，请参阅相关的 javadoc。spring-doc.cn

6.2. 使用 JavaMail`MimeMessageHelper`

在处理 JavaMail 消息时，一个非常方便的类是，它可以保护您免受必须使用冗长的 JavaMail API。使用，它是创建一个非常容易，如下例所示：org.springframework.mail.javamail.MimeMessageHelperMimeMessageHelperMimeMessagespring-doc.cn

// of course you would use DI in any real-world cases
JavaMailSenderImpl sender = new JavaMailSenderImpl();
sender.setHost("mail.host.com");

MimeMessage message = sender.createMimeMessage();
MimeMessageHelper helper = new MimeMessageHelper(message);
helper.setTo("[email protected]");
helper.setText("Thank you for ordering!");

sender.send(message);

6.2.1. 发送附件和内联资源

多部分电子邮件消息允许使用附件和内联资源。示例内联资源包括要在消息中使用的图像或样式表，但，您不希望显示为附件。spring-doc.cn

附件

以下示例演示如何使用发送电子邮件使用单个 JPEG 图像附件：MimeMessageHelperspring-doc.cn

JavaMailSenderImpl sender = new JavaMailSenderImpl();
sender.setHost("mail.host.com");

MimeMessage message = sender.createMimeMessage();

// use the true flag to indicate you need a multipart message
MimeMessageHelper helper = new MimeMessageHelper(message, true);
helper.setTo("[email protected]");

helper.setText("Check out this image!");

// let's attach the infamous windows Sample file (this time copied to c:/)
FileSystemResource file = new FileSystemResource(new File("c:/Sample.jpg"));
helper.addAttachment("CoolImage.jpg", file);

sender.send(message);

内联资源

以下示例演示如何使用发送电子邮件替换为内嵌图像：MimeMessageHelperspring-doc.cn

JavaMailSenderImpl sender = new JavaMailSenderImpl();
sender.setHost("mail.host.com");

MimeMessage message = sender.createMimeMessage();

// use the true flag to indicate you need a multipart message
MimeMessageHelper helper = new MimeMessageHelper(message, true);
helper.setTo("[email protected]");

// use the true flag to indicate the text included is HTML
helper.setText("<html><body><img src='cid:identifier1234'></body></html>", true);

// let's include the infamous windows Sample file (this time copied to c:/)
FileSystemResource res = new FileSystemResource(new File("c:/Sample.jpg"));
helper.addInline("identifier1234", res);

sender.send(message);

内联资源使用指定的（在上面的示例中）添加到中。添加文本的顺序和资源非常重要。请务必先添加文本，然后资源。如果你反过来做，它就行不通。MimeMessageContent-IDidentifier1234

6.2.2. 使用模板库创建电子邮件内容

前面几节所示示例中的代码显式创建了电子邮件的内容。通过使用方法调用（如 .这对于简单的情况很好，而且它在上述示例的上下文中是可以的，其目的是向您展示 API 的基础知识。message.setText(..)spring-doc.cn

但是，在典型的企业应用程序中，开发人员通常不会创建内容使用前面显示的方法的电子邮件消息，原因有很多：spring-doc.cn

在 Java 代码中创建基于 HTML 的电子邮件内容既乏味又容易出错。spring-doc.cn
显示逻辑和业务逻辑之间没有明确的区分。spring-doc.cn
更改电子邮件内容的显示结构需要编写 Java 代码， recomcompileing、redeploying 等。spring-doc.cn

通常，解决这些问题的方法是使用模板库（例如作为 FreeMarker）来定义电子邮件内容的显示结构。这会留下您的代码仅负责创建要在电子邮件模板中呈现的数据，以及发送电子邮件。当您的电子邮件内容变得相当复杂，并且，随着 Spring 框架对 FreeMarker，这变得很容易做到。spring-doc.cn

7. 任务执行和调度

Spring Framework 为任务。Spring 也具有支持线程池或委托给 CommonJ 中的请求。最终，这些通用接口背后的实现抽象出 Java 之间的差异 SE 5、Java SE 6 和 Java EE 环境。TaskExecutorTaskSchedulerspring-doc.cn

Spring 还具有集成类来支持使用（自 1.3 起的 JDK 的一部分）和 Quartz Scheduler （ https://www.quartz-scheduler.org/）进行调度。您可以分别使用具有对或实例的可选引用来设置这两个计划程序。此外，两者都有便利类 Quartz Scheduler 和 is available 允许您调用现有目标对象（类似于正常操作）。TimerFactoryBeanTimerTriggerTimerMethodInvokingFactoryBeanspring-doc.cn

7.1. Spring 抽象`TaskExecutor`

Executors 是线程池概念的 JDK 名称。“executor” 命名是由于无法保证底层实现是实际上是一个游泳池。执行程序可以是单线程的，甚至可以是同步的。Spring的 abstraction 隐藏了 Java SE 和 Java EE 环境之间的实现细节。spring-doc.cn

Spring 的接口与接口相同。事实上，最初它存在的主要原因是抽象出来使用线程池时需要 Java 5。该接口只有一个方法（）接受基于语义的任务执行以及线程池的配置。TaskExecutorjava.util.concurrent.Executorexecute(Runnable task)spring-doc.cn

最初创建它是为了给其他 Spring 组件一个抽象用于需要的线程池。组件（如、 JMS 和 Quartz 集成都使用抽象来池化线程。但是，如果您的 bean 需要线程池行为，您也可以根据自己的需要使用此抽象。TaskExecutorApplicationEventMulticasterAbstractMessageListenerContainerTaskExecutorspring-doc.cn

7.1.1. 类型`TaskExecutor`

Spring 包含许多预构建的 . 您很可能永远不需要实现自己的。 Spring 提供的变体如下：TaskExecutorspring-doc.cn

SyncTaskExecutor: 此实现不会异步运行调用。相反，每个调用发生在调用线程中。它主要用于各种情况不需要多线程处理，例如在简单的测试用例中。spring-doc.cn
SimpleAsyncTaskExecutor: 此实现不会重用任何线程。相反，它会启动一个新线程对于每个调用。但是，它确实支持阻止在释放槽之前超过限制的任何调用。如果你正在寻找真正的池化，请参阅此列表后面的。ThreadPoolTaskExecutorspring-doc.cn
ConcurrentTaskExecutor: 此实现是实例的适配器。还有另一种（）将配置参数公开为 Bean 属性。很少需要直接使用。但是，如果不是足够灵活，满足您的需求，是一种选择。java.util.concurrent.ExecutorThreadPoolTaskExecutorExecutorConcurrentTaskExecutorThreadPoolTaskExecutorConcurrentTaskExecutorspring-doc.cn
ThreadPoolTaskExecutor: 此实现是最常用的。它公开了配置 a 并将其包装在 . 如果您需要适应不同类型的，我们建议您改用 A。java.util.concurrent.ThreadPoolExecutorTaskExecutorjava.util.concurrent.ExecutorConcurrentTaskExecutorspring-doc.cn
WorkManagerTaskExecutor: 此实现使用 CommonJ 作为其后备服务提供商，并且是设置基于 CommonJ 的线程池的中心便捷类在 Spring 应用程序上下文中的 WebLogic 或 WebSphere 上的集成。WorkManagerspring-doc.cn
DefaultManagedTaskExecutor: 此实现使用在 JSR-236 中获得的 JNDI 兼容的运行时环境（例如 Java EE 7+ 应用程序服务器），为此，替换 CommonJ WorkManager。ManagedExecutorServicespring-doc.cn

7.1.2. 使用`TaskExecutor`

Spring 的实现被用作简单的 JavaBeans。在以下示例中，我们定义了一个 bean，它使用来异步打印输出一组消息：TaskExecutorThreadPoolTaskExecutorspring-doc.cn

import org.springframework.core.task.TaskExecutor;

public class TaskExecutorExample {

    private class MessagePrinterTask implements Runnable {

        private String message;

        public MessagePrinterTask(String message) {
            this.message = message;
        }

        public void run() {
            System.out.println(message);
        }
    }

    private TaskExecutor taskExecutor;

    public TaskExecutorExample(TaskExecutor taskExecutor) {
        this.taskExecutor = taskExecutor;
    }

    public void printMessages() {
        for(int i = 0; i < 25; i++) {
            taskExecutor.execute(new MessagePrinterTask("Message" + i));
        }
    }
}

如您所见，而不是从池中检索线程并自己执行它，您将 your 添加到队列中。然后使用其内部规则确定任务的运行时间。RunnableTaskExecutorspring-doc.cn

为了配置使用的规则，我们公开了简单的 bean 属性：TaskExecutorspring-doc.cn

<bean id="taskExecutor" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
    <property name="corePoolSize" value="5"/>
    <property name="maxPoolSize" value="10"/>
    <property name="queueCapacity" value="25"/>
</bean>

<bean id="taskExecutorExample" class="TaskExecutorExample">
    <constructor-arg ref="taskExecutor"/>
</bean>

7.2. Spring 抽象`TaskScheduler`

除了抽象之外，Spring 3.0 还引入了多种方法，用于调度任务在将来的某个时间点运行。下面的清单显示了接口定义：TaskExecutorTaskSchedulerTaskSchedulerspring-doc.cn

public interface TaskScheduler {

    ScheduledFuture schedule(Runnable task, Trigger trigger);

    ScheduledFuture schedule(Runnable task, Instant startTime);

    ScheduledFuture schedule(Runnable task, Date startTime);

    ScheduledFuture scheduleAtFixedRate(Runnable task, Instant startTime, Duration period);

    ScheduledFuture scheduleAtFixedRate(Runnable task, Date startTime, long period);

    ScheduledFuture scheduleAtFixedRate(Runnable task, Duration period);

    ScheduledFuture scheduleAtFixedRate(Runnable task, long period);

    ScheduledFuture scheduleWithFixedDelay(Runnable task, Instant startTime, Duration delay);

    ScheduledFuture scheduleWithFixedDelay(Runnable task, Date startTime, long delay);

    ScheduledFuture scheduleWithFixedDelay(Runnable task, Duration delay);

    ScheduledFuture scheduleWithFixedDelay(Runnable task, long delay);
}

最简单的方法是 named 的方法，它只接受 a 和 a 。这会导致任务在指定时间后运行一次。所有其他方法能够调度任务以重复运行。固定速率和固定延迟 methods 用于简单的定期执行，但接受 a 更灵活。scheduleRunnableDateTriggerspring-doc.cn

7.2.1. 界面`Trigger`

该接口本质上受到了 JSR-236 的启发，从 Spring 3.0 开始，尚未正式实施。的基本思想是执行时间可以根据过去的执行结果甚至任意条件来确定。如果这些确定确实考虑了先前执行的结果，则该信息在 .界面本身非常简单，如下面的清单所示：TriggerTriggerTriggerContextTriggerspring-doc.cn

public interface Trigger {

    Date nextExecutionTime(TriggerContext triggerContext);
}

这是最重要的部分。它封装了所有相关数据，并在必要时开放扩展。这是一个接口（实现由 default）的 S S以下清单显示了可用于实现的方法。TriggerContextTriggerContextSimpleTriggerContextTriggerspring-doc.cn

public interface TriggerContext {

    Date lastScheduledExecutionTime();

    Date lastActualExecutionTime();

    Date lastCompletionTime();
}

7.2.2. 实现`Trigger`

Spring 提供了该接口的两种实现。最有趣的一个是 .它支持基于 cron 表达式调度任务。为例如，以下任务计划在每小时后运行 15 分钟，但仅运行在工作日朝九晚五的“营业时间”内：TriggerCronTriggerspring-doc.cn

scheduler.schedule(task, new CronTrigger("0 15 9-17 * * MON-FRI"));

另一个实现是接受固定的 period、可选的 initial delay 值和一个布尔值，用于指示 period 应解释为 fixed-rate 或 fixed-delay。由于该接口已经定义了以固定速率调度任务的方法，或者使用 fixed delay，则应尽可能直接使用这些方法。实现的价值在于，您可以在依赖抽象。例如，允许周期性触发器可能很方便，基于 cron 的触发器，甚至是可以互换使用的自定义触发器实现。这样的组件可以利用依赖关系注入，以便您可以在外部配置此类组件，从而轻松修改或扩展它们。PeriodicTriggerTaskSchedulerPeriodicTriggerTriggerTriggersspring-doc.cn

7.2.3. 实现`TaskScheduler`

与 Spring 的抽象一样，这种安排的主要好处是应用程序的调度需求与部署解耦环境。在部署到应用程序服务器环境中，线程不应由应用程序本身。对于此类场景， Spring 提供了一个委托给 WebLogic 或 WebSphere 上的 CommonJ 的更新版本，以及一个更新的委托给 Java EE 7+ 环境中的 JSR-236 的版本。两者都通常使用 JNDI 查找进行配置。TaskExecutorTaskSchedulerTimerManagerTaskSchedulerTimerManagerDefaultManagedTaskSchedulerManagedScheduledExecutorServicespring-doc.cn

每当不需要外部线程管理时，更简单的替代方案是应用程序内的本地设置，可进行调整通过 Spring 的 .为方便起见， Spring 还提供了一个，它在内部委托给 a 以提供常见的 bean 样式配置，如下所示。这些变体非常适合 lenient 中的本地嵌入式线程池设置应用程序服务器环境，尤其是在 Tomcat 和 Jetty 上。ScheduledExecutorServiceConcurrentTaskSchedulerThreadPoolTaskSchedulerScheduledExecutorServiceThreadPoolTaskExecutorspring-doc.cn

7.3. 对调度和异步执行的 Comments 支持

Spring 为任务调度和异步方法都提供了 Comments 支持执行。spring-doc.cn

7.3.1. 启用 Scheduling Annotation

要启用对 and 注释的支持，您可以将 and 添加到其中一个类中，如下例所示：@Scheduled@Async@EnableScheduling@EnableAsync@Configurationspring-doc.cn

@Configuration
@EnableAsync
@EnableScheduling
public class AppConfig {
}

您可以为您的应用程序选择相关的注释。例如如果只需要支持，则可以省略。了解更多 fine-grained control 中，您还可以实现 interface 和/或 interface。有关完整详细信息，请参见 SchedulingConfigurer 和 AsyncConfigurer javadoc。@Scheduled@EnableAsyncSchedulingConfigurerAsyncConfigurerspring-doc.cn

如果您更喜欢 XML 配置，可以使用元素如下例所示：<task:annotation-driven>spring-doc.cn

<task:annotation-driven executor="myExecutor" scheduler="myScheduler"/>
<task:executor id="myExecutor" pool-size="5"/>
<task:scheduler id="myScheduler" pool-size="10"/>

请注意，对于前面的 XML，提供了一个执行程序引用来处理这些与带有注解的方法对应的任务，以及 scheduler 提供了管理那些带有 .@Async@Scheduledspring-doc.cn

处理 annotation 的默认通知模式是 which allows 仅用于通过代理拦截呼叫。同一类中的本地呼叫不能以这种方式被拦截。对于更高级的拦截模式，请考虑切换到与编译时或加载时编织相结合的模式。@Asyncproxyaspectj

7.3.2. 注解`@Scheduled`

您可以将注释与触发器元数据一起添加到方法中。为例如，以下方法每 5 秒调用一次，具有固定延迟，这意味着该时间段是从之前每个调用：@Scheduledspring-doc.cn

@Scheduled(fixedDelay=5000)
public void doSomething() {
    // something that should run periodically
}

如果需要固定速率执行，可以更改在注释。以下方法每 5 秒调用一次（在每个调用的连续开始时间）：spring-doc.cn

@Scheduled(fixedRate=5000)
public void doSomething() {
    // something that should run periodically
}

对于固定延迟和固定速率任务，您可以通过指示在首次执行方法之前等待的毫秒数，如下例所示：fixedRatespring-doc.cn

@Scheduled(initialDelay=1000, fixedRate=5000)
public void doSomething() {
    // something that should run periodically
}

如果简单的定期调度不够表达，你可以提供一个 cron 表达式。以下示例仅在工作日运行：spring-doc.cn

@Scheduled(cron="*/5 * * * * MON-FRI")
public void doSomething() {
    // something that should run on weekdays only
}

您还可以使用该属性指定 cron 表达式已解决。zone

请注意，要调度的方法必须具有 void 返回值，并且不能期望任何参数。如果该方法需要与应用程序中的其他对象交互 context 中，这些通常是通过依赖项注入提供的。spring-doc.cn

从 Spring Framework 4.3 开始，任何范围的 bean 都支持方法。@Scheduledspring-doc.cn

确保您没有在运行时初始化同一 Comments 类的多个实例，除非您确实希望为每个此类实例。与此相关，请确保您不要在 bean 上使用带有 Comments 并注册为常规 Spring bean 的类与容器一起。否则，您将获得双重初始化（一次通过 container 和 once through the aspect），结果是每个方法被调用两次。@Scheduled@Configurable@Scheduled@Configurable@Scheduledspring-doc.cn

7.3.3. 注解`@Async`

您可以在方法上提供注释，以便调用该方法异步发生。换句话说，调用方在调用，而该方法的实际执行发生在已提交到 Spring 。在最简单的情况下，您可以应用注释转换为返回的方法，如下例所示：@AsyncTaskExecutorvoidspring-doc.cn

@Async
void doSomething() {
    // this will be run asynchronously
}

与使用 annotation 注释的方法不同，这些方法可以预期参数，因为它们是由调用方在运行时以“正常”方式调用的，而不是而不是容器管理的计划任务。例如，以下代码为注释的合法应用：@Scheduled@Asyncspring-doc.cn

@Async
void doSomething(String s) {
    // this will be run asynchronously
}

即使是返回值的方法也可以异步调用。但是，此类方法都需要具有 -typed 返回值。这仍然提供了以下好处：异步执行，以便调用方可以在调用该 .以下示例演示如何对方法返回一个值：Futureget()Future@Asyncspring-doc.cn

@Async
Future<String> returnSomething(int i) {
    // this will be run asynchronously
}

@Asyncmethods 不仅可以声明常规返回类型但也包括 Spring 的 OR，截至 Spring 4.2 中，JDK 8 的 API 与异步任务，并用于与进一步处理步骤的即时组合。java.util.concurrent.Futureorg.springframework.util.concurrent.ListenableFuturejava.util.concurrent.CompletableFuture

您不能与生命周期回调结合使用，例如 .要异步初始化 Spring bean，您当前必须使用一个单独的初始化 Spring Bean，然后在 target，如下例所示：@Async@PostConstruct@Asyncspring-doc.cn

public class SampleBeanImpl implements SampleBean {

    @Async
    void doSomething() {
        // ...
    }

}

public class SampleBeanInitializer {

    private final SampleBean bean;

    public SampleBeanInitializer(SampleBean bean) {
        this.bean = bean;
    }

    @PostConstruct
    public void initialize() {
        bean.doSomething();
    }

}

没有直接的 XML 等效项，因为应该设计这样的方法首先，对于异步执行，而不是在外部重新声明为 asynchronous。但是，您可以使用 Spring AOP 手动设置 Spring，与自定义切入点结合使用。@AsyncAsyncExecutionInterceptor

7.3.4. 执行人资格`@Async`

默认情况下，在方法上指定时，使用的 Executor 是一个在启用异步支持时配置，即 “annotation-driven” 元素（如果您使用的是 XML 或您的实现）（如果有）。但是，当您需要指示 default 以外的执行程序应为在执行给定方法时使用。以下示例显示了如何执行此操作：@AsyncAsyncConfigurervalue@Asyncspring-doc.cn

@Async("otherExecutor")
void doSomething(String s) {
    // this will be run asynchronously by "otherExecutor"
}

在这种情况下，可以是 Spring 中任何 bean 的名称 container，也可以是与任何使用 element 或 Spring 的注释指定）。"otherExecutor"ExecutorExecutor<qualifier>@Qualifierspring-doc.cn

7.3.5. 异常管理`@Async`

当方法具有 -typed 返回值时，它很容易管理在方法执行期间引发的异常，因为此异常是调用 result 时抛出。使用 return 类型时，但是，异常未捕获，无法传输。您可以提供 an 来处理此类异常。以下示例显示了如何操作：@AsyncFuturegetFuturevoidAsyncUncaughtExceptionHandlerspring-doc.cn

public class MyAsyncUncaughtExceptionHandler implements AsyncUncaughtExceptionHandler {

    @Override
    public void handleUncaughtException(Throwable ex, Method method, Object... params) {
        // handle exception
    }
}

默认情况下，仅记录异常。您可以使用或 XML 元素定义自定义。AsyncUncaughtExceptionHandlerAsyncConfigurer<task:annotation-driven/>spring-doc.cn

7.4. 命名空间`task`

从版本 3.0 开始， Spring 包括一个用于配置和实例的 XML 名称空间。它还提供了一种将任务配置为使用触发器进行调度。TaskExecutorTaskSchedulerspring-doc.cn

7.4.1. 'scheduler' 元素

以下元素创建一个实例，其中指定的线程池大小：ThreadPoolTaskSchedulerspring-doc.cn

<task:scheduler id="scheduler" pool-size="10"/>

为该属性提供的值用作线程名称的前缀在池中。该元素相对简单。如果你没有提供属性，则默认线程池只有一个线程。调度程序没有其他配置选项。idschedulerpool-sizespring-doc.cn

7.4.2. 元素`executor`

下面将创建一个实例：ThreadPoolTaskExecutorspring-doc.cn

<task:executor id="executor" pool-size="10"/>

与上一节中所示的调度程序一样，为该属性提供的值用作游泳池。就池大小而言，该元素支持更多配置选项。首先，用于 a 本身的可配置性更强。不仅仅是单一尺寸，执行程序的线程池的 Core 和 Max Size 可以具有不同的值。如果提供单个值，则执行程序具有固定大小的线程池（核心和最大大小相同）。但是，该元素的属性也接受形式的范围。以下示例将最小值设置为最大值：idexecutorschedulerThreadPoolTaskExecutorexecutorpool-sizemin-max525spring-doc.cn

<task:executor
        id="executorWithPoolSizeRange"
        pool-size="5-25"
        queue-capacity="100"/>

在前面的配置中，还提供了一个值。线程池的配置也应该根据执行程序的队列容量。有关 pool 之间关系的完整描述大小和队列容量，请参阅 ThreadPoolExecutor 的文档。主要思想是，当提交任务时，执行程序首先尝试使用 Free Thread （如果当前活动线程数小于核心大小）。如果已达到核心大小，则任务将添加到队列中，只要其尚未达到容量。只有这样，如果队列的容量已 reached，则 Executor 是否会创建一个超出 Core 大小的新线程。如果最大大小，则执行程序拒绝该任务。queue-capacityspring-doc.cn

默认情况下，队列是无界的，但这很少是所需的配置。因为它可能导致如果向该队列添加了足够的任务，而所有池线程都处于繁忙状态。此外，如果队列是无界的，则最大大小为完全没有效果。由于 executor 总是在创建新的线程超出核心大小，则队列必须具有线程池的有限容量增长到超过核心大小（这就是为什么固定大小的池是唯一明智的情况当使用无界队列时）。OutOfMemoryErrorsspring-doc.cn

如上所述，考虑任务被拒绝的情况。默认情况下，当 task 被拒绝时，线程池执行程序会抛出一个 .然而拒绝策略实际上是可配置的。使用默认拒绝策略，即 implementation。对于在重负载下可以跳过某些任务的应用程序，您可以改为配置或。另一个有效的选择对于需要在重负载下限制提交任务的应用程序来说，是这。不是抛出异常或丢弃任务，该策略强制调用 submit 方法的线程运行任务本身。这个想法是这样的调用者在运行该任务时很忙，无法提交其他任务。因此，它提供了一种简单的方法来限制传入的 load 同时保持线程池和队列的限制。通常，这允许执行程序 “赶上” 它正在处理的任务，从而释放一些容量。您可以从元素上属性的可用值的枚举。TaskRejectedExceptionAbortPolicyDiscardPolicyDiscardOldestPolicyCallerRunsPolicyrejection-policyexecutorspring-doc.cn

以下示例显示了一个元素，其中包含许多要指定的属性各种行为：executorspring-doc.cn

<task:executor
        id="executorWithCallerRunsPolicy"
        pool-size="5-25"
        queue-capacity="100"
        rejection-policy="CALLER_RUNS"/>

最后，该设置确定线程的时间限制（以秒为单位）在停止之前可能会保持空闲状态。如果线程数超过核心数当前在池中，在等待此时间而不处理任务后，超出线程停止。时间值为零会导致过多的线程停止在执行任务后立即执行，而不在任务队列中保留后续工作。以下示例将该值设置为 2 分钟：keep-alivekeep-alivespring-doc.cn

<task:executor
        id="executorWithKeepAlive"
        pool-size="5-25"
        keep-alive="120"/>

7.4.3. 'scheduled-tasks' 元素

Spring 的 task 命名空间最强大的功能是支持配置要在 Spring Application Context 中调度的任务。这遵循一种方法类似于 Spring 中的其他“方法调用程序”，例如 JMS 名称空间提供的用于配置消息驱动的 POJO。基本上，属性可以指向任何 Spring 管理的对象，并且该属性提供了要在该对象上调用。下面的清单显示了一个简单的示例：refmethodspring-doc.cn

<task:scheduled-tasks scheduler="myScheduler">
    <task:scheduled ref="beanA" method="methodA" fixed-delay="5000"/>
</task:scheduled-tasks>

<task:scheduler id="myScheduler" pool-size="10"/>

调度程序由外部元素引用，每个单独的 task 包含其触发器元数据的配置。在前面的示例中， metadata 定义一个周期性触发器，该触发器具有固定的延迟，指示毫秒，以便在每个任务执行完成后等待。另一个选项是，指示该方法应运行的频率，而不管多长时间任何以前的执行都需要。此外，对于和任务，您可以指定 'initial-delay' 参数，指示等待的毫秒数在首次执行该方法之前。要获得更多控制，您可以改为提供属性。以下示例显示了以下其他选项：fixed-ratefixed-delayfixed-ratecronspring-doc.cn

<task:scheduled-tasks scheduler="myScheduler">
    <task:scheduled ref="beanA" method="methodA" fixed-delay="5000" initial-delay="1000"/>
    <task:scheduled ref="beanB" method="methodB" fixed-rate="5000"/>
    <task:scheduled ref="beanC" method="methodC" cron="*/5 * * * * MON-FRI"/>
</task:scheduled-tasks>

<task:scheduler id="myScheduler" pool-size="10"/>

7.5. 使用 Quartz 调度器

Quartz 使用，，和 objects 来实现各种调度的工作。有关 Quartz 背后的基本概念，请参阅 https://www.quartz-scheduler.org/。为方便起见， Spring 提供了几个简化在基于 Spring 的应用程序中使用 Quartz 的类。TriggerJobJobDetailspring-doc.cn

7.5.1. 使用`JobDetailFactoryBean`

Quartz 对象包含运行作业所需的所有信息。Spring 提供了一个，它为 XML 配置目的提供了 bean 样式的属性。请考虑以下示例：JobDetailJobDetailFactoryBeanspring-doc.cn

<bean name="exampleJob" class="org.springframework.scheduling.quartz.JobDetailFactoryBean">
    <property name="jobClass" value="example.ExampleJob"/>
    <property name="jobDataAsMap">
        <map>
            <entry key="timeout" value="5"/>
        </map>
    </property>
</bean>

作业详细信息配置包含运行作业（）所需的所有信息。超时在作业数据映射中指定。作业数据映射可通过（在执行时传递给您）获得，但也会获取其 properties 从 Job 数据映射到 Job 实例的 properties 中。因此，在下面的示例中，包含一个名为的 bean 属性，并且已自动应用它：ExampleJobJobExecutionContextJobDetailExampleJobtimeoutJobDetailspring-doc.cn

package example;

public class ExampleJob extends QuartzJobBean {

    private int timeout;

    /**
     * Setter called after the ExampleJob is instantiated
     * with the value from the JobDetailFactoryBean (5)
     */
    public void setTimeout(int timeout) {
        this.timeout = timeout;
    }

    protected void executeInternal(JobExecutionContext ctx) throws JobExecutionException {
        // do the actual work
    }
}

作业数据映射中的所有其他属性也可供您使用。spring-doc.cn

通过使用 and 属性，您可以修改名称和组的工作。默认情况下，作业的名称与 Bean 名称匹配的（在上面的前面示例中）。namegroupJobDetailFactoryBeanexampleJob

7.5.2. 使用`MethodInvokingJobDetailFactoryBean`

通常，您只需在特定对象上调用方法。通过使用，您可以完全执行此操作，如下例所示：MethodInvokingJobDetailFactoryBeanspring-doc.cn

<bean id="jobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
    <property name="targetObject" ref="exampleBusinessObject"/>
    <property name="targetMethod" value="doIt"/>
</bean>

前面的示例导致在方法上调用方法，如下例所示：doItexampleBusinessObjectspring-doc.cn

public class ExampleBusinessObject {

    // properties and collaborators

    public void doIt() {
        // do the actual work
    }
}

<bean id="exampleBusinessObject" class="examples.ExampleBusinessObject"/>

通过使用，您无需创建单行作业，它仅调用一个方法。您只需创建实际的业务对象，并且关联 Detail 对象。MethodInvokingJobDetailFactoryBeanspring-doc.cn

默认情况下，Quartz 作业是无状态的，因此 Job 可能会干扰彼此之间。如果为同一指定两个触发器，则为可能在第一个作业完成之前，第二个作业开始。如果类实现接口，则不会发生这种情况。第二个 job 在第一个 job 完成之前不会启动。要使 be non-concurrent 生成的作业，请将标志设置为，如下例所示：JobDetailJobDetailStatefulMethodInvokingJobDetailFactoryBeanconcurrentfalsespring-doc.cn

<bean id="jobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
    <property name="targetObject" ref="exampleBusinessObject"/>
    <property name="targetMethod" value="doIt"/>
    <property name="concurrent" value="false"/>
</bean>

默认情况下，作业将以并发方式运行。

7.5.3. 使用 Triggers 和`SchedulerFactoryBean`

我们已经创建了 job details 和 jobs。我们还回顾了方便的 bean，它允许您可以在特定对象上调用方法。当然，我们仍然需要将工作本身。这是通过使用触发器和 .几个触发器在 Quartz 中可用，并且 Spring 提供了两个具有方便默认值的 Quartz 实现：和。SchedulerFactoryBeanFactoryBeanCronTriggerFactoryBeanSimpleTriggerFactoryBeanspring-doc.cn

需要安排触发器。Spring 提供了一个公开触发器设置为 Properties。使用那些触发器。SchedulerFactoryBeanSchedulerFactoryBeanspring-doc.cn

下面的清单同时使用 a 和 a ：SimpleTriggerFactoryBeanCronTriggerFactoryBeanspring-doc.cn

<bean id="simpleTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerFactoryBean">
    <!-- see the example of method invoking job above -->
    <property name="jobDetail" ref="jobDetail"/>
    <!-- 10 seconds -->
    <property name="startDelay" value="10000"/>
    <!-- repeat every 50 seconds -->
    <property name="repeatInterval" value="50000"/>
</bean>

<bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
    <property name="jobDetail" ref="exampleJob"/>
    <!-- run every morning at 6 AM -->
    <property name="cronExpression" value="0 0 6 * * ?"/>
</bean>

前面的示例设置了两个触发器，一个触发器每 50 秒运行一次，启动延迟为 10 秒，每天早上 6 点运行 1 个。要完成所有内容，我们需要设置，如下例所示：SchedulerFactoryBeanspring-doc.cn

<bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
    <property name="triggers">
        <list>
            <ref bean="cronTrigger"/>
            <ref bean="simpleTrigger"/>
        </list>
    </property>
</bean>

还有更多属性可用于，例如作业详细信息、用于自定义 Quartz 的属性以及 Spring 提供的 JDBC DataSource。看 SchedulerFactoryBean javadoc 了解更多信息。SchedulerFactoryBeanspring-doc.cn

SchedulerFactoryBean还可以识别 Classpath 中的文件，基于 Quartz 属性键，与常规 Quartz 配置一样。请注意，许多设置与属性文件中的常见 Quartz 设置交互; 因此，建议不要在这两个级别都指定值。例如，不要设置如果你打算依赖 Spring 提供的DataSource，则为“org.quartz.jobStore.class”属性。quartz.propertiesSchedulerFactoryBean

8. 缓存抽象

从版本 3.1 开始， Spring 框架提供了对透明地将缓存添加到一个现有的 Spring 应用程序。与事务支持类似，缓存抽象允许一致地使用各种缓存解决方案，其中对代码的影响最小。spring-doc.cn

在 Spring Framework 4.1 中，缓存抽象得到了显著扩展，支持用于 JSR-107 注释和更多自定义选项。spring-doc.cn

8.1. 理解缓存抽象

缓存与缓冲区

术语 “buffer” 和 “cache” 往往可以互换使用。但是请注意，他们代表不同的事物。传统上，缓冲区用作中间体快速实体和慢速实体之间的数据的临时存储。因为一方必须等待对于另一个（影响性能），缓冲区通过允许整个一次移动的数据块，而不是小块移动。数据被写入和读取仅从 buffer 中获取一次。此外，缓冲区至少对一方可见那是知道的。spring-doc.cn

另一方面，根据定义，缓存是隐藏的，任何一方都不知道发生缓存。它还提高了性能，但这样做是为了让相同的数据快速阅读多次。spring-doc.cn

您可以在此处找到缓冲区和缓存之间差异的进一步说明。spring-doc.cn

从本质上讲，缓存抽象将缓存应用于 Java 方法，从而减少基于缓存中可用信息的执行次数。也就是说，每次调用 targeted 方法时，抽象会应用一个缓存行为，该行为会检查是否已为给定参数调用该方法。如果已经调用，则返回缓存的结果，而不必调用实际方法。如果尚未调用该方法，则调用该方法，并缓存结果并返回给用户，以便下次调用该方法时，缓存的结果是返回。这样，只能调用昂贵的方法（无论是 CPU 绑定还是 IO 绑定）一次，结果被重用，而无需实际再次调用该方法。缓存逻辑以透明方式应用，没有任何干扰调用者。spring-doc.cn

此方法仅适用于保证返回相同 output （result）的 input （或参数）的 intent 值，无论它被调用了多少次。

缓存抽象提供了其他与缓存相关的操作，例如具有以更新缓存的内容或删除一个或所有条目。这些 API 在以下情况下非常有用缓存处理在应用程序过程中可能更改的数据。spring-doc.cn

与 Spring 框架中的其他服务一样，缓存服务是一个抽象（不是 cache 实现），并且需要使用实际的 storage 来存储 cache 数据 — 也就是说，抽象使您不必编写 cache logic，但不需要提供实际数据存储。这种抽象由和接口实现。org.springframework.cache.Cacheorg.springframework.cache.CacheManagerspring-doc.cn

Spring 提供了该抽象的一些实现：基于 JDK 的缓存，Ehcache 2.x， Gemfire 缓存、Caffeine 和 JSR-107 兼容的缓存（例如 Ehcache 3.x）。有关更多信息，请参阅插入不同的后端缓存插入其他缓存存储和提供程序。java.util.concurrent.ConcurrentMapspring-doc.cn

缓存抽象对多线程和多进程环境，因为此类功能由 Cache 实现处理。

如果您有一个多进程环境（即部署在多个节点上的应用程序），您需要相应地配置缓存提供程序。根据您的使用案例，副本多个节点上的相同数据就足够了。但是，如果您在在应用程序过程中，您可能需要启用其他传播机制。spring-doc.cn

缓存特定项目直接等同于典型的 get-if-not-found-then-proceed-and-put-finally 代码块通过编程缓存交互找到。不应用锁，并且多个线程可能会尝试同时加载同一项。这同样适用于驱逐。如果多个线程正在尝试更新或逐出数据同时，您可以使用过时的数据。某些缓存提供程序提供高级功能在那个地区。有关更多详细信息，请参阅缓存提供程序的文档。spring-doc.cn

要使用缓存抽象，您需要注意两个方面：spring-doc.cn

缓存声明：确定需要缓存的方法及其策略。spring-doc.cn
缓存配置：存储数据并从中读取数据的后备缓存。spring-doc.cn

8.2. 基于声明式注解的缓存

对于缓存声明， Spring 的缓存抽象提供了一组 Java 注释：spring-doc.cn

@Cacheable：触发缓存填充。spring-doc.cn
@CacheEvict：触发缓存逐出。spring-doc.cn
@CachePut：在不干扰方法执行的情况下更新缓存。spring-doc.cn
@Caching：重新组合要应用于方法的多个缓存操作。spring-doc.cn
@CacheConfig：在类级别共享一些常见的缓存相关设置。spring-doc.cn

8.2.1. 注解`@Cacheable`

顾名思义，您可以使用它来划分可缓存的方法，即结果存储在缓存中的方法，以便在后续的 invocations（具有相同的参数）时，返回缓存中的值时，不会返回必须实际调用该方法。在最简单的形式中，注解声明需要与 annotated 方法关联的缓存的名称，如下所示示例显示：@Cacheablespring-doc.cn

@Cacheable("books")
public Book findBook(ISBN isbn) {...}

在前面的代码段中，该方法与名为 . 每次调用该方法时，都会检查缓存以查看调用是否具有已运行，无需重复。而在大多数情况下，只有一个 cache 时，注解允许指定多个名称，以便多个 cache 正在使用。在这种情况下，在调用 method — 如果至少命中了一个缓存，则返回关联的值。findBookbooksspring-doc.cn

不包含该值的所有其他缓存也会更新，即使缓存的方法实际上并未被调用。

以下示例对具有多个缓存的方法使用：@CacheablefindBookspring-doc.cn

@Cacheable({"books", "isbns"})
public Book findBook(ISBN isbn) {...}

默认密钥生成

由于缓存本质上是键值存储，因此每次调用缓存的方法需要翻译成适合缓存访问的 key。缓存抽象使用基于以下算法的简单：KeyGeneratorspring-doc.cn

如果未给出参数，则返回。SimpleKey.EMPTYspring-doc.cn
如果只给出一个 param，则返回该实例。spring-doc.cn
如果给出了多个参数，则返回包含所有参数的 a。SimpleKeyspring-doc.cn

这种方法适用于大多数用例，只要参数具有自然键即可并实现 valid 和 methods。如果不是这种情况，你需要改变策略。hashCode()equals()spring-doc.cn

要提供不同的默认密钥生成器，您需要实现该接口。org.springframework.cache.interceptor.KeyGeneratorspring-doc.cn

默认的密钥生成策略随着 Spring 4.0 的发布而改变。早些时候版本使用 Key 生成策略，对于多个 Key 参数，只考虑了 of 参数，而不是。这可能会导致意外的按键冲突（有关背景信息，请参阅 SPR-10237）。对于此类情况，新版本使用复合键。hashCode()equals()SimpleKeyGeneratorspring-doc.cn

如果您想继续使用之前的 key 策略，您可以配置已弃用的类或创建自定义基于哈希的实现。org.springframework.cache.interceptor.DefaultKeyGeneratorKeyGeneratorspring-doc.cn

自定义密钥生成声明

由于缓存是泛型的，因此目标方法很可能具有各种签名这不能轻易地映射到缓存结构之上。这往往变得很明显当 target 方法具有多个参数，其中只有一些参数适合缓存（而其余部分仅由 method logic使用）。请考虑以下示例：spring-doc.cn

@Cacheable("books")
public Book findBook(ISBN isbn, boolean checkWarehouse, boolean includeUsed)

乍一看，虽然这两个论点影响了这本书的找到方式，它们对缓存没有用处。此外，如果两者中只有一个很重要怎么办而另一个则不是？booleanspring-doc.cn

对于此类情况，注释允许您指定密钥的生成方式通过其属性。您可以使用 SpEL 选择感兴趣的参数（或其嵌套属性）、执行操作，甚至调用任意方法，而无需编写任何代码或实现任何接口。这是默认生成器的推荐方法，因为方法往往是随着代码库的增长，签名完全不同。虽然默认策略可能会适用于某些方法，但很少适用于所有方法。@Cacheablekeyspring-doc.cn

以下示例使用各种 SPEL 声明（如果您不熟悉 SPEL，帮自己一个忙，读一读 Spring Expression Language）：spring-doc.cn

@Cacheable(cacheNames="books", key="#isbn")
public Book findBook(ISBN isbn, boolean checkWarehouse, boolean includeUsed)

@Cacheable(cacheNames="books", key="#isbn.rawNumber")
public Book findBook(ISBN isbn, boolean checkWarehouse, boolean includeUsed)

@Cacheable(cacheNames="books", key="T(someType).hash(#isbn)")
public Book findBook(ISBN isbn, boolean checkWarehouse, boolean includeUsed)

前面的代码片段显示了选择某个参数（其属性，甚至是任意（静态）方法。spring-doc.cn

如果负责生成密钥的算法过于具体，或者需要要共享，您可以在操作上定义自定义。为此，指定要使用的 Bean 实现的名称，如下所示示例显示：keyGeneratorKeyGeneratorspring-doc.cn

@Cacheable(cacheNames="books", keyGenerator="myKeyGenerator")
public Book findBook(ISBN isbn, boolean checkWarehouse, boolean includeUsed)

和参数是互斥的，并且是一个操作指定 both 将导致异常。keykeyGenerator

默认缓存分辨率

缓存抽象使用一个简单的 that 使用配置的 .CacheResolverCacheManagerspring-doc.cn

要提供不同的默认缓存解析程序，您需要实现该接口。org.springframework.cache.interceptor.CacheResolverspring-doc.cn

自定义缓存分辨率

默认缓存分辨率非常适合使用 single 的 Random 的 Zip S S 的 RandomCacheManagerspring-doc.cn

对于使用多个缓存管理器的应用程序，您可以设置用于每个操作，如下例所示：cacheManagerspring-doc.cn

@Cacheable(cacheNames="books", cacheManager="anotherCacheManager") (1)
public Book findBook(ISBN isbn) {...}

1	指定。`anotherCacheManager`

您也可以以类似于替换密钥生成。分辨率为 requested 的 gURL 中，让实现实际解析根据运行时参数使用的缓存。以下示例说明如何指定：CacheResolverCacheResolverspring-doc.cn

@Cacheable(cacheResolver="runtimeCacheResolver") (1)
public Book findBook(ISBN isbn) {...}

1	指定 .`CacheResolver`

从 Spring 4.1 开始，cache 注解的属性不再是 mandatory，因为无论 Comments 的内容如何，都可以提供此特定信息。valueCacheResolverspring-doc.cn

与 and 类似，和参数是互斥的，并且同时指定会导致异常，因为 custom 被实现忽略。这可能不是您所期望的。keykeyGeneratorcacheManagercacheResolverCacheManagerCacheResolverspring-doc.cn

同步缓存

在多线程环境中，可能会同时调用相同的参数（通常在启动时）。默认情况下，缓存抽象不会锁定任何内容，相同的值可能会被多次计算，从而违背目的缓存。spring-doc.cn

对于这些特定情况，您可以使用 attribute 来指示底层 cache provider 在计算值时锁定缓存条目。因此，只有一个线程忙于计算该值，而其他线程被阻塞，直到进入在缓存中更新。以下示例演示如何使用该属性：syncsyncspring-doc.cn

@Cacheable(cacheNames="foos", sync=true) (1)
public Foo executeExpensiveOperation(String id) {...}

1	使用 attribute.`sync`

这是一项可选功能，您最喜欢的缓存库可能不支持它。核心框架提供的所有实现都支持它。请参阅缓存提供商的文档，了解更多详细信息。CacheManager

条件缓存

有时，某个方法可能并不适合一直进行缓存（例如，它可能取决于给定的参数）。缓存注释通过参数支持此类用例，该参数采用计算结果为或的表达式。如果，则缓存该方法。如果不是，则它的行为就像方法不是一样 cached （即，无论缓存中的值是什么，每次都会调用该方法或使用的参数）。例如，仅当参数的长度短于 32：conditionSpELtruefalsetruenamespring-doc.cn

@Cacheable(cacheNames="book", condition="#name.length() < 32") (1)
public Book findBook(String name)

1	在上设置条件。`@Cacheable`

除了参数之外，您还可以使用 parameter 否决向缓存中添加值。与不同，表达式被计算在调用该方法之后。为了扩展前面的例子，也许我们只想要缓存平装书，如下例所示：conditionunlessconditionunlessspring-doc.cn

@Cacheable(cacheNames="book", condition="#name.length() < 32", unless="#result.hardback") (1)
public Book findBook(String name)

1	使用 attribute 来阻止 hardbacks。`unless`

缓存抽象支持返回类型。如果值存在，它将存储在关联的缓存中。如果值不是 present）将存储在关联的缓存中。始终引用业务实体，而不是受支持的包装器，因此可以重写前面的示例如下：java.util.OptionalOptionalOptionalnull#resultspring-doc.cn

@Cacheable(cacheNames="book", condition="#name.length() < 32", unless="#result?.hardback")
public Optional<Book> findBook(String name)

请注意，still 引用而不是。既然可能是，我们使用 SpEL 的安全导航运算符。#resultBookOptional<Book>nullspring-doc.cn

可用的缓存 SPEL 求值上下文

每个表达式都根据专用上下文进行计算。除了内置参数外，框架还提供了专用的缓存相关元数据，例如参数名称。下表描述了制造的项目 available to context 中，以便您可以将它们用于键和条件计算：SpELspring-doc.cn

表 11.缓存 SPEL 可用元数据
名字	位置	描述	例
`methodName`spring-doc.cn	根对象spring-doc.cn	正在调用的方法的名称spring-doc.cn	`#root.methodName`spring-doc.cn
`method`spring-doc.cn	根对象spring-doc.cn	正在调用的方法spring-doc.cn	`#root.method.name`spring-doc.cn
`target`spring-doc.cn	根对象spring-doc.cn	正在调用的目标对象spring-doc.cn	`#root.target`spring-doc.cn
`targetClass`spring-doc.cn	根对象spring-doc.cn	正在调用的目标的类spring-doc.cn	`#root.targetClass`spring-doc.cn
`args`spring-doc.cn	根对象spring-doc.cn	用于调用目标的参数（作为数组）spring-doc.cn	`#root.args[0]`spring-doc.cn
`caches`spring-doc.cn	根对象spring-doc.cn	运行当前方法所针对的缓存的集合spring-doc.cn	`#root.caches[0].name`spring-doc.cn
参数名称spring-doc.cn	评估上下文spring-doc.cn	任何方法参数的名称。如果名称不可用（可能是由于没有调试信息），参数名称也可以在 where 代表参数索引（从开始）下找到。`#a<#arg>#arg0`spring-doc.cn	`#iban`or （您也可以使用 or 表示法作为别名）。`#a0#p0#p<#arg>`spring-doc.cn
`result`spring-doc.cn	评估上下文spring-doc.cn	方法调用的结果（要缓存的值）。仅在表达式、表达式（计算）或表达式（when is ）中可用。对于支持的包装器（如），是指实际对象，而不是包装器。`unlesscache putkeycache evictbeforeInvocationfalseOptional#result`spring-doc.cn	`#result`spring-doc.cn

8.2.2. 注解`@CachePut`

当需要更新缓存而不干扰方法执行时，您可以使用 Annotation.也就是说，该方法始终被调用，并且其 result 被放入缓存中（根据选项）。它支持与和相同的选项应用于缓存填充，而不是方法流程优化。以下示例使用注释：@CachePut@CachePut@Cacheable@CachePutspring-doc.cn

@CachePut(cacheNames="book", key="#isbn")
public Book updateBook(ISBN isbn, BookDescriptor descriptor)

在相同的方法上使用和 annotation 通常是强烈反对，因为他们的行为不同。虽然后者会导致方法调用，前者强制在运行缓存更新。这会导致意外行为，并且除了的特定极端情况（例如，具有将它们从每个 other），则应避免使用此类声明。另请注意，这些条件不应依赖于在 result 对象（即变量）上，因为这些是预先验证的确认排除项。@CachePut@Cacheable#result

8.2.3. 注解`@CacheEvict`

缓存抽象不仅允许填充缓存存储，还允许逐出。此过程可用于从缓存中删除过时或未使用的数据。与相反，划分执行缓存的方法逐出（即充当从缓存中删除数据的触发器的方法）。与它的同级类似，需要指定一个或多个缓存，则允许自定义缓存和密钥解析或条件，并具有一个额外的参数（）指示是否需要执行缓存范围的逐出而不仅仅是条目驱逐（基于键）。以下示例驱逐缓存中的所有条目：@Cacheable@CacheEvict@CacheEvictallEntriesbooksspring-doc.cn

@CacheEvict(cacheNames="books", allEntries=true) (1)
public void loadBooks(InputStream batch)

1	使用 attribute 从缓存中逐出所有条目。`allEntries`

当需要清除整个缓存区域时，此选项会派上用场。而不是逐出每个条目（这将花费很长时间，因为它效率低下），如前面的示例所示，所有条目都在一个操作中删除。请注意，框架会忽略此方案中指定的任何键，因为它不适用（整个缓存被驱逐，而不仅仅是一个条目）。spring-doc.cn

您还可以指示驱逐是应该在（默认）之后还是之前进行该方法使用属性调用。前者提供与其他 Comments 的语义相同：方法成功完成后，对缓存运行操作（在本例中为 Eviction）。如果该方法没有 run（因为它可能被缓存）或引发异常，则不会发生驱逐。后者（）导致驱逐始终发生在方法。这在不需要绑定驱逐的情况下非常有用到方法结果。beforeInvocationbeforeInvocation=truespring-doc.cn

请注意，方法可以与 - 一起使用，因为这些方法充当 trigger，则返回值将被忽略（因为它们不与缓存交互）。这是不是将数据添加到缓存或更新缓存中的数据的情况因此，需要一个结果。void@CacheEvict@Cacheablespring-doc.cn

8.2.4. 注解`@Caching`

有时，需要指定多个相同类型的 Comments（例如 or ），例如，因为 condition 或 key expression 在不同缓存之间是不同的。允许在同一方法上使用多个嵌套的、和注释。以下示例使用两个注释：@CacheEvict@CachePut@Caching@Cacheable@CachePut@CacheEvict@CacheEvictspring-doc.cn

@Caching(evict = { @CacheEvict("primary"), @CacheEvict(cacheNames="secondary", key="#p0") })
public Book importBooks(String deposit, Date date)

8.2.5. 注解`@CacheConfig`

到目前为止，我们已经看到缓存操作提供了许多自定义选项，并且您可以为每个操作设置这些选项。但是，一些自定义选项如果它们应用于类的所有操作，则配置起来可能会很繁琐。为实例，指定要用于 class 可以替换为单个类级定义。这就是发挥作用的地方。以下示例用于设置缓存的名称：@CacheConfig@CacheConfigspring-doc.cn

@CacheConfig("books") (1)
public class BookRepositoryImpl implements BookRepository {

    @Cacheable
    public Book findBook(ISBN isbn) {...}
}

1	用于设置缓存的名称。`@CacheConfig`

@CacheConfig是允许共享缓存名称的类级注解，自定义、自定义和自定义。将此注释放在类上不会打开任何缓存操作。KeyGeneratorCacheManagerCacheResolverspring-doc.cn

操作级自定义设置始终覆盖在上设置的自定义项。因此，这为每个缓存操作提供了三个级别的自定义：@CacheConfigspring-doc.cn

全局配置，可用于、。CacheManagerKeyGeneratorspring-doc.cn
在类级别，使用 .@CacheConfigspring-doc.cn
在操作级别。spring-doc.cn

8.2.6. 启用缓存注解

请务必注意，即使声明缓存注释不会自动触发他们的操作 - 就像 Spring 中的许多事情一样，该功能必须声明式启用（这意味着如果您怀疑缓存是罪魁祸首，您可以通过仅删除 1 个 configuration 行而不是您的代码）。spring-doc.cn

要启用缓存注释，请将注释添加到您的类之一：@EnableCaching@Configurationspring-doc.cn

@Configuration
@EnableCaching
public class AppConfig {
}

或者，对于 XML 配置，您可以使用以下元素：cache:annotation-drivenspring-doc.cn

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:cache="http://www.springframework.org/schema/cache"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/cache https://www.springframework.org/schema/cache/spring-cache.xsd">

        <cache:annotation-driven/>
</beans>

元素和注解都允许您指定影响缓存行为添加到通过 AOP 申请。该配置有意与 @Transactional 的配置相似。cache:annotation-driven@EnableCachingspring-doc.cn

处理缓存 annotation 的默认通知模式是，它允许仅用于通过代理拦截呼叫。同一类中的本地呼叫不能以这种方式被拦截。对于更高级的拦截模式，请考虑切换到与编译时或加载时编织相结合的模式。proxyaspectj

有关高级自定义（使用 Java 配置）的更多详细信息，这些自定义需要实现，请参阅 JavaDoc.CachingConfigurer

表 12.缓存注释设置
XML 属性	注释属性	违约	描述
`cache-manager`spring-doc.cn	N/A （参见 `CachingConfigurer` javadoc）spring-doc.cn	`cacheManager`spring-doc.cn	要使用的缓存管理器的名称。默认值在 behind 初始化具有此缓存管理器（或如果未设置）的场景。了解更多对缓存分辨率进行细粒度管理，请考虑设置 'cache-resolver' 属性。`CacheResolvercacheManager`spring-doc.cn
`cache-resolver`spring-doc.cn	N/A （参见 `CachingConfigurer` javadoc）spring-doc.cn	A 使用配置的 .`SimpleCacheResolvercacheManager`spring-doc.cn	用于解析后备缓存的CacheResolver的 Bean 名称。此属性不是必需的，只需指定为 'cache-manager' 属性。spring-doc.cn
`key-generator`spring-doc.cn	N/A （参见 `CachingConfigurer` javadoc）spring-doc.cn	`SimpleKeyGenerator`spring-doc.cn	要使用的自定义密钥生成器的名称。spring-doc.cn
`error-handler`spring-doc.cn	N/A （参见 `CachingConfigurer` javadoc）spring-doc.cn	`SimpleCacheErrorHandler`spring-doc.cn	要使用的自定义缓存错误处理程序的名称。默认情况下，在与缓存相关的操作将退回到客户端。spring-doc.cn
`mode`spring-doc.cn	`mode`spring-doc.cn	`proxy`spring-doc.cn	默认模式（）处理带注释的 bean 以使用 Spring 的 AOP 进行代理框架（如前所述，遵循代理语义，应用于方法调用仅通过代理进入）。相反，替代模式（）将影响了具有 Spring 的 AspectJ 缓存方面的类，修改了目标类的字节 code 应用于任何类型的方法调用。AspectJ 编织需要在 Classpath 中启用加载时编织（或编译时编织）。（有关如何设置的详细信息，请参阅 Spring 配置加载时编织。`proxyaspectjspring-aspects.jar`spring-doc.cn
`proxy-target-class`spring-doc.cn	`proxyTargetClass`spring-doc.cn	`false`spring-doc.cn	仅适用于代理模式。控制为什么类型的缓存代理创建使用 or 注释注释的类。如果该属性设置为，则会创建基于类的代理。如果是或省略属性，则为标准 JDK 创建基于接口的代理。（有关不同代理类型的详细检查，请参阅代理机制。`@Cacheable@CacheEvictproxy-target-classtrueproxy-target-classfalse`spring-doc.cn
`order`spring-doc.cn	`order`spring-doc.cn	Ordered.LOWEST_PRECEDENCEspring-doc.cn	定义应用于用或注释的 bean 的缓存通知的顺序。（有关订购 AOP 建议，请参阅建议订购。没有指定的 Sequences 意味着 AOP 子系统确定通知的 Sequences。`@Cacheable@CacheEvict`spring-doc.cn

<cache:annotation-driven/>仅在定义 bean 的同一应用程序上下文中查找。这意味着，如果输入 a for a ，则它仅检查控制器中的 bean，而不检查服务中的 bean。有关更多信息，请参阅 MVC 部分。@Cacheable/@CachePut/@CacheEvict/@Caching<cache:annotation-driven/>WebApplicationContextDispatcherServlet

方法可见性和缓存注释

使用代理时，应仅将缓存注释应用于具有公众可见性。如果您注释 protected、private 或 package-visible 方法使用这些 Annotations 时，不会引发错误，但 Annotated 方法不会显示配置的缓存设置。考虑使用 AspectJ（参见本节的其余部分）如果你需要注释非公共方法，因为它会改变字节码本身。spring-doc.cn

Spring 建议您只注释具体的类（以及 concrete 的方法类）替换为 Comments，而不是 Annotating 接口。您当然可以在接口（或接口方法），但这仅在您使用代理模式（）时有效。如果您使用基于 Weaving-based aspect （）时，缓存设置无法识别由 Weaving Infrastructure 提供的接口级声明。@Cache*@Cache*mode="proxy"mode="aspectj"

在代理模式（默认）下，只有通过 proxy 被拦截。这意味着自调用（实际上是 target 对象调用目标对象的另一个方法）不会导致实际的缓存，即使调用的方法标有 .考虑在这种情况下使用 THE MODE。此外，代理必须完全初始化为提供预期的行为，因此您不应在初始化代码（即）。@Cacheableaspectj@PostConstruct

8.2.7. 使用自定义注解

自定义注释和 AspectJ

此功能仅适用于基于代理的方法，但可以启用使用 AspectJ 进行一些额外的努力。spring-doc.cn

该模块仅为标准注释定义一个方面。如果你已经定义了自己的注解，你还需要为那些。查看示例。spring-aspectsAnnotationCacheAspectspring-doc.cn

缓存抽象允许您使用自己的 Comments 来识别方法。触发缓存填充或驱逐。作为模板机制，这非常方便，因为它消除了复制缓存注释声明的需要，即如果指定了 key 或 condition，或者 foreign imports （）不允许出现在您的代码库中。与其他人类似的 stereotype 注解中，你可以使用、、和作为元注释（即可以注释其他注释）。在以下示例中，我们将通用声明替换为我们自己的自定义注释：org.springframework@Cacheable@CachePut@CacheEvict@CacheConfig@Cacheablespring-doc.cn

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
@Cacheable(cacheNames="books", key="#isbn")
public @interface SlowService {
}

在前面的示例中，我们定义了自己的注解它本身用 .现在我们可以替换以下代码：SlowService@Cacheablespring-doc.cn

@Cacheable(cacheNames="books", key="#isbn")
public Book findBook(ISBN isbn, boolean checkWarehouse, boolean includeUsed)

以下示例显示了自定义注释，我们可以用它来替换前面的代码：spring-doc.cn

@SlowService
public Book findBook(ISBN isbn, boolean checkWarehouse, boolean includeUsed)

即使 is 不是 Spring 注解，容器也会自动选择 up 它的声明，并理解它的含义。请注意，如前所述，需要启用 Comments 驱动的行为。@SlowServicespring-doc.cn

8.3. JCache （JSR-107）注解

从 4.1 版开始， Spring 的缓存抽象完全支持 JCache 标准（JSR-107）注释：、、、以及、和同伴。即使不将缓存存储迁移到 JSR-107，也可以使用这些注释。内部实现使用 Spring 的缓存抽象，并提供符合规范。换句话说，如果您已经在使用 Spring 的缓存抽象，您可以切换到这些标准注释，而无需更改缓存存储（或配置）。@CacheResult@CachePut@CacheRemove@CacheRemoveAll@CacheDefaults@CacheKey@CacheValueCacheResolverKeyGeneratorspring-doc.cn

8.3.1. 功能总结

对于那些熟悉 Spring 缓存 Comments 的人来说，下表描述了 Spring 注解与其 JSR-107 之间的主要区别同行：spring-doc.cn

表 13.Spring 与 JSR-107 缓存注释
Spring	JSR-107 规范	备注
`@Cacheable`spring-doc.cn	`@CacheResult`spring-doc.cn	相当相似。可以缓存特定的异常并强制执行该方法，而不考虑缓存的内容。`@CacheResult`spring-doc.cn
`@CachePut`spring-doc.cn	`@CachePut`spring-doc.cn	虽然 Spring 使用方法调用的结果更新缓存，但 JCache 要求将其作为带有 . 由于这种差异， JCache 允许在实际方法调用。`@CacheValue`spring-doc.cn
`@CacheEvict`spring-doc.cn	`@CacheRemove`spring-doc.cn	相当相似。支持条件驱逐，当方法调用会导致异常。`@CacheRemove`spring-doc.cn
`@CacheEvict(allEntries=true)`spring-doc.cn	`@CacheRemoveAll`spring-doc.cn	看。`@CacheRemove`spring-doc.cn
`@CacheConfig`spring-doc.cn	`@CacheDefaults`spring-doc.cn	允许您以类似的方式配置相同的概念。spring-doc.cn

JCache 有的概念，它是相同的添加到 Spring 的接口中，除了 JCache 仅支持单个缓存。默认情况下，一个简单的实现会根据 name 声明的 NAME 的注释。需要注意的是，如果没有缓存名称是在注释上指定，则会自动生成默认值。请参阅 javadoc 了解更多信息。javax.cache.annotation.CacheResolverCacheResolver@CacheResult#cacheName()spring-doc.cn

CacheResolver实例由 .这是可能的为每个缓存操作自定义工厂，如下例所示：CacheResolverFactoryspring-doc.cn

@CacheResult(cacheNames="books", cacheResolverFactory=MyCacheResolverFactory.class) (1)
public Book findBook(ISBN isbn)

1	为此操作自定义工厂。

对于所有引用的类， Spring 尝试查找具有给定类型的 bean。如果存在多个匹配项，则会创建一个新实例，并且可以使用常规的 Bean 生命周期回调，例如依赖项注入。

键由为与 Spring 的 .默认情况下，所有方法参数都被采用考虑，除非至少有一个参数用 .这是类似于 Spring 的自定义密钥生成声明。例如，以下是相同的操作，一个使用 Spring 的抽象和另一个使用 JCache 的抽象：javax.cache.annotation.CacheKeyGeneratorKeyGenerator@CacheKeyspring-doc.cn

@Cacheable(cacheNames="books", key="#isbn")
public Book findBook(ISBN isbn, boolean checkWarehouse, boolean includeUsed)

@CacheResult(cacheName="books")
public Book findBook(@CacheKey ISBN isbn, boolean checkWarehouse, boolean includeUsed)

您还可以指定 on 操作，类似于指定 .CacheKeyResolverCacheResolverFactoryspring-doc.cn

JCache 可以管理带注释的方法引发的异常。这可以防止缓存，但它也可以缓存异常作为失败的指示器，而不是再次调用该方法。假设如果 ISBN 的结构无效。这是一个永久性的失败（没有一本书可能是使用此类参数检索）。以下内容缓存异常，以便进一步具有相同无效 ISBN 的调用直接引发缓存的异常，而不是再次调用该方法：InvalidIsbnNotFoundExceptionspring-doc.cn

@CacheResult(cacheName="books", exceptionCacheName="failures"
            cachedExceptions = InvalidIsbnNotFoundException.class)
public Book findBook(ISBN isbn)

8.3.2. 启用 JSR-107 支持

您无需执行任何特定操作即可启用 JSR-107 支持以及 Spring 的声明性注释支持。如果 JSR-107 API 和模块都存在于 Classpath 中，则 Both 和 XML 元素都会自动启用 JCache 支持。@EnableCachingcache:annotation-drivenspring-context-supportspring-doc.cn

根据您的使用案例，选择权基本上在您手中。您甚至可以混合和通过在某些服务上使用 JSR-107 API 并在 Spring 上使用 Spring 自己的注释来匹配服务别人。但是，如果这些服务影响相同的缓存，则应使用一致的和相同的密钥生成实现。

8.4. 基于声明式 XML 的缓存

如果注释不是一个选项（可能是由于无法访问源或没有外部代码），您可以使用 XML 进行声明式缓存。所以，而不是对缓存方法进行注释时，您可以指定 Target 方法和在外部缓存指令（类似于声明式事务管理建议）。示例上一节可以翻译成以下示例：spring-doc.cn

<!-- the service we want to make cacheable -->
<bean id="bookService" class="x.y.service.DefaultBookService"/>

<!-- cache definitions -->
<cache:advice id="cacheAdvice" cache-manager="cacheManager">
    <cache:caching cache="books">
        <cache:cacheable method="findBook" key="#isbn"/>
        <cache:cache-evict method="loadBooks" all-entries="true"/>
    </cache:caching>
</cache:advice>

<!-- apply the cacheable behavior to all BookService interfaces -->
<aop:config>
    <aop:advisor advice-ref="cacheAdvice" pointcut="execution(* x.y.BookService.*(..))"/>
</aop:config>

<!-- cache manager definition omitted -->

在前面的配置中，the 是可缓存的。缓存语义 to apply 封装在定义中，这会导致 method 用于将数据放入缓存中，而 method 用于驱逐数据。这两个定义都适用于缓存。bookServicecache:advicefindBooksloadBooksbooksspring-doc.cn

该定义将缓存建议应用于使用 AspectJ 切入点表达式编程（更多信息可在 Aspect Oriented Programming with Spring 中找到）。在前面的示例中，考虑中的所有方法，并将 Cache 建议应用于它们。aop:configBookServicespring-doc.cn

声明式 XML 缓存支持所有基于注释的模型，因此在这两者应该相当容易。此外，两者都可以在同一个应用程序中使用。基于 XML 的方法不会触及目标代码。然而，它本质上更多详细。当处理具有针对缓存时，确定正确的方法确实需要额外的努力，因为 argument 不是一个好的鉴别器。在这些情况下，您可以使用 AspectJ 切入点择优选择目标方法并应用适当的缓存功能。但是，通过 XML，可以更轻松地应用包或组或接口范围的缓存（同样，由于 AspectJ 切入点）并创建类似模板的定义（就像我们所做的那样在前面的示例中，通过属性定义目标缓存）。methodcache:definitionscachespring-doc.cn

8.5. 配置缓存存储

缓存抽象提供了多个存储集成选项。要使用它们，您需要声明一个 appropriate （一个控制和管理实例的实体，可用于检索这些实例以进行存储）。CacheManagerCachespring-doc.cn

8.5.1. 基于 JDK 的缓存`ConcurrentMap`

基于 JDK 的实现位于 package 下。它允许您用作后备存储。以下示例演示如何配置两个缓存：Cacheorg.springframework.cache.concurrentConcurrentHashMapCachespring-doc.cn

<!-- simple cache manager -->
<bean id="cacheManager" class="org.springframework.cache.support.SimpleCacheManager">
    <property name="caches">
        <set>
            <bean class="org.springframework.cache.concurrent.ConcurrentMapCacheFactoryBean" p:name="default"/>
            <bean class="org.springframework.cache.concurrent.ConcurrentMapCacheFactoryBean" p:name="books"/>
        </set>
    </property>
</bean>

前面的代码段使用为两个名为和的嵌套实例。请注意，名称是直接为每个缓存配置的。SimpleCacheManagerCacheManagerConcurrentMapCachedefaultbooksspring-doc.cn

由于缓存是由应用程序创建的，因此它与它的生命周期绑定，使其成为适用于基本用例、测试或简单应用程序。缓存扩展性良好并且速度非常快，但是它不提供任何管理、持久化功能，或驱逐合同。spring-doc.cn

8.5.2. 基于 Ehcache 的缓存

Ehcache 3.x 完全符合 JSR-107 标准，不需要专门的支持。

Ehcache 2.x 实现位于包中。同样，要使用它，您需要声明适当的 . 以下示例显示了如何执行此操作：org.springframework.cache.ehcacheCacheManagerspring-doc.cn

<bean id="cacheManager"
        class="org.springframework.cache.ehcache.EhCacheCacheManager" p:cache-manager-ref="ehcache"/>

<!-- EhCache library setup -->
<bean id="ehcache"
        class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean" p:config-location="ehcache.xml"/>

此设置引导 Spring IoC 中的 ehcache 库（通过 bean），然后将其连接到专用实现中。请注意，整个特定于 Ehcache 的配置都是从中读取的。ehcacheCacheManagerehcache.xmlspring-doc.cn

8.5.3. 咖啡因缓存

Caffeine 是 Guava 缓存的 Java 8 重写版，其实现位于包中，并提供对多种功能的访问咖啡因。org.springframework.cache.caffeinespring-doc.cn

以下示例配置了按需创建缓存的 a：CacheManagerspring-doc.cn

<bean id="cacheManager"
        class="org.springframework.cache.caffeine.CaffeineCacheManager"/>

您还可以提供要显式使用的缓存。在这种情况下，只有那些由 Manager 提供。以下示例显示了如何执行此操作：spring-doc.cn

<bean id="cacheManager" class="org.springframework.cache.caffeine.CaffeineCacheManager">
    <property name="caches">
        <set>
            <value>default</value>
            <value>books</value>
        </set>
    </property>
</bean>

Caffeine 还支持自定义和 . 有关这些内容的更多信息，请参阅 Caffeine 文档。CacheManagerCaffeineCacheLoaderspring-doc.cn

8.5.4. 基于 GemFire 的缓存

GemFire 是一种面向内存、磁盘支持、弹性可扩展、持续可用的 GemFire 活动（具有内置的基于模式的订阅通知），全局复制数据库并提供功能齐全的边缘缓存。有关如何将 GemFire 用作（以及更多），请参阅 Spring Data GemFire 参考文档。CacheManagerspring-doc.cn

8.5.5. JSR-107 缓存

Spring 的缓存抽象也可以使用符合 JSR-107 的缓存。The JCache implementation 位于 package 中。org.springframework.cache.jcachespring-doc.cn

同样，要使用它，您需要声明适当的 . 以下示例显示了如何执行此操作：CacheManagerspring-doc.cn

<bean id="cacheManager"
        class="org.springframework.cache.jcache.JCacheCacheManager"
        p:cache-manager-ref="jCacheManager"/>

<!-- JSR-107 cache manager setup  -->
<bean id="jCacheManager" .../>

8.5.6. 处理没有 Backing Store 的 Cache

有时，在切换环境或执行测试时，您可能有缓存声明，而无需配置实际的后备缓存。由于这是无效的配置，则在运行时会引发异常，因为缓存基础设施找不到合适的商店。在这种情况下，与其删除 cache 声明（这可能很乏味），您可以连接一个简单的虚拟缓存，该不执行缓存 — 也就是说，它强制每次都调用缓存的方法。以下示例显示了如何执行此操作：spring-doc.cn

<bean id="cacheManager" class="org.springframework.cache.support.CompositeCacheManager">
    <property name="cacheManagers">
        <list>
            <ref bean="jdkCache"/>
            <ref bean="gemfireCache"/>
        </list>
    </property>
    <property name="fallbackToNoOpCache" value="true"/>
</bean>

在前面的链接中，多个实例和通过该标志，为所有定义添加一个 no-op 缓存，而不是由配置的缓存管理器处理。也就是说，在或（在示例前面配置）由 no-op 缓存，它不存储任何信息，导致 Target 方法每次调用。CompositeCacheManagerCacheManagerfallbackToNoOpCachejdkCachegemfireCachespring-doc.cn

8.6. 插入不同的后端缓存

显然，有很多缓存产品可以用作后盾商店。对于不支持 JSR-107 的 API，您需要提供 a 和 a implementation。这听起来可能比实际更难，因为在实践中，类往往是简单的适配器，它们将缓存抽象框架在存储 API 之上，就像类一样。大多数类都可以使用包中的类（例如，它采用注意样板代码，只留下实际的映射完成）。CacheManagerCacheehcacheCacheManagerorg.springframework.cache.supportAbstractCacheManagerspring-doc.cn

8.7. 如何设置 TTL/TTI/驱逐策略/XXX 功能？

直接通过缓存提供商。缓存抽象是一个抽象而不是缓存实现。您使用的解决方案可能支持各种数据策略和其他解决方案不支持的不同拓扑（例如 JDK — 在缓存抽象中公开它将毫无用处因为没有支持）。应控制此类功能直接通过后备缓存（配置时）或通过其本机 API。ConcurrentHashMapspring-doc.cn

9. 附录

9.1. XML 架构

附录的这一部分列出了与集成技术相关的 XML 模式。spring-doc.cn

9.1.1. 模式`jee`

这些元素处理与 Java EE （Java Enterprise Edition）配置、例如，查找 JNDI 对象和定义 EJB 引用。jeespring-doc.cn

要使用架构中的元素，您需要在顶部具有以下序言的 Spring XML 配置文件。以下代码段中的文本引用了 correct schema，以便命名空间中的元素可供您使用：jeejeespring-doc.cn

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

    <!-- bean definitions here -->

</beans>

<jee：jndi-lookup/> （简单）

以下示例演示如何使用 JNDI 查找没有架构的数据源：jeespring-doc.cn

<bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean">
    <property name="jndiName" value="jdbc/MyDataSource"/>
</bean>
<bean id="userDao" class="com.foo.JdbcUserDao">
    <!-- Spring will do the cast automatically (as usual) -->
    <property name="dataSource" ref="dataSource"/>
</bean>

以下示例显示了如何使用 JNDI 查找具有架构的数据源：jeespring-doc.cn

<jee:jndi-lookup id="dataSource" jndi-name="jdbc/MyDataSource"/>

<bean id="userDao" class="com.foo.JdbcUserDao">
    <!-- Spring will do the cast automatically (as usual) -->
    <property name="dataSource" ref="dataSource"/>
</bean>

`<jee:jndi-lookup/>`（使用单个 JNDI 环境设置）

以下示例显示如何使用 JNDI 查找环境变量，而无需：jeespring-doc.cn

<bean id="simple" class="org.springframework.jndi.JndiObjectFactoryBean">
    <property name="jndiName" value="jdbc/MyDataSource"/>
    <property name="jndiEnvironment">
        <props>
            <prop key="ping">pong</prop>
        </props>
    </property>
</bean>

以下示例显示了如何使用 JNDI 查找环境变量：jeespring-doc.cn

<jee:jndi-lookup id="simple" jndi-name="jdbc/MyDataSource">
    <jee:environment>ping=pong</jee:environment>
</jee:jndi-lookup>

`<jee:jndi-lookup/>`（具有多个 JNDI 环境设置）

以下示例说明如何使用 JNDI 查找多个环境变量没有：jeespring-doc.cn

<bean id="simple" class="org.springframework.jndi.JndiObjectFactoryBean">
    <property name="jndiName" value="jdbc/MyDataSource"/>
    <property name="jndiEnvironment">
        <props>
            <prop key="sing">song</prop>
            <prop key="ping">pong</prop>
        </props>
    </property>
</bean>

以下示例显示如何使用 JNDI 通过以下方式查找多个环境变量：jeespring-doc.cn

<jee:jndi-lookup id="simple" jndi-name="jdbc/MyDataSource">
    <!-- newline-separated, key-value pairs for the environment (standard Properties format) -->
    <jee:environment>
        sing=song
        ping=pong
    </jee:environment>
</jee:jndi-lookup>

`<jee:jndi-lookup/>`（复杂）

以下示例显示了如何使用 JNDI 查找数据源和许多不同的属性没有：jeespring-doc.cn

<bean id="simple" class="org.springframework.jndi.JndiObjectFactoryBean">
    <property name="jndiName" value="jdbc/MyDataSource"/>
    <property name="cache" value="true"/>
    <property name="resourceRef" value="true"/>
    <property name="lookupOnStartup" value="false"/>
    <property name="expectedType" value="com.myapp.DefaultThing"/>
    <property name="proxyInterface" value="com.myapp.Thing"/>
</bean>

以下示例显示了如何使用 JNDI 查找数据源和许多不同的属性：jeespring-doc.cn

<jee:jndi-lookup id="simple"
        jndi-name="jdbc/MyDataSource"
        cache="true"
        resource-ref="true"
        lookup-on-startup="false"
        expected-type="com.myapp.DefaultThing"
        proxy-interface="com.myapp.Thing"/>

`<jee:local-slsb/>`（简单）

该元素配置对本地 EJB 无状态会话 Bean 的引用。<jee:local-slsb/>spring-doc.cn

以下示例说明如何配置对本地 EJB 无状态会话 Bean 的引用没有：jeespring-doc.cn

<bean id="simple"
        class="org.springframework.ejb.access.LocalStatelessSessionProxyFactoryBean">
    <property name="jndiName" value="ejb/RentalServiceBean"/>
    <property name="businessInterface" value="com.foo.service.RentalService"/>
</bean>

以下示例说明如何配置对本地 EJB 无状态会话 Bean 的引用跟：jeespring-doc.cn

<jee:local-slsb id="simpleSlsb" jndi-name="ejb/RentalServiceBean"
        business-interface="com.foo.service.RentalService"/>

`<jee:local-slsb/>`（复杂）

该元素配置对本地 EJB 无状态会话 Bean 的引用。<jee:local-slsb/>spring-doc.cn

以下示例说明如何配置对本地 EJB 无状态会话 Bean 的引用以及一些没有：jeespring-doc.cn

<bean id="complexLocalEjb"
        class="org.springframework.ejb.access.LocalStatelessSessionProxyFactoryBean">
    <property name="jndiName" value="ejb/RentalServiceBean"/>
    <property name="businessInterface" value="com.example.service.RentalService"/>
    <property name="cacheHome" value="true"/>
    <property name="lookupHomeOnStartup" value="true"/>
    <property name="resourceRef" value="true"/>
</bean>

以下示例说明如何配置对本地 EJB 无状态会话 Bean 的引用以及许多具有：jeespring-doc.cn

<jee:local-slsb id="complexLocalEjb"
        jndi-name="ejb/RentalServiceBean"
        business-interface="com.foo.service.RentalService"
        cache-home="true"
        lookup-home-on-startup="true"
        resource-ref="true">

<jee：remote-slsb/>

该元素配置对 EJB 无状态会话 Bean 的引用。<jee:remote-slsb/>remotespring-doc.cn

以下示例说明如何配置对远程 EJB 无状态会话 Bean 的引用没有：jeespring-doc.cn

<bean id="complexRemoteEjb"
        class="org.springframework.ejb.access.SimpleRemoteStatelessSessionProxyFactoryBean">
    <property name="jndiName" value="ejb/MyRemoteBean"/>
    <property name="businessInterface" value="com.foo.service.RentalService"/>
    <property name="cacheHome" value="true"/>
    <property name="lookupHomeOnStartup" value="true"/>
    <property name="resourceRef" value="true"/>
    <property name="homeInterface" value="com.foo.service.RentalService"/>
    <property name="refreshHomeOnConnectFailure" value="true"/>
</bean>

以下示例说明如何配置对远程 EJB 无状态会话 Bean 的引用跟：jeespring-doc.cn

<jee:remote-slsb id="complexRemoteEjb"
        jndi-name="ejb/MyRemoteBean"
        business-interface="com.foo.service.RentalService"
        cache-home="true"
        lookup-home-on-startup="true"
        resource-ref="true"
        home-interface="com.foo.service.RentalService"
        refresh-home-on-connect-failure="true">

9.1.2. 模式`jms`

这些元素处理配置与 JMS 相关的 bean，例如 Spring 的 Message Listener Containers。这些元素在标题为 JMS Namespace Support 的 JMS 章节中。有关此支持的完整详细信息，请参阅该章以及元素本身。jmsjmsspring-doc.cn

为了完整起见，要使用 schema 中的元素，您需要具有以下 preamble 位于 Spring XML 配置文件的顶部。的以下代码段引用了正确的架构，以便命名空间中的元素可供您使用：jmsjmsspring-doc.cn

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

    <!-- bean definitions here -->

</beans>

9.1.3. 使用`<context:mbean-export/>`

配置基于 Annotation 的 MBean 导出中详细介绍了此元素。spring-doc.cn

9.1.4. 模式`cache`

您可以使用这些元素来启用对 Spring 的、、和注释。它还支持基于 XML 的声明式缓存。有关详细信息，请参阅启用缓存注释和基于 XML 的声明性缓存。cache@CacheEvict@CachePut@Cachingspring-doc.cn

要使用架构中的元素，您需要在 top 的 Spring XML 配置文件。以下代码段中的文本引用正确的架构，以便命名空间中的元素可供您使用：cachecachespring-doc.cn

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

    <!-- bean definitions here -->

</beans>

集成

1. 远程处理和 Web 服务

1.1. RMI

1.1.1. 使用 Export ServiceRmiServiceExporter

1.1.2. 在客户端的服务中链接

1.2. 使用 Hessian 通过 HTTP 远程调用服务

1.2.1. 黑森州

1.2.2. 使用HessianServiceExporter

1.2.3. 在客户端的服务中链接

1.2.4. 将 HTTP 基本身份验证应用于通过 Hessian 公开的服务

1.3. Spring HTTP 调用程序

1.3.1. 公开 Service 对象

1.3.2. 在客户端链接服务

1.4. Java Web 服务

1.4.1. 使用 JAX-WS 公开基于 Servlet 的 Web 服务

1.4.2. 使用 JAX-WS 导出独立 Web 服务

1.4.3. 使用 JAX-WS RI 的 Spring 支持导出 Web 服务

1.4.4. 使用 JAX-WS 访问 Web 服务

1.5. JMS

1.5.1. 服务器端配置

1.5.2. 客户端配置

1.6. AMQP

1.7. 选择技术时的注意事项

1.8. REST 端点

1.8.1.RestTemplate

初始化

URI

头

身体

消息转换

Jackson JSON 视图

多部分

1.8.2. 使用（已弃用）AsyncRestTemplate

2. Enterprise JavaBeans （EJB） 集成

2.1. 访问 EJB

2.1.1. 概念

2.1.2. 访问本地 SLSB

2.1.3. 访问远程 SLSB

2.1.4. 访问 EJB 2.x SLSB 与 EJB 3 SLSB

3. JMS（Java 消息服务）

3.1. 使用 Spring JMS

3.1.1. 使用JmsTemplate

3.1.2. 连接

缓存消息收发资源

用SingleConnectionFactory

用CachingConnectionFactory

3.1.3. 目的地管理

3.1.4. 消息侦听器容器

用SimpleMessageListenerContainer

用DefaultMessageListenerContainer

3.1.5. 事务管理

3.2. 发送消息

3.2.1. 使用消息转换器

3.2.2. 使用 和SessionCallbackProducerCallback

3.3. 接收消息

3.3.1. 同步接收

3.3.2. 异步接收：消息驱动的 POJO

3.3.3. 使用界面SessionAwareMessageListener

3.3.4. 使用MessageListenerAdapter

3.3.5. 在 Transactions 中处理消息

3.4. 支持 JCA 消息端点

3.5. 注解驱动的侦听器端点

3.5.1. 启用 Listener 端点注解

3.5.2. 编程端点注册

3.5.3. 带注释的端点方法签名

3.5.4. 响应管理

3.6. JMS 命名空间支持

4. JMX

4.1. 将 bean 导出到 JMX

4.1.1. 创建 MBeanServer

4.1.2. 重用现有的MBeanServer

4.1.3. 延迟初始化的 MBean

4.1.4. 自动注册 MBean

4.1.5. 控制注册行为

4.2. 控制 bean 的管理接口

4.2.1. 使用界面MBeanInfoAssembler

4.2.2. 使用源级元数据：Java 注解

4.2.3. 源级元数据类型

4.2.4. 使用界面AutodetectCapableMBeanInfoAssembler

4.2.5. 使用 Java 接口定义管理接口

1.1.1. 使用 Export Service`RmiServiceExporter`

1.2.2. 使用`HessianServiceExporter`

1.8.1.`RestTemplate`

1.8.2. 使用（已弃用）`AsyncRestTemplate`

2. Enterprise JavaBeans （EJB）集成

3.1.1. 使用`JmsTemplate`

用`SingleConnectionFactory`

用`CachingConnectionFactory`

用`SimpleMessageListenerContainer`

用`DefaultMessageListenerContainer`

3.2.2. 使用和`SessionCallbackProducerCallback`

3.3.3. 使用界面`SessionAwareMessageListener`

3.3.4. 使用`MessageListenerAdapter`

4.1.2. 重用现有的`MBeanServer`

4.2.1. 使用界面`MBeanInfoAssembler`

4.2.4. 使用界面`AutodetectCapableMBeanInfoAssembler`

4.2.6. 使用`MethodNameBasedMBeanInfoAssembler`

4.3. 控制 bean 的实例`ObjectName`

4.3.1. 从属性中读取实例`ObjectName`

4.3.2. 使用`MetadataNamingStrategy`

5.1.2. Spring 中的配置`ConnectionFactory`

5.2.2. 使用`CciTemplate`

5.2.5. 小结`CciTemplateInteraction`

5.2.7. 使用示例`CciTemplate`

5.3.1. 使用`MappingRecordOperation`

5.3.2. 使用`MappingCommAreaOperation`

5.3.5. 使用示例`MappingRecordOperation`

5.3.6. 使用示例`MappingCommAreaOperation`

6.1.1. 基本和用法`MailSenderSimpleMailMessage`

6.1.2. 使用和`JavaMailSenderMimeMessagePreparator`

6.2. 使用 JavaMail`MimeMessageHelper`

7.1. Spring 抽象`TaskExecutor`

7.1.1. 类型`TaskExecutor`

7.1.2. 使用`TaskExecutor`

7.2. Spring 抽象`TaskScheduler`

7.2.1. 界面`Trigger`

7.2.2. 实现`Trigger`

7.2.3. 实现`TaskScheduler`

7.3.2. 注解`@Scheduled`

7.3.3. 注解`@Async`

7.3.4. 执行人资格`@Async`

7.3.5. 异常管理`@Async`

7.4. 命名空间`task`

7.4.2. 元素`executor`

7.5.1. 使用`JobDetailFactoryBean`

7.5.2. 使用`MethodInvokingJobDetailFactoryBean`

7.5.3. 使用 Triggers 和`SchedulerFactoryBean`