二级缓存注解

❶ spring注解

我是这样理解的，datasource是控制与数据库的交互，transactionManager是管理事务的。

1. Hibernate 的初始化. 读取Hibernate 的配置信息-〉创建Session Factory 1)创建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 缓存中删除一个对象时。 2.持久化状态(persisted) 特征： 1】处于Session 缓存中
   2】持久化对象数据库中设有对象记录
   3】Session 在特定时刻会保持二者同步Java如何进入持久化状态 1】Session 的save()把临时－》持久化状态
   2】Session 的load(),get()方法返回的对象
   3】Session 的find()返回的list集合中存放的对象
   4】Session 的update(),saveOrupdate()使游离－》持久化 3.游离状态(detached) 特征：1】不再位于Session 缓存中
   2】游离对象由持久化状态转变而来，数据库中可能还有对应记录。 Java如何进入持久化状态－》游离状态 1】Session 的close()方法
   2】Session 的evict()方法，从缓存中删除一个对象。提高性能。少用。

2. http://..com/link?url=KscttXiKFvsi4SCy--GtHCOyQJt_2SZykHtg_
   

❷ hibernate二级缓存，ehcache.xml文件在哪

合理的缓存应用可以极大地提高系统性能，最简单的是在应用层面做缓存（越高层面做缓存，效果往往越好），直接将数据缓存到服务器中，以全局map方式存储。在使用的时候直接从缓存的map中取，而不用连接数据库，从而提升性能。这种方式简单易行，但是map常驻服务器内存，并且在数据变更（增删改）的时候要手动更新map。还有一种方式比较通用，就是使用Hibernate二级缓存（SessionFactory级别的全局缓存，进程或集群级别），是一种通用缓存（一级缓存就不说了,Session级别缓存，hibernate自己管理），hibernate二级缓存多应用在多读少写的实体对象中，比如组织机构和系统字典。本文使用hibernate注解方式使用二级缓存，做一个说明（使用Ehcache）。1、添加ehcache.xml配置文件2、hibernate配置文件中，配置Ehcache相关属性hibernate.cache.use_second_level_cache=truehibernate.cache.use_query_cache=truehibernate.cache.provider_class=org.hibernate.cache.EhCacheProviderhibernate.generate_statistics=true调试的时候，可以设置log4j的log4j.logger.org.hibernate.cache=debug（记录二级缓存的活动），实际发布的时候，注释掉，以免影响性能。3、pom文件中引入相应jar包（Maven项目，如果还在手动添加jar包的，可以尝试使用maven）org.hibernatehibernate-ehcache3.6.9.Final4、注解方式配置实体配置了二级缓存后，并不是对所有的实体使用，而是需要指定哪些实体需要用到。如果不配置查询缓存（查询缓存会在下面讲到），则只会在根据id查询的操作中，缓存对象。在实体上配置@Cache(usage=CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)并指定缓存并发策略。@Entity@Cache(usage=CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)@Table(name="base_dict")@JsonIgnoreProperties(value={"hibernateLazyInitializer","handler","fieldHandler","parentDict"}){/****/=5569761987303812150L;@Id@Column(name="id",length=36)@GeneratedValue(generator="uuid")@GenericGenerator(name="uuid",strategy="org.hibernate.id.UUIDGenerator")@JsonProperty("id")privateStringid;/**字典名称*/@ForeignShow@Column(name="name",length=200)privateStringname;5、查询缓存的使用Queryquery=session.createQuery(hql);query.setCacheable(true);//启用查询缓存query.setCacheRegion(“queryCacheRegion”);//设置查询缓存区域（数据过期策略）QueryCache只是在特定的条件下才会发挥作用，而且要求相当严格：(1)完全相同的HQL重复执行。（注意，只有hql）(2)重复执行期间，QueryCache对应的数据表不能有数据变动（比如添、删、改操作）绝大多数的查询并不能从查询缓存中受益，所以Hibernate默认是不进行查询缓存的。查询缓存适用于以下场合：（1）在应用程序运行时经常使用的查询语句（参数相同）（2）很少对与查询语句检索到的数据进行插入、删除或更新操作query.list();

❸ 循环依赖的底层原理

从 Spring IOC 容器中获取 bean 实例的流程：从context.getBean()方法开始

三级缓存为什么会移除掉？
在三级缓存中找 找到了就会执行AOp 产出代理对象 然后将代理对象放入到二级缓存。三级缓存一定会能到的对象 但不一定 会执行 aop 二级缓存找不到 才会触发aop（通过lambda表达式，执行函数式接口，执行aop） 产生代理对象放入二级缓存，放入之后需要移除掉对应的三级缓存(保证只执行一次aop)如果三级缓存中对象不需要执行aop操作 ，那么产生的对象仍然要放入二级缓存 ，这是放入的对象是原始对象

为什么单例池：concurentHashmap是，二级缓存是hashmap，三级缓存是hashmap？
三级缓存的AOP过程需要加锁以保证操作的原子性
因为三级缓存的函数接口 内部已经加了锁，保证了操作的原子性 所以没必要使用concurenthashmap

问题：源码中加synchronized锁的意义？

背景：
二级缓存中的aService对象是三级缓存中的lambda表达式生成出来的，
他们是成对的，二级缓存中存在代理对象，则三级缓存中不应该存在lambda表达式；
或者说，三级缓存中存在lambda表达式，则二级缓存中不应当有该代理对象

解答：

其中：

是将原始对象信息存入三级缓存的操作，存入的是lambda表达式：
getEarlyBeanReference(beanName, mbd, bean)执行的结果,getEarlyBeanReference会对是否需要提前AOP进行判断，如果需要进行AOP，则生成代理对象放入二级缓存。

其中：

1、A doCreateBean()初始化，由于还未创建，从一级缓存查不到，此时只是一个半成品（提前暴露的对象），放入三级缓存singletonFactories;
2、A发现自己需要B对象，但是三级缓存中未发现B，创建B的原始对象，将带有B对象信息（beanName,bd,原始对象）的Lambda表达式放入singletonFactories;
3、B发现自己需要A对象，从一级缓存singletonObjects没找到，并知道了A对象正在创建，就确认发生了循环依赖，这时候再去二级缓存earlySingletonObjects中寻找A对象，没找到就继续在三级缓存singletonFactories中寻找A对象(一定能找到)，于是执行三级缓存中的lambda表达式得到一个代理对象或者是原始对象A（A中属性未赋值），将A放入二级缓存earlySingletonObjects，同时从三级缓存删除对应beanName的表达式；
同理向三级缓存加入对象时，也会从二级缓存中将相同BeanName的记录删除掉，所以二级缓存与三级缓存的之间的来两步操作具有原子性。

4、将A注入到对象B中；
5、B完成属性填充，执行初始化方法，将自己放入第一级缓存中（此时B是一个完整的对象）；
6、A得到对象B，将B注入到A中；
7、A完成属性填充，初始化，并放入到一级缓存中

注意：在对象创建开始的时候，会对对象创建状态利用Set:
singletonsCurrentlyInCreation进行记录:是否是正在创建,可用于判断是否发生了循环依赖。

@Lazy注解的作用：

initializeBean
Spring解决循环依赖问题--B站视频讲解
Spring 循环依赖的“常见”面试问题

❹ hibernate二级缓存 和 spring整合的缓存(就是用哪个Cacheable注解的)有什么区别么

二级缓存配置（spring+hibernate）

说明：本人不建议使用查询缓存，因为查询缓存要求完全相同的查询sql语句才会起作用，所说的查询缓存是针对第二次查询时 sql语句与第一次sql语句完全相同 那么就可以从缓存中取数据而不去数据库中取数据了，在不启用查询缓存的情况下 每次的查询数据也会缓存到二级缓存的 只不过每次查询都会去查询数据库（不包括根据ID查询），启用查询缓存很麻烦 需要每次查询时 调用Query.setCacheable(true)方法才可以，如：List<OrgiData> orgiDatas = (List<OrgiData>) s.createQuery("from OrgiData").setCacheable(true).list();

因此建议将查询缓存设置为如下：
hibernate.cache.use_query_cache=false

还有就是最重要的一点：对于经常修改或重要的数据不宜进行缓存，因为多并发时会造成数据不同步的情况。

首先增加ehcache-1.4.1.jar和backport-util-concurrent-3.1.jar或oscache-2.1.jar

一、spring配置

<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="mappingResources">
<list>
<value>com/handpay/core/merchant/bean/MerchGroupBuy.hbm.xml
</value>
</list>
</property>
<property name="hibernateProperties">
<value>
hibernate.dialect=org.hibernate.dialect.SQLServerDialect
hibernate.show_sql=true
hibernate.format_sql=true
hibernate.hbm2ddl.auto=update
hibernate.cache.use_second_level_cache=true
hibernate.cache.use_query_cache=false
hibernate.cache.provider_class=org.hibernate.cache.EhCacheProvider </value>
</property>
</bean>

<!---红色字体是二级缓存相关的设置->

二、hbm.xml文件示例

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.handpay.core.merchant.bean">
<class name="MerchGroupBuy" table="merch_group_buy">
<cache usage="read-write" region="com.handpay.core.merchant.bean.MerchGroupBuy"/>
<id name="id">
<generator class="native" />
</id>
<property name="code" />
<property name="createTime"/>
<property name="minNum"/>
<property name="status">
</property>
<property name="title"/>
<property name="typeCode"/>
<property name="updateTime"/>
</class>
</hibernate-mapping>

三、注解示例

@Entity
@Cache(usage = CacheConcurrencyStrategy.READ_ONLY)
@Table(name = "alcor_t_countries", catalog = "alcorweb")
public class AlcorTCountries implements java.io.Serializable{。。。。}

四、配置文件参数详解

ehcache.xml是ehcache的配置文件，并且存放在应用的classpath中。下面是对该XML文件中的一些元素及其属性的相关说明：

<diskStore>元素：指定一个文件目录，当EHCache把数据写到硬盘上时，将把数据写到这个文件目录下。 下面的参数这样解释：

user.home – 用户主目录

user.dir – 用户当前工作目录

java.io.tmpdir – 默认临时文件路径

<defaultCache>元素：设定缓存的默认数据过期策略。

<cache>元素：设定具体的命名缓存的数据过期策略。

<cache>元素的属性

name：缓存名称。通常为缓存对象的类名（非严格标准）。

maxElementsInMemory：设置基于内存的缓存可存放对象的最大数目。

maxElementsOnDisk：设置基于硬盘的缓存可存放对象的最大数目。

eternal：如果为true，表示对象永远不会过期，此时会忽略timeToIdleSeconds和timeToLiveSeconds属性，默认为false;

timeToIdleSeconds： 设定允许对象处于空闲状态的最长时间，以秒为单位。当对象自从最近一次被访问后，如果处于空闲状态的时间超过了timeToIdleSeconds属性值，这个对象就会过期。当对象过期，EHCache将把它从缓存中清空。只有当eternal属性为false，该属性才有效。如果该属性值为0，则表示对象可以无限期地处于空闲状态。

timeToLiveSeconds：设定对象允许存在于缓存中的最长时间，以秒为单位。当对象自从被存放到缓存中后，如果处于缓存中的时间超过了 timeToLiveSeconds属性值，这个对象就会过期。当对象过期，EHCache将把它从缓存中清除。只有当eternal属性为false，该属性才有效。如果该属性值为0，则表示对象可以无限期地存在于缓存中。timeToLiveSeconds必须大于timeToIdleSeconds属性，才有意义。

overflowToDisk：如果为true,表示当基于内存的缓存中的对象数目达到了maxElementsInMemory界限后，会把益出的对象写到基于硬盘的缓存中。注意：如果缓存的对象要写入到硬盘中的话，则该对象必须实现了Serializable接口才行。

memoryStoreEvictionPolicy：缓存对象清除策略。有三种：

1 FIFO ，first in first out ，这个是大家最熟的，先进先出，不多讲了

2 LFU ， Less Frequently Used ，就是上面例子中使用的策略，直白一点就是讲一直以来最少被使用的。如上面所讲，缓存的元素有一个hit 属性，hit 值最小的将会被清出缓存。

2 LRU ，Least Recently Used ，最近最少使用的，缓存的元素有一个时间戳，当缓存容量满了，而又需要腾出地方来缓存新的元素的时候，那么现有缓存元素中时间戳离当前时间最远的元素将被清出缓存。

五 、查看 二级缓存数据

1、使用sessionFactory直接获取
Map cacheEntries = sessionFactory().getStatistics()
.getSecondLevelCacheStatistics("cacheRegionName")
.getEntries();

其中 cacheRegionName 既是 ehcache.xml配置中的<cache 标签的name属性值

2、让log4j打印缓存信息（生成环境下请注释掉，以免影响性能）
log4j.logger.org.hibernate.cache=debug

❺ 英特尔 Pentium(奔腾) 双核 E6500 @ 2.93GHz 从开机起温度就一直是41度到关机 问是否正常

这个温度正常。一般情况下CPU的温度只要是不自动关机就问题不大。主板探测的温度不是很准确。一般专业人士都是用测温仪检测CPU温度。最简单的办法就是你开机之后用手背接触一下CPU散热片接近CPU的位置，如果只是温热的话就绝对没有问题。

❻ java hibernate注解@cache指的是设定缓存指的是一级还是二级

CPU缓存CPU缓存大小是重要的指标之一，但也影响对CPU速度的高速缓冲存储器的结构和尺寸是在CPU高速缓冲存储器内非常大，非常高的工作频率，通常用频率和处理器的操作效率远比系统存储器和硬盘驱动器大得多。当实际工作中，CPU经常需要重复相同的数据块被读出，并高速缓存大小增加时，可以大大提高CPU内部读取数据的命中率，而不存储器或硬盘上，然后寻找一种方法来提高系统性能。然而，由于CPU芯片面积和成本的因素要考虑，缓存是非常小的。
的L1高速缓存（高速缓存）是CPU的高速缓冲存储器的第一层被分成数据高速缓存和指令高速缓存。的内置于CPU的性能L1高速缓存大的影响，但由一个静态RAM的高速缓冲存储器构成的更复杂的结构，在CPU的芯片面积的情况下，也不能过大，L1级缓存容量是容量和结构没有可能做太多。 L1缓存一般服务器CPU容量通常为32 256KB。

L2缓存（二级缓存）是二级缓存的CPU，分内部和外部芯片。内部芯片二级缓存主频以相同的速度和运行，而外部二级缓存是只有一半的时钟速度。 L2高速缓存的大小会影响CPU的性能，原则是越大越好，现在家庭用CPU 512KB容量最大，但随着服务器和工作站CPU二级缓存高达256-1MB，有的可达2MB或者3MB。

L3缓存（三级缓存），分为两种，早期的是外置的，现在是内置的。虽然这是它的实际作用，L3缓存的应用可以进一步降低内存延迟，同时提升性能，当大量数据以计算的处理器。减少存储器等待时间和提高的大量数据的计算能力的游戏是非常有帮助的。增加L3高速缓存在服务器场中的性能方面仍然有显着改善。让我们有更大的L3缓存配置将更加有效地利用物理内存，所以它比较慢的磁盘I / O子系统可以处理更多的数据请求。处理器具有更大的L3缓存，以提供更有效的文件系统缓存行为及较短消息和处理器队列长度。

❼ struts+hibernate+spring结构整合后，action为什么必须注解为多例的

hibernate工作原理
原理：
1.读取并解析配置文件
2.读取并解析映射信息，创建SessionFactory
3.打开Sesssion
4.创建事务Transation
5.持久化操作
6.提交事务
7.关闭Session
8.关闭SesstionFactory

为什么要用：
1. 对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。

2. Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现。他很大程度的简化DAO层的编码工作

3. hibernate使用Java反射机制，而不是字节码增强程序来实现透明性。

4. hibernate的性能非常好，因为它是个轻量级框架。映射的灵活性很出色。它支持各种关系数据库，从一对一到多对多的各种复杂关系。

2． Hibernate是如何延迟加载?
1. Hibernate2延迟加载实现：a)实体对象 b)集合（Collection）

