Mybatis-Plus学习笔记（自用）

Mybatis-Plus学习笔记（自用）

本文根据黑马程序员的课程资料与百度搜索的资料共同整理所得，仅用于学习使用，如有侵权，请联系删除

1.纯Mybatis与Mybatis-Plus整合

1.导入依赖

   <dependencies>
    
        <dependency>
            <groupId>com.baomidougroupId>
            <artifactId>mybatis-plusartifactId>
            <version>3.1.1version>
        dependency>
 
        
    <dependency>
        <groupId>mysqlgroupId>
        <artifactId>mysql-connector-javaartifactId>
        <version>8.0.25version>
    dependency>
        
        <dependency>
            <groupId>com.alibabagroupId>
            <artifactId>druidartifactId>
            <version>1.1.24version>
        dependency>
 
        
        <dependency>
            <groupId>org.projectlombokgroupId>
            <artifactId>lombokartifactId>
            <optional>trueoptional>
            <version>1.18.4version>
        dependency>
        <dependency>
            <groupId>junitgroupId>
            <artifactId>junitartifactId>
            <version>4.12version>
        dependency>
        <dependency>
            <groupId>org.slf4jgroupId>
            <artifactId>slf4j-log4j12artifactId>
            <version>1.6.4version>
        dependency>
    dependencies>

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

jdbc.properties：

jdbc.username=
jdbc.password=
jdbc.url=jdbc:mysql://localhost:3306/mabatis-puls
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.initialSize=5
jdbc.maxActive=10

3.编写mybatis-config.xml文件：

4.编写User

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

5.将UserMapper继承BaseMapper，将拥有了BaseMapper中的所有方法：

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

6.使用MP中的MybatisSqlSessionFactoryBuilder进程构建

public class MybatistTest {
    @Test
    public void testFindAll() throws IOException {
        InputStream resourceAsFile = Resources.getResourceAsStream("mybatis-config.xml");
        //这里使用的是MP中的MybatisSqlSessionFactoryBuilder
        SqlSessionFactory sqlSessionFactory = new MybatisSqlSessionFactoryBuilder().build(resourceAsFile);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        
       //  可以调用BaseMapper中定义的方法
        List<User> users = mapper.selectList(null);
        System.out.println(users);
        sqlSession.close();
 
    }
}

2.Spring + Mybatis + MP

数据源、构建等工作交给了Spring管理

1.导入依赖

2.编写applicationContext.xml

<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
http://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="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
        <property name="driverClassName" value="${jdbc.driverClassName}"/>
        <property name="maxActive" value="10"/>
        <property name="minIdle" value="5"/>
    bean>
    
    <bean id="sessionFactory" class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
    bean>
 
    
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="mapper"/>
    bean>
 
beans>

3.编写User对象以及UserMapper接口

4.测试

3. SpringBoot + Mybatis + MP

简化MP整合

1.导入依赖（注意使用SpringBoot需要继承parent）

    <parent>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-parentartifactId>
        <version>2.1.4.RELEASEversion>
    parent>

2.编写application.properties

spring.application.name = my-mp-springboot
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/test/mp?
useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true&useSSL=false
spring.datasource.username=
spring.datasource.password=

3.编写User对象以及UserMapper接口

4.编写启动类

@MapperScan("cn.itcast.mp.mapper") //设置mapper接口的扫描包
@SpringBootApplication
public class MyApplication {
 
    public static void main(String[] args) {
    SpringApplication.run(MyApplication.class, args);
}
}

5.测试

4.通用CRUD详解

4.1 注解详解

• @TableName声明对应的表（当表名与实体类名不一致时）

@TableName("user")

• @TableId声明属性为表中的主键

  （若属性名称不为默认id:比如数据中的表中的字段是id,但是实体类是userId）

@TableId(type = IdType.AUTO)

//设置id的生成策略：
//AUTO---数据库ID自增
//NONE---该类型为未设置主键类型
//INPUT---用户输入ID,insert 前自行 set 主键值

//以下3种类型、只有当插入对象ID为空，才自动填充。
//ID_WORKER---全局唯一ID (idWorker,Long)
//UUID---全局唯一ID (UUID,String)
//ID_WORKER_STR---字符串全局唯一ID (idWorker 的字符串表示)

