无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作
强大的 CRUD 操作：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作，更有强大的条件构造器，满足各类使用需求
支持 Lambda 形式调用：通过 Lambda 表达式，方便的编写各类查询条件，无需再担心字段写错
支持主键自动生成：支持多达 4 种主键策略（内含分布式唯一 ID 生成器 - Sequence），可自由配置，完美解决主键问题
支持 ActiveRecord 模式：支持 ActiveRecord 形式调用，实体类只需继承 Model 类即可进行强大的 CRUD 操作
支持自定义全局通用操作：支持全局通用方法注入（ Write once, use anywhere ）
内置代码生成器：采用代码或者 Maven 插件可快速生成 Mapper 、 Model 、 Service 、 Controller 层代码，支持模板引擎，更有超多自定义配置等您来使用
内置分页插件：基于 MyBatis 物理分页，开发者无需关心具体操作，配置好插件之后，写分页等同于普通 List 查询
分页插件支持多种数据库：支持 mysql、MariaDB、Oracle、DB2、H2、HSQL、SQLite、Postgre、SQLServer 等多种数据库
内置性能分析插件：可输出 Sql 语句以及其执行时间，建议开发测试时启用该功能，能快速揪出慢查询
内置全局拦截插件：提供全表 delete 、 update 操作智能分析阻断，也可自定义拦截规则，预防误操作

1.4 框架结构

1.5 作者

2. 快速入门

对于Mybatis整合MP有常常有三种用法，分别是Mybatis+MP、Spring+Mybatis+MP、Spring Boot+Mybatis+MP。

2.0 准备工作

建立测试用的数据库和表，SQL以及如下：

/*
Navicat MySQL Data Transfer

Source Server         : MYSQL5_3306
Source Server Version : 50518
Source Host           : localhost:3306
Source Database       : db_mp_test

Target Server Type    : MYSQL
Target Server Version : 50518
File Encoding         : 65001

Date: 2021-05-23 10:45:35
*/

SET FOREIGN_KEY_CHECKS=0;

-- ----------------------------
-- Table structure for tb_user
-- ----------------------------
DROP TABLE IF EXISTS `tb_user`;
CREATE TABLE `tb_user` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `username` varchar(20) NOT NULL,
  `password` varchar(20) NOT NULL,
  `name` varchar(20) NOT NULL,
  `age` int(11) NOT NULL,
  `email` varchar(50) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of tb_user
-- ----------------------------
INSERT INTO `tb_user` VALUES ('1', 'zhangsan', '123456', '张三', '18', 'zhangsan@qq.com');
INSERT INTO `tb_user` VALUES ('2', 'lisi', '123456', '李四', '20', 'lisi@qq.com');
INSERT INTO `tb_user` VALUES ('3', 'wangwu', '123456', '王五', '21', 'wangwu@qq.com');
INSERT INTO `tb_user` VALUES ('4', 'zhaoliu', '654321', '赵六', '19', 'zhaoliu@qq.com');
INSERT INTO `tb_user` VALUES ('5', 'sunqi', '852369', '孙七', '22', 'sunqi@qq.com');

2.1 Mybatis整合Mybatis-Plus

2.1.1 原生Mybatis查询

第一步，创建一个基于maven的JavaWeb项目

第二步，导入相关的依赖

mybatis-plus的坐标如下：

<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus</artifactId>
    <version>3.4.3</version>
</dependency>

导入其他需要的依赖

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.38</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.22</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.12</version>
        </dependency>

第三步，配置日志文件log4j.properties在resources目录下

log4j.rootLogger=DEBUG,A1
log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=[%t][%c]-[%p]%m%n

第四步，在resources目录下创建mybatis的核心配置文件sqlMapConfig.xml文件，并且配置数据源

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTDConfig3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/db_mp_test"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
</configuration>

第五步，编写User实体类

public class User 
    private Long id;
    private String username;
    private String password;
    private String name;
    private Integer age;
    private String email;
    // 无参和全参构造器、get和set方法、toString方法

第六步，创建UserMapper接口

public interface UserMapper 
    List<User> findAll();

第六步，创建接口对应的UserMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTDMapper3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.demo.mapper.UserMapper">
    <select id="findAll" resultType="com.demo.bean.User">
        select * from tb_user
    </select>
</mapper>

在SqlMapConfig.xml配置文件中添加此映射

第七步，编写TestMybatis

