[[appendix.application-properties.integration]]
== Integration Properties
[cols="4,3,3", options="header"]
|===
|Name|Description|Default Value

|[[application-properties.integration.spring.activemq.broker-url]]xref:#application-properties.integration.spring.activemq.broker-url[`+spring.activemq.broker-url+`]
|+++URL of the ActiveMQ broker. Auto-generated by default.+++
|

|[[application-properties.integration.spring.activemq.close-timeout]]xref:#application-properties.integration.spring.activemq.close-timeout[`+spring.activemq.close-timeout+`]
|+++Time to wait before considering a close complete.+++
|`+15s+`

|[[application-properties.integration.spring.activemq.non-blocking-redelivery]]xref:#application-properties.integration.spring.activemq.non-blocking-redelivery[`+spring.activemq.non-blocking-redelivery+`]
|+++Whether to stop message delivery before re-delivering messages from a rolled back transaction. This implies that message order is not preserved when this is enabled.+++
|`+false+`

|[[application-properties.integration.spring.activemq.packages.trust-all]]xref:#application-properties.integration.spring.activemq.packages.trust-all[`+spring.activemq.packages.trust-all+`]
|+++Whether to trust all packages.+++
|

|[[application-properties.integration.spring.activemq.packages.trusted]]xref:#application-properties.integration.spring.activemq.packages.trusted[`+spring.activemq.packages.trusted+`]
|+++Comma-separated list of specific packages to trust (when not trusting all packages).+++
|

|[[application-properties.integration.spring.activemq.password]]xref:#application-properties.integration.spring.activemq.password[`+spring.activemq.password+`]
|+++Login password of the broker.+++
|

|[[application-properties.integration.spring.activemq.pool.block-if-full]]xref:#application-properties.integration.spring.activemq.pool.block-if-full[`+spring.activemq.pool.block-if-full+`]
|+++Whether to block when a connection is requested and the pool is full. Set it to false to throw a "JMSException" instead.+++
|`+true+`

|[[application-properties.integration.spring.activemq.pool.block-if-full-timeout]]xref:#application-properties.integration.spring.activemq.pool.block-if-full-timeout[`+spring.activemq.pool.block-if-full-timeout+`]
|+++Blocking period before throwing an exception if the pool is still full.+++
|`+-1ms+`

|[[application-properties.integration.spring.activemq.pool.enabled]]xref:#application-properties.integration.spring.activemq.pool.enabled[`+spring.activemq.pool.enabled+`]
|+++Whether a JmsPoolConnectionFactory should be created, instead of a regular ConnectionFactory.+++
|`+false+`

|[[application-properties.integration.spring.activemq.pool.idle-timeout]]xref:#application-properties.integration.spring.activemq.pool.idle-timeout[`+spring.activemq.pool.idle-timeout+`]
|+++Connection idle timeout.+++
|`+30s+`

|[[application-properties.integration.spring.activemq.pool.max-connections]]xref:#application-properties.integration.spring.activemq.pool.max-connections[`+spring.activemq.pool.max-connections+`]
|+++Maximum number of pooled connections.+++
|`+1+`

|[[application-properties.integration.spring.activemq.pool.max-sessions-per-connection]]xref:#application-properties.integration.spring.activemq.pool.max-sessions-per-connection[`+spring.activemq.pool.max-sessions-per-connection+`]
|+++Maximum number of pooled sessions per connection in the pool.+++
|`+500+`

|[[application-properties.integration.spring.activemq.pool.time-between-expiration-check]]xref:#application-properties.integration.spring.activemq.pool.time-between-expiration-check[`+spring.activemq.pool.time-between-expiration-check+`]
|+++Time to sleep between runs of the idle connection eviction thread. When negative, no idle connection eviction thread runs.+++
|`+-1ms+`

|[[application-properties.integration.spring.activemq.pool.use-anonymous-producers]]xref:#application-properties.integration.spring.activemq.pool.use-anonymous-producers[`+spring.activemq.pool.use-anonymous-producers+`]
|+++Whether to use only one anonymous "MessageProducer" instance. Set it to false to create one "MessageProducer" every time one is required.+++
|`+true+`

|[[application-properties.integration.spring.activemq.send-timeout]]xref:#application-properties.integration.spring.activemq.send-timeout[`+spring.activemq.send-timeout+`]
|+++Time to wait on message sends for a response. Set it to 0 to wait forever.+++
|`+0ms+`

|[[application-properties.integration.spring.activemq.user]]xref:#application-properties.integration.spring.activemq.user[`+spring.activemq.user+`]
|+++Login user of the broker.+++
|

|[[application-properties.integration.spring.artemis.broker-url]]xref:#application-properties.integration.spring.artemis.broker-url[`+spring.artemis.broker-url+`]
|+++Artemis broker url.+++
|`+tcp://localhost:61616+`

|[[application-properties.integration.spring.artemis.embedded.cluster-password]]xref:#application-properties.integration.spring.artemis.embedded.cluster-password[`+spring.artemis.embedded.cluster-password+`]
|+++Cluster password. Randomly generated on startup by default.+++
|

|[[application-properties.integration.spring.artemis.embedded.data-directory]]xref:#application-properties.integration.spring.artemis.embedded.data-directory[`+spring.artemis.embedded.data-directory+`]
|+++Journal file directory. Not necessary if persistence is turned off.+++
|

|[[application-properties.integration.spring.artemis.embedded.enabled]]xref:#application-properties.integration.spring.artemis.embedded.enabled[`+spring.artemis.embedded.enabled+`]
|+++Whether to enable embedded mode if the Artemis server APIs are available.+++
|`+true+`

|[[application-properties.integration.spring.artemis.embedded.persistent]]xref:#application-properties.integration.spring.artemis.embedded.persistent[`+spring.artemis.embedded.persistent+`]
|+++Whether to enable persistent store.+++
|`+false+`

|[[application-properties.integration.spring.artemis.embedded.queues]]xref:#application-properties.integration.spring.artemis.embedded.queues[`+spring.artemis.embedded.queues+`]
|+++Comma-separated list of queues to create on startup.+++
|`+[]+`

|[[application-properties.integration.spring.artemis.embedded.server-id]]xref:#application-properties.integration.spring.artemis.embedded.server-id[`+spring.artemis.embedded.server-id+`]
|+++Server ID. By default, an auto-incremented counter is used.+++
|`+0+`

|[[application-properties.integration.spring.artemis.embedded.topics]]xref:#application-properties.integration.spring.artemis.embedded.topics[`+spring.artemis.embedded.topics+`]
|+++Comma-separated list of topics to create on startup.+++
|`+[]+`

|[[application-properties.integration.spring.artemis.mode]]xref:#application-properties.integration.spring.artemis.mode[`+spring.artemis.mode+`]
|+++Artemis deployment mode, auto-detected by default.+++
|

|[[application-properties.integration.spring.artemis.password]]xref:#application-properties.integration.spring.artemis.password[`+spring.artemis.password+`]
|+++Login password of the broker.+++
|

|[[application-properties.integration.spring.artemis.pool.block-if-full]]xref:#application-properties.integration.spring.artemis.pool.block-if-full[`+spring.artemis.pool.block-if-full+`]
|+++Whether to block when a connection is requested and the pool is full. Set it to false to throw a "JMSException" instead.+++
|`+true+`

|[[application-properties.integration.spring.artemis.pool.block-if-full-timeout]]xref:#application-properties.integration.spring.artemis.pool.block-if-full-timeout[`+spring.artemis.pool.block-if-full-timeout+`]
|+++Blocking period before throwing an exception if the pool is still full.+++
|`+-1ms+`

|[[application-properties.integration.spring.artemis.pool.enabled]]xref:#application-properties.integration.spring.artemis.pool.enabled[`+spring.artemis.pool.enabled+`]
|+++Whether a JmsPoolConnectionFactory should be created, instead of a regular ConnectionFactory.+++
|`+false+`

|[[application-properties.integration.spring.artemis.pool.idle-timeout]]xref:#application-properties.integration.spring.artemis.pool.idle-timeout[`+spring.artemis.pool.idle-timeout+`]
|+++Connection idle timeout.+++
|`+30s+`

|[[application-properties.integration.spring.artemis.pool.max-connections]]xref:#application-properties.integration.spring.artemis.pool.max-connections[`+spring.artemis.pool.max-connections+`]
|+++Maximum number of pooled connections.+++
|`+1+`

|[[application-properties.integration.spring.artemis.pool.max-sessions-per-connection]]xref:#application-properties.integration.spring.artemis.pool.max-sessions-per-connection[`+spring.artemis.pool.max-sessions-per-connection+`]
|+++Maximum number of pooled sessions per connection in the pool.+++
|`+500+`

|[[application-properties.integration.spring.artemis.pool.time-between-expiration-check]]xref:#application-properties.integration.spring.artemis.pool.time-between-expiration-check[`+spring.artemis.pool.time-between-expiration-check+`]
|+++Time to sleep between runs of the idle connection eviction thread. When negative, no idle connection eviction thread runs.+++
|`+-1ms+`

|[[application-properties.integration.spring.artemis.pool.use-anonymous-producers]]xref:#application-properties.integration.spring.artemis.pool.use-anonymous-producers[`+spring.artemis.pool.use-anonymous-producers+`]
|+++Whether to use only one anonymous "MessageProducer" instance. Set it to false to create one "MessageProducer" every time one is required.+++
|`+true+`

|[[application-properties.integration.spring.artemis.user]]xref:#application-properties.integration.spring.artemis.user[`+spring.artemis.user+`]
|+++Login user of the broker.+++
|

|[[application-properties.integration.spring.batch.jdbc.initialize-schema]]xref:#application-properties.integration.spring.batch.jdbc.initialize-schema[`+spring.batch.jdbc.initialize-schema+`]
|+++Database schema initialization mode.+++
|`+embedded+`

|[[application-properties.integration.spring.batch.jdbc.isolation-level-for-create]]xref:#application-properties.integration.spring.batch.jdbc.isolation-level-for-create[`+spring.batch.jdbc.isolation-level-for-create+`]
|+++Transaction isolation level to use when creating job meta-data for new jobs.+++
|

|[[application-properties.integration.spring.batch.jdbc.platform]]xref:#application-properties.integration.spring.batch.jdbc.platform[`+spring.batch.jdbc.platform+`]
|+++Platform to use in initialization scripts if the @@platform@@ placeholder is used. Auto-detected by default.+++
|

|[[application-properties.integration.spring.batch.jdbc.schema]]xref:#application-properties.integration.spring.batch.jdbc.schema[`+spring.batch.jdbc.schema+`]
|+++Path to the SQL file to use to initialize the database schema.+++
|`+classpath:org/springframework/batch/core/schema-@@platform@@.sql+`

|[[application-properties.integration.spring.batch.jdbc.table-prefix]]xref:#application-properties.integration.spring.batch.jdbc.table-prefix[`+spring.batch.jdbc.table-prefix+`]
|+++Table prefix for all the batch meta-data tables.+++
|

|[[application-properties.integration.spring.batch.job.enabled]]xref:#application-properties.integration.spring.batch.job.enabled[`+spring.batch.job.enabled+`]
|+++Execute all Spring Batch jobs in the context on startup.+++
|`+true+`

|[[application-properties.integration.spring.batch.job.name]]xref:#application-properties.integration.spring.batch.job.name[`+spring.batch.job.name+`]
|+++Job name to execute on startup. Must be specified if multiple Jobs are found in the context.+++
|

|[[application-properties.integration.spring.hazelcast.config]]xref:#application-properties.integration.spring.hazelcast.config[`+spring.hazelcast.config+`]
|+++The location of the configuration file to use to initialize Hazelcast.+++
|

|[[application-properties.integration.spring.integration.channel.auto-create]]xref:#application-properties.integration.spring.integration.channel.auto-create[`+spring.integration.channel.auto-create+`]
|+++Whether to create input channels if necessary.+++
|`+true+`

|[[application-properties.integration.spring.integration.channel.max-broadcast-subscribers]]xref:#application-properties.integration.spring.integration.channel.max-broadcast-subscribers[`+spring.integration.channel.max-broadcast-subscribers+`]
|+++Default number of subscribers allowed on, for example, a 'PublishSubscribeChannel'.+++
|

|[[application-properties.integration.spring.integration.channel.max-unicast-subscribers]]xref:#application-properties.integration.spring.integration.channel.max-unicast-subscribers[`+spring.integration.channel.max-unicast-subscribers+`]
|+++Default number of subscribers allowed on, for example, a 'DirectChannel'.+++
|

|[[application-properties.integration.spring.integration.endpoint.no-auto-startup]]xref:#application-properties.integration.spring.integration.endpoint.no-auto-startup[`+spring.integration.endpoint.no-auto-startup+`]
|+++A comma-separated list of endpoint bean names patterns that should not be started automatically during application startup.+++
|

|[[application-properties.integration.spring.integration.endpoint.read-only-headers]]xref:#application-properties.integration.spring.integration.endpoint.read-only-headers[`+spring.integration.endpoint.read-only-headers+`]
|+++A comma-separated list of message header names that should not be populated into Message instances during a header copying operation.+++
|

|[[application-properties.integration.spring.integration.endpoint.throw-exception-on-late-reply]]xref:#application-properties.integration.spring.integration.endpoint.throw-exception-on-late-reply[`+spring.integration.endpoint.throw-exception-on-late-reply+`]
|+++Whether to throw an exception when a reply is not expected anymore by a gateway.+++
|`+false+`

