此版本仍在开发中，尚未被视为稳定版本。对于最新的稳定版本，请使用 Spring Integration 6.3.1！

此版本仍在开发中，尚未被视为稳定版本。对于最新的稳定版本，请使用 Spring Integration 6.3.1！

消息转换器在实现消息生产者和消息使用者的松耦合方面发挥着非常重要的作用。 与其要求每个消息生成组件知道下一个使用者期望什么类型，不如在这些组件之间添加转换器。 通用转换器（例如将 XML 文档转换为 XML 文档的转换器）也是高度可重用的。String

对于某些系统，最好提供规范的数据模型，但 Spring Integration 的一般理念是不需要任何特定的格式。 相反，为了获得最大的灵活性，Spring Integration 旨在提供最简单的扩展模型。 与其他端点类型一样，在 XML 或 Java 注释中使用声明性配置可以使简单的 POJO 适应消息转换器的角色。 本章的其余部分将介绍这些配置选项。

为了最大限度地提高灵活性，Spring 不需要基于 XML 的消息有效负载。 尽管如此，该框架确实提供了一些方便的转换器来处理基于 XML 的有效负载，如果这确实是您的应用程序的正确选择。 有关这些转换器的更多信息，请参见 XML 支持 - 处理 XML 有效负载。
为了最大限度地提高灵活性，Spring 不需要基于 XML 的消息有效负载。 尽管如此，该框架确实提供了一些方便的转换器来处理基于 XML 的有效负载，如果这确实是您的应用程序的正确选择。 有关这些转换器的更多信息，请参见 XML 支持 - 处理 XML 有效负载。

使用 Java 和其他 DSL 配置 Transformer

对于简单的 Java & Annotation 配置，Spring bean POJO 方法必须用注释标记，并且当从输入通道使用消息时，框架会调用它：@Transformer

public class SomeService {

    @Transformer(inputChannel = "transformChannel", outputChannel = "nextServiceChannel")
    public OutputData exampleTransformer(InputData payload) {
        ...
    }

}

有关详细信息，请参阅注释支持。

对于 Java、Groovy 或 Kotlin DSL，an 的运算符表示转换器端点：.transform()IntegrationFlow

  • Java DSL

  • Kotlin DSL

  • Groovy DSL

@Bean
public IntegrationFlow someFlow() {
    return IntegrationFlow
             .from("transformChannel")
             .transform(someService, "exampleTransformer")
             .channel("nextServiceChannel")
             .get();
}
@Bean
fun someFlow() =
    integrationFlow("transformChannel") {
        transform(someService, "exampleTransformer")
        channel("nextServiceChannel")
    }
@Bean
someFlow() {
    integrationFlow 'transformChannel',
            {
                transform someService, 'exampleTransformer'
                channel 'nextServiceChannel'
            }
}

有关 DSL 的更多信息，请参阅相应章节：

使用 XML 配置 Transformer

该元素用于创建消息转换终结点。 除了 和 属性之外，它还需要一个属性。 该对象可以指向包含单个方法注释的对象（请参阅使用注释配置转换器），也可以与属性中提供的显式方法名称值组合在一起。<transformer>input-channeloutput-channelrefref@Transformermethod

<int:transformer id="testTransformer" ref="testTransformerBean" input-channel="inChannel"
             method="transform" output-channel="outChannel"/>
<beans:bean id="testTransformerBean" class="org.foo.TestTransformer" />

如果自定义转换器处理程序实现可以在其他定义中重用，则通常建议使用属性。 但是，如果自定义转换器处理程序实现的范围应限定为 的单个定义，则可以定义内部 Bean 定义，如以下示例所示：ref<transformer><transformer>

<int:transformer id="testTransformer" input-channel="inChannel" method="transform"
                output-channel="outChannel">
  <beans:bean class="org.foo.TestTransformer"/>
</transformer>
不允许在同一配置中同时使用属性和内部处理程序定义，因为它会创建不明确的条件并导致引发异常。ref<transformer>
如果该属性引用了扩展的 Bean（例如框架本身提供的转换器），则通过将输出通道直接注入处理程序来优化配置。 在这种情况下，每个实例都必须指向单独的 Bean 实例（或 -scoped bean）或使用内部配置类型。 如果无意中引用了多个 Bean 中的同一消息处理程序，则会出现配置异常。refAbstractMessageProducingHandlerrefprototype<bean/>

