MyBatis-Flex BaseMapper的接口基本用法小結(jié)

更新時間：2025年02月14日 10:31:07 作者：水w

本文主要介紹了MyBatis-Flex BaseMapper的接口基本用法小結(jié),文中通過示例代碼介紹的非常詳細(xì),對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值,需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧

MyBatis-Flex簡單介紹

MyBatis-Flex 是一個優(yōu)雅的 MyBatis 增強(qiáng)框架，它非常輕量、同時擁有極高的性能與靈活性。我們可以輕松的使用 Mybaits-Flex 鏈接任何數(shù)據(jù)庫，其內(nèi)置的 QueryWrapper^亮點幫助我們極大的減少了 SQL 編寫的工作的同時，減少出錯的可能性。

總而言之，MyBatis-Flex 能夠極大地提高我們的開發(fā)效率和開發(fā)體驗，讓我們有更多的時間專注于自己的事情。

特性

1、輕量

除了 MyBatis，沒有任何第三方依賴輕依賴、沒有任何攔截器，其原理是通過 SqlProvider 的方式實現(xiàn)的輕實現(xiàn)。同時，在執(zhí)行的過程中，沒有任何的 Sql 解析（Parse）輕運行。這帶來了幾個好處：1、極高的性能；2、極易對代碼進(jìn)行跟蹤和調(diào)試； 3、更高的把控性。

2、靈活

支持 Entity 的增刪改查、以及分頁查詢的同時，MyBatis-Flex 提供了 Db + Row^靈活工具，可以無需實體類對數(shù)據(jù)庫進(jìn)行增刪改查以及分頁查詢。與此同時，MyBatis-Flex 內(nèi)置的 QueryWrapper^靈活可以輕易的幫助我們實現(xiàn) 多表查詢、鏈接查詢、子查詢 等等常見的 SQL 場景。

3、強(qiáng)大

支持任意關(guān)系型數(shù)據(jù)庫，還可以通過方言持續(xù)擴(kuò)展，同時支持 多（復(fù)合）主鍵、邏輯刪除、樂觀鎖配置、數(shù)據(jù)脫敏、數(shù)據(jù)審計、 數(shù)據(jù)填充 等等功能。

基礎(chǔ)方法

INSERT

BaseMapper 的接口提供了 insert 和 insertBatch 方法，用于新增數(shù)據(jù)。

insert(entity)：插入實體類數(shù)據(jù)，不忽略 null 值。
insertSelective(entity)：插入實體類數(shù)據(jù)，但是忽略 null 的數(shù)據(jù)，只對有值的內(nèi)容進(jìn)行插入。這樣的好處是數(shù)據(jù)庫已經(jīng)配置了一些默認(rèn)值，這些默認(rèn)值才會生效。
insert(entity, ignoreNulls)：插入實體類數(shù)據(jù)。
insertWithPk(entity)：插入帶有主鍵的實體類，不忽略 null 值。
insertSelectiveWithPk(entity)：插入帶有主鍵的實體類，忽略 null 值。
insertWithPk(entity, ignoreNulls)：帶有主鍵的插入，此時實體類不會經(jīng)過主鍵生成器生成主鍵。
insertBatch(entities)：批量插入實體類數(shù)據(jù)，只會根據(jù)第一條數(shù)據(jù)來構(gòu)建插入的字段內(nèi)容。
insertBatch(entities, size)：批量插入實體類數(shù)據(jù)，按 size 切分。
insertOrUpdate(entity)：插入或者更新，若主鍵有值，則更新，若沒有主鍵值，則插入，插入或者更新都不會忽略 null 值。
insertOrUpdateSelective(entity)：插入或者更新，若主鍵有值，則更新，若沒有主鍵值，則插入，插入或者更新都會忽略 null 值。
insertOrUpdate(entity, ignoreNulls)：插入或者更新，若主鍵有值，則更新，若沒有主鍵值，則插入。

