黑马程序员---MyBatisPlus（第一天）

最新推荐文章于 2023-04-07 16:15:16 发布

睡不着还睡不醒

最新推荐文章于 2023-04-07 16:15:16 发布

阅读量884

点赞数 1

分类专栏： mybatisplus SpringBoot 文章标签： mybatis java 数据库

本文链接：https://blog.csdn.net/Father_Of_Soft/article/details/128137464

版权

SpringBoot 同时被 2 个专栏收录

6 篇文章 0 订阅

订阅专栏

mybatisplus

2 篇文章 0 订阅

订阅专栏

一、了解MyBatis-Plus

1.1 MyBatis-Plus介绍

MyBatis-Plus（简称MP），是一个MyBatis的增强工具，在MyBatis的基础上只做增强不做改变，为简化开发，提高效率而生

1.2 特性

无侵入

损耗小

强大的CRUD操作

支持Lambda形式调用：通过Lambda表达式，方便的编写各类查询条件，无需再担心字段写错

支持多种数据库

支持主键自动生成

支持XML热加载

支持ActiveRecord模式

支持自定义全局通用操作：Write once,use anywhere

支持关键词自动转义

内置代码生成器

内置分页插件

内置性能分析插件

内置全局拦截插件

内置sql注入剥离器：有效预防sql注入攻击

二、快速开始

2.1.建库建表

create table tb_user(
    id int(20) not null auto_increment,
    user_name varchar(20) not null,
    password varchar(20) not null,
    name varchar(30) default null,
    age int(11) default null,
    email varchar(50) default null,
    primary key(id)
)auto_increment=1 default charset=utf8;

insert into tb_user(id,user_name,password,name,age,email) values
(1,'zhangsan','123456','张三',18,'test@itcast.cn');

insert into tb_user(id,user_name,password,name,age,email) values
(2,'lisi','123456','李四',20,'test@itcast.cn');

insert into tb_user(id,user_name,password,name,age,email) values
(3,'wangwu','123456','王五',42,'test@itcast.cn');

insert into tb_user(id,user_name,password,name,age,email) values
(4,'zhaoliu','123456','赵六',28,'test@itcast.cn');

insert into tb_user(id,user_name,password,name,age,email) values
(5,'xieqi','123456','谢七',43,'test@itcast.cn');

2.2.创建工程

导入依赖


    <dependencies>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus</artifactId>
            <version>3.1.1</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.28</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.11</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
            <version>1.18.24</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.6.2</version>
        </dependency>
    </dependencies>

添加log4j.properties

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

2.3.mybatis实现查询User

2.3.1 编写mybatis-config.xml文件

<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <properties resource="jdbc.properties"/>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>
    <!--引入mybatis的映射文件-->
    <mappers>
        <mapper resource="UserMapper.xml"/>
    </mappers>
</configuration>

2.3.2 编写User实体对象

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    private int id;
    private String userName;
    private String password;
    private String name;
    private int age;
    private String email;
    
}

2.3.3 编写UserMapper接口

public interface UserMapper {
    public List<User> findAll();
}

2.3.4 编写UserMapper.xml

<mapper namespace="com.itheima.mp.simple.mapper.UserMapper">
    <select id="findAll" resultType="com.itheima.mp.simple.pojo.User">
        select * from tb_user
    </select>

</mapper>

2.3.5 测试类

public class TestMyBaits {

    @Test
    public void testFindAll() throws Exception{
        InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

        //测试查询
        List<User> users = userMapper.findAll();
        for(User user:users){
            System.out.println(user);
        }
    }
}

2.4 MyBatis+MP实现查询User

第一步：将UserMapper继承BaseMapper，将拥有了BaseMapper中的所有方法


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

第二步：编写测试类

public class TestMP {

    @Test
    public void test() throws Exception{
        InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = new MybatisSqlSessionFactoryBuilder().build(inputStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

        List<User> list = userMapper.findAll();
        for(User user:list){
            System.out.println(user);
        }

    }
}

测试MP的功能：

①给实体类添加注解

@TableName("tb_user")

②测试功能

使用MP中的MybatisSqlSessionFactoryBuilder进程构建

public class TestMP {

