1.介紹篇
教程結合當前主流的springboot、Mybatis-Plus、lombok、mysql串起來重點、完整的學習Mybatis-Plus，場景比較簡單，即通過對“工作招聘信息表（dy_job表）”進行CURD操作（下面詳細介紹）。如有不清楚之處，可加微信或者qq問清楚。由於篇幅有限涉及的源代碼會貼出80%保證各路新手朋友按照一下步驟一步一步往下做完全沒問題，代碼沒有全部貼完有需要的朋友可以私信。本教程亮點，每一個章節都有總結和注意事項。
教程大綱（如果讀到中間有點模糊，請回頭看看這個大綱）：
1.1. lombok插件介紹
Lombok是一個可以通過簡單的注解形式來幫助我們簡化消除一些必須有但顯得很臃腫的Java代碼的工具，通過使用對應的注解，可以在編譯源碼的時候生成對應的方法。
為了代碼簡便，在這個培訓教材中加入了這個小插件。比較好用，在實際項目中也推薦使用。要使用這個小插件，需要到官網上去下載，然后單獨安裝一下，安裝方式很簡單，下面有介紹。
1.2. Mybatis-Plus插件介紹
Mybatis-Plus（簡稱MP）是一個 Mybatis 的增強工具，在 Mybatis 的基礎上只做增強不做改變，為簡化開發、提高效率而生。這是官方給的定義，關於mybatis-plus的更多介紹及特性，可以參考mybatis-plus官網。那么它是怎么增強的呢？其實就是它已經封裝好了一些crud方法，我們不需要再寫xml了，直接調用這些方法就行，就類似於JPA。
1.3. lombok的安裝
官方地址：https://projectlombok.org/
github地址：https://github.com/rzwitserloot/lombok。
1）第一步：下載
下載安裝很方便，打開https://projectlombok.org/，點擊Download進入下載頁面，並下載。
它是一個jar包文件，下載后直接點開安裝即可。
2）第二步：安裝
官網提供基於很多種開發工具的安裝方法，我是在eclipse上安裝，如下圖所示：
以下是官網上提供的安裝在eclipse上
安裝完之后到開發工具上查看一下插件，如果有，則顯示如下圖上的信息
3.1. 注意事項 ️
1）lombok目前發現的問題：eclipse所在目錄不要有中文，否則加載lombok是不成功的；
2）Mybatis-Plus不需要像lombok安裝，只需要在Maven項目中引入依賴即可，非常方便；
2.創建項目
2.1. 創建過程
工程名稱“mptest”，具體如下
1）第一步：創建Maven項目，如圖：
2）第二步：在"create a simple project。。。"前打勾
3）第三步：輸入項目名稱相關信息
2.2. 項目結構
3.pom文件中引入相關的依賴
3.1. 拷貝這段貼入剛創建工程的pom.xml里
<!-- Spring Boot的父級依賴 -->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.1.3.RELEASE</version>
<relativePath/>
</parent>
<!-- java版本 1.8 -->
<properties>
<java.version>1.8</java.version>
</properties>
<dependencies>
<!-- spring boot 啟動器-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<!-- spring boot web 啟動器-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!-- spring boot test 啟動器-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<!-- lombok簡化java代碼 如果沒有安裝，先安裝這個插件-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<!-- mybatis-plus插件 -->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.1.0</version>
</dependency>
<!-- mysql jdbc驅動 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
<!--緩存管理器-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<!-- spring集成AspectJ LTW織入器所需包-->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.8.13</version>
</dependency>
</dependencies>
3.1. 注意事項 ️
<!-- mybatis-plus插件 -->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.1.0</version>
</dependency>
如果在其它框架中引入依賴，只需要這個就可以了。
4.基礎代碼准備
4.1. 創建數據庫表
這里用的是mysql數據庫， 表名"dy_job"
表結構：
/*
Navicat Premium Data Transfer
Source Server : localhost-MAMP
Source Server Type : MySQL
Source Server Version : 50725
Source Host : localhost
Source Database : dydata
Target Server Type : MySQL
Target Server Version : 50725
File Encoding : utf-8
Date: 08/09/2019 00:19:41 AM
*/
SET NAMES utf8;
SET FOREIGN_KEY_CHECKS = 0;
-- ----------------------------
-- Table structure for `dy_job`
-- ----------------------------
DROP TABLE IF EXISTS `dy_job`;
CREATE TABLE `dy_job` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`position` varchar(200) DEFAULT NULL,
`count` int(11) DEFAULT '0',
`place` varchar(200) DEFAULT NULL,
`deal` varchar(200) DEFAULT NULL,
`addtime` date DEFAULT NULL,
`useful_life` int(11) DEFAULT NULL,
`content` longtext,
`access` int(11) DEFAULT '0',
`no_order` int(11) DEFAULT '0',
`wap_ok` int(1) DEFAULT '0',
`top_ok` int(1) DEFAULT '0',
`email` varchar(255) DEFAULT NULL,
`filename` varchar(255) DEFAULT NULL,
`lang` varchar(50) DEFAULT NULL,
`displaytype` int(11) NOT NULL DEFAULT '1',
PRIMARY KEY (`id`)
) ENGINE=MyISAM AUTO_INCREMENT=1021 DEFAULT CHARSET=utf8;
SET FOREIGN_KEY_CHECKS = 1;
4.2. 編寫相關代碼
4.2.1. 項目代碼結構
以上4個是核心的。
4.2.2. 寫一個Entity實體類
@Data
@EqualsAndHashCode(callSuper=false)
@TableName(value = "dy_job")
public class Job {
//主鍵,指定自增策略
@TableId(value = "id",type = IdType.AUTO)
private Integer id;
//職位
private String position;
//招聘人數
private Integer count;
//工作地點
private String place;
//待遇
private String deal;
//日期
private LocalDateTime addtime;
//備注信息
private String content;
//email
private String email;
@TableField(exist=false)
private String remark;
}
4.2.3. 寫一個Mapper映射接口
package com.mptest.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.mptest.entity.Job;
public interface JobMapper extends BaseMapper<Job>{
}
4.2.4. 寫一個SpringBoot主程序
package com.mptest;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
/**
* @SpringBoot主程序
* @author ming
*
*/
@SpringBootApplication
@MapperScan("com.mptest.mapper")
public class MPApplication {
public static void main(String[] args) {
SpringApplication.run(MPApplication.class, args);
}
}
4.2.5. 創建application.yml配置文件
server:
port: 8018
spring:
datasource:
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://localhost:3309/dydata
username: root
password: ming821215
mybatis-plus:
#信息輸出設置
configuration:
log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
#配置mapper xml文件，自定義sql語句
#mapper-locations: classpath*:mpProject/mp/mapper/*.xml
#日志級別設置
#logging:
# level:
# root: WARN
# org:
# springframework:
# security: DEBUG
# web: ERROR
4.2.6. 啟動工程，測試是否運行成功
運行成功后，顯示如下日志
4.3. 注意事項 ️
1）實體類中，如果類名和數據庫表明名稱不一樣，必須指定 @TableName(value = “dy_job”)，否則啟動報錯找不到數據庫表
2）實體類中，至少定義id，否則報錯。如：
@TableId(value = "id",type = IdType.AUTO)
private Integer id;
3）必須定義mapper接口，否則啟動主程序時，掃描不到映射接口會報錯。
4）主程序要加上 @MapperScan(“com.mptest.mapper”)。
5）application.yml中要配置數據庫連接，否則啟動會報錯
6）想讓程序能跑起來，需要注意以上5點
5.准備就緒，開始真正體驗Mybatis-Plus
5.1. 三種調用模式介紹
Mybatis-Plus有多種調用模式。例如：
1）ActiveRecord模式調用
普及：Active Record 是一種數據訪問設計模式，它可以幫助你實現數據對象Object到關系數據庫的映射。
應用Active Record 時，每一個類的實例對象唯一對應一個數據庫表的一行(一對一關系)，更多介紹看百度百科
[https://baike.baidu.com/item/Active Record/3106858](https://baike.baidu.com/item/Active Record/3106858)。
要使用它，需要Entity實體類繼承Model即可，如：
@Data
@TableName(value = "dy_job")
public class Job extends Model<Job> {
}
調用例子：
/**
* 新增
*/
@Test
public void add() {
//創建job對象
Job job = new Job();
//設置job相關值
job.setPosition("前端工程師");
job.setDeal("9k/月");
job.setPlace("重慶");
job.setCount(5);
job.setContent("技能要求：vue、jq、JavaScript、html、css等");
job.setAddtime(LocalDateTime.now());
//直接調用insert方法
boolean rs = job.insert();
//打印結果
System.out.println("新增結果："+rs);
}
通用Model中所有的方法：
2）繼承通用Mapper接口方式調用
如：public interface JobMapper extends BaseMapper<Job>{
}
調用例子：
@Autowired
private JobMapper jobMapper;
/**
* 查詢全部
*/
@Test
public void getJobList() {
//查詢所有
List<Job> list = jobMapper.selectList(null);
//輸出結果
list.forEach(System.out::println);
}
通用Mapper中所有方法：
3）繼承通用IService接口方式調用
如：public interface JobService extends IService<Job> {
}
如果是定義接口繼承通用IService，那么需要寫實現類，如：
@Service
public class JobServiceImpl extends ServiceImpl<JobMapper, Job> implements JobService{
}
調用例子：
@Autowired
private JobService jobService;
/**
* 查詢所有
*/
@Test
public void getList()
{
List<Job> list = jobService.list();
//打印輸出
list.forEach(System.out::println);
}
通用IService中所有的方法：
）經驗及建議
一般正式的項目中，建議采用第三種方式，第三種比較全面，可以結合第一種，因為第一種最簡單。
5.2. 插入、更新操作
如果包名、類名跟我的命名一樣，可以直接貼過去。
package com.mptest.test;
import java.io.Serializable;
import java.text.ParseException;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;
import javax.swing.plaf.synth.SynthSeparatorUI;
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 com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.additional.query.impl.LambdaQueryChainWrapper;
import com.baomidou.mybatisplus.extension.service.additional.update.impl.LambdaUpdateChainWrapper;
import com.baomidou.mybatisplus.extension.service.additional.update.impl.UpdateChainWrapper;
import com.mptest.entity.Job;
import com.mptest.mapper.JobMapper;
/**
* spring boot測試類
* @author ming
*
*/
@RunWith(SpringRunner.class)
@SpringBootTest
public class JobInsertOrUpdateTest {
@Autowired
private JobMapper jobMapper;
/**
* 查詢全部
*/
@Test
public void getJobList() {
//查詢所有
List<Job> list = this.jobMapper.selectList(null);
//輸出結果
list.forEach(System.out::println);
}
/**
* 新增單條記錄
* @throws ParseException
*/
@Test
public void add() throws ParseException {
//創建job對象
Job job = new Job();
//設置job相關值
job.setPosition("Python");
job.setDeal("25k/月");
job.setPlace("深圳");
job.setCount(1);
job.setContent("技能要求：精通Python常用算法，會大數據架構Hadoop");
job.setAddtime(LocalDateTime.now());
//調用插入方法
int rs = this.jobMapper.insert(job);
//打印結果
System.out.println("執行結果："+rs);
}
/**
* 更新記錄
* @throws ParseException
*/
@Test
public void updateByID() throws ParseException {
//創建job對象
Job job = new Job();
job.setId(9);
//設置job相關值
job.setPosition("PHP工程師");
job.setDeal("12k/月");
job.setPlace("北京");
job.setCount(8);
job.setContent("技能要求：熟悉使用PHP");
//調用更新方法
int rs = this.jobMapper.updateById(job);
//打印結果
System.out.println("更新結果："+rs);
}
/**
* 更新記錄
* @throws ParseException
*/
@Test
public void updateByWrapper() throws ParseException {
LambdaUpdateWrapper<Job> updateWrapper = new UpdateWrapper<Job>().lambda();
updateWrapper.eq(Job::getId, 10);
//創建job對象
Job job = new Job();
//job.setId(9);
//設置job相關值
job.setPosition("C++工程師");
job.setDeal("18k/月");
job.setPlace("廣州");
job.setCount(3);
job.setContent("技能要求：精通C++");
//調用更新方法
int rs = this.jobMapper.update(job, updateWrapper);
//打印結果
System.out.println("更新結果："+rs);
}
/**
* 更新記錄
* @throws ParseException
*/
@Test
public void updateByWrapperAndByEntity() throws ParseException {
Job jobWhere = new Job();
jobWhere.setId(10);
//System.out.println(jobWhere.toString());
//updateWrapper
LambdaUpdateWrapper<Job> updateWrapper = new UpdateWrapper<Job>(jobWhere).lambda();
//updateWrapper.eq(Job::getId, 10);
//創建job對象
Job job = new Job();
//job.setId(9);
//設置job相關值
job.setPosition("C++工程師");
job.setDeal("20k/月");
job.setPlace("廣州");
job.setCount(3);
job.setContent("技能要求：精通C++");
//調用更新方法
int rs = this.jobMapper.update(job, updateWrapper);
//打印結果
System.out.println("更新結果："+rs);
}
/**
* 更新記錄
* @throws ParseException
*/
@Test
public void updateByWrapperSg() throws ParseException {
//updateWrapper
LambdaUpdateWrapper<Job> updateWrapper = new UpdateWrapper<Job>().lambda();
//設置
updateWrapper
.set(Job::getPosition, "Python算法工程師")
.set(Job::getCount, 2)
.eq(Job::getId, 13);
//執行update更新方法
int rs = this.jobMapper.update(null, updateWrapper);
//打印結果
System.out.println("更新結果："+rs);
}
/**
* 更新記錄Chain
* @throws ParseException
*/
@Test
public void updateByWrapperChain() throws ParseException {
//updateWrapper
LambdaUpdateChainWrapper<Job> updateWrapper = new LambdaUpdateChainWrapper<Job>(jobMapper);
//設置
boolean rs = updateWrapper
.set(Job::getPosition, "Python工程師")
.set(Job::getCount, 5)
.eq(Job::getId, 13)
.update();
System.out.println("更新結果："+rs);
}
/**
* 通過id刪除數據
*/
@Test
public void deleteById() {
Integer id = 3 ;
//調用刪除方法deleteById
int rs = this.jobMapper.deleteById(id);
//打印結果
System.out.println("更新結果："+rs);
}
/**
* 通過多個id刪除數據
*/
@Test
public void deleteByIds() {
//調用刪除方法deleteById
Collection<Integer> idList = new ArrayList<Integer>() ;
idList.add(2);
idList.add(4);
//第一種傳遞參數
//int rs = this.jobMapper.deleteBatchIds(idList);
//第二種傳遞參數
int rs = this.jobMapper.deleteBatchIds(Arrays.asList("2","4","12"));
//打印結果
System.out.println("更新結果："+rs);
}
/**
* 通過Wrapper刪除數據
*/
@Test
public void deleteByWrapper() {
//外部傳來的逗號分割id
String params = "2,4,6,7";
List<String> paramsList = Arrays.asList(params.split(","));
//LambdaQueryWrapper對象
LambdaQueryWrapper<Job> wrapper = new QueryWrapper<Job>().lambda();
//條件
wrapper
.like(Job::getPosition,"工程師")
.in(Job::getId, paramsList);
//調用刪除方法
int rs = this.jobMapper.delete(wrapper);
//打印結果
System.out.println("更新結果："+rs);
}
}
5.4. 查詢語句、查詢條件
package com.mptest.test;
import java.text.ParseException;
import java.time.LocalDateTime;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.swing.plaf.synth.SynthSeparatorUI;
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 com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.additional.query.impl.LambdaQueryChainWrapper;
import com.baomidou.mybatisplus.extension.service.additional.update.impl.LambdaUpdateChainWrapper;
import com.baomidou.mybatisplus.extension.service.additional.update.impl.UpdateChainWrapper;
import com.mptest.entity.Job;
import com.mptest.mapper.JobMapper;
/**
* spring boot測試類
* @author ming
*
*/
@RunWith(SpringRunner.class)
@SpringBootTest
public class JobSelectTest {
@Autowired
private JobMapper jobMapper;
/**
* 查詢全部
*/
@Test
public void getJobList() {
//查詢所有
List<Job> list = jobMapper.selectList(null);
//輸出結果
list.forEach(System.out::println);
}
/**
* 以map作為條件查詢
*/
@Test
public void getByMap() {
//定義map
Map<String,Object> columnMap = new HashMap<String,Object>();
//設置id值
columnMap.put("id", 1);
//調用查詢方法
List<Job> list = this.jobMapper.selectByMap(columnMap);
//打印輸出
list.forEach(System.out::println);
}
/**
* 以Wrapper作為條件查詢
*/
@Test
public void getByWrapper() {
//查詢條件
QueryWrapper<Job> queryWrapper = Wrappers.<Job>query();
//開始設置查詢條件
queryWrapper
.like("position", "工程")
.lt("id", 10);
//調用查詢
List<Job> list = this.jobMapper.selectList(queryWrapper);
//打印輸出
list.forEach(System.out::println);
}
/**
* 以Wrapper作為復雜條件查詢
*/
@Test
public void getByWrapper2() {
//查詢條件
QueryWrapper<Job> queryWrapper = Wrappers.<Job>query();
//開始設置查詢條件
queryWrapper
.like("position", "工")
.between("count", 1, 2)
.isNull("email");
//調用查詢
List<Job> list = this.jobMapper.selectList(queryWrapper);
//打印輸出
list.forEach(System.out::println);
}
/**
* 以Wrapper作為復雜條件查詢
*/
@Test
public void getByWrapper3() {
//查詢條件
QueryWrapper<Job> queryWrapper = Wrappers.query();
//開始設置查詢條件
queryWrapper
.likeRight("position", "軟")
.or().ge("count", 3)
.orderByDesc("addtime")
.orderByAsc("id");
//調用查詢
List<Job> list = this.jobMapper.selectList(queryWrapper);
//打印輸出
list.forEach(System.out::println);
}
/**
* 帶子查詢
*/
@Test
public void getByWrapper4() {
//查詢條件
QueryWrapper<Job> queryWrapper = Wrappers.query();
//開始設置查詢條件
queryWrapper
.apply("date_format(addtime,'%Y-%m-%d')={0}", "2019-08-02")
.inSql("id", "select id from dy_job where count>1");
//調用查詢
List<Job> list = this.jobMapper.selectList(queryWrapper);
//打印輸出
list.forEach(System.out::println);
}
/**
* and lambda表達式查詢
*/
@Test
public void getByWrapper5() {
//查詢條件
QueryWrapper<Job> queryWrapper = Wrappers.query();
//開始設置查詢條件
queryWrapper
.like("position", "工程師")
.and(
sql->sql.le("count", 10).or().isNull("email")
)
.ge("id", 2);
//調用查詢
List<Job> list = this.jobMapper.selectList(queryWrapper);
//打印輸出
list.forEach(System.out::println);
}
/**
* or lambda表達式查詢
*/
@Test
public void getByWrapper6() {
//查詢條件
QueryWrapper<Job> queryWrapper = Wrappers.query();
//開始設置查詢條件
queryWrapper
.like("position", "工程師")
.or(
sql->sql.le("count", 10).isNull("email")
)
.ge("id", 2);
//調用查詢
List<Job> list = this.jobMapper.selectList(queryWrapper);
//打印輸出
list.forEach(System.out::println);
}
/**
* 前面是帶（） lambda表達式查詢
*/
@Test
public void getByWrapper7() {
//查詢條件
QueryWrapper<Job> queryWrapper = Wrappers.query();
//開始設置查詢條件
queryWrapper
.nested(sql->sql.like("position", "java").or().ge("count", 3))
.apply("date_format(addtime,'%Y-%m-%d')={0}", "2019-08-02")
.last("limit 2");
//.in("id", Arrays.asList(1,2,3,5,8));
//調用查詢
List<Job> list = this.jobMapper.selectList(queryWrapper);
//打印輸出
list.forEach(System.out::println);
}
/**
* 查詢指定字段
*/
@Test
public void getByWrapper8() {
//查詢條件
QueryWrapper<Job> queryWrapper = Wrappers.query();
//開始設置查詢條件
queryWrapper.select("id","position","addtime")
.nested(sql->sql.like("position", "java").or().ge("count", 3))
.apply("date_format(addtime,'%Y-%m-%d')={0}", "2019-08-02")
.in("id", Arrays.asList(1,2,3,5,6,7,8,9,10))
.last("limit 2");
//調用查詢
List<Job> list = this.jobMapper.selectList(queryWrapper);
//打印輸出
list.forEach(System.out::println);
}
/**
* 判斷參數是否為空
*/
@Test
public void getByWrapper9() {
//查詢條件
QueryWrapper<Job> queryWrapper = Wrappers.query();
String positionKey = "C#";
String countKey = null;
//開始設置查詢條件
queryWrapper
.like(StringUtils.isNotEmpty(positionKey),"position", positionKey)
.ge(StringUtils.isNotEmpty(countKey),"count", countKey)
.orderByDesc("addtime")
.orderByAsc("id")
.select("id","position","addtime");
//調用查詢
List<Job> list = this.jobMapper.selectList(queryWrapper);
//打印輸出
list.forEach(System.out::println);
}
/**
* 實體Entity作為參數查詢
*/
@Test
public void getByWrapperEntity() {
Job whereJob = new Job();
whereJob.setId(11);
whereJob.setPosition("C#架構師");
//查詢條件
QueryWrapper<Job> queryWrapper = Wrappers.query(whereJob);
//queryWrapper.eq("", "C#");
//調用查詢
List<Job> list = this.jobMapper.selectList(queryWrapper);
//打印輸出
list.forEach(System.out::println);
}
/**
* map押入條件
*
*/
@Test
public void getByWrapperAllEq() {
//查詢條件
QueryWrapper<Job> queryWrapper = Wrappers.query();
//創建map對象，並裝入條件列
Map<String,Object> whereMap = new HashMap<String,Object>();
whereMap.put("position", "C#架構師");
queryWrapper.allEq(whereMap);
//調用查詢
List<Job> list = this.jobMapper.selectList(queryWrapper);
//打印輸出
list.forEach(System.out::println);
}
/**
* 返回map類型
*
*/
@Test
public void getByWrapperMaps() {
//查詢條件
QueryWrapper<Job> queryWrapper = Wrappers.query();
queryWrapper
.select("addtime as 招聘時間","count(*) as 職位數量")
.gt("id", 1)
.like("position", "師")
.groupBy("招聘時間")
.having("職位數量>{0} and 職位數量<{1}", 1,10);
//調用查詢
List<Map<String,Object>> list = this.jobMapper.selectMaps(queryWrapper);
//打印輸出
list.forEach(System.out::println);
}
/**
* 返回Object對象類型
*
*/
@Test
public void getByWrapperObjs() {
//查詢條件
QueryWrapper<Job> queryWrapper = Wrappers.query();
queryWrapper
.select("count(*) as 職位數量")
.gt("id", 1)
.like("position", "師")
.groupBy("addtime")
.having("職位數量>{0} and 職位數量<{1}", 1,10);
//調用查詢
List<Object> list = this.jobMapper.selectObjs(queryWrapper);
//打印輸出
list.forEach(System.out::println);
}
/**
* 返回查詢記錄數量
*
*/
@Test
public void getByWrapperCount() {
//查詢條件
QueryWrapper<Job> queryWrapper = Wrappers.query();
queryWrapper
.gt("id", 1)
.like("position", "師");
//調用查詢
int count = this.jobMapper.selectCount(queryWrapper);
//打印輸出
System.out.println(count);
}
/**
* 返回一條記錄
*
*/
@Test
public void getByWrapperOne() {
//查詢條件
QueryWrapper<Job> queryWrapper = Wrappers.query();
queryWrapper
.eq("id", 5)
.like("position", "師");
//調用查詢
Job rs = this.jobMapper.selectOne(queryWrapper);
//打印輸出
System.out.println(rs);
}
/**
* LambdaQueryWrapper
* lambda語法查詢
*/
@Test
public void getByLambda() {
LambdaQueryWrapper<Job> lambdaQueryWrapper = new QueryWrapper<Job>().lambda();
lambdaQueryWrapper
.like(Job::getPosition, "工程師")
.gt(Job::getCount, 3)
.and(sql->sql.gt(Job::getId, 2).or().isNull(Job::getEmail));
//調用查詢
List<Job> list = this.jobMapper.selectList(lambdaQueryWrapper);
//打印輸出
list.forEach(System.out::println);
}
/**
* LambdaQueryWrapper
* lambda語法查詢
*/
@Test
public void getByLambdaQueryChain() {
//外部參數
String positionKey = "工程師";
String countKey = "3";
//查詢條件及查詢結果集
List<Job> list = new LambdaQueryChainWrapper<Job>(jobMapper)
.like(StringUtils.isNotEmpty(positionKey),Job::getPosition, positionKey)
.gt(StringUtils.isNotEmpty(countKey),Job::getCount, countKey)
.and(sql->sql.gt(Job::getId, 2).or().isNull(Job::getEmail))
.select(Job::getId,Job::getPosition,Job::getCount,Job::getAddtime)
.list();
//打印輸出
list.forEach(System.out::println);
}
/**
* 查詢自己定義的方法
*/
@Test
public void getByMyFunction() {
LambdaQueryWrapper<Job> lambdaQueryWrapper = new QueryWrapper<Job>().lambda();
lambdaQueryWrapper
.like(Job::getPosition, "工程師")
.gt(Job::getCount, 3)
.and(sql->sql.gt(Job::getId, 2).or().isNull(Job::getEmail));
//調用查詢
List<Job> list = this.jobMapper.getMyJobsList(lambdaQueryWrapper);
//打印輸出
list.forEach(System.out::println);
}
/**
* 分頁查詢，調用通用分頁方法
*/
@Test
public void getPage() {
LambdaQueryWrapper<Job> lambdaQueryWrapper = new QueryWrapper<Job>().lambda();
lambdaQueryWrapper
.like(Job::getPosition, "師")
.gt(Job::getCount, 3)
.and(sql->sql.gt(Job::getId, 2).or().isNull(Job::getEmail));
//每頁顯示10條
//當前頁
long current =1;
long size = 10;
Page<Job> page = new Page<Job>(current,size);
//返回IPage對象
IPage<Job> iPage = this.jobMapper.selectPage(page, lambdaQueryWrapper);
//獲取關鍵信息
System.out.println("總頁數："+iPage.getPages());
System.out.println("總記錄："+iPage.getTotal());
//當前頁數據列表
List<Job> list = iPage.getRecords();
//打印輸出
list.forEach(System.out::println);
}
/**
* 分頁查詢，調用自己定義的方法
*/
@Test
public void getMyPage() {
LambdaQueryWrapper<Job> lambdaQueryWrapper = new QueryWrapper<Job>().lambda();
lambdaQueryWrapper
.like(Job::getPosition, "師")
.gt(Job::getCount, 3)
.and(sql->sql.gt(Job::getId, 2).or().isNull(Job::getEmail));
//每頁顯示10條
//當前頁
long current =1;
long size = 5;
Page<Job> page = new Page<Job>(current,size);
//返回IPage對象
IPage<Job> iPage = this.jobMapper.getMyJobsPage(page, lambdaQueryWrapper);
//獲取關鍵信息
System.out.println("總頁數："+iPage.getPages());
System.out.println("總記錄："+iPage.getTotal());
//當前頁數據列表
List<Job> list = iPage.getRecords();
//打印輸出
list.forEach(System.out::println);
}
/**
* 分頁查詢，多表關聯
*/
@Test
public void getMyMorePage() {
//外部參數
String positionKey = "工程師";
LambdaQueryWrapper<Job> lambdaQueryWrapper = new QueryWrapper<Job>().lambda();
//參數
lambdaQueryWrapper.like(StringUtils.isNotEmpty(positionKey),Job::getPosition, positionKey);
//....
//每頁顯示10條
//當前頁
long current =1;
long size = 5;
Page<Map<String,Object>> page = new Page<Map<String,Object>>(current,size);
//返回IPage對象
IPage<Map<String,Object>> iPage = this.jobMapper.getMyJobsMorePage(page, lambdaQueryWrapper);
//獲取關鍵信息
System.out.println("總頁數："+iPage.getPages());
System.out.println("總記錄："+iPage.getTotal());
//當前頁數據列表
List<Map<String,Object>> list = iPage.getRecords();
//打印輸出
list.forEach(System.out::println);
}
}
5.5. 注意事項 ️
有3種查詢構造器：
1） QueryWrapper
2）LambdaQueryWrapper
3）LambdaQueryChainWrapper
更新構造器，也有3種：
1）UpdateWrapper
2） LambdaUpdateWrapper
3）LambdaUpdateChainWrapper
不管是查詢構造器還是更新構造器，我建議使用Lambda的方式，如果從上往下做過示例的朋友會看到，Lambda的方式編譯只要不出錯，運行時出錯率是很低的。
如果想用瀏覽器請求SpringBoot的API接口，可以在com.mptest.controller里寫，如：
package com.mptest.controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* test
* @author ming
*
*/
@RestController
public class MPController {
@RequestMapping("/say")
public String say() {
return "你好，我是張三";
}
//你可以在這里寫調用Mybatis-Plus的CURD方法以及更多，跟test的做法一樣。
//正式的項目中，建議是將邏輯處理再提取一層，這里更多的是接收參數，處理、調用相關的
//接口方法、以及返回數據。。。。
}
更多的Mybatis-Plus使用其實還有很多，例如：枚舉、多表關聯復雜查詢、自定義查詢、高性能的批量操作及優化、防止注入攻擊、邏輯刪除、代碼生成器等。這里對入門很有幫助，需更多的了解，可加微信留言，我有空的時候可以一起研究。