Find Usages Diff Raw Download HTML Widget
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions 
1
   /*
2
    * Copyright 2002-2014 the original author or authors.
3
    *
4
    * Licensed under the Apache License, Version 2.0 (the "License");
5
    * you may not use this file except in compliance with the License.
6
    * You may obtain a copy of the License at
7
    *
8
    *      http://www.apache.org/licenses/LICENSE-2.0
9
    *
10
   * Unless required by applicable law or agreed to in writing, software
11
   * distributed under the License is distributed on an "AS IS" BASIS,
12
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13
   * See the License for the specific language governing permissions and
14
   * limitations under the License.
15
   */
16
  
17
  package org.springframework.integration.http.support;
18
  
19
  import java.net.URI;
29
  import java.util.Date;
30
  import java.util.HashMap;
31
  import java.util.HashSet;
32
  import java.util.List;
33
  import java.util.Locale;
34
  import java.util.Map;
35
  import java.util.Set;
37
  
40
  
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
69
  
71
  
72
  	private static final Log logger = LogFactory.getLog(DefaultHttpHeaderMapper.class);
73
  
74
  	private volatile ConversionService conversionService;
75
  
76
  	private volatile BeanFactory beanFactory;
77
  
78
  	private static final String ACCEPT = "Accept";
79
  
80
  	private static final String ACCEPT_CHARSET = "Accept-Charset";
81
  
82
  	private static final String ACCEPT_ENCODING = "Accept-Encoding";
83
  
84
  	private static final String ACCEPT_LANGUAGE = "Accept-Language";
85
  
86
  	private static final String ACCEPT_RANGES = "Accept-Ranges";
87
  
88
  	private static final String AGE = "Age";
89
  
90
  	private static final String ALLOW = "Allow";
91
  
92
  	private static final String AUTHORIZATION = "Authorization";
93
  
94
  	private static final String CACHE_CONTROL = "Cache-Control";
95
  
96
  	private static final String CONNECTION = "Connection";
97
  
98
  	private static final String CONTENT_ENCODING = "Content-Encoding";
99
  
100
 	private static final String CONTENT_LANGUAGE = "Content-Language";
101
 
102
 	private static final String CONTENT_LENGTH = "Content-Length";
103
 
104
 	private static final String CONTENT_LOCATION = "Content-Location";
105
 
106
 	private static final String CONTENT_MD5 = "Content-MD5";
107
 
108
 	private static final String CONTENT_RANGE = "Content-Range";
109
 
110
 	private static final String CONTENT_TYPE = "Content-Type";
111
 
112
 	public  static final String COOKIE = "Cookie";
113
 
114
 	private static final String DATE = "Date";
115
 
116
 	private static final String ETAG = "ETag";
117
 
118
 	private static final String EXPECT = "Expect";
119
 
120
 	private static final String EXPIRES = "Expires";
121
 
122
 	private static final String FROM = "From";
123
 
124
 	private static final String HOST = "Host";
125
 
126
 	private static final String IF_MATCH = "If-Match";
127
 
128
 	private static final String IF_MODIFIED_SINCE = "If-Modified-Since";
129
 
130
 	private static final String IF_NONE_MATCH = "If-None-Match";
131
 
132
 	private static final String IF_RANGE = "If-Range";
133
 
134
 	private static final String IF_UNMODIFIED_SINCE = "If-Unmodified-Since";
135
 
136
 	private static final String LAST_MODIFIED = "Last-Modified";
137
 
138
 	private static final String LOCATION = "Location";
139
 
140
 	private static final String MAX_FORWARDS = "Max-Forwards";
141
 
142
 	private static final String PRAGMA = "Pragma";
143
 
144
 	private static final String PROXY_AUTHENTICATE = "Proxy-Authenticate";
145
 
146
 	private static final String PROXY_AUTHORIZATION = "Proxy-Authorization";
147
 
148
 	private static final String RANGE = "Range";
149
 
150
 	private static final String REFERER = "Referer";
151
 
152
 	private static final String REFRESH = "Refresh";
153
 
154
 	private static final String RETRY_AFTER = "Retry-After";
155
 
156
 	private static final String SERVER = "Server";
