一，Mybatis-Plus的概述

Mybatis-Plus是Mybatis的增强工具，在Mybatis的基础上只做增强不做改变，为了简化开发,提高效率而生

特征：

• 无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
• 损耗小：启动即会自动注入基本 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 操作智能分析阻断，也可自定义拦截规则，预防误操作

支持的数据库： 任何能使用 mybatis 进行 CRUD, 并且支持标准 SQL 的数据库，具体支持情况如下，如果不在下列表查看分页部分教程 PR 您的支持

• mysql，oracle，db2，h2，hsql，sqlite，postgresql，sqlserver，Phoenix，Gauss ，clickhouse，Sybase，OceanBase，Firebird，cubrid，goldilocks，csiidb

架构：

二，MybatisPlus的常用注解

常见的注解有：

• @TableName
• @TableID
• @TableField

一，@TableName

@TableName是表名注解

主要作用：对表名进行重新指定，默认接口类名为表名，假如不一致就需要通过这个注解指定表名

关于autoResultMap的说明:

mp会自动构建一个ResultMap并注入到mybatis里(一般用不上).下面讲两句: 因为mp底层是mybatis,所以一些mybatis的常识你要知道,mp只是帮你注入了常用crud到mybatis里 注入之前可以说是动态的(根据你entity的字段以及注解变化而变化),但是注入之后是静态的(等于你写在xml的东西) 而对于直接指定typeHandler,mybatis只支持你写在2个地方:

1. 定义在resultMap里,只作用于select查询的返回结果封装
2. 定义在insert和updatesql的#{property}里的property后面(例:#{property,typehandler=xxx.xxx.xxx}),只作用于设置值 而除了这两种直接指定typeHandler,mybatis有一个全局的扫描你自己的typeHandler包的配置,这是根据你的property的类型去找typeHandler并使用.

二，@TableID

TableID作用：标注注解，这个注解通过指定主键名和主键的类型

Table属性：

主键的类型：

注：默认为NONE，假如进行插入操作，数据库设置着主键递增，那么在映射类上也必须是AUTO

三，@TableField

TableField作用：对普通字段进行标识

二，BaseMapper接口的增删改查方法

BaseMapper接口是Mybatis-Plus提供的一个单表操作接口，内部封装了对单表操作的增删更改查方法

BaseMapper是Mybatis-Plus增强Mybatis的重要内容，但它也有局限性这个接口的方法只适合于单表操作，假如要多表操作和连接查询等，需要使用Mybatis的操作方式，它本身也兼容Mybatis的所有操作

在继承BaseMapper接口时，必须要声明它的泛型，表示它需要对操作的表和查询时返回的类型

BaseMapper的方法：

• insert(T entity)：插入
• deleteById(Serializable id)：按id删除
• deleteByMap(@Param("cm") Map<String, Object> columnMap)：按照Map条件删除
• delete(@Param("ew") Wrapper<T> queryWrapper)：queryWrapper条件删除
• deleteBatchIds(@Param("coll") Collection<? extends Serializable> idList)：ID批量删除
• updateById(@Param("et") T entity)：按照ID进行更新
• update(@Param("et") T entity, @Param("ew") Wrapper<T> updateWrapper)：按照updateWrapper进行条件删除
• selectById(Serializable id)：按照ID进行查询
• selectBatchIds(@Param("coll") Collection<? extends Serializable> idList)：按照ID进行批量查询
• selectByMap(@Param("cm") Map<String, Object> columnMap)：Map进行条件查询，单条查询
• selectOne(@Param("ew") Wrapper<T> queryWrapper)：按照queryWrapper进行条件查询，单条查询
• selectCount(@Param("ew") Wrapper<T> queryWrapper)：按照条件查询并返回查询到的记录条数
• selectList(@Param("ew") Wrapper<T> queryWrapper)：按照queryWrapper进行条件查询，多条查询
• selectPage(E page, @Param("ew") Wrapper<T> queryWrapper)：按照queryWrapper条件进行分页查询

一，BaseMapper接口的增删改操作

一，插入操作

插入操作提供BaseMapper提供的insert(T entity)方法

这个方法进行插入操作，插入后它会将插入信息进行回填到实体类

注：在插入时，需要提前设置主键ID的类型

例：

① 映射的实体类

@Data
@ToString
//设置映射的数据库表名
@TableName("mybatistest")
public class mybatisplus_pojo {
    //插入时使设置ID类型为自增
    @TableId(type = IdType.AUTO)
    int id;
    String name;
    int sex;
    int age;
}

② 映射接口

//BaseMapper的泛型表示操作的具体表映射实体类
public interface mybatisplus_mapper extends BaseMapper<mybatisplus_pojo> {

