MyBatis-Plus

1、了解Mybatis-Plus 1.1 Mybatis-Plus介绍        

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

官网：https://mybatis.plus/ 或 https://mp.baomidou.com/

愿景:我们的愿景是成为 MyBatis 最好的搭档，就像 魂斗罗 中的 1P、2P，基友搭配，效率翻倍。

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

2、快速开始

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

2.1、创建数据库以及表

-- 创建数据库
CREATE DATAbase mp;

-- 创建数据表
CREATE TABLE tb_user (
	id BIGINT(20) NOT NULL AUTO_INCREMENT COMMENT '主键ID',
	user_name VARCHAr(20) NOT NULL COMMENT '用户名',
	PASSWORD VARCHAr(20) NOT NULL COMMENT '密码',
	NAME VARCHAr(30) DEFAULT NULL COMMENT '姓名',
	age INT(11) DEFAULT NULL COMMENT '年龄',
	email VARCHAr(30) DEFAULT NULL COMMENT '邮箱',
	PRIMARY KEY (id)
) ENGINE=INNODB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

-- 添加数据
INSERT INTO tb_user VALUES (NULL, 'zhangsan', '123456', '张三', 18, 'test1@itcast.cn'),(NULL, 'lisi', '123456', '李四', 20, 'test2@itcast.cn'),(NULL, 'wangwu', '123456', '王五', 25, 'test3@itcast.cn'),(NULL, 'zhaoliu', '123456', '赵六', 26, 'test4@itcast.cn'),(NULL, 'sunqi', '123456', '孙七', 27, 'test5@itcast.cn');

-- 查看数据表
SELECT * FROM tb_user;

2.2 创建工程 2.2.1 导入依赖

    4.0.0

    org.example
    mybatis-plus-案例01
    pom
    1.0-SNAPSHOT
    
        itcast-mybatis-plus-simple
        itcast-mybatis-plus-spring
    

    

        
        
            com.baomidou
            mybatis-plus
            3.1.1
        

        
        
            mysql
            mysql-connector-java
            5.1.47
        

        
        
            com.alibaba
            druid
            1.1.16
        

        
        
            org.projectlombok
            lombok
            true
            1.18.4
        

        
        
            junit
            junit
            4.12
        

        
        
            org.slf4j
            slf4j-log4j12
            1.6.4
        
    

        
    
        
            
                org.apache.maven.plugins
                maven-compiler-plugin
                 1.8
                    1.8 
            
        
    

2.3 Mybatis + MP

        下面演示，通过纯Mybatis与Mybatis-Plus整合。

2.3.1、创建子Module

    
        mybatis-plus-案例01
        org.example
        1.0-SNAPSHOT
    
    4.0.0

    itcast-mybatis-plus-simple

2.3.2 导入日志文件  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.3 Mybatis实现查询User

第一步，编写MybatisConfig.xml文件

第二步，编写User实体对象

        第一种方法：使用get和set方法

package com.itheima.domain;

import com.baomidou.mybatisplus.annotation.TableName;


@TableName("tb_user")
public class User {
    private long id;
    private String username;
    private String password;
    private String name;
    private Integer age;
    private String email;

    public User() {
    }

    public User(int id, String user_name, String password, String name, int age, String email) {
        this.id = id;
        this.username = user_name;
        this.password = password;
        this.name = name;
        this.age = age;
        this.email = email;
    }

    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", user_name='" + username + ''' +
                ", password='" + password + ''' +
                ", name='" + name + ''' +
                ", age=" + age +
                ", email='" + email + ''' +
                '}';
    }
}

        第二种方法：使用lombok进行了简化bean操作

package cn.itcast.mp.simple.pojo;

import lombok.AllArgsConstructor;
import lombok.Data; 
import lombok.NoArgsConstructor;

 @Data
 @NoArgsConstructor
 @AllArgsConstructor
 public class User {

     private Long id;
     private String userName;
     private String password;
     private String name;
     private Integer age;
     private String email; 
}

第三步，编写UserMapper接口

package com.itheima.mapper;

import com.baomidou.mybatisplus.core.mapper.baseMapper;
import com.itheima.domain.User;

import java.util.List;


public interface UserMapper{

    List findAll();
}

第四步，编写映射配置文件 UserMapper.xml文件

    

    
        select * from tb_user
    




 
第五步，编写TestMybatis测试用例
 
package com.itheima;

import com.itheima.domain.User;
import com.itheima.mapper.UserMapper;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;

import java.io.InputStream;
import java.util.List;


public class TestMybatis {

    @Test
    public void testUserList() throws Exception{
        InputStream is = Resources.getResourceAsStream("MybatisConfig.xml");

        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);

        SqlSession sqlSession = sqlSessionFactory.openSession();

        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        List list = mapper.findAll();
        for (User user : list) { System.out.println(user);
        }
    }
}
 
测试结果
 
 
2.3.4 Mybatis+MP实现查询User 
第一步，将UserMapper继承baseMapper，将拥有了baseMapper中的所有方法
 
package com.itheima.mapper;

import com.baomidou.mybatisplus.core.mapper.baseMapper;
import com.itheima.domain.User;

import java.util.List;


public interface UserMapper extends baseMapper {

    List findAll();
}
 
第二步，使用MP中的MybatisSqlSessionFactoryBuilder生成SqlSessionFactory对象进程构建 测试用例 TestMybatisPlus：
 
package com.itheima;

import com.baomidou.mybatisplus.core.MybatisSqlSessionFactoryBuilder;
import com.itheima.domain.User;
import com.itheima.mapper.UserMapper;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.junit.Test;

import java.io.InputStream;
import java.util.List;


public class TestMybatisPlus {

    @Test
    public void testUserList() throws Exception{

        InputStream is = Resources.getResourceAsStream("MybatisConfig.xml");

        SqlSessionFactory sqlSessionFactory = new MybatisSqlSessionFactoryBuilder().build(is);

        SqlSession sqlSession = sqlSessionFactory.openSession();

        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        //测试用例
        //List list = mapper.findAll();
        List list = mapper.selectList(null);
        for (User user : list) { System.out.println(user);
        }
    }
}
 
运行报错
 
 
 解决：在User对象中添加@TableName，指定数据库表名
 
 
测试结果
 
 
简单说明：
         由于使用了MybatisSqlSessionFactoryBuilder进行了构建，继承的baseMapper中的方法就载入到了SqlSession中，所以就可以直接使用相关的方法；
 
 
2.4 Spring + Mybatis + MP 
        引入了Spring框架，数据源、构建等工作就交给了Spring管理。
 