|[[application-properties.integration.spring.integration.error.ignore-failures]]xref:#application-properties.integration.spring.integration.error.ignore-failures[`+spring.integration.error.ignore-failures+`]
|+++Whether to ignore failures for one or more of the handlers of the global 'errorChannel'.+++
|`+true+`

|[[application-properties.integration.spring.integration.error.require-subscribers]]xref:#application-properties.integration.spring.integration.error.require-subscribers[`+spring.integration.error.require-subscribers+`]
|+++Whether to not silently ignore messages on the global 'errorChannel' when there are no subscribers.+++
|`+true+`

|[[application-properties.integration.spring.integration.jdbc.initialize-schema]]xref:#application-properties.integration.spring.integration.jdbc.initialize-schema[`+spring.integration.jdbc.initialize-schema+`]
|+++Database schema initialization mode.+++
|`+embedded+`

|[[application-properties.integration.spring.integration.jdbc.platform]]xref:#application-properties.integration.spring.integration.jdbc.platform[`+spring.integration.jdbc.platform+`]
|+++Platform to use in initialization scripts if the @@platform@@ placeholder is used. Auto-detected by default.+++
|

|[[application-properties.integration.spring.integration.jdbc.schema]]xref:#application-properties.integration.spring.integration.jdbc.schema[`+spring.integration.jdbc.schema+`]
|+++Path to the SQL file to use to initialize the database schema.+++
|`+classpath:org/springframework/integration/jdbc/schema-@@platform@@.sql+`

|[[application-properties.integration.spring.integration.management.default-logging-enabled]]xref:#application-properties.integration.spring.integration.management.default-logging-enabled[`+spring.integration.management.default-logging-enabled+`]
|+++Whether Spring Integration components should perform logging in the main message flow. When disabled, such logging will be skipped without checking the logging level. When enabled, such logging is controlled as normal by the logging system's log level configuration.+++
|`+true+`

|[[application-properties.integration.spring.integration.management.observation-patterns]]xref:#application-properties.integration.spring.integration.management.observation-patterns[`+spring.integration.management.observation-patterns+`]
|+++Comma-separated list of simple patterns to match against the names of Spring Integration components. When matched, observation instrumentation will be performed for the component. Please refer to the javadoc of the smartMatch method of Spring Integration's PatternMatchUtils for details of the pattern syntax.+++
|

|[[application-properties.integration.spring.integration.poller.cron]]xref:#application-properties.integration.spring.integration.poller.cron[`+spring.integration.poller.cron+`]
|+++Cron expression for polling. Mutually exclusive with 'fixedDelay' and 'fixedRate'.+++
|

|[[application-properties.integration.spring.integration.poller.fixed-delay]]xref:#application-properties.integration.spring.integration.poller.fixed-delay[`+spring.integration.poller.fixed-delay+`]
|+++Polling delay period. Mutually exclusive with 'cron' and 'fixedRate'.+++
|

|[[application-properties.integration.spring.integration.poller.fixed-rate]]xref:#application-properties.integration.spring.integration.poller.fixed-rate[`+spring.integration.poller.fixed-rate+`]
|+++Polling rate period. Mutually exclusive with 'fixedDelay' and 'cron'.+++
|

|[[application-properties.integration.spring.integration.poller.initial-delay]]xref:#application-properties.integration.spring.integration.poller.initial-delay[`+spring.integration.poller.initial-delay+`]
|+++Polling initial delay. Applied for 'fixedDelay' and 'fixedRate'; ignored for 'cron'.+++
|

|[[application-properties.integration.spring.integration.poller.max-messages-per-poll]]xref:#application-properties.integration.spring.integration.poller.max-messages-per-poll[`+spring.integration.poller.max-messages-per-poll+`]
|+++Maximum number of messages to poll per polling cycle.+++
|

|[[application-properties.integration.spring.integration.poller.receive-timeout]]xref:#application-properties.integration.spring.integration.poller.receive-timeout[`+spring.integration.poller.receive-timeout+`]
|+++How long to wait for messages on poll.+++
|`+1s+`

|[[application-properties.integration.spring.integration.rsocket.client.host]]xref:#application-properties.integration.spring.integration.rsocket.client.host[`+spring.integration.rsocket.client.host+`]
|+++TCP RSocket server host to connect to.+++
|

|[[application-properties.integration.spring.integration.rsocket.client.port]]xref:#application-properties.integration.spring.integration.rsocket.client.port[`+spring.integration.rsocket.client.port+`]
|+++TCP RSocket server port to connect to.+++
|

|[[application-properties.integration.spring.integration.rsocket.client.uri]]xref:#application-properties.integration.spring.integration.rsocket.client.uri[`+spring.integration.rsocket.client.uri+`]
|+++WebSocket RSocket server uri to connect to.+++
|

|[[application-properties.integration.spring.integration.rsocket.server.message-mapping-enabled]]xref:#application-properties.integration.spring.integration.rsocket.server.message-mapping-enabled[`+spring.integration.rsocket.server.message-mapping-enabled+`]
|+++Whether to handle message mapping for RSocket through Spring Integration.+++
|`+false+`

|[[application-properties.integration.spring.jms.cache.consumers]]xref:#application-properties.integration.spring.jms.cache.consumers[`+spring.jms.cache.consumers+`]
|+++Whether to cache message consumers.+++
|`+false+`

|[[application-properties.integration.spring.jms.cache.enabled]]xref:#application-properties.integration.spring.jms.cache.enabled[`+spring.jms.cache.enabled+`]
|+++Whether to cache sessions.+++
|`+true+`

|[[application-properties.integration.spring.jms.cache.producers]]xref:#application-properties.integration.spring.jms.cache.producers[`+spring.jms.cache.producers+`]
|+++Whether to cache message producers.+++
|`+true+`

|[[application-properties.integration.spring.jms.cache.session-cache-size]]xref:#application-properties.integration.spring.jms.cache.session-cache-size[`+spring.jms.cache.session-cache-size+`]
|+++Size of the session cache (per JMS Session type).+++
|`+1+`

|[[application-properties.integration.spring.jms.client-id]]xref:#application-properties.integration.spring.jms.client-id[`+spring.jms.client-id+`]
|+++Client id of the connection.+++
|

|[[application-properties.integration.spring.jms.jndi-name]]xref:#application-properties.integration.spring.jms.jndi-name[`+spring.jms.jndi-name+`]
|+++Connection factory JNDI name. When set, takes precedence to others connection factory auto-configurations.+++
|

|[[application-properties.integration.spring.jms.listener.auto-startup]]xref:#application-properties.integration.spring.jms.listener.auto-startup[`+spring.jms.listener.auto-startup+`]
|+++Start the container automatically on startup.+++
|`+true+`

|[[application-properties.integration.spring.jms.listener.max-concurrency]]xref:#application-properties.integration.spring.jms.listener.max-concurrency[`+spring.jms.listener.max-concurrency+`]
|+++Maximum number of concurrent consumers.+++
|

|[[application-properties.integration.spring.jms.listener.min-concurrency]]xref:#application-properties.integration.spring.jms.listener.min-concurrency[`+spring.jms.listener.min-concurrency+`]
|+++Minimum number of concurrent consumers. When max-concurrency is not specified the minimum will also be used as the maximum.+++
|

|[[application-properties.integration.spring.jms.listener.receive-timeout]]xref:#application-properties.integration.spring.jms.listener.receive-timeout[`+spring.jms.listener.receive-timeout+`]
|+++Timeout to use for receive calls. Use -1 for a no-wait receive or 0 for no timeout at all. The latter is only feasible if not running within a transaction manager and is generally discouraged since it prevents clean shutdown.+++
|`+1s+`

|[[application-properties.integration.spring.jms.listener.session.acknowledge-mode]]xref:#application-properties.integration.spring.jms.listener.session.acknowledge-mode[`+spring.jms.listener.session.acknowledge-mode+`]
|+++Acknowledge mode of the listener container.+++
|`+auto+`

|[[application-properties.integration.spring.jms.listener.session.transacted]]xref:#application-properties.integration.spring.jms.listener.session.transacted[`+spring.jms.listener.session.transacted+`]
|+++Whether the listener container should use transacted JMS sessions. Defaults to false in the presence of a JtaTransactionManager and true otherwise.+++
|

|[[application-properties.integration.spring.jms.pub-sub-domain]]xref:#application-properties.integration.spring.jms.pub-sub-domain[`+spring.jms.pub-sub-domain+`]
|+++Whether the default destination type is topic.+++
|`+false+`

|[[application-properties.integration.spring.jms.subscription-durable]]xref:#application-properties.integration.spring.jms.subscription-durable[`+spring.jms.subscription-durable+`]
|+++Whether the subscription is durable.+++
|`+false+`

|[[application-properties.integration.spring.jms.template.default-destination]]xref:#application-properties.integration.spring.jms.template.default-destination[`+spring.jms.template.default-destination+`]
|+++Default destination to use on send and receive operations that do not have a destination parameter.+++
|

|[[application-properties.integration.spring.jms.template.delivery-delay]]xref:#application-properties.integration.spring.jms.template.delivery-delay[`+spring.jms.template.delivery-delay+`]
|+++Delivery delay to use for send calls.+++
|

|[[application-properties.integration.spring.jms.template.delivery-mode]]xref:#application-properties.integration.spring.jms.template.delivery-mode[`+spring.jms.template.delivery-mode+`]
|+++Delivery mode. Enables QoS (Quality of Service) when set.+++
|

|[[application-properties.integration.spring.jms.template.priority]]xref:#application-properties.integration.spring.jms.template.priority[`+spring.jms.template.priority+`]
|+++Priority of a message when sending. Enables QoS (Quality of Service) when set.+++
|

|[[application-properties.integration.spring.jms.template.qos-enabled]]xref:#application-properties.integration.spring.jms.template.qos-enabled[`+spring.jms.template.qos-enabled+`]
|+++Whether to enable explicit QoS (Quality of Service) when sending a message. When enabled, the delivery mode, priority and time-to-live properties will be used when sending a message. QoS is automatically enabled when at least one of those settings is customized.+++
|

|[[application-properties.integration.spring.jms.template.receive-timeout]]xref:#application-properties.integration.spring.jms.template.receive-timeout[`+spring.jms.template.receive-timeout+`]
|+++Timeout to use for receive calls.+++
|

|[[application-properties.integration.spring.jms.template.session.acknowledge-mode]]xref:#application-properties.integration.spring.jms.template.session.acknowledge-mode[`+spring.jms.template.session.acknowledge-mode+`]
|+++Acknowledge mode used when creating sessions.+++
|`+auto+`

|[[application-properties.integration.spring.jms.template.session.transacted]]xref:#application-properties.integration.spring.jms.template.session.transacted[`+spring.jms.template.session.transacted+`]
|+++Whether to use transacted sessions.+++
|`+false+`

|[[application-properties.integration.spring.jms.template.time-to-live]]xref:#application-properties.integration.spring.jms.template.time-to-live[`+spring.jms.template.time-to-live+`]
|+++Time-to-live of a message when sending. Enables QoS (Quality of Service) when set.+++
|

|[[application-properties.integration.spring.kafka.admin.auto-create]]xref:#application-properties.integration.spring.kafka.admin.auto-create[`+spring.kafka.admin.auto-create+`]
|+++Whether to automatically create topics during context initialization. When set to false, disables automatic topic creation during context initialization.+++
|`+true+`

|[[application-properties.integration.spring.kafka.admin.client-id]]xref:#application-properties.integration.spring.kafka.admin.client-id[`+spring.kafka.admin.client-id+`]
|+++ID to pass to the server when making requests. Used for server-side logging.+++
|

|[[application-properties.integration.spring.kafka.admin.close-timeout]]xref:#application-properties.integration.spring.kafka.admin.close-timeout[`+spring.kafka.admin.close-timeout+`]
|+++Close timeout.+++
|

|[[application-properties.integration.spring.kafka.admin.fail-fast]]xref:#application-properties.integration.spring.kafka.admin.fail-fast[`+spring.kafka.admin.fail-fast+`]
|+++Whether to fail fast if the broker is not available on startup.+++
|`+false+`

|[[application-properties.integration.spring.kafka.admin.modify-topic-configs]]xref:#application-properties.integration.spring.kafka.admin.modify-topic-configs[`+spring.kafka.admin.modify-topic-configs+`]
|+++Whether to enable modification of existing topic configuration.+++
|`+false+`

|[[application-properties.integration.spring.kafka.admin.operation-timeout]]xref:#application-properties.integration.spring.kafka.admin.operation-timeout[`+spring.kafka.admin.operation-timeout+`]
|+++Operation timeout.+++
|

|[[application-properties.integration.spring.kafka.admin.properties]]xref:#application-properties.integration.spring.kafka.admin.properties[`+spring.kafka.admin.properties.*+`]
|+++Additional admin-specific properties used to configure the client.+++
|

|[[application-properties.integration.spring.kafka.admin.security.protocol]]xref:#application-properties.integration.spring.kafka.admin.security.protocol[`+spring.kafka.admin.security.protocol+`]
|+++Security protocol used to communicate with brokers.+++
|

|[[application-properties.integration.spring.kafka.admin.ssl.bundle]]xref:#application-properties.integration.spring.kafka.admin.ssl.bundle[`+spring.kafka.admin.ssl.bundle+`]
|+++Name of the SSL bundle to use.+++
|

