springboot+mybatis-plus条件构造器示例

最新推荐文章于 2024-05-20 15:45:19 发布
最新推荐文章于 2024-05-20 15:45:19 发布
阅读量1.2k 收藏 1
点赞数
分类专栏： spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/i168wintop/article/details/94598222
版权

package com.xibei.mp.user;

import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.additional.query.impl.LambdaQueryChainWrapper;
import com.baomidou.mybatisplus.extension.service.additional.update.impl.LambdaUpdateChainWrapper;
import com.lord.mp.MpApplicationTests;
import com.lord.mp.dao.UserMapper;
import com.lord.mp.entity.User;

public class UserTest extends MpApplicationTests {

    @Autowired
    private UserMapper userMapper;

    @Test
    public void insert() {
        User user = new User();
        user.setName("张无忌");
        user.setAge(30);
        user.setManagerId(1088248166370832385L);
        user.setCreateTime(new Date());
        int rows = userMapper.insert(user);
        System.out.println("影响记录数：" + rows);
    }

    // @Test
    public void updateById() {
        User user = new User();
        user.setId(1134013564424658946L);
        user.setEmail("zwj@baomidou.com");
        int rows = userMapper.updateById(user);
        System.out.println("影响记录数：" + rows);
    }

    // @Test
    public void updateByWrapper1() {
        UpdateWrapper<User> userWrapper = Wrappers.update();
        userWrapper.eq("name", "李艺伟").eq("age", 28);

        User user = new User();
        user.setEmail("lyw2019@baomidou.com");
        user.setAge(29);

        int rows = userMapper.update(user, userWrapper);
        System.out.println("影响记录数：" + rows);
    }

    // 构造器参数和实体对象参数会重复出现
    // @Test
    public void updateByWrapper2() {
        User userWhere = new User();
        userWhere.setName("李艺伟");

        UpdateWrapper<User> userWrapper = Wrappers.update(userWhere);
        userWrapper.eq("name", "李艺伟").eq("age", 28);

        User user = new User();
        user.setAge(29);

        int rows = userMapper.update(user, userWrapper);
        System.out.println("影响记录数：" + rows);
    }

    // @Test
    public void updateByWrapper3() {
        UpdateWrapper<User> userWrapper = Wrappers.update();
        userWrapper.eq("name", "李艺伟").eq("age", 29).set("age", 30);

        User user = new User();
        user.setAge(29);

        int rows = userMapper.update(null, userWrapper);
        System.out.println("影响记录数：" + rows);
    }

    // @Test
    public void updateByWrapperLambda() {
        LambdaUpdateWrapper<User> lambdaUpdate = Wrappers.lambdaUpdate();
        lambdaUpdate.eq(User::getName, "李艺伟").eq(User::getAge, 30).set(User::getAge, 31);

        int rows = userMapper.update(null, lambdaUpdate);
        System.out.println("影响记录数：" + rows);
    }

    // @Test
    public void updateByWrapperLambdaChain() {
        boolean flag = new LambdaUpdateChainWrapper<User>(userMapper).eq(User::getName, "李艺伟").eq(User::getAge, 31)
                .set(User::getAge, 32).update();

        System.out.println("是否成功：" + flag);
    }

    // @Test
    public void deleteById() {
        int rows = userMapper.deleteById(1134013564424658946L);
        System.out.println("删除条数：" + rows);
    }

    // @Test
    public void deleteByMap() {
        Map<String, Object> columnMap = new HashMap<>();
        columnMap.put("name", "张无忌1");
        columnMap.put("age", 31);

        int rows = userMapper.deleteByMap(columnMap);
        System.out.println("删除条数：" + rows);
    }

    // @Test
    public void deleteBatchByIds() {
        int rows = userMapper.deleteBatchIds(Arrays.asList(1134345992649379841L, 1134346040569274369L));
        System.out.println("删除条数：" + rows);
    }

    @Test
    public void deleteByWrapper() {
        LambdaQueryWrapper<User> lambdaQuery = Wrappers.lambdaQuery();
        lambdaQuery.eq(User::getAge, 27).or().gt(User::getAge, 41);
        int rows = userMapper.delete(lambdaQuery);
        System.out.println("删除条数：" + rows);
    }

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