public class TestMybatis 
    @Test
    public void testFindAll() throws IOException 
        InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        // 获取UserMapper接口
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        // 执行findAll方法
        List<User> userList = mapper.findAll();
        // 打印结果
        for (User user : userList) 
            System.out.println(user);

控制台打印如下：

2.1.2 使用Mybatis-Plus查询

在原生的Mybatis基础上使用Mybatis-Plus查询只需要进行两步操作：

第一步，将UserMapper继承BaseMapper<T>，将拥有BaseMapper中的所有方法。

第二步，将原来的SqlSessionFactoryBuilder替换成MybatisSqlSessionFactoryBuilder进行构建

public class TestMybatisPlus 
    @Test
    public void testFindAll() throws IOException 
        InputStream inputStream = Resources.getResourceAsStream("SqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new MybatisSqlSessionFactoryBuilder().build(inputStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        // 获取UserMapper接口
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        // 执行findAll方法
        List<User> userList = mapper.findAll();
        // 打印结果
        for (User user : userList) 
            System.out.println(user);

打印结果如下：

本节源码请参考：GitHub的Demo

2.2 Spring&Mybatis整合Mybatis-Plus

引入了spring框架，数据源、构建工作交由Spring来管理。

第一步，创建一个基于web的maven项目并导入相关的包

        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus</artifactId>
            <version>3.4.3</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.38</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.22</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.12</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.4</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.3.4</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.3.4</version>
        </dependency>

第二步，编写jdbc.properties，将链接数据库的参数配置在里面

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/db_mp_test
jdbc.username=root
jdbc.password=root

第二步，编写spring的配置文件applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
    <!--引入properties配置文件-->
    <context:property-placeholder location="classpath:jdbc.properties"/>

    <!--定义数据源-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="$jdbc.driver"/>
        <property name="url" value="$jdbc.url"/>
        <property name="username" value="$jdbc.username"/>
        <property name="password" value="$jdbc.password"/>
    </bean>

    <!--这里使用MybatisSqlSessionFactory，完成Spring与Mybatis-Plus的整合-->
    <bean id="sqlSessionFactory" class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!--扫描Mapper接口类，使用的是Mybatis原生的扫描器-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.demo.mapper"/>
    </bean>
</beans>

第三步，编写User实体类，使用@TableName("tb_user")注解映射数据库表和实体类的关系

@TableName("tb_user")
public class User 
    private Long id;
    private String username;
    private String password;
    private String name;
    private Integer age;
    private String email;
    // 无参和全参构造器、get和set方法、toString方法

第四步，创建UserMapper接口，只需要继承BaseMapper<T>类，不需要写任何方法

public interface UserMapper extends BaseMapper<User>

第五步，编写测试用例

public class TestMybatisPlus 

    @Test
    public void testFindAll() 
        ApplicationContext app = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        UserMapper userMapper = (UserMapper) app.getBean("userMapper");
        List<User> userList = userMapper.selectList(null);
        for (User user : userList) 
            System.out.println(user);

打印结果如下：

在本例中没有写Mapper.xml，也没有写mybatis的配置文件了。

本节源码参考：GitHub的Demo

2.3 SpringBoot、Mybatis整合Mybatis-Plus

第一步，创建一个基于web的maven工程，然后导入相关的依赖坐标

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-logging</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
        <!--mybatis-plus的springboot支持-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.1.1</version>
        </dependency>
        <!--mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.48</version>
        </dependency>
        <!--日志-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
        </dependency>

注意，还需要在pom.xml中引入parent

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.4.RELEASE</version>
    </parent>

第二步，日志文件log4j.properties如下，在resources目录下

log4j.rootLogger=DEBUG,A1
log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=[%t][%c]-[%p]%m%n

第三步，编写springboot的配置文件application.properties

spring.application.name=springboot-mybatisplus

# 配置数据源连接参数
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/db_mp_test
spring.datasource.username=root
spring.datasource.password=root

第四步，编写实体类User，使用@TableName("tb_user")注解完成实体类和数据库表的映射

@TableName("tb_user")
public class User 
    private Long id;
    private String username;
    private String password;
    private String name;
    private Integer age;
    private String email;
    // 无参和全参构造器、get和set方法、toString方法

第四步，创建UserMapper接口，只需要继承BaseMapper<T>类，不需要写任何方法

public interface UserMapper extends BaseMapper<User>

第五步，编写springboot启动类

@MapperScan("com.demo.mapper")// 设置mapper接口的扫描包
@SpringBootApplication
public class MainApplication 
    public static void main(String[] args) 
        SpringApplication.run(MainApplication.class, args);

第六步，编写测试类进行测试

@RunWith(SpringRunner.class)
@SpringBootTest
public class TestMybatisPlus 

    @Autowired
    private UserMapper userMapper;

    @Test
    public void testFindAll() 
        List<User> userList = userMapper.selectList(null);
        for (User user : userList) 
            System.out.println(user);

打印结果如下：

本节源码参考：GitHub的Demo

3. 通用增删改查

通过前面的学习，我们了解到通过继承BaseMapper就可以获取到各种各样的单表操作，接下来我们将详细讲解这些操作。

3.1 插入操作

3.1.1 insert

在BaseMapper中的insert方法如下：

// 插入一条记录，返回受影响的行数
int insert(T entity);

测试方法如下：

public class TestMybatisPlus 

    @Test
    public void testInsert() 
        ApplicationContext app = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        UserMapper userMapper = (UserMapper) app.getBean("userMapper");
        // 创建测试实体类并封装数据
        User user = new User();
        user.setUsername("tangseng");
        user.setPassword("123456");
        user.setName("唐僧");
        user.setAge(18);
        user.setEmail("tangseng@qq.com");
        // 调用insert方法进行插入操作，返回受影响的行数
        int result = userMapper.insert(user);
        // 打印结果
        System.out.println("受影响行数：" + result);// 打印受影响行数
        System.out.println(user.getId());// 自增后的id会回填到对象中

3.1.2 @TableId

虽然数据写入到数据库中，但是id值不正确，我们期望数据库id主键自增长，实际是MybatisPlus生成了id的值写入到了数据库中。

但我们可以通过设置id的生成策略来进行设置。

Mybatis支持的id策略，可以查看IdType枚举类。

public enum IdType 
    AUTO(0),// 数据库ID自增
    NONE(1),//该类型为未设置主键类型
    INPUT(2),// 用户输入ID
    ASSIGN_ID(3),
    ASSIGN_UUID(4);

    private final int key;

    private IdType(int key) 
        this.key = key;
    

    public int getKey() 
        return this.key;

所以，如果我们想要id值自增长，可以在实体类的id字段上添加@TableId(type=IdType.AUTO)注解来指定id类型为自增长。

@TableName("tb_user")
public class User 
    @TableId(type = IdType.AUTO)// 设置id字段为自增长
    private Long id;
    private String username;
    private String password;
    private String name;
    private Integer age;
    private String email;
    // 无参和全参构造器、get和set方法、toString方法

再来执行测试，就会发现id字段是自增长了，并且这条插入数据的id会封装在User对象中返回。

3.1.3 @TableField

在MybatisPlus中通过@TableField注解可以指定字段的一些属性，常解决的问题有：

对象中的属性名和数据库表中的字段名不一致的问题，如非驼峰。
对象中属性字段在数据库表中不存在的问题。

3.2 更新操作

更新操作有2种，一种是根据id更新，另一种是根据条件更新。

3.2.1 updateById

方法的定义是：

// 根据ID进行更新数据库表记录，返回受影响行数
int updateById(@Param(Constants.ENTITY) T entity);

使用示例如下：

    @Test
    public void testUpdateById() 
        ApplicationContext app = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        UserMapper userMapper = (UserMapper) app.getBean("userMapper");
        // 创建要更新的字段，将主键id字段和其他要更新的字段封装在对象中
        User user = new User();
        user.setId(4L);// 待更新的主键ID
        user.setPassword("abcdef");// 更新的字段
        user.setAge(22);// 更新的字段
        // 调用updateById方法进行更新操作，返回受影响的行数
        int result = userMapper.updateById(user);
        System.out.println("受影响的行数：" + result);

3.2.2 update

根据条件更新的方法如下：

// 根据where多条件更新记录
// 有两个参数：第一个参数是entity指的是实体对象（set 条件值，可以为null）
// 第二个参数updateWrapper是实体对象封装操作类（可以为null，里面的entity用于生成where语句）
int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> updateWrapper);

