【Mybatis-Plus 学习笔记】2、日志配置及常用 CRUD

缺乏、安全感 2022-09-03 15:15 159阅读 0赞

## 前言 ##

上一篇文章中我们讲了 Mybatis-Plus 的定义以及相关特点，并从零开始编写了一个 SpringBoot + Mybatis-Plus 的实例。今天我们就来看看，如何利用 MP 来实现对数据库的增删改查。

## 日志配置 ##

使用 MP 时，默认是不打印任何 SQL 语句的。而为了方便日常开发工作的调试，我们需要联合控制台和各种数据可视化工具进行语句的拼接检查，因此我们利用 MP 自带的日志功能，在控制台输出我们的 SQL 语句，从而方便我们调试。

在配置文件 `application.yml` （IDEA 默认生成的配置文件为 `application.properties`）中，加入一下配置，这样 MP 就会在控制台中打印完整带参数的 SQL 语句，方便我们查看。

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

## Mapper CRUD 使用方法 ##

首先我们来看 `Mapper` 层 CRUD 涉及的一些方法，`Mapper` 层主要继承自 `BaseMapper` 接口，里边实现了各种用于操作数据库的增删改查的方法，以下我们就来看看日常我们常用的一些方法。

package com.cunyu.employee.mapper;
    
    import com.baomidou.mybatisplus.core.mapper.BaseMapper;
    import com.cunyu.employee.entity.Employee;
    
    /**
     * Created with IntelliJ IDEA.
     *
     * @author : cunyu
     * @version : 1.0
     * @project : Employee
     * @package : com.cunyu.employee.mapper
     * @className : EmployeeMapper
     * @createTime : 2021/8/7 17:45
     * @description : 员工 Mapper 类
     */
    public interface EmployeeMapper extends BaseMapper<Employee> {
        
    }

### insert 操作 ###

首先是插入数据，`insert` 方法中，传入我们所要插入数据库的实体对象作为参数即可。

*  **方法声明**

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

*  **插入实例**

package com.cunyu.employee;
    
    import com.cunyu.employee.entity.Employee;
    import com.cunyu.employee.mapper.EmployeeMapper;
    import org.junit.Assert;
    import org.junit.jupiter.api.Test;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    
    
    @SpringBootTest
    class EmployeeApplicationTests {
        
    
        @Test
        void contextLoads() {
        
        }
    
        @Autowired
        private EmployeeMapper employeeMapper;
    
        @Test
        void testInsert() {
        
            Employee employee = new Employee();
            employee.setId(4L);
            employee.setName("赵六");
            employee.setSex("男");
            employee.setEmail("zhaoliu@cunyu1943.com");
    
            Assert.assertEquals(1, employeeMapper.insert(employee));
            System.out.println("插入成功");
        }
    
    }

*  **测试结果**

![eafc4ae5b2e4bd3bc2695e14daca8cb6.png][]

*  **数据插入后的数据库**

![2bec29287ff01a73aaf20f8c23afe19a.png][]

### select 操作 ###

相比于插入数据操作，查询数据的方法就要更多，而且还能实现批量查询和条件查询。

1.  **根据主键查询**

将所要查询数据的主键作为参数传入我们的 `selectById` 方法中，即可实现。

*  **方法声明**

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

*  **查询实例**

package com.cunyu.employee;
    
    import com.cunyu.employee.entity.Employee;
    import com.cunyu.employee.mapper.EmployeeMapper;
    import org.junit.Assert;
    import org.junit.jupiter.api.Test;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    
    
    @SpringBootTest
    class EmployeeApplicationTests {
        
    
        @Test
        void contextLoads() {
        
        }
    
        @Autowired
        private EmployeeMapper employeeMapper;
    
        @Test
        void testSelectById() {
        
            Employee employee = employeeMapper.selectById(3);
            System.out.println(employee);
        }
    }

*  **测试结果**

![86a6bc3c0f430dab4efdcb583ddde74a.png][]

1.  **根据主键批量查询**

