JDBC 支持

Spring 集成提供了通道适配器，用于使用数据库查询来接收和发送消息。通过这些适配器， Spring 集成不仅支持普通的 JDBC SQL 查询，还支持存储过程和存储函数调用。spring-doc.cadn.net.cn

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

Maven 系列

<dependency>
    <groupId>org.springframework.integration</groupId>
    <artifactId>spring-integration-jdbc</artifactId>
    <version>6.0.9</version>
</dependency>

Gradle

compile "org.springframework.integration:spring-integration-jdbc:6.0.9"

默认情况下，以下 JDBC 组件可用：spring-doc.cadn.net.cn

Spring 集成 JDBC 模块还提供了一个 JDBC 消息存储。spring-doc.cadn.net.cn

入站通道适配器

入站通道适配器的主要功能是执行 SQLSELECTquery 并将结果集转换为 message。消息有效负载是整个结果集（表示为List），并且列表中的项的类型取决于行映射策略。默认策略是一个通用映射器，它返回一个Map对于查询结果中的每一行。（可选）您可以通过添加对RowMapper实例（有关行映射的更多详细信息，请参阅 Spring JDBC 文档）。spring-doc.cadn.net.cn

如果要转换SELECTquery result 添加到单个消息中，您可以使用下游拆分器。

入站适配器还需要对JdbcTemplate实例或DataSource.spring-doc.cadn.net.cn

以及SELECT语句来生成消息，则适配器还具有UPDATE将记录标记为已处理的语句，以便它们不会显示在下一次轮询中。更新可以通过原始 select 中的 ID 列表进行参数化。默认情况下，这是通过命名约定（输入结果集中名为id将转换为名为id). 以下示例定义了一个入站通道适配器，其中包含一个 update 查询和一个DataSource参考。spring-doc.cadn.net.cn

<int-jdbc:inbound-channel-adapter query="select * from item where status=2"
    channel="target" data-source="dataSource"
    update="update item set status=10 where id in (:id)" />

更新查询中的参数使用冒号（:）前缀添加到参数名称中（在前面的示例中，该参数是要应用于轮询结果集中的每一行的表达式）。这是 Spring JDBC 中命名参数 JDBC 支持的标准功能，与 Spring 集成中采用的约定（投影到轮询结果列表）相结合。 Spring 的基础 JDBC 功能限制了可用的表达式（例如，除句点以外的大多数特殊字符都是不允许的），但是由于目标通常是可通过 bean 路径寻址的对象列表（可能是一的列表），因此并没有过度限制。

要更改参数生成策略，您可以注入SqlParameterSourceFactory到适配器中以覆盖默认行为（适配器具有sql-parameter-source-factory属性）。 Spring 集成提供了ExpressionEvaluatingSqlParameterSourceFactory，这将创建一个基于 SPEL 的参数源，并将查询结果作为#root对象。（如果update-per-row为 true，则根对象为该行）。如果相同的参数名称在 update 查询中多次出现，则仅计算一次，并缓存其结果。spring-doc.cadn.net.cn

您还可以将参数源用于 select 查询。在这种情况下，由于没有要评估的 “result” 对象，因此每次都使用单个参数源（而不是使用参数源工厂）。从版本 4.0 开始，你可以使用 Spring 创建基于 SPEL 的参数源，如下例所示：spring-doc.cadn.net.cn

<int-jdbc:inbound-channel-adapter query="select * from item where status=:status"
	channel="target" data-source="dataSource"
	select-sql-parameter-source="parameterSource" />

<bean id="parameterSource" factory-bean="parameterSourceFactory"
			factory-method="createParameterSourceNoCache">
	<constructor-arg value="" />
</bean>

<bean id="parameterSourceFactory"
		class="o.s.integration.jdbc.ExpressionEvaluatingSqlParameterSourceFactory">
	<property name="parameterExpressions">
		<map>
			<entry key="status" value="@statusBean.which()" />
		</map>
	</property>
</bean>

<bean id="statusBean" class="foo.StatusDetermination" />

这value在每个参数表达式中可以是任何有效的 SpEL 表达式。这#rootobject 是parameterSource豆。对于所有评估，它都是静态的（在前面的示例中，一个空的String).spring-doc.cadn.net.cn

从版本 5.0 开始，您可以供应ExpressionEvaluatingSqlParameterSourceFactory跟sqlParameterTypes为特定参数指定目标 SQL 类型。spring-doc.cadn.net.cn

以下示例为查询中使用的参数提供了 SQL 类型：spring-doc.cadn.net.cn

<int-jdbc:inbound-channel-adapter query="select * from item where status=:status"
    channel="target" data-source="dataSource"
    select-sql-parameter-source="parameterSource" />

<bean id="parameterSource" factory-bean="parameterSourceFactory"
            factory-method="createParameterSourceNoCache">
    <constructor-arg value="" />
</bean>

<bean id="parameterSourceFactory"
        class="o.s.integration.jdbc.ExpressionEvaluatingSqlParameterSourceFactory">
    <property name="sqlParameterTypes">
        <map>
            <entry key="status" value="#{ T(java.sql.Types).BINARY}" />
        </map>
    </property>
</bean>

使用createParameterSourceNoCacheFactory 方法。否则，参数源将缓存计算结果。另请注意，由于禁用了缓存，因此如果相同的参数名称多次出现在 select 查询中，则会针对每次出现的情况重新评估该名称。

轮询和事务

入站适配器接受常规的 Spring 集成 Poller 作为子元素。因此，可以控制轮询的频率（以及其他用途）。用于 JDBC 的 Poller 的一个重要功能是可以选择将 poll作包装在事务中，如下例所示：spring-doc.cadn.net.cn

<int-jdbc:inbound-channel-adapter query="..."
        channel="target" data-source="dataSource" update="...">
    <int:poller fixed-rate="1000">
        <int:transactional/>
    </int:poller>
</int-jdbc:inbound-channel-adapter>

如果未显式指定 Poller，则使用默认值。与 Spring Integration 一样，它可以被定义为顶级 bean）。

在前面的示例中，数据库每 1000 毫秒轮询一次（或每秒轮询一次），并且 update 和 select 查询都在同一事务中执行。未显示事务管理器配置。但是，只要它知道数据源，轮询就是事务性的。一个常见的用例是将 downstream channels 作为 direct channels（默认），以便在同一个线程中调用端点，从而在同一个 transaction 中调用。这样，如果其中任何一个失败，事务将回滚，并且 Importing 数据将恢复到其原始状态。spring-doc.cadn.net.cn

`max-rows`对`max-messages-per-poll`

JDBC 入站通道适配器定义了一个名为max-rows. 当你指定适配器的 Poller 时，你还可以定义一个名为max-messages-per-poll. 虽然这两个属性看起来相似，但它们的含义却大不相同。spring-doc.cadn.net.cn