2. Hibernate3 提供了属性的延迟加载功能

当Hibernate在查询数据的时候，数据并没有存在与内存中，当程序真正对数据的操作时，对象才存在与内存中，就实现了延迟加载，他节省了服务器的内存开销，从而提高了服务器的性能。

3．Hibernate中怎样实现类之间的关系?(如：一对多、多对多的关系)

类与类之间的关系主要体现在表与表之间的关系进行操作，它们都市对对象进行操作，我们程序中把所有的表与类都映射在一起，它们通过配置文件中的many-to-one、one-to-many、many-to-many、

4． 说下Hibernate的缓存机制

1. 内部缓存存在Hibernate中又叫一级缓存，属于应用事物级缓存

2. 二级缓存：
a) 应用及缓存
b) 分布式缓存
条件：数据不会被第三方修改、数据大小在可接受范围、数据更新频率低、同一数据被系统频繁使用、非 关键数据
c) 第三方缓存的实现

5． Hibernate的查询方式
Sql、Criteria,object comptosition
Hql：
1、 属性查询
2、 参数查询、命名参数查询
3、 关联查询
4、 分页查询
5、 统计函数

6． 如何优化Hibernate？
1.使用双向一对多关联，不使用单向一对多
2.灵活使用单向一对多关联
3.不用一对一，用多对一取代
4.配置对象缓存，不使用集合缓存
5.一对多集合使用Bag,多对多集合使用Set
6. 继承类使用显式多态
7. 表字段要少，表关联不要怕多，有二级缓存撑腰