    // @Test
    public void selectByIds() {
        List<Long> idList = Arrays.asList(1088248166370832385L, 1088250446457389058L, 1094590409767661570L);
        List<User> userList = userMapper.selectBatchIds(idList);
        userList.forEach(System.out::println);
    }

    // @Test
    public void selectByMap() {
        Map<String, Object> paramMap = new HashMap<>();
        paramMap.put("name", "张无忌");
        paramMap.put("age", 31);
        List<User> userList = userMapper.selectByMap(paramMap);
        userList.forEach(System.out::println);
    }

    /**
     * 姓名中含雨并且年龄小于40
     * name like '%雨%' and age < 40
     */
    // @Test
    public void selectByWarpper1() {
        // 条件构造器
        QueryWrapper<User> userQuery = Wrappers.query();
        userQuery.like("name", "雨").lt("age", 40);

        List<User> userList = userMapper.selectList(userQuery);
        userList.forEach(System.out::println);
    }

    /**
     * 姓名中含雨并且年龄大于等于20且小于等于40并且email不为空
     * name like '%雨%' and age between 20 and 40 and email is not null
     */
    // @Test
    public void selectByWarpper2() {
        // 条件构造器
        QueryWrapper<User> userQuery = Wrappers.query();
        userQuery.like("name", "雨").between("age", 20, 40).isNotNull("email");

        List<User> userList = userMapper.selectList(userQuery);
        userList.forEach(System.out::println);
    }

    /**
     * 姓名为王姓或者年龄大于等于25，按照年龄降序排列，年龄相同按照id升序排列
     * name like '王%' or age >= 25 order by age desc,id asc
     */
    @Test
    public void selectByWarpper3() {
        // 条件构造器
        QueryWrapper<User> userQuery = Wrappers.query();
        userQuery.likeRight("name", "王").or().ge("age", 25).orderByDesc("age").orderByAsc("id");

        List<User> userList = userMapper.selectList(userQuery);
        userList.forEach(System.out::println);
    }

    /**
     * 创建时间为2019年2月14日并且直属上级名字为王姓
     * date_format(create_time,'%Y-%m-%d') and manager_id in (select id from user where name like '王%')
     */
    // @Test
    public void selectByWarpper4() {
        // 条件构造器
        QueryWrapper<User> userQuery = Wrappers.query();
        // 此处写法存在sql注入问题，不建议使用
        // userQuery.apply("date_format(create_time,'%Y-%m-%d')='2019-02-14' or true or true").inSql("manager_id",
        // "select id from user where name like '王%'");

        userQuery.apply("date_format(create_time,'%Y-%m-%d')={0}", "2019-02-14").inSql("manager_id",
                "select id from user where name like '王%'");

        List<User> userList = userMapper.selectList(userQuery);
        userList.forEach(System.out::println);
    }

    /**
     * 名字为王姓并且（年龄小于40或邮箱不为空）
     * name like '王%' and (age < 40 or email is not null)
     */
    // @Test
    public void selectByWarpper5() {
        // 条件构造器
        QueryWrapper<User> userQuery = Wrappers.query();
        userQuery.likeRight("name", "王").and(wq -> wq.lt("age", 40).or().isNotNull("email"));

        List<User> userList = userMapper.selectList(userQuery);
        userList.forEach(System.out::println);
    }

    /**
     * 名字为王姓或者（年龄小于40并且大于20并且邮箱不为空）
     * name like '王%' or (age < 40 and age > 20 and email is not null)
     */
    // @Test
    public void selectByWarpper6() {
        // 条件构造器
        QueryWrapper<User> userQuery = Wrappers.query();
        userQuery.likeRight("name", "王").or(wq -> wq.lt("age", 40).gt("age", 20).isNotNull("email"));

        List<User> userList = userMapper.selectList(userQuery);
        userList.forEach(System.out::println);
    }

    /**
     * （年龄小于40或邮箱不为空）并且名字为王姓
     * (age < 40 or email is not null) and name like '王%'
     */
    // @Test
    public void selectByWarpper7() {
        // 条件构造器
        QueryWrapper<User> userQuery = Wrappers.query();
        userQuery.nested(wq -> wq.lt("age", 40).or().isNotNull("email")).likeRight("name", "王");

        List<User> userList = userMapper.selectList(userQuery);
        userList.forEach(System.out::println);
    }

