INT-1011 Added 'overwrite' attribute for individual header sub-elements and renamed the top-level attribute to 'default-overwrite' (top level is a fallback if the sub-element does not provide a value).

org.springframework.integration/src/main/java/org/springframework/integration/config/xml/HeaderEnricherParserSupport.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2009 the original author or authors.
+ * Copyright 2002-2010 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -23,7 +23,6 @@ import org.w3c.dom.Element;
 import org.w3c.dom.Node;
 import org.w3c.dom.NodeList;
 
-import org.springframework.beans.factory.config.RuntimeBeanReference;
 import org.springframework.beans.factory.config.TypedStringValue;
 import org.springframework.beans.factory.support.BeanDefinitionBuilder;
 import org.springframework.beans.factory.support.ManagedMap;
@@ -49,10 +48,6 @@ public abstract class HeaderEnricherParserSupport extends AbstractTransformerPar
 		return IntegrationNamespaceUtils.BASE_PACKAGE + ".transformer.HeaderEnricher";
 	}
 
-	protected boolean shouldOverwrite(Element element) {
-		return "true".equals(element.getAttribute("overwrite").toLowerCase());
-	}
-
 	protected final void addElementToHeaderMapping(String elementName, String headerName) {
 		this.addElementToHeaderMapping(elementName, headerName, null);
 	}
@@ -70,7 +65,7 @@ public abstract class HeaderEnricherParserSupport extends AbstractTransformerPar
 		ManagedMap headers = new ManagedMap();
 		this.processHeaders(element, headers, parserContext);
 		builder.addConstructorArgValue(headers);
-		builder.addPropertyValue("overwrite", this.shouldOverwrite(element)); // TODO: should be a per-header config setting
+		IntegrationNamespaceUtils.setValueIfAttributeDefined(builder, element, "default-overwrite");
 	}
 
 	protected void processHeaders(Element element, ManagedMap<String, Object> headers, ParserContext parserContext) {
@@ -123,25 +118,28 @@ public abstract class HeaderEnricherParserSupport extends AbstractTransformerPar
 						parserContext.getReaderContext().error(
 								"Exactly one of the 'ref', 'value', or 'expression' attributes is required.", element);
 					}
+					Object headerSource = parserContext.extractSource(headerElement);
+					BeanDefinitionBuilder valueHolderBuilder = null;
 					if (isValue) {
 						if (hasMethod) {
 							parserContext.getReaderContext().error(
 									"The 'method' attribute cannot be used with the 'value' attribute.", element);
 						}
 						Object headerValue = (headerType != null) ?
-							new TypedStringValue(value, headerType) : value;
-						headers.put(headerName, headerValue);
+								new TypedStringValue(value, headerType) : value;
+						valueHolderBuilder = BeanDefinitionBuilder.genericBeanDefinition(
+								IntegrationNamespaceUtils.BASE_PACKAGE + ".transformer.HeaderEnricher$StaticValueHolder");
+						valueHolderBuilder.addConstructorArgValue(headerValue);
 					}
 					else if (isExpression) {
 						if (hasMethod) {
 							parserContext.getReaderContext().error(
 									"The 'method' attribute cannot be used with the 'expression' attribute.", element);
 						}
-						BeanDefinitionBuilder expressionBuilder = BeanDefinitionBuilder.genericBeanDefinition(
+						valueHolderBuilder = BeanDefinitionBuilder.genericBeanDefinition(
 								IntegrationNamespaceUtils.BASE_PACKAGE + ".transformer.HeaderEnricher$ExpressionHolder");
-						expressionBuilder.addConstructorArgValue(expression);
-						expressionBuilder.addConstructorArgValue(headerType);
-						headers.put(headerName, expressionBuilder.getBeanDefinition());
+						valueHolderBuilder.addConstructorArgValue(expression);
+						valueHolderBuilder.addConstructorArgValue(headerType);
 					}
 					else {
 						if (StringUtils.hasText(headerElement.getAttribute("type"))) {
@@ -149,16 +147,22 @@ public abstract class HeaderEnricherParserSupport extends AbstractTransformerPar
 									"The 'type' attribute cannot be used with the 'ref' attribute.", element);
 						}
 						if (hasMethod) {
-							BeanDefinitionBuilder methodExpressionBuilder = BeanDefinitionBuilder.genericBeanDefinition(
+							valueHolderBuilder = BeanDefinitionBuilder.genericBeanDefinition(
 									IntegrationNamespaceUtils.BASE_PACKAGE + ".transformer.HeaderEnricher$MethodExpressionHolder");
-							methodExpressionBuilder.addConstructorArgReference(ref);
-							methodExpressionBuilder.addConstructorArgValue(method);
-							headers.put(headerName, methodExpressionBuilder.getBeanDefinition());
+							valueHolderBuilder.addConstructorArgReference(ref);
+							valueHolderBuilder.addConstructorArgValue(method);
 						}
 						else {
-							headers.put(headerName, new RuntimeBeanReference(ref));
+							valueHolderBuilder = BeanDefinitionBuilder.genericBeanDefinition(
+									IntegrationNamespaceUtils.BASE_PACKAGE + ".transformer.HeaderEnricher$StaticValueHolder");
+							valueHolderBuilder.addConstructorArgReference(ref);
 						}
 					}
+					if (valueHolderBuilder == null) {
+						parserContext.getReaderContext().error("failed to parse header sub-element", headerSource);
+					}
+					IntegrationNamespaceUtils.setValueIfAttributeDefined(valueHolderBuilder, headerElement, "overwrite");
+					headers.put(headerName, valueHolderBuilder.getBeanDefinition());
 				}
 			}
 		}

