通用 Service CRUD 封装IService接口，它采用get（查询单行）、list（查询集合）、page（分页查询）、save（插入）、update（更新）、remove（删除），前缀命名方式区分 Mapper 层接口避免混淆。通用Service的使用场景是，如果方法很简单，例如，就是一个插入，或者根据条件更新，就不用在再Service写方法了，使用通用Service提供的方法即可。如果有较多的业务逻辑，一般在service中自定义方法，自己的service继承通用service。定义方法中，使用通用service要注入mapper。

同时 Service 还提供了一些批量方法（批量插入、批量删除、批量更新数据），这是 Mapper 没有的。

1、相关前提步骤

1)、定义一个接口继承 IService接口

package com.exerciseitems.mybatisplus.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.exerciseitems.mybatisplus.entity.User;

/**
 * @author : [LiuYanQiang]
 * @version : [v1.0]
 * @className : UserService
 * @description : [服务业务类]
 * @createTime : [2021/9/15 18:52]
 * @updateUser : [LiuYanQiang]
 * @updateTime : [2021/9/15 18:52]
 * @updateRemark : [描述说明本次修改内容]
 */
public interface UserService extends IService<User> {
}

2)、定义一个实现类，实现自定义的接口UserService之前要继承IService的实现类ServiceImpl

package com.exerciseitems.mybatisplus.service.Impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.exerciseitems.mybatisplus.entity.User;
import com.exerciseitems.mybatisplus.mapper.UserMapper;
import com.exerciseitems.mybatisplus.service.UserService;
import org.springframework.stereotype.Service;

/**
 * @author : [LiuYanQiang]
 * @version : [v1.0]
 * @className : UserServiceImpl
 * @description : [service实现类，需要继承MybatisPlus提供的service基类
 *                  IService:mp提供的接口。ServiceImpl:MybatisPlus提供的接口实现类。
 *                  ServiceImpl<BaseMapper<T>, T>是IService 的实现类。]
 * @createTime : [2021/9/15 18:57]
 * @updateUser : [LiuYanQiang]
 * @updateTime : [2021/9/15 18:57]
 * @updateRemark : [描述说明本次修改内容]
 */
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper,User> implements UserService {
}

3)、测试类注入自定义UserService 接口

package com.exerciseitems.mybatisplus.mapper;

import com.exerciseitems.mybatisplus.entity.User;
import com.exerciseitems.mybatisplus.service.UserService;
import jdk.nashorn.internal.ir.CallNode;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;

import static jdk.nashorn.internal.runtime.regexp.joni.Config.log;

/**
 * @author : [LiuYanQiang]
 * @version : [v1.0]
 * @className : UserServiceTest
 * @description : [测试类]
 * @createTime : [2021/9/15 19:15]
 * @updateUser : [LiuYanQiang]
 * @updateTime : [2021/9/15 19:15]
 * @updateRemark : [描述说明本次修改内容]
 */
@SpringBootTest
public class UserServiceTest {

    @Autowired
    private UserService userService;
}

4)、后面就可以进行相关的CRUD的操作了

注，后面实体类使用链式的链式操作需要在实体类上加入注解

//意思是访问器允许链式操作 
@Accessors(chain = true)

2、增

1)、save方法（插入一条数据）

（1）、官方提供的接口说明

// 插入一条记录（选择字段，策略插入）
boolean save(T entity);

参数说明

类型	参数名	描述
T	entity	实体对象

（2）、实现方式

    /*
     * @version V1.0
     * Title: save
     * @author LiuYanQiang
     * @description 保存方法
     * @createTime  2021/9/15 20:31
     * @param []
     * @return void
     * ==>  Preparing: INSERT INTO user ( id, name, age, gender, create_time, update_time ) VALUES ( ?, ?, ?, ?, ?, ? )
     * ==> Parameters: 1439062553530548226(String), 张三(String), 24(Integer), 男(String), 2021-09-18 11:03:43.911(Timestamp), 2021-09-18 11:03:43.911(Timestamp)
     */
    @Test
    public void save(){
        User user = new User();
        user.setName("张三");
        user.setAge(24);
        user.setGender("男");
        System.out.println(userService.save(user));
    }

