小程序开发定制使用Mybatis-plus清空表数据

方法一:

  1. public interface userInfoMapper extends BaseMapper<UserInfo> {
  2. //小程序开发定制清空指定表
  3. @Update("truncate table user")
  4. void deleteUserTemp();
  5. }

 方法二:

小程序开发定制直接使用自带的remove接口 ,同时使用QueryWrapper参数如:

userInfoTempService.remove(new QueryWrapper<>())

引申一下 Mybatis-plus小程序开发定制这个好用的框架:

我们知道 小程序开发定制是一个基于 java 小程序开发定制的持久层框架,小程序开发定制它内部封装了 jdbc,极大提高了我们的开发效率。
但是使用 Mybatis 开发也有很多痛点:
每个 Dao 接口都需要自己定义一堆增删改查方法:

  1. public interface UserDao {
  2. // 获取所有用户信息
  3. List<User> getUserList();
  4. // 根绝 id 获取用户信息
  5. User getUserById(int id);
  6. // 新增用户信息
  7. boolean add(User user);
  8. // 更新用户信息
  9. boolean update(User user);
  10. // 删除用户信息
  11. boolean delete(int id);
  12. }

每个 Mapper 文件都需要写一堆基本的增删改查语句。

3.如果查询的列表需要分页,我们还需要给查询方法封装成分页对象。

你可能会说:Mybatis 还能有痛点?用着多方便!

对于小项目而言,用着确实还行。但是遇到大项目,光 Dao 接口都有几百个,如果还要手动定义一堆增删改查方法和 sql 语句,那也很浪费时间。

那有没有这样一个框架:

1.封装了 Mybatis,自带 CRUD 方法,我们不需要自己定义 CRUD 方法。

2.提供各种查询方法,不需要在 mapper 文件中写一些基础的 sql 语句。

3.封装了分页功能,让分页查询无比丝滑。

有的,MybatisPlus 闪亮登场。
依赖:

  1. <!-- mybatis-plus 依赖-->
  2. <dependency>
  3. <groupId>com.baomidou</groupId>
  4. <artifactId>mybatis-plus-boot-starter</artifactId>
  5. <version>3.4.0</version>
  6. </dependency>

 -----------------------------------------------------------------------------------------------------------

MybatisPlus常用API-增删改查

 Get

  1. // 根据 ID 查询
  2. T getById(Serializable id);
  3. // 根据 Wrapper,查询一条记录。结果集,如果是多个会抛出异常,随机取一条加上限制条件 wrapper.last("LIMIT 1")
  4. T getOne(Wrapper<T> queryWrapper);
  5. // 根据 Wrapper,查询一条记录
  6. T getOne(Wrapper<T> queryWrapper, boolean throwEx);
  7. // 根据 Wrapper,查询一条记录
  8. Map<String, Object> getMap(Wrapper<T> queryWrapper);
  9. // 根据 Wrapper,查询一条记录
  10. <V> V getObj(Wrapper<T> queryWrapper, Function<? super Object, V> mapper);

Save

  1. // 插入一条记录(选择字段,策略插入)
  2. boolean save(T entity);
  3. // 插入(批量)
  4. boolean saveBatch(Collection<T> entityList);
  5. // 插入(批量)
  6. boolean saveBatch(Collection<T> entityList, int batchSize);

SaveOrUpdate

  1. // TableId 注解存在更新记录,否插入一条记录
  2. boolean saveOrUpdate(T entity);
  3. // 根据updateWrapper尝试更新,否继续执行saveOrUpdate(T)方法
  4. boolean saveOrUpdate(T entity, Wrapper<T> updateWrapper);
  5. // 批量修改插入
  6. boolean saveOrUpdateBatch(Collection<T> entityList);
  7. // 批量修改插入
  8. boolean saveOrUpdateBatch(Collection<T> entityList, int batchSize);

Remove

  1. // 根据 entity 条件,删除记录
  2. boolean remove(Wrapper<T> queryWrapper);
  3. // 根据 ID 删除
  4. boolean removeById(Serializable id);
  5. // 根据 columnMap 条件,删除记录
  6. boolean removeByMap(Map<String, Object> columnMap);
  7. // 删除(根据ID 批量删除)
  8. boolean removeByIds(Collection<? extends Serializable> idList);

 Update

  1. // 根据 UpdateWrapper 条件,更新记录 需要设置
  2. boolean update(Wrapper<T> updateWrapper);
  3. // 根据 whereWrapper 条件,更新记录
  4. boolean update(T updateEntity, Wrapper<T> whereWrapper);
  5. // 根据 ID 选择修改
  6. boolean updateById(T entity);
  7. // 根据ID 批量更新
  8. boolean updateBatchById(Collection<T> entityList);
  9. // 根据ID 批量更新
  10. boolean updateBatchById(Collection<T> entityList, int batchSize);

