3.MybatisPlus 查询方法

1.普通查询

package com.mp;
import com.mp.dao.UserMapper;
import com.mp.entity.User;
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.Arrays;
import java.util.HashMap;
import java.util.List;

/**
 * @Description 测试类，测试普通查询方法
 * @Author LL
 * @Date 2020-03-22 12:35
 */
@SpringBootTest
@RunWith(SpringRunner.class)
public class RetrieveTest {

    @Autowired
    private UserMapper userMapper;

    //根据id查询
    @Test
    public void selectById(){
        User user = userMapper.selectById(1094590409767661570L);
        System.out.println(user);
    }

    //根据多个id查询
    @Test
    public void selectByIds(){
        List<Long> ids = Arrays.asList(1094590409767661570L, 1094592041087729666L, 
                1241614720021913602L);
        List<User> users = userMapper.selectBatchIds(ids);
        users.forEach(System.out::println);
    }

    //根据条件map参数查询
    @Test
    public void selectByMap(){
        //map中的key值为数据库表中的字段，值为查询条件值
        HashMap<String, Object> paramMap = new HashMap<>();
        paramMap.put("name", "王天风");
        paramMap.put("age", 25);
        List<User> users = userMapper.selectByMap(paramMap);
        users.forEach(System.out::println);
    }
}

2.条件构造器查询

package com.mp;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.mp.dao.UserMapper;
import com.mp.entity.User;
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.Arrays;
import java.util.List;

/**
 * @Description 测试类，测试条件构造器查询方法
 * @Author LL
 * @Date 2020-03-22 12:35
 */
@SpringBootTest
@RunWith(SpringRunner.class)
public class RetrieveWrapperTest {

    @Autowired
    private UserMapper userMapper;

    /**
     * 名字中包含雨并且年龄小于40
     * name like '%雨%' and age<40
     */
    @Test
    public void selectByWrapper(){
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
//        QueryWrapper<User> query = Wrappers.query();
        queryWrapper.like("name", "雨")
                .lt("age", 40);
        List<User> users = userMapper.selectList(queryWrapper);
        users.forEach(System.out::println);
    }

    /**
     * 名字中包含雨年并且龄大于等于20且小于等于40并且email不为空
     * name like '%雨%' and age between 20 and 40 and email is not null
     */
    @Test
    public void selectByWrapper2(){
//        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        QueryWrapper<User> query = Wrappers.query();
        query.like("name", "雨")
                .between("age", 20, 40)
                .isNotNull("email");
        List<User> users = userMapper.selectList(query);
        users.forEach(System.out::println);
    }

    /**
     * 名字为王姓或者年龄大于等于25，按照年龄降序排列，年龄相同按照id升序排列
     *  name like '王%' or age>=25 order by age desc,id asc
     */
    @Test
    public void selectByWrapper3(){
        QueryWrapper<User> query = Wrappers.query();
        query.like("name", "王")
                .or()
                .ge("age", 25)
                .orderByDesc("age")
                .orderByAsc("id");
        List<User> users = userMapper.selectList(query);
        users.forEach(System.out::println);
    }

    /**
     * 创建日期为2019年2月14日并且直属上级为名字为王姓
     * date_format(create_time,'%Y-%m-%d')='2019-02-14'
     * and manager_id in (select id from user where name like '王%')
     */
    @Test
    public void selectByWrapper4(){
        QueryWrapper<User> query = Wrappers.query();
        String date = "2019-02-14";
        String name = "王";
        query.apply("date_format(create_time,'%Y-%m-%d')={0}", date)
                .inSql("manager_id", "select id from user where name like '"+name+"%'");
        List<User> users = userMapper.selectList(query);
        users.forEach(System.out::println);
    }

    /**
     * 名字为王姓并且（年龄小于40或邮箱不为空）
     * name like '王%' and (age<40 or email is not null)
     */
    @Test
    public void selectByWrapper5(){
        QueryWrapper<User> query = Wrappers.query();
        query.likeRight("name", "王")
                .and(wq->wq.lt("age", 40)
                        .or()
                        .isNotNull("email")
                );
        List<User> users = userMapper.selectList(query);
        users.forEach(System.out::println);
    }