    @Override
    int insert(mybatisplus_pojo entity);

}

③ 测试

@SpringBootTest
class SpringbootMybatisplusDomeApplicationTests {

   @Autowired
   mybatisplus_mapper mapper;

   @Test
   void insert(){
      //设置要插入数据，数据通过实体类的方式插入
      mybatisplus_pojo mybatisplusPojo = new mybatisplus_pojo();
      mybatisplusPojo.setName("FQ");
      mybatisplusPojo.setAge(20);
      mybatisplusPojo.setSex(0);
      int insert = mapper.insert(mybatisplusPojo);
      if(insert!=0){
         System.out.println("插入数据成功！");
      }else {
         System.out.println("插入数据失败！");
      }
   }}

二，更新操作

Updata更新主要分两种：

• updateById：按照ID做更新
• update：按照条件做更新

一，按照ID做更新

① 映射接口

public interface mybatisplus_mapper extends BaseMapper<mybatisplus_pojo> {

    //@Param("et")底层默认命名为et
    @Override
    int updateById(@Param("et") mybatisplus_pojo entity);
}

② 测试

@Test
void updateid(){
   mybatisplus_pojo mybatisplusPojo = new mybatisplus_pojo();
    //必须要设置ID
   mybatisplusPojo.setId(1);
   mybatisplusPojo.setName("UpdataID");
   mybatisplusPojo.setSex(1);
   mybatisplusPojo.setAge(10);
   int i = mapper.updateById(mybatisplusPojo);
   if(i!=0){
      System.out.println("更新数据成功！");
   }else {
      System.out.println("更新数据失败！");
   }
}

二，按照条件更新

通过update方法进行更新，它有两个主要参数：

• T entity：更新的实体
• Wrapper<T> updateWrapper：更新的条件

Wrapper接口有两个主要的实现类：

• QueryWrapper：这个较为通用，CRUD条件判断都可以使用
• UpdateWrapper：这个使用Update操作的条件判断，其他操作也能使用

例：

① 映射接口

public interface mybatisplus_mapper extends BaseMapper<mybatisplus_pojo> {

    @Override
    int update(@Param("et") mybatisplus_pojo entity, @Param("ew")Wrapper<mybatisplus_pojo> updateWrapper);
}

② 测试1(QueryWrapper)

@SpringBootTest
class SpringbootMybatisplusDomeApplicationTests {

   @Autowired
   mybatisplus_mapper mapper;

   @Test
   void updatewrapper(){
      mybatisplus_pojo mybatisplusPojo = new mybatisplus_pojo();
      mybatisplusPojo.setName("UpdataWrapper");
      mybatisplusPojo.setSex(0);
      mybatisplusPojo.setAge(100);
      //条件
      QueryWrapper<mybatisplus_pojo> queryWrapper = new QueryWrapper();
      //判断id字段的值为3，相当于where id=3
      queryWrapper.eq("id",3);
      int update = mapper.update(mybatisplusPojo, queryWrapper);
      System.out.println(update);
   }
}

③测试2(UpdateWrapper)

@SpringBootTest
class SpringbootMybatisplusDomeApplicationTests {

   @Autowired
   mybatisplus_mapper mapper;

    @Test
   void updatewrapper(){
      mybatisplus_pojo mybatisplusPojo = new mybatisplus_pojo();
      mybatisplusPojo.setName("UpdataWrapper");
      mybatisplusPojo.setSex(0);
      mybatisplusPojo.setAge(100);
      UpdateWrapper<mybatisplus_pojo> updateWrapper = new UpdateWrapper<>();
      //set方法是UpdateWrapper区别于QueryWrapper的一个特点，它可以指定要更新的值，最后接条件
      updateWrapper.set("sex",0).set("name","UpdateWrapper").eq("id",2);
      //因为updateWrapper设置了要更新的值，所有这个实体类设置为null
      int update = mapper.update(null,updateWrapper);
      System.out.println(update);
   }
}

三，删除操作

删除操作分为四种形式：

• deleteById：按照ID进行单个删除
• deleteByMap：把条件封装到Map集合中进行条件删除
• delete：Wrapper条件删除
• deleteBatchIds：按照ID进行批量删除

一，按照ID单个删除

① 映射接口

public interface mybatisplus_mapper extends BaseMapper<mybatisplus_pojo> {

    @Override
    int deleteById(Serializable id);
}

② 测试

@Test
void deleteid(){

   int i = mapper.deleteById(1L);
   System.out.println(i);
}

二，使用Map集合进行条件删除

deleteByMap就是把条件封装到Map进行删除

Map集合：

• Key：为表的字段
• Value：为字段的值

如：{"name",""wql}，条件为name的值为wql

