标签（空格分隔）： mybatis-plus

Iservice

  1. public interface IService<T> {
  3.     /**
  4.      * 默认批次提交数量
  5.      */
  6.     int DEFAULT_BATCH_SIZE = 1000;
  8.     /**
  9.      * 插入一条记录（选择字段，策略插入）
  10.      *
  11.      * @param entity 实体对象
  12.      */
  13.     default boolean save(T entity) {
  14.         return SqlHelper.retBool(getBaseMapper().insert(entity));
  15.     }
  17.     /**
  18.      * 插入（批量）
  19.      *
  20.      * @param entityList 实体对象集合
  21.      */
  22.     @Transactional(rollbackFor = Exception.class)
  23.     default boolean saveBatch(Collection<T> entityList) {
  24.         return saveBatch(entityList, DEFAULT_BATCH_SIZE);
  25.     }
  27.     /**
  28.      * 插入（批量）
  29.      *
  30.      * @param entityList 实体对象集合
  31.      * @param batchSize  插入批次数量
  32.      */
  33.     boolean saveBatch(Collection<T> entityList, int batchSize);
  35.     /**
  36.      * 批量修改插入
  37.      *
  38.      * @param entityList 实体对象集合
  39.      */
  40.     @Transactional(rollbackFor = Exception.class)
  41.     default boolean saveOrUpdateBatch(Collection<T> entityList) {
  42.         return saveOrUpdateBatch(entityList, DEFAULT_BATCH_SIZE);
  43.     }
  45.     /**
  46.      * 批量修改插入
  47.      *
  48.      * @param entityList 实体对象集合
  49.      * @param batchSize  每次的数量
  50.      */
  51.     boolean saveOrUpdateBatch(Collection<T> entityList, int batchSize);
  53.     /**
  54.      * 根据 ID 删除
  55.      *
  56.      * @param id 主键ID
  57.      */
  58.     default boolean removeById(Serializable id) {
  59.         return SqlHelper.retBool(getBaseMapper().deleteById(id));
  60.     }
  62.     /**
  63.      * 根据 columnMap 条件，删除记录
  64.      *
  65.      * @param columnMap 表字段 map 对象
  66.      */
  67.     default boolean removeByMap(Map<String, Object> columnMap) {
  68.         Assert.notEmpty(columnMap, "error: columnMap must not be empty");
  69.         return SqlHelper.retBool(getBaseMapper().deleteByMap(columnMap));
  70.     }
  72.     /**
  73.      * 根据 entity 条件，删除记录
  74.      *
  75.      * @param queryWrapper 实体包装类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
  76.      */
  77.     default boolean remove(Wrapper<T> queryWrapper) {
  78.         return SqlHelper.retBool(getBaseMapper().delete(queryWrapper));
  79.     }
  81.     /**
  82.      * 删除（根据ID 批量删除）
  83.      *
  84.      * @param idList 主键ID列表
  85.      */
  86.     default boolean removeByIds(Collection<? extends Serializable> idList) {
  87.         if (CollectionUtils.isEmpty(idList)) {
  88.             return false;
  89.         }
  90.         return SqlHelper.retBool(getBaseMapper().deleteBatchIds(idList));
  91.     }
  93.     /**
  94.      * 根据 ID 选择修改
  95.      *
  96.      * @param entity 实体对象
  97.      */
  98.     default boolean updateById(T entity) {
  99.         return SqlHelper.retBool(getBaseMapper().updateById(entity));
  100.     }
  102.     /**
  103.      * 根据 UpdateWrapper 条件，更新记录 需要设置sqlset
  104.      *
  105.      * @param updateWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper}
  106.      */
  107.     default boolean update(Wrapper<T> updateWrapper) {
  108.         return update(null, updateWrapper);
  109.     }
  111.     /**
  112.      * 根据 whereEntity 条件，更新记录
  113.      *
  114.      * @param entity        实体对象
  115.      * @param updateWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper}
  116.      */
  117.     default boolean update(T entity, Wrapper<T> updateWrapper) {
  118.         return SqlHelper.retBool(getBaseMapper().update(entity, updateWrapper));
  119.     }
  121.     /**
  122.      * 根据ID 批量更新
  123.      *
  124.      * @param entityList 实体对象集合
  125.      */
  126.     @Transactional(rollbackFor = Exception.class)
  127.     default boolean updateBatchById(Collection<T> entityList) {
  128.         return updateBatchById(entityList, DEFAULT_BATCH_SIZE);
  129.     }
  131.     /**
  132.      * 根据ID 批量更新
  133.      *
  134.      * @param entityList 实体对象集合
  135.      * @param batchSize  更新批次数量
  136.      */
  137.     boolean updateBatchById(Collection<T> entityList, int batchSize);
  139.     /**
  140.      * TableId 注解存在更新记录，否插入一条记录
  141.      *
  142.      * @param entity 实体对象
  143.      */
  144.     boolean saveOrUpdate(T entity);
  146.     /**
  147.      * 根据 ID 查询
  148.      *
  149.      * @param id 主键ID
  150.      */
  151.     default T getById(Serializable id) {
  152.         return getBaseMapper().selectById(id);
  153.     }
  155.     /**
  156.      * 查询（根据ID 批量查询）
  157.      *
  158.      * @param idList 主键ID列表
  159.      */
  160.     default List<T> listByIds(Collection<? extends Serializable> idList) {
  161.         return getBaseMapper().selectBatchIds(idList);
  162.     }
  164.     /**
  165.      * 查询（根据 columnMap 条件）
  166.      *
  167.      * @param columnMap 表字段 map 对象
  168.      */
  169.     default List<T> listByMap(Map<String, Object> columnMap) {
  170.         return getBaseMapper().selectByMap(columnMap);
  171.     }
  173.     /**
  174.      * 根据 Wrapper，查询一条记录 <br/>
  175.      * <p>结果集，如果是多个会抛出异常，随机取一条加上限制条件 wrapper.last("LIMIT 1")</p>
  176.      *
  177.      * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
  178.      */
  179.     default T getOne(Wrapper<T> queryWrapper) {
  180.         return getOne(queryWrapper, true);
  181.     }
  183.     /**
  184.      * 根据 Wrapper，查询一条记录
  185.      *
  186.      * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
  187.      * @param throwEx      有多个 result 是否抛出异常
  188.      */
  189.     T getOne(Wrapper<T> queryWrapper, boolean throwEx);
  191.     /**
  192.      * 根据 Wrapper，查询一条记录
  193.      *
  194.      * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
  195.      */
  196.     Map<String, Object> getMap(Wrapper<T> queryWrapper);
  198.     /**
  199.      * 根据 Wrapper，查询一条记录
  200.      *
  201.      * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
  202.      * @param mapper       转换函数
  203.      */
  204.     <V> V getObj(Wrapper<T> queryWrapper, Function<? super Object, V> mapper);
  206.     /**
  207.      * 查询总记录数
  208.      *
  209.      * @see Wrappers#emptyWrapper()
  210.      */
  211.     default int count() {
  212.         return count(Wrappers.emptyWrapper());
  213.     }
  215.     /**
  216.      * 根据 Wrapper 条件，查询总记录数
  217.      *
  218.      * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
  219.      */
  220.     default int count(Wrapper<T> queryWrapper) {
  221.         return SqlHelper.retCount(getBaseMapper().selectCount(queryWrapper));
  222.     }
  224.     /**
  225.      * 查询列表
  226.      *
  227.      * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
  228.      */
  229.     default List<T> list(Wrapper<T> queryWrapper) {
  230.         return getBaseMapper().selectList(queryWrapper);
  231.     }
  233.     /**
  234.      * 查询所有
  235.      *
  236.      * @see Wrappers#emptyWrapper()
  237.      */
  238.     default List<T> list() {
  239.         return list(Wrappers.emptyWrapper());
  240.     }
  242.     /**
  243.      * 翻页查询
  244.      *
  245.      * @param page         翻页对象
  246.      * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
  247.      */
  248.     default <E extends IPage<T>> E page(E page, Wrapper<T> queryWrapper) {
  249.         return getBaseMapper().selectPage(page, queryWrapper);
  250.     }
  252.     /**
  253.      * 无条件翻页查询
  254.      *
  255.      * @param page 翻页对象
  256.      * @see Wrappers#emptyWrapper()
  257.      */
  258.     default <E extends IPage<T>> E page(E page) {
  259.         return page(page, Wrappers.emptyWrapper());
  260.     }
  262.     /**
  263.      * 查询列表
  264.      *
  265.      * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
  266.      */
  267.     default List<Map<String, Object>> listMaps(Wrapper<T> queryWrapper) {
  268.         return getBaseMapper().selectMaps(queryWrapper);
  269.     }
  271.     /**
  272.      * 查询所有列表
  273.      *
  274.      * @see Wrappers#emptyWrapper()
  275.      */
  276.     default List<Map<String, Object>> listMaps() {
  277.         return listMaps(Wrappers.emptyWrapper());
  278.     }
  280.     /**
  281.      * 查询全部记录
  282.      */
  283.     default List<Object> listObjs() {
  284.         return listObjs(Function.identity());
  285.     }
  287.     /**
  288.      * 查询全部记录
  289.      *
  290.      * @param mapper 转换函数
  291.      */
  292.     default <V> List<V> listObjs(Function<? super Object, V> mapper) {
  293.         return listObjs(Wrappers.emptyWrapper(), mapper);
  294.     }
  296.     /**
  297.      * 根据 Wrapper 条件，查询全部记录
  298.      *
  299.      * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
  300.      */
  301.     default List<Object> listObjs(Wrapper<T> queryWrapper) {
  302.         return listObjs(queryWrapper, Function.identity());
  303.     }
  305.     /**
  306.      * 根据 Wrapper 条件，查询全部记录
  307.      *
  308.      * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
  309.      * @param mapper       转换函数
  310.      */
  311.     default <V> List<V> listObjs(Wrapper<T> queryWrapper, Function<? super Object, V> mapper) {
  312.         return getBaseMapper().selectObjs(queryWrapper).stream().filter(Objects::nonNull).map(mapper).collect(Collectors.toList());
  313.     }
  315.     /**
  316.      * 翻页查询
  317.      *
  318.      * @param page         翻页对象
  319.      * @param queryWrapper 实体对象封装操作类 {@link com.baomidou.mybatisplus.core.conditions.query.QueryWrapper}
  320.      */
  321.     default <E extends IPage<Map<String, Object>>> E pageMaps(E page, Wrapper<T> queryWrapper) {
  322.         return getBaseMapper().selectMapsPage(page, queryWrapper);
  323.     }
  325.     /**
  326.      * 无条件翻页查询
  327.      *
  328.      * @param page 翻页对象
  329.      * @see Wrappers#emptyWrapper()
  330.      */
  331.     default <E extends IPage<Map<String, Object>>> E pageMaps(E page) {
  332.         return pageMaps(page, Wrappers.emptyWrapper());
  333.     }
  335.     /**
  336.      * 获取对应 entity 的 BaseMapper
  337.      *
  338.      * @return BaseMapper
  339.      */
  340.     BaseMapper<T> getBaseMapper();
  342.     /**
  343.      * 获取 entity 的 class
  344.      *
  345.      * @return {@link Class<T>}
  346.      */
  347.     Class<T> getEntityClass();
  349.     /**
  350.      * 以下的方法使用介绍:
  351.      *
  352.      * 一. 名称介绍
  353.      * 1. 方法名带有 query 的为对数据的查询操作, 方法名带有 update 的为对数据的修改操作
  354.      * 2. 方法名带有 lambda 的为内部方法入参 column 支持函数式的
  355.      * 二. 支持介绍
  356.      *
  357.      * 1. 方法名带有 query 的支持以 {@link ChainQuery} 内部的方法名结尾进行数据查询操作
  358.      * 2. 方法名带有 update 的支持以 {@link ChainUpdate} 内部的方法名为结尾进行数据修改操作
  359.      *
  360.      * 三. 使用示例,只用不带 lambda 的方法各展示一个例子,其他类推
  361.      * 1. 根据条件获取一条数据: `query().eq("column", value).one()`
  362.      * 2. 根据条件删除一条数据: `update().eq("column", value).remove()`
  363.      *
  364.      */
  366.     /**
  367.      * 链式查询 普通
  368.      *
  369.      * @return QueryWrapper 的包装类
  370.      */
  371.     default QueryChainWrapper<T> query() {
  372.         return ChainWrappers.queryChain(getBaseMapper());
  373.     }
  375.     /**
  376.      * 链式查询 lambda 式
  377.      * <p>注意：不支持 Kotlin </p>
  378.      *
  379.      * @return LambdaQueryWrapper 的包装类
  380.      */
  381.     default LambdaQueryChainWrapper<T> lambdaQuery() {
  382.         return ChainWrappers.lambdaQueryChain(getBaseMapper());
  383.     }
  385.     /**
  386.      * 链式查询 lambda 式
  387.      * kotlin 使用
  388.      *
  389.      * @return KtQueryWrapper 的包装类
  390.      */
  391.     default KtQueryChainWrapper<T> ktQuery() {
  392.         return ChainWrappers.ktQueryChain(getBaseMapper(), getEntityClass());
  393.     }
  395.     /**
  396.      * 链式查询 lambda 式
  397.      * kotlin 使用
  398.      *
  399.      * @return KtQueryWrapper 的包装类
  400.      */
  401.     default KtUpdateChainWrapper<T> ktUpdate() {
  402.         return ChainWrappers.ktUpdateChain(getBaseMapper(), getEntityClass());
  403.     }
  405.     /**
  406.      * 链式更改 普通
  407.      *
  408.      * @return UpdateWrapper 的包装类
  409.      */
  410.     default UpdateChainWrapper<T> update() {
  411.         return ChainWrappers.updateChain(getBaseMapper());
  412.     }
  414.     /**
  415.      * 链式更改 lambda 式
  416.      * <p>注意：不支持 Kotlin </p>
  417.      *
  418.      * @return LambdaUpdateWrapper 的包装类
  419.      */
  420.     default LambdaUpdateChainWrapper<T> lambdaUpdate() {
  421.         return ChainWrappers.lambdaUpdateChain(getBaseMapper());
  422.     }
  424.     /**
  425.      * <p>
  426.      * 根据updateWrapper尝试更新，否继续执行saveOrUpdate(T)方法
  427.      * 此次修改主要是减少了此项业务代码的代码量（存在性验证之后的saveOrUpdate操作）
  428.      * </p>
  429.      *
  430.      * @param entity 实体对象
  431.      */
  432.     default boolean saveOrUpdate(T entity, Wrapper<T> updateWrapper) {
  433.         return update(entity, updateWrapper) || saveOrUpdate(entity);
  434.     }
  435. }