使用 POJO 时，用于转换的方法可能需要入站消息的类型或有效负载类型。 它还可以分别使用 和 参数注释单独或作为完整映射接受消息标头值。 该方法的返回值可以是任何类型。 如果返回值本身是 ，则传递到变压器的输出通道。Message@Header@HeadersMessage

从 Spring Integration 2.0 开始，消息转换器的转换方法无法再返回。 返回会导致异常，因为消息转换器应始终期望将每个源消息转换为有效的目标消息。 换言之，不应将消息转换器用作消息过滤器，因为有一个专用选项。 但是，如果您确实需要这种类型的行为（组件可能会返回并且不应被视为错误），则可以使用服务激活器。 默认情况下，它的值是，但可以设置为，以便为返回值引发异常，就像转换器一样。nullnull<filter>nullrequires-replyfalsetruenull

不允许在同一配置中同时使用属性和内部处理程序定义，因为它会创建不明确的条件并导致引发异常。ref<transformer>
如果该属性引用了扩展的 Bean（例如框架本身提供的转换器），则通过将输出通道直接注入处理程序来优化配置。 在这种情况下，每个实例都必须指向单独的 Bean 实例（或 -scoped bean）或使用内部配置类型。 如果无意中引用了多个 Bean 中的同一消息处理程序，则会出现配置异常。refAbstractMessageProducingHandlerrefprototype<bean/>

Transformers 和 Spring 表达式语言 （SpEL）

与路由器、聚合器和其他组件一样，从 Spring Integration 2.0 开始，只要转换逻辑相对简单，转换器也可以从 SpEL 支持中受益。 下面的示例演示如何使用 SpEL 表达式：

<int:transformer input-channel="inChannel"
	output-channel="outChannel"
	expression="payload.toUpperCase() + '- [' + T(System).currentTimeMillis() + ']'"/>

前面的示例在不写入自定义转换器的情况下转换有效负载。 我们的有效负载（假设为 ）是大写的，与当前时间戳连接，并应用了一些格式。String

普通变压器

Spring Integration 提供了一些 transformer 实现。

对象到字符串转换器

因为使用 的表示是相当常见的，Spring Integration 提供了一个（另请参阅工厂），其中输出是带有 String 的 a。 这是对入站消息的有效负载调用操作的结果。 下面的示例演示如何声明对象到字符串转换器的实例：toString()ObjectObjectToStringTransformerTransformersMessagepayloadStringtoString()

  • Java DSL

  • Kotlin DSL

  • Groovy DSL

  • XML

@Bean
public IntegrationFlow someFlow() {
    return IntegrationFlow
             .from("in")
             .transform(Transformers.objectToString())
             .channel("out")
             .get();
}
@Bean
fun someFlow() =
    integrationFlow("in") {
        transform(Transformers.objectToString())
        channel("out")
    }
@Bean
someFlow() {
    integrationFlow 'in',
            {
                transform Transformers.objectToString()
                channel 'out'
            }
}
<int:object-to-string-transformer input-channel="in" output-channel="out"/>

此转换器的潜在用途是将一些任意对象发送到命名空间中的“outbound-channel-adapter”。 默认情况下，该通道适配器仅支持 、字节数组或有效负载，因此在适配器处理必要的转换之前立即添加此转换器。 只要调用的结果是您希望写入文件的结果，就可以正常工作。 否则，您可以使用前面所示的通用“transformer”元素提供基于 POJO 的自定义转换器。fileStringjava.io.FiletoString()

调试时，通常不需要此转换器，因为 能够记录消息负载。 有关详细信息，请参阅 Wire Tap。logging-channel-adapter

对象到字符串转换器非常简单。 它在入站有效负载上调用。 从 Spring Integration 3.0 开始，此规则有两个例外：toString()

  • 如果有效负载为 ，则调用 。char[]new String(payload)

  • 如果有效负载是 ，它会调用 ，其中默认为 UTF-8。 可以通过在转换器上提供 charset 属性来修改。byte[]new String(payload, charset)charsetcharset

对于更复杂的操作（例如，在运行时动态选择字符集），可以改用基于 SpEL 表达式的转换器，如以下示例所示：

  • Java DSL

  • XML

@Bean
public IntegrationFlow someFlow() {
    return IntegrationFlow
             .from("in")
             .transform("new String(payload, headers['myCharset']")
             .channel("out")
             .get();
}
<int:transformer input-channel="in" output-channel="out"
       expression="new String(payload, headers['myCharset']" />

