spring中公共异常处理

异常简介

在项目中，异常是我们必须要考虑的。在java中异常分为3种：

check exception
runtime exception
error

在决定使用check exception 或者 runtimeExceptin 主要的原则是：

如果期望调用者能够适当地恢复，则使用check exception, 抛出异常，强迫调用者catch中处理该异常，或者传播出去。
用runtime exception 来表明编程错误。
总的来说，对于可恢复的异常使用check exception ，对于程序错误，则使用runtime exception。

项目中真实情况

然而在真实项目中，异常很被误用。有如下问题：

不知道改什么时候用check exception 和 runtime exception
不知道何时catch异常，代码充斥着try catch结构。异常处理混乱
catch住异常不知道如何处理，经常抓住打印一下堆栈信息就不管了。

最佳实践

不要忽略异常，如果要忽略请写明注释说明为什么忽略该异常。
只针对异常的情况，才使用异常
避免不必要的使用check exception，对编程的错误使用runtime exception
抛出与抽象相对应的异常
再细节消息中包含能捕获失败的信息。
努力使失败保持原子性

解决方案

为了解决以上问题，

自定义异常类型
定义统一返回值
统一处理

自定义异常

public abstract class AbstractSaasException extends RuntimeException {

    private final int errorCode;

    private final String errorMsg;

    public AbstractSaasException(int errorCode, String errorMsg) {
        super(errorMsg);
        this.errorCode = errorCode;
        this.errorMsg = errorMsg;
    }

    public int getErrorCode() {
        return errorCode;
    }

    public String getErrorMsg() {
        return errorMsg;
    }
}

具体实现

/**
 * 业务异常
 * Created by chenyao on 2018/5/21.
 */
public class BizException extends AbstractSaasException {

    public BizException(int errorCode, String errorMsg) {
        super(errorCode, errorMsg);
    }
}

errorCode, errorMsg，可以定义一个枚举，对常用异常信息做个定义，如下所示：

public enum ResultEnums {
    SUCCESS(true, 1, "success"),
    SYSTEM_EXCEPTION(false, -999, "系统异常, 请稍后重试"),
    ILLEGAL_ARGUMENT(false, -998, "非法参数"),
    ;
    private final boolean success;
    private final int code;
    private final String message;

    ResultEnums(boolean success, int code, String message) {
        this.success = success;
        this.code = code;
        this.message = message;
    }

    public boolean isSuccess() {
        return success;
    }

    public int getCode() {
        return code;
    }

    public String getMessage() {
        return message;
    }
}

定义好了异常，那个我们在开发中，如果遇到业务异常情况，可以直接跑出异常，由上层统一处理（后面会详细说明）。例如：

// 需要把异常情况，展示到前端，只需，抛对应的异常，由公共异常处理Advice处理，封装成Result
if(demoReqVO == null || StringUtils.isBlank(demoReqVO.getFlag())) {
    throw new BizException(ResultEnums.ILLEGAL_ARGUMENT.getCode(), ResultEnums.ILLEGAL_ARGUMENT.getMessage());
}

定义返回值

一般架构中，返回前端视图一般为json ，或者jsp等视图
那对json格式数据，我们可以统一定义个返回值，方便后面公共异常处理程序封装返回值。例如：

/**
 * 对外统一返回值
 * Created by chenyao on 2018/5/16.
 */
public class Result {
    private final boolean success;
    private final int code;
    private final String message;

    private final T data;

    private Result(boolean success, int code, String message, T data) {
        this.success = success;
        this.code = code;
        this.message = message;
        this.data = data;
    }

    public static  Result success() {
        return new Result<>(true, 0, "success", null);
    }

    public static  Result success(T data) {
        return new Result<>(true, 0, "success", data);
    }

    public static  Result fail(int code, String message) {
        return new Result<>(false, code, message, null);
    }

    public int getCode() {
        return code;
    }

    public String getMessage() {
        return message;
    }

    public boolean isSuccess() {
        return success;
    }

    public T getData() {
        return data;
    }

    @Override
    public String toString() {
        return ToStringBuilder.reflectionToString(this, ToStringStyle.SHORT_PREFIX_STYLE);
    }
}

那在我们返回前端那层就可以统一返回Result， exp:

/**
 * 返回值为json形式
 * 1. 请求参数，以bean方式封装
 * 2. 返回值，同一返回Result
 * 3. 不关心的异常，无需自己try catch处理异常，统一抛，由Advice处理
 * 4. 禁止自己操作Response，返回jsp or json data; json统一使用@ResponseBody，jsp统一返回ModelAndView
 * 5. 文件下载推荐使用ResponseEntity。
 * @param demoReqVO 请求参数，如果字段很多，使用vo接收；若不多，直接使用参数列表接收。不推荐使用request.getParameter方式
 * @return json统一返回Result，方便公共异常处理，封装
 */
@RequestMapping(value = "/resultJson")
@ResponseBody
public Result resultJson(@Valid DemoReqVO demoReqVO) {
    //controller 只做参数校验，调用service, 数据转换。不做主要业务逻辑。
    //1.一般情况，不关心的异常，可以try catch, 由公共的异常处理Advice处理
    //2. 需要把异常情况，展示到前端，只需，抛对应的异常，由公共异常处理Advice处理，封装成Result
    if(demoReqVO == null || StringUtils.isBlank(demoReqVO.getFlag())) {
        throw new BizException(ResultEnums.ILLEGAL_ARGUMENT.getCode(), ResultEnums.ILLEGAL_ARGUMENT.getMessage());
    }
    //其他业务操作
    demoService.update();


    //json统一返回Result，方便公共异常处理，封装
    return Result.success(new DemoResVO());
}

