springboot返回結果統一處理

一般來說異常統一處理都知道，@RestControllerAdvice和@ControllerAdive，然后使用@ExceptionHandler注解處理異常統一處理即可。如今前后端分離情況居多，返回給前端的我們也需要統一包裝一下，比方說：

package com.lhf.fvscommon.result;

import lombok.Data;

import java.io.Serializable;

/**
 * <p></p>
 *
 * @author lhf
 * @since 2020/10/22 10:26
 */

@Data
public class Result<T> {

    private int code;

    private T t;

    private String mes;

    public Result(int code, T t, String mes) {
        this.code = code;
        this.t = t;
        this.mes = mes;
    }


    public static <T> Result<T> success() {
        Status success = Status.SUCCESS;
        return new Result<>(success.code, null, success.mes);
    }

    /**
     * 請求成功默認返回
     *
     * @param t
     * @param <T>
     * @return
     */
    public static <T> Result<T> success(T t) {
        Status success = Status.SUCCESS;
        return new Result<>(success.code, t, success.mes);
    }

    /**
     * 請求成功自定義狀態返回
     *
     * @param t
     * @param status
     * @param <T>
     * @return
     */
    public static <T> Result<T> success(T t, Status status) {
        return new Result<>(status.code, t, status.mes);
    }

    /**
     * 請求失敗默認返回
     *
     * @param <T>
     * @return
     */
    public static <T> Result<T> failure() {
        Status failure = Status.FAILURE;
        return new Result<>(failure.code, null, failure.mes);
    }

    /**
     * 自定義失敗返回狀態，返回信息
     *
     * @param <T>
     * @return
     */
    public static <T> Result<T> failure(Status status, String mes) {
        return new Result<>(status.code, null, mes);
    }

    /**
     * 請求失敗自定義狀態
     *
     * @param status
     * @param <T>
     * @return
     */
    public static <T> Result<T> failure(Status status) {
        return new Result<>(status.code, null, status.mes);
    }


    /**
     * 構建
     *
     * @param <T>
     * @return
     */
    public static <T> Builder<T> builder() {
        return new Builder<>();
    }

    public static class Builder<T> {
        private int code;
        private T t;
        private String mes;

        public Builder<T> code(int code) {
            this.code = code;
            return this;
        }

        public Builder<T> t(T t) {
            this.t = t;
            return this;
        }

        public Builder<T> mes(String mes) {
            this.mes = mes;
            return this;
        }

        public Result<T> build() {
            return new Result<>(this.code, this.t, this.mes);
        }
    }
}

上訴代碼就是一個基本的返回統一處理的類，相比大家都不陌生，不過惡心的就是每次返回都需要手動包裝啊，這個就有點惡心了啊!能不能簡單點？

期間我想過aop，但是aop環繞增強返回的一定是實際返回的一個子類，於是要么我們使用一個公共類，Result繼承這個公共類，並且所有的返回前端數據對象都繼承他，好像也不是很好。而且還有一個潛在的問題就是萬一返回的是個String拿不完犢子？要么，實際返回就是一個Object，那這樣的話代碼可讀性就比較差了(別人讀你的代碼的時候並不知道你返回的是什么啊!!!),於是有改變策略使用了一下過濾器，但是我發現也不是很好(不太好處理)。最后我吧目標放到Springboot自帶的Json處理上，因為他的處理和我們要的結果好像是類似！

