8. Processors

8.1 Filter (filter)

Use the filter module in a stream to determine whether a Message should be passed to the output channel.

The filter processor has the following options:

expression
a SpEL expression used to transform messages (String, default: payload.toString())

8.1.1 Filter with SpEL expression

The simplest way to use the filter processor is to pass a SpEL expression when creating the stream. The expression should evaluate the message and return true or false. For example:

dataflow:> stream create --name filtertest --definition "http --server.port=9000 | filter --expression=payload=='good' | log" --deploy

This filter will only pass Messages to the log sink if the payload is the word "good". Try sending "good" to the HTTP endpoint and you should see it in the Spring Cloud Data Flow logs:

dataflow:> http post --target http://localhost:9000 --data "good"

Alternatively, if you send the word "bad" (or anything else), you shouldn’t see the log entry.

8.2 Groovy Filter (groovy-filter)

A Processor module that retains or discards messages according to a predicate, expressed as a Groovy script.

8.2.1 Options

The groovy-filter processor has the following options:

script
The script resource location (String, default: ``)
variables
Variable bindings as a comma delimited string of name-value pairs, e.g. 'foo=bar,baz=car' (String, default: ``)
variablesLocation
The location of a properties file containing custom script variable bindings (String, default: ``)

8.3 Http Client (httpclient)

A processor module that makes requests to an HTTP resource and emits the response body as a message payload. This processor can be combined, e.g., with a time source module to periodically poll results from a HTTP resource.

8.3.1 Options

The httpclient processor has the following options:

url
The URL to issue an http request to, as a static value.
urlExpression
A SpEL expression against incoming message to determine the URL to use.
httpMethod
The kind of http method to use.
body
The (static) body of the request to use.
bodyExpression
A SpEL expression against incoming message to derive the request body to use.
headersExpression
A SpEL expression used to derive the http headers map to use.
expectedResponseType
The type used to interpret the response.
replyExpression
A SpEL expression used to compute the final result, applied against the whole http response.

8.4 Bridge (bridge)

A Processor module that returns messages that is passed by connecting just the input and output channels.

8.5 Groovy Transform (groovy-transform)

A Processor module that transforms messages using a Groovy script.

8.5.1 Options

The groovy-transform processor has the following options:

script
The script resource location (String, default: ``)
variables
Variable bindings as a comma delimited string of name-value pairs, e.g. 'foo=bar,baz=car' (String, default: ``)
variablesLocation
The location of a properties file containing custom script variable bindings (String, default: ``)

8.6 Transform (transform)

Use the transform module in a stream to convert a Message’s content or structure.

8.6.1 Options

The transform processor has the following options:

expression
a SpEL expression used to transform messages (String, default: payload.toString())

8.6.2 Transform with SpEL expression

The simplest way to use the transform processor is to pass a SpEL expression when creating the stream. The expression should return the modified message or payload. For example:

dataflow:> stream create --name transformtest --definition "http --server.port=9003 | transform --expression=payload.toUpperCase() | log" --deploy

This transform will convert all message payloads to upper case. If sending the word "foo" to the HTTP endpoint and you should see "FOO" in the Spring Cloud Data Flow logs:

dataflow:> http post --target http://localhost:9003 --data "foo"

As part of the SpEL expression you can make use of the pre-registered JSON Path function. The syntax is #jsonPath(payload,'<json path expression>')

8.7 Splitter

The splitter module builds upon the concept of the same name in Spring Integration and allows the splitting of a single message into several distinct messages.

expression
a SpEL expression which would typically evaluate to an array or collection (String, default: null)
delimiters
A list of delimiters to tokenize a String payload ('expression' must be null) (String, default: null)
fileMarkers
Split File payloads, when true, START and END marker messages will be emitted, when false no markers are emitted (String, default: null)
charset
Split File payloads using this charset to convert bytes to String (String, default: null)
applySequence
Add correlation and sequence information to the message headers (String, default: true)

When no expression, fileMarkers, or charset is provided, a DefaultMessageSplitter is configured with (optional) delimiters. When fileMarkers or charset is provided, a FileSplitter is configured (you must provide either a fileMarkers or charset to split files, which must be text-based - they are split into lines). Otherwise, an ExpressionEvaluatingMessageSplitter is configured.

When splitting File payloads, the sequenceSize header is zero because the size cannot be determined at the beginning.

Ambiguous properties are not allowed.

8.7.1 JSON Example

As part of the SpEL expression you can make use of the pre-registered JSON Path function. The syntax is #jsonPath(payload, '<json path expression>').

For example, consider the following JSON:

{ "store": {
    "book": [
        {
            "category": "reference",
            "author": "Nigel Rees",
            "title": "Sayings of the Century",
            "price": 8.95
        },
        {
            "category": "fiction",
            "author": "Evelyn Waugh",
            "title": "Sword of Honour",
            "price": 12.99
        },
        {
            "category": "fiction",
            "author": "Herman Melville",
            "title": "Moby Dick",
            "isbn": "0-553-21311-3",
            "price": 8.99
        },
        {
            "category": "fiction",
            "author": "J. R. R. Tolkien",
            "title": "The Lord of the Rings",
            "isbn": "0-395-19395-8",
            "price": 22.99
        }
    ],
    "bicycle": {
        "color": "red",
        "price": 19.95
    }
}}

and an expression #jsonPath(payload, '$.store.book'); the result will be 4 messages, each with a Map payload containing the properties of a single book.