多个Map条件底层通过AND连接

例：

① 映射接口

public interface mybatisplus_mapper extends BaseMapper<mybatisplus_pojo> {

    @Override
    int deleteByMap(Map<String, Object> columnMap);
}

② 测试

@Test
void deletemap(){
   Map<String,Object> map = new HashMap<>();
   //设置删除条件，name字段的值为FQ，age字段的值为100，两个条件直接默认是AND连接
   map.put("name","FQ");
   map.put("age","100");
   int i = mapper.deleteByMap(map);
   System.out.println(i);
}

三， Wrapper指定条件删除

使用QueryWrapper进行条件删除

例：

① 映射接口

public interface mybatisplus_mapper extends BaseMapper<mybatisplus_pojo> {

    @Override
    int delete(@Param("ew")Wrapper<mybatisplus_pojo> queryWrapper);
}

② 测试

@Test
void deletewrapper(){
   //写法一
   QueryWrapper<mybatisplus_pojo> queryWrapper = new QueryWrapper<>();
   queryWrapper.eq("name","FQ").eq("age","100");

   //写法二：传入条件对象
   mybatisplus_pojo m = new mybatisplus_pojo();
   m.setName("FQ");//name为FQ
   m.setAge(100);//age为100
   QueryWrapper<mybatisplus_pojo> queryWrapper1 =new QueryWrapper<>(m);//将对象作为条件传入，这种写法可以避免你的字段写错

      int i = mapper.delete(queryWrapper);
      System.out.println(i);
}

四，按照ID进行批量删除

deleteBatchIds(Collection<? extends Serializable> idList)传入一个顶级集合Collection接口类型的对象

例：

① 映射接口

public interface mybatisplus_mapper extends BaseMapper<mybatisplus_pojo> {

    @Override
    int deleteBatchIds(Collection<? extends Serializable> idList);
}

② 测试

@Test
void deletedibatch(){
   //连续删除ID为2，3，4的数据
   List<Integer> integers = Arrays.asList(2, 3, 4);
   mapper.deleteBatchIds(integers);
}

二，BaseMapper接口查询方法

例：

① 映射接口

public interface mybatisplus_mapper extends BaseMapper<mybatisplus_pojo> {

    @Override
    mybatisplus_pojo selectById(Serializable id);

}

② 测试

@SpringBootTest
class SpringbootMybatisplusDomeApplicationTests {

   @Autowired
   mybatisplus_mapper mapper;

   @Test
   void contextLoads() {

      mybatisplus_pojo selectById = mapper.selectById(1L);

      System.out.println(selectById);
   }}

二，根据ID批量查询

通过selectBatchIds进行批量查询

例：

① 映射接口

public interface mybatisplus_mapper extends BaseMapper<mybatisplus_pojo> {

    @Override
    List<mybatisplus_pojo> selectBatchIds(@Param("coll")Collection<? extends Serializable> idList);
}

② 测试

@Test
void selectibatch(){

   List<Integer> list =Arrays.asList(3,2);

   List<mybatisplus_pojo> list1 = mapper.selectBatchIds(list);

   for(mybatisplus_pojo m :list1){

      System.out.println(m);
   }
}

③ 结果

三，使用Wrapper条件查询单条数据

使用selectOne(@Param("ew")Wrapper<mybatisplus_pojo> queryWrapper)进行单条数据的条件查询，传入一个queryWrapper条件对象

例：

① 映射接口

public interface mybatisplus_mapper extends BaseMapper<mybatisplus_pojo> {

    @Override
    mybatisplus_pojo selectOne(@Param("ew")Wrapper<mybatisplus_pojo> queryWrapper);
}

② 测试

@Test
void selectone(){

   QueryWrapper<mybatisplus_pojo> queryWrapper = new QueryWrapper<>();
   queryWrapper.eq("name","da").eq("age","21");

   mybatisplus_pojo mybatisplusPojo = mapper.selectOne(queryWrapper);

   System.out.println(mybatisplusPojo);

}

③ 结果

四，根据条件查询数据的列表

通过selectList(@Param("ew")Wrapper<mybatisplus_pojo> queryWrapper)进行条件批量查询

例：

① 映射接口

public interface mybatisplus_mapper extends BaseMapper<mybatisplus_pojo> {

    @Override
    List<mybatisplus_pojo> selectList(@Param("ew")Wrapper<mybatisplus_pojo> queryWrapper);
}

② 测试