2.4.1 创建子Module 


    
        mybatis-plus-案例01
        org.example
        1.0-SNAPSHOT
    
    4.0.0

    itcast-mybatis-plus-spring

    
        5.1.6.RELEASE
    

    
        
            org.springframework
            spring-webmvc
            ${spring.version}
        
        
            org.springframework
            spring-jdbc
            ${spring.version}
        
        
            org.springframework
            spring-test
            ${spring.version}
        
    

 
2.4.2 实现查询User 
第一步，编写jdbc.properties
 
jdbc.driver=com.mysql.jdbc.Driver

jdbc.url=jdbc:mysql://localhost:3306/mp
jdbc.username=root
jdbc.password=qal991213
 
 第二步，编写applicationContext.xml
 



    

    
    
        
        
        
        
        
        
    

    
    
        
    

    
    
        
    
 
第三步，编写User对象以及UserMapper接口
 
        User对象同上，这里不在阐述
 
        编写UserMapper接口：
 
package com.itheima.mapper;

import com.baomidou.mybatisplus.core.mapper.baseMapper;
import com.itheima.domain.User;

import java.util.List;


public interface UserMapper extends baseMapper {

}
 
第四步，编写测试用例
 
package com.itheima.test;

import com.itheima.domain.User;
import com.itheima.mapper.UserMapper;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.List;


@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class TestMybatisPlusSpring {
    @Autowired
    private UserMapper userMapper;

    @Test
    public void findAll(){
        List list = this.userMapper.selectList(null);
        for (User user : list) {
            System.out.println(user);
        }
    }
}
 
测试结果
 
 
2.5 SpringBoot + Mybatis + MP 
        使用SpringBoot将进一步的简化MP的整合，需要注意的是，由于使用SpringBoot需要继承parent，所以需要重新创建工程，并不是创建子Module。
 
2.5.1 创建工程 
2.3.2 导入依赖 


    4.0.0

    
        org.springframework.boot
        spring-boot-starter-parent
        2.1.4.RELEASE
    

    org.example
    mybatis-plus-springboot-案例01
    1.0-SNAPSHOT

    

        
            org.springframework.boot
            spring-boot-starter
            
                
                    org.springframework.boot
                    spring-boot-starter-logging
                
            
        

        
            org.springframework.boot
            spring-boot-starter-test
            test
        

        
        
            org.projectlombok
            lombok
            true
        

        
        
            com.baomidou
            mybatis-plus-boot-starter
            3.1.1
        

        
        
            mysql
            mysql-connector-java
            5.1.47
        

        
            org.slf4j
            slf4j-log4j12
        
    

    
        
            
                org.springframework.boot
                spring-boot-maven-plugin
            
        
    
 
 添加日志文件log4j.properties
 
 
 
log4j.rootLogger=DEBUG,A1

log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.Aa1.layout.ConversionPattern=[%t] [%c]-[%p] %m%n
 
 
 2.5.3 编写application.properties 
 
 
spring.application.name = itcast-mp-springboot

spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/mp
spring.datasource.username=root
spring.datasource.password=qal991213
 
 
2.5.4 编写pojo即User的实体类 
        同上，此处不再阐述
 
2.5.5 编写UserMapper接口 
package com.itheima.mapper;

import com.baomidou.mybatisplus.core.mapper.baseMapper;
import com.itheima.domain.User;


public interface UserMapper extends baseMapper {
}
 
 2.5.6 编写启动类 MyApplication 
package com.itheima;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;


@MapperScan("com.itheima.mapper")//设置mapper接口的扫描包
@SpringBootApplication
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class,args);
    }
}
 
2.5.7 编写测试用例 
package com.itheima.test;

import com.itheima.domain.User;
import com.itheima.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.SpringJUnit4ClassRunner;

import java.util.List;


@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest
public class TestMybatisSpringboot {

    @Autowired
    private UserMapper userMapper;

    @Test
    public void testSelect(){
        List list = this.userMapper.selectList(null);
        for (User user : list) {
            System.out.println(user);
        }
    }

}
 
测试结果 
 
3、通用CRUD 
        通过前面的学习，我们了解到通过继承baseMapper就可以获取到各种各样的单表操作，接下来我们将详细讲解这些操作。
 
 
3.1 插入操作 
3.1.1 方法定义 
 
int insert(T entity);
 
3.1.2 测试用例 
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest
public class TestMybatisSpringboot {

    @Autowired
    private UserMapper userMapper;

    //插入一条数据
    @Test
    public void testInsert(){
        User user = new User();
        user.setUsername("wangtongxue");
        user.setPassword("666666");
        user.setName("王晓娟");
        user.setAge(18);
        user.setMail("wangtongxue@163.com");

        int result = this.userMapper.insert(user);//返回的result是受影响的行数，并不是自增后的id

        System.out.println("result =>" + result);

        System.out.println(user.getId());//自增后的id会回填到对象中
    }
}
 
3.1.3 测试 
 
        可以看到，数据已经写入到了数据库，但是，id的值不正确，我们期望的是数据库自增长，实际是MP生成了id的值写入到了数据库。
 如何设置id的生成策略呢？
MP支持的id策略：
 
package com.baomidou.mybatisplus.annotation;
import lombok.Getter; 

      

@Getter 
public enum IdType { 
     
    AUTO(0), 
     
    NONE(1), 
     
    INPUT(2), 
     
     
    ID_WORKER(3), 
     
    UUID(4),
     
    ID_WORKER_STR(5); 

    private final int key; 

    IdType(int key) { 
        this.key = key; 
    } 
}
    
 
        修改User对象：
 
@TableName("tb_user")
public class User {

    @TableId(type = IdType.AUTO)//指定ID类型为自增长
    private long id;
    private String username;
 
3.1.4 @TableField 
        在MP中通过@TableField注解可以指定字段的一些属性，常常解决的问题有2个：
         1、对象中的属性名和字段名不一致的问题（非驼峰）
         2、对象中的属性字段在表中不存在的问题
 使用：
 
 
         其他用法，如大字段不加入查询字段：
 
 
         效果：
 
 
3.2 更新操作 
        在MP中，更新操作有2种，一种是根据id更新，另一种是根据条件更新。
 
3.2.1 根据id更新 
        方法定义：
 
 
int updateById(@Param(Constants.ENTITY) T entity);
 
        测试用例：
 
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest
public class TestMybatisSpringboot {

    @Autowired
    private UserMapper userMapper;