使用示例如下：

    @Test
    public void testUpdate() 
        ApplicationContext app = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        UserMapper userMapper = (UserMapper) app.getBean("userMapper");
        // 创建要更新的字段，将主键id字段和其他要更新的字段封装在对象中
        User user = new User();
        user.setPassword("abcdef");// 更新的字段
        user.setAge(22);// 更新的字段
        // 添加更新的条件
        QueryWrapper<User> wrapper = new QueryWrapper<User>();
        wrapper.eq("id", 6);
        // 执行更新操作
        // 第一个参数是设置SQL语句中的set后面的参数（如set username='zhangsan',age=13）
        // 第二个参数是设置SQL语句中的where后面的参数（如where id=3 and name='张三'）
        int result = userMapper.update(user, wrapper);
        System.out.println("受影响的行数：" + result);

也可以通过UpdateWrapper类来封装条件和更新的参数。

    @Test
    public void testUpdate2() 
        ApplicationContext app = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        UserMapper userMapper = (UserMapper) app.getBean("userMapper");
        // 设置更新的条件及更新的字段
        UpdateWrapper<User> wrapper = new UpdateWrapper<User>();
        // eq相当于设置where后面的条件；set相当于设置set后面的字段
        wrapper.eq("id", 6).set("password", "123456");
        // 执行更新操作
        int result = userMapper.update(null, wrapper);
        System.out.println("受影响的行数：" + result);

