hibernate 二级缓存 中将映射文件设置为 read-only,为何还能进行增删改?

hibernate 二级缓存 中将映射文件设置为 read-only,为何还能进行增删改?
例如某User对象;









为何还可以进行User进行增删改呢?不是只读吗?谢谢
[b]问题补充:[/b]
hibernate 二级缓存 中将映射文件设置为 read-only,为何还能进行增删改?
例如某User对象;









为何还可以进行User进行增删改呢?不是只读吗?谢谢

测试代码如下:
[code="java"]
public void testCache1(){
Session s = HibernateUtils.getSession() ;
Query q = s.createQuery("from User") ;
q.setCacheable(true) ;
for(Iterator iter=q.list().iterator(); iter.hasNext();){
User u = (User)iter.next() ;
System.out.println("user.getName ="+u.getUserName()) ;
}
s.close() ;

    System.out.println("----------------------------") ;

    s = HibernateUtils.getSession() ;

    s.beginTransaction() ;
    User user = new User() ;
    user.setUserName("yu") ;
    user.setPwd("123") ;
    Serializable id = s.save(user) ;
    s.beginTransaction().commit() ;
    s.close() ;

    System.out.println("----------------------------") ;

     s = HibernateUtils.getSession() ;
     q = s.createQuery("from User") ;
     q.setCacheable(true) ;
    for(Iterator iter=q.iterate(); iter.hasNext();){
        User u = (User)iter.next() ;
        System.out.println("user.getName ="+u.getUserName()) ;
    }
    s.close() ;
}

[/code]
输出结果:
Hibernate: select user0_.id as id0_, user0_.userName as userName0_, user0_.pwd as pwd0_, user0_.createTime as createTime0_ from User user0_

user.getName =yushan

Hibernate: insert into User (userName, pwd, createTime, id) values (?, ?, ?, ?)

Hibernate: select user0_.id as col_0_0_ from User user0_
user.getName =yushan
user.getName =yu
以上代码前提是已经开启查询缓存和二级缓存,User设置为read-only,第一次取出一条,然后增加条,为何第二次取的时候会有两条呢,而且还是从缓存中取得的?按理来说经过第一次取后二级缓存中只有一条记录,当save的时候也会往二级缓存中增加一条记录,但是第二次取的时候,因为二级缓存生存周期还未失效,且还是read-only,那么二级中应该只有一条啊?为何呢,请详解谢谢!
[b]问题补充:[/b]
hibernate 二级缓存 中将映射文件设置为 read-only,为何还能进行增删改?
例如某User对象;









为何还可以进行User进行增删改呢?不是只读吗?谢谢
[b]问题补充:[/b]
hibernate 二级缓存 中将映射文件设置为 read-only,为何还能进行增删改?
例如某User对象;









为何还可以进行User进行增删改呢?不是只读吗?谢谢

测试代码如下:
[code="java"]
public void testCache1(){
Session s = HibernateUtils.getSession() ;
Query q = s.createQuery("from User") ;
//q.setCacheable(true) ;
for(Iterator iter=q.iterate(); iter.hasNext();){
User u = (User)iter.next() ;
System.out.println("user.getName ="+u.getUserName()) ;
}
s.close() ;

    System.out.println("----------------------------") ;

    s = HibernateUtils.getSession() ;

    s.beginTransaction() ;
    User user = new User() ;
    user.setUserName("yu") ;
    user.setPwd("123") ;
    Serializable id = s.save(user) ;
    s.beginTransaction().commit() ;
    s.close() ;

    System.out.println("----------------------------") ;

     s = HibernateUtils.getSession() ;
     q = s.createQuery("from User") ;
    // q.setCacheable(true) ;
    for(Iterator iter=q.iterate(); iter.hasNext();){
        User u = (User)iter.next() ;
        System.out.println("user.getName ="+u.getUserName()) ;
    }
    s.close() ;
}

[/code]
输出结果:
Hibernate: select user0_.id as id0_, user0_.userName as userName0_, user0_.pwd as pwd0_, user0_.createTime as createTime0_ from User user0_

user.getName =yushan

Hibernate: insert into User (userName, pwd, createTime, id) values (?, ?, ?, ?)

Hibernate: select user0_.id as col_0_0_ from User user0_
user.getName =yushan
user.getName =yu
以上代码前提是已经开启查询缓存和二级缓存,User设置为read-only,第一次取出一条,然后增加条,为何第二次取的时候会有两条呢,而且还是从缓存中取得的?按理来说经过第一次取后二级缓存中只有一条记录,当save的时候也会往二级缓存中增加一条记录,但是第二次取的时候,因为二级缓存生存周期还未失效,且还是read-only,那么二级中应该只有一条啊?为何呢,请详解谢谢!
[b]问题补充:[/b]
hibernate 二级缓存 中将映射文件设置为 read-only,为何还能进行增删改?
例如某User对象;









为何还可以进行User进行增删改呢?不是只读吗?谢谢
[b]问题补充:[/b]
hibernate 二级缓存 中将映射文件设置为 read-only,为何还能进行增删改?
例如某User对象;









为何还可以进行User进行增删改呢?不是只读吗?谢谢

测试代码如下:
[code="java"]
public void testCache1(){
Session s = HibernateUtils.getSession() ;
Query q = s.createQuery("from User") ;
q.setCacheable(true) ;
for(Iterator iter=q.list().iterator(); iter.hasNext();){
User u = (User)iter.next() ;
System.out.println("user.getName ="+u.getUserName()) ;
}
s.close() ;

    System.out.println("----------------------------") ;

    s = HibernateUtils.getSession() ;

    s.beginTransaction() ;
    User user = new User() ;
    user.setUserName("yu") ;
    user.setPwd("123") ;
    Serializable id = s.save(user) ;
    s.beginTransaction().commit() ;
    s.close() ;

    System.out.println("----------------------------") ;

     s = HibernateUtils.getSession() ;
     q = s.createQuery("from User") ;
     q.setCacheable(true) ;
    for(Iterator iter=q.iterate(); iter.hasNext();){
        User u = (User)iter.next() ;
        System.out.println("user.getName ="+u.getUserName()) ;
    }
    s.close() ;
}

[/code]
输出结果:
Hibernate: select user0_.id as id0_, user0_.userName as userName0_, user0_.pwd as pwd0_, user0_.createTime as createTime0_ from User user0_

user.getName =yushan

Hibernate: insert into User (userName, pwd, createTime, id) values (?, ?, ?, ?)

Hibernate: select user0_.id as col_0_0_ from User user0_
user.getName =yushan
user.getName =yu
以上代码前提是已经开启查询缓存和二级缓存,User设置为read-only,第一次取出一条,然后增加条,为何第二次取的时候会有两条呢,而且还是从缓存中取得的?按理来说经过第一次取后二级缓存中只有一条记录,当save的时候也会往二级缓存中增加一条记录,但是第二次取的时候,因为二级缓存生存周期还未失效,且还是read-only,那么二级中应该只有一条啊?为何呢,请详解谢谢!
[b]问题补充:[/b]
hibernate 二级缓存 中将映射文件设置为 read-only,为何还能进行增删改?
例如某User对象;









为何还可以进行User进行增删改呢?不是只读吗?谢谢
[b]问题补充:[/b]
hibernate 二级缓存 中将映射文件设置为 read-only,为何还能进行增删改?
例如某User对象;