157
 
158
 	public  static final String SET_COOKIE = "Set-Cookie";
159
 
160
 	private static final String TE = "TE";
161
 
162
 	private static final String TRAILER = "Trailer";
163
 
164
 	private static final String UPGRADE = "Upgrade";
165
 
166
 	private static final String USER_AGENT = "User-Agent";
167
 
168
 	private static final String VARY = "Vary";
169
 
170
 	private static final String VIA = "Via";
171
 
172
 	private static final String WARNING = "Warning";
173
 
174
 	private static final String WWW_AUTHENTICATE = "WWW-Authenticate";
175
 
176
 	private static final String[] HTTP_REQUEST_HEADER_NAMES = new String[] {
202
 			,
205
 			,
207
 	};
208
 
209
 	private static String[] HTTP_RESPONSE_HEADER_NAMES = new String[] {
211
 			,
235
 			,
238
 	};
239
 
241
 
244
 	};
245
 
246
 	public static final String HTTP_REQUEST_HEADER_NAME_PATTERN = "HTTP_REQUEST_HEADERS";
247
 
248
 	public static final String HTTP_RESPONSE_HEADER_NAME_PATTERN = "HTTP_RESPONSE_HEADERS";
249
 
250
 	// Copy of 'org.springframework.http.HttpHeaders#DATE_FORMATS'
251
 	private static final String[] DATE_FORMATS = new String[] {
252
 			"EEE, dd MMM yyyy HH:mm:ss zzz",
253
 			"EEE, dd-MMM-yy HH:mm:ss zzz",
254
 			"EEE MMM dd HH:mm:ss yyyy"
255
 	};
256
 
257
 	private static TimeZone GMT = TimeZone.getTimeZone("GMT");
258
 
259
 	private volatile String[] outboundHeaderNames = new String[0];
260
 
261
 	private volatile String[] inboundHeaderNames = new String[0];
262
 
263
 	private volatile String[] excludedOutboundStandardRequestHeaderNames = new String[0];
264
 
265
 	private volatile String[] excludedInboundStandardResponseHeaderNames = new String[0];
266
 
267
 	private volatile String userDefinedHeaderPrefix = "X-";
268
 
270
 	public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
271
 		this. = beanFactory;
272
 	}
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.
283
 
284
 	public void setOutboundHeaderNames(String[] outboundHeaderNames) {
285
 		this. = (outboundHeaderNames != null) ? outboundHeaderNames : new String[0];
286
 	}
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.
298
 
299
 	public void setInboundHeaderNames(String[] inboundHeaderNames) {
300
 		this. = (inboundHeaderNames != null) ? inboundHeaderNames : new String[0];
301
 	}
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
307
 
308
 	public void setExcludedOutboundStandardRequestHeaderNames(String[] excludedOutboundStandardRequestHeaderNames) {
309
 		Assert.notNull(excludedOutboundStandardRequestHeaderNames, "'excludedOutboundStandardRequestHeaderNames' must not be null");
310
 		this. = excludedOutboundStandardRequestHeaderNames;
311
 	}
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
317
 
318
 	public void setExcludedInboundStandardResponseHeaderNames(String[] excludedInboundStandardResponseHeaderNames) {
319
 		Assert.notNull(excludedInboundStandardResponseHeaderNames, "'excludedInboundStandardResponseHeaderNames' must not be null");
320
 		this. = excludedInboundStandardResponseHeaderNames;
321
 	}
Sets the prefix to use with user-defined (non-standard) headers. Default is 'X-'.

Parameters:
userDefinedHeaderPrefix The user defined header prefix.
327
 
328
 	public void setUserDefinedHeaderPrefix(String userDefinedHeaderPrefix) {
329
 		this. = (userDefinedHeaderPrefix != null) ? userDefinedHeaderPrefix : "";
330
 	}
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). 
336
 
338
 	public void fromHeaders(MessageHeaders headers, HttpHeaders target) {
340
 			.debug(MessageFormat.format("outboundHeaderNames={0}", CollectionUtils.arrayToList()));
341
 		}
342
 		Set<String> headerNames = headers.keySet();
