MybatisPlus快速入门上手

一、SpringBoot集成Mybatisplus

1、创建项目添加依赖

<!-- MyBatisPlus -->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-bootstarter</artifactId>
    <version>3.5.0</version>
</dependency>
<!-- mysql驱动 -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connectorjava</artifactId>
    <version>8.0.26</version>
</dependency>
<!-- lombok -->
<dependency
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <optional>true</optional>
</dependency>

2、配置数据源和mybatisplus配置

# 数据源
spring:
 datasource:
   driver-class-name:
com.mysql.cj.jdbc.Driver
   url: jdbc:mysql:/school?serverTimezone=UTC
serverTimezone=UTC
   username: root
   password: root
#开启mybatis-plus  sql日志打印
mybatis-plus:
 configuration:
   log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
 global-config:
   db-config:
      #主键类型
     id-type: AUTO
      # 设置表名前缀
     table-prefix: tb_
      # 是否使用驼峰转下划线命名，默认开启
     table-underline: true
     # 全局逻辑删除的字段名
     logic-delete-field: deleted
      # 逻辑已删除值(默认为 1)
     logic-delete-value: 1
      # 逻辑未删除值(默认为 0)
     logic-not-delete-value: 0

二、MybatisPlus增删改查及相关注解

1、使用注意

使用mybatisplus首先要在写的mapper接口上添加extends BaseMaper<T>