然后我就debug，跟了好幾次終於確定了位置:看下邊的代碼(代碼有點長哈)

    protected <T> void writeWithMessageConverters(@Nullable T value, MethodParameter returnType,
            ServletServerHttpRequest inputMessage, ServletServerHttpResponse outputMessage)
            throws IOException, HttpMediaTypeNotAcceptableException, HttpMessageNotWritableException {

        Object body;
        Class<?> valueType;
        Type targetType;

        if (value instanceof CharSequence) { body = value.toString(); valueType = String.class; targetType = String.class; } else { body = value; valueType = getReturnValueType(body, returnType); targetType = GenericTypeResolver.resolveType(getGenericType(returnType), returnType.getContainingClass()); } if (isResourceType(value, returnType)) {
            outputMessage.getHeaders().set(HttpHeaders.ACCEPT_RANGES, "bytes");
            if (value != null && inputMessage.getHeaders().getFirst(HttpHeaders.RANGE) != null &&
                    outputMessage.getServletResponse().getStatus() == 200) {
                Resource resource = (Resource) value;
                try {
                    List<HttpRange> httpRanges = inputMessage.getHeaders().getRange();
                    outputMessage.getServletResponse().setStatus(HttpStatus.PARTIAL_CONTENT.value());
                    body = HttpRange.toResourceRegions(httpRanges, resource);
                    valueType = body.getClass();
                    targetType = RESOURCE_REGION_LIST_TYPE;
                }
                catch (IllegalArgumentException ex) {
                    outputMessage.getHeaders().set(HttpHeaders.CONTENT_RANGE, "bytes */" + resource.contentLength());
                    outputMessage.getServletResponse().setStatus(HttpStatus.REQUESTED_RANGE_NOT_SATISFIABLE.value());
                }
            }
        }

        MediaType selectedMediaType = null;
        MediaType contentType = outputMessage.getHeaders().getContentType();
        boolean isContentTypePreset = contentType != null && contentType.isConcrete();
        if (isContentTypePreset) {
            if (logger.isDebugEnabled()) {
                logger.debug("Found 'Content-Type:" + contentType + "' in response");
            }
            selectedMediaType = contentType;
        }
        else {
            HttpServletRequest request = inputMessage.getServletRequest();
            List<MediaType> acceptableTypes = getAcceptableMediaTypes(request);
            List<MediaType> producibleTypes = getProducibleMediaTypes(request, valueType, targetType);

            if (body != null && producibleTypes.isEmpty()) {
                throw new HttpMessageNotWritableException(
                        "No converter found for return value of type: " + valueType);
            }
            List<MediaType> mediaTypesToUse = new ArrayList<>();
            for (MediaType requestedType : acceptableTypes) {
                for (MediaType producibleType : producibleTypes) {
                    if (requestedType.isCompatibleWith(producibleType)) {
                        mediaTypesToUse.add(getMostSpecificMediaType(requestedType, producibleType));
                    }
                }
            }
            if (mediaTypesToUse.isEmpty()) {
                if (body != null) {
                    throw new HttpMediaTypeNotAcceptableException(producibleTypes);
                }
                if (logger.isDebugEnabled()) {
                    logger.debug("No match for " + acceptableTypes + ", supported: " + producibleTypes);
                }
                return;
            }

            MediaType.sortBySpecificityAndQuality(mediaTypesToUse);

            for (MediaType mediaType : mediaTypesToUse) {
                if (mediaType.isConcrete()) {
                    selectedMediaType = mediaType;
                    break;
                }
                else if (mediaType.isPresentIn(ALL_APPLICATION_MEDIA_TYPES)) {
                    selectedMediaType = MediaType.APPLICATION_OCTET_STREAM;
                    break;
                }
            }

            if (logger.isDebugEnabled()) {
                logger.debug("Using '" + selectedMediaType + "', given " +
                        acceptableTypes + " and supported " + producibleTypes);
            }
        }

        if (selectedMediaType != null) {
            selectedMediaType = selectedMediaType.removeQualityValue();
            for (HttpMessageConverter<?> converter : this.messageConverters) {
                GenericHttpMessageConverter genericConverter = (converter instanceof GenericHttpMessageConverter ?
                        (GenericHttpMessageConverter<?>) converter : null);
                if (genericConverter != null ?
                        ((GenericHttpMessageConverter) converter).canWrite(targetType, valueType, selectedMediaType) :
                        converter.canWrite(valueType, selectedMediaType)) {
                   body = getAdvice().beforeBodyWrite(body, returnType, selectedMediaType,
                            (Class<? extends HttpMessageConverter<?>>) converter.getClass(),
                            inputMessage, outputMessage);
                    if (body != null) {
                        Object theBody = body;
                        LogFormatUtils.traceDebug(logger, traceOn ->
                                "Writing [" + LogFormatUtils.formatValue(theBody, !traceOn) + "]");
                        addContentDispositionHeader(inputMessage, outputMessage);
                        if (genericConverter != null) {
                            genericConverter.write(body, targetType, selectedMediaType, outputMessage);
                        }
                        else {
                            ((HttpMessageConverter) converter).write(body, selectedMediaType, outputMessage);
                        }
                    }
                    else {
                        if (logger.isDebugEnabled()) {
                            logger.debug("Nothing to write: null body");
                        }
                    }
                    return;
                }
            }
        }

        if (body != null) {
            Set<MediaType> producibleMediaTypes =
                    (Set<MediaType>) inputMessage.getServletRequest()
                            .getAttribute(HandlerMapping.PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE);

            if (isContentTypePreset || !CollectionUtils.isEmpty(producibleMediaTypes)) {
                throw new HttpMessageNotWritableException(
                        "No converter for [" + valueType + "] with preset Content-Type '" + contentType + "'");
            }
            throw new HttpMediaTypeNotAcceptableException(this.allSupportedMediaTypes);
        }
    }