org.springframework.integration/src/main/java/org/springframework/integration/transformer/HeaderEnricher.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2009 the original author or authors.
+ * Copyright 2002-2010 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -43,38 +43,36 @@ import org.springframework.util.Assert;
  */
 public class HeaderEnricher implements Transformer {
 
-	private final Map<String, Object> headersToAdd;
+	private final Map<String, ValueHolder> headersToAdd;
 
-	private volatile boolean overwrite;
+	private volatile boolean defaultOverwrite = false;
 
 
 	/**
 	 * Create a HeaderEnricher with the given map of headers.
 	 */
-	public HeaderEnricher(Map<String, Object> headersToAdd) {
+	public HeaderEnricher(Map<String, ValueHolder> headersToAdd) {
 		Assert.notNull(headersToAdd, "headersToAdd must not be null");
 		this.headersToAdd = headersToAdd;
 	}
 
 
-	public void setOverwrite(boolean overwrite) {
-		this.overwrite = overwrite;
+	public void setDefaultOverwrite(boolean defaultOverwrite) {
+		this.defaultOverwrite = defaultOverwrite;
 	}
 
 	public Message<?> transform(Message<?> message) {
 		try {
 			Map<String, Object> headerMap = new HashMap<String, Object>(message.getHeaders());
-			for (Map.Entry<String, Object> entry : this.headersToAdd.entrySet()) {
+			for (Map.Entry<String, ValueHolder> entry : this.headersToAdd.entrySet()) {
 				String key = entry.getKey();
-				if (this.overwrite || headerMap.get(key) == null) {
-					Object value = entry.getValue();
-					if (value instanceof ExpressionHolder) {
-						value = ((ExpressionHolder) value).evaluate(message);
-					}
-					else if (value instanceof MethodExpressionHolder) {
-						value = ((MethodExpressionHolder) value).evaluate(message);
-					}
-					headerMap.put(key, value);
+				ValueHolder valueHolder = entry.getValue();
+				Boolean shouldOverwrite = valueHolder.isOverwrite();
+				if (shouldOverwrite == null) {
+					shouldOverwrite = this.defaultOverwrite;
+				}
+				if (shouldOverwrite || headerMap.get(key) == null) {
+					headerMap.put(key, valueHolder.evaluate(message));
 				}
 			}
 	        return MessageBuilder.withPayload(message.getPayload()).copyHeaders(headerMap).build();
@@ -85,7 +83,46 @@ public class HeaderEnricher implements Transformer {
 	}
 
 
-	static class ExpressionHolder {
+	public static interface ValueHolder {
+
+		Object evaluate(Message<?> message);
+
+		Boolean isOverwrite();
+
+	}
+
+
+	static abstract class AbstractValueHolder implements ValueHolder {
+
+		// null indicates no explicit setting; use header-enricher's 'default-overwrite' value
+		private volatile Boolean overwrite = null;
+
+		public void setOverwrite(Boolean overwrite) {
+			this.overwrite = overwrite;
+		}
+
+		public Boolean isOverwrite() {
+			return this.overwrite;
+		}
+
+	}
+
+
+	static class StaticValueHolder extends AbstractValueHolder {
+
+		private final Object value;
+
+		public StaticValueHolder(Object value) {
+			this.value = value;
+		}
+
+		public Object evaluate(Message<?> message) {
+			return this.value;
+		}
+	}
+
+
+	static class ExpressionHolder extends AbstractValueHolder {
 
 		private static final ExpressionParser parser = new SpelExpressionParser();
 
@@ -109,7 +146,7 @@ public class HeaderEnricher implements Transformer {
 		}
 
 
-		private Object evaluate(Message<?> message) throws ParseException, EvaluationException {
+		public Object evaluate(Message<?> message) throws ParseException, EvaluationException {
 			return (this.expectedType != null)
 					? this.expression.getValue(this.evaluationContext, message, this.expectedType)
 					: this.expression.getValue(this.evaluationContext, message);
@@ -117,7 +154,7 @@ public class HeaderEnricher implements Transformer {
 	}
 
 
-	static class MethodExpressionHolder {
+	static class MethodExpressionHolder extends AbstractValueHolder  {
 
 		private final MethodInvokingMessageProcessor processor;
 
@@ -125,7 +162,7 @@ public class HeaderEnricher implements Transformer {
 			this.processor = new MethodInvokingMessageProcessor(targetObject, method);
 		}
 
-		private Object evaluate(Message<?> message) {
+		public Object evaluate(Message<?> message) {
 			return this.processor.processMessage(message);
 		}
 	}

org.springframework.integration/src/main/resources/org/springframework/integration/config/xml/spring-integration-2.0.xsd

@@ -1185,6 +1185,16 @@
 										<xsd:union memberTypes="priorityEnumeration xsd:string"/>
 									</xsd:simpleType>
 								</xsd:attribute>
+								<xsd:attribute name="overwrite">
+									<xsd:annotation>
+										<xsd:documentation>
+	Boolean value to indicate whether this header value should overwrite an existing header value for the same name.
+										</xsd:documentation>
+									</xsd:annotation>
+									<xsd:simpleType>
+										<xsd:union memberTypes="xsd:boolean xsd:string"/>
+									</xsd:simpleType>
+								</xsd:attribute>
 							</xsd:complexType>
 						</xsd:element>
 						<xsd:element name="header" type="userDefinedHeaderType">
@@ -1196,7 +1206,18 @@
 						</xsd:element>
 						<xsd:element name="poller" type="innerPollerType" minOccurs="0" maxOccurs="1" />
 					</xsd:choice>
-					<xsd:attribute name="overwrite" type="xsd:string" />
+					<xsd:attribute name="default-overwrite">
+						<xsd:annotation>
+							<xsd:documentation>
+	Specify the default boolean value for whether to overwrite existing header values. This will only take effect for
+	sub-elements that do not provide their own 'overwrite' attribute. If the 'default-overwrite' attribute is not
+	provided, then the specified header values will NOT overwrite any existing ones with the same header names. 
+							</xsd:documentation>
+						</xsd:annotation>
+						<xsd:simpleType>
+							<xsd:union memberTypes="xsd:boolean xsd:string"/>
+						</xsd:simpleType> 
+					</xsd:attribute>
 				</xsd:extension>
 			</xsd:complexContent>
 		</xsd:complexType>
@@ -1291,6 +1312,16 @@
 				</xsd:appinfo>
 			</xsd:annotation>
 		</xsd:attribute>
+		<xsd:attribute name="overwrite">
+			<xsd:annotation>
+				<xsd:documentation>
+	Boolean value to indicate whether this header value should overwrite an existing header value for the same name.
+				</xsd:documentation>
+			</xsd:annotation>
+			<xsd:simpleType>
+				<xsd:union memberTypes="xsd:boolean xsd:string"/>
+			</xsd:simpleType>
+		</xsd:attribute>
 	</xsd:complexType>
 	
 	<xsd:element name="transformer" type="expressionOrInnerEndpointDefinitionAware">