struts工作原理

Struts工作机制？为什么要使用Struts？
工作机制：
Struts的工作流程:
在web应用启动时就会加载初始化ActionServlet,ActionServlet从
struts-config.xml文件中读取配置信息,把它们存放到各种配置对象
当ActionServlet接收到一个客户请求时,将执行如下流程.
-(1)检索和用户请求匹配的ActionMapping实例,如果不存在,就返回请求路径无效信息;
-(2)如果ActionForm实例不存在,就创建一个ActionForm对象,把客户提交的表单数据保存到ActionForm对象中;
-(3)根据配置信息决定是否需要表单验证.如果需要验证,就调用ActionForm的validate()方法;
-(4)如果ActionForm的validate()方法返回null或返回一个不包含ActionMessage的ActuibErrors对象, 就表示表单验证成功;
-(5)ActionServlet根据ActionMapping所包含的映射信息决定将请求转发给哪个Action,如果相应的 Action实例不存在,就先创建这个实例,然后调用Action的execute()方法;
-(6)Action的execute()方法返回一个ActionForward对象,ActionServlet在把客户请求转发给 ActionForward对象指向的JSP组件;
-(7)ActionForward对象指向JSP组件生成动态网页,返回给客户;

为什么要用：
JSP、Servlet、JavaBean技术的出现给我们构建强大的企业应用系统提供了可能。但用这些技术构建的系统非常的繁乱，所以在此之上，我们需要一个规则、一个把这些技术组织起来的规则，这就是框架，Struts便应运而生。

