项目中一般是这样处理异常的：
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];
}
可以将异常信息入库，这样便可以快速定位到问题原因。
项目中的异常工具类
import org.apache.commons.lang3.exception.ExceptionUtils;
public abstract class ExceptionUtil {
//主键/唯一键冲突的异常信息
public static final String UNIQUE_ERROR = "Duplicate entry";
/**
* 打印完整异常栈信息
*/
private static String getTraceMessage(Exception e) {
String[] traces = ExceptionUtils.getRootCauseStackTrace(e);
StringBuilder traceMessage = new StringBuilder();
for (String trace : traces) {
traceMessage.append(trace).append("\n");
}
return traceMessage.toString();
}
//判断返回的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;
}
}
父类.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;
}
}
