基本查询

  1.     /**
  2.      * id=?
  3.      */
  4.     @Test
  5.     void selectById() {
  6.         User user = mapper.selectById(1087982257332887553L);
  7.         System.out.println(user);
  8.     }
  10.     /**
  11.      * id IN ( ? , ? , ? )
  12.      */
  13.     @Test
  14.     void retrieveByIds() {
  15.         List<User> users = mapper.selectBatchIds(Arrays.asList(8, 9, 10));
  16.         users.forEach(System.out::println);
  17.     }
  19.     /**
  20.      * 根据map查询,key为column,value为具体的值
  21.      * name = ? AND age = ?
  22.      */
  23.     @Test
  24.     void retrieveByMap() {
  25.         Map<String, Object> map = new HashMap<>();
  26.         map.put("name", "大boss");
  27.         map.put("age", "40");
  28.         List<User> users = mapper.selectByMap(map);
  29.         users.forEach(System.out::println);
  30.     }

条件构造器查询

  1.     /**
  2.      * 名字中包含雨并且年龄小于40
  3.      * name like '%雨%' and age<40
  4.      */
  5.     @Test
  6.     void selectByWrapper1() {
  7.         QueryWrapper<User> wrapper = new QueryWrapper<>();
  8.         wrapper.like("name", "雨")
  9.                 .lt("age", 40);
  10.         List<User> users = mapper.selectList(wrapper);
  11.         users.forEach(System.out::println);
  12.     }
  14.     /**
  15.      * 名字中包含雨年并且龄大于等于20且小于等于40并且email不为空
  16.      * name like '%雨%' and age between 20 and 40 and email is not null
  17.      */
  18.     @Test
  19.     void selectByWrapper2() {
  20.         QueryWrapper<User> wrapper = new QueryWrapper<>();
  21.         wrapper.like("name", "雨")
  22.                 .between("age", 20, 40)
  23.                 .isNotNull("email");
  24.         List<User> users = mapper.selectList(wrapper);
  25.         users.forEach(System.out::println);
  26.     }
  28.     /**
  29.      * 名字为王姓或者年龄大于等于25，按照年龄降序排列，年龄相同按照id升序排列
  30.      * name like '王%' or age>=25 order by age desc,id asc
  31.      */
  32.     @Test
  33.     void selectByWrapper3() {
  34.         QueryWrapper<User> wrapper = new QueryWrapper<>();
  35.         wrapper.likeRight("name", "王")
  36.                 .or().ge("age", 25)
  37.                 .orderByDesc("age")
  38.                 .orderByAsc("id");
  39.         List<User> users = mapper.selectList(wrapper);
  40.         users.forEach(System.out::println);
  41.     }
  43.     /**
  44.      * 创建日期为2019年2月14日并且直属上级为名字为王姓
  45.      * date_format(create_time,'%Y-%m-%d')='2019-02-14' and
  46.      * manager_id in (select id from user where name like '王%')
  47.      */
  48.     @Test
  49.     void selectByWrapper4() {
  50.         QueryWrapper<User> wrapper = new QueryWrapper<>();
  51.         wrapper.apply("date_format(create_time,'%Y-%m-%d')={0}", "2019-02-14")
  52.                 .inSql("manager_id", "select id from user where name like '王%'");
  53.         List<User> users = mapper.selectList(wrapper);
  54.         users.forEach(System.out::println);
  55.     }
  58.     /**
  59.      * and中传入lambda
  60.      * <p>
  61.      * 名字为王姓并且（年龄小于40或邮箱不为空）
  62.      * name like '王%' and (age<40 or email is not null)
  63.      */
  64.     @Test
  65.     void selectByWrapper5() {
  66.         QueryWrapper<User> wrapper = new QueryWrapper<>();
  67.         wrapper.likeRight("name", "王").
  68.                 and(wq -> wq.lt("age", 40)
  69.                         .or().isNotNull("email"));
  70.         List<User> users = mapper.selectList(wrapper);
  71.         users.forEach(System.out::println);
  72.     }
  74.     /**
  75.      * 名字为王姓或者（年龄小于40并且年龄大于20并且邮箱不为空）
  76.      * name like '王%' or (age<40 and age>20 and email is not null)
  77.      */
  78.     @Test
  79.     void selectByWrapper6() {
  80.         QueryWrapper<User> wrapper = new QueryWrapper<>();
  81.         wrapper.likeRight("name", "王").
  82.                 or(wq -> wq.lt("age", 40)
  83.                         .gt("age", 20)
  84.                         .isNotNull("email"));
  85.         List<User> users = mapper.selectList(wrapper);
  86.         users.forEach(System.out::println);
  87.     }
  89.     /**
  90.      * （ 年龄小于40或邮箱不为空）并且名字为王姓
  91.      * (age<40 or email is not null) and name like '王%'
  92.      */
  93.     @Test
  94.     void selectByWrapper7() {
  95.         QueryWrapper<User> wrapper = new QueryWrapper<>();
  96.         wrapper.nested(wq -> wq.lt("age", 40)
  97.                 .or().isNotNull("email"))
  98.                 .likeRight("name", "王");
  99.         List<User> users = mapper.selectList(wrapper);
  100.         users.forEach(System.out::println);
  101.     }
  104.     /**
  105.      * 年龄为30、31、34、35
  106.      */
  107.     @Test
  108.     void selectByWrapper8() {
  109.         QueryWrapper<User> wrapper = new QueryWrapper<>();
  110.         wrapper.in("age", Arrays.asList(30, 31, 34, 35));
  111.         List<User> users = mapper.selectList(wrapper);
  112.         users.forEach(System.out::println);
  113.     }
  115.     /**
  116.      * 只返回满足条件的其中一条语句即可  limit 1
  117.      */
  118.     @Test
  119.     void selectByWrapper9() {
  120.         QueryWrapper<User> wrapper = new QueryWrapper<>();
  121.         wrapper.in("age", Arrays.asList(30, 31, 34, 35)).last("limit 1");
  122.         List<User> users = mapper.selectList(wrapper);
  123.         users.forEach(System.out::println);
  124.     }

