mybatis-plus教程-Mybatis-Plus增删改查

- 日理万妓 2023-06-13 08:54 128阅读 0赞

## 完整代码 ##

[https://github.com/pbteach/mybatis-plus-test][https_github.com_pbteach_mybatis-plus-test]

## Mybatis-plus增删改查 ##

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

![1556351189202][]

### 插入操作 ###

#### 方法定义 ####

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

#### 测试用例 ####

package com.pbteach.mp;
    
    import com.pbteach.mp.mapper.UserMapper;
    import com.pbteach.mp.pojo.User;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.test.context.junit4.SpringRunner;
    
    import java.util.List;
    
    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class UserMapperTest { 
    
        @Autowired
        private UserMapper userMapper;
    
        @Test
        public void testInsert(){ 
            User user = new User();
            user.setAge(20);
            user.setEmail("test@pbteach.com");
            user.setName("曹操");
            user.setUserName("caocao");
            user.setPassword("123456");
    
            int result = this.userMapper.insert(user); //返回的result是受影响的行数，并不是自增后的id
            System.out.println("result = " + result); 
    
            System.out.println(user.getId()); //自增后的id会回填到对象中
        }
    
    }

#### 测试 ####

[main] [com.pbteach.mp.mapper.UserMapper.insert]-[DEBUG] ==>  Preparing: INSERT INTO tb_user ( id, user_name, password, name, age, email ) VALUES ( ?, ?, ?, ?, ?, ? ) 
    [main] [com.pbteach.mp.mapper.UserMapper.insert]-[DEBUG] ==> Parameters: 1122045867793072130(Long), caocao(String), 123456(String), 曹操(String), 20(Integer), test@pbteach.com(String)
    [main] [com.pbteach.mp.mapper.UserMapper.insert]-[DEBUG] <==    Updates: 1
    [main] [org.mybatis.spring.SqlSessionUtils]-[DEBUG] Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@411291e5]
    result = 1
    1122045867793072130

![1573691210439][]

可以看到，数据已经写入到了数据库，但是，id的值不正确，我们期望的是数据库自增长，实际是MP生成了id的值写入到了数据库。

如何设置id的生成策略呢？

MP支持的id策略：

package com.baomidou.mybatisplus.annotation;
    
    import lombok.Getter;
    
    /** * 生成ID类型枚举类 * * @author hubin * @since 2015-11-10 */
    @Getter
    public enum IdType { 
        /** * 数据库ID自增 */
        AUTO(0),
        /** * 该类型为未设置主键类型 */
        NONE(1),
        /** * 用户输入ID * <p>该类型可以通过自己注册自动填充插件进行填充</p> */
        INPUT(2),
    
        /* 以下3种类型、只有当插入对象ID 为空，才自动填充。 */
        /** * 全局唯一ID (idWorker) */
        ID_WORKER(3),
        /** * 全局唯一ID (UUID) */
        UUID(4),
        /** * 字符串全局唯一ID (idWorker 的字符串表示) */
        ID_WORKER_STR(5);
    
        private final int key;
    
        IdType(int key) { 
            this.key = key;
        }
    }

修改User对象：

package com.pbteach.mp.pojo;
    
    import com.baomidou.mybatisplus.annotation.IdType;
    import com.baomidou.mybatisplus.annotation.TableId;
    import com.baomidou.mybatisplus.annotation.TableName;
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    @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;
    }

数据插入成功：

![1573691233384][]

#### @TableField ####

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

1、对象中的属性名和字段名不一致的问题（非驼峰）

2、对象中的属性字段在表中不存在的问题

使用：

![1556362315190][]

其他用法，如大字段不加入查询字段：

![1556362597538][]

效果：

![1556362621608][]

### 更新操作 ###

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

#### 根据id更新 ####

方法定义：

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

测试：

@RunWith(SpringRunner.class)
    @SpringBootTest
    public class UserMapperTest { 
    
        @Autowired
        private UserMapper userMapper;
    
        @Test
        public void testUpdateById() { 
            User user = new User();
            user.setId(6L); //主键
            user.setAge(21); //更新的字段
    
            //根据id更新，更新不为null的字段
            this.userMapper.updateById(user);
        }
    
    }

