JPA 支持

JPA 支持

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

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

专家
<dependency>
    <groupId>org.springframework.integration</groupId>
    <artifactId>spring-integration-jpa</artifactId>
    <version>6.1.9</version>
</dependency>
Gradle
compile "org.springframework.integration:spring-integration-jpa:6.1.9"

JPA API 必须通过一些特定于提供商的实现（例如 Hibernate ORM 框架）包含在内。spring-doc.cadn.net.cn

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

这些组件可用于执行select,create,update和delete通过向目标数据库发送和接收消息来对目标数据库进行作。spring-doc.cadn.net.cn

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

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

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

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

功能性

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

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

支持的持久性提供程序

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

Java 实现

提供的每个组件都使用o.s.i.jpa.core.JpaExecutor类，而类又使用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 Integration 提供的 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 的引用。 您必须提供此属性，entity-manager-factory属性或jpa-operations属性。spring-doc.cadn.net.cn

通常，您的 Spring 应用程序上下文仅定义一个 JPA 实体管理器工厂，并且EntityManager通过使用@PersistenceContext注解。 此方法不适用于 Spring Integration 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包装必要的数据源。spring-doc.cadn.net.cn

entity-class

实体类的完全限定名称。 此属性的确切语义各不相同，具体取决于我们是否正在执行persist或update作或我们是否从数据库中检索对象。spring-doc.cadn.net.cn

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

持久化数据时，entity-class属性指示要持久化的对象类型。 如果未指定（对于持久化作），则会自动从消息的有效负载中检索实体类。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） 要求事务在执行时处于活动状态。 对于入站通道适配器，无需执行任何特殊作。 它的工作方式类似于我们使用与其他入站通道适配器一起使用的轮询器配置事务管理器的方式。 以下 XML 示例配置一个事务管理器，该管理器使用具有入站通道适配器的轮询器：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是出站适配器或网关的输入通道，如果事务在当前执行线程中处于活动状态，那么 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>

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

与transactional轮询器的元素，该元素在 Spring Integration 的命名空间中定义，则transactional元素在 JPA 命名空间中定义。

入站通道适配器

入站通道适配器用于使用 JPA QL 对数据库执行选择查询并返回结果。 消息有效负载是单个实体或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用于执行所需 JPA作的实例。
3 属性信号组件是否应在应用程序上下文启动时自动启动。 该值默认为true.
4 JPA QL，其结果作为消息的有效负载发送
5 此属性告诉 JPQL 查询是在结果中给出单个实体还是List实体的。 如果该值设置为true，则单个实体将作为消息的有效负载发送。 但是，如果将此设置为true一个MessagingException被抛出。 该值默认为false.
6 这个非零、非负整数值告诉适配器在执行选择作时不要选择超过给定的行数。 默认情况下，如果未设置此属性，则查询将选择所有可能的记录。 此属性与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这List的实体作为消息的有效负载发送。 该值默认为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-class属性有一个值。 自选。
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

使用实体类

以下 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将其配置为通过输入通道接受实体，并将它们处理为PERSIST,MERGE或DELETE基础数据源中的实体。spring-doc.cadn.net.cn

从 Spring Integration 3.0 开始，有效负载PERSIST或MERGE也可以是类型java.lang.Iterable. 在这种情况下，每个对象返回的Iterable被视为实体，并使用基础EntityManager. 迭代器返回的 Null 值将被忽略。
从 5.5.4 版本开始，JpaOutboundGateway，带有JpaExecutor配置为PersistMode.DELETE，可以接受Iterable有效负载，以对提供的实体执行批量删除持久性作。

使用 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 将消息发送到出站通道适配器的输入通道。
2 要执行的 JPA QL。此查询可能包含通过使用parameter元素。
3 适配器用于执行 JPA作的实体管理器。
4 用于定义 JPA QL 的参数名称值的元素（每个参数一个）在query属性。

