yushanyigong 2008-11-11 17:57
浏览 292
已采纳

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条回答 默认 最新

  • iteye_521 2008-11-12 14:04
    关注

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

    本回答被题主选为最佳回答 , 对您是否有帮助呢?
    评论
查看更多回答(9条)

报告相同问题？

悬赏问题

  • ¥20 Keil uVision5创建project没反应
  • ¥15 mmseqs内存报错
  • ¥15 vika文档如何与obsidian同步
  • ¥15 华为手机相册里面的照片能够替换成自己想要的照片吗？
  • ¥15 陆空双模式无人机飞控设置
  • ¥15 sentaurus lithography
  • ¥100 求抖音ck号 或者提ck教程
  • ¥15 关于#linux#的问题：子进程1等待子进程A、B退出后退出(语言-c语言)
  • ¥20 web页面如何打开Outlook 365的全球离线通讯簿功能
  • ¥15 io.jsonwebtoken.security.Keys