我原本是用俄文寫這篇文章的。因此，如果您的母語(yǔ)是英語(yǔ)，您可以透過(guò)此連結(jié)閱讀。

在過(guò)去一年左右的時(shí)間裡，我看到一些文章和演講表明 JOOQ 是 Hibernate 的現(xiàn)代且優(yōu)越的替代品。參數(shù)通常包括：

1. JOOQ 允許您在編譯時(shí)驗(yàn)證所有內(nèi)容，而 Hibernate 則不能！
2. Hibernate 產(chǎn)生奇怪且並不總是最佳的查詢，而使用 JOOQ，一切都是透明的！
3. Hibernate 實(shí)體是可變的，這很糟糕。 JOOQ 允許所有實(shí)體都是不可變的（你好，函數(shù)式程式設(shè)計(jì)）！
4. JOOQ 不涉及任何帶有註解的「魔法」！

首先聲明，我認(rèn)為 JOOQ 是一個(gè)優(yōu)秀的函式庫(kù)（具體來(lái)說(shuō)是一個(gè)函式庫(kù)，而不是像 Hibernate 這樣的框架）。它擅長(zhǎng)完成自己的任務(wù)——以靜態(tài)類型的方式使用 SQL，在編譯時(shí)捕獲大多數(shù)錯(cuò)誤。

但是，當(dāng)我聽(tīng)到Hibernate 的時(shí)代已經(jīng)過(guò)去，我們現(xiàn)在應(yīng)該使用JOOQ 編寫所有內(nèi)容時(shí)，在我看來(lái)，這聽(tīng)起來(lái)像是在說(shuō)關(guān)係資料庫(kù)的時(shí)代已經(jīng)結(jié)束，我們現(xiàn)在應(yīng)該只使用NoSQL 。聽(tīng)起來(lái)很有趣嗎？然而，不久前，這樣的討論還相當(dāng)嚴(yán)肅。

我認(rèn)為問(wèn)題在於對(duì)這兩個(gè)工具解決的核心問(wèn)題的誤解。在這篇文章中，我的目的是澄清這些問(wèn)題。我們將探索：

1. 什麼是交易腳本？
2. 什麼是領(lǐng)域模型模式？
3. Hibernate 和 JOOQ 解決哪些具體問(wèn)題？
4. 為什麼其中一個(gè)不能取代另一個(gè)，它們?nèi)绾喂泊妫?

交易腳本

使用資料庫(kù)最簡(jiǎn)單、最直覺(jué)的方法是交易腳本模式。簡(jiǎn)而言之，您將所有業(yè)務(wù)邏輯組織為組合成單一交易的一組 SQL 命令。通常，類別中的每個(gè)方法代表一個(gè)業(yè)務(wù)操作，並且僅限於一個(gè)事務(wù)。

假設(shè)我們正在開(kāi)發(fā)一個(gè)應(yīng)用程序，允許演講者向會(huì)議提交演講（為簡(jiǎn)單起見(jiàn)，我們只記錄演講的標(biāo)題）。依照交易腳本模式，提交演講的方法可能如下所示（使用 JDBI for SQL）：

@Service
@RequiredArgsConstructor
public class TalkService {
    private final Jdbi jdbi;

    public TalkSubmittedResult submitTalk(Long speakerId, String title) {
        var talkId = jdbi.inTransaction(handle -> {
            // Count the number of accepted talks by the speaker
            var acceptedTalksCount =
                handle.select("SELECT count(*) FROM talk WHERE speaker_id = :id AND status = 'ACCEPTED'")
                    .bind("id", speakerId)
                    .mapTo(Long.class)
                    .one();
            // Check if the speaker is experienced
            var experienced = acceptedTalksCount >= 10;
            // Determine the maximum allowable number of submitted talks
            var maxSubmittedTalksCount = experienced ? 5 : 3;
            var submittedTalksCount =
                handle.select("SELECT count(*) FROM talk WHERE speaker_id = :id AND status = 'SUBMITTED'")
                    .bind("id", speakerId)
                    .mapTo(Long.class)
                    .one();
            // If the maximum number of submitted talks is exceeded, throw an exception
            if (submittedTalksCount >= maxSubmittedTalksCount) {
                throw new CannotSubmitTalkException("Submitted talks count is maximum: " + maxSubmittedTalksCount);
            }
            return handle.createUpdate(
                    "INSERT INTO talk (speaker_id, status, title) " +
                    "VALUES (:id, 'SUBMITTED', :title)"
                ).bind("id", speakerId)
                   .bind("title", title)
                   .executeAndReturnGeneratedKeys("id")
                   .mapTo(Long.class)
                   .one();
        });
        return new TalkSubmittedResult(talkId);
    }
}

