Mybatis-Plus增刪改查

本文轉載自查看原文 2020-12-06 11:03 2457 Mybatis-Plus/ java

閱讀原文

完整代碼 https://github.com/pbteach/mybatis-plus-test

Mybatis-plus增刪改查

插入操作

方法定義

   /**
     * 插入一條記錄
     *
     * @param entity 實體對象
     */
    int insert(T entity);

測試用例

package com.pbteach.mp;

import com.pbteach.mp.mapper.UserMapper;
import com.pbteach.mp.pojo.User;
import org.junit.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.List;

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {

    @Autowired
    private UserMapper userMapper;

    @Test
    public void testInsert(){
        User user = new User();
        user.setAge(20);
        user.setEmail("test@pbteach.com");
        user.setName("曹操");
        user.setUserName("caocao");
        user.setPassword("123456");

        int result = this.userMapper.insert(user); //返回的result是受影響的行數，並不是自增后的id
        System.out.println("result = " + result); 

        System.out.println(user.getId()); //自增后的id會回填到對象中
    }

}

測試

[main] [com.pbteach.mp.mapper.UserMapper.insert]-[DEBUG] ==>  Preparing: INSERT INTO tb_user ( id, user_name, password, name, age, email ) VALUES ( ?, ?, ?, ?, ?, ? ) 
[main] [com.pbteach.mp.mapper.UserMapper.insert]-[DEBUG] ==> Parameters: 1122045867793072130(Long), caocao(String), 123456(String), 曹操(String), 20(Integer), test@pbteach.com(String)
[main] [com.pbteach.mp.mapper.UserMapper.insert]-[DEBUG] <==    Updates: 1
[main] [org.mybatis.spring.SqlSessionUtils]-[DEBUG] Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@411291e5]
result = 1
1122045867793072130

可以看到，數據已經寫入到了數據庫，但是，id的值不正確，我們期望的是數據庫自增長，實際是MP生成了id的值寫入到了數據庫。

如何設置id的生成策略呢？

MP支持的id策略：

package com.baomidou.mybatisplus.annotation;

import lombok.Getter;

/**
 * 生成ID類型枚舉類
 *
 * @author hubin
 * @since 2015-11-10
 */
@Getter
public enum IdType {
    /**
     * 數據庫ID自增
     */
    AUTO(0),
    /**
     * 該類型為未設置主鍵類型
     */
    NONE(1),
    /**
     * 用戶輸入ID
     * <p>該類型可以通過自己注冊自動填充插件進行填充</p>
     */
    INPUT(2),

    /* 以下3種類型、只有當插入對象ID 為空，才自動填充。 */
    /**
     * 全局唯一ID (idWorker)
     */
    ID_WORKER(3),
    /**
     * 全局唯一ID (UUID)
     */
    UUID(4),
    /**
     * 字符串全局唯一ID (idWorker 的字符串表示)
     */
    ID_WORKER_STR(5);

    private final int key;

    IdType(int key) {
        this.key = key;
    }
}

修改User對象：

package com.pbteach.mp.pojo;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
@TableName("tb_user")
public class User {

    @TableId(type = IdType.AUTO) //指定id類型為自增長
    private Long id;
    private String userName;
    private String password;
    private String name;
    private Integer age;
    private String email;
}

數據插入成功：

@TableField
在MP中通過@TableField注解可以指定字段的一些屬性，常常解決的問題有2個：

1、對象中的屬性名和字段名不一致的問題（非駝峰）

2、對象中的屬性字段在表中不存在的問題

使用：

其他用法，如大字段不加入查詢字段：

效果：

更新操作

在MP中，更新操作有2種，一種是根據id更新，另一種是根據條件更新。

根據id更新
方法定義：

    /**
     * 根據 ID 修改
     *
     * @param entity 實體對象
     */
    int updateById(@Param(Constants.ENTITY) T entity);

測試：

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {

    @Autowired
    private UserMapper userMapper;

    @Test
    public void testUpdateById() {
        User user = new User();
        user.setId(6L); //主鍵
        user.setAge(21); //更新的字段

        //根據id更新，更新不為null的字段
        this.userMapper.updateById(user);
    }

}