上一个方法每次只能查询一条记录，如果我们想要查询多条数据记录，那么就可以将要查询数据的主键列表传入 `selectBatchIds` 方法即可。

*  **方法声明**

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

*  **批量查询实例**

package com.cunyu.employee;
    
    import com.cunyu.employee.entity.Employee;
    import com.cunyu.employee.mapper.EmployeeMapper;
    import org.junit.Assert;
    import org.junit.jupiter.api.Test;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    
    
    @SpringBootTest
    class EmployeeApplicationTests {
        
    
        @Test
        void contextLoads() {
        
        }
    
        @Autowired
        private EmployeeMapper employeeMapper;
    
        @Test
        void testSelectBatchIds() {
        
            List<Integer> ids = new ArrayList<>();
            ids.add(1);
            ids.add(4);
            List<Employee> employeeList = employeeMapper.selectBatchIds(ids);
            System.out.println(employeeList);
        }
    }

*  **测试结果**

![0c43ff686889a7ad13040a12bd011f6a.png][]

1.  **根据多条件查询**

除开支持主键查询外，MP 还支持条件查询，只要将我们的条件传入 `Map` 列表中，然后将其作为 `selectByMap` 方法的参数即可，其中传入 `Map` 的 `key` 对应我们数据库中的字段，而 `value` 则对应字段的值。

*  **方法声明**

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

*  **条件查询实例**

package com.cunyu.employee;
    
    import com.cunyu.employee.entity.Employee;
    import com.cunyu.employee.mapper.EmployeeMapper;
    import org.junit.Assert;
    import org.junit.jupiter.api.Test;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    
    
    @SpringBootTest
    class EmployeeApplicationTests {
        
    
        @Test
        void contextLoads() {
        
        }
    
        @Autowired
        private EmployeeMapper employeeMapper;
    
        @Test
        void testSelectByMap() {
        
            Map<String, Object> map = new HashMap<>();
            map.put("sex", "男");
            map.put("name", "张三");
            System.out.println(employeeMapper.selectByMap(map));
        }
    }

*  **测试结果**

![efa9b05a272b232f6ea259c8d3054e42.png][]

### update 操作 ###

更新操作，主要是根据我们数据库的主键进行查询，将对应主键的实体对象传入 `updateById` 方法即可。

*  **方法声明**

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

*  **更新实例**

package com.cunyu.employee;
    
    import com.cunyu.employee.entity.Employee;
    import com.cunyu.employee.mapper.EmployeeMapper;
    import org.junit.Assert;
    import org.junit.jupiter.api.Test;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    
    @SpringBootTest
    class EmployeeApplicationTests {
        
    
        @Autowired
        private EmployeeMapper employeeMapper;
    
        @Test
        void testUpdate() {
        
            Employee employee = new Employee();
    
            employee.setEmail("zhao6@cunyu1943.com");
            employee.setName("赵 6");
            employee.setSex("女");
            employee.setId(4L);
    
            Assert.assertEquals(1, employeeMapper.updateById(employee));
            System.out.println("更新成功");
        }
    
    }

*  **测试结果**

![21bdde18446f1bc7ec886ec01e0aa8bc.png][]

*  **数据更新后的数据库**

![0bf78710d200c2f7535ade0f232646ea.png][]

### delete 操作 ###

删除操作，既可以根据主键删除一条记录，也能根据主键列表实现批量删除，还能根据条件来进行删除。

1.  **根据主键删除一条数据**

将所要删除记录的主键作为参数传入 `deleteById` 方法即可。

*  **方法声明**

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

*  **删除实例**

*  **测试结果**

![13fa53d7ce388606a0dba6caa7884791.png][]

*  **删除数据后的数据库**

![754b2aa42b70340c6d1ef359bf4957a1.png][]

1.  **根据条件删除**

根据条件删除同样是讲条件传入 `Map` 中，然后将 `Map` 作为参数传入 `deleteByMap` 方法，其中 `key` 对应数据库中的字段，`value` 对应字段的值。

*  **方法声明**

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

*  **删除实例**