343
 		for (String name : headerNames) {
344
 			if (this.shouldMapOutboundHeader(name)) {
345
 				Object value = headers.get(name);
346
 				if (value != null) {
349
 						// prefix the user-defined header names if not already prefixed
350
 
351
 						name = StringUtils.startsWithIgnoreCase(name, this.) ? name :
352
 							this. + name;
353
 					}
355
 						.debug(MessageFormat.format("setting headerName=[{0}], value={1}", name, value));
356
 					}
357
 					this.setHttpHeader(target, name, value);
358
 				}
359
 			}
360
 		}
361
 	}
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). 
367
 
369
 	public Map<String, Object> toHeaders(HttpHeaders source) {
371
 			.debug(MessageFormat.format("inboundHeaderNames={0}", CollectionUtils.arrayToList()));
372
 		}
373
 		Map<String, Object> target = new HashMap<String, Object>();
374
 		Set<String> headerNames = source.keySet();
375
 		for (String name : headerNames) {
376
 			if (this.shouldMapInboundHeader(name)) {
377
 				if (!ObjectUtils.containsElement(, name) && !ObjectUtils.containsElement(, name)) {
378
 					String prefixedName = StringUtils.startsWithIgnoreCase(name, this.) ? name :
379
 						this. + name;
380
 					Object value = source.containsKey(prefixedName) ? this.getHttpHeader(source, prefixedName) : this.getHttpHeader(source, name);
381
 					if (value != null) {
383
 							.debug(MessageFormat.format("setting headerName=[{0}], value={1}", name, value));
384
 						}
385
 						this.setMessageHeader(target, name, value);
386
 					}
387
 				}
388
 				else {
389
 					Object value = this.getHttpHeader(source, name);
390
 					if (value != null) {
392
 							.debug(MessageFormat.format("setting headerName=[{0}], value={1}", name, value));
393
 						}
394
 						this.setMessageHeader(target, name, value);
395
 					}
396
 				}
397
 			}
398
 		}
399
 		return target;
400
 	}
401
 
403
 	public void afterPropertiesSet() throws Exception {
404
 		if (this. != null){
405
 			this. = IntegrationUtils.getConversionService(this.);
406
 		}
407
 	}
408
 
409
 	private boolean containsElementIgnoreCase(String[] headerNames, String name){
410
 		for (String headerName : headerNames) {
411
 			if (headerName.equalsIgnoreCase(name)){
412
 				return true;
413
 			}
414
 		}
415
 		return false;
416
 	}
417
 
418
 	private boolean shouldMapOutboundHeader(String headerName) {
419
 		if (this. == ) { // a default inbound mapper
420
 			/*
421
 			 * When using the default response header name list, suppress the
422
 			 * mapping of exclusions for specific headers.
423
 			 */
426
 					.debug(MessageFormat.format("headerName=[{0}] WILL NOT be mapped", headerName));
427
 				}
428
 				return false;
429
 			}
430
 		}
431
 		else if (this. == ) { // a default outbound mapper
432
 			/*
433
 			 * When using the default request header name list, suppress the
434
 			 * mapping of exclusions for specific headers.
435
 			 */
438
 					.debug(MessageFormat.format("headerName=[{0}] WILL NOT be mapped", headerName));
439
 				}
440
 				return false;
441
 			}
442
 		}
443
 		return this.shouldMapHeader(headerName, this.);
444
 	}
445
 
446
 	private boolean shouldMapInboundHeader(String headerName) {
447
 		return this.shouldMapHeader(headerName, this.);
448
 	}
449
 
450
 	private boolean shouldMapHeader(String headerName, String[] patterns) {
451
 		if (patterns != null && patterns.length > 0) {
452
 			for (String pattern : patterns) {
453
 				if (PatternMatchUtils.simpleMatch(pattern.toLowerCase(), headerName.toLowerCase())) {
455
 						.debug(MessageFormat.format("headerName=[{0}] WILL be mapped, matched pattern={1}", headerName, pattern));
456
 					}
457
 					return true;
458
 				}
462
 						.debug(MessageFormat.format("headerName=[{0}] WILL be mapped, matched pattern={1}", headerName, pattern));
463
 					}
464
 					return true;
465
 				}