① insert

    /**
     * insert(entity)：插入實體類數(shù)據(jù)，不忽略 null 值。
     * insert(entity, ignoreNulls)：插入實體類數(shù)據(jù)。
     */
    @Test
    public void testInsert() {
        /**
         * 默認(rèn)不忽略null值
         * INSERT INTO `tb_account`(`user_name`, `age`, `birthday`) VALUES (?, ?, ?)
         */
        int row = accountMapper.insert(new Account().setUserName(null).setBirthday(new Date()).setAge(25));
        Assertions.assertEquals(row, 1);

        /**
         * ignoreNulls true:忽略null , false:不忽略null
         * INSERT INTO `tb_account`(`user_name`) VALUES (?)
         */
        int row2 = accountMapper.insert(new Account().setUserName("ly3").setBirthday(null).setAge(null), true);
        Assertions.assertEquals(row2, 1);
    }

② insertSelective

    /**
     * insertSelective(entity)：插入實體類數(shù)據(jù)，但是忽略 null 的數(shù)據(jù)，只對有值的內(nèi)容進(jìn)行插入。這樣的好處是數(shù)據(jù)庫已經(jīng)配置了一些默認(rèn)值，這些默認(rèn)值才會生效。
     */
    @Test
    public void testInsertSelective() {
        /**
         * INSERT INTO `tb_account`(`user_name`) VALUES (?)
         */
        int row = accountMapper.insertSelective(new Account().setUserName("陳遠(yuǎn)航").setAge(null));
        Assertions.assertEquals(row, 1);
    }

③ insertWithPk

    /**
     * insertWithPk(entity)：插入帶有主鍵的實體類，不忽略 null 值。
     */
    @Test
    public void testInsertWithPk() {
        /**
         * INSERT INTO `tb_account`(`id`, `user_name`, `age`, `birthday`) VALUES (?, ?, ?, ?)
         */
        int row = accountMapper.insertWithPk(new Account().setUserName("廖楷瑞").setId(5L).setBirthday(null));
        Assertions.assertEquals(row, 1);
    }

④ insertBatch

    /**
     * insertBatch(entities)：批量插入實體類數(shù)據(jù)，只會根據(jù)第一條數(shù)據(jù)來構(gòu)建插入的字段內(nèi)容。
     * insertBatch(entities, size)：批量插入實體類數(shù)據(jù)，按 size 切分。
     */
    @Test
    public void testInsertBatch() {
        List<Account> accounts = new ArrayList<>(10);
        for (int i = 0; i < 10; i++) {
            Account account = new Account().setUserName("ly" + i).setBirthday(new Date()).setAge(20 + i);
            accounts.add(account);
        }
        /**
         * 批量插入，可以指定每次插入的數(shù)據(jù)大小size
         * size=2 : INSERT INTO `tb_account`(`user_name`, `age`, `birthday`) VALUES (?, ?, ?), (?, ?, ?)
         * size=3 : INSERT INTO `tb_account`(`user_name`, `age`, `birthday`) VALUES (?, ?, ?), (?, ?, ?), (?, ?, ?)
         * ......
         */
        int rows = accountMapper.insertBatch(accounts, 2);
        System.out.println("rows = " + rows);
    }

⑤ insertOrUpdate

    /**
     * insertOrUpdate(entity)：插入或者更新，若主鍵有值，則更新，若沒有主鍵值，則插入，插入或者更新都不會忽略 null 值。
     * insertOrUpdateSelective(entity)：插入或者更新，若主鍵有值，則更新，若沒有主鍵值，則插入，插入或者更新都會忽略 null 值。
     * insertOrUpdate(entity, ignoreNulls)：插入或者更新，若主鍵有值，則更新，若沒有主鍵值，則插入。
     */
    @Test
    public void testInsertOrUpdate() {
        Account account = new Account().setUserName("ly-update2").setId(3L).setBirthday(new Date()).setAge(21);
        /**
         * UPDATE `tb_account` SET `user_name` = ? , `age` = ? , `birthday` = ? WHERE `id` = ?
         */
        int row = accountMapper.insertOrUpdate(account);
        Assertions.assertEquals(row, 0, 1);

        account = new Account().setUserName("ly-update2").setBirthday(null).setAge(21);
        /**
         * INSERT INTO `tb_account`(`user_name`, `age`) VALUES (?, ?)
         */
        int row2 = accountMapper.insertOrUpdateSelective(account);
        Assertions.assertEquals(row2, 0, 1);
    }

