Hibernate 二级缓存 总结整理

和《Hibernate 关系映射 收集、总结整理》 一样，本篇文章也是我很早之前收集、总结整理的，在此也发上来 希望对大家有用。因为是很早之前写的，不当之处请指正。

 

1、缓存：缓存是什么，解决什么问题？

位于速度相差较大的两种硬件/软件之间的，用于协调两者数据传输速度差异的结构，均可称之为 Cache（摘自Robbin的《缓存技术浅谈》）。目的：让数据更接近于应用程序，协调速度不匹配，使访问速度更快。（请参考http://baike.baidu.com/view/907.htm 了解更多缓存知识）

    高速缓存不属于Hibernate等，属于独立产品或框架，可单独使用。

 

常见缓存算法：

a)         LFU（Least Frequently Used）：最近不常被使用（命中率低），一定时间段内使用次数最少的

b)        LRU（Least Recently Used）：最近很少使用（LinkedHashMap），没有被使用时间最长的

c)        FIFO（First In First Out）：先进先出

 

2、缓存策略

1．对象缓存

2．查询缓存

3．页面缓存

1．动态页面缓存

2．Servlet缓存

3．页面片段缓存

 

3、缓存分类

    1.         Web缓存：

                     i.              浏览器缓存：ajax（在客户端缓存）、HTTP协议

                     ii.          代理服务器缓存

    2.       操作系统缓存：如用于减少磁盘操作

    3.        数据库缓存：

                         i.              结果缓存：

                         ii.             排序缓存

                         iii.            插入缓存

                         iv.            日志缓存

                         v.              ………………

    4.         应用程序缓存

                        i.              对象缓存

                         ii.              查询缓存

                         iii.              页面缓存

                             1.         动态页面静态化：网页静态化、独立图片服务器

                             2.         页面局部缓存：

                             3.        请求回应缓存：

 

4、常见Java缓存框架

    §           EHCache

    §           OSCache

    §           JBossCache

    §           SwarmCache

 

5、通用缓存产品

    §           Memcached：在大规模互联网应用下使用，可用于分布式环境，每秒支撑1.5万～2万次请求

    §           Tokyo Tyrant：兼容memcached协议，可以持久化存储，支持故障切换，对缓存服务器有高可靠性要求可以使用，每秒支撑0.5万～0.8万次请求

 

6、基于Web应用的缓存应用场景：

（摘自bluedavy的《大型网站架构演化》）

8、缓存实战：

8.4、ORM缓存

8.4.1、目的：

Hibernate缓存：使当前数据库状态的表示接近应用程序，要么在内存中，要么在应用程序服务器机器的磁盘上。高速缓存是数据的一个本地副本，处于应用程序和数据库之间，可用来避免数据库的命中。

8.4.2、避免数据库命中：

应用程序根据标识符到缓存查，有就返回，没有再去数据库.

8.4.3、ORM缓存分类

一级缓存、二级缓存

8.4.4、缓存范围

1、事务范围高速缓存，对应于一级缓存（单Session）

       2、过程（JVM）范围高速缓存，对应于二级缓存（单SessionFactory）

              3、集群范围高速缓存，对应于二级缓存（多SessionFactory）

8.4.5、缓存哪些数据

              1、很少改变的数据；

2、不重要的数据，如论坛帖子，无需实时的数据；

              3、应用程序固有的而非共享的。

              4、读大于写有用

 

 

8.4.6、Hibernate缓存架构

图摘自《Hibernate in Action》

§           Hibernate中的二级缓存是可插拔的。

§           Hibernate二级缓存支持对象缓存、集合缓存、查询结果集缓存，对于查询结果集缓存可选。

§           查询缓存：需要两个额外的物理高速缓存区域：一个用于存放查询的结果集；另一个用于存储表上次更新的时间戳

 

 

8.4.6.2、高速缓存实战(ehcache)

8.4.6.2.1、全局配置(hibernate.cfg.xml)

<!-- 开启二级缓存 -->
<property name="hibernate.cache.use_second_level_cache">true</property>
<!-- 开启查询缓存 -->
<property name="hibernate.cache.use_query_cache">true</property>
<!-- 二级缓存区域名的前缀 -->
<!--<property name="hibernate.cache.region_prefix">h3test</property>-->
<!-- 高速缓存提供程序 -->
<property name="hibernate.cache.region.factory_class">
net.sf.ehcache.hibernate.EhCacheRegionFactory
</property>
<!-- 指定缓存配置文件位置 -->
<property name="hibernate.cache.provider_configuration_file_resource_path">
ehcache.xml
</property>
<!-- 强制Hibernate以更人性化的格式将数据存入二级缓存 -->
<property name="hibernate.cache.use_structured_entries">true</property>