package com.cunyu.employee;
    
    import com.cunyu.employee.entity.Employee;
    import com.cunyu.employee.mapper.EmployeeMapper;
    import org.junit.Assert;
    import org.junit.jupiter.api.Test;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    
    @SpringBootTest
    class EmployeeApplicationTests {
        
    
        @Autowired
        private EmployeeMapper employeeMapper;
    
        @Test
        void testDeleteByMap() {
        
            Map<String, Object> map = new HashMap<>();
            map.put("name", "赵 6");
            Assert.assertEquals(1, employeeMapper.deleteByMap(map));
            System.out.println("删除成功");
        }
    }

*  **测试结果**

![8ae3056bfe18e6a4f745a6c9ff509a30.png][]

*  **删除数据后的数据库**

![0e4ce5565c45b3af2113ba6fa265ae85.png][]

1.  **根据主键批量删除**

将要删除记录的主键传入集合中，然后将集合作为 `deleteBatchIds` 方法的参数即可。

*  **方法声明**

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

*  **批量删除实例**

package com.cunyu.employee;
    
    import com.cunyu.employee.entity.Employee;
    import com.cunyu.employee.mapper.EmployeeMapper;
    import org.junit.Assert;
    import org.junit.jupiter.api.Test;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    
    @SpringBootTest
    class EmployeeApplicationTests {
        
    
        @Autowired
        private EmployeeMapper employeeMapper;
    
        @Test
        void testDeleteBatchIds() {
        
            List<Integer> ids = new ArrayList<>();
            ids.add(1);
            ids.add(3);
            Assert.assertEquals(2, employeeMapper.deleteBatchIds(ids));
            System.out.println("删除成功");
        }
    }

*  **测试结果**

![7781d31edd822234ef741751cc84403d.png][]

*  **删除数据后的数据库**

![8ca0e6de77b33e31d83ac08480f40b5e.png][]

## Service CRUD 接口 ##

`Service` 层继承自 `IService` 接口，其中的方法和 `Mapper` 层中所提供的方法功能是一致的，除了方法名有所不同外，其他基本类似，但 `Service` 层中提供了更为丰富的方法，两者的继承结构如下图所示。

![12764416856e4a9194c4b7046683ecd4_tplv-k3u1fbpfcp-zoom-1.image][]

package com.cunyu.employee.service;
    
    import com.baomidou.mybatisplus.extension.service.IService;
    import com.cunyu.employee.entity.Employee;
    
    /**
     * Created with IntelliJ IDEA.
     *
     * @author : cunyu
     * @version : 1.0
     * @project : Employee
     * @package : com.cunyu.employee.service
     * @className : EmployeeService
     * @createTime : 2021/8/8 7:52
     * @description : 员工服务接口
     */
    @Service
    public interface EmployeeService extends IService<Employee> {
        
    }

package com.cunyu.employee.service.Impl;
    
    import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
    import com.cunyu.employee.entity.Employee;
    import com.cunyu.employee.mapper.EmployeeMapper;
    import com.cunyu.employee.service.EmployeeService;
    
    /**
     * Created with IntelliJ IDEA.
     *
     * @author : cunyu
     * @version : 1.0
     * @project : Employee
     * @package : com.cunyu.employee.service.Impl
     * @className : EmployeeServiceImpl
     * @createTime : 2021/8/8 7:53
     * @description : 员工服务类实现
     */
    
    @Service
    public class EmployeeServiceImpl extends ServiceImpl<EmployeeMapper, Employee> implements EmployeeService {
        
    }

### Save ###

1.  **插入一条记录**

功能同 `Mapper` 层中的 `insert` 方法，只不过方法名不同。

*  **方法声明**

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

*  **插入实例**

*  **测试结果**

![5996487ba47a09711b90c00741733206.png][]

*  **插入数据后的数据库**

![d074edd870e74a751570e165a2b442e3.png][]

1.  **批量插入**