max-messages-per-poll指定每个轮询间隔执行查询的次数，而max-rows指定每次执行返回的行数。spring-doc.cadn.net.cn

在正常情况下，您可能不希望将 poller 的max-messages-per-poll属性。其默认值为1，这意味着 JDBC 入站通道适配器的receive()method 对于每个轮询间隔只执行一次。spring-doc.cadn.net.cn

设置max-messages-per-poll属性设置为更大的值意味着查询将连续执行多次。有关max-messages-per-poll属性，请参见配置入站通道适配器。spring-doc.cadn.net.cn

相比之下，max-rows属性，如果大于0中，指定要从receive()方法。如果该属性设置为0，则所有行都包含在生成的消息中。该属性默认为0.spring-doc.cadn.net.cn

建议通过特定于供应商的查询选项（例如 MySQL）使用结果集限制LIMIT或 SQL ServerTOP或 Oracle 的ROWNUM. 有关更多信息，请参阅特定供应商文档。

出站通道适配器

出站通道适配器是入站通道适配器的反面：它的作用是处理消息并使用它来执行 SQL 查询。默认情况下，消息有效负载和标头可用作查询的输入参数，如下例所示：spring-doc.cadn.net.cn

<int-jdbc:outbound-channel-adapter
    query="insert into foos (id, status, name) values (:headers[id], 0, :payload[something])"
    data-source="dataSource"
    channel="input"/>

在前面的示例中，到达标记为input具有 Key 为something，因此运算符会从 map 中取消引用该值。标头也作为映射进行访问。[]spring-doc.cadn.net.cn

上述查询中的参数是传入消息上的 Bean 属性表达式（不是 SPEL 表达式）。此行为是SqlParameterSource，这是出站适配器创建的默认源。您可以注入不同的SqlParameterSourceFactory以获得不同的行为。

出站适配器需要引用DataSource或JdbcTemplate. 您还可以注入SqlParameterSourceFactory控制每个传入消息与查询的绑定。spring-doc.cadn.net.cn

如果 input 通道是直接通道，则出站适配器在与消息发送方相同的线程中运行其查询，因此，与消息的发送者相同的事务（如果有的话）。spring-doc.cadn.net.cn

使用 SPEL 表达式传递参数

大多数 JDBC 通道适配器的常见要求是将参数作为 SQL 查询或存储过程或函数的一部分进行传递。如前所述，默认情况下，这些参数是 Bean 属性表达式，而不是 SPEL 表达式。但是，如果需要将 SpEL 表达式作为参数传递，则必须显式注入SqlParameterSourceFactory.spring-doc.cadn.net.cn

以下示例使用ExpressionEvaluatingSqlParameterSourceFactory要达到该要求，请执行以下作：spring-doc.cadn.net.cn

<jdbc:outbound-channel-adapter data-source="dataSource" channel="input"
    query="insert into MESSAGES (MESSAGE_ID,PAYLOAD,CREATED_DATE) values (:id, :payload, :createdDate)"
    sql-parameter-source-factory="spelSource"/>

<bean id="spelSource"
      class="o.s.integration.jdbc.ExpressionEvaluatingSqlParameterSourceFactory">
    <property name="parameterExpressions">
        <map>
            <entry key="id"          value="headers['id'].toString()"/>
            <entry key="createdDate" value="new java.util.Date()"/>
            <entry key="payload"     value="payload"/>
        </map>
    </property>
</bean>

有关详细信息，请参阅定义参数源。spring-doc.cadn.net.cn

使用`PreparedStatement`回调

有时，的SqlParameterSourceFactory没有做我们需要的目标PreparedStatement或者我们需要做一些低级的 JDBC 工作。 Spring JDBC 模块提供了 API 来配置执行环境（例如ConnectionCallback或PreparedStatementCreator）和作参数值（例如SqlParameterSource). 它甚至可以访问用于低级作的 API，例如StatementCallback.spring-doc.cadn.net.cn

从 Spring Integration 4.2 开始，MessagePreparedStatementSetter允许在PreparedStatementmanually，在requestMessage上下文。该类的作用与PreparedStatementSetter在标准 Spring JDBC API 中。实际上，它是直接从内联PreparedStatementSetterimplementation 时，JdbcMessageHandler调用execute在JdbcTemplate.spring-doc.cadn.net.cn

此功能接口选项与sqlParameterSourceFactory，并且可以用作更强大的替代方案来填充PreparedStatement从requestMessage. 例如，当我们需要存储Filedata 到 DataBaseBLOB列。以下示例显示了如何执行此作：spring-doc.cadn.net.cn

@Bean
@ServiceActivator(inputChannel = "storeFileChannel")
public MessageHandler jdbcMessageHandler(DataSource dataSource) {
    JdbcMessageHandler jdbcMessageHandler = new JdbcMessageHandler(dataSource,
            "INSERT INTO imagedb (image_name, content, description) VALUES (?, ?, ?)");
    jdbcMessageHandler.setPreparedStatementSetter((ps, m) -> {
        ps.setString(1, m.getHeaders().get(FileHeaders.FILENAME));
        try (FileInputStream inputStream = new FileInputStream((File) m.getPayload()); ) {
            ps.setBlob(2, inputStream);
        }
        catch (Exception e) {
            throw new MessageHandlingException(m, e);
        }
        ps.setClob(3, new StringReader(m.getHeaders().get("description", String.class)));
    });
    return jdbcMessageHandler;
}

从 XML 配置的角度来看，prepared-statement-setter属性在<int-jdbc:outbound-channel-adapter>元件。它允许您指定一个MessagePreparedStatementSetterbean 引用。spring-doc.cadn.net.cn

批量更新

从版本 5.1 开始，JdbcMessageHandler执行JdbcOperations.batchUpdate()如果请求消息的有效负载是Iterable实例。每个元素的Iterable包装到Message替换为请求消息中的标头（如果此类元素不是Message已经。在常规SqlParameterSourceFactory的配置，这些消息用于构建SqlParameterSource[]对于上述JdbcOperations.batchUpdate()功能。当MessagePreparedStatementSetter配置时，会生成一个BatchPreparedStatementSettervariant 用于遍历每个项目的这些消息，并且提供的MessagePreparedStatementSetter被召来反对他们。在以下情况下不支持批量更新keysGenerated模式。spring-doc.cadn.net.cn

出站网关

出站网关就像出站和入站适配器的组合：它的作用是处理消息并使用它来执行 SQL 查询，然后通过将其发送到回复通道来响应结果。默认情况下，消息有效负载和标头可用作查询的输入参数，如下例所示：spring-doc.cadn.net.cn

