[JAVA基础篇23]—JAVA异常工具类ExceptionUt

项目中一般是这样处理异常的：

import com.tellme.utils.ExceptionUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.exception.ExceptionUtils;

@Slf4j
public class TestExceptionUtils {
    //处理异常的方式
    private static void say() {
        try {
            int i = 1 / 0;
        } catch (Exception e) {
            //将e传入，即保持了异常链的信息。否则的话，异常链便断了。
            throw new RuntimeException("xx", e);
        }
    }
}

org.apache.commons.lang3.exception.ExceptionUtils工具类的用法：

import com.tellme.utils.ExceptionUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.exception.ExceptionUtils;

@Slf4j
public class TestExceptionUtils {

    public static void main(String[] args) {
        try {
            say();
        } catch (Exception e) {
            log.error("", e);
            System.out.println("----------");
            //RuntimeException:xx  （打印的是直接异常）
            System.out.println("ExceptionUtils.getMessage(e)：" + ExceptionUtils.getMessage(e));
            //ArithmeticException: / by zero   （打印的是根异常，但是若是抛出异常时，没将跟异常向外抛出，那么捕获到的依旧是RuntimeException:xx）
            System.out.println("ExceptionUtils.getRootCauseMessage(e)：" + ExceptionUtils.getRootCauseMessage(e));
            //打印的是异常堆栈信息
            System.out.println("ExceptionUtils.getStackTrace(e)：" + ExceptionUtils.getStackTrace(e));
            //java.lang.ArithmeticException: / by zero   (打印的是根异常，但是若是抛出异常时，没将跟异常向外抛出，那么返回null)
            System.out.println("ExceptionUtils.getRootCause(e)：" + ExceptionUtils.getRootCause(e));
            //异常链中异常的数量：2
            System.out.println("ExceptionUtils.getThrowableCount(e)：" + ExceptionUtils.getThrowableCount(e));
            //java.lang.ArithmeticException: / by zero  数组，第一位的的是根异常信息
            System.out.println("ExceptionUtils.getRootCauseStackTrace(e)[0]：" + ExceptionUtils.getRootCauseStackTrace(e)[0]);
            //java.lang.RuntimeException: xx  数组，第一位的是直接异常信息
            System.out.println("ExceptionUtils.getStackFrames(e)[0]：" + ExceptionUtils.getStackFrames(e)[0]);
            //异常链的数组：[java.lang.RuntimeException: xx, java.lang.ArithmeticException: / by zero]
            System.out.println("ExceptionUtils.getThrowableList(e)：" + ExceptionUtils.getThrowableList(e));
            //自定义的异常链信息（打印直接异常的详细信息）：ExceptionUtil.getLogErrorMessage(e)：xx||RuntimeException||com.tellme.test.TestExceptionUtils.say(TestExceptionUtils.java:38)
            System.out.println("ExceptionUtil.getLogErrorMessage(e)：" + ExceptionUtil.getLogErrorMessage(e));
        }
    }

    private static void say() {
        try {
            int i = 1 / 0;
        } catch (Exception e) {
            //将e传入，即保持了异常链的信息。否则的话，异常链便断了。
            throw new RuntimeException("xx", e);
        }
    }
}

自定义的异常类：

    /**
     * 获取到异常描述
     *
     * @param e 异常信息
     * @return "异常信息||异常类名||异常位置"
     */
    public static String getLogErrorMessage(Exception e) {
        return e.getMessage() + "||" + e.getClass().getSimpleName() + "||" + e.getStackTrace()[0];
    }

可以将异常信息入库，这样便可以快速定位到问题原因。

项目中的异常工具类

public abstract class ExceptionUtil {

    //主键/唯一键冲突的异常信息
    public static final String UNIQUE_ERROR = "Duplicate entry";
    
   //判断返回的Message是否含有 UNIQUE_ERROR主键冲突。
    public static String getErrorCode(Exception e) {
        String errorCode = "";
        if (e.getCause() != null && e.getCause().getMessage() != null) {
            errorCode = e.getCause().getMessage();
        }
        if (Strings.isNullOrEmpty(errorCode) && e.getMessage() != null) {
            errorCode = e.getMessage();
        }
        return errorCode;
    }


    /**
     * 获取到异常描述
     *
     * @param e 异常信息
     * @return "异常信息||异常类名||异常位置"
     */
    public static String getLogErrorMessage(Exception e) {
        StackTraceElement[] stackTrace = e.getStackTrace();
        StackTraceElement stackTraceElement = null;
        if (stackTrace != null && stackTrace.length >= 1) {
            stackTraceElement = stackTrace[0];
        }
        return e.getMessage() + "||" + e.getClass().getSimpleName() + "||" + stackTraceElement;
    }

    /**
     * 判断抛出的异常是否包含某类异常
     *
     * @param throwable 抛出的异常
     * @param clazz     是否包含的异常类
     * @return true表示throwable中包含clazz的异常，false表示throwable中不包含clazz异常。
     */
    public static boolean containThrowable(Throwable throwable, Class<? extends Throwable> clazz) {
        boolean result = false;
        Throwable t = throwable;
        while (t != null) {
            if (clazz.isAssignableFrom(t.getClass())) {
                result = true;
                break;
            }
            t = t.getCause();
        }
        return result;
    }


}

注：isAssignableFrom()方法的用法

父类.class.isAssignableFrom(子类.class)
子类实例 instanceof 父类类型

通用的异常类

自定义异常可以这样设置，将异常对象传递下来

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class BusinessException extends RuntimeException {

    private static final Logger logger = LoggerFactory.getLogger(BusinessException.class);


    private static final long serialVersionUID = 1L;

    private String code = "";

    private String msg = "";

    //使用super(msg, cause)将异常对象组装成链存储起来
    public BusinessException(String code, String msg, Throwable cause) {
        super(msg, cause);
        this.setCode(code);
        this.setMsg(msg);
    }

    /**
     *
     */
    public BusinessException() {
        super();
    }
    public BusinessException(String message) {
        super(message);
    }

    /**
     *
     * @param message
     *          消息
     * @param cause
     *          原因
     */
    public BusinessException(String message, Throwable cause) {
        super(message, cause);
        this.setMsg(msg);
    }

    /**
     *
     * @param code
     * @param msg
     */
    public BusinessException(String code, String msg) {
        super(msg);
        this.setCode(code);
        this.setMsg(msg);
    }


    /**
     *
     * @param cause
     *          原因
     */
    public BusinessException(Throwable cause) {
        super(cause);
    }

    public String getCode() {
        return code;
    }

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

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

}