Spring-boot +Mybatis-plus

参考链接：https://blog.csdn.net/m0_37034294/category_9279620.html

本篇文章主要对这几天所学习的Mybatis-plus作一个总结。

目录

• 简述
• 快速搭建项目
• 拆解CURD 和 分页
• 强大构造器 QueryWrapper

---

一、简述

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

特性	解释
无侵入	只做增强不做改变，引入它不会对现有工程产生影响。
损耗小	启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作
强大的 CRUD 操作	内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作，更有强大的条件构造器，满足各类使用需求
支持多种数据库	例如Mysql\Oracle等
支持自定义全局通用操作	支持全局通用方法注入（ Write once, use anywhere ）
支持关键词自动转义	采用代码或者 Maven 插件可快速生成 Mapper 、 Model 、 Service 、 Controller 层代码，支持模板引擎，更有超多自定义配置等您来使用
内置分页插件	基于 MyBatis 物理分页，开发者无需关心具体操作，配置好插件之后，写分页等同于普通 List 查询
内置性能分析插件	可输出 Sql 语句以及其执行时间，建议开发测试时启用该功能，能快速揪出慢查询

以上特性并非mybatis-plus的全部特性，仅仅是个人理解并且用到的而已。

3. 结构框架图
   

---

二、用Spring-boot +Mybatis-plus快速搭建项目

我的环境：
JDK
Mysql
IDEA
Maven
Spring-boot
Mybatis-plus
Mysql

- 首先准备数据库的表格及数据（略）

• 然后进行pom.xml的依赖引入：

<!--这里只举例点题需要用到的依赖项-->

< spring-boot >
< mybatis-plus >  
< lombok > 
< mysql-connector >   

//如果springboot版本是SNAPSHOT快照版还需要添加仓库 
<repository>
<id>snapshots</id>
<url>https://oss.sonatype.org/content/repositories/snapshots/</url>
</repository>  

*注意：*引入 MyBatis-Plus 之后请不要再次引入 MyBatis 以及 MyBatis-Spring，以避免因版本差异导致的问题。

- 接下来就是application.yml的配置：

//DataSource Config
spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://******:3306/crm
    username: ****
    password: ****

#数据库连接换成自己的就可以

- 在 Spring Boot 启动类中添加 @MapperScan 注解，扫描 Mapper 文件夹：

@SpringBootApplication
@MapperScan("com.ivy.springbootmybatisplus.dao.mapper")
public class SpringbootMybatisPlusApplication {
    
    

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

//@MapperScan()内容填写你自己的mapper位置

- 对应数据库实体类编写：

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

//@Data注解会给此类默认提供Getter,Setter,equals,hashCode,toString方法

- 编写Mapper类 UserMapper.java :

public interface UserMapper extends BaseMapper<User> {
    