3.3 删除操作

3.3.1 deleteById

方法如下：

// 根据id进行删除记录，返回受影响的行数
int deleteById(Serializable id);

使用示例如下：

    @Test
    public void testDeleteById() 
        ApplicationContext app = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        UserMapper userMapper = (UserMapper) app.getBean("userMapper");
        // 执行删除操作
        int result = userMapper.deleteById(5L);
        System.out.println("受影响的行数：" + result);

3.3.2 deleteByMap

方法定义如下：

// 根据条件删除记录，columnMap是一个Map集合，存储着条件字段和对应的值
int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);

示例如下：

    @Test
    public void testDeleteByMap() 
        ApplicationContext app = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        UserMapper userMapper = (UserMapper) app.getBean("userMapper");
        // 将条件放到集合中
        Map<String, Object> columnMap = new HashMap<String, Object>();
        columnMap.put("age", "20");
        columnMap.put("name", "张三");
        // 执行多条件删除操作，多个条件之间为AND关系
        int result = userMapper.deleteByMap(columnMap);
        System.out.println("受影响的行数：" + result);

3.3.3 delete

方法定义：

// 根据实体类条件，删除记录，wrapper就是实体类对象封装操作类，可以为null
int delete(@Param(Constants.WRAPPER) Wrapper<T> wrapper);

示例如下：

    @Test
    public void testDelete() 
        ApplicationContext app = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        UserMapper userMapper = (UserMapper) app.getBean("userMapper");
        // 封装条件
        User user = new User();
        user.setAge(20);
        user.setId(3L);
        user.setName("李四");
        // 将实体对象进行封装，包装为操作条件
        QueryWrapper<User> wrapper = new QueryWrapper<User>(user);
        // 执行删除操作，多个条件之间为AND关系
        int result = userMapper.delete(wrapper);
        System.out.println("受影响的行数：" + result);

3.3.4 deleteBatchIds

批量按照id进行删除，方法定义如下：

// 删除，根据id批量删除
int deleteBatchIds(@Param("coll") Collection<? extends Serializable> idList);

示例如下：

    @Test
    public void testDeleteBatchIds() 
        ApplicationContext app = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        UserMapper userMapper = (UserMapper) app.getBean("userMapper");
        // 将要删除的id放到集合中
        List<Long> list = new ArrayList<Long>();
        list.add(1L);
        list.add(12L);
        list.add(22L);
        // 根据id集合批量删除
        int result = userMapper.deleteBatchIds(list);
        System.out.println("受影响的行数：" + result);

3.4 查询操作

3.4.1 selectById

方法定义如下：

// 根据id进行查询
T selectById(Serializable id);

示例如下：

    @Test
    public void testSelectById() 
        ApplicationContext app = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        UserMapper userMapper = (UserMapper) app.getBean("userMapper");
        // 根据id进行查询
        User user = userMapper.selectById(2L);
        System.out.println(user);

3.4.2 selectBatchIds

方法定义：

// 根据id集合批量查询，返回实体类集合
List<T> selectBatchIds(@Param("coll") Collection<? extends Serializable> idList);

