Mybatis-Flex之基础查询

最新推荐文章于 2024-07-10 15:47:57 发布
最新推荐文章于 2024-07-10 15:47:57 发布
阅读量1.8k 收藏 3
点赞数
分类专栏： MybatisFlex 文章标签： mybatis java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45529338/article/details/132121012
版权
1、selectOneById
/**
     * selectOneById(id)：根据主键查询数据。
     */
    @Test
    public void testSelectOneById() {
        /**
         * SELECT * FROM `tb_account` WHERE `id` = ?
         */
        Account account = accountMapper.selectOneById(10L);
        System.out.println("account = " + account);
    }
2、selectOneByMap
/**
     * selectOneByMap(whereConditions)：根据 Map 构建的条件来查询数据。查出满足条件的一条数据
     */
    @Test
    public void testSelectOneByMap() {
        Map<String, Object> condition = Map.of("age", 20);
        /**
         * SELECT `id`, `user_name`, `age`, `birthday` FROM `tb_account` WHERE `tb_account`.`user_name` = ? LIMIT 1
         */
        Account account = accountMapper.selectOneByMap(condition);
        Assertions.assertNotNull(account, "用户名不存在");
    }
3、selectOneByCondition
/**
     * selectOneByCondition(whereConditions)：根据查询条件查询数据。
     */
    @Test
    public void testSelectOneByCondition() {
        QueryWrapper wrapper = QueryWrapper.create()
                .select(ACCOUNT.AGE, ACCOUNT.ID, ACCOUNT.BIRTHDAY, ACCOUNT.USER_NAME)
                .from(ACCOUNT)
                .where(ACCOUNT.AGE.eq(20));
        /**
         * 查出多条记录会报错
         * SELECT `age`, `id`, `birthday`, `user_name` FROM `tb_account` WHERE `age` = ?
         */
        Account account = accountMapper.selectOneByQuery(wrapper);
        Assertions.assertNotNull(account);
    }
4、获取表名、列名
/**
     * 获取表名、列名
     */
    @Test
    public void testGetTableName() {
        // String schema = ACCOUNT.getSchema();
        // System.out.println("schema = " + schema);
        // 表名
        String tableName = ACCOUNT.getTableName();
        System.out.println("tableName = " + tableName);

        // 列名
        String columnName = ACCOUNT.AGE.getName();
        System.out.println("columnName = " + columnName);
    }
5、selectOneByQuery
/**
     * selectOneByQuery(queryWrapper)：根据查询条件来查询 1 条数据。
     */
    @Test
    public void testSelectOneByQuery() {
        QueryWrapper wrapper = QueryWrapper.create()
                .select(Account::getUserName)
                .from(ACCOUNT)
                .where(ACCOUNT.ID.eq(15));
        /**
         * SELECT `user_name` FROM `tb_account` WHERE `id` = ?
         */
        Account account = accountMapper.selectOneByQuery(wrapper);
        Assertions.assertNotNull(account);
    }
6、selectOneByQueryAs
/**
     * selectOneByQueryAs(queryWrapper, asType)：根据查询条件来查询 1 条数据。
     */
    @Test
    public void testSelectOneByQueryAs() {
        QueryWrapper wrapper = QueryWrapper.create()
                .select(Account::getUserName)
                .from(ACCOUNT)
                .where(ACCOUNT.ID.eq(10));
        /**
         * SELECT `user_name` FROM `tb_account` WHERE `id` = ?
         */
        AccountDTO accountDTO = accountMapper.selectOneByQueryAs(wrapper, AccountDTO.class);
        // accountDTO = AccountDTO(age=null, userName=UpdateEntity2)
        System.out.println("accountDTO = " + accountDTO);
        Assertions.assertNotNull(accountDTO);
    }
7、selectOneWithRelationsByMap
 /**
     * selectOneWithRelationsByMap(whereConditions)：根据 Map 构建的条件来查询 1 条数据。
     */
    @Test
    public void testSelectOneWithRelationsByMap() {
        Map<String, Object> condition = Map.of("age", 20);
        /**
         * SELECT `id`, `user_name`, `age`, `birthday` FROM `tb_account` WHERE `tb_account`.`age` = ? LIMIT 1
         */
        Account account = accountMapper.selectOneWithRelationsByMap(condition);
        System.out.println("account = " + account);
        Assertions.assertNotNull(account);
    }
