首页 > 其他分享 >MyBatis-Plus【通用Mapper篇】

MyBatis-Plus【通用Mapper篇】

时间：2022-09-30 11:10:38浏览次数：54  
标签：Mapper queryWrapper Param Plus Wrapper MyBatis param Constants user


MP-通用Mapper

一、通用Mapper

在MyBatis-Plus里面，可以实现对数据库的CRUD操作，官方对通用Mapper的解释如下说明:

通用 CRUD 封装BaseMapper (opens new window)接口，为 Mybatis-Plus 启动时自动解析实体表关系映射转换为 Mybatis 内部对象注入容器，
1、泛型 T 为​​任意实体对象​​​，
2、参数 Serializable 为任意类型主键 Mybatis-Plus ​​不推荐使用复合主键约定每一张表都有自己的唯一 id 主键​​​，
3、对象 Wrapper 为 ​​条件构造器​​

MyBatis-Plus【通用Mapper篇】_主键


这张图的大致含义就是 MyBatis-PLUS利用注解，核心模块和生成器等组件，来完成对实体的扫描，自动映射解析实体对象，完成表名与列名的对应关系。通过封装的SQL语句，最终完成 CRUD操作。

二、使用方式

在Mapper的接口上需要继承一个BaseMapper的接口，其泛型为操作的数据库表对应的pojo类。

@Repository("userMapper")
public interface UserMapper extends BaseMapper<User>{
}

1、源码分析

BaseMapper的源码如下所示，

public interface BaseMapper<T> extends Mapper<T> {

    /**
     * 插入一条记录
     *
     * @param entity 实体对象
     */
    int insert(T entity);

    /**
     * 根据 ID 删除
     *
     * @param id 主键ID
     */
    int deleteById(Serializable id);

    /**
     * 根据实体(ID)删除
     *
     * @param entity 实体对象
     * @since 3.4.4
     */
    int deleteById(T entity);

