我這樣寫程式碼，比直接使用 MyBatis 效率提高了 100 倍

阿新 • • 發佈：2022-05-30

對一個 Java 後端程式設計師來說，mybatis、hibernate、data-jdbc 等都是我們常用的 ORM 框架。它們有時候很好用，比如簡單的 CRUD，事務的支援都非常棒。但有時候用起來也非常繁瑣，比如接下來我們要聊到的一個常見的開發需求，而對這類需求，本文會給出一個比直接使用這些 ORM 開發效率至少會提高 100 倍的方法（絕無誇張）。

首先資料庫有兩張表

使用者表（user）：（簡單起見，假設只有 4 個欄位）

欄位名	型別	含義
id	bitint	使用者 ID
name	varchar(45)	使用者名稱
age	int	年齡
role_id	int	角色 ID

角色表（role）：（簡單起見，假設只有 2 個欄位）

欄位名	型別	含義
id	int	角色 ID
name	varchar(45)	角色名

接下來我們要實現一個使用者查詢的功能

這個查詢有點複雜，它的要求如下：

可按使用者名稱欄位查詢，要求：可精確匹配（等於某個值）可全模糊匹配（包含給定的值）可後模糊查詢（以...開頭）可前模糊查詢（以.. 結尾）可指定以上四種匹配是否可以忽略大小寫
可按年齡欄位查詢，要求：可精確匹配（等於某個年齡）可大於匹配（大於某個值）可小於匹配（小於某個值）可區間匹配（某個區間範圍）
可按角色ID查詢，要求：精確匹配

可按使用者ID查詢，要求：同年齡欄位
可指定只輸出哪些列（例如，只查詢 ID 與使用者名稱列）
支援分頁（每次查詢後，頁面都要顯示滿足條件的使用者總數）
查詢時可選擇按 ID、使用者名稱、年齡等任意欄位排序

後端介面該怎麼寫呢？

試想一下，對於這種要求的查詢，後端接口裡的程式碼如果用 mybatis、hibernate、data-jdbc 直接來寫的話，100 行程式碼能實現嗎？

反正我是沒這個信心，算了，我還是直接坦白，面對這種需求後端如何只用一行程式碼搞定吧（有興趣的同學可以 mybatis 等寫個試試，最後可以對比一下）

手把手：只一行程式碼實現以上需求

首先，重點人物出場啦：Bean Searcher, 它就是專門來對付這種列表檢索的，無論簡單的還是複雜的，統統一行程式碼搞定！而且它還非常輕量，Jar 包體積僅不到 100KB，無第三方依賴。

假設我們專案使用的框架是 Spring Boot（當然 Bean Searcher 對框架沒有要求，但在 Spring Boot 中使用更加方便）

新增依賴

Maven ：

<dependency>
    <groupId>com.ejlchina</groupId>
    <artifactId>bean-searcher-boot-starter</artifactId>
    <version>3.0.1</version>
</dependency>

Gradle ：

implementation 'com.ejlchina:bean-searcher-boot-starter:3.0.1'

然後寫個實體類來承載查詢的結果

@SearchBean(tables="user u, role r", joinCond="u.role_id = r.id", autoMapTo="u") 
public class User {

    private Long id;		// 使用者ID（u.id）
    private String name;	// 使用者名稱（u.name）
    private int age;		// 年齡（u.age）
    private int roleId;		// 角色ID（u.role_id）
    @DbField("r.name")		// 指明這個屬性來自 role 表的 name 欄位
    private int role;		// 角色名（r.name）

    // Getter and Setter ...
}

接著就可以寫使用者查詢介面了

介面路徑就叫 /user/index 吧：

@RestController
@RequestMapping("/user")
public class UserController {

    @Autowired
    private MapSearcher mapSearcher;  // 注入檢索器（由 bean-searcher-boot-starter 提供）