结果：

[main] [com.pbteach.mp.mapper.UserMapper.updateById]-[DEBUG] ==>  Preparing: UPDATE tb_user SET age=? WHERE id=? 
    [main] [com.pbteach.mp.mapper.UserMapper.updateById]-[DEBUG] ==> Parameters: 21(Integer), 6(Long)
    [main] [com.pbteach.mp.mapper.UserMapper.updateById]-[DEBUG] <==    Updates: 1

![1573691255238][]

#### 根据条件更新 ####

方法定义：

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

测试用例：

package com.pbteach.mp;
    
    import com.pbteach.mp.mapper.UserMapper;
    import com.pbteach.mp.pojo.User;
    import com.baomidou.mybatisplus.core.conditions.Wrapper;
    import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
    import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
    import net.minidev.json.writer.UpdaterMapper;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.test.context.junit4.SpringRunner;
    
    import java.util.List;
    
    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class UserMapperTest { 
    
        @Autowired
        private UserMapper userMapper;
    
        @Test
        public void testUpdate() { 
            User user = new User();
            user.setAge(22); //更新的字段
    
            //更新的条件
            QueryWrapper<User> wrapper = new QueryWrapper<>();
            wrapper.eq("id", 6);
    
            //执行更新操作
            int result = this.userMapper.update(user, wrapper);
            System.out.println("result = " + result);
        }
    
    }

或者，通过UpdateWrapper进行更新：

@Test
        public void testUpdate() { 
            //更新的条件以及字段
            UpdateWrapper<User> wrapper = new UpdateWrapper<>();
            wrapper.eq("id", 6).set("age", 23);
    
            //执行更新操作
            int result = this.userMapper.update(null, wrapper);
            System.out.println("result = " + result);
        }

测试结果：

[main] [com.pbteach.mp.mapper.UserMapper.update]-[DEBUG] ==>  Preparing: UPDATE tb_user SET age=? WHERE id = ? 
    [main] [com.pbteach.mp.mapper.UserMapper.update]-[DEBUG] ==> Parameters: 23(Integer), 6(Integer)
    [main] [com.pbteach.mp.mapper.UserMapper.update]-[DEBUG] <==    Updates: 1

均可达到更新的效果。

关于wrapper更多的用法后面会详细讲解。

### 删除操作 ###

#### deleteById ####

方法定义：

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

测试用例：

package com.pbteach.mp;
    
    import com.pbteach.mp.mapper.UserMapper;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.test.context.junit4.SpringRunner;
    
    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class UserMapperTest { 
    
        @Autowired
        private UserMapper userMapper;
    
        @Test
        public void testDeleteById() { 
            //执行删除操作
            int result = this.userMapper.deleteById(6L);
            System.out.println("result = " + result);
        }
    
    }

结果：

[main] [com.pbteach.mp.mapper.UserMapper.deleteById]-[DEBUG] ==>  Preparing: DELETE FROM tb_user WHERE id=? 
    [main] [com.pbteach.mp.mapper.UserMapper.deleteById]-[DEBUG] ==> Parameters: 6(Long)
    [main] [com.pbteach.mp.mapper.UserMapper.deleteById]-[DEBUG] <==    Updates: 1

![1573691274395][]

数据被删除。

#### deleteByMap ####

方法定义：

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

测试用例：

package com.pbteach.mp;
    
    import com.pbteach.mp.mapper.UserMapper;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.test.context.junit4.SpringRunner;
    
    import java.util.HashMap;
    import java.util.Map;
    
    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class UserMapperTest { 
    
        @Autowired
        private UserMapper userMapper;
    
        @Test
        public void testDeleteByMap() { 
            Map<String, Object> columnMap = new HashMap<>();
            columnMap.put("age",20);
            columnMap.put("name","张三");
    
            //将columnMap中的元素设置为删除的条件，多个之间为and关系
            int result = this.userMapper.deleteByMap(columnMap);
            System.out.println("result = " + result);
        }
    
    }