这里就和 `Mapper` 层中所有区别，`Mapper` 层中只支持单次插入，而 `Service` 层中支持批量插入，而传入的参数就是我们所要传入实体的集合，而且还可以分批次插入和统一插入。

2.1 **统一插入**

*  **方法声明**

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

*  **插入实例**

package com.cunyu.employee;
    
    import com.cunyu.employee.entity.Employee;
    import com.cunyu.employee.mapper.EmployeeMapper;
    import com.cunyu.employee.service.EmployeeService;
    import org.junit.Assert;
    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.List;
    
    @SpringBootTest
    class EmployeeApplicationTests {
        
    
        @Autowired
        private EmployeeService employeeService;
    
        @Test
        void testSaveBatch() {
        
            Employee employee1 = new Employee();
            employee1.setId(6L);
            employee1.setEmail("zhangliang@cunyu1943.com");
            employee1.setSex("男");
            employee1.setName("张良");
    
            Employee employee2 = new Employee();
            employee2.setId(7L);
            employee2.setEmail("zhouyu@cunyu1943.com");
            employee2.setName("周瑜");
            employee2.setSex("男");
    
            List<Employee> employeeList = new ArrayList<>();
            employeeList.add(employee1);
            employeeList.add(employee2);
    
            Assert.assertTrue(employeeService.saveBatch(employeeList));
            System.out.println("批量插入成功");
        }
    }

*  **测试结果**

![cc5f359bcbb2d4287e51e693c64320b5.png][]

*  **统一插入后的数据库**

![99b83c2bb2e50f9b687d2ccafe694a6c.png][]

2.2 **分批次插入**

*  **方法声明**

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

*  **分批次插入实例**

package com.cunyu.employee;
    
    import com.cunyu.employee.entity.Employee;
    import com.cunyu.employee.mapper.EmployeeMapper;
    import com.cunyu.employee.service.EmployeeService;
    import org.junit.Assert;
    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.List;
    
    @SpringBootTest
    class EmployeeApplicationTests {
        
    
        @Autowired
        private EmployeeService employeeService;
    
        @Test
        void testSaveBatch() {
        
            Employee employee1 = new Employee();
            employee1.setId(8L);
            employee1.setEmail("jialuo@cunyu1943.com");
            employee1.setSex("女");
            employee1.setName("迦罗");
    
            Employee employee2 = new Employee();
            employee2.setId(9L);
            employee2.setEmail("zhugeliang@cunyu1943.com");
            employee2.setName("诸葛亮");
            employee2.setSex("男");
    
            List<Employee> employeeList = new ArrayList<>();
            employeeList.add(employee1);
            employeeList.add(employee2);
    
            Assert.assertTrue(employeeService.saveBatch(employeeList,2));
            System.out.println("批量插入成功");
        }
    }

*  **测试结果**

![176bd864bf1fdeaa40b52a971a0c6bf0.png][]

*  **分批次插入后的数据库**

![3cf55bdf99d6ca96218127840beb604a.png][]

### SaveOrUpdate ###

1.  **单条修改插入**

*  **方法声明**

// TableId 注解存在更新记录，否插入一条记录
    boolean saveOrUpdate(T entity);

*  **单条修改插入实例**

package com.cunyu.employee;
    
    import com.cunyu.employee.entity.Employee;
    import com.cunyu.employee.mapper.EmployeeMapper;
    import com.cunyu.employee.service.EmployeeService;
    import org.junit.Assert;
    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.List;
    
    @SpringBootTest
    class EmployeeApplicationTests {
        
    
        @Autowired
        private EmployeeService employeeService;
    
        @Test
        void testSaveOrUpdate() {
        
            Employee employee = new Employee();
            employee.setId(5L);
            employee.setName("周武");
            employee.setEmail("zhouwu@cunyu1943.com");
            employee.setSex("男");
    
            Assert.assertTrue(employeeService.saveOrUpdate(employee));
            System.out.println("更新成功");
        }
    }

*  **测试结果**

![1bd07adc6afb9fa346f56563b97f3d20.png][]

*  **修改插入后的数据库**

