|
|
|
|
@@ -1,387 +0,0 @@
|
|
|
|
|
[[twitter]]
|
|
|
|
|
== Twitter Support
|
|
|
|
|
|
|
|
|
|
Spring Integration provides support for interacting with Twitter.
|
|
|
|
|
With the Twitter adapters, you can both receive and send Twitter messages.
|
|
|
|
|
You can also perform a Twitter search based on a schedule and publish the search results within messages.
|
|
|
|
|
Since version 4.0, a search outbound gateway is provided to perform dynamic searches.
|
|
|
|
|
|
|
|
|
|
Twitter is a social networking and micro-blogging service that enables its users to send and read messages known as tweets.
|
|
|
|
|
Tweets are text-based posts of up to 280 characters (up from 140 in 2018) displayed on the author's profile page and delivered to the author's subscribers, who are known as followers.
|
|
|
|
|
|
|
|
|
|
IMPORTANT: Versions of Spring Integration prior to 2.1 were dependent upon the http://twitter4j.org[Twitter4J API].
|
|
|
|
|
However, with the release of http://projects.spring.io/spring-social[Spring Social 1.0 GA], Spring Integration (as of version 2.1) now builds directly upon Spring Social's Twitter support, instead of Twitter4J.
|
|
|
|
|
All Twitter endpoints require the configuration of a `TwitterTemplate`, because even search operations require an authenticated template.
|
|
|
|
|
|
|
|
|
|
Spring Integration provides a convenient namespace configuration to define Twitter artifacts.
|
|
|
|
|
You can enable it by adding the following within your XML header:
|
|
|
|
|
|
|
|
|
|
====
|
|
|
|
|
[source,xml]
|
|
|
|
|
----
|
|
|
|
|
xmlns:int-twitter="http://www.springframework.org/schema/integration/twitter"
|
|
|
|
|
xsi:schemaLocation="http://www.springframework.org/schema/integration/twitter
|
|
|
|
|
http://www.springframework.org/schema/integration/twitter/spring-integration-twitter.xsd"
|
|
|
|
|
----
|
|
|
|
|
====
|
|
|
|
|
|
|
|
|
|
[[twitter-oauth]]
|
|
|
|
|
=== Twitter OAuth Configuration
|
|
|
|
|
|
|
|
|
|
For authenticated operations, Twitter uses OAuth, an authentication protocol that lets users approve an application to act on their behalf without sharing their password.
|
|
|
|
|
More information can be found at http://oauth.net[http://oauth.net] or in http://hueniverse.com/oauth[this article] from Hueniverse.
|
|
|
|
|
See the http://dev.twitter.com/pages/oauth_faq[OAuth FAQ] for more information about OAuth and Twitter.
|
|
|
|
|
|
|
|
|
|
In order to use OAuth authentication and authorization with Twitter, you must create a new application on the Twitter Developers site.
|
|
|
|
|
The following directions describe how to create a new application and obtain consumer keys and an access token:
|
|
|
|
|
|
|
|
|
|
. Go to http://dev.twitter.com[http://dev.twitter.com].
|
|
|
|
|
|
|
|
|
|
. Click on the `Register an app` link and fill out all required fields on the form provided.
|
|
|
|
|
Set `Application Type` to `Client` and, depending on the nature of your application, set `Default Access Type` to `Read & Write` or `Read-only`.
|
|
|
|
|
Submit the form.
|
|
|
|
|
If everything is successful, you see the `Consumer Key` and `Consumer Secret`.
|
|
|
|
|
Copy both values in a safe place.
|
|
|
|
|
|
|
|
|
|
. On the same page, you should see a `My Access Token` button on the side bar (right).
|
|
|
|
|
Click on it and you should see two more values: `Access Token` and `Access Token Secret`.
|
|
|
|
|
Copy these values in a safe place as well.
|
|
|
|
|
|
|
|
|
|
=== Twitter Template
|
|
|
|
|
|
|
|
|
|
As <<twitter,mentioned earlier>>, Spring Integration relies upon Spring Social.
|
|
|
|
|
That library provides an implementation of the template pattern( `o.s.social.twitter.api.impl.TwitterTemplate`) to let you interact with Twitter.
|
|
|
|
|
For anonymous operations (such as search), you need not explicitly define an instance of `TwitterTemplate`, since a default instance is created and injected into the endpoint.
|
|
|
|
|
However, for authenticated operations (update status, send direct message, asd others), you must configure a `TwitterTemplate` as a bean and inject it explicitly into the endpoint, because the authentication configuration is required.
|
|
|
|
|
The following example configures a TwitterTemplate:
|
|
|
|
|
|
|
|
|
|
====
|
|
|
|
|
[source,xml]
|
|
|
|
|
----
|
|
|
|
|
<bean id="twitterTemplate" class="o.s.social.twitter.api.impl.TwitterTemplate">
|
|
|
|
|
<constructor-arg value="4XzBPacJQxyBzzzH"/>
|
|
|
|
|
<constructor-arg value="AbRxUAvyCtqQtvxFK8w5ZMtMj20KFhB6o"/>
|
|
|
|
|
<constructor-arg value="21691649-4YZY5iJEOfz2A9qCFd9SjBRGb3HLmIm4HNE"/>
|
|
|
|
|
<constructor-arg value="AbRxUAvyNCtqQtxFK8w5ZMtMj20KFhB6o"/>
|
|
|
|
|
</bean>
|
|
|
|
|
----
|
|
|
|
|
====
|
|
|
|
|
|
|
|
|
|
NOTE: The values above are not real.
|
|
|
|
|
|
|
|
|
|
As the preceding configuration shows, all you need to do is to provide OAuth `attributes` as constructor arguments.
|
|
|
|
|
The values should be those you obtained in the previous step.
|
|
|
|
|
The order of constructor arguments is:
|
|
|
|
|
. `consumerKey`
|
|
|
|
|
. `consumerSecret`
|
|
|
|
|
. `accessToken`
|
|
|
|
|
. `accessTokenSecret`.
|
|
|
|
|
|
|
|
|
|
A more practical way to manage OAuth connection attributes is to use Spring's property placeholder support by creating a property file (for example, oauth.properties), as the following example shows:
|
|
|
|
|
|
|
|
|
|
====
|
|
|
|
|
[source,java]
|
|
|
|
|
----
|
|
|
|
|
twitter.oauth.consumerKey=4XzBPacJQxyBzzzH
|
|
|
|
|
twitter.oauth.consumerSecret=AbRxUAvyCtqQtvxFK8w5ZMtMj20KFhB6o
|
|
|
|
|
twitter.oauth.accessToken=21691649-4YZY5iJEOfz2A9qCFd9SjBRGb3HLmIm4HNE
|
|
|
|
|
twitter.oauth.accessTokenSecret=AbRxUAvyNCtqQtxFK8w5ZMtMj20KFhB6o
|
|
|
|
|
----
|
|
|
|
|
====
|
|
|
|
|
|
|
|
|
|
Then you can configure a `property-placeholder` to point to the above property file, as the following example shows:
|
|
|
|
|
|
|
|
|
|
====
|
|
|
|
|
[source,xml]
|
|
|
|
|
----
|
|
|
|
|
<context:property-placeholder location="classpath:oauth.properties"/>
|
|
|
|
|
|
|
|
|
|
<bean id="twitterTemplate" class="o.s.social.twitter.api.impl.TwitterTemplate">
|
|
|
|
|
<constructor-arg value="${twitter.oauth.consumerKey}"/>
|
|
|
|
|
<constructor-arg value="${twitter.oauth.consumerSecret}"/>
|
|
|
|
|
<constructor-arg value="${twitter.oauth.accessToken}"/>
|
|
|
|
|
<constructor-arg value="${twitter.oauth.accessTokenSecret}"/>
|
|
|
|
|
</bean>
|
|
|
|
|
----
|
|
|
|
|
====
|
|
|
|
|
|
|
|
|
|
[[twitter-inbound]]
|
|
|
|
|
=== Twitter Inbound Adapters
|
|
|
|
|
|
|
|
|
|
Twitter inbound adapters let you receive Twitter Messages.
|
|
|
|
|
There are several types of http://support.twitter.com/articles/119138-types-of-tweets-and-where-they-appear[twitter messages, or tweets].
|
|
|
|
|
|
|
|
|
|
As of version 2.0, Spring Integration provides support for receiving tweets as timeline updates, direct messages, and mention messages (as well as search results).
|
|
|
|
|
|
|
|
|
|
[IMPORTANT]
|
|
|
|
|
=====
|
|
|
|
|
Every inbound Twitter channel adapter is a polling consumer, which means you have to provide a poller configuration.
|
|
|
|
|
Twitter uses a concept called https://dev.twitter.com/docs/rate-limiting/1.1[Rate Limiting].
|
|
|
|
|
In a nutshell, Twitter uses rate limiting to manage how often an application can poll for updates.
|
|
|
|
|
You should consider this when setting your poller intervals so that the adapter polls in compliance with Twitter policies.
|
|
|
|
|
|
|
|
|
|
With Spring Integration prior to version 3.0, a hard-coded limit within the adapters was used to ensure the polling interval could not be less than 15 seconds.
|
|
|
|
|
This is no longer the case, and the poller configuration is applied directly.
|
|
|
|
|
=====
|
|
|
|
|
|
|
|
|
|
Another issue that you need to consider is handling duplicate Tweets.
|
|
|
|
|
The same adapter (for example, search or timeline update), while polling on Twitter, may receive the same values more than once.
|
|
|
|
|
For example, if you keep searching on Twitter with the same search criteria, you end up with the same set of tweets unless some new tweet that matches your search criteria was posted in between your searches.
|
|
|
|
|
In that situation, you get all the tweets you had before plus the new one.
|
|
|
|
|
However, you really want only the new tweet.
|
|
|
|
|
Spring Integration provides an elegant mechanism for handling these situations.
|
|
|
|
|
The latest Tweet ID (the last retrieved tweet in this case) is stored in an instance of the `org.springframework.integration.metadata.MetadataStore` strategy .
|
|
|
|
|
For more information, see "`<<metadata-store>>`".
|
|
|
|
|
|
|
|
|
|
NOTE: The key used to persist the latest Twitter ID is the value of the (required) `id` attribute of the Twitter inbound channel adapter component plus the `profileId` of the Twitter user.
|
|
|
|
|
|
|
|
|
|
Prior to version 4.0, the page size was hard-coded to 20.
|
|
|
|
|
You can now configure it by using the `page-size` attribute (which defaults to 20).
|
|
|
|
|
|
|
|
|
|
[[inbound-twitter-update]]
|
|
|
|
|
==== Inbound Message Channel Adapter
|
|
|
|
|
|
|
|
|
|
This adapter lets you receive updates from everyone you follow.
|
|
|
|
|
It is essentially the "`timeline update`" adapter.
|
|
|
|
|
The following example configures a Twitter inbound channel adapter to poll for at most three messages every five seconds:
|
|
|
|
|
|
|
|
|
|
====
|
|
|
|
|
[source,xml]
|
|
|
|
|
----
|
|
|
|
|
<int-twitter:inbound-channel-adapter
|
|
|
|
|
twitter-template="twitterTemplate"
|
|
|
|
|
channel="inChannel">
|
|
|
|
|
<int:poller fixed-rate="5000" max-messages-per-poll="3"/>
|
|
|
|
|
</int-twitter:inbound-channel-adapter>
|
|
|
|
|
----
|
|
|
|
|
====
|
|
|
|
|
|
|
|
|
|
[[inbound-twitter-direct]]
|
|
|
|
|
==== Direct Inbound Message Channel Adapter
|
|
|
|
|
|
|
|
|
|
This adapter lets you receive direct messages that were sent to you from other Twitter users.
|
|
|
|
|
The following example configures a Twitter direct message inbound channel adapter to poll for at most three direct messages every five seconds:
|
|
|
|
|
|
|
|
|
|
====
|
|
|
|
|
[source,xml]
|
|
|
|
|
----
|
|
|
|
|
<int-twitter:dm-inbound-channel-adapter
|
|
|
|
|
twitter-template="twiterTemplate"
|
|
|
|
|
channel="inboundDmChannel">
|
|
|
|
|
<int-poller fixed-rate="5000" max-messages-per-poll="3"/>
|
|
|
|
|
</int-twitter:dm-inbound-channel-adapter>
|
|
|
|
|
----
|
|
|
|
|
====
|
|
|
|
|
|
|
|
|
|
[[inbound-twitter-mention]]
|
|
|
|
|
==== Mentions Inbound Message Channel Adapter
|
|
|
|
|
|
|
|
|
|
This adapter lets you receive Twitter messages that mention you when someone uses the `@user` syntax.
|
|
|
|
|
The following example configures a Twitter mention inbound channel adapter to poll for at most three mentions every five seconds:
|
|
|
|
|
|
|
|
|
|
====
|
|
|
|
|
[source,xml]
|
|
|
|
|
----
|
|
|
|
|
<int-twitter:mentions-inbound-channel-adapter
|
|
|
|
|
twitter-template="twiterTemplate"
|
|
|
|
|
channel="inboundMentionsChannel">
|
|
|
|
|
<int:poller fixed-rate="5000" max-messages-per-poll="3"/>
|
|
|
|
|
</int-twitter:mentions-inbound-channel-adapter>
|
|
|
|
|
----
|
|
|
|
|
====
|
|
|
|
|
|
|
|
|
|
[[inbound-twitter-search]]
|
|
|
|
|
==== Search Inbound Message Channel Adapter
|
|
|
|
|
|
|
|
|
|
This adapter lets you perform searches.
|
|
|
|
|
You need not define a `twitter-template`, because you can search anonymously.
|
|
|
|
|
However you must define a search query.
|
|
|
|
|
The following example configures a Twitter search inbound channel adapter that searchs for the `#springintegration` hashtag and returns at most three results every five seconds:
|
|
|
|
|
|
|
|
|
|
====
|
|
|
|
|
[source,xml]
|
|
|
|
|
----
|
|
|
|
|
<int-twitter:search-inbound-channel-adapter
|
|
|
|
|
query="#springintegration"
|
|
|
|
|
channel="inboundMentionsChannel">
|
|
|
|
|
<int:poller fixed-rate="5000" max-messages-per-poll="3"/>
|
|
|
|
|
</int-twitter:search-inbound-channel-adapter>
|
|
|
|
|
----
|
|
|
|
|
====
|
|
|
|
|
|
|
|
|
|
See https://dev.twitter.com/docs/using-search to learn more about Twitter queries.
|
|
|
|
|
|
|
|
|
|
The configuration of all of these adapters is similar to other inbound adapters, with one exception: Some may need to have the `twitter-template` injected.
|
|
|
|
|
Once received, each Twitter message is encapsulated in a Spring Integration `Message` and sent to the channel specified by the `channel` attribute.
|
|
|
|
|
|
|
|
|
|
NOTE: Currently, the payload type of any Twitter `Message` is `org.springframework.integration.twitter.core.Tweet`, which is very similar to the object with the same name in Spring Social.
|
|
|
|
|
As we migrate to Spring Social, we plan to depend on its API.
|
|
|
|
|
Some of the artifacts that we currently use are about to be obsolete.
|
|
|
|
|
However, we have already made sure that the impact of such migration is minimal, by aligning our API with the current state (at the time of this writing) of Spring Social.
|
|
|
|
|
|
|
|
|
|
To get the text from the `org.springframework.social.twitter.api.Tweet`, invoke the `getText()` method.
|
|
|
|
|
|
|
|
|
|
[[twitter-outbound]]
|
|
|
|
|
=== Twitter Outbound Adapter
|
|
|
|
|
|
|
|
|
|
Twitter outbound channel adapters let you send Twitter Messages (called tweets).
|
|
|
|
|
|
|
|
|
|
As of version 2.0, Spring Integration supports sending status update messages and direct messages.
|
|
|
|
|
Twitter outbound channel adapters take the `Message` payload and send it as a Twitter message.
|
|
|
|
|
Currently, the only supported payload type is `String`, so you should consider adding a transformer if the payload of the incoming message is not a `String`.
|
|
|
|
|
|
|
|
|
|
[[outbound-twitter-update]]
|
|
|
|
|
==== Twitter Outbound Update Channel Adapter
|
|
|
|
|
|
|
|
|
|
This adapter lets you send regular status updates by sending a `Message` to the channel identified by the `channel` attribute.
|
|
|
|
|
The following example configures a basic Twitter outbound channel adapter:
|
|
|
|
|
|
|
|
|
|
====
|
|
|
|
|
[source,xml]
|
|
|
|
|
----
|
|
|
|
|
<int-twitter:outbound-channel-adapter
|
|
|
|
|
twitter-template="twitterTemplate"
|
|
|
|
|
channel="twitterChannel"/>
|
|
|
|
|
----
|
|
|
|
|
====
|
|
|
|
|
|
|
|
|
|
The only extra configuration adapter requires is the `twitter-template` reference.
|
|
|
|
|
|
|
|
|
|
Starting with version 4.0, the `<int-twitter:outbound-channel-adapter>` element supports a `tweet-data-expression` attribute to populate the `TweetData` argument (see http://projects.spring.io/spring-social-twitter/[Spring Social Twitter]) by using the message as the root object of the expression evaluation context.
|
|
|
|
|
The result can be one of the following:
|
|
|
|
|
|
|
|
|
|
* A `String`, which is used for the `TweetData` message
|
|
|
|
|
* A `Tweet` object, the `text` of which is used for the `TweetData` message
|
|
|
|
|
* An entire `TweetData` object.
|
|
|
|
|
|
|
|
|
|
For convenience, the `TweetData` object can be built from the expression directly without needing a fully qualified class name, as the following example shows:
|
|
|
|
|
|
|
|
|
|
====
|
|
|
|
|
[source,xml]
|
|
|
|
|
----
|
|
|
|
|
<int-twitter:outbound-channel-adapter
|
|
|
|
|
twitter-template="twitterTemplate"
|
|
|
|
|
channel="twitterChannel"
|
|
|
|
|
tweet-data-expression="new TweetData(payload).withMedia(headers.media).displayCoordinates(true)/>
|
|
|
|
|
----
|
|
|
|
|
====
|
|
|
|
|
|
|
|
|
|
This allows, among other things, attaching an image to the tweet.
|
|
|
|
|
|
|
|
|
|
[[outbound-twitter-direct]]
|
|
|
|
|
==== Twitter Outbound Direct Message Channel Adapter
|
|
|
|
|
|
|
|
|
|
This adapter lets you send Twitter direct messages (in other words, `@user`) by simply sending a `Message` to the channel identified by the `channel` attribute.
|
|
|
|
|
The following example configures a basic Twitter outbound direct message channel adapter:
|
|
|
|
|
|
|
|
|
|
====
|
|
|
|
|
[source,xml]
|
|
|
|
|
----
|
|
|
|
|
<int-twitter:dm-outbound-channel-adapter
|
|
|
|
|
twitter-template="twitterTemplate"
|
|
|
|
|
channel="twitterChannel"/>
|
|
|
|
|
----
|
|
|
|
|
====
|
|
|
|
|
|
|
|
|
|
The only extra configuration this adapter requires is the `twitter-template` reference.
|
|
|
|
|
|
|
|
|
|
When it comes to Twitter direct messages, you must specify to whom you are sending the message (that is, the target user ID).
|
|
|
|
|
The Twitter outbound direct message channel adapter looks for a target user ID in the message headers under the name of `twitter_dmTargetUserId`, which is also identified by the following constant: `TwitterHeaders.DM_TARGET_USER_ID`.
|
|
|
|
|
So, when creating a `Message`, you need only add a value for that header, as the following example shows:
|
|
|
|
|
|
|
|
|
|
====
|
|
|
|
|
[source,java]
|
|
|
|
|
----
|
|
|
|
|
Message message = MessageBuilder.withPayload("hello")
|
|
|
|
|
.setHeader(TwitterHeaders.DM_TARGET_USER_ID, "z_oleg").build();
|
|
|
|
|
----
|
|
|
|
|
====
|
|
|
|
|
|
|
|
|
|
The preceding approach works well if you create the `Message` programmatically.
|
|
|
|
|
However, it is more common to provide the header value within a messaging flow.
|
|
|
|
|
The value can be provided by an upstream `<header-enricher>`, as the following example shows:
|
|
|
|
|
|
|
|
|
|
====
|
|
|
|
|
[source,xml]
|
|
|
|
|
----
|
|
|
|
|
<int:header-enricher input-channel="in" output-channel="out">
|
|
|
|
|
<int:header name="twitter_dmTargetUserId" value="z_oleg"/>
|
|
|
|
|
</int:header-enricher>
|
|
|
|
|
----
|
|
|
|
|
====
|
|
|
|
|
|
|
|
|
|
It is quite common that the value must be determined dynamically.
|
|
|
|
|
For those cases, you can take advantage of SpEL support within the `<header-enricher>` by using the `expression` attribute, as the following example shows:
|
|
|
|
|
|
|
|
|
|
====
|
|
|
|
|
[source,xml]
|
|
|
|
|
----
|
|
|
|
|
<int:header-enricher input-channel="in" output-channel="out">
|
|
|
|
|
<int:header name="twitter_dmTargetUserId"
|
|
|
|
|
expression="@twitterIdService.lookup(headers.username)"/>
|
|
|
|
|
</int:header-enricher>
|
|
|
|
|
----
|
|
|
|
|
====
|
|
|
|
|
|
|
|
|
|
IMPORTANT: Twitter does not let you post duplicate messages.
|
|
|
|
|
This is a common problem during testing, when the same code works the first time but does not work the second time.
|
|
|
|
|
Consequently, you need to change the content of the message each time.
|
|
|
|
|
Appending a timestamp to the end of each message works well for testing.
|
|
|
|
|
|
|
|
|
|
[[twitter-sog]]
|
|
|
|
|
=== Twitter Search Outbound Gateway
|
|
|
|
|
|
|
|
|
|
In Spring Integration, an outbound gateway is used for two-way request-response communication with an external service.
|
|
|
|
|
The Twitter search outbound gateway lets you issue dynamic Twitter searches.
|
|
|
|
|
The reply message payload is a collection of `Tweet` objects.
|
|
|
|
|
If the search returns no results, the payload is an empty collection.
|
|
|
|
|
You can limit the number of tweets, and you can page through a larger set of tweets by making multiple calls.
|
|
|
|
|
To facilitate this, search reply messages contain a header called `twitter_searchMetadata`.
|
|
|
|
|
Its value is a `SearchMetadata` object.
|
|
|
|
|
For more information on the `Tweet`, `SearchParameters`, and `SearchMetadata` classes, see the http://projects.spring.io/spring-social-twitter/[Spring Social Twitter] documentation.
|
|
|
|
|
|
|
|
|
|
==== Configuring the Twitter Search Outbound Gateway
|
|
|
|
|
|
|
|
|
|
The following listing shows the available attributes for a Twitter search outbound gateway:
|
|
|
|
|
|
|
|
|
|
====
|
|
|
|
|
[source,xml]
|
|
|
|
|
----
|
|
|
|
|
<int-twitter:search-outbound-gateway id="twitter"
|
|
|
|
|
request-channel="in" <1>
|
|
|
|
|
twitter-template="twitterTemplate" <2>
|
|
|
|
|
search-args-expression="payload" <3>
|
|
|
|
|
reply-channel="out" <4>
|
|
|
|
|
reply-timeout="123" <5>
|
|
|
|
|
order="1" <6>
|
|
|
|
|
auto-startup="false" <7>
|
|
|
|
|
phase="100" /> <8>
|
|
|
|
|
----
|
|
|
|
|
|
|
|
|
|
<1> The channel used to send search requests to this gateway.
|
|
|
|
|
<2> A reference to a `TwitterTemplate` that has authentication configuration.
|
|
|
|
|
<3> A SpEL expression that evaluates to the arguments for the search.
|
|
|
|
|
Default: *"payload"* - in which case the payload can be a `String` (such as "#springintegration"), and the gateway limits the query to 20 tweets.
|
|
|
|
|
Alternatively, the payload can be a `SearchParameters` object.
|
|
|
|
|
You can also specify the expression as a http://docs.spring.io/spring/docs/current/spring-framework-reference/html/expressions.html#expressions-inline-lists[SpEL List].
|
|
|
|
|
The first element (a `String`) is the query, the remaining elements (`Number` objects) are `pageSize`, `sinceId`, and `maxId`, respectively. See the http://projects.spring.io/spring-social-twitter/[Spring Social Twitter] documentation for more information about these parameters.
|
|
|
|
|
When specifying a `SearchParameters` object directly in the SpEL expression, you do not have to fully qualify the class name.
|
|
|
|
|
The following examples all work:
|
|
|
|
|
+
|
|
|
|
|
`new SearchParameters(payload).count(5).sinceId(headers.sinceId)`
|
|
|
|
|
+
|
|
|
|
|
`{payload, 30}`
|
|
|
|
|
+
|
|
|
|
|
`{payload, headers.pageSize, headers.sinceId, headers.maxId}`
|
|
|
|
|
<4> The channel to which to send the reply.
|
|
|
|
|
If omitted, the `replyChannel` header is used.
|
|
|
|
|
|
|
|
|
|
<5> The timeout when sending the reply message to the reply channel.
|
|
|
|
|
It applies only if the reply channel can block (for example, a bounded queue channel that is full).
|
|
|
|
|
|
|
|
|
|
<6> When subscribed to a publish-subscribe channel, the order in which this endpoint is invoked.
|
|
|
|
|
|
|
|
|
|
<7> `SmartLifecycle` method.
|
|
|
|
|
|
|
|
|
|
<8> `SmartLifecycle` method.
|
|
|
|
|
====
|
Artem Bilan