(T为增删改查的对象）

public interface StudentMapper extends BaseMapper<Student> {
}

2、相关注解

@TableName    作用：指定类为哪个表的实体类    位置：类上方

@TableName 作用：指定类为哪个表的实体类 位置：类上方

@TableId 作用：指定实体类的属性为主键 位置：属性上方

属性： value：主键字段名  type：主键策略 

AUTO 自增主键

ASSIGN_ID 默认策略，使用雪花算法自动生成主键ID，主键类型为整形或字符串。

@TableField 作用：在属性和列名不同的情况下，指定映射关系 位置：非主键属性上方

@Data
@NoArgsConstructor
@AllArgsConstructor
@TableName("tb_student")
public class Student {
    @TableId(value = "sid",type =
IdType.AUTO)
    private Integer id;
    @TableField("sname")
    private String name;
    private String email;
    private String gender;
    private Integer age;
}

3、mybatisplus增删改查方法及测试案例与底层sql

增加   studentMapper.insert()

修改  studentMapper.updateById()

根据id删除  studentMapper.updateById()

批量删除   studentMapper.deleteBatchIds()

根据字段删除 studentMapper.deleteByMap()

根据id查询  studentMapper.selectById()

根据id批量查询  studentMapper.selectBatchIds()

根据字段查询  studentMapper.selectByMap()

    //添加
    @Test
    public void testAdd(){
        Student student=new Student(null,"xjt","sdsdsd@sds.com","m",22);
        studentMapper.insert(student);
        System.out.println(student.getId());
    }
    ==>  Preparing: INSERT INTO student ( name, email, gender, age ) VALUES ( ?, ?, ?, ? 
    ==> Parameters: xjt(String), sdsdsd@sds.com(String), m(String), 22(Integer)
    <==    Updates: 1

    //修改
    @Test
    public void testupdate(){
        Student student = new Student();
        student.setName("woshinibb");
        student.setId(1);
        studentMapper.updateById(student);
    }
    ==>  Preparing: UPDATE student SET name=? WHERE id=?
    ==> Parameters: woshinibb(String), 1(Integer)
    <==    Updates: 0

    //根据id删除
    @Test
    public void testDeleteById(){
        studentMapper.deleteById(1);
    }
    ==>  Preparing: DELETE FROM student WHERE id=?
    ==> Parameters: 1(Integer)
    <==    Updates: 0

    //批量删除
    @Test
    public void testDeleteBatch(){
        ArrayList<Integer> ids=new ArrayList<>();
        ids.add(2);
        ids.add(3);
        studentMapper.deleteBatchIds(ids);
    }
    ==>  Preparing: DELETE FROM student WHERE id IN ( ? , ? )
    ==> Parameters: 2(Integer), 3(Integer)
    <==    Updates: 0

    //根据字段条件删除
    @Test
    public void testDeleteMap(){
        Map<String,Object> map = new HashMap<>();
        map.put("sname","百战程序员");
        map.put("gender","m");
        studentMapper.deleteByMap(map);
    }
    ==>  Preparing: DELETE FROM student WHERE gender = ? AND name = ?
    ==> Parameters: m(String), 百战程序员(String)
    <==    Updates: 0

    //根据id查询
    @Test
    public void testFindById(){
        Student student = studentMapper.selectById(1);
        System.out.println(student);
    }
    ==>  Preparing: SELECT id,name,email,gender,age FROM student WHERE id=?
    ==> Parameters: 1(Integer)
    <==      Total: 0

    //根据id批量查询
    @Test
    public void testFindBatch(){
        List<Integer> list = new ArrayList<>();
        list.add(4);
        list.add(5);
        list.add(6);
        List<Student> list1=studentMapper.selectBatchIds(list);
        list1.forEach(System.out::println);
    }
    ==>  Preparing: SELECT id,name,email,gender,age FROM student WHERE id IN ( ? , ? , ? )
    ==> Parameters: 4(Integer), 5(Integer), 6(Integer)
    <==    Columns: id, name, email, gender, age
    <==        Row: 4, 小王, wang@itbaizhan.com, f, 35
    <==        Row: 5, 小李, li@itbaizhan.com, m, 32
    <==        Row: 6, 小赵, zhao@itbaizhan.com, m, 32
    <==      Total: 3

    //根据字段条件查询
    @Test
    public void testFindMap(){
        Map<String,Object> map = new HashMap<>();
        map.put("sname","小王");
        map.put("gender","f");
        studentMapper.selectByMap(map);
    }
    ==>  Preparing: SELECT id,name,email,gender,age FROM student WHERE (gender = ? AND age <= ?)
    ==> Parameters: f(String), 35(Integer)
    <==    Columns: id, name, email, gender, age
    <==        Row: 4, 小王, wang@itbaizhan.com, f, 35
    <==      Total: 1

三、条件构造器、分页查询、全局配置、逻辑删除

1、条件构造器

 实际应用

// 条件构造器1
@Test
public void testFindWrapper1() {
    // 查询年龄小于25或年龄大于30的人

    QueryWrapper<Student> queryWrapper = new QueryWrapper<>();
    queryWrapper.lt("age",25).or().gt("age",30);
    List<Student> students = studentMapper.selectList(queryWrapper);
    students.forEach(System.out::println);
}

// 条件构造器2
@Test
public void testFindWrapper2() {
    // 查询性别为女，且年龄小于等于35的数据
    QueryWrapper<Student> queryWrapper = newQueryWrapper<>();
    queryWrapper.eq("gender","f").le("age",35);
    List<Student> students =studentMapper.selectList(queryWrapper);
    students.forEach(System.out::println);
}

// 条件构造器3
@Test
public void testFindWrapper3() {
    // 查询名字包含"小"的学生，按照年龄升序排序
    QueryWrapper<Student> queryWrapper = newQueryWrapper<>();
    queryWrapper.like("sname","小").orderByAsc("age");

}

2、分页查询

注册分页插件在SpringBoot启动类中配置插件

    //配置插件
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor(){
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        // 分页插件
        interceptor.addInnerInterceptor(newPaginationInnerInterceptor(DbType.MYSQL));
        // 防止全表更新与删除插件
        interceptor.addInnerInterceptor(newBlockAttackInnerInterceptor());
        // 乐观锁插件
        interceptor.addInnerInterceptor(newOptimisticLockerInnerInterceptor());
        return  interceptor;
    }

使用案例

    //分页查询
    @Test
    public void testFindPage(){
        //创建分页条件，从第0条开始，获取两条数据。
        Page page = new Page(0,2);
        //分页查询
        IPage<Student> iPage = studentMapper.selectPage(page,null);
        //打印分页数据
        System.out.println("结果集："+iPage.getRecords());
        System.out.println("总页数："+iPage.getPages());
        System.out.println("总条数："+iPage.getTotal());
        System.out.println("当前页："+iPage.getCurrent());
        System.out.println("每页条数："+iPage.getSize());
    }

3、悲观锁与逻辑删除

数据库字段 version、deleted

实体类   @Version    private Integer version;    @TableLogic    private Integer deleted;