    @GetMapping("/index")
    public SearchResult<Map<String, Object>> index(HttpServletRequest request) {
    	// 這裡咱們只寫一行程式碼
        return mapSearcher.search(User.class, MapUtils.flat(request.getParameterMap()));
    }

}

上述程式碼中的 MapUtils 是 Bean Searcher 提供的一個工具類，MapUtils.flat(request.getParameterMap()) 只是為了把前端傳來的請求引數統一收集起來，然後剩下的，就全部交給 MapSearcher 檢索器了。

這樣就完了？那我們來測一下這個介面，看看效果吧

（1）無參請求

GET /user/index
返回結果：

{
    "dataList": [           // 使用者列表，預設返回第 0 頁，預設分頁大小為 15 （可配置）
        { "id": 1, "name": "Jack", "age": 25, "roleId": 1, "role": "普通使用者" },
        { "id": 2, "name": "Tom", "age": 26, "roleId": 1, "role": "普通使用者" },
        ...
    ],
    "totalCount": 100       // 使用者總數
}

（2）分頁請求（page | size）

GET /user/index? page=2 & size=10
返回結果：結構同（1）（只是每頁 10 條，返回第 2 頁）

引數名 size 和 page 可自定義， page 預設從 0 開始，同樣可自定義，並且可與其它引數組合使用

（3）資料排序（sort | order）

GET /user/index? sort=age & order=desc
返回結果：結構同（1）（只是 dataList 資料列表以 age 欄位降序輸出）

引數名 sort 和 order 可自定義，可與其它引數組合使用

（4）指定（排除）欄位（onlySelect | selectExclude）

GET /user/index? onlySelect=id,name,role
GET /user/index? selectExclude=age,roleId
返回結果：（列表只含 id,name 與 role 三個欄位）

{
    "dataList": [           // 使用者列表，預設返回第 0 頁（只包含 id,name,role 欄位）
        { "id": 1, "name": "Jack", "role": "普通使用者" },
        { "id": 2, "name": "Tom", "role": "普通使用者" },
        ...
    ],
    "totalCount": 100       // 使用者總數
}

引數名 onlySelect 和 selectExclude 可自定義，可與其它引數組合使用

（5）欄位過濾（op = eq）

GET /user/index? age=20
GET /user/index? age=20 & age-op=eq
返回結果：結構同（1）（但只返回 age = 20 的資料）

引數 age-op = eq 表示 age 的欄位運算子是 eq（Equal 的縮寫），表示引數 age 與引數值 20 之間的關係是 Equal，由於 Equal 是一個預設的關係，所以 age-op = eq 也可以省略

引數名 age-op 的字尾 -op 可自定義，且可與其它欄位引數和上文所列的引數（分頁、排序、指定欄位）組合使用，下文所列的欄位引數也是一樣，不再複述。

（6）欄位過濾（op = ne）

GET /user/index? age=20 & age-op=ne
返回結果：結構同（1）（但只返回 age != 20 的資料，ne 是 NotEqual 的縮寫）

（7）欄位過濾（op = ge）

GET /user/index? age=20 & age-op=ge
返回結果：結構同（1）（但只返回 age >= 20 的資料，ge 是 GreateEqual 的縮寫）

（8）欄位過濾（op = le）

GET /user/index? age=20 & age-op=le
返回結果：結構同（1）（但只返回 age <= 20 的資料，le 是 LessEqual 的縮寫）

（9）欄位過濾（op = gt）

GET /user/index? age=20 & age-op=gt
返回結果：結構同（1）（但只返回 age > 20 的資料，gt 是 GreateThan 的縮寫）

（10）欄位過濾（op = lt）

GET /user/index? age=20 & age-op=lt
返回結果：結構同（1）（但只返回 age < 20 的資料，lt 是 LessThan 的縮寫）

（11）欄位過濾（op = bt）

GET /user/index? age-0=20 & age-1=30 & age-op=bt
返回結果：結構同（1）（但只返回 20 <= age <= 30 的資料，bt 是 Between 的縮寫）