2)、saveBatch方法（批量插入数据）

（1）、官方提供的接口说明

// 插入（批量）
boolean saveBatch(Collection<T> entityList);
// 插入（批量）
boolean saveBatch(Collection<T> entityList, int batchSize);

参数说明

类型	参数名	描述
Collection<T>	entityList	实体对象集合
int	batchSize	插入批次数量

（2）、实现方式

    /*
     * @version V1.0
     * Title: saveBatch
     * @author LiuYanQiang
     * @description 批量插入
     * @createTime  2021/9/15 20:50
     * @param list 实体对象集合
     * @return 
     * ==>  Preparing: INSERT INTO user ( id, name, age, gender, create_time, update_time ) VALUES ( ?, ?, ?, ?, ?, ? ) 
     * ==> Parameters: 1439062885954277377(String), 王五(String), 22(Integer), 男(String), 2021-09-18 11:05:03.166(Timestamp), 2021-09-18 11:05:03.167(Timestamp)
     * ==> Parameters: 1439062887074156546(String), 赵六(String), 23(Integer), 男(String), 2021-09-18 11:05:03.437(Timestamp), 2021-09-18 11:05:03.438(Timestamp)
     */
    @Test
    public void saveBatch() {
        List<User> list=new ArrayList<>();
        list.add(new User().setName("王五").setAge(22).setGender("男"));
        list.add(new User().setName("赵六").setAge(23).setGender("男"));
        userService.saveBatch(list,2);
    }

3)、saveOrUpdate方法（插入数据或更新数据）

（1）、官方提供的接口说明

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

参数说明

类型	参数名	描述
T	entity	实体对象
Wrapper<T>	updateWrapper	实体对象封装操作类 UpdateWrapper

（2）、实现方式

 /*
     * @version V1.0
     * Title: saveOrUpdate
     * @author LiuYanQiang
     * @description 插入或修改(当有主键id存在的时候为修改update，当无主键是增加insert)
     * @createTime  2021/9/15 20:53
     * @param list 实体对象集合
     * @return
     * ==>  Preparing: UPDATE user SET name=?, age=?, gender=?, update_time=? WHERE id=? AND is_delete=0
     * ==> Parameters: 刘二(String), 13(Integer), 女(String), 2021-09-18 11:08:25.246(Timestamp), 4(String)
     * ==>  Preparing: INSERT INTO user ( id, name, age, gender, create_time, update_time ) VALUES ( ?, ?, ?, ?, ?, ? )
     * ==> Parameters: 1439064032395919361(String), 张三(String), 23(Integer), 男(String), 2021-09-18 11:09:36.502(Timestamp), 2021-09-18 11:09:36.502(Timestamp)
     */
    @Test
    public void saveOrUpdate() {
        User user = new User();
        //添加或修改，同一时间只能进行一项操作
        //此修改
        user.setId("4").setName("刘二").setAge(13).setGender("女");
        //此添加
        user.setName("张三").setAge(23).setGender("男");
        userService.saveOrUpdate(user);
    }

4)、saveOrUpdateBatch方法（批量插入数据或更新数据）

（1）、官方提供的接口说明

// TableId 注解存在更新记录，否插入一条记录
// 批量修改插入
boolean saveOrUpdateBatch(Collection<T> entityList);
// 批量修改插入
boolean saveOrUpdateBatch(Collection<T> entityList, int batchSize);

参数说明

类型	参数名	描述
Collection<T>	entityList	实体对象集合
int	batchSize	插入批次数量