        //继承基类

}

你会发现没有写mapper.xml，mapper.java中什么也没有，就可以使用了。

---

三、Spring boot + Mybatis plus详细拆解CRUD

springboot+mybatis-plus通过AutoGenerator自动生成entrty、controller、service、dao、mapper后，对于基本的CRUD的操作和注意事项(本篇文章暂时不讲AutoGenerator的内容)

小要点：我们如果需要控制台打印sql语句出来的话，就需要在yml配置文件中加入下面的代码块：

mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

下面的所有代码就是springboot + mybatis-plus自动生成后的所有简单CRUD操作查询，还没有涉及到条件构造器的QueryWrapper和UpdateWrapper。

1. 插入

/*
 * inset操作
 */
 @Test
 public void insertLoads() {
    
    
     User user = new User();
     user.setEmail("[email protected]");
     user.setAge(12);

     Integer insert = mapper.insert(user);
 }
//到这里就会顺利添加插入3个字段了（id、email、age），其他没有填写的字段是不会添加的。

//需要注意一点，我们的id是long类型如果想要一个自增的主键id，那么我们需要在实体类进行id主键自增的设置（IdType.AUTO这个就是主键自增的标识）
 @TableId(value = "id", type = IdType.AUTO)
 private Long id;

2. 更新

/*
 * update操作
 */
 @Test
 public void updateByIdLoads() {
    
    
     User user = new User();
     user.setAge(25);
     user.setEmail("[email protected]");
     user.setId(1L);

     Integer insert = mapper.updateById(user);
 }

3. 删除

/*
 * delect操作 根据id删除
 */
 @Test
 public void deleteByIdLoads() {
    
    
     Integer deleteById = mapper.deleteById(4L);
}


/*
 *deleteBatchId操作 根据id批量删除
 */
@Test
public void deleteLoads() {
    
    
    List<Long> list = new ArrayList<>();
    list.add(1L);
    list.add(2L);
    list.add(3L);
    Integer insert = mapper.deleteBatchIds(list);
}


/*
 * deleteByMap 根据map条件进行删除
 */
@Test
public void deleteByMapsLoads() {
    
    
    HashMap<String, Object> map = new HashMap<>(16);
    map.put("email", "[email protected]");
    map.put("age", 25);

    Integer insert = mapper.deleteByMap(map);                                                                                   
}
//这个就是通过map条件进行删除操作，条件查询到多少条删除多少，这里需要注意的是，map中的key对应的是数据库字段例如数据库user_id，实体类是userId这是在作为map key的时候需要填写user_id。

4. 查询

/*
 * 通过id查询对象
 */
 @Test
public void selectByIdLoads() {
    
    
  User user = mapper.selectById(4L);   
}

/*
 *通过多个id进行查询返回list集合
 */
 @Test
public void selectBatchIdsLoads() {
    
    
        List<Long> list = new ArrayList<>();
        list.add(1L);
        list.add(2L);
        list.add(3L);
        List<User> list1 = mapper.selectBatchIds(list);
        System.out.println("return selectBatchIds value = " + list1); 
 }

/*
 * 通过多个条件进行实体list查询
 */
@Test
public void selectByMapLoads() {
    
    
    HashMap<String, Object> map = new HashMap<>(16);
    map.put("email", "[email protected]");
    map.put("age", 25);
    List<User> list = mapper.selectByMap(map);   
}

5. 分页查询
要想实现mybatis-plus分页首先需要确定配置了分页插件配置方法如下：

/*
 *分页插件    在配置类或启动类中增加上面的bean就可以使用了，如不不添加分页不成功查询所有内容
 */
 @Bean
 public PaginationInterceptor paginationInterceptor() {
    
    
    return new PaginationInterceptor();
 }

然后就可以使用分页功能了：

/*
 * 分页查询
 */
 @Test
 public void selectPageLoads() {
    
    
    Page<User> page = new Page<>(1,5);   //page中的1代表当前页，5代表每页条数。
    IPage<User> lstUser = mapper.selectPage(page, null);   
 }

---

四、强大构造器 QueryWrapper

1. 关系图

1.1 说明
绿色框为抽象类abstract
蓝色框为正常class类，可new对象
黄色箭头指向为父子类关系，箭头指向为父类

1.2 wapper介绍 ：

1. Wrapper ： 条件构造抽象类，最顶端父类，抽象类中提供4个方法西面贴源码展示
2. AbstractWrapper ： 用于查询条件封装，生成 sql 的 where 条件
3. AbstractLambdaWrapper ： Lambda 语法使用 Wrapper统一处理解析 lambda 获取 column。
4. LambdaQueryWrapper ：看名称也能明白就是用于Lambda语法使用的查询Wrapper
5. LambdaUpdateWrapper ： Lambda 更新封装Wrapper
6. QueryWrapper ： Entity 对象封装操作类，不是用lambda语法
7. UpdateWrapper ： Update 条件封装，用于Entity对象更新操作

2. 条件构造器使用中的各个方法格式和说明

3. 代码演示

演示的是构造器条件进行的查询、删除、修改，构造器方法没有做过多演示，但是所有的构造器方法同理使用。

@RunWith(SpringRunner.class)
@SpringBootTest
public class QueryWrapperTests {
    
    

 @Autowired
 private UserMapper mapper;

 /**
  * 根据根据 entity 条件，删除记录,QueryWrapper实体对象封装操作类（可以为 null）
  * 下方获取到queryWrapper后删除的查询条件为name字段为null的and年龄大于等于12的and email字段不为null的
  * 同理写法条件添加的方式就不做过多介绍了。
  */
 @Test
 public void delete() {
    
    
     QueryWrapper<User> queryWrapper = new QueryWrapper<>();
     queryWrapper
             .isNull("name")
             .ge("age", 12)
             .isNotNull("email");
     int delete = mapper.delete(queryWrapper);
     System.out.println("delete return count = " + delete);
 }


 /**
  * 根据 entity 条件，查询一条记录,
  * 这里和上方删除构造条件一样，只是seletOne返回的是一条实体记录，当出现多条时会报错
  */
 @Test
 public void selectOne() {
    
    
     QueryWrapper<User> queryWrapper = new QueryWrapper<>();
     queryWrapper.eq("name", "ivy");

     User user = mapper.selectOne(queryWrapper);
     System.out.println(user);
 }