    /**
     * 年龄为30,31,34,35
     * age in (30,31,34,35)
     */
    // @Test
    public void selectByWarpper8() {
        // 条件构造器
        QueryWrapper<User> userQuery = Wrappers.query();
        userQuery.in("age", Arrays.asList(30, 31, 34, 35));

        List<User> userList = userMapper.selectList(userQuery);
        userList.forEach(System.out::println);
    }

    /**
     * 只返回满足条件的其中一条语句即可
     * limit 1
     */
    // @Test
    public void selectByWarpper9() {
        // 条件构造器
        QueryWrapper<User> userQuery = Wrappers.query();
        userQuery.in("age", Arrays.asList(30, 31, 34, 35)).last("limit 1");

        List<User> userList = userMapper.selectList(userQuery);
        userList.forEach(System.out::println);
    }

    /**
     * 姓名中含雨并且年龄小于40(只返回id和name两列)
     * name like '%雨%' and age < 40
     */
    // @Test
    public void selectByWarpper10_1() {
        // 条件构造器
        QueryWrapper<User> userQuery = Wrappers.query();
        userQuery.select("id", "name").like("name", "雨").lt("age", 40);

        List<User> userList = userMapper.selectList(userQuery);
        userList.forEach(System.out::println);
    }

    /**
     * 姓名中含雨并且年龄小于40(只返回id、name、age、email列)
     * name like '%雨%' and age < 40
     */
    // @Test
    public void selectByWarpper10_2() {
        // 条件构造器
        QueryWrapper<User> userQuery = Wrappers.query();
        userQuery.like("name", "雨").lt("age", 40).select(User.class,
                info -> !info.getColumn().equals("create_time") && !info.getColumn().equals("manager_id"));

        List<User> userList = userMapper.selectList(userQuery);
        userList.forEach(System.out::println);
    }

    /**
     * 按照直属上级分组，查询每组的平均年龄、最大年龄、最小年龄。并且只取年龄总和小于500的组
     * select avg(age) avg_age, max(age) max_age, min(age) min_age from user
     * group by manager_id having sum(age) < 500
     */
    // @Test
    public void selectByWarpper11() {
        // 条件构造器
        QueryWrapper<User> userQuery = Wrappers.query();
        userQuery.select("avg(age) avg_age", "max(age) max_age", "min(age) min_age").groupBy("manager_id")
                .having("sum(age) < {0}", 500);

        List<Map<String, Object>> userList = userMapper.selectMaps(userQuery);
        userList.forEach(System.out::println);
    }

    // @Test
    public void selectByWarpperObjs() {
        // 条件构造器
        QueryWrapper<User> userQuery = new QueryWrapper<>();
        userQuery.select("id", "name").like("name", "雨").lt("age", 40);

        List<Object> userList = userMapper.selectObjs(userQuery);
        userList.forEach(System.out::println);
    }

    // @Test
    public void selectByWarpperCount() {
        // 条件构造器
        QueryWrapper<User> userQuery = new QueryWrapper<>();
        userQuery.like("name", "雨").lt("age", 40);

        Integer count = userMapper.selectCount(userQuery);
        System.out.println("总记录数：" + count);
    }

    // @Test
    public void selectByWarpperOne() {
        // 条件构造器
        QueryWrapper<User> userQuery = new QueryWrapper<>();
        userQuery.like("name", "刘红雨").lt("age", 40);

        User user = userMapper.selectOne(userQuery);
        System.out.println(user);
    }

    // @Test
    public void selectByWarpperEntity() {
        User userWhere = new User();
        userWhere.setName("刘红雨");
        userWhere.setAge(32);

        // 条件构造器
        QueryWrapper<User> userQuery = new QueryWrapper<>(userWhere);
        // userQuery.like("name", "雨").lt("age", 40);

        List<User> userList = userMapper.selectList(userQuery);
        userList.forEach(System.out::println);
    }

    // @Test
    public void selectByWarpperAllEq() {
        Map<String, Object> params = new HashMap<>();
        params.put("name", "王天风");
        params.put("age", null);

        // 条件构造器
        QueryWrapper<User> userQuery = new QueryWrapper<>();
        // userQuery.allEq(params, false);
        userQuery.allEq((k, v) -> !k.equals("name"), params);

        List<User> userList = userMapper.selectList(userQuery);
        userList.forEach(System.out::println);
    }