|[[application-properties.integration.spring.kafka.admin.ssl.key-password]]xref:#application-properties.integration.spring.kafka.admin.ssl.key-password[`+spring.kafka.admin.ssl.key-password+`]
|+++Password of the private key in either key store key or key store file.+++
|

|[[application-properties.integration.spring.kafka.admin.ssl.key-store-certificate-chain]]xref:#application-properties.integration.spring.kafka.admin.ssl.key-store-certificate-chain[`+spring.kafka.admin.ssl.key-store-certificate-chain+`]
|+++Certificate chain in PEM format with a list of X.509 certificates.+++
|

|[[application-properties.integration.spring.kafka.admin.ssl.key-store-key]]xref:#application-properties.integration.spring.kafka.admin.ssl.key-store-key[`+spring.kafka.admin.ssl.key-store-key+`]
|+++Private key in PEM format with PKCS#8 keys.+++
|

|[[application-properties.integration.spring.kafka.admin.ssl.key-store-location]]xref:#application-properties.integration.spring.kafka.admin.ssl.key-store-location[`+spring.kafka.admin.ssl.key-store-location+`]
|+++Location of the key store file.+++
|

|[[application-properties.integration.spring.kafka.admin.ssl.key-store-password]]xref:#application-properties.integration.spring.kafka.admin.ssl.key-store-password[`+spring.kafka.admin.ssl.key-store-password+`]
|+++Store password for the key store file.+++
|

|[[application-properties.integration.spring.kafka.admin.ssl.key-store-type]]xref:#application-properties.integration.spring.kafka.admin.ssl.key-store-type[`+spring.kafka.admin.ssl.key-store-type+`]
|+++Type of the key store.+++
|

|[[application-properties.integration.spring.kafka.admin.ssl.protocol]]xref:#application-properties.integration.spring.kafka.admin.ssl.protocol[`+spring.kafka.admin.ssl.protocol+`]
|+++SSL protocol to use.+++
|

|[[application-properties.integration.spring.kafka.admin.ssl.trust-store-certificates]]xref:#application-properties.integration.spring.kafka.admin.ssl.trust-store-certificates[`+spring.kafka.admin.ssl.trust-store-certificates+`]
|+++Trusted certificates in PEM format with X.509 certificates.+++
|

|[[application-properties.integration.spring.kafka.admin.ssl.trust-store-location]]xref:#application-properties.integration.spring.kafka.admin.ssl.trust-store-location[`+spring.kafka.admin.ssl.trust-store-location+`]
|+++Location of the trust store file.+++
|

|[[application-properties.integration.spring.kafka.admin.ssl.trust-store-password]]xref:#application-properties.integration.spring.kafka.admin.ssl.trust-store-password[`+spring.kafka.admin.ssl.trust-store-password+`]
|+++Store password for the trust store file.+++
|

|[[application-properties.integration.spring.kafka.admin.ssl.trust-store-type]]xref:#application-properties.integration.spring.kafka.admin.ssl.trust-store-type[`+spring.kafka.admin.ssl.trust-store-type+`]
|+++Type of the trust store.+++
|

|[[application-properties.integration.spring.kafka.bootstrap-servers]]xref:#application-properties.integration.spring.kafka.bootstrap-servers[`+spring.kafka.bootstrap-servers+`]
|+++Comma-delimited list of host:port pairs to use for establishing the initial connections to the Kafka cluster. Applies to all components unless overridden.+++
|

|[[application-properties.integration.spring.kafka.client-id]]xref:#application-properties.integration.spring.kafka.client-id[`+spring.kafka.client-id+`]
|+++ID to pass to the server when making requests. Used for server-side logging.+++
|

|[[application-properties.integration.spring.kafka.consumer.auto-commit-interval]]xref:#application-properties.integration.spring.kafka.consumer.auto-commit-interval[`+spring.kafka.consumer.auto-commit-interval+`]
|+++Frequency with which the consumer offsets are auto-committed to Kafka if 'enable.auto.commit' is set to true.+++
|

|[[application-properties.integration.spring.kafka.consumer.auto-offset-reset]]xref:#application-properties.integration.spring.kafka.consumer.auto-offset-reset[`+spring.kafka.consumer.auto-offset-reset+`]
|+++What to do when there is no initial offset in Kafka or if the current offset no longer exists on the server.+++
|

|[[application-properties.integration.spring.kafka.consumer.bootstrap-servers]]xref:#application-properties.integration.spring.kafka.consumer.bootstrap-servers[`+spring.kafka.consumer.bootstrap-servers+`]
|+++Comma-delimited list of host:port pairs to use for establishing the initial connections to the Kafka cluster. Overrides the global property, for consumers.+++
|

|[[application-properties.integration.spring.kafka.consumer.client-id]]xref:#application-properties.integration.spring.kafka.consumer.client-id[`+spring.kafka.consumer.client-id+`]
|+++ID to pass to the server when making requests. Used for server-side logging.+++
|

|[[application-properties.integration.spring.kafka.consumer.enable-auto-commit]]xref:#application-properties.integration.spring.kafka.consumer.enable-auto-commit[`+spring.kafka.consumer.enable-auto-commit+`]
|+++Whether the consumer's offset is periodically committed in the background.+++
|

|[[application-properties.integration.spring.kafka.consumer.fetch-max-wait]]xref:#application-properties.integration.spring.kafka.consumer.fetch-max-wait[`+spring.kafka.consumer.fetch-max-wait+`]
|+++Maximum amount of time the server blocks before answering the fetch request if there isn't sufficient data to immediately satisfy the requirement given by "fetch-min-size".+++
|

|[[application-properties.integration.spring.kafka.consumer.fetch-min-size]]xref:#application-properties.integration.spring.kafka.consumer.fetch-min-size[`+spring.kafka.consumer.fetch-min-size+`]
|+++Minimum amount of data the server should return for a fetch request.+++
|

|[[application-properties.integration.spring.kafka.consumer.group-id]]xref:#application-properties.integration.spring.kafka.consumer.group-id[`+spring.kafka.consumer.group-id+`]
|+++Unique string that identifies the consumer group to which this consumer belongs.+++
|

|[[application-properties.integration.spring.kafka.consumer.heartbeat-interval]]xref:#application-properties.integration.spring.kafka.consumer.heartbeat-interval[`+spring.kafka.consumer.heartbeat-interval+`]
|+++Expected time between heartbeats to the consumer coordinator.+++
|

|[[application-properties.integration.spring.kafka.consumer.isolation-level]]xref:#application-properties.integration.spring.kafka.consumer.isolation-level[`+spring.kafka.consumer.isolation-level+`]
|+++Isolation level for reading messages that have been written transactionally.+++
|`+read-uncommitted+`

|[[application-properties.integration.spring.kafka.consumer.key-deserializer]]xref:#application-properties.integration.spring.kafka.consumer.key-deserializer[`+spring.kafka.consumer.key-deserializer+`]
|+++Deserializer class for keys.+++
|

|[[application-properties.integration.spring.kafka.consumer.max-poll-records]]xref:#application-properties.integration.spring.kafka.consumer.max-poll-records[`+spring.kafka.consumer.max-poll-records+`]
|+++Maximum number of records returned in a single call to poll().+++
|

|[[application-properties.integration.spring.kafka.consumer.properties]]xref:#application-properties.integration.spring.kafka.consumer.properties[`+spring.kafka.consumer.properties.*+`]
|+++Additional consumer-specific properties used to configure the client.+++
|

|[[application-properties.integration.spring.kafka.consumer.security.protocol]]xref:#application-properties.integration.spring.kafka.consumer.security.protocol[`+spring.kafka.consumer.security.protocol+`]
|+++Security protocol used to communicate with brokers.+++
|

|[[application-properties.integration.spring.kafka.consumer.ssl.bundle]]xref:#application-properties.integration.spring.kafka.consumer.ssl.bundle[`+spring.kafka.consumer.ssl.bundle+`]
|+++Name of the SSL bundle to use.+++
|

|[[application-properties.integration.spring.kafka.consumer.ssl.key-password]]xref:#application-properties.integration.spring.kafka.consumer.ssl.key-password[`+spring.kafka.consumer.ssl.key-password+`]
|+++Password of the private key in either key store key or key store file.+++
|

|[[application-properties.integration.spring.kafka.consumer.ssl.key-store-certificate-chain]]xref:#application-properties.integration.spring.kafka.consumer.ssl.key-store-certificate-chain[`+spring.kafka.consumer.ssl.key-store-certificate-chain+`]
|+++Certificate chain in PEM format with a list of X.509 certificates.+++
|

|[[application-properties.integration.spring.kafka.consumer.ssl.key-store-key]]xref:#application-properties.integration.spring.kafka.consumer.ssl.key-store-key[`+spring.kafka.consumer.ssl.key-store-key+`]
|+++Private key in PEM format with PKCS#8 keys.+++
|

|[[application-properties.integration.spring.kafka.consumer.ssl.key-store-location]]xref:#application-properties.integration.spring.kafka.consumer.ssl.key-store-location[`+spring.kafka.consumer.ssl.key-store-location+`]
|+++Location of the key store file.+++
|

|[[application-properties.integration.spring.kafka.consumer.ssl.key-store-password]]xref:#application-properties.integration.spring.kafka.consumer.ssl.key-store-password[`+spring.kafka.consumer.ssl.key-store-password+`]
|+++Store password for the key store file.+++
|

|[[application-properties.integration.spring.kafka.consumer.ssl.key-store-type]]xref:#application-properties.integration.spring.kafka.consumer.ssl.key-store-type[`+spring.kafka.consumer.ssl.key-store-type+`]
|+++Type of the key store.+++
|

|[[application-properties.integration.spring.kafka.consumer.ssl.protocol]]xref:#application-properties.integration.spring.kafka.consumer.ssl.protocol[`+spring.kafka.consumer.ssl.protocol+`]
|+++SSL protocol to use.+++
|

|[[application-properties.integration.spring.kafka.consumer.ssl.trust-store-certificates]]xref:#application-properties.integration.spring.kafka.consumer.ssl.trust-store-certificates[`+spring.kafka.consumer.ssl.trust-store-certificates+`]
|+++Trusted certificates in PEM format with X.509 certificates.+++
|

|[[application-properties.integration.spring.kafka.consumer.ssl.trust-store-location]]xref:#application-properties.integration.spring.kafka.consumer.ssl.trust-store-location[`+spring.kafka.consumer.ssl.trust-store-location+`]
|+++Location of the trust store file.+++
|

|[[application-properties.integration.spring.kafka.consumer.ssl.trust-store-password]]xref:#application-properties.integration.spring.kafka.consumer.ssl.trust-store-password[`+spring.kafka.consumer.ssl.trust-store-password+`]
|+++Store password for the trust store file.+++
|

|[[application-properties.integration.spring.kafka.consumer.ssl.trust-store-type]]xref:#application-properties.integration.spring.kafka.consumer.ssl.trust-store-type[`+spring.kafka.consumer.ssl.trust-store-type+`]
|+++Type of the trust store.+++
|

|[[application-properties.integration.spring.kafka.consumer.value-deserializer]]xref:#application-properties.integration.spring.kafka.consumer.value-deserializer[`+spring.kafka.consumer.value-deserializer+`]
|+++Deserializer class for values.+++
|

|[[application-properties.integration.spring.kafka.jaas.control-flag]]xref:#application-properties.integration.spring.kafka.jaas.control-flag[`+spring.kafka.jaas.control-flag+`]
|+++Control flag for login configuration.+++
|`+required+`

|[[application-properties.integration.spring.kafka.jaas.enabled]]xref:#application-properties.integration.spring.kafka.jaas.enabled[`+spring.kafka.jaas.enabled+`]
|+++Whether to enable JAAS configuration.+++
|`+false+`

|[[application-properties.integration.spring.kafka.jaas.login-module]]xref:#application-properties.integration.spring.kafka.jaas.login-module[`+spring.kafka.jaas.login-module+`]
|+++Login module.+++
|`+com.sun.security.auth.module.Krb5LoginModule+`

|[[application-properties.integration.spring.kafka.jaas.options]]xref:#application-properties.integration.spring.kafka.jaas.options[`+spring.kafka.jaas.options.*+`]
|+++Additional JAAS options.+++
|

|[[application-properties.integration.spring.kafka.listener.ack-count]]xref:#application-properties.integration.spring.kafka.listener.ack-count[`+spring.kafka.listener.ack-count+`]
|+++Number of records between offset commits when ackMode is "COUNT" or "COUNT_TIME".+++
|

|[[application-properties.integration.spring.kafka.listener.ack-mode]]xref:#application-properties.integration.spring.kafka.listener.ack-mode[`+spring.kafka.listener.ack-mode+`]
|+++Listener AckMode. See the spring-kafka documentation.+++
|

|[[application-properties.integration.spring.kafka.listener.ack-time]]xref:#application-properties.integration.spring.kafka.listener.ack-time[`+spring.kafka.listener.ack-time+`]
|+++Time between offset commits when ackMode is "TIME" or "COUNT_TIME".+++
|

|[[application-properties.integration.spring.kafka.listener.async-acks]]xref:#application-properties.integration.spring.kafka.listener.async-acks[`+spring.kafka.listener.async-acks+`]
|+++Support for asynchronous record acknowledgements. Only applies when spring.kafka.listener.ack-mode is manual or manual-immediate.+++
|

