MybatisPlus入门和分页和条件查询里面的条件和null值的处理方式和查询投影和查询条件设置和id生成相关和逻辑删除

2023-11-17

MybatisPlus

简化了mybatis之前的在springboot整合MyBatis时需要自己写sql语句在接口中，现在只需要让接口继承BaseMapper<实体类>，然后在测试类中接口.增删改查方法（）即可
在这里插入图片描述
不用像springboot整合mybatis一样勾选spring web，这里用勾选sql就行，然后把MyBatisPlus的坐标手动添加到pom文件中

包的路径图：

在pom文件中添加mybaitsplus的坐标

在yml文件中写上数据源所需的参数：可以使用德鲁伊数据池
在这里插入图片描述

代码：

pom文件：

<?xml version="1.0" encoding="UTF-8"?>

<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.0</version>
        <relativePath/>
    <!-- lookup parent from repository -->
   </parent>

    <groupId>com.itheima</groupId>

    <artifactId>mybatisplus01</artifactId>

    <version>0.0.1-SNAPSHOT</version>


    <properties>
        <java.version>1.8</java.version>
    </properties>


    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <!--springboot的版本-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.2.0</version>
        </dependency>
        <!--mybatis-plus的springboot支持-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.4.3.1</version>
        </dependency>
        <!--mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <!--简化代码的工具包-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
            <scope>provided</scope>
        </dependency>
        <!--测试-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!--mybatisplus-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-core</artifactId>
            <version>3.4.3.1</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
    <!--阿里云的仓库-->
    <repositories>
        <repository>
            <id>nexus-aliyun</id>
            <name>nexus-aliyun</name>
            <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
            <releases>
                <enabled>true</enabled>
            </releases>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </repository>
    </repositories>

</project>片

数据源所需参数：yml文件中

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/parent
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: root

实体类：

坐标lombok可以简化自己创建setter()``getter()等方法，具体的查看lombokjava库

@TableName("数据库的表名")：这样就不用实体类名必须与数据库的表名相同了，还有属性的注解等等，具体的就需要====》看文档

package com.itjh.pojo;

import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

@Data
@TableName("tblbook")
public class tblbook {
    private String name;
    private Integer id;
    private String description;
    private String type;
}

接口：

加了@Mapper注解，表示可以被当成接口扫描到，这样就会自动产生实现类，替换了之前mybatisConfig配置类中的加载接口所在包的操作

继承了BaseMapper<tblbook>，相关的sql语句不用自己写了，在测试类直接选择方法提供的增删改查方法即可

package com.itjh.dao;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.itjh.pojo.tblbook;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface Dao extends BaseMapper<tblbook> {
}

主方法不用动，测试类：直接调用封装好的方法即可

package com.itjh;

import com.itjh.dao.Dao;
import com.itjh.pojo.tblbook;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class Mybatisplus01ApplicationTests {
	@Autowired
    private Dao dao;
	@Test
    //动态sql
    void upDate(){
        tblbook tb=new tblbook();
        tb.setId(11);
        tb.setName("一响");
        int a=dao.updateById(tb);
        System.out.println(a);
    }
}

分页

将数据进行分页，并且设定每一页的数据量
首先需要添加拦截器配置类，在其中对于拦截下来的分页查询进行操作
别忘了让主方法扫描它，所以添加注解@Configuration

package com.itjh.config;

import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
//添加拦截器，保证分页查询成功
public class MpConfig {
    @Bean
    public MybatisPlusInterceptor interceptor(){
        //创建一个拦截器
        MybatisPlusInterceptor tor=new MybatisPlusInterceptor();
        //添加具体的拦截器，这里应该是分页拦截器
        tor.addInnerInterceptor(new PaginationInnerInterceptor());
        return tor;
    }
}

