跳转到内容
Trantor 文档

应用举例：

SaveDAO

saveIgnoreRelation

   /**
     * 保存一条记录
     * 若不存在则创建 存在则更新
     * 会忽略关联模型, 仅生效与模型自身
     *
     * @param data 待保存记录
     * @return 被保存的纪录
     */
    default ENTITY saveIgnoreRelation(@NotNull ENTITY data) {
        return __save(data, RelationModifyType.IgnoreRelation, false);
    }


   /**
     * 保存一组记录
     * 若不存在则创建 存在则更新
     * 会忽略关联模型, 仅生效与模型自身
     *
     * @param data 待创建数据集合
     * @return 保存条数
     */
    default long saveIgnoreRelation(@NotNull Collection<ENTITY> data) {
        return __save(data, RelationModifyType.IgnoreRelation, false);
    }


   /**
     * 保存一条记录，并按 select 构造器返回给定字段
     * 若不存在则创建 存在则更新
     * 会忽略关联模型, 仅生效与模型自身
     *
     * @param data   待创建记录
     * @param select select 构造器
     * @return 被创建的记录，只包含 select 构造器中描述的字段
     */
    default ENTITY saveIgnoreRelation(@NotNull ENTITY data, @NotNull Consumer<Select<HELP_MODEL, ENTITY>> select) {
        return __save(data, select, RelationModifyType.IgnoreRelation, false);
    }

saveConnectRelation

    /**
     * 保存一条记录
     * 若不存在则创建 存在则更新
     * 仅会建立关联模型关系, 不会创建或更新关联模型
     *
     * @param data 待保存记录
     * @return 被保存的纪录
     */
    default ENTITY saveConnectRelation(@NotNull ENTITY data) {
        return __save(data, RelationModifyType.ConnectRelation, false);
    }


    /**
     * 保存一组记录
     * 若不存在则创建 存在则更新
     * 仅会同步关联模型, 不会创建或更新
     *
     * @param data 待创建数据集合
     * @return 保存条数
     */
    default long saveConnectRelation(@NotNull Collection<ENTITY> data) {
        return __save(data, RelationModifyType.ConnectRelation, false);
    }


    /**
     * 保存一条记录，并按 select 构造器返回给定字段
     * 若不存在则创建 存在则更新
     * 仅会同步关联模型, 不会创建或更新
     *
     * @param data   待创建记录
     * @param select select 构造器
     * @return 被创建的记录，只包含 select 构造器中描述的字段
     */
    default ENTITY saveConnectRelation(@NotNull ENTITY data, @NotNull Consumer<Select<HELP_MODEL, ENTITY>> select) {
        return __save(data, select, RelationModifyType.ConnectRelation, false);
    }

saveWithRelation

  /**
     * 保存一条记录
     * 若不存在则创建 存在则更新
     * 规则同样适用于子对象
     *
     * @param data 待保存记录
     * @return 被保存的纪录
     */
    default ENTITY saveWithRelation(@NotNull ENTITY data) {
        return __save(data, RelationModifyType.WithRelation, false);
    }


    /**
     * 保存一组记录
     * 若不存在则创建 存在则更新
     * 规则同样适用于子对象
     *
     * @param data 待创建数据集合
     * @return 保存条数
     */
    default long saveWithRelation(@NotNull Collection<ENTITY> data) {
        return __save(data, RelationModifyType.WithRelation, false);
    }


    /**
     * 保存一条记录，并按 select 构造器返回给定字段
     * 若不存在则创建 存在则更新
     * 规则同样适用于子对象
     *
     * @param data   待创建记录
     * @param select select 构造器
     * @return 被创建的记录，只包含 select 构造器中描述的字段
     */
    default ENTITY saveWithRelation(@NotNull ENTITY data, @NotNull Consumer<Select<HELP_MODEL, ENTITY>> select) {
        return __save(data, select, RelationModifyType.WithRelation, false);
    }

saveIgnoreRelationSkipNull

    /**
     * 保存一条记录
     * 若不存在则创建 存在则更新
     * 会忽略关联模型, 仅生效与模型自身
     *
     * @param data 待保存记录
     * @return 被保存的纪录
     */
    default ENTITY saveIgnoreRelationSkipNull(@NotNull ENTITY data) {
        return __save(data, RelationModifyType.IgnoreRelation, true);
    }


   /**
     * 保存一组记录
     * 若不存在则创建 存在则更新
     * 会忽略关联模型, 仅生效与模型自身
     *
     * @param data 待创建数据集合
     * @return 保存条数
     */
    default long saveIgnoreRelationSkipNull(@NotNull Collection<ENTITY> data) {
        return __save(data, RelationModifyType.IgnoreRelation, true);
    }


   /**
     * 保存一条记录，并按 select 构造器返回给定字段
     * 若不存在则创建 存在则更新
     * 会忽略关联模型, 仅生效与模型自身
     *
     * @param data   待创建记录
     * @param select select 构造器
     * @return 被创建的记录，只包含 select 构造器中描述的字段
     */
    default ENTITY saveIgnoreRelationSkipNull(@NotNull ENTITY data, @NotNull Consumer<Select<HELP_MODEL, ENTITY>> select) {
        return __save(data, select, RelationModifyType.IgnoreRelation, true);
    }

saveConnectRelationSkipNull

    /**
     * 保存一条记录
     * 若不存在则创建 存在则更新
     * 仅会同步关联模型, 不会创建或更新
     *
     * @param data 待保存记录
     * @return 被保存的纪录
     */
    default ENTITY saveConnectRelationSkipNull(@NotNull ENTITY data) {
        return __save(data, RelationModifyType.ConnectRelation, true);
    }


    /**
     * 保存一组记录
     * 若不存在则创建 存在则更新
     * 仅会同步关联模型, 不会创建或更新
     *
     * @param data 待创建数据集合
     * @return 保存条数
     */
    default long saveConnectRelationSkipNull(@NotNull Collection<ENTITY> data) {
        return __save(data, RelationModifyType.ConnectRelation, true);
    }


  /**
     * 保存一条记录，并按 select 构造器返回给定字段
     * 若不存在则创建 存在则更新
     * 仅会同步关联模型, 不会创建或更新
     *
     * @param data   待创建记录
     * @param select select 构造器
     * @return 被创建的记录，只包含 select 构造器中描述的字段
     */
    default ENTITY saveConnectRelationSkipNull(@NotNull ENTITY data, @NotNull Consumer<Select<HELP_MODEL, ENTITY>> select) {
        return __save(data, select, RelationModifyType.ConnectRelation, true);
    }