（2）、实现方式

    /*
     * @version V1.0
     * Title: saveOrUpdateBatch
     * @author LiuYanQiang
     * @description 批量插入或批量修改(当有主键id存在的时候为修改update，当无主键是增加insert)
     * @createTime  2021/9/15 20:53
     * @param list 实体对象集合
     * @return
     * ==>  Preparing: INSERT INTO user ( id, name, age, gender, create_time, update_time ) VALUES ( ?, ?, ?, ?, ?, ? )
     * ==> Parameters: 5(String), 张三(String), 12(Integer), 男(String), 2021-09-18 11:11:02.756(Timestamp), 2021-09-18 11:11:02.756(Timestamp)
     * ==>  Preparing: INSERT INTO user ( id, name, age, gender, create_time, update_time ) VALUES ( ?, ?, ?, ?, ?, ? ) 
     * ==> Parameters: 1439064682412408834(String), 张三(String), 21(Integer), 男(String), 2021-09-18 11:12:11.476(Timestamp), 2021-09-18 11:12:11.476(Timestamp)
     * ==> Parameters: 1439064683779751938(String), 李四(String), 11(Integer), 男(String), 2021-09-18 11:12:11.851(Timestamp), 2021-09-18 11:12:11.851(Timestamp)
     */
    @Test
    public void saveOrUpdateBatch() {
        //添加或修改，同一时间只能进行一项操作
        List<User> list =new ArrayList<>();
        //此修改
        list.add(new User().setId("5").setName("张三").setAge(12).setGender("男"));
        //此添加
        list.add(new User().setName("张三").setAge(21).setGender("男"));
        list.add(new User().setName("李四").setAge(11).setGender("男"));
        userService.saveOrUpdateBatch(list);
    }

3、删

1)、remove方法（根据 entity 条件，删除记录）

（1）、官方提供的接口说明

// 根据 entity 条件，删除记录
boolean remove(Wrapper<T> queryWrapper);

参数说明

类型	参数名	描述
Wrapper<T>	queryWrapper	实体包装类 QueryWrapper

（2）、实现方式

    /*
     * @version V1.0
     * Title: remove
     * @author LiuYanQiang
     * @description 根据实体对象删除
     * @createTime  2021/9/16 9:49
     * @param []
     * @return void
     * ==>  Preparing: UPDATE user SET is_delete=1 WHERE is_delete=0 AND (name = ?)
     * ==> Parameters: 张三(String)
     */
    @Test
    public void remove(){
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("name","张三");
        userService.remove(queryWrapper);
    }

2)、removeById方法（根据 ID 删除）

（1）、官方提供的接口说明

// 根据 ID 删除
boolean removeById(Serializable id);

参数说明

类型	参数名	描述
Serializable	id	主键ID

（2）、实现方式

    /*
     * @version V1.0
     * Title: removeByIds
     * @author LiuYanQiang
     * @description 根据 ID 删除
     * @createTime  2021/9/16 10:02
     * @param []
     * @return void
     * ==>  Preparing: UPDATE user SET is_delete=1 WHERE id=? AND is_delete=0
     * ==> Parameters: 3(Integer)
     */
    @Test
    public void removeById(){
        userService.removeById(3);
    }

3)、removeByMap方法（根据 columnMap 条件，删除记录）

（1）、官方提供的接口说明

// 根据 columnMap 条件，删除记录
boolean removeByMap(Map<String, Object> columnMap);

参数说明

类型	参数名	描述
Map<String, Object>	columnMap	表字段 map 对象

（2）、实现方式

    /*
     * @version V1.0
     * Title: removeByMap
     * @author LiuYanQiang
     * @description 根据 columnMap 条件，删除记录
     * @createTime  2021/9/16 10:07
     * @param []
     * @return void
     * ==>  Preparing: UPDATE user SET is_delete=1 WHERE name = ? AND age = ? AND is_delete=0
     * ==> Parameters: 小明(String), 23(String)
     */
    @Test
    public void removeByMap(){
        Map<String,Object> map = new HashMap<>();
        map.put("name","小明");
        map.put("age","23");
        userService.removeByMap(map);
    }

4)、removeByIds方法（根据 ID 批量删除）

（1）、官方提供的接口说明

// 删除（根据ID 批量删除）
boolean removeByIds(Collection<? extends Serializable> idList);

参数说明

类型	参数名	描述
Collection<? extends Serializable>	idList	主键ID列表