@Test
void selectlist() {
   QueryWrapper<mybatisplus_pojo> queryWrapper = new QueryWrapper<>();
   queryWrapper.eq("name","da");

   List<mybatisplus_pojo> mybatisplus_pojos = mapper.selectList(queryWrapper);
   for(mybatisplus_pojo m :mybatisplus_pojos){

      System.out.println(m);
   }

③ 结果

五，记录条数的查询

通过selectCount(@Param("ew") Wrapper<T> queryWrapper)方法查询记录的条数

例：

① 映射接口

public interface mybatisplus_mapper extends BaseMapper<mybatisplus_pojo> {

    @Override
    Integer selectCount(@Param("ew")Wrapper<mybatisplus_pojo> queryWrapper);
}

② 测试

@Test
void selectcount(){
   QueryWrapper<mybatisplus_pojo> queryWrapper = new QueryWrapper<>();
   queryWrapper.eq("name","da");

   Integer integer = mapper.selectCount(queryWrapper);
   System.out.println(integer);

}

③ 结果

六，分页查询

通过selectPage(E page, @Param("ew")Wrapper<mybatisplus_pojo> queryWrapper)方法进行分页查询

两个重要参数：

• page：分页对象
• Wrapper：查询条件

Page的构造参数：

• long current：当前也
• long size：每一页的数据大小

在分页查询前需要先配置分页插件：

@Configuration
public class page_config  {
    @Bean//配置分页
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.H2));
        return interceptor;
    }
}

例：

① 映射接口

public interface mybatisplus_mapper extends BaseMapper<mybatisplus_pojo> {

    @Override
    <E extends IPage<mybatisplus_pojo>> E selectPage(E page, @Param("ew")Wrapper<mybatisplus_pojo> queryWrapper);
}

@Test
void selectpage() {
   //设置分页对象Page
   Page<mybatisplus_pojo> pojoPage = new Page<>(1,1);
   //设置条件查询
   QueryWrapper<mybatisplus_pojo> queryWrapper = new QueryWrapper<>();
   queryWrapper.like("name","da");
   //分页查询并获取分页查询对象
   Page<mybatisplus_pojo> pojoPage1 = mapper.selectPage(pojoPage, queryWrapper);

   System.out.println("查询的总页数："+pojoPage1.getPages());
   System.out.println("查询的总条数："+pojoPage1.getTotal());
   System.out.println("当前页数："+pojoPage1.getCurrent());
   
   //通过分页查询对象获取当前页的数据
   List<mybatisplus_pojo> records = pojoPage1.getRecords();
   for(mybatisplus_pojo m :records){
      System.out.println(m);
   }
}

③ 结果

四，MybatisPlus的常用配置

mybatis-plus:
  config-location:
  mapper-locations:

mybatis-plus:
  type-aliases-package:

mybatis-plus:
  configuration:
    map-underscore-to-camel-case:

mybatis-plus:
  configuration:
    cache-enabled: true

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

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

• eq：等于
• ne：不等于
• gt：大于
• ge：大于等于
• lt：小于
• le：小于等于
• between：在……之间，例：BETWEEN 1 AND 5 在1和之间的值符合条件
• notbetween：不在……之间，例：NOTBETWEEN 1 AND 5 不在5和1之间的值符合替条件
• in：是否包含
• notin：是否不包含

QueryWrapper<mybatisplus_pojo> queryWrapper = new QueryWrapper<>();
//name字段的值等于wql
queryWrapper.eq("name","wql");
//name字段的值不等于wql
queryWrapper.ne("name","wql");
//age字段的值大于18
queryWrapper.gt("age","18");
//age字段的值大于等于20
queryWrapper.ge("age","20");
//age字段的值小于12
queryWrapper.lt("age","12");
//age字段的值在15和20之间
queryWrapper.between("age",15,20);
//age字段的值不在14和20之间
queryWrapper.notBetween("age",14,20);
//age字段的值包1，2，3其中一个
queryWrapper.in("age",Arrays.asList(1,2,3));
//age字段的值不包含包1，2，3
queryWrapper.notIn("age",Arrays.asList(1,2,3));

QueryWrapper<mybatisplus_pojo> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("name","da")
         .gt("age","18")
         .between("age",1,3);
//底层转化的SQL
SELECT COUNT( * ) FROM mybatistest WHERE (name = da AND age > 18 AND age BETWEEN 1 AND 3)

//按照age字段进行升序排列，第二个参数为是否使用asc进行排序
queryWrapper.orderBy(true,true,"age");
//按照age字段进行升序排列
queryWrapper.orderByAsc("age");
按照age字段进行降序排列
queryWrapper.orderByDesc("age");

QueryWrapper<mybatisplus_pojo> queryWrapper = new QueryWrapper<>();
queryWrapper.select("name","age");//只查询显示name和age字段的数据
//底层SQL
SELECT name,age FROM mybatistest WHERE (name = ? AND age = ?)