saveWithRelationSkipNull

    /**
     * 保存一条记录
     * 若不存在则创建 存在则更新
     * 规则同样适用于子对象
     *
     * @param data 待保存记录
     * @return 被保存的纪录
     */
    default ENTITY saveWithRelationSkipNull(@NotNull ENTITY data) {
        return __save(data, RelationModifyType.WithRelation, true);
    }


    /**
     * 保存一组记录
     * 若不存在则创建 存在则更新
     * 规则同样适用于子对象
     *
     * @param data 待创建数据集合
     * @return 保存条数
     */
    default long saveWithRelationSkipNull(@NotNull Collection<ENTITY> data) {
        return __save(data, RelationModifyType.WithRelation, true);
    }


   /**
     * 保存一条记录，并按 select 构造器返回给定字段
     * 若不存在则创建 存在则更新
     * 规则同样适用于子对象
     *
     * @param data   待创建记录
     * @param select select 构造器
     * @return 被创建的记录，只包含 select 构造器中描述的字段
     */
    default ENTITY saveWithRelationSkipNull(@NotNull ENTITY data, @NotNull Consumer<Select<HELP_MODEL, ENTITY>> select) {
        return __save(data, select, RelationModifyType.WithRelation, true);
    }

CreateDAO

createIgnoreRelation

 /**
     * 创建一条记录
     * 会忽略关联模型, 仅创建模型自身
     *
     * @param data 待创建记录
     * @return 被创建的纪录
     */
    default ENTITY createIgnoreRelation(@NotNull ENTITY data) {
        return __create(data, RelationModifyType.IgnoreRelation);
    }


   /**
     * 创建一组记录
     * 会忽略关联模型, 仅创建模型自身
     *
     * @param data 待创建数据集合
     * @return 创建条数
     */
    default long createIgnoreRelation(@NotNull Collection<ENTITY> data) {
        return __create(data, RelationModifyType.IgnoreRelation);
    }


    /**
     * 创建一条记录，并按 select 构造器返回给定字段
     * 会忽略关联模型, 仅创建模型自身
     *
     * @param data   待创建记录
     * @param select select 构造器
     * @return 被创建的记录，只包含 select 构造器中描述的字段
     */
    default ENTITY createIgnoreRelation(@NotNull ENTITY data, @NotNull Consumer<Select<HELP_MODEL, ENTITY>> select) {
        return __create(data, select, RelationModifyType.IgnoreRelation);
    }

createConnectRelation

   /**
     * 创建一条记录
     * 仅会建立关联模型关系, 不会创建或更新关联模型
     *
     * @param data 待创建记录
     * @return 被创建的纪录
     */
    default ENTITY createConnectRelation(@NotNull ENTITY data) {
        return __create(data, RelationModifyType.ConnectRelation);
    }


   /**
     * 创建一组记录
     * 仅会同步关联模型, 不会创建或更新
     *
     * @param data 待创建数据集合
     * @return 创建条数
     */
    default long createConnectRelation(@NotNull Collection<ENTITY> data) {
        return __create(data, RelationModifyType.ConnectRelation);
    }


    /**
     * 创建一条记录，并按 select 构造器返回给定字段
     * 仅会同步关联模型, 不会创建或更新
     *
     * @param data   待创建记录
     * @param select select 构造器
     * @return 被创建的记录，只包含 select 构造器中描述的字段
     */
    default ENTITY createConnectRelation(@NotNull ENTITY data, @NotNull Consumer<Select<HELP_MODEL, ENTITY>> select) {
        return __create(data, select, RelationModifyType.ConnectRelation);
    }

createWithRelation

    /**
     * 创建一条记录
     * 会同步创建或更新关联模型
     *
     * @param data 待创建记录
     * @return 被创建的纪录
     */
    default ENTITY createWithRelation(@NotNull ENTITY data) {
        return __create(data, RelationModifyType.WithRelation);
    }


 /**
     * 创建一组记录
     * 规则同样适用于子对象
     *
     * @param data 待创建数据集合
     * @return 创建条数
     */
    default long createWithRelation(@NotNull Collection<ENTITY> data) {
        return __create(data, RelationModifyType.WithRelation);
    }


    /**
     * 创建一条记录，并按 select 构造器返回给定字段
     * 会同步创建或更新关联模型
     *
     * @param data   待创建记录
     * @param select select 构造器
     * @return 被创建的记录，只包含 select 构造器中描述的字段
     */
    default ENTITY createWithRelation(@NotNull ENTITY data, @NotNull Consumer<Select<HELP_MODEL, ENTITY>> select) {
        return __create(data, select, RelationModifyType.WithRelation);
    }

createIgnoreRelationReturnEntity

    /**
     * 创建一组记录
     * 会忽略关联模型, 仅创建模型自身
     *
     * @param data 待创建 数据集合
     * @return 包含id的对象集合
     */
    default List<ENTITY> createIgnoreRelationReturnEntity(@NotNull Collection<ENTITY> data) {
        return __createManyReturnEntity(data, RelationModifyType.IgnoreRelation);
    }

createConnectRelationReturnEntity

    /**
     * 创建一组记录
     * 仅会同步关联模型, 不会创建或更新
     *
     * @param data 待创建数据集合
     * @return 包含id的对象集合
     */
    default List<ENTITY> createConnectRelationReturnEntity(@NotNull Collection<ENTITY> data) {
        return __createManyReturnEntity(data, RelationModifyType.ConnectRelation);
    }

createWithRelationReturnEntity

    /**
     * 创建一组记录
     * 规则同样适用于子对象
     *
     * @param data 待创建数据集合
     * @return 包含id的对象集合
     */
    default List<ENTITY> createWithRelationReturnEntity(@NotNull Collection<ENTITY> data) {
        return __createManyReturnEntity(data, RelationModifyType.WithRelation);
    }

UpdateDAO

updateIgnoreRelation

    /**
     * 按 id 更新一条记录，id 在记录内
     * 会忽略关联模型, 仅更新模型自身
     *
     * @param data 待更新记录
     * @return __被更新记录
     */
    default ENTITY updateIgnoreRelation(@NotNull ENTITY data) {
        return __update(data, RelationModifyType.IgnoreRelation, false);
    }


    /**
     * 按构造器给定条件更新一条记录，where 条件需要确保只命中一条记录，否则会出错
     * 会忽略关联模型, 仅更新模型自身
     *
     * @param data   待更新记录数据
     * @param select select 构造器
     * @return __被更新记录，只包含 select 构造器中描述的字段
     */
    default ENTITY updateIgnoreRelation(@NotNull ENTITY data, @NotNull Consumer<Select<HELP_MODEL, ENTITY>> select) {
        return __update(data, select, RelationModifyType.IgnoreRelation, false);
    }


    /**
     * 按 id 循环更新一组记录
     * 会忽略关联模型, 仅更新模型自身
     *
     * @param data 待更新记录集合
     * @return __被更新记录集合
     */
    default List<ENTITY> updateIgnoreRelation(@NotNull Collection<ENTITY> data) {
        return __update(data, RelationModifyType.IgnoreRelation, false);
    }

