MyBatisPlus-基础CRUD操作

MyBatisPlus-基础CRUD操作

官网参考链接：https://baomidou.com/pages/49cc81/#service-crud-%E6%8E%A5%E5%8F%A3

工程项目续用上一篇:MyBatisPlus入门学习：利用MP代码生成器快速开发

结构图：

在application.yml文件加上日志输出可以打印sql语句

mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

Mapper CRUD 接口

说明:

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

使用：

在MpDemoApplicationTests添加方法

insert

// 插入一条记录
int insert(T entity);

@Test
void mapperInsert(){
    Singer singer=new Singer();
    singer.setName("陶喆");
    singer.setAge(22);
    singer.setOther("空无一人 这片沙滩~");
    int i = singerMapper.insert(singer);
    System.out.println("i = " + i);
}

注意返回值是int类型，返回的也不是id，返回1代表插入成功

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);

参数说明：

测试：

SelectByIdAndBatchIds()

@Test
void mapperSelectByIdAndBatchIds() {
    String id1 = "1556577794717298690";
    String id2 = "1556592930551185410";
    String id3 = "1556593922332053506";

    List<String> ids= new ArrayList<>();
    ids.add(id1);
    ids.add(id2);
    ids.add(id3);

    Singer singer = singerMapper.selectById(id1);
    System.out.println("===================根据单个id查询：\n"+singer.toString());

    List<Singer> singers = singerMapper.selectBatchIds(ids);
    System.out.println("===================根据多个id查询：");
    singers.forEach(System.out::println);
}

控制台输出：

selectOne

@Test
void mapperSelectOne() {
    QueryWrapper wrapper = new QueryWrapper<>();
    wrapper.eq("age",18);
    Singer singer = singerMapper.selectOne(wrapper);
    System.out.println("singer = " + singer.toString());
}

控制台输出：

selcetList

@Test
void mapperSelectList() {
    List<Singer> singers = singerMapper.selectList(null);
    singers.forEach(System.out::println);
}

控制台输出：

selectByMap

@Test
void mapperSelectByMap() {
    Map map=new HashMap<>();
    map.put("age",18);
    List<Singer> singers = singerMapper.selectByMap(map);
    singers.forEach(System.out::println);
}

控制台输出：

selectMaps

@Test
void mapperSelectMaps() {
    List<Map<String, Object>> maps = singerMapper.selectMaps(null);
    maps.forEach(System.out::println);
}

控制台输出：

selectObjs

注意：此方法只返回第一个字段的值

@Test
void mapperSelectObjs() {
    List<Object> objects = singerMapper.selectObjs(null);
    objects.forEach(System.out::println);
}

控制台输出：

selectPage

@Test
void mapperSelectPage() {
    IPage<Singer> singerIPage = singerMapper.selectPage(new Page<>(1,10), null);
    singerIPage.getRecords().forEach(System.out::println);
}

控制台输出：

selectMapsPage

@Test
void mapperSelectMapsPage() {
    Page<Map<String, Object>> mapPage = singerMapper.selectMapsPage(new Page<>(1, 10), null);
    mapPage.getRecords().forEach(System.out::println);
}

控制台输出：

selectCount

@Test
void mapperSelectCount() {
    Long count = singerMapper.selectCount(null);
    System.out.println("count = " + count);
}

update

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

@Test
void mapperUpdate() {
    QueryWrapper<Singer> wrapper = new QueryWrapper<>();
    wrapper.eq("age",17);
    Singer singer = singerMapper.selectOne(wrapper);
    System.out.println("singer.toString() = " + singer.toString());
    singer.setOther("改一下");
    singerMapper.update(singer,wrapper);
    System.out.println("=============================update======================================");
    List<Singer> singers = singerMapper.selectList(null);
    singers.forEach(System.out::println);
}

@Test
    void mapperUpdateById() {
        QueryWrapper<Singer> wrapper = new QueryWrapper<>();
        wrapper.eq("age",17);
        Singer singer = singerMapper.selectOne(wrapper);
        System.out.println("singer.toString() = " + singer.toString());
        singer.setOther("改回来");
        singerMapper.updateById(singer);
        System.out.println("=============================update======================================");
        List<Singer> singers = singerMapper.selectList(null);
        singers.forEach(System.out::println);
    }

