Hibernate READ_ONLY CacheConcurrencyStrategy如何工作

最新推荐文章于 2020-12-20 20:43:10 发布
最新推荐文章于 2020-12-20 20:43:10 发布
阅读量199 收藏
点赞数
文章标签： 数据库 java python mysql hibernate

介绍

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

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

只读二级缓存

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

存储库提交更改只读缓存并发策略

存储库是根实体，是任何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-through

SELECT 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 updated

SELECT 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 deleted

SELECT 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 Connection

SELECT 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 caching

SELECT 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 database

SELECT 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

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

尽管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 caching

SELECT 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 database

SELECT 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，而无需访问数据库。

结论

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

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

dnc8371
关注
Hibernate @Cache注解
小小布的程序世界
01-18 7001
参考文章： http://www.jianshu.com/p/6f357c4cc0f7 （Hibernate @Cache 注解） @Cache 定义了二级缓存策略和缓存范围 一、属性 1：usage: 当前缓存策略(NONE, READ_ONLY, NONSTRICT_READ_WRITE, TRANSACTIONAL)。 （1）read-only: 只读缓存 如果你的应
hibernate4配置二级缓存
05-31
`region`属性用于定义缓存区域，`usage`属性则表示缓存的并发策略，可以选择READ_ONLY、READ_WRITE或NONSTRICT_READ_WRITE。 4. **配置Ehcache**：创建一个ehcache.xml配置文件，指定缓存的配置细节，如缓存大小、...
CacheConcurrencyStrategy的五种缓存方式的简单介绍
candy_sweet的专栏
10-10 157
CacheConcurrencyStrategy有五种缓存方式：   　　 CacheConcurrencyStrategy.NONE，不适用，默认 　　 CacheConcurrencyStrategy.READ_ONLY ，只读模式，在此模式下，如果对数据进行更新操作，会有异常； 　　 CacheConcurrencyStrategy.READ_WRITE ，读写模式在更新缓存的时候会...
Hibernate缓存(一)
JAVA
10-26 183
缓存可以简单的看成一个 Map ，通过 key 在缓存里面找 value 。   一、缓存简介   Cache In Hibernate HIBERNATE 中的 CACHE 有两级 . 一级是在 Session 范围内的 CACHE . 即每个 Session 有...
springmvc hibernate事务管理read-only属性
AirFish的博客
04-11 2565
在利用freemarker做网页静态化中遇到的一个小问题。程序的逻辑大致是，当用户提交网页静态化请求时，会从数据库读取新闻纪录，查看对应的html路径是否存在，如果存在就将html文件删除然后重新生成静态化文件，修改数据库对应的数据记录。但是在开发过程中发现，update语句无法提交，经过查阅资料发现是事务管理配置的read-only属性出了问题。 因为get与update属于同一个事务。但是该
hibernate_Hibernate READ_ONLY CacheConcurrencyStrategy如何工作
cunhu2961的博客
12-20 122
hibernate介绍 正如我前面所解释的，企业的高速缓存需要勤奋。 因为数据在数据库(记录系统)和缓存层之间重复，所以我们需要确保两个单独的数据源不会分开。 如果缓存的数据是不可变的(数据库和缓存都无法修改它)，我们可以安全地对其进行缓存，而不必担心任何一致性问题。 只读数据始终是应用程序级缓存的良好候选者，可以提高读取性能，而不必放松一致性保证。 只读二级缓存 为了测试只读二级缓存策略，我...
关于spring+hibernate的read-only mode
wgj85的专栏
08-27 7660
org.springframework.dao.InvalidDataAccessApiUsageException: Write operations are not allowed in read-only mode (FlushMode.NEVER/MANUAL): Turn your Session into FlushMode.COMMIT/AUTO or remove r
hibernate_cache_level_1
11-12
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE) public class User { // entity fields and methods } ``` 在项目中，我们还需要合理配置缓存策略，包括缓存更新策略（read-write、read-only、...
Hibernate_二级缓存总结
12-03
- **CacheConcurrencyStrategy.READ_ONLY**：只读模式，不允许更新，尝试更新时抛出异常。 - **CacheConcurrencyStrategy.READ_WRITE**：读写模式，更新时锁定数据，其他事务需回退至数据库获取最新数据。 - **...
hibernate二级缓存要导入的包
10-18
因此，需要根据业务需求和性能优化的权衡来选择合适的缓存策略（如READ_ONLY、NONSTRICT_READ_WRITE、READ_WRITE和TRANSACTIONAL），并合理设置缓存过期时间。 此外，还可以通过调整缓存配置，如缓存大小、并发级别...
CacheConcurrencyStrategy
爱生活，爱JAVA
11-12 232
最近在项目中用到hibernate注解方式进行entity的注解，用到缓存的配置方式，其中有几个写法，给自己做个记录。 @Entity　 @Cache(usage=CacheConcurrencyStrategy.READ_ONLY) 　　如果使用使用hibernate annoation是使用@Cache(usage=CacheConcurrencyStrategy.)标签，有5种可选...
@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE, region = "entityCache")
Developer of XingKong22star
05-29 3199
缓存可以简单的看成一个 Map ，通过 key 在缓存里面找 value 。   一、缓存简介   Cache In Hibernate HIBERNATE 中的 CACHE 有两级 . 一级是在 Session 范围内的 CACHE . 即每个 Session 有自己的一个 CACHE, 当前操作的对象都会被保留在 CACHE 中 . 但是 Session 关闭后这个 CACHE 也
spring+hibernate中Connection is read-only问题的产生原因与解决方法
zyy_jay的专栏
05-31 356
报错：org.hibernate.exception.GenericJDBCException: Connection is read-only. Queries leading to data modification are not allowed 原因： spring-config.xml文件 [code="xml"] ...
hibernate二级只读缓存设置 --oracle 是对sessionFactory而言的
qq_19816777的博客
03-13 378
配置二级缓存的文件   hibernate.cfg.xml                                           "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">       oracle.jdbc.driver.OracleDriver   12345
关于hibernate中插入数据报read-only mode只读模式错误
cjlcc的博客
10-31 2548
项目中有时候会遇到插入数据到表中去报错只读模式 org.springframework.dao.InvalidDataAccessApiUsageException: Write operations are not allowed in read-only mode (FlushMode.MANUAL): Turn your Session into FlushMode.COMMIT/AUTO...
将inpupt属性设置为readOnly hibernate抛出异常
snow1wolf的专栏
10-14 475
org.springframework.dao.InvalidDataAccessApiUsageException: Write operations are not allowed in read-only mode (FlushMode.NEVER/MANUAL): Turn your Session into FlushMode.COMMIT/AUTO or remove 'readOnl
hibernate缓存并发策略CacheConcurrencyStrategy
u010334303的博客
02-10 183
首先你可能使用@Cache对缓存处理，该注解有三个属性 [code="java"]@Target({TYPE, METHOD, FIELD}) @Retention(RUNTIME) public @interface Cache { /** concurrency strategy chosen */ CacheConcurrencyStrategy usage(); /** ...
spring配置hibernate抛出read only 异常
代码艺术
02-01 814
org.springframework.dao.InvalidDataAccessApiUsageException: Write operations are not allowed in read-only mode (FlushMode.NEVER) - turn your Session into FlushMode.AUTO or remove 'readOnly' marker f
hibernate4session操作时报read_only的错误
chongbiejue8296的博客
06-08 241
在使用hibernate4的时候我直接使用getHibernateTemplate().save();就会报如下错误Write operations are not allowed in read-only mode (FlushMode.MANUAL): Turn your Session ...
hibernate FIND_IN_SET
最新发布
09-03
Hibernate的FIND_IN_SET是一个HQL（Hibernate Query Language）函数，它用于查询一个字段值是否包含在给定的集合（set）内。当你需要在一个SQL查询中检查某个字段的值是否存在于一组预定义的值列表中时，可以使用这个函数。它的基本语法如下： ```sql SELECT * FROM table_name WHERE column_name IN (FIND_IN_SET(value, 'comma-separated-value-list')) ``` 在这个例子中，`table_name`是你想要查询的数据表名，`column_name`是你关心的列，而`value`是你想查找的具体值，`'comma-separated-value-list'`则是逗号分隔的一组可能存在的值。 例如，如果你有一个用户角色表，其中有个角色id字段，你可以查询哪些用户拥有特定的角色，比如管理员角色： ```java List<User> users = session.createQuery( "FROM User u WHERE u.roles IN (:roleIds)") .setParameterList("roleIds", Arrays.asList(1, 2)) // 管理员角色ID列表 .list(); ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值