![28761dbe6cb714bec1758a759fe5ec8b.png][]

1.  **批量修改插入**

2.1 **统一插入**

*  **方法声明**

// 批量修改插入
    boolean saveOrUpdateBatch(Collection<T> entityList);

*  **统一插入实例**

package com.cunyu.employee;
    
    import com.cunyu.employee.entity.Employee;
    import com.cunyu.employee.mapper.EmployeeMapper;
    import com.cunyu.employee.service.EmployeeService;
    import org.junit.Assert;
    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.List;
    
    @SpringBootTest
    class EmployeeApplicationTests {
        
    
        @Autowired
        private EmployeeService employeeService;
    
        @Test
        void testSaveOrUpdateBatch() {
        
            Employee employee1 = new Employee();
            employee1.setId(10L);
            employee1.setEmail("zhongwuyan@cunyu1943.com");
            employee1.setSex("女");
            employee1.setName("钟无艳");
    
            Employee employee2 = new Employee();
            employee2.setId(11L);
            employee2.setEmail("direnjie@cunyu1943.com");
            employee2.setName("狄仁杰");
            employee2.setSex("男");
    
            List<Employee> employeeList = new ArrayList<>();
            employeeList.add(employee1);
            employeeList.add(employee2);
    
            Assert.assertTrue(employeeService.saveOrUpdateBatch(employeeList));
            System.out.println("批量修改插入成功");
        }
    }

*  **测试结果**

![882f141e5b1b562300fd340e99dd1e74.png][]

*  **统一插入数据后的数据库**

![ea95b0aef97d6fc8911c4de46dbdc9d6.png][]

2.2 **分批次插入**

*  **方法声明**

// 批量修改插入
    boolean saveOrUpdateBatch(Collection<T> entityList, int batchSize);

*  **方法实例**

package com.cunyu.employee;
    
    import com.cunyu.employee.entity.Employee;
    import com.cunyu.employee.mapper.EmployeeMapper;
    import com.cunyu.employee.service.EmployeeService;
    import org.junit.Assert;
    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.List;
    
    @SpringBootTest
    class EmployeeApplicationTests {
        
    
        @Autowired
        private EmployeeService employeeService;
    
        @Test
        void testSaveOrUpdateBatch() {
        
            Employee employee1 = new Employee();
            employee1.setId(12L);
            employee1.setEmail("yuji@cunyu1943.com");
            employee1.setSex("女");
            employee1.setName("虞姬");
    
            Employee employee2 = new Employee();
            employee2.setId(13L);
            employee2.setEmail("sulie@cunyu1943.com");
            employee2.setName("苏烈");
            employee2.setSex("男");
    
            List<Employee> employeeList = new ArrayList<>();
            employeeList.add(employee1);
            employeeList.add(employee2);
    
            Assert.assertTrue(employeeService.saveOrUpdateBatch(employeeList, 2));
            System.out.println("批量修改插入成功");
        }
    }

*  **测试结果**

![bb54a447984342587c7f179565fa04bd.png][]

*  **分批次插入数据后的数据库**

![d165237c3ffaff0011de68da405520dc.png][]

### Remove ###

1.  **根据 ID 删除**

*  **方法实例**

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

*  **删除实例**

*  **测试结果**

![4f28d3ad476649f51c2d21ca67575b4c.png][]

![43147f95524c777df4ca9b6c9534f2bf.png][]

1.  **根据条件删除**

*  **方法声明**

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

*  **按条件删除实例**

*  **测试结果**

![3b281656c97119c48bcc67ae039dd43f.png][]

*  **按条件删除后的数据库**

![e00c5eec6db5fb177385f916593a5ddf.png][]

1.  **根据 ID 批量删除**

*  **方法声明**

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

*  **批量删除实例**

*  **测试结果**

![36a48ba2fee8f6a5800b14a36020a96a.png][]

*  **批量删除后的数据库**

![c3a783950d27aa75ae82a123cad3955b.png][]

### Update ###

1.  **根据 ID 选择修改**

*  **方法声明**

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