基于Struts开发的应用由3类组件构成：控制器组件、模型组件、视图组件

8． Struts的validate框架是如何验证的？
在struts配置文件中配置具体的错误提示，再在FormBean中的validate()方法具体调用。

9． 说下Struts的设计模式
MVC模式: web应用程序启动时就会加载并初始化ActionServler。用户提交表单时，一个配置好的ActionForm对象被创建，并被填入表单相应的数据，ActionServler根据Struts-config.xml文件配置好的设置决定是否需要表单验证，如果需要就调用ActionForm的 Validate（）验证后选择将请求发送到哪个Action，如果Action不存在，ActionServlet会先创建这个对象，然后调用 Action的execute（）方法。Execute（）从ActionForm对象中获取数据，完成业务逻辑，返回一个ActionForward对象，ActionServlet再把客户请求转发给ActionForward对象指定的jsp组件，ActionForward对象指定的jsp生成动态的网页，返回给客户。

spring工作原理
1.spring mvc请所有的请求都提交给DispatcherServlet,它会委托应用系统的其他模块负责负责对请求进行真正的处理工作。
2.DispatcherServlet查询一个或多个HandlerMapping,找到处理请求的Controller.
3.DispatcherServlet请请求提交到目标Controller
4.Controller进行业务逻辑处理后，会返回一个ModelAndView
5.Dispathcher查询一个或多个ViewResolver视图解析器,找到ModelAndView对象指定的视图对象
6.视图对象负责渲染返回给客户端。