469
 						.debug(MessageFormat.format("headerName=[{0}] WILL be mapped, matched pattern={1}", headerName, pattern));
470
 					}
471
 					return true;
472
 				}
473
 			}
474
 		}
476
 			.debug(MessageFormat.format("headerName=[{0}] WILL NOT be mapped", headerName));
477
 		}
478
 		return false;
479
 	}
480
 
481
 	private void setHttpHeader(HttpHeaders target, String name, Object value) {
482
 		if (.equalsIgnoreCase(name)) {
483
 			if (value instanceof Collection<?>) {
484
 				Collection<?> values = (Collection<?>) value;
485
 				if (!CollectionUtils.isEmpty(values)) {
486
 					List<MediaType> acceptableMediaTypes = new ArrayList<MediaType>();
487
 					for (Object type : values) {
488
 						if (type instanceof MediaType) {
489
 							acceptableMediaTypes.add((MediaType) type);
490
 						}
491
 						else if (type instanceof String) {
492
 							acceptableMediaTypes.addAll(MediaType.parseMediaTypes((String) type));
493
 						}
494
 						else {
495
 							Class<?> clazz = (type != null) ? type.getClass() : null;
497
 									"Expected MediaType or String value for 'Accept' header value, but received: " + clazz);
498
 						}
499
 					}
500
 					target.setAccept(acceptableMediaTypes);
501
 				}
502
 			}
503
 			else if (value instanceof MediaType) {
504
 				target.setAccept(Collections.singletonList((MediaType) value));
505
 			}
506
 			else if (value instanceof String[]) {
507
 				List<MediaType> acceptableMediaTypes = new ArrayList<MediaType>();
508
 				for (String next : (String[]) value) {
509
 					acceptableMediaTypes.add(MediaType.parseMediaType(next));
510
 				}
511
 				target.setAccept(acceptableMediaTypes);
512
 			}
513
 			else if (value instanceof String) {
514
 				target.setAccept(MediaType.parseMediaTypes((String) value));
515
 			}
516
 			else {
517
 				Class<?> clazz = (value != null) ? value.getClass() : null;
519
 						"Expected MediaType or String value for 'Accept' header value, but received: " + clazz);
520
 			}
521
 		}
522
 		else if (.equalsIgnoreCase(name)) {
523
 			if (value instanceof Collection<?>) {
524
 				Collection<?> values = (Collection<?>) value;
525
 				if (!CollectionUtils.isEmpty(values)) {
526
 					List<Charset> acceptableCharsets = new ArrayList<Charset>();
527
 					for (Object charset : values) {
528
 						if (charset instanceof Charset) {
529
 							acceptableCharsets.add((Charset) charset);
530
 						}
531
 						else if (charset instanceof String) {
532
 							acceptableCharsets.add(Charset.forName((String) charset));
533
 						}
534
 						else {
535
 							Class<?> clazz = (charset != null) ? charset.getClass() : null;
537
 									"Expected Charset or String value for 'Accept-Charset' header value, but received: " + clazz);
538
 						}
539
 					}
540
 					target.setAcceptCharset(acceptableCharsets);
541
 				}
542
 			}
543
 			else if (value instanceof Charset[] || value instanceof String[]) {
544
 				List<Charset> acceptableCharsets = new ArrayList<Charset>();
545
 				Object[] values = ObjectUtils.toObjectArray(value);
546
 				for (Object charset : values) {
547
 					if (charset instanceof Charset) {
548
 						acceptableCharsets.add((Charset) charset);
549
 					}
550
 					else if (charset instanceof String) {
551
 						acceptableCharsets.add(Charset.forName((String) charset));
552
 					}
553
 				}
554
 				target.setAcceptCharset(acceptableCharsets);
555
 			}
556
 			else if (value instanceof Charset) {
557
 				target.setAcceptCharset(Collections.singletonList((Charset) value));
558
 			}
559
 			else if (value instanceof String) {
560
 				String[] charsets = StringUtils.commaDelimitedListToStringArray((String) value);
561
 				List<Charset> acceptableCharsets = new ArrayList<Charset>();
562
 				for (String charset : charsets) {
563
 					acceptableCharsets.add(Charset.forName(charset.trim()));
564
 				}
565
 				target.setAcceptCharset(acceptableCharsets);
566
 			}