在此程式碼中：

1. 我們計(jì)算演講者已提交的演講數(shù)量。
2. 我們檢查是否超出了提交演講的最大允許數(shù)量。
3. 如果一切正常，我們將建立一個(gè)狀態(tài)為「已提交」的新對(duì)話。

這裡存在潛在的競(jìng)爭(zhēng)條件，但為了簡(jiǎn)單起見(jiàn)，我們不會(huì)關(guān)注它。

這種方法的優(yōu)點(diǎn)：

1. 正在執(zhí)行的 SQL 是簡(jiǎn)單且可預(yù)測(cè)的。如果需要，可以輕鬆調(diào)整它以提高效能。
2. 我們只從資料庫(kù)中取得必要的資料。
3. 使用 JOOQ，這段程式碼可以寫得更簡(jiǎn)單、簡(jiǎn)潔，並且可以使用靜態(tài)型別！

缺點(diǎn)：

1. 僅透過(guò)單元測(cè)試來(lái)測(cè)試業(yè)務(wù)邏輯是不可能的。您將需要整合測(cè)試（而且是相當(dāng)多的測(cè)試）。
2. 如果領(lǐng)域很複雜，這種方法很快就會(huì)導(dǎo)致義大利麵條式程式碼。
3. 存在程式碼重複的風(fēng)險(xiǎn)，隨著系統(tǒng)的發(fā)展，這可能會(huì)導(dǎo)致意外的錯(cuò)誤。

如果您的服務(wù)具有非常簡(jiǎn)單的邏輯並且預(yù)計(jì)不會(huì)隨著時(shí)間的推移變得更加複雜，那麼這種方法是有效的並且有意義的。然而，域通常更大。因此，我們需要一個(gè)替代方案。

領(lǐng)域模型

領(lǐng)域模型模式的想法是我們不再將業(yè)務(wù)邏輯直接與 SQL 命令綁定。相反，我們建立域物件（在 Java 上下文中為類別）來(lái)描述行為並儲(chǔ)存有關(guān)域?qū)嶓w的資料。

在本文中，我們不會(huì)討論貧血模型和豐富模型之間的差異。如果您有興趣，我已經(jīng)寫了一篇關(guān)於該主題的詳細(xì)文章。

業(yè)務(wù)場(chǎng)景（服務(wù)）應(yīng)該僅使用這些對(duì)象，並避免與特定的資料庫(kù)查詢綁定。

當(dāng)然，在現(xiàn)實(shí)中，我們可能會(huì)混合使用與網(wǎng)域物件的互動(dòng)和直接資料庫(kù)查詢來(lái)滿足效能要求。在這裡，我們討論實(shí)現(xiàn)領(lǐng)域模型的經(jīng)典方法，其中不違反封裝和隔離。

例如，如果我們正在討論實(shí)體“Speaker”和“Talk”，如前所述，域物件可能如下所示：

@Service
@RequiredArgsConstructor
public class TalkService {
    private final Jdbi jdbi;

    public TalkSubmittedResult submitTalk(Long speakerId, String title) {
        var talkId = jdbi.inTransaction(handle -> {
            // Count the number of accepted talks by the speaker
            var acceptedTalksCount =
                handle.select("SELECT count(*) FROM talk WHERE speaker_id = :id AND status = 'ACCEPTED'")
                    .bind("id", speakerId)
                    .mapTo(Long.class)
                    .one();
            // Check if the speaker is experienced
            var experienced = acceptedTalksCount >= 10;
            // Determine the maximum allowable number of submitted talks
            var maxSubmittedTalksCount = experienced ? 5 : 3;
            var submittedTalksCount =
                handle.select("SELECT count(*) FROM talk WHERE speaker_id = :id AND status = 'SUBMITTED'")
                    .bind("id", speakerId)
                    .mapTo(Long.class)
                    .one();
            // If the maximum number of submitted talks is exceeded, throw an exception
            if (submittedTalksCount >= maxSubmittedTalksCount) {
                throw new CannotSubmitTalkException("Submitted talks count is maximum: " + maxSubmittedTalksCount);
            }
            return handle.createUpdate(
                    "INSERT INTO talk (speaker_id, status, title) " +
                    "VALUES (:id, 'SUBMITTED', :title)"
                ).bind("id", speakerId)
                   .bind("title", title)
                   .executeAndReturnGeneratedKeys("id")
                   .mapTo(Long.class)
                   .one();
        });
        return new TalkSubmittedResult(talkId);
    }
}