（2）、实现方式

    /*
     * @version V1.0
     * Title: removeByIds
     * @author LiuYanQiang
     * @description 根据ID批量删除
     * @createTime  2021/9/15 21:22
     * @param list 主键ID列表
     * @return
     * ==>  Preparing: UPDATE user SET is_delete=1 WHERE id IN ( ? , ? ) AND is_delete=0
     * ==> Parameters: 2(String), 3(String)
     */
    @Test
    public void removeByIds() {
        List<String> list=new ArrayList<>();
        list.add("2");
        list.add("3");
        userService.removeByIds(list);
    }

4、改

1)、update方法（根据updateWrapper和entity条件，更新记录）

（1）、官方提供的接口说明

// 根据 UpdateWrapper 条件，更新记录 需要设置sqlset
boolean update(Wrapper<T> updateWrapper);
// 根据 whereWrapper 条件，更新记录
boolean update(T updateEntity, Wrapper<T> whereWrapper);

参数说明

类型	参数名	描述
Wrapper<T>	updateWrapper	实体对象封装操作类 UpdateWrapper

（2）、实现方式

    /*
     * @version V1.0
     * Title: updateBatchById
     * @author LiuYanQiang
     * @description 根据updateWrapper和entity条件，更新记录
     * @createTime  2021/9/16 10:23
     * @param []
     * @return void
     * ==>  Preparing: UPDATE user SET name=?, age=?, gender=?, update_time=? WHERE is_delete=0 AND (name = ?) 
     *==> Parameters: 张三(String), 23(Integer), 男(String), 2021-09-18 11:20:08.948(Timestamp), 张三(String)
     * ==>  Preparing: UPDATE user SET age=? WHERE is_delete=0 AND (name = ? AND name = ?)
     *==> Parameters: 35(Integer), 张三(String), 张三(String)
     */
    @Test
    public void update(){
        UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
        //条件构造器作为参数进行更新(user可以设置多个属性  ， user属性为set = "value"  条件构造器为where字句的条件)
        updateWrapper.eq("name","张三");
        User user = new User();
        user.setName("张三").setAge(23).setGender("男");
        userService.update(user,updateWrapper);
        //条件构造器Set方法(直接set想要修改的字段和值)
        updateWrapper.eq("name","张三").set("age", 35);
        userService.update(null,updateWrapper);
    }

2)、updateById方法（根据ID，更新记录）

（1）、官方提供的接口说明

// 根据 ID 选择修改
boolean updateById(T entity);

参数说明

类型	参数名	描述
T	entity	实体对象

（2）、实现方式

    /*
     * @version V1.0
     * Title: updateBatchById
     * @author LiuYanQiang
     * @description 根据ID更新记录
     * @createTime  2021/9/16 10:39
     * @param []
     * @return void
     * ==>  Preparing: UPDATE user SET name=?, age=?, gender=?, update_time=? WHERE id=? AND is_delete=0
     * ==> Parameters: 张三(String), 23(Integer), 男(String), 2021-09-18 11:21:50.615(Timestamp), 1(String)
     */
    @Test
    public void updateById(){
        User user = new User();
        user.setId("1").setName("张三").setAge(23).setGender("男");
        userService.updateById(user);
    }

3)、updateBatchById方法（根据ID，批量更新）

（1）、官方提供的接口说明

// 根据ID 批量更新
boolean updateBatchById(Collection<T> entityList);
// 根据ID 批量更新
boolean updateBatchById(Collection<T> entityList, int batchSize);

参数说明

类型	参数名	描述
Collection<T>	entityList	实体对象集合
int	batchSize	更新批次数量

（2）、实现方式

    /*
     * @version V1.0
     * Title: updateBatchById
     * @author LiuYanQiang
     * @description 根据ID批量更新
     * @createTime  2021/9/15 21:40
     * @param list 实体对象集合
     * @return
     * ==>  Preparing: UPDATE user SET name=?, age=?, update_time=? WHERE id=? AND is_delete=0 
     * ==> Parameters: 张三(String), 12(Integer), 2021-09-18 11:22:56.381(Timestamp), 1(String)
     * ==> Parameters: 李四(String), 13(Integer), 2021-09-18 11:22:56.814(Timestamp), 2(String)
     */
    @Test
    public void updateBatchById() {
        Collection<User> list=new ArrayList<>();
        list.add(new User().setAge(12).setName("张三").setId("1"));
        list.add(new User().setAge(13).setName("李四").setId("2"));
        userService.updateBatchById(list);
    }