指定列与排除列

  1.     /**
  2.      * 查询指定列
  3.      * SELECT id,name FROM user WHERE (name LIKE ?)
  4.      */
  5.     @Test
  6.     void selectPart1() {
  7.         QueryWrapper<User> wrapper = new QueryWrapper<>();
  8.         wrapper.select("id", "name").like("name", "雨");
  9.         List<User> users = mapper.selectList(wrapper);
  10.         users.forEach(System.out::println);
  11.     }
  13.     /**
  14.      * 排除指定列
  15.      * SELECT id,name,age,manager_id FROM user WHERE (name LIKE ?)
  16.      */
  17.     @Test
  18.     void selectPart2() {
  19.         QueryWrapper<User> wrapper = new QueryWrapper<>();
  20.         wrapper.select(User.class, info -> !info.getColumn().equals("create_time") &&
  21.                 !info.getColumn().equals("email")
  22.         ).like("name", "雨");
  23.         List<User> users = mapper.selectList(wrapper);
  24.         users.forEach(System.out::println);
  25.     }

Condition处理参数 拼接动态语句

  1.     @Test
  2.     void testCondition(){
  3.         String name = "王";
  4.         String email = "";
  5.         //withOutCondition(name,email);
  6.         withCondition(name,email);
  7.     }
  9.     private void withOutCondition(String name,String email){
  10.         QueryWrapper<User> wrapper = new QueryWrapper<>();
  11.         if(StringUtils.isNotBlank(name)){
  12.             wrapper.like("name",name);
  13.         }
  14.         if(StringUtils.isNotBlank(email)){
  15.             wrapper.like("email",email);
  16.         }
  17.         List<User> users = mapper.selectList(wrapper);
  18.         users.forEach(System.out::println);
  19.     }
  20.     private void withCondition(String name,String email){
  21.         QueryWrapper<User> wrapper = new QueryWrapper<>();
  22.         wrapper.like(StringUtils.isNotBlank(name),"name",name)
  23.                 .like(StringUtils.isNotBlank(email),"email",email);
  24.         List<User> users = mapper.selectList(wrapper);
  25.         users.forEach(System.out::println);
  26.     }