<!-- Hibernate将收集有助于性能调节的统计数据 -->
<property name="hibernate.generate_statistics">true</property>

 

 8.4.6.2.2、ehcache配置（ehcache.xml）

<?xml version="1.0" encoding="UTF-8"?>
<ehcache name="h3test">
   <defaultCache
      maxElementsInMemory="100"
      eternal="false"
      timeToIdleSeconds="1200"
      timeToLiveSeconds="1200"
      overflowToDisk="false">
    </defaultCache>
</ehcache>

 

 8.4.6.2.3、实体只读缓存

1、修改FarmModel.hbm.xml,添加如下红色部分配置，表示实体缓存并只读

<hibernate-mapping>
    <class name="cn.javass.h3test.model.FarmModel" table="TBL_FARM">
        <cache usage="read-only"/>
    ……
</hibernate-mapping>

 

 2、测试代码

public static void readonlyTest() {
      SessionFactory sf = 
new Configuration().configure().buildSessionFactory();
        
      Session session1 = sf.openSession();
      Transaction t1 = session1.beginTransaction();
      //确保数据库中有标识符为1的FarmModel
      FarmModel farm = (FarmModel) session1.get(FarmModel.class, 1);
      //如果修改将报错，只读缓存不允许修改
      //farm.setName("aaa");
      t1.commit();
     session1.close();
        
        
      Session session2 = sf.openSession();
      Transaction t2 = session2.beginTransaction();
        
      farm = (FarmModel) session2.get(FarmModel.class, 1);
        
      t2.commit();
      session2.close();
      sf.close();
}

 

   §           只读缓存不允许更新，将报错Can't write to a readonly object。

   §           允许新增，（现在2。0 新增直接添加到二级缓存）

 

8.4.6.2.4、实体非严格读/写缓存

 

1、修改FarmModel.hbm.xml,添加如下红色部分配置，表示实体缓存并非严格读/写

<hibernate-mapping>
    <class name="cn.javass.h3test.model.FarmModel" table="TBL_FARM">
        <cache usage="nonstrict-read-write"/>
    ……
</hibernate-mapping>

 

 2、测试代码

public static void nonstrictReadWriteTest () {
      SessionFactory sf = 
new Configuration().configure().buildSessionFactory();
        
      Session session1 = sf.openSession();
      Transaction t1 = session1.beginTransaction();
      //确保数据库中有标识符为1的FarmModel
      FarmModel farm = (FarmModel) session1.get(FarmModel.class, 1);
      t1.commit();
     session1.close();
        
        
      Session session2 = sf.openSession();
      Transaction t2 = session2.beginTransaction();
        
      farm = (FarmModel) session2.get(FarmModel.class, 1);
        
      t2.commit();
      session2.close();
      sf.close();
}

       §           允许更新，更新后缓存失效，需再查询一次。

       §           允许新增，新增记录自动加到二级缓存中。

       §           整个过程不加锁，不保证。

 

8.4.6.2.5、实体读/写缓存

1、修改FarmModel.hbm.xml,添加如下红色部分配置，表示实体缓存并读/写

<hibernate-mapping>
    <class name="cn.javass.h3test.model.FarmModel" table="TBL_FARM">
        <cache usage="read-write"/>
    ……
</hibernate-mapping> 

 

2、测试代码

public static void readWriteTest() {
    SessionFactory sf = 
new Configuration().configure().buildSessionFactory();
        
    Session session1 = sf.openSession();
    Transaction t1 = session1.beginTransaction();
    //确保数据库中有标识符为1的FarmModel
    FarmModel farm = (FarmModel) session1.get(FarmModel.class, 1);
    farm.setName("as");
    t1.commit();
    session1.close();
            
    Session session2 = sf.openSession();
    Transaction t2 = session2.beginTransaction();
    farm = (FarmModel) session2.get(FarmModel.class, 1);
    t2.commit();
    session2.close();
    sf.close();
} 

    §          允许更新，更新后自动同步到缓存。

    §          允许新增，新增记录后自动同步到缓存。

    §           保证read committed隔离级别及可重复读隔离级别（通过时间戳实现）

    §           整个过程加锁，如果当前事务的时间戳早于二级缓存中的条目的时间戳，说明该条目已经被别的事务修改了，此时重新查询一次数据库，否则才使用缓存数据，因此保证可重复读隔离级别。

 

