• 使用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这个好用的框架:

    我们知道 MyBatis 是一个基于 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 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 page);
    7. // 条件分页查询
    8. IPage<Map<String, Object>> pageMaps(IPage page, Wrapper queryWrapper);

    Count

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

    query

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

    update

    1. // 链式更改 普通
    2. UpdateChainWrapper update();
    3. // 链式更改 lambda 式。注意:不支持 Kotlin
    4. LambdaUpdateChainWrapper 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 wrapper);
    3. // 删除(根据ID 批量删除)
    4. int deleteBatchIds(@Param(Constants.COLLECTION) Collection idList);
    5. // 根据 ID 删除
    6. int deleteById(Serializable id);
    7. // 根据 columnMap 条件,删除记录
    8. int deleteByMap(@Param(Constants.COLUMN_MAP) Map 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 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 page, @Param(Constants.WRAPPER) Wrapper queryWrapper);
    19. // 根据 Wrapper 条件,查询总记录数
    20. Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

    Java中QueryWrapper的常用方法

    queryWrapper.lt()——小于
    queryWrapper.le()——小于等于
    queryWrapper.gt()——大于
    queryWrapper.ge()——大于等于
    queryWrapper.eq()——等于
    queryWrapper.ne()——不等于
    queryWrapper.betweeen(“age”,10,20)——age在值10到20之间
    queryWrapper.notBetweeen(“age”,10,20)——age不在值10到20之间
    queryWrapper.like(“属性”,“值”)——模糊查询匹配值‘%值%’
    queryWrapper.notLike(“属性”,“值”)——模糊查询不匹配值‘%值%’
    queryWrapper.likeLeft(“属性”,“值”)——模糊查询匹配最后一位值‘%值’
    queryWrapper.likeRight(“属性”,“值”)——模糊查询匹配第一位值‘值%’
    queryWrapper.isNull()——值为空或null
    queryWrapper.isNotNull()——值不为空或null
    queryWrapper.in(“属性”,条件,条件 )——符合多个条件的值
    queryWrapper.notIn(“属性”,条件,条件 )——不符合多个条件的值
    queryWrapper.or()——或者
    queryWrapper.and()——和
    queryWrapper.orderByAsc(“属性”)——根据属性升序排序
    queryWrapper.orderByDesc(“属性”)——根据属性降序排序
    queryWrapper.inSql(“sql语句”)——符合sql语句的值
    queryWrapper.notSql(“sql语句”)——不符合SQL语句的值
    queryWrapper.esists(“SQL语句”)——查询符合SQL语句的值
    queryWrapper.notEsists(“SQL语句”)——查询不符合SQL语句的值

  • 相关阅读:
    vue实现CBC加密/解密
    表格制作软件排行榜,热门做表格的软件推荐
    【智能优化算法】基于Jaya算法求解单目标优化问题附matlab代码MOJAYA
    spring boot社区购物小程序毕业设-附源码291720
    日志冲突怎么解决?slf4j和log4j的区别?看完这一篇,这些都是小意思啦
    宝贝详情页接口及关键词搜索商品
    拿什么拯救你?这暴热的天气!只能用python分析做个可视化康康
    vulnhub靶场 Kioptrix-level-1
    学习笔记7--卫星定位技术(下)
    子序列 --- 编辑距离
  • 原文地址:https://blog.csdn.net/Alex_81D/article/details/127124805