mybatis二級緩存刷新
Ⅰ redis mybatis 二級緩存 為什麼必須要有 <property name="connectionfactory" ref
1、mybatis的二級緩存的范圍是命名空間（namespace）
2、只要這個命名空間下有一個 insert、update、delete mybatis 就會把這個命名空間下的二級緩清空。
3、如果同一個sql在不同的命名空間下，就會出現臟數據，因為一個insert、update、deleted 了另一個可能還使用者緩存數據，這樣就會出現數據的不一致性。
4、如果更新、刪除、插入的頻率比較高的話，就會刪除所有緩存在添加所有緩存在刪除，這樣緩存的命中率很低或者說根本就起不到緩存作用而且會消耗資源。
所以在沒解決這個問題的前提下，還是不提倡使用二級緩存。
Ⅱ mybatis的cache-ref怎麼使用
首先明確一點 cache-ref 只對二級緩存有效，沒有使用二級緩存時，這東西沒有意義。
以下說明只針對二級緩存。
當mybatis的當前命名空間存在DML的事務提交時，會使當前命名空間里的緩存失效，這樣在查詢時，會直接從資料庫拿到數據，並再次緩存。但是如果是多表連接查詢，如tableA join tableB，A表的DML操作在A的nameSpace,B表的DML操作在B的nameSpace，當B表在進行了數據修改時，不會使A表緩存失效，再使用tableA join tableB會直接從緩存中獲取數據，因為此時緩存沒有刷新，而且B表的數據也有變化，那麼此時讀取的就是臟數據。
此時就需要在B的nameSpace里使用<cache-ref namespace="A"/>，保證跟新B時，A的緩存也失效。再在A裡面執行 tableA join tableB時，會重新從資料庫里查詢最新數據。
Ⅲ mybatis怎麼開啟二級緩存
深入了解MyBatis二級緩存
一、創建Cache的完整過程
我們從SqlSessionFactoryBuilder解析mybatis-config.xml配置文件開始：
Reader reader = Resources.getResourceAsReader("mybatis-config.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
然後是：
XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
return build(parser.parse());
看parser.parse()方法：
parseConfiguration(parser.evalNode("/configuration"));
看處理Mapper.xml文件的位置：
mapperElement(root.evalNode("mappers"));
看處理Mapper.xml的XMLMapperBuilder：
XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration,
resource, configuration.getSqlFragments());
mapperParser.parse();
繼續看parse方法：
configurationElement(parser.evalNode("/mapper"));
到這里：
String namespace = context.getStringAttribute("namespace");
if (namespace.equals("")) {
throw new BuilderException("Mapper's namespace cannot be empty");
}
builderAssistant.setCurrentNamespace(namespace);
cacheRefElement(context.evalNode("cache-ref"));
cacheElement(context.evalNode("cache"));
從這里看到namespace就是xml中<mapper>元素的屬性。然後下面是先後處理的cache-ref和cache，後面的cache會覆蓋前面的cache-ref，但是如果一開始cache-ref沒有找到引用的cache，他就不會被覆蓋，會一直到最後處理完成為止，最後如果存在cache，反而會被cache-ref覆蓋。這里是不是看著有點暈、有點亂看所以千萬別同時配置這兩個，實際上也很少有人會這么做。
看看MyBatis如何處理<cache/>：
private void cacheElement(XNode context) throws Exception {
if (context != null) {
String type = context.getStringAttribute("type", "PERPETUAL");
Class<? extends Cache> typeClass = typeAliasRegistry.resolveAlias(type);
String eviction = context.getStringAttribute("eviction", "LRU");
Class<? extends Cache> evictionClass = typeAliasRegistry.resolveAlias(eviction);
Long flushInterval = context.getLongAttribute("flushInterval");
Integer size = context.getIntAttribute("size");
boolean readWrite = !context.getBooleanAttribute("readOnly", false);
boolean blocking = context.getBooleanAttribute("blocking", false);
Properties props = context.getChildrenAsProperties();
builderAssistant.useNewCache(typeClass, evictionClass,
flushInterval, size, readWrite, blocking, props);
}
}
從源碼可以看到MyBatis讀取了那些屬性，而且很容易可以到這些屬性的默認值。
創建Java的cache對象方法為builderAssistant.useNewCache，我們看看這段代碼：
public Cache useNewCache(Class<? extends Cache> typeClass,
Class<? extends Cache> evictionClass,
Long flushInterval,
Integer size,
boolean readWrite,
boolean blocking,
Properties props) {
typeClass = valueOrDefault(typeClass, PerpetualCache.class);
evictionClass = valueOrDefault(evictionClass, LruCache.class);
Cache cache = new CacheBuilder(currentNamespace)
.implementation(typeClass)
.addDecorator(evictionClass)
.clearInterval(flushInterval)
.size(size)
.readWrite(readWrite)
.blocking(blocking)
.properties(props)
.build();
configuration.addCache(cache);
currentCache = cache;
return cache;
}
從調用該方法的地方，我們可以看到並沒有使用返回值cache，在後面的過程中創建MappedStatement的時候使用了currentCache。
二、使用Cache過程
在系統中，使用Cache的地方在CachingExecutor中：
@Override
public <E> List<E> query(
MappedStatement ms, Object parameterObject,
RowBounds rowBounds, ResultHandler resultHandler,
CacheKey key, BoundSql boundSql) throws SQLException {
Cache cache = ms.getCache();
獲取cache後，先判斷是否有二級緩存。
只有通過<cache/>,<cache-ref/>或@CacheNamespace,@CacheNamespaceRef標記使用緩存的Mapper.xml或Mapper介面（同一個namespace，不能同時使用）才會有二級緩存。
if (cache != null) {
如果cache存在，那麼會根據sql配置(<insert>,<select>,<update>,<delete>的flushCache屬性來確定是否清空緩存。
flushCacheIfRequired(ms);
然後根據xml配置的屬性useCache來判斷是否使用緩存(resultHandler一般使用的默認值，很少會null)。
if (ms.isUseCache() && resultHandler == null) {
確保方法沒有Out類型的參數，mybatis不支持存儲過程的緩存，所以如果是存儲過程，這里就會報錯。
ensureNoOutParams(ms, parameterObject, boundSql);
沒有問題後，就會從cache中根據key來取值：
@SuppressWarnings("unchecked")
List<E> list = (List<E>) tcm.getObject(cache, key);
如果沒有緩存，就會執行查詢，並且將查詢結果放到緩存中。
if (list == null) {
list = delegate.<E>query(ms, parameterObject,
rowBounds, resultHandler, key, boundSql);
tcm.putObject(cache, key, list); // issue #578 and #116
}
返回結果
return list;
}
}
沒有緩存時，直接執行查詢
return delegate.<E>query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}
在上面的代碼中tcm.putObject(cache, key, list);這句代碼是緩存了結果。但是實際上直到sqlsession關閉，MyBatis才以序列化的形式保存到了一個Map（默認的緩存配置）中。
三、Cache使用時的注意事項
1. 只能在【只有單表操作】的表上使用緩存
不只是要保證這個表在整個系統中只有單表操作，而且和該表有關的全部操作必須全部在一個namespace下。
2. 在可以保證查詢遠遠大於insert,update,delete操作的情況下使用緩存
這一點不需要多說，所有人都應該清楚。記住，這一點需要保證在1的前提下才可以！
四、避免使用二級緩存
可能會有很多人不理解這里，二級緩存帶來的好處遠遠比不上他所隱藏的危害。
緩存是以namespace為單位的，不同namespace下的操作互不影響。
insert,update,delete操作會清空所在namespace下的全部緩存。
通常使用MyBatis Generator生成的代碼中，都是各個表獨立的，每個表都有自己的namespace。
為什麼避免使用二級緩存
在符合【Cache使用時的注意事項】的要求時，並沒有什麼危害。
其他情況就會有很多危害了。
針對一個表的某些操作不在他獨立的namespace下進行。
例如在UserMapper.xml中有大多數針對user表的操作。但是在一個XXXMapper.xml中，還有針對user單表的操作。
這會導致user在兩個命名空間下的數據不一致。如果在UserMapper.xml中做了刷新緩存的操作，在XXXMapper.xml中緩存仍然有效，如果有針對user的單表查詢，使用緩存的結果可能會不正確。
更危險的情況是在XXXMapper.xml做了insert,update,delete操作時，會導致UserMapper.xml中的各種操作充滿未知和風險。
有關這樣單表的操作可能不常見。但是你也許想到了一種常見的情況。
多表操作一定不能使用緩存
為什麼不能看
首先不管多表操作寫到那個namespace下，都會存在某個表不在這個namespace下的情況。
例如兩個表：role和user_role，如果我想查詢出某個用戶的全部角色role，就一定會涉及到多表的操作。
<select id="selectUserRoles" resultType="UserRoleVO">
select * from user_role a,role b where a.roleid = b.roleid and a.userid = #{userid}
</select>123123
像上面這個查詢，你會寫到那個xml中呢看看
不管是寫到RoleMapper.xml還是UserRoleMapper.xml，或者是一個獨立的XxxMapper.xml中。如果使用了二級緩存，都會導致上面這個查詢結果可能不正確。
如果你正好修改了這個用戶的角色，上面這個查詢使用緩存的時候結果就是錯的。
這點應該很容易理解。
在我看來，就以MyBatis目前的緩存方式來看是無解的。多表操作根本不能緩存。
如果你讓他們都使用同一個namespace（通過<cache-ref>）來避免臟數據，那就失去了緩存的意義。
看到這里，實際上就是說，二級緩存不能用。整篇文章介紹這么多也沒什麼用了。
五、挽救二級緩存看
想更高效率的使用二級緩存是解決不了了。
但是解決多表操作避免臟數據還是有法解決的。解決思路就是通過攔截器判斷執行的sql涉及到那些表（可以用jsqlparser解析），然後把相關表的緩存自動清空。但是這種方式對緩存的使用效率是很低的。
設計這樣一個插件是相當復雜的，既然我沒想著去實現，就不廢話了。
最後還是建議，放棄二級緩存，在業務層使用可控制的緩存代替更好。
Ⅳ mybatis的緩存有幾種
1、一級緩存
MyBatis默認開啟了一級緩存，一級緩存是在SqlSession 層面進行緩存的。即，同一個SqlSession ，多次調用同一個Mapper和同一個方法的同一個參數，只會進行一次資料庫查詢，然後把數據緩存到緩沖中，以後直接先從緩存中取出數據，不會直接去查資料庫。
但是不同的SqlSession對象，因為不用的SqlSession都是相互隔離的，所以相同的Mapper、參數和方法，他還是會再次發送到SQL到資料庫去執行，返回結果。
2、二級緩存
為了克服這個問題，需要開啟二級緩存，是的緩存zaiSqlSessionFactory層面給各個SqlSession 對象共享。默認二級緩存是不開啟的，需要手動進行配置。
<cache/>
如果這樣配置的話，很多其他的配置就會被默認進行，如：
映射文件所有的select 語句會被緩存
映射文件的所有的insert、update和delete語句會刷新緩存
緩存會使用默認的Least Recently Used（LRU，最近最少使用原則）的演算法來回收緩存空間
根據時間表，比如No Flush Interval，（CNFI，沒有刷新間隔），緩存不會以任何時間順序來刷新
緩存會存儲列表集合或對象（無論查詢方法返回什麼）的1024個引用
緩存會被視為是read/write（可讀/可寫）的緩存，意味著對象檢索不是共享的，而且可以很安全的被調用者修改，不幹擾其他調用者或縣城所作的潛在修改
- <cache eviction="LRU" flushInterval="100000" size="1024" readOnly="true"/>
eviction：緩存回收策略
- LRU：最少使用原則，移除最長時間不使用的對象
- FIFO：先進先出原則，按照對象進入緩存順序進行回收
- SOFT：軟引用，移除基於垃圾回收器狀態和軟引用規則的對象
- WEAK：弱引用，更積極的移除移除基於垃圾回收器狀態和弱引用規則的對象flushInterval：刷新時間間隔，單位為毫秒，這里配置的100毫秒。如果不配置，那麼只有在進行資料庫修改操作才會被動刷新緩存區
size：引用額數目，代表緩存最多可以存儲的對象個數
readOnly：是否只讀，如果為true，則所有相同的sql語句返回的是同一個對象（有助於提高性能，但並發操作同一條數據時，可能不安全），如果設置為false，則相同的sql，後面訪問的是cache的clone副本。
useCache配置
如果一條語句每次都需要最新的數據，就意味著每次都需要從資料庫中查詢數據，可以把這個屬性設置為false，如：
- <select id="selectAll" resultMap="BaseResultMap" useCache="false">
刷新緩存（就是清空緩存）
二級緩存默認會在insert、update、delete操作後刷新緩存，可以手動配置不更新緩存，如下：
- <update id="updateById" parameterType="User" flushCache="false" />
可以在開啟二級緩存時候，手動配置一些屬性
各個屬性意義如下：
可以在Mapper的具體方法下設置對二級緩存的訪問意願：
3、自定義緩存
自定義緩存對象，該對象必須實現 org.apache.ibatis.cache.Cache 介面
每次查詢資料庫前，MyBatis都會先在緩存中查找是否有該緩存對象。只有當調用了commit() 方法，MyBatis才會往緩存中寫入數據，數據記錄的鍵為數字編號+Mapper名+方法名+SQL語句+參數格式，值為返回的對象值。
Ⅳ 問問大神，請問mybatis和hibernate的區別
首先簡單介紹下兩者的概念：
Hibernate ：Hibernate 是當前最流行的ORM框架，對資料庫結構提供了較為完整的封裝。
Mybatis：Mybatis同樣也是非常流行的ORM框架，主要著力點在於POJO 與SQL之間的映射關系。
其次具體從幾個方面說一下兩者的區別：
1.兩者最大的區別：
針對簡單邏輯，Hibernate和MyBatis都有相應的代碼生成工具，可以生成簡單基本的DAO層方法。
針對高級查詢，Mybatis需要手動編寫SQL語句，以及ResultMap。而Hibernate有良好的映射機制，開發者無需關心SQL的生成與結果映射，可以更專注於業務流程。
2.開發難度對比
Hibernate的開發難度要大於Mybatis。主要由於Hibernate比較復雜、龐大，學習周期較長。
而Mybatis則相對簡單一些，並且Mybatis主要依賴於sql的書寫，讓開發者感覺更熟悉。
3.sql書寫比較
Mybatis的SQL是手動編寫的，所以可以按需求指定查詢的欄位。不過沒有自己的日誌統計，所以要藉助log4j來記錄日誌。
Hibernate也可以自己寫SQL來指定需要查詢的欄位，但這樣就破壞了Hibernate開發的簡潔性。不過Hibernate具有自己的日誌統計。
4.資料庫擴展性比較
Mybatis由於所有SQL都是依賴資料庫書寫的，所以擴展性，遷移性比較差。
Hibernate與資料庫具體的關聯都在XML中，所以HQL對具體是用什麼資料庫並不是很關心。
5.緩存機制比較
相同點：Hibernate和Mybatis的二級緩存除了採用系統默認的緩存機制外，都可以通過實現你自己的緩存或為其他第三方緩存方案，創建適配器來完全覆蓋緩存行為。
不同點：Hibernate的二級緩存配置在SessionFactory生成的配置文件中進行詳細配置，然後再在具體的表-對象映射中配置是那種緩存。
MyBatis的二級緩存配置都是在每個具體的表-對象映射中進行詳細配置，這樣針對不同的表可以自定義不同的緩存機制。並且Mybatis可以在命名空間中共享相同的緩存配置和實例，通過Cache-ref來實現。
兩者比較：因為Hibernate對查詢對象有著良好的管理機制，用戶無需關心SQL。所以在使用二級緩存時如果出現臟數據，系統會報出錯誤並提示。
而MyBatis在這一方面，使用二級緩存時需要特別小心。如果不能完全確定數據更新操作的波及范圍，避免Cache的盲目使用。否則，臟數據的出現會給系統的正常運行帶來很大的隱患。
6.總結：
Hibernate與MyBatis都可以是通過SessionFactoryBuider由XML配置文件生成SessionFactory，然後由SessionFactory 生成Session，最後由Session來開啟執行事務和SQL語句。
而MyBatis的優勢是MyBatis可以進行更為細致的SQL優化，可以減少查詢欄位，並且容易掌握。
Hibernate的優勢是DAO層開發比MyBatis簡單，Mybatis需要維護SQL和結果映射。資料庫移植性很好，MyBatis的資料庫移植性不好，不同的資料庫需要寫不同SQL。有更好的二級緩存機制，可以使用第三方緩存。MyBatis本身提供的緩存機制不佳。
參考博客：http://blog.csdn.net/julinfeng/article/details/19821923
Ⅵ 如何使用mybatis的二級緩存
一般來說，一級緩存可以分為一級數據緩存（Data Cache，D-Cache）和一級指令緩存（Instruction Cache，I-Cache）。二者分別用來存放數據以及對執行這些數據的指令進行即時解碼，而且兩者可以同時被CPU訪問，減少了爭用Cache所造成的沖突，提高了。
Ⅶ 請簡述MyBatis和Hibernate的區別。
答：Hibernate和Mybatis都是orm對象關系映射框架，都是用於將數據持久化的框架技術。
Hiberante較深度的封裝了jdbc，對開發者寫sql的能力要求的不是那麼的高，我們只要通過hql語句操作對象即可完成對數據持久化的操作了。
另外hibernate可移植性好，如一個項目開始使用的是mysql資料庫，但是隨著業務的發展，現mysql資料庫已經無法滿足當前的綉球了，現在決定使用Oracle資料庫，雖然sql標準定義的資料庫間的sql語句差距不大，但是不同的資料庫sql標准還是有差距的，那麼我們手動修改起來會存在很大的困難，使用hibernate只需改變一下資料庫方言即可搞定。用hibernate框架，資料庫的移植變的非常方便。
但是hibernate也存在著諸多的不足，比如在實際開發過程中會生成很多不必要的sql語句耗費程序資源，優化起來也不是很方便，且對存儲過程支持的也不夠太強大。但是針對於hibernate它也提供了一些優化策略，比如說懶載入、緩存、策略模式等都是針對於它的優化方案。
Mybatis 也是對jdbc的封裝，但是封裝的沒有hibernate那麼深，我們可以再配置文件中寫sql語句，可以根據需求定製sql語句，數據優化起來較hibernate容易很多。
Mybatis要求程序員寫sql的能力要相對使用hibernate的開發人員要高的多，且可移植性也不是很好。
涉及到大數據的系統使用Mybatis比較好，因為優化較方便。涉及的數據量不是很大且對優化沒有那麼高，可以使用hibernate