mybatis-plus简单使用

MyBatis是Java的持久层框架，实际工作中就是来简化和规范传统的数据库CURD操作。

MyBatis-Plus（MP）是MyBatis的增强工具，所谓增强，实际上是对MyBatis进行了进一步的封装，简化了Dao或Mapper以及Service层的重复无技术性的代码，可以提高我们的开发效率。

MP的官网https://mybatis.plus/是一个非常好的学习途径，在代码实践中看源码对理解MP的插件、特性也非常有帮助。

特性

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

MP提供的实例很多，由于自己不是在项目中用到的，还不清楚在项目中的实际应用更偏向于哪一部分，而且刚接触，对于我这个初入职场的小菜鸡来说学习效率比较低，只简单尝试了Mapper的CURD操作，其他部分等到项目中运用的时候再深究。

1. 首先新建一个SpringBoot Maven项目，在pom.xml中引入数据库、Tomcat相关包，再引入MP的包。

 

 2. 接着，在application.yml中配置数据库，并给SpringBoot启动类加上扫描Mapper的注解。

 

 3. 下一步就可以在数据库新建一个简单的表，并创建一个有映射关系的pojo实体类。这里部分属性有注解是因为数据库字段的命名和实体类属性不一致，可以加上@TableField来手动映射。@Data是lombok简化get/set/toString等方法的注解。

 

 4. 在Mapper包下新建一个Mapper类，继承BaseMapper<Pojo>。

 

 

 5. 最后在测试类下写测试方法。代码如下：

package com.zxin.mybatisplus;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.zxin.mybatisplus.mapper.EquipmentMapper;
import com.zxin.mybatisplus.pojo.CompanyEquipment;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import javax.annotation.Resource;
import javax.sound.midi.Soundbank;
import java.util.*;

@RunWith(SpringRunner.class)
@SpringBootTest
/**
 * MyBatisPlus测试CRUD
 */
public class MybatisPlusApplicationTests {
    @Resource
    private EquipmentMapper equipmentMapper;


    @Test
    /**
     * 查询selectList and selectById
     */
    public void query1() {
        List<CompanyEquipment> companyEquipments = equipmentMapper.selectList(null);
        CompanyEquipment companyEquipment = equipmentMapper.selectById(19);
        System.out.println(companyEquipment.toString());
    }

    @Test
    /**
     * selectByMap
     */
    public void query2(){
        Map<String, Object> map = new HashMap<>();
        map.put("CompanyId", 24);
        List<CompanyEquipment> companyEquipments = equipmentMapper.selectByMap(map);
        companyEquipments.forEach(System.out::println);
    }