<int-jdbc:outbound-gateway
    update="insert into mythings (id, status, name) values (:headers[id], 0, :payload[thing])"
    request-channel="input" reply-channel="output" data-source="dataSource" />

前面示例的结果是将一条记录插入到mythingstable 并返回一条消息，指示受影响的行数（有效负载是一个 Map：{UPDATED=1}）拖动到 output channel 。spring-doc.cadn.net.cn

如果更新查询是带有自动生成的键的插入，则可以通过在keys-generated="true"添加到前面的示例（这不是默认值，因为某些数据库平台不支持它）。以下示例显示了更改后的配置：spring-doc.cadn.net.cn

<int-jdbc:outbound-gateway
    update="insert into mythings (status, name) values (0, :payload[thing])"
    request-channel="input" reply-channel="output" data-source="dataSource"
    keys-generated="true"/>

除了更新计数或生成的密钥，您还可以提供 select 查询来执行并从结果（例如入站适配器）生成回复消息，如下例所示：spring-doc.cadn.net.cn

<int-jdbc:outbound-gateway
    update="insert into foos (id, status, name) values (:headers[id], 0, :payload[foo])"
    query="select * from foos where id=:headers[$id]"
    request-channel="input" reply-channel="output" data-source="dataSource"/>

从 Spring Integration 2.2 开始，更新 SQL 查询不再是必需的。现在，您可以使用query属性或query元素。如果您需要使用通用网关或有效负载扩充器等方式主动检索数据，这将非常有用。然后从结果生成回复消息（类似于入站适配器的工作方式）并传递给回复通道。以下示例演示如何使用query属性：spring-doc.cadn.net.cn

<int-jdbc:outbound-gateway
    query="select * from foos where id=:headers[id]"
    request-channel="input"
    reply-channel="output"
    data-source="dataSource"/>

默认情况下，SELECTquery 仅返回游标中的一行（第一行）。您可以使用max-rows选择。如果需要返回 SELECT 中的所有行，请考虑指定max-rows="0".spring-doc.cadn.net.cn

与通道适配器一样，您还可以提供SqlParameterSourceFactory请求和回复的实例。默认值与出站适配器相同，因此请求消息可用作表达式的根。如果keys-generated="true"，表达式的根是生成的键（如果只有一个 map，则为 map，如果为多值，则为 map 列表）。spring-doc.cadn.net.cn

出站网关需要引用DataSource或JdbcTemplate. 它还可以具有SqlParameterSourceFactoryinjected 来控制传入消息与查询的绑定。spring-doc.cadn.net.cn

从版本 4.2 开始，request-prepared-statement-setter属性在<int-jdbc:outbound-gateway>作为request-sql-parameter-source-factory. 它允许您指定一个MessagePreparedStatementSetterBean 引用，它实现了更复杂的PreparedStatement执行前的准备工作。spring-doc.cadn.net.cn

从版本 6.0 开始，JdbcOutboundGateway按原样返回空列表结果，而不是将其转换为null和以前一样，意思是 “没有回答”。这会导致在处理空列表是 downstream logic一部分的应用程序中进行额外的配置。请参阅 Splitter Discard Channel 了解可能的空列表处理选项。spring-doc.cadn.net.cn

请参阅出站通道适配器以了解有关MessagePreparedStatementSetter.spring-doc.cadn.net.cn

JDBC 消息存储

Spring 集成提供了两种特定于 JDBC 的消息存储实现。这JdbcMessageStore适合与聚合商和 Claim Check 模式一起使用。这JdbcChannelMessageStoreimplementation 专门为 Message Channel 提供了更具针对性和可扩展性的实现。spring-doc.cadn.net.cn

请注意，您可以使用JdbcMessageStore要支持消息通道，JdbcChannelMessageStore为此目的进行了优化。spring-doc.cadn.net.cn

从版本 5.0.11、5.1.2 开始，JdbcChannelMessageStore已优化。如果您在此类存储中有大型消息组，则可能需要更改索引。此外，的PriorityChannel被注释掉，因为除非您使用的是 JDBC 支持的此类通道，否则不需要它。

使用OracleChannelMessageStoreQueryProvider，则必须添加优先级通道索引，因为它包含在查询的 hint 中。

初始化数据库

在开始使用 JDBC 消息存储组件之前，您应该为目标数据库配置适当的对象。spring-doc.cadn.net.cn

Spring 集成附带了一些可用于初始化数据库的示例脚本。在spring-integration-jdbcJAR 文件中，您可以在org.springframework.integration.jdbc包。它为一系列常见数据库平台提供了示例 create 和 example drop 脚本。使用这些脚本的常见方法是在 Spring JDBC 数据源初始化器中引用它们。请注意，这些脚本作为示例以及所需表和列名称的规范提供。您可能会发现需要增强它们以供生产环境使用（例如，通过添加索引声明）。spring-doc.cadn.net.cn

通用 JDBC 消息存储

JDBC 模块提供了 Spring 集成的实现MessageStore（在索赔检查模式中很重要）和MessageGroupStore（在 Aggregator 等有状态模式中很重要）由数据库提供支持。这两个接口都是由JdbcMessageStore，并且支持在 XML 中配置存储实例，如下例所示：spring-doc.cadn.net.cn

<int-jdbc:message-store id="messageStore" data-source="dataSource"/>

您可以指定JdbcTemplate而不是DataSource.spring-doc.cadn.net.cn

以下示例显示了一些其他可选属性：spring-doc.cadn.net.cn

<int-jdbc:message-store id="messageStore" data-source="dataSource"
    lob-handler="lobHandler" table-prefix="MY_INT_"/>

在前面的示例中，我们指定了LobHandler用于将消息作为大型对象处理（这通常对 Oracle 是必需的）和存储生成的查询中的表名的前缀。表名前缀默认为INT_.spring-doc.cadn.net.cn

后备消息通道

如果您打算使用 JDBC 返回消息通道，我们建议使用JdbcChannelMessageStore实现。它只能与 Message Channel 结合使用。spring-doc.cadn.net.cn

支持的数据库

这JdbcChannelMessageStore使用特定于数据库的 SQL 查询从数据库中检索消息。因此，您必须将ChannelMessageStoreQueryProvider属性JdbcChannelMessageStore. 这channelMessageStoreQueryProvider提供您指定的特定数据库的 SQL 查询。 Spring 集成为以下关系数据库提供支持：spring-doc.cadn.net.cn

如果您的数据库未列出，则可以扩展AbstractChannelMessageStoreQueryProvider类并提供您自己的自定义查询。spring-doc.cadn.net.cn

版本 4.0 添加了MESSAGE_SEQUENCE列添加到表中，以确保先进先出（FIFO）排队，即使消息以相同的毫秒数存储也是如此。spring-doc.cadn.net.cn

