一.簡介

官網網址:http://mp.baomidou.com/
參考教程：http://mp.baomidou.com/guide/

二.特性

無侵入：只做增強不做改變，引入它不會對現有工程產生影響，如絲般順滑
損耗小：啟動即會自動注入基本 CURD，效能基本無損耗，直接面向物件操作
強大的 CRUD 操作：內建通用 Mapper、通用 Service，僅僅通過少量配置即可實現單表大部分 CRUD 操作，更有強大的條件構造器，滿足各類使用需求
支援 Lambda 形式呼叫：通過 Lambda 表示式，方便的編寫各類查詢條件，無需再擔心欄位寫錯
支援多種資料庫：支援 MySQL、MariaDB、Oracle、DB2、H2、HSQL、SQLite、Postgre、SQLServer2005、SQLServer 等多種資料庫

支援主鍵自動生成：支援多達 4 種主鍵策略（內含分散式唯一 ID 生成器 - Sequence），可自由配置，完美解決主鍵問題
支援 XML 熱載入：Mapper 對應的 XML 支援熱載入，對於簡單的 CRUD 操作，甚至可以無 XML 啟動
支援 ActiveRecord 模式：支援 ActiveRecord 形式呼叫，實體類只需繼承 Model 類即可進行強大的 CRUD 操作
支援自定義全域性通用操作：支援全域性通用方法注入（ Write once,use anywhere ）
支援關鍵詞自動轉義：支援資料庫關鍵詞（order、key…）自動轉義，還可自定義關鍵詞
內建程式碼生成器：採用程式碼或者 Maven 外掛可快速生成 Mapper 、 Model 、 Service 、 Controller 層程式碼，支援模板引擎，更有超多自定義配置等您來使用
內建分頁外掛：基於 MyBatis 物理分頁，開發者無需關心具體操作，配置好外掛之後，寫分頁等同於普通 List 查詢
內建效能分析外掛：可輸出 Sql 語句以及其執行時間，建議開發測試時啟用該功能，能快速揪出慢查詢
內建全域性攔截外掛：提供全表 delete 、 update 操作智慧分析阻斷，也可自定義攔截規則，預防誤操作
內建 Sql 注入剝離器：支援 Sql 注入剝離，有效預防 Sql 注入攻擊

三.MyBatis_plus入門

①建立並初始化資料庫
mybatis_plus

②建立 User 表
其表結構如下:

其對應的資料庫 Schema 指令碼如下:

DROP TABLE IF EXISTS user;
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)
);

其對應的資料庫 Data 指令碼如下：

DELETE FROM user;
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]');

四.初始化工程

使用 Spring Initializr 快速初始化一個 Spring Boot 工程

Group：com.atguigu
Artifact：mybatis-plus
版本：2.2.1.RELEASE

五.新增依賴

①引入依賴
spring-boot-starter、spring-boot-starter-test
新增：mybatis-plus-boot-starter、MySQL、lombok、
在專案中使用Lombok可以減少很多重複程式碼的書寫。比如說getter/setter/toString等方法的編寫

<dependencies>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter</artifactId>
 </dependency>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-test</artifactId>
 <scope>test</scope>
 <exclusions>
 <exclusion>
 <groupId>org.junit.vintage</groupId>
 <artifactId>junit-vintage-engine</artifactId>
 </exclusion>
 </exclusions>
 </dependency>
 <!--mybatis-plus-->
 <dependency>
 <groupId>com.baomidou</groupId>
 <artifactId>mybatis-plus-boot-starter</artifactId>
 <version>3.0.5</version>
 </dependency>
 <!--mysql-->
 <dependency>
 <groupId>mysql</groupId>
 <artifactId>mysql-connector-java</artifactId>
 </dependency>
 <!--lombok用來簡化實體類-->
 <dependency>
 <groupId>org.projectlombok</groupId>
 <artifactId>lombok</artifactId>
 </dependency>
 </dependencies>

注意：引入 MyBatis-Plus 之後請不要再次引入 MyBatis 以及 MyBatis-Spring，以避免因版本差異導致的問題。

②idea中安裝lombok外掛
1).idea2020版本

六.配置

在 application.properties 配置檔案中新增 MySQL 資料庫的相關配置：

mysql5:

#mysql資料庫連線
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/mybatis_plus
spring.datasource.username=root
spring.datasource.password=123456

