浅谈微服务下异常处理

2019独角兽企业重金招聘Python工程师标准>>>

谈到微服务,必不可免就谈到spring cloud.

笔者正是基于spring cloud架构下的异常处理.

异常,按照业务划分下来,分为三类: 参数校验异常,自定义异常,以及系统异常.

参数校验异常: 通常是缺少参数,参数类型错误,以及相关校验不通过(javax.validation).

通常我们项目一开始,便定义了统一的基础异常类,和统一的错误码.

例如:

• 成功: 2000
• 缺少参数: 5001
• 参数类型错误: 5002
• 参数校验异常: 5003
• 系统异常: 5000

基础异常类:

public abstract class BaseException extends RuntimeException {
    private String code = ResultCodeConstant.SYSTEM_ERROR;

    public Result getResult() {
        return Result.fail(this.code, this.getMessage() != null?this.getMessage():"error");
    }

    public BaseException() {
    }

    public BaseException(String message) {
        super(message);
    }

    public BaseException(String code, String message) {
        super(message);
        this.code = code;
    }

    public BaseException(String message, Throwable cause) {
        super(message, cause);
    }

    public BaseException(Throwable cause) {
        super(cause);
    }

    public BaseException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
    }

    public String getCode() {
        return this.code;
    }

    public void setCode(String code) {
        this.code = code;
    }
}

code常量类:

public class ResultCodeConstant {
    public static final String SUCCESS = "2000";//成功
    public static final String ARGUMENT_VANISH = "5001";//缺少参数
    public static final String ARGUMENT_TYPE_MISMATCH = "5002";//类型错误
    public static final String ARGUMENT_CONSTRAINT_VIOLATION = "5003";//参数校验错误
    public static final String SYSTEM_ERROR = "5000";
}

对外服务

为了达到对外服务的友好和保密,处理异常时,往往是拦截异常后返回友好结果.

首先约定了对外的结果的封装

public class Result<T> implements Serializable {
    private String code;
    private String desc;
    private T data;

    public T getData() {
        return this.data;
    }

    public Result(String code, String desc, T data) {
        this.code = code;
        this.desc = desc;
        this.data = data;
    }

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

    public Result() {
    }

    public Result(String code, String desc) {
        this.code = code;
        this.desc = desc;
    }

    public String getCode() {
        return this.code;
    }

    public void setCode(String code) {
        this.code = code;
    }

    public String getDesc() {
        return this.desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }

    public String toJsonString() {
        return JSONObject.toJSONString(this, new SerializerFeature[]{SerializerFeature.WriteNullStringAsEmpty, SerializerFeature.WriteDateUseDateFormat});
    }

    public static Result okDesc() {
        return new Result(ResultCodeConstant.SUCCESS, "成功");
    }

    public static Result okDesc(String desc) {
        return new Result(ResultCodeConstant.SUCCESS, desc);
    }

    public static Result ok(Object data) {
        return new Result(ResultCodeConstant.SUCCESS, "", data);
    }

    public static Result ok(String desc, Object data) {
        return new Result(ResultCodeConstant.SUCCESS, desc, data);
    }

    public static Result fail() {
        return new Result(ResultCodeConstant.SYSTEM_ERROR, "error");
    }

    public static Result fail(String dsec) {
        return new Result(ResultCodeConstant.SYSTEM_ERROR, dsec);
    }

    public static Result fail(String code, String dsec) {
        return new Result(code, dsec);
    }

    public static Result fail(String code, String dsec, Object data) {
        return new Result(code, dsec, data);
    }
}

在spring中,可以通过@ControllerAdvice来拦截controller中抛出的异常

/**
 * Created by wenshiliang on 2017/1/16.
 */
@ControllerAdvice()
@ConfigurationProperties
@Slf4j
public class GlobalExceptionHandler {



    @Autowired
    private CounterService counterService;

    public GlobalExceptionHandler() {
        log.info("GlobalExceptionHandler构建");
    }

    @ExceptionHandler(BaseException.class)
    @ResponseBody
    public Result baseExceptionHandler(BaseException e, HttpServletResponse response) {
        log.error("拦截自定义异常", e);
        counterService.increment("exception.custom");
        return e.getResult();
    }

    @ExceptionHandler(MissingServletRequestParameterException.class)
    @ResponseBody
    public Result missingServletRequestParameterExceptionHandler(MissingServletRequestParameterException e,
                                                                 HttpServletResponse response) {
        log.warn("缺少参数", e);
        counterService.increment("exception.check");
        return Result.fail(ResultCodeConstant.ARGUMENT_VANISH,"缺少参数");
    }

    @ExceptionHandler(MethodArgumentTypeMismatchException.class)
    @ResponseBody
    public Result methodArgumentTypeMismatchExceptionExceptionHandler(MethodArgumentTypeMismatchException e,
                                                                      HttpServletResponse response) {
        log.warn("参数类型不正确", e);
        counterService.increment("exception.check");
        return Result.fail(ResultCodeConstant.ARGUMENT_TYPE_MISMATCH,"参数类型不正确");
    }


    /**
     * 参数校验异常
     *
     * @param e
     * @param response
     * @return
     */
    @ExceptionHandler(ConstraintViolationException.class)
    @ResponseBody
    public Result constraintViolationExceptionHandler(ConstraintViolationException e, HttpServletResponse response) {
        log.warn("参数校验异常", e);
        StringBuilder builder = new StringBuilder();
        Set<ConstraintViolation<?>> set = e.getConstraintViolations();
        if (set != null && set.size() > 0) {
            set.forEach(active -> {
                log.warn(active.getRootBeanClass() + active.getMessage());
                builder.append(active.getMessage()).append(".");
            });
        } else {
            builder.append("参数校验异常");
        }
        counterService.increment("exception.check");
        return Result.fail(ResultCodeConstant.ARGUMENT_CONSTRAINT_VIOLATION,builder.toString());
    }

    @ExceptionHandler(BindException.class)
    @ResponseBody
    public Result BindException(BindException e, HttpServletResponse response) {
        log.warn("参数校验异常", e);
        counterService.increment("exception.check");
        String desc = e.getBindingResult().getFieldError().getDefaultMessage();
        return Result.fail(ResultCodeConstant.ARGUMENT_CONSTRAINT_VIOLATION, desc);
    }



    @ExceptionHandler//处理其他异常
    @ResponseBody //
    public Result exceptionHandler(Exception e, HttpServletResponse response) {
        Result result = null;
        log.error("拦截异常", e);
        counterService.increment("exception.system");
        result = Result.fail();
        return result;
    }
}

##对内服务

转载于:https://my.oschina.net/superwen/blog/1502954