结果：

[main] [com.pbteach.mp.mapper.UserMapper.deleteByMap]-[DEBUG] ==>  Preparing: DELETE FROM tb_user WHERE name = ? AND age = ? 
    [main] [com.pbteach.mp.mapper.UserMapper.deleteByMap]-[DEBUG] ==> Parameters: 张三(String), 20(Integer)
    [main] [com.pbteach.mp.mapper.UserMapper.deleteByMap]-[DEBUG] <==    Updates: 0

#### delete ####

方法定义：

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

测试用例：

package com.pbteach.mp;
    
    import com.pbteach.mp.mapper.UserMapper;
    import com.pbteach.mp.pojo.User;
    import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.test.context.junit4.SpringRunner;
    
    import java.util.HashMap;
    import java.util.Map;
    
    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class UserMapperTest { 
    
        @Autowired
        private UserMapper userMapper;
    
        @Test
        public void testDeleteByMap() { 
            User user = new User();
            user.setAge(20);
            user.setName("张三");
    
            //将实体对象进行包装，包装为操作条件
            QueryWrapper<User> wrapper = new QueryWrapper<>(user);
    
            int result = this.userMapper.delete(wrapper);
            System.out.println("result = " + result);
        }
    
    }

结果：

[main] [com.pbteach.mp.mapper.UserMapper.delete]-[DEBUG] ==>  Preparing: DELETE FROM tb_user WHERE name=? AND age=? 
    [main] [com.pbteach.mp.mapper.UserMapper.delete]-[DEBUG] ==> Parameters: 张三(String), 20(Integer)
    [main] [com.pbteach.mp.mapper.UserMapper.delete]-[DEBUG] <==    Updates: 0

#### deleteBatchIds ####

方法定义：

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

测试用例：

package com.pbteach.mp;
    
    import com.pbteach.mp.mapper.UserMapper;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.test.context.junit4.SpringRunner;
    
    import java.util.Arrays;
    
    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class UserMapperTest { 
    
        @Autowired
        private UserMapper userMapper;
    
        @Test
        public void testDeleteByMap() { 
            //根据id集合批量删除
            int result = this.userMapper.deleteBatchIds(Arrays.asList(1L,10L,20L));
            System.out.println("result = " + result);
        }
    
    }

结果：

[main] [com.pbteach.mp.mapper.UserMapper.deleteBatchIds]-[DEBUG] ==>  Preparing: DELETE FROM tb_user WHERE id IN ( ? , ? , ? ) 
    [main] [com.pbteach.mp.mapper.UserMapper.deleteBatchIds]-[DEBUG] ==> Parameters: 1(Long), 10(Long), 20(Long)
    [main] [com.pbteach.mp.mapper.UserMapper.deleteBatchIds]-[DEBUG] <==    Updates: 1

### 查询操作 ###

MP提供了多种查询操作，包括根据id查询、批量查询、查询单条数据、查询列表、分页查询等操作。

#### selectById ####

方法定义：

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

测试用例：

结果：

[main] [com.pbteach.mp.mapper.UserMapper.selectById]-[DEBUG] ==>  Preparing: SELECT id,user_name,password,name,age,email FROM tb_user WHERE id=? 
    [main] [com.pbteach.mp.mapper.UserMapper.selectById]-[DEBUG] ==> Parameters: 2(Long)
    [main] [com.pbteach.mp.mapper.UserMapper.selectById]-[DEBUG] <==      Total: 1
    
    result = User(id=2, userName=lisi, password=123456, name=李四, age=20, email=test2@pbteach.com, address=null)

#### selectBatchIds ####

方法定义：

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

测试用例：

