如何优雅地包装controller的返回结果

现在项目情况都是前后端分离,后端人员为了能让前端人员能够看懂返回结果,同时还需要返回结果的格式一致,所以就有了固定的结果返回体。

Controller控制器返回给前端常见的的格式有三种:

  • 自定义返回体Result
  • 自定义Map
  • ResponseEntity

今天,我们用到的是第一种情况吗,自定义返回体Result。

1、自定义返回体Result

通常情况下,需要前端需要的信息如下,JSON格式:一般会存在3个Key:code,msg,data

{
    code:  1,
    msg:  "",
    data: null 
}

所以我们就会在Java中定义类如下:


public class Result implements Serializable {
    private Integer code;
    private String message;
    private Object data;
    
    public Result(Integer code, String message, Object data) {
        this.code = code;
        this.message = message;
        this.data = data;
    }
    
	...
}

我们来看下3个字段的意思:

  • code:状态码
  • message:请求情况,例如请求成功,用户名不存在,密码错误等
  • data:数据

一般情况情况下,code和message是一起的,所以我们可以用上枚举来记录存在的状态码和信息。

2、Code和Msg的枚举类

我们定义的枚举可以如下:

public enum ResultCode {

    SUCCESS(1,"成功"),
    PARAM_IS_INVALID(1001,"参数无效"),
    PARAM_IS_BLANK(1002,"参数为空"),
    USER_NOT_LOGGED_IN(2001,"用户未登录"),
    USER_LOGIN_ERROR(2002,"用户不存在或密码错误"),
    USER_NOT_EXISITED(2003,"用户不存在");

    private Integer code;
    private String message;

    public Integer getCode() {
        return code;
    }

    public String getMessage() {
        return message;
    }

    ResultCode(Integer code, String message) {
        this.code = code;
        this.message = message;
    }
}

我们将Result可用的构造方法添加上去,与ResultCode枚举类联动起来。

    public Result(ResultCode resultCode){
        this.code = resultCode.getCode();
        this.message = resultCode.getMessage();
    }

    public Result(ResultCode resultCode,Object data) {
        this.code = resultCode.getCode();
        this.message = resultCode.getMessage();
        this.data = data;
    }

但是这样子还不是很香,构造起来看的脑瓜疼,每一个类我们都需要手动去构造,所以我们在Result中加上静态方法。

new Result(ResultCode.SUCCESS,data);

3、静态方法

方法如下:


    public static Result success(){
        Result result = new Result(ResultCode.SUCCESS);
        return result;
    }

    public static Result success(Object data){
        Result result = new Result(ResultCode.SUCCESS, data);
        return result;
    }

    public static Result failure(ResultCode resultCode){
        Result result = new Result(resultCode);
        return result;
    }

    public static Result failure(ResultCode resultCode,Object data){
        Result result = new Result(resultCode, data);
        return result;
    }

这样子,我们只需要调用Result.success(data);就好了,但是还是脑瓜疼,我想直接返回数据,于是我们加上ResponseBodyAdvice

4、ResponseBodyAdvice

ResponseBodyAdvice接口的实现类作用在controller将请求处理好返回结果,但是在将结果返回给客户端之前。

ResponseBodyAdvice接口详情如下:共有两个接口

  • supports:判断是否需要执行beforeBodyWrite方法,返回结果为true执行,为false则不执行。
  • beforeBodyWrite:对response具体的处理方法
public interface ResponseBodyAdvice<T> {
    //判断是否要执行beforeBodyWrite方法,true为执行,false不执行
    boolean supports(MethodParameter var1, Class<? extends HttpMessageConverter<?>> var2);
    
	//对response处理的执行方法
    @Nullable
    T beforeBodyWrite(@Nullable T var1, MethodParameter var2, MediaType var3, Class<? extends HttpMessageConverter<?>> var4, ServerHttpRequest var5, ServerHttpResponse var6);
}

所以我们这样子,在beforeBodyWrite方法中加入我们想要封装的方式。