DELETE

BaseMapper 的接口提供了 deleteById、deleteBatchByIds、deleteByMap、deleteByQuery 方法，用于刪除數(shù)據(jù)；

deleteById(id)：根據(jù)主鍵刪除數(shù)據(jù)。如果是多個主鍵的情況下，需要傳入數(shù)組，例如：new Integer[]{100,101}。
deleteBatchByIds(ids)：根據(jù)多個主鍵批量刪除數(shù)據(jù)。
deleteBatchByIds(ids, size)：根據(jù)多個主鍵批量刪除數(shù)據(jù)。
deleteByMap(whereConditions)：根據(jù) Map 構(gòu)建的條件來刪除數(shù)據(jù)。
deleteByCondition(whereConditions)：根據(jù)查詢條件來刪除數(shù)據(jù)。
deleteByQuery(queryWrapper)：根據(jù)查詢條件來刪除數(shù)據(jù)。

① deleteById

    /**
     * deleteById(id)：根據(jù)主鍵刪除數(shù)據(jù)。
     * ??? 如果是多個主鍵的情況下，需要傳入數(shù)組，例如：new Integer[]{100,101}。 ??? 懷疑態(tài)度
     */
    @Test
    public void testDeleteById() {
        /**
         * DELETE FROM `tb_account` WHERE `id` = ?
         */
        int row = accountMapper.deleteById(9L);
        Assertions.assertTrue(row > 0);
    }

② deleteBatchByIds

    /**
     * deleteBatchByIds(ids)：根據(jù)多個主鍵批量刪除數(shù)據(jù)。
     * deleteBatchByIds(ids, size)：根據(jù)多個主鍵批量刪除數(shù)據(jù)。
     */
    @Test
    public void testDeleteBatchByIds() {
        List<Integer> ids = List.of(5, 6, 7, 8);
        /**
         * DELETE FROM `tb_account` WHERE `id` = ? OR `id` = ? OR `id` = ? OR `id` = ?
         */
        int rows = accountMapper.deleteBatchByIds(ids);
        Assertions.assertTrue(rows > 0);

        /**
         * 分批刪除
         * size=2 : DELETE FROM `tb_account` WHERE `id` = ? OR `id` = ?
         */
        int rows2 = accountMapper.deleteBatchByIds(ids, 2);
        Assertions.assertTrue(rows2 > 0);
    }

③ deleteByMap

    /**
     * deleteByMap(whereConditions)：根據(jù) Map 構(gòu)建的條件來刪除數(shù)據(jù)。
     */
    @Test
    public void testDeleteByMap() {
        /**
         * DELETE FROM `tb_account` WHERE `tb_account`.`age` = ?
         */
        int rows = accountMapper.deleteByMap(Map.of("age", 25));
        Assertions.assertTrue(rows > 0);
    }

④ deleteByCondition

    /**
     * deleteByCondition(whereConditions)：根據(jù)查詢條件來刪除數(shù)據(jù)。
     */
    @Test
    public void testDeleteByCondition() {
        QueryCondition condition = QueryCondition.createEmpty().and("age = 27");
        /**
         * DELETE FROM `tb_account` WHERE age = 27
         */
        int rows = accountMapper.deleteByCondition(condition);
        Assertions.assertTrue(rows > 0);

        /**
         * DELETE FROM `tb_account` WHERE `id` > ?
         */
        int rows2 = accountMapper.deleteByCondition(ACCOUNT.ID.gt(35));
        Assertions.assertTrue(rows2 > 0);
    }