|[[application-properties.integration.spring.kafka.listener.auto-startup]]xref:#application-properties.integration.spring.kafka.listener.auto-startup[`+spring.kafka.listener.auto-startup+`]
|+++Whether to auto start the container.+++
|`+true+`

|[[application-properties.integration.spring.kafka.listener.change-consumer-thread-name]]xref:#application-properties.integration.spring.kafka.listener.change-consumer-thread-name[`+spring.kafka.listener.change-consumer-thread-name+`]
|+++Whether to instruct the container to change the consumer thread name during initialization.+++
|

|[[application-properties.integration.spring.kafka.listener.client-id]]xref:#application-properties.integration.spring.kafka.listener.client-id[`+spring.kafka.listener.client-id+`]
|+++Prefix for the listener's consumer client.id property.+++
|

|[[application-properties.integration.spring.kafka.listener.concurrency]]xref:#application-properties.integration.spring.kafka.listener.concurrency[`+spring.kafka.listener.concurrency+`]
|+++Number of threads to run in the listener containers.+++
|

|[[application-properties.integration.spring.kafka.listener.idle-between-polls]]xref:#application-properties.integration.spring.kafka.listener.idle-between-polls[`+spring.kafka.listener.idle-between-polls+`]
|+++Sleep interval between Consumer.poll(Duration) calls.+++
|`+0+`

|[[application-properties.integration.spring.kafka.listener.idle-event-interval]]xref:#application-properties.integration.spring.kafka.listener.idle-event-interval[`+spring.kafka.listener.idle-event-interval+`]
|+++Time between publishing idle consumer events (no data received).+++
|

|[[application-properties.integration.spring.kafka.listener.idle-partition-event-interval]]xref:#application-properties.integration.spring.kafka.listener.idle-partition-event-interval[`+spring.kafka.listener.idle-partition-event-interval+`]
|+++Time between publishing idle partition consumer events (no data received for partition).+++
|

|[[application-properties.integration.spring.kafka.listener.immediate-stop]]xref:#application-properties.integration.spring.kafka.listener.immediate-stop[`+spring.kafka.listener.immediate-stop+`]
|+++Whether the container stops after the current record is processed or after all the records from the previous poll are processed.+++
|`+false+`

|[[application-properties.integration.spring.kafka.listener.log-container-config]]xref:#application-properties.integration.spring.kafka.listener.log-container-config[`+spring.kafka.listener.log-container-config+`]
|+++Whether to log the container configuration during initialization (INFO level).+++
|

|[[application-properties.integration.spring.kafka.listener.missing-topics-fatal]]xref:#application-properties.integration.spring.kafka.listener.missing-topics-fatal[`+spring.kafka.listener.missing-topics-fatal+`]
|+++Whether the container should fail to start if at least one of the configured topics are not present on the broker.+++
|`+false+`

|[[application-properties.integration.spring.kafka.listener.monitor-interval]]xref:#application-properties.integration.spring.kafka.listener.monitor-interval[`+spring.kafka.listener.monitor-interval+`]
|+++Time between checks for non-responsive consumers. If a duration suffix is not specified, seconds will be used.+++
|

|[[application-properties.integration.spring.kafka.listener.no-poll-threshold]]xref:#application-properties.integration.spring.kafka.listener.no-poll-threshold[`+spring.kafka.listener.no-poll-threshold+`]
|+++Multiplier applied to "pollTimeout" to determine if a consumer is non-responsive.+++
|

|[[application-properties.integration.spring.kafka.listener.observation-enabled]]xref:#application-properties.integration.spring.kafka.listener.observation-enabled[`+spring.kafka.listener.observation-enabled+`]
|+++Whether to enable observation.+++
|`+false+`

|[[application-properties.integration.spring.kafka.listener.poll-timeout]]xref:#application-properties.integration.spring.kafka.listener.poll-timeout[`+spring.kafka.listener.poll-timeout+`]
|+++Timeout to use when polling the consumer.+++
|

|[[application-properties.integration.spring.kafka.listener.type]]xref:#application-properties.integration.spring.kafka.listener.type[`+spring.kafka.listener.type+`]
|+++Listener type.+++
|`+single+`

|[[application-properties.integration.spring.kafka.producer.acks]]xref:#application-properties.integration.spring.kafka.producer.acks[`+spring.kafka.producer.acks+`]
|+++Number of acknowledgments the producer requires the leader to have received before considering a request complete.+++
|

|[[application-properties.integration.spring.kafka.producer.batch-size]]xref:#application-properties.integration.spring.kafka.producer.batch-size[`+spring.kafka.producer.batch-size+`]
|+++Default batch size. A small batch size will make batching less common and may reduce throughput (a batch size of zero disables batching entirely).+++
|

|[[application-properties.integration.spring.kafka.producer.bootstrap-servers]]xref:#application-properties.integration.spring.kafka.producer.bootstrap-servers[`+spring.kafka.producer.bootstrap-servers+`]
|+++Comma-delimited list of host:port pairs to use for establishing the initial connections to the Kafka cluster. Overrides the global property, for producers.+++
|

|[[application-properties.integration.spring.kafka.producer.buffer-memory]]xref:#application-properties.integration.spring.kafka.producer.buffer-memory[`+spring.kafka.producer.buffer-memory+`]
|+++Total memory size the producer can use to buffer records waiting to be sent to the server.+++
|

|[[application-properties.integration.spring.kafka.producer.client-id]]xref:#application-properties.integration.spring.kafka.producer.client-id[`+spring.kafka.producer.client-id+`]
|+++ID to pass to the server when making requests. Used for server-side logging.+++
|

|[[application-properties.integration.spring.kafka.producer.compression-type]]xref:#application-properties.integration.spring.kafka.producer.compression-type[`+spring.kafka.producer.compression-type+`]
|+++Compression type for all data generated by the producer.+++
|

|[[application-properties.integration.spring.kafka.producer.key-serializer]]xref:#application-properties.integration.spring.kafka.producer.key-serializer[`+spring.kafka.producer.key-serializer+`]
|+++Serializer class for keys.+++
|

|[[application-properties.integration.spring.kafka.producer.properties]]xref:#application-properties.integration.spring.kafka.producer.properties[`+spring.kafka.producer.properties.*+`]
|+++Additional producer-specific properties used to configure the client.+++
|

|[[application-properties.integration.spring.kafka.producer.retries]]xref:#application-properties.integration.spring.kafka.producer.retries[`+spring.kafka.producer.retries+`]
|+++When greater than zero, enables retrying of failed sends.+++
|

|[[application-properties.integration.spring.kafka.producer.security.protocol]]xref:#application-properties.integration.spring.kafka.producer.security.protocol[`+spring.kafka.producer.security.protocol+`]
|+++Security protocol used to communicate with brokers.+++
|

|[[application-properties.integration.spring.kafka.producer.ssl.bundle]]xref:#application-properties.integration.spring.kafka.producer.ssl.bundle[`+spring.kafka.producer.ssl.bundle+`]
|+++Name of the SSL bundle to use.+++
|

|[[application-properties.integration.spring.kafka.producer.ssl.key-password]]xref:#application-properties.integration.spring.kafka.producer.ssl.key-password[`+spring.kafka.producer.ssl.key-password+`]
|+++Password of the private key in either key store key or key store file.+++
|

|[[application-properties.integration.spring.kafka.producer.ssl.key-store-certificate-chain]]xref:#application-properties.integration.spring.kafka.producer.ssl.key-store-certificate-chain[`+spring.kafka.producer.ssl.key-store-certificate-chain+`]
|+++Certificate chain in PEM format with a list of X.509 certificates.+++
|

|[[application-properties.integration.spring.kafka.producer.ssl.key-store-key]]xref:#application-properties.integration.spring.kafka.producer.ssl.key-store-key[`+spring.kafka.producer.ssl.key-store-key+`]
|+++Private key in PEM format with PKCS#8 keys.+++
|

|[[application-properties.integration.spring.kafka.producer.ssl.key-store-location]]xref:#application-properties.integration.spring.kafka.producer.ssl.key-store-location[`+spring.kafka.producer.ssl.key-store-location+`]
|+++Location of the key store file.+++
|

|[[application-properties.integration.spring.kafka.producer.ssl.key-store-password]]xref:#application-properties.integration.spring.kafka.producer.ssl.key-store-password[`+spring.kafka.producer.ssl.key-store-password+`]
|+++Store password for the key store file.+++
|

|[[application-properties.integration.spring.kafka.producer.ssl.key-store-type]]xref:#application-properties.integration.spring.kafka.producer.ssl.key-store-type[`+spring.kafka.producer.ssl.key-store-type+`]
|+++Type of the key store.+++
|

|[[application-properties.integration.spring.kafka.producer.ssl.protocol]]xref:#application-properties.integration.spring.kafka.producer.ssl.protocol[`+spring.kafka.producer.ssl.protocol+`]
|+++SSL protocol to use.+++
|

|[[application-properties.integration.spring.kafka.producer.ssl.trust-store-certificates]]xref:#application-properties.integration.spring.kafka.producer.ssl.trust-store-certificates[`+spring.kafka.producer.ssl.trust-store-certificates+`]
|+++Trusted certificates in PEM format with X.509 certificates.+++
|

|[[application-properties.integration.spring.kafka.producer.ssl.trust-store-location]]xref:#application-properties.integration.spring.kafka.producer.ssl.trust-store-location[`+spring.kafka.producer.ssl.trust-store-location+`]
|+++Location of the trust store file.+++
|

|[[application-properties.integration.spring.kafka.producer.ssl.trust-store-password]]xref:#application-properties.integration.spring.kafka.producer.ssl.trust-store-password[`+spring.kafka.producer.ssl.trust-store-password+`]
|+++Store password for the trust store file.+++
|

|[[application-properties.integration.spring.kafka.producer.ssl.trust-store-type]]xref:#application-properties.integration.spring.kafka.producer.ssl.trust-store-type[`+spring.kafka.producer.ssl.trust-store-type+`]
|+++Type of the trust store.+++
|

|[[application-properties.integration.spring.kafka.producer.transaction-id-prefix]]xref:#application-properties.integration.spring.kafka.producer.transaction-id-prefix[`+spring.kafka.producer.transaction-id-prefix+`]
|+++When non empty, enables transaction support for producer.+++
|

|[[application-properties.integration.spring.kafka.producer.value-serializer]]xref:#application-properties.integration.spring.kafka.producer.value-serializer[`+spring.kafka.producer.value-serializer+`]
|+++Serializer class for values.+++
|

|[[application-properties.integration.spring.kafka.properties]]xref:#application-properties.integration.spring.kafka.properties[`+spring.kafka.properties.*+`]
|+++Additional properties, common to producers and consumers, used to configure the client.+++
|

|[[application-properties.integration.spring.kafka.retry.topic.attempts]]xref:#application-properties.integration.spring.kafka.retry.topic.attempts[`+spring.kafka.retry.topic.attempts+`]
|+++Total number of processing attempts made before sending the message to the DLT.+++
|`+3+`

|[[application-properties.integration.spring.kafka.retry.topic.delay]]xref:#application-properties.integration.spring.kafka.retry.topic.delay[`+spring.kafka.retry.topic.delay+`]
|+++Canonical backoff period. Used as an initial value in the exponential case, and as a minimum value in the uniform case.+++
|`+1s+`

|[[application-properties.integration.spring.kafka.retry.topic.enabled]]xref:#application-properties.integration.spring.kafka.retry.topic.enabled[`+spring.kafka.retry.topic.enabled+`]
|+++Whether to enable topic-based non-blocking retries.+++
|`+false+`

|[[application-properties.integration.spring.kafka.retry.topic.max-delay]]xref:#application-properties.integration.spring.kafka.retry.topic.max-delay[`+spring.kafka.retry.topic.max-delay+`]
|+++Maximum wait between retries. If less than the delay then the default of 30 seconds is applied.+++
|`+0+`

|[[application-properties.integration.spring.kafka.retry.topic.multiplier]]xref:#application-properties.integration.spring.kafka.retry.topic.multiplier[`+spring.kafka.retry.topic.multiplier+`]
|+++Multiplier to use for generating the next backoff delay.+++
|`+0+`

|[[application-properties.integration.spring.kafka.retry.topic.random-back-off]]xref:#application-properties.integration.spring.kafka.retry.topic.random-back-off[`+spring.kafka.retry.topic.random-back-off+`]
|+++Whether to have the backoff delays.+++
|`+false+`

|[[application-properties.integration.spring.kafka.security.protocol]]xref:#application-properties.integration.spring.kafka.security.protocol[`+spring.kafka.security.protocol+`]
|+++Security protocol used to communicate with brokers.+++
|

|[[application-properties.integration.spring.kafka.ssl.bundle]]xref:#application-properties.integration.spring.kafka.ssl.bundle[`+spring.kafka.ssl.bundle+`]
|+++Name of the SSL bundle to use.+++
|

|[[application-properties.integration.spring.kafka.ssl.key-password]]xref:#application-properties.integration.spring.kafka.ssl.key-password[`+spring.kafka.ssl.key-password+`]
|+++Password of the private key in either key store key or key store file.+++
|

|[[application-properties.integration.spring.kafka.ssl.key-store-certificate-chain]]xref:#application-properties.integration.spring.kafka.ssl.key-store-certificate-chain[`+spring.kafka.ssl.key-store-certificate-chain+`]
|+++Certificate chain in PEM format with a list of X.509 certificates.+++
|

