Hibernate READ_ONLY CacheConcurrencyStrategy如何工作

介绍

正如我前面所解释的，企业的高速缓存需要勤奋。由于数据在数据库（ 记录系统 ）和缓存层之间重复，因此我们需要确保两个单独的数据源不会分开。

如果缓存的数据是不可变的（数据库和缓存都无法修改它），我们可以安全地对其进行缓存，而不必担心任何一致性问题。只读数据始终是应用程序级缓存的理想选择，可以在不放松一致性保证的情况下提高读取性能。

只读二级缓存

为了测试只读二级缓存策略，我们将使用以下域模型：

存储库是根实体，是任何Commit实体的父代。每个提交都有一个“ 更改”组件（可嵌入的值类型）列表。

所有实体都缓存为只读元素：

@org.hibernate.annotations.Cache(usage = CacheConcurrencyStrategy.READ_ONLY
)

持久实体

只读二级缓存使用一种直读缓存策略，在获取时会缓存实体。

doInTransaction(session -> {Repository repository = new Repository("Hibernate-Master-Class");session.persist(repository);
});

当一个实体持久化时，只有数据库包含该实体的副本。首次获取实体时，记录系统将传递到缓存层。

@Test
public void testRepositoryEntityLoad() {LOGGER.info("Read-only entities are read-through");doInTransaction(session -> {Repository repository = (Repository) session.get(Repository.class, 1L);assertNotNull(repository);});doInTransaction(session -> {LOGGER.info("Load Repository from cache");session.get(Repository.class, 1L);});
}

此测试生成输出：

--Read-only entities are read-throughSELECT readonlyca0_.id   AS id1_2_0_,readonlyca0_.NAME AS name2_2_0_
FROM   repository readonlyca0_
WHERE  readonlyca0_.id = 1 --JdbcTransaction - committed JDBC Connection--Load Repository from cache--JdbcTransaction - committed JDBC Connection

将实体加载到二级缓存后，缓存将为随后的所有调用提供服务，从而绕过数据库。

更新实体

只读缓存条目不允许更新。任何此类尝试最终都会引发异常：

@Test
public void testReadOnlyEntityUpdate() {try {LOGGER.info("Read-only cache entries cannot be updated");doInTransaction(session -> {Repository repository = (Repository) session.get(Repository.class, 1L);repository.setName("High-Performance Hibernate");});} catch (Exception e) {LOGGER.error("Expected", e);}
}

运行此测试将生成以下输出：

--Read-only cache entries cannot be updatedSELECT readonlyca0_.id   AS id1_2_0_,readonlyca0_.NAME AS name2_2_0_
FROM   repository readonlyca0_
WHERE  readonlyca0_.id = 1 UPDATE repository
SET    NAME = 'High-Performance Hibernate'
WHERE  id = 1 --JdbcTransaction - rolled JDBC Connection--ERROR Expected
--java.lang.UnsupportedOperationException: Can't write to a readonly object

因为只读缓存实体实际上是不可变的，所以最好将它们赋予 Hibernate特有的@Immutable批注。

删除实体

同时删除关联的实体时，也会删除只读缓存条目：

@Test
public void testReadOnlyEntityDelete() {LOGGER.info("Read-only cache entries can be deleted");doInTransaction(session -> {Repository repository = (Repository) session.get(Repository.class, 1L);assertNotNull(repository);session.delete(repository);});doInTransaction(session -> {Repository repository = (Repository) session.get(Repository.class, 1L);assertNull(repository);});
}

生成以下输出：

--Read-only cache entries can be deletedSELECT readonlyca0_.id   AS id1_2_0_,readonlyca0_.NAME AS name2_2_0_
FROM   repository readonlyca0_
WHERE  readonlyca0_.id = 1;DELETE FROM repository
WHERE  id = 1--JdbcTransaction - committed JDBC ConnectionSELECT readonlyca0_.id   AS id1_2_0_,readonlyca0_.NAME AS name2_2_0_
FROM   repository readonlyca0_
WHERE  readonlyca0_.id = 1; --JdbcTransaction - committed JDBC Connection

PersistenceContext使移除实体状态转换入队，并且在刷新时，数据库和二级缓存都将删除关联的实体记录。

集合缓存

提交实体具有变更组件的集合。

@ElementCollection
@CollectionTable(name="commit_change",joinColumns=@JoinColumn(name="commit_id")
)
private List<Change> changes = new ArrayList<>();

尽管Commit实体作为只读元素进行缓存，但第二级缓存将忽略Change集合。