⑤ deleteByQuery

    /**
     * deleteByQuery(queryWrapper)：根據(jù)查詢條件來刪除數(shù)據(jù)。
     */
    @Test
    public void testDeleteByQuery() {
        /**
         * DELETE FROM `tb_account` WHERE `age` >= ?
         */
        QueryWrapper wrapper = QueryWrapper.create().where(ACCOUNT.AGE.ge(32));
        int rows = accountMapper.deleteByQuery(wrapper);
        Assertions.assertTrue(rows > 0);
    }

UPDATE

BaseMapper 的接口提供了 update、updateByMap、updateByQuery 方法，用于更新數(shù)據(jù)；

update(entity)：根據(jù)主鍵來更新數(shù)據(jù)，若實體類屬性數(shù)據(jù)為 null，該屬性不會新到數(shù)據(jù)庫。
update(entity, ignoreNulls)：根據(jù)主鍵來更新數(shù)據(jù)到數(shù)據(jù)庫。
updateByMap(entity, whereConditions)：根據(jù) Map 構(gòu)建的條件來更新數(shù)據(jù)。
updateByMap(entity, ignoreNulls, whereConditions)：根據(jù) Map 構(gòu)建的條件來更新數(shù)據(jù)。
updateByCondition(entity, whereConditions)：根據(jù)查詢條件來更新數(shù)據(jù)。
updateByCondition(entity, ignoreNulls, whereConditions)：根據(jù)查詢條件來更新數(shù)據(jù)。
updateByQuery(entity, queryWrapper)：根據(jù)查詢條件來更新數(shù)據(jù)。
updateByQuery(entity, ignoreNulls, queryWrapper)：根據(jù)查詢條件來更新數(shù)據(jù)。

① update

    @Test
    public void testUpdate() {
        Account account = new Account().setId(5L)
                .setAge(39)
                .setUserName("測試修改")
                .setBirthday(new Date(2023, Calendar.SEPTEMBER, 6, 12, 12, 12));
        /**
         * UPDATE `tb_account` SET `user_name` = ? , `age` = ? , `birthday` = ? WHERE `id` = ?
         */
        int rows = accountMapper.update(account);
        Assertions.assertTrue(rows > 0);
    }
	
    @Test
    public void testUpdateIgnoreNulls() {
        Account account = new Account().setId(6L)
                .setAge(null)
                .setUserName(null)
                .setBirthday(new Date(2023, Calendar.SEPTEMBER, 6, 12, 12, 12));
        /**
         * 不忽略null值
         * UPDATE `tb_account` SET `user_name` = ? , `age` = ? , `birthday` = ? WHERE `id` = ?
         */
        int rows = accountMapper.update(account, false);
        System.out.println("rows = " + rows);
    }

② updateByMap

    @Test
    public void testUpdateByMap() {
        Account account = new Account()
                .setId(7L) // 不生效
                .setUserName("updateByMap")
                .setAge(24)
                .setBirthday(null);
        // 注意：這樣更新實體類的id是不生效的
        Map<String, Object> whereCondition = Map.of("id", 13);

        /**
         * 忽略null
         * UPDATE `tb_account` SET `user_name` = ? , `age` = ? WHERE `id` = ?
         */
        accountMapper.updateByMap(account, whereCondition);

        /**
         * 不忽略null
         * UPDATE `tb_account` SET `user_name` = ? , `age` = ? , `birthday` = ? WHERE `id` = ?
         */
        accountMapper.updateByMap(account, false, whereCondition);
    }

③ updateByCondition

    /**
     * updateByCondition(entity, whereConditions)：根據(jù)查詢條件來更新數(shù)據(jù)。
     * updateByCondition(entity, ignoreNulls, whereConditions)：根據(jù)查詢條件來更新數(shù)據(jù)。
     */
    @Test
    public void testUpdateByCondition() {
        Account account = new Account()
                .setId(8L)
                .setUserName("updateByCondition")
                .setBirthday(DateUtil.toDate(LocalDateTime.now()));
        QueryCondition condition = QueryCondition.create(new QueryColumn("id"),
                SqlConsts.EQUALS, 8);
        /**
         * 忽略null
         * UPDATE `tb_account` SET `user_name` = ? , `birthday` = ? WHERE `id` = ?
         */
        accountMapper.updateByCondition(account, condition);

        /**
         * 不忽略null
         * UPDATE `tb_account` SET `user_name` = ? , `age` = ? , `birthday` = ? WHERE `id` = ?
         */
        accountMapper.updateByCondition(account, false, condition);
    }

