MyBatis-Plus | 充分不必要

一、什麼是 MyBatis-Plus

官網地址：點擊進入

MyBatis-Plys（簡稱 MP）是一個 MyBatis 的增強工具，在MyBatis 的基礎上只做增強不做改變，爲簡化開發、提高效率而生。

二、爲什麼要用 MyBatis-Plus

MP的特性：

• 無侵入： 只做增強不做改變，引入它不會對現有工程產生影響，如絲般順滑
• 損耗小： 啓動即會自動注入基本的 CRUD，性能基本無損耗，直接面向對象操作
• 強大的 CRUD 操作： 通過 Lambda 表達式，方便的編寫各類查詢條件，無需再擔心字段寫錯
• 支持主鍵自動生成： 支持多達4種主鍵策略(內含分佈式唯一 ID 生成器 - Sequence)，可自由配置，完美解決主鍵問題
• 支持 ActiveRecord 模式： 支持 ActiveRecord 形式調用，實體類只需要繼承 Model 類即可進行強大的 CRUD 操作
• 支持自定義全局通用操作： 支持全局通用方法注入(Write once,use anywhere)
• 內置代碼生成器： 採用代碼或者 Maven 插件可快速生成Mapper、Model、Service、Controller 層代碼，支持模板引擎，更有超多自定義配置等您來使用
• 內置分頁插件： 基於MyBatis 物理分頁，開發者無需關心具體操作，配置好插件之後，寫分頁等同於普通 List 查詢
• 分頁插件支持多種數據庫： 支持MySQL、MariaDB、Oracle、DB2、H2、HSQL、SQLite、Postgre、SQL、Server等多種數據庫
• 內置性能分析插件： 可輸出 Sql 語句以及執行時間，建議開發測試時啓用該功能，能快速揪出慢查詢
• 內置全局攔截插件： 提供全表 delete、update 操作智能分析阻斷，也可自定義攔截規則，預防誤操作

支持數據庫

• mysql 、mariadb 、oracle 、db2 、h2 、hsql 、sqlite 、postgresql 、sqlserver 、presto 、Gauss 、Firebird
• Phoenix 、clickhouse 、Sybase ASE 、 OceanBase 、達夢數據庫 、虛谷數據庫 、人大金倉數據庫 、南大通用數據庫

三、測試環境

3.1.創建並初始化數據庫

CREATE DATABASE TQYL_MP

CREATE TABLE user
(
id BIGINT(20) NOT NULL COMMENT '主鍵ID',
name VARCHAR(30) NULL DEFAULT NULL COMMENT '姓名',
age INT(11) NULL DEFAULT NULL COMMENT '年齡',
email VARCHAR(50) NULL DEFAULT NULL COMMENT '郵箱',
PRIMARY KEY (id)
);

INSERT INTO user (id, name, age, email) VALUES
(1, 'Jone', 18, '[email protected]'),
(2, 'Jack', 20, '[email protected]'),
(3, 'Tom', 28, '[email protected]'),
(4, 'Sandy', 21, '[email protected]'),
(5, 'Billie', 24, '[email protected]');

3.2.初始化 Spring Boot工程

• 步驟一：

• 步驟二：

• 步驟三：

後面就直接next

3.3.添加依賴

 <!--簡化代碼的工具包-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency> <!--mybatis-plus的springboot支持-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.1.1</version>
        </dependency> <!--mysql驅動-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
            <scope>test</scope>
        </dependency>

3.4.application.yml

spring:
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/tqyl_mp?useUnicode=true&characterEncoding=utf8&serverTimezone=UTC
    username: root
    password: 1234

3.5.編寫 pojo

package com.tqyl.domain;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import javax.persistence.Column;
import javax.persistence.Id;
import javax.persistence.Table;
import java.io.Serializable;

@Data
@NoArgsConstructor
@AllArgsConstructor
@Table(name = "`user`")
public class User implements Serializable {
    /**
     * 主鍵ID
     */
    @Id
    @Column(name = "id")
    private Long id;

    /**
     * 姓名
     */
    @Column(name = "`name`")
    private String name;

    /**
     * 年齡
     */
    @Column(name = "age")
    private Integer age;

