二級緩存註解

❶ 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