MyBatis-Plus第一章：集成SpringBoot的基本使用，和利用QueryWrapper构建复杂条件查询

最新推荐文章于 2024-03-09 14:36:33 发布

三井寿14

最新推荐文章于 2024-03-09 14:36:33 发布

阅读量2.3k

点赞数 1

分类专栏： Mybatis

本文链接：https://blog.csdn.net/weixin_49702090/article/details/110787060

版权

Mybatis 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

MyBatis-Plus 无需编写SQL，但是一些复杂的SQL还需要我们手动编写。
基于SpringBoot下的测试。

一、基本使用

1、导入依赖

	<build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>8</source>
                    <target>8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

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

    <dependencies>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.12</version>
                <scope>test</scope>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>1.18.16</version>
            </dependency>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.47</version>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>1.18.16</version>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            <dependency>
                <groupId>com.baomidou</groupId>
                <artifactId>mybatis-plus-boot-starter</artifactId>
                <version>3.0.5</version>
            </dependency>
    </dependencies>

2、编写数据库连接application.properties文件

# 配置数据库连接
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.url=jdbc:mysql://localhost:3306/question_bank?useSSL=false&useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

# 配置日志
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

3、实体类

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User implements Serializable {

    @TableId(type = IdType.AUTO) //指定主键生成策略
    //主键生成方式有：uuid、自增id、雪花算法、redis、zookeeper
    private Integer id;
    private String username;
    private String password;
    private String email;
    private String gender;
    private Integer role;

//    public enum IdType{
//        AUTO(0),   自增ID，使用较多，数据库必须也是 auto increment
//        NONE(1),   数据库不使用主键，一般不会
//        INPUT(2),  手动输入，必须手动输入id，否则不能获取自增列,
//                  （虽然数据库端设置auto increment也会添加成功，但是后台无法获取自增id）
//        ID_WORKER(30),  局唯一ID，默认type，会由雪花算法生成155464464646好多位数
//        UUID(4),  全局唯一 UUID
//        ID_Woeker_STR(5); 字符串表示法
//    }
}

4、编写Mapper接口

@Repository //代表持久层，将bean的创建交给Ioc管理
public interface UserMapper extends BaseMapper<User> {
}

实现BaseMapper接口便能自动替我们完成一些简单的CRUD操作

5、进行简单的CRUD单元测试

import com.lg.dto.User;
import com.lg.mapper.UserMapper;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.ArrayList;
import java.util.List;

/**
 * Author:LiuGang
 */
@RunWith(SpringRunner.class)
@SpringBootTest
public class MybatisTest {
    @Autowired
    private UserMapper userMapper;

    //1、测试查询
    @Test
   public void contextLoad(){
   		//（1）查询所有----------------------------------------------
        List<User> users = userMapper.selectList(null);
        users.forEach(System.out::println);

		//（2）根据id查询单个----------------------------------------
		//User user=userMapper.selectById(1);

		//（3）查询多个----------------------------------------------
		//List<User> u = userMapper.selectBatchIds(Arrarys.asList(1,2,3));

		//（4）自定义条件 Map 查询------------------------------------
		//Map<String,Object> map=new HashMap<String,Object>();
		//构建查询条件
		//map.put("username","kobe"); 
		//map.put("password","123456");
		//List<User> u =userMapper.selectByMap(map);
		//MyBatis-Plus在执行该方法时会自动创建动态SQL，where username='kobe' and password='123456' ;
    }

    //2、测试添加
    @Test
    public void addUser(){
        User user=new User(null, "wang", "123456", "123@qq.com", "男", 2);
        //添加成功会自动获取自增主键，自增主键默认由雪花算法生成，一般不用,可在实体类上方加@TableId注解定义主键生成策略
        int row = userMapper.insert(user);
        System.out.println("自动生成的主键:"+user.getId());
    }

    //3、测试删除
    @Test
    public void deleteUser(){
        //（1）根据主键ID删除
        //int row = userMapper.deleteById(15);

        //（2）批量删除
        List<Integer> list=new ArrayList<Integer>(2);
        list.add(15);
        list.add(16);
        int row = userMapper.deleteBatchIds(list);

        String ret=row>=1?"成功":"失败";
        System.out.println("删除结果："+ret);
    }

    //4、测试修改
    @Test
    public void updateUser(){
        int row = userMapper.updateById(new User(16, "wang", "8888888", "123@qq.com", "男", 2));
        String ret=row>=1?"成功":"失败";
        System.out.println("修改结果："+ret);
    }

