java培训-Hibernate的缓存解读
JAVAWEB面试题（含答案）
1、jsp和servlet的区别、共同点、各自应用的范围？？JSP是Servlet技术的扩展，本质上就是Servlet的简易方式。
JSP编译后是“类servlet”。
Servlet和JSP最主要的不同点在于，Servlet的应用逻辑是在Java文件中，并且完全从表示层中的HTML里分离开来。
而JSP的情况是Java和HTML可以组合成一个扩展名为.jsp的文件。
JSP侧重于视图，Servlet主要用于控制逻辑。
在struts框架中,JSP位于MVC设计模式的视图层,而Servlet位于控制层.2、cookie和session的作用、区别、应用范围，session的工作原理Cookie:主要用在保存客户端，其值在客户端与服务端之间传送，不安全，存储的数据量有限。
Session:保存在服务端，每一个session在服务端有一个sessionID作一个标识。
存储的数据量大，安全性高。
占用服务端的内存资源。
3、jstl是什么？优点有哪些？？JSTL（JSP Standard Tag Library，JSP标准标签库)是一个不断完善的开放源代码的JSP标签库，由四个定制标记库（core、format、xml和sql）和一对通用标记库验证器（ScriptFreeTLV和PermittedTaglibsTLV）组成。
优点有：最大程序地提高了WEB应用在各应用服务器在应用程序服务器之间提供了一致的接口，最大程序地提高了1、在应用程序服务器之间提供了一致的接口，之间的移植。
2、简化了JSP和WEB应用程序的开发。
3、以一种统一的方式减少了JSP中的scriptlet代码数量，可以达到没有任何scriptlet 代码的程序。
在我们公司的项目中是不允许有任何的scriptlet代码出现在JSP中。
4、允许JSP设计工具与WEB应用程序开发的进一步集成。
相信不久就会有支持JSTL的IDE 开发工具出现。
4、j2ee的优越性主要表现在哪些方面？MVC模式a、J2EE基于JAVA技术，与平台无关b、J2EE拥有开放标准，许多大型公司实现了对该规范支持的应用服务器。
hibernate框架的工作原理
hibernate框架的工作原理Hibernate框架的工作原理Hibernate是一个开源的ORM(Object-Relational Mapping)框架，它将Java对象映射到关系型数据库中。
它提供了一种简单的方式来处理数据持久化，同时也提供了一些高级特性来优化性能和可维护性。
1. Hibernate框架的基本概念在开始讲解Hibernate框架的工作原理之前，需要先了解一些基本概念：Session：Session是Hibernate与数据库交互的核心接口，它代表了一个会话，可以用来执行各种数据库操作。
SessionFactory：SessionFactory是一个线程安全的对象，它用于创建Session对象。
通常情况下，应用程序只需要创建一个SessionFactory对象。
Transaction：Transaction是对数据库操作进行事务管理的接口。
在Hibernate中，所有对数据库的操作都应该在事务中进行。
Mapping文件：Mapping文件用于描述Java类与数据库表之间的映射关系。
它定义了Java类属性与数据库表字段之间的对应关系。
2. Hibernate框架的工作流程Hibernate框架主要分为两个部分：持久化层和业务逻辑层。
其中，持久化层负责将Java对象映射到数据库中，并提供数据访问接口；业务逻辑层则负责处理业务逻辑，并调用持久化层进行数据访问。
Hibernate框架的工作流程如下：2.1 创建SessionFactory对象在应用程序启动时，需要创建一个SessionFactory对象。
SessionFactory是一个线程安全的对象，通常情况下只需要创建一个即可。
2.2 创建Session对象在业务逻辑层需要进行数据访问时，需要先创建一个Session对象。
Session是Hibernate与数据库交互的核心接口，它代表了一个会话，可以用来执行各种数据库操作。
2.3 执行数据库操作在获取了Session对象之后，就可以执行各种数据库操作了。
Java中的缓存技术
Java中的缓存技术缓存技术在软件开发中起着至关重要的作用。
它可以提高系统性能、降低对底层资源的访问频率，从而减轻服务器负载并改善用户体验。
在Java开发中，有许多可供选择的缓存技术。
本文将介绍几种常见的Java缓存技术，以及它们的应用场景和原理。
一、内存缓存内存缓存是最常见的缓存技术之一，它将数据保存在内存中，以提高读取速度。
在Java中，可以使用集合框架中的Map接口的实现类来实现内存缓存，如HashMap、ConcurrentHashMap等。
这些类提供了快速的Key-Value存储，通过Key快速查找对应的Value，以实现快速访问缓存数据。
内存缓存适用于数据读取频繁但不经常更新的场景，例如字典数据、配置信息等。
需要注意的是，内存缓存的容量是有限的，当缓存数据超过容量限制时，需要采取一些策略来处理，如LRU（最近最少使用）算法将最久未访问的数据移出缓存。
二、分布式缓存分布式缓存是一种将数据存储在多台服务器节点上的缓存技术。
Java中有多种分布式缓存框架可供选择，如Redis、Memcached等。
这些框架提供了高性能、可扩展的分布式缓存服务，可以在集群中存储大量的数据，并提供分布式缓存的管理和查询接口。
分布式缓存适用于需要同时服务大量客户端并具有高并发读写需求的场景，例如电商网站的商品信息、社交网络的用户数据等。
通过将数据存储在多台服务器上，可以提高系统的可用性和扩展性。
三、页面缓存页面缓存是将网页内容保存在缓存中，以减少对数据库或后端服务的访问频率，从而提高页面的加载速度。
在Java中，可以通过使用Web服务器或反向代理服务器的缓存功能，例如Nginx、Varnish等，来实现页面缓存。
页面缓存适用于内容相对静态或者不经常变化的场景，例如新闻网站的文章、博客网站的页面等。
通过将网页内容保存在缓存中，可以避免每次请求都重新生成页面，大大提高响应速度和系统的并发能力。
四、数据库缓存数据库缓存是将数据库查询结果保存在缓存中，以减少对数据库的频繁查询，提高系统的响应速度和并发能力。
三大框架
Hibernate1.Hibernate 的初始化.读取Hibernate 的配置信息-〉创建Session Factory1)创建Configeration类的实例。
它的构造方法：将配置信息(Hibernate config.xml)读入到内存。
一个Configeration 实例代表Hibernate 所有Java类到Sql数据库映射的集合。
2)创建SessionFactory实例把Configeration 对象中的所有配置信息拷贝到SessionFactory的缓存中。
SessionFactory的实例代表一个数据库存储员源，创建后不再与Configeration 对象关联。
缓存(cache):指Java对象的属性(通常是一些集合类型的属性－－占用内存空间。
SessionFactory的缓存中：Hibernate 配置信息。
OR映射元数据。
缓存－大：重量级对象小：轻量级对象3)调用SessionFactory创建Session的方法1】用户自行提供JDBC连接。
Connection con=dataSource.getConnection(); Session s=sessionFactory.openSession(con);2】让SessionFactory提供连接Session s=sessionFactory.openSession();4)通过Session 接口提供的各种方法来操纵数据库访问。
Hibernate 的缓存体系一级缓存：Session 有一个内置的缓存，其中存放了被当前工作单元加载的对象。
每个Session 都有自己独立的缓存，且只能被当前工作单元访问。
二级缓存：SessionFactory的外置的可插拔的缓存插件。
其中的数据可被多个Session共享访问。
SessionFactory的内置缓存：存放了映射元数据，预定义的Sql语句。
Hibernate 中Java对象的状态1.临时状态(transient)特征：1】不处于Session 缓存中2】数据库中没有对象记录Java如何进入临时状态1】通过new语句刚创建一个对象时2】当调用Session 的delete()方法，从Session 缓存中删除一个对象时。
java二级缓存原理
java二级缓存原理Java二级缓存原理随着互联网的发展和应用程序的复杂化，对于数据的访问和处理速度要求也越来越高。
在Java中，缓存技术被广泛应用于提高系统的性能和响应速度。
其中，二级缓存是一种常用的缓存技术，可以有效地减少对数据库等资源的访问次数，提高系统的性能。
一、什么是二级缓存二级缓存是指在应用程序和数据库之间添加一层缓存，用于存储频繁访问的数据。
通常情况下，二级缓存会将数据存储在内存中，以提高数据的访问速度。
相比一级缓存（即应用内存中的缓存），二级缓存具有更大的容量和更高的性能。
二、为什么需要二级缓存在大多数应用程序中，对于频繁访问的数据，每次都直接从数据库中读取会导致较高的数据库负载和较慢的响应速度。
而通过使用二级缓存，可以将这些数据缓存在内存中，减少对数据库的访问次数，从而提高系统的性能和响应速度。
三、二级缓存的实现原理1. 缓存的数据结构二级缓存通常使用哈希表或者红黑树等数据结构来存储缓存数据。
这些数据结构具有快速的查找和插入操作，可以提高数据的访问效率。
2. 缓存的更新策略为了保证缓存数据的及时性和准确性，二级缓存需要实现一定的更新策略。
常见的更新策略有以下几种：- 缓存失效策略：当缓存中的数据过期或者被修改时，将其标记为失效状态，并在下次访问时更新缓存数据。
- 定时刷新策略：定期清理缓存中的失效数据，并从数据库中重新加载最新的数据。
- 主动更新策略：当数据库中的数据发生变化时，通过数据库触发器或者消息队列等机制，自动更新缓存中的数据。
3. 缓存的淘汰策略当缓存中的数据量超过一定的限制时，为了避免内存溢出，需要实现一定的淘汰策略。
常见的淘汰策略有以下几种：- 先进先出（FIFO）策略：将最早进入缓存的数据淘汰出去。
- 最少使用（LFU）策略：将最少被访问的数据淘汰出去。
- 最近最少使用（LRU）策略：将最近最少被访问的数据淘汰出去。
4. 缓存的一致性由于缓存数据是存储在内存中的，可能会出现缓存与数据库数据不一致的情况。
hibernate缓存机制详细分析（一级、二级、查询缓存，非常清晰明白）
hibernate缓存机制详细分析（⼀级、⼆级、查询缓存，⾮常清晰明⽩）您可以通过点击右下⾓的按钮来对⽂章内容作出评价, 也可以通过左下⽅的关注按钮来关注我的博客的最新动态。
如果⽂章内容对您有帮助, 不要忘记点击右下⾓的推荐按钮来⽀持⼀下哦如果您对⽂章内容有任何疑问, 可以通过评论或发邮件的⽅式联系我:****************/**********************如果需要转载，请注明出处，谢谢！！在本篇随笔⾥将会分析⼀下hibernate的缓存机制，包括⼀级缓存(session级别)、⼆级缓存(sessionFactory级别)以及查询缓存，当然还要讨论下我们的N+1的问题。
随笔虽长，但我相信看完的朋友绝对能对hibernate的 N+1问题以及缓存有更深的了解。
⼀、N+1问题⾸先我们来探讨⼀下N+1的问题，我们先通过⼀个例⼦来看⼀下，什么是N+1问题：list()获得对象： /** * 此时会发出⼀条sql，将30个学⽣全部查询出来*/ List<Student> ls = (List<Student>)session.createQuery("from Student").setFirstResult(0).setMaxResults(30).list();Iterator<Student> stus = ls.iterator();for(;stus.hasNext();){Student stu = (Student)stus.next();System.out.println(stu.getName());}如果通过list()⽅法来获得对象，毫⽆疑问，hibernate会发出⼀条sql语句，将所有的对象查询出来，这点相信⼤家都能理解Hibernate: select student0_.id as id2_, student0_.name as name2_, student0_.rid as rid2_, student0_.sex as sex2_ from t_student student0_ limit ?那么，我们再来看看iterator()这种情况iterator()获得对象 /** * 如果使⽤iterator⽅法返回列表，对于hibernate⽽⾔，它仅仅只是发出取id列表的sql* 在查询相应的具体的某个学⽣信息时，会发出相应的SQL去取学⽣信息* 这就是典型的N+1问题* 存在iterator的原因是，有可能会在⼀个session中查询两次数据，如果使⽤list每⼀次都会把所有的对象查询上来* ⽽是要iterator仅仅只会查询id，此时所有的对象已经存储在⼀级缓存(session的缓存)中，可以直接获取*/ Iterator<Student> stus = (Iterator<Student>)session.createQuery("from Student").setFirstResult(0).setMaxResults(30).iterate();for(;stus.hasNext();){Student stu = (Student)stus.next();System.out.println(stu.getName());}在执⾏完上述的测试⽤例后，我们来看看控制台的输出，看会发出多少条 sql 语句：Hibernate: select student0_.id as col_0_0_ from t_student student0_ limit ?Hibernate: select student0_.id as id2_0_, student0_.name as name2_0_, student0_.rid as rid2_0_, student0_.sex as sex2_0_ from t_student student0_ where student0_.id=?沈凡Hibernate: select student0_.id as id2_0_, student0_.name as name2_0_, student0_.rid as rid2_0_, student0_.sex as sex2_0_ from t_student student0_ where student0_.id=?王志名Hibernate: select student0_.id as id2_0_, student0_.name as name2_0_, student0_.rid as rid2_0_, student0_.sex as sex2_0_ from t_student student0_ where student0_.id=?叶敦.........我们看到，当如果通过iterator()⽅法来获得我们对象的时候，hibernate⾸先会发出1条sql去查询出所有对象的 id 值，当我们如果需要查询到某个对象的具体信息的时候，hibernate此时会根据查询出来的 id 值再发sql语那么这种 N+1 问题我们如何解决呢，其实我们只需要使⽤ list() ⽅法来获得对象即可。
Java缓存机制
在软件开发中，缓存是一种常用的优化技术，用于存储频繁访问的数据，使得下一次访问时可以更快地获取数据。
而在Java中，也存在着各种不同的缓存机制，用于提升程序的性能与效率。
一、内存缓存内存缓存是最常见的缓存机制之一。
在Java中，可以使用各种数据结构来实现内存缓存，比如Hashtable、HashMap、ConcurrentHashMap等。
使用内存缓存的好处是可以将数据存储在内存中，而不是频繁地访问数据库或者其他外部存储介质，从而提升访问速度。
同时，内存缓存还可以减轻数据库的负载，提高系统的并发能力。
二、CPU缓存CPU缓存是指CPU内部的高速缓存，用于暂时存储处理器频繁访问的数据。
在Java中，可以通过使用局部变量和静态变量来利用CPU缓存。
局部变量存储在方法栈帧中，相对于对象的实例变量来说，访问局部变量的速度更快。
因此，在开发过程中，应该尽量使用局部变量来存储频繁访问的数据。
静态变量是存储在方法区中的，与对象的实例无关。
由于静态变量只有一个副本，所以可以减少对CPU缓存的竞争，提高程序的性能。
三、磁盘缓存磁盘缓存是将数据存储在磁盘中，并使用相应的缓存算法来提高数据的读写速度。
在Java中，可以通过使用文件缓存或者数据库缓存来实现磁盘缓存。
文件缓存是将数据存储在本地文件系统中，比如将一些配置文件加载到内存中进行处理。
数据库缓存是将数据存储在数据库中，并使用缓存算法来提高数据的访问速度。
一般情况下，数据库缓存会使用LRU（最近最少使用）算法来决定何时移除某个数据。
四、网络缓存网络缓存是将数据存储在网络中，通过网络进行传输。
在Java中，可以通过使用HTTP缓存或者CDN来实现网络缓存。
HTTP缓存是浏览器和服务器之间的缓存，用于存储HTTP请求和响应的数据。
通过合理设定HTTP头信息，可以实现数据的缓存，减少带宽的消耗。
CDN（内容分发网络）是一种将数据分布到全球多台服务器的网络架构，用于存储静态文件，提供更快的数据访问速度。
jpa二级缓存设置专业资料
共 12 页
第 2 页
sheagle@
ehcache 缓存设置
缓存的软件实现 在 Hibernate 的 Session 的实现中包含了缓存的实现 由第三方提供， Hibernate 仅提供了缓存适配器(CacheProvider)。 用于把特定的缓存插件集成到 Hibernate 中。 启用缓存的方式 只要应用程序通过 Session 接口来执行保存、更新、删除、加载和查 询数据库数据的操作，Hibernate 就会启用第一级缓存，把数据库中的数据以对象的形式拷 贝到缓存中，对于批量更新和批量删除操作，如果不希望启用第一级缓存，可以绕过 Hibernate API，直接通过 JDBC API 来执行指操作。 用户可以在单个类或类的单个集合的 粒度上配置第二级缓存。 如果类的实例被经常读但很少被修改， 就可以考虑使用第二级缓存。 只有为某个类或集合配置了第二级 缓存，Hibernate 在运行时才会把它的实例加入到第二 级缓存中。 用户管理缓存的方式 第一级缓存的物理介质为内存，由于内存容量有限，必须通过恰 当的检索策略和检索方式来限制加载对象的数目。 Session 的 evit()方法可以显式清空缓存 中特定对象，但这种方法不值得推荐。 第二级缓存的物理介质可以是内存和硬盘，因此第 二级缓存可以存放大量的数据， 数据过期策略的 maxElementsInMemory 属性值可以控制内存 中 的对象数目。管理第二级缓存主要包括两个方面：选择需要使用第二级缓存的持久类， 设置合适的并发访问策略：选择缓存适配器，设置合适的数据过期策略。
2.3.5 配置二级缓存的主要步骤： 1) 选择需要使用二级缓存的持久化类，设置它的命名缓存的并发访问策略。这是最值 得认真考虑的步骤。 2) 选择合适的缓存插件，然后编辑该插件的配置文件。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
Hibernate的缓存解读缓存是介于物理数据源与应用程序之间，是对数据库中的数据复制一份临时放在内存中的容器，其作用是为了减少应用程序对物理数据源访问的次数，从而提高了应用的运行性能。
缓存是介于物理数据源与应用程序之间，是对数据库中的数据复制一份临时放在内存中的容器，其作用是为了减少应用程序对物理数据源访问的次数，从而提高了应用的运行性能。
Hibernate在进行读取数据的时候，根据缓存机制在相应的缓存中查询，如果在缓存中找到了需要的数据(我们把这称做“缓存命中")，则就直接把命中的数据作为结果加以利用，避免了大量发送SQL语句到数据库查询的性能损耗。
Hibernate缓存分类：一、Session缓存（又称作事务缓存）：Hibernate内置的，不能卸除。
缓存范围：缓存只能被当前Session对象访问。
缓存的生命周期依赖于Session的生命周期，当Session被关闭后，缓存也就结束生命周期。
二、SessionFactory缓存（又称作应用缓存）：使用第三方插件，可插拔。
缓存范围：缓存被应用范围内的所有session共享。
这些session有可能是并发访问缓存，因此必须对缓存进行更新。
缓存的生命周期依赖于应用的生命周期，应用结束时，缓存也就结束了生命周期，二级缓存存在于应用程序范围。
Hibernate一些与一级缓存相关的操作（时间点）：数据放入缓存：1. save()。
当session对象调用save()方法保存一个对象后，该对象会被放入到session的缓存中。
2. get()和load()。
当session对象调用get()或load()方法从数据库取出一个对象后，该对象也会被放入到session 的缓存中。
3. 使用HQL和QBC等从数据库中查询数据。
例如：数据库有一张表如下：使用get()或load()证明缓存的存在：1.public class Client2.{3.public static void main(String[] args)4. {5. Session session = HibernateUtil.getSessionFactory().openSession();6. Transaction tx = null;7.try8. {9./*开启一个事务*/10. tx = session.beginTransaction();11./*从数据库中获取id="402881e534fa5a440134fa5a45340002"的Customer对象*/12. Customer customer1 = (Customer)session.get(Customer.class, "402881e534fa5a440134fa5a45340002");13. System.out.println("customer.getUsername is"+customer1.getUsername());14./*事务提交*/15. mit();16.17. System.out.println("-------------------------------------");18.19./*开启一个新事务*/20. tx = session.beginTransaction();21./*从数据库中获取id="402881e534fa5a440134fa5a45340002"的Customer对象*/22. Customer customer2 = (Customer)session.get(Customer.class, "402881e534fa5a440134fa5a45340002");23. System.out.println("customer2.getUsername is"+customer2.getUsername());24./*事务提交*/25. mit();26.27. System.out.println("-------------------------------------");28.29./*比较两个get()方法获取的对象是否是同一个对象*/30. System.out.println("customer1 == customer2 result is "+(customer1==customer2));31. }32.catch (Exception e)33. {34.if(tx!=null)35. {36. tx.rollback();37. }38. }39.finally40. {41. session.close();42. }43. }44.}程序控制台输出结果：1.Hibernate:2. select3. customer0_.id as id0_0_,4. customer0_.username as username0_0_,5. customer0_.balance as balance0_0_6. from7. customer customer0_8. where9. customer0_.id=?10.customer.getUsername islisi11.-------------------------------------12.customer2.getUsername islisi13.-------------------------------------14.customer1 == customer2 result is true输出结果中只包含了一条SELECT SQL语句，而且customer1 == customer2 result is true说明两个取出来的对象是同一个对象。
其原理是：第一次调用get()方法， Hibernate先检索缓存中是否有该查找对象，发现没有，Hibernate 发送SELECT语句到数据库中取出相应的对象，然后将该对象放入缓存中，以便下次使用，第二次调用get()方法，Hibernate先检索缓存中是否有该查找对象，发现正好有该查找对象，就从缓存中取出来，不再去数据库中检索。
数据从缓存中清除：1. evit()将指定的持久化对象从缓存中清除，释放对象所占用的内存资源，指定对象从持久化状态变为脱管状态，从而成为游离对象。
2. clear()将缓存中的所有持久化对象清除，释放其占用的内存资源。
其他缓存操作：1. contains()判断指定的对象是否存在于缓存中。
2. flush()刷新缓存区的内容，使之与数据库数据保持同步。
Hibernate使用二级缓存适合存放到第二级缓存中的数据：1. 很少被修改的数据。
2. 不是很重要的数据，允许出现偶尔并发的数据。
3. 不会被并发访问的数据。
4. 参考数据,指的是供应用参考的常量数据，它的实例数目有限，它的实例会被许多其他类的实例引用，实例极少或者从来不会被修改。
不适合存放到第二级缓存的数据：1. 经常被修改的数据。
2. 财务数据，绝对不允许出现并发。
3. 与其他应用共享的数据。
Hibernate如何将数据库中的数据放入到二级缓存中？注意，你可以把缓存看做是一个Map对象，它的Key用于存储对象OID，Value用于存储POJO。
首先，当我们使用Hibernate从数据库中查询出数据，获取检索的数据后，Hibernate 将检索出来的对象的OID放入缓存中key中，然后将具体的POJO放入value中，等待下一次再次向数据查询数据时，Hibernate根据你提供的OID先检索一级缓存，若没有且配置了二级缓存，则检索二级缓存，如果还没有则才向数据库发送SQL语句，然后将查询出来的对象放入缓存中。
为Hibernate配置二级缓存：在主配置文件中hibernate.cfg.xml1.<property name="e_second_level_cache">true</property>2.<property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property>配置ehcache.xml1.<?xml version="1.0"encoding="UTF-8"?>2.<ehcache>3.<!--4.缓存到硬盘的路径5. -->6.<diskStore path="d:/ehcache"></diskStore>7.8. <!--9.默认设置10. maxElementsInMemory : 在內存中最大緩存的对象数量。
11. eternal : 缓存的对象是否永远不变。
12. timeToIdleSeconds ：可以操作对象的时间。
13. timeToLiveSeconds ：缓存中对象的生命周期，时间到后查询数据会从数据库中读取。
14. overflowToDisk ：内存满了，是否要缓存到硬盘。
15. -->16.<defaultCache maxElementsInMemory="200"eternal="false"17.timeToIdleSeconds="50"timeToLiveSeconds="60"overflowToDisk="true"></defaultCache>18.19. <!--20.指定缓存的对象。
21.下面出现的的属性覆盖上面出现的，没出现的继承上面的。
22. -->23.<cache name="com.suxiaolei.hibernate.pojos.Order"maxElementsInMemory="200"eternal="false"24.timeToIdleSeconds="50"timeToLiveSeconds="60"overflowToDisk="true"></cache>25.26.</ehcache>在需要被缓存的对象中hbm文件中的<class>标签下添加一个<cache>子标签1.<hibernate-mapping>2.<class name="com.suxiaolei.hibernate.pojos.Order"table="orders">3.<cache usage="read-only"/>4.5.<id name="id"type="string">6.<column name="id"></column>7.<generator class="uuid"></generator>8.</id>9.10.<property name="orderNumber"column="orderNumber"type="string"></property>11.<property name="cost"column="cost"type="integer"></property>12.13.<many-to-one name="customer"class="com.suxiaolei.hibernate.pojos.Customer"14.column="customer_id"cascade="save-update">15.</many-to-one>16.</class>17.</hibernate-mapping>若存在一对多的关系，想要在在获取一方的时候将关联的多方缓存起来，需要再集合属性下添加<cache>子标签，这里需要将关联的对象的hbm文件中必须在存在<class>标签下也添加<cache>标签，不然Hibernate只会缓存OID。