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

女爷i 2023-01-05 12:06 117阅读 0赞

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

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);
        }
    }

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

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