MyBatis-Plus

一.什么是MyBatis_Plus

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

特点:无入侵,损耗小,支持Lambda形式调用,支持主键自动生成,支持ActiveRecordd模式,支持自定义全局通用操作,内置代码生成器,内置分页插件,分页检查支持多种数据库,内置性能分析插件,内置全局拦截插件,

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CWGGI8mH-1649552885085)(E:\java预习资料\项目二\总结图\MyBatis-puls\Snipaste_2022-04-09_20-53-55.png)]

二.所需配置

pom依赖

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.4.3</version>
    </parent>
    <dependencies>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.0</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.17</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.22</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.16</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>

启动类配置

//分页拦截器
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        PaginationInnerInterceptor paginationInnerInterceptor = new PaginationInnerInterceptor(DbType.MYSQL);
        paginationInnerInterceptor.setOverflow(true); //合理化
        interceptor.addInnerInterceptor(paginationInnerInterceptor);
        return interceptor;
    }

properties配置

#mysql
spring.datasource.url=jdbc:mysql://localhost:3306/mybatis-plus?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8&nullCatalogMeansCurrent=true
spring.datasource.username=root
spring.datasource.password=admin
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
# 配置slq打印日志
logging.level.cn.wolfcode.mp.mapper=debug

三.类和重要注解

建domain和mapper和测试类

Employee

@ToString
@Getter
@Setter
@TableName("t_employee")//指定当前实体类映射的表名
public class Employee {
    @TableId(type = IdType.AUTO)//id自增
    private Long id;//默认生成的id策略是雪花算法
    //@TableField("uname")//明确指定当前映射的列
    private String name;
    private String password;
    private String email;
    private int age;
    private int admin;
    //@TableField(exist = false)//明确指定当前字段不进行映射
    private Long deptId;
    //@TableField(exist = false)
    private Department department;
}

EmployeeMapper

public interface EmployeeMapper extends BaseMapper<Employee> {
}

就可以使用了,mybatis-plus内部提供了17个方法来使用.不要写xml和sql语句

四.测试实践

使用17个方法练习

@SpringBootTest(classes = App.class)
public class CRUDTest {
    @Autowired
    private EmployeeMapper employeeMapper;
}

1.修改的方法四个

 /**
     * Mybatis-plus sql 拼接规则
     * 1>在sql拼接时,如果传入的参数是实体类对象,如果对象属性值为null,该属性不参与sql拼接
     * 2>在sql拼接时,如果传入的参数是实体类对象,,如果对象属性是基本类型.
     * 有默认值,myBatis-plus认为有值,该属性参与sql拼接
     *
     * 解决方案呢?
     * 1>使用基本类型的包装类型
     * 2>按照先查询,再替换,后更新顺序执行逻辑
     * 3>使用mapper接口中 update(null ,wrapper) 方法 [局部更新(部分字段)]
     */
//Preparing: UPDATE t_employee SET uname=?, age=?, admin=? WHERE id=?
    //zhiyi(String), 0(Integer), 0(Integer), 1(Long)
    @Test
    public void TestUpdate(){
        Employee employee = new Employee();
        employee.setId(1L);
        employee.setName("zhiyi");
        //返回受影响行数
        int i = employeeMapper.updateById(employee);
    }
    @Test
    public void TestUpdate1(){
        //条件构造器--暂时理解where操作
        UpdateWrapper<Employee> wrapper = new UpdateWrapper<>();
        //eq是等于的意思,
        wrapper.eq("id",1L);
        wrapper.set("name","zhiyi2");
        //null的意思不传实体类,直接set进去sql里
        employeeMapper.update(null,wrapper);
    }
    /**
     * 总结:updateById用于,知道id并更新所有字段
     * update,加上wrapper条件更新部分字段
     */

2.删除