为什么用：
{AOP 让开发人员可以创建非行为性的关注点，称为横切关注点，并将它们插入到应用程序代码中。使用 AOP 后，公共服务 （比如日志、持久性、事务等）就可以分解成方面并应用到域对象上，同时不会增加域对象的对象模型的复杂性。
IOC 允许创建一个可以构造对象的应用环境，然后向这些对象传递它们的协作对象。正如单词 倒置 所表明的，IOC 就像反 过来的 JNDI。没有使用一堆抽象工厂、服务定位器、单元素（singleton）和直接构造（straight construction），每一个对象都是用其协作对象构造的。因此是由容器管理协作对象（collaborator）。
Spring即使一个AOP框架，也是一IOC容器。 Spring 最好的地方是它有助于您替换对象。有了 Spring，只要用 JavaBean 属性和配置文件加入依赖性（协作对象）。然后可以很容易地在需要时替换具有类似接口的协作对象。}

Spring 框架是一个分层架构，由 7 个定义良好的模块组成。Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式，如图 1 所示。

组成 Spring 框架的每个模块（或组件）都可以单独存在，或者与其他一个或多个模块联合实现。每个模块的功能如下：

☆ 核心容器：核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转 （IOC）模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。

☆ Spring 上下文：Spring 上下文是一个配置文件，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。