    /**
     * 名字为王姓或者（年龄小于40并且年龄大于20并且邮箱不为空）
     * name like '王%' or (age<40 and age>20 and email is not null)
     */
    @Test
    public void selectByWrapper6(){
        QueryWrapper<User> query = Wrappers.query();
        query.likeRight("name", "王")
                .or(wq->wq.lt("age", 40)
                        .gt("age", 20)
                        .isNotNull("email")
                );
        List<User> users = userMapper.selectList(query);
        users.forEach(System.out::println);
    }

    /**
     * （年龄小于40或邮箱不为空）并且名字为王姓
     * (age<40 or email is not null) and name like '王%'
     */
    @Test
    public void selectByWrapper7(){
        QueryWrapper<User> query = Wrappers.query();
        query.nested(wq->wq.lt("age", 40).or().isNotNull("email"))
                .likeRight("name", "王");
        List<User> users = userMapper.selectList(query);
        users.forEach(System.out::println);
    }

    /**
     * 年龄为30、31、34、35
     * age in (30、31、34、35)
     */
    @Test
    public void selectByWrapper8(){
        QueryWrapper<User> query = Wrappers.query();
        query.in("age", Arrays.asList(30,31,34,35));
        List<User> users = userMapper.selectList(query);
        users.forEach(System.out::println);
    }

    /**
     * 只返回满足条件的其中一条语句即可
     * limit 1
     */
    @Test
    public void selectByWrapper9(){
        QueryWrapper<User> query = Wrappers.query();
        query.in("age", Arrays.asList(30,31,34,35)).last("limit 1");
        List<User> users = userMapper.selectList(query);
        users.forEach(System.out::println);
    }
}

3.在select中字段不全部出现的查询

package com.mp;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.mp.dao.UserMapper;
import com.mp.entity.User;
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.List;

/**
 * @Description 测试类，select中字段不全部出现的查询
 * @Author LL
 * @Date 2020-03-22 12:35
 */
@SpringBootTest
@RunWith(SpringRunner.class)
public class RetrieveWrapperTest2 {

    @Autowired
    private UserMapper userMapper;

    /**
     * 名字中包含雨并且年龄小于40
     * 第一种情况：select id,name
     *             from user
     *             where name like '%雨%' and age<40
     */
    @Test
    public void selectByWrapper10(){
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.select("id", "name")
                .like("name", "雨")
                .lt("age", 40);
        List<User> users = userMapper.selectList(queryWrapper);
        users.forEach(System.out::println);
    }

    /**
     * 名字中包含雨并且年龄小于40
     * 第二种情况：select id,name,age,email
     *             from user
     *             where name like '%雨%' and age<40
     */
    @Test
    public void selectByWrapper11(){
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.like("name", "雨")
                .lt("age", 40)
                .select(User.class, info->!info.getColumn().equals("create_time")
                &&!info.getColumn().equals("manager_id"));
        List<User> users = userMapper.selectList(queryWrapper);
        users.forEach(System.out::println);
    }
}

4.condition的使用

在添加sql条件时，会判断条件是否存在从而动态拼接sql

package com.mp;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.mp.dao.UserMapper;
import com.mp.entity.User;
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.List;

/**
 * @Description 测试类，condition的使用
 * @Author LL
 * @Date 2020-03-22 18:35
 */
@SpringBootTest
@RunWith(SpringRunner.class)
public class ConditionTest {

    @Autowired
    private UserMapper userMapper;

    //根据条件拼接SQL
    private void conditionWrapper(String name, String email){
        QueryWrapper<User> query = Wrappers.query();
//        if (StringUtils.isNotEmpty(name)){
//            query.like("name", name);
//        }
//        if (StringUtils.isNotEmpty(email)){
//            query.like("email", email);
//        }

        //根据condition的条件判断是否拼接对应的查询条件
        query.like(StringUtils.isNotEmpty(name), "name", name)
                .like(StringUtils.isNotEmpty(email), "email", email);
        List<User> users = userMapper.selectList(query);
        users.forEach(System.out::println);
    }

    @Test
    public void test(){
        String name = "王";
        String email = "";
        conditionWrapper(name, email);
    }

}