8、selectOneWithRelationsByCondition
/**
     * selectOneWithRelationsByCondition(whereConditions)：根据查询条件查询 1 条数据。
     */
    @Test
    public void testSelectOneWithRelationsByCondition() {
        QueryCondition condition = ACCOUNT.ID.eq(10L);
        /**
         * SELECT `id`, `user_name`, `age`, `birthday` FROM `tb_account` WHERE `id` = ? LIMIT 1
         */
        Account account = accountMapper.selectOneWithRelationsByCondition(condition);
        Assertions.assertNotNull(account);
    }
9、selectOneWithRelationsByQuery
/**
     * selectOneWithRelationsByQuery(queryWrapper)：根据查询条件来查询 1 条数据。
     */
    @Test
    public void testSelectOneWithRelationsByQuery() {
        QueryWrapper wrapper = QueryWrapper.create().select(Account::getId, Account::getUserName)
                .from(ACCOUNT)
                .where(ACCOUNT.ID.ge(6))
                .orderBy(Account::getBirthday)
                .asc()
                .limit(1);
        /**
         * SELECT `id`, `user_name` FROM `tb_account` WHERE `id` >= ? ORDER BY `birthday` ASC LIMIT 1
         */
        Account account = accountMapper.selectOneWithRelationsByQuery(wrapper);
        Assertions.assertNotNull(account);
    }
10、selectOneWithRelationsByQueryAs
/**
     * selectOneWithRelationsByQueryAs(queryWrapper, asType)：根据查询条件来查询 1 条数据。
     */
    @Test
    public void testSelectOneWithRelationsByQueryAs() {
        QueryWrapper wrapper = QueryWrapper.create().select(ACCOUNT.DEFAULT_COLUMNS)
                .from(ACCOUNT)
                .where(ACCOUNT.ID.ge(6))
                .groupBy(ACCOUNT.ID)
                .having(ACCOUNT.AGE.le(30))
                .orderBy(Account::getBirthday)
                .desc()
                .limit(1);
        /**
         * SELECT `id`, `age`, `birthday`, `user_name` FROM `tb_account` WHERE `id` >= ? GROUP BY `id` HAVING `age` <= ? ORDER BY `birthday` DESC LIMIT 1
         */
        AccountDTO accountDTO = accountMapper.selectOneWithRelationsByQueryAs(wrapper, AccountDTO.class);
        Assertions.assertNotNull(accountDTO);
    }
11、selectListByIds
 /**
     * selectListByIds(ids)：根据多个主键来查询多条数据。
     */
    @Test
    public void testSelectListByIds() {
        List<Integer> ids = List.of(2, 4, 6, 8, 10);
        /**
         * SELECT `id`, `user_name`, `age`, `birthday` FROM `tb_account` WHERE `id` = ? OR `id` = ? OR `id` = ? OR `id` = ? OR `id` = ?
         */
        List<Account> accounts = accountMapper.selectListByIds(ids);
        Assertions.assertTrue(accounts.size() > 0);
        System.out.println("accounts = " + accounts);
    }
12、selectListByMap
/**
     * selectListByMap(whereConditions)：根据 Map 来构建查询条件，查询多条数据。
     */
    @Test
    public void testSelectListByMap() {
        // 注意这里的key要和数据库的列名column对应
        Map<String, Object> condition = Map.of("age", 20, "user_name", "zs");
        /**
         * SELECT `id`, `user_name`, `age`, `birthday` FROM `tb_account` WHERE `tb_account`.`user_name` = ? AND `tb_account`.`age` = ?
         */
        List<Account> accounts = accountMapper.selectListByMap(condition);
        Assertions.assertTrue(accounts.size() > 0);
        System.out.println("accounts = " + accounts);
    }
