java异常处理的基本实现方式

1、首先定义一个异常对应的异常对象，存放异常信息

package com.xuecheng.framework.model.response;
public interface ResultCode {
    //操作是否成功,true为成功，false操作失败
    boolean success();
    //操作代码
    int code();
    //提示信息
    String message();
}

2、定义一个枚举，实现ResultCode接口，定义异常对应的异常信息

package com.xuecheng.framework.model.response;
import lombok.ToString;
@ToString
public enum CommonCode implements ResultCode{
    INVALID_PARAM(false,99998,"请求体缺失"),
    IndexOutOfBounds(false,99997,"索引越界异常"),
    NullPointerException(false,99996,"空指针异常"),
    SUCCESS(true,10000,"操作成功！"),
    FAIL(false,11111,"操作失败！"),
    UNAUTHENTICATED(false,10001,"此操作需要登陆系统！"),
    UNAUTHORISE(false,10002,"权限不足，无权操作！"),
    SERVER_ERROR(false,99999,"抱歉，系统繁忙，请稍后重试！");
    //操作是否成功
    boolean success;
    //操作代码
    int code;
    //提示信息
    String message;
    private CommonCode(boolean success,int code, String message){
        this.success = success;
        this.code = code;
        this.message = message;
    }
    @Override
    public boolean success() {
        return success;
    }
    @Override
    public int code() {
        return code;
    }
    @Override
    public String message() {
        return message;
    }
}

3、自定义一个异常类，继承RuntimeException，出现已知异常时抛出此异常

package com.xuecheng.framework.exception;
import com.xuecheng.framework.model.response.ResultCode;
/**
 * 自定义异常类
 */
public class CustomException extends RuntimeException {
    // 定义一个属性，当捕捉到错误的时候返回获取一场对应的属性
    private ResultCode resultCode;
    /**
     * 公共异常类的构造法方法，用来处理可预知的异常类
     * @param resultCode
     */
    public CustomException(ResultCode resultCode){
        this.resultCode = resultCode;
    }
    /**
     * 获取错误代码
     * @return
     */
    public ResultCode getResultCode(){
        return resultCode;
    }
}

4、定义一个用来抛出异常的工具类，直接使用此类抛出异常

package com.xuecheng.framework.exception;
import com.xuecheng.framework.model.response.ResultCode;
public class ExceptionCast {
    /**
     * 用来直接抛出CustomException
     * @param resultCode
     */
    public static void cast(ResultCode resultCode){
        throw new CustomException(resultCode);
    }
}

5、定义一个捕获到异常时返回的对象，此对象保存错误信息

package com.xuecheng.framework.model.response;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;
@Data
@ToString
@NoArgsConstructor
public class ResponseResult implements Response {
    //操作是否成功
    boolean success = SUCCESS;
    //操作代码
    int code = SUCCESS_CODE;
    //提示信息
    String message;
    public ResponseResult(ResultCode resultCode){
        this.success = resultCode.success();
        this.code = resultCode.code();
        this.message = resultCode.message();
    }
    public static ResponseResult SUCCESS(){
        return new ResponseResult(CommonCode.SUCCESS);
    }
    public static ResponseResult FAIL(){
        return new ResponseResult(CommonCode.FAIL);
    }
}

6、定义一个捕获异常的类，当捕获到自定义异常（CustomException）和未知异常时（Exception），以json格式返回错误信息

package com.xuecheng.framework.exception;

import com.google.common.collect.ImmutableMap;
import com.xuecheng.framework.model.response.CommonCode;
import com.xuecheng.framework.model.response.ResponseResult;
import com.xuecheng.framework.model.response.ResultCode;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;

/**
 * 增强的控制器，SpringMVC提供的功能
 * 全局异常处理
 * 全局数据绑定
 * 全局数据预处理
 */
@ControllerAdvice
/**
 * 异常捕获类
 */
public class ExceptionCatch {

    // 记录错误日志
    private static final Logger LOGGER = LoggerFactory.getLogger(ExceptionCatch.class);

    // 定义一个map，配置异常类型所对应的错误代码
    private static ImmutableMap<Class<? extends Throwable>,ResultCode> EXECEPTIONS;

    // 定义的builder对象，用来构建ImmutableMap集合
    protected static ImmutableMap.Builder<Class<? extends Throwable>,ResultCode> builder = ImmutableMap.builder();

    // 定义异常对应的错误,用来异常对应的错误代码放入集合
    static {
        builder.put(HttpMessageNotReadableException.class,CommonCode.INVALID_PARAM);
        builder.put(IndexOutOfBoundsException.class,CommonCode.IndexOutOfBounds);
        builder.put(NullPointerException.class,CommonCode.NullPointerException);
    }
    /**
     * 捕获CustomException异常
     * @param customException
     * @return
     */
    @ExceptionHandler(CustomException.class)
    @ResponseBody
    public ResponseResult customException(CustomException customException){
        LOGGER.error("catch CustomException{}:" + customException.getResultCode().message());// 打印错误信息
        return new ResponseResult(customException.getResultCode());
    }


    @ExceptionHandler(Exception.class) // 用来捕获Exception异常
    @ResponseBody
    public ResponseResult exception(Exception exception){
        if(EXECEPTIONS == null){
            EXECEPTIONS = builder.build();// 构建异常集合
        }
        // 通过异常类获取对应结果代码
        ResultCode resultCode = EXECEPTIONS.get(exception.getClass());
        if (resultCode == null) {
            return new ResponseResult(CommonCode.SERVER_ERROR);
        } else {
            LOGGER.error("catch exception(未知异常错误){}:" + EXECEPTIONS.get(exception.getClass()).message());// 打印错误信息
            return new ResponseResult(resultCode);
        }
    }
}