這裡，Speaker 類別包含提交演講的業(yè)務(wù)邏輯。資料庫(kù)互動(dòng)抽象化出來(lái)，讓領(lǐng)域模型專注於業(yè)務(wù)規(guī)則。

假設(shè)這個(gè)儲(chǔ)存庫(kù)介面：

@AllArgsConstructor
public class Speaker {
    private Long id;
    private String firstName;
    private String lastName;
    private List<Talk> talks;

    public Talk submitTalk(String title) {
        boolean experienced = countTalksByStatus(Status.ACCEPTED) >= 10;
        int maxSubmittedTalksCount = experienced ? 3 : 5;
        if (countTalksByStatus(Status.SUBMITTED) >= maxSubmittedTalksCount) {
            throw new CannotSubmitTalkException(
              "Submitted talks count is maximum: " + maxSubmittedTalksCount);
        }
        Talk talk = Talk.newTalk(this, Status.SUBMITTED, title);
        talks.add(talk);
        return talk;
    }

    private long countTalksByStatus(Talk.Status status) {
        return talks.stream().filter(t -> t.getStatus().equals(status)).count();
    }
}

@AllArgsConstructor
public class Talk {
    private Long id;
    private Speaker speaker;
    private Status status;
    private String title;
    private int talkNumber;

    void setStatus(Function<Status, Status> fnStatus) {
        this.status = fnStatus.apply(this.status);
    }

    public enum Status {
        SUBMITTED, ACCEPTED, REJECTED
    }
}

那麼SpeakerService可以這樣實(shí)作：

public interface SpeakerRepository {
    Speaker findById(Long id);
    void save(Speaker speaker);
}

領(lǐng)域模型的優(yōu)點(diǎn)：

1. 域物件與實(shí)作細(xì)節(jié)（即資料庫(kù)）完全解耦。這使得它們可以輕鬆地通過(guò)常規(guī)單元測(cè)試進(jìn)行測(cè)試。
2. 業(yè)務(wù)邏輯集中在域物件內(nèi)。與事務(wù)腳本方法不同，這大大降低了邏輯在應(yīng)用程式中傳播的風(fēng)險(xiǎn)。
3. 如果需要，網(wǎng)域物件可以完全不可變，這可以提高使用它們時(shí)的安全性（您可以將它們傳遞給任何方法，而不必?fù)?dān)心意外修改）。
4. 領(lǐng)域?qū)ο裰械臋谖豢梢蕴鎿Q為值對(duì)象，這不僅提高了可讀性，而且保證了賦值時(shí)欄位的有效性（不能創(chuàng)建內(nèi)容無(wú)效的值對(duì)象）。

總之，優(yōu)點(diǎn)很多。然而，有一個(gè)重要的挑戰(zhàn)。有趣的是，在經(jīng)常宣揚(yáng)領(lǐng)域模型模式的領(lǐng)域驅(qū)動(dòng)設(shè)計(jì)書籍中，這個(gè)問(wèn)題要不是根本沒(méi)有提到，就是只是簡(jiǎn)單提及。

問(wèn)題是如何將域物件儲(chǔ)存到資料庫(kù)，然後讀取它們？換句話說(shuō)，如何實(shí)作儲(chǔ)存庫(kù)？

現(xiàn)在，答案是顯而易見(jiàn)的。只需使用 Hibernate（或更好的是 Spring Data JPA）即可省去麻煩。但讓我們想像一下，我們正處?kù)兑粋€(gè) ORM 框架尚未發(fā)明的世界。我們?cè)撊绾谓鉀Q這個(gè)問(wèn)題呢？

手動(dòng)測(cè)繪

為了實(shí)現(xiàn)SpeakerRepository，我還使用JDBI：

@Service
@RequiredArgsConstructor
public class TalkService {
    private final Jdbi jdbi;