☆ Spring AOP：通过配置管理特性，Spring AOP 模块直接将面向方面的编程功能集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理的任何对象支持 AOP。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖 EJB 组件，就可以将声明性事务管理集成到应用程序中。

☆ Spring DAO：JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。

☆ Spring ORM：Spring 框架插入了若干个 ORM 框架，从而提供了 ORM 的对象关系工具，其中包括 JDO、Hibernate 和 iBatis SQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。

☆ Spring Web 模块：Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。所以，Spring 框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。

☆ Spring MVC 框架：MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过策略接口，MVC 框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括 JSP、Velocity、Tiles、iText 和 POI。

Spring 框架的功能可以用在任何 J2EE 服务器中，大多数功能也适用于不受管理的环境。Spring 的核心要点是：支持不绑定到特定 J2EE 服务的可重用业务和数据访问对象。毫无疑问，这样的对象可以在不同 J2EE 环境 （Web 或 EJB）、独立应用程序、测试环境之间重用。

IOC 和 AOP

控制反转模式（也称作依赖性介入）的基本概念是：不创建对象，但是描述创建它们的方式。在代码中不直接与对象和服务连接，但在配置文件中描述哪一个组件需要哪一项服务。容器（在 Spring 框架中是 IOC 容器） 负责将这些联系在一起。

在典型的 IOC 场景中，容器创建了所有对象，并设置必要的属性将它们连接在一起，决定什么时间调用方法。下表列出了 IOC 的一个实现模式。

❽ 如何配置hibernate二级缓存

答案转载自：http://blog.csdn.net/runming56/article/details/8574047

如何在程序里使用二级缓存：
首先在hibernate.cfg.xml开启二级缓存

Xml代码

<hibernate-configuration>
<session-factory>

......

<!-- 开启二级缓存 -->
<property name="hibernate.cache.use_second_level_cache">true</property>
<!-- 启动"查询缓存"如果想缓存使用findall()、list()、Iterator()、createCriteria()、createQuery()等方法获得的数据结果集,必须配置此项-->
<property name="hibernate.cache.use_query_cache">true</property>
<!-- 设置二级缓存插件EHCache的Provider类-->
<!-- <property name="hibernate.cache.provider_class">
org.hibernate.cache.EhCacheProvider
</property> -->
<!-- 二级缓存区域名的前缀 -->
<!--<property name="hibernate.cache.region_prefix">test</property>-->
<!-- 高速缓存提供程序 -->
<property name="hibernate.cache.region.factory_class">
net.sf.ehcache.hibernate.EhCacheRegionFactory
</property>
<!-- Hibernate4以后都封装到org.hibernate.cache.ehcache.EhCacheRegionFactory -->
<!-- 指定缓存配置文件位置 -->
<!-- <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>