④ updateByQuery

    /**
     * updateByQuery(entity, queryWrapper)：根據(jù)查詢條件來更新數(shù)據(jù)。
     * updateByQuery(entity, ignoreNulls, queryWrapper)：根據(jù)查詢條件來更新數(shù)據(jù)。
     */
    @Test
    public void testUpdateByQuery() {
        Account account = new Account().setUserName("updateByQuery");

        /**
         * UPDATE `tb_account` SET `user_name` = ? WHERE `id` = ?
         */
        accountMapper.updateByQuery(account,
                QueryWrapper.create().where(ACCOUNT.ID.eq(9L)));
    }

⑤ UpdateEntity部分字段更新

    @Test
    public void testUpdateEntity1() {
        Account account = UpdateEntity.of(Account.class, 10L);
        /**
         * 官方說明：通過 UpdateEntity 創(chuàng)建的對象，只會更新調(diào)用了 setter 方法的字段，若不調(diào)用 setter 方法，不管這個對象里的屬性的值是什么，都不會更新到數(shù)據(jù)庫。
         */
        account.setAge(66)
                .setUserName("UpdateEntity")
                .setBirthday(null);
        accountMapper.update(account);
    }

    @Test
    public void testUpdateEntity2() {
        Account account = new Account()
                .setId(10L)
                .setUserName("UpdateEntity2");
        UpdateWrapper wrapper = UpdateWrapper.of(account);
        // wrapper.set(ACCOUNT.AGE, ACCOUNT.AGE.add(1));

        wrapper.setRaw("age", "age + 1");
        accountMapper.update(account);
    }

    @Test
    public void testUpdateEntity3() {
        Account account = new Account()
                .setId(10L)
                .setUserName("UpdateEntity2");
        UpdateWrapper wrapper = UpdateWrapper.of(account);

        // wrapper.set(ACCOUNT.AGE, ACCOUNT.AGE.add(1));

        wrapper.setRaw(ACCOUNT.AGE, "select * from t_account where id = 3");
        // accountMapper.updateByCondition(account, wrapper);
    }

⑥ UpdateChain

    @Test
    public void testUpdateChain() {
        /**
         * UPDATE `tb_account` SET `birthday` = ? , `age` = age + 1 WHERE `age` = ?
         */
        UpdateChain.of(Account.class)
                .set(Account::getBirthday, new Date())
                .setRaw(Account::getAge, "age + 1")
                .where(ACCOUNT.AGE.eq(11)).update();
    }

set() 和 setRaw() 的區(qū)別在 Row、UpdateWrapper、UpdateChain 中，都提供了 set() 和 setRaw() 兩個方法用于設(shè)置數(shù)據(jù)。那么，它們有什么區(qū)別呢？

set() 方法用于設(shè)置參數(shù)數(shù)據(jù)。
setRaw() 用于設(shè)置 SQL 拼接數(shù)據(jù)。

舉個例子，

//更新數(shù)據(jù)
UpdateChain.of(Account.class)
	.set(Account::getAge, ACCOUNT.AGE.add(1))
	.where(Account::getId).ge(100)
	.and(Account::getAge).eq(18)
	.update();

通過 UpdateChain 進(jìn)行 update()，其執(zhí)行的 SQL 如下：

UPDATE `tb_account` SET `age` = `age` + 1
WHERE  `id` >= 100 AND `age` = 18

到此這篇關(guān)于MyBatis-Flex BaseMapper的接口基本用法小結(jié)的文章就介紹到這了,更多相關(guān)MyBatis-Flex BaseMapper接口用法內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: