微服务如何接收下游服务抛出的异常

最新推荐文章于 2024-02-02 16:37:40 发布

快乐妮子

最新推荐文章于 2024-02-02 16:37:40 发布

阅读量4.5k

点赞数

分类专栏： web

本文链接：https://blog.csdn.net/u014240299/article/details/107179846

版权

web 专栏收录该内容

28 篇文章 0 订阅

订阅专栏

相信大家在使用微服务的过程中，必定会遇到远程服务的调用，既然这样，必定也会存在一个如何优雅的接收调用下游服务的响应的问题。

文章介绍的思路总结下：统一响应数据处理+ 统一异常处理！

说明：我这里采用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]