    // @Test
    public void selectByWarpperMaps() {
        // 条件构造器
        QueryWrapper<User> userQuery = new QueryWrapper<>();
        userQuery.select("name", "age").like("name", "雨").lt("age", 40);

        List<Map<String, Object>> userList = userMapper.selectMaps(userQuery);
        userList.forEach(System.out::println);
    }

    // @Test
    public void selectLambda1() {
        // 条件构造器
        LambdaQueryWrapper<User> lambdaQueryWrapper = Wrappers.lambdaQuery();
        lambdaQueryWrapper.like(User::getName, "雨").lt(User::getAge, 40);

        List<User> userList = userMapper.selectList(lambdaQueryWrapper);
        userList.forEach(System.out::println);
    }

    // @Test
    public void selectLambda2() {
        // 条件构造器
        LambdaQueryWrapper<User> lambdaQuery = new LambdaQueryWrapper<>();
        lambdaQuery.likeRight(User::getName, "王").and(age -> age.lt(User::getAge, 40).or().isNotNull(User::getEmail));

        List<User> userList = userMapper.selectList(lambdaQuery);
        userList.forEach(System.out::println);
    }

    // @Test
    public void selectLambda3() {
        // 条件构造器
        List<User> userList = new LambdaQueryChainWrapper<User>(userMapper).like(User::getName, "雨")
                .ge(User::getAge, 20).list();
        userList.forEach(System.out::println);
    }

    // @Test
    public void selectMy() {
        LambdaQueryWrapper<User> lambda = new QueryWrapper<User>().lambda();
        lambda.likeRight(User::getName, "王").and(age -> age.lt(User::getAge, 40).or().isNotNull(User::getEmail));

        List<User> userList = userMapper.selectAll(lambda);
        userList.forEach(System.out::println);
    }

    // @Test
    public void selectListPage() {
        // 条件构造器
        QueryWrapper<User> userQuery = Wrappers.query();
        userQuery.ge("age", 26);

        Page<User> page = new Page<User>(1, 3);

        IPage<User> userPage = userMapper.selectPage(page, userQuery);
        System.out.println("总页数：" + userPage.getPages());
        System.out.println("总记录数：" + userPage.getTotal());

        List<User> userList = userPage.getRecords();
        userList.forEach(System.out::println);
    }

    // @Test
    public void selectMapsPage() {
        // 条件构造器
        QueryWrapper<User> userQuery = Wrappers.query();
        userQuery.ge("age", 26);

        Page<User> page = new Page<User>(1, 3);

        IPage<Map<String, Object>> userPage = userMapper.selectMapsPage(page, userQuery);
        System.out.println("总页数：" + userPage.getPages());
        System.out.println("总记录数：" + userPage.getTotal());

        List<Map<String, Object>> userList = userPage.getRecords();
        userList.forEach(System.out::println);
    }

    // @Test
    public void selectPageRecords() {
        // 条件构造器
        QueryWrapper<User> userQuery = Wrappers.query();
        userQuery.ge("age", 26);

        Page<User> page = new Page<User>(1, 3, false);

        IPage<Map<String, Object>> userPage = userMapper.selectMapsPage(page, userQuery);
        System.out.println("总页数：" + userPage.getPages());
        System.out.println("总记录数：" + userPage.getTotal());

        List<Map<String, Object>> userList = userPage.getRecords();
        userList.forEach(System.out::println);
    }

    @Test
    public void selecMypage() {
        // 条件构造器
        QueryWrapper<User> userQuery = Wrappers.query();
        userQuery.ge("age", 26);

        Page<User> page = new Page<User>(1, 3);

        IPage<User> userPage = userMapper.selectUserPage(page, userQuery);
        System.out.println("总页数：" + userPage.getPages());
        System.out.println("总记录数：" + userPage.getTotal());

        List<User> userList = userPage.getRecords();
        userList.forEach(System.out::println);
    }

    /**
     *
     * 多个查询参数，其中为空则不做条件
     */
    // @Test
    public void testCondition() {
        String name = "王";
        String email = "";
        condition(name, email);
    }

    private void condition(String name, String email) {
        QueryWrapper<User> userQuery = new QueryWrapper<>();

        // if (StringUtils.isNotEmpty(name)) {
        // userQuery.like("name", name);
        // }
        // if (StringUtils.isNotEmpty(email)) {
        // userQuery.like("email", email);
        // }

        userQuery.like(StringUtils.isNotEmpty(name), "name", name).like(StringUtils.isNotEmpty(email), "email", email);
        List<User> userList = userMapper.selectList(userQuery);
        userList.forEach(System.out::println);
    }

}

 