//删除
    @Test
    public void TestDelete(){
        //DELETE FROM t_employee WHERE id=?
        employeeMapper.deleteById(1L);
    }

    @Test
    public void TestDeleteBatchIds(){
        //需求:删除（根据ID 批量删除）
        //Preparing: DELETE FROM t_employee WHERE id IN ( ? , ? , ? )
        //Parameters: 1(Long), 2(Long), 3(Long)
        employeeMapper.deleteBatchIds(Arrays.asList(1L,2L,3L));
    }

    @Test
    public void TestDeleteMap(){
        //需求：删除name=zhiyi并且age=18的员工信息
        //key:条件列  value:条件值
        HashMap<String, Object> map = new HashMap<>();
        map.put("name","zhiyi");
        map.put("age",18);
        employeeMapper.deleteByMap(map);
        //DELETE FROM t_employee WHERE name = ? AND age = ?
        //zhiyi(String), 18(Integer)
    }

    @Test
    public void TestDelete1(){
        //需求：删除name=zhiyi并且age=18的员工信息
        //查询相关条件建议用queryWrapper
        QueryWrapper<Employee> wrapper = new QueryWrapper<>();
        wrapper.eq("name","zhiyi");
        wrapper.eq("age",18);
        employeeMapper.delete(wrapper);
        //DELETE FROM t_employee WHERE (name = ? AND age = ?)
        //zhiyi(String), 18(Integer)
    }

3.查询

//查询
    @Test
    public void TestSelectById(){
        //需求：查询id=4的员工信息
        System.out.println(employeeMapper.selectById(4L));
        //SELECT id,name,password,email,age,admin,dept_id FROM t_employee WHERE id=?
    }

    @Test
    public void TestSelectBatchIds(){
        //需求：查询id=4，id=5的员工信息
        List<Employee> employees = employeeMapper.selectBatchIds(Arrays.asList(4L, 5L));
        //SELECT id,name,password,email,age,admin,dept_id FROM t_employee WHERE id IN ( ? , ? )
    }

    @Test
    public void TestSelectByMap(){
        //需求： 查询name=zhiyi， age=19的员工信息
        HashMap<String, Object> map = new HashMap<>();
        map.put("name","zhiyi");
        map.put("age",19);
        List<Employee> employees = employeeMapper.selectByMap(map);
        //SELECT id,name,password,email,age,admin,dept_id FROM t_employee WHERE name = ? AND age = ?
    }

    @Test
    public void TestSelectCount(){
        //需求： 查询满足条件的所有的员工个数
        //wrapper这里可以理解成where
        QueryWrapper<Employee> wrapper = new QueryWrapper<>();
        //没有加就默认查询全部
        //employeeMapper.selectCount(null);
        Integer count = employeeMapper.selectCount(wrapper);
        //Preparing: SELECT COUNT( 1 ) FROM t_employee
    }

    @Test
    public void TestSelectList(){
        //需求： 查询满足条件的所有的员工信息， 返回List<Employee>
        QueryWrapper<Employee> wrapper = new QueryWrapper<>();
        List<Employee> list = employeeMapper.selectList(wrapper);
        list.forEach(System.err::println);
        //SELECT id,name,password,email,age,admin,dept_id FROM t_employee
    }

    @Test
    public void TestSelectMaps(){
        //需求： 查询满足条件的所有的员工信息，
        // 返回List<Map<String, Object>>  底层将每条数据封装成HashMap
        QueryWrapper<Employee> wrapper = new QueryWrapper<>();
        List<Map<String, Object>> list = employeeMapper.selectMaps(wrapper);
        list.forEach(System.err::println);
        //SELECT id,name,password,email,age,admin,dept_id FROM t_employee
    }

    /**
     * 什么时候用用selectList查询 ,什么时候用selectMap查询
     * 执行的sql返回的列能封装成对象,使用selectList,如果不能,使用selectMap   目的:防止封装的数据丢失
     * eg:SELECT dept_id ,count(id) FROM t_employee group by dept_id
     * 执行之后,返回count 列是无法封装到employee对象中,但是可以封装到map中
     */

