`
lp895876294
  • 浏览: 284806 次
  • 性别: Icon_minigender_1
  • 来自: 济南
社区版块
存档分类
最新评论

基于Hibernate4.3的JPA缓存

    博客分类:
  • JPA
 
阅读更多
Cache

        缓存(Cache )是计算机领域非常通用的概念。它介于应用程序和永久性数据存储源(如硬盘上的文件或者内存)之间,其作用是降低应用程序直接读写永久性数据存储源的频率,从而提高应用的运行性能。缓存中的数据是数据存储源中数据的拷贝,应用程序在运行时直接读写缓存中的数据,只在某些特定时刻按照缓存中的数据来同步更新数据存储源(JPA中persist方法、merge方法是声明实体的状态,并没有将实体持久化到数据库中,通过自动或手动调用flush才会将数据同步到数据库)。
       缓存的物理介质通常是内存,而永久性数据存储源的物理介质通常是硬盘或磁盘,应用程序读写内存的速度显然比读写硬盘的速度快,如果缓存中存放的数据量非常大,也会用硬盘作为缓存的物理介质。

       需要被缓存的数据:经常被访问、很少被修改并且需要共享访问的数据。

 

一级缓存

       基于Hibernate的JPA一级缓存是由EntityManager提供的,因此它只存在于EntityManager的生命周期中,当程序调用persist、find、getResultList 等方法时,如EntityManager缓存中还不存在相应的对象,JPA会把该对象加入到一级缓存中,当EntityManager关闭的时候该EntityManager所管理的一级缓存也会立即被清除,一级缓存是EntityManager所内置的,不能被卸载,也不能进行任何配置。

 

二级缓存

       基于Hibernate的JPA二级缓存是EntityManagerFactory提供的,能够缓存不同EntityManager中的实体对象。EntityManager查询策略为:首先查询一级缓存(当前EntityManager)中的托管数据,如果找不到查询EntityManagerFactory中缓存的数据,如果仍找不到则进行数据库查询。

 

缓存方式

       read-only:只读模式,在此模式下,如果对数据进行更新操作,会有异常。

       read_write:读写模式在更新缓存的时候会把缓存里面的数据换成一个锁,其它事务如果去取相应的缓存数据,发现被锁了,直接就去数据库查询;如果应用程序需要更新数据,那么使用读/写缓存比较合适。如果应用程序要求“序列化事务”的隔离级别(serializable transaction isolation level),那么就决不能使用这种缓存策略。
       nonstrict read/write如果应用程序只偶尔需要更新数据(也就是说,两个事务同时更新同一记录的情况很不常见),也不需要十分严格的事务隔离。不保证缓存与数据库中数据的一致性,如果存在两个事务同时访问缓存中相同数据的可能,必须为该数据配置一个很短的数据过期时间,从而尽量避免脏读。对于极少被修改,并且允许偶尔脏读的数据,可以采用这种并发访问策略。

      transactional仅仅在事务环境中使用,它提供了Repeatable Read事务隔离级别。对于经常被读但很少修改的数据,可以采用这种隔离类型,因为它可以防止脏读和不可重复读这类的并发问题。

 

缓存配置

配置基于Hibernate的缓存信息

<!-- 产生缓存统计信息 -->
				<entry key="hibernate.generate_statistics" value="true"/>
				<!-- 使用二级缓存 -->
				<entry key="hibernate.cache.use_second_level_cache" value="true" />
            	<entry key="hibernate.cache.use_structured_entries" value ="true" />
            	<!-- 使用查询缓存 -->  
            	<entry key="hibernate.cache.use_query_cache" value="true" /> 
            	<!-- Hibernate4第三方cache --> 
				<entry key="hibernate.cache.region.factory_class" value="org.hibernate.cache.ehcache.EhCacheRegionFactory"/>
				<entry key="net.sf.ehcache.configurationResourceName" value="/ehcache-hibernate-local.xml"/>
hibernate.cache.use_second_level_cache:是否使用二级缓存。二级缓存只能够缓存实体对象,即只能够缓存使用find方法获取的实体对象。

hibernate.cache.use_query_cache:是否启用查询缓存。是针对普通属性结果集的缓存。(没有到验证use_query_cache=true或false时对缓存查询是否有影像。)

hibernate.cache.region.factory_class:第三方的缓存类。

net.sf.ehcache.configurationResourceName:encache查询缓存配置文件。

ehcache-hibernate-local.xml文件内容

<?xml version="1.0" encoding="UTF-8"?>
<ehcache updateCheck="false" name="hibernateCache">
	<diskStore path="java.io.tmpdir/ehcache/jpa" />
	<!-- 使用encache2.6,否则提示不存在属性maxEntriesLocalHeap -->
	<defaultCache maxEntriesLocalHeap="10000" eternal="false" timeToIdleSeconds="300" timeToLiveSeconds="600"
		overflowToDisk="true" maxEntriesLocalDisk="100000" />
	<!-- 也可以单独为某个实体指定配置信息 -->
<!-- 	<cache name="com.projects.jpa.entity.Customer" maxEntriesLocalHeap="1000" eternal="true" -->
<!-- 		overflowToDisk="true" maxEntriesLocalDisk="10000"/> -->
</ehcache>

为需要缓存的实体类配置Hibernate的Cache属性,如果不配置Cache注解,是不对实体进行二级缓存的。

@Cache(usage=CacheConcurrencyStrategy.READ_WRITE)
public class Customer extends BaseEntity {
         ......
}

问题:即使以上都配置了,使用getResultList也不能使用缓存,需要为Query对象明确指定使用缓存如下:

		Query query = entityManager.createQuery("from Customer c") ;
		query.setHint("org.hibernate.cacheable", true);
		List<Customer> list = query.getResultList() ;

      

 

参考文章:http://www.iteye.com/topic/1133637

 

目前在使用spring-data-jpa和hibernate4的时候,对于缓存关系不是很清楚,以及二级缓存和查询缓存的各种配置等等,于是就有了这篇初级的jpa+hibernate缓存配置使用的文章。


JPA和hibernate的缓存关系,以及系统demo环境说明

JPA全称是:Java Persistence API

引用
JPA itself is just a specification, not a product; it cannot perform persistence or anything else by itself.

JPA仅仅只是一个规范,而不是产品;使用JPA本身是不能做到持久化的。


所以,JPA只是一系列定义好的持久化操作的接口,在系统中使用时,需要真正的实现者,在这里,我们使用Hibernate作为实现者。所以,还是用spring-data-jpa+hibernate4+spring3.2来做demo例子说明本文。


JPA规范中定义了很多的缓存类型:一级缓存,二级缓存,对象缓存,数据缓存,等等一系列概念,搞的人糊里糊涂,具体见这里:
http://en.wikibooks.org/wiki/Java_Persistence/Caching

不过缓存也必须要有实现,因为使用的是hibernate,所以基本只讨论hibernate提供的缓存实现。

很多其他的JPA实现者,比如toplink(EclipseLink),也许还有其他的各种缓存实现,在此就不说了。



先直接给出所有的demo例子

hibernate实现中只有三种缓存类型:

一级缓存,二级缓存和查询缓存。

在hibernate的实现概念里,他把什么集合缓存之类的统一放到二级缓存里去了。


1. 一级缓存测试:

文件配置:

Java代码  收藏代码
  1. <bean id="entityManagerFactory"  
  2.     class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">  
  3.     <property name="dataSource" ref="dataSource" />  
  4.     <property name="jpaVendorAdapter" ref="hibernateJpaVendorAdapter" />  
  5.     <property name="packagesToScan" value="com.restjplat.quickweb" />  
  6.     <property name="jpaProperties">  
  7.         <props>  
  8.             <prop key="hibernate.show_sql">${hibernate.show_sql}</prop>  
  9.             <prop key="hibernate.format_sql">true</prop>  
  10.         </props>  
  11.     </property>  
  12. </bean>  


可见没有添加任何配置项。

Java代码  收藏代码
  1. private void firstCacheTest(){    
  2.     EntityManager em = emf.createEntityManager();  
  3.     Dict d1 = em.find(Dict.class1); //find id为1的对象  
  4.     Dict d2 = em.find(Dict.class1); //find id为1的对象  
  5.     logger.info((d1==d2)+""); //true  
  6.   
  7.     EntityManager em1 = emf.createEntityManager();  
  8.     Dict d3 = em1.find(Dict.class1); //find id为1的对象  
  9.     EntityManager em2 = emf.createEntityManager();  
  10.     Dict d4 = em2.find(Dict.class1); //find id为1的对象  
  11.     logger.info((d3==d4)+""); //false  
  12. }  


Java代码  收藏代码
  1. 输出为:因为sql语句打出来太长,所以用*号代替  
  2. Hibernate: ***********  
  3. 2014-03-17 20:41:44,819  INFO [main] (DictTest.java:76) - true  
  4. Hibernate: ***********  
  5. Hibernate: ***********  
  6. 2014-03-17 20:41:44,869  INFO [main] (DictTest.java:84) - false  


由此可见:同一个session内部,一级缓存生效,同一个id的对象只有一个。不同session,一级缓存无效。

2. 二级缓存测试:

文件配置:

1:实体类直接打上 javax.persistence.Cacheable 标记。
Java代码  收藏代码
  1. @Entity  
  2. @Table(name ="dict")  
  3. @Cacheable  
  4. public class Dict extends IdEntity{}  


2:配置文件修改,在 jpaProperties 下添加,用ehcache来实现二级缓存,另外因为加入了二级缓存,我们将hibernate的统计打开来看看到底是不是被缓存了。
Java代码  收藏代码
  1. <prop key="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</prop>  
  2. <prop key="javax.persistence.sharedCache.mode">ENABLE_SELECTIVE</prop>  
  3. <prop key="hibernate.generate_statistics">true</prop>  


注1:如果在配置文件中加入了
<prop key="javax.persistence.sharedCache.mode">ENABLE_SELECTIVE</prop& gt;,则不需要在实体内配置hibernate的 @cache标记,只要打上JPA的@cacheable标记即可默认开启该实体的2级缓存。

注2:如果不使用javax.persistence.sharedCache.mode配置,直接在实体内打@cache标记也可以。

Java代码  收藏代码
  1. @Cache(usage = CacheConcurrencyStrategy.READ_ONLY)  
  2. public class Dict extends IdEntity{}  


至于 hibernate的 hibernate.cache.use_second_level_cache这个属性,文档里是这么写的:
引用
Can be used to completely disable the second level cache, which is enabled by default for classes which specify a <cache> mapping.

即打上只要有@cache标记,自动开启。

所以有两种方法配置开启二级缓存:

第一种不使用hibernate的@cache标记,直接用@cacheable标记和缓存映射配置项。

第二种用hibernate的@cache标记使用。



另外javax.persistence.sharedCache.mode的其他配置如下:

The javax.persistence.sharedCache.mode property can be set to one of the following values:
    • ENABLE_SELECTIVE (Default and recommended value): entities are not cached unless explicitly marked as cacheable.
    • DISABLE_SELECTIVE: entities are cached unless explicitly marked as not cacheable.
    • NONE: no entity are cached even if marked as cacheable. This option can make sense to disable second-level cache altogether.
    • ALL: all entities are always cached even if marked as non cacheable.
如果用all的话,连实体上的@cacheable都不用打,直接默认全部开启二级缓存

测试代码:

Java代码  收藏代码
  1. private void secondCachetest(){  
  2.         EntityManager em1 = emf.createEntityManager();  
  3.         Dict d1 = em1.find(Dict.class1); //find id为1的对象  
  4.         logger.info(d1.getName());  
  5.         em1.close();  
  6.           
  7.         EntityManager em2 = emf.createEntityManager();  
  8.         Dict d2 = em2.find(Dict.class1); //find id为1的对象  
  9.         logger.info(d2.getName());  
  10.         em2.close();  
  11.     }  

输出:
Java代码  收藏代码
  1. Hibernate: **************  
  2. a  
  3. a  
  4. ===================L2======================  
  5. com.restjplat.quickweb.model.Dict : 1  


可见二级缓存生效了,只输出了一条sql语句,同时监控中也出现了数据。

另外也可以看看如果是配置成ALL,并且把@cacheable删掉,输出如下:

Java代码  收藏代码
  1. Hibernate: ************  
  2. a  
  3. a  
  4. ===================L2======================  
  5. com.restjplat.quickweb.model.Children : 0  
  6. com.restjplat.quickweb.model.Dict : 1  
  7. org.hibernate.cache.spi.UpdateTimestampsCache : 0  
  8. org.hibernate.cache.internal.StandardQueryCache : 0  
  9. com.restjplat.quickweb.model.Parent : 0  
  10. =================query cache=================  


并且可以看见,所有的实体类都加入二级缓存中去了


3. 查询缓存测试:

一,二级缓存都是根据对象id来查找,如果需要加载一个List的时候,就需要用到查询缓存。

在Spring-data-jpa实现中,也可以使用查询缓存。

文件配置:
在 jpaProperties 下添加,这里必须明确标出增加查询缓存。
Java代码  收藏代码
  1. <prop key="hibernate.cache.use_query_cache">true</prop>  


然后需要在方法内打上@QueryHint来实现查询缓存,我们写几个方法来测试如下:

Java代码  收藏代码
  1. public interface DictDao extends JpaRepository<Dict, Integer>,JpaSpecificationExecutor<Dict>{  
  2.   
  3.     // spring-data-jpa默认继承实现的一些方法,实现类为  
  4.     // SimpleJpaRepository。  
  5.     // 该类中的方法不能通过@QueryHint来实现查询缓存。  
  6.     @QueryHints({ @QueryHint(name = "org.hibernate.cacheable", value ="true") })  
  7.     List<Dict> findAll();  
  8.       
  9.     @Query("from Dict")  
  10.     @QueryHints({ @QueryHint(name = "org.hibernate.cacheable", value ="true") })  
  11.     List<Dict> findAllCached();  
  12.       
  13.     @Query("select t from Dict t where t.name = ?1")  
  14.     @QueryHints({ @QueryHint(name = "org.hibernate.cacheable", value ="true") })  
  15.     Dict findDictByName(String name);  
  16. }  


测试方法
Java代码  收藏代码
  1. private void QueryCacheTest(){  
  2.         //无效的spring-data-jpa实现的接口方法  
  3.         //输出两条sql语句  
  4.         dao.findAll();  
  5.         dao.findAll();  
  6.         System.out.println("================test 1 finish======================");  
  7.         //自己实现的dao方法可以被查询缓存  
  8.         //输出一条sql语句  
  9.         dao.findAllCached();  
  10.         dao.findAllCached();  
  11.         System.out.println("================test 2 finish======================");  
  12.         //自己实现的dao方法可以被查询缓存  
  13.         //输出一条sql语句  
  14.         dao.findDictByName("a");  
  15.         dao.findDictByName("a");  
  16.         System.out.println("================test 3 finish======================");  
  17.     }  


输出结果:
Java代码  收藏代码
  1. Hibernate: **************  
  2. Hibernate: **************  
  3. ================test 1 finish======================  
  4. Hibernate: ***********  
  5. ================test 2 finish======================  
  6. Hibernate: ***********  
  7. ================test 3 finish======================  
  8. ===================L2======================  
  9. com.restjplat.quickweb.model.Dict : 5  
  10. org.hibernate.cache.spi.UpdateTimestampsCache : 0  
  11. org.hibernate.cache.internal.StandardQueryCache : 2  
  12. =================query cache=================  
  13. select t from Dict t where t.name = ?1  
  14. select generatedAlias0 from Dict as generatedAlias0  
  15. from Dict  


很明显,查询缓存生效。但是为什么第一种方法查询缓存无法生效,原因不明,只能后面看看源代码了。

4.集合缓存测试:

根据hibernate文档的写法,这个应该是算在2级缓存里面。

测试类:
Java代码  收藏代码
  1. @Entity  
  2. @Table(name ="parent")  
  3. @Cacheable  
  4. public class Parent extends IdEntity {  
  5.       
  6.     private static final long serialVersionUID = 1L;  
  7.     private String name;  
  8.     private List<Children> clist;  
  9.       
  10.     public String getName() {  
  11.         return name;  
  12.     }  
  13.     public void setName(String name) {  
  14.         this.name = name;  
  15.     }  
  16.       
  17.     @OneToMany(fetch = FetchType.EAGER,mappedBy = "parent")  
  18.         @Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)  
  19.     public List<Children> getClist() {  
  20.         return clist;  
  21.     }  
  22.     public void setClist(List<Children> clist) {  
  23.         this.clist = clist;  
  24.     }  
  25. }  
  26.   
  27. @Entity  
  28. @Table(name ="children")  
  29. @Cacheable  
  30. public class Children extends IdEntity{  
  31.   
  32.     private static final long serialVersionUID = 1L;  
  33.     private String name;  
  34.     private Parent parent;  
  35.       
  36.     @ManyToOne(fetch = FetchType.LAZY)  
  37.     @JoinColumn(name = "parent_id")  
  38.     public Parent getParent() {  
  39.         return parent;  
  40.     }  
  41.   
  42.     public void setParent(Parent parent) {  
  43.         this.parent = parent;  
  44.     }  
  45.   
  46.     public String getName() {  
  47.         return name;  
  48.     }  
  49.   
  50.     public void setName(String name) {  
  51.         this.name = name;  
  52.     }     
  53. }  


测试方法:
Java代码  收藏代码
  1. private void cellectionCacheTest(){  
  2.         EntityManager em1 = emf.createEntityManager();  
  3.         Parent p1 = em1.find(Parent.class1);  
  4.         List<Children> c1 = p1.getClist();  
  5.         em1.close();  
  6.         System.out.println(p1.getName()+" ");  
  7.         for (Children children : c1) {  
  8.             System.out.print(children.getName()+",");  
  9.         }  
  10.         System.out.println();  
  11.         EntityManager em2 = emf.createEntityManager();  
  12.         Parent p2 = em2.find(Parent.class1);  
  13.         List<Children> c2 = p2.getClist();  
  14.         em2.close();  
  15.         System.out.println(p2.getName()+" ");  
  16.         for (Children children : c2) {  
  17.             System.out.print(children.getName()+",");  
  18.         }  
  19.         System.out.println();  
  20.     }  


输出:
Java代码  收藏代码
  1. Hibernate: ********************  
  2. Michael   
  3. kate,Jam,Jason,Brain,  
  4. Michael   
  5. kate,Jam,Jason,Brain,  
  6. ===================L2======================  
  7. com.restjplat.quickweb.model.Children : 4  
  8. com.restjplat.quickweb.model.Dict : 0  
  9. org.hibernate.cache.spi.UpdateTimestampsCache : 0  
  10. com.restjplat.quickweb.model.Parent.clist : 1  
  11. org.hibernate.cache.internal.StandardQueryCache : 0  
  12. com.restjplat.quickweb.model.Parent : 1  
  13. =================query cache=================  


在统计数据里可见二级缓存的对象数量。

本文我们不讨论关于缓存的更新策略,脏数据等等的东西,只是讲解配置方式。


接下来是源代码篇

理清楚各种配置以后,我们来看一下hibernate和spring-data-jpa的一些缓存实现源代码。

上面有个遗留问题,为什么spring-data-jpa默认实现的findAll()方法无法保存到查询缓存?只能啃源代码了。

打断点跟踪吧

入口方法是spring-data-jpa里的 SimpleJpaRepository类

Java代码  收藏代码
  1. public List<T> findAll() {  
  2.         return getQuery(null, (Sort) null).getResultList();  
  3.     }  
  4.   
  5. 然后到 QueryImpl<X>类的  
  6. private List<X> list() {  
  7.         if (getEntityGraphQueryHint() != null) {  
  8.             SessionImplementor sessionImpl = (SessionImplementor) getEntityManager().getSession();  
  9.             HQLQueryPlan entityGraphQueryPlan = new HQLQueryPlan( getHibernateQuery().getQueryString(), false,  
  10.                     sessionImpl.getEnabledFilters(), sessionImpl.getFactory(), getEntityGraphQueryHint() );  
  11.             // Safe to assume QueryImpl at this point.  
  12.             unwrap( org.hibernate.internal.QueryImpl.class ).setQueryPlan( entityGraphQueryPlan );  
  13.         }  
  14.         return query.list();  
  15.     }  
  16.   
  17. 进入query.list();  
  18.   
  19. query类的代码解析google一下很多,于是直接到最后:  
  20.   
  21. 进入QueryLoader的list方法。  
  22.   
  23. protected List list(  
  24.             final SessionImplementor session,  
  25.             final QueryParameters queryParameters,  
  26.             final Set<Serializable> querySpaces,  
  27.             final Type[] resultTypes) throws HibernateException {  
  28.   
  29.         final boolean cacheable = factory.getSettings().isQueryCacheEnabled() &&  
  30.             queryParameters.isCacheable();  
  31.   
  32.         if ( cacheable ) {  
  33.             return listUsingQueryCache( session, queryParameters, querySpaces, resultTypes );  
  34.         }  
  35.         else {  
  36.             return listIgnoreQueryCache( session, queryParameters );  
  37.         }  
  38.     }  


果然有个cacheable,值为false,说明的确是没有从缓存里取数据。

用自定义的jpa查询方法测试后发现,这个值为true。

于是接着看cacheable的取值过程:

Java代码  收藏代码
  1. final boolean cacheable = factory.getSettings().isQueryCacheEnabled() &&  
  2.             queryParameters.isCacheable();  


factory.getSettings().isQueryCacheEnabled() 这个一定是true,因为是在配置文件中打开的。那只能是queryParameters.isCacheable() 这个的问题了。

Java代码  收藏代码
  1. 在query.list()的方法内部:  
  2.   
  3. public List list() throws HibernateException {  
  4.         verifyParameters();  
  5.         Map namedParams = getNamedParams();  
  6.         before();  
  7.         try {  
  8.             return getSession().list(  
  9.                     expandParameterLists(namedParams),  
  10.                     getQueryParameters(namedParams)  
  11.                 );  
  12.         }  
  13.         finally {  
  14.             after();  
  15.         }  
  16.     }  
  17.   
  18. getQueryParameters(namedParams)这个方法实际获取的是query对象的cacheable属性的值,也就是说,query对象新建的时候cacheable的值决定了这个query方法能不能被查询缓存。  


接下来query的建立过程:

Java代码  收藏代码
  1. 在 SimpleJpaRepository 类中 return applyLockMode(em.createQuery(query));  
  2.   
  3. 直接由emcreate,再跟踪到 AbstractEntityManagerImpl中  
  4.   
  5. @Override  
  6.     public <T> QueryImpl<T> createQuery(  
  7.             String jpaqlString,  
  8.             Class<T> resultClass,  
  9.             Selection selection,  
  10.             QueryOptions queryOptions) {  
  11.         try {  
  12.             org.hibernate.Query hqlQuery = internalGetSession().createQuery( jpaqlString );  
  13.   
  14.             ....  
  15.             return new QueryImpl<T>( hqlQuery, this, queryOptions.getNamedParameterExplicitTypes() );  
  16.         }  
  17.         catch ( RuntimeException e ) {  
  18.             throw convert( e );  
  19.         }  
  20.     }  
  21. 即通过session.createQuery(jpaqlString ) 创建初始化对象。  
  22.   
  23. 在query类定义中  
  24. public abstract class AbstractQueryImpl implements Query {  
  25.   
  26.         private boolean cacheable;  
  27. }  
  28. cacheable不是对象类型,而是基本类型,所以不赋值的情况下默认为“false”。  


也就是说spring-data-jpa接口提供的简单快速的各种接口实现全是不能使用查询缓存的,完全不知道为什么这么设计。

接下来看看我们自己实现的查询方法实现:

直接找到query方法的setCacheable()方法打断点,因为肯定改变这个值才能有查询缓存。


Java代码  收藏代码
  1. 于是跟踪到 SimpleJpaQuery类中  
  2. protected Query createQuery(Object[] values) {  
  3.         return applyLockMode(applyHints(doCreateQuery(values), method), method);  
  4. }  


在返回query的过程中通过applyHints()方法读取了方法上的QueryHint注解从而设置了查询缓存。
分享到:
评论

相关推荐

    JPA_Hibernate 4.3 jar包

    总之,`JPA_Hibernate 4.3 jar包`是为Java开发者提供了一个完整的解决方案,以JPA标准的方式利用Hibernate进行数据持久化操作。通过合理配置和使用,可以在保证代码的可维护性的同时,提高数据库操作的效率和便捷性...

    springmvc4_hibernate4.3_JPA2.1_Shiro1.2_Ehcache

    spring4.04,springmvc, hibernate4.3 ,JPA2.1, shiro1.2, ehcache2 完全整合,用Ehcache做缓存,通用的DAO、Service接口和实现。完全注解配置,事务拦截方式处理。C0p3做连接池,JSP和Freemarker做View的模板。Shiro...

    Struts2.3+Spring4.0+hibernate4.3

    Struts2.3、Spring4.0和Hibernate4.3是经典的Java Web开发框架组合,被称为SSH2(Struts2、Spring、Hibernate第二版)。这个组合在过去的许多年里被广泛应用,提供了强大的功能来构建企业级应用。下面将详细介绍这三...

    struts2.3.16+spring4+hibernate4.3 包整合

    Hibernate4.3版本引入了一些新特性,如JPA 2.1支持、二进制数据类型增强、以及对Java 8日期和时间API的支持。它通过HQL(Hibernate查询语言)简化了数据库查询,并提供了缓存机制以提高性能。 **SSH整合** 涉及到这...

    hibernate开发包

    8. **第二级缓存**:Hibernate 4.3支持缓存策略,第二级缓存可以提高性能,通过SessionFactory配置,可选择实现如Ehcache的缓存提供者。 9. **事务管理**:Hibernate支持JTA(Java Transaction API)和JDBC事务管理...

    Hibernate 手册中文版chm格式

    4. Criteria查询:提供了一种基于对象的查询方式,比HQL更动态、更灵活。 5. Criteria API和DetachedCriteria:进一步深入,探讨如何使用Criteria API执行复杂的查询,并介绍DetachedCriteria,用于在不同会话间...

    hibernate-4.3.9(最新稳定版)(jar)

    此外,4.3.9版本的Hibernate强化了对多线程和并发场景的支持,通过优化内部的锁定机制和缓存策略,提高了在高并发环境下的系统稳定性和响应速度。它还修复了若干已知的bug,确保了框架的健壮性。 在这个版本中,...

    springmvc4+spring4+hibernate5.1.3+二级缓存ehcache+fastjson配置

    在本配置中,Hibernate版本为5.1.3,支持JPA规范,提供了二级缓存功能,提高了数据访问性能。 4. **二级缓存(Ehcache)**: Ehcache是Hibernate的一个可选二级缓存插件,用于存储数据库查询结果,减少对数据库的...

    hibernate-orm-4.3.zip

    在Hibernate 4.3版本中,它进一步优化了性能,增强了对JPA(Java Persistence API)的支持,并引入了一些新的特性。 二、源码结构分析 解压后的“hibernate-orm-4.3”文件夹包含了Hibernate ORM的全部源代码,主要...

    springmvc框架所需的jar包下载

    在Hibernate4.3中,引入了对JPA 2.1的支持,增强了性能和可伸缩性,支持延迟加载、缓存策略和事务管理。在Spring MVC中,可以通过Spring的HibernateTemplate或HibernateJpaTemplate进行集成,实现数据持久化。 3. *...

    springMVC做的小项目,可作为springMVC入门教材

    总结,这个项目提供了一个很好的学习平台,通过 SpringMVC、Spring 4.2 和 Hibernate 4.3 的集成,展示了如何构建一个现代的、基于注解的 Java Web 应用程序。对于初学者来说,了解并实践这个项目,可以深入理解 MVC...

    hibernate4.3.11

    2. 配置文件:`hibernate.cfg.xml`是Hibernate的核心配置文件,包含数据库连接、方言选择、缓存策略等关键设置。 3. 实体类注解:通过@Entity、@Table、@Column等注解,可以快速定义Java类与数据库表的映射关系。 ...

    SpringMVC+hibernate+spring+shiro+Ehcache所需jar包

    这个压缩包"SpringMVC+hibernate+spring+shiro+Ehcache所需jar包"提供了搭建基于SpringMVC、Spring 4.2、Hibernate 4.3、Shiro 1.2.4和Ehcache 2.0的基础组件,这些都是Java开发中非常流行和实用的工具。接下来,...

    hibernate-release-4.3.5

    `hibernate-entitymanager.jar`则提供了JPA(Java Persistence API)的支持,使得开发者可以使用标准的JPA接口进行操作。此外,`hibernate-validator.jar`用于实现JSR-303/JSR-349数据验证,确保输入数据的合法性。...

    persistence.xml:用于Hibernate-JAVA项目的persistence.xml

    3. `&lt;properties&gt;`:这部分用于设置JPA或Hibernate的特定属性,如数据库连接URL、用户名、密码、方言、缓存策略等。例如,`hibernate.dialect`用于指定数据库方言,`hibernate.show_sql`控制是否打印SQL语句。 4. `...

    hibernate4.3.10 jar

    这个版本引入了新的特性,如查询缓存改进,性能优化以及对JPA 2.1的支持。 2. **Javassist库**:`javassist-3.18.1-GA.jar`是Hibernate用来动态生成和修改字节码的工具,使ORM框架能够无须预编译就能处理类,极大地...

    黑马程序员_hibernate框架开发2016版讲义和笔记资料_day1_day2_day3_day4

    1.2 Hibernate概述:Hibernate是Java领域中最受欢迎的ORM框架之一,它支持JPA规范,提供了丰富的API和工具,能够处理复杂的数据库交互。 二、Hibernate的安装与配置 2.1 安装:添加Hibernate的JAR包到项目类路径中...

    Spring4.3.17jar包压缩包

    1. **spring-orm-4.3.17.RELEASE.jar**:这个模块提供了与Object/Relational Mapping (ORM)框架如Hibernate、JPA等集成的支持。它使得Spring可以与这些ORM工具无缝配合,实现数据持久化。 2. **spring-jdbc-4.3.17....

    hibernate 4.3.10.Final

    3.4 Cache:Hibernate的缓存机制包括一级缓存(Session级别的)和二级缓存(SessionFactory级别的),能够有效减少对数据库的访问,提高系统性能。 四、实战应用 4.1 实体类和映射文件:开发者需定义Java实体类,...

    hibernate-release-4.3.11.Final.zip

    总结,"hibernate-release-4.3.11.Final.zip"压缩包是Hibernate 4.3.11版本的完整资源,对于学习和开发基于Hibernate的应用程序提供了全面的支持。通过掌握Hibernate的核心概念和技术,开发者可以更好地利用ORM技术...

Global site tag (gtag.js) - Google Analytics