重點我們看第二個紅色的部分：getAdvice()返回的是RequestResponseBodyAdviceChain，呦吼看着名字應該是責任鏈模式了。當然這不是重點，偶爾皮一下，就不那么無聊了。那么重點是這個類了，

 

 從圖片上不難看出，這個玩意兒就是處理返回的呀。我們再來看看ResponseBodyAdvice，畢竟我們重點關注的也應該是這個！！！

 

 他就兩個方法supports和beforeBodyWrite，supports：此組件是否支持給定的控制器方法返回類型和所選的{@code HttpMessageConverter}類型，但是spring源碼並沒有給出這個方法的實現而是直接拋出一個異常（當然一定是有處理的，往后看啦）

 

 就很憨憨呀，來看下一個beforeBodyWrite：從方法名字不難發現，響應體寫入之前的操作。

 

 

 可以看到這個返回處理的類是數組，也就是說我能不能繼承一個，重寫一個beforeBodyWrite呢?

 

 

 以上變這段代碼看來，可以看到一個ControllerAdviceBean，從名字來看，不難發現應該是一個@ControllerAdvice標記的Bean對象沒錯了。availableAdvice變量是什么，追蹤源碼發現就是ResponseBodyAdvice集合，最終我得出的結論就是我們自定義的ResponseBodyAdvice類將是一個@ControllerAdvice標記的類。現在來試一下吧!!!

package com.lhf.fvscore.result.advice;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.lhf.fvscommon.result.Result;
import com.lhf.fvscore.annotation.ResultBody;
import org.springframework.core.MethodParameter;
import org.springframework.http.MediaType;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;

import java.lang.reflect.AnnotatedElement;
import java.util.Arrays;

/**
 * <p>
 *
 * </p>
 *
 * @author lhf
 * @since 2020/11/6 14:30
 */
@ControllerAdvice(annotations = {ResultBody.class})
public class ResultAdvise implements ResponseBodyAdvice<Object> {

    private final ThreadLocal<ObjectMapper> threadLocal = ThreadLocal.withInitial(ObjectMapper::new);

    private static final Class[] annos = {
            RequestMapping.class,
            GetMapping.class,
            PostMapping.class,
            DeleteMapping.class,
            PutMapping.class,
            PatchMapping.class
    };

    @Override
    public boolean supports(MethodParameter methodParameter, Class aClass) {
        return this.validateMethod(methodParameter);
    }

    @Override
    public Object beforeBodyWrite(Object body, MethodParameter methodParameter, MediaType mediaType, Class aClass, ServerHttpRequest request, ServerHttpResponse response) {

        Object out;
        ObjectMapper mapper = threadLocal.get();
        response.getHeaders().setContentType(MediaType.APPLICATION_JSON);
        if (body instanceof Result) {
            out = body;
        } else if (body instanceof String) {
            Result<Object> result = Result.success(body);
            try {
                out = mapper.writeValueAsString(result);
            } catch (JsonProcessingException e) {
                out = Result.failure();
            }
        } else {
            out = Result.success(body);
        }
        return out;

    }

    private boolean validateMethod(MethodParameter methodParameter) {
        AnnotatedElement element = methodParameter.getAnnotatedElement();
        return Arrays.stream(annos).anyMatch(anno -> anno.isAnnotation() && element.isAnnotationPresent(anno));
    }
71 }

還記得上邊有翻譯或supports方法的注釋嗎?此組件是否支持給定的控制器方法返回類型和所選的{@code HttpMessageConverter}類型,但是我們在這里並不關心后半部分，是不是HttpMessageConverter類型在封裝json的時候框架本身回去驗證（AbstractMappingJacksonResponseBodyAdvice.java）我們所關心的應該是，這個方法是不是@RequestMapping標記的，所以我只驗證了這一點。

當然，我這里用的自定義注解，沒有什么特殊的需求可以直接攔截@RestController即可

/**
 * <p></p>
 *
 * @author lhf
 * @since 2020/11/5 8:42
 */
@Documented
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface ResultBody {
}

接下來就是測試了:

 

 

 

 完美(當然期間遇到很多坑，差點就死了)

歡迎大佬吐槽