用Assert(断言)封装异常，让代码更优雅(附项目源码)

有关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

巴特西

用Assert(断言)封装异常，让代码更优雅(附项目源码)

一、善解人意的Enum

二、验证统一异常处理

三、测试验证

四、总结

感谢

最新文章

热门文章