結果：

[main] [com.pbteach.mp.mapper.UserMapper.updateById]-[DEBUG] ==>  Preparing: UPDATE tb_user SET age=? WHERE id=? 
[main] [com.pbteach.mp.mapper.UserMapper.updateById]-[DEBUG] ==> Parameters: 21(Integer), 6(Long)
[main] [com.pbteach.mp.mapper.UserMapper.updateById]-[DEBUG] <==    Updates: 1

根據條件更新

方法定義：

    /**
     * 根據 whereEntity 條件，更新記錄
     *
     * @param entity        實體對象 (set 條件值,可以為 null)
     * @param updateWrapper 實體對象封裝操作類（可以為 null,里面的 entity 用於生成 where 語句）
     */
    int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> updateWrapper);

測試用例：

package com.pbteach.mp;

import com.pbteach.mp.mapper.UserMapper;
import com.pbteach.mp.pojo.User;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import net.minidev.json.writer.UpdaterMapper;
import org.junit.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.List;

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {

    @Autowired
    private UserMapper userMapper;

    @Test
    public void testUpdate() {
        User user = new User();
        user.setAge(22); //更新的字段

        //更新的條件
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.eq("id", 6);

        //執行更新操作
        int result = this.userMapper.update(user, wrapper);
        System.out.println("result = " + result);
    }

}

或者，通過UpdateWrapper進行更新：

    @Test
    public void testUpdate() {
        //更新的條件以及字段
        UpdateWrapper<User> wrapper = new UpdateWrapper<>();
        wrapper.eq("id", 6).set("age", 23);

        //執行更新操作
        int result = this.userMapper.update(null, wrapper);
        System.out.println("result = " + result);
    }

測試結果：

[main] [com.pbteach.mp.mapper.UserMapper.update]-[DEBUG] ==>  Preparing: UPDATE tb_user SET age=? WHERE id = ? 
[main] [com.pbteach.mp.mapper.UserMapper.update]-[DEBUG] ==> Parameters: 23(Integer), 6(Integer)
[main] [com.pbteach.mp.mapper.UserMapper.update]-[DEBUG] <==    Updates: 1

均可達到更新的效果。

關於wrapper更多的用法后面會詳細講解。

刪除操作

deleteById

方法定義：

/**
 * 根據 ID 刪除
 *
 * @param id 主鍵ID
 */
int deleteById(Serializable id);

測試用例：

package com.pbteach.mp;

import com.pbteach.mp.mapper.UserMapper;
import org.junit.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;

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {

    @Autowired
    private UserMapper userMapper;

    @Test
    public void testDeleteById() {
        //執行刪除操作
        int result = this.userMapper.deleteById(6L);
        System.out.println("result = " + result);
    }

}

結果：

[main] [com.pbteach.mp.mapper.UserMapper.deleteById]-[DEBUG] ==>  Preparing: DELETE FROM tb_user WHERE id=? 
[main] [com.pbteach.mp.mapper.UserMapper.deleteById]-[DEBUG] ==> Parameters: 6(Long)
[main] [com.pbteach.mp.mapper.UserMapper.deleteById]-[DEBUG] <==    Updates: 1

數據被刪除。

deleteByMap
方法定義：

    /**
     * 根據 columnMap 條件，刪除記錄
     *
     * @param columnMap 表字段 map 對象
     */
    int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);

測試用例：

package com.pbteach.mp;

import com.pbteach.mp.mapper.UserMapper;
import org.junit.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.HashMap;
import java.util.Map;

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {

    @Autowired
    private UserMapper userMapper;

    @Test
    public void testDeleteByMap() {
        Map<String, Object> columnMap = new HashMap<>();
        columnMap.put("age",20);
        columnMap.put("name","張三");

        //將columnMap中的元素設置為刪除的條件，多個之間為and關系
        int result = this.userMapper.deleteByMap(columnMap);
        System.out.println("result = " + result);
    }

}

結果：