updateConnectRelation

    /**
     * 按 id 更新一条记录，id 在记录内
     * 仅会建立关联模型关系, 不会创建或更新关联模型
     *
     * @param data 待更新记录
     * @return __被更新记录
     */
    default ENTITY updateConnectRelation(@NotNull ENTITY data) {
        return __update(data, RelationModifyType.ConnectRelation, false);
    }


    /**
     * 按构造器给定条件更新一条记录，where 条件需要确保只命中一条记录，否则会出错
     * 仅会同步关联关联模型, 不会创建或更新
     *
     * @param data   待更新记录数据
     * @param select select 构造器
     * @return __被更新记录，只包含 select 构造器中描述的字段
     */
    default ENTITY updateConnectRelation(@NotNull ENTITY data, @NotNull Consumer<Select<HELP_MODEL, ENTITY>> select) {
        return __update(data, select, RelationModifyType.ConnectRelation, false);
    }


    /**
     * 按 id 循环更新一组记录
     * 仅会同步关联关联模型, 不会创建或更新
     *
     * @param data 待更新记录集合
     * @return __被更新记录集合
     */
    default List<ENTITY> updateConnectRelation(@NotNull Collection<ENTITY> data) {
        return __update(data, RelationModifyType.ConnectRelation, false);
    }

updateWithRelation

    /**
     * 按 id 更新一条记录，id 在记录内
     * 会同步关联、创建或者更新关联模型
     * 关联或创建时需要全量关联记录，没有的则视为解除关联
     *
     * @param data 待更新记录
     * @return __被更新记录
     */
    default ENTITY updateWithRelation(@NotNull ENTITY data) {
        return __update(data, RelationModifyType.WithRelation, false);
    }


    /**
     * 按构造器给定条件更新一条记录，where 条件需要确保只命中一条记录，否则会出错
     * 会更同步关联、创建或者更新关联模型
     * 关联或创建时需要全量关联记录，没有的则视为解除关联
     *
     * @param data   待更新记录数据
     * @param select select 构造器
     * @return __被更新记录，只包含 select 构造器中描述的字段
     */
    default ENTITY updateWithRelation(@NotNull ENTITY data, @NotNull Consumer<Select<HELP_MODEL, ENTITY>> select) {
        return __update(data, select, RelationModifyType.WithRelation, false);
    }


    /**
     * 按 id 循环更新一组记录
     * 会更同步关联、创建或者更新关联模型
     * 关联或创建时需要全量关联记录，没有的则视为解除关联
     *
     * @param data 待更新记录集合
     * @return __被更新记录集合
     */
    default List<ENTITY> updateWithRelation(@NotNull Collection<ENTITY> data) {
        return __update(data, RelationModifyType.WithRelation, false);
    }

updateWhereIgnoreRelation

    /**
     * 按构造器给定条件更新一条记录，where 条件需要确保只命中一条记录，否则会出错
     * 会忽略关联模型, 仅更新模型自身
     *
     * @param data      待更新记录数据
     * @param condition select 构造器
     * @return __只包含主模型字段的被更新记录
     */
    default ENTITY updateWhereIgnoreRelation(@NotNull ENTITY data, @NotNull Consumer<ConditionSet> condition) {
        return __updateWhere(data, condition, RelationModifyType.IgnoreRelation, false);
    }


    /**
     * 按 condition 构造器给定的条件更新一条记录，并按 select 构造器返回给定字段
     * 会忽略关联模型, 仅更新模型自身
     *
     * @param data   待更新记录
     * @param select select 构造器
     * @return __被更新记录，只包含 select 构造器中描述的字段
     */
    default ENTITY updateWhereIgnoreRelation(@NotNull ENTITY data, @NotNull Consumer<ConditionSet> condition, @NotNull Consumer<Select<HELP_MODEL, ENTITY>> select) {
        return __updateWhere(data, condition, select, RelationModifyType.IgnoreRelation, false);
    }

updateWhereConnectRelation

    /**
     * 按构造器给定条件更新一条记录，where 条件需要确保只命中一条记录，否则会出错
     * 仅会同步关联关联模型, 不会创建或更新
     *
     * @param data      待更新记录数据
     * @param condition select 构造器
     * @return __只包含主模型字段的被更新记录
     */
    default ENTITY updateWhereConnectRelation(@NotNull ENTITY data, @NotNull Consumer<ConditionSet> condition) {
        return __updateWhere(data, condition, RelationModifyType.ConnectRelation, false);
    }


    /**
     * 按 condition 构造器给定的条件更新一条记录，并按 select 构造器返回给定字段
     * 仅会同步关联关联模型, 不会创建或更新
     *
     * @param data   待更新记录
     * @param select select 构造器
     * @return __被更新记录，只包含 select 构造器中描述的字段
     */
    default ENTITY updateWhereConnectRelation(@NotNull ENTITY data, @NotNull Consumer<ConditionSet> condition, @NotNull Consumer<Select<HELP_MODEL, ENTITY>> select) {
        return __updateWhere(data, condition, select, RelationModifyType.ConnectRelation, false);
    }

updateWhereWithRelation

    /**
     * 按构造器给定条件更新一条记录，where 条件需要确保只命中一条记录，否则会出错
     * 会更同步关联、创建或者更新关联模型
     * 关联或创建时需要全量关联记录，没有的则视为解除关联
     *
     * @param data      待更新记录数据
     * @param condition select 构造器
     * @return __只包含主模型字段的被更新记录
     */
    default ENTITY updateWhereWithRelation(@NotNull ENTITY data, @NotNull Consumer<ConditionSet> condition) {
        return __updateWhere(data, condition, RelationModifyType.WithRelation, false);
    }


    /**
     * 按 condition 构造器给定的条件更新一条记录，并按 select 构造器返回给定字段
     * 会更同步关联、创建或者更新关联模型
     * 关联或创建时需要全量关联记录，没有的则视为解除关联
     *
     * @param data   待更新记录
     * @param select select 构造器
     * @return __被更新记录，只包含 select 构造器中描述的字段
     */
    default ENTITY updateWhereWithRelation(@NotNull ENTITY data, @NotNull Consumer<ConditionSet> condition, @NotNull Consumer<Select<HELP_MODEL, ENTITY>> select) {
        return __updateWhere(data, condition, select, RelationModifyType.WithRelation, false);
    }