为何还可以进行User进行增删改呢?不是只读吗?谢谢

测试代码如下:
[code="java"]
public void testCache1(){
Session s = HibernateUtils.getSession() ;
Query q = s.createQuery("from User") ;
//q.setCacheable(true) ;
for(Iterator iter=q.iterate(); iter.hasNext();){
User u = (User)iter.next() ;
System.out.println("user.getName ="+u.getUserName()) ;
}
s.close() ;

    System.out.println("----------------------------") ;

    s = HibernateUtils.getSession() ;

    s.beginTransaction() ;
    User user = new User() ;
    user.setUserName("yu") ;
    user.setPwd("123") ;
    Serializable id = s.save(user) ;
    s.beginTransaction().commit() ;
    s.close() ;

    System.out.println("----------------------------") ;

     s = HibernateUtils.getSession() ;
     q = s.createQuery("from User") ;
    // q.setCacheable(true) ;
    for(Iterator iter=q.iterate(); iter.hasNext();){
        User u = (User)iter.next() ;
        System.out.println("user.getName ="+u.getUserName()) ;
    }
    s.close() ;
}

[/code]
输出结果:
Hibernate: select user0_.id as id0_, user0_.userName as userName0_, user0_.pwd as pwd0_, user0_.createTime as createTime0_ from User user0_

user.getName =yushan

Hibernate: insert into User (userName, pwd, createTime, id) values (?, ?, ?, ?)

Hibernate: select user0_.id as col_0_0_ from User user0_
user.getName =yushan
user.getName =yu
以上代码前提是已经开启查询缓存和二级缓存,User设置为read-only,第一次取出一条,然后增加条,为何第二次取的时候会有两条呢,而且还是从缓存中取得的?按理来说经过第一次取后二级缓存中只有一条记录,当save的时候也会往二级缓存中增加一条记录,但是第二次取的时候,因为二级缓存生存周期还未失效,且还是read-only,那么二级中应该只有一条啊?为何呢,请详解谢谢!

[color=red]按 jones 的意思是不是 read-only 形式下,不能对二级缓存中的对象做任何修改,但可以修改该对象在数据库中的状态 是吗?那么我还有个,在前面的基础上,即在第一次查询 和第二次查询的之间放入一段修改缓存中某对象的时咋出现题呢,代码如下[/color]

[code="java"]s = HibernateUtils.getSession() ;
//s.setCacheMode(CacheMode.GET) ;
User u = new User() ;
u.setId("8aa3b33c1d8eb43b011d8eb441300001") ;
u.setName("yushan5118") ;
s.saveOrUpdate(u) ;
s.beginTransaction().commit() ;
s.close() ;[/code]
[color=red]出现一个异常:
ERROR ReadOnlyCache:42 - Application attempted to edit read only item: com.c35.hibernate.po.User#8aa3b33c1d8eb43b011d8eb441300001
且数据库中的该对象属性未变化? 按理不是说不能修改缓存里面的,但可以操纵数据库吗?谢谢[/color]
[b]问题补充:[/b]
hibernate 二级缓存 中将映射文件设置为 read-only,为何还能进行增删改?
例如某User对象;









为何还可以进行User进行增删改呢?不是只读吗?谢谢
[b]问题补充:[/b]
hibernate 二级缓存 中将映射文件设置为 read-only,为何还能进行增删改?
例如某User对象;









为何还可以进行User进行增删改呢?不是只读吗?谢谢

测试代码如下:
[code="java"]
public void testCache1(){
Session s = HibernateUtils.getSession() ;
Query q = s.createQuery("from User") ;
q.setCacheable(true) ;
for(Iterator iter=q.list().iterator(); iter.hasNext();){
User u = (User)iter.next() ;
System.out.println("user.getName ="+u.getUserName()) ;
}
s.close() ;

    System.out.println("----------------------------") ;

    s = HibernateUtils.getSession() ;

    s.beginTransaction() ;
    User user = new User() ;
    user.setUserName("yu") ;
    user.setPwd("123") ;
    Serializable id = s.save(user) ;
    s.beginTransaction().commit() ;
    s.close() ;

    System.out.println("----------------------------") ;

     s = HibernateUtils.getSession() ;
     q = s.createQuery("from User") ;
     q.setCacheable(true) ;
    for(Iterator iter=q.iterate(); iter.hasNext();){
        User u = (User)iter.next() ;
        System.out.println("user.getName ="+u.getUserName()) ;
    }
    s.close() ;
}

[/code]
输出结果:
Hibernate: select user0_.id as id0_, user0_.userName as userName0_, user0_.pwd as pwd0_, user0_.createTime as createTime0_ from User user0_

user.getName =yushan

Hibernate: insert into User (userName, pwd, createTime, id) values (?, ?, ?, ?)

Hibernate: select user0_.id as col_0_0_ from User user0_
user.getName =yushan
user.getName =yu
以上代码前提是已经开启查询缓存和二级缓存,User设置为read-only,第一次取出一条,然后增加条,为何第二次取的时候会有两条呢,而且还是从缓存中取得的?按理来说经过第一次取后二级缓存中只有一条记录,当save的时候也会往二级缓存中增加一条记录,但是第二次取的时候,因为二级缓存生存周期还未失效,且还是read-only,那么二级中应该只有一条啊?为何呢,请详解谢谢!
[b]问题补充:[/b]
hibernate 二级缓存 中将映射文件设置为 read-only,为何还能进行增删改?
例如某User对象;









为何还可以进行User进行增删改呢?不是只读吗?谢谢
[b]问题补充:[/b]
hibernate 二级缓存 中将映射文件设置为 read-only,为何还能进行增删改?
例如某User对象;









为何还可以进行User进行增删改呢?不是只读吗?谢谢

测试代码如下:
[code="java"]
public void testCache1(){
Session s = HibernateUtils.getSession() ;
Query q = s.createQuery("from User") ;
//q.setCacheable(true) ;
for(Iterator iter=q.iterate(); iter.hasNext();){
User u = (User)iter.next() ;
System.out.println("user.getName ="+u.getUserName()) ;
}
s.close() ;

    System.out.println("----------------------------") ;

    s = HibernateUtils.getSession() ;

    s.beginTransaction() ;
    User user = new User() ;
    user.setUserName("yu") ;
    user.setPwd("123") ;
    Serializable id = s.save(user) ;
    s.beginTransaction().commit() ;
    s.close() ;

    System.out.println("----------------------------") ;

     s = HibernateUtils.getSession() ;
     q = s.createQuery("from User") ;
    // q.setCacheable(true) ;
    for(Iterator iter=q.iterate(); iter.hasNext();){
        User u = (User)iter.next() ;
        System.out.println("user.getName ="+u.getUserName()) ;
    }
    s.close() ;
}

[/code]
输出结果:
Hibernate: select user0_.id as id0_, user0_.userName as userName0_, user0_.pwd as pwd0_, user0_.createTime as createTime0_ from User user0_

user.getName =yushan

Hibernate: insert into User (userName, pwd, createTime, id) values (?, ?, ?, ?)