*  **根据 ID 修改实例**

*  **测试结果**

![21c7a6ffa9423f11939a36d00b249933.png][]

*  **更新后的数据库**

![e2c6861eb9678452797bb6373e430b71.png][]

1.  **根据 ID 批量更新**

2.1 **统一更新**

*  **方法声明**

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

*  **批量更新实例**

package com.cunyu.employee;
    
    import com.cunyu.employee.entity.Employee;
    import com.cunyu.employee.mapper.EmployeeMapper;
    import com.cunyu.employee.service.EmployeeService;
    import org.junit.Assert;
    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.List;
    
    @SpringBootTest
    class EmployeeApplicationTests {
        
    
        @Autowired
        private EmployeeService employeeService;
    
        @Test
        void testUpdateBatchById() {
        
            Employee employee1 = new Employee();
            employee1.setId(6L);
            employee1.setName("妲己");
            employee1.setSex("女");
            employee1.setEmail("daji@cunyu1943.com");
    
            Employee employee2 = new Employee();
            employee2.setId(13L);
            employee2.setName("小乔");
            employee2.setSex("女");
            employee2.setEmail("xiaoqiao@cunyu1943.com");
    
            List<Employee> employeeList = new ArrayList<>();
            employeeList.add(employee1);
            employeeList.add(employee2);
    
            Assert.assertTrue(employeeService.updateBatchById(employeeList));
            System.out.println("更新成功");
        }
    }

*  **测试结果**

![1ceaa41986d6c4df67c64613b13f292f.png][]

*  **批量更新后的数据库**

![4c610fff64f2d26ecdde6de141613e7b.png][]

2.2 **分批次更新**

*  **方法声明**

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

*  **分批次更新实例**

package com.cunyu.employee;
    
    import com.cunyu.employee.entity.Employee;
    import com.cunyu.employee.mapper.EmployeeMapper;
    import com.cunyu.employee.service.EmployeeService;
    import org.junit.Assert;
    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.List;
    
    @SpringBootTest
    class EmployeeApplicationTests {
        
    
        @Autowired
        private EmployeeService employeeService;
    
        @Test
        void testUpdateBatchById() {
        
            Employee employee1 = new Employee();
            employee1.setId(7L);
            employee1.setName("武则天");
            employee1.setSex("女");
            employee1.setEmail("wuzetian@cunyu1943.com");
    
            Employee employee2 = new Employee();
            employee2.setId(3L);
            employee2.setName("李元芳");
            employee2.setSex("男");
            employee2.setEmail("liyuanfang@cunyu1943.com");
    
            List<Employee> employeeList = new ArrayList<>();
            employeeList.add(employee1);
            employeeList.add(employee2);
    
            Assert.assertTrue(employeeService.updateBatchById(employeeList, 2));
            System.out.println("更新成功");
        }
    }

*  **测试结果**

![f1adac18df09758c69dae5b98eecb8bc.png][]

*  **分批次更新后的数据库**

![68924264cc41e5c2d46d432dc2e33149.png][]

### Get ###

1.  **根据 ID 查询**

将所要查询记录的 `id` 作为参数，然后将查询到的实体返回。

*  **方法声明**

// 根据 ID 查询
    T getById(Serializable id);

*  **查询实例**

*  **测试结果**

![3590f21fa1cc05fb37090df84129487e.png][]

### List ###

1.  **查询所有**

查询所有记录，然后返回到一个集合中。

*  **方法声明**

// 查询所有
    List<T> list();

*  **查询实例**

*  **测试结果**

![0d603e74557b79206aaf184530f41007.png][]

1.  **根据 ID 批量查询**

讲所要查询的记录 `id` 传入集合，然后座位方法参数，最后返回查询到的结果到一个集合中。

*  **方法声明**

// 查询（根据ID 批量查询）
    Collection<T> listByIds(Collection<? extends Serializable> idList);

*  **批量查询实例**

*  **测试结果**

![13e0ccaf7974bde5b83c98bd9c00a5e9.png][]