......

</session-factory>
</hibernate-configuration>

然后是ehcache配置（ehcache.xml）
cache参数详解：
● name:指定区域名
● maxElementsInMemory ：缓存在内存中的最大数目
● maxElementsOnDisk：缓存在磁盘上的最大数目
● eternal ：设置是否永远不过期
● overflowToDisk ： 硬盘溢出数目
● timeToIdleSeconds ：对象处于空闲状态的最多秒数后销毁
● timeToLiveSeconds ：对象处于缓存状态的最多秒数后销毁
● memoryStoreEvictionPolicy:缓存算法，有LRU（默认）、LFU、LFU

关于缓存算法，常见有三种：
● LRU：（Least Rencently Used）新来的对象替换掉使用时间算最近很少使用的对象
● LFU：（Least Frequently Used）替换掉按命中率高低算比较低的对象
● LFU：（First In First Out）把最早进入二级缓存的对象替换掉

Xml代码

<?xml version="1.0" encoding="UTF-8"?>
<ehcache>
<!--如果缓存中的对象存储超过指定的缓存数量的对象存储的磁盘地址-->
<diskStore path="D:/ehcache"/>

<!-- 默认cache：如果没有对应的特定区域的缓存，就使用默认缓存 -->
<defaultCache maxElementsInMemory="10000"
eternal="false"
timeToIdleSeconds="300"
timeToLiveSeconds="600"
overflowToDisk="false"/>
<!-- 指定区域cache：通过name指定，name对应到Hibernate中的区域名即可-->
<cache name="cn.javass.h3test.model.UserModel"
eternal="false"
maxElementsInMemory="100"
timeToIdleSeconds="1200"
timeToLiveSeconds="1200"
overflowToDisk="false">
</cache>

</ehcache>

在每个实体的hbm文件中配置cache元素，usage可以是read-only或者是read-write等4种。

Xml代码

<?xml version="1.0" encoding='UTF-8'?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd" >
<hibernate-mapping>
<class>
<!-- 设置该持久化类的二级缓存并发访问策略 read-only read-write nonstrict-read-write transactional-->
<class name="cn.java.test.model.User" table="TBL_USER">
<cache usage="read-write"/>
......
</class>
</hibernate-mapping>

也可以用Hibernate注解配置缓存实体类

Java代码

@Entity
@Table
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
public class User implements Serializable {
private static final long serialVersionUID = -5121812640999313420L;
private Integer id;
private String name;

......
}

❾ spring3.2.2+hibernate 怎么集成ehcache

spring boot集成ehcache 2.x 用于hibernate二级缓存

spring boot集成ehcache 2x 用于hibernate二级缓存
项目依赖
Ehcache简介
hibernate二级缓存配置
ehcache配置文件
ehcache事件监听
注解方式使用二级缓存
完整代码

本文将介绍如何在spring boot中集成ehcache作为hibernate的二级缓存。各个框架版本如下
spring boot：1.4.3.RELEASE
spring framework: 4.3.5.RELEASE
hibernate：5.0.1.Final（spring-boot-starter-data-jpa默认依赖）
ehcache：2.10.3
项目依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-cache</artifactId>
</dependency>

<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-ehcache</artifactId>
<exclusions>
<exclusion>
<groupId>net.sf.ehcache</groupId>
<artifactId>ehcache-core</artifactId>
</exclusion>
</exclusions>
</dependency>

<dependency>
<groupId>net.sf.ehcache</groupId>
<artifactId>ehcache</artifactId>
<version>2.10.3</version>
</dependency>

