Mybatis-plus 课件

1 定义及特性

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

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

2 ORM思想

以对象的方法操作数据库，可以实现结果集与对象的自动映射。

3 代码演示

1、引入Mybatis-plus包
2、pojo类

package com.jt.pojo;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;

@Data
@NoArgsConstructor //无参构造
@AllArgsConstructor //该构造方法含有所有字段
@Accessors(chain=true) //开启链式加载结构，重构了set方法可以连续赋值
//@TableName("user") //标识对象与表的映射关系；如果表名与对象的名称一致，则(“user”)可以省略不写
public class User {
    //实体对象的属性类型都是包装类型；Integer默认null,int默认0
    @TableId(type= IdType.AUTO) //这里的id并不代表某个字段，而是代表主键;括号内属性表示主键自增
    private Integer id;

    //@TableField(value="user_name") //标识字段；与表名称一样可以省略
    //@TableField //与表名称一样可以省略
    private String name;
    private Integer age;
    private String sex;
}

3、Mapper

package com.jt.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jt.pojo.User;

//该接口演示Mybatis-plus
public interface UserMapper1 extends BaseMapper<User> {
}

service

package com.jt.service;

import com.jt.pojo.User;

import java.util.List;

public interface UserService {
    List<User> findAll();
}

serviceImpl

package com.jt.service;

import com.jt.mapper.UserMapper;
import com.jt.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserServiceImpl implements UserService{

    @Autowired
    private UserMapper userMapper;

    @Override
    public List<User> findAll() {
        //return userMapper.findAll();
        return userMapper.selectList(null);
    }
}

4 案例演示

package com.jt;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.jt.mapper.UserMapper1;
import com.jt.pojo.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.Arrays;
import java.util.List;

@SpringBootTest
class SpringbootDemo2ApplicationTests {

    //该注入演示Mybatis-plus
    @Autowired
    private UserMapper1 userMapper1;

    @Test //演示链式加载
    void contextLoads() {
        User user = new User();
        user.setId(100).setName("张三").setAge(100).setSex("男");
    }

    //delete；根据name;删除name="宋江"的数据
    @Test
    public void testDelete1() {
        //根据除主键之外的数据删除信息
        QueryWrapper queryWrapper = new QueryWrapper();
        queryWrapper.eq("name", "宋江");
        userMapper1.delete(queryWrapper);
    }

    //删除；根据主键批量删除
    @Test
    public void testDelete() {
        Integer[] ids = {1, 3, 5, 7};
        List<Integer> idList = Arrays.asList(ids);

        int i = userMapper1.deleteBatchIds(idList);

        System.out.println(i);
    }

    /*修改
    将name为“宋江”的修改为“林冲”

    官方文档：
    根据 whereEntity 条件，更新记录
    boolean update(T entity, Wrapper<T> updateWrapper);
    */
    @Test
    public void testUpdate1() {
        User user = new User();
        user.setName("林冲");

        UpdateWrapper<User> updateWrapper = new UpdateWrapper<>();
        updateWrapper.eq("name", "宋江");

        userMapper1.update(user, updateWrapper);
    }

    /*修改
    修改id=56的name="吴用"
    自己手写

    console sql语句如下：
    Preparing: UPDATE user SET name=? WHERE id=?
    Parameters: 李逵(String), 56(Integer)

    特别说明：user.setId(56).setName("李逵");与user.setName("潘金莲").setId(56);效果是一样的，都是以id值为条件修改name值
    */
    @Test
    public void testUpdate() {
        User user = new User();
        //根据对象中不为null的属性，当作set条件，以id值为条件修改name值
        //user.setId(56).setName("李逵");
        user.setName("潘金莲").setId(56);
        int i = userMapper1.updateById(user);
        System.out.println(i);
    }

    //添加；不用加主键
    @Test
    public void testInsert(){

        User user = new User();

        user.setName("宋江").setAge(38).setSex("男");

        int i = userMapper1.insert(user);
        System.out.println(i);
    }

    /*查询
    官方文档解释：
    根据Wrapper条件，查询全部记录。注意：只返回第一个字段的值
    List<Object> selectObjs(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
    */
    @Test
    public void testSelect05() {
        //获取表中第一列主键信息
        List<Object> idList = userMapper1.selectObjs(null);

        System.out.println(idList);
        idList.forEach(System.out::println);
    }

    /*查询
     查询id=1,3,5,6的记录
     sql:select * from user where id in(1,3,5,6)
     和testSelect03()功能一样
    */
    @Test
    public void testSelect04() {
        Integer[] ids = {1, 3, 5, 7}; //模拟业务传过来的数组数据 public void testSelect03(Integer[] ids) {
        List<Integer> idList = Arrays.asList(ids); //数组转为集合

        List<User> userList = userMapper1.selectBatchIds(idList);

        //System.out.println(userList);
        userList.forEach(System.out::println);
    }

    /*查询
     查询id=1,3,5,6的记录
     sql:select * from user where id in(1,3,5,6)
     和testSelect04()功能一样
    */
    @Test
    public void testSelect03() {
        Integer[] ids = {1, 3, 5, 7};
        List<Integer> idList = Arrays.asList(ids);

        QueryWrapper queryWrapper = new QueryWrapper();
        queryWrapper.in("id", 1, 3, 5, 7);

        List<User> userList = userMapper1.selectList(queryWrapper);
        userList.forEach(System.out::println);
    }

    /*查询
    查询age=18,sex为女的数据
    sql:xxx where age=18 and sex="女"
    条件构造器的作用：用来拼接where条件
    eq =
    > gt
    < lt
    >= ge
    <= le
    */
    @Test
    public void testSelect02() {
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("age", 18)
                    .eq("sex", "女");

        List<User> userList = userMapper1.selectList(queryWrapper);

        System.out.println(userList);
        userList.forEach(System.out::println);
    }

    //查询；根据id查询一条数据
    @Test
    public void testSelect01() {
        User user = userMapper1.selectById(54);
        System.out.println(user);
    }

    //查询；查询全部数据
    @Test
    public void testSelect() {
        List<User> userList = userMapper1.selectList(null);
        //Assert.assertEquals(5, userList.size()); //这条语句运行错误;在官方文档上面摘抄的代码
        userList.forEach(System.out::println);

        //得到总记录数
        int count = userMapper1.selectCount(null);
        System.out.println("总记录数为：" + count);
    }
}