JPA 支持

JPA 支持

Spring 集成的 JPA（Java 持久性 API）模块提供了使用 JPA 执行各种数据库作的组件。spring-doc.cadn.net.cn

您需要将此依赖项包含在您的项目中：spring-doc.cadn.net.cn

Maven 系列
<dependency>
    <groupId>org.springframework.integration</groupId>
    <artifactId>spring-integration-jpa</artifactId>
    <version>6.0.9</version>
</dependency>
Gradle
compile "org.springframework.integration:spring-integration-jpa:6.0.9"

JPA API 必须通过一些特定于供应商的实现来包含，例如 Hibernate ORM Framework。spring-doc.cadn.net.cn

提供了以下组件：spring-doc.cadn.net.cn

这些组件可用于执行select,create,update和delete对目标数据库的作。spring-doc.cadn.net.cn

JPA 入站通道适配器允许您轮询和检索 （select） 数据，而 JPA 出站通道适配器允许您创建、更新和删除实体。spring-doc.cadn.net.cn

您可以使用 JPA 的出站网关将实体持久保存到数据库中，从而继续流并向下游执行更多组件。 同样，您可以使用出站网关从数据库中检索实体。spring-doc.cadn.net.cn

例如，您可以使用出站网关，它接收Message替换为userId作为其请求通道上的有效负载，以查询数据库，检索 User 实体，并将其传递到下游以进行进一步处理。spring-doc.cadn.net.cn

认识到这些语义差异， Spring 集成提供了两个单独的 JPA 出站网关：spring-doc.cadn.net.cn

功能性

所有 JPA 组件都使用以下选项之一执行各自的 JPA作：spring-doc.cadn.net.cn

以下部分更详细地介绍了每个组件。spring-doc.cadn.net.cn

支持的持久性提供程序

Spring 集成 JPA 支持已针对 Hibernate 持久化提供程序进行了测试。spring-doc.cadn.net.cn

Java 实现

提供的每个组件都使用o.s.i.jpa.core.JpaExecutor类，而 API 的 API 类又使用o.s.i.jpa.core.JpaOperations接口。JpaOperations其作方式与典型的数据访问对象 （DAO） 类似，并提供 find、persist、executeUpdate 等方法。 对于大多数用例，默认实现 （o.s.i.jpa.core.DefaultJpaOperations） 应该就足够了。 但是，如果需要自定义行为，您可以指定自己的实现。spring-doc.cadn.net.cn

要初始化JpaExecutor，您必须使用接受以下之一的构造函数之一：spring-doc.cadn.net.cn

以下示例演示如何初始化JpaExecutor替换为entityManagerFactory并在出站网关中使用它：spring-doc.cadn.net.cn

@Bean
public JpaExecutor jpaExecutor() {
    JpaExecutor executor = new JpaExecutor(this.entityManagerFactory);
    executor.setJpaParameters(Collections.singletonList(new JpaParameter("firstName", null, "#this")));
    executor.setUsePayloadAsParameterSource(true);
    executor.setExpectSingleResult(true);
    return executor;
}

@ServiceActivator(inputChannel = "getEntityChannel")
@Bean
public MessageHandler retrievingJpaGateway() {
    JpaOutboundGateway gateway = new JpaOutboundGateway(jpaExecutor());
    gateway.setGatewayType(OutboundGatewayType.RETRIEVING);
    gateway.setOutputChannelName("resultsChannel");
    return gateway;
}

命名空间支持

使用 XML 名称空间支持时，底层解析器类会为您实例化相关的 Java 类。 因此，您通常不需要处理 JPA 适配器的内部工作原理。 本节记录了 Spring 集成提供的 XML 名称空间支持，并向您展示如何使用 XML 名称空间支持来配置 JPA 组件。spring-doc.cadn.net.cn

常见的 XML 名称空间配置属性

某些配置参数由所有 JPA 组件共享：spring-doc.cadn.net.cn

auto-startup

Lifecycle 属性，用于指示是否应在应用程序上下文启动期间启动此组件。 默认为true. 自选。spring-doc.cadn.net.cn

id

标识底层 Spring Bean 定义，它是EventDrivenConsumer或PollingConsumer. 自选。spring-doc.cadn.net.cn

entity-manager-factory

对适配器用于创建EntityManager. 您必须提供此属性entity-manager属性或jpa-operations属性。spring-doc.cadn.net.cn

entity-manager

对组件使用的 JPA 实体管理器的引用。 您必须提供此属性entity-manager-factory属性或jpa-operations属性。spring-doc.cadn.net.cn

通常，Spring 应用程序上下文只定义一个 JPA 实体管理器工厂，而EntityManager使用@PersistenceContext注解。 这种方法不适用于 Spring 集成 JPA 组件。 通常，注入 JPA 实体管理器工厂是最好的，但是，当您想注入EntityManager显式地，您必须定义一个SharedEntityManagerBean. 有关更多信息，请参阅相关的 Javadoc。

以下示例显示了如何显式包含实体管理器工厂：spring-doc.cadn.net.cn

<bean id="entityManager"
      class="org.springframework.orm.jpa.support.SharedEntityManagerBean">
    <property name="entityManagerFactory" ref="entityManagerFactoryBean" />
</bean>
jpa-operations

对实现JpaOperations接口。 在极少数情况下，建议您提供自己的JpaOperations接口，而不是依赖默认实现 （org.springframework.integration.jpa.core.DefaultJpaOperations). 如果您使用jpa-operations属性，则不得提供 JPA 实体管理器或 JPA 实体管理器工厂，因为JpaOperations包装必要的 DataSource。spring-doc.cadn.net.cn

entity-class

实体类的完全限定名称。 这个 attribute 的确切语义会有所不同，具体取决于我们是否执行persist或update作，或者我们是否要从数据库中检索对象。spring-doc.cadn.net.cn

