Mybatis-Plus学习

Mybatis-Plus

官网：https://mp.baomidou.com/guide/

特性

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

快速入门

地址：https://mp.baomidou.com/guide/quick-start.html#%E5%88%9D%E5%A7%8B%E5%8C%96%E5%B7%A5%E7%A8%8B

• 创建数据库mybatis-Plus

  CREATE TABLE USER
  (
  	id BIGINT(20) NOT NULL COMMENT '主键ID',
  	NAME VARCHAR(30) NULL DEFAULT NULL COMMENT '姓名',
  	age INT(11) NULL DEFAULT NULL COMMENT '年龄',
  	email VARCHAR(50) NULL DEFAULT NULL COMMENT '邮箱',
  	PRIMARY KEY (id)
  );
  
  INSERT INTO USER (id, NAME, age, email) VALUES
  (1, 'Jone', 18, 'test1@baomidou.com'),
  (2, 'Jack', 20, 'test2@baomidou.com'),
  (3, 'Tom', 28, 'test3@baomidou.com'),
  (4, 'Sandy', 21, 'test4@baomidou.com'),
  (5, 'Billie', 24, 'test5@baomidou.com');
  

• 创建Spring-boot项目

• 导入依赖

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>
<!--自己开发的，并非官方的        -->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.0.5</version>
</dependency>
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>

我们使用Mybatis-Plus可以节省我们大量的代码

• 连接数据库

spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.url=jdbc:mysql://localhost:3306/mybatis-plu?useSSL=false&useUnicode=true&characterEncoding=utf-8
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

• 传统方式 pojo-dao（xml）-service-Controller

• 使用Mybatis-Plus

  • pojo

  @Data
  @AllArgsConstructor
  @NoArgsConstructor
  public class User {
      private Long id;
      private String name;
      private Integer age;
      private String email;
  
  }
  

  • Mapper

  /*
  * 在对应的Mapper上继承BaseMapper，注意泛型
  * 所有的CURD都已经编写完成
  * 不需要像以前一样写一大推的xml文件了
  * */
  @Repository//代表持久层
  public interface UserMapper extends BaseMapper<User> {
  
  }
  

  • 注意在主启动类上加上

  //扫描mapper
  @MapperScan("com.wzw.mapper")
  @SpringBootApplication
  public class MybatisplusApplication {
  
      public static void main(String[] args) {
          SpringApplication.run(MybatisplusApplication.class, args);
      }
  
  }
  

  • Test

  //继承了BaseMapper，所有的方法都来自父类，我们也可以编写自己的扩展方法
  @Autowired
  private UserMapper userMapper;
  
  @Test
  void contextLoads() {
      /*
      * 查询全部数据
      * 参数是一个Wrapper，条件构造器，这里我们先不用，用null表示查询所有数据
      * */
      List<User> userList = userMapper.selectList(null);
      System.out.println(userList);
  }
  

  • 结果

  [User(id=1, name=Jone, age=18, email=test1@baomidou.com), 
  
  User(id=2, name=Jack, age=20, email=test2@baomidou.com), 
  
  User(id=3, name=Tom, age=28, email=test3@baomidou.com), 
  
  User(id=4, name=Sandy, age=21, email=test4@baomidou.com), 
  
  User(id=5, name=Billie, age=24, email=test5@baomidou.com)]
  

配置日志

# 配置日志
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

CRUD扩展

插入

/*
* 会帮我们自动生成id，
* */
@Test
void TestInsert(){
    User user = new User(null,"汪镇威",21,"1522060995@qq.com");
    int insert = userMapper.insert(user);
    System.out.println(insert);
    System.out.println(user);

}

数据库插入的id的默认值为：全局的唯一id

id生成策略

分布式唯一id生成：https://blog.csdn.net/weixin_43737917/article/details/107136039

雪花算法

snowflake是Twitter开源的分布式ID生成算法，结果是一个long型的ID。其核心思想是：使用41bit作为毫秒数，10bit作为机器的ID（5个bit是数据中心，5个bit的机器ID），12bit作为毫秒内的流水号（意味着每个节点在每毫秒可以产生 4096 个 ID），最后还有一个符号位，永远是0。可以保证全球唯一java