4.分页查询

@Test
    public void TestSelectPage() {
        QueryWrapper<Employee> wrapper = new QueryWrapper<>();
        //需求：查询第二页员工数据， 每页显示3条， （分页返回的数据是实体对象）
        //步骤1.当前页  参数2每页显示条数
        Page<Employee> page = new Page<>(2, 3);
        //步骤2.编写分页代码
        Page<Employee> page1 = employeeMapper.selectPage(page, wrapper);
        System.out.println(page==page1);
        System.out.println("当前页：" + page.getCurrent());
        System.out.println("每页显示条数：" + page.getSize());
        System.out.println("总页数：" + page.getPages());
        System.out.println("总数：" + page.getTotal());
        System.out.println("当前页数据：" + page.getRecords());
    }

五.条件构造器的修改操作和查询操作

1.修改操作

@Test
    public  void testUpdate(){
        //条件构造器---暂时理解where操作
        //需求：将id=4的用户name改为zhiyi
        UpdateWrapper<Employee> wrapper = new UpdateWrapper<>();
        wrapper.eq("id",4L);
        wrapper.set("name","zhiyi");
        employeeMapper.update(null,wrapper);
        //UPDATE t_employee SET name=? WHERE (id = ?)
    }

    @Test
    public  void testUpdate2(){
        //条件构造器---暂时理解where操作
        //需求：将id=4的用户name改为zhiyi
        UpdateWrapper<Employee> wrapper = new UpdateWrapper<>();
        wrapper.eq("id",4L);
        wrapper.setSql("name='zhiyi'");//sql片段,直接插进去sql中
        //Preparing: UPDATE t_employee SET name=? WHERE (id = ?)
    }

    @Test
    public  void testUpdate3(){
        //条件构造器---暂时理解where操作
        //需求：将id=4的用户name改为zhiyi
        LambdaUpdateWrapper<Employee> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(Employee::getId,4L);
        wrapper.set(Employee::getName,"zhiyi");
        employeeMapper.update(null,wrapper);
    }

2…查询操作

//查询
    @Test
    public  void testQuery1(){
        //需求：查询name=zhiyi， age=19的用户
        QueryWrapper<Employee> wrapper = new QueryWrapper<>();
        wrapper.eq("name","zhiyi");
        wrapper.eq("age",19);
        System.out.println(employeeMapper.selectList(wrapper));
        //SELECT id,name,password,email,age,admin,dept_id FROM t_employee WHERE (name = ? AND age = ?)
    }

    @Test
    public  void testQuery2(){
        //需求：查询name=zhiyi， age=19的用户
        LambdaQueryWrapper<Employee> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(Employee::getName,"zhiyi");
        wrapper.eq(Employee::getAge,19);
        System.out.println(employeeMapper.selectList(wrapper));
        //SELECT id,name,password,email,age,admin,dept_id FROM t_employee WHERE (name = ? AND age = ?)
    }

六.高级查询

1.包含了模糊查询,分页查询,排序,分组

