SpringBoot全局处理统一返回类型

       在日常开发中，我们会定义各种各样的返回类型，不便于后期维护，也不便于前台进行数据处理；有些项目会封装一个统一的返回类型，让开发人员用这个封装类返回，但是随着项目人员的变更，如果没有统一的要求规范，后期也会变得不可控，而且代码的耦合度也太高。

       基于此场景，我们封装了一个统一返回类型（响应状态、返回数据等），并设置全局统一处理。

       接口调用返回如下所示：

{
	"code": 200,   //响应状态
	"cost": 0,     //请求耗时，在本文章不做演示
	"data": "test",//返回数据
	"msg": "成功"   //响应描述
}

需要的依赖     

     首先添加需要的依赖

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.9</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

    </dependencies>

Result（返回类）

     然后，我们定义一个返回类，全局返回统一采用本模板返回，包含一个前端常用字段，还有一些初始化对象的方法。

package com.gml.springboot2.entity;

import com.gml.springboot2.enums.ResultEnum;
import lombok.Data;
import java.io.Serializable;

/**
 * @author gml
 * @description  全局统一返回类型
 * @date 2019/11/29
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Result<T> implements Serializable {

    /**
     * 成功数据
     */
    private T data;

    /**
     * 响应编码200为成功
     */
    private Integer code;

    /**
     * 请求消耗时间
     */
    private long cost;

    /**
     * 描述
     */
    private String msg;

    /**
     * 请求id
     */
    private String requestId;

    public Result(Integer code, String msg) {
        this.code = code;
        this.msg = msg;
    }

    public static Result create(Integer code, String msg){
        Result result = new Result(code, msg);
        return result;
    }

    /**
     * 无数据返回成功
     * @return
     */
    public static Result createSuccess() {
        return create(ResultEnum.SUCCESS.getCode(), ResultEnum.SUCCESS.getMsg());
    }

    /**
     * 有数据返回成功
     * @param data
     * @param <T>
     * @return
     */
    public static <T> Result<T> createSuccess(T data) {
        return createSuccess().setData(data);
    }

    /**
     * 无描述返回失败
     * @return
     */
    public static Result createFail() {
        return create(ResultEnum.Fail.getCode(), ResultEnum.Fail.getMsg());
    }

    /**
     * 自定义返回失败描述
     * @param code
     * @param msg
     * @return
     */
    public static Result createFail(Integer code, String msg) {
        return create(code, msg);
    }

    public Result setData(T data){
        this.data = data;
        return this;
    }

}

      全局设置

      实现ResponseBodyAdvice接口，ResponseBodyAdvice是Spring4.1新加入的接口，在消息体被HttpMessageConverter写入之前允许Controller中的方法调整响应中的内容，比如做一些返回处理。

      ResponseBodyAdvice接口里面一共定义了两个方法

           supports：进行一些逻辑判断是否需要进行后续的beforeBodyWrite的方法

           beforeBodyWrite：进行一些返回处理

      然后一定一个类实现ResponseBodyAdvice接口，代码如下：

package com.gml.springboot2.config;

import com.alibaba.fastjson.JSONObject;
import com.gml.springboot2.entity.Result;
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.RestControllerAdvice;
import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;

import java.util.Objects;

/**
 * @author gml
 * @description
 * @date 2019/11/29
 */
@RestControllerAdvice
public class CommonResponseAdvice implements ResponseBodyAdvice {
    @Override
    public boolean supports(MethodParameter methodParameter, Class aClass) {
        return filter(methodParameter);
    }

    /**
     * 根据返回类型来判断是否需要进行后续操作
     * @param methodParameter
     * @return
     */
    private boolean filter(MethodParameter methodParameter) {
        return true;
    }


    /**
     *
     * @param returnValue           返回值
     * @param methodParameter       Controller方法返回类型
     * @param mediaType
     * @param aClass
     * @param serverHttpRequest
     * @param serverHttpResponse
     * @return
     */
    @Override
    public Object beforeBodyWrite(Object returnValue, MethodParameter returnType, MediaType selectedContentType, Class selectedConverterType, ServerHttpRequest request, ServerHttpResponse response) {
        Result result;
        //获取返回值类型
        String returnClassType = returnType.getParameterType().getSimpleName();

        //如果返回值类型为void，则默认返回成功
        if("void".equals(returnClassType)){
            result = Result.createSuccess();
        }else if ("Result".equals(returnClassType)){
            result = (Result) returnValue;
        }else if ("String".equals(returnClassType)){
            //json的转换会出问题
            result = Result.createSuccess(returnValue);
            result.setCost(cost);
            return JSON.toJSONString(result);
        }else {
            if (Objects.isNull(returnValue)){
                result = Result.createSuccess();
            }else {
                result = Result.createSuccess(returnValue);
            }
        }
        //一定要转换为String，否则会报错
        return result;
    }
}

       测试

       写一个Controller，测试一下返回值

package com.gml.springboot2.controller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author gml
 * @description
 * @date 2019/11/29
 */

@RestController
public class TestController {

    @RequestMapping("/test")
    public String test(){
        return "返回数据";
    }
}

      浏览器访问如下图

     

测试成功