老姥
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【项目实战】在MyBatis-Plus的LambdaQueryWrapper中，实现MySQL的limit语句
本本本添哥
04-20 5845
last方法接受一个字符串参数，该参数可以是任何有效的SQL语句，包括MySQL的limit语句。但是，要注意，last方法有sql注入的风险,请谨慎使用。
基于SpringBoot + MyBatis-Plus的快速开发脚手架
09-11
2. **条件构造器**：通过Lambda表达式或QueryWrapper构建复杂的查询条件，避免了大量的代码重复。 3. **分页插件**：内置分页插件，支持多种数据库的分页需求。 4. **实体继承**：支持单一表继承和多表继承，方便...
mybatis plus使用
求道问术
12-02 5571
目录总结注解常用注解排除字段查询查询方式idnullisNotBlankdate_format子查询betweenisNotNullor()orderByDesc/Asclambda括号nestedinselectOneselectCount聚集函数selectMapsselectList指定列select对象+@TableField分页sql在xml中sql在mapper中AR模式主键默认主键策略局部主键策略全局主键策略配置局部配置-insertStrategy全局配置-insertStrategy全局配
Mybatis-Plus中LambdaQueryWrapper与QueryWrapper的使用
最新发布
lin_silvery的博客
05-20 1632
在开发过程中，几乎每个需求都需要写一些最基础的crud操作，这在mapper和xml文件中会产生大量重复的代码，引入mybatis-plus可以解决最简单的crud以有效缓解，但大部分人在一些比较复杂的查询操作以及考虑sql优化的场景下依旧选择手写xml文件，但是mybatis-plus并不是无法解决这个问题。关于连表查询，我能想到的就是sql中使用数据量小的表来连接数据量大的表，以减少索引扫描循环的次数，以及想使用or连接条件时，需要前后字段都存在索引；两个参数中前者是表中的列名，后者是查询的条件。
MyBatisPlus---使用limit查询
牧小七的博客
01-09 4887
MyBatisPlus框架，使用方法，进行limit查询。
SpringBoot - MyBatis-Plus - QueryWrapper、LambdaQueryWrapper和LambdaQueryChainWrapper的用法(二)
记录并分享
06-06 2104
当我们查询数据的时候，一般都需要设置查询条件，除了使用最基本的QueryWrapper进行查询条件的封装外，还可以使用Lambda 条件构造器LambdaQueryWrapper和链式查询LambdaQueryChainWrapper这两个高级用法。
MyBatis中的LambdaQueryWrapper构造器
java123456111的博客
07-21 1588
在上面的代码中，我们可以看到首先是使用了mybatisplus的条件构造器LambdaQueryWrapper对象。首先有个User表对应的实体类为User.java，其中包含一些基本user字段。然后设置User的stat字段的值为0，name字段的值为宇子。引入lambda后，避免在代码里写user_id字样的代码。从中可以得出在java8中作用就是获取方法；............
spring boot整合mybatis+mybatis-plus的示例代码
08-28
MyBatis 是一个流行的持久层框架，而 MyBatis-Plus 是一个基于 MyBatis 的增强工具，它提供了许多有用的功能，如代码生成器、条件构造器等。 Spring Boot 简介 Spring Boot 是一个基于 Spring 框架的轻量级框架，...
整合案例springboot整合swagger+mybatis-plus
08-16
MyBatis-Plus是MyBatis的增强工具，提供了很多便捷的操作，比如自动CRUD（创建、读取、更新、删除）操作，条件构造器，以及分页插件等。它简化了SQL的编写，降低了学习成本。在SpringBoot中整合MyBatis-Plus，需要...
springboot+mybatis-plus.rar
07-28
它支持自动插入、更新、删除、查询，同时提供了条件构造器，可以方便地生成复杂的动态SQL。 在"tsh-mp"这个示例项目中，我们可以期待看到以下几个关键部分： 1. **pom.xml**：项目的Maven配置文件，包含了...
SpringBoot集成MyBatis-Plus代码生成器Demo
03-31
在本项目"SpringBoot集成MyBatis-Plus代码生成器Demo"中，我们将探讨如何将流行的SpringBoot框架与MyBatis-Plus结合，并利用MyBatis-Plus的代码生成器来自动化我们的开发流程。这个源码工程是基于IntelliJ IDEA 2020...
LambdaQueryWrapper构建查询条件
weixin_42133138的博客
08-16 1万+
每天进步一点点
mybatis-plus中wrapper的用法（详细）
热门推荐
DayDayUp
09-03 11万+
mybatis-plus中wrapper的用法，ge、le、ne、eq、及多表查询自写sql
java 8 lambda表达式和mybatis-plus中结合使用，根据今日时间返回倒序最新数据 queryWrapper常用方法及简单应用
凝孑哒哒哒的博客
08-05 1万+
mybatis-plus中查询对象 queryWrapper常见方法 众所周知 mybatis-plus支持 Lambda 形式调用：及通过 Lambda 表达式，方便的编写各类查询条件，无需再担心字段写错。 那么到底在项目中我们该如何使用呢，就让我们来看看吧 大家可以插个眼????????????方便日后查看哦！ QueryWrapper与lambda表达式结合查询 List<ProjectSms> list = list(new QueryWrapper<ProjectSms>(
用LambdaQuerWrapper实现一个查询条件查询所有字段
时光有伱，记忆成花~
07-19 3242
用LambdaQuerWrapper实现一个查询条件查询所有字段
Lambda常用
weixin_40364776的博客
02-04 412
业务开发中Lambda常用语句
lambda强大的功能（分页、过滤、排序、减少代码量等等）
এ某年某月某日এ的博客
04-10 1896
如需转载分享，请标明出处，且不用于盈利为目的，谢谢合作！ lambda强大的功能（分页、过滤、排序、减少代码量等等） 情景1.获取某个集合（students）中对象（Student）的某个属性（id）值的集合 List<Student> students = 数据库查的数据; List ids= students.stream().map(Student::getId).collect...
浮光笔记：Mybatis SQL相关
fg_bear的博客
04-27 794
mybatisplus、一对多、动态sql
mybits-plus QueryWrapper运用梳理
my_futrue的博客
09-16 944
mybits-plus QueryWrapper运用梳理、mybits-plus apply、mybits-plus order、mybits-plus orderby field、mybits-plus last、MySQL 计算年龄
springboot+mybatis-plus条件查询
08-24
在Spring Boot中使用MyBatis-Plus进行条件查询非常简单。以下是一些示例代码，演示了如何使用MyBatis-Plus进行条件查询： 1. 首先，确保在pom.xml文件中添加了MyBatis-Plus的依赖： ```xml <dependency> <groupId>com.baomidou</groupId> <artifactId>mybatis-plus-boot-starter</artifactId> <version>最新版本</version> </dependency> ``` 2. 创建一个实体类，表示数据库表中的一条记录。使用`@TableName`注解指定数据库表名，使用`@TableField`注解指定字段映射关系。 ```java import com.baomidou.mybatisplus.annotation.TableName; import com.baomidou.mybatisplus.annotation.TableField; @TableName("user") public class User { private Long id; @TableField("username") private String username; @TableField("age") private Integer age; // 省略getter和setter方法 } ``` 3. 创建一个Mapper接口，继承自`BaseMapper`接口，并且使用`@Mapper`注解标记为MyBatis的Mapper。 ```java import com.baomidou.mybatisplus.core.mapper.BaseMapper; import org.apache.ibatis.annotations.Mapper; @Mapper public interface UserMapper extends BaseMapper<User> { } ``` 4. 在Service层中注入UserMapper，并且使用MyBatis-Plus提供的查询构造器进行条件查询。 ```java import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; @Service public class UserService { @Autowired private UserMapper userMapper; public List<User> findUsersByAgeRange(int minAge, int maxAge) { QueryWrapper<User> queryWrapper = new QueryWrapper<>(); queryWrapper.between("age", minAge, maxAge); return userMapper.selectList(queryWrapper); } } ``` 在上述示例中，`QueryWrapper`是MyBatis-Plus提供的查询构造器，可以使用它来构建查询条件。`between`方法用于指定age字段在minAge和maxAge之间的范围。 这只是一个简单的示例，你可以根据自己的需求使用更多的查询条件和操作符。MyBatis-Plus还提供了许多其他功能，如分页查询和动态条件查询等。你可以查阅MyBatis-Plus官方文档来了解更多信息。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值