Hibernate: select user0_.id as col_0_0_ from User user0_
user.getName =yushan
user.getName =yu
以上代码前提是已经开启查询缓存和二级缓存,User设置为read-only,第一次取出一条,然后增加条,为何第二次取的时候会有两条呢,而且还是从缓存中取得的?按理来说经过第一次取后二级缓存中只有一条记录,当save的时候也会往二级缓存中增加一条记录,但是第二次取的时候,因为二级缓存生存周期还未失效,且还是read-only,那么二级中应该只有一条啊?为何呢,请详解谢谢!
[b]问题补充:[/b]
hibernate 二级缓存 中将映射文件设置为 read-only,为何还能进行增删改?
例如某User对象;









为何还可以进行User进行增删改呢?不是只读吗?谢谢
[b]问题补充:[/b]
hibernate 二级缓存 中将映射文件设置为 read-only,为何还能进行增删改?
例如某User对象;









为何还可以进行User进行增删改呢?不是只读吗?谢谢

测试代码如下:
[code="java"]
public void testCache1(){
Session s = HibernateUtils.getSession() ;
Query q = s.createQuery("from User") ;
q.setCacheable(true) ;
for(Iterator iter=q.list().iterator(); iter.hasNext();){
User u = (User)iter.next() ;
System.out.println("user.getName ="+u.getUserName()) ;
}
s.close() ;

    System.out.println("----------------------------") ;

    s = HibernateUtils.getSession() ;

    s.beginTransaction() ;
    User user = new User() ;
    user.setUserName("yu") ;
    user.setPwd("123") ;
    Serializable id = s.save(user) ;
    s.beginTransaction().commit() ;
    s.close() ;

    System.out.println("----------------------------") ;

     s = HibernateUtils.getSession() ;
     q = s.createQuery("from User") ;
     q.setCacheable(true) ;
    for(Iterator iter=q.iterate(); iter.hasNext();){
        User u = (User)iter.next() ;
        System.out.println("user.getName ="+u.getUserName()) ;
    }
    s.close() ;
}

[/code]
输出结果:
Hibernate: select user0_.id as id0_, user0_.userName as userName0_, user0_.pwd as pwd0_, user0_.createTime as createTime0_ from User user0_

user.getName =yushan

Hibernate: insert into User (userName, pwd, createTime, id) values (?, ?, ?, ?)

Hibernate: select user0_.id as col_0_0_ from User user0_
user.getName =yushan
user.getName =yu
以上代码前提是已经开启查询缓存和二级缓存,User设置为read-only,第一次取出一条,然后增加条,为何第二次取的时候会有两条呢,而且还是从缓存中取得的?按理来说经过第一次取后二级缓存中只有一条记录,当save的时候也会往二级缓存中增加一条记录,但是第二次取的时候,因为二级缓存生存周期还未失效,且还是read-only,那么二级中应该只有一条啊?为何呢,请详解谢谢!
[b]问题补充:[/b]
hibernate 二级缓存 中将映射文件设置为 read-only,为何还能进行增删改?
例如某User对象;









为何还可以进行User进行增删改呢?不是只读吗?谢谢
[b]问题补充:[/b]
hibernate 二级缓存 中将映射文件设置为 read-only,为何还能进行增删改?
例如某User对象;









为何还可以进行User进行增删改呢?不是只读吗?谢谢

测试代码如下:
[code="java"]
public void testCache1(){
Session s = HibernateUtils.getSession() ;
Query q = s.createQuery("from User") ;
//q.setCacheable(true) ;
for(Iterator iter=q.iterate(); iter.hasNext();){
User u = (User)iter.next() ;
System.out.println("user.getName ="+u.getUserName()) ;
}
s.close() ;

    System.out.println("----------------------------") ;

    s = HibernateUtils.getSession() ;

    s.beginTransaction() ;
    User user = new User() ;
    user.setUserName("yu") ;
    user.setPwd("123") ;
    Serializable id = s.save(user) ;
    s.beginTransaction().commit() ;
    s.close() ;

    System.out.println("----------------------------") ;

     s = HibernateUtils.getSession() ;
     q = s.createQuery("from User") ;
    // q.setCacheable(true) ;
    for(Iterator iter=q.iterate(); iter.hasNext();){
        User u = (User)iter.next() ;
        System.out.println("user.getName ="+u.getUserName()) ;
    }
    s.close() ;
}

[/code]
输出结果:
Hibernate: select user0_.id as id0_, user0_.userName as userName0_, user0_.pwd as pwd0_, user0_.createTime as createTime0_ from User user0_

user.getName =yushan

Hibernate: insert into User (userName, pwd, createTime, id) values (?, ?, ?, ?)

Hibernate: select user0_.id as col_0_0_ from User user0_
user.getName =yushan
user.getName =yu
以上代码前提是已经开启查询缓存和二级缓存,User设置为read-only,第一次取出一条,然后增加条,为何第二次取的时候会有两条呢,而且还是从缓存中取得的?按理来说经过第一次取后二级缓存中只有一条记录,当save的时候也会往二级缓存中增加一条记录,但是第二次取的时候,因为二级缓存生存周期还未失效,且还是read-only,那么二级中应该只有一条啊?为何呢,请详解谢谢!

[color=red]按 jones 的意思是不是 read-only 形式下,不能对二级缓存中的对象做任何修改,但可以修改该对象在数据库中的状态 是吗?那么我还有个,在前面的基础上,即在第一次查询 和第二次查询的之间放入一段修改缓存中某对象的时咋出现题呢,代码如下[/color]

[code="java"]s = HibernateUtils.getSession() ;
//s.setCacheMode(CacheMode.GET) ;
User u = new User() ;
u.setId("8aa3b33c1d8eb43b011d8eb441300001") ;
u.setName("yushan5118") ;
s.saveOrUpdate(u) ;
s.beginTransaction().commit() ;
s.close() ;[/code]
[color=red]出现一个异常:
ERROR ReadOnlyCache:42 - Application attempted to edit read only item: com.c35.hibernate.po.User#8aa3b33c1d8eb43b011d8eb441300001
且数据库中的该对象属性未变化? 按理不是说不能修改缓存里面的,但可以操纵数据库吗?谢谢[/color]

read-only只是Hibernate用来决定如何处理缓存数据的,如果你的缓存对象是read-only的,Hibernate可不负责你的缓存与数据库之间的同步处理,因为Hibernate认为你这个对象根本就永远都不会改变。
[color=red]那么 Hibernate 只对缓存里面的对象read-only,当我修改某个对象的时候,hibernate难道还会判断我修改的对象是否是缓存中已经有的,如果有就不接受修改 是吗?要是这样,想修改该对象在数据库中的内容 该咋办,又不影响read-only?能否帮忙解释一下为何会出现ERROR ReadOnlyCache:42错误?[/color] 在此感谢jones

[b]问题补充:[/b]
hibernate 二级缓存 中将映射文件设置为 read-only,为何还能进行增删改?
例如某User对象;









为何还可以进行User进行增删改呢?不是只读吗?谢谢
[b]问题补充:[/b]
hibernate 二级缓存 中将映射文件设置为 read-only,为何还能进行增删改?
例如某User对象;









为何还可以进行User进行增删改呢?不是只读吗?谢谢