主方法不变，测试方法：

 @Test
    void getByPage(){
        //创建分页的对象，把参数放进去，相当于limit 2,2
        IPage page=new Page(2,2);
        dao.selectPage(page,null);
        System.out.println("当前页："+page.getCurrent());
        System.out.println("当前页的大小："+page.getSize());
        System.out.println("一共有多少条数据："+page.getTotal());
        System.out.println("数据："+page.getRecords());

    }

除此之外mybatisplus还实现了动态sql：不用输入全数据就被允许定位到想要的数据的位置，如有4个字段，而我的测试类中的方法只提供了2个字段的信息，仍然可以完成数据的操作

@Test
    //动态sql
    void upDate(){
        tblbook tb=new tblbook();
        tb.setId(11);
        tb.setName("一响");
        int a=dao.updateById(tb);
        System.out.println(a);
    }

条件

开发中的SQL语句中一般都是含有条件，所以这里提供了，可以添加条件的方法，比如先创建查询条件的对象QueryWrapper<实体类>
然后调用其方法进行条件查询：
条件里面当然也可以有and和or等，查看文档怎么写，或者看视屏=====》条件查询

@Test
    void getAll() {
        QueryWrapper<tblbook> n=new QueryWrapper<tblbook>();
        //查询id比5小的数据
        n.lt("id",5);
        List<tblbook> list=dao.selectList(n);
        System.out.println(list);
    }

在这里插入图片描述

null值的处理方式

无非就是先判断是否为null再将其进行处理，现在旨在于简化这个判断，而it() gt()等方法可以进行判断：n.gt(null!=tb.getId(),"id",5),前一个参数为true时，后面的才会执行，id<5
看注释，这里用了链式

	@Test
    void getAll() {
        tblbook tb=new tblbook();
        //设置一个值，用来等会儿判断是否为空
        tb.setId(5);
        //查询条件对象
        QueryWrapper<tblbook> n=new QueryWrapper<tblbook>();
        //只有满足第一个参数为true，才会将后面的参数传送进去
        n.gt(null!=tb.getId(),"id",5).lt(null!=tb.getId(),"id",12);
        List<tblbook> list=dao.selectList(n);
        System.out.println(list);
    }

在这里插入图片描述

查询投影

即查询的结果只显示我们想要显示的字段，lambda和普通形式的条件对象进行查询投影的操作时是不同的：

lambda：

 @Test
    void getAll() {
        tblbook tb=new tblbook();
        LambdaQueryWrapper<tblbook> lambdaQueryWrapper=new LambdaQueryWrapper<tblbook>();
        lambdaQueryWrapper.select(tblbook::getId);
         List<tblbook> list=dao.selectList(lambdaQueryWrapper);
        System.out.println(list);
    }

普通类型：

@Test
    void getAll3() {
        //查询条件对象
        QueryWrapper<tblbook> n=new QueryWrapper<tblbook>();
        //普通条件对象的查询投影，一下都是作为sql语句添加进自动生成的sql语句中
        n.select("name","id");
        List<tblbook> list=dao.selectList(n);
        System.out.println(list);
        //将查询到的数据的条数统计起来，但是这个count不是实体类的对象，
        // 所以需要将实体类和count作为平级的关系装进集合中
        n.select("count(*)");
        List<Map<String, Object>> maps=dao.selectMaps(n);
        System.out.println(maps);
    }

查询条件设置

and、or 、between等加进自动生成的sql语句中时，应当怎么个加的法子，看官方文档，写的非常通俗易懂

id生成相关

和id有关的有很多种方式生成，可以按照数据库自己的自增来进行id生成，可以自己设定，也可以通过雪花算法得出id值等等等等，有很多：

按照数据库的自增来：
在实体类上的id属性上面加上注解@TableId(type=IdType.AUTO)，当然数据库中的id应当是勾选了自增的：

package com.itjh.pojo;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

//代替了setter、getter等方法
@Data
public class tblbook {
    private String name;
    @TableId(type=IdType.AUTO)
    private Integer id;
    private String description;
    private String type;
}