updateManyIgnoreRelation

    /**
     * 按一组 id 批量更新记录为相同的值
     * 会忽略关联模型, 仅更新模型自身
     *
     * @param ids  待更新记录 id 集合
     * @param data 待更新记录数据
     * @return __更新成功数量
     */
    default long updateManyIgnoreRelation(@NotNull Collection<ID> ids, @NotNull ENTITY data) {
        return __updateMany(ids, data, RelationModifyType.IgnoreRelation, false);
    }


    /**
     * 按一组 id 批量更新记录为相同的值
     * 会忽略关联模型, 仅更新模型自身
     *
     * @param ids  待更新记录 id 集合
     * @param data 待更新记录数据
     * @return __更新成功数量
     */
    default long updateManyIgnoreRelation(@NotNull Collection<ID> ids, @NotNull Map<String, Object> data) {
        return __updateMany(ids, data, RelationModifyType.IgnoreRelation, false);
    }


    /**
     * 按 condition 构造器给定的条件批量更新记录为相同的值
     * 会忽略关联模型, 仅更新模型自身
     *
     * @param condition select 构造器
     * @param data      待更新记录数据
     * @return __更新成功数量
     */
    default long updateManyIgnoreRelation(@NotNull Consumer<ConditionSet> condition, @NotNull ENTITY data) {
        return __updateMany(condition, data, RelationModifyType.IgnoreRelation, false);
    }

updateManyConnectRelation

    /**
     * 按一组 id 批量更新记录为相同的值
     * 仅会同步关联关联模型, 不会创建或更新
     *
     * @param ids  待更新记录 id 集合
     * @param data 待更新记录数据
     * @return __更新成功数量
     */
    default long updateManyConnectRelation(@NotNull Collection<ID> ids, @NotNull ENTITY data) {
        return __updateMany(ids, data, RelationModifyType.ConnectRelation, false);
    }


    /**
     * 按一组 id 批量更新记录为相同的值
     * 仅会同步关联关联模型, 不会创建或更新
     *
     * @param ids  待更新记录 id 集合
     * @param data 待更新记录数据
     * @return __更新成功数量
     */
    default long updateManyConnectRelation(@NotNull Collection<ID> ids, @NotNull Map<String, Object> data) {
        return __updateMany(ids, data, RelationModifyType.ConnectRelation, false);
    }


    /**
     * 按 condition 构造器给定的条件批量更新记录为相同的值
     * 仅会同步关联关联模型, 不会创建或更新
     *
     * @param condition select 构造器
     * @param data      待更新记录数据
     * @return __更新成功数量
     */
    default long updateManyConnectRelation(@NotNull Consumer<ConditionSet> condition, @NotNull ENTITY data) {
        return __updateMany(condition, data, RelationModifyType.ConnectRelation, false);
    }

updateManyWithRelation

    /**
     * 按一组 id 批量更新记录为相同的值
     * 会更同步关联、创建或者更新关联模型
     * 关联或创建时需要全量关联记录，没有的则视为解除关联
     *
     * @param ids  待更新记录 id 集合
     * @param data 待更新记录数据
     * @return __更新成功数量
     */
    default long updateManyWithRelation(@NotNull Collection<ID> ids, @NotNull ENTITY data) {
        return __updateMany(ids, data, RelationModifyType.WithRelation, false);
    }


    /**
     * 按一组 id 批量更新记录为相同的值
     * 会更同步关联、创建或者更新关联模型
     * 关联或创建时需要全量关联记录，没有的则视为解除关联
     *
     * @param ids  待更新记录 id 集合
     * @param data 待更新记录数据
     * @return __更新成功数量
     */
    default long updateManyWithRelation(@NotNull Collection<ID> ids, @NotNull Map<String, Object> data) {
        return __updateMany(ids, data, RelationModifyType.WithRelation, false);
    }


    /**
     * 按 condition 构造器给定的条件批量更新记录为相同的值
     * 会更同步关联、创建或者更新关联模型
     * 关联或创建时需要全量关联记录，没有的则视为解除关联
     *
     * @param condition select 构造器
     * @param data      待更新记录数据
     * @return __更新成功数量
     */
    default long updateManyWithRelation(@NotNull Consumer<ConditionSet> condition, @NotNull ENTITY data) {
        return __updateMany(condition, data, RelationModifyType.WithRelation, false);
    }

updateIgnoreRelationSkipNull

    /**
     * 按 id 更新一条记录，id 在记录内
     * 会忽略关联模型, 仅更新模型自身
     *
     * @param data 待更新记录
     * @return __被更新记录
     */
    default ENTITY updateIgnoreRelationSkipNull(@NotNull ENTITY data) {
        return __update(data, RelationModifyType.IgnoreRelation, true);
    }


    /**
     * 按构造器给定条件更新一条记录，where 条件需要确保只命中一条记录，否则会出错
     * 会忽略关联模型, 仅更新模型自身
     *
     * @param data   待更新记录数据
     * @param select select 构造器
     * @return __被更新记录，只包含 select 构造器中描述的字段
     */
    default ENTITY updateIgnoreRelationSkipNull(@NotNull ENTITY data, @NotNull Consumer<Select<HELP_MODEL, ENTITY>> select) {
        return __update(data, select, RelationModifyType.IgnoreRelation, true);
    }


    /**
     * 按 id 循环更新一组记录
     * 会忽略关联模型, 仅更新模型自身
     *
     * @param data 待更新记录集合
     * @return __被更新记录集合
     */
    default List<ENTITY> updateIgnoreRelationSkipNull(@NotNull Collection<ENTITY> data) {
        return __update(data, RelationModifyType.IgnoreRelation, true);
    }

updateConnectRelationSkipNull

    /**
     * 按 id 更新一条记录，id 在记录内
     * 仅会同步关联关联模型, 不会创建或更新
     *
     * @param data 待更新记录
     * @return __被更新记录
     */
    default ENTITY updateConnectRelationSkipNull(@NotNull ENTITY data) {
        return __update(data, RelationModifyType.ConnectRelation, true);
    }


    /**
     * 按构造器给定条件更新一条记录，where 条件需要确保只命中一条记录，否则会出错
     * 仅会同步关联关联模型, 不会创建或更新
     *
     * @param data   待更新记录数据
     * @param select select 构造器
     * @return __被更新记录，只包含 select 构造器中描述的字段
     */
    default ENTITY updateConnectRelationSkipNull(@NotNull ENTITY data, @NotNull Consumer<Select<HELP_MODEL, ENTITY>> select) {
        return __update(data, select, RelationModifyType.ConnectRelation, true);
    }


    /**
     * 按 id 循环更新一组记录
     * 仅会同步关联关联模型, 不会创建或更新
     *
     * @param data 待更新记录集合
     * @return __被更新记录集合
     */
    default List<ENTITY> updateConnectRelationSkipNull(@NotNull Collection<ENTITY> data) {
        return __update(data, RelationModifyType.ConnectRelation, true);
    }