8.4.6.2.6、实体事务缓存

需要特定缓存的支持和JTA事务支持，此处不演示。

 

8.4.6.2.7、集合缓存

此处演示读/写缓存示例，其他自测

1、修改FarmModel.hbm.xml,添加如下红色部分配置，表示实体缓存并读/写

<hibernate-mapping>
    <class name="cn.javass.h3test.model.UserModel" table="TBL_USER">
        <cache usage="read-write" />
        <set name="farms" cascade="all" inverse="true" lazy="false">
            <cache usage="read-write"/>
            <key column="fk_user_id"/>
            <one-to-many class="cn.javass.h3test.model.FarmModel"/>
        </set>
    </class>
</hibernate-mapping>

 

2、测试代码

public static void collectionReadWriteTest() {
SessionFactory sf = 
new Configuration().configure().buildSessionFactory();
        
    Session session1 = sf.openSession();
    Transaction t1 = session1.beginTransaction();
    //确保数据库中有标识符为118的UserModel
    UserModel user = (UserModel) session1.get(UserModel.class, 118);
    user.getFarms();
    t1.commit();
    session1.close();
        
    Session session2 = sf.openSession();
    Transaction t2 = session2.beginTransaction();
    user = (UserModel) session2.get(UserModel.class, 118);
    user.getFarms();
    t2.commit();
    session2.close();
    sf.close();
} 

    §           和实体并发策略有相同含义；

    §           但集合缓存只缓存集合元素的标识符，在二级缓存中只存放相应实体的标识符，然后再通过标识符去二级缓存查找相应的实体最后组合为集合返回。

 

 

8.4.6.2.8、查询缓存

1、保证全局配置中有开启了查询缓存。

2、修改FarmModel.hbm.xml,添加如下红色部分配置，表示实体缓存并读/写

<hibernate-mapping>
    <class name="cn.javass.h3test.model.FarmModel" table="TBL_FARM">
        <cache usage="read-write"/>
    ……
</hibernate-mapping> 

  3、测试代码

public static void queryCacheTest() {
SessionFactory sf = 
new Configuration().configure().buildSessionFactory();
     
Session session1 = sf.openSession();
    Transaction t1 = session1.beginTransaction();
    Query query = session1.createQuery("from FarmModel");
    //即使全局打开了查询缓存，此处也是必须的
    query.setCacheable(true);
    List<FarmModel> farmList = query.list();
    t1.commit();
    session1.close();
    
    Session session2 = sf.openSession();
    Transaction t2 = session2.beginTransaction();
    query = session2.createQuery("from FarmModel");
    //即使全局打开了查询缓存，此处也是必须的
    query.setCacheable(true);
    farmList = query.list();
    t2.commit();
    session2.close();
        sf.close();
}

      §           和实体并发策略有相同含义；

      §           和集合缓存类似，只缓存集合元素的标识符，在二级缓存中只存放相应实体的标识符，然后再通过标识符 去二级缓存查找相应的实体最后组合为集合返回。

  

 

8.4.6.2.9、高速缓存区域

Hibernate在不同的高速缓存区域保存不同的类（实体）/集合，如果不配置区域默认都保存到“默认缓存”（defaultCache）中。

  每一个区域可以设置过期策略、缓存条目大小等等。

  对于类缓存，默认区域名是全限定类名，如cn.javass.h3test.model.UserModel。

  对于集合而言，默认区域名是全限定类名+属性名，如cn.javass.….UserModel.farms。

  可通过hibernate.cache.region_prefix指定特定SessionFactory的区域前缀，如前缀是h3test，则如类缓存的区域名就是h3test. cn.javass.h3test.model.UserModel。如果应用程序使用多个SessionFactory 这可能是必须的。

 

    可通过<cache usage="read-write" region="区域名"/>自定义区域名，不过默认其实就可以了。

 

 

8.4.6.2.10、ehcache配置详解：