delete

@Test
void mapperDelete(){
    QueryWrapper<Singer> wrapper = new QueryWrapper<>();
    wrapper.eq("age",22);
    singerMapper.delete(wrapper);
    System.out.println("=============================delete======================================");
    List<Singer> singers = singerMapper.selectList(null);
    singers.forEach(System.out::println);
}

    @Test
    void mapperDeleteBatchsIds(){
        ArrayList<String> ids = new ArrayList<>();
        ids.add("1556830638657703938");
        singerMapper.deleteBatchIds(ids);
        System.out.println("=============================delete======================================");
        List<Singer> singers = singerMapper.selectList(null);
        singers.forEach(System.out::println);
    }

    @Test
    void mapperDeleteByMap(){
        Map<String,Object> map=new HashMap<>();
        map.put("age",22);
        singerMapper.deleteByMap(map);
        System.out.println("=============================delete======================================");
        List<Singer> singers = singerMapper.selectList(null);
        singers.forEach(System.out::println);
    }

Service CRUD接口

说明:

• 通用 Service CRUD 封装IService 接口，进一步封装 CRUD 采用 get 查询单行 remove 删除 list 查询集合 page 分页 前缀命名方式区分 Mapper 层避免混淆，
• 泛型 T 为任意实体对象
• 建议如果存在自定义通用 Service 方法的可能，请创建自己的 IBaseService 继承 Mybatis-Plus 提供的基类
• 对象 Wrapper 为 条件构造器

使用

Save

// 插入一条记录（选择字段，策略插入）
boolean save(T entity);
// 插入（批量）
boolean saveBatch(Collection<T> entityList);
// 插入（批量）
boolean saveBatch(Collection<T> entityList, int batchSize);

注意：service的插入返回的是布尔类型

批次插入

SaveOrUpdate

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

//TableId 注解存在更新记录，否则插入一条记录
singerService.saveOrUpdate(singer);
singer.setAge(16);
//这里wrapper为null会更新所有数据，慎用。。。我
singerService.saveOrUpdate(singer,null);

saveOrUpdate()这里要注意：

entity如果没有id会直插入

如果有id会先查询数据有就更新没有则执行插入

如果还传了wrapper要注意null值会导致对所有数据更新

Remove

// 根据 entity 条件，删除记录
boolean remove(Wrapper<T> queryWrapper);
// 根据 ID 删除
boolean removeById(Serializable id);
// 根据 columnMap 条件，删除记录
boolean removeByMap(Map<String, Object> columnMap);
// 删除（根据ID 批量删除）
boolean removeByIds(Collection<? extends Serializable> idList);

Update

// 根据 UpdateWrapper 条件，更新记录 需要设置sqlset
boolean update(Wrapper<T> updateWrapper);
// 根据 whereWrapper 条件，更新记录
boolean update(T updateEntity, Wrapper<T> whereWrapper);
// 根据 ID 选择修改
boolean updateById(T entity);
// 根据ID 批量更新
boolean updateBatchById(Collection<T> entityList);
// 根据ID 批量更新
boolean updateBatchById(Collection<T> entityList, int batchSize);

这两和mapper没多大区别，略！

Get

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

@Test
void serviceGet(){
    QueryWrapper<Singer> wrapper=new QueryWrapper();
    Singer byId = singerService.getById("1556883204896604161");
    System.out.println("byId = " + byId);
    wrapper.eq("age",18);
    wrapper.last("LIMIT 1");
    singerService.getOne(wrapper,true);
    Singer one = singerService.getOne(wrapper);
    System.out.println("one = " + one);
}

getOne：结果集有多条会报异常

singerService.getOne(wrapper, false);

false则不报异常选择一条数据输出

或者加上wrapper.last(“LIMIT 1”);

Map getMap(Wrapper queryWrapper);

map多条返回一条数据不报错

@Test
void serviceGetMap(){
    QueryWrapper<Singer> wrapper=new QueryWrapper();
    wrapper.eq("age",18);
    Map<String, Object> map = singerService.getMap(wrapper);
    System.out.println("map = " + map);
}