5、查

1)、Get方法

（1）、官方提供的接口说明

// 根据 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);

参数说明

类型	参数名	描述
Serializable	id	主键ID
Wrapper<T>	queryWrapper	实体对象封装操作类 QueryWrapper
boolean	throwEx	有多个 result 是否抛出异常
T	entity	实体对象
Function<? super Object, V>	mapper	转换函数

（2）、实现方式

    /*
     * @version V1.0
     * Title: getById
     * @author LiuYanQiang
     * @description 根据 ID 查询
     * @createTime  2021/9/16 10:50
     * @param []
     * @return void
     * ==>  Preparing: SELECT id,name,age,gender,create_time,update_time,version,status AS statusEnum,is_delete FROM user WHERE id=? AND is_delete=0
     * ==> Parameters: 1(Integer)
     * */
    @Test
    public void getById(){
        System.out.println(userService.getById(1));
    }

    /*
     * @version V1.0
     * Title: getOne
     * @author LiuYanQiang
     * @description 根据 Wrapper，查询一条记录。结果集，如果是多个会抛出异常，随机取一条加上限制条件
     * @createTime  2021/9/16 10:52
     * @param []
     * @return void
     * ==>  Preparing: SELECT id,name,age,gender,create_time,update_time,version,status AS statusEnum,is_delete FROM user WHERE is_delete=0 AND (name LIKE ? AND age < ?)
     * ==> Parameters: %刘%(String), 40(Integer)
     * */
    @Test
    public void getOne(){
        // 查询条件：名字中包含'ha'并且年龄小于40
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.like(User::getName,"刘").lt(User::getAge,40);
        // 开始查询符合的单条记录（如果满足条件的记录有多条，那就不能用这个方法，会报错。）
        User user = userService.getOne(queryWrapper);
        System.out.println(user);
    }

    /*
     * @version V1.0
     * Title: getMap
     * @author LiuYanQiang
     * @description 根据 Wrapper，查询一条记录
     *              getMap 的用法和上面的 getOne 很像，都是传入一个查询构造器进行查询。不同的是 getMap 返回的是一个 Map，而不是实体类对象
     *              注意： Map 里的 key 为表字段名，而不是对应实体类的属性名。
     * @createTime  2021/9/16 10:55
     * @param []
     * @return void
     * ==>  Preparing: SELECT id,name,age,gender,create_time,update_time,version,status AS statusEnum,is_delete FROM user WHERE is_delete=0 AND (name = ?)
     * ==> Parameters: 张三(String)
     * */
    @Test
    public void getMap(){
        QueryWrapper wrapper = new QueryWrapper();
        wrapper.eq("name","张三");
        Map<String,Object> map  = userService.getMap(wrapper);
        System.out.println(map);
    }

    /*
     * @version V1.0
     * Title: getObj
     * @author LiuYanQiang
     * @description 根据 Wrapper，查询一条记录（使用查询构造器，查询一条记录，返回这条记录的第一个字段值）
     *              getObj 的用法和上面的 getOne 很像，都是传入一个查询构造器进行查询。不同的是 getObj 返回的是一个字段值（该方法第二个参数是转换函数，必填）
     * @createTime  2021/9/16 11:22
     * @param []
     * @return void
     * ==>  Preparing: SELECT id,name,age,gender,create_time,update_time,version,status AS statusEnum,is_delete FROM user WHERE is_delete=0 AND (name LIKE ? AND age < ?)
     * ==> Parameters: %刘%(String), 40(Integer)
     * */
    @Test
    public void getObj(){

        // 查询条件：名字中包含'刘'并且年龄等于40
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.like(User::getName,"刘").eq(User::getAge,23);
        // 开始查询符合的单条记录的第一个字段值
        Integer id = userService.getObj(queryWrapper, (o) -> {
            return Integer.parseInt(o.toString());
        });
        System.out.println(id);
    }

