Spring Cloud的全局封装实践

前言

跨应用的全局封装通过模仿java的异常抛出实现，通过各个服务使用相同的接口返回格式实现服务消息的传递，在规范化的同时快速定位真正出现问题的服务。

全局接口返回格式分为外部接口格式和内部接口格式，这里简化为内外接口格式一致。

整体流程如下:

全局返回封装类

整个spring cloud服务的统一接口

public class ResponseResult<T> implements Serializable {

    /**
     *
     */
    private static final long serialVersionUID = 1679552421651455773L;

    private int status; //状态码，根据服务实际需求自定义

    private String msg;

    private T data;

    private String url; //请求的url

    private Long host; //出现问题的根服务

    public static ResponseResult ok(Object data, String url) {
        return new ResponseResult(ResponseStatusCode.OK, data, url, null);
    }

    public static ResponseResult ok(String msg, Object data, String url) {
        return new ResponseResult(ResponseStatusCode.OK, msg, data, url, null);
    }

    public static ResponseResult ok(String msg, String url) {
        return new ResponseResult(ResponseStatusCode.OK, msg, null, url, null);
    }

    public static ResponseResult fail(int status, String msg, String url, Long host) {
        return new ResponseResult(status, msg, url, host);
    }

    public ResponseResult() {
    }

    public ResponseResult(String msg, T data, String url, Long host) {
        this.msg = msg;
        this.data = data;
        this.url = url;
        this.host = host;
    }

    public ResponseResult(int status, String msg, String url, Long host) {
        this.status = status;
        this.msg = msg;
        this.url = url;
        this.host = host;
    }

    public ResponseResult(int status, T data, String url, Long host) {
        this.status = status;
        this.data = data;
        this.url = url;
        this.host = host;
    }

    public ResponseResult(int status, String msg, T data, String url, Long host) {
        this.status = status;
        this.msg = msg;
        this.data = data;
        this.url = url;
        this.host = host;
    }

    public ResponseResult(int status, String msg, T data, Long host) {
        this.status = status;
        this.msg = msg;
        this.data = data;
        this.host = host;
    }

    public int getStatus() {
        return status;
    }

    public void setStatus(int status) {
        this.status = status;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public T getData() {
        return data;
    }

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

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public Long getHost() {
        return host;
    }

    public void setHost(Long host) {
        this.host = host;
    }
}

状态码常量类

这个类为整体服务定义的状态码，可以使用枚举实现

public class ResponseStatusCode {

    /**
     * OK
     */
    public static final int OK = 0;

    /**
     * 未知异常
     */
    public static final int UNKNOW_EXCEPTION = 100;

    /**
     * 参数异常
     */
    public static final int ARGUMENT_EXCEPTION = 104;
    
    /**
     * 自定义异常
     */
    public static final int ARGUMENT_EXCEPTION = XXX;
}

自定义异常类

自定义异常类继承RuntimeException

public class CustomException extends RuntimeException{
    public static final long serialVersionUID = 1L;
    private int status;
    private Long host;

    public CustomException(int status) {
        this.status = status;
    }

    /**
     * 抛出异常使用自定义的异常码
     * @param status 自定义异常码
     * @param message 异常信息
     */
    public CustomException(int status, String message) {
        super(message);
        this.status = status;
    }

    public CustomException(String message, Throwable cause, int status) {
        super(message, cause);
        this.status = status;
    }

    public CustomException(Throwable cause, int status) {
        super(cause);
        this.status = status;
    }

    public CustomException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace, int status) {
        super(message, cause, enableSuppression, writableStackTrace);
        this.status = status;
    }

    public CustomException(int status, Long host) {
        this.status = status;
        this.host = host;
    }

    /**
     * 抛出异常使用自定义的异常码
     * @param status 自定义异常码
     * @param message 异常信息
     * @param host 主机
     */
    public CustomException(int status, String message, Long host) {
        super(message);
        this.status = status;
        this.host = host;
    }

    public CustomException(String message, Throwable cause, int status, Long host) {
        super(message, cause);
        this.status = status;
        this.host = host;
    }

    public CustomException(Throwable cause, int status, Long host) {
        super(cause);
        this.status = status;
        this.host = host;
    }

    public CustomException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace, int status, Long host) {
        super(message, cause, enableSuppression, writableStackTrace);
        this.status = status;
        this.host = host;
    }

    public int getStatus() {
        return status;
    }

    public void setStatus(int status) {
        this.status = status;
    }

    public Long getHost() {
        return host;
    }

    public void setHost(Long host) {
        this.host = host;
    }
}

接口全局响应处理类

使用spring自带controller响应处理类，使用全局封装类封装返回

@ControllerAdvice
public class CustomResponseAdivce implements ResponseBodyAdvice<Object> {

    // 这个方法表示对于哪些请求要执行beforeBodyWrite，返回true执行，返回false不执行
    @Override
    public boolean supports(MethodParameter methodParameter, Class aClass) {
        return true;
    }

    // 对于返回的对象如果不是最终对象ResponseResult，则选包装一下
    @Override
    public Object beforeBodyWrite(Object o, MethodParameter methodParameter, MediaType mediaType, Class aClass,
                                  ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse) {
        ServletServerHttpRequest servletServerHttpRequest = (ServletServerHttpRequest) serverHttpRequest;
        String url = servletServerHttpRequest.getServletRequest().getRequestURL().toString();

        if (!(o instanceof ResponseResult)) {
            ResponseResult responseResult = null;
            // 因为handler处理类的返回类型是String，为了保证一致性，这里需要将ResponseResult转回去
            if (o instanceof String) {
                responseResult = ResponseResult.ok(o, url);
                ObjectMapper mapper = new ObjectMapper();
                String responseString = "";
                try {
                    responseString = mapper.writeValueAsString(responseResult);
                } catch (JsonProcessingException e) {
                    e.printStackTrace();
                }
                return responseString;
            }else {
                responseResult = ResponseResult.ok(o, url);
                return responseResult;
            }
        }
        return o;
    }
    
}