引數 age-0 = 20 表示 age 的第 0 個引數值是 20。上述提到的 age = 20 實際上是 age-0 = 20 的簡寫形式。另：引數名 age-0 與 age-1 中的連字元 - 可自定義。

（12）欄位過濾（op = mv）

GET /user/index? age-0=20 & age-1=30 & age-2=40 & age-op=mv
返回結果：結構同（1）（但只返回 age in (20, 30, 40) 的資料，mv 是 MultiValue 的縮寫，表示有多個值的意思）

（13）欄位過濾（op = in）

GET /user/index? name=Jack & name-op=in
返回結果：結構同（1）（但只返回 name 包含 Jack 的資料，in 是 Include 的縮寫）

（14）欄位過濾（op = sw）

GET /user/index? name=Jack & name-op=sw
返回結果：結構同（1）（但只返回 name 以 Jack 開頭的資料，sw 是 StartWith 的縮寫）

（15）欄位過濾（op = ew）

GET /user/index? name=Jack & name-op=ew
返回結果：結構同（1）（但只返回 name 以 Jack 結尾的資料，sw 是 EndWith 的縮寫）

（16）欄位過濾（op = ey）

GET /user/index? name-op=ey
返回結果：結構同（1）（但只返回 name 為空或為 null 的資料，ey 是 Empty 的縮寫）

（17）欄位過濾（op = ny）

GET /user/index? name-op=ny
返回結果：結構同（1）（但只返回 name 非空的資料，ny 是 NotEmpty 的縮寫）

（18）忽略大小寫（ic = true）

GET /user/index? name=Jack & name-ic=true
返回結果：結構同（1）（但只返回 name 等於 Jack (忽略大小寫) 的資料，ic 是 IgnoreCase 的縮寫）

引數名 name-ic 中的字尾 -ic 可自定義，該引數可與其它的引數組合使用，比如這裡檢索的是 name 等於 Jack 時忽略大小寫，但同樣適用於檢索 name 以 Jack 開頭或結尾時忽略大小寫。

當然，以上各種條件都可以組合，例如

查詢 name 以 Jack (忽略大小寫) 開頭，且 roleId = 1，結果以 id 欄位排序，每頁載入 10 條，查詢第 2 頁：

GET /user/index? name=Jack & name-op=sw & name-ic=true & roleId=1 & sort=id & size=10 & page=2
返回結果：結構同（1）

OK，效果看完了，/user/index 接口裡我們確實只寫了一行程式碼，它便可以支援這麼多種的檢索方式，有沒有覺得現在你寫的一行程式碼就可以幹過別人的一百行呢？

Bean Searcher

本例中，我們只使用了 Bean Searcher 提供的 MapSearcher 檢索器的一個 search 方法，其實，它有很多 search 方法。

檢索方法

searchCount(Class<T> beanClass, Map<String, Object> params) 查詢指定條件下的資料總條數
searchSum(Class<T> beanClass, Map<String, Object> params, String field) 查詢指定條件下的某欄位的統計值
searchSum(Class<T> beanClass, Map<String, Object> params, String[] fields) 查詢指定條件下的多欄位的統計值
search(Class<T> beanClass, Map<String, Object> params) 分頁查詢指定條件下資料列表與總條數
search(Class<T> beanClass, Map<String, Object> params, String[] summaryFields) 同上 + 多欄位統計
searchFirst(Class<T> beanClass, Map<String, Object> params) 查詢指定條件下的第一條資料
searchList(Class<T> beanClass, Map<String, Object> params) 分頁查詢指定條件下資料列表
searchAll(Class<T> beanClass, Map<String, Object> params) 查詢指定條件下所有資料列表

MapSearcher 與 BeanSearcher

另外，Bean Searcher 除了提供了 MapSearcher 檢索器外，還提供了 BeanSearcher 檢索器，它同樣擁有 MapSearcher 擁有的方法，只是它返回的單條資料不是 Map，而是一個泛型物件。