updateWithRelationSkipNull

    /**
     * 按 id 更新一条记录，id 在记录内
     * 会更同步关联、创建或者更新关联模型
     * 关联或创建时需要全量关联记录，没有的则视为解除关联
     *
     * @param data 待更新记录
     * @return __被更新记录
     */
    default ENTITY updateWithRelationSkipNull(@NotNull ENTITY data) {
        return __update(data, RelationModifyType.WithRelation, true);
    }


    /**
     * 按构造器给定条件更新一条记录，where 条件需要确保只命中一条记录，否则会出错
     * 会更同步关联、创建或者更新关联模型
     * 关联或创建时需要全量关联记录，没有的则视为解除关联
     *
     * @param data   待更新记录数据
     * @param select select 构造器
     * @return __被更新记录，只包含 select 构造器中描述的字段
     */
    default ENTITY updateWithRelationSkipNull(@NotNull ENTITY data, @NotNull Consumer<Select<HELP_MODEL, ENTITY>> select) {
        return __update(data, select, RelationModifyType.WithRelation, true);
    }


    /**
     * 按 id 循环更新一组记录
     * 会更同步关联、创建或者更新关联模型
     * 关联或创建时需要全量关联记录，没有的则视为解除关联
     *
     * @param data 待更新记录集合
     * @return __被更新记录集合
     */
    default List<ENTITY> updateWithRelationSkipNull(@NotNull Collection<ENTITY> data) {
        return __update(data, RelationModifyType.WithRelation, true);
    }

updateWhereIgnoreRelationSkipNull

    /**
     * 按构造器给定条件更新一条记录，where 条件需要确保只命中一条记录，否则会出错
     * 会忽略关联模型, 仅更新模型自身
     *
     * @param data      待更新记录数据
     * @param condition select 构造器
     * @return __只包含主模型字段的被更新记录
     */
    default ENTITY updateWhereIgnoreRelationSkipNull(@NotNull ENTITY data, @NotNull Consumer<ConditionSet> condition) {
        return __updateWhere(data, condition, RelationModifyType.IgnoreRelation, true);
    }


    /**
     * 按 condition 构造器给定的条件更新一条记录，并按 select 构造器返回给定字段
     * 会忽略关联模型, 仅更新模型自身
     *
     * @param data   待更新记录
     * @param select select 构造器
     * @return __被更新记录，只包含 select 构造器中描述的字段
     */
    default ENTITY updateWhereIgnoreRelationSkipNull(@NotNull ENTITY data, @NotNull Consumer<ConditionSet> condition, @NotNull Consumer<Select<HELP_MODEL, ENTITY>> select) {
        return __updateWhere(data, condition, select, RelationModifyType.IgnoreRelation, true);
    }

updateWhereConnectRelationSkipNull

    /**
     * 按构造器给定条件更新一条记录，where 条件需要确保只命中一条记录，否则会出错
     * 仅会同步关联关联模型, 不会创建或更新
     *
     * @param data      待更新记录数据
     * @param condition select 构造器
     * @return __只包含主模型字段的被更新记录
     */
    default ENTITY updateWhereConnectRelationSkipNull(@NotNull ENTITY data, @NotNull Consumer<ConditionSet> condition) {
        return __updateWhere(data, condition, RelationModifyType.ConnectRelation, true);
    }


    /**
     * 按 condition 构造器给定的条件更新一条记录，并按 select 构造器返回给定字段
     * 仅会同步关联关联模型, 不会创建或更新
     *
     * @param data   待更新记录
     * @param select select 构造器
     * @return __被更新记录，只包含 select 构造器中描述的字段
     */
    default ENTITY updateWhereConnectRelationSkipNull(@NotNull ENTITY data, @NotNull Consumer<ConditionSet> condition, @NotNull Consumer<Select<HELP_MODEL, ENTITY>> select) {
        return __updateWhere(data, condition, select, RelationModifyType.ConnectRelation, true);
    }

updateWhereWithRelationSkipNull

    /**
     * 按构造器给定条件更新一条记录，where 条件需要确保只命中一条记录，否则会出错
     * 会更同步关联、创建或者更新关联模型
     * 关联或创建时需要全量关联记录，没有的则视为解除关联
     *
     * @param data      待更新记录数据
     * @param condition select 构造器
     * @return __只包含主模型字段的被更新记录
     */
    default ENTITY updateWhereWithRelationSkipNull(@NotNull ENTITY data, @NotNull Consumer<ConditionSet> condition) {
        return __updateWhere(data, condition, RelationModifyType.WithRelation, true);
    }


    /**
     * 按 condition 构造器给定的条件更新一条记录，并按 select 构造器返回给定字段
     * 会更同步关联、创建或者更新关联模型
     * 关联或创建时需要全量关联记录，没有的则视为解除关联
     *
     * @param data   待更新记录
     * @param select select 构造器
     * @return __被更新记录，只包含 select 构造器中描述的字段
     */
    default ENTITY updateWhereWithRelationSkipNull(@NotNull ENTITY data, @NotNull Consumer<ConditionSet> condition, @NotNull Consumer<Select<HELP_MODEL, ENTITY>> select) {
        return __updateWhere(data, condition, select, RelationModifyType.WithRelation, true);
    }

updateManyWithRelationSkipNull

    /**
     * 按一组 id 批量更新记录为相同的值
     * 会更同步关联、创建或者更新关联模型
     * 关联或创建时需要全量关联记录，没有的则视为解除关联
     *
     * @param ids  待更新记录 id 集合
     * @param data 待更新记录数据
     * @return __更新成功数量
     */
    default long updateManyWithRelationSkipNull(@NotNull Collection<ID> ids, @NotNull ENTITY data) {
        return __updateMany(ids, data, RelationModifyType.WithRelation, true);
    }


    /**
     * 按一组 id 批量更新记录为相同的值
     * 会更同步关联、创建或者更新关联模型
     * 关联或创建时需要全量关联记录，没有的则视为解除关联
     *
     * @param ids  待更新记录 id 集合
     * @param data 待更新记录数据
     * @return __更新成功数量
     */
    default long updateManyWithRelationSkipNull(@NotNull Collection<ID> ids, @NotNull Map<String, Object> data) {
        return __updateMany(ids, data, RelationModifyType.WithRelation, true);
    }


    /**
     * 按 condition 构造器给定的条件批量更新记录为相同的值
     * 会更同步关联、创建或者更新关联模型
     * 关联或创建时需要全量关联记录，没有的则视为解除关联
     *
     * @param condition select 构造器
     * @param data      待更新记录数据
     * @return __更新成功数量
     */
    default long updateManyWithRelationSkipNull(@NotNull Consumer<ConditionSet> condition, @NotNull ENTITY data) {
        return __updateMany(condition, data, RelationModifyType.WithRelation, true);
    }

