mybatis-plus-join

mybatis-plus-join是mybatis plus的一個(gè)多表插件，上手簡(jiǎn)單，十分鐘不到就能學(xué)會(huì)全部使用方式，只要會(huì)用mp就會(huì)用這個(gè)插件，僅僅依賴(lài)了lombok，而且是擴(kuò)展mp的構(gòu)造器并非更改原本的構(gòu)造器，不會(huì)對(duì)原有項(xiàng)目產(chǎn)生一點(diǎn)點(diǎn)影響，相信大多數(shù)項(xiàng)目都有這倆插件，四舍五入就是沒(méi)依賴(lài)。

mybatis-plus-join插件地址：

gitee：https://gitee.com/mhb0409/mybatis-plus-join
github：https://github.com/bobo667/mybatis-plus-join

mybatis-plus-join示例：

gitee: https://gitee.com/mhb0409/mybatis-plus-join-example
github: https://github.com/bobo667/mybatis-plus-join-example

關(guān)于該插件的一點(diǎn)問(wèn)題

1. 出現(xiàn)了bug怎么辦，不是mybatis plus官方的會(huì)不會(huì)不穩(wěn)定啊？ 這個(gè)大可以放心，這個(gè)插件我已經(jīng)在生產(chǎn)環(huán)境跑了一年多了，已經(jīng)有許多開(kāi)發(fā)者再用，沒(méi)出過(guò)什么問(wèn)題，如果遇到問(wèn)題可以在 Issues 上提出，我看見(jiàn)就會(huì)解決，上午提的，不忙的話下午就能打包新版本，忙的話大概就需要晚上就差不多了
2. 關(guān)于維護(hù)到啥時(shí)候？mybatis plus不倒我不倒（當(dāng)然，如果長(zhǎng)期沒(méi)有star，哪怕是我得先倒了，還是那，您的star就是作者更新的動(dòng)力，手動(dòng)?( ′???` )比心）
3. 有什么有想法的新功能啊，或者改善啊，可以在Issues 上提出
4. 如果想聯(lián)系作者，可以在wx上搜索小程序 馬匯博的博客在關(guān)于我中有微信號(hào)，歡迎來(lái)擾

目前支持大部分mp常用版本

maven坐標(biāo)

mybatis plus：3.2.0版本依賴(lài)地址：

 <dependency>
    <groupId>icu.mhb</groupId>
    <artifactId>mybatis-plus-join</artifactId>
    <version>1.2.0</version>
 </dependency>

最新版本依賴(lài)地址：

 <dependency>
    <groupId>icu.mhb</groupId>
    <artifactId>mybatis-plus-join</artifactId>
    <version>1.3.4</version>
 </dependency>

版本對(duì)應(yīng)關(guān)系（此處只顯示對(duì)應(yīng)的最新版本）

標(biāo)注：*號(hào)代表，從起始版本之后都是可以使用的

版本日志

1.0.1 版本

1.初始化項(xiàng)目 mybatis-plus-join項(xiàng)目誕生

1.0.2 版本

1.優(yōu)化了selectAs()方法，支持函數(shù)簡(jiǎn)潔式寫(xiě)法

2.增加了緩存優(yōu)化性能

1.0.3 版本

1.支持3.4.3.4版本

2.增加根據(jù)傳入實(shí)體不為空的數(shù)據(jù)查詢

3.優(yōu)化了代碼邏輯

4.增加notDefaultSelectAll() 不默認(rèn)查詢主表全部的字段

1.0.4 版本

1.支持查詢單個(gè)參數(shù)時(shí)候返回單個(gè)參數(shù)，例如List<String> String

2.優(yōu)化轉(zhuǎn)換類(lèi)型的方式

1.0.5 版本

1.修復(fù)在沒(méi)有條件下order 排序失效的問(wèn)題

1.0.6 版本

1.修復(fù)實(shí)體條件為主鍵ID的時(shí)候沒(méi)有加別名問(wèn)題

2.增加返回值支持一對(duì)一查詢

1.0.8 版本

1. 增加了多對(duì)多映射

2. 去掉了fastJSON依賴(lài)

3. 更改serviceImpl動(dòng)態(tài)返回類(lèi)型的處理方式，采用更優(yōu)的插件式注入方式

   

   這次終于去掉了總是說(shuō)的fastJSON依賴(lài)，現(xiàn)在采用動(dòng)態(tài)注入resultMap方式，來(lái)構(gòu)建普通多表，一對(duì)一，多對(duì)多查詢，采用插件式懶加載 + 緩存機(jī)制，啟動(dòng)時(shí)間無(wú)影響，使用加載一下就可以直接從緩存調(diào)用，保證不影響使用中的效率。

1.0.9 版本

1. 更改默認(rèn)表、字段別名關(guān)鍵字As 為 空格

2. 增加自定義表、字段別名關(guān)鍵字，在不同數(shù)據(jù)庫(kù)中兼容

1.1.1 版本

1. 修復(fù)在添加邏輯刪除的時(shí)候SQL報(bào)錯(cuò)問(wèn)題

2. 返回類(lèi)型支持Map類(lèi)型

3. 增加主表和子表自定義別名，方便多個(gè)相同子表對(duì)應(yīng)一個(gè)主表

   這次更新解決了目前使用的一些特殊場(chǎng)景下的缺陷問(wèn)題，使用的更靈活了

1.1.2 版本

1. 修復(fù)邏輯刪除沒(méi)有加別名的問(wèn)題

2. 修復(fù)多個(gè)連表情況下，只查詢主表的邏輯刪除的問(wèn)題

3. 修復(fù)在定義typeHandler不生效的問(wèn)題

   

   這次更新主要是修復(fù)的bug版本，目前作者沒(méi)有什么特別多的思路去要寫(xiě)什么樣的新功能，如果各位有可以提出來(lái)

1.1.3 版本

1. 更改邏輯刪除出現(xiàn)的條件為join后，而不是where后

2. Merge pull request !2 from f_ms/N/A

3. Merge pull request !1 from f_ms/N/A

   

   這次更新主要是修復(fù)的bug版本，目前作者沒(méi)有什么特別多的思路去要寫(xiě)什么樣的新功能，如果各位有可以提出來(lái)

1.1.4 版本

1. 修復(fù)邏輯刪除值錯(cuò)誤的bug  **gitee issues-I5UY2K** 
2. typeHandler 增加子表支持  **gitee issues-I5SUV6**
3. 修復(fù) 在調(diào)用 and()方法的情況下，設(shè)置的表別名失效的問(wèn)題
4. orderBy 排序增加順序下標(biāo)，可根據(jù)下標(biāo)來(lái)調(diào)整對(duì)應(yīng)的排序順序
5. 增加 orderBySql 方法，可以手寫(xiě)排序SQL
6. selectAs 自定義查詢字段方法增加重載參數(shù) boolean isQuotes，來(lái)標(biāo)識(shí)是否需要是字符，可以用這種方式寫(xiě)一些簡(jiǎn)單的函數(shù)
7. 增加distinct函數(shù)方法
8. 優(yōu)化了代碼結(jié)構(gòu)

1.1.5 版本

1. MybatisPlusJoinConfig增加isUseMsCache方法，代表使用不使用MappedStatement的緩存，如果為true，就會(huì)更改他的id如果是使用mate的某些插件特效出現(xiàn)classNotFoud，因?yàn)楦牧薓appedStatement Id報(bào)錯(cuò)，可以嘗試把這個(gè)改成false，就不會(huì)更改id內(nèi)容
2. 增加方法JoinLambdaWrapper#changeQueryWrapper 轉(zhuǎn)換查詢條件

1.1.6版本

1. 修復(fù)一對(duì)一，多對(duì)多的情況下主表和字表字段名字重復(fù)，出現(xiàn)賦值錯(cuò)誤的情況
2. 修復(fù)getTableFieldInfoByFieldName 獲取不到tableInfo的情況下會(huì)報(bào)錯(cuò)的問(wèn)題

1.3.1版本

單純的升級(jí)個(gè)版本跨過(guò)1.2.0

1.3.2版本

1. selectAs(cb -> {cb.add()})方式，自動(dòng)增加表前綴，在一對(duì)一，多對(duì)多的場(chǎng)景下，相同字段名可以無(wú)需寫(xiě)別名即可映射

2. 修復(fù)gitee /issues/I64AZ0 分頁(yè)參數(shù)傳遞的問(wèn)題

3. 增加selectAs(SFunction<T, ?> column, SFunction<J, ?> alias) 和  selectAs#addFunAlias 支持用函數(shù)來(lái)表示別名

   （不建議使用，建議使用最新版）

1.3.2.1版本

該版本主要是修復(fù)1.3.2的版本bug

1.  selectAs(SFunction<T, ?> column, SFunction<J, ?> alias) 和  selectAs#addFunAlias 方法，生成的別名和屬性名沒(méi)有對(duì)應(yīng)報(bào)錯(cuò)的bug

1.3.3 版本(重大更新)

1.  增加@JoinField 注解，定義映射關(guān)系，可在wrapper中用push**Join方法加入，即可查詢并映射
2.  條件構(gòu)造器增加基礎(chǔ)join查詢四件套可以用wrapper直接進(jìn)行查詢 
3.  manyToManySelect和oneToOneSelect 增加可以不指定查詢列，查詢?nèi)苛胁⒂成?4.  修復(fù) JoinLambdaWrapper 和 JoinWrapper的  select(Class<T> entityClass, Predicate<TableFieldInfo> predicate) 沒(méi)有加別名的問(wèn)題修復(fù)
5.  增加接口 JoinCompareFun，eq、ne..可以傳入別的表的函數(shù)，實(shí)現(xiàn)兩個(gè)表字段關(guān)聯(lián)

1.3.3.1 版本

支持了mybatis-plus 3.5.3版本往后

1.3.4 版本

1.  主表可使用masterLogicDelete方法配置是否開(kāi)啟邏輯刪除
2.  查詢字段增加子查詢 selectSunQuery方法
3.  joinAnd 增加條件構(gòu)造器，可以自由構(gòu)造多條件join and
4.  項(xiàng)目異常更改為mpj異常
5.  合并 pr https://gitee.com/mhb0409/mybatis-plus-join/pulls/3

1.3.4.1 版本（兼容老版本）

兼容 3.3.2 - 3.4.2 mp版本

其他版本

1.2.0 版本

1.支持了3.2.0 版本

廢話不多說(shuō)，直接看怎么使用

   
    /**
     * 查詢列表
     *
     * @param wrapper 實(shí)體對(duì)象封裝操作類(lèi)
     * @param <E>     返回泛型（如果只查詢一個(gè)字段可以傳遞String Int之類(lèi)的類(lèi)型）
     * @return 返回E 類(lèi)型的列表
     */
    <EV, E> List<EV> joinList(Wrapper<E> wrapper, Class<EV> clz);

    /**
     * 查詢單個(gè)對(duì)象
     *
     * @param wrapper 實(shí)體對(duì)象封裝操作類(lèi)
     * @param clz     返回對(duì)象 （如果只查詢一個(gè)字段可以傳遞String Int之類(lèi)的類(lèi)型）
     * @param <E>     包裝泛型類(lèi)型
     * @param <EV>    返回類(lèi)型泛型
     * @return EV
     */
    <E, EV> EV joinGetOne(Wrapper<E> wrapper, Class<EV> clz);


    /**
     * 查詢count
     *
     * @param wrapper 實(shí)體對(duì)象封裝操作類(lèi)
     * @param <E>     返回泛型
     * @return 總數(shù)
     */
    <E> int joinCount(Wrapper<E> wrapper);


    /**
     * 翻頁(yè)查詢
     *
     * @param page    翻頁(yè)對(duì)象
     * @param wrapper 實(shí)體對(duì)象封裝操作類(lèi)
     */
    <EV, E extends IPage<EV>, C> IPage<EV> joinPage(E page, Wrapper<C> wrapper, Class<EV> clz);

一共是四個(gè)方法，分別重寫(xiě)于mp的

joinList -> list

joinGetOne -> getOne

joinCount -> count

joinPage -> page

注意：這幾個(gè)方法，前面?zhèn)z參數(shù)和mp的用法一致，最后一個(gè)class類(lèi)型的是返回類(lèi)型，這個(gè)主要是大多數(shù)多表操作都是需要有額外字段，所以需要額外定義，而Wrapper wrapper中的這個(gè)需要填寫(xiě)在需要構(gòu)建條件的實(shí)體，這個(gè)實(shí)體是任意的，不強(qiáng)制，創(chuàng)建條件構(gòu)造器的時(shí)候定義的那個(gè)對(duì)象就是主表

基本使用方法

1.mapper繼承 JoinBaseMapper< T>

2.service繼承 JoinIService< T>

3.impl 繼承 JoinServiceImpl<M,T>

4.注入mp自定義方法，主要是繼承JoinDefaultSqlInjector （因?yàn)榘姹靖?，這里的參數(shù)可能有所變化，改一下傳遞一下就行了）

package icu.mhb.mpj.example.config;

import com.baomidou.mybatisplus.core.injector.AbstractMethod;
import icu.mhb.mybatisplus.plugln.injector.JoinDefaultSqlInjector;
import org.springframework.context.annotation.Configuration;

import java.util.List;

@Configuration
public class MyBatisPlusConfig extends JoinDefaultSqlInjector {

    @Override
    public List<AbstractMethod> getMethodList(Class<?> mapperClass) {
        List<AbstractMethod> methodList = super.getMethodList(mapperClass);
        // 自己的自定義方法
        return methodList;
    }

}

然后就可以愉快的使用了

自定義查詢字段和表別名關(guān)鍵字

// 為何要這個(gè)東西，因?yàn)樵诓煌瑪?shù)據(jù)庫(kù)之間，別名關(guān)鍵字不一樣，例如Mysql表別名是 As 而oracle中 是 is 關(guān)鍵字所以需要

// 以oracle 關(guān)鍵字為例
  @Bean
    public MybatisPlusJoinConfig mybatisPlusJoinConfig() {
        return MybatisPlusJoinConfig.builder()
                // 查詢字段別名關(guān)鍵字
                .columnAliasKeyword("is")
                // 表、left join、right join、inner join 表別名關(guān)鍵字
                .tableAliasKeyword("is")
                .build();
    }

// 運(yùn)行的SQL
SELECT 1 is id
 FROM users is users
 LEFT JOIN users_age is users_age
 ON users_age.id = users.age_id

自定義是否使用MappedStatement緩存（如果有出現(xiàn)classNotFoud情況，可以嘗試關(guān)閉）

// 為何要這個(gè)東西，因?yàn)樵诓煌瑪?shù)據(jù)庫(kù)之間，別名關(guān)鍵字不一樣，例如Mysql表別名是 As 而oracle中 是 is 關(guān)鍵字所以需要

  @Bean
    public MybatisPlusJoinConfig mybatisPlusJoinConfig() {
        return MybatisPlusJoinConfig.builder()
                /*
                  是否使用MappedStatement緩存，如果使用在JoinInterceptor中就會(huì)更改
                  MappedStatement的id，導(dǎo)致mybatis-plus-mate 的某些攔截器插件報(bào)錯(cuò)，
                  設(shè)置成false，代表不使用緩存則不會(huì)更改MappedStatement的id
                 */
                .isUseMsCache(false)
                .build();
    }

自定義函數(shù)關(guān)鍵字例如Distinct

// 為何要這個(gè)東西，可能有些數(shù)據(jù)庫(kù)關(guān)鍵字不一樣，他有默認(rèn)實(shí)現(xiàn)，一般情況下不需要傳，除非你的數(shù)據(jù)庫(kù)真是關(guān)鍵字不一樣

// 第一步需要建個(gè)類(lèi)，實(shí)現(xiàn)IFuncKeyWord
public class FuncKeyWordImpl implements IFuncKeyWord {
    @Override
    public String distinct() {
        return "distinct";
    }
}

// 第二部在構(gòu)造器中set進(jìn)去
JoinLambdaWrapper<Users> wrapper = joinLambdaQueryWrapper(Users.class)
                .setFuncKeyWord(new FuncKeyWordImpl())
  
// 后續(xù)會(huì)改進(jìn)為增加全局注入，但是這種方式依舊會(huì)保留，避免你多數(shù)據(jù)源情況下兩個(gè)數(shù)據(jù)庫(kù)查詢的關(guān)鍵字都不相同

下面來(lái)看構(gòu)造器的使用：

// 第一步new 一個(gè)JoinLambdaWrapper構(gòu)造參數(shù)是主表的實(shí)體對(duì)象（如果在service中直接使用joinLambdaWrapper()方法即可獲得）
JoinLambdaWrapper<Users> wrapper = new JoinLambdaWrapper<>(Users.class);

// 第二步 使用leftJoin方法創(chuàng)建一個(gè)左連接
/*
	有三個(gè)方法可以使用 
	leftJoin 左聯(lián)
	rightJoin 右聯(lián)
	innerJoin 內(nèi)聯(lián)
*/

// 這一部分一個(gè)參數(shù)是join中定義的連接的表，第二個(gè)參數(shù)是隨意的表，但是是要出現(xiàn)構(gòu)造器中的
wrapper.leftJoin(UsersAge.class,UsersAge::getId,Users::getAgeId);
// 然后可以設(shè)置多表中的查詢條件，這一步和mp一致
wrapper.eq(UserAge::getAgeName,"95")
  		.select(UserAge::getAgeName)
      // 最后一步 需要使用end方法結(jié)束
      .end();


// 完整的就是
JoinLambdaWrapper<Users> wrapper = new JoinLambdaWrapper<>(Users.class);
wrapper.leftJoin(UsersAge.class,UsersAge::getId,Users::getAgeId)
  	.eq(UserAge::getAgeName,"95")
  	.select(UserAge::getAgeName)
  	.end();

usersService.joinList(wrapper,UsersVo.class);

// 或者如果你的類(lèi)只有mapper繼承了，那你可以
JoinLambdaWrapper<Users> wrapper = new JoinLambdaWrapper<>(Users.class);
wrapper.leftJoin(UsersAge.class,UsersAge::getId,Users::getAgeId)
  	.eq(UserAge::getAgeName,"95")
  	.select(UserAge::getAgeName)
  	.joinList(UsersVo.class);

// 執(zhí)行SQL 
select 
  users.user_id,
  users.user_name,
  users_age.age_name
from users users
  left join users_age users_age on users_age.id = users.age_id
where (
	users_age.age_name = '95'
)

是不是就很簡(jiǎn)單，就和mp的原生的比，就是增加了 join方法啥的

加料用法

OK，來(lái)點(diǎn)絲滑的加料用法

使用selectSunQuery構(gòu)建子查詢（1.3.4版本之后）

// joinList
List<UsersVo> list = Joins.of(Users.class)
                .masterLogicDelete(false)
                .pushLeftJoin(UsersVo::getUsersAge, UsersAge.class)
                .selectSunQuery(UsersAge.class, w -> {
                    w.eq(UsersAge::getId, Users::getAgeId)
                            .eq(UsersAge::getId, 1)
                            .le(UsersAge::getCreateTime, new Date())
                      			// 需要注意的是這個(gè)查詢字段只能有一個(gè)
                            .selectAs(cb -> {
//                                cb.add("count(1)", "counts", false);
                                cb.add(UsersAge::getId, "counts");
                              // 這里的話，他的關(guān)聯(lián)表是需要在之前出現(xiàn)的，這個(gè)selectSunQuery 在主表也是一樣字表也是一樣的，但是需要放在后面，因?yàn)槿绻谇懊婵赡荜P(guān)聯(lián)表的別名被重寫(xiě)定義了，那么他就會(huì)出現(xiàn)SQL錯(cuò)誤
                            }).leftJoin(Users.class, Users::getAgeId, UsersAge::getId, w2 -> {
                                w2.eq(Users::getUserId, 1);
                            });
                })
                .joinAnd(0, w -> w.eq(UsersAge::getId, Users::getAgeId)
                                            .ne(UsersAge::getId, 10))
                .isNotNull(UsersAge::getId).end().joinList(UsersVo.class);

 // 生成SQL
SELECT
	users.user_name,
	users.create_time,
	users.age_id,
	users.content_json,
	users.user_id,
	t1.age_doc AS t1_ageDoc,
	t1.age_name AS t1_ageName,
	t1.create_time AS t1_createTime,
	t1.content_json_age AS t1_contentJsonAge,
	t1.id AS t1_id,
	(
	SELECT
		t1.id AS counts 
	FROM
		users_age t1
		LEFT JOIN users AS users ON users.age_id = t1.id 
		AND users.age_id = 0 
	WHERE
		( users.user_id = 1 ) 
		AND ( t1.id = users.age_id AND t1.id = 1 AND t1.create_time <= '2023-01-20 16:11:14.38' ) 
	) AS counts 
FROM
	users AS users
	LEFT JOIN users_age AS t1 ON t1.id = users.age_id 
	AND ( t1.id = users.age_id AND t1.id <> 10 ) 
WHERE
	( t1.id IS NOT NULL );
    

使用構(gòu)建器調(diào)用join*查詢方法（1.3.3版本之后）

// joinList
List<UsersVo> list = Joins.of(Users.class)
                .leftJoin(UsersAge.class,UsersAge::getAgeId,Users::getAgeId)
  							.eq(UsersAge::getAgeName,1).end()
                .joinList(UsersVo.class);

 // 生成SQL
SELECT
	users.user_name,
	users.create_time,
	users.age_id,
	users.content_json,
	users.user_id
FROM
	users AS users
	LEFT JOIN users_age AS users_age ON users_age.id = users.age_id 
WHERE
	users_age.age_name = '1'
    
 // joinGetOne
UsersVo userVo = Joins.of(Users.class)
                .leftJoin(UsersAge.class,UsersAge::getAgeId,Users::getAgeId)
  							.eq(UsersAge::getAgeName,1).end()
                .joinGetOne(UsersVo.class);

 // 生成SQL
SELECT
	users.user_name,
	users.create_time,
	users.age_id,
	users.content_json,
	users.user_id
FROM
	users AS users
	LEFT JOIN users_age AS users_age ON users_age.id = users.age_id 
WHERE
	users_age.age_name = '1'
    
  // joinCount
UsersVo userVo = Joins.of(Users.class)
                .leftJoin(UsersAge.class,UsersAge::getAgeId,Users::getAgeId)
  							.eq(UsersAge::getAgeName,1).end()
                .joinCount();

 // 生成SQL
SELECT
	count(*)
FROM
	users AS users
	LEFT JOIN users_age AS users_age ON users_age.id = users.age_id 
WHERE
	users_age.age_name = '1'
    
 // joinCount
Page<UsersVo> pageResult = Joins.of(Users.class)
                .leftJoin(UsersAge.class,UsersAge::getAgeId,Users::getAgeId)
  							.eq(UsersAge::getAgeName,1).end()
                .joinPage(page,UsersVo.class);

 // 生成SQL
SELECT
	users.user_name,
	users.create_time,
	users.age_id,
	users.content_json,
	users.user_id
FROM
	users AS users
	LEFT JOIN users_age AS users_age ON users_age.id = users.age_id 
WHERE
	users_age.age_name = '1'
limit 10
    

eq、ne…等兩個(gè)表字段關(guān)聯(lián)（1.3.3版本之后）

List<UsersVo> list = Joins.of(Users.class)
                .pushLeftJoin(UsersVo::getUsersAge)
                .eq(Users::getAgeId, UsersAge::getId)
                .le(Users::getAgeId, UsersAge::getId)
                .lt(Users::getAgeId, UsersAge::getId)
                .ge(Users::getAgeId, UsersAge::getId)
                .gt(Users::getAgeId, UsersAge::getId)
                .ne(Users::getAgeId, UsersAge::getId)
                .between(Users::getAgeId, UsersAge::getId, UsersAge::getAgeName)
                .notBetween(Users::getAgeId, UsersAge::getId, UsersAge::getAgeName)
                .joinList(UsersVo.class);


 // 生成SQL
SELECT
	users.user_name,
	users.create_time,
	users.age_id,
	users.content_json,
	users.user_id,
	t2.age_doc AS t2_ageDoc,
	t2.age_name AS t2_ageName,
	t2.create_time AS t2_createTime,
	t2.content_json_age AS t2_contentJsonAge,
	t2.id AS t2_id 
FROM
	users AS users
	LEFT JOIN users_age AS t2 ON t2.id = users.age_id 
WHERE
	(
		users.age_id = t2.id 
		AND users.age_id <= t2.id 
		AND users.age_id < t2.id 
		AND users.age_id >= t2.id 
		AND users.age_id > t2.id 
		AND users.age_id <> t2.id 
		AND users.age_id BETWEEN t2.id 
		AND t2.age_name 
	AND users.age_id NOT BETWEEN t2.id 
	AND t2.age_name)

push*Join 和 @JoinField 方便構(gòu)建join查詢方法（1.3.3版本之后）

// 第一步 在查詢返回的模型中添加對(duì)象或者集合
// 注解參數(shù)
  // 主表對(duì)象class   
  masterModelClass();
  // 子表對(duì)象class
  sunModelClass();
  // 主表關(guān)聯(lián)字段，注意不要寫(xiě)別名啥的，就寫(xiě)實(shí)體類(lèi)中的屬性名
  masterModelField();
  // 子表關(guān)聯(lián)字段，注意不要寫(xiě)別名啥的，就寫(xiě)實(shí)體類(lèi)中的屬性名
  sunModelField();
  // 子表別名,如果你關(guān)聯(lián)的對(duì)象中有兩個(gè)相同的表，就需要顯示填寫(xiě)一下別名，否則不用寫(xiě)
  sunAlias() default "";
  // 關(guān)聯(lián)類(lèi)型
  relevancyType();


@JoinField(masterModelClass = Users.class, masterModelField = "ageId",
            sunModelClass = UsersAge.class, sunModelField = "id", relevancyType = RelevancyType.ONT_TO_ONE,
            sunAlias = "t1")
private UsersAge usersAge;

@JoinField(masterModelClass = Users.class, masterModelField = "ageId",
            sunModelClass = UsersAge.class, sunModelField = "id", relevancyType = RelevancyType.MANY_TO_MANY,
            sunAlias = "t2")
private List<UsersAge> usersAges;

// 添加完注解之后，就可以用push*Join方法，添加進(jìn)去
 pushLeftJoin(UsersVo::getUsersAge) 
 
 List<UsersVo> list = Joins.of(Users.class)
                .pushLeftJoin(UsersVo::getUsersAge)
                .joinList(UsersVo.class);
// 如果你添加完這個(gè)join之后，還需要再添加條件之類(lèi)的
 List<UsersVo> list = Joins.of(Users.class)
   							// 就需要用該參數(shù)，指定一下構(gòu)建的泛型class
                .pushLeftJoin(UsersVo::getUsersAge, UsersAge.class)
   							.eq(UsersAge::getId, Users::getAgeId).end()
                .joinList(UsersVo.class);
// 執(zhí)行SQL
	SELECT 
  users.user_name,users.create_time,users.age_id,users.content_json,users.user_id, t1.age_doc as t1_ageDoc , t1.age_name as t1_ageName , t1.create_time as t1_createTime , t1.content_json_age as t1_contentJsonAge , t1.id as t1_id 
  FROM users as users 
  LEFT JOIN users_age as t1 ON t1.id = users.age_id
 
// 返回對(duì)象
UsersVo(....
        usersAge=UsersAge(id=1, ageDoc=90, ageName=90, createTime=Fri Dec 17 13:11:11 CST 2021, contentJsonAge=TestUserJson(name=456, content=嗚嗚嗚)))
 

changeQueryWrapper 轉(zhuǎn)換條件構(gòu)造器

//  轉(zhuǎn)換查詢Wrapper 會(huì)把 查詢條件，group，order by，having轉(zhuǎn)換
//  注意該方法無(wú)法給 多個(gè)入?yún)⑻砑觿e名，例如 orderByDesc("id","id2") 這種情況下別名就會(huì)添加錯(cuò)誤
 QueryWrapper<Users> wrapper1 = new QueryWrapper<>();
        wrapper1.eq("user_id", 1)
                .and(w -> {
                    w.like("user_id", 2).or()
                            .le("user_id", 34);
                })
                .orderByDesc("user_id")
                .groupBy("user_id")
                .having("1={0}", 1);
 wrapper.changeQueryWrapper(wrapper1);

// SQL
SELECT users.create_time, users.content_json, users.user_id, u_age.age_doc, u_age.age_name, u_age.id, u_age.content_json_age, u_age.id AS ageTableId, '1' AS mpnb, sum(u_age.id) AS ageIds
 FROM users AS users
 LEFT JOIN users_age AS u_age
 ON u_age.id = users.age_id
WHERE (users.user_id = 1 AND (user_id LIKE '%2%' OR user_id <= 34)) GROUP BY users.user_id HAVING 1 = 1 ORDER BY users.user_id DESC;

orderBy 順序排列

// 根據(jù)index下標(biāo)進(jìn)行排列排序順序 
// @param condition 是否執(zhí)行 @param isAsc     是否正序
// @param index     下標(biāo) @param column    列
orderBy(boolean condition, boolean isAsc, R column, int index) 

// 手寫(xiě)排序SQL @param condition 是否執(zhí)行  @param sql      SQL
orderBySql(boolean condition, String sql, int index);

JoinLambdaWrapper<Users> wrapper = joinLambdaQueryWrapper(Users.class)
                .orderByDesc(Users::getAgeId) // 如果存在有下標(biāo)的排序和無(wú)下標(biāo)的排序，無(wú)下標(biāo)的排序，會(huì)被存在于最前面
                .leftJoin(UsersAge.class, UsersAge::getId, Users::getAgeId)
                .orderByAsc(UsersAge::getId, 2)
                .orderBySql("users.user_id asc", 0) // 可以手寫(xiě)排序SQL，處理一些復(fù)雜的操作，這個(gè)orderBySql字表和主表中都可以存在
                .end()
                .orderBySql("users_age.age_name desc", 1);
 return super.joinList(wrapper, UsersVo.class);

// SQL
SELECT users.content_json, users_age.content_json_age as contentJsonAge
FROM users as users
LEFT JOIN users_age as users_age ON users_age.id = users.age_id 
ORDER BY users.age_id DESC,users.user_id asc,users_age.age_name desc,users_age.id ASC;

distinct 去重

// 根據(jù)index下標(biāo)進(jìn)行排列排序順序 
// @param condition 是否執(zhí)行 @param isAsc     是否正序
// @param index     下標(biāo) @param column    列
orderBy(boolean condition, boolean isAsc, R column, int index) 

// 手寫(xiě)排序SQL @param condition 是否執(zhí)行  @param sql      SQL
orderBySql(boolean condition, String sql, int index);

JoinLambdaWrapper<Users> wrapper = joinLambdaQueryWrapper(Users.class)
  							.distinct() // 這個(gè)只能存在于主表
                .orderByDesc(Users::getAgeId) // 如果存在有下標(biāo)的排序和無(wú)下標(biāo)的排序，無(wú)下標(biāo)的排序，會(huì)被存在于最前面
                .leftJoin(UsersAge.class, UsersAge::getId, Users::getAgeId)
                .orderByAsc(UsersAge::getId, 2)
                .orderBySql("users.user_id asc", 0) // 可以手寫(xiě)排序SQL，處理一些復(fù)雜的操作，這個(gè)orderBySql字表和主表中都可以存在
                .end()
                .orderBySql("users_age.age_name desc", 1);
 return super.joinList(wrapper, UsersVo.class);

// SQL
SELECT DISTINCT users.content_json, users_age.content_json_age as contentJsonAge
FROM users as users
LEFT JOIN users_age as users_age ON users_age.id = users.age_id 
ORDER BY users.age_id DESC,users.user_id asc,users_age.age_name desc,users_age.id ASC;

自定義別名和返回map類(lèi)型

// 兩個(gè)參數(shù)代表自定義別名
JoinLambdaWrapper<Users> wrapper = joinLambdaQueryWrapper(Users.class, "userMaster");

wrapper
       .select(Users::getUserId, Users::getUserName)
  		// leftJoin innerJoin rightJoin 三個(gè)參數(shù)代表使用默認(rèn)別名，四個(gè)參數(shù)代表使用自定義別名
       .leftJoin(UsersAge.class, UsersAge::getId, Users::getAgeId, "u_age")
       .select(UsersAge::getAgeDoc).end()
       .leftJoin(UsersAge.class, UsersAge::getId, Users::getAgeId, "u_a")
       .select(UsersAge::getAgeName).end();

// 需要注意的是當(dāng)返回參數(shù)為map的時(shí)候是沒(méi)有下劃線轉(zhuǎn)駝峰的，如果需要請(qǐng)自行配置mybatis的下劃線轉(zhuǎn)駝峰
List<Map> dataList = super.joinList(wrapper, Map.class);

// SQL
SELECT
	userMaster.user_id,
	userMaster.user_name,
	u_age.age_doc,
	u_a.age_name 
FROM
	users AS userMaster
	LEFT JOIN users_age AS u_age ON u_age.id = userMaster.age_id
	LEFT JOIN users_age AS u_a ON u_a.id = userMaster.age_id;

一對(duì)一查詢映射

// 很多時(shí)候連表返回的字段很多都相同，所以在每個(gè)vo里面都會(huì)出現(xiàn)，如果把這些重復(fù)性字段封裝成一個(gè)類(lèi)，會(huì)更好維護(hù)，所以說(shuō)針對(duì)這個(gè)情況 版本 >= 1.0.6 即可使用oneToOneSelect 方法

 JoinLambdaWrapper<Users> wrapper = joinLambdaQueryWrapper(Users.class);

 wrapper.leftJoin(UsersAge.class, UsersAge::getId, Users::getAgeId)
   // oneToOneSelect 第一個(gè)參數(shù)需要映射的實(shí)體類(lèi)字段，第二個(gè)參數(shù)則是查詢函數(shù)
        .oneToOneSelect(UsersVo::getUsersAge, (cb) -> {
             cb.add(UsersAge::getAgeDoc, UsersAge::getAgeName)
               /* 
              當(dāng)你出現(xiàn)兩個(gè)實(shí)體類(lèi)映射字段相同，例如 user實(shí)體中有個(gè)字段id，userAge表中也有個(gè)字段id，你									想要同時(shí)獲取這兩個(gè)字段，這時(shí)候則可以使用
               |column : 查詢字段
               |alias  : 別名
							 |fieldName : 字段名稱(chēng)
               add(SFunction<T, ?> column, String alias, SFunction<F, ?> fieldName)
               */
               .add(UsersAge::getId, "ageId", UsersAge::getId)
          		// 在1.3.2版本后 屬性名和映射vo的屬性名相同的情況下，可以不必寫(xiě)別名，就可以完成自動(dòng)映射
          	 .add(UsersAge::getId);
         })
   // 1.3.3版本之后可以 這樣子查詢這個(gè)類(lèi)的所有查詢字段并賦值到對(duì)象中
     .oneToOneSelect(UsersVo::getUsersAge,UsersAge.class)
   .end();


 return super.joinList(wrapper, UsersVo.class);

// 執(zhí)行SQL 
SELECT users.user_name, users.create_time, users.age_id, users.user_id, users_age.age_doc
	, users_age.age_name, users_age.id AS ageId
FROM users users
	LEFT JOIN users_age users_age ON users_age.id = users.age_id
  
// 返回結(jié)果
[
  {
   "ageId":1,
   "createTime":1635416270000,
   "userId":1,
   "userName":"名字啊",
   "usersAge":{
     "ageDoc":"90",
     "ageName":"90",
     "id":1
   }
  }....
]

多對(duì)多查詢映射

JoinLambdaWrapper<UsersAge> wrapper = joinLambdaQueryWrapper(UsersAge.class);

wrapper.leftJoin(Users.class, Users::getAgeId, UsersAge::getId)
  			// manyToManySelect 多對(duì)多，對(duì)應(yīng)的就是 mybatis中的resultMap中的collection標(biāo)簽
  			// 該方法第一個(gè)參數(shù)代表的是需要映射到的實(shí)體類(lèi)字段
        // 第二個(gè)參數(shù)代表list中的實(shí)體類(lèi)型 例如 List<Users> 這里的實(shí)體類(lèi)型就是Users
  			// 第三個(gè)就是要查詢的字段
        .manyToManySelect(UsersAgesVo::getUsersList, Users.class, (cb) -> {
          	// 在1.3.2版本后 屬性名和映射vo的屬性名相同的情況下，可以不必寫(xiě)別名，就可以完成自動(dòng)映射
           cb.add(Users::getUserName, Users::getUserId, Users::getCreateTime);
         })
  			   // 1.3.3版本之后可以 這樣子查詢這個(gè)類(lèi)的所有查詢字段并賦值到集合對(duì)象中
    		.manyToManySelect(UsersAgesVo::getUsersList,Users.class)
  .end();
return super.joinList(wrapper, UsersAgesVo.class);

// 執(zhí)行SQL
SELECT 		   
 users_age.age_doc,users_age.age_name,users_age.id,users.user_name,users.user_id,users.create_time
FROM users_age AS users_age
	LEFT JOIN users AS users ON users.age_id = users_age.id;

// 返回?cái)?shù)據(jù)
[
  {"ageDoc":"90","ageName":"90","id":1,
   "usersList":[
     {"createTime":1635416270000,"userId":1,"userName":"名字啊"},
     {"createTime":1635416270000,"userId":2,"userName":"名字2"}
   ]
  }
]

返回基礎(chǔ)類(lèi)型數(shù)據(jù)

// 當(dāng)我們只需要查詢一個(gè)字段，例如id列表，現(xiàn)在支持直接傳遞基礎(chǔ)類(lèi)型

JoinLambdaWrapper<Users> wrapper = joinLambdaQueryWrapper(Users.class)
                .select(Users::getUserId);

List<Integer> ids = super.joinList(wrapper, Integer.class);

System.out.println(JSON.toJSONString(ids));

// 輸出結(jié)果：[1,2]

// 也支持返回單個(gè)數(shù)據(jù)類(lèi)型

JoinLambdaWrapper<Users> wrapper = joinLambdaQueryWrapper(Users.class)
                .select(Users::getUserName)
                .eq(Users::getUserId, 1)
                .last("limit 1");

String userName = super.joinGetOne(wrapper, String.class);

System.out.println(userName);

// 輸出結(jié)果："我是名字1"

根據(jù)實(shí)體不為空的數(shù)據(jù)查詢

// 如果需要根據(jù)實(shí)體查詢可以采用這樣的實(shí)例化
JoinLambdaWrapper<Users> wrapper = new JoinLambdaWrapper<>(new Users().setUserName("name啊")
                                                                          .setUserId(1L));
// 或者可以采用這樣的setEntity
// wrapper.setEntity(new Users().setUserName("name啊"));

// 這一部分一個(gè)參數(shù)是join中定義的連接的表，第二個(gè)參數(shù)是隨意的表，但是是要出現(xiàn)構(gòu)造器中的
wrapper.leftJoin(UsersAge.class,UsersAge::getId,Users::getAgeId)
// 然后可以設(shè)置多表中的查詢條件，這一步和mp一致
			.eq(UserAge::getAgeName,"95")
  		.select(UserAge::getAgeName)
// 最后一步 需要使用end方法結(jié)束
      wrapper.end();

// 執(zhí)行查詢
usersService.joinList(wrapper,UsersVo.class);

// 執(zhí)行SQL 
select 
  users.user_id,
  users.user_name,
  users_age.age_name
from users users
  left join users_age users_age on users_age.id = users.age_id
where 
 users.user_id = 1
 and users.user_name = 'name啊'
 and users_age.age_name = '95'

notDefaultSelectAll() 不默認(rèn)查詢主表全部的字段

// 如果需要根據(jù)實(shí)體查詢可以采用這樣的實(shí)例化
JoinLambdaWrapper<Users> wrapper = new JoinLambdaWrapper<>(new Users().setUserName("name啊")
                                                                          .setUserId(1L));

// 因?yàn)槟J(rèn)是查詢主表所有查詢字段，如果不需要查詢主表全部字段就調(diào)用該方法
wrapper.notDefaultSelectAll();

// 這一部分一個(gè)參數(shù)是join中定義的連接的表，第二個(gè)參數(shù)是隨意的表，但是是要出現(xiàn)構(gòu)造器中的
wrapper.leftJoin(UsersAge.class,UsersAge::getId,Users::getAgeId)
// 然后可以設(shè)置多表中的查詢條件，這一步和mp一致
			.eq(UserAge::getAgeName,"95")
  		.select(UserAge::getAgeName)
// 最后一步 需要使用end方法結(jié)束
			.end();

// 執(zhí)行查詢
usersService.joinList(wrapper,UsersVo.class);

// 執(zhí)行SQL 
select 
  users_age.age_name
from users users
  left join users_age users_age on users_age.id = users.age_id
where 
 users.user_id = 1
 and users.user_name = 'name啊'
 and users_age.age_name = '95'

selectAs() 查詢添加別名

/* 
  selectAs(List<As<T>> columns) 
  selectAs(SFunction<T, ?> column, String alias)
  查詢并添加別名
*/
// 拿起來(lái)我們上面用的哪個(gè)實(shí)例。我現(xiàn)在需要給ageName給個(gè)別名 user_age_name
JoinLambdaWrapper<Users> wrapper = new JoinLambdaWrapper<>(Users.class);
wrapper.leftJoin(UsersAge.class,UsersAge::getId,Users::getAgeId)
  	.eq(UserAge::getAgeName,"95")
  	.selectAs(UserAge::getAgeName,"user_age_name")
  	// 在1.3.2版本后可以采用函數(shù)的方式寫(xiě)別名
  		.selectAs(UserAge::getAgeName,UsersVo::getUserAgeName)
  	.end();
// 執(zhí)行查詢
usersService.joinList(wrapper,UsersVo.class);

// 執(zhí)行SQL 
select 
  users.user_id,
	users.user_name,
	users_age.age_name as user_age_name
from users users
  left join users_age users_age on users_age.id = users.age_id
where (
	users_age.age_name = '95'
)
    
// 現(xiàn)在來(lái)個(gè)高級(jí)需求，我需要查詢出users_age表中的兩個(gè)字段并且需要加一個(gè)固定值

JoinLambdaWrapper<Users> wrapper = new JoinLambdaWrapper<>(Users.class);
wrapper.join(UsersAge.class)
  	.leftJoin(UsersAge::getId,Users::getAgeId)
  	.eq(UserAge::getAgeName,"95")
    .selectAs((cb) -> {
      cb.add(UserAge::getAgeName,"user_age_name")
        .add(UserAge::getAgeDoc)
        .addFunAlias(UserAge::getAgeName,UsersVo::getUserAgeName) // 該方法在1.3.2版本后支持
        .add("mp永遠(yuǎn)滴神","mpnb")
        .add("sum(users_age.id)","ageIdSum",false); // 這個(gè)為false就是代表不是字符串，會(huì)原樣查詢 在1.3.1版本后支持
    }).end();
// 執(zhí)行查詢
usersService.joinList(wrapper,UsersVo.class);
 
// 執(zhí)行SQL 
select 
  users.user_id,
	users.user_name,
	users_age.age_name as user_age_name,
	users_age.age_doc,
	'mp永遠(yuǎn)滴神' as mpnb,
	sum(users_age.id) as ageIdSum
from users users
  left join users_age users_age on users_age.id = users.age_id
where (
	users_age.age_name = '95'
)

 
/*
	這里需要注意啊，如果selectAs那個(gè)地方因?yàn)槭呛瘮?shù)接口，所以值是不可以改變的，如果是可變的那么可以采用
	selectAs(Arrays.asList(
			new As(UserAge::getAgeName,"user_age_name"),
			new As(UserAge::getAgeDoc)
	))
*/
    

selectAll() 查詢?nèi)?/h4>

// selectAll()方法，查詢出當(dāng)前表所有的子段
JoinLambdaWrapper<Users> wrapper = new JoinLambdaWrapper<>(Users.class);
wrapper.leftJoin(UsersAge.class,UsersAge::getId,Users::getAgeId)
  	.eq(UserAge::getAgeName,"95")
  	.selectAll().end();
// 執(zhí)行查詢
usersService.joinList(wrapper,UsersVo.class);
 
// 執(zhí)行SQL 
select 
  users.user_id,
	users.user_name,
	users_age.age_name,
	users_age.age_doc,
	users_age.id
from users users
  left join users_age users_age on users_age.id = users.age_id
where (
	users_age.age_name = '95'
)

joinAnd() join添加條件(1.3.4版本后可根據(jù)Wrapper設(shè)定條件)

   
/*
		相信有很多情況需要限制join的表的限制條件那么就需要 
    joinAnd(SFunction<T, Object> field, Object val, int index)
*/

JoinLambdaWrapper<Users> wrapper = new JoinLambdaWrapper<>(Users.class);
wrapper.leftJoin(UsersAge.class,UsersAge::getId,Users::getAgeId)
  	.joinAnd(UsersAge::getId,1,0) // 需要注意啊，這個(gè)最后一個(gè)下標(biāo)是指的第幾個(gè)join，因?yàn)橛袝r(shí)候會(huì)出現(xiàn)多個(gè)連接，附表連接主表，附表的附表連接附表這樣子
  	.eq(UserAge::getAgeName,"95")
  	.selectAs((cb) -> {
      cb.add(UserAge::getAgeName,"user_age_name")
        .add(UserAge::getAgeDoc)
        .add("mp永遠(yuǎn)滴神","mpnb");
    }).end();
// 執(zhí)行查詢
usersService.joinList(wrapper,UsersVo.class);

// 執(zhí)行SQL 
select 
  users.user_id,
	users.user_name,
	users_age.age_name as user_age_name,
	users_age.age_doc,
	'mp永遠(yuǎn)滴神' as mpnb
from users users
  left join users_age users_age on users_age.id = users.age_id and users_age.id = 1
where (
	users_age.age_name = '95'
)
 
// 1.3.4版本后寫(xiě)法
    Joins.of(Users.class)
                .masterLogicDelete(false)
                .pushLeftJoin(UsersVo::getUsersAge, UsersAge.class)
    						.joinAnd(0, w -> w.eq(UsersAge::getId, Users::getAgeId)
                                            .ne(UsersAge::getId, 10))
                .isNotNull(UsersAge::getId).end().joinList(UsersVo.class)
    
 // 執(zhí)行SQL
    SELECT 
    users.user_name,users.create_time,users.age_id,users.content_json,users.user_id, t1.age_doc as t1_ageDoc , t1.age_name as t1_ageName , t1.create_time as t1_createTime , t1.content_json_age as t1_contentJsonAge , t1.id as t1_id 
    FROM users as users 
    LEFT JOIN users_age as t1 ON t1.id = users.age_id and (t1.id = users.age_id AND t1.id <> 10) WHERE (t1.id IS NOT NULL)

同個(gè)接口返回任意實(shí)體

// 這個(gè)就不得不說(shuō)了，大多數(shù)情況下，一個(gè)接口是返回一個(gè)實(shí)體類(lèi)型的，但是很多情況下，我們有不同的業(yè)務(wù)需求，所返回的對(duì)象也是不一樣的，全部加在一個(gè)對(duì)象中又太臃腫不好維護(hù)，所以就需要這個(gè)返回任意定制類(lèi)型
// 使用方法 在最后一個(gè)參數(shù)中增加上自己的實(shí)體類(lèi)型就行了
List<UsersVo> usersVoList = usersService.joinList(wrapper,UsersVo.class);

自定義別名 TableAlias

/*
	這個(gè)自定義別名是某些業(yè)務(wù)下，比如說(shuō)在項(xiàng)目中構(gòu)建了SQL啊，之類(lèi)的，但是構(gòu)建的SQL別名一般都是固定的達(dá)到通用，
	所以需要在實(shí)體中增加別名使用@TableAlias注解就行了，如果沒(méi)有添加別名 就默認(rèn)使用表名作為別名 
*/
@TableName("app_users")
@TableAlias("users")
public class Users implements Serializable {
  
}

用法注意

1.在使用 join service 一系列方法的時(shí)候，所有參數(shù)都不能傳null

2.這個(gè)條件構(gòu)造器啊，你在join的時(shí)候就相當(dāng)于創(chuàng)建一個(gè)新的構(gòu)造器，你要在這個(gè)新的構(gòu)造器中實(shí)現(xiàn)你所有的操作，包括查詢，和條件，排序之類(lèi)的，這樣的好處在于，維護(hù)好一些，畢竟都放在一起的話，到時(shí)候容易迷。

3.您的start是作者更新的動(dòng)力，如果用的人多的話，可以留言，我會(huì)繼續(xù)更新并適配mp其他版本，如果各位等不了呢，也可以把源碼下載下來(lái)，放進(jìn)你的項(xiàng)目中改一下里面的東西。文章來(lái)源地址http://www.zghlxwxcb.cn/news/detail-402172.html

到了這里，關(guān)于mybatis-plus-join mybatis-plus必備神器的文章就介紹完了。如果您還想了解更多內(nèi)容，請(qǐng)?jiān)谟疑辖撬阉鱐OY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！