在检索数据时，您可以指定entity-class属性来指示您希望从数据库中检索此类型的对象。 在这种情况下，您不得定义任何查询属性 （jpa-query,native-query或named-query).spring-doc.cadn.net.cn

持久化数据时，entity-classattribute 指示要保留的对象类型。 如果未指定（对于持久作），则会自动从消息的有效负载中检索实体类。spring-doc.cadn.net.cn

jpa-query

定义要使用的 JPA 查询 （Java 持久性查询语言）。spring-doc.cadn.net.cn

native-query

定义要使用的本机 SQL 查询。spring-doc.cadn.net.cn

named-query

引用命名查询。 命名查询可以在 Native SQL 或 JPAQL 中定义，但底层 JPA 持久性提供程序在内部处理这种区别。spring-doc.cadn.net.cn

提供 JPA 查询参数

要提供参数，您可以使用parameterXML 元素。 它具有一种机制，允许您为基于 Java 持久性查询语言 （JPQL） 或本机 SQL 查询的查询提供参数。 您还可以为命名查询提供参数。spring-doc.cadn.net.cn

基于表达式的参数

以下示例演示如何设置基于表达式的参数：spring-doc.cadn.net.cn

<int-jpa:parameter expression="payload.name" name="firstName"/>
基于值的参数

以下示例说明如何设置基于值的参数：spring-doc.cadn.net.cn

<int-jpa:parameter name="name" type="java.lang.String" value="myName"/>
位置参数

以下示例演示如何设置基于表达式的参数：spring-doc.cadn.net.cn

<int-jpa:parameter expression="payload.name"/>
<int-jpa:parameter type="java.lang.Integer" value="21"/>

事务处理

所有 JPA作（例如INSERT,UPDATE和DELETE） 要求事务在执行时处于活动状态。 对于入站通道适配器，您无需执行任何特殊作。 它的工作方式类似于我们使用与其他入站通道适配器一起使用的 Poller 配置事务管理器的方式。 下面的 XML 示例配置了一个事务管理器，该事务管理器使用带有入站通道适配器的 Poller ：spring-doc.cadn.net.cn

<int-jpa:inbound-channel-adapter
    channel="inboundChannelAdapterOne"
    entity-manager="em"
    auto-startup="true"
    jpa-query="select s from Student s"
    expect-single-result="true"
    delete-after-poll="true">
    <int:poller fixed-rate="2000" >
        <int:transactional propagation="REQUIRED"
            transaction-manager="transactionManager"/>
    </int:poller>
</int-jpa:inbound-channel-adapter>

但是，在使用出站通道适配器或网关时，您可能需要专门启动事务。 如果DirectChannel是出站适配器或网关的 input 通道，如果事务在当前执行线程中处于活动状态，则 JPA作将在同一事务上下文中执行。 您还可以将此 JPA作配置为作为新事务运行，如下例所示：spring-doc.cadn.net.cn

<int-jpa:outbound-gateway
    request-channel="namedQueryRequestChannel"
    reply-channel="namedQueryResponseChannel"
    named-query="updateStudentByRollNumber"
    entity-manager="em"
    gateway-type="UPDATING">
    <int-jpa:parameter name="lastName" expression="payload"/>
    <int-jpa:parameter name="rollNumber" expression="headers['rollNumber']"/>
		<int-jpa:transactional propagation="REQUIRES_NEW"
        transaction-manager="transactionManager"/>
</int-jpa:outbound-gateway>

在前面的示例中，出站网关或适配器的 transactional 元素指定了事务属性。 如果您有DirectChannel作为适配器的 input 通道，并且您希望适配器在与调用者相同的事务上下文中执行作。 但是，如果您使用ExecutorChannel，您必须具有transactional元素，因为调用客户端的事务上下文不会传播。spring-doc.cadn.net.cn

与transactional元素，该元素定义在 Spring Integration 的名称空间中，transactional元素在 JPA 命名空间中定义。

入站通道适配器

入站通道适配器用于使用 JPA QL 对数据库执行 select 查询并返回结果。 消息有效负载可以是单个实体，也可以是List的实体。 以下 XML 配置了一个inbound-channel-adapter:spring-doc.cadn.net.cn

<int-jpa:inbound-channel-adapter channel="inboundChannelAdapterOne"  (1)
                    entity-manager="em"                              (2)
                    auto-startup="true"                              (3)
                    query="select s from Student s"                  (4)
                    expect-single-result="true"                      (5)
                    max-results=""                                   (6)
                    max-results-expression=""                        (7)
                    delete-after-poll="true"                         (8)
                    flush-after-delete="true">                       (9)
    <int:poller fixed-rate="2000" >
      <int:transactional propagation="REQUIRED" transaction-manager="transactionManager"/>
    </int:poller>
</int-jpa:inbound-channel-adapter>
1 该通道inbound-channel-adapter将消息（连同有效负载）放在执行 JPA QL 之后的query属性。
2 这EntityManager实例。
3 Attribute 指示组件是否应在应用程序上下文启动时自动启动。 该值默认为true.
4 其结果作为消息的有效负载发送的 JPA QL
5 此属性指示 JPQL 查询是在结果中给出单个实体，还是给出List的实体。 如果该值设置为true，则单个实体将作为消息的有效负载发送。 但是，如果在将此项设置为true一个MessagingException被抛出。 该值默认为false.
6 此非零、非负整数值指示适配器在执行 select作时选择不超过给定行数的行数。 默认情况下，如果未设置此属性，则查询将选择所有可能的记录。 此属性与max-results-expression. 自选。
7 一个表达式，用于查找结果集中的最大结果数。 互斥max-results. 自选。
8 将此值设置为true如果要删除执行查询后收到的行。 您必须确保该组件作为事务的一部分运行。 否则，您可能会遇到如下异常：java.lang.IllegalArgumentException: Removing a detached instance …​
9 将此值设置为true如果要在删除收到的实体后立即刷新持久性上下文，并且不想依赖flushMode的EntityManager. 该值默认为false.