5.实体对象作为条件构造器构造方法的参数

package com.mp;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.mp.dao.UserMapper;
import com.mp.entity.User;
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.List;

/**
 * @Description 测试类，condition的使用
 * @Author LL
 * @Date 2020-03-22 18:35
 */
@SpringBootTest
@RunWith(SpringRunner.class)
public class ConditionTest {

    @Autowired
    private UserMapper userMapper;

    /**
     * 测试实体类作为条件参数
     */
    @Test
    public void testEntity(){
        User user = new User()
                .setName("张三").setAge(31);

        QueryWrapper<User> query = Wrappers.query(user);
        List<User> users = userMapper.selectList(query);
        users.forEach(System.out::println);
    }
}

如果名称需要模糊查询，可以在User实体类的相应字段上添加注解，注解参数可查看SqlCondition.java

package com.mp.entity;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import lombok.experimental.Accessors;

import java.time.LocalDateTime;

/**
 * @Description 实体类
 * @Author LL
 * @Date 2020-03-22 12:22
 */
@Data
@Accessors(chain = true)
@TableName("user")//指定表名称
public class User {

    @TableId//指明此字段为主键id
    private Long id;//主键

    @TableField(condition = SqlCondition.LIKE)//指定查询时的查询形式，name like '%?%'
    private String name;//姓名

    @TableField(condition = "%s&lt;#{%s}")//指定查询时的查询形式，age<?
    private Integer age;//年龄

    private String email;//邮箱

    private Long managerId;//上级id

    private LocalDateTime createTime;//创建时间

    @TableField(exist = false)//表示不是数据库字段
    private String remark;//标识

}

查询SQL：SELECT id,create_time,name,manager_id,email,age FROM user WHERE name LIKE CONCAT('%',?,'%') AND age<?

6.AllEq的用法

package com.mp;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.mp.dao.UserMapper;
import com.mp.entity.User;
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.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @Description 测试类，AllEq的使用
 * @Author LL
 * @Date 2020-03-22 18:35
 */
@SpringBootTest
@RunWith(SpringRunner.class)
public class AllEqTest {

    @Autowired
    private UserMapper userMapper;

    /**
     * AllEq
     */
    @Test
    public void testAllEq(){
        Map<String, Object> map = new HashMap<>();
        map.put("name", "王天风");
        map.put("age", 25);
//        map.put("age", null);//传null值，则会在Sql中拼接为 is null
        QueryWrapper<User> query = Wrappers.query();
        query.allEq(map);
//        query.allEq((k, v)->k.equals("name"), map);//过滤掉name字段
        List<User> users = userMapper.selectList(query);
        users.forEach(System.out::println);
    }

}

7.其它条件构造器用法

package com.mp;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.mp.dao.UserMapper;
import com.mp.entity.User;
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.List;
import java.util.Map;

/**
 * @Description 测试类，其它的用法
 * @Author LL
 * @Date 2020-03-22 18:35
 */
@SpringBootTest
@RunWith(SpringRunner.class)
public class OthersTest {

    @Autowired
    private UserMapper userMapper;

    /**
     * 返回值为map类型
     * 在返回结果中不同于实体类不需要的字段值为null时不显示
     */
    @Test
    public void testMap(){
        QueryWrapper<User> query = Wrappers.query();
        query.like("name", "雨").gt("age", 20);
        List<Map<String, Object>> maps = userMapper.selectMaps(query);
        maps.forEach(System.out::println);
    }

    /**
     * 返回结果为Map类型，使用场景如下
     *
     * 按照直属上级分组，查询每组的平均年龄、最大年龄、最小年龄。
     * 并且只取年龄总和小于500的组。
     * select avg(age) avg_age,min(age) min_age,max(age) max_age
     * from user
     * group by manager_id
     * having sum(age) <500
     */
    @Test
    public void testMap2(){
        QueryWrapper<User> query = Wrappers.query();
        query.select("avg(age) avg_age","min(age) min_age","max(age) max_age")
                .groupBy("manager_id")
                .having("sum(age)<{0}", 500);

        List<Map<String, Object>> maps = userMapper.selectMaps(query);
        maps.forEach(System.out::println);
    }
/*
    查询结果日志：
    DEBUG==>  Preparing: SELECT avg(age) avg_age,min(age) min_age,max(age) max_age FROM user
    GROUP BY manager_id HAVING sum(age)<?
    DEBUG==> Parameters: 500(Integer)
    TRACE<==    Columns: avg_age, min_age, max_age
    TRACE<==        Row: 40.0000, 40, 40
    TRACE<==        Row: 25.0000, 25, 25
    TRACE<==        Row: 30.5000, 28, 32
    DEBUG<==      Total: 3
    {max_age=40, avg_age=40.0000, min_age=40}
    {max_age=25, avg_age=25.0000, min_age=25}
    {max_age=32, avg_age=30.5000, min_age=28}
*/