测试类：不用给id值，不会报错的，但是数据库id没有设置自增的话就会报错

@Test
    void insertl() {
        tblbook tb=new tblbook();
        tb.setName("真探");
        tb.setDescription("每集时长挺长");
        tb.setType("悬疑片");
        int a=dao.insert(tb);
        System.out.println(a);
    }

结果当然是数据库中的更新是按照自增顺序给的

按自己设置id来：
实体类添加注解@TableId(type=IdType.INPUT):

package com.itjh.pojo;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

@Data
@TableName("tblbook")
public class tblbook {
    private String name;
    @TableId(type=IdType.INPUT)
    private Integer id;
    private String description;
    private String type;
}

测试类中自己设置id值：不会受数据库的自增影响

@Test
    void insertl() {
        tblbook tb=new tblbook();
        tb.setName("真探");
        tb.setDescription("每集时长挺长");
        tb.setType("悬疑片");
        tb.setId(16);
        int a=dao.insert(tb);
        System.out.println(a);
    }

雪花算法：
根据雪花算法自动生成id值：注解@TableId(type=IdType.ASSIGN_ID)，数据库中的自增不会影响注解
当然，实体类的id要设置成Long包装类型，不能是long

@Data
@TableName("tblbook")
public class tblbook {
    private String name;
    @TableId(type=IdType.ASSIGN_ID)
    private Long id;
    private String description;
    private String type;
}

测试类：没有设置id，全靠雪花自己动

 @Test
    void insertl() {
        tblbook tb=new tblbook();
        tb.setName("真探");
        tb.setDescription("每集时长挺长");
        tb.setType("悬疑片");
        int a=dao.insert(tb);
        System.out.println(a);
    }

结果：id很长
在这里插入图片描述

各种算法：具体的可以查看MyBatisPlus文档
在这里插入图片描述

全局设置：

不用每一个属性进行指定id生成策略，可以在yml文件中进行统一的制定

#    雪花自增的全局配置
mybatis-plus:
  global-config:
    db-config:
      id-type: assign_id

类上面的@TableName("tblbook")注解也可以：

#    配置类上面的表名的前缀
mybatis-plus:
  global-config:
    db-config:
      id-type: assign_id
      table-prefix: tbl

实体类：最终会和上面全局中的tbl进行拼接得到tblbook，就等于之前类上面的@TableName("tblbook")

@Data
public class book(){
}

批量操作:

在一个集合中添加数字元素，然后当成id扔进方法中，就能批量的进行删除操作
在这里插入图片描述

逻辑删除：

只是在逻辑上删除了（心理上假装删除了），实际上还在，
就是新加一个字段，默认值为0或者1，0为没有被心理上删除，1为已经被心理上删除了
在这里插入图片描述

然后，在实体类中的对应逻辑删除的表示字段上添加注解@TableLogic(value = "0",delval = "1")，增删改查操作会根据具体的逻辑删除字段的当前值进行区别化的操作，具体的查看文档很详细

@Data
@TableName("book")
public class tblbook {
    private String name;
    @TableId(type=IdType.ASSIGN_ID)
    private Long id;
    private String description;
    private String type;
    //如果删除执行到这里，则需要假装删除，实则是更新操作
    //判断数据库中的默认值为0的话，就按照上面说的来
    @TableLogic(value = "0",delval = "1")
    private int delet;
}

这里演示一下删除操作：逻辑删除id为3的数据

@Test
    void delet(){
        System.out.println(dao.deleteById(3L));
    }

而结果本质其实是更新：
在这里插入图片描述
仅仅是将id为3的数据的delet字段的数据改为1，并没有真正的删除id所指的那一行数据

可以直接加载yml文件中，进行全局配置，这样就不用每一个实体类都去配置逻辑删除注解了

mybatis-plus:
  global-config:
    db-config:
      logic-delete-field: delet
      logic-delete-value: 1
      logic-not-delete-value: 0

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)