配置参数参考

下面的清单显示了可以为inbound-channel-adapter:spring-doc.cadn.net.cn

<int-jpa:inbound-channel-adapter
  auto-startup="true"           (1)
  channel=""                    (2)
  delete-after-poll="false"     (3)
  delete-per-row="false"        (4)
  entity-class=""               (5)
  entity-manager=""             (6)
  entity-manager-factory=""     (7)
  expect-single-result="false"  (8)
  id=""
  jpa-operations=""             (9)
  jpa-query=""                  (10)
  named-query=""                (11)
  native-query=""               (12)
  parameter-source=""           (13)
  send-timeout="">              (14)
  <int:poller ref="myPoller"/>
 </int-jpa:inbound-channel-adapter>
1 此生命周期属性指示此组件是否应在应用程序上下文启动时自动启动。 此属性默认为true. 自选。
2 适配器向其发送一条消息的通道，其中包含执行所需 JPA作的有效负载。
3 一个布尔标志，指示是否在适配器轮询所选记录后删除这些记录。 默认情况下，值为false（即，记录不会被删除）。 您必须确保该组件作为事务的一部分运行。 否则，您可能会遇到异常，例如：java.lang.IllegalArgumentException: Removing a detached instance …​. 自选。
4 一个布尔标志，指示记录是可以批量删除还是必须一次删除一条记录。 默认情况下，值为false（即，可以批量删除记录）。 自选。
5 要从数据库中查询的实体类的完全限定名称。 适配器根据实体类名自动构建 JPA 查询。 自选。
6 一个jakarta.persistence.EntityManager用于执行 JPA作。 自选。
7 一个jakarta.persistence.EntityManagerFactory用于获取jakarta.persistence.EntityManager执行 JPA作。 自选。
8 一个布尔标志，指示 select作是应返回单个结果还是List的结果。 如果此标志设置为true，则所选的单个实体将作为消息的有效负载发送。 如果返回多个实体，则会引发异常。 如果false这Listof entities 作为消息的有效负载发送。 该值默认为false. 自选。
9 的实现org.springframework.integration.jpa.core.JpaOperations用于执行 JPA作。 我们建议不要提供您自己的实现，而是使用默认的org.springframework.integration.jpa.core.DefaultJpaOperations实现。 您可以使用任何entity-manager,entity-manager-factory或jpa-operations属性。 自选。
10 要由此适配器执行的 JPA QL。 自选。
11 需要由此适配器执行的命名查询。 自选。
12 此适配器执行的本机查询。 您可以使用任何jpa-query,named-query,entity-class或native-query属性。 自选。
13 的实现o.s.i.jpa.support.parametersource.ParameterSource用于解析查询中参数的值。 如果entity-classattribute 具有值。 自选。
14 向通道发送消息时等待的最长时间（以毫秒为单位）。 自选。

使用 Java 配置进行配置

以下 Spring Boot 应用程序显示了如何使用 Java 配置入站适配器的示例：spring-doc.cadn.net.cn

@SpringBootApplication
@EntityScan(basePackageClasses = StudentDomain.class)
public class JpaJavaApplication {

    public static void main(String[] args) {
        new SpringApplicationBuilder(JpaJavaApplication.class)
            .web(false)
            .run(args);
    }

    @Autowired
    private EntityManagerFactory entityManagerFactory;

    @Bean
    public JpaExecutor jpaExecutor() {
        JpaExecutor executor = new JpaExecutor(this.entityManagerFactory);
        jpaExecutor.setJpaQuery("from Student");
        return executor;
    }

    @Bean
    @InboundChannelAdapter(channel = "jpaInputChannel",
                     poller = @Poller(fixedDelay = "${poller.interval}"))
    public MessageSource<?> jpaInbound() {
        return new JpaPollingChannelAdapter(jpaExecutor());
    }

    @Bean
    @ServiceActivator(inputChannel = "jpaInputChannel")
    public MessageHandler handler() {
        return message -> System.out.println(message.getPayload());
    }

}

使用 Java DSL 进行配置

Spring 下面的 Boot 应用程序显示了如何使用 Java DSL 配置入站适配器的示例：spring-doc.cadn.net.cn

@SpringBootApplication
@EntityScan(basePackageClasses = StudentDomain.class)
public class JpaJavaApplication {

    public static void main(String[] args) {
        new SpringApplicationBuilder(JpaJavaApplication.class)
            .web(false)
            .run(args);
    }

    @Autowired
    private EntityManagerFactory entityManagerFactory;

    @Bean
    public IntegrationFlow pollingAdapterFlow() {
        return IntegrationFlow
            .from(Jpa.inboundAdapter(this.entityManagerFactory)
                        .entityClass(StudentDomain.class)
                        .maxResults(1)
                        .expectSingleResult(true),
                e -> e.poller(p -> p.trigger(new OnlyOnceTrigger())))
            .channel(c -> c.queue("pollingResults"))
            .get();
    }

}

出站通道适配器

JPA 出站通道适配器允许您通过请求通道接受消息。 有效负载可以用作要保留的实体，也可以与 JPQL 查询的参数表达式中的标头一起使用。 以下部分介绍了执行这些作的可能方法。spring-doc.cadn.net.cn

使用 Entity 类

以下 XML 将出站通道适配器配置为将实体持久保存到数据库：spring-doc.cadn.net.cn

<int-jpa:outbound-channel-adapter channel="entityTypeChannel"               (1)
    entity-class="org.springframework.integration.jpa.test.entity.Student"  (2)
    persist-mode="PERSIST"                                                  (3)
    entity-manager="em"/ >                                                  (4)