1.  **根据条件查询**

条件传入 `Map` 集合，`key` 对应字段，`value` 对应值，然后返回集合。

*  **方法声明**

// 查询（根据 columnMap 条件）
    Collection<T> listByMap(Map<String, Object> columnMap);

*  **根据条件查询实例**

*  **测试结果**

![83c2fbbe1dd98236217aecee73168797.png][]

1.  **查询所有列表**

*  **方法声明**

// 查询所有列表
    List<Map<String, Object>> listMaps();

*  **查询实例**

*  **测试结果**

![ca254977c9086653ab4b422b8809834c.png][]

1.  **查询所有记录**

用于查询所有数据记录，并将其返回到一个集合中。

*  **方法声明**

// 查询全部记录
    List<Object> listObjs();

*  **查询实例**

*  **测试结果**

![22fba4882741eaeee5c940d77b0131dc.png][]

### Count ###

1.  **查询记录总数**

用于统计数据控中的记录总条数，方法返回记录条数。

*  **方法声明**

// 查询总记录数
    int count();

*  **查询记录总数实例**

*  **测试结果**

![b79542a84e068a734cb25be93500e83c.png][]

## 总结 ##

好了，以上就是关于 Mybatis-Plus 的日志配置以及如何进行 CRUD 的相关内容了，这里 CRUD 主要又分为 Mapper 层和 Service 层，我们可以根据自己的需要进行选择。当然，在我们日常使用中，常常都是两个接口一起使用，关于更多 MP 的使用技巧，我们下期文章再见！