567
 			else {
568
 				Class<?> clazz = (value != null) ? value.getClass() : null;
570
 						"Expected Charset or String value for 'Accept-Charset' header value, but received: " + clazz);
571
 			}
572
 		}
573
 		else if (.equalsIgnoreCase(name)) {
574
 			if (value instanceof Collection<?>) {
575
 				Collection<?> values = (Collection<?>) value;
576
 				if (!CollectionUtils.isEmpty(values)) {
577
 					Set<HttpMethod> allowedMethods = new HashSet<HttpMethod>();
578
 					for (Object method : values) {
579
 						if (method instanceof HttpMethod) {
580
 							allowedMethods.add((HttpMethod) method);
581
 						}
582
 						else if (method instanceof String) {
583
 							allowedMethods.add(HttpMethod.valueOf((String) method));
584
 						}
585
 						else {
586
 							Class<?> clazz = (method != null) ? method.getClass() : null;
588
 									"Expected HttpMethod or String value for 'Allow' header value, but received: " + clazz);
589
 						}
590
 					}
591
 					target.setAllow(allowedMethods);
592
 				}
593
 			}
594
 			else {
595
 				if (value instanceof HttpMethod) {
596
 					target.setAllow(Collections.singleton((HttpMethod) value));
597
 				}
598
 				else if (value instanceof HttpMethod[]) {
599
 					Set<HttpMethod> allowedMethods = new HashSet<HttpMethod>();
600
 					for (HttpMethod next : (HttpMethod[]) value) {
601
 						allowedMethods.add(next);
602
 					}
603
 					target.setAllow(allowedMethods);
604
 				}
605
 				else if (value instanceof String || value instanceof String[]) {
606
 					String[] values = (value instanceof String[]) ? (String[]) value
607
 							: StringUtils.commaDelimitedListToStringArray((String) value);
608
 					Set<HttpMethod> allowedMethods = new HashSet<HttpMethod>();
609
 					for (String next : values) {
610
 						allowedMethods.add(HttpMethod.valueOf(next.trim()));
611
 					}
612
 					target.setAllow(allowedMethods);
613
 				}
614
 				else {
615
 					Class<?> clazz = (value != null) ? value.getClass() : null;
617
 							"Expected HttpMethod or String value for 'Allow' header value, but received: " + clazz);
618
 				}
619
 			}
620
 		}
621
 		else if (.equalsIgnoreCase(name)) {
622
 			if (value instanceof String) {
623
 				target.setCacheControl((String) value);
624
 			}
625
 			else {
626
 				Class<?> clazz = (value != null) ? value.getClass() : null;
628
 						"Expected String value for 'Cache-Control' header value, but received: " + clazz);
629
 			}
630
 		}
631
 		else if (.equalsIgnoreCase(name)) {
632
 			if (value instanceof Number) {
633
 				target.setContentLength(((Number) value).longValue());
634
 			}
635
 			else if (value instanceof String) {
636
 				target.setContentLength(Long.parseLong((String) value));
637
 			}
638
 			else {
639
 				Class<?> clazz = (value != null) ? value.getClass() : null;
641
 						"Expected Number or String value for 'Content-Length' header value, but received: " + clazz);
642
 			}
643
 		}
644
 		else if (.equalsIgnoreCase(name)) {
645
 			if (value instanceof MediaType) {
646
 				target.setContentType((MediaType) value);
647
 			}
648
 			else if (value instanceof String) {
649
 				target.setContentType(MediaType.parseMediaType((String) value));
650
 			}
651
 			else {
652
 				Class<?> clazz = (value != null) ? value.getClass() : null;
654
 						"Expected MediaType or String value for 'Content-Type' header value, but received: " + clazz);
655
 			}
656
 		}