如果需要将 an 序列化为字节数组或将字节数组反序列化回 ，Spring Integration 提供了对称序列化转换器。 默认情况下，它们使用标准的 Java 序列化，但您可以分别使用 和 属性来提供 Spring 或策略的实现。 另请参阅工厂类。 以下示例演示如何使用 Spring 的序列化程序和反序列化程序：ObjectObjectSerializerDeserializerserializerdeserializerTransformers

  • Java DSL

  • XML

@Bean
public IntegrationFlow someFlow() {
    return IntegrationFlow
             .from("objectsIn")
             .transform(Transformers.serializer())
             .channel("bytesOut")
             .channel("bytesIn")
             .transform(Transformers.deserializer("com.mycom.*", "com.yourcom.*"))
             .channel("objectsOut")
             .get();
}
<int:payload-serializing-transformer input-channel="objectsIn" output-channel="bytesOut"/>

<int:payload-deserializing-transformer input-channel="bytesIn" output-channel="objectsOut"
    allow-list="com.mycom.*,com.yourcom.*"/>
反序列化来自不受信任源的数据时，应考虑添加包和类模式。 默认情况下，所有类都是反序列化的。allow-list

Object-to- 和 -to- 变压器MapMapObject

Spring Integration 还提供了 -to- 和 -to- 转换器，它们使用 JSON 对对象图进行序列化和反序列化。 对象层次结构被内省到最原始的类型（、 等）。 此类型的路径用 SpEL 描述，它变为转换后的 . 基元类型变为值。ObjectMapMapObjectStringintkeyMap

请看以下示例：

public class Parent{
    private Child child;
    private String name;
    // setters and getters are omitted
}

public class Child{
    private String name;
    private List<String> nickNames;
    // setters and getters are omitted
}

上述示例中的两个类将转换为以下内容：Map

{person.name=George, person.child.name=Jenna, person.child.nickNames[0]=Jen ...}

基于 JSON 的允许您在不共享实际类型的情况下描述对象结构，这允许您将对象图还原并重新构建为不同类型的对象图，只要您维护该结构即可。Map

例如，可以使用 -to- 转换器将上述结构还原回以下对象图：MapObject

public class Father {
    private Kid child;
    private String name;
    // setters and getters are omitted
}

public class Kid {
    private String name;
    private List<String> nickNames;
    // setters and getters are omitted
}

如果需要创建“结构化”地图，可以提供属性。 默认值为“true”。 如果将其设置为“false”，则结构是对象的 a。flattenMapMap

请看以下示例：

public class Parent {
	private Child child;
	private String name;
	// setters and getters are omitted
}

public class Child {
	private String name;
	private List<String> nickNames;
	// setters and getters are omitted
}

上述示例中的两个类将转换为以下内容：Map

{name=George, child={name=Jenna, nickNames=[Bimbo, ...]}}

为了配置这些转换器，Spring Integration提供了相应的XML组件和Java DSL工厂：

  • Java DSL

  • XML

@Bean
public IntegrationFlow someFlow() {
    return IntegrationFlow
             .from("directInput")
             .transform(Transformers.toMap())
             .channel("output")
             .get();
}
<int:object-to-map-transformer input-channel="directInput" output-channel="output"/>

您还可以将该属性设置为 false，如下所示：flatten

  • Java DSL

  • XML

@Bean
public IntegrationFlow someFlow() {
    return IntegrationFlow
             .from("directInput")
             .transform(Transformers.toMap(false))
             .channel("output")
             .get();
}
<int:object-to-map-transformer input-channel="directInput" output-channel="output" flatten="false"/>

Spring Integration 为 Map-to-Object 提供 XML 命名空间支持，Java DSL 工厂具有该方法，如以下示例所示：fromMap()

  • Java DSL

  • XML

@Bean
public IntegrationFlow someFlow() {
    return IntegrationFlow
             .from("input")
             .transform(Transformers.fromMap(org.something.Person.class))
             .channel("output")
             .get();
}
<int:map-to-object-transformer input-channel="input"
                         output-channel="output"
                         type="org.something.Person"/>

或者，您可以使用属性和原型范围的 Bean，如以下示例所示：ref

  • Java DSL

  • XML

@Bean
IntegrationFlow someFlow() {
    return IntegrationFlow
             .from("inputA")
             .transform(Transformers.fromMap("person"))
             .channel("outputA")
             .get();
}