13、selectListByMap
/**
     * selectListByMap(whereConditions, count)：根据 Map 来构建查询条件，查询多条数据。
     */
    @Test
    public void testSelectListByMapAndCount() {
        int count = 2;
        Map<String, Object> condition = Map.of("age", 20);
        /**
         * SELECT `id`, `user_name`, `age`, `birthday` FROM `tb_account` WHERE `tb_account`.`age` = ? LIMIT 2
         */
        List<Account> accounts = accountMapper.selectListByMap(condition, count);
        Assertions.assertEquals(2, accounts.size());
        System.out.println("accounts = " + accounts);
    }
14、selectListByCondition
/**
     * selectListByCondition(whereConditions)：根据查询条件查询多条数据。
     */
    @Test
    public void testSelectListByCondition() {
        QueryCondition condition = ACCOUNT.ID.eq(5).and(ACCOUNT.AGE.ge(20));
        /**
         * SELECT `id`, `user_name`, `age`, `birthday` FROM `tb_account` WHERE `id` = ? AND `age` >= ?
         */
        List<Account> accounts = accountMapper.selectListByCondition(condition);
        Assertions.assertTrue(accounts.size() > 0);
        System.out.println("accounts = " + accounts);
    }
15、selectListByCondition
/**
     * selectListByCondition(whereConditions, count)：根据查询条件查询多条数据。
     */
    @Test
    public void testSelectListByConditionAndCount() {
        QueryCondition condition = ACCOUNT.ID.eq(5).and(ACCOUNT.AGE.ge(20));
        /**
         * SELECT `id`, `user_name`, `age`, `birthday` FROM `tb_account` WHERE `id` = ? AND `age` >= ? LIMIT 2
         */
        List<Account> accounts = accountMapper.selectListByCondition(condition, 2);
        Assertions.assertEquals(2, accounts.size());
        System.out.println("accounts = " + accounts);
    }
16、selectListByQuery
 /**
     * selectListByQuery(queryWrapper)：根据查询条件查询数据列表。
     */
    @Test
    public void testSelectListByQuery() {
        /**
         * SELECT * FROM `tb_account` WHERE id >= 10
         */
        List<Account> accounts = accountMapper.selectListByQuery(QueryWrapper.create().select(ACCOUNT.ALL_COLUMNS).from(ACCOUNT).where("id >= " + 10));
        Assertions.assertTrue(accounts.size() > 0);
    }
17、selectListByQuery
/**
     * selectListByQuery(queryWrapper, consumers)：根据查询条件查询数据列表。
     */
    @Test
    public void testSelectListByQueryAndConsumers() {
        // 暂时没整明白consumers参数的用处
        Consumer<FieldQueryBuilder<Account>> consumer = (builder) -> {
            builder.nestedField(Account::getUserName);
        };
        /**
         * SELECT * FROM `tb_account` WHERE `age` >= ?
         */
        List<Account> accounts = accountMapper.selectListByQuery(QueryWrapper.create().select(ACCOUNT.ALL_COLUMNS)
                .from(ACCOUNT).where(ACCOUNT.AGE.ge(15)), consumer);
        Assertions.assertTrue(accounts.size() > 0);
        System.out.println("accounts = " + accounts);
    }
18、selectCursorByQuery
/**
     * selectCursorByQuery(queryWrapper)：根据查询条件查询游标数据，该方法必须在事务中才能正常使用，非事务下无法获取数据。
     */
    @Transactional
    @Test
    public void testSelectCursorByQuery() {
        /**
         * SELECT * FROM `tb_account` WHERE `age` <= ?
         */
        Cursor<Account> accounts = accountMapper.selectCursorByQuery(QueryWrapper.create().select(ACCOUNT.ALL_COLUMNS).from(ACCOUNT).where(ACCOUNT.AGE.le(18)));
        accounts.forEach(item -> {
            System.out.println("item = " + item);
        });
        Assertions.assertNotNull(accounts);
    }