package com.pbteach.mp;
    
    import com.pbteach.mp.mapper.UserMapper;
    import com.pbteach.mp.pojo.User;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.test.context.junit4.SpringRunner;
    
    import java.util.Arrays;
    import java.util.List;
    
    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class UserMapperTest { 
    
        @Autowired
        private UserMapper userMapper;
    
        @Test
        public void testSelectBatchIds() { 
            //根据id集合批量查询
            List<User> users = this.userMapper.selectBatchIds(Arrays.asList(2L, 3L, 10L));
            for (User user : users) { 
                System.out.println(user);
            }
        }
    
    }

结果：

[main] [com.pbteach.mp.mapper.UserMapper.selectBatchIds]-[DEBUG] ==>  Preparing: SELECT id,user_name,password,name,age,email FROM tb_user WHERE id IN ( ? , ? , ? ) 
    [main] [com.pbteach.mp.mapper.UserMapper.selectBatchIds]-[DEBUG] ==> Parameters: 2(Long), 3(Long), 10(Long)
    [main] [com.pbteach.mp.mapper.UserMapper.selectBatchIds]-[DEBUG] <==      Total: 2
    
    User(id=2, userName=lisi, password=123456, name=李四, age=20, email=test2@pbteach.com, address=null)
    User(id=3, userName=wangwu, password=123456, name=王五, age=28, email=test3@pbteach.com, address=null)

#### selectOne ####

方法定义：

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

测试用例：

package com.pbteach.mp;
    
    import com.pbteach.mp.mapper.UserMapper;
    import com.pbteach.mp.pojo.User;
    import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.test.context.junit4.SpringRunner;
    
    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class UserMapperTest { 
    
        @Autowired
        private UserMapper userMapper;
    
        @Test
        public void testSelectOne() { 
            QueryWrapper<User> wrapper = new QueryWrapper<User>();
            wrapper.eq("name", "李四");
    
            //根据条件查询一条数据，如果结果超过一条会报错
            User user = this.userMapper.selectOne(wrapper);
            System.out.println(user);
        }
    
    }

结果：

[main] [com.pbteach.mp.mapper.UserMapper.selectOne]-[DEBUG] ==>  Preparing: SELECT id,user_name,password,name,age,email FROM tb_user WHERE name = ? 
    [main] [com.pbteach.mp.mapper.UserMapper.selectOne]-[DEBUG] ==> Parameters: 李四(String)
    [main] [com.pbteach.mp.mapper.UserMapper.selectOne]-[DEBUG] <==      Total: 1
    
    User(id=2, userName=lisi, password=123456, name=李四, age=20, email=test2@pbteach.com, address=null)

#### selectCount ####

方法定义：

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

测试用例：

package com.pbteach.mp;
    
    import com.pbteach.mp.mapper.UserMapper;
    import com.pbteach.mp.pojo.User;
    import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.test.context.junit4.SpringRunner;
    
    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class UserMapperTest { 
    
        @Autowired
        private UserMapper userMapper;
    
        @Test
        public void testSelectCount() { 
            QueryWrapper<User> wrapper = new QueryWrapper<User>();
            wrapper.gt("age", 23); //年龄大于23岁
    
            //根据条件查询数据条数
            Integer count = this.userMapper.selectCount(wrapper);
            System.out.println("count = " + count);
        }
    
    }

结果：

[main] [com.pbteach.mp.mapper.UserMapper.selectCount]-[DEBUG] ==>  Preparing: SELECT COUNT( 1 ) FROM tb_user WHERE age > ? 
    [main] [com.pbteach.mp.mapper.UserMapper.selectCount]-[DEBUG] ==> Parameters: 23(Integer)
    [main] [com.pbteach.mp.mapper.UserMapper.selectCount]-[DEBUG] <==      Total: 1
    
    count = 2

#### selectList ####

方法定义：

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

测试用例：

package com.pbteach.mp;
    
    import com.pbteach.mp.mapper.UserMapper;
    import com.pbteach.mp.pojo.User;
    import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.test.context.junit4.SpringRunner;
    
    import java.util.List;
    
    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class UserMapperTest { 
    
        @Autowired
        private UserMapper userMapper;
    
        @Test
        public void testSelectList() { 
            QueryWrapper<User> wrapper = new QueryWrapper<User>();
            wrapper.gt("age", 23); //年龄大于23岁
    
            //根据条件查询数据
            List<User> users = this.userMapper.selectList(wrapper);
            for (User user : users) { 
                System.out.println("user = " + user);
            }
        }
    
    }