@Bean
@Scope("prototype")
Person person() {
    return new Person();
}
<int:map-to-object-transformer input-channel="inputA"
                               output-channel="outputA"
                               ref="person"/>
<bean id="person" class="org.something.Person" scope="prototype"/>
“ref”和“type”属性是互斥的。 此外，如果使用“ref”属性，则必须指向“原型”范围的 Bean。 否则，将抛出 a。BeanCreationException

从 5.0 版开始，您可以提供自定义 — 当您需要特殊格式的日期或空集合的空格式（和其他用途）时。 有关实现的更多信息，请参阅 JSON Transformers。ObjectToMapTransformerJsonObjectMapperJsonObjectMapper

流变压器

将有效负载转换为 a（如果提供了 a，则为 a）。StreamTransformerInputStreambyte[]Stringcharset

下面的示例演示如何在 XML 中使用该元素：stream-transformer

  • Java DSL

  • XML

@Bean
public IntegrationFlow someFlow() {
    return IntegrationFlow
             .from("input")
             .transform(Transformers.fromStream("UTF-8"))
             .channel("output")
             .get();
}
<int:stream-transformer input-channel="directInput" output-channel="output"/> <!-- byte[] -->

<int:stream-transformer id="withCharset" charset="UTF-8"
    input-channel="charsetChannel" output-channel="output"/> <!-- String -->

下面的示例演示如何使用类和注释在 Java 中配置流转换器：StreamTransformer@Transformer

@Bean
@Transformer(inputChannel = "stream", outputChannel = "data")
public StreamTransformer streamToBytes() {
    return new StreamTransformer(); // transforms to byte[]
}

@Bean
@Transformer(inputChannel = "stream", outputChannel = "data")
public StreamTransformer streamToString() {
    return new StreamTransformer("UTF-8"); // transforms to String
}

JSON 转换器

Spring Integration 提供了对象到 JSON 和 JSON 到对象的转换器。 以下一对示例演示如何在 XML 中声明它们：

<int:object-to-json-transformer input-channel="objectMapperInput"/>

<int:json-to-object-transformer input-channel="objectMapperInput"
    type="foo.MyDomainObject"/>

默认情况下，前面列表中的变压器使用香草 . 它基于类路径中的实现。 您可以使用适当的选项或基于所需的库（如 GSON）提供自己的自定义实现，如以下示例所示：JsonObjectMapperJsonObjectMapper

<int:json-to-object-transformer input-channel="objectMapperInput"
    type="something.MyDomainObject" object-mapper="customObjectMapper"/>

从版本 3.0 开始，该属性引用了新策略接口的实例：. 此抽象允许使用 JSON 映射器的多个实现。 提供了包装 Jackson 2 的实现，并在类路径上检测到版本。 该类分别是 。object-mapperJsonObjectMapperJackson2JsonObjectMapper

您可能希望考虑使用一种或一种工厂方法来创建具有所需特征的。 以下示例演示如何使用此类工厂：FactoryBeanJsonObjectMapper

public class ObjectMapperFactory {

    public static Jackson2JsonObjectMapper getMapper() {
        ObjectMapper mapper = new ObjectMapper();
        mapper.configure(JsonParser.Feature.ALLOW_COMMENTS, true);
        return new Jackson2JsonObjectMapper(mapper);
    }
}

下面的示例演示如何在 XML 中执行相同的操作：

<bean id="customObjectMapper" class="something.ObjectMapperFactory"
            factory-method="getMapper"/>

从版本 2.2 开始，如果输入消息还没有该标头，则默认将标头设置为 。object-to-json-transformercontent-typeapplication/json

如果希望将标头设置为其他值或用某个值（包括 ）显式覆盖任何现有标头，请使用该属性。 如果要禁止显示标头的设置，请将该属性设置为空字符串 （）。 这样做会导致消息没有标头，除非输入消息中存在此类标头。content-typeapplication/jsoncontent-typecontent-type""content-type

从版本 3.0 开始，将反映源类型的标头添加到消息中。 同样，在将 JSON 转换为对象时，可以使用这些类型标头。 这些标头映射在 AMQP 适配器中，以便它们与 Spring-AMQP JsonMessageConverter 完全兼容。ObjectToJsonTransformerJsonToObjectTransformer