    @Test
    public void test() throws Exception{
        InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = new MybatisSqlSessionFactoryBuilder().build(inputStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

        List<User> list=userMapper.selectList(null);
        for(User user:list){
            System.out.println(user);
        }

    }
}

可以看到，MyBatis-Plus会自动生成SQL语句

2.5 Spring+MyBatis+MP

2.5.1 创建子Module

pom.xml

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.9</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.3.9</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.3.9</version>
        </dependency>
    </dependencies>

2.5.2 实现查询User

第一步，编写jdbc.properties

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/db_ssm?serverTimezone=UTC
jdbc.username=root
jdbc.password=root

第二步，编写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">

    <context:property-placeholder location="classpath:jdbc.properties"/>

    <!--定义数据源-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
        <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>

    <!--使用MP提供的sqlSessionFactory，完成了Spring与MP的整合-->
    <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="cn.itcast.mp.simple.mapper"/>
    </bean>


</beans>

第三步，编写User实体类

@Data
@AllArgsConstructor
@NoArgsConstructor
@TableName("tb_user")
public class User {
    private int id;
    private String userName;
    private String password;
    private String name;
    private int age;
    private String email;
}

第四步，编写UserMapper接口

@Mapper
public interface UserMapper extends BaseMapper<User> {
}

第五步，测试


@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations="classpath:applicationContext.xml")
public class TestMyBatisSpring {

    @Autowired
    private UserMapper userMapper;

    @Test
    public void testSelectList(){
        List<User> users = this.userMapper.selectList(null);
        for(User user:users){
            System.out.println(user);
        }
    }

}

2.6 SpringBoot+MyBatis+MP

使用SpringBoot将进一步简化MP的整合，需要注意的是，由于使用SpringBoot需要继承parent，所以需要重新创建工程，而不是创建子Module

第一步、创建工程，导入依赖

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

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.2</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

    </dependencies>

第二步，编写application.yml

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/db_springboot?serverTimezone=UTC
    username: root
    password: root

第三步，创建实体类

@Data
@AllArgsConstructor
@NoArgsConstructor
@TableName("tb_user")
public class User {
    private Integer id;
    private String userName;
    private String password;
    private String name;
    private Integer age;
    private String email;
}

第四步，编写Mapper接口

public interface UserMapper extends BaseMapper<User> {
}

第五步，添加@MapperScan注解

@SpringBootApplication
@MapperScan("cn.itcast.mp.mapper")
public class MyApplication {

    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class,args);
    }


}

第六步，编写测试类

@SpringBootTest
public class TestMyBatisSpringBoot {

    @Autowired
    private UserMapper userMapper;

    @Test
    public void testSelectList(){
        List<User> users = userMapper.selectList(null);
        for(User user:users){
            System.out.println(user);
        }
    }
}

三、通用CRUD

3.1 插入操作

3.1.1 方法定义

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

3.1.2 方法测试

   @Test
    public void testInsert(){
        /*
        *  result返回数据库受影响的行数
        * */
        User user=new User(null, "jiangting", "123321", "江停", 35, "123@qq.com");
        int result=userMapper.insert(user);
        System.out.println("受影响的行数==>"+result);
        //新增数据之后，自增长的id会回填到对象中
        System.out.println("id==>"+user.getId());
    }

运行结果：

可以看到，id的值是有问题的

3.1.3 @TableId

这是因为plus插件中有各种id生成的策略，如果想要id自增，需要在自增主键上加注解：

    @TableId(type= IdType.AUTO)
    private Integer id;

再次运行，成功

3.1.4 @TableField

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

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

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

③查询时不返回该字段的值

example for ①：

    @TableField(value="email")  //指定数据表中的字段名
    private String mail;

example for ②：

注意，如果对象中没有设置addresss（即为空），则该属性不会填入insert语句

   @TableField(exist=false)
    private String address; //在数据库表中不存在