    /**
     * 郵箱
     */
    @Column(name = "email")
    private String email;

    private static final long serialVersionUID = 1L;
}

3.6.Mapper

package com.tqyl.dao;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.tqyl.domain.User;
import org.apache.ibatis.annotations.Mapper;


@Mapper
public interface UserMapper extends BaseMapper<User> {
    
}

3.7.啓動類

package com.tqyl;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@MapperScan("com.tqyl.dao")
@SpringBootApplication
public class TqylMpApplication {
    public static void main(String[] args) {
        SpringApplication.run(TqylMpApplication.class, args);
    }
}

3.8.測試類

package com.tqyl;

import com.tqyl.dao.UserMapper;
import com.tqyl.domain.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;

/**
 * @author 庭前雲落
 * @Date 2020/9/15 14:17
 * @description
 */
@RunWith(SpringRunner.class)
@SpringBootTest
public class TqylTest {

    @Autowired
    private UserMapper userMapper;

    @Test
    public void testSelect(){
        System.out.println("-----------華麗的分割線------------");
       List<User> ulist = userMapper.selectList(null);
        for (User user : ulist) {
            System.out.println(user);
        }
    }
}

四、CRUD 接口

Mapper CRUD 接口

• 通用 CURD 封裝 BaseMapper 接口，爲 Mybatis-Plus 啓動時自動解析實體表關係映射轉換爲 Mybatis 內部對象注入容器
• 泛型 T 爲任意實體對象
• 參數 Serializable 爲任意類型主鍵 Mybatis-Plus 不推薦使用複合主鍵約定每一張表都有自己的唯一 id 主鍵
• 對象 Wrapper 爲條件構造器

1、Insert

// 插入一條記錄
int insert(T entity);

TEST

  @Test
    public void testInsert(){
        User user = new User();
        user.setAge(20);
        user.setEmail("[email protected]");
        user.setName("庭前雲落");
        //返回的result是受影響的行數，並不是自增後的id
        int result = userMapper.insert(user);
        System.out.println("result="+result);
        //自增後的id會回填到對象中
        System.out.println(user.getId());
    }

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

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

MP 支持的 id 策略：

public enum IdType {
    //數據庫ID自增  
    AUTO(0),
    //該類型爲未設置主鍵類型
    NONE(1),
    //用戶輸入ID，該類型可以通過自己註冊自動填充插件進行填充
    INPUT(2),
    /* 以下3種類型、只有當插入對象ID 爲空，才自動填充。 */
    /*** 全局唯一ID (idWorker) */
    ID_WORKER(3),
    /*** 全局唯一ID (UUID) */
    UUID(4),
    /*** 字符串全局唯一ID (idWorker 的字符串表示) */
    ID_WORKER_STR(5);

    private final int key;

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

修改後的 User ID 類型：

數據插入成功：

擴展: @TableField

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

1、對象中的屬性名和字段名不一致的問題(非駝峯)

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

@TableField(value="email")//解決字段名不一致
@TableField(exist=false)//該字段在數據庫表中不存在

2、UPDATE

// 根據 whereEntity 條件，更新記錄
int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> updateWrapper);
// 根據 ID 修改
int updateById(@Param(Constants.ENTITY) T entity);

類型	參數名	描述
T	entity	實體對象 (set 條件值,可爲 null)
Wrapper<T>	updateWrapper	實體對象封裝操作類（可以爲 null,裏面的 entity 用於生成 where 語句）

根據 ID 修改

// 根據 ID 修改
int updateById(@Param(Constants.ENTITY) T entity);

測試：

    @Test
    public void testUpdateById(){
        User user = new User();
        user.setId(6L);//主鍵
        user.setName("庭前雲落的修改");

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

根據條件更新

// 根據 whereEntity 條件，更新記錄
int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> updateWrapper);