    /**
     * 查询总记录数
     */
    @Test
    public void testCount(){
        QueryWrapper<User> query = Wrappers.query();
        query.like("name", "雨").gt("age", 20);
        int count = userMapper.selectCount(query);
        System.out.println("总记录数："+count);
    }
/*
    查询结果日志：
    DEBUG==>  Preparing: SELECT COUNT( 1 ) FROM user WHERE (name LIKE ? AND age > ?)
    DEBUG==> Parameters: %雨%(String), 20(Integer)
    TRACE<==    Columns: COUNT( 1 )
    TRACE<==        Row: 2
    DEBUG<==      Total: 1
    总记录数：2
 */


    /**
     * 查询结果为一条数据，多条会报错
     */
    @Test
    public void testOne(){
        QueryWrapper<User> query = Wrappers.query();
        query.like("name", "雨").gt("age", 31);
        User user = userMapper.selectOne(query);
        System.out.println(user);
    }

}

8.lambda条件构造器用法

package com.mp;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.additional.query.impl.LambdaQueryChainWrapper;
import com.mp.dao.UserMapper;
import com.mp.entity.User;
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.List;

/**
 * @Description 测试类，Lambda条件构造器用法
 * @Author LL
 * @Date 2020-03-22 19:35
 */
@SpringBootTest
@RunWith(SpringRunner.class)
public class LambdaTest {

    @Autowired
    private UserMapper userMapper;

    /**
     * lambda条件构造器
     */
    @Test
    public void selectLambda(){
        //Lamdba条件构造器创建方式
//        LambdaQueryWrapper<User> lambda = new QueryWrapper<User>().lambda();//方式一
//        LambdaQueryWrapper<User> lambdaWrapper = new LambdaQueryWrapper<>();//方式二
        LambdaQueryWrapper<User> lambdaQuery = Wrappers.lambdaQuery();//方式三
        lambdaQuery.like(User::getName, "雨")
                .lt(User::getAge, 40);
        List<User> users = userMapper.selectList(lambdaQuery);
        users.forEach(System.out::println);
    }

    /**
     * （年龄小于40或邮箱不为空）并且名字为王姓
     * (age<40 or email is not null) and name like '王%'
     */
    @Test
    public void selectLambda2(){
        LambdaQueryWrapper<User> lambdaQuery = Wrappers.lambdaQuery();
        lambdaQuery.nested(wq->wq.lt(User::getAge, 40).or().isNotNull(User::getEmail))
                .likeRight(User::getName, "王");
        List<User> users = userMapper.selectList(lambdaQuery);
        users.forEach(System.out::println);
    }

    /**
     * 直接使用userMapper接口创建
     */
    @Test
    public void selectLambda3(){
        List<User> users = new LambdaQueryChainWrapper<>(userMapper)
                .like(User::getName, "雨").ge(User::getAge, 20).list();
        users.forEach(System.out::println);
    }
}
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 206,968评论 6赞 482
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 88,601评论 2赞 382
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 153,220评论 0赞 344
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 55,416评论 1赞 279
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 64,425评论 5赞 374
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 49,144评论 1赞 285
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 38,432评论 3赞 401
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 37,088评论 0赞 261
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 43,586评论 1赞 300
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 36,028评论 2赞 325
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,137评论 1赞 334
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,783评论 4赞 324
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 39,343评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,333评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,559评论 1赞 262
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 45,595评论 2赞 355
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,901评论 2赞 345

推荐阅读更多精彩内容