public void testQuery1(){
        QueryWrapper<Employee> wrapper = new QueryWrapper<>();
        //wrapper.select("name","age");
        wrapper.select("name,age");//sql片段
        List<Employee> list = employeeMapper.selectList(wrapper);
        list.forEach(System.out::println);
        //Preparing: SELECT name,age FROM t_employee
    }

    @Test
    public void testQuery2(){
        //需求：查询所有员工， 返回员工以a字母开头的列
        QueryWrapper<Employee> wrapper = new QueryWrapper<>();
        wrapper.select(Employee.class,tableFieldInfo -> tableFieldInfo.getProperty().startsWith("a"));
        employeeMapper.selectList(wrapper);
    }

    @Test
    public void testQuery3(){
        //需求：查询所有员工信息按age正序排， 如果age一样， 按id正序排
        QueryWrapper<Employee> wrapper = new QueryWrapper<>();
        //wrapper.orderByAsc("age");
        //wrapper.orderByDesc("id");//FROM t_employee ORDER BY age ASC,id DESC

        //开关方法
        //参数1开关参数.true/false决定是否执行后续逻辑(逻辑) 参数2 排序列
        //wrapper.orderByAsc(true,"age");//ORDER BY age ASC

        //参数1:开关参数,  参数2.是否正序,参数:排序列
        wrapper.orderBy(true,true,"age");//ORDER BY age ASC
        employeeMapper.selectList(wrapper);
    }
    @Test
    public void testQuery4(){
        //需求： 以部门id进行分组查询，查每个部门员工个数
        QueryWrapper<Employee> wrapper = new QueryWrapper<>();
        wrapper.select("dept_id,count(id) count");
        wrapper.groupBy("dept_id");
        List<Map<String, Object>> maps = employeeMapper.selectMaps(wrapper);
        //Preparing: SELECT dept_id,count(id) count FROM t_employee GROUP BY dept_id
    }

    @Test
    public void testQuery5(){
        //需求： 以部门id进行分组查询，查每个部门员工个数， 将大于3人的部门过滤出来
        QueryWrapper<Employee> wrapper = new QueryWrapper<>();
        wrapper.select("dept_id,count(id) count");
        wrapper.groupBy("dept_id");
        //wrapper.having("count>3");//GROUP BY dept_id HAVING count>3
        wrapper.having("count>{0}",3);//GROUP BY dept_id HAVING count>?
        List<Map<String, Object>> maps = employeeMapper.selectMaps(wrapper);
    }

    @Test
    public void testQuery6(){
        //需求：查询name=zhiyi员工信息
        QueryWrapper<Employee> wrapper = new QueryWrapper<>();
        HashMap<String, Object> map = new HashMap<>();
        map.put("name","zhiyi");
        map.put("age",null);
        wrapper.allEq(map);
        wrapper.allEq(map,false);
        employeeMapper.selectList(wrapper);//WHERE (name = ? AND age IS NULL AND name = ?)
    }

    @Test
    public void testQuery7(){
        QueryWrapper<Employee> wrapper = new QueryWrapper<>();
        //wrapper.in("id",1L,2L,3L);//WHERE (id IN (?,?,?))
        wrapper.inSql("id","1,2,3");// WHERE (id IN (1,2,3))
        employeeMapper.selectList(wrapper);
    }

2.模糊查询

//模糊查询
    @Test
    public void testQuery8(){
        QueryWrapper<Employee> wrapper = new QueryWrapper<>();
        //wrapper.like("name","yi");// %yi%
        //wrapper.likeRight("name","yi");// yi%
        wrapper.likeLeft("name","yi");//%yi
        employeeMapper.selectList(wrapper);
    }


    @Test
    public void testQuery9() {
        //需求:查询age=19  或者 name=zhiyi  或者id=4的用户
        QueryWrapper<Employee> wrapper = new QueryWrapper<>();
        wrapper.eq("age",19)
                .or()
                .eq("name","zhiyi")
                .or()
                .eq("id",4L);
        employeeMapper.selectList(wrapper);
        //WHERE (age = ? OR name = ? OR id = ?)
    }


    @Test
    public void testQuery10() {
        //需求:查询name含有yi的字样,并且小于18或者大于30的用户
        QueryWrapper<Employee> wrapper = new QueryWrapper<>();
        //wrapper.like("name","yi")
          //      .lt("age",18).or().gt("age",30);
        //WHERE (name LIKE ? AND age < ? OR age > ?)


        wrapper.like("name","yi")
                .and(wrapper2->wrapper2.lt("age",19).or().gt("age",30));
        // WHERE (name LIKE ? AND (age < ? OR age > ?))
        employeeMapper.selectList(wrapper);
    }