// 根据 Wrapper，查询一条记录
V getObj(Wrapper queryWrapper, Function mapper);

这个没弄懂传的什么参数，后面再填坑吧。

List

// 查询所有
List<T> list();
// 查询列表
List<T> list(Wrapper<T> queryWrapper);
// 查询（根据ID 批量查询）
Collection<T> listByIds(Collection<? extends Serializable> idList);
// 查询（根据 columnMap 条件）
Collection<T> listByMap(Map<String, Object> columnMap);
// 查询所有列表
List<Map<String, Object>> listMaps();
// 查询列表
List<Map<String, Object>> listMaps(Wrapper<T> queryWrapper);
// 查询全部记录
List<Object> listObjs();
// 查询全部记录
<V> List<V> listObjs(Function<? super Object, V> mapper);
// 根据 Wrapper 条件，查询全部记录
List<Object> listObjs(Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询全部记录
<V> List<V> listObjs(Wrapper<T> queryWrapper, Function<? super Object, V> mapper);

@Test
void list(){
    List<Singer> list = singerService.list();
    QueryWrapper<Singer> wrapper=new QueryWrapper();
    wrapper.eq("age",18);
    List<Singer> list2 = singerService.list(wrapper);
    List<Map<String, Object>> maps = singerService.listMaps();
    maps.forEach(System.out::println);

    List<Map<String, Object>> maps2 = singerService.listMaps(wrapper);
    maps2.forEach(System.out::println);
}

Page

// 无条件分页查询
IPage<T> page(IPage<T> page);
// 条件分页查询
IPage<T> page(IPage<T> page, Wrapper<T> queryWrapper);
// 无条件分页查询
IPage<Map<String, Object>> pageMaps(IPage<T> page);
// 条件分页查询
IPage<Map<String, Object>> pageMaps(IPage<T> page, Wrapper<T> queryWrapper);

@Test
void page(){
    Page<Singer> page = singerService.page(new Page<>(1, 5));
    page.getRecords().forEach(System.out::println);
    Page<Map<String, Object>> mapPage = singerService.pageMaps(new Page<>(1, 5));
    mapPage.getRecords().forEach(System.out::println);
}

Count

// 查询总记录数
int count();
// 根据 Wrapper 条件，查询总记录数
int count(Wrapper<T> queryWrapper);

Chain

query

// 链式查询 普通
QueryChainWrapper<T> query();
// 链式查询 lambda 式。注意：不支持 Kotlin
LambdaQueryChainWrapper<T> lambdaQuery();

// 示例：
query().eq("column", value).one();
lambdaQuery().eq(Entity::getId, value).list();

@Test
void query(){
    Long count = singerService.query().eq("age", 18).count();
    List<Singer> list = singerService.lambdaQuery().eq(Singer::getName, "周杰伦").list();
    list.forEach(System.out::println);
}

update

// 链式更改 普通
UpdateChainWrapper<T> update();
// 链式更改 lambda 式。注意：不支持 Kotlin
LambdaUpdateChainWrapper<T> lambdaUpdate();

// 示例：
update().eq("column", value).remove();
lambdaUpdate().eq(Entity::getId, value).update(entity);

@Test
void update(){
    Singer singer = new Singer();
    singer.setName("周杰伦2");
    singer.setAge(18);
    singer.setOther("爱你穿越时间，两行来自秋末的眼泪");
    singerService.update().eq("age", 18).remove();
    singerService.lambdaUpdate().eq(Singer::getName,"周杰伦2").update(singer);
}

完整代码

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.example.mp_demo.entity.Singer;
import com.example.mp_demo.mapper.SingerMapper;
import com.example.mp_demo.service.SingerService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@SpringBootTest
class MpDemoApplicationTests {

    @Autowired
    private SingerMapper singerMapper;

    @Autowired
    private SingerService singerService;

    @Test
    void mapperInsert() {
        Singer singer = new Singer();
        singer.setName("陶喆");
        singer.setAge(22);
        singer.setOther("空无一人 这片沙滩~");
        int i = singerMapper.insert(singer);
        System.out.println("i = " + i);
    }

    @Test
    void mapperSelectById() {
        String id1 = "1556577794717298690";
        String id2 = "1556592930551185410";
        String id3 = "1556593922332053506";

        List<String> ids = new ArrayList<>();
        ids.add(id1);
        ids.add(id2);
        ids.add(id3);

        Singer singer = singerMapper.selectById(id1);
        System.out.println("===================根据单个id查询：\n" + singer.toString());

        List<Singer> singers = singerMapper.selectBatchIds(ids);
        System.out.println("===================根据多个id查询：");
        singers.forEach(System.out::println);
    }

    @Test
    void mapperSelectOne() {
        QueryWrapper<Singer> wrapper = new QueryWrapper<>();
        wrapper.eq("age",18);
        Singer singer = singerMapper.selectOne(wrapper);
        System.out.println("singer = " + singer.toString());
    }

    @Test
    void mapperSelectList() {
        List<Singer> singers = singerMapper.selectList(null);
        singers.forEach(System.out::println);
    }

    @Test
    void mapperSelectByMap() {
        Map map=new HashMap<>();
        map.put("age",18);
        List<Singer> singers = singerMapper.selectByMap(map);
        singers.forEach(System.out::println);
    }

    @Test
    void mapperSelectMaps() {
        List<Map<String, Object>> maps = singerMapper.selectMaps(null);
        maps.forEach(System.out::println);
    }

    @Test
    void mapperSelectObjs() {
        List<Object> objects = singerMapper.selectObjs(null);
        objects.forEach(System.out::println);
    }

    @Test
    void mapperSelectPage() {
        IPage<Singer> singerIPage = singerMapper.selectPage(new Page<>(1,10), null);
        singerIPage.getRecords().forEach(System.out::println);
    }

    @Test
    void mapperSelectMapsPage() {
        Page<Map<String, Object>> mapPage = singerMapper.selectMapsPage(new Page<>(1, 10), null);
        mapPage.getRecords().forEach(System.out::println);
    }

    @Test
    void mapperSelectCount() {
        Long count = singerMapper.selectCount(null);
        System.out.println("count = " + count);
    }

    @Test
    void mapperUpdate() {
        QueryWrapper<Singer> wrapper = new QueryWrapper<>();
        wrapper.eq("age",17);
        Singer singer = singerMapper.selectOne(wrapper);
        System.out.println("singer.toString() = " + singer.toString());
        singer.setOther("改一下");
        singerMapper.update(singer,wrapper);
        System.out.println("=============================update======================================");
        List<Singer> singers = singerMapper.selectList(null);
        singers.forEach(System.out::println);
    }

    @Test
    void mapperUpdateById() {
        QueryWrapper<Singer> wrapper = new QueryWrapper<>();
        wrapper.eq("age",17);
        Singer singer = singerMapper.selectOne(wrapper);
        System.out.println("singer.toString() = " + singer.toString());
        singer.setOther("改回来");
        singerMapper.updateById(singer);
        System.out.println("=============================update======================================");
        List<Singer> singers = singerMapper.selectList(null);
        singers.forEach(System.out::println);
    }

    @Test
    void mapperDelete(){
        QueryWrapper<Singer> wrapper = new QueryWrapper<>();
        wrapper.eq("age",22);
        singerMapper.delete(wrapper);
        System.out.println("=============================delete======================================");
        List<Singer> singers = singerMapper.selectList(null);
        singers.forEach(System.out::println);
    }

    @Test
    void mapperDeleteBatchsIds(){
        ArrayList<String> ids = new ArrayList<>();
        ids.add("1556830638657703938");
        singerMapper.deleteBatchIds(ids);
        System.out.println("=============================delete======================================");
        List<Singer> singers = singerMapper.selectList(null);
        singers.forEach(System.out::println);
    }

    @Test
    void mapperDeleteByMap(){
        Map<String,Object> map=new HashMap<>();
        map.put("age",22);
        singerMapper.deleteByMap(map);
        System.out.println("=============================delete======================================");
        List<Singer> singers = singerMapper.selectList(null);
        singers.forEach(System.out::println);
    }

    @Test
    void serviceSave() {
        Singer singer = new Singer();
        singer.setName("周杰伦2");
        singer.setAge(18);
        singer.setOther("爱你穿越时间，两行来自秋末的眼泪");
        boolean save = singerService.save(singer);
        System.out.println("save = " + save);
    }

    @Test
    void serviceSaveBatch() {
        Singer singer1 = new Singer();
        singer1.setName("周杰伦7");
        singer1.setAge(18);
        singer1.setOther("不懂你的黑色幽默");

        Singer singer2 = new Singer();
        singer2.setName("周杰伦8");
        singer2.setAge(18);
        singer2.setOther("周杰伦周杰伦周杰伦周杰伦周杰伦，你的完美主义太彻底");

        List<Singer> singers=new ArrayList<>();
        singers.add(singer1);
        singers.add(singer2);
        boolean save = singerService.saveBatch(singers,1);
        System.out.println("save = " + save);
        List<Singer> list = singerService.list();
        list.forEach(System.out::println);
    }

    @Test
    void serviceSaveOrUpdate(){
        Singer singer = new Singer();
        singer.setId("214124123");
        singer.setName("周杰伦001");
        singer.setAge(15);
        singer.setOther("爱像一阵风");
        singerService.saveOrUpdate(singer);
        singer.setAge(16);
       // singerService.saveOrUpdate(singer,null);
    }

    @Test
    void serviceSaveOrUpdateBatch(){

        Singer singer = new Singer();
        singer.setName("周杰伦2");
        singer.setAge(18);
        singer.setOther("爱你穿越时间，两行来自秋末的眼泪");

        Singer singer3 = new Singer();
        singer3.setName("周杰伦7");
        singer3.setAge(18);
        singer3.setOther("不懂你的黑色幽默");

        Singer singer2 = new Singer();
        singer2.setName("周杰伦8");
        singer2.setAge(18);
        singer2.setOther("周杰伦周杰伦周杰伦周杰伦周杰伦，你的完美主义太彻底");

        Singer singer4 = new Singer();
        singer4.setName("周杰伦9");
        singer4.setAge(16);
        singer4.setOther("我的城堡说欢迎光临");

        List list=new ArrayList();
        list.add(singer);
        list.add(singer2);
        list.add(singer3);
        list.add(singer4);
        singerService.saveOrUpdateBatch(list);
    }

    @Test
    void serviceGet(){
        QueryWrapper<Singer> wrapper=new QueryWrapper();
        Singer byId = singerService.getById("1556883204896604161");
        System.out.println("byId = " + byId);
        wrapper.eq("age",18);
        wrapper.last("LIMIT 1");
        singerService.getOne(wrapper,true);
        Singer one = singerService.getOne(wrapper);
        System.out.println("one = " + one);
    }

    @Test
    void serviceGetMap(){
        QueryWrapper<Singer> wrapper=new QueryWrapper();
        wrapper.eq("age",18);
        Map<String, Object> map = singerService.getMap(wrapper);
        System.out.println("map = " + map);
    }

    @Test
    void list(){
        List<Singer> list = singerService.list();
        QueryWrapper<Singer> wrapper=new QueryWrapper();
        wrapper.eq("age",18);
        List<Singer> list2 = singerService.list(wrapper);
        List<Map<String, Object>> maps = singerService.listMaps();
        maps.forEach(System.out::println);

        List<Map<String, Object>> maps2 = singerService.listMaps(wrapper);
        maps2.forEach(System.out::println);
    }

    @Test
    void page(){
        Page<Singer> page = singerService.page(new Page<>(1, 5));
        page.getRecords().forEach(System.out::println);
        Page<Map<String, Object>> mapPage = singerService.pageMaps(new Page<>(1, 5));
        mapPage.getRecords().forEach(System.out::println);
    }

    @Test
    void query(){
        Long count = singerService.query().eq("age", 18).count();
        List<Singer> list = singerService.lambdaQuery().eq(Singer::getName, "周杰伦").list();
        list.forEach(System.out::println);
    }

    @Test
    void update(){
        Singer singer = new Singer();
        singer.setName("周杰伦2");
        singer.setAge(18);
        singer.setOther("爱你穿越时间，两行来自秋末的眼泪");
        singerService.update().eq("age", 18).remove();
        singerService.lambdaUpdate().eq(Singer::getName,"周杰伦2").update(singer);
    }
}