测试代码如下:
[code="java"]
public void testCache1(){
Session s = HibernateUtils.getSession() ;
Query q = s.createQuery("from User") ;
q.setCacheable(true) ;
for(Iterator iter=q.list().iterator(); iter.hasNext();){
User u = (User)iter.next() ;
System.out.println("user.getName ="+u.getUserName()) ;
}
s.close() ;

    System.out.println("----------------------------") ;

    s = HibernateUtils.getSession() ;

    s.beginTransaction() ;
    User user = new User() ;
    user.setUserName("yu") ;
    user.setPwd("123") ;
    Serializable id = s.save(user) ;
    s.beginTransaction().commit() ;
    s.close() ;

    System.out.println("----------------------------") ;

     s = HibernateUtils.getSession() ;
     q = s.createQuery("from User") ;
     q.setCacheable(true) ;
    for(Iterator iter=q.iterate(); iter.hasNext();){
        User u = (User)iter.next() ;
        System.out.println("user.getName ="+u.getUserName()) ;
    }
    s.close() ;
}

[/code]
输出结果:
Hibernate: select user0_.id as id0_, user0_.userName as userName0_, user0_.pwd as pwd0_, user0_.createTime as createTime0_ from User user0_

user.getName =yushan

Hibernate: insert into User (userName, pwd, createTime, id) values (?, ?, ?, ?)

Hibernate: select user0_.id as col_0_0_ from User user0_
user.getName =yushan
user.getName =yu
以上代码前提是已经开启查询缓存和二级缓存,User设置为read-only,第一次取出一条,然后增加条,为何第二次取的时候会有两条呢,而且还是从缓存中取得的?按理来说经过第一次取后二级缓存中只有一条记录,当save的时候也会往二级缓存中增加一条记录,但是第二次取的时候,因为二级缓存生存周期还未失效,且还是read-only,那么二级中应该只有一条啊?为何呢,请详解谢谢!
[b]问题补充:[/b]
hibernate 二级缓存 中将映射文件设置为 read-only,为何还能进行增删改?
例如某User对象;









为何还可以进行User进行增删改呢?不是只读吗?谢谢
[b]问题补充:[/b]
hibernate 二级缓存 中将映射文件设置为 read-only,为何还能进行增删改?
例如某User对象;









为何还可以进行User进行增删改呢?不是只读吗?谢谢

测试代码如下:
[code="java"]
public void testCache1(){
Session s = HibernateUtils.getSession() ;
Query q = s.createQuery("from User") ;
//q.setCacheable(true) ;
for(Iterator iter=q.iterate(); iter.hasNext();){
User u = (User)iter.next() ;
System.out.println("user.getName ="+u.getUserName()) ;
}
s.close() ;

    System.out.println("----------------------------") ;

    s = HibernateUtils.getSession() ;

    s.beginTransaction() ;
    User user = new User() ;
    user.setUserName("yu") ;
    user.setPwd("123") ;
    Serializable id = s.save(user) ;
    s.beginTransaction().commit() ;
    s.close() ;

    System.out.println("----------------------------") ;

     s = HibernateUtils.getSession() ;
     q = s.createQuery("from User") ;
    // q.setCacheable(true) ;
    for(Iterator iter=q.iterate(); iter.hasNext();){
        User u = (User)iter.next() ;
        System.out.println("user.getName ="+u.getUserName()) ;
    }
    s.close() ;
}

[/code]
输出结果:
Hibernate: select user0_.id as id0_, user0_.userName as userName0_, user0_.pwd as pwd0_, user0_.createTime as createTime0_ from User user0_

user.getName =yushan

Hibernate: insert into User (userName, pwd, createTime, id) values (?, ?, ?, ?)

Hibernate: select user0_.id as col_0_0_ from User user0_
user.getName =yushan
user.getName =yu
以上代码前提是已经开启查询缓存和二级缓存,User设置为read-only,第一次取出一条,然后增加条,为何第二次取的时候会有两条呢,而且还是从缓存中取得的?按理来说经过第一次取后二级缓存中只有一条记录,当save的时候也会往二级缓存中增加一条记录,但是第二次取的时候,因为二级缓存生存周期还未失效,且还是read-only,那么二级中应该只有一条啊?为何呢,请详解谢谢!
[b]问题补充:[/b]
hibernate 二级缓存 中将映射文件设置为 read-only,为何还能进行增删改?
例如某User对象;









为何还可以进行User进行增删改呢?不是只读吗?谢谢
[b]问题补充:[/b]
hibernate 二级缓存 中将映射文件设置为 read-only,为何还能进行增删改?
例如某User对象;









为何还可以进行User进行增删改呢?不是只读吗?谢谢

测试代码如下:
[code="java"]
public void testCache1(){
Session s = HibernateUtils.getSession() ;
Query q = s.createQuery("from User") ;
q.setCacheable(true) ;
for(Iterator iter=q.list().iterator(); iter.hasNext();){
User u = (User)iter.next() ;
System.out.println("user.getName ="+u.getUserName()) ;
}
s.close() ;

    System.out.println("----------------------------") ;

    s = HibernateUtils.getSession() ;

    s.beginTransaction() ;
    User user = new User() ;
    user.setUserName("yu") ;
    user.setPwd("123") ;
    Serializable id = s.save(user) ;
    s.beginTransaction().commit() ;
    s.close() ;

    System.out.println("----------------------------") ;

     s = HibernateUtils.getSession() ;
     q = s.createQuery("from User") ;
     q.setCacheable(true) ;
    for(Iterator iter=q.iterate(); iter.hasNext();){
        User u = (User)iter.next() ;
        System.out.println("user.getName ="+u.getUserName()) ;
    }
    s.close() ;
}

[/code]
输出结果:
Hibernate: select user0_.id as id0_, user0_.userName as userName0_, user0_.pwd as pwd0_, user0_.createTime as createTime0_ from User user0_

user.getName =yushan

Hibernate: insert into User (userName, pwd, createTime, id) values (?, ?, ?, ?)

Hibernate: select user0_.id as col_0_0_ from User user0_
user.getName =yushan
user.getName =yu
以上代码前提是已经开启查询缓存和二级缓存,User设置为read-only,第一次取出一条,然后增加条,为何第二次取的时候会有两条呢,而且还是从缓存中取得的?按理来说经过第一次取后二级缓存中只有一条记录,当save的时候也会往二级缓存中增加一条记录,但是第二次取的时候,因为二级缓存生存周期还未失效,且还是read-only,那么二级中应该只有一条啊?为何呢,请详解谢谢!
[b]问题补充:[/b]
hibernate 二级缓存 中将映射文件设置为 read-only,为何还能进行增删改?
例如某User对象;









为何还可以进行User进行增删改呢?不是只读吗?谢谢
[b]问题补充:[/b]
hibernate 二级缓存 中将映射文件设置为 read-only,为何还能进行增删改?
例如某User对象;









为何还可以进行User进行增删改呢?不是只读吗?谢谢