• @TableFieId(“字段”)，用来声明当实体类属性与表字段不一致的情况

//在MP中通过@TableField注解可以指定字段的一些属性，常常解决的问题有3个：
//1、对象中的属性名和字段名不一致的问题（非驼峰）
@TableField(value = "email")
private String mail;
//2、对象中的属性字段在表中不存在的问题
@TableField(exist = false)
//3、不希望某个属性值出现在查询结果中
@TableField(select = false)

4.2 增删改查操作

• 增

// 插入一条记录
int insert(T entity);

//result数据库受影响的行数
int result = this.userMapper.insert(user); 
//获取自增长后的id值, 自增长后的id值会回填到user对象中,数据库插入的id为全局默认的id
System.out.println("分配的id值为" + user.getId());

• 删

//根据 ID 删除
int deleteById(Serializable id);


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

//根据 columnMap 条件，删除记录
int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);

Map<String,Object> map = new HashMap<>();
map.put("user_name", "cui");
map.put("password", "123");
// 根据map删除数据，多条件之间是and关系
int result = this.userMapper.deleteByMap(map);

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

//用法一：
//QueryWrapper wrapper = new QueryWrapper<>();
// wrapper.eq("user_name", "cui")
//        .eq("password", "123");
//用法二(推荐使用)：
User user = new User();
user.setPassword("123");
user.setUserName("cui");
QueryWrapper<User> wrapper = new QueryWrapper<>(user);
// 根据包装条件做删除
int result = this.userMapper.delete(wrapper);

• 改

//根据 ID 修改
int updateById(@Param(Constants.ENTITY) T entity);

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

User user = new User();
user.setAge(20); //更新的字段
user.setPassword("8888888"); 
//更新条件
QueryWrapper<User> wrapper = new QueryWrapper<>();
wrapper.eq("user_name", "zhangsan"); //匹配user_name = zhangsan 的用户数据 
//根据条件做更新
int result = this.userMapper.update(user, wrapper);

//或者，通过UpdateWrapper进行更新
UpdateWrapper<User> wrapper = new UpdateWrapper<>();
wrapper.set("age", 21).set("password", "999999") //更新的字段，设置的是字段的名字，而不是实体的属性
        .eq("user_name", "zhangsan"); //更新的条件
 
        //根据条件做更新
        int result = this.userMapper.update(null, wrapper);

• 查

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

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

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

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

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

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

4.3 SQL注入原理

在MP中，ISqlInjector负责SQL的注入工作，它是一个接口，

AbstractSqlInjector是它的实现类，在AbstractSqlInjector中，

主要是由inspectInject()方法进行注入的，在实现方法中，

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);

以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中。

5.配置

5.1 基础配置

• configLocation：声明配置文件的位置（configLocation）

# Springboot
 mybatis-plus.config-location = classpath:mybatis-config.xml
# SpringMVC

    

• mapperLocations----配置自定义方法的位置