以实体作为参数

  1.     /**
  2.      * WHERE name=? AND age=?
  3.      * 以实体为参数 和普通设置参数 互不干扰, 都会存在, 使用时需慎重
  4.      * 以实体为参数,默认是等值的,需要使用@TableField注解,并注明sqlCondition
  5.      */
  6.     @Test
  7.     void selectByWrapperEntity(){
  8.         User user = new User();
  9.         user.setName("天乔巴夏");
  10.         user.setAge(20);
  11.         QueryWrapper<User> wrapper = new QueryWrapper<>(user);
  12.         List<User> users = mapper.selectList(wrapper);
  13.         users.forEach(System.out::println);
  14.     }
  17.     @TableField(value = "name",condition = SqlCondition.LIKE) //指定字段名
  18.     private String name;

AllEq的使用

  1.     @Test
  2.     void selectByWrapperAllEq(){
  3.         QueryWrapper<User> wrapper = new QueryWrapper<>();
  4.         Map<String,Object> params = new HashMap<>();
  5.         params.put("name","天乔巴夏");
  6.         params.put("age",null); // age is null , 可以通过 下面这句设置 false
  7.         wrapper.allEq(params,false);
  8.         List<User> users = mapper.selectList(wrapper);
  9.         users.forEach(System.out::println);
  10.     }
  12.     @Test
  13.     void selectByWrapperAllEq2() {
  14.         QueryWrapper<User> wrapper = new QueryWrapper<>();
  15.         Map<String, Object> params = new HashMap<>();
  16.         params.put("name", "天乔巴夏");
  17.         params.put("age", null); // age is null , 可以通过 下面这句设置 false
  18.         wrapper.allEq((k, v) -> !k.equals("name"), params, false);
  19.         List<User> users = mapper.selectList(wrapper);
  20.         users.forEach(System.out::println);
  21.     }

自定义查询

注解形式

  1. public interface UserMapper extends BaseMapper<User> {
  3.     @Select("select * from user ${ew.customSqlSegment}")
  4.     List<User>  selectAll(@Param(Constants.WRAPPER)Wrapper<User> wrapper);
  6. }
  8.     /**
  9.      * 测试自定义方法 注解
  10.      */
  11.     @Test
  12.     void selectByCustomAnno(){
  13.         QueryWrapper<User> wrapper = new QueryWrapper<>();
  14.         wrapper.eq("name","天乔巴夏");
  15.         List<User> users = mapper.selectAll(wrapper);
  16.         users.forEach(System.out::println);
  17.     }

xml形式

  1. public interface UserMapper extends BaseMapper<User> {
  3.     List<User>  selectAll2(@Param(Constants.WRAPPER)Wrapper<User> wrapper);
  5. }
  6. <?xml version="1.0" encoding="UTF-8"?>
  7. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  8. <mapper namespace="com.hyh.mybatisplus.mapper.UserMapper">
  10.     <select id="selectAll2" resultType="com.hyh.mybatisplus.entity.User">
  11.         select * from user ${ew.customSqlSegment}
  12.     </select>
  13. </mapper>