[main] [com.pbteach.mp.mapper.UserMapper.deleteByMap]-[DEBUG] ==>  Preparing: DELETE FROM tb_user WHERE name = ? AND age = ? 
[main] [com.pbteach.mp.mapper.UserMapper.deleteByMap]-[DEBUG] ==> Parameters: 張三(String), 20(Integer)
[main] [com.pbteach.mp.mapper.UserMapper.deleteByMap]-[DEBUG] <==    Updates: 0

delete

方法定義：

/**
 * 根據 entity 條件，刪除記錄
 *
 * @param wrapper 實體對象封裝操作類（可以為 null）
 */
int delete(@Param(Constants.WRAPPER) Wrapper<T> wrapper);

測試用例：

package com.pbteach.mp;

import com.pbteach.mp.mapper.UserMapper;
import com.pbteach.mp.pojo.User;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.junit.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.HashMap;
import java.util.Map;

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {

    @Autowired
    private UserMapper userMapper;

    @Test
    public void testDeleteByMap() {
        User user = new User();
        user.setAge(20);
        user.setName("張三");

        //將實體對象進行包裝，包裝為操作條件
        QueryWrapper<User> wrapper = new QueryWrapper<>(user);

        int result = this.userMapper.delete(wrapper);
        System.out.println("result = " + result);
    }

}

結果：

[main] [com.pbteach.mp.mapper.UserMapper.delete]-[DEBUG] ==>  Preparing: DELETE FROM tb_user WHERE name=? AND age=? 
[main] [com.pbteach.mp.mapper.UserMapper.delete]-[DEBUG] ==> Parameters: 張三(String), 20(Integer)
[main] [com.pbteach.mp.mapper.UserMapper.delete]-[DEBUG] <==    Updates: 0

deleteBatchIds

方法定義：

    /**
     * 刪除（根據ID 批量刪除）
     *
     * @param idList 主鍵ID列表(不能為 null 以及 empty)
     */
    int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);

測試用例：

package com.pbteach.mp;

import com.pbteach.mp.mapper.UserMapper;
import org.junit.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;

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {

    @Autowired
    private UserMapper userMapper;

    @Test
    public void testDeleteByMap() {
        //根據id集合批量刪除
        int result = this.userMapper.deleteBatchIds(Arrays.asList(1L,10L,20L));
        System.out.println("result = " + result);
    }

}

結果：

[main] [com.pbteach.mp.mapper.UserMapper.deleteBatchIds]-[DEBUG] ==>  Preparing: DELETE FROM tb_user WHERE id IN ( ? , ? , ? ) 
[main] [com.pbteach.mp.mapper.UserMapper.deleteBatchIds]-[DEBUG] ==> Parameters: 1(Long), 10(Long), 20(Long)
[main] [com.pbteach.mp.mapper.UserMapper.deleteBatchIds]-[DEBUG] <==    Updates: 1

查詢操作

MP提供了多種查詢操作，包括根據id查詢、批量查詢、查詢單條數據、查詢列表、分頁查詢等操作。

selectById

方法定義：

    /**
     * 根據 ID 查詢
     *
     * @param id 主鍵ID
     */
    T selectById(Serializable id);

測試用例：

package com.pbteach.mp;

import com.pbteach.mp.mapper.UserMapper;
import com.pbteach.mp.pojo.User;
import org.junit.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;

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {

    @Autowired
    private UserMapper userMapper;

    @Test
    public void testSelectById() {
        //根據id查詢數據
        User user = this.userMapper.selectById(2L);
        System.out.println("result = " + user);
    }

}

結果：

[main] [com.pbteach.mp.mapper.UserMapper.selectById]-[DEBUG] ==>  Preparing: SELECT id,user_name,password,name,age,email FROM tb_user WHERE id=? 
[main] [com.pbteach.mp.mapper.UserMapper.selectById]-[DEBUG] ==> Parameters: 2(Long)
[main] [com.pbteach.mp.mapper.UserMapper.selectById]-[DEBUG] <==      Total: 1

result = User(id=2, userName=lisi, password=123456, name=李四, age=20, email=test2@pbteach.com, address=null)

selectBatchIds

方法定義：