19、selectRowsByQuery
/**
     * selectRowsByQuery(queryWrapper)：根据查询条件查询 Row 数据。
     */
    @Test
    public void testSelectRowsByQuery() {
        /**
         * SELECT `id`, `user_name`, `age`, `birthday` FROM `tb_account` WHERE `user_name` = ?
         */
        List<Row> rows = accountMapper.selectRowsByQuery(QueryWrapper.create().where(ACCOUNT.USER_NAME.eq("zs")));
        rows.stream().parallel().forEach(item -> {
            Object id = item.get("id");
            System.out.println("id = " + id);
            System.out.println("item = " + item);
        });
        Assertions.assertTrue(rows.size() > 0);
        System.out.println("rows = " + rows);
    }
20、selectListByQueryAs
/**
     * selectListByQueryAs(queryWrapper, asType)：根据查询条件查询数据列表，要求返回的数据为 asType。这种场景一般用在 left join 时，有多出了实体类本身的字段内容，可以转换为 dto、vo 等场景
     */
    @Test
    public void testSelectListByQueryAs() {
        /**
         *SELECT `id`, `user_name`, `age`, `birthday` FROM `tb_account` WHERE age >=20
         */
        List<AccountDTO> accountDTOS = accountMapper.selectListByQueryAs(QueryWrapper.create().where("age >=" + 20), AccountDTO.class);
        Assertions.assertTrue(accountDTOS.size() > 0);
        System.out.println("accountDTOS = " + accountDTOS);
    }
21、selectAll
/**
     * selectAll()：查询全部数据。
     */
    @Test
    public void testSelectAll() {
        /**
         * SELECT `id`, `user_name`, `age`, `birthday` FROM `tb_account`
         */
        List<Account> accounts = accountMapper.selectAll();
        Assertions.assertTrue(accounts.size() > 0);
        System.out.println("accounts = " + accounts);
    }
22、selectObjectByQuery
 /**
     * selectObjectByQuery(queryWrapper)：查询第一列返回的数据，QueryWrapper 执行的结果应该只有 1 列，例如：QueryWrapper.create().select(ACCOUNT.id).where(...);
     */
    @Test
    public void testSelectObjectByQuery() {
        String where = String.format("id = %d", 10);
        QueryWrapper wrapper = QueryWrapper.create().select(ACCOUNT.USER_NAME).where(where);
        /**
         *  SELECT `user_name` FROM `tb_account` WHERE id = 10
         */
        String userName = (String) accountMapper.selectObjectByQuery(wrapper);
        Assertions.assertNotNull(StringUtil.trimOrNull(userName));
        System.out.println("userName = " + userName);
    }
23、selectObjectByQueryAs
/**
     * selectObjectByQueryAs(queryWrapper, asType)：查询第一列返回的数据，QueryWrapper 执行的结果应该只有 1 列，例如：QueryWrapper.create().select(ACCOUNT.id).where(...);
     */
    @Test
    public void testSelectObjectByQueryAs() {
        String where = String.format("id = %d", 10);
        /**
         * SELECT `user_name` FROM `tb_account` WHERE id = 10
         */
        QueryWrapper wrapper = QueryWrapper.create().select(ACCOUNT.USER_NAME).where(where);
        String res = accountMapper.selectObjectByQueryAs(wrapper, String.class);
        Assertions.assertNotNull(res);
        System.out.println("res = " + res);
    }
24、selectObjectListByQuery
/**
     * selectObjectListByQuery(queryWrapper)：查询第一列返回的数据集合，QueryWrapper 执行的结果应该只有 1 列，例如：QueryWrapper.create().select(ACCOUNT.id).where(...);
     */
    @Test
    public void testSelectObjectListByQuery() {
        /**
         * SELECT `age` FROM `tb_account` WHERE `age` = ?
         */
        List<Object> objects = accountMapper.selectObjectListByQuery(QueryWrapper.create().select(ACCOUNT.AGE).where(ACCOUNT.AGE.eq(20)));
        Assertions.assertNotNull(objects);
        Assertions.assertTrue(objects.size() > 0);
        System.out.println("objects = " + objects);
    }