1 将有效 JPA 实体发送到 JPA 出站通道适配器的通道。
2 适配器接受的实体类的完全限定名称，以保留在数据库中。 实际上，在大多数情况下，你可以省略这个属性，因为适配器可以从 Spring Integration 消息有效负载中自动确定实体类。
3 适配器要执行的作。 有效值为PERSIST,MERGE和DELETE. 默认值为MERGE.
4 要使用的 JPA 实体管理器。

的这四个属性outbound-channel-adapter将其配置为通过 Input Channel 接受实体并将其处理为PERSIST,MERGE或DELETE来自基础数据源的实体。spring-doc.cadn.net.cn

从 Spring Integration 3.0 开始，payloads 到PERSIST或MERGE也可以是 typejava.lang.Iterable. 在这种情况下，由Iterable被视为实体，并使用底层EntityManager. 迭代器返回的 Null 值将被忽略。
从版本 5.5.4 开始，JpaOutboundGateway，其中JpaExecutor配置了PersistMode.DELETE可以接受Iterablepayload 对提供的实体执行批量删除持久作。

使用 JPA 查询语言 （JPA QL）

上一节展示了如何执行PERSIST作。 本节介绍如何将出站通道适配器与 JPA QL 一起使用。spring-doc.cadn.net.cn

以下 XML 将出站通道适配器配置为将实体持久保存到数据库：spring-doc.cadn.net.cn

<int-jpa:outbound-channel-adapter channel="jpaQlChannel"                                      (1)
  jpa-query="update Student s set s.firstName = :firstName where s.rollNumber = :rollNumber"  (2)
  entity-manager="em">                                                                        (3)
    <int-jpa:parameter name="firstName"  expression="payload['firstName']"/>                  (4)
    <int-jpa:parameter name="rollNumber" expression="payload['rollNumber']"/>
</int-jpa:outbound-channel-adapter>
1 将消息发送到出站通道适配器的 input 通道。
2 要执行的 JPA QL。 此查询可能包含使用parameter元素。
3 适配器用于执行 JPA作的实体管理器。
4 用于定义 JPA QL 的参数名称值的元素（每个参数一个）query属性。

这parameter元素接受一个属性，该属性的name对应于提供的 JPA QL 中指定的命名参数（前面示例中的第 2 点）。 参数的值可以是 static，也可以是使用表达式派生的。 static 值和派生值的表达式是使用value和expression属性。 这些属性是互斥的。spring-doc.cadn.net.cn

如果value属性，则可以提供可选的type属性。 此属性的值是类的完全限定名称，其值由value属性。 默认情况下，该类型被假定为java.lang.String. 以下示例显示如何定义 JPA 参数：spring-doc.cadn.net.cn

<int-jpa:outbound-channel-adapter ...
>
    <int-jpa:parameter name="level" value="2" type="java.lang.Integer"/>
    <int-jpa:parameter name="name" expression="payload['name']"/>
</int-jpa:outbound-channel-adapter>

如前面的示例所示，您可以使用多个parameter元素，并使用表达式定义一些参数，并使用 Expressions 和其他具有 static 值的参数。 但是，请注意不要多次指定相同的参数名称。 您应该提供一个parameter元素。 例如，我们指定两个参数：level和name. 这levelattribute 是java.lang.Integer，而name属性派生自消息的有效负载。spring-doc.cadn.net.cn

虽然指定select对 JPA QL 有效，则这样做没有意义。 出站通道适配器不返回任何结果。 如果要选择一些值，请考虑改用出站网关。

使用本机查询

本节介绍如何使用本机查询对 JPA 出站通道适配器执行作。 使用本机查询与使用 JPA QL 类似，不同之处在于查询是本机数据库查询。 通过使用本机查询，我们失去了使用 JPA QL 获得的数据库供应商独立性。spring-doc.cadn.net.cn

通过使用本机查询，我们可以实现的一件事是执行数据库插入，这在 JPA QL 中是不可能的。 （为了执行插入，我们将 JPA 实体发送到通道适配器，如前所述）。 下面是一个小的 xml 片段，它演示了如何使用本机查询在表中插入值。spring-doc.cadn.net.cn

您的 JPA 提供程序可能不支持将命名参数与本机 SQL 查询结合使用。 虽然它们与 Hibernate 一起工作良好，但 OpenJPA 和 EclipseLink 不支持它们。 请参阅 https://issues.apache.org/jira/browse/OPENJPA-111。 JPA 2.0 规范的第 3.8.12 节规定：“只有位置参数绑定和对结果项的位置访问可以移植地用于本机查询。

以下示例使用本机查询配置 outbound-channel-adapter：spring-doc.cadn.net.cn

<int-jpa:outbound-channel-adapter channel="nativeQlChannel"
  native-query="insert into STUDENT_TABLE(FIRST_NAME,LAST_UPDATED) values (:lastName,:lastUpdated)"  (1)
  entity-manager="em">
    <int-jpa:parameter name="lastName" expression="payload['updatedLastName']"/>
    <int-jpa:parameter name="lastUpdated" expression="new java.util.Date()"/>
</int-jpa:outbound-channel-adapter>
1 此出站通道适配器执行的本机查询。

请注意，其他属性（例如channel和entity-manager） 和parameter元素具有与 JPA QL 相同的语义。spring-doc.cadn.net.cn

使用命名查询

使用命名查询与使用 JPA QL 或本机查询类似，不同之处在于我们指定命名查询而不是查询。 首先，我们将介绍如何定义 JPA 命名查询。 然后，我们将介绍如何声明出站通道适配器以使用命名查询。 如果我们有一个名为Student，我们可以在Student类来定义两个命名查询：selectStudent和updateStudent. 以下示例显示了如何执行此作：spring-doc.cadn.net.cn

