# apiAssert

**Repository Path**: chaibao/api-assert

## Basic Information

- **Project Name**: apiAssert
- **Description**: 校验、断言小框架
- **Primary Language**: Java
- **License**: Apache-2.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 2
- **Created**: 2022-10-18
- **Last Updated**: 2022-10-18

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# Api-Assert 介绍

- [github地址](https://github.com/min1854/apiAssert)
- [gitee地址](https://gitee.com/min1854/api-assert)


api-assert 是一个经量级的小小框架，或者说是一个工具类，用于提供在日常开发中，经常需要一些条件判断，如果条件成立需要抛出异常编写的重复，api-assert 提供了链式校验的方式，目前提供了几种检查器：

- com.old.apiAssert.check.FirstApiAssert 第一检查器，检查器可以提供链式编程，并且当第一个条件成立之后就不会再替换异常信息，并由调用者最终决定是否抛出异常
- com.old.apiAssert.check.FunctionApiAssert 由调用者提供异常对象，当条件成立时会立刻抛出异常
- com.old.apiAssert.check.OperateApiAssert 与 Optional 类的思想类似，用于提供对一个对象的校验与对象内部属性的校验，支持 Lambda，并支持 FunctionApiAssert 检查器的功能。
- com.old.apiAssert.check.ReflectionApiAssert 调用者传入异常类型，检查器当条件成立之后会立刻抛出异常



# 用例
添加 maven 依赖
```xml
<dependency>
  <groupId>io.github.min1854</groupId>
  <artifactId>apiAssert</artifactId>
  <version>2.0.0</version>
</dependency>
```


# 注意
2.0.0 版本与之前的版本不太兼容，使用需要注意。2.0 版本将框架进行了重写，使用了继承方式，抛弃了原有的复合方式。并重新抽取了父类与规范。


# 版本

## 2.0.0
因 2.0 版本将框架进行了重构，所以版本号使用新的大版本号。2.0.0 相比之前的版本，扩展性更高，重复代码更少。并且提供了 Enum 作为消息内容的校验器。

- 重构代码
- 新增枚举校验器 EnumOperationApiAssert、EnumFunctionApiAssert
- OperationApiAssert 增加 校验对象、标准校验器的 then 方法

# 使用
```java
public class Demo {

    public OperateApiAssert<TestEntity> createAssert() {
        TestEntity entity = new TestEntity();
        entity.setId(1);
        entity.setDeleteFlag(false);
        return OperateApiAssert.create(entity, NoArgConstructorException::new);
    }


    @Test(expected = ApiAssertException.class)
    public void testThen() {
        OperateApiAssert<Object> apiAssert = createAssert()
                .then((testEntity, standardApiAssert) -> {
                    standardApiAssert.isNull(new Object(), "为空");
                    return new Object();
                });

        OperateApiAssert<TestEntity> then = apiAssert.then(TestEntity::new);
        then.isNull(TestEntity::getId, "新创建的实体 id 为空");
    }


    @Test(expected = ApiAssertException.class)
    public void testCheckObjGenErrorMsg() {
        OperateApiAssert<TestEntity> apiAssert = createAssert();
        OperateApiAssert<Object> then = apiAssert
                .nonNull(TestEntity::getName, "名称不为空")
                .nonNull(TestEntity::getName, TestEntity::getName)
                .isNull(TestEntity::getId, TestEntity::toString)
                .isTrue(TestEntity::getDeleteFlag, TestEntity::getName)
                .isFalse(testEntity -> {
                    return !testEntity.getDeleteFlag();
                }, TestEntity::getName)
                .isEmpty(TestEntity::getId, TestEntity::getName)
                .then(() -> {
                    System.out.println("新增错误对象生成信息方法");
                    return new Object();
                });
        then.isNull(Object::toString, Object::toString);
        then.throwRuntime(new NoArgConstructorException("最终抛出"));

    }


    @Test(expected = ApiAssertException.class)
    public void testOperateApiAssert() {
        OperateApiAssert<TestEntity> apiAssert = createAssert();

        apiAssert
                .isEmpty(TestEntity::getId, "id 为空")
                .isTrue(TestEntity::getDeleteFlag, "当前对象已删除")
                .isNull(new Object(), "对象为空")
                .isEmpty(apiAssert.getObj(), "这是空对象")
                .isTrue(false, "条件成立")
                .isFalse(true, "条件不成立")
        ;


        System.out.println(apiAssert.getClass());
        apiAssert.isTrue(true, "条件成立");

    }

    @Test
    public void process() {
        OperateApiAssert<TestEntity> apiAssert = createAssert();

        apiAssert.process(() -> {
                    System.out.println("校验前，业务逻辑");
                    System.out.println("实体类 id 值：" + apiAssert.getObj().getId());
                })
                .process(testEntity -> {
                    System.out.println("实体信息：" + testEntity);
                })
                .process((testEntity, standardApiAssert) -> {
                    standardApiAssert.isNull(new Object(), "为空");
                    standardApiAssert.isEmpty(new TestEntity(), "新测试对象为空");
                })
        ;
        Object transitionResult = apiAssert.process(() -> {
            Object o = new Object();
            System.out.println("返回对象: " + o);
            return o;
        });
        apiAssert.isNull(transitionResult, "校验过程中出现为空的对象");
    }

    @Test
    public void then() {
        Object base = new Object();
        OperateApiAssert<Object> then = createAssert().then(base);

        then.isNull("该对象是否为空");

        Object obj = then.getObj();
        then.isFalse(obj.equals(base), "两者不相同");

        OperateApiAssert<TestEntity> anAssert = then.then(new TestEntity());


        anAssert.isNull("对象为空");


        OperateApiAssert<Integer> idAssert = anAssert.then(TestEntity::getId);
        idAssert.isTrue(id -> false, "条件为真");
    }

}
```