Ehcache简介
ehcache是一个纯Java的缓存框架，既可以当做一个通用缓存使用，也可以作为将其作为hibernate的二级缓存使用。缓存数据可选择如下三种存储方案
MemoryStore – On-heap memory used to hold cache elements. This tier is subject to Java garbage collection.
OffHeapStore – Provides overflow capacity to the MemoryStore. Limited in size only by available RAM. Not subject to Java garbage collection (GC). Available only with Terracotta BigMemory procts.
DiskStore – Backs up in-memory cache elements and provides overflow capacity to the other tiers.
hibernate二级缓存配置
hibernate的二级缓存支持entity和query层面的缓存，org.hibernate.cache.spi.RegionFactory各类可插拔的缓存提供商与hibernate的集成。
# 打开hibernate统计信息
spring.jpa.properties.hibernate.generate_statistics=true

# 打开二级缓存
spring.jpa.properties.hibernate.cache.use_second_level_cache=true

# 打开查询缓存
spring.jpa.properties.hibernate.cache.use_query_cache=true

# 指定缓存provider
spring.jpa.properties.hibernate.cache.region.factory_class=org.hibernate.cache.ehcache.SingletonEhCacheRegionFactory

# 配置shared-cache-mode
spring.jpa.properties.javax.persistence.sharedCache.mode=ENABLE_SELECTIVE

关于hibernate缓存相关的所有配置可参考hibernate5.0官方文档#缓存
ehcache配置文件
ehcache 2.x配置文件样板参考官方网站提供的ehcache.xml。本例中使用的配置文件如下所示
<?xml version="1.0" encoding="UTF-8"?>

<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="http://www.ehcache.org/ehcache.xsd"
updateCheck="true" monitoring="autodetect"
dynamicConfig="true">

<diskStore path="user.dir/cache"/>
<transactionManagerLookup class="net.sf.ehcache.transaction.manager."
properties="jndiName=java:/TransactionManager" propertySeparator=";"/>
< class="com.yangyi.base.ehcache." properties=""/>

<defaultCache
maxEntriesLocalHeap="0"
eternal="false"
timeToIdleSeconds="1200"
timeToLiveSeconds="1200">
<!--<terracotta/>-->
</defaultCache>

<cache name="entityCache"
maxEntriesLocalHeap="1000"
maxEntriesLocalDisk="10000"
eternal="false"
diskSpoolBufferSizeMB="20"
timeToIdleSeconds="10"
timeToLiveSeconds="20"
memoryStoreEvictionPolicy="LFU"
transactionalMode="off">
<persistence strategy="localTempSwap"/>
<cacheEventListenerFactory class="com.yangyi.base.ehcache." />
</cache>

<cache name="org.hibernate.cache.internal.StandardQueryCache"
maxEntriesLocalHeap="5" eternal="false" timeToLiveSeconds="120">
<persistence strategy="localTempSwap" />
<cacheEventListenerFactory class="com.yangyi.base.ehcache." />
</cache>

<cache name="org.hibernate.cache.spi.UpdateTimestampsCache"
maxEntriesLocalHeap="5000" eternal="true">
<persistence strategy="localTempSwap" />
<cacheEventListenerFactory class="com.yangyi.base.ehcache." />
</cache>
</ehcache>

注解方式使用二级缓存
要使用entity cache，需要在entity上配上相应的注解方可生效。javax.persistence.Cacheable注解标记该entity使用二级缓存，org.hibernate.annotations.Cache注解指定缓存策略，以及存放到哪个缓存区域。
有关缓存策略详细信息可参考hibernate5.0官方文档#缓存
package com.yangyi.entity;

import org.hibernate.annotations.Cache;
import org.hibernate.annotations.CacheConcurrencyStrategy;
import javax.persistence.Cacheable;
import javax.persistence.Entity;
import javax.persistence.JoinTable;

@Entity
@Table(name = "users")
@Cacheable
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE, region = "entityCache")
public class User implements Serializable {

}

最后，我们需要在spring boot应用层面打开cache功能，使用org.springframework.cache.annotation.EnableCaching注解
package com.yangyi;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;

@SpringBootApplication
@EnableCaching
public class Application {

public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}

完整代码
完整代码示例见github spring-boot-ehcache2.x-hibernate-second-level-cache