1、默认cache：如果没有对应的特定区域的缓存，就使用默认缓存。

   <defaultCache
      maxElementsInMemory="100"
      eternal="false"
      timeToIdleSeconds="1200"
      timeToLiveSeconds="1200"
      overflowToDisk="false">
    </defaultCache>

   2、指定区域cache：通过name指定，name对应到Hibernate中的区域名即可。

   <cache name="cn.javass.h3test.model.UserModel"
      maxElementsInMemory="100"
      eternal="false"
      timeToIdleSeconds="1200"
      timeToLiveSeconds="1200"
      overflowToDisk="false">
    </cache>

 3、cache参数详解：

 

  name:指定区域名

  maxElementsInMemory ：缓存在内存中的最大数目

  maxElementsOnDisk：缓存在磁盘上的最大数目

  eternal ：缓存是否持久

  overflowToDisk ： 硬盘溢出数目

  timeToIdleSeconds ：当缓存条目闲置n秒后销毁

  timeToLiveSeconds ：当缓存条目存活n秒后销毁

  memoryStoreEvictionPolicy:缓存算法，有LRU（默认）、LFU、FIFO

 

 

  4、StandardQueryCache

 

  用于查询缓存使用，如果指定了该缓存，那么查询缓存将放在该缓存中。

<cache
    name="org.hibernate.cache.StandardQueryCache"
    maxElementsInMemory="5"
    eternal="false"
    timeToLiveSeconds="120"
overflowToDisk="true"/>

 

  如果不给查询设置区域名默认缓存到这，可以通过“query.setCacheRegion("区域名");”来设置查询的区域名。

 

5、UpdateTimestampsCache

    时间戳缓存，内部使用，用于保存最近更新的表的时间戳，这是非常重要的，无需失效，关闭时间戳缓存区域的过期时间。

<cache
    name="org.hibernate.cache.UpdateTimestampsCache"
    maxElementsInMemory="5000"
    eternal="true"
    overflowToDisk="true"/>

  

    Hibernate使用时间戳区域来决定被高速缓存的查询结果集是否是失效的。当你重新执行了一个启用了高速缓存的查询时，Hibernate就在时间戳缓存中查找对被查询的（几张）表所做的最近插入、更新或删除的时间戳。如果找到的时间戳晚于高速缓存查询结果的时间戳，那么缓存结果将被丢弃，重新执行一次查询。

 

8.4.6.2.11、什么时候需要查询缓存

  大多数时候无法从结果集高速缓存获益。必须知道:每隔多久重复执行同一查询。

  对于那些查询非常多但插入、删除、更新非常少的应用程序来说，查询缓存可提升性能。但写入多查询少的没有用，总失效。

 

8.4.6.2.12、管理一级缓存

无论何时，当你给save()、update()或 saveOrUpdate()方法传递一个对象时，或使用load()、 get()、list()、iterate() 或scroll()方法获得一个对象时, 该对象都将被加入到Session的内部缓存中。

当随后flush()方法被调用时，对象的状态会和数据库取得同步。 如果你不希望此同步操作发生，或者你正处理大量对象、需要对有效管理内存时，你可以调用evict() 方法，从一级缓存中去掉这些对象及其集合。

ScrollableResult cats = sess.createQuery("from Cat as cat").scroll(); //a huge result set

while ( cats.next() ) {

    Cat cat = (Cat) cats.get(0);

    doSomethingWithACat(cat);

    sess.evict(cat);

}

Session还提供了一个contains()方法，用来判断某个实例是否处于当前session的缓存中。

如若要把所有的对象从session缓存中彻底清除，则需要调用Session.clear()。

 

CacheMode参数用于控制具体的Session如何与二级缓存进行交互。

CacheMode.NORMAL - 从二级缓存中读、写数据。

CacheMode.GET - 从二级缓存中读取数据，仅在数据更新时对二级缓存写数据。

CacheMode.PUT - 仅向二级缓存写数据，但不从二级缓存中读数据。

CacheMode.REFRESH - 仅向二级缓存写数据，但不从二级缓存中读数据。通过 hibernate.cache.use_minimal_puts的设置，强制二级缓存从数据库中读取数据，刷新缓存内容。

 

8.4.6.2.12、管理二级缓存

对于二级缓存来说，在SessionFactory中定义了许多方法， 清除缓存中实例、整个类、集合实例或者整个集合。