测试代码如下:
[code="java"]
public void testCache1(){
Session s = HibernateUtils.getSession() ;
Query q = s.createQuery("from User") ;
//q.setCacheable(true) ;
for(Iterator iter=q.iterate(); iter.hasNext();){
User u = (User)iter.next() ;
System.out.println("user.getName ="+u.getUserName()) ;
}
s.close() ;

    System.out.println("----------------------------") ;

    s = HibernateUtils.getSession() ;

    s.beginTransaction() ;
    User user = new User() ;
    user.setUserName("yu") ;
    user.setPwd("123") ;
    Serializable id = s.save(user) ;
    s.beginTransaction().commit() ;
    s.close() ;

    System.out.println("----------------------------") ;

     s = HibernateUtils.getSession() ;
     q = s.createQuery("from User") ;
    // q.setCacheable(true) ;
    for(Iterator iter=q.iterate(); iter.hasNext();){
        User u = (User)iter.next() ;
        System.out.println("user.getName ="+u.getUserName()) ;
    }
    s.close() ;
}

[/code]
输出结果:
Hibernate: select user0_.id as id0_, user0_.userName as userName0_, user0_.pwd as pwd0_, user0_.createTime as createTime0_ from User user0_

user.getName =yushan

Hibernate: insert into User (userName, pwd, createTime, id) values (?, ?, ?, ?)

Hibernate: select user0_.id as col_0_0_ from User user0_
user.getName =yushan
user.getName =yu
以上代码前提是已经开启查询缓存和二级缓存,User设置为read-only,第一次取出一条,然后增加条,为何第二次取的时候会有两条呢,而且还是从缓存中取得的?按理来说经过第一次取后二级缓存中只有一条记录,当save的时候也会往二级缓存中增加一条记录,但是第二次取的时候,因为二级缓存生存周期还未失效,且还是read-only,那么二级中应该只有一条啊?为何呢,请详解谢谢!

[color=red]按 jones 的意思是不是 read-only 形式下,不能对二级缓存中的对象做任何修改,但可以修改该对象在数据库中的状态 是吗?那么我还有个,在前面的基础上,即在第一次查询 和第二次查询的之间放入一段修改缓存中某对象的时咋出现题呢,代码如下[/color]

[code="java"]s = HibernateUtils.getSession() ;
//s.setCacheMode(CacheMode.GET) ;
User u = new User() ;
u.setId("8aa3b33c1d8eb43b011d8eb441300001") ;
u.setName("yushan5118") ;
s.saveOrUpdate(u) ;
s.beginTransaction().commit() ;
s.close() ;[/code]
[color=red]出现一个异常:
ERROR ReadOnlyCache:42 - Application attempted to edit read only item: com.c35.hibernate.po.User#8aa3b33c1d8eb43b011d8eb441300001
且数据库中的该对象属性未变化? 按理不是说不能修改缓存里面的,但可以操纵数据库吗?谢谢[/color]
[b]问题补充:[/b]
hibernate 二级缓存 中将映射文件设置为 read-only,为何还能进行增删改?
例如某User对象;









为何还可以进行User进行增删改呢?不是只读吗?谢谢
[b]问题补充:[/b]
hibernate 二级缓存 中将映射文件设置为 read-only,为何还能进行增删改?
例如某User对象;









为何还可以进行User进行增删改呢?不是只读吗?谢谢

测试代码如下:
[code="java"]
public void testCache1(){
Session s = HibernateUtils.getSession() ;
Query q = s.createQuery("from User") ;
q.setCacheable(true) ;
for(Iterator iter=q.list().iterator(); iter.hasNext();){
User u = (User)iter.next() ;
System.out.println("user.getName ="+u.getUserName()) ;
}
s.close() ;

    System.out.println("----------------------------") ;

    s = HibernateUtils.getSession() ;

    s.beginTransaction() ;
    User user = new User() ;
    user.setUserName("yu") ;
    user.setPwd("123") ;
    Serializable id = s.save(user) ;
    s.beginTransaction().commit() ;
    s.close() ;

    System.out.println("----------------------------") ;

     s = HibernateUtils.getSession() ;
     q = s.createQuery("from User") ;
     q.setCacheable(true) ;
    for(Iterator iter=q.iterate(); iter.hasNext();){
        User u = (User)iter.next() ;
        System.out.println("user.getName ="+u.getUserName()) ;
    }
    s.close() ;
}

[/code]
输出结果:
Hibernate: select user0_.id as id0_, user0_.userName as userName0_, user0_.pwd as pwd0_, user0_.createTime as createTime0_ from User user0_

user.getName =yushan

Hibernate: insert into User (userName, pwd, createTime, id) values (?, ?, ?, ?)

Hibernate: select user0_.id as col_0_0_ from User user0_
user.getName =yushan
user.getName =yu
以上代码前提是已经开启查询缓存和二级缓存,User设置为read-only,第一次取出一条,然后增加条,为何第二次取的时候会有两条呢,而且还是从缓存中取得的?按理来说经过第一次取后二级缓存中只有一条记录,当save的时候也会往二级缓存中增加一条记录,但是第二次取的时候,因为二级缓存生存周期还未失效,且还是read-only,那么二级中应该只有一条啊?为何呢,请详解谢谢!
[b]问题补充:[/b]
hibernate 二级缓存 中将映射文件设置为 read-only,为何还能进行增删改?
例如某User对象;









为何还可以进行User进行增删改呢?不是只读吗?谢谢
[b]问题补充:[/b]
hibernate 二级缓存 中将映射文件设置为 read-only,为何还能进行增删改?
例如某User对象;









为何还可以进行User进行增删改呢?不是只读吗?谢谢

测试代码如下:
[code="java"]
public void testCache1(){
Session s = HibernateUtils.getSession() ;
Query q = s.createQuery("from User") ;
//q.setCacheable(true) ;
for(Iterator iter=q.iterate(); iter.hasNext();){
User u = (User)iter.next() ;
System.out.println("user.getName ="+u.getUserName()) ;
}
s.close() ;

    System.out.println("----------------------------") ;

    s = HibernateUtils.getSession() ;

    s.beginTransaction() ;
    User user = new User() ;
    user.setUserName("yu") ;
    user.setPwd("123") ;
    Serializable id = s.save(user) ;
    s.beginTransaction().commit() ;
    s.close() ;

    System.out.println("----------------------------") ;

     s = HibernateUtils.getSession() ;
     q = s.createQuery("from User") ;
    // q.setCacheable(true) ;
    for(Iterator iter=q.iterate(); iter.hasNext();){
        User u = (User)iter.next() ;
        System.out.println("user.getName ="+u.getUserName()) ;
    }
    s.close() ;
}

[/code]
输出结果:
Hibernate: select user0_.id as id0_, user0_.userName as userName0_, user0_.pwd as pwd0_, user0_.createTime as createTime0_ from User user0_

user.getName =yushan

Hibernate: insert into User (userName, pwd, createTime, id) values (?, ?, ?, ?)

Hibernate: select user0_.id as col_0_0_ from User user0_
user.getName =yushan
user.getName =yu
以上代码前提是已经开启查询缓存和二级缓存,User设置为read-only,第一次取出一条,然后增加条,为何第二次取的时候会有两条呢,而且还是从缓存中取得的?按理来说经过第一次取后二级缓存中只有一条记录,当save的时候也会往二级缓存中增加一条记录,但是第二次取的时候,因为二级缓存生存周期还未失效,且还是read-only,那么二级中应该只有一条啊?为何呢,请详解谢谢!
[b]问题补充:[/b]
hibernate 二级缓存 中将映射文件设置为 read-only,为何还能进行增删改?
例如某User对象;