測試：

    @Test
    public void testUpdate(){
        User user = new User();
        //更新的字段
        user.setAge(122);
        //更新的條件
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.eq("id",6);

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

OR，通過 UpdateWrapper進行操作：

    @Test
    public void testUpdate2(){
        //更新的條件
        UpdateWrapper<User> wrapper = new UpdateWrapper<>();
        wrapper.eq("id",6).set("age",23);
        
        //執行更新操作
        int result = userMapper.update(null,wrapper);
        System.out.println("result="+result);
    }

3、DELETE

// 根據 entity 條件，刪除記錄
int delete(@Param(Constants.WRAPPER) Wrapper<T> wrapper);
// 刪除（根據ID 批量刪除）
int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
// 根據 ID 刪除
int deleteById(Serializable id);
// 根據 columnMap 條件，刪除記錄
int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);

類型	參數名	描述
Wrapper<T>	wrapper	實體對象封裝操作類（可以爲 null）
Collection<? extends Serializable>	idList	主鍵ID列表(不能爲 null 以及 empty)
Serializable	id	主鍵ID
Map<String, Object>	columnMap	表字段 map 對象

deleteById

// 根據 ID 刪除
int deleteById(Serializable id);

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

deleteByMap

// 根據 columnMap 條件，刪除記錄
int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);

    public void testDeleteByMap(){
        HashMap<String, Object> columnMap = new HashMap<>();
        columnMap.put("age",20);
        columnMap.put("name","Jack");

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

    }

delete

// 根據 entity 條件，刪除記錄
int delete(@Param(Constants.WRAPPER) Wrapper<T> wrapper);

    @Test
    public void testDelete(){
        User user = new User();
        user.setAge(21);
        user.setName("Sandy");

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

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

deleteBatchlds

// 刪除（根據ID 批量刪除）
int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);

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

4、SELECT

// 根據 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);

類型	參數名	描述
Serializable	id	主鍵ID
Wrapper<T>	queryWrapper	實體對象封裝操作類（可以爲 null）
Collection<? extends Serializable>	idList	主鍵ID列表(不能爲 null 以及 empty)
Map<String, Object>	columnMap	表字段 map 對象
IPage<T>	page	分頁查詢條件（可以爲 RowBounds.DEFAULT）

selectById

// 根據 ID 查詢
T selectById(Serializable id);

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

selectBatchlds

// 查詢（根據ID 批量查詢）
List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);

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

selectOne

// 根據 entity 條件，查詢一條記錄
T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

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

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

selectCount

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

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

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

selectList

// 根據 entity 條件，查詢全部記錄
List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);

    @Test
    public void testSelectList(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        //年齡大於23歲
        wrapper.gt("age",23);
        //根據條件查詢數據
        List<User> ulist = userMapper.selectList(wrapper);
        for (User user : ulist) {
            System.out.println("user="+user);
        }
    }

selectPage

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

配置分頁插件：

package com.tqyl.config;

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;

/**
 * @author 庭前雲落
 * @Date 2020/9/16 9:40
 * @description
 */
@Configuration
@MapperScan("com.tqyl.dao")//設置mapper接口的掃描包
public class MybatisPlusConfig {

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

測試用例：