@Entity
@Table(name="Student")
@NamedQueries({
    @NamedQuery(name="selectStudent",
        query="select s from Student s where s.lastName = 'Last One'"),
    @NamedQuery(name="updateStudent",
        query="update Student s set s.lastName = :lastName,
               lastUpdated = :lastUpdated where s.id in (select max(a.id) from Student a)")
})
public class Student {

...
}

或者，您可以使用 orm.xml 来定义命名查询，如下例所示：spring-doc.cadn.net.cn

<entity-mappings ...>
    ...
    <named-query name="selectStudent">
        <query>select s from Student s where s.lastName = 'Last One'</query>
    </named-query>
</entity-mappings>

现在我们已经展示了如何使用注释或使用orm.xml，我们现在显示一个小的 XML 片段，它定义了一个outbound-channel-adapter通过使用命名查询，如下例所示：spring-doc.cadn.net.cn

<int-jpa:outbound-channel-adapter channel="namedQueryChannel"
            named-query="updateStudent"	 (1)
            entity-manager="em">
        <int-jpa:parameter name="lastName" expression="payload['updatedLastName']"/>
        <int-jpa:parameter name="lastUpdated" expression="new java.util.Date()"/>
</int-jpa:outbound-channel-adapter>
1 我们希望适配器在通过通道接收消息时执行的命名查询。

配置参数参考

下面的清单显示了您可以在出站通道适配器上设置的所有属性：spring-doc.cadn.net.cn

<int-jpa:outbound-channel-adapter
  auto-startup="true"  (1)
  channel=""  (2)
  entity-class=""  (3)
  entity-manager=""  (4)
  entity-manager-factory=""  (5)
  id=""
  jpa-operations=""  (6)
  jpa-query=""  (7)
  named-query=""  (8)
  native-query=""  (9)
  order=""  (10)
  parameter-source-factory=""   (11)
  persist-mode="MERGE"   (12)
  flush="true"   (13)
  flush-size="10"   (14)
  clear-on-flush="true"   (15)
  use-payload-as-parameter-source="true"   (16)
	<int:poller/>
	<int-jpa:transactional/>    (17)
	<int-jpa:parameter/>    (18)
</int-jpa:outbound-channel-adapter>
1 生命周期属性指示此组件是否应在应用程序上下文启动期间启动。 它默认为true. 自选。
2 出站适配器从中接收消息以执行所需作的通道。
3 JPA Operation 的实体类的完全限定名称。 这entity-class,query和named-query属性是互斥的。 自选。
4 一个jakarta.persistence.EntityManager用于执行 JPA作。 自选。
5 一个jakarta.persistence.EntityManagerFactory用于获取jakarta.persistence.EntityManager执行 JPA作。 自选。
6 的实现org.springframework.integration.jpa.core.JpaOperations用于执行 JPA作。 我们建议不要提供您自己的实现，而是使用默认的org.springframework.integration.jpa.core.DefaultJpaOperations实现。 您可以使用任何一个entity-manager,entity-manager-factory或jpa-operations属性。 自选。
7 要由此适配器执行的 JPA QL。 自选。
8 需要由此适配器执行的命名查询。 自选。
9 此适配器要执行的本机查询。 您可以使用任何一个jpa-query,named-query或native-query属性。 自选。
10 注册多个使用者时此使用者的顺序，从而管理负载均衡和故障转移。 它默认为Ordered.LOWEST_PRECEDENCE. 自选。
11 一个o.s.i.jpa.support.parametersource.ParameterSourceFactory用于获取o.s.i.jpa.support.parametersource.ParameterSource，用于解析查询中参数的值。 如果您使用 JPA 实体执行作，则忽略。 这parameter子元素与parameter-source-factory属性，并且必须在提供的ParameterSourceFactory. 自选。
12 接受以下选项之一：PERSIST,MERGE或DELETE. 指示适配器需要执行的作。 仅当您将实体用于 JPA作时才相关。 如果您提供 JPA QL、命名查询或本机查询，则忽略。 它默认为MERGE. 自选。 从 Spring Integration 3.0 开始，要持久化或合并的有效负载也可以是 typejava.lang.Iterable. 在这种情况下，由Iterable被视为实体，并使用底层EntityManager. 迭代器返回的 Null 值将被忽略。
13 将此值设置为true如果您想在 persist、merge 或 delete作后立即刷新持久性上下文，并且不想依赖flushMode的EntityManager. 它默认为false. 仅在未指定flush-size属性。 如果此属性设置为true,flush-size隐式设置为1，如果没有其他值配置它。
14 如果要在 persist、merge 或 delete作后立即刷新持久性上下文，并且不想依赖flushMode的EntityManager. 默认值设置为0，意思是 “'no flush'”。 此属性适用于具有以下Iterable负载。 例如，如果flush-size设置为3然后entityManager.flush()在每三个实体之后调用。 此外entityManager.flush()在整个循环后再次调用。 如果 'flush-size' 属性指定的值大于 '0'，则无需配置flush属性。
15 如果要在每次刷新作后立即清除持久性上下文，请将此值设置为 'true'。 仅当flush属性设置为true或者，如果flush-size属性设置为大于0.
16 如果设置为true，则消息的有效负载将用作参数的源。 如果设置为false，但是，整个Message可用作参数的源。 自选。
17 定义事务管理属性和对 JPA 适配器要使用的事务管理器的引用。 自选。
18 一个或多个parameterattributes — 查询中使用的每个参数一个。 计算值或表达式以计算参数的值。 自选。

使用 Java 配置进行配置

Spring 下面的 Boot 应用程序显示了如何使用 Java 配置出站适配器的示例：spring-doc.cadn.net.cn

@SpringBootApplication
@EntityScan(basePackageClasses = StudentDomain.class)
@IntegrationComponentScan
public class JpaJavaApplication {

    public static void main(String[] args) {
        new SpringApplicationBuilder(JpaJavaApplication.class)
            .web(false)
            .run(args);
    }

    @Autowired
    private EntityManagerFactory entityManagerFactory;

    @MessagingGateway
    interface JpaGateway {

       @Gateway(requestChannel = "jpaPersistChannel")
       @Transactional
       void persistStudent(StudentDomain payload);

    }

    @Bean
    public JpaExecutor jpaExecutor() {
        JpaExecutor executor = new JpaExecutor(this.entityManagerFactory);
        jpaExecutor.setEntityClass(StudentDomain.class);
        jpaExecutor.setPersistMode(PersistMode.PERSIST);
        return executor;
    }

    @Bean
    @ServiceActivator(channel = "jpaPersistChannel")
    public MessageHandler jpaOutbound() {
        JpaOutboundGateway adapter = new JpaOutboundGateway(jpaExecutor());
        adapter.setProducesReply(false);
        return adapter;
    }

}

使用 Java DSL 进行配置

Spring 下面的 Boot 应用程序显示了如何使用 Java DSL 配置出站适配器的示例：spring-doc.cadn.net.cn

@SpringBootApplication
@EntityScan(basePackageClasses = StudentDomain.class)
public class JpaJavaApplication {

    public static void main(String[] args) {
        new SpringApplicationBuilder(JpaJavaApplication.class)
            .web(false)
            .run(args);
    }

    @Autowired
    private EntityManagerFactory entityManagerFactory;

    @Bean
    public IntegrationFlow outboundAdapterFlow() {
        return f -> f
                .handle(Jpa.outboundAdapter(this.entityManagerFactory)
                                .entityClass(StudentDomain.class)
                                .persistMode(PersistMode.PERSIST),
                        e -> e.transactional());
    }

}

出站网关

JPA 入站通道适配器允许您轮询数据库以检索一个或多个 JPA 实体。 因此，检索到的数据用于启动 Spring 集成流，该流使用检索到的数据作为消息有效负载。spring-doc.cadn.net.cn

此外，您可以在流的末尾使用 JPA 出站通道适配器来持久保存数据，实质上是在持久化作结束时停止流。spring-doc.cadn.net.cn

但是，如何在流中执行 JPA 持久性作呢？例如，您可能在 Spring Integration 消息流中处理了业务数据，并且您希望保留这些数据，但您仍然需要进一步使用下游的其他组件。 或者，您需要执行 JPQL 查询并主动检索数据，然后在流中的后续组件中处理数据，而不是使用 Poller 轮询数据库。spring-doc.cadn.net.cn

这就是 JPA 出站网关发挥作用的地方。 它们使您能够保存数据以及检索数据。 为了便于这些使用， Spring 集成提供了两种类型的 JPA 出站网关：spring-doc.cadn.net.cn

每当使用出站网关执行保存、更新或单独删除数据库中某些记录的作时，您都需要使用更新的出站网关。 例如，如果您使用entity为了持久化它，将返回一个合并和持久化的实体作为结果。 在其他情况下，将返回受影响的 （更新或删除） 的记录数。spring-doc.cadn.net.cn

从数据库中检索（选择）数据时，我们使用检索出站网关。 使用检索出站网关，我们可以使用 JPQL、命名查询（本机或基于 JPQL）或本机查询 （SQL） 来选择数据和检索结果。spring-doc.cadn.net.cn

更新的出站网关在功能上类似于出站通道适配器，不同之处在于，更新的出站网关在执行 JPA作后将结果发送到网关的回复通道。spring-doc.cadn.net.cn

检索出站网关类似于入站通道适配器。spring-doc.cadn.net.cn

我们建议您首先阅读本章前面的 Outbound Channel Adapter 部分和 Inbound Channel Adapter 部分，因为大多数常见概念都在其中进行了解释。

这种相似性是使用 centralJpaExecutor类来尽可能统一通用功能。spring-doc.cadn.net.cn

通用于所有 JPA 出站网关，类似于outbound-channel-adapter，我们可以使用它来执行各种 JPA作：spring-doc.cadn.net.cn

有关配置示例，请参阅 JPA 出站网关示例。spring-doc.cadn.net.cn

通用配置参数

JPA 出站网关始终可以访问 Spring 集成Message作为输入。 因此，可以使用以下参数：spring-doc.cadn.net.cn

parameter-source-factory

一个o.s.i.jpa.support.parametersource.ParameterSourceFactory用于获取o.s.i.jpa.support.parametersource.ParameterSource. 这ParameterSource用于解析查询中提供的参数的值。 如果您使用 JPA 实体执行作，则parameter-source-factory属性。 这parameter子元素与parameter-source-factory并且它们必须在提供的ParameterSourceFactory. 自选。spring-doc.cadn.net.cn

use-payload-as-parameter-source

如果设置为true，则Message用作参数的源。 如果设置为false，则整个Message可用作参数的源。 如果未传入 JPA 参数，则此属性默认为true. 这意味着，如果您使用默认的BeanPropertyParameterSourceFactory，则有效负载的 Bean 属性将用作 JPA 查询的参数值的源。 但是，如果传入了 JPA 参数，则默认情况下，此属性的计算结果为false. 原因是 JPA 参数允许您提供 SPEL 表达式。 因此，访问整个Message，包括标头。 自选。spring-doc.cadn.net.cn

更新出站网关

以下清单显示了您可以在 updating-outbound-gateway 上设置的所有属性，并描述了关键属性：spring-doc.cadn.net.cn

<int-jpa:updating-outbound-gateway request-channel=""  (1)
    auto-startup="true"
    entity-class=""
    entity-manager=""
    entity-manager-factory=""
    id=""
    jpa-operations=""
    jpa-query=""
    named-query=""
    native-query=""
    order=""
    parameter-source-factory=""
    persist-mode="MERGE"
    reply-channel=""  (2)
    reply-timeout=""  (3)
    use-payload-as-parameter-source="true">

    <int:poller/>
    <int-jpa:transactional/>

    <int-jpa:parameter name="" type="" value=""/>
    <int-jpa:parameter name="" expression=""/>
</int-jpa:updating-outbound-gateway>
1 出站网关从中接收消息以执行所需作的通道。 此属性类似于channel属性的outbound-channel-adapter. 自选。
2 网关在执行所需的 JPA作后将响应发送到的通道。 如果未定义此属性，则请求消息必须具有replyChannel页眉。 自选。
3 指定网关等待将结果发送到回复通道的时间。 仅当回复通道本身可能阻止发送作（例如，有界的QueueChannel目前已满）。 默认情况下，网关无限期等待。 该值以毫秒为单位指定。 自选。

其余属性在本章前面介绍。 请参阅 配置参数参考 和 配置参数参考。spring-doc.cadn.net.cn

使用 Java 配置进行配置

以下 Spring Boot 应用程序显示了如何使用 Java 配置出站适配器的示例：spring-doc.cadn.net.cn

@SpringBootApplication
@EntityScan(basePackageClasses = StudentDomain.class)
@IntegrationComponentScan
public class JpaJavaApplication {

    public static void main(String[] args) {
        new SpringApplicationBuilder(JpaJavaApplication.class)
            .web(false)
            .run(args);
    }

    @Autowired
    private EntityManagerFactory entityManagerFactory;

    @MessagingGateway
    interface JpaGateway {

       @Gateway(requestChannel = "jpaUpdateChannel")
       @Transactional
       void updateStudent(StudentDomain payload);

    }

    @Bean
    @ServiceActivator(channel = "jpaUpdateChannel")
    public MessageHandler jpaOutbound() {
        JpaOutboundGateway adapter =
               new JpaOutboundGateway(new JpaExecutor(this.entityManagerFactory));
        adapter.setOutputChannelName("updateResults");
        return adapter;
    }

}

使用 Java DSL 进行配置

以下 Spring Boot 应用程序显示了如何使用 Java DSL 配置出站适配器的示例：spring-doc.cadn.net.cn

@SpringBootApplication
@EntityScan(basePackageClasses = StudentDomain.class)
public class JpaJavaApplication {

    public static void main(String[] args) {
        new SpringApplicationBuilder(JpaJavaApplication.class)
            .web(false)
            .run(args);
    }

    @Autowired
    private EntityManagerFactory entityManagerFactory;

    @Bean
    public IntegrationFlow updatingGatewayFlow() {
        return f -> f
                .handle(Jpa.updatingGateway(this.entityManagerFactory),
                        e -> e.transactional(true))
                .channel(c -> c.queue("updateResults"));
    }

}

检索出站网关

以下示例演示如何配置检索出站网关：spring-doc.cadn.net.cn

Java DSL
@SpringBootApplication
@EntityScan(basePackageClasses = StudentDomain.class)
public class JpaJavaApplication {

    public static void main(String[] args) {
        new SpringApplicationBuilder(JpaJavaApplication.class)
            .web(false)
            .run(args);
    }

    @Autowired
    private EntityManagerFactory entityManagerFactory;

    @Bean
    public IntegrationFlow retrievingGatewayFlow() {
        return f -> f
                .handle(Jpa.retrievingGateway(this.entityManagerFactory)
                       .jpaQuery("from Student s where s.id = :id")
                       .expectSingleResult(true)
                       .parameterExpression("id", "payload"))
                .channel(c -> c.queue("retrieveResults"));
    }

}
Kotlin DSL
@Bean
fun retrievingGatewayFlow() =
    integrationFlow {
        handle(Jpa.retrievingGateway(this.entityManagerFactory)
                .jpaQuery("from Student s where s.id = :id")
                .expectSingleResult(true)
                .parameterExpression("id", "payload"))
        channel { queue("retrieveResults") }
    }
Java
@SpringBootApplication
@EntityScan(basePackageClasses = StudentDomain.class)
public class JpaJavaApplication {

    public static void main(String[] args) {
        new SpringApplicationBuilder(JpaJavaApplication.class)
            .web(false)
            .run(args);
    }

    @Autowired
    private EntityManagerFactory entityManagerFactory;


    @Bean
    public JpaExecutor jpaExecutor() {
        JpaExecutor executor = new JpaExecutor(this.entityManagerFactory);
        jpaExecutor.setJpaQuery("from Student s where s.id = :id");
        executor.setJpaParameters(Collections.singletonList(new JpaParameter("id", null, "payload")));
        jpaExecutor.setExpectSingleResult(true);
        return executor;
    }

    @Bean
    @ServiceActivator(channel = "jpaRetrievingChannel")
    public MessageHandler jpaOutbound() {
        JpaOutboundGateway adapter = new JpaOutboundGateway(jpaExecutor());
        adapter.setOutputChannelName("retrieveResults");
        adapter.setGatewayType(OutboundGatewayType.RETRIEVING);
        return adapter;
    }

}
XML 格式
<int-jpa:retrieving-outbound-gateway request-channel=""
    auto-startup="true"
    delete-after-poll="false"
    delete-in-batch="false"
    entity-class=""
    id-expression=""              (1)
    entity-manager=""
    entity-manager-factory=""
    expect-single-result="false"  (2)
    id=""
    jpa-operations=""
    jpa-query=""
    max-results=""                (3)
    max-results-expression=""     (4)
    first-result=""               (5)
    first-result-expression=""    (6)
    named-query=""
    native-query=""
    order=""
    parameter-source-factory=""
    reply-channel=""
    reply-timeout=""
    use-payload-as-parameter-source="true">
    <int:poller></int:poller>
    <int-jpa:transactional/>

    <int-jpa:parameter name="" type="" value=""/>
    <int-jpa:parameter name="" expression=""/>
</int-jpa:retrieving-outbound-gateway>
1 （自 Spring Integration 4.0 起）确定primaryKey的值EntityManager.find(Class entityClass, Object primaryKey)方法对requestMessage作为 Evaluation Context 的根对象。 这entityClass参数由entity-class属性（如果存在）。 否则，它由payload类。 如果您使用id-expression. 自选。
2 一个布尔标志，指示 select作是应返回单个结果还是List的结果。 如果此标志设置为true，则单个实体将作为消息的有效负载发送。 如果返回多个实体，则会引发异常。 如果false这Listof entities 作为消息的有效负载发送。 它默认为false. 自选。
3 这个非零、非负整数值告诉适配器在执行 select作时选择的行数不要超过指定的行数。 默认情况下，如果未设置此属性，则所有可能的记录都由给定的查询选择。 此属性与max-results-expression. 自选。
4 一个表达式，可用于查找结果集中的最大结果数。 它与max-results. 自选。
5 这个非零、非负整数值告诉适配器要从中检索结果的第一条记录。 此属性与first-result-expression. 版本 3.0 引入了此属性。 自选。
6 根据消息计算此表达式，以查找结果集中第一条记录的位置。 此属性与first-result. 版本 3.0 引入了此属性。 自选。

当您选择在检索时删除实体，并且您检索了实体集合时，默认情况下，将按实体删除实体。 这可能会导致性能问题。spring-doc.cadn.net.cn

或者，您可以设置 attributedeleteInBatch自true，这将执行批量删除。 但是，这样做的限制是不支持级联删除。spring-doc.cadn.net.cn

JSR 317：Java™ Persistence 2.0 在第 4.10 章 “批量更新和删除作”中指出：spring-doc.cadn.net.cn

“删除作仅适用于指定类及其子类的实体。 它不会级联到相关实体。spring-doc.cadn.net.cn

有关更多信息，请参阅 JSR 317：Java™ 持久性 2.0spring-doc.cadn.net.cn
从版本 6.0 开始，Jpa.retrievingGateway()当查询没有返回任何实体时，将返回空列表结果。 以前null返回结束流或引发异常，具体取决于requiresReply. 或者，要恢复到之前的行为，请添加filter在 gateway 之后过滤掉空列表。 在空列表处理是下游 logic一部分的应用程序中，它需要额外的配置。 请参阅 Splitter Discard Channel 了解可能的空列表处理选项。

JPA 出站网关示例

本节包含使用更新出站网关和检索出站网关的各种示例：spring-doc.cadn.net.cn

使用实体类更新

在以下示例中，通过使用org.springframework.integration.jpa.test.entity.Studententity 类作为 JPA 定义参数：spring-doc.cadn.net.cn

<int-jpa:updating-outbound-gateway request-channel="entityRequestChannel"  (1)
    reply-channel="entityResponseChannel"  (2)
    entity-class="org.springframework.integration.jpa.test.entity.Student"
    entity-manager="em"/>
1 这是出站网关的请求通道。 它类似于channel属性的outbound-channel-adapter.
2 这是网关与出站适配器的不同之处。 这是接收来自 JPA作的回复的通道。 但是，如果您对收到的回复不感兴趣，只想执行该作，请使用 JPAoutbound-channel-adapter是适当的选择。 在此示例中，我们使用实体类，回复是由于 JPA作而创建或合并的实体对象。
使用 JPQL 更新

以下示例使用 Java 持久性查询语言 （JPQL） 更新实体。 这要求使用更新的出站网关：spring-doc.cadn.net.cn

<int-jpa:updating-outbound-gateway request-channel="jpaqlRequestChannel"
  reply-channel="jpaqlResponseChannel"
  jpa-query="update Student s set s.lastName = :lastName where s.rollNumber = :rollNumber"  (1)
  entity-manager="em">
    <int-jpa:parameter name="lastName" expression="payload"/>
    <int-jpa:parameter name="rollNumber" expression="headers['rollNumber']"/>
</int-jpa:updating-outbound-gateway>
1 网关执行的 JPQL 查询。 由于我们使用了更新出站网关，因此只有update和deleteJPQL 查询将是明智的选择。

当您发送带有Stringpayload 中，该 intent 还包含一个名为rollNumber替换为long值，则具有指定卷号的学生的姓氏将更新为 Message payload. 使用更新网关时，返回值始终为整数值，该值表示受 JPA QL 执行影响的记录数。spring-doc.cadn.net.cn

使用 JPQL 检索实体

以下示例使用检索出站网关和 JPQL 从数据库中检索（选择）一个或多个实体：spring-doc.cadn.net.cn

<int-jpa:retrieving-outbound-gateway request-channel="retrievingGatewayReqChannel"
    reply-channel="retrievingGatewayReplyChannel"
    jpa-query="select s from Student s where s.firstName = :firstName and s.lastName = :lastName"
    entity-manager="em">
    <int-jpa:parameter name="firstName" expression="payload"/>
    <int-jpa:parameter name="lastName" expression="headers['lastName']"/>
</int-jpa:outbound-gateway>
使用 检索实体id-expression

以下示例使用具有id-expression要从数据库中检索（查找）一个且仅一个实体： 这primaryKey是id-expression评估。 这entityClass是 Message 的类payload.spring-doc.cadn.net.cn

<int-jpa:retrieving-outbound-gateway
	request-channel="retrievingGatewayReqChannel"
    reply-channel="retrievingGatewayReplyChannel"
    id-expression="payload.id"
    entity-manager="em"/>
使用命名查询更新

使用命名查询与直接使用 JPQL 查询基本相同。 区别在于，named-query属性，如下例所示：spring-doc.cadn.net.cn

<int-jpa:updating-outbound-gateway request-channel="namedQueryRequestChannel"
    reply-channel="namedQueryResponseChannel"
    named-query="updateStudentByRollNumber"
    entity-manager="em">
    <int-jpa:parameter name="lastName" expression="payload"/>
    <int-jpa:parameter name="rollNumber" expression="headers['rollNumber']"/>
</int-jpa:outbound-gateway>
您可以在此处找到使用 Spring Integration 的 JPA 适配器的完整示例应用程序。