2)、List方法

（1）、官方提供的接口说明

// 查询所有
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);

参数说明

类型	参数名	描述
Wrapper<T>	queryWrapper	实体对象封装操作类 QueryWrapper
Collection<? extends Serializable>	idList	主键ID列表
Map<?String, Object>	columnMap	表字段 map 对象
Function<? super Object, V>	mapper	转换函数

（2）、实现方式

    /*
     * @version V1.0
     * Title: list
     * @author LiuYanQiang
     * @description 使用查询构造器，返回一个 list
     * @createTime  2021/9/17 8:15
     * @param []
     * @return void
     * ==>  Preparing: SELECT id,name,age,gender,create_time,update_time,version,status AS statusEnum,is_delete FROM user WHERE is_delete=0
     * ==> Parameters:
     * ==>  Preparing: SELECT id,name,age,gender,create_time,update_time,version,status AS statusEnum,is_delete FROM user WHERE is_delete=0 AND (name LIKE ? AND age = ?)
     * ==>  Parameters: %小%(String), 23(Integer)
     * */
    @Test
    public void list(){
        //1.list 方法如果参数为空，则查询所有的数据
        List<User> list = userService.list();
        //2.list 方法也可以传入查询条件构造器进行查询
        // 查询条件：名字中包含'小'并且年龄等于23
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.like(User::getName,"小").eq(User::getAge,23);
        // 开始查询
        List<User> list = userService.list(queryWrapper);
        System.out.println(list);
    }

    /*
     * @version V1.0
     * Title: listByIds
     * @author LiuYanQiang
     * @description 根据 ID 批量查询，返回一个 list
     * @createTime  2021/9/17 10:39
     * @param []
     * @return void
     * ==>  Preparing: SELECT id,name,age,gender,create_time,update_time,version,status AS statusEnum,is_delete FROM user WHERE id IN ( ? , ? , ? ) AND is_delete=0
     * ==>  Parameters: 1(Integer), 2(Integer), 3(Integer)
     * */
    @Test
    public void listByIds(){
        List<User> list = userService.listByIds(Arrays.asList(1,2,3));
        System.out.println(list);
    }

    /*
     * @version V1.0
     * Title: listByMap
     * @author LiuYanQiang
     * @description 通过 MAP 封装的条件查询，返回一个 list
     *              注意：map 写的是数据表中的列名，而非实体类的属性名。比如属性名为 userName，数据表中字段为 user_name，这里应该写的是 user_name。
     * @createTime  2021/9/17 10:43
     * @param []
     * @return void
     * ==>  Preparing: SELECT id,name,age,gender,create_time,update_time,version,status AS statusEnum,is_delete FROM user WHERE name = ? AND age = ? AND is_delete=0
     * ==>  Parameters: 张三(String), 23(Integer)
     * */
    @Test
    public void listByMap(){
        Map<String,Object> map = new HashMap<>();
        map.put("name", "张三");
        map.put("age", 23);
        List<User> list = userService.listByMap(map);
        System.out.println(list);
    }

    /*
     * @version V1.0
     * Title: listMaps
     * @author LiuYanQiang
     * @description 使用查询构造器，返回一个 list
     *              listMaps 的用法和上面的 list 很像，都是传入一个查询构造器进行查询，然后返回一个 List。不同在于 listMaps 返回的 List 里面是 Map。
     *              注意： Map 里的 key 为表字段名，而不是对应实体类的属性名。
     * @createTime  2021/9/17 10:48
     * @param []
     * @return void
     * ==>  Preparing: SELECT id,name,age,gender,create_time,update_time,version,status AS statusEnum,is_delete FROM user WHERE is_delete=0
     * ==> Parameters:
     * ==>  Preparing: SELECT id,name,age,gender,create_time,update_time,version,status AS statusEnum,is_delete FROM user WHERE is_delete=0 AND (name LIKE ? AND age = ?)
     * ==> Parameters: %张%(String), 23(Integer)
     * */
    @Test
    public void listMaps(){
        //1.listMaps 方法如果参数为空，则查询所有的数据
        List<Map<String, Object>> list = userService.listMaps();
        System.out.println(list);
        //2.listMaps 方法也可以传入查询条件构造器进行查询
        // 查询条件：名字中包含'张'并且年龄等于23
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.like(User::getName,"张").eq(User::getAge,23);
        // 开始查询
        List<Map<String, Object>> list = userService.listMaps(queryWrapper);
        System.out.println(list);
    }

    /*
     * @version V1.0
     * Title: listObjs
     * @author LiuYanQiang
     * @description 使用查询构造器，返回一个 List<Object>
     *              listObjs 的用法和前面的 list 很像，都是传入一个查询构造器进行查询，然后返回一个 List。不同在于 listObjs 返回的 List 里面只有返每条结果的第一个字段值。
     * @createTime  2021/9/17 11:05
     * @param []
     * @return void
     * ==>  Preparing: SELECT id,name,age,gender,create_time,update_time,version,status AS statusEnum,is_delete FROM user WHERE is_delete=0
     * ==> Parameters:
     * ==>  Preparing: SELECT id,name,age,gender,create_time,update_time,version,status AS statusEnum,is_delete FROM user WHERE is_delete=0 AND (name LIKE ? AND age = ?)
     * ==> Parameters: %张%(String), 23(Integer)
     * */
    @Test
    public void listObjs(){
        //1.listObjs 方法如果参数为空，则查询所有的数据
        List<Object> list = userService.listObjs();
        System.out.println(list);
        //还可以传入个自定义的转换函数
        List<Object> list = userService.listObjs((o) -> {
            return "用户" + o.toString();
        });
        System.out.println(list);
        //2.listObjs 方法也可以传入查询条件构造器进行查询
        // 查询条件：名字中包含'张'并且年龄等于23
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.like(User::getName,"张").eq(User::getAge,23);
        // 开始查询
        List<Object> list = userService.listObjs(queryWrapper);
        System.out.println(list);

        //3.根据 Wrapper 条件，查询全部记录
        // 查询条件：名字中包含'刘'并且年龄等于40
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.like(User::getName,"刘").eq(User::getAge,23);
        List<User> list = userService.listObjs(queryWrapper, new Function<Object, User>() {
            @Override
            public User apply(Object id) {
                System.out.println("apply的参数"+id.toString());
                User user = userService.getById(Integer.valueOf(id.toString()));
                return user;
            }
        });
        list.stream().forEach(System.out::println);
    }