    public TalkSubmittedResult submitTalk(Long speakerId, String title) {
        var talkId = jdbi.inTransaction(handle -> {
            // Count the number of accepted talks by the speaker
            var acceptedTalksCount =
                handle.select("SELECT count(*) FROM talk WHERE speaker_id = :id AND status = 'ACCEPTED'")
                    .bind("id", speakerId)
                    .mapTo(Long.class)
                    .one();
            // Check if the speaker is experienced
            var experienced = acceptedTalksCount >= 10;
            // Determine the maximum allowable number of submitted talks
            var maxSubmittedTalksCount = experienced ? 5 : 3;
            var submittedTalksCount =
                handle.select("SELECT count(*) FROM talk WHERE speaker_id = :id AND status = 'SUBMITTED'")
                    .bind("id", speakerId)
                    .mapTo(Long.class)
                    .one();
            // If the maximum number of submitted talks is exceeded, throw an exception
            if (submittedTalksCount >= maxSubmittedTalksCount) {
                throw new CannotSubmitTalkException("Submitted talks count is maximum: " + maxSubmittedTalksCount);
            }
            return handle.createUpdate(
                    "INSERT INTO talk (speaker_id, status, title) " +
                    "VALUES (:id, 'SUBMITTED', :title)"
                ).bind("id", speakerId)
                   .bind("title", title)
                   .executeAndReturnGeneratedKeys("id")
                   .mapTo(Long.class)
                   .one();
        });
        return new TalkSubmittedResult(talkId);
    }
}

方法很簡(jiǎn)單。對(duì)於每個(gè)儲(chǔ)存庫(kù)，我們編寫一個(gè)單獨(dú)的實(shí)現(xiàn)，該實(shí)作可以使用任何 SQL 庫(kù)（如 JOOQ 或 JDBI）與資料庫(kù)配合使用。

乍看之下（甚至可能是第二眼），這個(gè)解決方案可能看起來(lái)相當(dāng)不錯(cuò)?？紤]一下：

1. 程式碼保持高度透明，就像交易腳本方法一樣。
2. 僅透過(guò)整合測(cè)試來(lái)測(cè)試業(yè)務(wù)邏輯不再有問(wèn)題。這些僅用於儲(chǔ)存庫(kù)實(shí)作（可能還有一些 E2E 場(chǎng)景）。
3. 映射程式碼就在我們面前。不涉及 Hibernate 魔法。發(fā)現(xiàn)錯(cuò)誤？找到正確的線並修復(fù)它。

休眠的必要性

現(xiàn)實(shí)世界中的事情會(huì)變得更加有趣，你可能會(huì)遇到這樣的場(chǎng)景：

1. 域物件可能需要支援繼承。
2. 一組欄位可以組合成一個(gè)單獨(dú)的值物件（嵌入在 JPA/Hibernate 中）。
3. 某些欄位不應(yīng)在每次取得網(wǎng)域物件時(shí)加載，而應(yīng)僅在存取時(shí)加載，以提高效能（延遲載入）。
4. 物件之間可能存在複雜的關(guān)係（一對(duì)多、多對(duì)多等）。
5. 您只需要在 UPDATE 語(yǔ)句中包含已更改的字段，因?yàn)槠渌侄魏苌俑?，並且通過(guò)網(wǎng)絡(luò)發(fā)送它們是沒(méi)有意義的（DynamicUpdate 註釋）。

最重要的是，隨著業(yè)務(wù)邏輯和領(lǐng)域物件的發(fā)展，您需要維護(hù)映射程式碼。

如果您嘗試自己處理這些要點(diǎn)，您最終會(huì)發(fā)現(xiàn)自己（驚訝?。┱诰帉戭愃?Hibernate 的框架 - 或者更可能是一個(gè)更簡(jiǎn)單的版本。

JOOQ 和 Hibernate 的目標(biāo)

JOOQ 解決了編寫 SQL 查詢時(shí)缺乏靜態(tài)類型的問(wèn)題。這有助於減少編譯階段的錯(cuò)誤數(shù)量。透過(guò)直接從資料庫(kù)模式產(chǎn)生程式碼，對(duì)模式的任何更新都將立即顯示程式碼需要修復(fù)的位置（它根本無(wú)法編譯）。

Hibernate 解決了網(wǎng)域物件對(duì)應(yīng)到關(guān)聯(lián)式資料庫(kù)的問(wèn)題，反之亦然（從資料庫(kù)讀取資料並將其對(duì)應(yīng)到網(wǎng)域物件）。

因此，爭(zhēng)論 Hibernate 更差或 JOOQ 更好是沒(méi)有意義的。這些工具是為不同的目的而設(shè)計(jì)的。如果您的應(yīng)用程式是圍繞著事務(wù)腳本範(fàn)例構(gòu)建的，那麼 JOOQ 無(wú)疑是理想的選擇。但是，如果您想使用網(wǎng)域模型模式並避免使用 Hibernate，則必須在自訂儲(chǔ)存庫(kù)實(shí)作中享受手動(dòng)對(duì)應(yīng)的樂(lè)趣。當(dāng)然，如果您的雇主付錢讓您建造另一個(gè) Hibernate 殺手，那就沒(méi)有問(wèn)題了。但最有可能的是，他們希望您專注於業(yè)務(wù)邏輯，而不是物件到資料庫(kù)映射的基礎(chǔ)設(shè)施代碼。