这parameter元素接受一个属性，其name对应于提供的 JPA QL 中指定的命名参数（前面示例中的第 2 点）。参数的值可以是静态的，也可以是使用表达式派生的。静态值和派生值的表达式是使用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出站通道适配器元素中的元素，并使用表达式定义一些参数，而其他参数则具有静态值。但是，请注意不要多次指定相同的参数名称。应提供一个parameter元素。 例如，我们指定两个参数：level和name. 这level属性是类型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，我们可以在Studentclass 来定义两个命名查询：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作的实体类的完全限定名称。 这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 开始，要持久化或合并的有效负载也可以是java.lang.Iterable. 在这种情况下，每个对象返回的Iterable被视为实体，并使用基础EntityManager. 迭代器返回的 Null 值将被忽略。
13 将此值设置为true如果要在持久化、合并或删除作后立即刷新持久性上下文，并且不想依赖flushMode的EntityManager. 它默认为false. 仅当您未指定flush-size属性。 如果此属性设置为true,flush-size隐式设置为1，如果没有其他值配置它。
14 如果要在持久化、合并或删除作后立即刷新持久性上下文，并且不想依赖flushMode的EntityManager. 默认值设置为0，意思是“'没有冲水'”。 此属性适用于Iterable负载。 例如，如果flush-size设置为3然后entityManager.flush()每三个实体之后调用一次。 此外entityManager.flush()在整个循环之后再次调用。 如果指定了大于“0”的值“flush-size”属性，则无需配置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 Integration 流，该流使用检索到的数据作为消息有效负载。spring-doc.cadn.net.cn

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

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

这就是 JPA 出站网关发挥作用的地方。 它们使您能够保留数据以及检索数据。 为了方便这些用途，Spring Integration提供了两种类型的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

我们建议您首先阅读本章前面的 出站通道适配器 部分和 入站通道适配器 部分，因为其中解释了大多数常见概念。

这种相似性是使用中央的主要因素JpaExecutor类来尽可能统一通用功能。spring-doc.cadn.net.cn

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

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

常用配置参数

JPA 出站网关始终可以访问 Spring IntegrationMessage作为输入。 因此，可以使用以下参数：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作为评估上下文的根对象。 这entityClass参数由entity-class属性，如果存在。否则，它是从payload类。 如果使用id-expression. 自选。
2 一个布尔标志，指示 select作是返回单个结果还是List结果。 如果此标志设置为true，则单个实体将作为消息的有效负载发送。 如果返回多个实体，则会引发异常。 如果false这List的实体作为消息的有效负载发送。 它默认为false. 自选。
3 此非零、非负整数值告诉适配器在执行选择作时不要选择超过指定行数。 默认情况下，如果未设置此属性，则给定查询将选择所有可能的记录。 此属性与max-results-expression. 自选。
4 可用于查找结果集中最大结果数的表达式。 它与max-results. 自选。
5 此非零、非负整数值告诉适配器要从中检索结果的第一条记录。 此属性与first-result-expression. 3.0 版引入了此属性。 自选。
6 根据消息计算此表达式，以查找结果集中第一条记录的位置。 此属性与first-result. 3.0 版引入了此属性。 自选。

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

或者，您可以设置属性deleteInBatch自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™ Persistence 2.0spring-doc.cadn.net.cn
从 6.0 版开始，Jpa.retrievingGateway()当查询没有返回实体时，返回空列表结果。 以前null返回时结束流或抛出异常，具体取决于requiresReply. 或者，要恢复到以前的行为，请添加filter在网关之后过滤掉空列表。 在空列表处理是下游逻辑一部分的应用程序中，它需要额外的配置。 有关可能的空列表处理选项，请参阅拆分器丢弃通道。

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 查询将是明智的选择。

当您发送带有String有效负载，该负载还包含名为rollNumber使用longvalue，则具有指定卷号的学生的姓氏将更新为消息有效负载中的值。 使用更新网关时，返回值始终是整数值，该值表示受执行 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 适配器的完整示例应用程序。