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_
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_
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_
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_
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_
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_
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_
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_
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_
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_
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_
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_
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_
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_
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_
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_
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_
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_
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_
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_
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
[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缓存的行为一样会被发现