|[[application-properties.integration.spring.kafka.ssl.key-store-key]]xref:#application-properties.integration.spring.kafka.ssl.key-store-key[`+spring.kafka.ssl.key-store-key+`]
|+++Private key in PEM format with PKCS#8 keys.+++
|

|[[application-properties.integration.spring.kafka.ssl.key-store-location]]xref:#application-properties.integration.spring.kafka.ssl.key-store-location[`+spring.kafka.ssl.key-store-location+`]
|+++Location of the key store file.+++
|

|[[application-properties.integration.spring.kafka.ssl.key-store-password]]xref:#application-properties.integration.spring.kafka.ssl.key-store-password[`+spring.kafka.ssl.key-store-password+`]
|+++Store password for the key store file.+++
|

|[[application-properties.integration.spring.kafka.ssl.key-store-type]]xref:#application-properties.integration.spring.kafka.ssl.key-store-type[`+spring.kafka.ssl.key-store-type+`]
|+++Type of the key store.+++
|

|[[application-properties.integration.spring.kafka.ssl.protocol]]xref:#application-properties.integration.spring.kafka.ssl.protocol[`+spring.kafka.ssl.protocol+`]
|+++SSL protocol to use.+++
|

|[[application-properties.integration.spring.kafka.ssl.trust-store-certificates]]xref:#application-properties.integration.spring.kafka.ssl.trust-store-certificates[`+spring.kafka.ssl.trust-store-certificates+`]
|+++Trusted certificates in PEM format with X.509 certificates.+++
|

|[[application-properties.integration.spring.kafka.ssl.trust-store-location]]xref:#application-properties.integration.spring.kafka.ssl.trust-store-location[`+spring.kafka.ssl.trust-store-location+`]
|+++Location of the trust store file.+++
|

|[[application-properties.integration.spring.kafka.ssl.trust-store-password]]xref:#application-properties.integration.spring.kafka.ssl.trust-store-password[`+spring.kafka.ssl.trust-store-password+`]
|+++Store password for the trust store file.+++
|

|[[application-properties.integration.spring.kafka.ssl.trust-store-type]]xref:#application-properties.integration.spring.kafka.ssl.trust-store-type[`+spring.kafka.ssl.trust-store-type+`]
|+++Type of the trust store.+++
|

|[[application-properties.integration.spring.kafka.streams.application-id]]xref:#application-properties.integration.spring.kafka.streams.application-id[`+spring.kafka.streams.application-id+`]
|+++Kafka streams application.id property; default spring.application.name.+++
|

|[[application-properties.integration.spring.kafka.streams.auto-startup]]xref:#application-properties.integration.spring.kafka.streams.auto-startup[`+spring.kafka.streams.auto-startup+`]
|+++Whether to auto-start the streams factory bean.+++
|`+true+`

|[[application-properties.integration.spring.kafka.streams.bootstrap-servers]]xref:#application-properties.integration.spring.kafka.streams.bootstrap-servers[`+spring.kafka.streams.bootstrap-servers+`]
|+++Comma-delimited list of host:port pairs to use for establishing the initial connections to the Kafka cluster. Overrides the global property, for streams.+++
|

|[[application-properties.integration.spring.kafka.streams.cleanup.on-shutdown]]xref:#application-properties.integration.spring.kafka.streams.cleanup.on-shutdown[`+spring.kafka.streams.cleanup.on-shutdown+`]
|+++Cleanup the application’s local state directory on shutdown.+++
|`+false+`

|[[application-properties.integration.spring.kafka.streams.cleanup.on-startup]]xref:#application-properties.integration.spring.kafka.streams.cleanup.on-startup[`+spring.kafka.streams.cleanup.on-startup+`]
|+++Cleanup the application’s local state directory on startup.+++
|`+false+`

|[[application-properties.integration.spring.kafka.streams.client-id]]xref:#application-properties.integration.spring.kafka.streams.client-id[`+spring.kafka.streams.client-id+`]
|+++ID to pass to the server when making requests. Used for server-side logging.+++
|

|[[application-properties.integration.spring.kafka.streams.properties]]xref:#application-properties.integration.spring.kafka.streams.properties[`+spring.kafka.streams.properties.*+`]
|+++Additional Kafka properties used to configure the streams.+++
|

|[[application-properties.integration.spring.kafka.streams.replication-factor]]xref:#application-properties.integration.spring.kafka.streams.replication-factor[`+spring.kafka.streams.replication-factor+`]
|+++The replication factor for change log topics and repartition topics created by the stream processing application.+++
|

|[[application-properties.integration.spring.kafka.streams.security.protocol]]xref:#application-properties.integration.spring.kafka.streams.security.protocol[`+spring.kafka.streams.security.protocol+`]
|+++Security protocol used to communicate with brokers.+++
|

|[[application-properties.integration.spring.kafka.streams.ssl.bundle]]xref:#application-properties.integration.spring.kafka.streams.ssl.bundle[`+spring.kafka.streams.ssl.bundle+`]
|+++Name of the SSL bundle to use.+++
|

|[[application-properties.integration.spring.kafka.streams.ssl.key-password]]xref:#application-properties.integration.spring.kafka.streams.ssl.key-password[`+spring.kafka.streams.ssl.key-password+`]
|+++Password of the private key in either key store key or key store file.+++
|

|[[application-properties.integration.spring.kafka.streams.ssl.key-store-certificate-chain]]xref:#application-properties.integration.spring.kafka.streams.ssl.key-store-certificate-chain[`+spring.kafka.streams.ssl.key-store-certificate-chain+`]
|+++Certificate chain in PEM format with a list of X.509 certificates.+++
|

|[[application-properties.integration.spring.kafka.streams.ssl.key-store-key]]xref:#application-properties.integration.spring.kafka.streams.ssl.key-store-key[`+spring.kafka.streams.ssl.key-store-key+`]
|+++Private key in PEM format with PKCS#8 keys.+++
|

|[[application-properties.integration.spring.kafka.streams.ssl.key-store-location]]xref:#application-properties.integration.spring.kafka.streams.ssl.key-store-location[`+spring.kafka.streams.ssl.key-store-location+`]
|+++Location of the key store file.+++
|

|[[application-properties.integration.spring.kafka.streams.ssl.key-store-password]]xref:#application-properties.integration.spring.kafka.streams.ssl.key-store-password[`+spring.kafka.streams.ssl.key-store-password+`]
|+++Store password for the key store file.+++
|

|[[application-properties.integration.spring.kafka.streams.ssl.key-store-type]]xref:#application-properties.integration.spring.kafka.streams.ssl.key-store-type[`+spring.kafka.streams.ssl.key-store-type+`]
|+++Type of the key store.+++
|

|[[application-properties.integration.spring.kafka.streams.ssl.protocol]]xref:#application-properties.integration.spring.kafka.streams.ssl.protocol[`+spring.kafka.streams.ssl.protocol+`]
|+++SSL protocol to use.+++
|

|[[application-properties.integration.spring.kafka.streams.ssl.trust-store-certificates]]xref:#application-properties.integration.spring.kafka.streams.ssl.trust-store-certificates[`+spring.kafka.streams.ssl.trust-store-certificates+`]
|+++Trusted certificates in PEM format with X.509 certificates.+++
|

|[[application-properties.integration.spring.kafka.streams.ssl.trust-store-location]]xref:#application-properties.integration.spring.kafka.streams.ssl.trust-store-location[`+spring.kafka.streams.ssl.trust-store-location+`]
|+++Location of the trust store file.+++
|

|[[application-properties.integration.spring.kafka.streams.ssl.trust-store-password]]xref:#application-properties.integration.spring.kafka.streams.ssl.trust-store-password[`+spring.kafka.streams.ssl.trust-store-password+`]
|+++Store password for the trust store file.+++
|

|[[application-properties.integration.spring.kafka.streams.ssl.trust-store-type]]xref:#application-properties.integration.spring.kafka.streams.ssl.trust-store-type[`+spring.kafka.streams.ssl.trust-store-type+`]
|+++Type of the trust store.+++
|

|[[application-properties.integration.spring.kafka.streams.state-dir]]xref:#application-properties.integration.spring.kafka.streams.state-dir[`+spring.kafka.streams.state-dir+`]
|+++Directory location for the state store.+++
|

|[[application-properties.integration.spring.kafka.streams.state-store-cache-max-size]]xref:#application-properties.integration.spring.kafka.streams.state-store-cache-max-size[`+spring.kafka.streams.state-store-cache-max-size+`]
|+++Maximum size of the in-memory state store cache across all threads.+++
|

|[[application-properties.integration.spring.kafka.template.default-topic]]xref:#application-properties.integration.spring.kafka.template.default-topic[`+spring.kafka.template.default-topic+`]
|+++Default topic to which messages are sent.+++
|

|[[application-properties.integration.spring.kafka.template.observation-enabled]]xref:#application-properties.integration.spring.kafka.template.observation-enabled[`+spring.kafka.template.observation-enabled+`]
|+++Whether to enable observation.+++
|`+false+`

|[[application-properties.integration.spring.kafka.template.transaction-id-prefix]]xref:#application-properties.integration.spring.kafka.template.transaction-id-prefix[`+spring.kafka.template.transaction-id-prefix+`]
|+++Transaction id prefix, override the transaction id prefix in the producer factory.+++
|

|[[application-properties.integration.spring.pulsar.admin.authentication.param]]xref:#application-properties.integration.spring.pulsar.admin.authentication.param[`+spring.pulsar.admin.authentication.param.*+`]
|+++Authentication parameter(s) as a map of parameter names to parameter values.+++
|

|[[application-properties.integration.spring.pulsar.admin.authentication.plugin-class-name]]xref:#application-properties.integration.spring.pulsar.admin.authentication.plugin-class-name[`+spring.pulsar.admin.authentication.plugin-class-name+`]
|+++Fully qualified class name of the authentication plugin.+++
|

|[[application-properties.integration.spring.pulsar.admin.connection-timeout]]xref:#application-properties.integration.spring.pulsar.admin.connection-timeout[`+spring.pulsar.admin.connection-timeout+`]
|+++Duration to wait for a connection to server to be established.+++
|`+1m+`

|[[application-properties.integration.spring.pulsar.admin.read-timeout]]xref:#application-properties.integration.spring.pulsar.admin.read-timeout[`+spring.pulsar.admin.read-timeout+`]
|+++Server response read time out for any request.+++
|`+1m+`

|[[application-properties.integration.spring.pulsar.admin.request-timeout]]xref:#application-properties.integration.spring.pulsar.admin.request-timeout[`+spring.pulsar.admin.request-timeout+`]
|+++Server request time out for any request.+++
|`+5m+`

|[[application-properties.integration.spring.pulsar.admin.service-url]]xref:#application-properties.integration.spring.pulsar.admin.service-url[`+spring.pulsar.admin.service-url+`]
|+++Pulsar web URL for the admin endpoint in the format '(http\|https)://host:port'.+++
|`+http://localhost:8080+`

|[[application-properties.integration.spring.pulsar.client.authentication.param]]xref:#application-properties.integration.spring.pulsar.client.authentication.param[`+spring.pulsar.client.authentication.param.*+`]
|+++Authentication parameter(s) as a map of parameter names to parameter values.+++
|

|[[application-properties.integration.spring.pulsar.client.authentication.plugin-class-name]]xref:#application-properties.integration.spring.pulsar.client.authentication.plugin-class-name[`+spring.pulsar.client.authentication.plugin-class-name+`]
|+++Fully qualified class name of the authentication plugin.+++
|

|[[application-properties.integration.spring.pulsar.client.connection-timeout]]xref:#application-properties.integration.spring.pulsar.client.connection-timeout[`+spring.pulsar.client.connection-timeout+`]
|+++Duration to wait for a connection to a broker to be established.+++
|`+10s+`

|[[application-properties.integration.spring.pulsar.client.failover.backup-clusters]]xref:#application-properties.integration.spring.pulsar.client.failover.backup-clusters[`+spring.pulsar.client.failover.backup-clusters+`]
|+++List of backup clusters. The backup cluster is chosen in the sequence of the given list. If all backup clusters are available, the Pulsar client chooses the first backup cluster.+++
|

|[[application-properties.integration.spring.pulsar.client.failover.check-interval]]xref:#application-properties.integration.spring.pulsar.client.failover.check-interval[`+spring.pulsar.client.failover.check-interval+`]
|+++Frequency of performing a probe task.+++
|

|[[application-properties.integration.spring.pulsar.client.failover.delay]]xref:#application-properties.integration.spring.pulsar.client.failover.delay[`+spring.pulsar.client.failover.delay+`]
|+++Delay before the Pulsar client switches from the primary cluster to the backup cluster.+++
|

|[[application-properties.integration.spring.pulsar.client.failover.policy]]xref:#application-properties.integration.spring.pulsar.client.failover.policy[`+spring.pulsar.client.failover.policy+`]
|+++Cluster failover policy.+++
|`+order+`

|[[application-properties.integration.spring.pulsar.client.failover.switch-back-delay]]xref:#application-properties.integration.spring.pulsar.client.failover.switch-back-delay[`+spring.pulsar.client.failover.switch-back-delay+`]
|+++Delay before the Pulsar client switches from the backup cluster to the primary cluster.+++
|