这使以无需任何特殊配置即可工作：

  • …​→amqp-outbound-adapter---→

  • ---→amqp-inbound-adapter→json-to-object-transformer→…​

    其中出站适配器配置了 ，而入站适配器使用默认的 .JsonMessageConverterSimpleMessageConverter

  • …​→object-to-json-transformer→amqp-outbound-adapter---→

  • ---→amqp-inbound-adapter→…​

    其中出站适配器配置了 ，而入站适配器使用默认的 .SimpleMessageConverterJsonMessageConverter

  • …​→object-to-json-transformer→amqp-outbound-adapter---→

  • ---→amqp-inbound-adapter→json-to-object-transformer→

    其中两个适配器都配置了 .SimpleMessageConverter

使用标头确定类型时，不应提供属性，因为它优先于标头。class

除了 JSON Transformer 之外，Spring Integration 还提供了一个内置的 SpEL 函数，用于表达式。 有关更多信息，请参见 Spring Expression Language （SpEL）。#jsonPath

从 3.0 版开始，Spring Integration 还提供了一个内置的 SpEL 函数，用于表达式。 有关详细信息 #xpath 请参阅 SpEL 函数。#xpath

从版本 4.0 开始，支持该属性来指定节点 JSON 表示形式。 结果节点树表示取决于提供的 . 默认情况下，使用 a 并将对象到节点树的转换委托给方法。 节点 JSON 表示形式为下游消息流使用具有访问 JSON 数据属性的 SpEL 表达式提供了效率。 有关详细信息，请参阅属性访问器。ObjectToJsonTransformerresultTypeJsonObjectMapperObjectToJsonTransformerJackson2JsonObjectMapperObjectMapper#valueToTreeJsonPropertyAccessor

从版本 5.1 开始，可以将其配置为在使用使用此数据类型操作的下游处理程序时生成带有有效负载的消息，以便于使用此数据类型。resultTypeBYTESbyte[]

从版本 5.2 开始，可以使用 a 进行配置，以便在使用目标 JSON 处理器进行反序列化期间支持泛型。 此外，此组件现在首先查阅请求消息标头以了解是否存在 or，否则会回退到配置的类型。 现在，它还会根据任何可能的下游方案的请求消息有效负载填充标头。JsonToObjectTransformerResolvableTypeJsonHeaders.RESOLVABLE_TYPEJsonHeaders.TYPE_IDObjectToJsonTransformerJsonHeaders.RESOLVABLE_TYPE

从版本 5.2.6 开始，可以提供 a 来解析 a 以在运行时根据请求消息从 JSON 转换有效负载。 默认情况下，它会在请求消息中进行查询。 如果此表达式返回或构建抛出 ，则 transformer 回退到提供的 。 此逻辑以表达式的形式存在，因为可能没有实际的类值，而是某些类型 ID，这些 ID 必须根据某些外部注册表映射到目标类。JsonToObjectTransformervalueTypeExpressionResolvableTypeJsonHeadersnullResolvableTypeClassNotFoundExceptiontargetTypeJsonHeaders

Apache Avro 变形金刚

版本 5.2 添加了简单的转换器，用于与 Apache Avro 之间的转换。

它们并不复杂，因为没有模式注册表;转换器只是使用从 Avro 架构生成的实现中嵌入的架构。SpecificRecord

发送到的消息必须具有实现的有效负载;变压器可以处理多种类型。 必须使用用作要反序列化的默认类型的类进行配置。 还可以指定 SpEL 表达式，以确定要使用该方法反序列化的类型。 默认 SpEL 表达式为 （），默认情况下，该表达式由 具有源类的完全限定类名填充。 如果表达式返回 ，则使用 。SimpleToAvroTransformerSpecificRecordSimpleFromAvroTransformerSpecificRecordsetTypeExpressionheaders[avro_type]AvroHeaders.TYPESimpleToAvroTransformernulldefaultType

也有一个方法。 这允许生产者和使用者解耦，其中发送者可以将标头设置为表示类型的某个令牌，然后使用者将该令牌映射到类型。SimpleToAvroTransformersetTypeExpression

协议缓冲器变压器

V6.1 增加了对从协议缓冲区数据内容转换和向协议缓冲区数据内容转换的支持。

将消息有效负载转换为本机字节数组或 json 文本有效负载。 内容类型（默认使用）生成字节数组输出有效负载。 如果内容类型是 add the if found on the classpath，则输出为 text json 有效负载。 如果未将内容类型标头设置为 。ToProtobufTransformercom.google.protobuf.Messageapplication/x-protobufapplication/jsoncom.google.protobuf:protobuf-java-utilToProtobufTransformerapplication/x-protobuf