[eafc4ae5b2e4bd3bc2695e14daca8cb6.png]: /images/20220829/8c0c1f1a9d6643ed964800da8ce18ee6.png
[2bec29287ff01a73aaf20f8c23afe19a.png]: /images/20220829/eb87aad6a25941aaa47994789103e2ac.png
[86a6bc3c0f430dab4efdcb583ddde74a.png]: /images/20220829/4cc9ccfa96ad49819ca4df95a9aab396.png
[0c43ff686889a7ad13040a12bd011f6a.png]: /images/20220829/b33a3fe482c047e7b1c38e82bbd12f9e.png
[efa9b05a272b232f6ea259c8d3054e42.png]: /images/20220829/12463155cb264c7d9ce03ee3e14d4295.png
[21bdde18446f1bc7ec886ec01e0aa8bc.png]: /images/20220829/850159e121bc4449a40fe3f564c21c2a.png
[0bf78710d200c2f7535ade0f232646ea.png]: /images/20220829/067963211e884aa6b488fac0eb668374.png
[13fa53d7ce388606a0dba6caa7884791.png]: /images/20220829/5537fb5de5874e1cac7e25e89ae25b6f.png
[754b2aa42b70340c6d1ef359bf4957a1.png]: /images/20220829/6331eb56f1f845a0a48e80687cd9533e.png
[8ae3056bfe18e6a4f745a6c9ff509a30.png]: /images/20220829/203a470914b14402a744f7fafe2547a0.png
[0e4ce5565c45b3af2113ba6fa265ae85.png]: /images/20220829/b6704da1c1a244b392fd04e9225d4bb8.png
[7781d31edd822234ef741751cc84403d.png]: /images/20220829/ea816250c3c24500bc6425df56c5f0ad.png
[8ca0e6de77b33e31d83ac08480f40b5e.png]: /images/20220829/b1c945a8f00243f9b6ab968cade28a54.png
[12764416856e4a9194c4b7046683ecd4_tplv-k3u1fbpfcp-zoom-1.image]: /images/20220829/278f37979576493d820082ded6da6db7.png
[5996487ba47a09711b90c00741733206.png]: /images/20220829/21d2bc797eba4aa5b8ad47c12097eec8.png
[d074edd870e74a751570e165a2b442e3.png]: /images/20220829/528abf1f45e9467baeb0ebdebcb15b9f.png
[cc5f359bcbb2d4287e51e693c64320b5.png]: /images/20220829/2f4ee9e50e8b4f929b71bdb26c37c571.png
[99b83c2bb2e50f9b687d2ccafe694a6c.png]: /images/20220829/4af3f59e405347bc9e198979d9784b77.png
[176bd864bf1fdeaa40b52a971a0c6bf0.png]: /images/20220829/abfe66babe9143eca04a1c779f19ef83.png
[3cf55bdf99d6ca96218127840beb604a.png]: /images/20220829/5be987be979e43678c1527e2306171fc.png
[1bd07adc6afb9fa346f56563b97f3d20.png]: /images/20220829/d82c7ba3418a4e6e9d0c002108aa0050.png
[28761dbe6cb714bec1758a759fe5ec8b.png]: /images/20220829/49516c06a9024af88e5e93a12e7a0b65.png
[882f141e5b1b562300fd340e99dd1e74.png]: /images/20220829/7b3e6fe48ab84300b545434b541ddecb.png
[ea95b0aef97d6fc8911c4de46dbdc9d6.png]: /images/20220829/39b6a9fa1f9e489db78f319bd53c017b.png
[bb54a447984342587c7f179565fa04bd.png]: /images/20220829/d81c1048eb41473e89baf6589e8f64ab.png
[d165237c3ffaff0011de68da405520dc.png]: /images/20220829/462be31bb95b4eb8b89da70909fb44b3.png
[4f28d3ad476649f51c2d21ca67575b4c.png]: /images/20220829/71b9f994378446f2ae5826d2d796fab9.png
[43147f95524c777df4ca9b6c9534f2bf.png]: /images/20220829/b0c38b6e3f004207bcfe6c2f86d7090d.png
[3b281656c97119c48bcc67ae039dd43f.png]: /images/20220829/be2c452c35b740dab286db0ca0149078.png
[e00c5eec6db5fb177385f916593a5ddf.png]: /images/20220829/aed0dec769d74be58d384e668a77780c.png
[36a48ba2fee8f6a5800b14a36020a96a.png]: /images/20220829/0a1ca0a0f95e43e597ff9292ab3bc2aa.png
[c3a783950d27aa75ae82a123cad3955b.png]: /images/20220829/3c1b2fa0445f41d3bb207ce82a66a6f2.png
[21c7a6ffa9423f11939a36d00b249933.png]: /images/20220829/0a79b9c288504870838332c1b9d0c5c5.png
[e2c6861eb9678452797bb6373e430b71.png]: /images/20220829/16f54c2a9abf49f59ae1087f4af1c111.png
[1ceaa41986d6c4df67c64613b13f292f.png]: /images/20220829/340fa649caa048169dfeffaacc7e836b.png
[4c610fff64f2d26ecdde6de141613e7b.png]: /images/20220829/3cdf5c406190457e866e1eb59caf0943.png
[f1adac18df09758c69dae5b98eecb8bc.png]: /images/20220829/971e390956c0466ab4c0971c35080417.png
[68924264cc41e5c2d46d432dc2e33149.png]: /images/20220829/4deb03200b8444719eae09a37ca2f99c.png
[3590f21fa1cc05fb37090df84129487e.png]: /images/20220829/dba95e83e12a44cbb5d26afdbfa6fe31.png
[0d603e74557b79206aaf184530f41007.png]: /images/20220829/7cfc80658ad84086beb1fd214f6ca583.png
[13e0ccaf7974bde5b83c98bd9c00a5e9.png]: /images/20220829/bb1c0691c68b446e97721c59db6814bf.png
[83c2fbbe1dd98236217aecee73168797.png]: /images/20220829/ddd015b615f142b2b1054cdd135f4fb5.png
[ca254977c9086653ab4b422b8809834c.png]: /images/20220829/38593742085940a182ec4cccd35886a6.png
[22fba4882741eaeee5c940d77b0131dc.png]: /images/20220829/da88740ad0ce4167b4649f8261683c0a.png
[b79542a84e068a734cb25be93500e83c.png]: /images/20220829/3f0cac5558354fe2b98bdc2205a1b3d5.png