引數構建工具

另外，如果你是在 Service 裡使用 Bean Searcher，那麼直接使用 Map<String, Object> 型別的引數可能不太優雅，為此， Bean Searcher 特意提供了一個引數構建工具。

例如，同樣查詢 name 以 Jack (忽略大小寫) 開頭，且 roleId = 1，結果以 id 欄位排序，每頁載入 10 條，載入第 2 頁，使用引數構建器，程式碼可以這麼寫：

Map<String, Object> params = MapUtils.builder()
        .field(User::getName, "Jack").op(Operator.StartWith).ic()
        .field(User::getRoleId, 1)
        .orderBy(User::getId, "asc")
        .page(2, 10)
        .build()
List<User> users = beanSearcher.searchList(User.class, params);

這裡使用的是 BeanSearcher 檢索器，以及它的 searchList(Class<T> beanClass, Map<String, Object> params) 方法。

運算子約束

上文我們看到，Bean Searcher 對實體類中的每一個欄位，都直接支援了很多的檢索方式。

但某同學：哎呀！檢索方式太多了，我根本不需要這麼多，我的資料量幾十億，使用者名稱欄位的前模糊查詢方式利用不到索引，萬一把我的資料庫查崩了怎麼辦呀？

好辦，Bean Searcher 支援運算子的約束，實體類的使用者名稱 name 欄位只需要註解一下即可：

@SearchBean(tables="user u, role r", joinCond="u.role_id = r.id", autoMapTo="u") 
public class User {

    @DbField(onlyOn = {Operator.Equal, Operator.StartWith})
    private String name;

    // 為減少篇幅，省略其它欄位...
}

如上，通過 @DbField 註解的 onlyOn 屬性，指定這個使用者名稱 name 只能適用與精確匹配和後模糊查詢，其它檢索方式它將直接忽略。

上面的程式碼是限制了 name 只能有兩種檢索方式，如果再嚴格一點，只允許精確匹配，那其實有兩種寫法。

（1）還是使用運算子約束：

@SearchBean(tables="user u, role r", joinCond="u.role_id = r.id", autoMapTo="u") 
public class User {

    @DbField(onlyOn = Operator.Equal)
    private String name;

    // 為減少篇幅，省略其它欄位...
}

（2）在 Controller 的介面方法裡把運算子引數覆蓋：

@GetMapping("/index")
public SearchResult<Map<String, Object>> index(HttpServletRequest request) {
    Map<String, Object> params = MapUtils.flatBuilder(request.getParameterMap())
        .field(User::getName).op(Operator.Equal)   // 把 name 欄位的運算子直接覆蓋為 Equal
        .build()
    return mapSearcher.search(User.class, params);
}

條件約束

該同學又：哎呀！我的資料量還是很大，age 欄位沒有索引，我不想讓它參與 where 條件，不然很可能就出現慢 SQL 啊！

不急，Bean Searcher 還支援條件的約束，讓這個欄位直接不能作為條件：

@SearchBean(tables="user u, role r", joinCond="u.role_id = r.id", autoMapTo="u") 
public class User {

    @DbField(conditional = false)
    private int age;

    // 為減少篇幅，省略其它欄位...
}

如上，通過 @DbField 註解的 conditional 屬性，就直接不允許 age 欄位參與條件了，無論前端怎麼傳參，Bean Searcher 都不搭理。

引數過濾器

該同學仍：哎呀！哎呀 ...

別怕！ Bean Searcher 還支援配置全域性引數過濾器，可自定義任何引數過濾規則，在 Spring Boot 專案中，只需要配置一個 Bean：

@Bean
public ParamFilter myParamFilter() {
    return new ParamFilter() {
        @Override
        public <T> Map<String, Object> doFilter(BeanMeta<T> beanMeta, Map<String, Object> paraMap) {
            // beanMeta 是正在檢索的實體類的元資訊, paraMap 是當前的檢索引數
            // TODO: 這裡可以寫一些自定義的引數過濾規則
            return paraMap;      // 返回過濾後的檢索引數
        }
    };
}