657
 		else if (.equalsIgnoreCase(name)) {
658
 			if (value instanceof Date) {
659
 				target.setDate(((Date) value).getTime());
660
 			}
661
 			else if (value instanceof Number) {
662
 				target.setDate(((Number) value).longValue());
663
 			}
664
 			else if (value instanceof String) {
665
 				try {
666
 					target.setDate(Long.parseLong((String) value));
667
 				}
668
 				catch (NumberFormatException e) {
669
 					target.setDate(this.getFirstDate((String) value, ));
670
 				}
671
 			}
672
 			else {
673
 				Class<?> clazz = (value != null) ? value.getClass() : null;
675
 						"Expected Date, Number, or String value for 'Date' header value, but received: " + clazz);
676
 			}
677
 		}
678
 		else if (.equalsIgnoreCase(name)) {
679
 			if (value instanceof String) {
680
 				target.setETag((String) value);
681
 			}
682
 			else {
683
 				Class<?> clazz = (value != null) ? value.getClass() : null;
685
 						"Expected String value for 'ETag' header value, but received: " + clazz);
686
 			}
687
 		}
688
 		else if (.equalsIgnoreCase(name)) {
689
 			if (value instanceof Date) {
690
 				target.setExpires(((Date) value).getTime());
691
 			}
692
 			else if (value instanceof Number) {
693
 				target.setExpires(((Number) value).longValue());
694
 			}
695
 			else if (value instanceof String) {
696
 				try {
697
 					target.setExpires(Long.parseLong((String) value));
698
 				}
699
 				catch (NumberFormatException e) {
700
 					target.setExpires(this.getFirstDate((String) value, ));
701
 				}
702
 			}
703
 			else {
704
 				Class<?> clazz = (value != null) ? value.getClass() : null;
706
 						"Expected Date, Number, or String value for 'Expires' header value, but received: " + clazz);
707
 			}
708
 		}
709
 		else if (.equalsIgnoreCase(name)) {
710
 			if (value instanceof Date) {
711
 				target.setIfModifiedSince(((Date) value).getTime());
712
 			}
713
 			else if (value instanceof Number) {
714
 				target.setIfModifiedSince(((Number) value).longValue());
715
 			}
716
 			else if (value instanceof String) {
717
 				try {
718
 					target.setIfModifiedSince(Long.parseLong((String) value));
719
 				}
720
 				catch (NumberFormatException e) {
722
 				}
723
 			}
724
 			else {
725
 				Class<?> clazz = (value != null) ? value.getClass() : null;
727
 						"Expected Date, Number, or String value for 'If-Modified-Since' header value, but received: " + clazz);
728
 			}
729
 		}
731
 			String ifUnmodifiedSinceValue = null;
732
 			if (value instanceof Date) {
733
 				ifUnmodifiedSinceValue = this.formatDate(((Date) value).getTime());
734
 			}
735
 			else if (value instanceof Number) {
736
 				ifUnmodifiedSinceValue = this.formatDate(((Number) value).longValue());
737
 			}
738
 			else if (value instanceof String) {
739
 				try {
740
 					ifUnmodifiedSinceValue = this.formatDate(Long.parseLong((String) value));
741
 				}
742
 				catch (NumberFormatException e) {
743
 					long longValue = this.getFirstDate((String) value, );
744
 					ifUnmodifiedSinceValue = this.formatDate(longValue);
745
 				}
746
 			}
747
 			else {
748
 				Class<?> clazz = (value != null) ? value.getClass() : null;
750
 						"Expected Date, Number, or String value for 'If-Unmodified-Since' header value, but received: " + clazz);
751
 			}
752
 			target.set(, ifUnmodifiedSinceValue);
753
 		}
754
 		else if (.equalsIgnoreCase(name)) {
755
 			if (value instanceof String) {
756
 				target.setIfNoneMatch((String) value);
757
 			}
758
 			else if (value instanceof String[]) {
759
 				String delmitedString = StringUtils.arrayToCommaDelimitedString((String[]) value);
760
 				target.setIfNoneMatch(delmitedString);
761
 			}
762
 			else if (value instanceof Collection) {
763
 				Collection<?> values = (Collection<?>) value;
764
 				if (!CollectionUtils.isEmpty(values)) {
765
 					List<String> ifNoneMatchList = new ArrayList<String>();
766
 					for (Object next : values) {
767
 						if (next instanceof String) {
768
 							ifNoneMatchList.add((String) next);
769
 						}
770
 						else {
771
 							Class<?> clazz = (next != null) ? next.getClass() : null;
773
 									"Expected String value for 'If-None-Match' header value, but received: " + clazz);
774
 						}
775
 					}
776
 					target.setIfNoneMatch(ifNoneMatchList);
777
 				}
778
 			}