其他的查询

  1.     /**
  2.      * 优雅返回指定字段的结果
  3.      */
  4.     @Test
  5.     void selectByWrapperMaps1() {
  6.         QueryWrapper<User> wrapper = new QueryWrapper<>();
  7.         wrapper.like("name", "雨")
  8.                 .lt("age", 40)
  9.         .select("id","name");
  10.         List<Map<String, Object>> mapList = mapper.selectMaps(wrapper);
  11.         mapList.forEach(System.out::println);
  12.     }
  15.     /**
  16.      * 按照直属上级分组，查询每组的平均年龄、最大年龄、最小年龄。
  17.      * 并且只取年龄总和小于500的组。
  18.      *
  19.      * select avg(age) avg_age,min(age) min_age,max(age) max_age
  20.      * from user
  21.      * group by manager_id
  22.      * having sum(age) <500
  23.      */
  24.     @Test
  25.     void selectByWrapperMaps2() {
  26.         QueryWrapper<User> wrapper = new QueryWrapper<>();
  27.         wrapper.select("avg(age) avg_age","min(age) min_age","max(age) max_age")
  28.                 .groupBy("manager_id").having("sum(age)<{0}",500);
  29.         List<Map<String, Object>> mapList = mapper.selectMaps(wrapper);
  30.         mapList.forEach(System.out::println);
  31.     }
  34.     /**
  35.      * 查个数
  36.      */
  37.     @Test
  38.     void selectCount() {
  39.         QueryWrapper<User> wrapper = new QueryWrapper<>();
  40.         wrapper.like("name","雨");
  41.         Integer cnt = mapper.selectCount(wrapper);
  42.         System.out.println(cnt);
  43.     }
  45.     /**
  46.      * 查一个实体
  47.      */
  48.     @Test
  49.     void selectOne(){
  50.         QueryWrapper<User> wrapper = new QueryWrapper<>();
  51.         wrapper.eq("name","天乔巴夏");
  52.         User user = mapper.selectOne(wrapper);
  53.         System.out.println(user);
  54.     }
  56.     /**
  57.      * lambda构造,编译时检查字段信息,防止误写
  58.      */
  59.     @Test
  60.     void selectLambda(){
  61.         //LambdaQueryWrapper<User> lambda = new QueryWrapper<User>().lambda();
  62.         //LambdaQueryWrapper<User> lambdaQueryWrapper = new LambdaQueryWrapper<>();
  63.         LambdaQueryWrapper<User> lambdaQuery = Wrappers.<User>lambdaQuery();
  64.         lambdaQuery.like(User::getName,"雨").lt(User::getAge,40);
  65.         // where name like '%雨%'
  66.         List<User> users = mapper.selectList(lambdaQuery);
  67.         users.forEach(System.out::println);
  68.     }