# Springboot
 mybatis-plus.mapper-locations = classpath*:mybatis/*.xml
# SPringMVC

    

• typeAliasesPackage—配置别名包扫描路径，配置后可直接用类名

# Springboot
mybatis-plus.type-aliases-package = cn.itcast.mp.pojo
# SpringMVC

    

5.2 进阶配置

本部分（Configuration）的配置大都为 MyBatis 原生支持的配置（这意味着可以通过 MyBatis XML 配置文件的形式进行配置），同时说明配置参数不能和mybatis-plus.config-location同时存在（因为用的就是原配置）

• mapUnderscoreToCamelCase配置是否开启自动驼峰命名规则映射

  （MP默认开启，mybatis中默认不开启）

# Springboot:
# 意味着若数据库命名符合规则，则无需使用 @TableField 注解指定数据库字段名。
mybatis-plus.configuration.map-underscore-to-camel-case=false

• cacheEnabled—配置是否需要缓存（默认开启）

# SpringBoot:
# 全局地开启或关闭配置文件中的所有映射器已经配置的任何缓存
 mybatis-plus.configuration.cache-enabled=false

5.3 DB策略配置

• idType—配置主键类型

# 全局默认主键类型，设置后，即可省略实体对象中的@TableId(type = IdType.AUTO)配置。
# Springboot:
mybatis-plus.global-config.db-config.id-type=auto

# SpringMVC:
# 这里使用MP提供的sqlSessionFactory，完成了Spring与MP的整合

    
    
        
            
                
                    
                
            
        
    

• tablePrefix—配置表明前缀

# 表名前缀，全局配置后可省略@TableName()配置。
# Springboot:
 mybatis-plus.global-config.db-config.table-prefix=tb_
 
# SpringMVC:

    
    
        
            
                
                    
                    
                
            
    
    

6.条件构造器

1.allEq

//params : key 为数据库字段名, value 为字段值 
//null2IsNull : 为 true 则在 map 的 value 为 null 时调用 isNull 方法,为 false 时则忽略 value 为 null 的情况(默认为true)

allEq(Map params)
allEq(Map params, boolean null2IsNull)
allEq(boolean condition, Map params, boolean null2IsNull)
    
allEq({id:1,name:"cui",age:null}) ---> id = 1 and name = 'cui' and age is null
allEq({id:1,name:"cui",age:null}, false) ---> id = 1 and name = 'cui'

//filter : 过滤函数,是否允许字段传入比对条件中
allEq(BiPredicate filter, Map params)
allEq(BiPredicate filter, Map params, boolean null2IsNull)
allEq(boolean condition, BiPredicate filter, Map params, boolean null2IsNull)

//设置条件
Map<String,Object> params = new HashMap<>();
params.put("name", "cui");
params.put("age", "18");
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<User> users = this.userMapper.selectList(wrapper);

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, …)

​

QueryWrapper<User> wrapper = new QueryWrapper<>();
//SELECT id,user_name,password,name,age,email FROM tb_user WHERE password = ? AND age >= ? AND name IN (?,?,?)

wrapper.eq("password", "123").ge("age", 18).in("name", "cui", "hua","x");
List<User> users = this.userMapper.selectList(wrapper);

3.模糊查询

操作	意义
LIKE ‘%值%’	like(“name”, “王”) —> name like ‘%王%’
NOT LIKE ‘%值%’	notLike(“name”, “王”) —> name not like ‘%王%’
LIKE ‘%值’	likeLeft(“name”, “王”) —> name like ‘%王’
LIKE ‘值%’	likeRight(“name”, “王”) —> name like ‘王%’

QueryWrapper<User> wrapper = new QueryWrapper<>();
//SELECT id,user_name,password,name,age,email FROM tb_user WHERE name LIKE ?
//Parameters: %c%(String)
wrapper.like("name", "c");
List<User> users = this.userMapper.selectList(wrapper);

4.排序

操作	意义
orderBy	orderBy(true, true, “id”, “name”) —> order by id ASC,name ASC
orderByAsc	orderByAsc(“id”, “name”) —> order by id ASC,name ASC
orderByDesc	orderByDesc(“id”, “name”) —> order by id DESC,name DESC

5.逻辑查询(不调用 or 则默认为使用 and 连接)

QueryWrapper<User> wrapper = new QueryWrapper<>();
wrapper.eq("name","李四").or().eq("age", 24);
List<User> users = this.userMapper.selectList(wrapper);

7.ActiveRecord

• ActiveRecord也属于ORM（对象关系映射）层，遵循标准的ORM模型：表映射到记录，记录映射到对象，字段映射到对象属性。

• ActiveRecord的主要思想是：每一个数据库表对应创建一个类，类的每一个对象实例对应于数据库中表的一行记录；

• ActiveRecord同时负责把自己持久化，在ActiveRecord中封装了对数据库的访问，即CURD;

在MP中，开启AR非常简单，

只需要将实体对象继承Model即可，只需继承 Model 类即可进行强大的 CRUD 操作

• 需要项目中提前准备好已注入对应实体的BaseMapper

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User extends Model<User> {
    private Long id;
    private String userName;
    private String password;
    private String name;
    private Integer age;
    private String email;
}

8.Mybatis-Plus的插件

8.1 mybatis的插件机制

MyBatis 允许你在已映射语句执行过程中的某一点进行拦截调用。

默认情况下，MyBatis 允许使用插件来拦截的方法 调用包括：

//拦截执行器的方法
Executor (update, query, flushStatements, commit, rollback, getTransaction, close, isClosed) 
//拦截参数的处理
ParameterHandler (getParameterObject, setParameters) 
//拦截结果集的处理
ResultSetHandler (handleResultSets, handleOutputParameters)  
//拦截Sql语法构建的处理    
StatementHandler (prepare, parameterize, batch, update, query)  

@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();
}

8.2 执行分析插件

在MP中提供了对SQL执行的分析的插件，可用作阻断全表更新、删除的操作，

注意：该插件仅适用于开发环境，不适用于生产环境。

@Bean
public SqlExplainInterceptor sqlExplainInterceptor(){
 
    SqlExplainInterceptor sqlExplainInterceptor = new SqlExplainInterceptor();
 
    List<ISqlParser> sqlParserList = new ArrayList<>();
 
    // 攻击 SQL 阻断解析器、加入解析链
    sqlParserList.add(new BlockAttackSqlParser());
    sqlExplainInterceptor.setSqlParserList(sqlParserList);
 
    return sqlExplainInterceptor;
}

8.3 性能分析插件

性能分析拦截器，用于输出每条 SQL 语句及其执行时间，可以设置最大执行时间，超过时间会抛出异常。

​ 该插件只用于开发环境，不建议生产环境使用。

<configuration>
<plugins>
        
        <plugin interceptor="com.baomidou.mybatisplus.extension.plugins.PerformanceInterceptor">
            
            <property name="maxTime" value="100"/>
            
            <property name="format" value="true"/>
        plugin>
configuration>

8.4 乐观锁插件

应用场景：防止出现多线程同时更新导致的数据互不匹配，即确保更新记录时，这条记录没有被其他线程更新

• 不管谁先执行都会确保只能有一个线程更新数据

  取出记录时，获取当前version
  更新时，带上这个version
  执行更新时， set version = newVersion where version = oldVersion
  如果version不对，就更新失败

//Spring
<bean class="com.baomidou.mybatisplus.extension.plugins.OptimisticLockerInterceptor"/>
//SpringBoot
@Bean
public OptimisticLockerInterceptor optimisticLockerInterceptor() {
    return new OptimisticLockerInterceptor();
}

//第一步，为表添加version字段，并且设置初始值为1：
//ALTER TABLE `tb_user` ADD COLUMN `version` int(10) NULL AFTER `email`;
//第二步，为User实体对象添加version字段，并且添加@Version注解：
//UPDATE `tb_user` SET `version`='1';
@Version
private Integer version;

User user = new User();
user.setId(2L);// 查询条件
User userVersion = user.selectById();
user.setAge(23); // 更新的数据
user.setVersion(userVersion.getVersion()); // 当前的版本信息
System.out.println("result => " + result);

说明：

• 支持的数据类型只有:int,Integer,long,Long,Date,Timestamp,LocalDateTime
• 整数类型下 newVersion = oldVersion + 1
• newVersion 会回写到 entity 中
• 仅支持 updateById(id) 与 update(entity, wrapper) 方法
• 在 update(entity, wrapper) 方法下, wrapper 不能复用!!!

9.Sql 注入器实现自定义全局操作

当需要扩充BaseMapper中的方法，需要用到Sql 注入器

1.编写MyBaseMapper（其他的Mapper都可以继承该Mapper，这样实现了统一的扩展:其他mapper都应该继承MyBaseMapper，而MyBaseMapper应该继承BaseMapper)

public interface MyBaseMapper<T> extends BaseMapper<T> {
    List<T> findAll();
    // 扩展其他的方法
}


public interface UserMapper extends MyBaseMapper<User> {
    User findById(Long id);
}

2.编写MySqlInjector( 如果直接继承AbstractSqlInjector的话，原有的BaseMapper中的方法将失效，所以选择继承DefaultSqlInjector 进行扩展。)

public class MySqlInjector extends DefaultSqlInjector {
 
    @Override
    public List<AbstractMethod> getMethodList() {
        List<AbstractMethod> list = new ArrayList<>();
 
        // 获取父类中的集合
        list.addAll(super.getMethodList());
 
        // 再扩充自定义的方法
        list.add(new FindAll());
 
        return list;
    }
}

3.编写FindAll

public class FindAll extends AbstractMethod {
    
    @Override
    public MappedStatement injectMappedStatement(Class<?> mapperClass, Class<?> modelClass, TableInfo tableInfo) {
        String sql = "select * from " + tableInfo.getTableName();
        SqlSource sqlSource = languageDriver.createSqlSource(configuration,sql, modelClass);
 
        return this.addSelectMappedStatement(mapperClass, "findAll", sqlSource, modelClass, tableInfo);
    }
}

4.注入到Spring容器

/**
     * 注入自定义的SQL注入器
     * @return
     */