sessionFactory.evict(Cat.class, catId); //evict a particular Cat

sessionFactory.evict(Cat.class);  //evict all Cats

sessionFactory.evictCollection("Cat.kittens", catId); //evict a particular collection of kittens

sessionFactory.evictCollection("Cat.kittens"); //evict all kitten collections

sessionFactory.evictQueries()//evict all queries

 

8.4.6.2.13、监控二级缓存

如若需要查看二级缓存或查询缓存区域的内容，你可以使用统计（Statistics） API。

通过sessionFactory.getStatistics()；获取Hibernate统计信息。

此时，你必须手工打开统计选项。

hibernate.generate_statistics true

hibernate.cache.use_structured_entries true

 

具体详见“hibernate监控.rar”（需要自己稍微改改才能用）

需要修改head.jsp中的如下代码获取sessionFactory

  if(sessionFactory == null) {
    WebApplicationContext applicationContext = WebApplicationContextUtils.getWebApplicationContext(request.getSession().getServletContext());
    sessionFactory = (SessionFactory)applicationContext.getBean("userSessionFactory"); 
  }

 

 

参考资料:

Robbin的《缓存技术浅谈》

百度百科的高速缓存知识 http://baike.baidu.com/view/907.htm 

bluedavy的《大型网站架构演化》（http://www.blogjava.net/BlueDavy/archive/2008/09/03/226749.html）

《Hibernate in Action》

 

评论

33 楼 寒冰lyl 2014-09-03  

32 楼 在世界的中心呼喚愛 2014-01-26  

不是很喜欢这类文章，很多配置。。
这类文章，我也只有在项目使用到才会去看看。。。
前面的概念很好，又复习了一遍。

31 楼 tanxiangbo 2014-01-26  

log4j:WARN No such property [maxBackupIndex] in org.apache.log4j.DailyRollingFileAppender.
Hibernate:
    select
        bo.*,
        p.code as productCode,
        p.name as productName,
        p.norm as norm ,
        (case
            when bo.channelId is not null then (select
                name
            from
                t_sel_channel c
            where
                c.id=bo.channelId)
            else ''
        end) as channelName ,
        (case
            when bo.customerId is not null then (select
                name
            from
                t_ba_customer bc
            where
                bc.id=bo.customerId)
            else ''
        end) as customerName
    from
        ( select
            b.product_id as productId ,
            sum(b.num) as borrowNum,
            sum(b.writeoffs_num) as writeoffsNum,
            sum(b.return_num) as returnNum ,
            sum(b.num)-sum(case
                when b.writeoffs_num is null then 0
                else b.writeoffs_num
            end)-sum(case
                when b.return_num is null then 0
                else b.return_num
            end) as num ,
            b.borrower_id as borrowerId,
            b.borrower_name as borrowerName,
            b.whs_id as whsId,
            b.whs_name as whsName,
            b.channel_id as channelId,
            b.customer_id as customerId
        from
            t_whs_borrow_details as b 
        where
            1=1 
            and b.whs_id in(
                ?, ?, ?
            )
        group by
            b.product_id,
            b.borrower_id,
            b.whs_id
        order by
            b.stamp desc )as bo 
    left join
        t_sel_product p
            on p.id=bo.productId
java.lang.IllegalStateException: aliases expected length is 0; actual length is 16
张哥帮忙看看是什么原因？

30 楼 jacking124 2014-01-14  

jinnianshilongnian 写道

jacking124 写道

张哥，我打开二级查询缓存的时候，

Query query = session.createSQLQuery(querySQL.toString()).setFirstResult(FirstResult)
					.setMaxResults(MaxResults);
			// 打开查询缓存
			query.setCacheable(true);
			spList = query.list();

的时候出现这个错误：
java.lang.IllegalStateException: aliases expected length is 0; actual length is 2
研究了半天，我没有搞明白呀！

你的query贴下 是不是有问题

谢谢，张哥，问题解决的了，就是Query的问题！！

29 楼 kkrgwbj 2014-01-14  

在吗?想请教你个问题.clob类型不能放入二级缓存中.请问有解决方法吗?

28 楼 jinnianshilongnian 2014-01-10  

jacking124 写道

张哥，我打开二级查询缓存的时候，

Query query = session.createSQLQuery(querySQL.toString()).setFirstResult(FirstResult)
					.setMaxResults(MaxResults);
			// 打开查询缓存
			query.setCacheable(true);
			spList = query.list();