|[[application-properties.integration.spring.pulsar.client.lookup-timeout]]xref:#application-properties.integration.spring.pulsar.client.lookup-timeout[`+spring.pulsar.client.lookup-timeout+`]
|+++Client lookup timeout.+++
|

|[[application-properties.integration.spring.pulsar.client.operation-timeout]]xref:#application-properties.integration.spring.pulsar.client.operation-timeout[`+spring.pulsar.client.operation-timeout+`]
|+++Client operation timeout.+++
|`+30s+`

|[[application-properties.integration.spring.pulsar.client.service-url]]xref:#application-properties.integration.spring.pulsar.client.service-url[`+spring.pulsar.client.service-url+`]
|+++Pulsar service URL in the format '(pulsar\|pulsar+ssl)://host:port'.+++
|`+pulsar://localhost:6650+`

|[[application-properties.integration.spring.pulsar.consumer.dead-letter-policy.dead-letter-topic]]xref:#application-properties.integration.spring.pulsar.consumer.dead-letter-policy.dead-letter-topic[`+spring.pulsar.consumer.dead-letter-policy.dead-letter-topic+`]
|+++Name of the dead topic where the failing messages will be sent.+++
|

|[[application-properties.integration.spring.pulsar.consumer.dead-letter-policy.initial-subscription-name]]xref:#application-properties.integration.spring.pulsar.consumer.dead-letter-policy.initial-subscription-name[`+spring.pulsar.consumer.dead-letter-policy.initial-subscription-name+`]
|+++Name of the initial subscription of the dead letter topic. When not set, the initial subscription will not be created. However, when the property is set then the broker's 'allowAutoSubscriptionCreation' must be enabled or the DLQ producer will fail.+++
|

|[[application-properties.integration.spring.pulsar.consumer.dead-letter-policy.max-redeliver-count]]xref:#application-properties.integration.spring.pulsar.consumer.dead-letter-policy.max-redeliver-count[`+spring.pulsar.consumer.dead-letter-policy.max-redeliver-count+`]
|+++Maximum number of times that a message will be redelivered before being sent to the dead letter queue.+++
|`+0+`

|[[application-properties.integration.spring.pulsar.consumer.dead-letter-policy.retry-letter-topic]]xref:#application-properties.integration.spring.pulsar.consumer.dead-letter-policy.retry-letter-topic[`+spring.pulsar.consumer.dead-letter-policy.retry-letter-topic+`]
|+++Name of the retry topic where the failing messages will be sent.+++
|

|[[application-properties.integration.spring.pulsar.consumer.name]]xref:#application-properties.integration.spring.pulsar.consumer.name[`+spring.pulsar.consumer.name+`]
|+++Consumer name to identify a particular consumer from the topic stats.+++
|

|[[application-properties.integration.spring.pulsar.consumer.priority-level]]xref:#application-properties.integration.spring.pulsar.consumer.priority-level[`+spring.pulsar.consumer.priority-level+`]
|+++Priority level for shared subscription consumers.+++
|`+0+`

|[[application-properties.integration.spring.pulsar.consumer.read-compacted]]xref:#application-properties.integration.spring.pulsar.consumer.read-compacted[`+spring.pulsar.consumer.read-compacted+`]
|+++Whether to read messages from the compacted topic rather than the full message backlog.+++
|`+false+`

|[[application-properties.integration.spring.pulsar.consumer.retry-enable]]xref:#application-properties.integration.spring.pulsar.consumer.retry-enable[`+spring.pulsar.consumer.retry-enable+`]
|+++Whether to auto retry messages.+++
|`+false+`

|[[application-properties.integration.spring.pulsar.consumer.subscription.initial-position]]xref:#application-properties.integration.spring.pulsar.consumer.subscription.initial-position[`+spring.pulsar.consumer.subscription.initial-position+`]
|+++Position where to initialize a newly created subscription.+++
|

|[[application-properties.integration.spring.pulsar.consumer.subscription.mode]]xref:#application-properties.integration.spring.pulsar.consumer.subscription.mode[`+spring.pulsar.consumer.subscription.mode+`]
|+++Subscription mode to be used when subscribing to the topic.+++
|

|[[application-properties.integration.spring.pulsar.consumer.subscription.name]]xref:#application-properties.integration.spring.pulsar.consumer.subscription.name[`+spring.pulsar.consumer.subscription.name+`]
|+++Subscription name for the consumer.+++
|

|[[application-properties.integration.spring.pulsar.consumer.subscription.topics-mode]]xref:#application-properties.integration.spring.pulsar.consumer.subscription.topics-mode[`+spring.pulsar.consumer.subscription.topics-mode+`]
|+++Determines which type of topics (persistent, non-persistent, or all) the consumer should be subscribed to when using pattern subscriptions.+++
|

|[[application-properties.integration.spring.pulsar.consumer.subscription.type]]xref:#application-properties.integration.spring.pulsar.consumer.subscription.type[`+spring.pulsar.consumer.subscription.type+`]
|+++Subscription type to be used when subscribing to a topic.+++
|

|[[application-properties.integration.spring.pulsar.consumer.topics]]xref:#application-properties.integration.spring.pulsar.consumer.topics[`+spring.pulsar.consumer.topics+`]
|+++Topics the consumer subscribes to.+++
|

|[[application-properties.integration.spring.pulsar.consumer.topics-pattern]]xref:#application-properties.integration.spring.pulsar.consumer.topics-pattern[`+spring.pulsar.consumer.topics-pattern+`]
|+++Pattern for topics the consumer subscribes to.+++
|

|[[application-properties.integration.spring.pulsar.defaults.type-mappings]]xref:#application-properties.integration.spring.pulsar.defaults.type-mappings[`+spring.pulsar.defaults.type-mappings+`]
|+++List of mappings from message type to topic name and schema info to use as a defaults when a topic name and/or schema is not explicitly specified when producing or consuming messages of the mapped type.+++
|

|[[application-properties.integration.spring.pulsar.function.enabled]]xref:#application-properties.integration.spring.pulsar.function.enabled[`+spring.pulsar.function.enabled+`]
|+++Whether to enable function support.+++
|`+true+`

|[[application-properties.integration.spring.pulsar.function.fail-fast]]xref:#application-properties.integration.spring.pulsar.function.fail-fast[`+spring.pulsar.function.fail-fast+`]
|+++Whether to stop processing further function creates/updates when a failure occurs.+++
|`+true+`

|[[application-properties.integration.spring.pulsar.function.propagate-failures]]xref:#application-properties.integration.spring.pulsar.function.propagate-failures[`+spring.pulsar.function.propagate-failures+`]
|+++Whether to throw an exception if any failure is encountered during server startup while creating/updating functions.+++
|`+true+`

|[[application-properties.integration.spring.pulsar.function.propagate-stop-failures]]xref:#application-properties.integration.spring.pulsar.function.propagate-stop-failures[`+spring.pulsar.function.propagate-stop-failures+`]
|+++Whether to throw an exception if any failure is encountered during server shutdown while enforcing stop policy on functions.+++
|`+false+`

|[[application-properties.integration.spring.pulsar.listener.observation-enabled]]xref:#application-properties.integration.spring.pulsar.listener.observation-enabled[`+spring.pulsar.listener.observation-enabled+`]
|+++Whether to record observations for when the Observations API is available and the client supports it.+++
|`+false+`

|[[application-properties.integration.spring.pulsar.listener.schema-type]]xref:#application-properties.integration.spring.pulsar.listener.schema-type[`+spring.pulsar.listener.schema-type+`]
|+++SchemaType of the consumed messages.+++
|

|[[application-properties.integration.spring.pulsar.producer.access-mode]]xref:#application-properties.integration.spring.pulsar.producer.access-mode[`+spring.pulsar.producer.access-mode+`]
|+++Type of access to the topic the producer requires.+++
|

|[[application-properties.integration.spring.pulsar.producer.batching-enabled]]xref:#application-properties.integration.spring.pulsar.producer.batching-enabled[`+spring.pulsar.producer.batching-enabled+`]
|+++Whether to automatically batch messages.+++
|`+true+`

|[[application-properties.integration.spring.pulsar.producer.cache.enabled]]xref:#application-properties.integration.spring.pulsar.producer.cache.enabled[`+spring.pulsar.producer.cache.enabled+`]
|+++Whether to enable caching in the PulsarProducerFactory.+++
|`+true+`

|[[application-properties.integration.spring.pulsar.producer.cache.expire-after-access]]xref:#application-properties.integration.spring.pulsar.producer.cache.expire-after-access[`+spring.pulsar.producer.cache.expire-after-access+`]
|+++Time period to expire unused entries in the cache.+++
|`+1m+`

|[[application-properties.integration.spring.pulsar.producer.cache.initial-capacity]]xref:#application-properties.integration.spring.pulsar.producer.cache.initial-capacity[`+spring.pulsar.producer.cache.initial-capacity+`]
|+++Initial size of cache.+++
|`+50+`

|[[application-properties.integration.spring.pulsar.producer.cache.maximum-size]]xref:#application-properties.integration.spring.pulsar.producer.cache.maximum-size[`+spring.pulsar.producer.cache.maximum-size+`]
|+++Maximum size of cache (entries).+++
|`+1000+`

|[[application-properties.integration.spring.pulsar.producer.chunking-enabled]]xref:#application-properties.integration.spring.pulsar.producer.chunking-enabled[`+spring.pulsar.producer.chunking-enabled+`]
|+++Whether to split large-size messages into multiple chunks.+++
|`+false+`

|[[application-properties.integration.spring.pulsar.producer.compression-type]]xref:#application-properties.integration.spring.pulsar.producer.compression-type[`+spring.pulsar.producer.compression-type+`]
|+++Message compression type.+++
|

|[[application-properties.integration.spring.pulsar.producer.hashing-scheme]]xref:#application-properties.integration.spring.pulsar.producer.hashing-scheme[`+spring.pulsar.producer.hashing-scheme+`]
|+++Message hashing scheme to choose the partition to which the message is published.+++
|

|[[application-properties.integration.spring.pulsar.producer.message-routing-mode]]xref:#application-properties.integration.spring.pulsar.producer.message-routing-mode[`+spring.pulsar.producer.message-routing-mode+`]
|+++Message routing mode for a partitioned producer.+++
|

|[[application-properties.integration.spring.pulsar.producer.name]]xref:#application-properties.integration.spring.pulsar.producer.name[`+spring.pulsar.producer.name+`]
|+++Name for the producer. If not assigned, a unique name is generated.+++
|

|[[application-properties.integration.spring.pulsar.producer.send-timeout]]xref:#application-properties.integration.spring.pulsar.producer.send-timeout[`+spring.pulsar.producer.send-timeout+`]
|+++Time before a message has to be acknowledged by the broker.+++
|`+30s+`

|[[application-properties.integration.spring.pulsar.producer.topic-name]]xref:#application-properties.integration.spring.pulsar.producer.topic-name[`+spring.pulsar.producer.topic-name+`]
|+++Topic the producer will publish to.+++
|

|[[application-properties.integration.spring.pulsar.reader.name]]xref:#application-properties.integration.spring.pulsar.reader.name[`+spring.pulsar.reader.name+`]
|+++Reader name.+++
|

|[[application-properties.integration.spring.pulsar.reader.read-compacted]]xref:#application-properties.integration.spring.pulsar.reader.read-compacted[`+spring.pulsar.reader.read-compacted+`]
|+++Whether to read messages from a compacted topic rather than a full message backlog of a topic.+++
|`+false+`

|[[application-properties.integration.spring.pulsar.reader.subscription-name]]xref:#application-properties.integration.spring.pulsar.reader.subscription-name[`+spring.pulsar.reader.subscription-name+`]
|+++Subscription name.+++
|

|[[application-properties.integration.spring.pulsar.reader.subscription-role-prefix]]xref:#application-properties.integration.spring.pulsar.reader.subscription-role-prefix[`+spring.pulsar.reader.subscription-role-prefix+`]
|+++Prefix of subscription role.+++
|

|[[application-properties.integration.spring.pulsar.reader.topics]]xref:#application-properties.integration.spring.pulsar.reader.topics[`+spring.pulsar.reader.topics+`]
|+++Topics the reader subscribes to.+++
|

|[[application-properties.integration.spring.pulsar.template.observations-enabled]]xref:#application-properties.integration.spring.pulsar.template.observations-enabled[`+spring.pulsar.template.observations-enabled+`]
|+++Whether to record observations for when the Observations API is available.+++
|`+false+`

|[[application-properties.integration.spring.pulsar.transaction.enabled]]xref:#application-properties.integration.spring.pulsar.transaction.enabled[`+spring.pulsar.transaction.enabled+`]
|+++Whether transaction support is enabled.+++
|`+false+`

|[[application-properties.integration.spring.rabbitmq.address-shuffle-mode]]xref:#application-properties.integration.spring.rabbitmq.address-shuffle-mode[`+spring.rabbitmq.address-shuffle-mode+`]
|+++Mode used to shuffle configured addresses.+++
|`+none+`

|[[application-properties.integration.spring.rabbitmq.addresses]]xref:#application-properties.integration.spring.rabbitmq.addresses[`+spring.rabbitmq.addresses+`]
|+++Comma-separated list of addresses to which the client should connect. When set, the host and port are ignored.+++
|