779
 		}
780
 		else if (.equalsIgnoreCase(name)) {
781
 			if (value instanceof Date) {
782
 				target.setLastModified(((Date) value).getTime());
783
 			}
784
 			else if (value instanceof Number) {
785
 				target.setLastModified(((Number) value).longValue());
786
 			}
787
 			else if (value instanceof String) {
788
 				try {
789
 					target.setLastModified(Long.parseLong((String) value));
790
 				}
791
 				catch (NumberFormatException e) {
793
 				}
794
 			}
795
 			else {
796
 				Class<?> clazz = (value != null) ? value.getClass() : null;
798
 						"Expected Date, Number, or String value for 'Last-Modified' header value, but received: " + clazz);
799
 			}
800
 		}
801
 		else if (.equalsIgnoreCase(name)) {
802
 			if (value instanceof URI) {
803
 				target.setLocation((URI) value);
804
 			}
805
 			else if (value instanceof String) {
806
 				try {
807
 					target.setLocation(new URI((String) value));
808
 				}
809
 				catch (URISyntaxException e) {
810
 					throw new IllegalArgumentException(e);
811
 				}
812
 			}
813
 			else {
814
 				Class<?> clazz = (value != null) ? value.getClass() : null;
816
 						"Expected URI or String value for 'Location' header value, but received: " + clazz);
817
 			}
818
 		}
819
 		else if (.equalsIgnoreCase(name)) {
820
 			if (value instanceof String) {
821
 				target.setPragma((String) value);
822
 			}
823
 			else {
824
 				Class<?> clazz = (value != null) ? value.getClass() : null;
826
 						"Expected String value for 'Pragma' header value, but received: " + clazz);
827
 			}
828
 		}
829
 		else if (value instanceof String) {
830
 			target.set(name, (String) value);
831
 		}
832
 		else if (value instanceof String[]) {
833
 			for (String next : (String[]) value) {
834
 				target.add(name, next);
835
 			}
836
 		}
837
 		else if (value instanceof Iterable<?>) {
838
 			for (Object next : (Iterable<?>) value) {
839
 				String convertedValue = null;
840
 				if (next instanceof String) {
841
 					convertedValue = (String) next;
842
 				}
843
 				else {
844
 					convertedValue = this.convertToString(value);
845
 				}
846
 				if (StringUtils.hasText(convertedValue)){
847
 					target.add(name, (String) next);
848
 				}
849
 				else {
850
 					.warn("Element of the header '" + name + "' with value '" + value +
851
 							"' will not be set since it is not a String and no Converter " +
852
 							"is available. Consider registering a Converter with ConversionService (e.g., <int:converter>)");
853
 				}
854
 			}
855
 		}
856
 		else {
857
 			String convertedValue = this.convertToString(value);
858
 			if (StringUtils.hasText(convertedValue)) {
859
 				target.set(name, convertedValue);
860
 			}
861
 			else {
862
 				.warn("Header '" + name + "' with value '" + value +
863
 						"' will not be set since it is not a String and no Converter " +
864
 						"is available. Consider registering a Converter with ConversionService (e.g., <int:converter>)");
865
 			}
866
 		}
867
 	}
868
 