3.自定义sql

自定义sql和平时的mybatis一样

/自定义sql
    @Test
    public void testQuery11() {
        List<Employee> list = employeeMapper.listByXmlSingle();
    }

    @Test
    public void testQuery12() {
        List<Employee> list = employeeMapper.listByXmlJoin();
        list.forEach(System.err::println);
    }

EmployeeMapper中

public interface EmployeeMapper extends BaseMapper<Employee> {
    List<Employee> listByXmlSingle();
    List<Employee> listByXmlJoin();
}

EmployeeMapper.xml

<select id="listByXmlSingle" resultMap="BaseResultMap">
        select id,name,password,email,age,admin,dept_id
        from t_employee
    </select>
    <select id="listByXmlJoin" resultMap="BaseResultMap">
        select e.id,e.name,e.password,e.email,e.age,e.admin,e.dept_id
        ,d.id d_id,d.name d_name, d.sn d_sn
        from t_employee e left join department d on e.dept_id = d.id
    </select>

就这么多

七.通用的Service接口

1：自定义服务接口集成IService接口

/**
 * 自定义服务层接口
 * 1>自定义接口继承IService父接口
 * 2>明确指定一个泛型,当前接口操作的实体类对象:Employee
 */
public interface IEmployeeService extends IService<Employee> {
    IPage<Employee> query(EmployeeQuery qo);
}

2：服务接口实现类集成IService接口实现类ServiceImpl同时实现自定义接口

注意ServiceImpl实现类泛型：

泛型1：实体类的mapper接口

泛型2：实体类

/**
 * 自定义访问层接口实现类写法
 * 1.>实现自定义访问接口IEmployeeService
 * 2>继承ServiceImpl通用接口实现类
 * 3>明确指出两个泛型
 *  1.当前操作的实体类对象对应Mapper接口EmployeeMapper
 *  2.当前操作的实体类对象Employee
 */
@Service
public class EmployeeServiceImpl extends ServiceImpl<EmployeeMapper, Employee>
        implements IEmployeeService {
}

2.分页的操作

1.在Employee实体类中加一个字段

@TableField(exist = false)
private Department department;

创建EmployeeQuery类

@Getter
@Setter
public class EmployeeQuery {
    private Integer currentPage=1;
    private Integer PageSize=3;
}

2.在IEmployeeService中添加抽象方法

IPage<Employee> query(EmployeeQuery qo);

3.在EmployeeServiceImpl类实现方法

@Override
    public IPage<Employee> query(EmployeeQuery qo) {
        IPage<Employee> page = new Page<>(qo.getCurrentPage(), qo.getPageSize());  //设置分页信息
        QueryWrapper<Employee> wrapper = Wrappers.<Employee>query();  //拼接条件
        return super.page(page,wrapper);
    }

4.测试类

@Test
    public void testPage(){
        EmployeeQuery qo = new EmployeeQuery();
        qo.setPageSize(3);
        qo.setCurrentPage(2);
        IPage<Employee> page = employeeService.query(qo);
        System.out.println("当前页：" + page.getCurrent());
        System.out.println("总页数：" + page.getPages());
        System.out.println("每页显示条数：" + page.getSize());
        System.out.println("总记录数：" + page.getTotal());
        System.out.println("当前页显示记录：" + page.getRecords());
    }

ppers.query(); //拼接条件
return super.page(page,wrapper);
}

4.测试类

```java
@Test
    public void testPage(){
        EmployeeQuery qo = new EmployeeQuery();
        qo.setPageSize(3);
        qo.setCurrentPage(2);
        IPage<Employee> page = employeeService.query(qo);
        System.out.println("当前页：" + page.getCurrent());
        System.out.println("总页数：" + page.getPages());
        System.out.println("每页显示条数：" + page.getSize());
        System.out.println("总记录数：" + page.getTotal());
        System.out.println("当前页显示记录：" + page.getRecords());
    }