/**
 * 查詢（根據ID 批量查詢）
 *
 * @param idList 主鍵ID列表(不能為 null 以及 empty)
 */
List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);

測試用例：

package com.pbteach.mp;

import com.pbteach.mp.mapper.UserMapper;
import com.pbteach.mp.pojo.User;
import org.junit.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.List;

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {

    @Autowired
    private UserMapper userMapper;

    @Test
    public void testSelectBatchIds() {
        //根據id集合批量查詢
        List<User> users = this.userMapper.selectBatchIds(Arrays.asList(2L, 3L, 10L));
        for (User user : users) {
            System.out.println(user);
        }
    }

}

結果：

[main] [com.pbteach.mp.mapper.UserMapper.selectBatchIds]-[DEBUG] ==>  Preparing: SELECT id,user_name,password,name,age,email FROM tb_user WHERE id IN ( ? , ? , ? ) 
[main] [com.pbteach.mp.mapper.UserMapper.selectBatchIds]-[DEBUG] ==> Parameters: 2(Long), 3(Long), 10(Long)
[main] [com.pbteach.mp.mapper.UserMapper.selectBatchIds]-[DEBUG] <==      Total: 2

User(id=2, userName=lisi, password=123456, name=李四, age=20, email=test2@pbteach.com, address=null)
User(id=3, userName=wangwu, password=123456, name=王五, age=28, email=test3@pbteach.com, address=null)

selectOne

方法定義：

/**
 * 根據 entity 條件，查詢一條記錄
 *
 * @param queryWrapper 實體對象封裝操作類（可以為 null）
 */
T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

測試用例：

package com.pbteach.mp;

import com.pbteach.mp.mapper.UserMapper;
import com.pbteach.mp.pojo.User;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.junit.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;

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {

    @Autowired
    private UserMapper userMapper;

    @Test
    public void testSelectOne() {
        QueryWrapper<User> wrapper = new QueryWrapper<User>();
        wrapper.eq("name", "李四");

        //根據條件查詢一條數據，如果結果超過一條會報錯
        User user = this.userMapper.selectOne(wrapper);
        System.out.println(user);
    }

}

結果：

[main] [com.pbteach.mp.mapper.UserMapper.selectOne]-[DEBUG] ==>  Preparing: SELECT id,user_name,password,name,age,email FROM tb_user WHERE name = ? 
[main] [com.pbteach.mp.mapper.UserMapper.selectOne]-[DEBUG] ==> Parameters: 李四(String)
[main] [com.pbteach.mp.mapper.UserMapper.selectOne]-[DEBUG] <==      Total: 1

User(id=2, userName=lisi, password=123456, name=李四, age=20, email=test2@pbteach.com, address=null)

selectCount

方法定義：

/**

根據 Wrapper 條件，查詢總記錄數
@param queryWrapper 實體對象封裝操作類（可以為 null）
*/
Integer selectCount(@Param(Constants.WRAPPER) Wrapper queryWrapper);

測試用例：

package com.pbteach.mp;

import com.pbteach.mp.mapper.UserMapper;
import com.pbteach.mp.pojo.User;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.junit.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;

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {

    @Autowired
    private UserMapper userMapper;

    @Test
    public void testSelectCount() {
        QueryWrapper<User> wrapper = new QueryWrapper<User>();
        wrapper.gt("age", 23); //年齡大於23歲

        //根據條件查詢數據條數
        Integer count = this.userMapper.selectCount(wrapper);
        System.out.println("count = " + count);
    }

}

結果：

[main] [com.pbteach.mp.mapper.UserMapper.selectCount]-[DEBUG] ==>  Preparing: SELECT COUNT( 1 ) FROM tb_user WHERE age > ? 
[main] [com.pbteach.mp.mapper.UserMapper.selectCount]-[DEBUG] ==> Parameters: 23(Integer)
[main] [com.pbteach.mp.mapper.UserMapper.selectCount]-[DEBUG] <==      Total: 1

count = 2

selectList

方法定義：

/**
 * 根據 entity 條件，查詢全部記錄
 *
 * @param queryWrapper 實體對象封裝操作類（可以為 null）
 */