BaseMapper

  1. public interface BaseMapper<T> extends Mapper<T> {
  3.     /**
  4.      * 插入一条记录
  5.      *
  6.      * @param entity 实体对象
  7.      */
  8.     int insert(T entity);
  10.     /**
  11.      * 根据 ID 删除
  12.      *
  13.      * @param id 主键ID
  14.      */
  15.     int deleteById(Serializable id);
  17.     /**
  18.      * 根据 columnMap 条件，删除记录
  19.      *
  20.      * @param columnMap 表字段 map 对象
  21.      */
  22.     int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
  24.     /**
  25.      * 根据 entity 条件，删除记录
  26.      *
  27.      * @param queryWrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）
  28.      */
  29.     int delete(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
  31.     /**
  32.      * 删除（根据ID 批量删除）
  33.      *
  34.      * @param idList 主键ID列表(不能为 null 以及 empty)
  35.      */
  36.     int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
  38.     /**
  39.      * 根据 ID 修改
  40.      *
  41.      * @param entity 实体对象
  42.      */
  43.     int updateById(@Param(Constants.ENTITY) T entity);
  45.     /**
  46.      * 根据 whereEntity 条件，更新记录
  47.      *
  48.      * @param entity        实体对象 (set 条件值,可以为 null)
  49.      * @param updateWrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）
  50.      */
  51.     int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> updateWrapper);
  53.     /**
  54.      * 根据 ID 查询
  55.      *
  56.      * @param id 主键ID
  57.      */
  58.     T selectById(Serializable id);
  60.     /**
  61.      * 查询（根据ID 批量查询）
  62.      *
  63.      * @param idList 主键ID列表(不能为 null 以及 empty)
  64.      */
  65.     List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
  67.     /**
  68.      * 查询（根据 columnMap 条件）
  69.      *
  70.      * @param columnMap 表字段 map 对象
  71.      */
  72.     List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
  74.     /**
  75.      * 根据 entity 条件，查询一条记录
  76.      *
  77.      * @param queryWrapper 实体对象封装操作类（可以为 null）
  78.      */
  79.     T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
  81.     /**
  82.      * 根据 Wrapper 条件，查询总记录数
  83.      *
  84.      * @param queryWrapper 实体对象封装操作类（可以为 null）
  85.      */
  86.     Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
  88.     /**
  89.      * 根据 entity 条件，查询全部记录
  90.      *
  91.      * @param queryWrapper 实体对象封装操作类（可以为 null）
  92.      */
  93.     List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
  95.     /**
  96.      * 根据 Wrapper 条件，查询全部记录
  97.      *
  98.      * @param queryWrapper 实体对象封装操作类（可以为 null）
  99.      */
  100.     List<Map<String, Object>> selectMaps(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
  102.     /**
  103.      * 根据 Wrapper 条件，查询全部记录
  104.      * <p>注意： 只返回第一个字段的值</p>
  105.      *
  106.      * @param queryWrapper 实体对象封装操作类（可以为 null）
  107.      */
  108.     List<Object> selectObjs(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
  110.     /**
  111.      * 根据 entity 条件，查询全部记录（并翻页）
  112.      *
  113.      * @param page         分页查询条件（可以为 RowBounds.DEFAULT）
  114.      * @param queryWrapper 实体对象封装操作类（可以为 null）
  115.      */
  116.     <E extends IPage<T>> E selectPage(E page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
  118.     /**
  119.      * 根据 Wrapper 条件，查询全部记录（并翻页）
  120.      *
  121.      * @param page         分页查询条件
  122.      * @param queryWrapper 实体对象封装操作类
  123.      */
  124.     <E extends IPage<Map<String, Object>>> E selectMapsPage(E page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
  125. }