3)、分页查询

（1）、官方提供的接口说明

// 无条件分页查询
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);

参数说明

类型	参数名	描述
IPage<T>	page	翻页对象
Wrapper<T>	queryWrapper	实体对象封装操作类 QueryWrapper

（2）、实现方式

添加配置

package com.exerciseitems.mybatisplus.config;

import com.baomidou.mybatisplus.extension.plugins.OptimisticLockerInterceptor;
import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author : [LiuYanQiang]
 * @version : [v1.0]
 * @className : MyBatisPlusConfig
 * @description : [分页查询配置]
 * @createTime : [2021/9/14 16:25]
 * @updateUser : [LiuYanQiang]
 * @updateTime : [2021/9/14 16:25]
 * @updateRemark : [描述说明本次修改内容]
 * 逻辑分页与物理分页比较:
 * 逻辑分页：内存开销比较大，在数据量比较小的情况下效率比物理分页高；在数据量很大的情况下，内存开销过大，容易内存溢出，不建议使用。
 * 物理分页：内存开销比较小，在数据量比较小的情况下效率比逻辑分页还是低；在数据量很大的情况下，建议使用物理分页。
 */
@Configuration
public class MyBatisPlusConfig {
    //mybatis-plus分页插件
    @Bean
    public PaginationInterceptor paginationInterceptor(){

        return new PaginationInterceptor();
    }
}