List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

測試用例：

package com.pbteach.mp;

import com.pbteach.mp.mapper.UserMapper;
import com.pbteach.mp.pojo.User;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.junit.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.List;

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {

    @Autowired
    private UserMapper userMapper;

    @Test
    public void testSelectList() {
        QueryWrapper<User> wrapper = new QueryWrapper<User>();
        wrapper.gt("age", 23); //年齡大於23歲

        //根據條件查詢數據
        List<User> users = this.userMapper.selectList(wrapper);
        for (User user : users) {
            System.out.println("user = " + user);
        }
    }

}

結果：

[main] [com.pbteach.mp.mapper.UserMapper.selectList]-[DEBUG] ==>  Preparing: SELECT id,user_name,password,name,age,email FROM tb_user WHERE age > ? 
[main] [com.pbteach.mp.mapper.UserMapper.selectList]-[DEBUG] ==> Parameters: 23(Integer)
[main] [com.pbteach.mp.mapper.UserMapper.selectList]-[DEBUG] <==      Total: 2

user = User(id=3, userName=wangwu, password=123456, name=王五, age=28, email=test3@pbteach.com, address=null)
user = User(id=5, userName=sunqi, password=123456, name=孫七, age=24, email=test5@pbteach.com, address=null)

selectPage

方法定義：

/**
 * 根據 entity 條件，查詢全部記錄（並翻頁）
 *
 * @param page         分頁查詢條件（可以為 RowBounds.DEFAULT）
 * @param queryWrapper 實體對象封裝操作類（可以為 null）
 */
IPage<T> selectPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

配置分頁插件：

package com.pbteach.mp;

import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@MapperScan("com.pbteach.mp.mapper") //設置mapper接口的掃描包
public class MybatisPlusConfig {

    /**
     * 分頁插件
     */
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        return new PaginationInterceptor();
    }
}

測試用例：

package com.pbteach.mp;

import com.pbteach.mp.mapper.UserMapper;
import com.pbteach.mp.pojo.User;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.junit.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.List;

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {

    @Autowired
    private UserMapper userMapper;

    @Test
    public void testSelectPage() {
        QueryWrapper<User> wrapper = new QueryWrapper<User>();
        wrapper.gt("age", 20); //年齡大於20歲

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

        //根據條件查詢數據
        IPage<User> iPage = this.userMapper.selectPage(page, wrapper);
        System.out.println("數據總條數：" + iPage.getTotal());
        System.out.println("總頁數：" + iPage.getPages());


        List<User> users = iPage.getRecords();
        for (User user : users) {
            System.out.println("user = " + user);
        }
    }

}

結果：

[main] [com.pbteach.mp.mapper.UserMapper.selectPage]-[DEBUG] ==>  Preparing: SELECT COUNT(1) FROM tb_user WHERE age > ? 
[main] [com.pbteach.mp.mapper.UserMapper.selectPage]-[DEBUG] ==> Parameters: 20(Integer)
[main] [com.pbteach.mp.mapper.UserMapper.selectPage]-[DEBUG] ==>  Preparing: SELECT id,user_name,password,name,age,email FROM tb_user WHERE age > ? LIMIT ?,? 
[main] [com.pbteach.mp.mapper.UserMapper.selectPage]-[DEBUG] ==> Parameters: 20(Integer), 0(Long), 1(Long)
[main] [com.pbteach.mp.mapper.UserMapper.selectPage]-[DEBUG] <==      Total: 1
[main] [org.mybatis.spring.SqlSessionUtils]-[DEBUG] Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@6ecd665]
數據總條數：3
總頁數：3
user = User(id=3, userName=wangwu, password=123456, name=王五, age=28, email=test3@pbteach.com, address=null)

SQL注入的原理

前面我們已經知道，MP在啟動后會將BaseMapper中的一系列的方法注冊到meppedStatements中，那么究竟是如何注入的呢？流程又是怎么樣的？下面我們將一起來分析下。

在MP中，ISqlInjector負責SQL的注入工作，它是一個接口，AbstractSqlInjector是它的實現類，實現關系如下：

