這是關於如何解決使用 Spring Data JDBC 時可能遇到的各種挑戰系列的第四篇文章。該系列包括：

1. Spring Data JDBC - 如何使用自定義 ID 生成。

2. Spring Data JDBC - 如何實現雙向關係？

3. Spring Data JDBC - 如何實現快取？

4. Spring Data JDBC - 如何對聚合根進行區域性更新？（本文）

5. Spring Data JDBC - 如何為我的領域模型生成 Schema？

如果您是 Spring Data JDBC 的新手，應該先閱讀介紹以及這篇文章，它解釋了聚合在 Spring Data JDBC 上下文中的相關性。相信我，這很重要。

Spring Data JDBC 圍繞聚合（Aggregate）和倉庫（Repository）的概念構建。倉庫是類似集合的物件，用於查詢、載入、儲存和刪除聚合。聚合是物件叢集，它們之間關係緊密，並且在程式控制位於其方法之外時內部保持一致。因此，聚合也作為一個原子操作一起載入和持久化。

然而，Spring Data JDBC 不跟蹤您的聚合如何變化。因此，Spring Data JDBC 持久化聚合的演算法最小化了對資料庫狀態的假設。如果您的聚合包含實體集合，這會很耗費資源。

為了舉例說明會發生什麼，我們再次以小黃人（Minions）為例。這個小黃人有一套玩具（Toys）。

class Minion {

	@Id Long id;
	String name;
	Color color = Color.YELLOW;
	Set<Toy> toys = new HashSet<>();
	@Version int version;

	Minion(String name) {
		this.name = name;
	}

	@PersistenceConstructor
	private Minion(Long id, String name, Collection<Toy> toys, int version) {

		this.id = id;
		this.name = name;
		this.toys.addAll(toys);
		this.version = version;
	}

	Minion addToy(Toy toy) {

		toys.add(toy);
		return this;
	}
}

這些類的 Schema 如下所示：

CREATE TABLE MINION
(
    ID             IDENTITY PRIMARY KEY,
    NAME           VARCHAR(255),
    COLOR          VARCHAR(10),
    VERSION      INT
);

CREATE TABLE TOY
(
    MINION  BIGINT NOT NULL,
    NAME    VARCHAR(255)
);

而倉庫介面目前很簡單：

interface MinionRepository extends CrudRepository<Minion, Long> {}

如果我們儲存一個數據庫中已經存在的小黃人，會發生以下情況：

1. 該小黃人在資料庫中的所有玩具都會被刪除。

2. 小黃人本身會被更新。

3. 目前屬於該小黃人的所有玩具都會被插入到資料庫中。

當玩具很多且沒有變化、沒有刪除或新增時，這樣做會很浪費。然而，Spring Data JDBC 對此一無所知，並且為了保持簡單，它也不應該知道。此外，您在程式碼中可能比 Spring Data 或任何其他工具或庫知道得更多，並且可以利用這些知識。接下來的部分將介紹執行此操作的各種方法。

使用聚合根的精簡檢視

玩具是任何合格小黃人不可或缺的一部分，但也許有些領域不關心玩具。如果是這樣，擁有一個對映到同一張表的 PlainMinion 也無妨。

@Table("MINION")
class PlainMinion {
	@Id Long id;
	String name;
	@Version int version;
}

由於它不知道玩具，它會保持玩具不變，您可以透過測試來驗證這一點：

@SpringBootTest
class SelectiveUpdateApplicationTests {

	@Autowired MinionRepository minions;
	@Autowired PlainMinionRepository plainMinions;

	@Test
	void renameWithReducedView() {

		Minion bob = new Minion("Bob")
				.addToy(new Toy("Tiger Duck"))
				.addToy(new Toy("Security blanket"));
		minions.save(bob);

		PlainMinion plainBob = plainMinions.findById(bob.id).orElseThrow();
		plainBob.name = "Bob II.";
		plainMinions.save(plainBob);

		Minion bob2 = minions.findById(bob.id).orElseThrow();

		assertThat(bob2.toys).containsExactly(bob.toys.toArray(new Toy[]{}));
	}
}