异常处理类

业务中通过抛出异常的方式来处理错误，在此处可以全局处理

@RestControllerAdvice
public class ExceptionAdvice {
    private Logger logger = LoggerFactory.getLogger(this.getClass());

    /**
     * 出错服务端口
     */
    @Value("${server.port}")
    private int servicePort;

    /**
     * 封装异常
     *
     * @param req 请求
     * @param e   异常类
     * @return 返回封装类
     */
    @ExceptionHandler(value = Exception.class)
    public ResponseResult jsonErrorHandler(HttpServletRequest req, Exception e) {
        logger.error(req.getRequestURL().toString(), e);
        Long host = null;
        //分配异常码与host
        int status = ResponseStatusCode.UNKNOW_EXCEPTION;
        String msg = e.getMessage();
        if (e instanceof IOException || e instanceof CustomIOException) {
            status = ResponseStatusCode.IO_EXCEPTION;
            if (e instanceof CustomIOException){
                host = ((CustomIOException) e).getHost();
            }
        } else if (e instanceof NullPointerException || e instanceof CustomNullPointerException) {
            status = ResponseStatusCode.NULL_EXCEPTION;
            if (e instanceof CustomNullPointerException){
                host = ((CustomNullPointerException) e).getHost();
            }
        } else if (e instanceof SQLException || e instanceof CustomSQLException) {
            status = ResponseStatusCode.SQL_EXCEPTION;
            if (e instanceof CustomSQLException){
                host = ((CustomSQLException) e).getHost();
            }
        } else if (e instanceof ArgumentException) {
            status = ResponseStatusCode.ARGUMENT_EXCEPTION;
            if (((ArgumentException) e).getHost() != null && !((ArgumentException) e).getHost().equals(0)){
                host = ((ArgumentException) e).getHost();
            }
        } else if (e instanceof CustomException) {
            status = ((CustomException) e).getStatus();
            if (((CustomException) e).getHost() != null && !((CustomException) e).getHost().equals(0)){
                host = ((CustomException) e).getHost();
            }
        } else if (e instanceof UndeclaredThrowableException) {
            Throwable targetEx = ((UndeclaredThrowableException) e).getUndeclaredThrowable();
            if (targetEx != null) {
                msg = targetEx.getMessage();
            }
        }
        //获取出错服务ip
        int ip = 0;
        try {
            ip = Integer.valueOf(
                    Arrays.stream(
                            InetAddress.getLocalHost().getHostAddress()
                                    .split("\\.")).collect(Collectors.joining()));
        } catch (Exception e1) {
        }
        return ResponseResult.fail(
                status, msg, req.getRequestURL().toString(),
                host == null? Long.valueOf(String.valueOf(ip) + servicePort): host);
    }

}

接口响应处理类

上游服务获得下游服务的响应的处理类

public class ResponseHandler<T> {

    /**
     * 处理调用远程接口的返回
     * @param responseResult
     * @return
     */
    public T handler(ResponseResult<?> responseResult) {
        int statusToken = responseResult.getStatus();
        String msg = responseResult.getMsg();
        Long host = responseResult.getHost();
        if (ResponseStatusCode.OK != statusToken){
            exceptionHandler(statusToken,msg, host);
        }

        return (T) responseResult.getData();
    }

    /**
     * 处理异常
     * @param statusToken 状态码
     * @param msg 错误消息
     * @param host 主机
     */
    private static void exceptionHandler(int statusToken, String msg, Long host) {
        if (ResponseStatusCode.IO_EXCEPTION == statusToken) {
            throw new CustomIOException(msg, host);
        } else if (ResponseStatusCode.NULL_EXCEPTION== statusToken) {
            throw new CustomNullPointerException(msg, host);
        } else if (ResponseStatusCode.SQL_EXCEPTION== statusToken) {
            throw new CustomSQLException(msg, host);
        } else if (ResponseStatusCode.ARGUMENT_EXCEPTION== statusToken) {
            throw new ArgumentException(msg, host);
        } else if (ResponseStatusCode.UNKNOW_EXCEPTION== statusToken) {
            throw new UnknowException(msg, host);
        } else {
            throw new CustomException(statusToken, msg, host);
        }
    }
}

接口例子

上面是所有服务都需要拥有的类，然后是几个调用的小例子

首先是几个接口

@RestController
@RefreshScope
public class DcController {
    final
    ClientService clientService;

    @Autowired
    public DcController(ClientService clientService) {
        this.clientService = clientService;
    }
    
    @GetMapping("exception1")
    public String exception1() {
        throw new ArgumentException("错误");
    }

    @GetMapping("exception2")
    public int exception2() {
        throw new CustomException(250, "业务异常，自定义异常码");
    }

    @GetMapping("exception3")
    public int exception3(){
        return new ResponseHandler<List<MetaVO>>().handler(clientService.generateList()).get(0).getDbid();
    }

    @GetMapping("list")
    public List<MetaVO> generateList() {
        List<MetaVO> list = new ArrayList<>();
        for (int i = 0; i < 2; i++) {
            MetaVO metaVO = new MetaVO();
            metaVO.setDbid(i);
            list.add(metaVO);
        }
        return list;
    }

}

然后是结果

总结

以上就是spring cloud的全局封装实践，开发人员编写业务逻辑不需要考虑返回的封装，只需要考虑业务和自定义的状态码而已