的时候出现这个错误：
java.lang.IllegalStateException: aliases expected length is 0; actual length is 2
研究了半天，我没有搞明白呀！

你的query贴下 是不是有问题

27 楼 jacking124 2014-01-10  

张哥，我打开二级查询缓存的时候，

Query query = session.createSQLQuery(querySQL.toString()).setFirstResult(FirstResult)
					.setMaxResults(MaxResults);
			// 打开查询缓存
			query.setCacheable(true);
			spList = query.list();

的时候出现这个错误：
java.lang.IllegalStateException: aliases expected length is 0; actual length is 2
研究了半天，我没有搞明白呀！

26 楼 jinnianshilongnian 2013-06-07  

愛吃小雪生 写道

楼主请问下  我按照你写的这种方式使用二级缓存 好像是用起了，第二次list查询不会有sql，但是不管怎么弄 我使用 System.out.println(sf.getStatistics().getSecondLevelCacheHitCount());  查询缓存命中次数的时候都为0  这是什么原因？而且数据量10w以上的时候比不用缓存还慢  谢谢  求联系 [e-mail]

估计你没有开启二级缓存监控
hibernate.generate_statistics=true


可以参考
https://github.com/zhangkaitao/es/blob/master/web/src/main/resources/spring-config.xml
https://github.com/zhangkaitao/es/blob/master/web/src/main/resources/resources.properties

25 楼 愛吃小雪生 2013-06-07  

楼主请问下  我按照你写的这种方式使用二级缓存 好像是用起了，第二次list查询不会有sql，但是不管怎么弄 我使用 System.out.println(sf.getStatistics().getSecondLevelCacheHitCount());  查询缓存命中次数的时候都为0  这是什么原因？而且数据量10w以上的时候比不用缓存还慢  谢谢  求联系 [e-mail]

24 楼 jinnianshilongnian 2013-01-23  

yeahwell 写道

你好，我想请问你一下，你使用hibernate4.1.2和ehcache2.4.3配置成功了吗？在配置文件中，hibernate.cache.region.factory_class=net.sf.ehcache.hibernate.SingletonEhCacheRegionFactory，这个应该使用什么，我使用org.hibernate.cache.ehcache.EhCacheRegionFactory也不行。求指导

请参考
http://jinnianshilongnian.iteye.com/blog/1423971

23 楼 yeahwell 2013-01-22  

你好，我想请问你一下，你使用hibernate4.1.2和ehcache2.4.3配置成功了吗？在配置文件中，hibernate.cache.region.factory_class=net.sf.ehcache.hibernate.SingletonEhCacheRegionFactory，这个应该使用什么，我使用org.hibernate.cache.ehcache.EhCacheRegionFactory也不行。求指导

22 楼 xujinnan 2012-11-05  

受益匪浅！博主能不能写篇有关延时加载的文章供大家学习一下呢？

21 楼 jinnianshilongnian 2012-07-31  

lucky16 写道

你好，博主。
看了你的博客，觉得你应该对SSH了解的比较透彻，
所以想请教一下，你碰见过在SSH环境下动态添加domain的字段的情况吗？
要求不重启服务器，在web端添加后就可以使用的。
有什么好点的解决方案吗？

为什么要这么做？ 在人少的时候重启不就可以了。

一般服务器都会有reload功能，一般通过重新创建classloader完成，老的classloader不会释放，因此很容易内存溢出。

建议在人少时通过重启解决

20 楼 lucky16 2012-07-31  

你好，博主。
看了你的博客，觉得你应该对SSH了解的比较透彻，
所以想请教一下，你碰见过在SSH环境下动态添加domain的字段的情况吗？
要求不重启服务器，在web端添加后就可以使用的。
有什么好点的解决方案吗？

19 楼 jinnianshilongnian 2012-05-16  

421584397 写道

http://www.verydemo.com/demo/53/70/10571
这里有关于hibernate联级对象缓存文章，写得不错

谢谢 我也看看

18 楼 421584397 2012-05-15  

http://www.verydemo.com/demo/53/70/10571
这里有关于hibernate联级对象缓存文章，写得不错

17 楼 jeffsui 2012-05-15  

3楼,用get方式获得的对象,对应了对象的持久化状态。