@TableId(typt=IdType.ID_WORKER)
private Long id;

public enum IdType {
    /**
     * 数据库ID自增
     */
    AUTO(0),
    /**
     * 该类型为未设置主键类型
     */
    NONE(1),
    /**
     * 用户输入ID
     * 该类型可以通过自己注册自动填充插件进行填充
     */
    INPUT(2),

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

注意 官网已经废弃了最后三种，

主键自增

@TableId(type = IdType.AUTO)

使用这个的条件，数据库表id必须设置自增

更新

    /*
    * 通过条件自动拼接动态Sql
    * User user = new User(6L,"汪镇威");
    * 只会修改你的名字
    * User user = new User(6L,"汪镇威",20);
    * 修改你的名字和年龄，邮件不会变
    * */
@Test
void TestUpdate(){
    User user = new User(6L,"汪镇威",20,"1522060995@qq.com");
   userMapper.updateById(user);
}

自动填充

创建时间，修改时间！这些操作都是自动化完成的，不需要我们手动更新

阿里巴巴开发手册：所有数据库表：gmt_creat gmt_modified 几乎所有的表都要配置上，而且需要自动化！

• 方式一: 数据库级别

1.在表中新增creat_time,update_time

private Date creatTime;
private Date updateTime;

• 方式二：代码级别

先去掉时间字段默认值

/*
* 字段添加填充内容
FieldFill.INSERT表示插入时操作
FieldFill.INSERT_UPDATE表示插入，更新时操作
* */
@TableField(fill = FieldFill.INSERT)
private Date creatTime;
@TableField(fill = FieldFill.INSERT_UPDATE)
private Date updateTime;

编写处理器来处理这个注解即可！

官网：https://mp.baomidou.com/guide/auto-fill-metainfo.html

package com.wzw.Handler;

import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
import com.wzw.pojo.User;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.reflection.MetaObject;
import org.springframework.stereotype.Component;

import java.util.Date;

@Slf4j
@Component//一定不要忘记把我们的处理器加入到我们的IOC容器中
public class MyMetaObjectHandler implements MetaObjectHandler {
    /*
    * 插入时的填充策略
    * */
    @Override
    public void insertFill(MetaObject metaObject) {
        User user = new User();
        log.info("插入填充");
        /*
        * setFieldValByName(String fieldName, Object fieldVal, MetaObject metaObject)
        * fieldName:插入的字段名
        * fieldVal：插入的字段值
        * */
        this.setFieldValByName("creatTime",new Date(),metaObject);
        this.setFieldValByName("updateTime",new Date(),metaObject);
    }
    /*
     * 更新时的填充策略
     * */
    @Override
    public void updateFill(MetaObject metaObject) {
        log.info("更新操作");
        this.setFieldValByName("updateTime",new Date(),metaObject);
    }
}

测试

乐观锁

乐观锁：顾名思义，十分乐观，他认为不会出现问题，无论干什么不去上锁！，如果出现问题，再次更新值测试

version，new version 版本号

悲观锁：十分悲观，他任务干什么都会出现问题，无论干什么都会上锁，再去操作

Mybatis-plus乐观锁实现方式：

官网：https://mp.baomidou.com/guide/interceptor-optimistic-locker.html#optimisticlockerinnerinterceptor

当要更新一条记录的时候，希望这条记录没有被别人更新
乐观锁实现方式：

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

update user set name ="wzw" ,version=version+1
where id=2 and version=oldVersion

给数据库加字段

    /*
    * 版本号注解
    * */
    @Version
    private Integer version;

测试乐观锁

/*
* 测试乐观锁
* */
@Test
void TestOptimisticLocker(){
    //线程1
    User user = userMapper.selectById(1);
    user.setName("wzw");
    user.setAge(31);

    //模拟另一个线程执行了插队操作
    User user1 = userMapper.selectById(1);
    user1.setName("yda");
    user1.setAge(21);
    userMapper.updateById(user1);
    /*
    *如果没有乐观锁就会覆盖插队线程的值！更新失败
    * */
    userMapper.updateById(user);
}

查询操作

/*
* 批量查询
* */
@Test
void TestBatchIds(){
    List<User> userList = userMapper.selectBatchIds(Arrays.asList(1, 2, 3));
    userList.forEach(System.out::println);
}
/*
* 条件查询之使用map
* */
@Test
void TestMap(){
    HashMap<String, Object> map = new HashMap<>();
    map.put("name","汪镇威");
    map.put("age",20);
    List<User> userList = userMapper.selectByMap(map);


}

分页查询

1、原始的Limit进行分页

2、pageHalper分页插件

3、mybatis-plus内置分页插件

官网：https://mp.baomidou.com/guide/interceptor-pagination.html#paginationinnerinterceptor

• 配置config

