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仅仅只是一个规范,而不是产品;使用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. 一级缓存测试:
文件配置:
- <bean id="entityManagerFactory"
- class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
- <property name="dataSource" ref="dataSource" />
- <property name="jpaVendorAdapter" ref="hibernateJpaVendorAdapter" />
- <property name="packagesToScan" value="com.restjplat.quickweb" />
- <property name="jpaProperties">
- <props>
- <prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
- <prop key="hibernate.format_sql">true</prop>
- </props>
- </property>
- </bean>
可见没有添加任何配置项。
- private void firstCacheTest(){
- EntityManager em = emf.createEntityManager();
- Dict d1 = em.find(Dict.class, 1); //find id为1的对象
- Dict d2 = em.find(Dict.class, 1); //find id为1的对象
- logger.info((d1==d2)+""); //true
- EntityManager em1 = emf.createEntityManager();
- Dict d3 = em1.find(Dict.class, 1); //find id为1的对象
- EntityManager em2 = emf.createEntityManager();
- Dict d4 = em2.find(Dict.class, 1); //find id为1的对象
- logger.info((d3==d4)+""); //false
- }
- 输出为:因为sql语句打出来太长,所以用*号代替
- Hibernate: ***********
- 2014-03-17 20:41:44,819 INFO [main] (DictTest.java:76) - true
- Hibernate: ***********
- Hibernate: ***********
- 2014-03-17 20:41:44,869 INFO [main] (DictTest.java:84) - false
由此可见:同一个session内部,一级缓存生效,同一个id的对象只有一个。不同session,一级缓存无效。
2. 二级缓存测试:
文件配置:
1:实体类直接打上 javax.persistence.Cacheable 标记。
- @Entity
- @Table(name ="dict")
- @Cacheable
- public class Dict extends IdEntity{}
2:配置文件修改,在 jpaProperties 下添加,用ehcache来实现二级缓存,另外因为加入了二级缓存,我们将hibernate的统计打开来看看到底是不是被缓存了。
- <prop key="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</prop>
- <prop key="javax.persistence.sharedCache.mode">ENABLE_SELECTIVE</prop>
- <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标记也可以。
- @Cache(usage = CacheConcurrencyStrategy.READ_ONLY)
- public class Dict extends IdEntity{}
至于 hibernate的 hibernate.cache.use_second_level_cache这个属性,文档里是这么写的:
即打上只要有@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.
测试代码:
- private void secondCachetest(){
- EntityManager em1 = emf.createEntityManager();
- Dict d1 = em1.find(Dict.class, 1); //find id为1的对象
- logger.info(d1.getName());
- em1.close();
- EntityManager em2 = emf.createEntityManager();
- Dict d2 = em2.find(Dict.class, 1); //find id为1的对象
- logger.info(d2.getName());
- em2.close();
- }
输出:
- Hibernate: **************
- a
- a
- ===================L2======================
- com.restjplat.quickweb.model.Dict : 1
可见二级缓存生效了,只输出了一条sql语句,同时监控中也出现了数据。
另外也可以看看如果是配置成ALL,并且把@cacheable删掉,输出如下:
- Hibernate: ************
- a
- a
- ===================L2======================
- com.restjplat.quickweb.model.Children : 0
- com.restjplat.quickweb.model.Dict : 1
- org.hibernate.cache.spi.UpdateTimestampsCache : 0
- org.hibernate.cache.internal.StandardQueryCache : 0
- com.restjplat.quickweb.model.Parent : 0
- =================query cache=================
并且可以看见,所有的实体类都加入二级缓存中去了
3. 查询缓存测试:
一,二级缓存都是根据对象id来查找,如果需要加载一个List的时候,就需要用到查询缓存。
在Spring-data-jpa实现中,也可以使用查询缓存。
文件配置:
在 jpaProperties 下添加,这里必须明确标出增加查询缓存。
- <prop key="hibernate.cache.use_query_cache">true</prop>
然后需要在方法内打上@QueryHint来实现查询缓存,我们写几个方法来测试如下:
- public interface DictDao extends JpaRepository<Dict, Integer>,JpaSpecificationExecutor<Dict>{
- // spring-data-jpa默认继承实现的一些方法,实现类为
- // SimpleJpaRepository。
- // 该类中的方法不能通过@QueryHint来实现查询缓存。
- @QueryHints({ @QueryHint(name = "org.hibernate.cacheable", value ="true") })
- List<Dict> findAll();
- @Query("from Dict")
- @QueryHints({ @QueryHint(name = "org.hibernate.cacheable", value ="true") })
- List<Dict> findAllCached();
- @Query("select t from Dict t where t.name = ?1")
- @QueryHints({ @QueryHint(name = "org.hibernate.cacheable", value ="true") })
- Dict findDictByName(String name);
- }
测试方法
- private void QueryCacheTest(){
- //无效的spring-data-jpa实现的接口方法
- //输出两条sql语句
- dao.findAll();
- dao.findAll();
- System.out.println("================test 1 finish======================");
- //自己实现的dao方法可以被查询缓存
- //输出一条sql语句
- dao.findAllCached();
- dao.findAllCached();
- System.out.println("================test 2 finish======================");
- //自己实现的dao方法可以被查询缓存
- //输出一条sql语句
- dao.findDictByName("a");
- dao.findDictByName("a");
- System.out.println("================test 3 finish======================");
- }
输出结果:
- Hibernate: **************
- Hibernate: **************
- ================test 1 finish======================
- Hibernate: ***********
- ================test 2 finish======================
- Hibernate: ***********
- ================test 3 finish======================
- ===================L2======================
- com.restjplat.quickweb.model.Dict : 5
- org.hibernate.cache.spi.UpdateTimestampsCache : 0
- org.hibernate.cache.internal.StandardQueryCache : 2
- =================query cache=================
- select t from Dict t where t.name = ?1
- select generatedAlias0 from Dict as generatedAlias0
- from Dict
很明显,查询缓存生效。但是为什么第一种方法查询缓存无法生效,原因不明,只能后面看看源代码了。
4.集合缓存测试:
根据hibernate文档的写法,这个应该是算在2级缓存里面。
测试类:
- @Entity
- @Table(name ="parent")
- @Cacheable
- public class Parent extends IdEntity {
- private static final long serialVersionUID = 1L;
- private String name;
- private List<Children> clist;
- public String getName() {
- return name;
- }
- public void setName(String name) {
- this.name = name;
- }
- @OneToMany(fetch = FetchType.EAGER,mappedBy = "parent")
- @Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
- public List<Children> getClist() {
- return clist;
- }
- public void setClist(List<Children> clist) {
- this.clist = clist;
- }
- }
- @Entity
- @Table(name ="children")
- @Cacheable
- public class Children extends IdEntity{
- private static final long serialVersionUID = 1L;
- private String name;
- private Parent parent;
- @ManyToOne(fetch = FetchType.LAZY)
- @JoinColumn(name = "parent_id")
- public Parent getParent() {
- return parent;
- }
- public void setParent(Parent parent) {
- this.parent = parent;
- }
- public String getName() {
- return name;
- }
- public void setName(String name) {
- this.name = name;
- }
- }
测试方法:
- private void cellectionCacheTest(){
- EntityManager em1 = emf.createEntityManager();
- Parent p1 = em1.find(Parent.class, 1);
- List<Children> c1 = p1.getClist();
- em1.close();
- System.out.println(p1.getName()+" ");
- for (Children children : c1) {
- System.out.print(children.getName()+",");
- }
- System.out.println();
- EntityManager em2 = emf.createEntityManager();
- Parent p2 = em2.find(Parent.class, 1);
- List<Children> c2 = p2.getClist();
- em2.close();
- System.out.println(p2.getName()+" ");
- for (Children children : c2) {
- System.out.print(children.getName()+",");
- }
- System.out.println();
- }
输出:
- Hibernate: ********************
- Michael
- kate,Jam,Jason,Brain,
- Michael
- kate,Jam,Jason,Brain,
- ===================L2======================
- com.restjplat.quickweb.model.Children : 4
- com.restjplat.quickweb.model.Dict : 0
- org.hibernate.cache.spi.UpdateTimestampsCache : 0
- com.restjplat.quickweb.model.Parent.clist : 1
- org.hibernate.cache.internal.StandardQueryCache : 0
- com.restjplat.quickweb.model.Parent : 1
- =================query cache=================
在统计数据里可见二级缓存的对象数量。
本文我们不讨论关于缓存的更新策略,脏数据等等的东西,只是讲解配置方式。
接下来是源代码篇
理清楚各种配置以后,我们来看一下hibernate和spring-data-jpa的一些缓存实现源代码。
上面有个遗留问题,为什么spring-data-jpa默认实现的findAll()方法无法保存到查询缓存?只能啃源代码了。
打断点跟踪吧
入口方法是spring-data-jpa里的 SimpleJpaRepository类
- public List<T> findAll() {
- return getQuery(null, (Sort) null).getResultList();
- }
- 然后到 QueryImpl<X>类的
- private List<X> list() {
- if (getEntityGraphQueryHint() != null) {
- SessionImplementor sessionImpl = (SessionImplementor) getEntityManager().getSession();
- HQLQueryPlan entityGraphQueryPlan = new HQLQueryPlan( getHibernateQuery().getQueryString(), false,
- sessionImpl.getEnabledFilters(), sessionImpl.getFactory(), getEntityGraphQueryHint() );
- // Safe to assume QueryImpl at this point.
- unwrap( org.hibernate.internal.QueryImpl.class ).setQueryPlan( entityGraphQueryPlan );
- }
- return query.list();
- }
- 进入query.list();
- query类的代码解析google一下很多,于是直接到最后:
- 进入QueryLoader的list方法。
- protected List list(
- final SessionImplementor session,
- final QueryParameters queryParameters,
- final Set<Serializable> querySpaces,
- final Type[] resultTypes) throws HibernateException {
- final boolean cacheable = factory.getSettings().isQueryCacheEnabled() &&
- queryParameters.isCacheable();
- if ( cacheable ) {
- return listUsingQueryCache( session, queryParameters, querySpaces, resultTypes );
- }
- else {
- return listIgnoreQueryCache( session, queryParameters );
- }
- }
果然有个cacheable,值为false,说明的确是没有从缓存里取数据。
用自定义的jpa查询方法测试后发现,这个值为true。
于是接着看cacheable的取值过程:
- final boolean cacheable = factory.getSettings().isQueryCacheEnabled() &&
- queryParameters.isCacheable();
factory.getSettings().isQueryCacheEnabled() 这个一定是true,因为是在配置文件中打开的。那只能是queryParameters.isCacheable() 这个的问题了。
- 在query.list()的方法内部:
- public List list() throws HibernateException {
- verifyParameters();
- Map namedParams = getNamedParams();
- before();
- try {
- return getSession().list(
- expandParameterLists(namedParams),
- getQueryParameters(namedParams)
- );
- }
- finally {
- after();
- }
- }
- getQueryParameters(namedParams)这个方法实际获取的是query对象的cacheable属性的值,也就是说,query对象新建的时候cacheable的值决定了这个query方法能不能被查询缓存。
接下来query的建立过程:
- 在 SimpleJpaRepository 类中 return applyLockMode(em.createQuery(query));
- 直接由emcreate,再跟踪到 AbstractEntityManagerImpl中
- @Override
- public <T> QueryImpl<T> createQuery(
- String jpaqlString,
- Class<T> resultClass,
- Selection selection,
- QueryOptions queryOptions) {
- try {
- org.hibernate.Query hqlQuery = internalGetSession().createQuery( jpaqlString );
- ....
- return new QueryImpl<T>( hqlQuery, this, queryOptions.getNamedParameterExplicitTypes() );
- }
- catch ( RuntimeException e ) {
- throw convert( e );
- }
- }
- 即通过session.createQuery(jpaqlString ) 创建初始化对象。
- 在query类定义中
- public abstract class AbstractQueryImpl implements Query {
- private boolean cacheable;
- }
- cacheable不是对象类型,而是基本类型,所以不赋值的情况下默认为“false”。
也就是说spring-data-jpa接口提供的简单快速的各种接口实现全是不能使用查询缓存的,完全不知道为什么这么设计。
接下来看看我们自己实现的查询方法实现:
直接找到query方法的setCacheable()方法打断点,因为肯定改变这个值才能有查询缓存。
- 于是跟踪到 SimpleJpaQuery类中
- protected Query createQuery(Object[] values) {
- return applyLockMode(applyHints(doCreateQuery(values), method), method);
- }
在返回query的过程中通过applyHints()方法读取了方法上的QueryHint注解从而设置了查询缓存。
相关推荐
总之,`JPA_Hibernate 4.3 jar包`是为Java开发者提供了一个完整的解决方案,以JPA标准的方式利用Hibernate进行数据持久化操作。通过合理配置和使用,可以在保证代码的可维护性的同时,提高数据库操作的效率和便捷性...
spring4.04,springmvc, hibernate4.3 ,JPA2.1, shiro1.2, ehcache2 完全整合,用Ehcache做缓存,通用的DAO、Service接口和实现。完全注解配置,事务拦截方式处理。C0p3做连接池,JSP和Freemarker做View的模板。Shiro...
Struts2.3、Spring4.0和Hibernate4.3是经典的Java Web开发框架组合,被称为SSH2(Struts2、Spring、Hibernate第二版)。这个组合在过去的许多年里被广泛应用,提供了强大的功能来构建企业级应用。下面将详细介绍这三...
Hibernate4.3版本引入了一些新特性,如JPA 2.1支持、二进制数据类型增强、以及对Java 8日期和时间API的支持。它通过HQL(Hibernate查询语言)简化了数据库查询,并提供了缓存机制以提高性能。 **SSH整合** 涉及到这...
8. **第二级缓存**:Hibernate 4.3支持缓存策略,第二级缓存可以提高性能,通过SessionFactory配置,可选择实现如Ehcache的缓存提供者。 9. **事务管理**:Hibernate支持JTA(Java Transaction API)和JDBC事务管理...
4. Criteria查询:提供了一种基于对象的查询方式,比HQL更动态、更灵活。 5. Criteria API和DetachedCriteria:进一步深入,探讨如何使用Criteria API执行复杂的查询,并介绍DetachedCriteria,用于在不同会话间...
此外,4.3.9版本的Hibernate强化了对多线程和并发场景的支持,通过优化内部的锁定机制和缓存策略,提高了在高并发环境下的系统稳定性和响应速度。它还修复了若干已知的bug,确保了框架的健壮性。 在这个版本中,...
在本配置中,Hibernate版本为5.1.3,支持JPA规范,提供了二级缓存功能,提高了数据访问性能。 4. **二级缓存(Ehcache)**: Ehcache是Hibernate的一个可选二级缓存插件,用于存储数据库查询结果,减少对数据库的...
在Hibernate 4.3版本中,它进一步优化了性能,增强了对JPA(Java Persistence API)的支持,并引入了一些新的特性。 二、源码结构分析 解压后的“hibernate-orm-4.3”文件夹包含了Hibernate ORM的全部源代码,主要...
在Hibernate4.3中,引入了对JPA 2.1的支持,增强了性能和可伸缩性,支持延迟加载、缓存策略和事务管理。在Spring MVC中,可以通过Spring的HibernateTemplate或HibernateJpaTemplate进行集成,实现数据持久化。 3. *...
总结,这个项目提供了一个很好的学习平台,通过 SpringMVC、Spring 4.2 和 Hibernate 4.3 的集成,展示了如何构建一个现代的、基于注解的 Java Web 应用程序。对于初学者来说,了解并实践这个项目,可以深入理解 MVC...
2. 配置文件:`hibernate.cfg.xml`是Hibernate的核心配置文件,包含数据库连接、方言选择、缓存策略等关键设置。 3. 实体类注解:通过@Entity、@Table、@Column等注解,可以快速定义Java类与数据库表的映射关系。 ...
这个压缩包"SpringMVC+hibernate+spring+shiro+Ehcache所需jar包"提供了搭建基于SpringMVC、Spring 4.2、Hibernate 4.3、Shiro 1.2.4和Ehcache 2.0的基础组件,这些都是Java开发中非常流行和实用的工具。接下来,...
`hibernate-entitymanager.jar`则提供了JPA(Java Persistence API)的支持,使得开发者可以使用标准的JPA接口进行操作。此外,`hibernate-validator.jar`用于实现JSR-303/JSR-349数据验证,确保输入数据的合法性。...
3. `<properties>`:这部分用于设置JPA或Hibernate的特定属性,如数据库连接URL、用户名、密码、方言、缓存策略等。例如,`hibernate.dialect`用于指定数据库方言,`hibernate.show_sql`控制是否打印SQL语句。 4. `...
这个版本引入了新的特性,如查询缓存改进,性能优化以及对JPA 2.1的支持。 2. **Javassist库**:`javassist-3.18.1-GA.jar`是Hibernate用来动态生成和修改字节码的工具,使ORM框架能够无须预编译就能处理类,极大地...
1.2 Hibernate概述:Hibernate是Java领域中最受欢迎的ORM框架之一,它支持JPA规范,提供了丰富的API和工具,能够处理复杂的数据库交互。 二、Hibernate的安装与配置 2.1 安装:添加Hibernate的JAR包到项目类路径中...
1. **spring-orm-4.3.17.RELEASE.jar**:这个模块提供了与Object/Relational Mapping (ORM)框架如Hibernate、JPA等集成的支持。它使得Spring可以与这些ORM工具无缝配合,实现数据持久化。 2. **spring-jdbc-4.3.17....
3.4 Cache:Hibernate的缓存机制包括一级缓存(Session级别的)和二级缓存(SessionFactory级别的),能够有效减少对数据库的访问,提高系统性能。 四、实战应用 4.1 实体类和映射文件:开发者需定义Java实体类,...
总结,"hibernate-release-4.3.11.Final.zip"压缩包是Hibernate 4.3.11版本的完整资源,对于学习和开发基于Hibernate的应用程序提供了全面的支持。通过掌握Hibernate的核心概念和技术,开发者可以更好地利用ORM技术...