结果：

[main] [com.pbteach.mp.mapper.UserMapper.selectList]-[DEBUG] ==>  Preparing: SELECT id,user_name,password,name,age,email FROM tb_user WHERE age > ? 
    [main] [com.pbteach.mp.mapper.UserMapper.selectList]-[DEBUG] ==> Parameters: 23(Integer)
    [main] [com.pbteach.mp.mapper.UserMapper.selectList]-[DEBUG] <==      Total: 2
    
    user = User(id=3, userName=wangwu, password=123456, name=王五, age=28, email=test3@pbteach.com, address=null)
    user = User(id=5, userName=sunqi, password=123456, name=孙七, age=24, email=test5@pbteach.com, address=null)

#### selectPage ####

方法定义：

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

配置分页插件：

package com.pbteach.mp;
    
    import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
    import org.mybatis.spring.annotation.MapperScan;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    @Configuration
    @MapperScan("com.pbteach.mp.mapper") //设置mapper接口的扫描包
    public class MybatisPlusConfig { 
    
        /** * 分页插件 */
        @Bean
        public PaginationInterceptor paginationInterceptor() { 
            return new PaginationInterceptor();
        }
    }

测试用例：

package com.pbteach.mp;
    
    import com.pbteach.mp.mapper.UserMapper;
    import com.pbteach.mp.pojo.User;
    import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
    import com.baomidou.mybatisplus.core.metadata.IPage;
    import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.test.context.junit4.SpringRunner;
    
    import java.util.List;
    
    @RunWith(SpringRunner.class)
    @SpringBootTest
    public class UserMapperTest { 
    
        @Autowired
        private UserMapper userMapper;
    
        @Test
        public void testSelectPage() { 
            QueryWrapper<User> wrapper = new QueryWrapper<User>();
            wrapper.gt("age", 20); //年龄大于20岁
    
            Page<User> page = new Page<>(1,1);
    
            //根据条件查询数据
            IPage<User> iPage = this.userMapper.selectPage(page, wrapper);
            System.out.println("数据总条数：" + iPage.getTotal());
            System.out.println("总页数：" + iPage.getPages());
    
    
            List<User> users = iPage.getRecords();
            for (User user : users) { 
                System.out.println("user = " + user);
            }
        }
    
    }

结果：

[main] [com.pbteach.mp.mapper.UserMapper.selectPage]-[DEBUG] ==>  Preparing: SELECT COUNT(1) FROM tb_user WHERE age > ? 
    [main] [com.pbteach.mp.mapper.UserMapper.selectPage]-[DEBUG] ==> Parameters: 20(Integer)
    [main] [com.pbteach.mp.mapper.UserMapper.selectPage]-[DEBUG] ==>  Preparing: SELECT id,user_name,password,name,age,email FROM tb_user WHERE age > ? LIMIT ?,? 
    [main] [com.pbteach.mp.mapper.UserMapper.selectPage]-[DEBUG] ==> Parameters: 20(Integer), 0(Long), 1(Long)
    [main] [com.pbteach.mp.mapper.UserMapper.selectPage]-[DEBUG] <==      Total: 1
    [main] [org.mybatis.spring.SqlSessionUtils]-[DEBUG] Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@6ecd665]
    数据总条数：3
    总页数：3
    user = User(id=3, userName=wangwu, password=123456, name=王五, age=28, email=test3@pbteach.com, address=null)

### SQL注入的原理 ###

前面我们已经知道，MP在启动后会将BaseMapper中的一系列的方法注册到meppedStatements中，那么究竟是如何注入的呢？流程又是怎么样的？下面我们将一起来分析下。

在MP中，ISqlInjector负责SQL的注入工作，它是一个接口，AbstractSqlInjector是它的实现类，实现关系如下：

![1556433826583][]