@RestControllerAdvice("com.order.food.delivery.controller")
public class ResponseResultHandler implements ResponseBodyAdvice<Object> {

    @Override
    public boolean supports(MethodParameter methodParameter, Class<? extends HttpMessageConverter<?>> aClass) {
        return true;
    }

    @Override
    public Object beforeBodyWrite(Object body, MethodParameter methodParameter, MediaType mediaType, Class<? extends HttpMessageConverter<?>> aClass, ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse) {
        return Result.success(body);
    }
}

看,通过自定ResponseBodyAdvice来决定返回结果的封装方式,我们就可以直接返回数据了。

@ControllerAdvice就是表示我们需要对哪个controller的结果需要包装,但是我有一个不需要包装了,怎么办?于是我们自定义注解+拦截器添加标记,在supports方法中检验是否有标记来决定是否执行beforeBodyWrite方法。

5、自定义注解和拦截器

我们先来个空注解

/**
 * 返回结果处理标记注解
 *
 * @author :Mr.Garlic
 * @date : 2021/1/10
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE,ElementType.METHOD})
@Documented
public @interface ResponseResult {
}

我们再来个拦截器并把它配置进容器,我们起个标记,有注解的话就加个标记到request中。


/**
 * ResponseResult注解拦截器
 *
 * @author: Mr.Garlic
 * @date: 2021/1/10
 */
public class ResponseResultInterceptor implements HandlerInterceptor {
    
    /**
     * 标记名称
     */
    public static final String RESPONSE_NEED_RESULT = "RESPONSE_NEED_RESULT";


    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        //请求方法
        if(handler instanceof HandlerMethod){
            final HandlerMethod handlerMethod = (HandlerMethod)handler;
            //  拿到的是方法所在的controller类的class类
            final Class<?> clazz = handlerMethod.getBeanType();
            // 拿到method对象
            final Method method = handlerMethod.getMethod();
            // 判断是否在类对象上面加了注解
            if(clazz.isAnnotationPresent(ResponseResult.class)){
                // 设置此请求返回体
                request.setAttribute(RESPONSE_NEED_RESULT,
                                     clazz.getAnnotation(ResponseResult.class));
            }else if(method.isAnnotationPresent(ResponseResult.class)){
                // 设置此请求返回体
                request.setAttribute(RESPONSE_NEED_RESULT,
                                     method.getAnnotation(ResponseResult.class));
            }
        }
        return true;
    }
}


/**
 * web配置类
 *
 * @author :Mr.Garlic
 * @date : 2021/1/11
 */
@Configuration
public class WebConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new ResponseResultInterceptor()).addPathPatterns("/**");
    }
}

然后我们再来修改下自定义ResponseBodyAdvice里面的逻辑

/**
 * controller返回结果包装
 *
 * @author: Mr.Garlic
 * @date: 2021/1/11
 */
@RestControllerAdvice("com.order.food.delivery.controller")
public class ResponseResultHandler implements ResponseBodyAdvice<Object> {

    /**
     * 标记名称
     */
    public static final String RESPONSE_NEED_RESULT = "RESPONSE_NEED_RESULT";

    // 判断是否需要执行beforeBodyWrite
    @Override
    public boolean supports(MethodParameter methodParameter, Class<? extends HttpMessageConverter<?>> aClass) {
        
        ServletRequestAttributes servletRequestAttributes = (ServletRequestAttributes)RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = servletRequestAttributes.getRequest();
        ResponseResult responseResultAnn = (ResponseResult)request.getAttribute(RESPONSE_NEED_RESULT);
        return responseResultAnn == null?false:true;
    }

    @Override
    public Object beforeBodyWrite(Object body, MethodParameter methodParameter, MediaType mediaType, Class<? extends HttpMessageConverter<?>> aClass, ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse) {
        return Result.success(body);
    }
}

这样子,我们可以很直接,有选择地包装对象啦。

你说,后面还有没有选择,当然有啦,优化流程怎么可能少得了缓存呢,不过,下次吧!

已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 书香水墨 设计师:CSDN官方博客 返回首页