Page方法

    /*
     * @version V1.0
     * Title: PageTst
     * @author LiuYanQiang
     * @description Page分页方法
     *              利用IService 接口提供了 page 方法实现分页查询，比如下面我们查询第1页的数据（每页5条记录）
     * @createTime  2021/9/18 9:12
     * @param []
     * @return com.baomidou.mybatisplus.core.metadata.IPage<com.exerciseitems.mybatisplus.entity.User>*/
    @RequestMapping("/PageTest")
    public IPage<User> PageTest(){
        //查询条件
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.like(User::getName,"张").eq(User::getAge,23);
        // 开始查询
        IPage<User> page = userService.page(new Page<>(1,5), queryWrapper);
        return page;
    }

PageMaps方法

    /*
     * @version V1.0
     * Title: PageMapsTest
     * @author LiuYanQiang
     * @description PageMaps分页方法
     *              PageMaps 的用法和上面的 page 很像，都是传入分页查询条件、以及查询构造器进行查询，然后返回一个 List。不同在于 PageMaps 返回的结果里面是 Map
     *              注意： Map 里的 key 为表字段名，而不是对应实体类的属性名。
     * @createTime  2021/9/18 9:18
     * @param []
     * @return com.baomidou.mybatisplus.core.metadata.IPage<java.util.Map<java.lang.String,java.lang.Object>>*/
    @RequestMapping("/PageMapsTest")
    public IPage<Map<String,Object>> PageMapsTest(){
        //查询条件
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.like(User::getName,"张").eq(User::getAge,23);
        // 开始查询
        IPage<Map<String, Object>> page  = userService.pageMaps(new Page<>(1,5), queryWrapper);
        return page;
    }

4)、查询数量

（1）、官方提供的接口说明

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

参数说明

类型	参数名	描述
Wrapper<T>	queryWrapper	实体对象封装操作类 QueryWrapper

（2）、实现方式

    /*
     * @version V1.0
     * Title: count
     * @author LiuYanQiang
     * @description 查询总记录数
     * @createTime  2021/9/15 21:44
     * @param
     * @return
     */
    @Test
    public void count() {
        int count = userService.count();
        System.out.println(count);
    }

MyBatisPlus——内置Service方面的CRUD

目录

1、相关前提步骤

1)、定义一个接口继承 IService接口

2)、定义一个实现类，实现自定义的接口UserService之前要继承IService的实现类ServiceImpl

3)、测试类注入自定义UserService 接口

4)、后面就可以进行相关的CRUD的操作了

2、增

1)、save方法（插入一条数据）

（1）、官方提供的接口说明

（2）、实现方式

2)、saveBatch方法（批量插入数据）

（1）、官方提供的接口说明

（2）、实现方式

3)、saveOrUpdate方法（插入数据或更新数据）

（1）、官方提供的接口说明

（2）、实现方式

4)、saveOrUpdateBatch方法（批量插入数据或更新数据）

（1）、官方提供的接口说明

（2）、实现方式

3、删

1)、remove方法（根据 entity 条件，删除记录）

（1）、官方提供的接口说明

（2）、实现方式

2)、removeById方法（根据 ID 删除）

（1）、官方提供的接口说明

（2）、实现方式

3)、removeByMap方法（根据 columnMap 条件，删除记录）

（1）、官方提供的接口说明

（2）、实现方式

4)、removeByIds方法（根据 ID 批量删除）

（1）、官方提供的接口说明

（2）、实现方式

4、改

1)、update方法（根据updateWrapper和entity条件，更新记录）

（1）、官方提供的接口说明

（2）、实现方式

2)、updateById方法（根据ID，更新记录）

（1）、官方提供的接口说明

（2）、实现方式

3)、updateBatchById方法（根据ID，批量更新）

（1）、官方提供的接口说明

（2）、实现方式

5、查

1)、Get方法

（1）、官方提供的接口说明

（2）、实现方式

2)、List方法

（1）、官方提供的接口说明

（2）、实现方式

3)、分页查询

（1）、官方提供的接口说明

（2）、实现方式

添加配置

Page方法

PageMaps方法

4)、查询数量

（1）、官方提供的接口说明

（2）、实现方式

猜你喜欢