在AbstractSqlInjector中，主要是由inspectInject()方法进行注入的，如下：

@Override
    public void inspectInject(MapperBuilderAssistant builderAssistant, Class<?> mapperClass) { 
        Class<?> modelClass = extractModelClass(mapperClass);
        if (modelClass != null) { 
            String className = mapperClass.toString();
            Set<String> mapperRegistryCache = GlobalConfigUtils.getMapperRegistryCache(builderAssistant.getConfiguration());
            if (!mapperRegistryCache.contains(className)) { 
                List<AbstractMethod> methodList = this.getMethodList();
                if (CollectionUtils.isNotEmpty(methodList)) { 
                    TableInfo tableInfo = TableInfoHelper.initTableInfo(builderAssistant, modelClass);
                    // 循环注入自定义方法
                    methodList.forEach(m -> m.inject(builderAssistant, mapperClass, modelClass, tableInfo));
                } else { 
                    logger.debug(mapperClass.toString() + ", No effective injection method was found.");
                }
                mapperRegistryCache.add(className);
            }
        }
    }

在实现方法中，`methodList.forEach(m -> m.inject(builderAssistant, mapperClass, modelClass, tableInfo));`是关键，循环遍历方法，进行注入。

最终调用抽象方法injectMappedStatement进行真正的注入：

/** * 注入自定义 MappedStatement * * @param mapperClass mapper 接口 * @param modelClass mapper 泛型 * @param tableInfo 数据库表反射信息 * @return MappedStatement */
        public abstract MappedStatement injectMappedStatement(Class<?> mapperClass, Class<?> modelClass, TableInfo tableInfo);

查看该方法的实现：

![1556434252779][]

以SelectById为例查看：

public class SelectById extends AbstractMethod { 
    
        @Override
        public MappedStatement injectMappedStatement(Class<?> mapperClass, Class<?> modelClass, TableInfo tableInfo) { 
            SqlMethod sqlMethod = SqlMethod.LOGIC_SELECT_BY_ID;
            SqlSource sqlSource = new RawSqlSource(configuration, String.format(sqlMethod.getSql(),
                sqlSelectColumns(tableInfo, false),
                tableInfo.getTableName(), tableInfo.getKeyColumn(), tableInfo.getKeyProperty(),
                tableInfo.getLogicDeleteSql(true, false)), Object.class);
            return this.addSelectMappedStatement(mapperClass, sqlMethod.getMethod(), sqlSource, modelClass, tableInfo);
        }
    }

可以看到，生成了SqlSource对象，再将SQL通过addSelectMappedStatement方法添加到meppedStatements中。

![1556435280979][]

public abstract MappedStatement injectMappedStatement(Class<?> mapperClass, Class<?> modelClass, TableInfo tableInfo);