25、testSelectObjectListByQueryAs
/**
     * selectObjectListByQueryAs(queryWrapper, asType)：查询第一列返回的数据集合，QueryWrapper 执行的结果应该只有 1 列，例如：QueryWrapper.create().select(ACCOUNT.id).where(...);
     */
    @Test
    public void testSelectObjectListByQueryAs() {
        /**
         * SELECT `user_name` FROM `tb_account` WHERE `age` = ?
         */
        List<String> userNameList = accountMapper.selectObjectListByQueryAs(QueryWrapper.create().select(ACCOUNT.USER_NAME).where(ACCOUNT.AGE.eq(20)), String.class);
        Assertions.assertNotNull(userNameList);
        Assertions.assertTrue(userNameList.size() > 0);
        System.out.println("userNameList = " + userNameList);
    }
26、selectCountByQuery
/**
     * selectCountByQuery(queryWrapper)：查询数据量。
     */
    @Test
    public void testSelectCountByQuery() {
        /**
         * SELECT COUNT(*) FROM `tb_account` WHERE `id` > ?
         */
        long count = accountMapper.selectCountByQuery(QueryWrapper.create().select(ACCOUNT.ID));
        Assertions.assertTrue(count > 0);
        System.out.println("count = " + count);
    }
27、selectCountByCondition
/**
     * selectCountByCondition(whereConditions)：根据条件查询数据总量。
     */
    @Test
    public void test() {
        long count = accountMapper.selectCountByCondition(ACCOUNT.ID.ge(0));
        Assertions.assertTrue(count > 0);
        System.out.println("count = " + count);
    }