自定义消息插入

从 5.0 版本开始，通过重载ChannelMessageStorePreparedStatementSetter类中，您可以在JdbcChannelMessageStore. 您可以使用它来设置不同的列或更改表结构或序列化策略。例如，而不是默认序列化为byte[]，您可以将其结构存储为 JSON 字符串。spring-doc.cadn.net.cn

以下示例使用setValues来存储公共列，并覆盖将消息负载存储为varchar:spring-doc.cadn.net.cn

public class JsonPreparedStatementSetter extends ChannelMessageStorePreparedStatementSetter {

    @Override
    public void setValues(PreparedStatement preparedStatement, Message<?> requestMessage,
        Object groupId, String region, 	boolean priorityEnabled) throws SQLException {
        // Populate common columns
        super.setValues(preparedStatement, requestMessage, groupId, region, priorityEnabled);
        // Store message payload as varchar
        preparedStatement.setString(6, requestMessage.getPayload().toString());
    }
}

通常，我们不建议使用关系数据库进行排队。相反，如果可能，请考虑改用 JMS 或 AMQP 支持的通道。有关进一步参考，请参阅以下资源：spring-doc.cadn.net.cn

数据库作为队列反模式。spring-doc.cadn.net.cn

如果您仍计划将数据库用作队列，请考虑使用 PostgreSQL 及其通知机制，这将在后续部分中介绍。spring-doc.cadn.net.cn

并发轮询

轮询消息通道时，您可以选择配置关联的Poller替换为TaskExecutor参考。spring-doc.cadn.net.cn

但请记住，如果您使用 JDBC 支持的消息通道，并且计划使用多个线程对通道进行事务性轮询，从而轮询消息存储，则应确保使用支持多版本并发控制（MVCC）的关系数据库。否则，锁定可能是一个问题，并且在使用多个线程时，性能可能无法按预期实现。例如，Apache Derby 在这方面是有问题的。spring-doc.cadn.net.cn

实现更好的 JDBC 队列吞吐量并避免不同线程可能轮询相同的Message在队列中，设置usingIdCache的属性JdbcChannelMessageStore自true当使用不支持 MVCC 的数据库时。以下示例显示了如何执行此作：spring-doc.cadn.net.cn

<bean id="queryProvider"
    class="o.s.i.jdbc.store.channel.PostgresChannelMessageStoreQueryProvider"/>

<int:transaction-synchronization-factory id="syncFactory">
    <int:after-commit expression="@store.removeFromIdCache(headers.id.toString())" />
    <int:after-rollback expression="@store.removeFromIdCache(headers.id.toString())"/>
</int:transaction-synchronization-factory>

<task:executor id="pool" pool-size="10"
    queue-capacity="10" rejection-policy="CALLER_RUNS" />

<bean id="store" class="o.s.i.jdbc.store.JdbcChannelMessageStore">
    <property name="dataSource" ref="dataSource"/>
    <property name="channelMessageStoreQueryProvider" ref="queryProvider"/>
    <property name="region" value="TX_TIMEOUT"/>
    <property name="usingIdCache" value="true"/>
</bean>

<int:channel id="inputChannel">
    <int:queue message-store="store"/>
</int:channel>

<int:bridge input-channel="inputChannel" output-channel="outputChannel">
    <int:poller fixed-delay="500" receive-timeout="500"
        max-messages-per-poll="1" task-executor="pool">
        <int:transactional propagation="REQUIRED" synchronization-factory="syncFactory"
        isolation="READ_COMMITTED" transaction-manager="transactionManager" />
    </int:poller>
</int:bridge>

<int:channel id="outputChannel" />

优先通道

从版本 4.0 开始，JdbcChannelMessageStore实现PriorityCapableChannelMessageStore并提供priorityEnabled选项，让它用作message-store参考priority-queue实例。为此，INT_CHANNEL_MESSAGEtable 的MESSAGE_PRIORITYcolumn 来存储PRIORITY消息标头。此外，新的MESSAGE_SEQUENCEcolumn 让我们实现强大的先进先出（FIFO）轮询机制，即使在同一毫秒内以相同的优先级存储多条消息也是如此。消息从数据库中轮询（选择）order by MESSAGE_PRIORITY DESC NULLS LAST, CREATED_DATE, MESSAGE_SEQUENCE.spring-doc.cadn.net.cn

我们不建议使用相同的JdbcChannelMessageStorebean 用于优先级和非优先级队列通道，因为priorityEnabled选项应用于整个存储，并且不会为队列通道保留正确的 FIFO 队列语义。然而，同样的INT_CHANNEL_MESSAGE表（甚至region）可用于JdbcChannelMessageStore类型。要配置该场景，可以从一个消息存储 Bean 扩展另一个消息存储 Bean，如下例所示：

<bean id="channelStore" class="o.s.i.jdbc.store.JdbcChannelMessageStore">
    <property name="dataSource" ref="dataSource"/>
    <property name="channelMessageStoreQueryProvider" ref="queryProvider"/>
</bean>

<int:channel id="queueChannel">
    <int:queue message-store="channelStore"/>
</int:channel>

<bean id="priorityStore" parent="channelStore">
    <property name="priorityEnabled" value="true"/>
</bean>

<int:channel id="priorityChannel">
    <int:priority-queue message-store="priorityStore"/>
</int:channel>

对消息存储进行分区

通常使用JdbcMessageStore作为一组应用程序或同一应用程序中的节点的全局存储。为了提供一些防止名称冲突的保护并控制数据库元数据配置，消息存储允许以两种方式对表进行分区。一种方法是通过更改前缀（如前所述）来使用单独的表名。另一种方法是指定一个regionname 用于对单个表中的数据进行分区。第二种方法的一个重要用例是MessageStore正在管理支持 Spring 集成消息通道的持久队列。持久通道的消息数据在存储区中的通道名称上键入。因此，如果通道名称不是全局唯一的，则通道可以选取并非适用于它们的数据。为避免此危险，您可以使用消息存储region为具有相同逻辑名称的不同物理通道保持数据独立。spring-doc.cadn.net.cn

PostgreSQL：接收推送通知

PostgreSQL 提供了一个侦听和通知框架，用于在数据库表作时接收推送通知。 Spring 集成利用这种机制（从版本 6.0 开始）来允许在将新消息添加到JdbcChannelMessageStore. 使用此功能时，必须定义一个数据库触发器，该触发器可以作为schema-postgresql.sql文件，该文件包含在 Spring 集成的 JDBC 模块中。spring-doc.cadn.net.cn