@Bean
public MySqlInjector mySqlInjector(){
    return new MySqlInjector();
}

10.自动填充功能

1.添加@TableField注解

@TableField(fill = FieldFill.INSERT) //插入数据时进行填充
private String password;

//FieldFill提供了多种模式选择： 
public enum FieldFill {
    /**
    * 默认不处理
    */
    DEFAULT,
    /**
    * 插入时填充字段
    */
    INSERT,
    /**
    * 更新时填充字段
    */
    UPDATE,
    /**
    * 插入和更新时填充字段
    */
    INSERT_UPDATE
}

2.编写MyMetaObjectHandler

@Component
public class MyMetaObjectHandler implements MetaObjectHandler {
    /**
     * 插入数据时填充
     * @param metaObject
     */
    @Override
    public void insertFill(MetaObject metaObject) {
        // 先获取到password的值，再进行判断，如果为空，就进行填充，如果不为空，就不做处理
        Object password = getFieldValByName("password", metaObject);
        //字段为空就填入
        if(null == password){
           setFieldValByName("password", "888888", metaObject);
        }
    }
 
    /**
     * 更新数据时填充
     * @param metaObject
     */
    @Override
    public void updateFill(MetaObject metaObject) {
 
    }
}

11.逻辑删除

将数据标记为删除，而并非真正的物理删除（非DELETE操作),