为何还可以进行User进行增删改呢?不是只读吗?谢谢
[b]问题补充:[/b]
hibernate 二级缓存 中将映射文件设置为 read-only,为何还能进行增删改?
例如某User对象;









为何还可以进行User进行增删改呢?不是只读吗?谢谢

测试代码如下:
[code="java"]
public void testCache1(){
Session s = HibernateUtils.getSession() ;
Query q = s.createQuery("from User") ;
q.setCacheable(true) ;
for(Iterator iter=q.list().iterator(); iter.hasNext();){
User u = (User)iter.next() ;
System.out.println("user.getName ="+u.getUserName()) ;
}
s.close() ;

    System.out.println("----------------------------") ;

    s = HibernateUtils.getSession() ;

    s.beginTransaction() ;
    User user = new User() ;
    user.setUserName("yu") ;
    user.setPwd("123") ;
    Serializable id = s.save(user) ;
    s.beginTransaction().commit() ;
    s.close() ;

    System.out.println("----------------------------") ;

     s = HibernateUtils.getSession() ;
     q = s.createQuery("from User") ;
     q.setCacheable(true) ;
    for(Iterator iter=q.iterate(); iter.hasNext();){
        User u = (User)iter.next() ;
        System.out.println("user.getName ="+u.getUserName()) ;
    }
    s.close() ;
}

[/code]
输出结果:
Hibernate: select user0_.id as id0_, user0_.userName as userName0_, user0_.pwd as pwd0_, user0_.createTime as createTime0_ from User user0_

user.getName =yushan

Hibernate: insert into User (userName, pwd, createTime, id) values (?, ?, ?, ?)

Hibernate: select user0_.id as col_0_0_ from User user0_
user.getName =yushan
user.getName =yu
以上代码前提是已经开启查询缓存和二级缓存,User设置为read-only,第一次取出一条,然后增加条,为何第二次取的时候会有两条呢,而且还是从缓存中取得的?按理来说经过第一次取后二级缓存中只有一条记录,当save的时候也会往二级缓存中增加一条记录,但是第二次取的时候,因为二级缓存生存周期还未失效,且还是read-only,那么二级中应该只有一条啊?为何呢,请详解谢谢!
[b]问题补充:[/b]
hibernate 二级缓存 中将映射文件设置为 read-only,为何还能进行增删改?
例如某User对象;









为何还可以进行User进行增删改呢?不是只读吗?谢谢
[b]问题补充:[/b]
hibernate 二级缓存 中将映射文件设置为 read-only,为何还能进行增删改?
例如某User对象;









为何还可以进行User进行增删改呢?不是只读吗?谢谢

测试代码如下:
[code="java"]
public void testCache1(){
Session s = HibernateUtils.getSession() ;
Query q = s.createQuery("from User") ;
//q.setCacheable(true) ;
for(Iterator iter=q.iterate(); iter.hasNext();){
User u = (User)iter.next() ;
System.out.println("user.getName ="+u.getUserName()) ;
}
s.close() ;

    System.out.println("----------------------------") ;

    s = HibernateUtils.getSession() ;

    s.beginTransaction() ;
    User user = new User() ;
    user.setUserName("yu") ;
    user.setPwd("123") ;
    Serializable id = s.save(user) ;
    s.beginTransaction().commit() ;
    s.close() ;

    System.out.println("----------------------------") ;

     s = HibernateUtils.getSession() ;
     q = s.createQuery("from User") ;
    // q.setCacheable(true) ;
    for(Iterator iter=q.iterate(); iter.hasNext();){
        User u = (User)iter.next() ;
        System.out.println("user.getName ="+u.getUserName()) ;
    }
    s.close() ;
}

[/code]
输出结果:
Hibernate: select user0_.id as id0_, user0_.userName as userName0_, user0_.pwd as pwd0_, user0_.createTime as createTime0_ from User user0_

user.getName =yushan

Hibernate: insert into User (userName, pwd, createTime, id) values (?, ?, ?, ?)

Hibernate: select user0_.id as col_0_0_ from User user0_
user.getName =yushan
user.getName =yu
以上代码前提是已经开启查询缓存和二级缓存,User设置为read-only,第一次取出一条,然后增加条,为何第二次取的时候会有两条呢,而且还是从缓存中取得的?按理来说经过第一次取后二级缓存中只有一条记录,当save的时候也会往二级缓存中增加一条记录,但是第二次取的时候,因为二级缓存生存周期还未失效,且还是read-only,那么二级中应该只有一条啊?为何呢,请详解谢谢!

[color=red]按 jones 的意思是不是 read-only 形式下,不能对二级缓存中的对象做任何修改,但可以修改该对象在数据库中的状态 是吗?那么我还有个,在前面的基础上,即在第一次查询 和第二次查询的之间放入一段修改缓存中某对象的时咋出现题呢,代码如下[/color]

[code="java"]s = HibernateUtils.getSession() ;
//s.setCacheMode(CacheMode.GET) ;
User u = new User() ;
u.setId("8aa3b33c1d8eb43b011d8eb441300001") ;
u.setName("yushan5118") ;
s.saveOrUpdate(u) ;
s.beginTransaction().commit() ;
s.close() ;[/code]
[color=red]出现一个异常:
ERROR ReadOnlyCache:42 - Application attempted to edit read only item: com.c35.hibernate.po.User#8aa3b33c1d8eb43b011d8eb441300001
且数据库中的该对象属性未变化? 按理不是说不能修改缓存里面的,但可以操纵数据库吗?谢谢[/color]

read-only只是Hibernate用来决定如何处理缓存数据的,如果你的缓存对象是read-only的,Hibernate可不负责你的缓存与数据库之间的同步处理,因为Hibernate认为你这个对象根本就永远都不会改变。
[color=red]那么 Hibernate 只对缓存里面的对象read-only,当我修改某个对象的时候,hibernate难道还会判断我修改的对象是否是缓存中已经有的,如果有就不接受修改 是吗?要是这样,想修改该对象在数据库中的内容 该咋办,又不影响read-only?能否帮忙解释一下为何会出现ERROR ReadOnlyCache:42错误?[/color] 在此感谢jones

[color=red]还有就是 当我开启 s.setCacheMode(CacheMode.GET) ,应该是不该把这个修改的对象放到二级缓存中,由此我认为应该不会与二级缓存的read-only产生冲突啊,请jones 帮忙解释一下,小弟不胜感激啊[/color]

[b]问题补充:[/b]
hibernate 二级缓存 中将映射文件设置为 read-only,为何还能进行增删改?
例如某User对象;









为何还可以进行User进行增删改呢?不是只读吗?谢谢
[b]问题补充:[/b]
hibernate 二级缓存 中将映射文件设置为 read-only,为何还能进行增删改?
例如某User对象;









为何还可以进行User进行增删改呢?不是只读吗?谢谢

测试代码如下:
[code="java"]
public void testCache1(){
Session s = HibernateUtils.getSession() ;
Query q = s.createQuery("from User") ;
q.setCacheable(true) ;
for(Iterator iter=q.list().iterator(); iter.hasNext();){
User u = (User)iter.next() ;
System.out.println("user.getName ="+u.getUserName()) ;
}
s.close() ;

    System.out.println("----------------------------") ;

    s = HibernateUtils.getSession() ;

    s.beginTransaction() ;
    User user = new User() ;
    user.setUserName("yu") ;
    user.setPwd("123") ;
    Serializable id = s.save(user) ;
    s.beginTransaction().commit() ;
    s.close() ;

    System.out.println("----------------------------") ;

     s = HibernateUtils.getSession() ;
     q = s.createQuery("from User") ;
     q.setCacheable(true) ;
    for(Iterator iter=q.iterate(); iter.hasNext();){
        User u = (User)iter.next() ;
        System.out.println("user.getName ="+u.getUserName()) ;
    }
    s.close() ;
}

