相信大家在使用微服务的过程中,必定会遇到远程服务的调用,既然这样,必定也会存在一个如何优雅的接收调用下游服务的响应的问题。
文章介绍的思路总结下: 统一响应数据处理+ 统一异常处理 !
说明:我这里采用Feign的方式来进行远程服务调用。 如果下游服务抛出了异常,正常情况下,上游接收到的是一个FeignException的异常。
解决思路
(1)统一接口响应实体
每个微服务接口的响应类型统一,比如我这边都统一成ResponseBaseDTO类。这个类可以做成一个底层共通的jar包,或者做成一个共通的微服务。
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
@Getter
@Setter
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class ResponseBaseDTO {
private String code;
private String message;
private Object data;
}
接着在每个微服务里拓展下ResponseBaseDTO , 比如写一个子类,子类里可以定义如何去构造ResponseBaseDTO。
import com.yuki.code.enums.UserErrorEnum;
import com.yuki.common.dto.ResponseBaseDTO;
public class ResponseDTO<T> extends ResponseBaseDTO {
public static ResponseBaseDTO success() {
return success(null);
}
public static ResponseBaseDTO success(Object data) {
return ResponseBaseDTO.builder().code(UserErrorEnum.SUCCESS.getCode()).message(UserErrorEnum.SUCCESS.getMsg()).data(data).build();
}
public static ResponseBaseDTO error(String code, String message) {
return ResponseBaseDTO.builder().code(code).message(message).build();
}
public static ResponseBaseDTO error(UserErrorEnum errorEnum) {
return ResponseBaseDTO.builder().code(errorEnum.getCode()).message(errorEnum.getMsg()).build();
}
public static ResponseBaseDTO error(UserErrorEnum errorEnum, String message) {
return ResponseBaseDTO.builder().code(errorEnum.getCode()).message(message).build();
}
}
思考一下,为什么要自定义呢?主要是因为每个微服务里必定都有自己对应的错误枚举类。这些枚举类主要就是业务异常对应的响应code和响应msg。以下是我的用户服务的错误枚举类:
import lombok.Getter;
@Getter
public enum UserErrorEnum {
SUCCESS("0", "成功"){
//所有微服务的成功code都统一为0 !
//如果有前端对接的话,一般认定某个固定code就是正常code
//如果每个微服务不一致的话,前端对接的时候应该头很大
@Override
public String getCode() {
return "0";
}
},
SYS_ERROR("0001", "系统异常"),
VALID_ERROR("0002", "校验参数有误"),
EMAIL_EXIST_ERROR("1001", "邮箱已被占"),
USER_NOT_EXIST_ERROR("1002", "账号不存在"),
USER_PASSWROD_ERROR("1003", "账号密码错误"),
;
private String code;
private String msg;
UserErrorEnum(String code, String msg) {
this.code = code;
this.msg = msg;
}
//其中的前缀10表示的是用户服务。每个服务建议都使用唯一的前缀标识。
//这样当上游服务接收到下游服务抛出异常的情况下,就知道是哪个微服务出现了问题
public String getCode() {
return "10" + code;
}
}
(2)统一处理接口响应数据的接口
这里算插播的一段,主要是为了简化接口返回值的处理。正常没有优化的情况下,如果我的接口需要返回一个LoginToken对象,我会这么写:
//查询用户信息
@GetMapping("/info/{token}")
public ResponseBaseDTO info(@PathVariable String token){
LagouToken tokenModel = userService.findByToken(token);
//。。。。
tokenModel.setPassword(null);//敏感字段不返回
tokenModel.setToken(null);
//编辑返回值
ResponseBaseDTO data = new ResponseBaseDTO();
data.setCode(UserErrorEnum.SUCCESS.getCode());
data.setMessage(UserErrorEnum.SUCCESS.getMsg());
data.setData(tokenModel);
return data;
}
相当于每个接口的返回值类型都是ResponseBaseDTO, 这样每个接口最后都需要编辑ResponseBaseDTO的setCode ,setMessage 的方法 。 emmm。。。。觉得有点繁琐。先看看优化后的代码 :
//查询用户信息
@GetMapping("/info/{token}")
public LagouToken info(@PathVariable String token) throws BusinessException {
LagouToken tokenModel = userService.findByToken(token);
if (tokenModel == null) {
throw new BusinessException(UserErrorEnum.USER_NOT_EXIST_ERROR);
}
tokenModel.setPassword(null);//敏感字段不返回
tokenModel.setToken(null);
return tokenModel;
}
{
"code": "0",
"message": "成功",
"data": {
"id": 2,
"email": "1323168489@qq.com",
"token": null,
"password": null
}
}
瓦特 ! 接口直接是LagouToken对象就可以了么!
这里使用的@RestControllerAdvice + 实现 ResponseBodyAdvice 统一处理接口响应数据。
import com.yuki.code.dto.ResponseDTO;
import com.yuki.code.enums.UserErrorEnum;
import com.yuki.common.dto.ResponseBaseDTO;
import org.springframework.core.MethodParameter;
import org.springframework.http.MediaType;
import org.springframework.http.converter.HttpMessageConverter;
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;
@RestControllerAdvice
public class GlobalResponseHandler implements ResponseBodyAdvice<Object> {
@Override
public boolean supports(MethodParameter methodParameter, Class<? extends HttpMessageConverter<?>> aClass) {
//对所有类型的结果都支持
return true;
}
@Override
public Object beforeBodyWrite(Object o, MethodParameter methodParameter, MediaType mediaType, Class<? extends HttpMessageConverter<?>> aClass, ServerHttpRequest serverHttpRequest, ServerHttpResponse serverHttpResponse) {
//null , Object(实体对象,list,map) , 统一异常处理后的ResponseDTO
if (o instanceof ResponseBaseDTO) {
// ResponseDTO 无需再封装
return o;
}
ResponseBaseDTO build = ResponseDTO.builder().code(UserErrorEnum.SUCCESS.getCode()).message(UserErrorEnum.SUCCESS.getMsg())
.data(o).build();
return build;
}
}
(3)统一处理接口异常
这波操作是重点 , 重点在于拦截下FeignClientException , 因为在Feign调用服务的时候,会将下游的异常接口再封装成FeignClientException 。
如果我们在上游服务中,拦截到FeignClientException ,并提取出对应的ResponseBaseDTO , 再抛出不就解决问题了么 ?
相信这个大家不会陌生吧。肯定直接想到了@RestControllerAdvice + @ExceptionHandler 。这里直接贴代码吧,也是很简单的 :
package com.yuki.code.handler;
import com.alibaba.fastjson.JSON;
import com.netflix.client.ClientException;
import com.yuki.code.dto.ResponseDTO;
import com.yuki.code.enums.UserErrorEnum;
import com.yuki.code.exception.BusinessException;
import com.yuki.code.util.StringUtils;
import com.yuki.common.dto.ResponseBaseDTO;
import feign.FeignException;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpStatus;
import org.springframework.validation.BindException;
import org.springframework.validation.ObjectError;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import java.nio.ByteBuffer;
import java.util.List;
import java.util.Optional;
/**
* 全局统一异常处理
*/
@Slf4j
@RestControllerAdvice
public class GlobalExceptionHandler {
@ExceptionHandler(value = {FeignException.class})
@ResponseStatus(value = HttpStatus.INTERNAL_SERVER_ERROR)
public ResponseBaseDTO feignException(FeignException e) {
log.error("FeignException:", e);
//由于上游服务也同样使用了统一数据处理,不管正常还是异常,响应
//的都是ResponseBaseDTO 。所以这里的responseBody()其实就是
// ResponseBaseDTO 的json 字符串 。
Optional<ByteBuffer> byteBuffer = e.responseBody();
if (byteBuffer.isPresent()) {
String responseJson = StringUtils.getString(byteBuffer.get());
ResponseBaseDTO responseBaseDTO = JSON.parseObject(responseJson, ResponseBaseDTO.class);
return ResponseDTO.error(responseBaseDTO.getCode(), responseBaseDTO.getMessage());
}
return ResponseDTO.error(UserErrorEnum.SYS_ERROR, "调用下游服务异常");
}
/**
* 业务异常
*
* @param e
* @return
*/
@ExceptionHandler(value = {BusinessException.class})
@ResponseStatus(value = HttpStatus.INTERNAL_SERVER_ERROR)
public ResponseBaseDTO businessException(BusinessException e) {
log.error("BusinessException:", e);
//从error枚举转成code + message ,提高通用性(支持扇出的服务)
return ResponseDTO.error(e.getCode(), e.getMessage());
}
/**
* 参数校验异常
*
* @param e
* @return
*/
@ExceptionHandler(value = {BindException.class})
@ResponseStatus(value = HttpStatus.INTERNAL_SERVER_ERROR)
public ResponseBaseDTO validException(BindException e) {
log.error("BindException:", e);
return this.getValidExceptionResult(e.getBindingResult().getAllErrors());
}
/**
* 运行异常
*
* @param e
* @return
*/
@ExceptionHandler(value = {Exception.class})
@ResponseStatus(value = HttpStatus.INTERNAL_SERVER_ERROR)
public ResponseBaseDTO exception(Exception e) {
log.error("Exception:", e);
return ResponseDTO.error(UserErrorEnum.SYS_ERROR);
}
//参数校验异常处理
private ResponseBaseDTO getValidExceptionResult(List<ObjectError> objectErrors) {
StringBuilder sb = new StringBuilder();
for (ObjectError error : objectErrors) {
sb.append(error.getObjectName()).append(";");
}
String message = sb.length() > 0 ? sb.toString().substring(0, sb.length() - 1) : sb.toString();
//参数校验失败
return ResponseDTO.error(UserErrorEnum.VALID_ERROR, message);
}
}
另外,正因为有了这个统一异常处理,所以,如果代码中遇到了业务异常,直接抛出即可, 前端接收到的数据会被处理成ResponseBaseDTO的JSON 。
遗留问题
本人遇到了一个,如果方法直接返回String类型的话,接口响应的时候会报错,大概就是类型转换错误,额,目前还没找到原因,只能避开这个bug , 待有空余时间再查下具体原因。
//查询用户信息
@GetMapping("/info/{token}")
public String info(@PathVariable String token) throws BusinessException {
LagouToken tokenModel = userService.findByToken(token);
if (tokenModel == null) {
throw new BusinessException(UserErrorEnum.USER_NOT_EXIST_ERROR);
}
//直接
return tokenModel.getToken();
}
java.lang.ClassCastException: com.yuki.common.dto.ResponseBaseDTO cannot be cast to java.lang.String
at org.springframework.http.converter.StringHttpMessageConverter.addDefaultHeaders(StringHttpMessageConverter.java:44) ~[spring-web-5.2.7.RELEASE.jar:5.2.7.RELEASE]
at org.springframework.http.converter.AbstractHttpMessageConverter.write(AbstractHttpMessageConverter.java:211) ~[spring-web-5.2.7.RELEASE.jar:5.2.7.RELEASE]
at org.springframework.web.servlet.mvc.method.annotation.AbstractMessageConverterMethodProcessor.writeWithMessageConverters(AbstractMessageConverterMethodProcessor.java:290) ~[spring-webmvc-5.2.7.RELEASE.jar:5.2.7.RELEASE]
at org.springframework.web.servlet.mvc.method.annotation.RequestResponseBodyMethodProcessor.handleReturnValue(RequestResponseBodyMethodProcessor.java:181) ~[spring-webmvc-5.2.7.RELEASE.jar:5.2.7.RELEASE]
at org.springframework.web.method.support.HandlerMethodReturnValueHandlerComposite.handleReturnValue(HandlerMethodReturnValueHandlerComposite.java:82) ~[spring-web-5.2.7.RELEASE.jar:5.2.7.RELEASE]
at org.springframework.web.servlet.mvc.method.annotation.ServletInvocableHandlerMethod.invokeAndHandle(ServletInvocableHandlerMethod.java:123) ~[spring-webmvc-5.2.7.RELEASE.jar:5.2.7.RELEASE]
at org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.invokeHandlerMethod(RequestMappingHandlerAdapter.java:879) ~[spring-webmvc-5.2.7.RELEASE.jar:5.2.7.RELEASE]
at org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.handleInternal(RequestMappingHandlerAdapter.java:793) ~[spring-webmvc-5.2.7.RELEASE.jar:5.2.7.RELEASE]
at org.springframework.web.servlet.mvc.method.AbstractHandlerMethodAdapter.handle(AbstractHandlerMethodAdapter.java:87) ~[spring-webmvc-5.2.7.RELEASE.jar:5.2.7.RELEASE]
at org.springframework.web.servlet.DispatcherServlet.doDispatch(DispatcherServlet.java:1040) ~[spring-webmvc-5.2.7.RELEASE.jar:5.2.7.RELEASE]
at org.springframework.web.servlet.DispatcherServlet.doService(DispatcherServlet.java:943) ~[spring-webmvc-5.2.7.RELEASE.jar:5.2.7.RELEASE]
at org.springframework.web.servlet.FrameworkServlet.processRequest(FrameworkServlet.java:1006) [spring-webmvc-5.2.7.RELEASE.jar:5.2.7.RELEASE]
at org.springframework.web.servlet.FrameworkServlet.doGet(FrameworkServlet.java:898) [spring-webmvc-5.2.7.RELEASE.jar:5.2.7.RELEASE]
at javax.servlet.http.HttpServlet.service(HttpServlet.java:634) [tomcat-embed-core-9.0.36.jar:9.0.36]
at org.springframework.web.servlet.FrameworkServlet.service(FrameworkServlet.java:883) [spring-webmvc-5.2.7.RELEASE.jar:5.2.7.RELEASE]
at javax.servlet.http.HttpServlet.service(HttpServlet.java:741) [tomcat-embed-core-9.0.36.jar:9.0.36]
at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:231) [tomcat-embed-core-9.0.36.jar:9.0.36]
at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:166) [tomcat-embed-core-9.0.36.jar:9.0.36]
at org.apache.tomcat.websocket.server.WsFilter.doFilter(WsFilter.java:53) [tomcat-embed-websocket-9.0.36.jar:9.0.36]
at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:193) [tomcat-embed-core-9.0.36.jar:9.0.36]
at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:166) [tomcat-embed-core-9.0.36.jar:9.0.36]
at org.springframework.web.filter.RequestContextFilter.doFilterInternal(RequestContextFilter.java:100) [spring-web-5.2.7.RELEASE.jar:5.2.7.RELEASE]
at org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:119) [spring-web-5.2.7.RELEASE.jar:5.2.7.RELEASE]
at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:193) [tomcat-embed-core-9.0.36.jar:9.0.36]