mysql8以上（spring boot 2.1）:
注意：driver和url的變化

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/mybatis_plus?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=UTF-8
spring.datasource.username=root
spring.datasource.password=123456

注意：
1、這裡的 url 使用了 ?serverTimezone=GMT%2B8 字尾，因為Spring Boot 2.1 集成了 8.0版本的jdbc驅動，這個版本的 jdbc 驅動需要新增這個字尾，否則執行測試用例報告如下錯誤：

java.sql.SQLException: The server time zone value ‘Öйú±ê׼ʱ¼ä' is unrecognized or represents more

2、這裡的 driver-class-name 使用了 com.mysql.cj.jdbc.Driver ，在 jdbc 8 中 建議使用這個驅動，之前的 com.mysql.jdbc.Driver 已經被廢棄，否則執行測試用例的時候會有 WARN 資訊

七.編寫程式碼

①主類
在 Spring Boot 啟動類中新增 @MapperScan 註解，掃描 Mapper 資料夾
注意：掃描的包名根據實際情況修改

@SpringBootApplication
@MapperScan("com.mybatisplus.mapper")
public class MybatisPlusApplication {
 ......
}

②實體
建立包 entity 編寫實體類 User.java（此處使用了 Lombok 簡化程式碼）

//@Data:該註解使用在類上，該註解會提供getter、setter、equals、canEqual、hashCode、toString方法。
@Data
public class User {
 private Long id;
 private String name;
 private Integer age;
 private String email;
}

@Data:該註解使用在類上，該註解會提供getter、setter、equals、canEqual、hashCode、toString方法。
Lombok使用參考：https://blog.csdn.net/motui/article/details/79012846

③mapper

建立包 mapper 編寫Mapper 介面： UserMapper.java

public interface UserMapper extends BaseMapper<User> {
 
}

八.開始使用

新增測試類，進行功能測試：

@SpringBootTest
public class MybatisPlusApplicationTests {
 @Autowired
 private UserMapper userMapper;
 @Test
 public void testSelectList() {
 System.out.println(("----- selectAll method test ------"));
 //UserMapper 中的 selectList() 方法的引數為 MP 內建的條件封裝器 Wrapper
 //所以不填寫就是無任何條件
 List<User> users = userMapper.selectList(null);
 users.forEach(System.out::println);
 }
}

注意：

IDEA在 userMapper 處報錯，因為找不到注入的物件，因為類是動態建立的，但是程式可以正確的執行。

為了避免報錯，可以在 dao 層 的介面上新增----- @Repository 注

控制檯輸出：

User(id=1,name=Jone,age=18,[email protected])
User(id=2,name=Jack,age=20,[email protected])
User(id=3,name=Tom,age=28,[email protected])
User(id=4,name=Sandy,age=21,[email protected])
User(id=5,name=Billie,age=24,[email protected])

通過以上幾個簡單的步驟，我們就實現了 User 表的 CRUD 功能，甚至連 XML 檔案都不用編寫！

九.配置日誌

檢視sql輸出日誌:在application.properties中加:

#mybatis日誌
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

在輸出臺中就有日誌了

十.MyBatisPlus的CRUD 介面

1、主鍵策略

（1）ID_WORKER
MyBatis-Plus預設的主鍵策略是：ID_WORKER 全域性唯一ID
參考資料：分散式系統唯一ID生成方案彙總：https://www.cnblogs.com/haoxinyue/p/5208136.html

（2）自增策略
要想主鍵自增需要配置如下主鍵策略
①.需要在建立資料表的時候設定主鍵自增
實體欄位中配置 @TableId(type = IdType.AUTO)

在User實體類中的id 上加

@TableId(type = IdType.AUTO)
private Long id;

要想影響所有實體的配置，可以設定全域性主鍵配置

#全域性設定主鍵生成策略
mybatis-plus.global-config.db-config.id-type=auto

其它主鍵策略：分析 IdType 原始碼可知

@Getter
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 int key;
 IdType(int key) {
 this.key = key;
 }
}

2.插入操作

在User實體類中加

//@TableId:MyBatis-Plus預設的主鍵策略是：ID_WORKER 全域性唯一ID
 @TableId(type = IdType.ID_WORKER)
 private Long id;

在測試類中