异常统一处理

在spring mvc架构中，我们可以使用ControllerAdvice，不使用spring mvc框架的项目中（微服务中的dubbo接口，网关api）可以使用spring aop实现。

ControllerAdvice

/**
 * 统一异常处理
 */
@ControllerAdvice
public class CommonControllerAdvice {
    private static final Logger logger = LoggerFactory.getLogger(CommonControllerAdvice.class);
    private static final Map DEFAULT_VALUE_OF_PRIMITIVE = new HashMap() {{
        put(int.class, 0);
        put(double.class, 0.0D);
        put(long.class, 0L);
        put(char.class, '\u0000');
        put(float.class, 0.0F);
        put(short.class, 0);
        put(byte.class, 0);
        put(boolean.class, false);
        put(void.class, null);
    }};


    @ExceptionHandler(value = Exception.class)
    public ModelAndView handler(HttpServletRequest request,
                                HttpServletResponse response, HandlerMethod handler, Exception ex) {
        Method method = handler.getMethod();
        //1.打印error日志，包括入参，异常信息
        logger.error("[commonControllerAdvice,method:{}, params:{}] 异常", method.getName(), request.getQueryString(), ex);
        //2. 处理返回值
        //2.1 json (Result, Collection, 基本类型)
        //2.2 jsp view
        ErrorMessage message = build(ex);
        Class returnType = method.getReturnType();
        if (isRest(handler)) {
            MappingJackson2JsonView jsonView = new MappingJackson2JsonView();
            //The effect of setting this flag is similar to using MappingJackson2HttpMessageConverter with an @ResponseBody request-handling method.
            //使 @ResponseBody效果一样
            jsonView.setExtractValueFromSingleKeyModel(true);
            ModelAndView view = new ModelAndView(jsonView);
            Object returnObj = null;
            if (returnType == Result.class) {
                returnObj = Result.fail(message.getCode(), message.getMessage());
            } else {
                returnObj = create(returnType);
            }
            view.addObject("_result", returnObj);
            return view;
        }
        //jsp
        ModelAndView jspView = new ModelAndView("error");
        jspView.addObject("exception", ex.getMessage());
        return jspView;
    }

    private boolean isRest(HandlerMethod handler) {
        Method method = handler.getMethod();
        ResponseBody annotation = method.getAnnotation(ResponseBody.class);
        if(annotation != null) {
            return  true;
        }
        Class clazz = handler.getBeanType();
        RestController restController = clazz.getAnnotation(RestController.class);
        if(restController != null) {
            return true;
        }
        return false;
    }


    /**
     * 创建返回值
     *
     * @param clazz
     * @return
     */
    private Object create(Class clazz) {
        Object instance;
        try {
            if (clazz == null) {
                return null;
            }
            if (clazz.isInterface()) {
                return interfaceInstance(clazz);
            }
            if (clazz.isPrimitive()) {
                //对基本类型处理
                return primitiveInstance(clazz);
            }
            if (clazz.isArray()) {
                return new Object[0];
            }
            instance = clazz.newInstance();
        } catch (InstantiationException | IllegalAccessException e) {
            //ignore exception, 对未知类型，或者无默认构造函数，统一返回null
            return null;
        }
        return instance;
    }

    private Object interfaceInstance(Class clazz) {
        if (clazz == List.class || clazz == Collection.class) {
            return Collections.emptyList();
        }
        if (clazz == Map.class) {
            return Collections.emptyMap();
        }
        return null;
    }

    private Object primitiveInstance(Class clazz) {
        return DEFAULT_VALUE_OF_PRIMITIVE.get(clazz);
    }


    private ErrorMessage build(Exception ex) {
        if (ex instanceof AbstractSaasException) {
            AbstractSaasException e = (AbstractSaasException) ex;
            return new ErrorMessage(e.getErrorCode(), e.getMessage());
        }
        if(ex instanceof BindException) {
            BindException bindException = (BindException) ex;
            String message = bindException.getBindingResult().getAllErrors()
                    .stream()
                    .findFirst()
                    .map(DefaultMessageSourceResolvable::getDefaultMessage)
                    .orElse(ResultEnums.SYSTEM_EXCEPTION.getMessage());
            return new ErrorMessage(ResultEnums.ILLEGAL_ARGUMENT.getCode(), message);
        }
        return new ErrorMessage(ResultEnums.SYSTEM_EXCEPTION.getCode(), ResultEnums.SYSTEM_EXCEPTION.getMessage());
    }


    private static class ErrorMessage {
        private final int code;
        private final String message;

        ErrorMessage(int code, String message) {
            this.code = code;
            this.message = message;
        }

        public int getCode() {
            return code;
        }

        public String getMessage() {
            return message;
        }
    }
}

@Aspect
@Component
public class ExceptionHandleAspect {

    @Around(value = "execution(public * com.pajk.pentos.service.*.*Impl.*(..)) && !@within(com.pajk.pentos.service.aop.IgnoreExceptionHandle) && !@annotation(com.pajk.pentos.service.aop.IgnoreExceptionHandle)")
    @Order(100) //数字越小优先级越高
    public Object handleException(ProceedingJoinPoint joinPoint) {
        try {
            return joinPoint.proceed();
        } catch (Throwable e) {
            ExceptionResultHandler instance = ExceptionResultHandler.createInstance(joinPoint, e);
            return instance.handleAndReturned();
        }
    }
}

具体ExceptionResultHandler实现和上面例子差不多。不在赘述

参考资料

efftive java 第二版
spring 官方文档