[/code]
输出结果:
Hibernate: select user0_.id as id0_, user0_.userName as userName0_, user0_.pwd as pwd0_, user0_.createTime as createTime0_ from User user0_

user.getName =yushan

Hibernate: insert into User (userName, pwd, createTime, id) values (?, ?, ?, ?)

Hibernate: select user0_.id as col_0_0_ from User user0_
user.getName =yushan
user.getName =yu
以上代码前提是已经开启查询缓存和二级缓存,User设置为read-only,第一次取出一条,然后增加条,为何第二次取的时候会有两条呢,而且还是从缓存中取得的?按理来说经过第一次取后二级缓存中只有一条记录,当save的时候也会往二级缓存中增加一条记录,但是第二次取的时候,因为二级缓存生存周期还未失效,且还是read-only,那么二级中应该只有一条啊?为何呢,请详解谢谢!
[b]问题补充:[/b]
hibernate 二级缓存 中将映射文件设置为 read-only,为何还能进行增删改?
例如某User对象;









为何还可以进行User进行增删改呢?不是只读吗?谢谢
[b]问题补充:[/b]
hibernate 二级缓存 中将映射文件设置为 read-only,为何还能进行增删改?
例如某User对象;









为何还可以进行User进行增删改呢?不是只读吗?谢谢

测试代码如下:
[code="java"]
public void testCache1(){
Session s = HibernateUtils.getSession() ;
Query q = s.createQuery("from User") ;
//q.setCacheable(true) ;
for(Iterator iter=q.iterate(); iter.hasNext();){
User u = (User)iter.next() ;
System.out.println("user.getName ="+u.getUserName()) ;
}
s.close() ;

    System.out.println("----------------------------") ;

    s = HibernateUtils.getSession() ;

    s.beginTransaction() ;
    User user = new User() ;
    user.setUserName("yu") ;
    user.setPwd("123") ;
    Serializable id = s.save(user) ;
    s.beginTransaction().commit() ;
    s.close() ;

    System.out.println("----------------------------") ;

     s = HibernateUtils.getSession() ;
     q = s.createQuery("from User") ;
    // q.setCacheable(true) ;
    for(Iterator iter=q.iterate(); iter.hasNext();){
        User u = (User)iter.next() ;
        System.out.println("user.getName ="+u.getUserName()) ;
    }
    s.close() ;
}

[/code]
输出结果:
Hibernate: select user0_.id as id0_, user0_.userName as userName0_, user0_.pwd as pwd0_, user0_.createTime as createTime0_ from User user0_

user.getName =yushan

Hibernate: insert into User (userName, pwd, createTime, id) values (?, ?, ?, ?)

Hibernate: select user0_.id as col_0_0_ from User user0_
user.getName =yushan
user.getName =yu
以上代码前提是已经开启查询缓存和二级缓存,User设置为read-only,第一次取出一条,然后增加条,为何第二次取的时候会有两条呢,而且还是从缓存中取得的?按理来说经过第一次取后二级缓存中只有一条记录,当save的时候也会往二级缓存中增加一条记录,但是第二次取的时候,因为二级缓存生存周期还未失效,且还是read-only,那么二级中应该只有一条啊?为何呢,请详解谢谢!
[b]问题补充:[/b]
hibernate 二级缓存 中将映射文件设置为 read-only,为何还能进行增删改?
例如某User对象;









为何还可以进行User进行增删改呢?不是只读吗?谢谢
[b]问题补充:[/b]
hibernate 二级缓存 中将映射文件设置为 read-only,为何还能进行增删改?
例如某User对象;









为何还可以进行User进行增删改呢?不是只读吗?谢谢

测试代码如下:
[code="java"]
public void testCache1(){
Session s = HibernateUtils.getSession() ;
Query q = s.createQuery("from User") ;
q.setCacheable(true) ;
for(Iterator iter=q.list().iterator(); iter.hasNext();){
User u = (User)iter.next() ;
System.out.println("user.getName ="+u.getUserName()) ;
}
s.close() ;

    System.out.println("----------------------------") ;

    s = HibernateUtils.getSession() ;

    s.beginTransaction() ;
    User user = new User() ;
    user.setUserName("yu") ;
    user.setPwd("123") ;
    Serializable id = s.save(user) ;
    s.beginTransaction().commit() ;
    s.close() ;

    System.out.println("----------------------------") ;

     s = HibernateUtils.getSession() ;
     q = s.createQuery("from User") ;
     q.setCacheable(true) ;
    for(Iterator iter=q.iterate(); iter.hasNext();){
        User u = (User)iter.next() ;
        System.out.println("user.getName ="+u.getUserName()) ;
    }
    s.close() ;
}

[/code]
输出结果:
Hibernate: select user0_.id as id0_, user0_.userName as userName0_, user0_.pwd as pwd0_, user0_.createTime as createTime0_ from User user0_

user.getName =yushan

Hibernate: insert into User (userName, pwd, createTime, id) values (?, ?, ?, ?)

Hibernate: select user0_.id as col_0_0_ from User user0_
user.getName =yushan
user.getName =yu
以上代码前提是已经开启查询缓存和二级缓存,User设置为read-only,第一次取出一条,然后增加条,为何第二次取的时候会有两条呢,而且还是从缓存中取得的?按理来说经过第一次取后二级缓存中只有一条记录,当save的时候也会往二级缓存中增加一条记录,但是第二次取的时候,因为二级缓存生存周期还未失效,且还是read-only,那么二级中应该只有一条啊?为何呢,请详解谢谢!
[b]问题补充:[/b]
hibernate 二级缓存 中将映射文件设置为 read-only,为何还能进行增删改?
例如某User对象;









为何还可以进行User进行增删改呢?不是只读吗?谢谢
[b]问题补充:[/b]
hibernate 二级缓存 中将映射文件设置为 read-only,为何还能进行增删改?
例如某User对象;









为何还可以进行User进行增删改呢?不是只读吗?谢谢

测试代码如下:
[code="java"]
public void testCache1(){
Session s = HibernateUtils.getSession() ;
Query q = s.createQuery("from User") ;
//q.setCacheable(true) ;
for(Iterator iter=q.iterate(); iter.hasNext();){
User u = (User)iter.next() ;
System.out.println("user.getName ="+u.getUserName()) ;
}
s.close() ;

    System.out.println("----------------------------") ;

    s = HibernateUtils.getSession() ;

    s.beginTransaction() ;
    User user = new User() ;
    user.setUserName("yu") ;
    user.setPwd("123") ;
    Serializable id = s.save(user) ;
    s.beginTransaction().commit() ;
    s.close() ;

    System.out.println("----------------------------") ;

     s = HibernateUtils.getSession() ;
     q = s.createQuery("from User") ;
    // q.setCacheable(true) ;
    for(Iterator iter=q.iterate(); iter.hasNext();){
        User u = (User)iter.next() ;
        System.out.println("user.getName ="+u.getUserName()) ;
    }
    s.close() ;
}