updateManyIgnoreRelationSkipNull

    /**
     * 按一组 id 批量更新记录为相同的值
     * 会忽略关联模型, 仅更新模型自身
     *
     * @param ids  待更新记录 id 集合
     * @param data 待更新记录数据
     * @return __更新成功数量
     */
    default long updateManyIgnoreRelationSkipNull(@NotNull Collection<ID> ids, @NotNull ENTITY data) {
        return __updateMany(ids, data, RelationModifyType.IgnoreRelation, true);
    }


    /**
     * 按一组 id 批量更新记录为相同的值
     * 会忽略关联模型, 仅更新模型自身
     *
     * @param ids  待更新记录 id 集合
     * @param data 待更新记录数据
     * @return __更新成功数量
     */
    default long updateManyIgnoreRelationSkipNull(@NotNull Collection<ID> ids, @NotNull Map<String, Object> data) {
        return __updateMany(ids, data, RelationModifyType.IgnoreRelation, true);
    }


    /**
     * 按 condition 构造器给定的条件批量更新记录为相同的值
     * 会忽略关联模型, 仅更新模型自身
     *
     * @param condition select 构造器
     * @param data      待更新记录数据
     * @return __更新成功数量
     */
    default long updateManyIgnoreRelationSkipNull(@NotNull Consumer<ConditionSet> condition, @NotNull ENTITY data) {
        return __updateMany(condition, data, RelationModifyType.IgnoreRelation, true);
    }

updateManyConnectRelationSkipNull

    /**
     * 按一组 id 批量更新记录为相同的值
     * 仅会同步关联关联模型, 不会创建或更新
     *
     * @param ids  待更新记录 id 集合
     * @param data 待更新记录数据
     * @return __更新成功数量
     */
    default long updateManyConnectRelationSkipNull(@NotNull Collection<ID> ids, @NotNull ENTITY data) {
        return __updateMany(ids, data, RelationModifyType.ConnectRelation, true);
    }


    /**
     * 按一组 id 批量更新记录为相同的值
     * 仅会同步关联关联模型, 不会创建或更新
     *
     * @param ids  待更新记录 id 集合
     * @param data 待更新记录数据
     * @return __更新成功数量
     */
    default long updateManyConnectRelationSkipNull(@NotNull Collection<ID> ids, @NotNull Map<String, Object> data) {
        return __updateMany(ids, data, RelationModifyType.ConnectRelation, true);
    }


    /** 按 condition 构造器给定的条件批量更新记录为相同的值
     * 仅会同步关联关联模型, 不会创建或更新
     *
     * @param condition select 构造器
     * @param data      待更新记录数据
     * @return __更新成功数量
     */
    default long updateManyConnectRelationSkipNull(@NotNull Consumer<ConditionSet> condition, @NotNull ENTITY data) {
        return __updateMany(condition, data, RelationModifyType.ConnectRelation, true);
    }

DeleteDAO

delete

   /**
     * 按 id 删除一条记录
     *
     * @param id id
     */
    void delete(@NotNull ID id);


    /**
     * 按一组 id 批量删除记录
     *
     * @param ids id 集合
     * @return 删除成功数量
     */
    long delete(@NotNull Collection<ID> ids);


    /**
     * 按给定条件批量删除记录
     *
     * @param conditions 条件
     */
    long delete(@NotNull Consumer<ConditionSet> conditions);

QueryDAO

findById

    /**
     * 按 id 查找一条记录
     *
     * @param id id
     * @return Optional 包装的查找到的记录
     */
    Optional<ENTITY> findById(@NotNull ID id);


    /**
     * 按 id 查找一条记录，并构造需要返回的字段，这在查询关联模型时非常实用
     *
     * @param id     id
     * @param select select 构造器
     * @return Optional 包装的查找到的记录，记录中只会存在指定的字段
     */
    Optional<ENTITY> findById(@NotNull ID id, @NotNull Consumer<Select<HELP_MODEL, ENTITY>> select);

findByIds

    /**
     * 按一组 id 查找一组记录
     *
     * @param ids id 集合
     * @return 记录列表，查找不到任何记录时返回空列表
     */
    List<ENTITY> findByIds(@NotNull Collection<ID> ids);


    /**
     * 按一组 id 查找一组记录，并构造需要返回的字段，这在查询关联模型时非常实用
     *
     * @param ids    id 集合
     * @param select select 构造器
     * @return 查找到的记录列表，记录中只会存在指定的字段，查找不到任何记录时返回空列表
     */
    List<ENTITY> findByIds(@NotNull Collection<ID> ids, @NotNull Consumer<Select<HELP_MODEL, ENTITY>> select);

findOne

    /**
     * 编码查找单条记录，可指定 where 、orderBy 、limit 和 select
     *
     * @param query 构造器
     * @return Optional 包装的查找到的记录
     */
    Optional<ENTITY> findOne(@NotNull Consumer<Query<HELP_MODEL, ENTITY>> query);

find

    /**
     * 编码查找一组记录，可指定 where 、orderBy 、limit 和 select
     *
     * @param query 构造器
     * @return 查找到的记录列表或空列表
     */
    List<ENTITY> find(@NotNull Consumer<Query<HELP_MODEL, ENTITY>> query);

count

    /**
     * 编码 count 记录，可指定 where 、orderBy 、limit ，对 select 的指定是无效的
     *
     * @param query 构造器
     * @return count
     */
    long count(@NotNull Consumer<Query<HELP_MODEL, ENTITY>> query);