推送通知通过PostgresChannelMessageTableSubscriber类，它允许其订阅者在到达任何给定的新消息时接收回调region和groupId. 即使消息附加到不同的 JVM 上，但附加到同一个数据库，也会收到这些通知。这PostgresSubscribableChannelimplementation 使用PostgresChannelMessageTableSubscriber.SubscriptionContract 从 store 中提取消息，作为对来自上述PostgresChannelMessageTableSubscriber通知。spring-doc.cadn.net.cn

例如，推送通知some group可以按以下方式接收：spring-doc.cadn.net.cn

@Bean
public JdbcChannelMessageStore messageStore(DataSource dataSource) {
    JdbcChannelMessageStore messageStore = new JdbcChannelMessageStore(dataSource);
    messageStore.setChannelMessageStoreQueryProvider(new PostgresChannelMessageStoreQueryProvider());
    return messageStore;
}

@Bean
public PostgresChannelMessageTableSubscriber subscriber(
      @Value("${spring.datasource.url}") String url,
      @Value("${spring.datasource.username}") String username,
      @Value("${spring.datasource.password}") String password) {
    return new PostgresChannelMessageTableSubscriber(() ->
        DriverManager.getConnection(url, username, password).unwrap(PgConnection.class));
}

@Bean
public PostgresSubscribableChannel channel(
    PostgresChannelMessageTableSubscriber subscriber,
    JdbcChannelMessageStore messageStore) {
  return new PostgresSubscribableChannel(messageStore, "some group", subscriber);
}

事务支持spring-doc.cadn.net.cn

从版本 6.0.5 开始，指定PlatformTransactionManager在PostgresSubscribableChannel将在交易中通知订阅者。订户中的异常将导致事务回滚，并将消息放回消息存储中。默认情况下，事务支持未激活。spring-doc.cadn.net.cn

重试spring-doc.cadn.net.cn

从版本 6.0.5 开始，可以通过提供RetryTemplate到PostgresSubscribableChannel. 默认情况下，不执行重试。spring-doc.cadn.net.cn

任何活动PostgresChannelMessageTableSubscriber占用独占 JDBCConnection在其活动生命周期的持续时间内。因此，此连接并非源自池化，这一点很重要DataSource. 此类连接池通常希望发出的连接在预定义的超时窗口内关闭。spring-doc.cadn.net.cn

对于独占连接的这种需求，还建议 JVM 只运行单个PostgresChannelMessageTableSubscriber可用于注册任意数量的订阅。spring-doc.cadn.net.cn

存储过程

在某些情况下，普通的 JDBC 支持是不够的。也许您处理的是旧式关系数据库架构，或者您有复杂的数据处理需求，但最终您必须使用存储过程或存储函数。从 Spring Integration 2.1 开始，我们提供了三个组件来执行存储过程或存储函数：spring-doc.cadn.net.cn

存储过程入站通道适配器spring-doc.cadn.net.cn
存储过程出站通道适配器spring-doc.cadn.net.cn
存储过程出站网关spring-doc.cadn.net.cn

支持的数据库

为了启用对存储过程和存储函数的调用，存储过程组件使用org.springframework.jdbc.core.simple.SimpleJdbcCall类。因此，完全支持以下数据库执行存储过程：spring-doc.cadn.net.cn

如果您想改为执行存储函数，则完全支持以下数据库：spring-doc.cadn.net.cn

MySQL （MySQL的spring-doc.cadn.net.cn
Microsoft SQL 服务器spring-doc.cadn.net.cn
神谕spring-doc.cadn.net.cn
PostgreSQL 数据库spring-doc.cadn.net.cn

即使您的特定数据库可能没有得到完全支持，只要您的 RDBMS 支持存储过程或存储函数，您很可能可以非常成功地使用存储过程 Spring Integration 组件。spring-doc.cadn.net.cn

事实上，一些提供的集成测试使用 H2 数据库。尽管如此，全面测试这些使用场景非常重要。spring-doc.cadn.net.cn

配置

存储过程组件提供完整的 XML 命名空间支持，并且配置组件与前面讨论的通用 JDBC 组件类似。spring-doc.cadn.net.cn

常见配置属性

所有存储过程组件共享某些配置参数：spring-doc.cadn.net.cn

auto-startup：生命周期属性，指示是否应在应用程序上下文启动期间启动此组件。它默认为true. 自选。spring-doc.cadn.net.cn
data-source：对javax.sql.DataSource，用于访问数据库。必填。spring-doc.cadn.net.cn
id：标识底层 Spring Bean 定义，它是EventDrivenConsumer或PollingConsumer，具体取决于出站通道适配器的channel属性引用SubscribableChannel或PollableChannel. 自选。spring-doc.cadn.net.cn
ignore-column-meta-data：对于完全支持的数据库，底层SimpleJdbcCallclass 可以从 JDBC 元数据中自动检索存储过程或存储函数的参数信息。spring-doc.cadn.net.cn

但是，如果数据库不支持元数据查找，或者您需要提供自定义参数定义，则可以将此标志设置为true. 它默认为false. 自选。spring-doc.cadn.net.cn
is-function：如果true时，将调用 SQL 函数。在这种情况下，stored-procedure-name或stored-procedure-name-expressionattributes 定义被调用函数的名称。它默认为false. 自选。spring-doc.cadn.net.cn
stored-procedure-name：此属性指定存储过程的名称。如果is-function属性设置为true，则此属性指定函数名称。此属性或stored-procedure-name-expression必须指定。spring-doc.cadn.net.cn
stored-procedure-name-expression：此属性使用 SpEL 表达式指定存储过程的名称。通过使用 SPEL，您可以访问完整的消息（如果可用），包括其 Headers 和有效负载。您可以使用此属性在运行时调用不同的存储过程。例如，您可以提供要作为消息标头执行的存储过程名称。表达式必须解析为String.spring-doc.cadn.net.cn

如果is-function属性设置为true，则此属性指定存储函数。此属性或stored-procedure-name必须指定。spring-doc.cadn.net.cn
jdbc-call-operations-cache-size：定义缓存的最大数量SimpleJdbcCallOperations实例。基本上，对于每个存储过程名称，一个新的SimpleJdbcCallOperations实例，作为回报，该实例将被缓存。spring-doc.cadn.net.cn

Spring Integration 2.2 添加了stored-procedure-name-expression属性和jdbc-call-operations-cache-size属性。

默认缓存大小为10. 值0禁用缓存。不允许使用负值。spring-doc.cadn.net.cn

如果启用 JMX，则有关jdbc-call-operations-cache作为 MBean 公开。有关更多信息，请参阅 MBean Exporter 。spring-doc.cadn.net.cn
sql-parameter-source-factory：（不适用于存储过程入站通道适配器。对SqlParameterSourceFactory. 默认情况下，传入的Messagepayload 用作存储过程输入参数的源，方法是使用BeanPropertySqlParameterSourceFactory.spring-doc.cadn.net.cn