将字节数组或文本 protobuf 有效负载（取决于内容类型）转换回实例。 应显式指定预期的类类型（使用该方法）或使用 SpEL 表达式来确定要使用该方法反序列化的类型。 默认的 SpEL 表达式为 （），它由 具有源类的完全限定类名填充。FromProtobufTransformercom.google.protobuf.MessageFromProtobufTransformersetExpectedTypesetExpectedTypeExpressionheaders[proto_type]ProtoHeaders.TYPEToProtobufTransformercom.google.protobuf.Message

例如，编译以下 IDL：

syntax = "proto2";
package tutorial;

option java_multiple_files = true;
option java_package = "org.example";
option java_outer_classname = "MyProtos";

message MyMessageClass {
  optional string foo = 1;
  optional string bar = 2;
}

将生成一个新类。org.example.MyMessageClass

然后使用：

// Transforms a MyMessageClass instance into a byte array.
ToProtobufTransformer toTransformer = new ToProtobufTransformer();

MyMessageClass test = MyMessageClass.newBuilder()
                                .setFoo("foo")
                                .setBar("bar")
                                .build();
// message1 payload is byte array protocol buffer wire format.
Message message1 = toTransformer.transform(new GenericMessage<>(test));

// Transforms a byte array payload into a MyMessageClass instance.
FromProtobufTransformer fromTransformer = new FromProtobufTransformer();

// message2 payload == test
Message message2 =  fromTransformer.transform(message1);
调试时，通常不需要此转换器，因为 能够记录消息负载。 有关详细信息，请参阅 Wire Tap。logging-channel-adapter
反序列化来自不受信任源的数据时，应考虑添加包和类模式。 默认情况下，所有类都是反序列化的。allow-list
“ref”和“type”属性是互斥的。 此外，如果使用“ref”属性，则必须指向“原型”范围的 Bean。 否则，将抛出 a。BeanCreationException

从版本 3.0 开始，该属性引用了新策略接口的实例：. 此抽象允许使用 JSON 映射器的多个实现。 提供了包装 Jackson 2 的实现，并在类路径上检测到版本。 该类分别是 。object-mapperJsonObjectMapperJackson2JsonObjectMapper

从版本 2.2 开始，如果输入消息还没有该标头，则默认将标头设置为 。object-to-json-transformercontent-typeapplication/json

如果希望将标头设置为其他值或用某个值（包括 ）显式覆盖任何现有标头，请使用该属性。 如果要禁止显示标头的设置，请将该属性设置为空字符串 （）。 这样做会导致消息没有标头，除非输入消息中存在此类标头。content-typeapplication/jsoncontent-typecontent-type""content-type
使用标头确定类型时，不应提供属性，因为它优先于标头。class

使用注释配置 Transformer

您可以将批注添加到需要类型或消息负载类型的方法。 返回值的处理方式与前面描述 <transformer> 元素的部分中所述的方式完全相同。 下面的示例演示如何使用批注将 a 转换为：@TransformerMessage@TransformerStringOrder

@Transformer
Order generateOrder(String productId) {
    return new Order(productId);
}

Transformer 方法也可以接受 和 注释，如 中所述。 以下示例演示如何使用批注：@Header@HeadersAnnotation Support@Header

@Transformer
Order generateOrder(String productId, @Header("customerName") String customer) {
    return new Order(productId, customer);
}

另请参阅使用注释为端点提供建议。

标头过滤器

有时，您的转换用例可能就像删除几个标头一样简单。 对于此类用例，Spring Integration提供了一个标头过滤器，允许您指定应从输出消息中删除的某些标头名称（例如，出于安全原因或仅暂时需要的值删除标头）。 基本上，标头过滤器与标头扩充器相反。 后者在 Header Enricher 中进行了讨论。 下面的示例定义标头筛选器：

  • Java DSL

  • XML

@Bean
public IntegrationFlow someFlow() {
    return IntegrationFlow
             .from("inputChannel")
             .headerFilter("lastName", "state")
             .channel("outputChannel")
             .get();
}
<int:header-filter input-channel="inputChannel"
		output-channel="outputChannel" header-names="lastName, state"/>

如您所见，标头过滤器的配置非常简单。 它是具有输入和输出通道以及属性的典型端点。 该属性接受需要删除的标头的名称（如果有多个，则用逗号分隔）。 因此，在前面的示例中，出站消息中不存在名为“lastName”和“state”的标头。header-names

基于编解码器的转换器

请参阅编解码器。