example for ③：

    @TableField(select=false)
    private String password;

查询后发现password为空，不会被查询到：

3.2 更新操作

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

3.2.1 根据id更新

方法定义：

/*

* 根据ID修改

*

* @Param entity 实体对象

*/

int updateById(@Param(Constants.ENTITY) T entity)

测试用例：

    @Test
    public void testUpdateById(){
        User user=new User();
        user.setId(7);
        user.setMail("gongzhou@123.com");
        user.setPassword("666666");
        int i = userMapper.updateById(user);
        System.out.println("i===>"+i);
    }

3.2.2 根据条件更新

方法定义：

/*

* 根据whereEntity 条件，更新记录

*

*@Param entity 实体对象（set 条件值，可以为null）

*@Param updateWrapper 实体对象封装操作类（可以为null，里面的entity用于生成where语句）

*/
int update(@Param("et") T entity, @Param("ew") Wrapper<T> updateWrapper);

测试用例：

需要注意的是eq方法中要修改的字段名是数据库中的字段名

QueryWrapper版：

    @Test
    public void testUpdate(){
        User user=new User();
        user.setMail("gongzhou@123.com");
        user.setPassword("660006");
        QueryWrapper<User> wrapper=new QueryWrapper<>();
        wrapper.eq("user_name","zhangsan");
        int i = userMapper.update(user,wrapper);
        System.out.println("i=>"+i);

    }

UpdateWrapper版：

    @Test
    public void testUpdate2(){
        UpdateWrapper<User> wrapper=new UpdateWrapper<>();
        wrapper.set("age",21).set("password","999888")  //更新的字段
        .eq("user_name","zhangsan");   //更新的条件

        //根据条件做更新
        int i = userMapper.update(null, wrapper);
        System.out.println("i==>"+i);

    }

3.3 删除操作

3.3.1 deleteById

方法定义：

/*

* 根据 ID 删除

* @Param id 主键ID

*/

int deleteById(Serializable id);

测试用例：

    @Test
    public void testDeleteById(){
        int i = userMapper.deleteById(8);
        System.out.println("delete  i==>"+i);
    }

3.3.2 deleteByMap

方法定义：

/*

* 根据 columnMap 条件，删除记录

*

* @Param columnMap 表字段map对象

*/
int deleteByMap(@Param("cm") Map<String, Object> columnMap);

测试用例：

根据map删除数据，多条件之间是and关系

    @Test
    public void testDeleteByMap(){
        Map<String,Object> map=new HashMap<>();
        map.put("user_name","zhangsan");
        map.put("password","999888");
        int i = userMapper.deleteByMap(map);
        System.out.println("i=>"+i);
    }

3.3.3 delete

方法定义：

/*

* 根据 entity 条件，删除记录

*

* @Param wrapper 实体对象封装操作类（可以为null）

*/
int delete(@Param("ew") Wrapper<T> queryWrapper);

测试用例：

用法1：

    @Test
    public void testDelete(){
        QueryWrapper<User> wrapper=new QueryWrapper<>();
        wrapper.eq("user_name","jiangting").eq("password","666666");
        //根据包装条件做删除
        int i = userMapper.delete(wrapper);
        System.out.println("i====>"+i);

    }

用法2：

    @Test
    public void testDelete(){
        User user=new User();
        user.setUserName("jiangting");
        user.setPassword("123321");
        QueryWrapper<User> wrapper=new QueryWrapper<>(user);
        //根据包装条件做删除
        int i = userMapper.delete(wrapper);
        System.out.println("i====>"+i);

    }

3.3.4 deleteBatchIds

方法定义：

/*

* 删除（根据 ID 批量删除）

*

* @Param idList 主键ID列表（不能为null 以及 empty）

*/
int deleteBatchIds(@Param("coll") Collection<?> idList);

测试用例：

    @Test
    public void testDeleteBatchIds(){
        int i = userMapper.deleteBatchIds(Arrays.asList(5, 6));
        System.out.println("i==>"+i);
    }