    //根据id更新
    @Test
    public void testUpdateById(){
        User user = new User();
        user.setId(1L);
        //user.setAge(21);
        user.setName("sha逼焦");

        int result = this.userMapper.updateById(user);

        System.out.println("result =>" + result);
    }
}
 
3.2.2 根据条件更新 
        方法定义：
 
 
int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper updateWrapper);
 
        测试用例：
 
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest
public class TestMybatisSpringboot {

    @Autowired
    private UserMapper userMapper;

    //根据条件更新
    @Test
    public void testUpdate(){
        User user = new User();
        user.setAge(44); //更新的字段
        user.setName("狗逼焦");

        //更新的条件
        QueryWrapper wrapper = new QueryWrapper<>();
        wrapper.eq("id",1L);

        //执行更新操作
        int result = this.userMapper.update(user, wrapper);

        System.out.println("result =>" + result);
    }
}
 
        或者，通过UpdateWrapper进行更新：
 
@Test 
public void testUpdate() { 
    //更新的条件以及字段 
    UpdateWrapper wrapper = new UpdateWrapper<>(); 
    wrapper.eq("id", 6).set("age", 23); 
    //执行更新操作 
    int result = this.userMapper.update(null, wrapper); 
    System.out.println("result = " + result); 
}
 
均可达到更新的效果。
 
3.3 删除操作 
3.3.1 deleteById 
        方法定义：
 
 
int deleteById(Serializable id);
 
        测试用例：
 
@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); 
    } 
}
 
数据被删除。
 
3.3.2 deleteByMap 
        方法定义：
 
 
int deleteByMap(@Param(Constants.COLUMN_MAP) Map columnMap);
 
        测试用例：
 
@RunWith(SpringRunner.class) 
@SpringBootTest 
public class UserMapperTest { 

    @Autowired 
    private UserMapper userMapper; 

    @Test 
    public void testDeleteByMap() { 
        Map columnMap = new HashMap<>(); 
        columnMap.put("age",20); 
        columnMap.put("name","张三"); 
        //将columnMap中的元素设置为删除的条件，多个之间为and关系 
        int result = this.userMapper.deleteByMap(columnMap); 
        System.out.println("result = " + result); 
    } 
}
 
3.3.3 delete 
        方法定义：
 
 
int delete(@Param(Constants.WRAPPER) Wrapper wrapper);
 
        测试用例：
 
@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 wrapper = new QueryWrapper<>(user); 

        int result = this.userMapper.delete(wrapper); 
        System.out.println("result = " + result); 
    } 
}
 
3.3.4 deleteBatchIds 
        方法定义：
 
 
int deleteBatchIds(@Param(Constants.COLLECTION) Collection idList);
 
        测试用例：
 
@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); 
    } 
}
 
3.4 查询操作 
        MP提供了多种查询操作，包括根据id查询、批量查询、查询单条数据、查询列表、分页查询等操作。
 
3.4.1 selectById 
        方法定义：
 
 
T selectById(Serializable id);
 
        测试用例：
 
@RunWith(SpringRunner.class) 
@SpringBootTest 
public class UserMapperTest { 

    @Autowired 
    private UserMapper userMapper; 

    @Test 
    public void testSelectById() { 
        //根据id查询数据 
        User user = this.userMapper.selectById(2L); 
        System.out.println("result = " + user); 
    } 
}
 
3.4.2 selectBatchIds 
        方法定义：
 
 
List selectBatchIds(@Param(Constants.COLLECTION) Collection idList);
 
        测试用例：
 
@RunWith(SpringRunner.class) 
@SpringBootTest 
public class UserMapperTest { 

    @Autowired 
    private UserMapper userMapper; 

    @Test 
    public void testSelectBatchIds() { 
        //根据id集合批量查询 
        List users = this.userMapper.selectBatchIds(Arrays.asList(2L, 3L, 10L)); 
        for (User user : users) { 
        System.out.println(user); 
        } 
    } 
}
 
3.4.3 selectOne 
        方法定义：
 
 
T selectOne(@Param(Constants.WRAPPER) Wrapper queryWrapper);
 
        测试用例：
 
@RunWith(SpringRunner.class) 
@SpringBootTest 
public class UserMapperTest { 

    @Autowired 
    private UserMapper userMapper; 

    @Test 
    public void testSelectOne() { 
        QueryWrapper wrapper = new QueryWrapper(); 
        wrapper.eq("name", "李四"); 

        //根据条件查询一条数据，如果结果超过一条会报错 
        User user = this.userMapper.selectOne(wrapper);
        System.out.println(user); 
    } 
}
 
3.4.4 selectCount 
        方法定义：
 
 
Integer selectCount(@Param(Constants.WRAPPER) Wrapper queryWrapper);
 
        测试用例：
 
@RunWith(SpringRunner.class) 
@SpringBootTest 
public class UserMapperTest {
 
    @Autowired 
    private UserMapper userMapper; 

    @Test 
    public void testSelectCount() { 
        QueryWrapper wrapper = new QueryWrapper(); 
        wrapper.gt("age", 23);  //年龄大于23岁 

        //根据条件查询数据条数
        Integer count = this.userMapper.selectCount(wrapper); 
        System.out.println("count = " + count); 
    } 
}
 
3.4.5 selectList 
        方法定义：
 
 
List selectList(@Param(Constants.WRAPPER) Wrapper queryWrapper);
 
        测试用例：
 
@RunWith(SpringRunner.class) 
@SpringBootTest 
public class UserMapperTest { 

    @Autowired 
    private UserMapper userMapper;

    @Test 
    public void testSelectList() { 

        QueryWrapper wrapper = new QueryWrapper(); 
        wrapper.gt("age", 23); //年龄大于23岁

        //根据条件查询数据 
        List users = this.userMapper.selectList(wrapper); 
        for (User user : users) { 
            System.out.println("user = " + user); 
        } 
    } 
}
 
3.4.6 selectPage 
        方法定义：
 
 
IPage selectPage(IPage page, @Param(Constants.WRAPPER) Wrapper queryWrapper);
 
        配置分页插件：
 
@Configuration 
@MapperScan("cn.itcast.mp.mapper") //设置mapper接口的扫描包 
public class MybatisPlusConfig { 

     

    @Bean 
    public PaginationInterceptor paginationInterceptor() {
        return new PaginationInterceptor(); 
    } 
}
 
        测试用例：
 
@RunWith(SpringRunner.class) 
@SpringBootTest 
public class UserMapperTest { 

    @Autowired 
    private UserMapper userMapper; 