List

  1. // 查询所有
  2. List<T> list();
  3. // 查询列表
  4. List<T> list(Wrapper<T> queryWrapper);
  5. // 查询(根据ID 批量查询)
  6. Collection<T> listByIds(Collection<? extends Serializable> idList);
  7. // 查询(根据 columnMap 条件)
  8. Collection<T> listByMap(Map<String, Object> columnMap);
  9. // 查询所有列表
  10. List<Map<String, Object>> listMaps();
  11. // 查询列表
  12. List<Map<String, Object>> listMaps(Wrapper<T> queryWrapper);
  13. // 查询全部记录
  14. List<Object> listObjs();
  15. // 查询全部记录
  16. <V> List<V> listObjs(Function<? super Object, V> mapper);
  17. // 根据 Wrapper 条件,查询全部记录
  18. List<Object> listObjs(Wrapper<T> queryWrapper);
  19. // 根据 Wrapper 条件,查询全部记录
  20. <V> List<V> listObjs(Wrapper<T> queryWrapper, Function<? super Object, V> mapper);

Page

  1. // 无条件分页查询
  2. IPage<T> page(IPage<T> page);
  3. // 条件分页查询
  4. IPage<T> page(IPage<T> page, Wrapper<T> queryWrapper);
  5. // 无条件分页查询
  6. IPage<Map<String, Object>> pageMaps(IPage<T> page);
  7. // 条件分页查询
  8. IPage<Map<String, Object>> pageMaps(IPage<T> page, Wrapper<T> queryWrapper);

Count

  1. // 查询总记录数
  2. int count();
  3. // 根据 Wrapper 条件,查询总记录数
  4. int count(Wrapper<T> queryWrapper);

query

  1. // 链式查询 普通
  2. QueryChainWrapper<T> query();
  3. // 链式查询 lambda 式。注意:不支持 Kotlin
  4. LambdaQueryChainWrapper<T> lambdaQuery();
  5. // 示例:
  6. query().eq("column", value).one();
  7. lambdaQuery().eq(Entity::getId, value).list();

update

  1. // 链式更改 普通
  2. UpdateChainWrapper<T> update();
  3. // 链式更改 lambda 式。注意:不支持 Kotlin
  4. LambdaUpdateChainWrapper<T> lambdaUpdate();
  5. // 示例:
  6. update().eq("column", value).remove();
  7. lambdaUpdate().eq(Entity::getId, value).update(entity);

Delete

  1. // 根据 entity 条件,删除记录
  2. int delete(@Param(Constants.WRAPPER) Wrapper<T> wrapper);
  3. // 删除(根据ID 批量删除)
  4. int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
  5. // 根据 ID 删除
  6. int deleteById(Serializable id);
  7. // 根据 columnMap 条件,删除记录
  8. int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);

Select

  1. // 根据 ID 查询
  2. T selectById(Serializable id);
  3. // 根据 entity 条件,查询一条记录
  4. T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
  5. // 查询(根据ID 批量查询)
  6. List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
  7. // 根据 entity 条件,查询全部记录
  8. List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
  9. // 查询(根据 columnMap 条件)
  10. List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
  11. // 根据 Wrapper 条件,查询全部记录
  12. List<Map<String, Object>> selectMaps(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
  13. // 根据 Wrapper 条件,查询全部记录。注意: 只返回第一个字段的值
  14. List<Object> selectObjs(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
  15. // 根据 entity 条件,查询全部记录(并翻页)
  16. IPage<T> selectPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
  17. // 根据 Wrapper 条件,查询全部记录(并翻页)
  18. IPage<Map<String, Object>> selectMapsPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
  19. // 根据 Wrapper 条件,查询总记录数
  20. Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

网站建设定制开发 软件系统开发定制 定制软件开发 软件开发定制 定制app开发 app开发定制 app开发定制公司 电商商城定制开发 定制小程序开发 定制开发小程序 客户管理系统开发定制 定制网站 定制开发 crm开发定制 开发公司 小程序开发定制 定制软件 收款定制开发 企业网站定制开发 定制化开发 android系统定制开发 定制小程序开发费用 定制设计 专注app软件定制开发 软件开发定制定制 知名网站建设定制 软件定制开发供应商 应用系统定制开发 软件系统定制开发 企业管理系统定制开发 系统定制开发