3.4 查询操作

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

3.4.1 selectById

方法定义：

/*

* 根据 ID 查询

*

* @Param id 主键ID

*/
T selectById(Serializable id);

测试用例：

    @Test
    public void testSelectById(){
        User user = userMapper.selectById(3);
        System.out.println(user);
    }
}

3.4.2 selectBatchIds

方法定义：

/*

* 查询（根据 ID 批量查询）

*

* @Param idList 主键ID列表（不能为null 以及 empty）

*/
List<T> selectBatchIds(@Param("coll") Collection<? extends Serializable> idList);

测试用例：

    @Test
    public void testSelectBatchIds(){
        List<User> users = userMapper.selectBatchIds(Arrays.asList(1, 2, 3));
        users.forEach(System.out::println);
    }

3.4.3 selectOne

方法定义：

/*

* 根据 entity 条件，查询一条记录

*

* @Param queryWrapper 实体对象封装操作类（可以为null）

*/
default T selectOne(@Param("ew") Wrapper<T> queryWrapper);

测试用例：

查询的数据超过一条时，会抛出异常

    @Test
    public void testSelectOne(){
        QueryWrapper<User> wrapper=new QueryWrapper<>();
        wrapper.eq("user_name","lisi");
        User user = userMapper.selectOne(wrapper);
        System.out.println(user);
    }

3.4.4 selectCount

方法定义：

/*

* 根据Wrapper 条件，查询总记录数

*

* @Param queryWrapper 实体对象封装操作类（可以为null）

*/
Long selectCount(@Param("ew") Wrapper<T> queryWrapper);

测试用例：

wrapper.gt(column,value); //表示大于value的条目值

同理有 ge 大于等于

le 小于等于

gt 大于

lt 小于

    @Test
    public void testSelectCount(){
        QueryWrapper<User> wrapper=new QueryWrapper<>();
        wrapper.gt("age",22);
        Long count = userMapper.selectCount(wrapper);
        System.out.println(count);

    }

3.4.5 selectList

方法定义：

/*

* 根据 entity条件，查询全部记录

*

* @Param queryWrapper 实体对象封装操作类（可以为null）

*/
List<T> selectList(@Param("ew") Wrapper<T> queryWrapper);

测试用例：

    @Test
    public void testSelectList(){
        QueryWrapper<User> wrapper=new QueryWrapper<>();
        wrapper.like("email","itcast");
        List<User> users = userMapper.selectList(wrapper);
        users.forEach(System.out::println);
    }

3.4.6 selectPage

方法定义：

/*

* 根据 entity 条件，查询全部记录（并翻页）

*

* @Param page 分页查询条件（可以为 RowBounds.DEFAULT）

* @Param queryWrapper 实体对象封装操作类（可以为null）

*/
<P extends IPage<T>> P selectPage(P page, @Param("ew") Wrapper<T> queryWrapper);

配置分页插件：

@Configuration
@MapperScan("cn.itcast.mp.mapper")
public class MybatisPlusConfig {

    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor(){
        MybatisPlusInterceptor interceptor=new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.H2));
        return interceptor;
    }
}

测试用例：

    @Test
    public void testSelectPage(){
        Page<User> page=new Page<>(3,1); //查询第一页，查询一条数据
        QueryWrapper<User> wrapper=new QueryWrapper<>();
        wrapper.like("email","itcast");
        IPage<User> userPage = userMapper.selectPage(page, wrapper);
        System.out.println("数据总条数："+userPage.getTotal());
        System.out.println("数据总页数："+userPage.getPages());
        System.out.println("当前页数："+userPage.getCurrent());
        List<User> records = userPage.getRecords();
        records.forEach(System.out::println);


    }

3.5 SQL注入的原理

MP在启动后会将BaseMapper中的一系列方法注册到mappedStatement中，那么，是如何注入的呢？

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

public interface ISqlInjector {
    /*
     *检查SQL是否注入（已经注入过不再注入）
    */