 /**
  * 根据 Wrapper 条件，查询总记录数
  * @param queryWrapper 实体对象
  */
 @Test
 public void selectCount() {
    
    
     QueryWrapper<User> queryWrapper = new QueryWrapper<>();
     queryWrapper.eq("name", "ivy");
     Integer count = mapper.selectCount(queryWrapper);
     System.out.println(count);
 }


 /**
  * 根据 entity 条件，查询全部记录
  * @param queryWrapper 实体对象封装操作类（可以为 null）为null查询全部
  */
 @Test
 public void selectList() {
    
    
     List<User> list = mapper.selectList(null);
     System.out.println(list);
 }

 /**
  * 根据 Wrapper 条件，查询全部记录
  * @param queryWrapper 实体对象封装操作类（可以为 null）
  */
 @Test
 public void selectMaps() {
    
    
     QueryWrapper<User> queryWrapper = new QueryWrapper<>();
     queryWrapper.isNotNull("name");
     List<Map<String, Object>> maps = mapper.selectMaps(queryWrapper);
     for (Map<String, Object> map : maps) {
    
    
         System.out.println(map);
     }
 }

 
------------------------------------------------------------------------------
 /**
  * 根据 entity 条件，查询全部记录（并翻页）
  * @param page         分页查询条件（可以为 RowBounds.DEFAULT）
  * @param queryWrapper 实体对象封装操作类（可以为 null）
  */
 @Test
 public void selectPage() {
    
    
     Page<User> page = new Page<>(1, 5);
     QueryWrapper<User> queryWrapper = new QueryWrapper<>();

     IPage<User> userIPage = mapper.selectPage(page, queryWrapper);
     System.out.println(userIPage);
 }

  
  /* 这里需要在项目中加入分页插件
  *   @Bean
  *     public PaginationInterceptor paginationInterceptor() {
  *         return new PaginationInterceptor();
  *     }
  */


 /**
  * 根据 Wrapper 条件，查询全部记录（并翻页）
  * @param page         分页查询条件
  * @param queryWrapper 实体对象封装操作类
  */
 @Test
 public void selectMapsPage() {
    
    
     Page<User> page = new Page<>(1, 5);
     QueryWrapper<User> queryWrapper = new QueryWrapper<>();

     IPage<Map<String, Object>> mapIPage = mapper.selectMapsPage(page, queryWrapper);
     System.out.println(mapIPage);
 }

 /**
  * 和上个分页同理只是返回类型不同
  */


 /**
  * 根据 whereEntity 条件，更新记录
  * @param entity        实体对象 (set 条件值,不能为 null)
  * @param updateWrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）
  */
 @Test
 public void update() {
    
    

     //修改值
     User user = new User();
     user.setStatus(true);
     user.setName("zhangsan");

     //修改条件
     UpdateWrapper<User> userUpdateWrapper = new UpdateWrapper<>();
     userUpdateWrapper.eq("name", "ivy");

     int update = mapper.update(user, userUpdateWrapper);

     System.out.println(update);
 }
}

简单总结：
我们在使用条件构造器的时候要使用QueryWrapper或者UpdateWrapper来充当条件语句来进行构造
QueryWrapper(LambdaQueryWrapper) 和 UpdateWrapper(LambdaUpdateWrapper) 的父类用于生成 sql 的 where 条件， entity 属性也用于生成 sql 的 where 条件。

条件	作用	格式
eq	等于 =	new QueryWrapper.eq(“字段”,“字段值”)
ne	不等于<>	QueryWrapper<表名> 对象 = new QueryWrapper<>(); 对象.ne(“字段”,“字段值”)

a. 就是Mapper 继承该BaseMapper接口后，无需编写 mapper.xml 文件，即可获得CRUD功能。在业务层中注入mapper对象调用BaseMapper中原本就有的sql语句方法，就可以得到查询的数据（整个过程不用编写任何一句mapper.xml文件）

b. 想要添加条件可以使用queryMapper进行拼接来设定条件。比如：

//单条件： where 等于
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("name", "ivy");   //queryWrapper.eq("对应数据库中的字段名", "字段的值");
User user = mapper.selectOne(queryWrapper);

//添加多条件： 比如搜索名字为ivy并且年纪大于25岁的，直接写多个queryWrapper拼接就好了：
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("name", "ivy");
queryWrapper.gt("age", "25");
User user = mapper.selectOne(queryWrapper);
//-------相当于sql语句：where name = ivy and age > 25;
        

以上就是对Mybatis-plus学习的总结，不足之处或者理解错的请大佬提出。