SpringCloud请求响应数据转换（一）

  1 /**
  2      * Writes the given return type to the given output message.
  3      * @param value the value to write to the output message
  4      * @param returnType the type of the value
  5      * @param inputMessage the input messages. Used to inspect the {@code Accept} header.
  6      * @param outputMessage the output message to write to
  7      * @throws IOException thrown in case of I/O errors
  8      * @throws HttpMediaTypeNotAcceptableException thrown when the conditions indicated by {@code Accept} header on
  9      * the request cannot be met by the message converters
 10      */
 11     @SuppressWarnings("unchecked")
 12     protected <T> void writeWithMessageConverters(T value, MethodParameter returnType,
 13             ServletServerHttpRequest inputMessage, ServletServerHttpResponse outputMessage)
 14             throws IOException, HttpMediaTypeNotAcceptableException, HttpMessageNotWritableException {
 15 
 16         Object outputValue;
 17         Class<?> valueType;
 18         Type declaredType;
 19 //判断控制层返回的value类型，对String进行特殊处理，其他获取对应类型valueType(如java.util.ArrayList)和声明类型declaredType(列表元素具体类型，如java.util.List<com.service.entity.PersonVO>)
 20         if (value instanceof CharSequence) {
 21             outputValue = value.toString();
 22             valueType = String.class;
 23             declaredType = String.class;
 24         }
 25         else {
 26             outputValue = value;
 27             valueType = getReturnValueType(outputValue, returnType);
 28             declaredType = getGenericType(returnType);
 29         }
 30 
 31         HttpServletRequest request = inputMessage.getServletRequest();
 32 //获取浏览器支持的媒体类型，如*/*
 33         List<MediaType> requestedMediaTypes = getAcceptableMediaTypes(request);
 34 //获取控制层指定的返回媒体类型，默认为*/*,如@RequestMapping(value = "/test", produces = MediaType.APPLICATION_JSON_UTF8_VALUE),表示服务响应的格式为application/json格式。
 35         List<MediaType> producibleMediaTypes = getProducibleMediaTypes(request, valueType, declaredType);
 36 
 37         if (outputValue != null && producibleMediaTypes.isEmpty()) {
 38             throw new IllegalArgumentException("No converter found for return value of type: " + valueType);
 39         }
 40 //判断浏览器支持的媒体类型是否兼容返回媒体类型
 41         Set<MediaType> compatibleMediaTypes = new LinkedHashSet<MediaType>();
 42         for (MediaType requestedType : requestedMediaTypes) {
 43             for (MediaType producibleType : producibleMediaTypes) {
 44                 if (requestedType.isCompatibleWith(producibleType)) {
 45                     compatibleMediaTypes.add(getMostSpecificMediaType(requestedType, producibleType));
 46                 }
 47             }
 48         }
 49         if (compatibleMediaTypes.isEmpty()) {
 50             if (outputValue != null) {
 51                 throw new HttpMediaTypeNotAcceptableException(producibleMediaTypes);
 52             }
 53             return;
 54         }
 55 
 56         List<MediaType> mediaTypes = new ArrayList<MediaType>(compatibleMediaTypes);
 57         MediaType.sortBySpecificityAndQuality(mediaTypes);
 58 
 59         MediaType selectedMediaType = null;
 60         for (MediaType mediaType : mediaTypes) {
 61             if (mediaType.isConcrete()) {
 62                 selectedMediaType = mediaType;
 63                 break;
 64             }
 65             else if (mediaType.equals(MediaType.ALL) || mediaType.equals(MEDIA_TYPE_APPLICATION)) {
 66                 selectedMediaType = MediaType.APPLICATION_OCTET_STREAM;
 67                 break;
 68             }
 69         }
 70 
 71         if (selectedMediaType != null) {
 72             selectedMediaType = selectedMediaType.removeQualityValue();
 73 //遍历所有Http消息转换器，如上图，（1）首先Byte和String等非GenericHttpMessageConverter转换器；
     （2）MappingJackson2HttpMessageConverter转换器继承GenericHttpMessageConverter，会将对象类型转换为json（采用com.fasterxml.jackson）
 74             for (HttpMessageConverter<?> messageConverter : this.messageConverters) {
 75 //判断转换器是否为GenericHttpMessageConverter，其中canWrite()方法判断是否能通过该转换器将响应写入响应流，见后续代码
 76                 if (messageConverter instanceof GenericHttpMessageConverter) {
 77                     if (((GenericHttpMessageConverter) messageConverter).canWrite(
 78                             declaredType, valueType, selectedMediaType)) {
 79 //获取切片；调切片的beforeBodyWrite方法，处理控制层方法返回值，最终outputValue为处理后的数据，如工程中返回的ResultMessage
 80                         outputValue = (T) getAdvice().beforeBodyWrite(outputValue, returnType, selectedMediaType,
 81                                 (Class<? extends HttpMessageConverter<?>>) messageConverter.getClass(),
 82                                 inputMessage, outputMessage);
 83                         if (outputValue != null) {
 84                             addContentDispositionHeader(inputMessage, outputMessage);
 85 //将处理后的数据写入响应流，同时添加响应头，并调该转换器的写入方法；如MappingJackson2HttpMessageConverter的writeInternal方法，会将数据写入json中，具体见后续代码
 86                             ((GenericHttpMessageConverter) messageConverter).write(
 87                                     outputValue, declaredType, selectedMediaType, outputMessage);
 88                             if (logger.isDebugEnabled()) {
 89                                 logger.debug("Written [" + outputValue + "] as \"" + selectedMediaType +
 90                                         "\" using [" + messageConverter + "]");
 91                             }
 92                         }
 93                         return;
 94                     }
 95                 }
 96 //处理Byte和String等类型的数据
 97                 else if (messageConverter.canWrite(valueType, selectedMediaType)) {
 98                     outputValue = (T) getAdvice().beforeBodyWrite(outputValue, returnType, selectedMediaType,
 99                             (Class<? extends HttpMessageConverter<?>>) messageConverter.getClass(),
100                             inputMessage, outputMessage);
101                     if (outputValue != null) {
102                         addContentDispositionHeader(inputMessage, outputMessage);
103                         ((HttpMessageConverter) messageConverter).write(outputValue, selectedMediaType, outputMessage);
104                         if (logger.isDebugEnabled()) {
105                             logger.debug("Written [" + outputValue + "] as \"" + selectedMediaType +
106                                     "\" using [" + messageConverter + "]");
107                         }
108                     }
109                     return;
110                 }
111             }
112         }
113 
114         if (outputValue != null) {
115             throw new HttpMediaTypeNotAcceptableException(this.allSupportedMediaTypes);
116         }
117     }

 1 @Override
 2     public boolean canWrite(Class<?> clazz, MediaType mediaType) {
 3         //判断客户端是否支持返回的媒体类型
 4         if (!canWrite(mediaType)) {
 5             return false;
 6         }
 7         if (!logger.isWarnEnabled()) {
 8             return this.objectMapper.canSerialize(clazz);
 9         }
10         AtomicReference<Throwable> causeRef = new AtomicReference<Throwable>();
11         //判断是否可以通过ObjectMapper对clazz进行序列化
12         if (this.objectMapper.canSerialize(clazz, causeRef)) {
13             return true;
14         }
15         logWarningIfNecessary(clazz, causeRef.get());
16         return false;
17     }