    void inspectInject(MapperBuilderAssistant builderAssistant, Class<?> mapperClass);
}

在ISqlInjector的实现类AbstractSqlInjector中，通过下列语句循环注入自定义方法

if (CollectionUtils.isNotEmpty(methodList)) {
                    methodList.forEach((m) -> {
                        m.inject(builderAssistant, mapperClass, modelClass, tableInfo);
                    });

点进inject，在this.injectMappedStatement注入自定义方法

    public void inject(MapperBuilderAssistant builderAssistant, Class<?> mapperClass, Class<?> modelClass, TableInfo tableInfo) {
        this.configuration = builderAssistant.getConfiguration();
        this.builderAssistant = builderAssistant;
        this.languageDriver = this.configuration.getDefaultScriptingLanguageInstance();
        this.injectMappedStatement(mapperClass, modelClass, tableInfo);
    }

进入injectMappedStatement查看

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

是一个抽象方法，鼠标放在injectMappedStatement，点击Ctrl+H

可以看到，最终调用抽象方法injectMappedStatement进行真正的注入：

以SelectById为例：

public class SelectById extends AbstractMethod {
    public SelectById() {
        super(SqlMethod.SELECT_BY_ID.getMethod());
    }

    public SelectById(String name) {
        super(name);
    }

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

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

四、配置

在MP中有大量的配置，其中有一部分是MyBatis原生的配置，另一部分是MP的配置

4.1 基本配置

4.1.1 configLocation

MyBatis配置文件位置，如果你有单独的MyBatis配置，请将其路径配置到configLocation中。

mybatis-plus:
  #指定全局的配置文件
  config-location: classpath:mybatis-config.xml

4.1.2 mapperLocations

mybatis mapper所对应的xml文件位置，如果你在mapper中有自定义方法（xml中有自定义实现），需要进行该配置，告诉mapper所对应的xml文件位置

mybatis-plus:
  #指定Mapper.xml文件的路径
  mapper-locations: classpath*:mybatis/*.xml

测试用例：

UserMapper.java

public interface UserMapper extends BaseMapper<User> {
    User findById(int id);

}

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="cn.itcast.mp.mapper.UserMapper">
    <select id="findById" resultType="cn.itcast.mp.pojo.User">
        select * from tb_user where id=#{id}
    </select>

</mapper>

测试类：

    @Test
    public void testFindById(){
        User user = userMapper.findById(2);
        System.out.println(user);
    }

4.1.3 typeAliasesPackage

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

mybatis-plus:
  #实体对象的扫描包
  type-aliases-package: cn.itcast.mp.pojo

4.2 进阶配置

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

4.2.1 mapUnderscoreToCamelCase

类型：boolean

默认值：true

是否开启自动驼峰命名规则（camel case）映射，即从经典数据库列名（下划线命名）到经典Java属性名（驼峰命名）的类似映射

注意：

此属性在mybatis中默认值为false，在Mybatis-Plus中，此属性也将用于生成最终的SQL的select body

如果您的数据库命名符合规则，无需使用@TableField注解指定数据库字段名

该参数不能和mybatis-plus.config-location同时存在

mybatis-plus:
  configuration:
    #禁用自定的驼峰映射
    map-underscore-to-camel-case: false

4.2.2 cacheEnabled

类型：boolean

默认值：true

全局地开启或关闭配置文件中的所有映射器已经配置的任何缓存，默认为true

mybatis-plus:
  configuration:
    cache-enabled: false

4.3 DB策略配置

4.3.1 idType

全局默认主键类型，设置后，即可省略实体对象中的@TableId(type=IdType.AUTO)配置

全局的id生成策略

mybatis-plus:
  global-config:
    db-config:
      id-type: auto

4.3.2 tablePrefix

类型：String

默认值：null

表名前缀，全局配置后可省略@TableName()配置

mybatis-plus:
  global-config:
    db-config:
      table-prefix: tb_

五、条件构造器

在MP中，Wrapper接口的实现类关系如下：

可以看到，AbstractWrapper和AbstractLambdaWrapper是重点实现。

接下来我们重点学习AbstractWrapper以及其子类

5.1 allEq

传入map集合：

    @Test
    public void testAllEq(){
        Map<String,Object> params=new HashMap<>();
        params.put("user_name","jiangting");
        params.put("age",35);
        QueryWrapper<User> wrapper=new QueryWrapper<>();
        wrapper.allEq(params);
        List<User> users = userMapper.selectList(wrapper);
        users.forEach(System.out::println);
    }

过滤器用法：

    @Test
    public void testAllEq(){
        Map<String,Object> params=new HashMap<>();
        params.put("user_name","jiangting");
        params.put("age",35);
        QueryWrapper<User> wrapper=new QueryWrapper<>();
        wrapper.allEq(((k,v)->(k.equals("age")||k.equals("id"))),params);
        List<User> users = userMapper.selectList(wrapper);
        users.forEach(System.out::println);
    }

5.2 基本比较操作

eq：等于==

ne：不等于<>

gt：大于>

ge：大于等于>=

lt：小于<

le：小于等于<=

between：BETWEEN 值1 AND 值2

notBetween：NOT BETWEEN 值1 AND 值2

in：字段 IN (value.get(0),value.get(1),...)

notIn：字段 NOT IN (v0,v1,...)

测试用例：

    @Test
    public void testEq(){
        QueryWrapper<User> wrapper=new QueryWrapper<>();
        wrapper.eq("password","123321")
                .ge("age",30)
                .in("name","江停","张三","王五");
        List<User> users = userMapper.selectList(wrapper);
        users.forEach(System.out::println);
    }

5.3 模糊查询

like：LIKE '%值%'

例:like ("name","王")==>name like '%王%'

notLike: NOT LIKE '%值%'

例:notLike("name","王")==>name not like '%王%'

likeLieft：LIKE '%值%'

例:likeLeft("name","王")==>name like '%王'

likeRight：LIKE '值%'

例：likeRight("name","王")==>name like '王%'

测试用例：

    @Test
    public void testEq1(){
        QueryWrapper<User> wrapper=new QueryWrapper<>();
        wrapper.likeRight("name","江").like("email","123");
        List<User> users = userMapper.selectList(wrapper);
        users.forEach(System.out::println);
    }

5.4 排序

orderBy：

排序：ORDER BY 字段，...

例：orderBy(true,true,"id,"name") ===> order by id ASC,name ASC

orderByAsc：

排序：ORDER BY 字段，... ASC

例：orderByAsc("id","name") ===> order by id ASC,name ASC

orderByDesc：

排序：ORDER BY 字段，... DESC

例：orderByDesc("id","name") ===>order by id DESC,name DESC

测试用例：

    @Test
    public void testOrderByAgeDesc(){
        QueryWrapper<User> wrapper=new QueryWrapper<>();
        wrapper.orderByDesc("age","id");
        List<User> users = userMapper.selectList(wrapper);
        users.forEach(System.out::println);
    }

5.5 逻辑查询

or：

拼接OR

主动调用or表示紧接着下一个方法不使用and连接（不调用or则默认为and连接）

and：

AND嵌套

例：and(i->i.eq("name","李白").ne("status","活着")) ===>and(name='李白' and status<>'活着')

测试用例：

    @Test
    public void testOr(){
        QueryWrapper<User> wrapper=new QueryWrapper<>();
        wrapper.eq("name","王五").or().eq("age",35);
        List<User> users = userMapper.selectList(wrapper);
        users.forEach(System.out::println);
    }

运行结果：

5.6 select

在MP查询中，默认查询所有的字段，如果有需要也可以通过select进行指定字段

    @Test
    public void testSelect(){
        QueryWrapper<User> wrapper=new QueryWrapper<>();
        wrapper.eq("name","王五")
                .or()
                .eq("age",35)
                .select("user_name","id","age");
        List<User> users = userMapper.selectList(wrapper);
        users.forEach(System.out::println);
    }