示例：

    @Test
    public void testSelectBatchIds() 
        ApplicationContext app = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        UserMapper userMapper = (UserMapper) app.getBean("userMapper");
        // 根据id集合进行查询
        List<Long> idList = new ArrayList<Long>();
        idList.add(1L);
        idList.add(2L);
        idList.add(3L);
        idList.add(4L);
        // 调用方法进行查询
        List<User> userList = userMapper.selectBatchIds(idList);
        for (User user : userList) 
            System.out.println(user);

3.4.3 selectOne

方法如下：

// 查询一条数据
T selectOne(@Param("ew") Wrapper<T> queryWrapper);

示例：

    @Test
    public void testSelectOne() 
        ApplicationContext app = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        UserMapper userMapper = (UserMapper) app.getBean("userMapper");
        // 设定条件
        QueryWrapper<User> wrapper = new QueryWrapper<User>();
        wrapper.eq("name", "李四");
        // 根据条件查询一条数据，如果结果超过一条就会报错
        User user = userMapper.selectOne(wrapper);
        System.out.println(user);

3.4.4 selectCount

方法定义：

// 根据wrapper条件，查询总记录数，其中参数可以为null
Integer selectCount(@Param("ew") Wrapper<T> queryWrapper);

示例如下：

    @Test
    public void testSelectCount() 
        ApplicationContext app = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        UserMapper userMapper = (UserMapper) app.getBean("userMapper");
        // 设定条件
        QueryWrapper<User> wrapper = new QueryWrapper<User>();
        wrapper.gt("age", 15);// 查询年龄大于15岁的人
        // 根据条件查询记录总数
        Integer count = userMapper.selectCount(wrapper);
        System.out.println("记录总数：" + count);

3.4.5 selectList

方法定义：

// 根据条件查询符合条件的全部记录
List<T> selectList(@Param("ew") Wrapper<T> queryWrapper);

示例：

    @Test
    public void testSelectList() 
        ApplicationContext app = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        UserMapper userMapper = (UserMapper) app.getBean("userMapper");
        // 设定条件
        QueryWrapper<User> wrapper = new QueryWrapper<User>();
        wrapper.gt("age", 15);// 查询年龄大于15岁的人
        // 根据条件查询记录
        List<User> userList = userMapper.selectList(wrapper);
        for (User user : userList) 
            System.out.println(user);

3.4.6 selectPage

该方法是分页查询，方法的定义：

// 根据条件分页查询记录，第一个参数分页查询条件，第二个参数为对象封装操作类（可以为null）
IPage<T> selectPage(IPage<T> page, @Param("ew") Wrapper<T> queryWrapper);

在使用该方法之前，现需要配置分页插件，如果是spring整合MybatisPlus，则需要在spring的核心配置文件中添加如下内容：

    <!--这里使用MybatisSqlSessionFactory，完成Spring与Mybatis-Plus的整合-->
    <bean id="sqlSessionFactory" class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!-- spring xml 方式 -->
        <property name="plugins">
            <array>
                <bean class="com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor">
                    <!-- COUNT SQL 解析.可以没有 -->
                    <property name="countSqlParser" ref="countSqlParser"/>
                </bean>
            </array>
        </property>
    </bean>
    <bean id="countSqlParser" class="com.baomidou.mybatisplus.extension.plugins.pagination.optimize.JsqlParserCountOptimize">
        <!-- 设置为 true 可以优化部分 left join 的sql -->
        <property name="optimizeJoin" value="true"/>
    </bean>

如果是SpringBoot整合MybatisPlus则需要创建一个配置类，类中如下内容：

@Configuration
@MapperScan("com.demo.mapper")
public class CustomMyBatisPlusConfig 

    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() 
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(paginationInnerInterceptor());
        return interceptor;
    

    @Bean
    public PaginationInnerInterceptor paginationInnerInterceptor() 
        PaginationInnerInterceptor page = new PaginationInnerInterceptor();
        page.setDbType(DbType.MYSQL);
        return page;