查看该方法的实现：
    
     [外链图片转存中...(img-7KAuG7HQ-1573778210222)]
    
    以SelectById为例查看：
    
    ```java
    public class SelectById extends AbstractMethod {
    
        @Override
        public MappedStatement injectMappedStatement(Class<?> mapperClass, Class<?> modelClass, TableInfo tableInfo) {
            SqlMethod sqlMethod = SqlMethod.LOGIC_SELECT_BY_ID;
            SqlSource sqlSource = new RawSqlSource(configuration, String.format(sqlMethod.getSql(),
                sqlSelectColumns(tableInfo, false),
                tableInfo.getTableName(), tableInfo.getKeyColumn(), tableInfo.getKeyProperty(),
                tableInfo.getLogicDeleteSql(true, false)), Object.class);
            return this.addSelectMappedStatement(mapperClass, sqlMethod.getMethod(), sqlSource, modelClass, tableInfo);
        }
    }
    ```
    
    可以看到，生成了SqlSource对象，再将SQL通过addSelectMappedStatement方法添加到meppedStatements中。
    
    ![在这里插入图片描述](https://imgconvert.csdnimg.cn/aHR0cDovL3d3dy5wYnRlYWNoLmNvbS9wb3N0L2phdmFfZGlzdHJpYnV0L215YmF0aXMtcGx1cy0wMS8xNTU2NDM1MjgwOTc5LnBuZw?x-oss-process=image/format,png)

[https_github.com_pbteach_mybatis-plus-test]: https://github.com/pbteach/mybatis-plus-test
[1556351189202]: https://imgconvert.csdnimg.cn/aHR0cDovL3d3dy5wYnRlYWNoLmNvbS9wb3N0L2phdmFfZGlzdHJpYnV0L215YmF0aXMtcGx1cy0wMS8xNTU2MzUxMTg5MjAyLnBuZw?x-oss-process=image/format,png
[1573691210439]: https://imgconvert.csdnimg.cn/aHR0cDovL3d3dy5wYnRlYWNoLmNvbS9wb3N0L2phdmFfZGlzdHJpYnV0L215YmF0aXMtcGx1cy0wMS8xNTczNjkxMjEwNDM5LnBuZw?x-oss-process=image/format,png
[1573691233384]: https://imgconvert.csdnimg.cn/aHR0cDovL3d3dy5wYnRlYWNoLmNvbS9wb3N0L2phdmFfZGlzdHJpYnV0L215YmF0aXMtcGx1cy0wMS8xNTczNjkxMjMzMzg0LnBuZw?x-oss-process=image/format,png
[1556362315190]: https://imgconvert.csdnimg.cn/aHR0cDovL3d3dy5wYnRlYWNoLmNvbS9wb3N0L2phdmFfZGlzdHJpYnV0L215YmF0aXMtcGx1cy0wMS8xNTU2MzYyMzE1MTkwLnBuZw?x-oss-process=image/format,png
[1556362597538]: https://imgconvert.csdnimg.cn/aHR0cDovL3d3dy5wYnRlYWNoLmNvbS9wb3N0L2phdmFfZGlzdHJpYnV0L215YmF0aXMtcGx1cy0wMS8xNTU2MzYyNTk3NTM4LnBuZw?x-oss-process=image/format,png
[1556362621608]: https://imgconvert.csdnimg.cn/aHR0cDovL3d3dy5wYnRlYWNoLmNvbS9wb3N0L2phdmFfZGlzdHJpYnV0L215YmF0aXMtcGx1cy0wMS8xNTU2MzYyNjIxNjA4LnBuZw?x-oss-process=image/format,png
[1573691255238]: https://imgconvert.csdnimg.cn/aHR0cDovL3d3dy5wYnRlYWNoLmNvbS9wb3N0L2phdmFfZGlzdHJpYnV0L215YmF0aXMtcGx1cy0wMS8xNTczNjkxMjU1MjM4LnBuZw?x-oss-process=image/format,png
[1573691274395]: https://imgconvert.csdnimg.cn/aHR0cDovL3d3dy5wYnRlYWNoLmNvbS9wb3N0L2phdmFfZGlzdHJpYnV0L215YmF0aXMtcGx1cy0wMS8xNTczNjkxMjc0Mzk1LnBuZw?x-oss-process=image/format,png
[1556433826583]: https://imgconvert.csdnimg.cn/aHR0cDovL3d3dy5wYnRlYWNoLmNvbS9wb3N0L2phdmFfZGlzdHJpYnV0L215YmF0aXMtcGx1cy0wMS8xNTU2NDMzODI2NTgzLnBuZw?x-oss-process=image/format,png
[1556434252779]: https://imgconvert.csdnimg.cn/aHR0cDovL3d3dy5wYnRlYWNoLmNvbS9wb3N0L2phdmFfZGlzdHJpYnV0L215YmF0aXMtcGx1cy0wMS8xNTU2NDM0MjUyNzc5LnBuZw?x-oss-process=image/format,png
[1556435280979]: https://imgconvert.csdnimg.cn/aHR0cDovL3d3dy5wYnRlYWNoLmNvbS9wb3N0L2phdmFfZGlzdHJpYnV0L215YmF0aXMtcGx1cy0wMS8xNTU2NDM1MjgwOTc5LnBuZw?x-oss-process=image/format,png