public class MybatisPlusApplicationTests {
 @Autowired
 private UserMapper userMapper;
 public void testInsert(){
 User user = new User();
 user.setName("Helen");
 user.setAge(18);
 user.setEmail("[email protected]");
 int result = userMapper.insert(user);
 System.out.println(result); //影響的行數
 System.out.println(user); //id自動回填
 }

注意：資料庫插入id值預設為：全域性唯一id

3.update

1、根據Id更新操作
**注意：**update時生成的sql自動是動態sql：UPDATE user SET age=? WHERE id=?

 @Test
 public void testUpdateById(){
 User user = new User();
 user.setId(1L);
 user.setAge(28);
 int result = userMapper.updateById(user);
 System.out.println(result);
 }

2、自動填充
專案中經常會遇到一些資料，每次都使用相同的方式填充，例如記錄的建立時間，更新時間等。
我們可以使用MyBatis Plus的自動填充功能，完成這些欄位的賦值工作：

（1）資料庫表中新增自動填充欄位
在User表中新增datetime型別的新的欄位 create_time、update_time
（2）實體上添加註解

@Data
public class User {
 @TableId(type = IdType.ID_WORKER)
 private Long id;
 private String name;
 private Integer age;
 private String email;

	//在資料庫中是create_time 在User實體類中是createTime,_t自動轉換T
 @TableField( fill=FieldFill.INSERT)
 private Date createTime;
 @TableField(fill = FieldFill.INSERT_UPDATE)
 private Date updateTime;
 }

（3）實現元物件處理器介面
注意：不要忘記新增 @Component 註解

package com.handler;

import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
import org.apache.ibatis.reflection.MetaObject;
import org.springframework.stereotype.Controller;

import java.util.Date;
@Component 
public class MyMetaObjectHandler implements MetaObjectHandler {
	 /**
 * 插入時時間
 * @param metaObject
 */
 @Override
 public void insertFill(MetaObject metaObject) {
 this.setFieldValByName("createTime",new Date(),metaObject);
 this.setFieldValByName("updateTime",metaObject);
 

 }
 /**
 * 修改時時間
 * @param metaObject
 */
 @Override
 public void updateFill(MetaObject metaObject) {
 this.setFieldValByName("updateTime",metaObject);

 }
}

（4）再次執行 測試 結果

4.樂觀鎖

**主要適用場景：**當要更新一條記錄的時候，希望這條記錄沒有被別人更新，也就是說實現執行緒安全的資料更新
樂觀鎖實現方式：

①取出記錄時，獲取當前version
②更新時，帶上這個version
③執行更新時， set version = newVersion where version = oldVersion
④如果version不對，就更新失敗

（1）資料庫中新增version欄位`在這裡插入程式碼片

ALTER TABLE `user` ADD COLUMN `version` INT

（2）實體類新增version欄位 :並新增 @Version 註解

@TableField(fill = FieldFill.INSERT)
3
private Integer version;

（3）元物件處理器介面新增version的insert預設值

@Controller
public class MyMetaObjectHandler implements MetaObjectHandler {
 /**
 * 插入時時間
 * @param metaObject
 */
 @Override
 public void insertFill(MetaObject metaObject) {
 this.setFieldValByName("createTime",metaObject);
 //看這裡
 this.setFieldValByName("version",1,metaObject);

 }

 /**
 * 修改時時間
 * @param metaObject
 */
 @Override
 public void updateFill(MetaObject metaObject) {
 this.setFieldValByName("updateTime",metaObject);

 }
}

特別說明:

支援的資料型別只有 int,Integer,long,Long,Date,Timestamp,LocalDateTime
整數型別下 newVersion = oldVersion + 1
newVersion 會回寫到 entity 中
僅支援 updateById(id) 與 update(entity,wrapper) 方法
在 update(entity,wrapper) 方法下,wrapper 不能複用!!!

（4）在 MybatisPlusConfig 中註冊 Bean
建立配置類

package com.config;

import com.baomidou.mybatisplus.core.injector.ISqlInjector;
import com.baomidou.mybatisplus.extension.injector.LogicSqlInjector;
import com.baomidou.mybatisplus.extension.plugins.OptimisticLockerInterceptor;
import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import com.baomidou.mybatisplus.extension.plugins.PerformanceInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;
import org.springframework.stereotype.Controller;

@Configuration
@MapperScan("com.mapper")
public class MyConfig {
 /**
 * 樂觀鎖外掛
 */
 @Bean
 public OptimisticLockerInterceptor optimisticLockerInterceptor() {
 return new OptimisticLockerInterceptor();
 }
 }

（5）測試樂觀鎖可以修改成功
測試後分析列印的sql語句，將version的數值進行了加1操作

/**
 * 測試 樂觀鎖外掛
 */
@Test
public void testOptimisticLocker() {
 //查詢
 User user = userMapper.selectById(1L);
 //修改資料
 user.setName("Helen Yao");
 user.setEmail("[email protected]");
 //執行更新
 userMapper.updateById(user);
}

（5）測試樂觀鎖修改失敗

/**
 * 測試樂觀鎖外掛 失敗
 */
@Test
public void testOptimisticLockerFail() {
 //查詢
 User user = userMapper.selectById(1L);
 //修改資料
 user.setName("Helen Yao1");
 user.setEmail("[email protected]");
 //模擬取出資料後，資料庫中version實際資料比取出的值大，即已被其它執行緒修改並更新了version
 user.setVersion(user.getVersion() - 1);
 //執行更新
 userMapper.updateById(user);
}

5.select

1、根據id查詢記錄

@Test
public void testSelectById(){
 User user = userMapper.selectById(1L);
 System.out.println(user);
}

2、通過多個id批量查詢
完成了動態sql的foreach的功能

@Test
public void testSelectBatchIds(){
 List<User> users = userMapper.selectBatchIds(Arrays.asList(1,2,3));
 users.forEach(System.out::println);
}

3、簡單的條件查詢
通過map封裝查詢條件(不怎麼用 看看就行)

@Test
public void testSelectByMap(){
 HashMap<String,Object> map = new HashMap<>();
 map.put("name","Helen");
 map.put("age",18);
 List<User> users = userMapper.selectByMap(map);
 users.forEach(System.out::println);
}

**注意：**map中的key對應的是資料庫中的列名。例如資料庫user_id，實體類是userId，這時map的key需要填寫user_id

4、分頁
MyBatis Plus自帶分頁外掛，只要簡單的配置即可實現分頁功能
（1）建立配置類
此時可以刪除主類中的 @MapperScan 掃描註解

@Configuration
@MapperScan("com.mapper")
public class MyConfig {

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

（2）測試selectPage分頁(自己用的)
測試：最終通過page物件獲取相關資料

 /**
 * 分頁查詢
 */
 @Test
 void pages(){
 //1.建立page物件
 //傳入兩個引數：當前 頁 和 每頁顯示記錄數
 Page<User> page=new Page<User>(1,5);
 //呼叫mp分頁查詢的方法
 //呼叫mp分頁查詢過程中，底層封裝
 //把分頁所有資料封裝到page物件裡面
 userMapper.selectPage(page,null);
 //通過page物件獲取分頁資料
 System.out.println(page.getCurrent());
 System.out.println(page.getRecords());
 System.out.println(page.getSize());
 System.out.println(page.getTotal());
 System.out.println(page.getPages());


 System.out.println(page.hasNext());
 System.out.println(page.hasPrevious());


 }

控制檯sql語句列印：SELECT id,email,create_time,update_time FROM user LIMIT 0,5

（3）測試selectMapsPage分頁：結果集是Map(zjd沒有用過)

@Test
public void testSelectMapsPage() {
 Page<User> page = new Page<>(1,5);
 IPage<Map<String,Object>> mapIPage = userMapper.selectMapsPage(page,null);
 //注意：此行必須使用 mapIPage 獲取記錄列表，否則會有資料型別轉換錯誤
 mapIPage.getRecords().forEach(System.out::println);
 System.out.println(page.getCurrent());
 System.out.println(page.getPages());
 System.out.println(page.getSize());
 System.out.println(page.getTotal());
 System.out.println(page.hasNext());
 System.out.println(page.hasPrevious());
}

6.delete

1、根據id刪除記錄

@Test
public void testDeleteById(){
 int result = userMapper.deleteById(8L);
 System.out.println(result);
}

2、批量刪除

@Test
 public void testDeleteBatchIds() {
 int result = userMapper.deleteBatchIds(Arrays.asList(8,9,10));
 System.out.println(result);
 }

3、簡單的條件查詢刪除

@Test
public void testDeleteByMap() {
 HashMap<String,18);
 int result = userMapper.deleteByMap(map);
 System.out.println(result);
}

4、*邏輯刪除

物理刪除：真實刪除，將對應資料從資料庫中刪除，之後查詢不到此條被刪除資料
邏輯刪除：假刪除，將對應資料中代表是否被刪除欄位狀態修改為“被刪除狀態”，之後在資料庫中仍舊能看到此條資料記錄
（1）資料庫中新增 deleted欄位

ALTER TABLE `user` ADD COLUMN `deleted` boolean

（2）實體類新增deleted 欄位
並加上 @TableLogic 註解 和 @TableField(fill = FieldFill.INSERT) 註解

@TableLogic
@TableField(fill = FieldFill.INSERT)
private Integer deleted;

（3）元物件處理器介面新增deleted的insert預設值

@Controller
public class MyMetaObjectHandler implements MetaObjectHandler {
 /**
 * 插入時時間
 * @param metaObject
 */
 @Override
 public void insertFill(MetaObject metaObject) {
 this.setFieldValByName("createTime",metaObject);
 this.setFieldValByName("version",metaObject);
 //看這裡********
 this.setFieldValByName("deleted",metaObject);

 }
}

（4）application.properties 加入配置
此為預設值，如果你的預設值和mp預設的一樣,該配置可無

mybatis-plus.global-config.db-config.logic-delete-value=1
mybatis-plus.global-config.db-config.logic-not-delete-value=0

（5）在 MyConfig 中註冊 Bean

@Bean
public ISqlInjector sqlInjector() {
 return new LogicSqlInjector();
}

（6）測試邏輯刪除
測試後發現，資料並沒有被刪除，deleted欄位的值由0變成了1
測試後分析列印的sql語句，是一條update
**注意：**被刪除資料的deleted 欄位的值必須是 0，才能被選取出來執行邏輯刪除的操作

/**
 * 測試 邏輯刪除
 */
@Test
public void testLogicDelete() {
 int result = userMapper.deleteById(1L);
 System.out.println(result);
}

（7）測試邏輯刪除後的查詢
MyBatis Plus中查詢操作也會自動新增邏輯刪除欄位的判斷

/**
 * 測試 邏輯刪除後的查詢：
 * 不包括被邏輯刪除的記錄
 */
@Test
public void testLogicDeleteSelect() {
 User user = new User();
 List<User> users = userMapper.selectList(null);
 users.forEach(System.out::println);

}

測試後分析列印的sql語句，包含 WHERE deleted=0
SELECT id,update_time,deleted FROM user WHERE deleted=0

7.效能分析

效能分析攔截器，用於輸出每條 SQL 語句及其執行時間
SQL 效能執行分析,開發環境使用，超過指定時間，停止執行。有助於發現問題

1、配置外掛
（1）引數說明
引數：maxTime： SQL 執行最大時長，超過自動停止執行，有助於發現問題。
引數：format： SQL是否格式化，預設false。
（2）在 MyConfig 中配置

/**
 * SQL 執行效能分析外掛
 * 開發環境使用，線上不推薦。 maxTime 指的是 sql 最大執行時長
 *
 * 三種環境
 *dev: 開發環境
 * test: 測試環境
 * prod: 生產環境
 *
 *
 */
 @Bean
 @Profile({"dev","test"})// 設定 dev test 環境開啟
 public PerformanceInterceptor performanceInterceptor() {
 PerformanceInterceptor performanceInterceptor = new PerformanceInterceptor();
 performanceInterceptor.setMaxTime(500);//ms/毫秒，超過此處設定的ms則sql不執行
 performanceInterceptor.setFormat(true);
 return performanceInterceptor;
 }

（3）Spring Boot 中設定dev環境

#環境設定：dev、test、prod
spring.profiles.active=dev

2、測試
（1）常規測試

/**
 * 測試 效能分析外掛
 */
@Test
public void testPerformance() {
 User user = new User();
 user.setName("我是Helen");
 user.setEmail("[email protected]");
 user.setAge(18);
 userMapper.insert(user);
}

輸出：

（2）將maxTime 改小之後再次進行測試

performanceInterceptor.setMaxTime(5);//ms，超過此處設定的ms不執行

如果執行時間過長，則丟擲異常：The SQL execution time is too large,
輸出:

8.其它

如果想進行復雜條件查詢，那麼需要使用條件構造器 Wapper，涉及到如下方法
1、delete
2、selectOne
3、selectCount
4、selectList
5、selectMaps
6、selectObjs
7、update

十一.條件構造器_wapper介紹

1.wapper介紹

Wrapper ： 條件構造抽象類，最頂端父類
AbstractWrapper ： 用於查詢條件封裝，生成 sql 的 where 條件
QueryWrapper ： Entity 物件封裝操作類，不是用lambda語法
UpdateWrapper ： Update 條件封裝，用於Entity物件更新操作
AbstractLambdaWrapper ： Lambda 語法使用 Wrapper統一處理解析 lambda 獲取 column。
LambdaQueryWrapper ：看名稱也能明白就是用於Lambda語法使用的查詢Wrapper
LambdaUpdateWrapper ： Lambda 更新封裝Wrapper

2.AbstractWrapper

注意：以下條件構造器的方法入參中的 column 均表示資料庫欄位
1、ge、gt、le、lt、isNull、isNotNull

@Test
public void testDelete() {
 QueryWrapper<User> queryWrapper = new QueryWrapper<>();
 queryWrapper
 .isNull("name")
 .ge("age",12)
 .isNotNull("email");
 int result = userMapper.delete(queryWrapper);
 System.out.println("delete return count = " + result);
}

SQL：UPDATE user SET deleted=1 WHERE deleted=0 AND name IS NULL AND age >= ? AND email IS NOT NULL

2、eq、ne
注意:seletOne 返回的是一條實體記錄，當出現多條時會報錯

@Test
public void testSelectOne() {

 QueryWrapper<User> queryWrapper = new QueryWrapper<>();
 queryWrapper.eq("name","Tom");
 User user = userMapper.selectOne(queryWrapper);
 System.out.println(user);
}

SELECT id,deleted,version FROM user WHERE deleted=0 AND name = ?
3、between、notBetween
包含大小邊界

@Test
public void testSelectCount() {
 QueryWrapper<User> queryWrapper = new QueryWrapper<>();
 queryWrapper.between("age",30);
 Integer count = userMapper.selectCount(queryWrapper);
 System.out.println(count);
}

SELECT COUNT(1) FROM user WHERE deleted=0 AND age BETWEEN ? AND ?
4、allEq

@Test
public void testSelectList() {
 QueryWrapper<User> queryWrapper = new QueryWrapper<>();
 Map<String,Object> map = new HashMap<>();
 map.put("id",2);
 map.put("name","Jack");
 map.put("age",20);
 queryWrapper.allEq(map);
 List<User> users = userMapper.selectList(queryWrapper);
 users.forEach(System.out::println);
}

SELECT id,version
FROM user WHERE deleted=0 AND name = ? AND id = ? AND age = ?

5、like、notLike、likeLeft、likeRight
selectMaps返回Map集合列表

@Test
public void testSelectMaps() {
 QueryWrapper<User> queryWrapper = new QueryWrapper<>();
 queryWrapper
 .notLike("name","e")
 .likeRight("email","t");
 List<Map<String,Object>> maps = userMapper.selectMaps(queryWrapper);//返回值是Map列表
 maps.forEach(System.out::println);
}

SELECT id,version
FROM user WHERE deleted=0 AND name NOT LIKE ? AND email LIKE ?

6、in、notIn、inSql、notinSql、exists、notExists

in、notIn：
①notIn(“age”,{1,3})—>age not in (1,3)
②notIn(“age”,3)—>age not in (1,3)
inSql、notinSql：可以實現子查詢
①例: inSql(“age”,“1,3,4,5,6”)—>age in (1,6)
②例: inSql(“id”,“select id from table where id < 3”)—>id in (select id from table where id < 3)

@Test
public void testSelectObjs() {
 QueryWrapper<User> queryWrapper = new QueryWrapper<>();
 //queryWrapper.in("id",3);
 queryWrapper.inSql("id","select id from user where id < 3");
 List<Object> objects = userMapper.selectObjs(queryWrapper);//返回值是Object列表
 objects.forEach(System.out::println);
}

SELECT id,version
FROM user WHERE deleted=0 AND id IN (select id from user where id < 3)

7、or、and
注意：這裡使用的是 UpdateWrapper
不呼叫or則預設為使用 and 連

@Test
public void testUpdate1() {
 //修改值
 User user = new User();
 user.setAge(99);
 user.setName("Andy");
 //修改條件
 UpdateWrapper<User> userUpdateWrapper = new UpdateWrapper<>();
 userUpdateWrapper
 .like("name","h")
 .or()
 .between("age",30);
 int result = userMapper.update(user,userUpdateWrapper);
 System.out.println(result);
}

UPDATE user SET name=?,age=?,update_time=? WHERE deleted=0 AND name LIKE ? OR age BETWEEN ? AND ?

8、巢狀or、巢狀and
這裡使用了lambda表示式，or中的表示式最後翻譯成sql時會被加上圓括號

@Test
public void testUpdate2() {
 //修改值
 User user = new User();
 user.setAge(99);
 user.setName("Andy");
 //修改條件
 UpdateWrapper<User> userUpdateWrapper = new UpdateWrapper<>();
 userUpdateWrapper
 .like("name","h")
 .or(i -> i.eq("name","李白").ne("age",20));
 int result = userMapper.update(user,update_time=?

WHERE deleted=0 AND name LIKE ?

OR ( name = ? AND age <> ? )

9、orderBy、orderByDesc、orderByAsc

@Test
public void testSelectListOrderBy() {
 QueryWrapper<User> queryWrapper = new QueryWrapper<>();
 queryWrapper.orderByDesc("id");
 List<User> users = userMapper.selectList(queryWrapper);
 users.forEach(System.out::println);
}

SELECT id,version

FROM user WHERE deleted=0 ORDER BY id DESC
10、last

直接拼接到 sql 的最後

注意：只能呼叫一次,多次呼叫以最後一次為準 有sql注入的風險,請謹慎使用

@Test
public void testSelectListLast() {
 QueryWrapper<User> queryWrapper = new QueryWrapper<>();
 queryWrapper.last("limit 1");
 List<User> users = userMapper.selectList(queryWrapper);
 users.forEach(System.out::println);
}

}

SELECT id,version

FROM user WHERE deleted=0 limit 1
11、指定要查詢的列

@Test
public void testSelectListColumn() {
 QueryWrapper<User> queryWrapper = new QueryWrapper<>();
 queryWrapper.select("id","name","age");
 List<User> users = userMapper.selectList(queryWrapper);
 users.forEach(System.out::println);
}

SELECT id,age FROM user WHERE deleted=0
12、set、setSql

最終的sql會合並 user.setAge()，以及 userUpdateWrapper.set() 和 setSql() 中 的欄位

@Test
public void testUpdateSet() {
 //修改值
 User user = new User();
 user.setAge(99);
 //修改條件
 UpdateWrapper<User> userUpdateWrapper = new UpdateWrapper<>();
 userUpdateWrapper
 .like("name","h")
 .set("name","老李頭")//除了可以查詢還可以使用set設定修改的欄位
 .setSql(" email = '[email protected]'");//可以有子查詢
 int result = userMapper.update(user,userUpdateWrapper);
}

UPDATE user SET age=?,update_time=?,name=?,email = ‘[email protected]' WHERE deleted=0 AND name LIKE ?
(自己打的)

 //mp實現複雜查詢操作
 @Test
 public void testSelectQuery() {
 //建立QueryWrapper物件
 QueryWrapper<User> wrapper = new QueryWrapper<>();

 //通過QueryWrapper設定條件
 //ge、gt、le、lt
 //查詢age>=30記錄
 //第一個引數欄位名稱，第二個引數設定值
 wrapper.ge("age",30);

 //eq：等於、ne：不等於
 //wrapper.eq("name","lilei");
 //wrapper.ne("name","lilei");

 //between：兩者之間
 //查詢年齡 20-30
 // wrapper.between("age",30);

 //like
 //wrapper.like("name","嶽");

 //orderByDesc
 // wrapper.orderByDesc("id");

 //last
 //wrapper.last("limit 1");

 //指定要查詢的列
// wrapper.select("id","name");

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

 }

總結
到此這篇關於Mybatis_plus基礎教程(總結篇)的文章就介紹到這了,更多相關Mybatis plus基礎內容請搜尋我們以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援我們！