示例如下：

    @Test
    public void testSelectPage() 
        ApplicationContext app = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        UserMapper userMapper = (UserMapper) app.getBean("userMapper");
        // 设定分页参数，第一个参数是页码（从1开始），第二个参数是页显示条数
        Page<User> page = new Page<User>(1L, 2L);
        // 设定筛选条件
        QueryWrapper<User> wrapper = new QueryWrapper<User>();
        wrapper.gt("age", 15);// 查询年龄大于15岁的人
        // 根据条件查询记录
        IPage<User> userPage = userMapper.selectPage(page, null);
        System.out.println("数据总条数：" + userPage.getTotal());
        System.out.println("总页数：" + userPage.getPages());
        // 打印分页记录
        List<User> userList = userPage.getRecords();// 获取分页记录数
        for (User user : userList) 
            System.out.println(user);

打印结果如下：

本节源码参考：GitHub的Demo

4. 配置

Mybatis-Plus各种配置的官方参考文档：mybatis.plus

4.1 基本配置

4.1.1 configLocation

MyBatis 配置文件位置，如果您有单独的 MyBatis 配置，请将其路径配置到 configLocation 中。 MyBatisConfiguration 的具体内容请参考MyBatis 官方文档。

spring整合mybatis-plus，SqlMapConfig.xml配置文件是mybatis的配置文件

<bean id="sqlSessionFactory" class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">
    <property name="configLocation" value="classpath:SqlMapConfig.xml"/>
</bean>

springboot整合mybatis-plus，需要在application.properties中配置：

mybatis-plus.config-location = classpath:SqlMapConfig.xml

4.1.2 mapperLocations

MyBatis Mapper 所对应的 XML 文件位置，如果您在 Mapper 中有自定义方法（XML 中有自定义实现），需要进行该配置，告诉 Mapper 所对应的 XML 文件位置。

spring整合mybatis-plus：

    <bean id="sqlSessionFactory" class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">
        <property name="mapperLocations" value="classpath*:com/demo/mapper/*.xml"/>
    </bean>

springboot整合mybatis-plus，需要在application.properties中配置：

mybatis-plus.mapper-locations = classpath*:com/demo/mapper/*.xml

注意：maven多模块的扫描路径以classpath*:开头，即加载多个jar包下的XML文件。

UserMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.demo.mapper.UserMapper">
    <select id="findAll" resultType="com.demo.bean.User">
        select * from tb_user
    </select>
</mapper>

UserMapper.java

public interface UserMapper extends BaseMapper<User> 
    List<User> findAll();

进行测试

    @Test
    public void testFindAll()
        ApplicationContext app = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
        UserMapper userMapper = (UserMapper) app.getBean("userMapper");
        List<User> all = userMapper.findAll();
        for (User user : all) 
            System.out.println(user);

4.1.3 typeAliasesPackage

MyBaits 别名包扫描路径，通过该属性可以给包中的类注册别名，注册后在 Mapper 对应的 XML 文件中可以直接使用类名，而不用使用全限定的类名（即 XML 中调用的时候不用包含包名）。

spring整合mybatis-plus：

    <bean id="sqlSessionFactory" class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">
        <property name="typeAliasesPackage" value="com.demo.bean"/>
    </bean>

springboot整合mybatis-plus，需要在application.properties中配置：

mybatis-plus.type-aliases-package = com.demo.bean

注意，这里IDEA工具会爆红，但是代码是能够运行成功的，因为已经成功配置了的。

4.2 进阶配置

本部分（Configuration）的配置大都为 MyBatis 原生支持的配置，这意味着您可以通过 MyBatis XML 配置文件的形式进行配置。

4.2.1 mapUnderscoreToCamelCase

该配置表示十分开启自动驼峰命名规则（camel case）映射，即从数据库列名如user_name到Java属性名userName（驼峰命名）的映射。

该属性是一个Boolean类型，默认值是true，表示开启了自动驼峰命名规则映射。

注意：此属性在 MyBatis 中原默认值为 false，在 MyBatis-Plus 中，此属性也将用于生成最终的 SQL 的 select body如果您的数据库命名符合规则无需使用@TableField注解指定数据库字段名。

springboot整合mybatis-plus，需要在application.properties中配置ÿ

以上是关于Mybatis-Plus学习笔记的主要内容，如果未能解决你的问题，请参考以下文章

Mybatis-Plus学习笔记

Mybatis-Plus入门学习笔记

Spring boot + mybatis-plus 遇到数据库字段创建不规范大驼峰下划线导致前端传参数后端收不到参数解决方案

Mybatis-Plus学习笔记

Mybatis-plus工具学习笔记---[基本概述,入门案例搭建,通用service接口使用]

MyBatis-Plus-自动填充功能（学习笔记）