查询时需要携带状态条件，确保被标记的数据不被查询到。这样做的目的就是避免数据被真正的删除 ，有回旋余地。

1.修改表结构

ALTER TABLE `tb_user`
ADD COLUMN `deleted` int(1) 
NULL DEFAULT 0 COMMENT '1代表删除，0代表未删除' 
AFTER`version`;

//增加deleted属性并且添加@TableLogic注解：
@TableLogic
private Integer deleted;

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

12.通用枚举

1.修改表结构

ALTER TABLE `tb_user`
ADD COLUMN `sex` int(1) 
NULL DEFAULT 1 COMMENT '1-男，2-女' 
AFTER `deleted`;

2.定义枚举

public enum SexEnum implements IEnum<Integer> {
    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;
    }
}

3.配置application.properties：

# 枚举包扫描
mybatis-plus.type-enums-package=cn.itcast.mp.enums

4.修改实体

private SexEnum sex;

13.代码生成器

AutoGenerator 是 MyBatis-Plus 的代码生成器

通过 AutoGenerator 可以快速生成 Entity、Mapper、Mapper XML、Service、Controller 等各个模块的代码

1.创建工程导入包

        
        <dependency>
            <groupId>com.baomidougroupId>
            <artifactId>mybatis-plus-boot-starterartifactId>
            <version>3.1.1version>
        dependency>
        <dependency>
            <groupId>com.baomidougroupId>
            <artifactId>mybatis-plus-generatorartifactId>
            <version>3.1.1version>
        dependency>   

2.直接套用

//mysql 代码生成器演示例子
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 + "！");
    }
 
    //RUN THIS
    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("cui");
        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<FileOutConfig> focList = new ArrayList<>();
        focList.add(new FileOutConfig("/templates/mapper.xml.ftl") {
            @Override
            public String outputFile(TableInfo tableInfo) {
                // 自定义输入文件名称
                return projectPath + "/cui-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.BaseEntity");
        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();
    }
 
}

14.MyBatisX

安装方法：打开 IDEA，进入 File -> Settings -> Plugins -> Browse Repositories，输入 mybatisx 搜索并安装。
功能： Java 与 XML 调回跳转中，帮助把Mapper 方法自动生成 XML

MyBatis-Plus (baomidou.com)