16 楼 jinnianshilongnian 2012-05-14  

stevenjohn 写道

stevenjohn 写道

indexs

jinnianshilongnian 写道

stevenjohn 写道

问个问题，如果hibernate的one-to-many，里面如果用list不用set的话。那么
<set name="answerset"  lazy="true"   >
         <key>
          <column name="questionid"></column>
         </key>
          <one-to-many class="com.itcso.crm.pojo.Answerlibrary" />
   </set>


    <list name="answerlibraries" inverse="false" lazy="true" cascade="all" >
         <key>
          <column name="questionid"></column>
         </key>
         <index >
         <column name="indexs"></column>
         </index>
          <one-to-many class="com.itcso.crm.pojo.Answerlibrary" />
        </list >


那么
  <index >
         <column name="indexs"></column>
         </index>
indexs这个字段在数据库里面是怎么设置的，这个如果用mysql的话，不能自动增长，怎么处理一下，这个字段呢？我看网上有人根本没在映射文件hbm.xml里面配置这个字段。

stevenjohn 写道

问个问题，如果hibernate的one-to-many，里面如果用list不用set的话。那么
<set name="answerset"  lazy="true"   >
         <key>
          <column name="questionid"></column>
         </key>
          <one-to-many class="com.itcso.crm.pojo.Answerlibrary" />
   </set>


    <list name="answerlibraries" inverse="false" lazy="true" cascade="all" >
         <key>
          <column name="questionid"></column>
         </key>
         <index >
         <column name="indexs"></column>
         </index>
          <one-to-many class="com.itcso.crm.pojo.Answerlibrary" />
        </list >


那么
  <index >
         <column name="indexs"></column>
         </index>
indexs这个字段在数据库里面是怎么设置的，这个如果用mysql的话，不能自动增长，怎么处理一下，这个字段呢？我看网上有人根本没在映射文件hbm.xml里面配置这个字段。

你用list 会有问题的  主键递增 如100的话  那么集合就需要100个空间  浪费啊 

这个indexs不是主键
CREATE TABLE `employee` (
  `eid` varchar(36) NOT NULL,
  `ename` varchar(50) NOT NULL,
  `did` varchar(36) NOT NULL,
  `indexs` int(11) NOT NULL,
  PRIMARY KEY (`eid`),
  KEY `FK4722E6AEFEA415DC` (`did`),
  CONSTRAINT `FK4722E6AEFEA415DC` FOREIGN KEY (`did`) REFERENCES `department` (`did`)
) ENGINE=InnoDB DEFAULT CHARSET=gbk


CREATE TABLE `department` (
  `did` varchar(36) NOT NULL,
  `dname` varchar(50) NOT NULL,
  PRIMARY KEY (`did`)
) ENGINE=InnoDB DEFAULT CHARSET=gbk

只是一个普通的字段。

还有是不是不推荐使用list，在one-to-many的情况下？

  indexes不需要是索引，，，它映射到list 只是作为索引，，list 在 index比较小而且不重复时可以用用 不过场景我没遇到过

15 楼 stevenjohn 2012-05-14  

stevenjohn 写道

indexs

jinnianshilongnian 写道

stevenjohn 写道

问个问题，如果hibernate的one-to-many，里面如果用list不用set的话。那么
<set name="answerset"  lazy="true"   >
         <key>
          <column name="questionid"></column>
         </key>
          <one-to-many class="com.itcso.crm.pojo.Answerlibrary" />
   </set>


    <list name="answerlibraries" inverse="false" lazy="true" cascade="all" >
         <key>
          <column name="questionid"></column>
         </key>
         <index >
         <column name="indexs"></column>
         </index>
          <one-to-many class="com.itcso.crm.pojo.Answerlibrary" />
        </list >


那么
  <index >
         <column name="indexs"></column>
         </index>
indexs这个字段在数据库里面是怎么设置的，这个如果用mysql的话，不能自动增长，怎么处理一下，这个字段呢？我看网上有人根本没在映射文件hbm.xml里面配置这个字段。

stevenjohn 写道

问个问题，如果hibernate的one-to-many，里面如果用list不用set的话。那么
<set name="answerset"  lazy="true"   >
         <key>
          <column name="questionid"></column>
         </key>
          <one-to-many class="com.itcso.crm.pojo.Answerlibrary" />
   </set>


    <list name="answerlibraries" inverse="false" lazy="true" cascade="all" >
         <key>
          <column name="questionid"></column>
         </key>
         <index >
         <column name="indexs"></column>
         </index>
          <one-to-many class="com.itcso.crm.pojo.Answerlibrary" />
        </list >