順便說(shuō)一句，我相信 Hibernate 和 JOOQ 的組合對(duì)於 CQRS 效果很好。您有一個(gè)執(zhí)行命令的應(yīng)用程式（或其邏輯部分），例如 CREATE/UPDATE/DELETE 操作 - 這就是 Hibernate 非常適合的地方。另一方面，您有一個(gè)讀取資料的查詢服務(wù)。在這裡，JOOQ 表現(xiàn)出色。與 Hibernate 相比，它使得建立複雜查詢和最佳化它們變得更加容易。

JOOQ 中的 DAO 怎麼樣？

這是真的。 JOOQ 可讓您產(chǎn)生包含用於從資料庫(kù)取得實(shí)體的標(biāo)準(zhǔn)查詢的 DAO。您甚至可以用您的方法擴(kuò)展這些 DAO。此外，JOOQ 將產(chǎn)生可以使用 setter 填充的實(shí)體（類似於 Hibernate），並傳遞給 DAO 中的插入或更新方法。這不是像Spring Data嗎？

對(duì)於簡(jiǎn)單的情況，這確實(shí)可行。然而，它與手動(dòng)實(shí)現(xiàn)存儲(chǔ)庫(kù)沒(méi)有太大區(qū)別。問(wèn)題類似：

1. 實(shí)體不會(huì)有任何關(guān)係：沒(méi)有ManyToOne，沒(méi)有OneToMany。只是資料庫(kù)列，這使得編寫業(yè)務(wù)邏輯變得更加困難。
2. 實(shí)體是單獨(dú)產(chǎn)生的。您無(wú)法將它們組織成繼承層次結(jié)構(gòu)。
3. 實(shí)體與 DAO 一起產(chǎn)生的事實(shí)意味著您無(wú)法按照自己的意願(yuàn)修改它們。例如，用值物件取代欄位、新增與另一個(gè)實(shí)體的關(guān)係或?qū)谖环纸M到可嵌入是不可能的，因?yàn)橹匦庐a(chǎn)生實(shí)體將覆寫您的變更。是的，您可以配置生成器以稍微不同的方式建立實(shí)體，但自訂選項(xiàng)是有限的（並且不如自己編寫程式碼那麼方便）。

所以，如果你想建立一個(gè)複雜的領(lǐng)域模型，你必須手動(dòng)完成。如果沒(méi)有 Hibernate，映射的責(zé)任將完全落在您身上。當(dāng)然，使用 JOOQ 比 JDBI 更愉快，但這個(gè)過(guò)程仍然是勞力密集的。

甚至 JOOQ 的創(chuàng)建者 Lukas Eder 在他的部落格中也提到，DAO 被添加到庫(kù)中是因?yàn)樗且环N流行的模式，而不是因?yàn)樗欢ㄍ扑]使用它們。

結(jié)論

感謝您閱讀這篇文章。我是 Hibernate 的忠實(shí)粉絲，認(rèn)為它是一個(gè)優(yōu)秀的框架。不過(guò)，我知道有些人可能會(huì)覺(jué)得 JOOQ 比較方便。我文章的重點(diǎn)是 Hibernate 和 JOOQ 不是競(jìng)爭(zhēng)對(duì)手。如果這些工具帶來(lái)價(jià)值，甚至可以在同一產(chǎn)品中共存。

如果您對(duì)內(nèi)容有任何意見(jiàn)或回饋，我很樂(lè)意討論。祝你度過(guò)富有成效的一天！

資源

1. JDBI
2. 交易腳本
3. 領(lǐng)域模型
4. 我的文章 – 使用 Spring Boot 和 Hibernate 的豐富域模型
5. 儲(chǔ)存庫(kù)模式
6. 值物件
7. JPA 嵌入式
8. JPA 動(dòng)態(tài)更新
9. CQRS
10. Lukas Eder：去 DAO 還是不去 DAO

以上是JOOQ 不是 Hibernate 的替代品。他們解決不同的問(wèn)題的詳細(xì)內(nèi)容。更多資訊請(qǐng)關(guān)注PHP中文網(wǎng)其他相關(guān)文章！