[/code]
输出结果:
Hibernate: select user0_.id as id0_, user0_.userName as userName0_, user0_.pwd as pwd0_, user0_.createTime as createTime0_ from User user0_

user.getName =yushan

Hibernate: insert into User (userName, pwd, createTime, id) values (?, ?, ?, ?)

Hibernate: select user0_.id as col_0_0_ from User user0_
user.getName =yushan
user.getName =yu
以上代码前提是已经开启查询缓存和二级缓存,User设置为read-only,第一次取出一条,然后增加条,为何第二次取的时候会有两条呢,而且还是从缓存中取得的?按理来说经过第一次取后二级缓存中只有一条记录,当save的时候也会往二级缓存中增加一条记录,但是第二次取的时候,因为二级缓存生存周期还未失效,且还是read-only,那么二级中应该只有一条啊?为何呢,请详解谢谢!

[color=red]按 jones 的意思是不是 read-only 形式下,不能对二级缓存中的对象做任何修改,但可以修改该对象在数据库中的状态 是吗?那么我还有个,在前面的基础上,即在第一次查询 和第二次查询的之间放入一段修改缓存中某对象的时咋出现题呢,代码如下[/color]

[code="java"]s = HibernateUtils.getSession() ;
//s.setCacheMode(CacheMode.GET) ;
User u = new User() ;
u.setId("8aa3b33c1d8eb43b011d8eb441300001") ;
u.setName("yushan5118") ;
s.saveOrUpdate(u) ;
s.beginTransaction().commit() ;
s.close() ;[/code]
[color=red]出现一个异常:
ERROR ReadOnlyCache:42 - Application attempted to edit read only item: com.c35.hibernate.po.User#8aa3b33c1d8eb43b011d8eb441300001
且数据库中的该对象属性未变化? 按理不是说不能修改缓存里面的,但可以操纵数据库吗?谢谢[/color]
[b]问题补充:[/b]
hibernate 二级缓存 中将映射文件设置为 read-only,为何还能进行增删改?
例如某User对象;









为何还可以进行User进行增删改呢?不是只读吗?谢谢
[b]问题补充:[/b]
hibernate 二级缓存 中将映射文件设置为 read-only,为何还能进行增删改?
例如某User对象;









为何还可以进行User进行增删改呢?不是只读吗?谢谢

测试代码如下:
[code="java"]
public void testCache1(){
Session s = HibernateUtils.getSession() ;
Query q = s.createQuery("fro

10个回答

[quote]
那么 Hibernate 只对缓存里面的对象read-only,当我修改某个对象的时候,hibernate难道还会判断我修改的对象是否是缓存中已经有的,如果有就不接受修改是吗?要是这样,想修改该对象在数据库中的内容 该咋办,又不影响read-only?能否帮忙解释一下为何会出现ERROR ReadOnlyCache:42错误?
[/quote]
因为你这个对象配置了缓存策略,所以[color=red]每次修改并保存[/color]一个这个对象的同时,Hibernate都会把这个对象的实例放到缓存中的,所以每次如果你修改一个对象的时候,Hibernate在操作缓存过程中必然会发现已经存在了,而且是readonly的,必然会抛出异常。
你的缓存策略选择的有问题,一般readonly策略只用在永远不会发生改变的对象上面,比如数据库中存放的系统常量,这种东东只需要查询一次放到缓存中就可以了,你的User对象用readonly一点儿都不适合,建议换成read-write策略

这个只读说的是缓存策略,只读。对于不会发生改变的数据,可使用只读型缓存。

你真应该好好看看这个了,四种缓存策略
(1) read-only
只读。对于不会发生改变的数据,可使用只读型缓存。

(2)nonstrict-read-write
不严格可读写缓存。如果应用程序对并发访问下的数据同步要求不是很严格的话,而且数据更新操作频率较低。采用本项,可获得良好的性能。

(3) read-write
对于经常被读但很少修改的数据,可以采用这种隔离类型,因为它可以防止脏读这类的并发问题.

(4)transactional(事物型)
在Hibernate中,事务型缓存必须运行在JTA事务环境中。

read-only 并不是不能修改
read-only而是你的应用程序只需读取一个持久化类的实例,而无需对其修改, 那么就可以对其进行只读 缓存。这是最简单,也是实用性最好的方法。甚至在集群中,它也能完美地运作。

[code="java"] [/code]只是说明使用的缓存策略,并不是说数据库里的真实数据不能修改。

[quote]read-only [/quote]
这个表示的是Hibernate认为你缓存中的对象是永远不会被修改的,这样Hibernate就永远都不会把缓存的状态跟数据库做同步,read-only指的就是缓存这个对象一旦被缓存了永远都不会被改变了。
[quote]那么二级中应该只有一条啊?[/quote]
单条记录的对象混存是根据id判断的,你两次ID不同,当然缓存中要放两个对象了。

[quote]按 jones 的意思是不是 read-only 形式下,不能对二级缓存中的对象做任何修改,但可以修改该对象在数据库中的状态 是吗?[/quote]
read-only只是Hibernate用来决定如何处理缓存数据的,如果你的缓存对象是read-only的,Hibernate可不负责你的缓存与数据库之间的同步处理,因为Hibernate认为你这个对象根本就永远都不会改变。

[quote]
出现一个异常:
ERROR ReadOnlyCache:42 - Application attempted to edit read only item: com.c35.hibernate.po.User#8aa3b33c1d8eb43b011d8eb441300001
且数据库中的该对象属性未变化? 按理不是说不能修改缓存里面的,但可以操纵数据库吗?谢谢
[/quote]
这个问题很明显啊,因为你的这个对象已经在缓存中存在了,你保存这个对象的时候Hibernate原本打算给你同步到缓存中,但是突然发现缓存中已经存在了同一个ID的缓存对象并且是只读的,它就应该你你正在修改一个readonly的缓存条目
还是那句话,[color=red]Hibernate是根据ID来唯一标识实体的[/color]

[quote]且数据库中的该对象属性未变化? 按理不是说不能修改缓存里面的,但可以操纵数据库吗?谢谢[/quote]
数据库中当然不会变化了,因为保存数据和同步缓存是在同一个事务里面,同步缓存的过程中发生了异常,事务回滚了。
[quote]理不是说不能修改缓存里面的,但可以操纵数据库吗?[/quote]
如果你把这个对象的缓存策略设置成readonly并且这个对象ID相同的缓存条目已经存在的话,那么你就不可能修改成功了,因为每次Hibernate往缓存中放这个ID的对象的时候都发现这个ID已经存在并且是readonly,必然会抛出 Application attempted to edit read only item:异常的

[quote]
static CacheMode GET
The session may read items from the cache, but will not add items, [color=red]except to invalidate items when updates occur[/color]
[/quote]
虽然只从缓存中读取,但是updates发生的时候还是要校验的,你修改readonly缓存的行为一样会被发现

Csdn user default icon
上传中...
上传图片
插入图片
抄袭、复制答案,以达到刷声望分或其他目的的行为,在CSDN问答是严格禁止的,一经发现立刻封号。是时候展现真正的技术了!
立即提问