我也有梦想呀
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MyBatis = MyBatis单表查询和多表查询
人生起落，生活苦甜，坚持追求！
05-11 964
单表查询，mapper映射文件讲解，表关系，多表查询 一.MyBatis单表查询 （1）resultMap标签 如果数据库返回结果的列名和要封装的实体的属性名完全一致的话用resultType属性 如果数据库返回结果的列名和要封装的实体的属性名有不一致的情况用resultMap属性 ====使用resultMap==手动建立对象关系映射== (1)UserMapper接口 // ResultMap标签 public List<User> fi...
spring+mybatis+flex4框架组合，适合初学者
10-24
spring+mybatis+flex4框架组合，适合初学者
Mybatis-Flex各种查询，强烈建议收藏
最新发布
乐于分享，共同成长
07-10 1278
Mybatis-Flex各种查询，强烈建议收藏
Mybatis-Flex
Java牛马的博客
04-25 2262
（阿里云开发的 Mybatis 增强框架，来至于阿里云·云效产品团队）都要强大；（老牌的 MyBatis 增强框架，开源于 2016 年），以及。据说最终结果是：无论。
MyBatis-Flex-多表联查(自动映射)
kunkun2580的博客
04-19 1023
MyBatis-Flex(自动映射).MyBatis-Flex多表联查
Mybatis-Flex之QueryWrapper
startqbb的博客
09-01 1424
自定义操作符，让实体属性值通过and|or…进行连接SQLSELECT` id `,` age `,FROMWHEREMF/*** 自定义操作符*/@Test。
这是一款高度自定义代码生成idea插件，目前提供的 模板是依托于mybatis-flex 代码提示、自动APT，SQL预览等特性
12-16
Mybatis-Flex是一个灵活扩展的Mybatis增强框架，它在Mybatis的基础上添加了更多的功能和便利性。而这款IDEA插件则进一步增强了Mybatis-Flex的开发体验。通过利用此插件，开发者可以自定义代码生成模板，实现对数据库...
Mybatis-Flex 一个优雅的 Mybatis 增强框架
04-16
而 Mybatis-Flex 则在此基础上添加了更多的实用特性，以提升开发效率和代码质量。 Mybatis-Flex 的核心特性包括但不限于： 1. **动态 SQL 支持**：Mybatis-Flex 提供更强大的动态 SQL 功能，使得开发者能够更加...
springboot-mybatis-flex.zip
04-15
标题 "springboot-mybatis-flex.zip" 暗示了这个压缩包包含了一个使用Spring Boot和MyBatis框架的项目。Spring Boot是Java生态系统中的一个流行框架，它简化了创建独立的、生产级别的基于Spring的应用程序。MyBatis...
mybatis-flex整合mybatisplus
02-24
而MyBatis-Plus是在MyBatis的基础上进行扩展的一个框架，它提供了更多的便利功能，如通用CRUD操作、分页查询、条件构造器等。 接下来是介绍mybatis-flex的整合方式。mybatis-flex通过提供一个基于注解的方式来整合...
mybatis-flex和mybatis-plus开发中哪个用得更多
05-10
相比之下，MyBatis-Flex 的使用相对较少，它是一个基于 MyBatis 的轻量级框架，提供了更加灵活的 SQL 语句编写方式和更好的扩展性，不过需要开发者有一定的 MyBatis 使用经验和 SQL 编写能力。因此，在实际开发中，...
SpringBoot+MyBatis flex实现简单增删改查
m0_67930426的博客
09-17 577
项目创建完成。
mybatis-flex探索
qq_14926283的博客
08-10 1055
最近无意之中发现了一个非常棒的持久层框架mybatis-flex，迫不及待研究了一下发现简直就是我的梦中情框，之前写ibatis，后来写mybatis，接着写mybatis-plus，接着研究mybatis-flex。
Mybatis-基础操作-条件查询
ADCvbV的博客
06-02 571
但${参数名称}这个占位符性能低,不安全还存在SQL注入问题,因此可以通过MySQL提供的一个函数来解决。-->concat字符串拼接函数。
6. Mybatis映射文件深入 - 新增数据后返回主键ID - 动态SQL - SQL片段
DevOps海洋的渔夫@专栏
04-24 684
6. Mybatis映射文件深入 - 新增数据后返回主键ID - 动态SQL - SQL片段前言在前面的篇章中，我们已经认识了如何使用 resultMap标签 映射查询的结果集字段、多条件...
mybatis-flex入门体验（一）
shigen的博客
03-22 357
shigen坚持更新文章的博客写手，擅长Java、python、vue、shell等编程语言和各种应用程序、脚本的开发。记录成长，分享认知，留住感动。趁着下午的空闲时间，研究了一下，看着对我还是挺有吸引力的。
MyBatis-flex用法
weixin_58872594的博客
08-05 913
摘要：介绍mybatis-flex的使用
【Java开发】 Mybatis-Flex 01：快速入门
尹煜的博客
07-29 3549
是一个优雅的MyBatis增强框架，它非常轻量、同时拥有极高的性能与灵活性。📌特征轻量：除了 MyBatis，没有任何第三方依赖、没有任何拦截器，在执行的过程中，没有任何的 Sql 解析（Parse）。这带来了几个好处：极高的性能、极易对代码进行跟踪和调试、把控性更高。灵活：支持 Entity 的增删改查、以及分页查询的同时，MyBatis-Flex 提供了 Db + Row 工具，可以无需实体类对数据库进行增删改查以及分页查询。
Mybatis-Flex 与 Mybatis-Plus 哪个好用
08-24
根据个人需求而定，Mybatis-Flex 和 Mybatis-Plus 都是基于 MyBatis 框架的增强工具，各有其特点和优势。 Mybatis-Flex 是一个功能强大的代码生成工具，它可以根据数据库表结构自动生成相应的 Java 代码，包括实体类、Mapper 接口、SQL 语句等。它具有灵活的配置选项，可以根据需求进行定制化开发，同时支持多种数据库的适配。 Mybatis-Plus 是一个功能丰富且易于使用的 MyBatis 增强工具，它提供了很多便捷的功能，如自动注入、通用 CRUD 操作、代码生成等。同时，Mybatis-Plus 还提供了一些特性，如分页插件、逻辑删除、乐观锁等，方便开发者进行快速开发。 综上所述，选择使用哪个工具取决于你的具体需求。如果你更注重代码生成和灵活性，可以考虑使用 Mybatis-Flex；如果你想要更多的便捷功能和易用性，可以选择 Mybatis-Plus。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值