mybatis plus

// 根据 ID 查询
T selectById(Serializable id);
// 根据 entity 条件，查询一条记录
T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
 
// 查询（根据ID 批量查询）
List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
// 根据 entity 条件，查询全部记录
List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 查询（根据 columnMap 条件）
List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
// 根据 Wrapper 条件，查询全部记录
List<Map<String, Object>> selectMaps(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询全部记录。注意： 只返回第一个字段的值
List<Object> selectObjs(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
 
// 根据 entity 条件，查询全部记录（并翻页）
IPage<T> selectPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询全部记录（并翻页）
IPage<Map<String, Object>> selectMapsPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
// 根据 Wrapper 条件，查询总记录数
Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

mybatis-plus查询

package com.sen.MybatisPlus.MybatisPlus;
 
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.sen.MybatisPlus.MybatisPlus.entity.User;
import com.sen.MybatisPlus.MybatisPlus.mapper.UserMapper;
import org.junit.jupiter.api.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;
import java.util.Map;
 
@RunWith(SpringRunner.class)
@SpringBootTest
class MybatisPlusApplicationTests {
 
    @Autowired
    private UserMapper userMapper;
 
    /**
     * 查询所有数据
     * UserMapper 中的 selectList() 方法的参数
     * 为 MP 内置的条件封装器 Wrapper，所以不填写就是无任何条件（条件构造器）
     */
    @Test
    public void selectList() {
        List<User> list = userMapper.selectList(null);
        list.forEach(System.out::println);
    }
 
    /**
     * 根据 entity 条件，查询一条记录
     * 其实 QueryWrapper 条件构造器（相当于给SQL的条件语句）
     * selectOne() 方法查询必须有且只能查询一条记录，多一条会报错。
     */
    @Test
    public void selectOne() {
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        //查询名字为 Tom 的一条记录
        queryWrapper.eq("name","Tom");
        User user = userMapper.selectOne(queryWrapper);
        System.out.println(user);
    }
 
    /**
     * 根据主键ID查询数据
     * 查询主键id=2 的一条数据，只能查询一个主键的数据不能多个
     */
    @Test
    public void selectById() {
        User user = userMapper.selectById(2);
        System.out.println(user);
    }
 
    /**
     * 根据 List 的 ID 集合 查询对应的用户list
     */
    @Test
    public void selectBatchIds() {
        List<User> list = userMapper.selectBatchIds(Arrays.asList(5, 3, 1));
        list.forEach(System.out::println);
    }
 
    /**
     * 查询（根据 columnMap 条件）,查询年龄为20岁的所有记录
     *
     * 注意：建议尽量减少使用map这种方式。
     * 因为可能字段名可能存在修改的情况,
     * 如果，项目开发一段时间后，再修改，影响太大
     */
    @Test
    public void selectByMap() {
        Map<String, Object> map = new HashMap<>();
        map.put("age", "20");
        List<User> list = userMapper.selectByMap(map);
        list.forEach(System.out::println);
    }
 
    /**
     * 查询大于20岁的学生，名称中包含“J”的人，带条件判断的，可以采用这种方式
     * SELECT * FROM user WHERE (name LIKE ? AND age > ?)
     * gt()方法 相当于:大于 > 但没有等于=
     */
    @Test
    public void selectListWrapper() {
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.like("name", "J");//格式：(字段，值）
        queryWrapper.gt("age", "19"); //查询不小于20岁
        List<User> list = userMapper.selectList(queryWrapper);
        list.forEach(System.out::println);
    }
 
    /**
     * 根据 Wrapper 条件，查询全部记录。
     * 查询名字含有 a 的，且年龄大于等于20。
     * ge()方法 相当于: 大于等于 >= 。
     * like()方法  相当于: NOT LIKE '%值%' 。
     */
    @Test
    public void selectMaps(){
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.like("name","a");
        queryWrapper.ge("age","20");
        List<Map<String, Object>> maps = userMapper.selectMaps(queryWrapper);
        maps.forEach(System.out::println);
    }
    
 
    //分页查询需要需要在项目中加入分页插件，下文介绍有-------
    /**
     * 根据 entity 条件，查询全部记录（并翻页）。
     * 查询年龄大于 18 且 小于等于30 岁的所有记录，分 3 条数记录为一页
     * gt()方法 相当于: 大于 > 。
     * le()方法 相当于: 小于等于 <= 。
     */
    @Test
    public void selectPage(){
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        queryWrapper.gt("age","18");
        queryWrapper.le("age","30");
        //第一个参数表示当前页
        //第二个参数表示当前页显示多少条
        //第三个参数是否查询count
        Page<User> page = new Page<>(1,3);
        Page<User> userIPage = userMapper.selectPage(page, queryWrapper);
        List<User> records = userIPage.getRecords();
        records.forEach(System.out::println);
    }
 
 
    /**
     * 根据 Wrapper 条件，查询全部记录（并翻页）
     */
    @Test
    public void selectMapsPage() {
        QueryWrapper<User> query = new QueryWrapper<User>();
        //第一个参数表示当前页
        //第二个参数表示当前页显示多少条
        Page<Map<String, Object>> page = new Page<>(2, 3);
        Page<Map<String, Object>> maps = userMapper.selectMapsPage(page, query);
        maps.getRecords().forEach(System.out::println);
 
    }
 
 
    /**
     * 根据 Wrapper 条件，查询总记录数
     * 查询一共有多少条数据记录
     */
    @Test
    public void selectCount(){
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        Integer count = userMapper.selectCount(queryWrapper);
        System.out.printf("一共有" + String.valueOf(count) + "条记录");
    }
 
}
 

@Test
    public void testCommonSelect() {
        // 根据ID查询
        AuthUser authUser1 = authUserDao.selectById(1);
        System.out.println(authUser1);
        // 根据条件查询
        QueryWrapper<AuthUser> queryWrapper = new QueryWrapper<AuthUser>();
        queryWrapper.eq("username", "hehe");
        AuthUser authUser2 = authUserDao.selectOne(queryWrapper);
        System.out.println(authUser2);
        // 查询数量
        Integer integer = authUserDao.selectCount(null);
        System.out.println("总个数：" + integer);
        Map map = new HashMap();
        map.put("username", "hello");
        List list = authUserDao.selectByMap(map);
        System.out.println(list);
        // 查询全部
        List<AuthUser> authUsers = authUserDao.selectList(null);
        System.out.println("查询全部list：" + authUsers);
        QueryWrapper queryWrapper1 = new QueryWrapper();
        // 查询某字段
        queryWrapper1.select("username");
        List<Map<String, Object>> maps = authUserDao.selectMaps(queryWrapper1);
        System.out.println("查询全部maps：" + maps);
        List<String> list1 = new ArrayList<>();
        list1.add("1");
        list1.add("2");
        List<Integer> integers = Arrays.asList(2);
        List<AuthUser> authUsers1 = authUserDao.selectBatchIds(integers);
        System.out.println("selectBatchIds: " + authUsers1);
        QueryWrapper queryWrapper2 = new QueryWrapper();
        queryWrapper2.select("username");
        List selectObjs = authUserDao.selectObjs(queryWrapper2);
        System.out.println("selectObjs: " + selectObjs);
        QueryWrapper<AuthUser> queryWrapper3 = new QueryWrapper<>();
        queryWrapper.gt("id", "2");
//        queryWrapper.le("age","30");
        //第一个参数表示当前页
        //第二个参数表示当前页显示多少条
        //第三个参数是否查询count
        Page<AuthUser> page = new Page<>(1, 10);
        Page<AuthUser> selectPage = authUserDao.selectPage(page, queryWrapper);
        List<AuthUser> records = selectPage.getRecords();
        String countId = selectPage.getCountId();
        Long maxLimit = selectPage.getMaxLimit();
        List<OrderItem> orders = selectPage.getOrders();
        long size = selectPage.getSize();
        long total = selectPage.getTotal();
        System.out.println("selectPage countId:" + countId
                + ", maxLimit:" + maxLimit + ", orders:" + orders
                + ", size:" + size + ", total:" + total + ", records:" + records);
        QueryWrapper<AuthUser> query = new QueryWrapper<AuthUser>();
        //第一个参数表示当前页
        //第二个参数表示当前页显示多少条
        Page<Map<String, Object>> page2 = new Page<>(1, 10);
        Page<Map<String, Object>> mapss = authUserDao.selectMapsPage(page2, query);
        for (Map<String, Object> stringObjectMap : mapss.getRecords()) {
            System.out.println("stringObjectMap: "+stringObjectMap);
        }
    }