对于基本用例，这可能就足够了。对于更复杂的选项，请考虑传入一个或多个ProcedureParameter值。请参阅定义参数源。自选。spring-doc.cadn.net.cn
use-payload-as-parameter-source：（不适用于存储过程入站通道适配器。如果设置为true，则Message用作提供参数的源。如果设置为false，但是，整个Message可用作参数的源。spring-doc.cadn.net.cn

如果未传入过程参数，则此属性默认为true. 这意味着，通过使用默认的BeanPropertySqlParameterSourceFactory中，有效负载的 Bean 属性将用作存储过程或存储函数的参数值的源。spring-doc.cadn.net.cn

但是，如果传入了过程参数，则此属性（默认情况下）的计算结果为false.ProcedureParameter允许提供 SpEL 表达式。因此，访问整个Message. 该属性在底层StoredProcExecutor. 自选。spring-doc.cadn.net.cn

常见配置子元素

存储过程组件共享一组通用的子元素，您可以使用这些子元素来定义参数并将其传递给存储过程或存储函数。以下元素可用：spring-doc.cadn.net.cn

parameterspring-doc.cadn.net.cn
returning-resultsetspring-doc.cadn.net.cn
sql-parameter-definitionspring-doc.cadn.net.cn
pollerspring-doc.cadn.net.cn
parameter：提供存储过程参数的机制。参数可以是静态的，也可以是使用 SPEL 表达式提供的。spring-doc.cadn.net.cn
<int-jdbc:parameter name="" (1) type="" (2) value=""/> (3) <int-jdbc:parameter name="" expression=""/> (4)
+ <1> 要传递到存储过程或存储函数中的参数的名称。必填。 <2> 此属性指定值的类型。如果未提供任何内容，则此属性默认为java.lang.String. 仅当value属性。自选。 <3> 参数的值。您必须提供此属性或expression属性。自选。 <4>而不是value属性，您可以指定一个 SPEL 表达式来传递参数的值。如果指定expression这value属性。自选。spring-doc.cadn.net.cn
自选。spring-doc.cadn.net.cn
returning-resultset：存储过程可能会返回多个结果集。通过设置一个或多个returning-resultset元素中，您可以指定RowMappers以转换每个返回的ResultSet转换为有意义的对象。自选。spring-doc.cadn.net.cn
<int-jdbc:returning-resultset name="" row-mapper="" />

sql-parameter-definition：如果使用完全支持的数据库，则通常不必指定存储过程参数定义。相反，这些参数可以自动从 JDBC 元数据派生。但是，如果您使用的数据库不完全受支持，则必须使用sql-parameter-definition元素。spring-doc.cadn.net.cn

您还可以选择关闭对通过 JDBC 获取的参数元数据信息的任何处理，方法是使用ignore-column-meta-data属性。spring-doc.cadn.net.cn

<int-jdbc:sql-parameter-definition
                                   name=""                           (1)
                                   direction="IN"                    (2)
                                   type="STRING"                     (3)
                                   scale="5"                         (4)
                                   type-name="FOO_STRUCT"            (5)
                                   return-type="fooSqlReturnType"/>  (6)

1	指定 SQL 参数的名称。必填。
2	指定 SQL 参数定义的方向。默认为`IN`. 有效值为：`IN`,`OUT`和`INOUT`. 如果您的过程返回结果集，请使用`returning-resultset`元素。自选。
3	用于此 SQL 参数定义的 SQL 类型。转换为整数值，定义如下`java.sql.Types`. 或者，您也可以提供整数值。如果未明确设置此属性，则默认为 'VARCHAR'。自选。
4	SQL 参数的比例。仅用于数字和十进制参数。自选。
5	这`typeName`对于用户命名的类型，例如：`STRUCT`,`DISTINCT`,`JAVA_OBJECT`和命名数组类型。此属性与`scale`属性。自选。
6	对复杂类型的自定义值处理程序的引用。的实现`SqlReturnType`. 此属性与`scale`属性，仅适用于 OUT 和 INOUT 参数。自选。

poller：允许您配置消息轮询器（如果此端点是PollingConsumer. 自选。spring-doc.cadn.net.cn

定义参数源

参数源控制检索 Spring 集成消息属性并将其映射到相关存储过程输入参数的技术。spring-doc.cadn.net.cn

存储过程组件遵循某些规则。默认情况下，Messagepayload 用作存储过程的输入参数的源。在这种情况下，一个BeanPropertySqlParameterSourceFactory被使用。对于基本用例，这可能就足够了。下一个示例说明了该默认行为。spring-doc.cadn.net.cn

要使用BeanPropertySqlParameterSourceFactory要工作，您的 Bean 属性必须以小写形式定义。这是因为在org.springframework.jdbc.core.metadata.CallMetaDataContext（Java 方法是matchInParameterValuesWithCallParameters()），则检索到的存储过程参数声明将转换为小写。因此，如果您有驼峰式 bean 属性（例如lastName），则查找失败。在这种情况下，请提供显式的ProcedureParameter.

假设我们有一个有效负载，它由一个具有以下三个属性的简单 bean 组成：id,name和description. 此外，我们有一个名为INSERT_COFFEE接受三个 input 参数：id,name和description. 我们还使用完全支持的数据库。在这种情况下，存储过程出站适配器的以下配置就足够了：spring-doc.cadn.net.cn

<int-jdbc:stored-proc-outbound-channel-adapter data-source="dataSource"
    channel="insertCoffeeProcedureRequestChannel"
    stored-procedure-name="INSERT_COFFEE"/>

对于更复杂的选项，请考虑传入一个或多个ProcedureParameter值。spring-doc.cadn.net.cn

如果您提供ProcedureParameter值显式地显示，默认情况下，ExpressionEvaluatingSqlParameterSourceFactory用于参数处理，以启用 SpEL 表达式的全部功能。spring-doc.cadn.net.cn

如果您需要对参数的检索方式进行更多控制，请考虑传入SqlParameterSourceFactory通过使用sql-parameter-source-factory属性。spring-doc.cadn.net.cn

存储过程入站通道适配器

下面的清单列出了对存储过程入站通道适配器很重要的属性：spring-doc.cadn.net.cn

<int-jdbc:stored-proc-inbound-channel-adapter
                                   channel=""                                    (1)
                                   stored-procedure-name=""
                                   data-source=""
                                   auto-startup="true"
                                   id=""
                                   ignore-column-meta-data="false"
                                   is-function="false"
                                   skip-undeclared-results=""                    (2)
                                   return-value-required="false"                 (3)
    <int:poller/>
    <int-jdbc:sql-parameter-definition name="" direction="IN"
                                               type="STRING"
                                               scale=""/>
    <int-jdbc:parameter name="" type="" value=""/>
    <int-jdbc:parameter name="" expression=""/>
    <int-jdbc:returning-resultset name="" row-mapper="" />