869
 	private Object getHttpHeader(HttpHeaders source, String name) {
870
 		if (.equalsIgnoreCase(name)) {
871
 			return source.getAccept();
872
 		}
873
 		else if (.equalsIgnoreCase(name)) {
874
 			return source.getAcceptCharset();
875
 		}
876
 		else if (.equalsIgnoreCase(name)) {
877
 			return source.getAllow();
878
 		}
879
 		else if (.equalsIgnoreCase(name)) {
880
 			String cacheControl = source.getCacheControl();
881
 			return (StringUtils.hasText(cacheControl)) ? cacheControl : null;
882
 		}
883
 		else if (.equalsIgnoreCase(name)) {
884
 			long contentLength = source.getContentLength();
885
 			return (contentLength > -1) ? contentLength : null;
886
 		}
887
 		else if (.equalsIgnoreCase(name)) {
888
 			return source.getContentType();
889
 		}
890
 		else if (.equalsIgnoreCase(name)) {
891
 			long date = source.getDate();
892
 			return (date > -1) ? date : null;
893
 		}
894
 		else if (.equalsIgnoreCase(name)) {
895
 			String eTag = source.getETag();
896
 			return (StringUtils.hasText(eTag)) ? eTag : null;
897
 		}
898
 		else if (.equalsIgnoreCase(name)) {
899
 			try {
900
 				long expires = source.getExpires();
901
 				return (expires > -1) ? expires : null;
902
 			}
903
 			catch (Exception e) {
906
 				}
907
 				// According to RFC 2616
908
 				return null;
909
 			}
910
 		}
911
 		else if (.equalsIgnoreCase(name)) {
912
 			return source.getIfNoneMatch();
913
 		}
914
 		else if (.equalsIgnoreCase(name)) {
915
 			long modifiedSince = source.getIfModifiedSince();
916
 			return (modifiedSince > -1) ? modifiedSince : null;
917
 		}
919
 			String unmodifiedSince = source.getFirst();
920
 			return unmodifiedSince != null ? this.getFirstDate(unmodifiedSince, ) : null;
921
 		}
922
 		else if (.equalsIgnoreCase(name)) {
923
 			long lastModified = source.getLastModified();
924
 			return (lastModified > -1) ? lastModified : null;
925
 		}
926
 		else if (.equalsIgnoreCase(name)) {
927
 			return source.getLocation();
928
 		}
929
 		else if (.equalsIgnoreCase(name)) {
930
 			String pragma = source.getPragma();
931
 			return (StringUtils.hasText(pragma)) ? pragma : null;
932
 		}
933
 		return source.get(name);
934
 	}
935
 
936
 	private void setMessageHeader(Map<String, Object> target, String name, Object value) {
937
 		if (ObjectUtils.isArray(value)) {
938
 			Object[] values = ObjectUtils.toObjectArray(value);
939
 			if (!ObjectUtils.isEmpty(values)) {
940
 				if (values.length == 1) {
941
 					target.put(name, values);
942
 				}
943
 				else {
944
 					target.put(name, values[0]);
945
 				}
946
 			}
947
 		}
948
 		else if (value instanceof Collection<?>) {
949
 			Collection<?> values = (Collection<?>) value;
950
 			if (!CollectionUtils.isEmpty(values)) {
951
 				if (values.size() == 1) {
952
 					target.put(name, values.iterator().next());
953
 				}
954
 				else {
955
 					target.put(name, values);
956
 				}
957
 			}
958
 		}
959
 		else if (value != null) {
960
 			target.put(name, value);
961
 		}
962
 	}
963
 
964
 	private String convertToString(Object value){
965
 		if (this. != null &&
966
 				this..canConvert(TypeDescriptor.forObject(value), TypeDescriptor.valueOf(String.class))){
967
 			return this..convert(value, String.class);
968
 		}
969
 		return null;
970
 	}
971
 
972
 	// Utility methods
973
 
974
 	private long getFirstDate(String headerValue, String headerName) {
975
 		for (String dateFormat : ) {
976
 			DateFormat simpleDateFormat = new SimpleDateFormat(dateFormat, .);
977
 			simpleDateFormat.setTimeZone();
978
 			try {
979
 				return simpleDateFormat.parse(headerValue).getTime();
980
 			}
981
 			catch (ParseException e) {
982
 				// ignore
983
 			}
984
 		}
985
 		throw new IllegalArgumentException("Cannot parse date value '" + headerValue +"' for '" + headerName + "' header");
986
 	}
987
 
988
 	private String formatDate(long date) {
989
 		DateFormat dateFormat = new SimpleDateFormat([0], .);
990
 		dateFormat.setTimeZone();
991
 		return dateFormat.format(new Date(date));
992
 	}
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.
1006
		return mapper;
1007
	}
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.
1021
		return mapper;