    @Test
    public void query3(){
        /**
         * 条件构造器查询：使用queryWrapper.点各种条件
         */
        QueryWrapper<CompanyEquipment> queryWrapper = new QueryWrapper<>();

        //条件设置为("CompanyId",24)--->CompanyId = 24，等同于allEq方法中Map参数只put一个键值对。（键需要是数据库的列）
        //eq为等于，同样的，ne表示不等于，gt是大于，ge是大于等于，lt是小于，le是小于等于，参数都是两个值，也就是一个键值对
        queryWrapper.eq("CompanyId",24);

        //写多条queryWrapper.eq("CompanyId",24)，会用and连接，等同于先创建一个Map，再push多个键值对，使用allEq。
        //怎样写多条eq但是用or连接？ 答：eq("id",1).or().eq("name","老王")--->id = 1 or name = '老王'
        queryWrapper.eq("CompanyId", 24);
        queryWrapper.eq("IsPass", 0);

        //Map如果只put一对键值，相当于eq方法，put多对键值，相当于多条queryWrapper.eq。
        Map<String, Object> map = new HashMap<>();
        map.put("CompanyId", 24);
        //如果map中的键对应的值不为空，allEq的第二个参数true/false就没有意义
        map.put("Reason", null);
        //约束为空的对象，是否条件为空，例如map中的Reason设置了null，查询时true/false决定是否在条件中加入值为null的列。
        queryWrapper.allEq(map, true);

        //需要传3个值，第一个是哪一列，第二个是大于的值，第三个是小于的值。
        //同样的，notBetween也是传3个值，表示不在这个范围内的。
        //该方法等同于两条ge，le方法。
        queryWrapper.between("ExpiredDate","2020-08-01","2020-08-31");

        //like就是sql的like，该语句表示Name中包含“新”的数据有哪些
        //同样的，还有notLike/likeLeft/likeRight
        queryWrapper.like("Name", "新");

        //找到该属性为null的数据
        //同理，isNotNull是查找该属性不为空的数据
        queryWrapper.isNull("Reason");

        //int[] companyIds = {16,17,18};
        //in方法需要的参数是，数据表的列名和一个集合。注意：数组不可以。
        //同理notIn，表示不在这个集合元素中的数据
        List<Integer> companyIds = new ArrayList<>();
        //也可以array转list
        //List<Integer> companyIds = Arrays.asList(17, 18);
        companyIds.add(17);
        companyIds.add(18);
        queryWrapper.in("CompanyId",companyIds);

        //inSql可以实现和in相同的效果，且第二个参数可以为sql语句，如：select CompanyId from table_name where IsPass = 0;
        //notInSql表示不在这个范围中的数据
        queryWrapper.inSql("companyIds", "16,17,18");

        /**
         * 其他一些方法举例
         * groupBy("id", "name")--->group by id,name
         * orderByAsc("id", "name")--->order by id ASC,name ASC
         * orderByDesc("id", "name")--->order by id DESC,name DESC
         * having("sum(age) > 10")--->having sum(age) > 10
         * having("sum(age) > {0}", 11)--->having sum(age) > 11
         *
         */

        List<CompanyEquipment> companyEquipments1 = equipmentMapper.selectList(queryWrapper);
        companyEquipments1.forEach(System.out::println);

        //CompanyEquipment companyEquipment = equipmentMapper.selectOne(queryWrapper);
        //System.out.println(companyEquipment);
    }

    @Test
    /**
     * 常见的数据库更新操作
     */
    public void update(){
        /**
         * 有两种方式:byId、byWrapper,都是约束条件的作用，也就是说必须有实体对象
         */
        CompanyEquipment equipment = new CompanyEquipment();
        //byId
        //必需参数
        equipment.setId(39);
        //可选参数
        equipment.setName("ABDKWA待审核设备");
        equipment.setIsPass(-1);

        int updateCount = equipmentMapper.updateById(equipment);
        System.out.println(updateCount);


        //by条件构造器
        //id非必需，根据需求传入修改的字段
        equipment.setReason("不予通过，材料缺少，证书已过期");
        UpdateWrapper<CompanyEquipment> updateWrapper = new UpdateWrapper<>();
        updateWrapper.ne("IsPass",1);
        int updateCount2 = equipmentMapper.update(equipment, updateWrapper);
        System.out.println(updateCount2);
    }


    @Test
    /**
     * 删除
     */
    public void delete() {
        //通过id删除，只需要传入一个id即可
        int idCount = equipmentMapper.deleteById(28);

        //根据id的集合实现批量删除
        List<Integer> ids = new ArrayList<>();
        ids.add(1);
        ids.add(2);
        int idsCount = equipmentMapper.deleteBatchIds(ids);

        //通过条件构造器找到数据，多eq几次，效果相当于deleteByMap
        QueryWrapper<CompanyEquipment> wrapper = new QueryWrapper<>();
        wrapper.eq("Name","一个设备设备zzz");
        int wrapperCount = equipmentMapper.delete(wrapper);

        //通过Map确定需要删除的数据，和条件构造器效果相同
        Map<String, Object> deleteMap = new HashMap<>();
        deleteMap.put("Name", "一个设备设备zzz");
        int mapCount = equipmentMapper.deleteByMap(deleteMap);
    }

    @Test
    /**
     * 插入
     */
    public void insert() {
        //直接将实体对象传入即可
        CompanyEquipment equipment = new CompanyEquipment();

        //如果设置了主键自增，可以不设置id
        equipment.setName("MP设备");
        equipment.setCompanyId(24);
        int insertCount = equipmentMapper.insert(equipment);
        System.out.println(insertCount);
    }
}

自己就测试了这么多，查询的方法比较多，使用的时候分成多个方法练习，或者把其他部分注释掉。

Java小白，初入职场，啥都写，都很菜，欢迎各位大佬补充和指正！