</int-jdbc:stored-proc-inbound-channel-adapter>

1	轮询消息发送到的通道。如果存储过程或函数未返回任何数据，则`Message`为 null。必填。
2	如果此属性设置为`true`，则存储过程调用的所有结果都没有相应的`SqlOutParameter`声明。例如，存储过程可以返回更新计数值，即使存储过程仅声明一个 result 参数。确切的行为取决于数据库实现。该值在底层`JdbcTemplate`. 该值默认为`true`. 自选。
3	指示是否应包含此过程的返回值。从 Spring Integration 3.0 开始。自选。

存储过程出站通道适配器

下面的清单列出了对存储过程出站通道适配器很重要的属性：spring-doc.cadn.net.cn

<int-jdbc:stored-proc-outbound-channel-adapter channel=""                        (1)
                                               stored-procedure-name=""
                                               data-source=""
                                               auto-startup="true"
                                               id=""
                                               ignore-column-meta-data="false"
                                               order=""                          (2)
                                               sql-parameter-source-factory=""
                                               use-payload-as-parameter-source="">
    <int:poller fixed-rate=""/>
    <int-jdbc:sql-parameter-definition name=""/>
    <int-jdbc:parameter name=""/>

</int-jdbc:stored-proc-outbound-channel-adapter>

1	此终端节点的接收消息通道。必填。
2	指定此终端节点作为订阅者连接到通道时的调用顺序。当该通道使用`failover`调度策略。当此终端节点本身是具有队列的通道的轮询使用者时，它不起作用。自选。

存储过程出站网关

下面的清单列出了对存储过程出站通道适配器很重要的属性：spring-doc.cadn.net.cn

<int-jdbc:stored-proc-outbound-gateway request-channel=""                        (1)
                                       stored-procedure-name=""
                                       data-source=""
                                   auto-startup="true"
                                   id=""
                                   ignore-column-meta-data="false"
                                   is-function="false"
                                   order=""
                                   reply-channel=""                              (2)
                                   reply-timeout=""                              (3)
                                   return-value-required="false"                 (4)
                                   skip-undeclared-results=""                    (5)
                                   sql-parameter-source-factory=""
                                   use-payload-as-parameter-source="">
<int-jdbc:sql-parameter-definition name="" direction="IN"
                                   type=""
                                   scale="10"/>
<int-jdbc:sql-parameter-definition name=""/>
<int-jdbc:parameter name="" type="" value=""/>
<int-jdbc:parameter name="" expression=""/>
<int-jdbc:returning-resultset name="" row-mapper="" />

1	此终端节点的接收消息通道。必填。
2	收到数据库响应后应将回复发送到的消息通道。自选。
3	允许您指定此网关在引发异常之前等待成功发送回复消息的时间。请记住，当发送到`DirectChannel`，则调用发生在发送方的线程中。因此，send作的失败可能是由下游的其他组件引起的。默认情况下，网关无限期等待。该值以毫秒为单位指定。自选。
4	指示是否应包含此过程的返回值。自选。
5	如果`skip-undeclared-results`属性设置为`true`，则存储过程调用的所有结果都没有相应的`SqlOutParameter`声明。例如，存储过程可能会返回更新计数值，即使存储过程只声明了一个 result 参数。确切的行为取决于数据库。该值在底层`JdbcTemplate`. 该值默认为`true`. 自选。

例子

本节包含两个调用 Apache Derby 存储过程的示例。第一个过程调用一个存储过程，该存储过程返回一个ResultSet. 通过使用RowMapper，数据将转换为域对象，然后成为 Spring Integration 消息有效负载。spring-doc.cadn.net.cn

在第二个示例中，我们调用了一个存储过程，该过程使用输出参数来返回数据。spring-doc.cadn.net.cn

请看一下 Spring Integration Samples 项目。spring-doc.cadn.net.cn

该项目包含此处引用的 Apache Derby 示例，以及有关如何运行它的说明。 Spring Integration Samples 项目还提供了一个使用 Oracle 存储过程的示例。spring-doc.cadn.net.cn

在第一个示例中，我们将名为FIND_ALL_COFFEE_BEVERAGES，它不定义任何输入参数，但返回一个ResultSet.spring-doc.cadn.net.cn

在 Apache Derby 中，存储过程是用 Java 实现的。下面的清单显示了方法签名：spring-doc.cadn.net.cn

public static void findAllCoffeeBeverages(ResultSet[] coffeeBeverages)
            throws SQLException {
    ...
}

下面的清单显示了相应的 SQL：spring-doc.cadn.net.cn

CREATE PROCEDURE FIND_ALL_COFFEE_BEVERAGES() \
PARAMETER STYLE JAVA LANGUAGE JAVA MODIFIES SQL DATA DYNAMIC RESULT SETS 1 \
EXTERNAL NAME 'o.s.i.jdbc.storedproc.derby.DerbyStoredProcedures.findAllCoffeeBeverages';

在 Spring Integration 中，您现在可以通过使用stored-proc-outbound-gateway，如下例所示：spring-doc.cadn.net.cn

<int-jdbc:stored-proc-outbound-gateway id="outbound-gateway-storedproc-find-all"
                                       data-source="dataSource"
                                       request-channel="findAllProcedureRequestChannel"
                                       expect-single-result="true"
                                       stored-procedure-name="FIND_ALL_COFFEE_BEVERAGES">
<int-jdbc:returning-resultset name="coffeeBeverages"
    row-mapper="org.springframework.integration.support.CoffeBeverageMapper"/>
</int-jdbc:stored-proc-outbound-gateway>

在第二个示例中，我们将名为FIND_COFFEE，该参数具有一个 input 参数。而不是返回ResultSet，则它使用 output 参数。以下示例显示了方法签名：spring-doc.cadn.net.cn

public static void findCoffee(int coffeeId, String[] coffeeDescription)
            throws SQLException {
    ...
}

下面的清单显示了相应的 SQL：spring-doc.cadn.net.cn

CREATE PROCEDURE FIND_COFFEE(IN ID INTEGER, OUT COFFEE_DESCRIPTION VARCHAR(200)) \
PARAMETER STYLE JAVA LANGUAGE JAVA EXTERNAL NAME \
'org.springframework.integration.jdbc.storedproc.derby.DerbyStoredProcedures.findCoffee';

在 Spring 集成中，您现在可以通过使用stored-proc-outbound-gateway，如下例所示：spring-doc.cadn.net.cn