@Test
public void testCollectionCache() {LOGGER.info("Collections require separate caching");doInTransaction(session -> {Repository repository = (Repository) session.get(Repository.class, 1L);Commit commit = new Commit(repository);commit.getChanges().add(new Change("README.txt", "0a1,5..."));commit.getChanges().add(new Change("web.xml", "17c17..."));session.persist(commit);});doInTransaction(session -> {LOGGER.info("Load Commit from database");Commit commit = (Commit) session.get(Commit.class, 1L);assertEquals(2, commit.getChanges().size());});doInTransaction(session -> {LOGGER.info("Load Commit from cache");Commit commit = (Commit) session.get(Commit.class, 1L);assertEquals(2, commit.getChanges().size());});
}

运行此测试将生成以下输出：

--Collections require separate cachingSELECT readonlyca0_.id   AS id1_2_0_,readonlyca0_.NAME AS name2_2_0_
FROM   repository readonlyca0_
WHERE  readonlyca0_.id = 1;INSERT INTO commit(id, repository_id)
VALUES      (DEFAULT, 1);INSERT INTO commit_change(commit_id, diff, path)
VALUES      (1, '0a1,5...', 'README.txt');       INSERT INTO commit_change(commit_id, diff, path)
VALUES      (1, '17c17...', 'web.xml');--JdbcTransaction - committed JDBC Connection--Load Commit from databaseSELECT readonlyca0_.id   AS id1_2_0_,readonlyca0_.NAME AS name2_2_0_
FROM   repository readonlyca0_
WHERE  readonlyca0_.id = 1;SELECT changes0_.commit_id AS commit_i1_0_0_,changes0_.diff      AS diff2_1_0_,changes0_.path      AS path3_1_0_
FROM   commit_change changes0_
WHERE  changes0_.commit_id = 1 --JdbcTransaction - committed JDBC Connection--Load Commit from cacheSELECT changes0_.commit_id AS commit_i1_0_0_,changes0_.diff      AS diff2_1_0_,changes0_.path      AS path3_1_0_
FROM   commit_change changes0_
WHERE  changes0_.commit_id = 1 --JdbcTransaction - committed JDBC Connection

尽管Commit实体是从缓存中检索的，但Change集合始终是从数据库中获取的。由于更改也是不可变的，因此我们也希望对其进行缓存，以节省不必要的数据库往返次数。

启用集合缓存支持

默认情况下，不缓存集合，并且要启用此行为，我们必须使用缓存并发策略为它们添加注释：

@ElementCollection
@CollectionTable(name="commit_change",joinColumns=@JoinColumn(name="commit_id")
)
@org.hibernate.annotations.Cache(usage = CacheConcurrencyStrategy.READ_ONLY
)
private List<Change> changes = new ArrayList<>();

重新运行先前的测试将产生以下输出：

--Collections require separate cachingSELECT readonlyca0_.id   AS id1_2_0_,readonlyca0_.NAME AS name2_2_0_
FROM   repository readonlyca0_
WHERE  readonlyca0_.id = 1;INSERT INTO commit(id, repository_id)
VALUES      (DEFAULT, 1);INSERT INTO commit_change(commit_id, diff, path)
VALUES      (1, '0a1,5...', 'README.txt');       INSERT INTO commit_change(commit_id, diff, path)
VALUES      (1, '17c17...', 'web.xml');--JdbcTransaction - committed JDBC Connection--Load Commit from databaseSELECT readonlyca0_.id   AS id1_2_0_,readonlyca0_.NAME AS name2_2_0_
FROM   repository readonlyca0_
WHERE  readonlyca0_.id = 1;SELECT changes0_.commit_id AS commit_i1_0_0_,changes0_.diff      AS diff2_1_0_,changes0_.path      AS path3_1_0_
FROM   commit_change changes0_
WHERE  changes0_.commit_id = 1 --JdbcTransaction - committed JDBC Connection--Load Commit from cache--JdbcTransaction - committed JDBC Connection

一旦集合被缓存，我们就可以获取Commit实体及其所有Change，而无需访问数据库。

结论

只读实体可以安全地进行缓存，我们可以仅使用第二级缓存来加载整个不可变实体图。由于高速缓存是直通的 ，因此从数据库中获取实体时将对其进行高速缓存。只读缓存不是直写的，因为持久存储实体只会在新的数据库行中实现，而不会传播到缓存中。

代码可在GitHub上获得。

翻译自: https://www.javacodegeeks.com/2015/04/how-does-hibernate-read_only-cacheconcurrencystrategy-work.html