    /**
     * 根据 columnMap 条件，删除记录
     *
     * @param columnMap 表字段 map 对象
     */
    int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);

    /**
     * 根据 entity 条件，删除记录
     *
     * @param queryWrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）
     */
    int delete(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

    /**
     * 删除（根据ID或实体 批量删除）
     *
     * @param idList 主键ID列表或实体列表(不能为 null 以及 empty)
     */
    int deleteBatchIds(@Param(Constants.COLLECTION) Collection<?> idList);

    /**
     * 根据 ID 修改
     *
     * @param entity 实体对象
     */
    int updateById(@Param(Constants.ENTITY) T entity);

    /**
     * 根据 whereEntity 条件，更新记录
     *
     * @param entity        实体对象 (set 条件值,可以为 null)
     * @param updateWrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）
     */
    int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> updateWrapper);

    /**
     * 根据 ID 查询
     *
     * @param id 主键ID
     */
    T selectById(Serializable id);

    /**
     * 查询（根据ID 批量查询）
     *
     * @param idList 主键ID列表(不能为 null 以及 empty)
     */
    List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);

    /**
     * 查询（根据 columnMap 条件）
     *
     * @param columnMap 表字段 map 对象
     */
    List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);

    /**
     * 根据 entity 条件，查询一条记录
     * <p>查询一条记录，例如 qw.last("limit 1") 限制取一条记录, 注意：多条数据会报异常</p>
     *
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     */
    default T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper) {
        List<T> ts = this.selectList(queryWrapper);
        if (CollectionUtils.isNotEmpty(ts)) {
            if (ts.size() != 1) {
                throw ExceptionUtils.mpe("One record is expected, but the query result is multiple records");
            }
            return ts.get(0);
        }
        return null;
    }

    /**
     * 根据 Wrapper 条件，判断是否存在记录
     *
     * @param queryWrapper 实体对象封装操作类
     * @return
     */
    default boolean exists(Wrapper<T> queryWrapper) {
        Long count = this.selectCount(queryWrapper);
        return null != count && count > 0;
    }

    /**
     * 根据 Wrapper 条件，查询总记录数
     *
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     */
    Long selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

    /**
     * 根据 entity 条件，查询全部记录
     *
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     */
    List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

    /**
     * 根据 Wrapper 条件，查询全部记录
     *
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     */
    List<Map<String, Object>> selectMaps(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

    /**
     * 根据 Wrapper 条件，查询全部记录
     * <p>注意： 只返回第一个字段的值</p>
     *
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     */
    List<Object> selectObjs(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

    /**
     * 根据 entity 条件，查询全部记录（并翻页）
     *
     * @param page         分页查询条件（可以为 RowBounds.DEFAULT）
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     */
    <P extends IPage<T>> P selectPage(P page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

    /**
     * 根据 Wrapper 条件，查询全部记录（并翻页）
     *
     * @param page         分页查询条件
     * @param queryWrapper 实体对象封装操作类
     */
    <P extends IPage<Map<String, Object>>> P selectMapsPage(P page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
}

1️⃣Insert 插入方法

参数说明：

类型

参数名

描述

T

Entity

实体对象

案例演示：

@Test
  public void test2() {
    // 新增用户信息 INSERT INTO user ( id, name, age, email ) VALUES ( ?, ?, ?, ? )
    User user = new User("joker",23,"[email protected]");
    int insert = userMapper.insert(user);
    System.out.println("成功插入"+insert+"条数据");
    // 在MyBatis里默认是使用雪花算法创建id 不会默认使用数据库里面的自增主键
    System.out.println("id:"+user.getId());
  }

注意：如果未设置主键，MyBatis-plus则会使用雪花算法自动生成一个随机的Long型的的主键

2️⃣Delete 删除方法

方法介绍：

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

参数说明：

类型

参数名

描述

Wrapper

wrapper

实体对象封装操作类（可以为 null）

Collection<? extends Serializable>

idList

主键 ID 列表(不能为 null 以及 empty)

Serializable

id

主键 ID

Map<String, Object>

columnMap

表字段 map 对象

案例演示：
1、delete

@Test
  public void test() {
    // 根据 entity 条件，删除记录
    //int delete(@Param(Constants.WRAPPER) Wrapper<T> wrapper);
    User user = new User();
    user.setId(13L);
    Wrapper<User> wrapper = new UpdateWrapper<>(user);

    int delete = userMapper.delete(wrapper);
    System.out.println("删除了"+delete+"条数据");
  }

2、deleteBatchIds：

@Test
  public void test5() {
    // 批量删除 DELETE FROM user WHERE id IN ( ? , ? )
    Collection<Long> ids = new ArrayList<>();
    ids.add(5L);
    ids.add(2L);
    int deleteBatchIds = userMapper.deleteBatchIds(ids);
    System.out.println("删除了"+deleteBatchIds+"条数据");
  }

3、deleteById

@Test
  public void test3() {
    // 根据id删除 DELETE FROM user WHERE id=?
    int deleteById = userMapper.deleteById(1529380500983910401L); 
    System.out.println("成功删除"+deleteById);
  }

4、deleteByMap

@Test
  public void test4() {
    // 根据条件删除数据 可以删除多个 DELETE FROM user WHERE name = ? AND age = ?
    Map<String, Object> map = new HashMap<>();
    map.put("name", "张三");
    map.put("age", 23);
    int deleteByMap = userMapper.deleteByMap(map);
    System.out.println("删除了"+deleteByMap);
  }

3️⃣Update 修改方法

// 根据 whereWrapper 条件，更新记录
int update(@Param(Constants.ENTITY) T updateEntity, @Param(Constants.WRAPPER) Wrapper<T> whereWrapper);
// 根据 ID 修改
int updateById(@Param(Constants.ENTITY) T entity);

参数说明：

类型

参数名

描述

T

entity

实体对象 (set 条件值,可为 null)

Wrapper

updateWrapper

实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）

案例演示：
1、Update

@Test
  public void testupdate() {
    // 根据id修改数据 UPDATE user SET name=?, age=?, email=? WHERE id=?
    User user  = new User(1L,"koppy",25,"[email protected]");
    User wrapperUser = new User();
    wrapperUser.setId(1L);
    Wrapper<User> wrapper = new UpdateWrapper<>(wrapperUser);
    int updateById = userMapper.update(user, wrapper);
    System.out.println("修改了"+updateById+"条数据");
  }

2、updateById

@Test
  public void test6() {
    // 根据id修改数据 UPDATE user SET name=?, age=?, email=? WHERE id=?
    User user  = new User(1L,"koppy",45,"[email protected]");
    int updateById = userMapper.updateById(user);
    System.out.println("修改了"+updateById+"条数据");
  }

4️⃣ Select 查询方法

// 根据 ID 查询
T selectById(Serializable id);
// 根据 entity 条件，查询一条记录
T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

// 查询（根据ID 批量查询）
List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
// 根据 entity 条件，查询全部记录
List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 查询（根据 columnMap 条件）
List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
// 根据 Wrapper 条件，查询全部记录
List<Map<String, Object>> selectMaps(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询全部记录。注意： 只返回第一个字段的值
List<Object> selectObjs(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

// 根据 entity 条件，查询全部记录（并翻页）
IPage<T> selectPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询全部记录（并翻页）
IPage<Map<String, Object>> selectMapsPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询总记录数
Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

参数说明：

类型

参数名

描述

Serializable

id

主键 ID

Wrapper

queryWrapper

实体对象封装操作类（可以为 null）

Collection<? extends Serializable>

idList

主键 ID 列表(不能为 null 以及 empty)

Map<String, Object>

columnMap

表字段 map 对象

IPage

page

分页查询条件（可以为 RowBounds.DEFAULT）

案例演示：
1、selectById

@Test
  public void testSelect() {
    User user = userMapper.selectById(1L);
    System.out.println(user);
  }

MyBatis-Plus【通用Mapper篇】_java_02


2、selectOne

@Test
  public void TestSelectOne() {
    User user  =new User();
    user.setAge(18);
    Wrapper<User> queWrapper  =new QueryWrapper<>(user);
    
    User selectOne = userMapper.selectOne(queWrapper);
    System.out.println(selectOne);
  }

注意：在使用SelectOne的方法的时候，需要注意的是！！！selectOne中方法如果查出多条数据，则会抛出一个警告，但是不会报错，原因就是SelectOne的底层中，对查询结果进行了一个判断，如果将结果>1则会抛出warn，否则会返回第一个查询结果

selectOne的底层源码:

/**
     * 根据 entity 条件，查询一条记录
     * <p>查询一条记录，例如 qw.last("limit 1") 限制取一条记录, 注意：多条数据会报异常</p>
     *
     * @param queryWrapper 实体对象封装操作类（可以为 null）
     */
    default T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper) {
        List<T> ts = this.selectList(queryWrapper);
        if (CollectionUtils.isNotEmpty(ts)) {
            if (ts.size() != 1) {
                throw ExceptionUtils.mpe("One record is expected, but the query result is multiple records");
            }
            return ts.get(0);
        }
        return null;
    }

**还要额外说明一点：我用的是MP的最新版本，不会像网上说的抛出警告，可能旧版本会吧，这个还需要看源码
3、selectByPage 不带条件的查询

@Test
  public void selectByPage() {
    Page<User> page = new Page<>();
    page.setCurrent(1);
    page.setSize(5);
    User user = new User();
    user.setAge(15);
    Wrapper<User> wrapper  =new QueryWrapper<>();
    
    Page<User> page2 = userMapper.selectPage(page, null);
    List<User> list = page2.getRecords();
    for (User user2 : list) {
      System.out.println(user2);
    }
  }

MyBatis-Plus【通用Mapper篇】_数据_03


selectMapsPage带条件的查询

@Test
  public void testSelectMapsPage() {
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    // 返回指定列，这里是数据库的字段，而不是实体类的属性
    queryWrapper.select("id", "name", "age", "email");
    Map<String, Object> paramMaps = new HashMap<>();
    paramMaps.put("age",21);
    queryWrapper.allEq(paramMaps);
    Page<Map<String, Object>> page = new Page<>(1, 5);
    // 第1个参数：分页参数 第2个参数：条件查询包装参数——指定了返回哪些列
    Page<Map<String, Object>> pageParam = userMapper.selectMapsPage(page, queryWrapper);
    List<Map<String, Object>> records = pageParam.getRecords();
    records.forEach(System.out::println);
    System.out.println("总页数："+pageParam.getPages()); // 总页数
    System.out.println("总记录数："+pageParam.getTotal()); // 总记录数
    System.out.println("当前页码："+pageParam.getCurrent()); // 当前页码
    System.out.println("每页记录数："+pageParam.getSize()); // 每页记录数
    System.out.println("是否有下一页："+pageParam.hasNext()); // 是否有下一页
    System.out.println("是否有上一页"+pageParam.hasPrevious()); // 是否有上一页
  }

MyBatis-Plus【通用Mapper篇】_java_04


标签：Mapper,queryWrapper,Param,Plus,Wrapper,MyBatis,param,Constants,user
From： https://blog.51cto.com/u_14957231/5725610

相关文章

  • MyBatis-Plus【启程篇】
    Mybatis-Plu只为增强而生​​一、初始MyBatis-Plus​​​​二、如何使用​​​​1、环境准备​​​​2、新建数据库​​​​3、新建SpringBoot项目，并前期工作​​​​4、编......
  • MyBatis-缓存
    MyBatis缓存缓存的目的就是为了提高执行效率**内存：**不能永久存储数据，我们都知道内存他是​​断电即丢失​​​的，我们要想把数据永久存储，可以写入到磁盘上，但是缺点就是慢，而......
  • MyBatis加载Mapper映射文件的方式
    MyBatis加载Mapper的映射文件的方式我们都知道MyBatis是一款半自动的ORM框架，它的特点就是具有灵活的sql操作MyBatis是利用mapper的映射文件，来将数据库的中字段与Java的属性......
  • MYBatis-动态SQL
    MyBatis动态SQL什么是动态SQL?官方给出动态SQL的解释是一个基于OGNL的表达式，MyBatis3替换了之前的大部分元素，大大精简了元素种类，现在要学习的元素种类比原来的一半还要少......
  • MyBatis批量修改-Oracel
    MyBatis批量修改再利用MyBatis操作Oracle实现批量的修改操做的时候，需要用到存储过程的知识点批量修改，不同于批量的插入，批量修改可以同时操作不同表，但是如何保证他们是在同......
  • MyBatis-Plus 条件查询器
    MyBatis-Plus剩余内容​​本篇的主要代码依赖于之前的通用Mapper和通用Service篇​​前两个星期忙着转正的事情，比较忙。所以快两个周每太更新博客，这周末抓紧时间把剩余的MP......
  • SpringBoot之Mybatis开启SQL记录和Pagehelper
    配置mybatismybatis:#mapper路径mapper-locations:classpath:mapper/*.xmlconfiguration:#日志输出log-impl:org.apache.ibatis.logging.stdout.StdO......
  • MyBatis
    1.概念Mybatis是一款半ORM（对象关系映射）的持久层框架，支持定制化SQL、存储过程以及高级映射。避免了几乎所有的JDBC代码和手动设置参数及获取结果集。可以使用注解或......
  • Mybatis学习
    什么是Mybatis?看官网的定义：MyBatis是一款优秀的持久层框架，它支持自定义SQL、存储过程以及高级映射。MyBatis免除了几乎所有的JDBC代码以及设置参数和获取结果集的......
  • Mybatis（2022-09-29）
    SSMSpringMVC+Spring+Mybatis3SpringMVC：充当的就是Servlet的角色。可以理解为SpringMVC是Spring的WEB支持。1Mybatis：充当的就是Dao层。2Spring：充当的时一个润滑油......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99