有关Assert断言大家并不陌生，我们在做单元测试的时候,看业务事务复合预期，我们可以通过断言来校验，断言常用的方法如下:
public class Assert {
/**
* 结果 = 预期 则正确
*/
static public void assertEquals(Object expected, Object actual);
/**
* 结果 != 预期 则正确
*/
static public void assertNotEquals(Object unexpected, Object actual);
/**
* condition == true 则正确
*/
static public void assertTrue(boolean condition);
/**
* condition == false 则正确
*/
static public void assertFalse(boolean condition);
/**
* 永远是错误
*/
static public void fail();
/**
* 结果不为空 则正确
*/
static public void assertNotNull(Object object);
/**
* 结果为空 则正确
*/
static public void assertNull(Object object);
/**
* 两个对象引用 相等 则正确（上面相当于equels 这里类似于使用“==”比较两个对象）
*/
static public void assertSame(Object expected, Object actual);
/**
* 两个对象引用 不相等 则正确
*/
static public void assertNotSame(Object unexpected, Object actual);
/**
* 两个数组相等 则正确
*/
public static void assertArrayEquals(Object[] expecteds, Object[] actuals);
/**
* 这个单独介绍 具体参考博客:https://www.cnblogs.com/qdhxhz/p/13684458.html
*/
public static <T> void assertThat(T actual, Matcher<? super T> matcher);
};
使用断言能让我们编码看去更加的清爽，比如：
@Test
public void test1() {
Order order = orderDao.selectById(orderId);
Assert.notNull(order, "订单不存在。");
}
@Test
public void test2() {
// 另一种写法
Order order = orderDao.selectById(orderId);
if (order == null) {
throw new IllegalArgumentException("订单不存在。");
}
}
这两种方式一对比，是不是明显感觉第一种更优雅,第二种写法则是相对丑陋的 if {...} 代码块。那么 神奇的 Assert.notNull() 背后到底做了什么呢？
下面是 Assert 的部分源码：
public abstract class Assert {
public Assert() {
}
public static void notNull(@Nullable Object object, String message) {
if (object == null) {
throw new IllegalArgumentException(message);
}
}
}
可以看到，Assert 其实就是帮我们把 if {...} 封装了一下，是不是很神奇。虽然很简单，但不可否认的是编码体验至少提升了一个档次。
那么我们是不是可以模仿Assert，也写一个自定义断言类，不过断言失败后抛出的异常不是IllegalArgumentException 这些内置异常，而是我们自己定义的异常。
下面让我们来尝试一下。
public interface Assert {
/**
* 创建异常
* @param args
* @return
*/
BaseException newException(Object... args);
/**
* 创建异常
* @param t
* @param args
* @return
*/
BaseException newException(Throwable t, Object... args);
/**
* 断言对象 obj 非空。如果对象 obj 为空，则抛出异常
*
* @param obj 待判断对象
*/
default void assertNotNull(Object obj) {
if (obj == null) {
throw newException(obj);
}
}
/**
* 断言对象 obj 非空。如果对象 obj 为空，则抛出异常
* 异常信息 message 支持传递参数方式，避免在判断之前进行字符串拼接操作
*
* @param obj 待判断对象
* @param args message占位符对应的参数列表
*/
default void assertNotNull(Object obj, Object... args) {
if (obj == null) {
throw newException(args);
}
}
}
注：
- 这里只给出Assert接口的部分源码，更多断言方法请参考项目的源码。
- BaseException 是所有自定义异常的基类。
- 在接口中定义默认方法是Java8的新语法。
上面的Assert断言方法是使用接口的默认方法定义的，然后有没有发现当断言失败后，抛出的异常不是具体的某个异常，而是交由2个newException接口方法提供。
因为业务逻辑中出现的异常基本都是对应特定的场景，比如根据用户id获取用户信息，查询结果为null，此时抛出的异常可能为UserNotFoundException，并且有特
定的异常码（比如7001）和异常信息“用户不存在”。所以具体抛出什么异常，有Assert的实现类决定。
看到这里，你可能会有会有疑问，按照上面的做法，那不是有多少个异常情况，我都要去实现Assert接口，然后在写定义等量的断言类和异常类，这显然是反人类的，
这也没想象中高明嘛。别急，且听我细细道来。
一、善解人意的Enum
自定义异常BaseException有2个属性，即code、message，这样一对属性，有没有想到什么类一般也会定义这2个属性？
没错，就是枚举类。且看我如何将 Enum 和 Assert 结合起来，相信我一定会让你眼前一亮。如下：
public interface IResponseEnum {
int getCode();
String getMessage();
}
我们自定一个业务异常类
/**
* 业务异常
* 业务处理时，出现异常，可以抛出该异常
*
*/
public class BusinessException extends BaseException {
private static final long serialVersionUID = 1L;
public BusinessException(IResponseEnum responseEnum, Object[] args, String message) {
super(responseEnum, args, message);
}
public BusinessException(IResponseEnum responseEnum, Object[] args, String message, Throwable cause) {
super(responseEnum, args, message, cause);
}
}
业务异常断言实现类，它同时继承2个接口，一个是Assert接口，一个是IResponseEnum接口
public interface BusinessExceptionAssert extends IResponseEnum, Assert {
@Override
default BaseException newException(Object... args) {
String msg = MessageFormat.format(this.getMessage(), args);
return new BusinessException(this, args, msg);
}
@Override
default BaseException newException(Throwable t, Object... args) {
String msg = MessageFormat.format(this.getMessage(), args);
return new BusinessException(this, args, msg, t);
}
}
业务异常枚举
/**
* 业务异常枚举
*/
@Getter
@AllArgsConstructor
public enum BusinessResponseEnum implements BusinessExceptionAssert {
USER_NOT_FOUND(6001, "未查询到用户信息"),
ORDER_NOT_FOUND(7001, "未查询到订单信息"),
;
/**
* 返回码
*/
private int code;
/**
* 返回消息
*/
private String message;
}
这样如果是业务异常，就都可以在BusinessResponseEnum中定义一个新枚举对象就可以了。以后每增加一种异常情况，只需增加一个枚举实例即可，再也不用每一种异常
都定义一个异常类了。接下来看使用如下：
/**
* 查询用户信息
*/
public User queryDetail(Integer userId) {
final User user = this.getById(userId);
// 校验非空
BusinessResponseEnum.USER_NOT_FOUND.assertNotNull(user);
return user;
}
若不使用断言，代码可能如下：
/**
* 查询用户信息
*/
public User queryDetail(Integer userId) {
final User user = this.getById(userId);
if (user == null) {
throw new UserNotFoundException();
// 或者这样
throw new BusinessException(6001, "未查询到用户信息");
}
return user;
}
使用枚举类结合(继承)Assert，只需根据特定的异常情况定义不同的枚举实例，如上面的USER_NOT_FOUND、ORDER_NOT_FOUND，就能够针对不同情况抛出特定的异常
（这里指携带特定的异常码和异常消息），这样既不用定义大量的异常类，同时还具备了断言的良好可读性。
二、验证统一异常处理
在throw抛出异常后，我们就可以统一去处理异常，如果有必要我们可以加入异常日志存入数据库中，有助于后续排查问题。
/**
* 全局异常处理器
*
* @author xub
* @date 2022/2/28 上午10:52
*/
@Slf4j
@Component
@ControllerAdvice
@ConditionalOnWebApplication
public class ViewExceptionResolver {
/**
* 生产环境
*/
private final static String ENV_PROD = "prod";
@Autowired
private UnifiedMessageSource unifiedMessageSource;
/**
* 当前环境
*/
@Value("${spring.profiles.active}")
private String profile;
/**
* 获取国际化消息
*
* @param e 异常
* @return
*/
public String getMessage(BaseException e) {
String code = "response." + e.getResponseEnum().toString();
String message = unifiedMessageSource.getMessage(code, e.getArgs());
if (message == null || message.isEmpty()) {
return e.getMessage();
}
return message;
}
/**
* 业务异常
*
* @param e 异常
* @return 异常结果
*/
@ExceptionHandler(value = BusinessException.class)
@ResponseBody
public CommandResult handleBusinessException(BaseException e) {
log.error(e.getMessage(), e);
return CommandResult.ofFail(e.getResponseEnum().getCode(), getMessage(e));
}
/**
* 自定义异常
*
* @param e 异常
* @return 异常结果
*/
@ExceptionHandler(value = BaseException.class)
@ResponseBody
public CommandResult handleBaseException(BaseException e) {
log.error(e.getMessage(), e);
return CommandResult.ofFail(e.getResponseEnum().getCode(), getMessage(e));
}
/**
* 未定义异常
*
* @param e 异常
* @return 异常结果
*/
@ExceptionHandler(value = Exception.class)
@ResponseBody
public CommandResult handleException(Exception e) {
log.error(e.getMessage(), e);
if (ENV_PROD.equals(profile)) {
// 当为生产环境, 不适合把具体的异常信息展示给用户, 比如数据库异常信息.
int code = CommonResponseEnum.SERVER_ERROR.getCode();
BaseException baseException = new BaseException(CommonResponseEnum.SERVER_ERROR);
String message = getMessage(baseException);
return CommandResult.ofFail(code, message);
}
return CommandResult.ofFail(CommonResponseEnum.SERVER_ERROR.getCode(), e.getMessage());
}
}
三、测试验证
这里请求地址，业务id=10数据库是不存在这个用户，所以会报错。
localhost:8085/user/getUserInfo?userId=10
达到了预期效果。
四、总结
使用 断言 和 枚举类 相结合的方式，再配合统一异常处理，基本大部分的异常都能够被捕获。为什么说大部分异常，因为当引入 spring cloud security 后，还会
有认证/授权异常，网关的服务降级异常、跨模块调用异常、远程调用第三方服务异常等，这些异常的捕获方式与本文介绍的不太一样，不过限于篇幅，这里不做详细说明，
以后会有单独的文章介绍。
项目地址：用Assert(断言)封装异常，让代码更优雅(附项目源码)
感谢
这篇文章给自己提供了很好的思路，基本上按照这个思路往下写的
统一异常处理介绍及实战:https://www.jianshu.com/p/3f3d9e8d1efa