page

   /**
     * 按条件分页查询，可指定 where
     *
     * @param condition 条件构造器
     * @param pageNo    页码
     * @param pageSize  分页大小
     * @return 分页结果
     */
    Paging<ENTITY> page(@NotNull Consumer<ConditionSet> condition, long pageNo, long pageSize);


    /**
     * 按条件分页查询，可指定 where 、 select
     *
     * @param condition 条件构造器
     * @param select    select 构造器
     * @param pageNo    页码
     * @param pageSize  分页大小
     */
    Paging<ENTITY> page(@NotNull Consumer<ConditionSet> condition, @NotNull Consumer<Select<HELP_MODEL, ENTITY>> select, long pageNo, long pageSize);


    /**
     * 按条件分页查询，可指定 where 、orderBy
     *
     * @param condition 条件构造器
     * @param orderBy   order by 条件
     * @param pageNo    页码
     * @param pageSize  分页大小
     * @return 分页结果
     */
    Paging<ENTITY> page(@NotNull Consumer<ConditionSet> condition, @Nullable OrderBy orderBy, long pageNo, long pageSize);


    /**
     * 按条件分页查询，可指定 where 、orderBy
     *
     * @param condition 条件构造器
     * @param select    select 构造器
     * @param orderBy   order by 条件
     * @param pageNo    页码
     * @param pageSize  分页大小
     * @return 分页结果
     */
    Paging<ENTITY> page(@NotNull Consumer<ConditionSet> condition, @NotNull Consumer<Select<HELP_MODEL, ENTITY>> select,
                        @Nullable OrderBy orderBy, long pageNo, long pageSize);
    Paging<ENTITY> page(@NotNull Consumer<ConditionSet> condition, @NotNull Consumer<Select<HELP_MODEL, ENTITY>> select,
                        long pageNo, long pageSize, @Nullable OrderBy... orderBy);


    /**
     * 按条件分页查询，可指定 where 、orderBy 、groupBy
     * 说明：带groupBy的分页适合聚合查询，非聚合查询场景不建议使用（因为DB在"非严格模式"下的groupBy查询结果是随机的）
     *
     * @param condition 条件构造器
     * @param select    select 构造器
     * @param orderBy   order by 条件
     * @param groupBy   group by 条件
     * @param pageNo    页码
     * @param pageSize  分页大小
     * @return 分页结果
     */
    Paging<ENTITY> page(@NotNull Consumer<ConditionSet> condition, @NotNull Consumer<Select<HELP_MODEL, ENTITY>> select,
                        @Nullable OrderBy orderBy, @Nullable GroupBy groupBy, long pageNo, long pageSize);
    Paging<ENTITY> page(@NotNull Consumer<ConditionSet> condition, @NotNull Consumer<Select<HELP_MODEL, ENTITY>> select,
                        long pageNo, long pageSize, @Nullable GroupBy groupBy, @Nullable OrderBy... orderBy);

exists

    /**
     * 根据条件查询是否存在记录，可指定 where 、orderBy 、limit ，对 select 的指定是无效的
     *
     * @param query 构造器
     * @return exists
     */
    boolean exists(@NotNull Consumer<Query<HELP_MODEL, ENTITY>> query);

FunctionDAO

sum

    /**
     * 根据一组条件 sum 一个字段值
     *
     * @param field     sum 字段
     * @param condition sum 条件
     * @return sum 结果值
     */
    Long sum(String field, Consumer<ConditionSet> condition);

max

    /**
     * 在一组条件内找出该字段最大的值
     *
     * @param field     max 字段
     * @param condition max 条件
     * @return 条件内 max 字段的最大值
     */
    Object max(String field, Consumer<ConditionSet> condition);

maxAsLong

    /**
     * 在一组条件内找出该字段最大的值
     *
     * @param field     max 字段
     * @param condition max 条件
     * @return 条件内 max 字段的最大值
     */
    default long maxAsLong(String field, Consumer<ConditionSet> condition) {
        return maxAs(field, condition);
    }

maxAsString

    /**
     * 在一组条件内找出该字段最大的值
     *
     * @param field     max 字段
     * @param condition max 条件
     * @return 条件内 max 字段的最大值
     */
    default String maxAsString(String field, Consumer<ConditionSet> condition) {
        return maxAs(field, condition);
    }

min

    /**
     * 在一组条件内找出该字段最小的值
     *
     * @param field     min 字段
     * @param condition min 条件
     * @return 条件内 min 字段的最小值
     */
    Object min(String field, Consumer<ConditionSet> condition);

minAsLong

    /**
     * 在一组条件内找出该字段最小的值
     *
     * @param field     min 字段
     * @param condition min 条件
     * @return 条件内 min 字段的最小值
     */
    default long maxAsLong(String field, Consumer<ConditionSet> condition) {
        return maxAs(field, condition);
    }

minAsString

    /**
     * 在一组条件内找出该字段最小的值
     *
     * @param field     min 字段
     * @param condition min 条件
     * @return 条件内 min 字段的最小值
     */
    default String minAsString(String field, Consumer<ConditionSet> condition) {
        return minAs(field, condition);
    }

应用举例：

@Repository
public class StudentRepository extends TrantorDAO<Student, Long> {


}

创建

  • 单条数据
@Component
public class StudentServerAction {


    @Autowired
    private StudentRepository studentRepo;


    @TAction(modelClass = Student.class)
    public void save(@TParam Student student) {


        Integer id = TContext.getFrontendContext().getCurrentBusinessDimensionId();
        Classes classes = new Classes();
        classes.setId(Long.valueOf(id));
        student.setClasses(classes);
        studentRepo.saveWithRelationSkipNull(student);
    }
}
  • 批量创建
@Component
public class StudentServerAction {


    @Autowired
    private StudentRepository studentRepo;


    @TAction(modelClass = Student.class)
    public void batchsave(@TCollectionParam(Student.class) List<Student> students) {


        studentRepo.saveWithRelationSkipNull(students);
       }
}

更新

  • 单条更新
@Component
public class StudentServerAction {


    @Autowired
    private StudentRepository studentRepo;


    @TAction(modelClass = Student.class)
    public void update(@TParam Student student) {


      studentRepo.updateConnectRelationSkipNull(student);


        }
}
  • 批量更新
@Component
public class StudentServerAction {


    @Autowired
    private StudentRepository studentRepo;


    @TAction(modelClass = Student.class)
    public void batchupdate(@TCollectionParam(Student.class) List<Student> students) {


            studentRepo.updateConnectRelationSkipNull(students);
       }
}

查询

操作符

/**
 * 条件筛选
 */
public enum Operators {
    EQ(""),                               //等于
    NEQ("_not"),                          //不等于
    IN("_in"),                            //在范围内
    NOT_IN("_not_in"),                    //不在范围内
    LT("_lt"),                            //小于
    LTE("_lte"),                          //小于等于
    GT("_gt"),                            //大于
    GTE("_gte"),                          //大于等于
    LT_FIELD("_lt_field"),                //小于模型字段
    LTE_FIELD("_lte_field"),              //小于等于模型字段
    GT_FIELD("_gt_field"),                //大于模型字段
    GTE_FIELD("_gte_field"),              //大于等于模型字段
    EQ_FIELD("_eq_field"),                //等于模型字段
    CONTAINS("_contains"),                //包含模型字段
    NOT_CONTAINS("_not_contains"),        //不包含模型字段
    STARTS_WITH("_starts_with"),          //开始于
    NO_STARTS_WITH("_not_starts_with"),   //非开始于
    ENDS_WITH("_ends_with"),              //结束于
    NO_ENDS_WITH("_not_ends_with");       //非结束于