    @Test 
    public void testSelectPage() { 
        QueryWrapper wrapper = new QueryWrapper(); 
        wrapper.gt("age", 20); //年龄大于20岁 

        Page page = new Page<>(1,1); 

        //根据条件查询数据 
        IPage iPage = this.userMapper.selectPage(page, wrapper); 
        System.out.println("数据总条数：" + iPage.getTotal()); 
        System.out.println("总页数：" + iPage.getPages()); 

        List users = iPage.getRecords(); 
        for (User user : users) { 
            System.out.println("user = " + user); 
        } 
    } 
}
 
3.5 SQL注入的原理 
        前面我们已经知道，MP在启动后会将baseMapper中的一系列的方法注册到meppedStatements中，那么究竟是如何注入的呢？流程又是怎么样的？下面我们将一起来分析下。

         在MP中，ISqlInjector负责SQL的注入工作，它是一个接口，AbstractSqlInjector是它的实现类，实现关系如下：
 
 
         在AbstractSqlInjector中，主要是由inspectInject()方法进行注入的，如下：
 
public void inspectInject(MapperBuilderAssistant builderAssistant, Class mapperClass) {
        Class modelClass = this.extractModelClass(mapperClass);
        if (modelClass != null) {
            String className = mapperClass.toString();
            Set mapperRegistryCache = GlobalConfigUtils.getMapperRegistryCache(builderAssistant.getConfiguration());
            if (!mapperRegistryCache.contains(className)) {
                List 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进行真正的注入：
 
 
         查看该方法的实现：
 
 
         以SelectById为例查看：
 
 
        可以看到，生成了SqlSource对象，再将SQL通过addSelectMappedStatement方法添加到meppedStatements中。
 
 
4、配置 
        在MP中有大量的配置，其中有一部分是Mybatis原生的配置，另一部分是MP的配置，详情：https://mybatis.plus/config/
 
        下面我们对常用的配置做讲解。
 
4.1 基本配置 
4.1.1 configLocation 
        MyBatis 配置文件位置，如果您有单独的 MyBatis 配置，请将其路径配置到 configLocation 中。 MyBatisConfiguration 的具体内容请参考MyBatis 官方文档 （即指定全局的配置文件）
 
Spring Boot：
 
mybatis-plus.config-location = classpath:MybatisConfig.xml
 
Spring MVC：
 
 
     
 
4.1.2 mapperLocations 
        MyBatis Mapper 所对应的 XML 文件位置，如果您在 Mapper 中有自定义方法（XML 中有自定义实现），需要进行该配置，告诉 Mapper 所对应的 XML 文件位置。（可以写自己的sql语句）
 
Spring Boot：
 
mybatis-plus.mapper-locations = classpath*:mybatis
public interface UserMapper extends baseMapper {

    User findById(Long id);
}
 
测试用例：
 
@RunWith(SpringRunner.class) 
@SpringBootTest 
public class UserMapperTest {
 
    @Autowired 
    private UserMapper userMapper; 

    @Test 
    public void testSelectPage() { 

        User user = this.userMapper.findById(2L); 
        System.out.println(user);
    } 
}
 
4.1.3 typeAliasesPackage 
        MyBaits 别名包扫描路径，通过该属性可以给包中的类注册别名，注册后在 Mapper 对应的 XML 文件中可以直接使用类名，而不用使用全限定的类名（即 XML 中调用的时候不用包含包名）。
 
Spring Boot：
 
mybatis-plus.type-aliases-package = cn.itcast.mp.pojo
 
Spring MVC：
 
 
     
 
4.2 进阶配置 
        本部分（Configuration）的配置大都为 MyBatis 原生支持的配置，这意味着您可以通过 MyBatis XML 配置文件的形式进行配置。
 
4.2.1 map-Underscore-To-Camel-Case 
类型： boolean 
默认值： true
        是否开启自动驼峰命名规则（camel case）映射，即从经典数据库列名 A_COLUMN（下划线命名） 到经典 Java 属性名 aColumn（驼峰命名） 的类似映射。
 
注意：
 此属性在 MyBatis 中原默认值为 false，在 MyBatis-Plus 中，此属性也将用于生成最终的 SQL 的 select body
 如果您的数据库命名符合规则无需使用 @TableField 注解指定数据库字段名
 
SpringBoot：
 
注意：关闭自动驼峰映射，该参数不能和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 
类型： com.baomidou.mybatisplus.annotation.IdType
默认值： ID_WORKER
         全局默认主键类型，设置后，即可省略实体对象中的@TableId(type = IdType.AUTO)配置。
 
SpringBoot：
 
mybatis-plus.global-config.db-config.id-type=auto
 
SpringMVC：
 
 
     
     
     
         
             
                                     
                      
                 
             
         
     
 
4.3.2 tablePrefix 
类型： String
默认值： null
         表名前缀，全局配置后可省略@TableName()配置。
 
 SpringBoot：
 
mybatis-plus.global-config.db-config.table-prefix=tb_
 
SpringMVC：
 
 
     
     
         
             
                 
                     
                     
                   
                 
             
         
    
 
5 、条件构造器 
        在MP中，Wrapper接口的实现类关系如下：
 
 
        可以看到，AbstractWrapper和AbstractChainWrapper是重点实现，接下来我们重点学习AbstractWrapper以及其子类。
 
说明:
 
        QueryWrapper(LambdaQueryWrapper) 和 UpdateWrapper(LambdaUpdateWrapper) 的父类 用于生成 sql的 where 条件, entity 属性也用于生成 sql 的 where 条件
 
        注意: entity 生成的 where 条件与 使用各个 api 生成的 where 条件没有任何关联行为
 
官网文档地址：https://mybatis.plus/guide/wrapper.html
 
5.1 allEq 
5.1.1 说明 
 
 
allEq(Map params)
 allEq(Map params, boolean null2IsNull)
 allEq(boolean condition, Map params, boolean null2IsNull)
 
 
 全部eq(或个别isNull)
        个别参数说明: params : key 为数据库字段名, value 为字段值 ,null2IsNull : 为 true 则在 map 的 value 为 null 时调用 isNull 方法,为 false 时则忽略 value 为 null 的
 
例1: allEq({id:1,name:"老王",age:null}) ---> id = 1 and name = '老王' and age is null
例2: allEq({id:1,name:"老王",age:null}, false) ---> id = 1 and name = '老王'
 
 
allEq(BiPredicate filter, Map params)
 
 
allEq(BiPredicate filter, Map params, boolean null2IsNull)
 
 
allEq(boolean condition, BiPredicate filter, Map params, boolean null2IsNull)
 
 
        个别参数说明: filter : 过滤函数,是否允许字段传入比对条件中 params 与 null2IsNull : 同上
 
例1: allEq((k,v) -> k.indexOf("a") > 0, {id:1,name:"老王",age:null}) ---> name = '老王' and age is null
例2: allEq((k,v) -> k.indexOf("a") > 0, {id:1,name:"老王",age:null}, false) ---> name = '老王'
 5.1.2 测试用例 
@RunWith(SpringRunner.class) 
@SpringBootTest 
public class UserMapperTest { 
    @Autowired 
    private UserMapper userMapper;

    @Test
    public void testWrapper(){
        QueryWrapper wrapper = new QueryWrapper<>();

        //设置条件
        Map params = new HashMap<>();
        params.put("name","曹操");
        params.put("age","20");
        params.put("password",null);

        //wrapper.allEq(params); SELECT * FROM tb_user WHERe password IS NULL AND name = ? AND age = ?
        //wrapper.allEq(params,false); SELECt * FROM tb_user WHERe name = ? AND age = ?
        //wrapper.allEq((K,V) -> (K.equals("name") || (K.equals("age"))) , params);  SELECt * FROM tb_user WHERe name = ? AND age = ?

        List list = this.userMapper.selectList(wrapper);
        for (User user : list) {
            System.out.println(user);
        }

    }
}
 
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, ...)
 测试用例：
 
@RunWith(SpringRunner.class) 
@SpringBootTest 
public class UserMapperTest { 

    @Autowired 
    private UserMapper userMapper;

    @Test
    public void userMapper(){
        QueryWrapper wrapper = new QueryWrapper<>();

        //SELECT * FROM tb_user WHERe password = ? AND age >= ? AND name IN (?,?,?)
        wrapper.eq("password","123456")
                .ge("age",20)
                .in("name","李四","王五","赵六");

        List list = this.userMapper.selectList(wrapper);
        for (User user : list) {
            System.out.println(user);
        }
    }
}
 
5.3 模糊查询 
like 
  
LIKE '%值%'
例: like("name", "王") ---> name like '%王%'
notLike 
  
NOT LIKE '%值%'
例: notLike("name", "王") ---> name not like '%王%'
likeLeft 
  
LIKE '%值'
例: likeLeft("name", "王") ---> name like '%王'
likeRight 
  
LIKE '值%'
例: likeRight("name", "王") ---> name like '王%'
 测试用例：
 
@RunWith(SpringRunner.class) 
@SpringBootTest 
public class UserMapperTest { 

    @Autowired 
    private UserMapper userMapper;

    @Test//模糊查询
    public void testWrapperLike(){
        QueryWrapper wrapper = new QueryWrapper<>();


        //wrapper.likeLeft("name","焦"); SELECT * FROM tb_user WHERe name LIKE ? Parameters: %焦(String)

        //wrapper.like("name","张"); SELECt * FROM tb_user WHERe name LIKE ? Parameters: %张%(String)

        List list = this.userMapper.selectList(wrapper);
        for (User user : list) {
            System.out.println(user);
        }
    }

    
}
 
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
 测试用例：
 
@RunWith(SpringRunner.class) 
@SpringBootTest 
public class UserMapperTest { 

    @Autowired 
    private UserMapper userMapper;

    @Test//排序
    public void testWrapperOrder(){
        QueryWrapper wrapper = new QueryWrapper<>();

        //按照倒序进行排序
        wrapper.orderByDesc("age"); //SELECT * FROM tb_user ORDER BY age DESC

        List list = this.userMapper.selectList(wrapper);
        for (User user : list) {
            System.out.println(user);
        }
    }    
}
 
5.5 逻辑查询 
or 
  
拼接 OR
主动调用 or 表示紧接着下一个方法不是用 and 连接!(不调用 or 则默认为使用 and 连接)
and 
  
AND 嵌套
例: and(i -> i.eq("name", "李白").ne("status", "活着")) ---> and (name = '李白' and status <> '活着')
 测试用例：
 
@RunWith(SpringRunner.class) 
@SpringBootTest 
public class UserMapperTest { 

    @Autowired 
    private UserMapper userMapper;

    @Test//逻辑查询
    public void testWrapperOr(){
        QueryWrapper wrapper = new QueryWrapper<>();

        wrapper.eq("name","李四").or().eq("age",0); //SELECT * FROM tb_user WHERe name = ? OR age = ?

        List list = this.userMapper.selectList(wrapper);
        for (User user : list) {
            System.out.println(user);
        }
    }
}
 
5.6 select 
        在MP查询中，默认查询所有的字段，如果有需要也可以通过select方法进行指定字段。
 
@RunWith(SpringRunner.class) 
@SpringBootTest 
public class UserMapperTest { 

    @Autowired 
    private UserMapper userMapper;

    @Test//查询表中指定字段的数据
    public void testWrapperSelect(){
        QueryWrapper wrapper = new QueryWrapper<>();

        wrapper.select("username","password"); //SELECT username,password FROM tb_user

        List list = this.userMapper.selectList(wrapper);
        for (User user : list) {
            System.out.println(user);
        }
    }
}
 
6、插件 
6.1 mybatis的插件机制 
        MyBatis 允许你在已映射语句执行过程中的某一点进行拦截调用。默认情况下，MyBatis 允许使用插件来拦截的方法调用包括：
 
 
 
1. Executor (update, query, flushStatements, commit, rollback, getTransaction, close, isClosed)
 2. ParameterHandler (getParameterObject, setParameters)
 3. ResultSetHandler (handleResultSets, handleOutputParameters)
 4. StatementHandler (prepare, parameterize, batch, update, query)
 
 
        我们看到了可以拦截Executor接口的部分方法，比如update，query，commit，rollback等方法，还有其他接口的一些方法等。
 
总体概括为：
         1. 拦截执行器的方法
         2. 拦截参数的处理
         3. 拦截结果集的处理
         4. 拦截Sql语法构建的处理
 
拦截器示例：
 
第一步，先创建一个 plugins 包，并写上自定义的拦截器
 
@Intercepts({@Signature( 
        type= Executor.class, 
        method = "update", 
        args = {MappedStatement.class,Object.class})}) 
public class MyInterceptor implements Interceptor { 

    @Override 
    public Object intercept(Invocation invocation) throws Throwable { 
        //拦截方法，具体业务逻辑编写的位置 
        return invocation.proceed();
        }

        @Override 
        public Object plugin(Object target) { 
            //创建target对象的代理对象,目的是将当前拦截器加入到该对象中 
            return Plugin.wrap(target, this); 
            }

        @Override 
        public void setProperties(Properties properties) { 
            //属性设置 
        } 
}
 
        注入到Spring容器：
 
@Bean 
public MyInterceptor myInterceptor(){ 
    return new MyInterceptor(); 
}
 
        或者通过xml配置，mybatisConfig.xml：
 
 
 
 
     
         
     
 
6.2 执行分析插件 
        在MP中提供了对SQL执行的分析的插件，可用作阻断全表更新、删除的操作，
 
        注意：该插件仅适用于开发环境，不适用于生产环境。
 
SpringBoot配置：
 
@Bean 
public SqlExplainInterceptor sqlExplainInterceptor(){ 
    SqlExplainInterceptor sqlExplainInterceptor = new SqlExplainInterceptor(); 

    List sqlParserList = new ArrayList<>(); 
    // 攻击 SQL 阻断解析器、加入解析链 
    sqlParserList.add(new BlockAttackSqlParser());         
    sqlExplainInterceptor.setSqlParserList(sqlParserList); 

    return sqlExplainInterceptor; 
}
 
测试：
 
@Test
    public void testUpdateAnalyse(){
        User user = new User();
        user.setAge(20);

        int result = this.userMapper.update(user,null);
        System.out.println(result);
    }
 
        结果：可以看到，当执行全表更新时，会抛出异常，这样有效防止了一些误操作。
 
6.3 性能分析插件 
        性能分析拦截器，用于输出每条 SQL 语句及其执行时间，可以设置最大执行时间，超过时间会抛出异常。
 
        该插件只用于开发环境，不建议生产环境使用。
 
配置：
 
 
 
 
     
         
         
             
             
             
         
     
 
执行结果：
 
 
 
Time：14 ms - ID：com.itheima.mapper.UserMapper.selectList
 Execute SQL：
     SELECT
         id,
         username,
         password,
         name,
         age,
         email AS mail 
     FROM
         tb_user
 
 
        可以看到，执行时间为14ms。如果将maxTime设置为1，那么，该操作会抛出异常。
 
 
 
Caused by: com.baomidou.mybatisplus.core.exceptions.MybatisPlusException:  The SQL execution time is too large, please optimize !  
 
 
6.4 乐观锁插件 
6.4.1 主要适用场景 
        意图：当要更新一条记录的时候，希望这条记录没有被别人更新
 乐观锁实现方式：
 
取出记录时，获取当前version
更新时，带上这个version
执行更新时， set version = newVersion where version = oldVersion
如果version不对，就更新失败
 6.4.2 插件配置 
 spring xml:
 
 
spring boot:
 
@Bean 
public OptimisticLockerInterceptor optimisticLockerInterceptor() { 
    return new OptimisticLockerInterceptor(); 
}
 
6.4.3 注解实体字段 
        需要为实体字段添加@Version注解。
 
第一步，为表添加version字段，并且设置初始值为1：
 
ALTER TABLE `tb_user` ADD COLUMN `version` int(10) NULL AFTER `email`; 

UPDATe `tb_user` SET `version`='1';
 
第二步，为User实体对象添加version字段，并且添加@Version注解：
 
@Version 
private Integer version;
 
6.4.4 测试 
测试用例：
 
@Test
    public void testUpdateVersion(){
        User user = new User();
        User user1 = this.userMapper.selectById(1L);
        user.setAge(17);
        user.setId(1L);
        user.setVersion(user1.getVersion());//获取到的version为1

        int result = this.userMapper.updateById(user);
        System.out.println("result =>" + result);
    }
 
        可以看到，更新的条件中有version条件，并且更新的version为2。
         如果再次执行，更新则不成功。这样就避免了多人同时更新时导致数据的不一致。
 
6.4.5 特别说明 
支持的数据类型只有:int,Integer,long,Long,Date,Timestamp,LocalDateTime
整数类型下 newVersion = oldVersion + 1 newVersion 会回写到 entity 中
仅支持 updateById(id) 与 update(entity, wrapper) 方法
在 update(entity, wrapper) 方法下, wrapper 不能复用!!!
7、Sql 注入器 
        我们已经知道，在MP中，通过AbstractSqlInjector将baseMapper中的方法注入到了Mybatis容器，这样这些方法才可以正常执行。
 
        那么，如果我们需要扩充baseMapper中的方法，又该如何实现呢？
 
        下面我们以扩展findAll方法为例进行学习。
 
8、自动填充功能 
        有些时候我们可能会有这样的需求，插入或者更新数据时，希望有些字段可以自动填充数据，比如密码、version等。在MP中提供了这样的功能，可以实现自动填充。
 
8.1 添加@TableField注解 
@TableField(fill = FieldFill.INSERT) //插入数据时进行填充 
private String password;
 
        为password添加自动填充功能，在新增数据时有效。
 
        FieldFill提供了多种模式选择：
 
public enum FieldFill { 
     
    DEFAULT, 
     
    INSERT, 
     
    UPDATE, 
     
    INSERT_UPDATE 
}
 
8.2 编写MymetaObjectHandler 
package com.itheima.handler;

import com.baomidou.mybatisplus.core.handlers.metaObjectHandler;
import org.apache.ibatis.reflection.metaObject;
import org.springframework.stereotype.Component;


@Component
public class MymetaObjectHandler implements metaObjectHandler {
    @Override
    public void insertFill(metaObject metaObject) {
        //首先得到表中password的值，然后对得到的值进行判断，如果为空则进行填充，否则不用管
        Object password = getFieldValByName("password", metaObject);
        if(password == null){
            //字段为空，可以进行填充
            setFieldValByName("password", "888888", metaObject);
        }
    }

    @Override
    public void updateFill(metaObject metaObject) {

    }
}
 
8.3 测试 
//插入一条数据
    @Test
    public void testInsert(){
        User user = new User();
        user.setUsername("guanyu");
        //user.setPassword("666666");
        user.setName("关羽");
        user.setAge(200);
        user.setMail("guanyu@163.com");

        int result = this.userMapper.insert(user);

        System.out.println("result =>" + result);

        System.out.println(user.getId());
    }
 
9、逻辑删除 
        开发系统时，有时候在实现功能时，删除操作需要实现逻辑删除，所谓逻辑删除就是将数据标记为删除，而并非真正的物理删除（非DELETE操作），查询时需要携带状态条件，确保被标记的数据不被查询到。这样做的目的就是避免数据被真正的删除。
 
        MP就提供了这样的功能，方便我们使用，接下来我们一起学习下。
 
9.1 修改表结构 
        为tb_user表增加deleted字段，用于表示数据是否被删除，1代表删除，0代表未删除。
 
ALTER TABLE `tb_user` ADD COLUMN `deleted` INT(1) NULL DEFAULT 0 COMMENT '1代表删除，0代表未删除' AFTER `version`;
 
        同时，也修改User实体，增加deleted属性并且添加@TableLogic注解：
 
@TableLogic 
private Integer deleted;
 
9.2 配置 
application.properties：
 
# 逻辑已删除值(默认为 1) 
mybatis-plus.global-config.db-config.logic-delete-value=1 
# 逻辑未删除值(默认为 0) 
mybatis-plus.global-config.db-config.logic-not-delete-value=0
 
9.3 测试 
//删除操作  根据ID删除
    @Test
    public void testDeleteById(){
        int result = this.userMapper.deleteById(1l);

        System.out.println("result =>" + result);
    }
 
测试查询：
 
//根据id进行查询
    @Test
    public void selectById(){
        User user = this.userMapper.selectById(1l);
        System.out.println(user);
    }
 
        可见，已经实现了逻辑删除。
 
10、通用枚举 
         解决了繁琐的配置，让 mybatis 优雅的使用枚举属性！
 
10.1 修改表结构 
ALTER TABLE tb_user ADD COLUMN sex INT(1) NULL DEFAULT 1 COMMENT '1-男，2-女' AFTER deleted;
 
10.2 定义枚举 
package com.itheima.enums;

import com.baomidou.mybatisplus.core.enums.IEnum;


public enum SexEnum implements IEnum {

    MAN(1,"男"),
    WOMAN(2,"女");

    private int value;
    private String desc;

    SexEnum(int value, String desc) {
        this.value = value;
        this.desc = desc;
    }

    @Override
    public Integer getValue() {
        return this.value;
    }

    @Override
    public String toString() {
        return this.desc;
    }
}
 
10.3 配置 
# 枚举包扫描 
mybatis-plus.type-enums-package=cn.itcast.mp.enums
 
10.4 修改实体 
private SexEnum sex;
 
10.5 测试 
测试插入数据：
 
 //插入一条数据
    @Test
    public void testInsert(){
        User user = new User();
        user.setUsername("diaochan");
        //user.setPassword("666666");
        user.setName("貂蝉");
        user.setAge(18);
        user.setMail("diaochan@163.com");
        user.setVersion(1);
        user.setSex(SexEnum.WOMAN);

        int result = this.userMapper.insert(user);

        System.out.println("result =>" + result);

        System.out.println(user.getId());
    }
 
SQL：
 
==>  Preparing: INSERT INTO tb_user ( username, password, name, age, email, version, sex ) VALUES ( ?, ?, ?, ?, ?, ?, ? ) 
==> Parameters: diaochan(String), 888888(String), 貂蝉(String), 18(Integer), diaochan@163.com(String), 1(Integer), 2(Integer)
<==    Updates: 1
 
查询：
 
//根据id进行查询
    @Test
    public void selectById(){
        User user = this.userMapper.selectById(9l);
        System.out.println(user);
    }
 
结果： 
 
User{id=9, username='diaochan', password='888888', name='貂蝉', age=18, mail='diaochan@163.com', address='null', version=1, deleted=0, sex=女}
 
        从测试可以看出，可以很方便的使用枚举了。
         查询条件时也是有效的：
 
@Test
    public void testSelectBySex(){
        QueryWrapper wrapper = new QueryWrapper<>();
        wrapper.eq("sex",SexEnum.WOMAN);

        List list = this.userMapper.selectList(wrapper);
        for (User user : list) {
            System.out.println(user);
        }
    }
 
SQL：
 
==>  Preparing: SELECT id,username,password,name,age,email AS mail,version,deleted,sex FROM tb_user WHERe deleted=0 AND sex = ? 
==> Parameters: 2(Integer)
<==      Total: 1
 
11、代码生成器 
        AutoGenerator 是 MyBatis-Plus 的代码生成器，通过 AutoGenerator 可以快速生成 Entity、Mapper、MapperXML、Service、Controller 等各个模块的代码，极大的提升了开发效率。
 
11.1 创建工程 
pom.xml：
 
 
 
    4.0.0 

     
        org.springframework.boot 
        spring-boot-starter-parent 
        2.1.4.RELEASE 
     

    cn.itcast.mp 
    itcast-mp-generator 
    1.0-SNAPSHOT 

     
         
            org.springframework.boot 
            spring-boot-starter-test 
            test 
         

         
         
            com.baomidou 
            mybatis-plus-boot-starter 
            3.1.1 
         

         
            com.baomidou 
            mybatis-plus-generator 
            3.1.1 
         

         
            org.springframework.boot 
            spring-boot-starter-freemarker 
         

         
         
            mysql 
            mysql-connector-java 
            5.1.47 
         

         
            org.slf4j 
            slf4j-log4j12 
         
     

    
         
             
                org.springframework.boot 
                spring-boot-maven-plugin 
             
         
     
 
11.2 代码 
package cn.itcast.mp.generator; 
import java.util.ArrayList; 
import java.util.List; 
import java.util.Scanner; 
import com.baomidou.mybatisplus.core.exceptions.MybatisPlusException; 
import com.baomidou.mybatisplus.core.toolkit.StringPool; 
import com.baomidou.mybatisplus.core.toolkit.StringUtils; 
import com.baomidou.mybatisplus.generator.AutoGenerator; 
import com.baomidou.mybatisplus.generator.InjectionConfig; 
import com.baomidou.mybatisplus.generator.config.DataSourceConfig; 
import com.baomidou.mybatisplus.generator.config.FileOutConfig; 
import com.baomidou.mybatisplus.generator.config.GlobalConfig; 
import com.baomidou.mybatisplus.generator.config.PackageConfig; 
import com.baomidou.mybatisplus.generator.config.StrategyConfig; 
import com.baomidou.mybatisplus.generator.config.TemplateConfig; 
import com.baomidou.mybatisplus.generator.config.po.TableInfo; 
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy; 
import com.baomidou.mybatisplus.generator.engine.FreemarkerTemplateEngine; 
 
public class MysqlGenerator { 

 

    public static String scanner(String tip) { 
        Scanner scanner = new Scanner(System.in); 
        StringBuilder help = new StringBuilder(); 
        help.append("请输入" + tip + "："); 
        System.out.println(help.toString()); 
        if (scanner.hasNext()) { 
            String ipt = scanner.next();
            if (StringUtils.isNotEmpty(ipt)) { 
                return ipt; 
            } 
        }
        throw new MybatisPlusException("请输入正确的" + tip + "！"); 
    }


 

public static void main(String[] args) { 
    // 代码生成器 
    AutoGenerator mpg = new AutoGenerator(); 

    // 全局配置 
    GlobalConfig gc = new GlobalConfig(); 
    String projectPath = System.getProperty("user.dir"); 
    gc.setOutputDir(projectPath + "/src/main/java"); 
    gc.setAuthor("itcast"); 
    gc.setOpen(false); 
    mpg.setGlobalConfig(gc); 

    // 数据源配置 
    DataSourceConfig dsc = new DataSourceConfig();             
    dsc.setUrl("jdbc:mysql://127.0.0.1:3306/mp? useUnicode=true&useSSL=false&characterEncoding=utf8"); 
    // dsc.setSchemaName("public"); 
    dsc.setDriverName("com.mysql.jdbc.Driver"); 
    dsc.setUsername("root"); 
    dsc.setPassword("root"); 
    mpg.setDataSource(dsc); 

    // 包配置 
    PackageConfig pc = new PackageConfig(); 
    pc.setModuleName(scanner("模块名")); 
    pc.setParent("cn.itcast.mp.generator"); 
    mpg.setPackageInfo(pc); 

    // 自定义配置 
    InjectionConfig cfg = new InjectionConfig() { 
        @Override 
        public void initMap() { 
            // to do nothing 
        } 
    };
    List focList = new ArrayList<>(); 
    focList.add(new FileOutConfig("/templates/mapper.xml.ftl") { 
        @Override 
        public String outputFile(TableInfo tableInfo) { 
            // 自定义输入文件名称 
            return projectPath + "/itcast-mp- generator/src/main/resources/mapper/" + pc.getModuleName()+ "/" + tableInfo.getEntityName() + "Mapper" + StringPool.DOT_XML; 
            } 
        }); 

        cfg.setFileOutConfigList(focList); 
        mpg.setCfg(cfg); 
        mpg.setTemplate(new TemplateConfig().setXml(null));   
        
        // 策略配置 
        StrategyConfig strategy = new StrategyConfig();             
        strategy.setNaming(NamingStrategy.underline_to_camel);         
        strategy.setColumnNaming(NamingStrategy.underline_to_camel); 

//strategy.setSuperEntityClass("com.baomidou.mybatisplus.samples.generator.common.baseE ntity");
        strategy.setEntityLombokModel(true); //strategy.setSuperControllerClass("com.baomidou.mybatisplus.samples.generator.common.baseController"); 
        strategy.setInclude(scanner("表名")); 
        strategy.setSuperEntityColumns("id"); 
        strategy.setControllerMappingHyphenStyle(true);             
        strategy.setTablePrefix(pc.getModuleName() + "_"); 
        mpg.setStrategy(strategy); 
        // 选择 freemarker 引擎需要指定如下加，注意 pom 依赖必须有！ 
        mpg.setTemplateEngine(new FreemarkerTemplateEngine()); 
        mpg.execute(); 
     } 
}

 
测试：
 
                请输入模块名：
 
                user
 
                请输入表明：
 
                tb_user
 
12、MybatisX 快速开发插件 
        MybatisX 是一款基于 IDEA 的快速开发插件，为效率而生。
 
        安装方法：打开 IDEA，进入 File -> Settings -> Plugins -> Browse Repositories，输入 mybatisx 搜索并安装。
 
功能：
 
Java 与 XML 调回跳转
Mapper 方法自动生成 XML



转载请注明：文章转载自 www.mshxw.com
本文地址：https://www.mshxw.com/it/353480.html


   上一篇  Java笔记 —— 反射的两个实例
 
   下一篇  【Flutter】Dart中的Mixins混入你知道是什么吗？
  






Java相关栏目本月热门文章

  
1【Linux驱动开发】设备树详解（二）设备树语法详解
  
2别跟客户扯细节
  
3Springboot+RabbitMQ+ACK机制(生产方确认(全局、局部)、消费方确认)、知识盲区
  
4【Java】对象处理流（ObjectOutputStream和ObjectInputStream）
  
5【分页】常见两种SpringBoot项目中分页技巧
  
6一文带你搞懂OAuth2.0
  
7我要写整个中文互联网界最牛逼的JVM系列教程 | 「JVM与Java体系架构」章节：虚拟机与Java虚拟机介绍
  
8【Spring Cloud】新闻头条微服务项目：FreeMarker模板引擎实现文章静态页面生成
  
9JavaSE - 封装、static成员和内部类
  
10树莓派mjpg-streamer实现监控及拍照功能调试
  
11用c++写一个蓝屏代码
  
12从JDK8源码中看ArrayList和LinkedList的区别
  
13idea 1、报错java: 找不到符号 符号: 变量 log 2、转换成Maven项目
  
14在openwrt使用C语言增加ubus接口（包含C uci操作）
  
15Spring 解决循环依赖
  
16SpringMVC——基于MVC架构的Spring框架
  
17Andy‘s First Dictionary C++ STL set应用
  
18动态内存管理
  
19我的创作纪念日
  
20Docker自定义镜像-Dockerfile







热门相关搜索



路由器设置
木托盘
宝塔面板
儿童python教程
心情低落
朋友圈
vim
双一流学科
专升本
我的学校
日记学校
西点培训学校
汽修学校
情书
化妆学校
塔沟武校
异形模板
西南大学排名
最精辟人生短句
6步教你追回被骗的钱
南昌大学排名
清朝十二帝
北京印刷学院排名
北方工业大学排名
北京航空航天大学排名
首都经济贸易大学排名
中国传媒大学排名
首都师范大学排名
中国地质大学(北京)排名
北京信息科技大学排名
中央民族大学排名
北京舞蹈学院排名
北京电影学院排名
中国戏曲学院排名
河北政法职业学院排名
河北经贸大学排名
天津中德应用技术大学排名
天津医学高等专科学校排名
天津美术学院排名
天津音乐学院排名
天津工业大学排名
北京工业大学耿丹学院排名
北京警察学院排名
天津科技大学排名
北京邮电大学(宏福校区)排名
北京网络职业学院排名
北京大学医学部排名
河北科技大学排名
河北地质大学排名
河北体育学院排名







学习工具
代数计算器
三角函数
解析几何
立体几何


知识解答
教育知识
百科知识
生活知识
常识知识


写作必备
作文大全
作文素材
句子大全

实用范文


关于我们
关于我们
联系我们
网站地图


 
名师互学网交流群


名师互学网客服





名师互学网 版权所有 (c)2021-2022      ICP备案号：晋ICP备2021003244-6号
 






关于我们
文章归档
网站地图
联系我们
版权所有 (c)2021-2022 MSHXW.COM
ICP备案号：晋ICP备2021003244-6号