<int-jdbc:stored-proc-outbound-gateway id="outbound-gateway-storedproc-find-coffee"
                                       data-source="dataSource"
                                       request-channel="findCoffeeProcedureRequestChannel"
                                       skip-undeclared-results="true"
                                       stored-procedure-name="FIND_COFFEE"
                                       expect-single-result="true">
    <int-jdbc:parameter name="ID" expression="payload" />
</int-jdbc:stored-proc-outbound-gateway>

JDBC Lock Registry

版本 4.3 引入了JdbcLockRegistry. 某些组件（例如，aggregator 和 resequencer）使用从LockRegistry实例来确保一次只有一个线程作一个组。这DefaultLockRegistry在单个组件中执行此功能。现在，您可以在这些组件上配置外部锁注册表。当与共享的MessageGroupStore中，您可以使用JdbcLockRegistry跨多个应用程序实例提供此功能，以便一次只有一个实例可以作组。spring-doc.cadn.net.cn

当本地线程释放锁时，另一个本地线程通常可以立即获取该锁。如果锁由使用其他注册表实例的线程释放，则获取锁可能需要长达 100 毫秒的时间。spring-doc.cadn.net.cn

这JdbcLockRegistry基于LockRepositoryabstraction 的 API 中，它有一个DefaultLockRepository实现。数据库架构脚本位于org.springframework.integration.jdbc软件包，该软件包针对特定的 RDBMS 供应商进行划分。例如，下面的清单显示了 lock table 的 H2 DDL：spring-doc.cadn.net.cn

CREATE TABLE INT_LOCK  (
    LOCK_KEY CHAR(36),
    REGION VARCHAR(100),
    CLIENT_ID CHAR(36),
    CREATED_DATE TIMESTAMP NOT NULL,
    constraint INT_LOCK_PK primary key (LOCK_KEY, REGION)
);

这INT_可以根据目标数据库设计要求进行更改。因此，您必须使用prefix属性DefaultLockRepositorybean 定义。spring-doc.cadn.net.cn

有时，一个应用程序已移动到无法释放分布式锁并删除数据库中的特定记录的状态。为此，此类死锁可以在下一次锁定调用时由其他应用程序过期。这timeToLive（TTL）选项DefaultLockRepository为此目的而提供。您可能还需要指定CLIENT_ID对于为给定DefaultLockRepository实例。如果是这样，您可以指定id以与DefaultLockRepository作为构造函数参数。spring-doc.cadn.net.cn

从版本 5.1.8 开始，JdbcLockRegistry可以使用idleBetweenTries-一个Duration在锁定记录插入/更新执行之间休眠。默认情况下，它是100毫秒，并且在某些环境中，非领导者会过于频繁地污染与数据源的连接。spring-doc.cadn.net.cn

从版本 5.4 开始，RenewableLockRegistryinterface 已引入并添加到JdbcLockRegistry. 这renewLock()方法必须在锁定的进程期间调用，以防锁定的进程比锁定的生存时间长。因此，生存时间可以大大缩短，部署可以快速重新获得丢失的锁。spring-doc.cadn.net.cn

仅当锁由当前线程持有时，才能进行锁续订。

String 中，使用JdbcLockRegistry支持自动清理 JdbcLock 的缓存JdbcLockRegistry.locks通过JdbcLockRegistry.setCacheCapacity(). 有关更多信息，请参阅其 JavaDocs。spring-doc.cadn.net.cn

String 的 6.0 版本，则DefaultLockRepository可随附PlatformTransactionManager而不是依赖于应用程序上下文中的主 bean。spring-doc.cadn.net.cn

JDBC 元数据存储

版本 5.0 引入了 JDBCMetadataStore（请参阅元数据存储）实现。您可以使用JdbcMetadataStore在应用程序重启时保持元数据状态。这MetadataStoreimplementation 可以与适配器一起使用，例如：spring-doc.cadn.net.cn

要将这些适配器配置为使用JdbcMetadataStore中，使用 Bean 名称metadataStore. Feed 入站通道适配器和 Feed 入站通道适配器都会自动获取并使用声明的JdbcMetadataStore，如下例所示：spring-doc.cadn.net.cn

@Bean
public MetadataStore metadataStore(DataSource dataSource) {
    return new JdbcMetadataStore(dataSource);
}

这org.springframework.integration.jdbc包包含多个 RDMBS 供应商的数据库架构脚本。例如，下面的清单显示了元数据表的 H2 DDL：spring-doc.cadn.net.cn

CREATE TABLE INT_METADATA_STORE  (
	METADATA_KEY VARCHAR(255) NOT NULL,
	METADATA_VALUE VARCHAR(4000),
	REGION VARCHAR(100) NOT NULL,
	constraint INT_METADATA_STORE_PK primary key (METADATA_KEY, REGION)
);

您可以将INT_前缀以匹配目标数据库设计要求。您还可以配置JdbcMetadataStore以使用自定义前缀。spring-doc.cadn.net.cn

这JdbcMetadataStore实现ConcurrentMetadataStore，使其在多个应用程序实例之间可靠地共享，其中只有一个实例可以存储或修改键的值。由于交易保证，所有这些作都是原子的。spring-doc.cadn.net.cn

事务管理必须使用JdbcMetadataStore. 入站通道适配器可以提供对TransactionManager在 Poller 配置中。与非事务性MetadataStoreimplementations，使用JdbcMetadataStore，则只有在事务提交后，该条目才会显示在目标表中。发生回滚时，不会向INT_METADATA_STORE桌子。spring-doc.cadn.net.cn

从版本 5.0.7 开始，您可以配置JdbcMetadataStore使用 RDBMS 供应商特定的lockHint对元数据存储条目进行基于锁的查询的选项。默认情况下，它是FOR UPDATE如果目标数据库不支持行锁定功能，则可以使用空字符串进行配置。请咨询您的供应商，以获取SELECTexpression 在更新之前锁定行。spring-doc.cadn.net.cn

JDBC 支持

JDBC 支持

入站通道适配器

轮询和事务

max-rows对max-messages-per-poll

出站通道适配器

使用 SPEL 表达式传递参数

使用PreparedStatement回调

批量更新

出站网关

JDBC 消息存储

初始化数据库

通用 JDBC 消息存储

后备消息通道

支持的数据库

自定义消息插入

并发轮询

优先通道

对消息存储进行分区

PostgreSQL：接收推送通知

存储过程

支持的数据库

配置

常见配置属性

常见配置子元素

定义参数源

存储过程入站通道适配器

存储过程出站通道适配器

存储过程出站网关

例子

JDBC Lock Registry

JDBC 元数据存储

`max-rows`对`max-messages-per-poll`

使用`PreparedStatement`回调