某同學問

引數咋這麼怪，這麼多呢，和前端有仇麼

引數名是否奇怪，這其實看個人喜好，如果你不喜歡中劃線 -，不喜歡 op、ic 字尾，完全可以自定義，參考這篇文件：

http://searcher.ejlchina.com/guide/lates…

引數個數的多少，其實是和需求的複雜程度相關的。如果需求很簡單，那麼很多引數沒必要讓前端傳，後端直接塞進去就好。比如：name 只要求後模糊匹配，age 只要求區間匹配，則可以：

@GetMapping("/index")
public SearchResult<Map<String, Object>> index(HttpServletRequest request) {
    Map<String, Object> params = MapUtils.flatBuilder(request.getParameterMap())
        .field(User::getName).op(Operator.StartWith)
        .field(User::getAge).op(Operator.Between)
        .build()
    return mapSearcher.search(User.class, params);
}

這樣前端就不用傳 name-op 與 age-op 這兩個引數了。

其實還有一種更簡單的方法，那就是運算子約束（當約束存在時，運算子預設就是 onlyOn 屬性中指定的第一個值，前端可以省略不傳）：

@SearchBean(tables="user u, role r", joinCond="u.role_id = r.id", autoMapTo="u") 
public class User {

    @DbField(onlyOn = Operator.StartWith)
    private String name;
    @DbField(onlyOn = Operator.Between)
    private String age;

    // 為減少篇幅，省略其它欄位...
}

入參是 request，我 swagger 文件不好渲染了呀

其實，Bean Searcher 的檢索器只是需要一個 Map<String, Object> 型別的引數，至於這個引數是怎麼來的，和 Bean Searcher 並沒有直接關係。前文之所以從 request 裡取，只是因為這樣程式碼看起來簡潔，如果你喜歡宣告引數，完全可以把程式碼寫成這樣：

@GetMapping("/index")
public SearchResult<Map<String, Object>> index(Integer page, Integer size, 
            String sort, String order, String name, Integer roleId,
            @RequestParam(value = "name-op", required = false) String name_op,
            @RequestParam(value = "name-ic", required = false) Boolean name_ic,
            @RequestParam(value = "age-0", required = false) Integer age_0,
            @RequestParam(value = "age-1", required = false) Integer age_1,
            @RequestParam(value = "age-op", required = false) String age_op) {
    Map<String, Object> params = MapUtils.builder()
        .field(Employee::getName, name).op(name_op).ic(name_ic)
        .field(Employee::getAge, age_0, age_1).op(age_op)
        .field(Employee::getRoleId, roleId)
        .orderBy(sort, order)
        .page(page, size)
        .build();
    return mapSearcher.search(User.class, params);
}

結語

本文介紹了 Bean Searcher 在複雜列表檢索領域的超強能力。它之所以可以極大提高這類需求的研發效率，根本上歸功於它獨創的動態欄位運算子與多表對映機制，這是傳統 ORM 框架所沒有的。但由於篇幅所限，它的特性本文不能盡述，比如它還：

支援聚合查詢
支援 Select|Where|From子查詢
支援實體類嵌入引數
支援欄位轉換器
支援 Sql 攔截器
支援多資料來源
支援自定義註解
等等

要了解更多，先來點個 Star 吧 : Github 、Gitee。

Bean Searcher 是我在工作中總結封裝出來的一個小工具，公司內部使用了 4 年，經歷大小專案三四十個，只是最近才著手完善文件分享給大家，如果你喜歡，一定去點個 Star 哦 ^_^。

再奉上 Bean Searcher 的詳細文件：http://searcher.ejlchina.com/

最後，再來個 Demo 地址：

Spring Boot 框架中使用 demo

Grails 框架中使用 demo

搜尋

複製