只需確保玩具和小黃人之間有外部索引鍵關聯，這樣您就不會在不刪除其玩具的情況下意外刪除小黃人。此外，這僅適用於聚合根。聚合內的實體會被刪除並重新建立，因此在此類實體的精簡檢視中不存在的任何列都會重置為其預設值。

使用直接資料庫更新

或者，您可以在新的倉庫方法中直接編寫更新語句：

interface MinionRepository extends CrudRepository<Minion, Long> {

	@Modifying
	@Query("UPDATE MINION SET COLOR ='PURPLE', VERSION = VERSION +1 WHERE ID = :id")
	void turnPurple(Long id);
}

您需要注意，這會繞過 Spring Data JDBC 中的任何邏輯。您必須確保這不會對您的應用程式造成問題。這種邏輯的一個例子是樂觀鎖。上面的語句處理了樂觀鎖，這樣其他正在對 Minion 進行操作的程序就不會意外撤銷顏色更改。類似地，如果您的實體有審計列，您需要確保它們得到相應的更新。如果您使用生命週期事件或實體回撥，您需要考慮如何模擬它們的操作。

使用自定義方法

許多 Spring Data 使用者常常忽略的一個替代方案是實現一個自定義方法，您可以在其中編寫您想要或需要的任何程式碼以達到您的目的。

為此，您可以讓您的倉庫擴充套件一個介面，該介面包含您想要實現的方法：

interface MinionRepository extends CrudRepository<Minion, Long>, PartyHatRepository {}

interface PartyHatRepository {

	void addPartyHat(Minion minion);
}

然後為其提供一個同名但添加了 Impl 字尾的實現：

class PartyHatRepositoryImpl implements PartyHatRepository {

	private final NamedParameterJdbcOperations template;

	public PartyHatRepositoryImpl(NamedParameterJdbcOperations template) {
		this.template = template;
	}

	@Override
	public void addPartyHat(Minion minion) {

		Map<String, Object> insertParams = new HashMap<>();
		insertParams.put("id", minion.id);
		insertParams.put("name", "Party Hat");
		template.update("INSERT INTO TOY (MINION, NAME) VALUES (:id, :name)", insertParams);

		Map<String, Object> updateParams = new HashMap<>();
		updateParams.put("id", minion.id);
		updateParams.put("version", minion.version);
		final int updateCount = template.update("UPDATE MINION SET VERSION = :version + 1 WHERE ID = :id AND VERSION = :version", updateParams);
		if (updateCount != 1) {
			throw new OptimisticLockingFailureException("Minion was changed before a Party Hat was given");
		}
	}
}

在我們的示例中，我們執行多個 SQL 語句來新增一個玩具並確保使用了樂觀鎖：

@Test
void grantPartyHat() {

  Minion bob = new Minion("Bob")
      .addToy(new Toy("Tiger Duck"))
      .addToy(new Toy("Security blanket"));
  minions.save(bob);

  minions.addPartyHat(bob);

  Minion bob2 = minions.findById(bob.id).orElseThrow();

  assertThat(bob2.toys).extracting("name").containsExactlyInAnyOrder("Tiger Duck", "Security blanket", "Party Hat");
  assertThat(bob2.name).isEqualTo("Bob");
  assertThat(bob2.color).isEqualTo(Color.YELLOW);
  assertThat(bob2.version).isEqualTo(bob.version+1);

  assertThatExceptionOfType(OptimisticLockingFailureException.class).isThrownBy(() -> minions.addPartyHat(bob));
}

結論

Spring Data JDBC 旨在讓您在標準情況下更輕鬆。同時，如果您希望行為有所不同，它也不會妨礙您。您可以在許多層面選擇實現所需的行為。

完整的示例程式碼可在 Spring Data 示例倉庫中找到。

還會有更多類似的文章。如果您希望我涵蓋特定主題，請告訴我。