    @Test
    public void testSelectPage(){
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.gt("age",20);

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

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

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

五、SQL注入器

注入器配置

全局配置 sqlInjector 用於注入 ISqlInjector 接口的子類，實現自定義方法注入

• SQL自動注入器接口 ISqlInjector

  public interface ISqlInjector {
  
      /**
       * <p>
       * 檢查SQL是否注入(已經注入過不再注入)
       * </p>
       *
       * @param builderAssistant mapper 信息
       * @param mapperClass      mapper 接口的 class 對象
       */
      void inspectInject(MapperBuilderAssistant builderAssistant, Class<?> mapperClass);
  }
  

  自定義自己的通用方法可以實現接口 ISqlInjector 也可以繼承抽象類 AbstractSqlInjector 注入通用方法 SQL 語句 然後繼承 BaseMapper添加到自定義方法，全局配置 sqlInjector 注入 MP會自動講類所有方法注入到 mybatis 容器中。

六、條件構造器

說明

• 以下出現的第一個入參 boolean condition 表示該條件是否加入最後生成的 sql 中

• 以下代碼塊內的多個方法均從上往下補全個別 boolean 類型的入參，默認爲 true

• 以下方法在入參中出現的 R 爲泛型，普通 wrapper 中是 String，在LambdaWrapper中是函數

  (例：Entity::getId，Entity爲實體類，getId 爲字段 id的 getMethodsd)

• 以下方法入參中的R column均表示數據庫字段,當R具體類型爲String時則爲數據庫字段名(字段名是數據庫關鍵字的自己用轉義符包裹!)!而不是實體類數據字段名!!!,另當R具體類型爲SFunction時項目runtime不支持eclipse自家的編譯器!!!

• 以下舉例均爲使用普通wrapper,入參爲Map和List的均以json形式表現!

• 使用中如果入參的Map或者List爲空,則不會加入最後生成的sql中!!!

allEq

allEq(Map<R, V> params)
allEq(Map<R, V> params, boolean null2IsNull)
allEq(boolean condition, Map<R, V> params, boolean null2IsNull)

• 全部eq(或個別 isNull)

個別參數說明：

params : key爲數據庫字段名,value爲字段值 null2IsNull : 爲true則在map的value爲null時調用 isNull 方法,爲false時則忽略value爲null的

• 例1: allEq({id:1,name:"老王",age:null})--->id = 1 and name = '老王' and age is null
• 例2: allEq({id:1,name:"老王",age:null}, false)--->id = 1 and name = '老王'

allEq(BiPredicate<R, V> filter, Map<R, V> params)
allEq(BiPredicate<R, V> filter, Map<R, V> params, boolean null2IsNull)
allEq(boolean condition, BiPredicate<R, V> filter, Map<R, V> params, boolean null2IsNull) 

個別參數說明：

filter：過濾函數，是否允許字段傳入對比條件中

params 與 null2IsNull：同上

• 例1: allEq((k,v) -> k.indexOf("a") >= 0, {id:1,name:"老王",age:null})--->name = '老王' and age is null
• 例2: allEq((k,v) -> k.indexOf("a") >= 0, {id:1,name:"老王",age:null}, false)--->name = '老王'

測試

 @Test
    public void testAllEq() {
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        //設置條件
        HashMap<String, Object> params = new HashMap<>();
        params.put("name", "Jack");
        params.put("age", 20);
        params.put("email", null);

        //SELECT * FROM tb_user WHERE password IS NULL AND name = ? AND age = ?
        wrapper.allEq(params);
        
        //SELECT * FROM tb_user WHERE name = ? AND age = ?
        wrapper.allEq(params, false);

        //SELECT * FROM tb_user WHERE name = ? AND age = ?
        wrapper.allEq(k, v)->(k.equals("name") || k.equals("age")), params);

        List<User> users = this.userMapper.selectList(wrapper);
        for (User user : users) {
            System.out.println(user);
        }
    

6.1.基本比較操作

• eq
  • 等於 =
  • 例: eq("name", "老王")--->name = '老王'

eq(R column, Object val)
eq(boolean condition, R column, Object val)

• ne
  • 不等於 <>
  • 例: ne("name", "老王")--->name <> '老王'

ne(R column, Object val)
ne(boolean condition, R column, Object val)

• gt
  • 大於 >
  • 例: gt("age", 18)--->age > 18

gt(R column, Object val)
gt(boolean condition, R column, Object val)

• ge
  • 大於等於 >=
  • 例: ge("age", 18)--->age >= 18

ge(R column, Object val)
ge(boolean condition, R column, Object val)

• lt
  • 小於 <
  • 例: lt("age", 18)--->age < 18

lt(R column, Object val)
lt(boolean condition, R column, Object val)

• le
  • 小於等於 <=
  • 例: le("age", 18)--->age <= 18

le(R column, Object val)
le(boolean condition, R column, Object val)

• between
  • BETWEEN 值1 AND 值2
  • 例: between("age", 18, 30)--->age between 18 and 30

between(R column, Object val1, Object val2)
between(boolean condition, R column, Object val1, Object val2)

• notBetween
  • NOT BETWEEN 值1 AND 值2
  • 例: notBetween("age", 18, 30)--->age not between 18 and 30

notBetween(R column, Object val1, Object val2)
notBetween(boolean condition, R column, Object val1, Object val2)

• in
• 字段 IN (value.get(0), value.get(1), ...)
• 例: in("age",{1,2,3})--->age in (1,2,3)

in(R column, Collection<?> value)
in(boolean condition, R column, Collection<?> value)

• 字段 IN (v0, v1, ...)
• 例: in("age", 1, 2, 3)--->age in (1,2,3)

in(R column, Object... values)
in(boolean condition, R column, Object... values)

• notIn
• 字段 NOT IN (value.get(0), value.get(1), ...)
• 例: notIn("age",{1,2,3})--->age not in (1,2,3)

notIn(R column, Collection<?> value)
notIn(boolean condition, R column, Collection<?> value)

• 字段 NOT IN (v0, v1, ...)
• 例: notIn("age", 1, 2, 3)--->age not in (1,2,3)

notIn(R column, Object... values)
notIn(boolean condition, R column, Object... values)

測試

    @Test
    public void testEq() {
        QueryWrapper<User> wrapper = new QueryWrapper<>();

        //SELECT id,name,age,email FROM tb_user WHERE email = ? AND age >= ? AND name IN (?,?,?)
        wrapper.eq("email", "[email protected]").ge("age", 20).in("name", "Jack", "Tom", "Sandy");
        List<User> ulist = userMapper.selectList(wrapper);
        for (User user : ulist) {
            System.out.println(ulist);
        }
    }

6.2.模糊查詢

• like
  • LIKE ' %值%'
  • 例：like("name"，"王") --> name like '%王%'

like(R column, Object val)
like(boolean condition, R column, Object val)

• notLike
  • NOT LIKE '%值%'
  • 例：notLike("name","王") --> name like '%王'

notLike(R column, Object val)
notLike(boolean condition, R column, Object val)

• likeLeft
  • LIKE '%值'
  • 例: likeLeft("name", "王") ---> name like '%王'

likeLeft(R column, Object val)
likeLeft(boolean condition, R column, Object val)

• likeRight
  • LIKE '值%'
  • 例：likeRight("name"，"王") --> name like '王%'

likeRight(R column, Object val)
likeRight(boolean condition, R column, Object val)

測試

    @Test
    public void testLike() {
        QueryWrapper<User> wrapper = new QueryWrapper<>();

        // SELECT id,name,age,email FROM tb_user WHERE name LIKE ?
        // Parameters: %J%(String)

        wrapper.like("name","J");

        List<User> ulist = userMapper.selectList(wrapper);
        for (User user : ulist) {
            System.out.println(user);
        }
    }

6.3.排序

• order By

  • 排序：ORDER BY 字段...
  • 例：orderBy(true, true, "id", "name") ---> order by id ASC,name ASC

  orderBy(boolean condition, boolean isAsc, R... columns)
  

• orderByAsc

  • 排序：ORDER BY 字段，.... ASC
  • 例：orderByAsc("id", "name") ---> order by id ASC,name ASC

  orderByAsc(R... columns)
  orderByAsc(boolean condition, R... columns)
  

• orderByDesc

  • 排序：ORDER BY 字段，... DESC
  • 例: orderByDesc("id", "name") ---> order by id DESC,name DESC

  orderByDesc(R... columns)
  orderByDesc(boolean condition, R... columns)
  

      @Test
      public void testOrder(){
          QueryWrapper<User> wrapper = new QueryWrapper<>();
  
          //SELECT id,user_name,name,age,email FROM tb_user ORDER BY age DESC
           wrapper.orderByDesc("age");
  
          List<User> ulist = userMapper.selectList(wrapper);
          for (User user : ulist) {
              System.out.println(user);
          }
      }
  

6.4.邏輯查詢

• or
  • 拼接 OR
  • 主動調用 or 表示緊接着下一個方法不是用 and 連接!(不調用 or 則默認爲使用 and 連接)
• and
  • AND 嵌套
  • 例: and(i -> i.eq("name", "李白").ne("status", "活着")) ---> and (name = '李白' and status <> '活着')

    @Test
    public void testAndOr() {
        QueryWrapper<User> wrapper = new QueryWrapper<>();

        //SELECT id,name,age,email FROM tb_user WHERE name = ? OR age = ?
        wrapper.eq("name", "Jone").or().eq("age", 18);
        List<User> ulist = userMapper.selectList(wrapper);
        for (User user : ulist) {
            System.out.println(ulist);
        }
    }