Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   /*
    * Copyright 2002-2014 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.
    * You may obtain a copy of the License at
    *
    *      http://www.apache.org/licenses/LICENSE-2.0
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package org.springframework.integration.http.support;
  
  import java.net.URI;
  import java.util.Date;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.List;
  import java.util.Locale;
  import java.util.Map;
  import java.util.Set;
  
  
Default org.springframework.integration.mapping.HeaderMapper implementation for HTTP.

Author(s):
Mark Fisher
Jeremy Grelle
Oleg Zhurakousky
Gunnar Hillert
Gary Russell
Artem Bilan
Since:
2.0
  
  
  	private static final Log logger = LogFactory.getLog(DefaultHttpHeaderMapper.class);
  
  	private volatile ConversionService conversionService;
  
  	private volatile BeanFactory beanFactory;
  
  	private static final String ACCEPT = "Accept";
  
  	private static final String ACCEPT_CHARSET = "Accept-Charset";
  
  	private static final String ACCEPT_ENCODING = "Accept-Encoding";
  
  	private static final String ACCEPT_LANGUAGE = "Accept-Language";
  
  	private static final String ACCEPT_RANGES = "Accept-Ranges";
  
  	private static final String AGE = "Age";
  
  	private static final String ALLOW = "Allow";
  
  	private static final String AUTHORIZATION = "Authorization";
  
  	private static final String CACHE_CONTROL = "Cache-Control";
  
  	private static final String CONNECTION = "Connection";
  
  	private static final String CONTENT_ENCODING = "Content-Encoding";
  
 	private static final String CONTENT_LANGUAGE = "Content-Language";
 
 	private static final String CONTENT_LENGTH = "Content-Length";
 
 	private static final String CONTENT_LOCATION = "Content-Location";
 
 	private static final String CONTENT_MD5 = "Content-MD5";
 
 	private static final String CONTENT_RANGE = "Content-Range";
 
 	private static final String CONTENT_TYPE = "Content-Type";
 
 	public  static final String COOKIE = "Cookie";
 
 	private static final String DATE = "Date";
 
 	private static final String ETAG = "ETag";
 
 	private static final String EXPECT = "Expect";
 
 	private static final String EXPIRES = "Expires";
 
 	private static final String FROM = "From";
 
 	private static final String HOST = "Host";
 
 	private static final String IF_MATCH = "If-Match";
 
 	private static final String IF_MODIFIED_SINCE = "If-Modified-Since";
 
 	private static final String IF_NONE_MATCH = "If-None-Match";
 
 	private static final String IF_RANGE = "If-Range";
 
 	private static final String IF_UNMODIFIED_SINCE = "If-Unmodified-Since";
 
 	private static final String LAST_MODIFIED = "Last-Modified";
 
 	private static final String LOCATION = "Location";
 
 	private static final String MAX_FORWARDS = "Max-Forwards";
 
 	private static final String PRAGMA = "Pragma";
 
 	private static final String PROXY_AUTHENTICATE = "Proxy-Authenticate";
 
 	private static final String PROXY_AUTHORIZATION = "Proxy-Authorization";
 
 	private static final String RANGE = "Range";
 
 	private static final String REFERER = "Referer";
 
 	private static final String REFRESH = "Refresh";
 
 	private static final String RETRY_AFTER = "Retry-After";
 
 	private static final String SERVER = "Server";
 
 	public  static final String SET_COOKIE = "Set-Cookie";
 
 	private static final String TE = "TE";
 
 	private static final String TRAILER = "Trailer";
 
 	private static final String UPGRADE = "Upgrade";
 
 	private static final String USER_AGENT = "User-Agent";
 
 	private static final String VARY = "Vary";
 
 	private static final String VIA = "Via";
 
 	private static final String WARNING = "Warning";
 
 	private static final String WWW_AUTHENTICATE = "WWW-Authenticate";
 
 	private static final String[] HTTP_REQUEST_HEADER_NAMES = new String[] {
 			,
 			,
 	};
 
 	private static String[] HTTP_RESPONSE_HEADER_NAMES = new String[] {
 			,
 			,
 	};
 
 
 	};
 
 	public static final String HTTP_REQUEST_HEADER_NAME_PATTERN = "HTTP_REQUEST_HEADERS";
 
 	public static final String HTTP_RESPONSE_HEADER_NAME_PATTERN = "HTTP_RESPONSE_HEADERS";
 
 	// Copy of 'org.springframework.http.HttpHeaders#DATE_FORMATS'
 	private static final String[] DATE_FORMATS = new String[] {
 			"EEE, dd MMM yyyy HH:mm:ss zzz",
 			"EEE, dd-MMM-yy HH:mm:ss zzz",
 			"EEE MMM dd HH:mm:ss yyyy"
 	};
 
 	private static TimeZone GMT = TimeZone.getTimeZone("GMT");
 
 	private volatile String[] outboundHeaderNames = new String[0];
 
 	private volatile String[] inboundHeaderNames = new String[0];
 
 	private volatile String[] excludedOutboundStandardRequestHeaderNames = new String[0];
 
 	private volatile String[] excludedInboundStandardResponseHeaderNames = new String[0];
 
 	private volatile String userDefinedHeaderPrefix = "X-";
 
 	public void setBeanFactory(BeanFactory beanFactorythrows BeansException {
 		this. = beanFactory;
 	}

Provide the header names that should be mapped to an HTTP request (for outbound adapters) or HTTP response (for inbound adapters) from a Spring Integration Message's headers. The values can also contain simple wildcard patterns (e.g. "foo*" or "*foo") to be matched.

Any non-standard headers will be prefixed with the value specified by setUserDefinedHeaderPrefix(java.lang.String). The default is 'X-'.

Parameters:
outboundHeaderNames The outbound header names.
 
 	public void setOutboundHeaderNames(String[] outboundHeaderNames) {
 		this. = (outboundHeaderNames != null) ? outboundHeaderNames : new String[0];
 	}

Provide the header names that should be mapped from an HTTP request (for inbound adapters) or HTTP response (for outbound adapters) to a Spring Integration Message's headers. The values can also contain simple wildcard patterns (e.g. "foo*" or "*foo") to be matched.

This will match the header name directly or, for non-standard HTTP headers, it will match the header name prefixed with the value specified by setUserDefinedHeaderPrefix(java.lang.String). The default is 'X-'.

Parameters:
inboundHeaderNames The inbound header names.
 
 	public void setInboundHeaderNames(String[] inboundHeaderNames) {
 		this. = (inboundHeaderNames != null) ? inboundHeaderNames : new String[0];
 	}

Provide header names from the list of standard headers that should be suppressed when mapping outbound endpoint request headers.

Parameters:
excludedOutboundStandardRequestHeaderNames the excludedStandardRequestHeaderNames to set
 
 	public void setExcludedOutboundStandardRequestHeaderNames(String[] excludedOutboundStandardRequestHeaderNames) {
 		Assert.notNull(excludedOutboundStandardRequestHeaderNames"'excludedOutboundStandardRequestHeaderNames' must not be null");
 		this. = excludedOutboundStandardRequestHeaderNames;
 	}

Provide header names from the list of standard headers that should be suppressed when mapping inbound endopoint response headers.

Parameters:
excludedInboundStandardResponseHeaderNames the excludedStandardResponseHeaderNames to set
 
 	public void setExcludedInboundStandardResponseHeaderNames(String[] excludedInboundStandardResponseHeaderNames) {
 		Assert.notNull(excludedInboundStandardResponseHeaderNames"'excludedInboundStandardResponseHeaderNames' must not be null");
 		this. = excludedInboundStandardResponseHeaderNames;
 	}

Sets the prefix to use with user-defined (non-standard) headers. Default is 'X-'.

Parameters:
userDefinedHeaderPrefix The user defined header prefix.
 
 	public void setUserDefinedHeaderPrefix(String userDefinedHeaderPrefix) {
 		this. = (userDefinedHeaderPrefix != null) ? userDefinedHeaderPrefix : "";
 	}

Map from the integration MessageHeaders to an HttpHeaders instance. Depending on which type of adapter is using this mapper, the HttpHeaders might be for an HTTP request (outbound adapter) or for an HTTP response (inbound adapter).
 
 	public void fromHeaders(MessageHeaders headersHttpHeaders target) {
 			.debug(MessageFormat.format("outboundHeaderNames={0}", CollectionUtils.arrayToList()));
 		}
 		Set<StringheaderNames = headers.keySet();
 		for (String name : headerNames) {
 			if (this.shouldMapOutboundHeader(name)) {
 				Object value = headers.get(name);
 				if (value != null) {
 						// prefix the user-defined header names if not already prefixed
 
 						name = StringUtils.startsWithIgnoreCase(namethis.) ? name :
 							this. + name;
 					}
 						.debug(MessageFormat.format("setting headerName=[{0}], value={1}"namevalue));
 					}
 					this.setHttpHeader(targetnamevalue);
 				}
 			}
 		}
 	}

Map from an HttpHeaders instance to integration MessageHeaders. Depending on which type of adapter is using this mapper, the HttpHeaders might be from an HTTP request (inbound adapter) or from an HTTP response (outbound adapter).
 
 	public Map<StringObjecttoHeaders(HttpHeaders source) {
 			.debug(MessageFormat.format("inboundHeaderNames={0}", CollectionUtils.arrayToList()));
 		}
 		Map<StringObjecttarget = new HashMap<StringObject>();
 		Set<StringheaderNames = source.keySet();
 		for (String name : headerNames) {
 			if (this.shouldMapInboundHeader(name)) {
 				if (!ObjectUtils.containsElement(name) && !ObjectUtils.containsElement(name)) {
 					String prefixedName = StringUtils.startsWithIgnoreCase(namethis.) ? name :
 						this. + name;
 					Object value = source.containsKey(prefixedName) ? this.getHttpHeader(sourceprefixedName) : this.getHttpHeader(sourcename);
 					if (value != null) {
 							.debug(MessageFormat.format("setting headerName=[{0}], value={1}"namevalue));
 						}
 						this.setMessageHeader(targetnamevalue);
 					}
 				}
 				else {
 					Object value = this.getHttpHeader(sourcename);
 					if (value != null) {
 							.debug(MessageFormat.format("setting headerName=[{0}], value={1}"namevalue));
 						}
 						this.setMessageHeader(targetnamevalue);
 					}
 				}
 			}
 		}
 		return target;
 	}
 
 	public void afterPropertiesSet() throws Exception {
 		if (this. != null){
 			this. = IntegrationUtils.getConversionService(this.);
 		}
 	}
 
 	private boolean containsElementIgnoreCase(String[] headerNamesString name){
 		for (String headerName : headerNames) {
 			if (headerName.equalsIgnoreCase(name)){
 				return true;
 			}
 		}
 		return false;
 	}
 
 	private boolean shouldMapOutboundHeader(String headerName) {
 		if (this. == ) { // a default inbound mapper
 			/*
 			 * When using the default response header name list, suppress the
 			 * mapping of exclusions for specific headers.
 			 */
 					.debug(MessageFormat.format("headerName=[{0}] WILL NOT be mapped"headerName));
 				}
 				return false;
 			}
 		}
 		else if (this. == ) { // a default outbound mapper
 			/*
 			 * When using the default request header name list, suppress the
 			 * mapping of exclusions for specific headers.
 			 */
 					.debug(MessageFormat.format("headerName=[{0}] WILL NOT be mapped"headerName));
 				}
 				return false;
 			}
 		}
 		return this.shouldMapHeader(headerNamethis.);
 	}
 
 	private boolean shouldMapInboundHeader(String headerName) {
 		return this.shouldMapHeader(headerNamethis.);
 	}
 
 	private boolean shouldMapHeader(String headerNameString[] patterns) {
 		if (patterns != null && patterns.length > 0) {
 			for (String pattern : patterns) {
 				if (PatternMatchUtils.simpleMatch(pattern.toLowerCase(), headerName.toLowerCase())) {
 						.debug(MessageFormat.format("headerName=[{0}] WILL be mapped, matched pattern={1}"headerNamepattern));
 					}
 					return true;
 				}
 						.debug(MessageFormat.format("headerName=[{0}] WILL be mapped, matched pattern={1}"headerNamepattern));
 					}
 					return true;
 				}
 						.debug(MessageFormat.format("headerName=[{0}] WILL be mapped, matched pattern={1}"headerNamepattern));
 					}
 					return true;
 				}
 			}
 		}
 			.debug(MessageFormat.format("headerName=[{0}] WILL NOT be mapped"headerName));
 		}
 		return false;
 	}
 
 	private void setHttpHeader(HttpHeaders targetString nameObject value) {
 		if (.equalsIgnoreCase(name)) {
 			if (value instanceof Collection<?>) {
 				Collection<?> values = (Collection<?>) value;
 				if (!CollectionUtils.isEmpty(values)) {
 					List<MediaTypeacceptableMediaTypes = new ArrayList<MediaType>();
 					for (Object type : values) {
 						if (type instanceof MediaType) {
 							acceptableMediaTypes.add((MediaTypetype);
 						}
 						else if (type instanceof String) {
 							acceptableMediaTypes.addAll(MediaType.parseMediaTypes((Stringtype));
 						}
 						else {
 							Class<?> clazz = (type != null) ? type.getClass() : null;
 									"Expected MediaType or String value for 'Accept' header value, but received: " + clazz);
 						}
 					}
 					target.setAccept(acceptableMediaTypes);
 				}
 			}
 			else if (value instanceof MediaType) {
 				target.setAccept(Collections.singletonList((MediaTypevalue));
 			}
 			else if (value instanceof String[]) {
 				List<MediaTypeacceptableMediaTypes = new ArrayList<MediaType>();
 				for (String next : (String[]) value) {
 					acceptableMediaTypes.add(MediaType.parseMediaType(next));
 				}
 				target.setAccept(acceptableMediaTypes);
 			}
 			else if (value instanceof String) {
 				target.setAccept(MediaType.parseMediaTypes((Stringvalue));
 			}
 			else {
 				Class<?> clazz = (value != null) ? value.getClass() : null;
 						"Expected MediaType or String value for 'Accept' header value, but received: " + clazz);
 			}
 		}
 		else if (.equalsIgnoreCase(name)) {
 			if (value instanceof Collection<?>) {
 				Collection<?> values = (Collection<?>) value;
 				if (!CollectionUtils.isEmpty(values)) {
 					List<CharsetacceptableCharsets = new ArrayList<Charset>();
 					for (Object charset : values) {
 						if (charset instanceof Charset) {
 							acceptableCharsets.add((Charsetcharset);
 						}
 						else if (charset instanceof String) {
 							acceptableCharsets.add(Charset.forName((Stringcharset));
 						}
 						else {
 							Class<?> clazz = (charset != null) ? charset.getClass() : null;
 									"Expected Charset or String value for 'Accept-Charset' header value, but received: " + clazz);
 						}
 					}
 					target.setAcceptCharset(acceptableCharsets);
 				}
 			}
 			else if (value instanceof Charset[] || value instanceof String[]) {
 				List<CharsetacceptableCharsets = new ArrayList<Charset>();
 				Object[] values = ObjectUtils.toObjectArray(value);
 				for (Object charset : values) {
 					if (charset instanceof Charset) {
 						acceptableCharsets.add((Charsetcharset);
 					}
 					else if (charset instanceof String) {
 						acceptableCharsets.add(Charset.forName((Stringcharset));
 					}
 				}
 				target.setAcceptCharset(acceptableCharsets);
 			}
 			else if (value instanceof Charset) {
 				target.setAcceptCharset(Collections.singletonList((Charsetvalue));
 			}
 			else if (value instanceof String) {
 				String[] charsets = StringUtils.commaDelimitedListToStringArray((Stringvalue);
 				List<CharsetacceptableCharsets = new ArrayList<Charset>();
 				for (String charset : charsets) {
 					acceptableCharsets.add(Charset.forName(charset.trim()));
 				}
 				target.setAcceptCharset(acceptableCharsets);
 			}
 			else {
 				Class<?> clazz = (value != null) ? value.getClass() : null;
 						"Expected Charset or String value for 'Accept-Charset' header value, but received: " + clazz);
 			}
 		}
 		else if (.equalsIgnoreCase(name)) {
 			if (value instanceof Collection<?>) {
 				Collection<?> values = (Collection<?>) value;
 				if (!CollectionUtils.isEmpty(values)) {
 					Set<HttpMethodallowedMethods = new HashSet<HttpMethod>();
 					for (Object method : values) {
 						if (method instanceof HttpMethod) {
 							allowedMethods.add((HttpMethodmethod);
 						}
 						else if (method instanceof String) {
 							allowedMethods.add(HttpMethod.valueOf((Stringmethod));
 						}
 						else {
 							Class<?> clazz = (method != null) ? method.getClass() : null;
 									"Expected HttpMethod or String value for 'Allow' header value, but received: " + clazz);
 						}
 					}
 					target.setAllow(allowedMethods);
 				}
 			}
 			else {
 				if (value instanceof HttpMethod) {
 					target.setAllow(Collections.singleton((HttpMethodvalue));
 				}
 				else if (value instanceof HttpMethod[]) {
 					Set<HttpMethodallowedMethods = new HashSet<HttpMethod>();
 					for (HttpMethod next : (HttpMethod[]) value) {
 						allowedMethods.add(next);
 					}
 					target.setAllow(allowedMethods);
 				}
 				else if (value instanceof String || value instanceof String[]) {
 					String[] values = (value instanceof String[]) ? (String[]) value
 							: StringUtils.commaDelimitedListToStringArray((Stringvalue);
 					Set<HttpMethodallowedMethods = new HashSet<HttpMethod>();
 					for (String next : values) {
 						allowedMethods.add(HttpMethod.valueOf(next.trim()));
 					}
 					target.setAllow(allowedMethods);
 				}
 				else {
 					Class<?> clazz = (value != null) ? value.getClass() : null;
 							"Expected HttpMethod or String value for 'Allow' header value, but received: " + clazz);
 				}
 			}
 		}
 		else if (.equalsIgnoreCase(name)) {
 			if (value instanceof String) {
 				target.setCacheControl((Stringvalue);
 			}
 			else {
 				Class<?> clazz = (value != null) ? value.getClass() : null;
 						"Expected String value for 'Cache-Control' header value, but received: " + clazz);
 			}
 		}
 		else if (.equalsIgnoreCase(name)) {
 			if (value instanceof Number) {
 				target.setContentLength(((Numbervalue).longValue());
 			}
 			else if (value instanceof String) {
 				target.setContentLength(Long.parseLong((Stringvalue));
 			}
 			else {
 				Class<?> clazz = (value != null) ? value.getClass() : null;
 						"Expected Number or String value for 'Content-Length' header value, but received: " + clazz);
 			}
 		}
 		else if (.equalsIgnoreCase(name)) {
 			if (value instanceof MediaType) {
 				target.setContentType((MediaTypevalue);
 			}
 			else if (value instanceof String) {
 				target.setContentType(MediaType.parseMediaType((Stringvalue));
 			}
 			else {
 				Class<?> clazz = (value != null) ? value.getClass() : null;
 						"Expected MediaType or String value for 'Content-Type' header value, but received: " + clazz);
 			}
 		}
 		else if (.equalsIgnoreCase(name)) {
 			if (value instanceof Date) {
 				target.setDate(((Datevalue).getTime());
 			}
 			else if (value instanceof Number) {
 				target.setDate(((Numbervalue).longValue());
 			}
 			else if (value instanceof String) {
 				try {
 					target.setDate(Long.parseLong((Stringvalue));
 				}
 				catch (NumberFormatException e) {
 					target.setDate(this.getFirstDate((Stringvalue));
 				}
 			}
 			else {
 				Class<?> clazz = (value != null) ? value.getClass() : null;
 						"Expected Date, Number, or String value for 'Date' header value, but received: " + clazz);
 			}
 		}
 		else if (.equalsIgnoreCase(name)) {
 			if (value instanceof String) {
 				target.setETag((Stringvalue);
 			}
 			else {
 				Class<?> clazz = (value != null) ? value.getClass() : null;
 						"Expected String value for 'ETag' header value, but received: " + clazz);
 			}
 		}
 		else if (.equalsIgnoreCase(name)) {
 			if (value instanceof Date) {
 				target.setExpires(((Datevalue).getTime());
 			}
 			else if (value instanceof Number) {
 				target.setExpires(((Numbervalue).longValue());
 			}
 			else if (value instanceof String) {
 				try {
 					target.setExpires(Long.parseLong((Stringvalue));
 				}
 				catch (NumberFormatException e) {
 					target.setExpires(this.getFirstDate((Stringvalue));
 				}
 			}
 			else {
 				Class<?> clazz = (value != null) ? value.getClass() : null;
 						"Expected Date, Number, or String value for 'Expires' header value, but received: " + clazz);
 			}
 		}
 		else if (.equalsIgnoreCase(name)) {
 			if (value instanceof Date) {
 				target.setIfModifiedSince(((Datevalue).getTime());
 			}
 			else if (value instanceof Number) {
 				target.setIfModifiedSince(((Numbervalue).longValue());
 			}
 			else if (value instanceof String) {
 				try {
 					target.setIfModifiedSince(Long.parseLong((Stringvalue));
 				}
 				catch (NumberFormatException e) {
 				}
 			}
 			else {
 				Class<?> clazz = (value != null) ? value.getClass() : null;
 						"Expected Date, Number, or String value for 'If-Modified-Since' header value, but received: " + clazz);
 			}
 		}
 			String ifUnmodifiedSinceValue = null;
 			if (value instanceof Date) {
 				ifUnmodifiedSinceValue = this.formatDate(((Datevalue).getTime());
 			}
 			else if (value instanceof Number) {
 				ifUnmodifiedSinceValue = this.formatDate(((Numbervalue).longValue());
 			}
 			else if (value instanceof String) {
 				try {
 					ifUnmodifiedSinceValue = this.formatDate(Long.parseLong((Stringvalue));
 				}
 				catch (NumberFormatException e) {
 					long longValue = this.getFirstDate((Stringvalue);
 					ifUnmodifiedSinceValue = this.formatDate(longValue);
 				}
 			}
 			else {
 				Class<?> clazz = (value != null) ? value.getClass() : null;
 						"Expected Date, Number, or String value for 'If-Unmodified-Since' header value, but received: " + clazz);
 			}
 			target.set(ifUnmodifiedSinceValue);
 		}
 		else if (.equalsIgnoreCase(name)) {
 			if (value instanceof String) {
 				target.setIfNoneMatch((Stringvalue);
 			}
 			else if (value instanceof String[]) {
 				String delmitedString = StringUtils.arrayToCommaDelimitedString((String[]) value);
 				target.setIfNoneMatch(delmitedString);
 			}
 			else if (value instanceof Collection) {
 				Collection<?> values = (Collection<?>) value;
 				if (!CollectionUtils.isEmpty(values)) {
 					List<StringifNoneMatchList = new ArrayList<String>();
 					for (Object next : values) {
 						if (next instanceof String) {
 							ifNoneMatchList.add((Stringnext);
 						}
 						else {
 							Class<?> clazz = (next != null) ? next.getClass() : null;
 									"Expected String value for 'If-None-Match' header value, but received: " + clazz);
 						}
 					}
 					target.setIfNoneMatch(ifNoneMatchList);
 				}
 			}
 		}
 		else if (.equalsIgnoreCase(name)) {
 			if (value instanceof Date) {
 				target.setLastModified(((Datevalue).getTime());
 			}
 			else if (value instanceof Number) {
 				target.setLastModified(((Numbervalue).longValue());
 			}
 			else if (value instanceof String) {
 				try {
 					target.setLastModified(Long.parseLong((Stringvalue));
 				}
 				catch (NumberFormatException e) {
 				}
 			}
 			else {
 				Class<?> clazz = (value != null) ? value.getClass() : null;
 						"Expected Date, Number, or String value for 'Last-Modified' header value, but received: " + clazz);
 			}
 		}
 		else if (.equalsIgnoreCase(name)) {
 			if (value instanceof URI) {
 				target.setLocation((URIvalue);
 			}
 			else if (value instanceof String) {
 				try {
 					target.setLocation(new URI((Stringvalue));
 				}
 				catch (URISyntaxException e) {
 					throw new IllegalArgumentException(e);
 				}
 			}
 			else {
 				Class<?> clazz = (value != null) ? value.getClass() : null;
 						"Expected URI or String value for 'Location' header value, but received: " + clazz);
 			}
 		}
 		else if (.equalsIgnoreCase(name)) {
 			if (value instanceof String) {
 				target.setPragma((Stringvalue);
 			}
 			else {
 				Class<?> clazz = (value != null) ? value.getClass() : null;
 						"Expected String value for 'Pragma' header value, but received: " + clazz);
 			}
 		}
 		else if (value instanceof String) {
 			target.set(name, (Stringvalue);
 		}
 		else if (value instanceof String[]) {
 			for (String next : (String[]) value) {
 				target.add(namenext);
 			}
 		}
 		else if (value instanceof Iterable<?>) {
 			for (Object next : (Iterable<?>) value) {
 				String convertedValue = null;
 				if (next instanceof String) {
 					convertedValue = (Stringnext;
 				}
 				else {
 					convertedValue = this.convertToString(value);
 				}
 				if (StringUtils.hasText(convertedValue)){
 					target.add(name, (Stringnext);
 				}
 				else {
 					.warn("Element of the header '" + name + "' with value '" + value +
 							"' will not be set since it is not a String and no Converter " +
 							"is available. Consider registering a Converter with ConversionService (e.g., <int:converter>)");
 				}
 			}
 		}
 		else {
 			String convertedValue = this.convertToString(value);
 			if (StringUtils.hasText(convertedValue)) {
 				target.set(nameconvertedValue);
 			}
 			else {
 				.warn("Header '" + name + "' with value '" + value +
 						"' will not be set since it is not a String and no Converter " +
 						"is available. Consider registering a Converter with ConversionService (e.g., <int:converter>)");
 			}
 		}
 	}
 
 	private Object getHttpHeader(HttpHeaders sourceString name) {
 		if (.equalsIgnoreCase(name)) {
 			return source.getAccept();
 		}
 		else if (.equalsIgnoreCase(name)) {
 			return source.getAcceptCharset();
 		}
 		else if (.equalsIgnoreCase(name)) {
 			return source.getAllow();
 		}
 		else if (.equalsIgnoreCase(name)) {
 			String cacheControl = source.getCacheControl();
 			return (StringUtils.hasText(cacheControl)) ? cacheControl : null;
 		}
 		else if (.equalsIgnoreCase(name)) {
 			long contentLength = source.getContentLength();
 			return (contentLength > -1) ? contentLength : null;
 		}
 		else if (.equalsIgnoreCase(name)) {
 			return source.getContentType();
 		}
 		else if (.equalsIgnoreCase(name)) {
 			long date = source.getDate();
 			return (date > -1) ? date : null;
 		}
 		else if (.equalsIgnoreCase(name)) {
 			String eTag = source.getETag();
 			return (StringUtils.hasText(eTag)) ? eTag : null;
 		}
 		else if (.equalsIgnoreCase(name)) {
 			try {
 				long expires = source.getExpires();
 				return (expires > -1) ? expires : null;
 			}
 			catch (Exception e) {
 				}
 				// According to RFC 2616
 				return null;
 			}
 		}
 		else if (.equalsIgnoreCase(name)) {
 			return source.getIfNoneMatch();
 		}
 		else if (.equalsIgnoreCase(name)) {
 			long modifiedSince = source.getIfModifiedSince();
 			return (modifiedSince > -1) ? modifiedSince : null;
 		}
 			String unmodifiedSince = source.getFirst();
 			return unmodifiedSince != null ? this.getFirstDate(unmodifiedSince) : null;
 		}
 		else if (.equalsIgnoreCase(name)) {
 			long lastModified = source.getLastModified();
 			return (lastModified > -1) ? lastModified : null;
 		}
 		else if (.equalsIgnoreCase(name)) {
 			return source.getLocation();
 		}
 		else if (.equalsIgnoreCase(name)) {
 			String pragma = source.getPragma();
 			return (StringUtils.hasText(pragma)) ? pragma : null;
 		}
 		return source.get(name);
 	}
 
 	private void setMessageHeader(Map<StringObjecttargetString nameObject value) {
 		if (ObjectUtils.isArray(value)) {
 			Object[] values = ObjectUtils.toObjectArray(value);
 			if (!ObjectUtils.isEmpty(values)) {
 				if (values.length == 1) {
 					target.put(namevalues);
 				}
 				else {
 					target.put(namevalues[0]);
 				}
 			}
 		}
 		else if (value instanceof Collection<?>) {
 			Collection<?> values = (Collection<?>) value;
 			if (!CollectionUtils.isEmpty(values)) {
 				if (values.size() == 1) {
 					target.put(namevalues.iterator().next());
 				}
 				else {
 					target.put(namevalues);
 				}
 			}
 		}
 		else if (value != null) {
 			target.put(namevalue);
 		}
 	}
 
 	private String convertToString(Object value){
 		if (this. != null &&
 				this..canConvert(TypeDescriptor.forObject(value), TypeDescriptor.valueOf(String.class))){
 			return this..convert(valueString.class);
 		}
 		return null;
 	}
 
 	// Utility methods
 
 	private long getFirstDate(String headerValueString headerName) {
 		for (String dateFormat : ) {
 			DateFormat simpleDateFormat = new SimpleDateFormat(dateFormat.);
 			simpleDateFormat.setTimeZone();
 			try {
 				return simpleDateFormat.parse(headerValue).getTime();
 			}
 			catch (ParseException e) {
 				// ignore
 			}
 		}
 		throw new IllegalArgumentException("Cannot parse date value '" + headerValue +"' for '" + headerName + "' header");
 	}
 
 	private String formatDate(long date) {
 		DateFormat dateFormat = new SimpleDateFormat([0], .);
 		dateFormat.setTimeZone();
 		return dateFormat.format(new Date(date));
 	}

Factory method for creating a basic outbound mapper instance. This will map all standard HTTP request headers when sending an HTTP request, and it will map all standard HTTP response headers when receiving an HTTP response.

Returns:
The default outbound mapper.
		return mapper;
	}

Factory method for creating a basic inbound mapper instance. This will map all standard HTTP request headers when receiving an HTTP request, and it will map all standard HTTP response headers when sending an HTTP response.

Returns:
The default inbound mapper.
		return mapper;