|[[application-properties.integration.spring.rabbitmq.cache.channel.checkout-timeout]]xref:#application-properties.integration.spring.rabbitmq.cache.channel.checkout-timeout[`+spring.rabbitmq.cache.channel.checkout-timeout+`]
|+++Duration to wait to obtain a channel if the cache size has been reached. If 0, always create a new channel.+++
|

|[[application-properties.integration.spring.rabbitmq.cache.channel.size]]xref:#application-properties.integration.spring.rabbitmq.cache.channel.size[`+spring.rabbitmq.cache.channel.size+`]
|+++Number of channels to retain in the cache. When "check-timeout" > 0, max channels per connection.+++
|

|[[application-properties.integration.spring.rabbitmq.cache.connection.mode]]xref:#application-properties.integration.spring.rabbitmq.cache.connection.mode[`+spring.rabbitmq.cache.connection.mode+`]
|+++Connection factory cache mode.+++
|`+channel+`

|[[application-properties.integration.spring.rabbitmq.cache.connection.size]]xref:#application-properties.integration.spring.rabbitmq.cache.connection.size[`+spring.rabbitmq.cache.connection.size+`]
|+++Number of connections to cache. Only applies when mode is CONNECTION.+++
|

|[[application-properties.integration.spring.rabbitmq.channel-rpc-timeout]]xref:#application-properties.integration.spring.rabbitmq.channel-rpc-timeout[`+spring.rabbitmq.channel-rpc-timeout+`]
|+++Continuation timeout for RPC calls in channels. Set it to zero to wait forever.+++
|`+10m+`

|[[application-properties.integration.spring.rabbitmq.connection-timeout]]xref:#application-properties.integration.spring.rabbitmq.connection-timeout[`+spring.rabbitmq.connection-timeout+`]
|+++Connection timeout. Set it to zero to wait forever.+++
|

|[[application-properties.integration.spring.rabbitmq.dynamic]]xref:#application-properties.integration.spring.rabbitmq.dynamic[`+spring.rabbitmq.dynamic+`]
|+++Whether to create an AmqpAdmin bean.+++
|`+true+`

|[[application-properties.integration.spring.rabbitmq.host]]xref:#application-properties.integration.spring.rabbitmq.host[`+spring.rabbitmq.host+`]
|+++RabbitMQ host. Ignored if an address is set.+++
|`+localhost+`

|[[application-properties.integration.spring.rabbitmq.listener.direct.acknowledge-mode]]xref:#application-properties.integration.spring.rabbitmq.listener.direct.acknowledge-mode[`+spring.rabbitmq.listener.direct.acknowledge-mode+`]
|+++Acknowledge mode of container.+++
|

|[[application-properties.integration.spring.rabbitmq.listener.direct.auto-startup]]xref:#application-properties.integration.spring.rabbitmq.listener.direct.auto-startup[`+spring.rabbitmq.listener.direct.auto-startup+`]
|+++Whether to start the container automatically on startup.+++
|`+true+`

|[[application-properties.integration.spring.rabbitmq.listener.direct.consumers-per-queue]]xref:#application-properties.integration.spring.rabbitmq.listener.direct.consumers-per-queue[`+spring.rabbitmq.listener.direct.consumers-per-queue+`]
|+++Number of consumers per queue.+++
|

|[[application-properties.integration.spring.rabbitmq.listener.direct.de-batching-enabled]]xref:#application-properties.integration.spring.rabbitmq.listener.direct.de-batching-enabled[`+spring.rabbitmq.listener.direct.de-batching-enabled+`]
|+++Whether the container should present batched messages as discrete messages or call the listener with the batch.+++
|`+true+`

|[[application-properties.integration.spring.rabbitmq.listener.direct.default-requeue-rejected]]xref:#application-properties.integration.spring.rabbitmq.listener.direct.default-requeue-rejected[`+spring.rabbitmq.listener.direct.default-requeue-rejected+`]
|+++Whether rejected deliveries are re-queued by default.+++
|

|[[application-properties.integration.spring.rabbitmq.listener.direct.force-stop]]xref:#application-properties.integration.spring.rabbitmq.listener.direct.force-stop[`+spring.rabbitmq.listener.direct.force-stop+`]
|+++Whether the container (when stopped) should stop immediately after processing the current message or stop after processing all pre-fetched messages.+++
|`+false+`

|[[application-properties.integration.spring.rabbitmq.listener.direct.idle-event-interval]]xref:#application-properties.integration.spring.rabbitmq.listener.direct.idle-event-interval[`+spring.rabbitmq.listener.direct.idle-event-interval+`]
|+++How often idle container events should be published.+++
|

|[[application-properties.integration.spring.rabbitmq.listener.direct.missing-queues-fatal]]xref:#application-properties.integration.spring.rabbitmq.listener.direct.missing-queues-fatal[`+spring.rabbitmq.listener.direct.missing-queues-fatal+`]
|+++Whether to fail if the queues declared by the container are not available on the broker.+++
|`+false+`

|[[application-properties.integration.spring.rabbitmq.listener.direct.observation-enabled]]xref:#application-properties.integration.spring.rabbitmq.listener.direct.observation-enabled[`+spring.rabbitmq.listener.direct.observation-enabled+`]
|+++Whether to enable observation.+++
|`+false+`

|[[application-properties.integration.spring.rabbitmq.listener.direct.prefetch]]xref:#application-properties.integration.spring.rabbitmq.listener.direct.prefetch[`+spring.rabbitmq.listener.direct.prefetch+`]
|+++Maximum number of unacknowledged messages that can be outstanding at each consumer.+++
|

|[[application-properties.integration.spring.rabbitmq.listener.direct.retry.enabled]]xref:#application-properties.integration.spring.rabbitmq.listener.direct.retry.enabled[`+spring.rabbitmq.listener.direct.retry.enabled+`]
|+++Whether publishing retries are enabled.+++
|`+false+`

|[[application-properties.integration.spring.rabbitmq.listener.direct.retry.initial-interval]]xref:#application-properties.integration.spring.rabbitmq.listener.direct.retry.initial-interval[`+spring.rabbitmq.listener.direct.retry.initial-interval+`]
|+++Duration between the first and second attempt to deliver a message.+++
|`+1000ms+`

|[[application-properties.integration.spring.rabbitmq.listener.direct.retry.max-attempts]]xref:#application-properties.integration.spring.rabbitmq.listener.direct.retry.max-attempts[`+spring.rabbitmq.listener.direct.retry.max-attempts+`]
|+++Maximum number of attempts to deliver a message.+++
|`+3+`

|[[application-properties.integration.spring.rabbitmq.listener.direct.retry.max-interval]]xref:#application-properties.integration.spring.rabbitmq.listener.direct.retry.max-interval[`+spring.rabbitmq.listener.direct.retry.max-interval+`]
|+++Maximum duration between attempts.+++
|`+10000ms+`

|[[application-properties.integration.spring.rabbitmq.listener.direct.retry.multiplier]]xref:#application-properties.integration.spring.rabbitmq.listener.direct.retry.multiplier[`+spring.rabbitmq.listener.direct.retry.multiplier+`]
|+++Multiplier to apply to the previous retry interval.+++
|`+1+`

|[[application-properties.integration.spring.rabbitmq.listener.direct.retry.stateless]]xref:#application-properties.integration.spring.rabbitmq.listener.direct.retry.stateless[`+spring.rabbitmq.listener.direct.retry.stateless+`]
|+++Whether retries are stateless or stateful.+++
|`+true+`

|[[application-properties.integration.spring.rabbitmq.listener.simple.acknowledge-mode]]xref:#application-properties.integration.spring.rabbitmq.listener.simple.acknowledge-mode[`+spring.rabbitmq.listener.simple.acknowledge-mode+`]
|+++Acknowledge mode of container.+++
|

|[[application-properties.integration.spring.rabbitmq.listener.simple.auto-startup]]xref:#application-properties.integration.spring.rabbitmq.listener.simple.auto-startup[`+spring.rabbitmq.listener.simple.auto-startup+`]
|+++Whether to start the container automatically on startup.+++
|`+true+`

|[[application-properties.integration.spring.rabbitmq.listener.simple.batch-size]]xref:#application-properties.integration.spring.rabbitmq.listener.simple.batch-size[`+spring.rabbitmq.listener.simple.batch-size+`]
|+++Batch size, expressed as the number of physical messages, to be used by the container.+++
|

|[[application-properties.integration.spring.rabbitmq.listener.simple.concurrency]]xref:#application-properties.integration.spring.rabbitmq.listener.simple.concurrency[`+spring.rabbitmq.listener.simple.concurrency+`]
|+++Minimum number of listener invoker threads.+++
|

|[[application-properties.integration.spring.rabbitmq.listener.simple.consumer-batch-enabled]]xref:#application-properties.integration.spring.rabbitmq.listener.simple.consumer-batch-enabled[`+spring.rabbitmq.listener.simple.consumer-batch-enabled+`]
|+++Whether the container creates a batch of messages based on the 'receive-timeout' and 'batch-size'. Coerces 'de-batching-enabled' to true to include the contents of a producer created batch in the batch as discrete records.+++
|`+false+`

|[[application-properties.integration.spring.rabbitmq.listener.simple.de-batching-enabled]]xref:#application-properties.integration.spring.rabbitmq.listener.simple.de-batching-enabled[`+spring.rabbitmq.listener.simple.de-batching-enabled+`]
|+++Whether the container should present batched messages as discrete messages or call the listener with the batch.+++
|`+true+`

|[[application-properties.integration.spring.rabbitmq.listener.simple.default-requeue-rejected]]xref:#application-properties.integration.spring.rabbitmq.listener.simple.default-requeue-rejected[`+spring.rabbitmq.listener.simple.default-requeue-rejected+`]
|+++Whether rejected deliveries are re-queued by default.+++
|

|[[application-properties.integration.spring.rabbitmq.listener.simple.force-stop]]xref:#application-properties.integration.spring.rabbitmq.listener.simple.force-stop[`+spring.rabbitmq.listener.simple.force-stop+`]
|+++Whether the container (when stopped) should stop immediately after processing the current message or stop after processing all pre-fetched messages.+++
|`+false+`

|[[application-properties.integration.spring.rabbitmq.listener.simple.idle-event-interval]]xref:#application-properties.integration.spring.rabbitmq.listener.simple.idle-event-interval[`+spring.rabbitmq.listener.simple.idle-event-interval+`]
|+++How often idle container events should be published.+++
|

|[[application-properties.integration.spring.rabbitmq.listener.simple.max-concurrency]]xref:#application-properties.integration.spring.rabbitmq.listener.simple.max-concurrency[`+spring.rabbitmq.listener.simple.max-concurrency+`]
|+++Maximum number of listener invoker threads.+++
|

|[[application-properties.integration.spring.rabbitmq.listener.simple.missing-queues-fatal]]xref:#application-properties.integration.spring.rabbitmq.listener.simple.missing-queues-fatal[`+spring.rabbitmq.listener.simple.missing-queues-fatal+`]
|+++Whether to fail if the queues declared by the container are not available on the broker and/or whether to stop the container if one or more queues are deleted at runtime.+++
|`+true+`

|[[application-properties.integration.spring.rabbitmq.listener.simple.observation-enabled]]xref:#application-properties.integration.spring.rabbitmq.listener.simple.observation-enabled[`+spring.rabbitmq.listener.simple.observation-enabled+`]
|+++Whether to enable observation.+++
|`+false+`

|[[application-properties.integration.spring.rabbitmq.listener.simple.prefetch]]xref:#application-properties.integration.spring.rabbitmq.listener.simple.prefetch[`+spring.rabbitmq.listener.simple.prefetch+`]
|+++Maximum number of unacknowledged messages that can be outstanding at each consumer.+++
|

|[[application-properties.integration.spring.rabbitmq.listener.simple.retry.enabled]]xref:#application-properties.integration.spring.rabbitmq.listener.simple.retry.enabled[`+spring.rabbitmq.listener.simple.retry.enabled+`]
|+++Whether publishing retries are enabled.+++
|`+false+`

|[[application-properties.integration.spring.rabbitmq.listener.simple.retry.initial-interval]]xref:#application-properties.integration.spring.rabbitmq.listener.simple.retry.initial-interval[`+spring.rabbitmq.listener.simple.retry.initial-interval+`]
|+++Duration between the first and second attempt to deliver a message.+++
|`+1000ms+`

|[[application-properties.integration.spring.rabbitmq.listener.simple.retry.max-attempts]]xref:#application-properties.integration.spring.rabbitmq.listener.simple.retry.max-attempts[`+spring.rabbitmq.listener.simple.retry.max-attempts+`]
|+++Maximum number of attempts to deliver a message.+++
|`+3+`

|[[application-properties.integration.spring.rabbitmq.listener.simple.retry.max-interval]]xref:#application-properties.integration.spring.rabbitmq.listener.simple.retry.max-interval[`+spring.rabbitmq.listener.simple.retry.max-interval+`]
|+++Maximum duration between attempts.+++
|`+10000ms+`

|[[application-properties.integration.spring.rabbitmq.listener.simple.retry.multiplier]]xref:#application-properties.integration.spring.rabbitmq.listener.simple.retry.multiplier[`+spring.rabbitmq.listener.simple.retry.multiplier+`]
|+++Multiplier to apply to the previous retry interval.+++
|`+1+`

|[[application-properties.integration.spring.rabbitmq.listener.simple.retry.stateless]]xref:#application-properties.integration.spring.rabbitmq.listener.simple.retry.stateless[`+spring.rabbitmq.listener.simple.retry.stateless+`]
|+++Whether retries are stateless or stateful.+++
|`+true+`