在AbstractSqlInjector中，主要是由inspectInject()方法進行注入的，如下：

@Override
public void inspectInject(MapperBuilderAssistant builderAssistant, Class<?> mapperClass) {
    Class<?> modelClass = extractModelClass(mapperClass);
    if (modelClass != null) {
        String className = mapperClass.toString();
        Set<String> mapperRegistryCache = GlobalConfigUtils.getMapperRegistryCache(builderAssistant.getConfiguration());
        if (!mapperRegistryCache.contains(className)) {
            List<AbstractMethod> methodList = this.getMethodList();
            if (CollectionUtils.isNotEmpty(methodList)) {
                TableInfo tableInfo = TableInfoHelper.initTableInfo(builderAssistant, modelClass);
                // 循環注入自定義方法
                methodList.forEach(m -> m.inject(builderAssistant, mapperClass, modelClass, tableInfo));
            } else {
                logger.debug(mapperClass.toString() + ", No effective injection method was found.");
            }
            mapperRegistryCache.add(className);
        }
    }
}

在實現方法中，methodList.forEach(m -> m.inject(builderAssistant, mapperClass, modelClass, tableInfo));是關鍵，循環遍歷方法，進行注入。

最終調用抽象方法injectMappedStatement進行真正的注入：

    /**
     * 注入自定義 MappedStatement
     *
     * @param mapperClass mapper 接口
     * @param modelClass  mapper 泛型
     * @param tableInfo   數據庫表反射信息
     * @return MappedStatement
     */
    public abstract MappedStatement injectMappedStatement(Class<?> mapperClass, Class<?> modelClass, TableInfo tableInfo);

查看該方法的實現：

以SelectById為例查看：

public class SelectById extends AbstractMethod {

    @Override
    public MappedStatement injectMappedStatement(Class<?> mapperClass, Class<?> modelClass, TableInfo tableInfo) {
        SqlMethod sqlMethod = SqlMethod.LOGIC_SELECT_BY_ID;
        SqlSource sqlSource = new RawSqlSource(configuration, String.format(sqlMethod.getSql(),
            sqlSelectColumns(tableInfo, false),
            tableInfo.getTableName(), tableInfo.getKeyColumn(), tableInfo.getKeyProperty(),
            tableInfo.getLogicDeleteSql(true, false)), Object.class);
        return this.addSelectMappedStatement(mapperClass, sqlMethod.getMethod(), sqlSource, modelClass, tableInfo);
    }
}

可以看到，生成了SqlSource對象，再將SQL通過addSelectMappedStatement方法添加到meppedStatements中。

public abstract MappedStatement injectMappedStatement(Class<?> mapperClass, Class<?> modelClass, TableInfo tableInfo);1

// 查看該方法的實現：


//以SelectById為例查看：


public class SelectById extends AbstractMethod {

    @Override
    public MappedStatement injectMappedStatement(Class<?> mapperClass, Class<?> modelClass, TableInfo tableInfo) {
        SqlMethod sqlMethod = SqlMethod.LOGIC_SELECT_BY_ID;
        SqlSource sqlSource = new RawSqlSource(configuration, String.format(sqlMethod.getSql(),
            sqlSelectColumns(tableInfo, false),
            tableInfo.getTableName(), tableInfo.getKeyColumn(), tableInfo.getKeyProperty(),
            tableInfo.getLogicDeleteSql(true, false)), Object.class);
        return this.addSelectMappedStatement(mapperClass, sqlMethod.getMethod(), sqlSource, modelClass, tableInfo);
    }
}

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 mybatis-plus 增刪改查(普通) Mybatis-plus實現數據庫的增刪改查操作 SpringBoot整合Mybatis-plus實現增刪查改 springboot-mybatis plus增刪改查CURD操作 springmvc+mybatis的增刪改查入門 Mybatis(一）實現單表的增刪改查 mybatis反向生成sql，基本的增刪改查 Mybatis實現單表增刪改查操作 MyBatis初級實戰之二：增刪改查 mybatis 之動態sql 增刪改查