 //分页插件
    @Bean
    public PaginationInterceptor paginationInterceptor(){
        return new PaginationInterceptor();
    }

• 测试

  /*
  * 测试分页查询
  * 使用了分页后，一切都变得简单了
  * */
  @Test
  void TestLimit(){
      /*
      * 参数current，当前页
      * 参数size，展示几条数据
      * */
      Page<User> page = new Page<>(2,5);
      userMapper.selectPage(page,null);
      System.out.println(page.getTotal());
      page.getRecords().forEach(System.out::println);
  }

删除

    /*
    * 删除
    * */
    @Test
    void TestDelete(){
        userMapper.deleteById(1452156706527178757L);
    }
    /*
    * 批量删除
    * */
    @Test
    void TestDeleteBatchIds(){
        userMapper.deleteBatchIds(Arrays.asList(1452156706527178756L,1452156706527178755L));
    }
    /*
    * 条件删除
    * */
    @Test
    void TestDeleteMap(){
        HashMap<String , Object> map = new HashMap<>();
        map.put("name","汪镇威");
        userMapper.deleteByMap(map);
    }

逻辑删除

物理删除：从数据库中直接删除

逻辑删除：再数据库中没有被删除，而是是他失效！delete=0 => delete=1

管理员可以查看被删除的记录！防止记录的丢失，类似于回收站！

• pojo

/*
* 逻辑删除注解
* */
@TableLogic
private Integer deleted;

• 配置

/*
* 逻辑删除
* 高版本只需要配置yml
* */
@Bean
public ISqlInjector iSqlInjector(){
    return  new LogicSqlInjector();
}

#配置逻辑删除
mybatis-plus.global-config.db-config.logic-delete-value=1
mybatis-plus.global-config.db-config.logic-not-delete-value=0

注意：遇到一个大坑

数据库字段名取名不能去关键字，比如delete，update等

性能分析插件

我们在平时的开发中，我们会遇到一些慢Sql。测试！

mybatis-plus也提供了性能分析插件，如果超过这个时间就停止运行！

官网：https://mp.baomidou.com/guide/p6spy.html

p6spy

<dependency>
  <groupId>p6spy</groupId>
  <artifactId>p6spy</artifactId>
  <version>最新版本</version>
</dependency>

条件构造器

/*
 * 条件构造器
 * */
@Test
void TestContext(){
    /*
    * 查询name不为空的用户，并且邮箱不为空的用户，年龄大于等于12
    * SELECT * FROM user WHERE deleted=0 AND name IS NOT NULL AND email IS NOT NULL AND age >= ?
     * */
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.isNotNull("name")
            .isNotNull("email")
            .ge("age",12);
    userMapper.selectList(wrapper);

}

@Test
void TestContext2(){
    /*
     * 查询name等于yda
     * SELECT * FROM user WHERE deleted=0 AND name = ?
     * */
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.eq("name","yda");
    userMapper.selectList(wrapper);
}

@Test
void TestContext3(){
    /*
     * 查询age在20和30之间
     * SELECT COUNT(1) FROM user WHERE deleted=0 AND age BETWEEN ? AND ?
     * */
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.between("age",10,20);
    userMapper.selectCount(wrapper);
}

模糊查询

@Test
void TestContext4(){
    /*
     * 查询名字不是yda的,模糊查询
     * SELECT * FROM user WHERE deleted=0 AND name NOT LIKE ? AND name LIKE ? 
     * Parameters: %yda%(String), %k%(String)
     * */
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.notLike("name","yda")
            .like("name","k");
    List<User> userList = userMapper.selectList(wrapper);
    System.out.println(userList);
}

子查询

@Test
void TestContext5(){
    /*
     * id在子查询中查出来
     * SELECT * FROM user WHERE deleted=0 AND id IN (select id from user where id<3)
     * */
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.inSql("id","select id from user where id<3");
    List<Object> list = userMapper.selectObjs(wrapper);

}

排序

@Test
void TestContext6(){
    /*
     * 根据id进行排序
     * SELECT * FROM user WHERE deleted=0 AND id IN (select id from user where id<3)
     * */
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.orderByDesc("id");//降序
    wrapper.orderByAsc("id");//升序
    List<User> list = userMapper.selectList(wrapper);
    list.forEach(System.out::println);

}

代码生成器

import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.config.DataSourceConfig;
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.po.TableFill;
import com.baomidou.mybatisplus.generator.config.rules.DateType;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
import java.util.ArrayList;
    // 代码自动生成器
    public class WparkCode {
        public static void main(String[] args) {
            // 需要构建一个 代码自动生成器 对象
            AutoGenerator mpg = new AutoGenerator();
            // 配置策略
            // 1、全局配置
            GlobalConfig gc = new GlobalConfig();
            String projectPath = System.getProperty("user.dir");
            gc.setOutputDir(projectPath+"/src/main/java");
            gc.setAuthor("wanghang");
            gc.setOpen(false);
            gc.setFileOverride(false); // 是否覆盖
            gc.setServiceName("%sService"); // 去Service的I前缀
            gc.setIdType(IdType.ID_WORKER);
            gc.setDateType(DateType.ONLY_DATE);
            gc.setSwagger2(true);
            mpg.setGlobalConfig(gc);
            //2、设置数据源
            DataSourceConfig dsc = new DataSourceConfig();
            dsc.setUrl("jdbc:mysql://localhost:3306/mybatis_plus? useSSL=false&useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8");
            dsc.setDriverName("com.mysql.cj.jdbc.Driver");
            dsc.setUsername("root");
            dsc.setPassword("123456");
            dsc.setDbType(DbType.MYSQL);
            mpg.setDataSource(dsc);
            //3、包的配置
            PackageConfig pc = new PackageConfig();
            pc.setModuleName("blog");
            pc.setParent("com.wpark");
            pc.setEntity("entity");
            pc.setMapper("mapper");
            pc.setService("service");
            pc.setController("controller");
            mpg.setPackageInfo(pc);
            //4、策略配置
            StrategyConfig strategy = new StrategyConfig();
            strategy.setInclude("user"); // 设置要映射的表名
                    strategy.setNaming(NamingStrategy.underline_to_camel);
            strategy.setColumnNaming(NamingStrategy.underline_to_camel);
            strategy.setEntityLombokModel(true); // 自动lombok；
            strategy.setLogicDeleteFieldName("deleted");
            // 自动填充配置
            TableFill gmtCreate = new TableFill("gmt_create", FieldFill.INSERT);
            TableFill gmtModified = new TableFill("gmt_modified", FieldFill.INSERT_UPDATE);
            ArrayList<TableFill> tableFills = new ArrayList<>();
            tableFills.add(gmtCreate);
            tableFills.add(gmtModified);
            strategy.setTableFillList(tableFills);
            // 乐观锁
            strategy.setVersionFieldName("version");
            strategy.setRestControllerStyle(true);
            strategy.setControllerMappingHyphenStyle(true); //localhost:8080/hello_id_2
            mpg.setStrategy(strategy);
            mpg.execute(); //执行
        }
    }

setLogicDeleteFieldName(“deleted”);
// 自动填充配置
TableFill gmtCreate = new TableFill(“gmt_create”, FieldFill.INSERT);
TableFill gmtModified = new TableFill(“gmt_modified”, FieldFill.INSERT_UPDATE);
ArrayList tableFills = new ArrayList<>();
tableFills.add(gmtCreate);
tableFills.add(gmtModified);
strategy.setTableFillList(tableFills);
// 乐观锁
strategy.setVersionFieldName(“version”);
strategy.setRestControllerStyle(true);
strategy.setControllerMappingHyphenStyle(true); //localhost:8080/hello_id_2
mpg.setStrategy(strategy);
mpg.execute(); //执行
}
}