|[[application-properties.integration.spring.rabbitmq.listener.stream.native-listener]]xref:#application-properties.integration.spring.rabbitmq.listener.stream.native-listener[`+spring.rabbitmq.listener.stream.native-listener+`]
|+++Whether the container will support listeners that consume native stream messages instead of Spring AMQP messages.+++
|`+false+`

|[[application-properties.integration.spring.rabbitmq.listener.stream.observation-enabled]]xref:#application-properties.integration.spring.rabbitmq.listener.stream.observation-enabled[`+spring.rabbitmq.listener.stream.observation-enabled+`]
|+++Whether to enable observation.+++
|`+false+`

|[[application-properties.integration.spring.rabbitmq.listener.type]]xref:#application-properties.integration.spring.rabbitmq.listener.type[`+spring.rabbitmq.listener.type+`]
|+++Listener container type.+++
|`+simple+`

|[[application-properties.integration.spring.rabbitmq.max-inbound-message-body-size]]xref:#application-properties.integration.spring.rabbitmq.max-inbound-message-body-size[`+spring.rabbitmq.max-inbound-message-body-size+`]
|+++Maximum size of the body of inbound (received) messages.+++
|`+64MB+`

|[[application-properties.integration.spring.rabbitmq.password]]xref:#application-properties.integration.spring.rabbitmq.password[`+spring.rabbitmq.password+`]
|+++Login to authenticate against the broker.+++
|`+guest+`

|[[application-properties.integration.spring.rabbitmq.port]]xref:#application-properties.integration.spring.rabbitmq.port[`+spring.rabbitmq.port+`]
|+++RabbitMQ port. Ignored if an address is set. Default to 5672, or 5671 if SSL is enabled.+++
|

|[[application-properties.integration.spring.rabbitmq.publisher-confirm-type]]xref:#application-properties.integration.spring.rabbitmq.publisher-confirm-type[`+spring.rabbitmq.publisher-confirm-type+`]
|+++Type of publisher confirms to use.+++
|

|[[application-properties.integration.spring.rabbitmq.publisher-returns]]xref:#application-properties.integration.spring.rabbitmq.publisher-returns[`+spring.rabbitmq.publisher-returns+`]
|+++Whether to enable publisher returns.+++
|`+false+`

|[[application-properties.integration.spring.rabbitmq.requested-channel-max]]xref:#application-properties.integration.spring.rabbitmq.requested-channel-max[`+spring.rabbitmq.requested-channel-max+`]
|+++Number of channels per connection requested by the client. Use 0 for unlimited.+++
|`+2047+`

|[[application-properties.integration.spring.rabbitmq.requested-heartbeat]]xref:#application-properties.integration.spring.rabbitmq.requested-heartbeat[`+spring.rabbitmq.requested-heartbeat+`]
|+++Requested heartbeat timeout; zero for none. If a duration suffix is not specified, seconds will be used.+++
|

|[[application-properties.integration.spring.rabbitmq.ssl.algorithm]]xref:#application-properties.integration.spring.rabbitmq.ssl.algorithm[`+spring.rabbitmq.ssl.algorithm+`]
|+++SSL algorithm to use. By default, configured by the Rabbit client library.+++
|

|[[application-properties.integration.spring.rabbitmq.ssl.bundle]]xref:#application-properties.integration.spring.rabbitmq.ssl.bundle[`+spring.rabbitmq.ssl.bundle+`]
|+++SSL bundle name.+++
|

|[[application-properties.integration.spring.rabbitmq.ssl.enabled]]xref:#application-properties.integration.spring.rabbitmq.ssl.enabled[`+spring.rabbitmq.ssl.enabled+`]
|+++Whether to enable SSL support. Determined automatically if an address is provided with the protocol (amqp:// vs. amqps://).+++
|

|[[application-properties.integration.spring.rabbitmq.ssl.key-store]]xref:#application-properties.integration.spring.rabbitmq.ssl.key-store[`+spring.rabbitmq.ssl.key-store+`]
|+++Path to the key store that holds the SSL certificate.+++
|

|[[application-properties.integration.spring.rabbitmq.ssl.key-store-algorithm]]xref:#application-properties.integration.spring.rabbitmq.ssl.key-store-algorithm[`+spring.rabbitmq.ssl.key-store-algorithm+`]
|+++Key store algorithm.+++
|`+SunX509+`

|[[application-properties.integration.spring.rabbitmq.ssl.key-store-password]]xref:#application-properties.integration.spring.rabbitmq.ssl.key-store-password[`+spring.rabbitmq.ssl.key-store-password+`]
|+++Password used to access the key store.+++
|

|[[application-properties.integration.spring.rabbitmq.ssl.key-store-type]]xref:#application-properties.integration.spring.rabbitmq.ssl.key-store-type[`+spring.rabbitmq.ssl.key-store-type+`]
|+++Key store type.+++
|`+PKCS12+`

|[[application-properties.integration.spring.rabbitmq.ssl.trust-store]]xref:#application-properties.integration.spring.rabbitmq.ssl.trust-store[`+spring.rabbitmq.ssl.trust-store+`]
|+++Trust store that holds SSL certificates.+++
|

|[[application-properties.integration.spring.rabbitmq.ssl.trust-store-algorithm]]xref:#application-properties.integration.spring.rabbitmq.ssl.trust-store-algorithm[`+spring.rabbitmq.ssl.trust-store-algorithm+`]
|+++Trust store algorithm.+++
|`+SunX509+`

|[[application-properties.integration.spring.rabbitmq.ssl.trust-store-password]]xref:#application-properties.integration.spring.rabbitmq.ssl.trust-store-password[`+spring.rabbitmq.ssl.trust-store-password+`]
|+++Password used to access the trust store.+++
|

|[[application-properties.integration.spring.rabbitmq.ssl.trust-store-type]]xref:#application-properties.integration.spring.rabbitmq.ssl.trust-store-type[`+spring.rabbitmq.ssl.trust-store-type+`]
|+++Trust store type.+++
|`+JKS+`

|[[application-properties.integration.spring.rabbitmq.ssl.validate-server-certificate]]xref:#application-properties.integration.spring.rabbitmq.ssl.validate-server-certificate[`+spring.rabbitmq.ssl.validate-server-certificate+`]
|+++Whether to enable server side certificate validation.+++
|`+true+`

|[[application-properties.integration.spring.rabbitmq.ssl.verify-hostname]]xref:#application-properties.integration.spring.rabbitmq.ssl.verify-hostname[`+spring.rabbitmq.ssl.verify-hostname+`]
|+++Whether to enable hostname verification.+++
|`+true+`

|[[application-properties.integration.spring.rabbitmq.stream.host]]xref:#application-properties.integration.spring.rabbitmq.stream.host[`+spring.rabbitmq.stream.host+`]
|+++Host of a RabbitMQ instance with the Stream plugin enabled.+++
|`+localhost+`

|[[application-properties.integration.spring.rabbitmq.stream.name]]xref:#application-properties.integration.spring.rabbitmq.stream.name[`+spring.rabbitmq.stream.name+`]
|+++Name of the stream.+++
|

|[[application-properties.integration.spring.rabbitmq.stream.password]]xref:#application-properties.integration.spring.rabbitmq.stream.password[`+spring.rabbitmq.stream.password+`]
|+++Login password to authenticate to the broker. When not set spring.rabbitmq.password is used.+++
|

|[[application-properties.integration.spring.rabbitmq.stream.port]]xref:#application-properties.integration.spring.rabbitmq.stream.port[`+spring.rabbitmq.stream.port+`]
|+++Stream port of a RabbitMQ instance with the Stream plugin enabled.+++
|

|[[application-properties.integration.spring.rabbitmq.stream.username]]xref:#application-properties.integration.spring.rabbitmq.stream.username[`+spring.rabbitmq.stream.username+`]
|+++Login user to authenticate to the broker. When not set, spring.rabbitmq.username is used.+++
|

|[[application-properties.integration.spring.rabbitmq.stream.virtual-host]]xref:#application-properties.integration.spring.rabbitmq.stream.virtual-host[`+spring.rabbitmq.stream.virtual-host+`]
|+++Virtual host of a RabbitMQ instance with the Stream plugin enabled. When not set, spring.rabbitmq.virtual-host is used.+++
|

|[[application-properties.integration.spring.rabbitmq.template.allowed-list-patterns]]xref:#application-properties.integration.spring.rabbitmq.template.allowed-list-patterns[`+spring.rabbitmq.template.allowed-list-patterns+`]
|+++Simple patterns for allowable packages/classes for deserialization.+++
|

|[[application-properties.integration.spring.rabbitmq.template.default-receive-queue]]xref:#application-properties.integration.spring.rabbitmq.template.default-receive-queue[`+spring.rabbitmq.template.default-receive-queue+`]
|+++Name of the default queue to receive messages from when none is specified explicitly.+++
|

|[[application-properties.integration.spring.rabbitmq.template.exchange]]xref:#application-properties.integration.spring.rabbitmq.template.exchange[`+spring.rabbitmq.template.exchange+`]
|+++Name of the default exchange to use for send operations.+++
|

|[[application-properties.integration.spring.rabbitmq.template.mandatory]]xref:#application-properties.integration.spring.rabbitmq.template.mandatory[`+spring.rabbitmq.template.mandatory+`]
|+++Whether to enable mandatory messages.+++
|

|[[application-properties.integration.spring.rabbitmq.template.observation-enabled]]xref:#application-properties.integration.spring.rabbitmq.template.observation-enabled[`+spring.rabbitmq.template.observation-enabled+`]
|+++Whether to enable observation.+++
|`+false+`

|[[application-properties.integration.spring.rabbitmq.template.receive-timeout]]xref:#application-properties.integration.spring.rabbitmq.template.receive-timeout[`+spring.rabbitmq.template.receive-timeout+`]
|+++Timeout for receive() operations.+++
|

|[[application-properties.integration.spring.rabbitmq.template.reply-timeout]]xref:#application-properties.integration.spring.rabbitmq.template.reply-timeout[`+spring.rabbitmq.template.reply-timeout+`]
|+++Timeout for sendAndReceive() operations.+++
|

|[[application-properties.integration.spring.rabbitmq.template.retry.enabled]]xref:#application-properties.integration.spring.rabbitmq.template.retry.enabled[`+spring.rabbitmq.template.retry.enabled+`]
|+++Whether publishing retries are enabled.+++
|`+false+`

|[[application-properties.integration.spring.rabbitmq.template.retry.initial-interval]]xref:#application-properties.integration.spring.rabbitmq.template.retry.initial-interval[`+spring.rabbitmq.template.retry.initial-interval+`]
|+++Duration between the first and second attempt to deliver a message.+++
|`+1000ms+`

|[[application-properties.integration.spring.rabbitmq.template.retry.max-attempts]]xref:#application-properties.integration.spring.rabbitmq.template.retry.max-attempts[`+spring.rabbitmq.template.retry.max-attempts+`]
|+++Maximum number of attempts to deliver a message.+++
|`+3+`

|[[application-properties.integration.spring.rabbitmq.template.retry.max-interval]]xref:#application-properties.integration.spring.rabbitmq.template.retry.max-interval[`+spring.rabbitmq.template.retry.max-interval+`]
|+++Maximum duration between attempts.+++
|`+10000ms+`

|[[application-properties.integration.spring.rabbitmq.template.retry.multiplier]]xref:#application-properties.integration.spring.rabbitmq.template.retry.multiplier[`+spring.rabbitmq.template.retry.multiplier+`]
|+++Multiplier to apply to the previous retry interval.+++
|`+1+`

|[[application-properties.integration.spring.rabbitmq.template.routing-key]]xref:#application-properties.integration.spring.rabbitmq.template.routing-key[`+spring.rabbitmq.template.routing-key+`]
|+++Value of a default routing key to use for send operations.+++
|

|[[application-properties.integration.spring.rabbitmq.username]]xref:#application-properties.integration.spring.rabbitmq.username[`+spring.rabbitmq.username+`]
|+++Login user to authenticate to the broker.+++
|`+guest+`

|[[application-properties.integration.spring.rabbitmq.virtual-host]]xref:#application-properties.integration.spring.rabbitmq.virtual-host[`+spring.rabbitmq.virtual-host+`]
|+++Virtual host to use when connecting to the broker.+++
|

|[[application-properties.integration.spring.webservices.path]]xref:#application-properties.integration.spring.webservices.path[`+spring.webservices.path+`]
|+++Path that serves as the base URI for the services.+++
|`+/services+`

|[[application-properties.integration.spring.webservices.servlet.init]]xref:#application-properties.integration.spring.webservices.servlet.init[`+spring.webservices.servlet.init.*+`]
|+++Servlet init parameters to pass to Spring Web Services.+++
|

|[[application-properties.integration.spring.webservices.servlet.load-on-startup]]xref:#application-properties.integration.spring.webservices.servlet.load-on-startup[`+spring.webservices.servlet.load-on-startup+`]
|+++Load on startup priority of the Spring Web Services servlet.+++
|`+-1+`

|[[application-properties.integration.spring.webservices.wsdl-locations]]xref:#application-properties.integration.spring.webservices.wsdl-locations[`+spring.webservices.wsdl-locations+`]
|+++Comma-separated list of locations of WSDLs and accompanying XSDs to be exposed as beans.+++
|

|===