Mybatis Plus各种查询方法

  1. package com.xiao.permission_system;
  3. import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
  4. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
  5. import com.baomidou.mybatisplus.extension.service.additional.query.impl.LambdaQueryChainWrapper;
  6. import com.mysql.cj.util.StringUtils;
  7. import com.xiao.permission_system.entity.UserInfo;
  8. import com.xiao.permission_system.mapper.UserInfoMapper;
  9. import org.junit.Test;
  10. import org.junit.runner.RunWith;
  11. import org.springframework.beans.factory.annotation.Autowired;
  12. import org.springframework.boot.test.context.SpringBootTest;
  13. import org.springframework.test.context.junit4.SpringRunner;
  15. import java.util.Arrays;
  16. import java.util.HashMap;
  17. import java.util.List;
  18. import java.util.Map;;
  20. @RunWith(SpringRunner.class)
  21. @SpringBootTest
  22. public class PermissionSystemApplicationTests {
  24.     @Test
  25.     public void contextLoads() {
  26.     }
  28.     @Autowired
  29.     private UserInfoMapper userInfoMapper;
  31.     /**
  32.      * 普通查询
  33.      */
  34.     @Test
  35.     public void selectById() {
  36.         UserInfo userInfo = userInfoMapper.selectById(123);
  37.         System.out.println(userInfo);
  38.     }
  40.     /**
  41.      * 批量查询
  42.      */
  43.     @Test
  44.     public void selectByIds() {
  45.         List<Long> ids = Arrays.asList(123L,124L,125L);
  46.         List<UserInfo> userInfo = userInfoMapper.selectBatchIds(ids);
  47.         System.out.println(userInfo);
  48.     }
  50.     /**
  51.      * 名字包含娟并且年龄小雨30
  52.      */
  53.     @Test
  54.     public void selectByWrapper() {
  55.         QueryWrapper<UserInfo> queryWrapper = new QueryWrapper<UserInfo>();
  56.         queryWrapper.like("username","娟").lt("age",30);
  57.         List<UserInfo> userInfoList = userInfoMapper.selectList(queryWrapper);
  58.         userInfoList.forEach(System.out::println);
  59.     }
  60.     /**
  61.      * 名字包含娟并且年龄大雨等于20且小于等于40并且email不为空
  62.      */
  63.     @Test
  64.     public void selectByWrapper2() {
  65.         QueryWrapper<UserInfo> queryWrapper = new QueryWrapper<UserInfo>();
  66.         queryWrapper.like("username","娟").between("age",20,30).isNotNull("email");
  67.         List<UserInfo> userInfoList = userInfoMapper.selectList(queryWrapper);
  68.         userInfoList.forEach(System.out::println);
  69.     }
  71.     /**
  72.      * 名字姓肖或者年量大雨等于20，按照年龄降序排列，年龄相同按照id生序排列
  73.      */
  74.     @Test
  75.     public void selectByWrapper3() {
  76.         QueryWrapper<UserInfo> queryWrapper = new QueryWrapper<UserInfo>();
  77.         queryWrapper.likeRight("username","肖")
  78.                 .or().ge("age",20).orderByDesc("age").orderByAsc("id");
  79.         List<UserInfo> userInfoList = userInfoMapper.selectList(queryWrapper);
  80.         userInfoList.forEach(System.out::println);
  81.     }
  83.     /**
  84.      * 创建日期为2019年10月2日并且直属上级名字为王姓
  85.      */
  86.     @Test
  87.     public void selectByWrapper4() {
  88.         QueryWrapper<UserInfo> queryWrapper = new QueryWrapper<UserInfo>();
  89.         queryWrapper.apply("date_format(create_time,'%Y-%m-%d')={0}","2019-10-07")
  90.                 .inSql("parent_id","select id from user where username like '王%'");
  91.         List<UserInfo> userInfoList = userInfoMapper.selectList(queryWrapper);
  92.         userInfoList.forEach(System.out::println);
  93.     }
  95.     /**
  96.      * 名字为王姓并且（年龄小于40或邮箱不为空）
  97.      */
  98.     @Test
  99.     public void selectByWrapper5() {
  100.         QueryWrapper<UserInfo> queryWrapper = new QueryWrapper<UserInfo>();
  101.         queryWrapper.likeRight("username","王")
  102.                 .and(wq->wq.lt("age",40))
  103.                 .or().isNotNull("email");
  104.         List<UserInfo> userInfoList = userInfoMapper.selectList(queryWrapper);
  105.         userInfoList.forEach(System.out::println);
  106.     }
  107.     /**
  108.      * 名字为王姓并且（年龄小于40并且大与20或邮箱不为空）
  109.      */
  110.     @Test
  111.     public void selectByWrapper6() {
  112.         QueryWrapper<UserInfo> queryWrapper = new QueryWrapper<UserInfo>();
  113.         queryWrapper.likeRight("username","王")
  114.                 .and(wq->wq.lt("age",40).gt("age",20))
  115.                 .or().isNotNull("email");
  116.         List<UserInfo> userInfoList = userInfoMapper.selectList(queryWrapper);
  117.         userInfoList.forEach(System.out::println);
  118.     }
  119.     /**
  120.      * （年龄小于40并且大与20或邮箱不为空）名字为王姓并且
  121.      */
  122.     @Test
  123.     public void selectByWrapper7() {
  124.         QueryWrapper<UserInfo> queryWrapper = new QueryWrapper<UserInfo>();
  125.         queryWrapper.nested(wq->wq.lt("age",40))
  126.                 .or().isNotNull("email")
  127.                 .likeRight("username","王");
  128.         List<UserInfo> userInfoList = userInfoMapper.selectList(queryWrapper);
  129.         userInfoList.forEach(System.out::println);
  130.     }
  131.     /**
  132.      * 年龄23，30，40
  133.      */
  134.     @Test
  135.     public void selectByWrapper8() {
  136.         QueryWrapper<UserInfo> queryWrapper = new QueryWrapper<UserInfo>();
  137.         queryWrapper.in("age",Arrays.asList(20,30,40));
  138.         List<UserInfo> userInfoList = userInfoMapper.selectList(queryWrapper);
  139.         userInfoList.forEach(System.out::println);
  140.     }
  141.     /**
  142.      * 只返回满足条件的其中一条语句即可
  143.      */
  144.     @Test
  145.     public void selectByWrapper9() {
  146.         QueryWrapper<UserInfo> queryWrapper = new QueryWrapper<UserInfo>();
  147.         queryWrapper.in("age",Arrays.asList(20,30,40)).last("limit 1");
  148.         List<UserInfo> userInfoList = userInfoMapper.selectList(queryWrapper);
  149.         userInfoList.forEach(System.out::println);
  150.     }
  152.     /**
  153.      * 名字中包含雨并且年龄小于40(只取id,username)
  154.      */
  155.     @Test
  156.     public void selectByWrapper10() {
  157.         QueryWrapper<UserInfo> queryWrapper = new QueryWrapper<UserInfo>();
  158.         queryWrapper.select("id","username").like("username","雨").lt("age",40);
  159.         List<UserInfo> userInfoList = userInfoMapper.selectList(queryWrapper);
  160.         userInfoList.forEach(System.out::println);
  161.     }
  163.     /**
  164.      * 名字中包含雨并且年龄小于40(不取create_time,parent_id两个字段,即不列出全部字段)
  165.      */
  166.     @Test
  167.     public void selectByWrapper11() {
  168.         QueryWrapper<UserInfo> queryWrapper = new QueryWrapper<UserInfo>();
  169.         queryWrapper.like("username","雨").lt("age",40)
  170.                     .select(UserInfo.class,info->!info.getColumn().equals("create_time")&&
  171.                             !info.getColumn().equals("parent_id"));
  172.         List<UserInfo> userInfoList = userInfoMapper.selectList(queryWrapper);
  173.         userInfoList.forEach(System.out::println);
  174.     }
  176.     /**
  177.      * 姓名和邮箱不为空
  178.      */
  179.     public void testCondition() {
  180.         String username = "王";
  181.         String email = "";
  182.         condition(username,email);
  183.     }
  185.     private void condition(String username,String email){
  186.         QueryWrapper<UserInfo> queryWrapper = new QueryWrapper<UserInfo>();
  187.         queryWrapper.like(StringUtils.isNullOrEmpty(username),"name",username)
  188.                     .like(StringUtils.isNullOrEmpty(email),"email",email);
  189.         List<UserInfo> userInfoList = userInfoMapper.selectList(queryWrapper);
  190.         userInfoList.forEach(System.out::println);
  191.     }
  193.     /**
  194.      * 实体作为条件构造器方法的参数
  195.      */
  196.     @Test
  197.     public void selectByWrapperEntity() {
  198.         UserInfo whereUser = new UserInfo();
  199.         whereUser.setUsername("xiaojuan");
  200.         whereUser.setAge(22);
  201.         QueryWrapper<UserInfo> queryWrapper = new QueryWrapper<UserInfo>(whereUser);
  202.         List<UserInfo> userInfoList = userInfoMapper.selectList(queryWrapper);
  203.         userInfoList.forEach(System.out::println);
  204.     }
  205.     /**
  206.      * AllEq用法
  207.      */
  208.     @Test
  209.     public void selectByWrapperAllEq() {
  210.         QueryWrapper<UserInfo> queryWrapper = new QueryWrapper<UserInfo>();
  211.         Map<String, Object> params = new HashMap<String, Object>();
  212.         params.put("nuserame","xiaojuan");
  213.         params.put("age",null);
  214.         queryWrapper.allEq(params);
  215.         List<UserInfo> userInfoList = userInfoMapper.selectList(queryWrapper);
  216.         userInfoList.forEach(System.out::println);
  217.     }
  219.     /**
  220.      * AllEq用法(排除不是条件的字段)
  221.      */
  222.     @Test
  223.     public void selectByWrapperAllEq2() {
  224.         QueryWrapper<UserInfo> queryWrapper = new QueryWrapper<UserInfo>();
  225.         Map<String, Object> params = new HashMap<String, Object>();
  226.         params.put("nuserame","xiaojuan");
  227.         params.put("age",null);
  228.         queryWrapper.allEq((k,v)->!k.equals("name"),params);
  229.         List<UserInfo> userInfoList = userInfoMapper.selectList(queryWrapper);
  230.         userInfoList.forEach(System.out::println);
  231.     }
  233.     /**
  234.      * selectMaps
  235.      */
  236.     @Test
  237.     public void selectByWrapperMaps() {
  238.         QueryWrapper<UserInfo> queryWrapper = new QueryWrapper<UserInfo>();
  239.         queryWrapper.like("name","肖").lt("age",40);
  240.         List<Map<String,Object>> userInfoList = userInfoMapper.selectMaps(queryWrapper);
  241.         userInfoList.forEach(System.out::println);
  242.     }
  244.     /**
  245.      * 按照直属上级分组，查询每组的平均年龄，最大年龄，最小年龄。并且只取年龄总和小于500的组
  246.      */
  247.     @Test
  248.     public void selectByWrapperMaps2() {
  249.         QueryWrapper<UserInfo> queryWrapper = new QueryWrapper<UserInfo>();
  250.         queryWrapper.select("avg(age) avg_age","min(min) min_age","max(age) max_age")
  251.                 .groupBy("parent_id").having("sum(age)<{0}",500);
  252.         List<Map<String,Object>> userInfoList = userInfoMapper.selectMaps(queryWrapper);
  253.         userInfoList.forEach(System.out::println);
  254.     }
  256.     /**
  257.      * selectObjs
  258.      */
  259.     @Test
  260.     public void selectByWrapperObjs() {
  261.         QueryWrapper<UserInfo> queryWrapper = new QueryWrapper<UserInfo>();
  262.         queryWrapper.select("id","name").like("name","肖").lt("age",40);
  263.         List<Object> userInfoList = userInfoMapper.selectObjs(queryWrapper);
  264.         userInfoList.forEach(System.out::println);
  265.     }
  267.     /**
  268.      * selectCount
  269.      */
  270.     @Test
  271.     public void selectByWrapperCount() {
  272.         QueryWrapper<UserInfo> queryWrapper = new QueryWrapper<UserInfo>();
  273.         queryWrapper.like("name","肖").lt("age",40);
  274.         Integer count = userInfoMapper.selectCount(queryWrapper);
  275.         System.out.println(count);
  276.     }
  278.     /**
  279.      * selectOne
  280.      */
  281.     @Test
  282.     public void selectByWrapperSelectOne() {
  283.         QueryWrapper<UserInfo> queryWrapper = new QueryWrapper<UserInfo>();
  284.         queryWrapper.like("name","肖").lt("age",40);
  285.         UserInfo user = userInfoMapper.selectOne(queryWrapper);
  286.         System.out.println(user);
  287.     }
  289.     /**
  290.      * 使用Lambda
  291.      */
  292.     @Test
  293.     public void selectLambda() {
  294.        // LambdaQueryWrapper<UserInfo> lambda = new QueryWrapper<UserInfo>().lambda();
  295.         LambdaQueryWrapper<UserInfo> lambda = new LambdaQueryWrapper<UserInfo>();
  296.         lambda.like(UserInfo::getUsername,"娟").lt(UserInfo::getAge,40);
  297.         List<UserInfo> userInfoList = userInfoMapper.selectList(lambda);
  298.         userInfoList.forEach(System.out::println);
  299.     }
  301.     /**
  302.      * 使用Lambda,名字为王姓（年龄小于40或邮箱不为空）
  303.      */
  304.     @Test
  305.     public void selectLambd2() {
  306.         LambdaQueryWrapper<UserInfo> lambda = new LambdaQueryWrapper<UserInfo>();
  307.         lambda.like(UserInfo::getUsername,"娟")
  308.                 .and(lqw->lqw.lt(UserInfo::getAge,40).or().isNotNull(UserInfo::getEmail));
  309.         List<UserInfo> userInfoList = userInfoMapper.selectList(lambda);
  310.         userInfoList.forEach(System.out::println);
  311.     }
  313.     /**
  314.      * 使用Lambda链式
  315.      */
  316.     @Test
  317.     public void selectLambd3() {
  318.         List<UserInfo> userInfoList = new LambdaQueryChainWrapper<UserInfo>(userInfoMapper)
  319.                 .like(UserInfo::getUsername,"娟").ge(UserInfo::getAge,20).list();
  320.         userInfoList.forEach(System.out::println);
  321.     }
  322. }