    private String opStr;


    private Operators(String opStr) {
        this.opStr = opStr;
    }


    public String getOpStr() {
        return this.opStr;
    }
}
/**
 * 这里通过treeAction来展示数据的查询
 */
@Component
public class SchoolDeparementTreeAction implements TreeDataAction<Department, Long> {


    @Autowired
    DepartmentRepository dao;


    /**
     * 作用于父节点点击[+]展开子级数据时，返回子级数据；需要注意由于此处无分页，如果单级数据量非常大时，建议不要使用树形交互方式
     */
    @Override
    public TreeDataResult<Department> loadChildren(@Nullable Long parentId, TreeDataParams params) {
        List<Department> result = new ArrayList<>();


        if (parentId == null) {
            //获取单条数据，条件：父级公司为null
            Optional<Department> response = dao.findOne(query -> {
                query.where(conditionSet -> conditionSet.condition(Department.parent_field, Operators.EQ, null));


                query.selectAll();
                query.orderBy(Department.createdAt_field, false);
            });


            result.add(response.get());
        } else {
             //获取多条数据，条件：父级公司的ID等于 parentId
            List<Department> response = dao.find(query -> {
                query.where(conditionSet -> conditionSet.condition(Department.parent_field, depart -> {
                    depart.eq(Department.id_field, parentId);
                }));


                query.selectAll();
                query.orderBy(Department.createdAt_field, false);
            });
            //获取上一层级
            Optional<Department> parent = dao.findOne(query -> {
                query.where(conditionSet -> conditionSet.condition(Department.id_field, Operators.EQ, parentId));


                query.selectAll();
            });
            //填充
            for (Department department : response) {
                department.setParent(parent.get());
            }


            result.addAll(response);
        }


        return new TreeDataResult<>(result);
    }


    /**
     * 用于树形容器和控件的搜索框提示。需返回模糊搜索的前几条结果，建议不超过十条。返回数据仅需包含 id 和显示名。
     */
    @Override
    public TreeSearchResult<Long> search(TreeDataParams params) {
        List<TreeItem<Long>> result = new ArrayList<>();
         //获取多条数据，条件：父级公司的name 包含字符串参数
        List<Department> response = dao.find(query -> {
            query.where(conditionSet -> conditionSet.condition(Department.name_field, Operators.CONTAINS, params.getFuzzyValue()));


            query.selectAll();
            query.orderBy(Department.createdAt_field, false);
        });


        for (Department department : response) {
            TreeItem<Long> t = new TreeItem<>();
            t.setId(department.getId());
            t.setDisplayName(department.getName());


            result.add(t);
        }


        return new TreeSearchResult<>(result);
    }


    /**
     * 一般和 search 方法配套使用，用于从一条特定数据反向构建树，以便树形容器能正常展示数据。
     * 反向构建需要包含该条数据本身；该条数据的兄弟节点数据；该条数据的祖先链和祖先链上每个节点的兄弟节点数据。
     * 数据无需按树形进行组织，只需全部平铺为 List 即可。但需要保证每条数据都带有给定的 parentId 字段。Trantor 前端数据容器将根据返回数据组织成树。
     *
     * @param parentId 上一级ID
     * @param params   其他相关参数
     * @return 返回数据结果集
     */
    @Override
    public TreeDataResult<Department> reverseBuild(@Nullable Long parentId, TreeDataParams params) {


        List<Department> result = new ArrayList<>();


        Long temp=parentId;
        while (true) {


            //获取当前层级
            Long finalTemp = temp;
            Optional<Department> currentResponse = dao.findOne(query -> {
                query.where(conditionSet -> conditionSet.condition(Department.id_field, Operators.EQ, finalTemp));
                query.select(select -> select.getObject(Department.parent_field));
                query.selectAll();
            });
            result.add(currentResponse.get());
            //获取上一级
            Optional<Department> before = dao.findOne(query -> {
                query.where(conditionSet -> conditionSet.condition(Department.id_field, Operators.EQ, currentResponse.get().getParent().getId()));
                query.select(select -> select.getObject(Department.parent_field));
                query.selectAll();
            });


            if(Arguments.isNull(before.get().getParent())){


                break;
            }
            //获取当前层级的下一级
            List<Department> response = dao.find(query -> {
                query.where(conditionSet -> conditionSet.condition(Department.parent_field, depart -> {
                    depart.eq(Department.id_field, before.get().getParent().getId());
                }));


                query.select(select -> select.getObject(Department.parent_field));
                query.selectAll();
                query.orderBy(Department.createdAt_field, false);


            });
            temp= currentResponse.get().getParent().getId();
            result.addAll(response);
        }
        return new TreeDataResult<>(result);
    }


    /**
     * 方法用于树控件的数据回填（例如 ：加载更多，或者下拉框的场景）
     */
    @Override
    public TreeDataResult<Department> loadByIds(List<Long> longs, TreeDataParams params) {


        List<Department> response = dao.findByIds(longs);


        return new TreeDataResult<>(response);
    }
}
@Data
@TModel(name = "学校部门模型", mainField = "name")
public class Department extends BaseModel<Long> {


    private static final long serialVersionUID = 5211638242173698941L;
    @TModelField(name = "部门名称", nullable = false)
    private String name;


    @TModelField(name = "部门编码")
    private String code;


    @TModelField(name = "上级部门")
    @RelationMeta(name = "DepartmentParent")
    private Department parent;
}

删除

  • 单条删除
@Component
public class StudentServerAction {


    @Autowired
    private StudentRepository studentRepo;


    @TAction(modelClass = Student.class)
    public void delete(@TParam Student student) {
        studentRepo.delete(student.getId());
    }
}
  • 批量删除
@Component
public class StudentServerAction {


    @Autowired
    private StudentRepository studentRepo;


    @TAction(modelClass = Student.class)
    public void batchdelete(@TCollectionParam(Student.class) List<Student> students) {


      List<Long> ids = students.stream().map(RootModel::getId).collect(Collectors.toList());
                       studentRepo.delete(ids);
      }
}
  • 条件删除
@Component
public class StudentServerAction {


    @Autowired
    private StudentRepository studentRepo;


    @TAction(modelClass = Student.class)
    public void deleteByCondition(String name, String id) {
        studentRepo.delete(student -> {
            student.condition(Student.name_field, Operators.CONTAINS, name);
            student.condition(Student.id_field, Operators.EQ, id);
        });
    }
}