1 @Override
2     public boolean supports(Class<?> clazz) {
3         return String.class == clazz;
4     }

 1 @Override
 2     public Object beforeBodyWrite(Object body, MethodParameter returnType, MediaType contentType,
 3             Class<? extends HttpMessageConverter<?>> converterType,
 4             ServerHttpRequest request, ServerHttpResponse response) {
 5 
 6         return processBody(body, returnType, contentType, converterType, request, response);
 7     }
 8 
 9     @SuppressWarnings("unchecked")
10     private <T> Object processBody(Object body, MethodParameter returnType, MediaType contentType,
11             Class<? extends HttpMessageConverter<?>> converterType,
12             ServerHttpRequest request, ServerHttpResponse response) {
13          //获取并遍历所有与ResponseBodyAdvice匹配的切面，其中returnType包含了请求方法相关信息
14         for (ResponseBodyAdvice<?> advice : getMatchingAdvice(returnType, ResponseBodyAdvice.class)) {
15              //调切面的supports方法，判断切面是否支持返回类型和转换类型
16             if (advice.supports(returnType, converterType)) {
17                  //调切面的beforeBodyWrite方法，进行数据处理
18                 body = ((ResponseBodyAdvice<T>) advice).beforeBodyWrite((T) body, returnType,
19                         contentType, converterType, request, response);
20             }
21         }
22         return body;
23     }
24     @SuppressWarnings("unchecked")
25     private <A> List<A> getMatchingAdvice(MethodParameter parameter, Class<? extends A> adviceType) {
26          //获取所有切面
27         List<Object> availableAdvice = getAdvice(adviceType);
28         if (CollectionUtils.isEmpty(availableAdvice)) {
29             return Collections.emptyList();
30         }
31         List<A> result = new ArrayList<A>(availableAdvice.size());
32         //遍历所有切面，找到符合adviceType的切面
33         for (Object advice : availableAdvice) {
34             if (advice instanceof ControllerAdviceBean) {
35                 ControllerAdviceBean adviceBean = (ControllerAdviceBean) advice;
36                 if (!adviceBean.isApplicableToBeanType(parameter.getContainingClass())) {
37                     continue;
38                 }
39                 advice = adviceBean.resolveBean();
40             }
41              //判断adviceType 是否为advice.getClass()的父类或父接口等
42             if (adviceType.isAssignableFrom(advice.getClass())) {
43                 result.add((A) advice);
44             }
45         }
46         return result;
47     }

 1 @RestControllerAdvice(annotations = RestController.class)
 2 public class ControllerInterceptor implements ResponseBodyAdvice<Object>{
 3     //异常情况处理
 4     @ExceptionHandler(value = BizException.class)
 5     public String defaultErrorHandler(HttpServletRequest req, BizException e) throws Exception {
 6         ResultMessage rm = new ResultMessage();
 7         ErrorMessage errorMessage = new ErrorMessage(e.getErrCode(), e.getErrMsg());
 8         rm.setErrorMessage(errorMessage);
 9         rm.setSuccess(false);
10         return JSONUtil.ObjectToString(rm);
11     }
12 
13     //数据处理
14     @Override
15     public Object beforeBodyWrite(Object object, MethodParameter methodPram, MediaType mediaType,
16             Class<? extends HttpMessageConverter<?>> clazz, ServerHttpRequest request, ServerHttpResponse response) {
17         ResultMessage rm = new ResultMessage();
18         rm.setSuccess(true);
19         rm.setData(object);
20         
21         Object obj;
22          //处理控制层返回字符串情况，解决上文说的类型转换异常
23         if(object != null && object.getClass().equals(String.class)){
24             obj = JSONObject.fromObject(rm).toString();
25         }else{
26             obj = rm;
27         }
28         return obj;
29     }
30 
31     //确定是否支持，此处返回true
32     @Override
33     public boolean supports(MethodParameter methodPram, Class<? extends HttpMessageConverter<?>> clazz) {
34         return true;
35     }
36 }

 1 /**
 2      * This implementation sets the default headers by calling {@link #addDefaultHeaders},
 3      * and then calls {@link #writeInternal}.
 4      */
 5     public final void write(final T t, final Type type, MediaType contentType, HttpOutputMessage outputMessage)
 6             throws IOException, HttpMessageNotWritableException {
 7 
 8         final HttpHeaders headers = outputMessage.getHeaders();
 9         //添加默认的响应头，包括Content-Type和Content-Length
10         addDefaultHeaders(headers, t, contentType);
11 
12         if (outputMessage instanceof StreamingHttpOutputMessage) {
13             StreamingHttpOutputMessage streamingOutputMessage = (StreamingHttpOutputMessage) outputMessage;
14             streamingOutputMessage.setBody(new StreamingHttpOutputMessage.Body() {
15                 @Override
16                 public void writeTo(final OutputStream outputStream) throws IOException {
17                     writeInternal(t, type, new HttpOutputMessage() {
18                         @Override
19                         public OutputStream getBody() throws IOException {
20                             return outputStream;
21                         }
22                         @Override
23                         public HttpHeaders getHeaders() {
24                             return headers;
25                         }
26                     });
27                 }
28             });
29         }
30         else {
31             //非StreamingHttpOutputMessage情况下，会调该方法将数据写入响应流
32             writeInternal(t, type, outputMessage);
33             outputMessage.getBody().flush();
34         }
35     }
36 /**
37      * Add default headers to the output message.
38      * <p>This implementation delegates to {@link #getDefaultContentType(Object)} if a content
39      * type was not provided, set if necessary the default character set, calls
40      * {@link #getContentLength}, and sets the corresponding headers.
41      * @since 4.2
42      */
43     protected void addDefaultHeaders(HttpHeaders headers, T t, MediaType contentType) throws IOException{
44          //设置Content-Type
45         if (headers.getContentType() == null) {
46             MediaType contentTypeToUse = contentType;
47             if (contentType == null || contentType.isWildcardType() || contentType.isWildcardSubtype()) {
48                 contentTypeToUse = getDefaultContentType(t);
49             }
50             else if (MediaType.APPLICATION_OCTET_STREAM.equals(contentType)) {
51                 MediaType mediaType = getDefaultContentType(t);
52                 contentTypeToUse = (mediaType != null ? mediaType : contentTypeToUse);
53             }
54             if (contentTypeToUse != null) {
55                 if (contentTypeToUse.getCharset() == null) {
56                     Charset defaultCharset = getDefaultCharset();
57                     if (defaultCharset != null) {
58                         contentTypeToUse = new MediaType(contentTypeToUse, defaultCharset);
59                     }
60                 }
61                 headers.setContentType(contentTypeToUse);
62             }
63         }
64         //设置Content-Length，当t为ArrayList对象时，值为null
65         if (headers.getContentLength() < 0) {
66             Long contentLength = getContentLength(t, headers.getContentType());
67             if (contentLength != null) {
68                 headers.setContentLength(contentLength);
69             }
70         }
71     }

 1 @Override
 2     protected void writeInternal(Object object, Type type, HttpOutputMessage outputMessage)
 3             throws IOException, HttpMessageNotWritableException {
 4 
 5         JsonEncoding encoding = getJsonEncoding(outputMessage.getHeaders().getContentType());
 6         JsonGenerator generator = this.objectMapper.getFactory().createGenerator(outputMessage.getBody(), encoding);
 7         try {
 8             writePrefix(generator, object);
 9 
10             Class<?> serializationView = null;
11             FilterProvider filters = null;
12             Object value = object;
13             JavaType javaType = null;
14             if (object instanceof MappingJacksonValue) {
15                 MappingJacksonValue container = (MappingJacksonValue) object;
16                 value = container.getValue();
17                 serializationView = container.getSerializationView();
18                 filters = container.getFilters();
19             }
20             if (type != null && value != null && TypeUtils.isAssignable(type, value.getClass())) {
21                 javaType = getJavaType(type, null);
22             }
23             ObjectWriter objectWriter;
24             if (serializationView != null) {
25                 objectWriter = this.objectMapper.writerWithView(serializationView);
26             }
27             else if (filters != null) {
28                 objectWriter = this.objectMapper.writer(filters);
29             }
30             else {
31                 objectWriter = this.objectMapper.writer();
32             }
33             if (javaType != null && javaType.isContainerType()) {
34                 objectWriter = objectWriter.forType(javaType);
35             }
36              //通过ObjectWrite构建json数据结构
37             objectWriter.writeValue(generator, value);
38 
39             writeSuffix(generator, object);
40             generator.flush();
41 
42         }
43         catch (JsonProcessingException ex) {
44             throw new HttpMessageNotWritableException("Could not write content: " + ex.getMessage(), ex);
45         }
46     }

 1 //返回字符串对应的字节数长度，作为Content-Length，上文中的异常就出现在此处。
 2 @Override
 3     protected Long getContentLength(String str, MediaType contentType) {
 4         Charset charset = getContentTypeCharset(contentType);
 5         try {
 6             return (long) str.getBytes(charset.name()).length;
 7         }
 8         catch (UnsupportedEncodingException ex) {
 9             // should not occur
10             throw new IllegalStateException(ex);
11         }
12     }
13 
14 @Override
15     protected void writeInternal(String str, HttpOutputMessage outputMessage) throws IOException {
16         if (this.writeAcceptCharset) {
17             outputMessage.getHeaders().setAcceptCharset(getAcceptedCharsets());
18         }
19         Charset charset = getContentTypeCharset(outputMessage.getHeaders().getContentType());
20         //将字符串数据copy后写入输出流
21         StreamUtils.copy(str, charset, outputMessage.getBody());
22     }
23 StreamUtils类：
24 /**
25      * Copy the contents of the given String to the given output OutputStream.
26      * Leaves the stream open when done.
27      * @param in the String to copy from
28      * @param charset the Charset
29      * @param out the OutputStream to copy to
30      * @throws IOException in case of I/O errors
31      */
32     public static void copy(String in, Charset charset, OutputStream out) throws IOException {
33         Assert.notNull(in, "No input String specified");
34         Assert.notNull(charset, "No charset specified");
35         Assert.notNull(out, "No OutputStream specified");
36         Writer writer = new OutputStreamWriter(out, charset);
37         writer.write(in);
38         writer.flush();
39     }