    /**
     * 雪花算法：
     * snowflake是Twitter开源的分布式ID生成算法，结果是一个long型的ID。
     * 其核心思想是：使用41bit作为毫秒数，10bit作为机器的ID（5个bit是数据中心，5个bit是机器的ID），
     * 12bit作为毫秒内的流水号（意味着每个节点在每毫秒可以产生4096个ID）
     * 最后还有一个符号位，永远是0。可以保证几乎全球唯一
     */

}

二、QueryWrapper 的使用（构建复杂查询条件）

对于单表下的相对复杂的条件查询，MyBatis-Plus 中也封装好了相对应的方法，这些方法便是来源于核心类——QueryWrapper。其本质也是此框架在执行过程中为你动态拼接好了SQL而已。如何使用？都封装了哪些方法？以下为你演示！

1、isNotNull（）——非空

2、ge（）——great then or equal to 大于等于

 	/**
     * 1、查询 role 是非空的，version >=2;
     */
 @Test
    public void m1() {
        //（查询包装）构建查询条件
        QueryWrapper<User> wrapper=new QueryWrapper<>();
        wrapper.isNotNull("role")
                .ge("version", 2); // ge=>great then or equal to （大于等于）

        //查询
        List<User> list = userMapper.selectList(wrapper);
        //遍历结果
        list.forEach(System.out::println);
    }

分析查询结果：
在这里插入图片描述
3、selectOne（Wrapper wrapper）——查询一条记录

4、eq（）——等于

 	/**
     * 查询一条记录，名字等于 wang
     */
    @Test
    public void m2() {
        //（查询包装）构建查询条件
        QueryWrapper<User> wrapper=new QueryWrapper<>();
        wrapper.eq("username", "wang");
        //查询并获取结果
        User user= userMapper.selectOne(wrapper);
    }

5、selectCount( Wrapper wrapper ) —— 获取wrapper条件下的总记录行数，Integer 类型

6、between（）—— 在…之间的

	/**
     * 2、查询 version 在 3 和 7 之间的记录有几行（等到行数 Integer）
     */
    @Test
    public void m3() {
        //（查询包装）构建查询条件
        QueryWrapper<User> wrapper=new QueryWrapper<>();
        wrapper.between("version", 3, 7);
        //查询
        Integer num= userMapper.selectCount(wrapper);
        //打印结果
        System.out.println("一共有"+num+"条记录的version在3~7之间");
    }

7、like（）——包含

8、notLike（）——不包含

9、likeLeft（）——左匹配

10、likeRight（）——右匹配

11、selectMaps（Wrapper wrapper）——查出数据不以对象形式存储，以map形式

{password=1213131, deleted=0, gender=女, id=30, version=1, email=123@qq.com, username=ssss}

	 /**
     * 4、模糊查询
     */
    @Test
    public void m4() {
        //（查询包装）构建查询条件
        QueryWrapper<User> wrapper=new QueryWrapper<>();
        wrapper.notLike("username", "g")  // AND username NOT LIKE '%g%' 
                .likeRight("password", "12"); // AND password LIKE '12%'
        //查询
        List<Map<String, Object>> maps = userMapper.selectMaps(wrapper);
        //打印结果
        maps.forEach(System.out::println);
    }

12、inSql（）——自定义一个子查询作为查询条件

 /**
     * 5、自定义查询条件（使用子查询）
     */
    @Test
    public void m5() {
        //（查询包装）构建查询条件
        QueryWrapper<User> wrapper=new QueryWrapper<>();
        wrapper.inSql("id", "select id from user where gender ='女'");
        //查询
        List<Object> list = userMapper.selectObjs(wrapper);
        //打印结果
        list.forEach(System.out::println);
    }

在这里插入图片描述

13、orderByAsc（）——升序排序

14、orderByDesc（）——降序排序

 	/**
     * 6、排序查询
     */
    @Test
    public void m6() {
        //（查询包装）构建查询条件
        QueryWrapper<User> wrapper=new QueryWrapper<>();
        //wrapper.orderByAsc("version");
        wrapper.orderByDesc("version");
        //查询
        //selectMaps --{password=1213131, deleted=0, gender=女, id=30, version=1, email=123@qq.com, username=ssss}
        List<User> list = userMapper.selectList(wrapper);
        //打印结果
        list.forEach(System.out::println);
    }

15、其他方法请查询 API

三井寿14

关注

1
点赞
踩
9

收藏

觉得还不错? 一键收藏
2
评论
MyBatis-Plus第一章：集成SpringBoot的基本使用，和利用QueryWrapper构建复杂条件查询

MyBatis-Plus 无需编写SQL，但是一些复杂的SQL还需要我们手动编写。基于SpringBoot下的测试。1、导入依赖 <build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-pl
复制链接

扫一扫