那么
  <index >
         <column name="indexs"></column>
         </index>
indexs这个字段在数据库里面是怎么设置的，这个如果用mysql的话，不能自动增长，怎么处理一下，这个字段呢？我看网上有人根本没在映射文件hbm.xml里面配置这个字段。

你用list 会有问题的  主键递增 如100的话  那么集合就需要100个空间  浪费啊 

这个indexs不是主键
CREATE TABLE `employee` (
  `eid` varchar(36) NOT NULL,
  `ename` varchar(50) NOT NULL,
  `did` varchar(36) NOT NULL,
  `indexs` int(11) NOT NULL,
  PRIMARY KEY (`eid`),
  KEY `FK4722E6AEFEA415DC` (`did`),
  CONSTRAINT `FK4722E6AEFEA415DC` FOREIGN KEY (`did`) REFERENCES `department` (`did`)
) ENGINE=InnoDB DEFAULT CHARSET=gbk


CREATE TABLE `department` (
  `did` varchar(36) NOT NULL,
  `dname` varchar(50) NOT NULL,
  PRIMARY KEY (`did`)
) ENGINE=InnoDB DEFAULT CHARSET=gbk

只是一个普通的字段。

还有是不是不推荐使用list，在one-to-many的情况下？

14 楼 stevenjohn 2012-05-14  

indexs

jinnianshilongnian 写道

stevenjohn 写道

问个问题，如果hibernate的one-to-many，里面如果用list不用set的话。那么
<set name="answerset"  lazy="true"   >
         <key>
          <column name="questionid"></column>
         </key>
          <one-to-many class="com.itcso.crm.pojo.Answerlibrary" />
   </set>


    <list name="answerlibraries" inverse="false" lazy="true" cascade="all" >
         <key>
          <column name="questionid"></column>
         </key>
         <index >
         <column name="indexs"></column>
         </index>
          <one-to-many class="com.itcso.crm.pojo.Answerlibrary" />
        </list >


那么
  <index >
         <column name="indexs"></column>
         </index>
indexs这个字段在数据库里面是怎么设置的，这个如果用mysql的话，不能自动增长，怎么处理一下，这个字段呢？我看网上有人根本没在映射文件hbm.xml里面配置这个字段。

stevenjohn 写道

问个问题，如果hibernate的one-to-many，里面如果用list不用set的话。那么
<set name="answerset"  lazy="true"   >
         <key>
          <column name="questionid"></column>
         </key>
          <one-to-many class="com.itcso.crm.pojo.Answerlibrary" />
   </set>


    <list name="answerlibraries" inverse="false" lazy="true" cascade="all" >
         <key>
          <column name="questionid"></column>
         </key>
         <index >
         <column name="indexs"></column>
         </index>
          <one-to-many class="com.itcso.crm.pojo.Answerlibrary" />
        </list >


那么
  <index >
         <column name="indexs"></column>
         </index>
indexs这个字段在数据库里面是怎么设置的，这个如果用mysql的话，不能自动增长，怎么处理一下，这个字段呢？我看网上有人根本没在映射文件hbm.xml里面配置这个字段。

你用list 会有问题的  主键递增 如100的话  那么集合就需要100个空间  浪费啊 

这个indexs不是主键
CREATE TABLE `employee` (
  `eid` varchar(36) NOT NULL,
  `ename` varchar(50) NOT NULL,
  `did` varchar(36) NOT NULL,
  `idx` int(11) NOT NULL,
  PRIMARY KEY (`eid`),
  KEY `FK4722E6AEFEA415DC` (`did`),
  CONSTRAINT `FK4722E6AEFEA415DC` FOREIGN KEY (`did`) REFERENCES `department` (`did`)
) ENGINE=InnoDB DEFAULT CHARSET=gbk


CREATE TABLE `department` (
  `did` varchar(36) NOT NULL,
  `dname` varchar(50) NOT NULL,
  PRIMARY KEY (`did`)
) ENGINE=InnoDB DEFAULT CHARSET=gbk

只是一个普通的字段。

还有是不是不推荐使用list，在one-to-many的情况下？