javaredis緩存用法，mybatis 遍歷map_Mybatis 緩存系統源碼解析

public interface Cache {//獲取緩存的id，即 namespaceString getId();// 添加緩存void putObject(Object key, Object value);//根據key來獲取緩存對應的值Object getObject(Object key);// 刪除key對應的緩存Object removeObject(Object key);// 清空緩存  void clear();// 獲取緩存中數據的大小int getSize();//取得讀寫鎖, 從3.2.6開始沒用了ReadWriteLock getReadWriteLock();
}

public class PerpetualCache implements Cache {// id,一般對應mapper.xml 的namespace 的值private String id;// 用來存放數據，即緩存底層就是使用 map 來實現的private Map<Object, Object> cache = new HashMap<Object, Object>();public PerpetualCache(String id) {this.id = id;}//......其他的getter方法.....// 添加緩存@Overridepublic void putObject(Object key, Object value) {cache.put(key, value);}// 獲取緩存@Overridepublic Object getObject(Object key) {return cache.get(key);}// 刪除緩存@Overridepublic Object removeObject(Object key) {return cache.remove(key);}// 清空緩存@Overridepublic void clear() {cache.clear();}
}

public class CacheKey implements Cloneable, Serializable {private static final int DEFAULT_MULTIPLYER = 37;private static final int DEFAULT_HASHCODE = 17;// 參與計算hashcode，默認值為37private int multiplier;// CacheKey 對象的 hashcode ，默認值 17private int hashcode;// 檢驗和 private long checksum;// updateList 集合的個數private int count;// 由該集合中的所有對象來共同決定兩個 CacheKey 是否相等private List<Object> updateList;public int getUpdateCount() {return updateList.size();}// 調用該方法，向 updateList 集合添加對應的對象public void update(Object object) {if (object != null && object.getClass().isArray()) {// 如果是數組，則循環處理每一項int length = Array.getLength(object);for (int i = 0; i < length; i++) {Object element = Array.get(object, i);doUpdate(element);}} else {doUpdate(object);}}// 計算 count checksum hashcode 和把對象添加到 updateList 集合中private void doUpdate(Object object) {int baseHashCode = object == null ? 1 : object.hashCode();count++;checksum += baseHashCode;baseHashCode *= count;hashcode = multiplier * hashcode + baseHashCode;updateList.add(object);}// 判斷兩個 CacheKey 是否相等@Overridepublic boolean equals(Object object) {if (this == object) {return true;}if (!(object instanceof CacheKey)) {return false;}final CacheKey cacheKey = (CacheKey) object;if (hashcode != cacheKey.hashcode) {return false;}if (checksum != cacheKey.checksum) {return false;}if (count != cacheKey.count) {return false;}// 如果前幾項都不滿足，則循環遍歷 updateList 集合，判斷每一項是否相等，如果有一項不相等則這兩個CacheKey不相等for (int i = 0; i < updateList.size(); i++) {Object thisObject = updateList.get(i);Object thatObject = cacheKey.updateList.get(i);if (thisObject == null) {if (thatObject != null) {return false;}} else {if (!thisObject.equals(thatObject)) {return false;}}}return true;}@Overridepublic int hashCode() {return hashcode;}
}

 public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) {//cacheKey 對象 CacheKey cacheKey = new CacheKey();// 向 updateList 存入idcacheKey.update(ms.getId());// 存入offsetcacheKey.update(rowBounds.getOffset());// 存入limitcacheKey.update(rowBounds.getLimit());// 存入sqlcacheKey.update(boundSql.getSql());List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();TypeHandlerRegistry typeHandlerRegistry = ms.getConfiguration().getTypeHandlerRegistry();for (ParameterMapping parameterMapping : parameterMappings) {if (parameterMapping.getMode() != ParameterMode.OUT) {String propertyName = parameterMapping.getProperty();MetaObject metaObject = configuration.newMetaObject(parameterObject);Object  value = metaObject.getValue(propertyName);// 存入每一個參數cacheKey.update(value);}}if (configuration.getEnvironment() != null) {// 存入 environmentIdcacheKey.update(configuration.getEnvironment().getId());}return cacheKey;}

public interface Executor {ResultHandler NO_RESULT_HANDLER = null;// insert | update | delete 的操作方法int update(MappedStatement ms, Object parameter) throws SQLException;// 查詢，帶分頁，帶緩存  <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey cacheKey, BoundSql boundSql) throws SQLException;// 查詢，帶分頁 <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException;// 查詢存儲過程<E> Cursor<E> queryCursor(MappedStatement ms, Object parameter, RowBounds rowBounds) throws SQLException;//刷新批處理語句List<BatchResult> flushStatements() throws SQLException;// 事務提交void commit(boolean required) throws SQLException;// 事務回滾void rollback(boolean required) throws SQLException;// 創建緩存的keyCacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql);// 是否緩存boolean isCached(MappedStatement ms, CacheKey key);// 清空緩存void clearLocalCache();// 延遲加載void deferLoad(MappedStatement ms, MetaObject resultObject, String property, CacheKey key, Class<?> targetType);// 獲取事務Transaction getTransaction();
}

public abstract class BaseExecutor implements Executor {// 事務，提交，回滾，關閉事務protected Transaction transaction;// 底層的 Executor 對象protected Executor wrapper;// 延遲加載隊列protected ConcurrentLinkedQueue<DeferredLoad> deferredLoads;// 一級緩存，用于緩存查詢結果protected PerpetualCache localCache;// 一級緩存，用于緩存輸出類型參數（存儲過程）protected PerpetualCache localOutputParameterCache;protected Configuration configuration;// 用來記錄嵌套查詢的層數protected int queryStack;private boolean closed;protected BaseExecutor(Configuration configuration, Transaction transaction) {this.transaction = transaction;this.deferredLoads = new ConcurrentLinkedQueue<DeferredLoad>();this.localCache = new PerpetualCache("LocalCache");this.localOutputParameterCache = new PerpetualCache("LocalOutputParameterCache");this.closed = false;this.configuration = configuration;this.wrapper = this;}
// 4 個抽象方法，由子類實現，模板方法中可變部分protected abstract int doUpdate(MappedStatement ms, Object parameter)throws SQLException;protected abstract List<BatchResult> doFlushStatements(boolean isRollback) throws SQLException;protected abstract <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql)throws SQLException;protected abstract <E> Cursor<E> doQueryCursor(MappedStatement ms, Object parameter, RowBounds rowBounds, BoundSql boundSql)throws SQLException;// 執行 insert | update | delete 語句，調用 doUpdate 方法實現,在執行這些語句的時候，會清空緩存public int update(MappedStatement ms, Object parameter) throws SQLException {// ....// 清空緩存clearLocalCache();// 執行SQL語句return doUpdate(ms, parameter);}// 刷新批處理語句，且執行緩存中還沒執行的SQL語句@Overridepublic List<BatchResult> flushStatements() throws SQLException {return flushStatements(false);}public List<BatchResult> flushStatements(boolean isRollBack) throws SQLException {// ...// doFlushStatements 的 isRollBack 參數表示是否執行緩存中的SQL語句，false表示執行，true表示不執行return doFlushStatements(isRollBack);}// 查詢存儲過程@Overridepublic <E> Cursor<E> queryCursor(MappedStatement ms, Object parameter, RowBounds rowBounds) throws SQLException {BoundSql boundSql = ms.getBoundSql(parameter);return doQueryCursor(ms, parameter, rowBounds, boundSql);}// 事務的提交和回滾@Overridepublic void commit(boolean required) throws SQLException {// 清空緩存clearLocalCache();// 刷新批處理語句，且執行緩存中的QL語句flushStatements();if (required) {transaction.commit();}}@Overridepublic void rollback(boolean required) throws SQLException {if (!closed) {try {// 清空緩存clearLocalCache();// 刷新批處理語句，且不執行緩存中的SQLflushStatements(true);} finally {if (required) {transaction.rollback();}}}}

 @Overridepublic <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {// 獲取查詢SQLBoundSql boundSql = ms.getBoundSql(parameter);// 創建緩存的key，創建邏輯在 CacheKey中已經分析過了CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);// 執行查詢return query(ms, parameter, rowBounds, resultHandler, key, boundSql);}// 執行查詢邏輯public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {// ....if (queryStack == 0 && ms.isFlushCacheRequired()) {// 如果不是嵌套查詢，且 <select> 的 flushCache=true 時才會清空緩存clearLocalCache();}List<E> list;try {// 嵌套查詢層數加1queryStack++;// 首先從一級緩存中進行查詢list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;if (list != null) {// 如果命中緩存，則處理存儲過程handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);} else {// 如果緩存中沒有對應的數據，則查數據庫中查詢數據list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);}} finally {queryStack--;}// ... 處理延遲加載的相關邏輯return list;}// 從數據庫查詢數據private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {List<E> list;// 在緩存中添加占位符localCache.putObject(key, EXECUTION_PLACEHOLDER);try {// 查庫操作，由子類實現list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);} finally {// 刪除占位符localCache.removeObject(key);}// 將從數據庫查詢的結果添加到一級緩存中localCache.putObject(key, list);// 處理存儲過程if (ms.getStatementType() == StatementType.CALLABLE) {localOutputParameterCache.putObject(key, parameter);}return list;}

public class TransactionalCache implements Cache {// 底層封裝的二級緩存對應的Cache對象private Cache delegate;// 為true時，表示當前的 TransactionalCache 不可查詢，且提交事務時會清空緩存private boolean clearOnCommit;// 存放需要添加到二級緩存中的數據private Map<Object, Object> entriesToAddOnCommit;// 存放為命中緩存的 CacheKey 對象private Set<Object> entriesMissedInCache;public TransactionalCache(Cache delegate) {this.delegate = delegate;this.clearOnCommit = false;this.entriesToAddOnCommit = new HashMap<Object, Object>();this.entriesMissedInCache = new HashSet<Object>();}// 添加緩存數據的時候，先暫時放到 entriesToAddOnCommit 集合中，在事務提交的時候，再把數據放入到二級緩存中，避免臟數據@Overridepublic void putObject(Object key, Object object) {entriesToAddOnCommit.put(key, object);}// 提交事務，public void commit() {if (clearOnCommit) {delegate.clear();}// 把 entriesToAddOnCommit  集合中的數據放入到二級緩存中flushPendingEntries();reset();}// 把 entriesToAddOnCommit  集合中的數據放入到二級緩存中private void flushPendingEntries() {for (Map.Entry<Object, Object> entry : entriesToAddOnCommit.entrySet()) {// 放入到二級緩存中delegate.putObject(entry.getKey(), entry.getValue());}for (Object entry : entriesMissedInCache) {if (!entriesToAddOnCommit.containsKey(entry)) {delegate.putObject(entry, null);}}}// 事務回滾public void rollback() {// 把未命中緩存的數據清除掉unlockMissedEntries();reset();}private void unlockMissedEntries() {for (Object entry : entriesMissedInCache) {delegate.removeObject(entry);}}

public class TransactionalCacheManager {//用來管理 CachingExecutor 使用的二級緩存// key 為對應的CachingExecutor 使用的二級緩存// value 為對應的 TransactionalCache 對象private Map<Cache, TransactionalCache> transactionalCaches = new HashMap<Cache, TransactionalCache>();public void clear(Cache cache) {getTransactionalCache(cache).clear();}public Object getObject(Cache cache, CacheKey key) {return getTransactionalCache(cache).getObject(key);}  public void putObject(Cache cache, CacheKey key, Object value) {getTransactionalCache(cache).putObject(key, value);}public void commit() {for (TransactionalCache txCache : transactionalCaches.values()) {txCache.commit();}}public void rollback() {for (TransactionalCache txCache : transactionalCaches.values()) {txCache.rollback();}}// 所有的調用都會調用 TransactionalCache 的方法來實現private TransactionalCache getTransactionalCache(Cache cache) {TransactionalCache txCache = transactionalCaches.get(cache);if (txCache == null) {txCache = new TransactionalCache(cache);transactionalCaches.put(cache, txCache);}return txCache;}}

public class CachingExecutor implements Executor {// 底層的 Executorprivate Executor delegate;private TransactionalCacheManager tcm = new TransactionalCacheManager();// 查詢方法@Overridepublic <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {// 獲取 SQLBoundSql boundSql = ms.getBoundSql(parameterObject);// 創建緩存key，在CacheKey中已經分析過創建過程CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);}// 查詢public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)throws SQLException {// 獲取查詢語句所在namespace對應的二級緩存Cache cache = ms.getCache();// 是否開啟了二級緩存if (cache != null) {// 根據 <select> 的屬性 useCache 的配置，決定是否需要清空二級緩存flushCacheIfRequired(ms);if (ms.isUseCache() && resultHandler == null) {// 二級緩存不能保存輸出參數，否則拋異常ensureNoOutParams(ms, parameterObject, boundSql);// 從二級緩存中查詢對應的值List<E> list = (List<E>) tcm.getObject(cache, key);if (list == null) {// 如果二級緩存沒有命中，則調用底層的 Executor 查詢，其中會先查詢一級緩存，一級緩存也未命中，才會去查詢數據庫list = delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);// 查詢到的數據放入到二級緩存中去tcm.putObject(cache, key, list); // issue #578 and #116}return list;}}// 如果沒有開啟二級緩存，則直接調用底層的 Executor 查詢，還是會先查一級緩存return delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);}

public class SynchronizedCache implements Cache {private Cache delegate;public SynchronizedCache(Cache delegate) {this.delegate = delegate;}@Overridepublic synchronized int getSize() {return delegate.getSize();}@Overridepublic synchronized void putObject(Object key, Object object) {delegate.putObject(key, object);}@Overridepublic synchronized Object getObject(Object key) {return delegate.getObject(key);}@Overridepublic synchronized Object removeObject(Object key) {return delegate.removeObject(key);}// ............
}
接下來看下添加 Cache 裝飾器的方法，在 CacheBuilder.build() 方法中進行添加：
public class CacheBuilder {//...........// 創建緩存public Cache build() {// 設置緩存的實現類setDefaultImplementations();Cache cache = newBaseCacheInstance(implementation, id);setCacheProperties(cache);// 添加裝飾器類if (PerpetualCache.class.equals(cache.getClass())) {for (Class<? extends Cache> decorator : decorators) {cache = newCacheDecoratorInstance(decorator, cache);setCacheProperties(cache);}// 為 Cache 添加裝飾器cache = setStandardDecorators(cache);} else if (!LoggingCache.class.isAssignableFrom(cache.getClass())) {cache = new LoggingCache(cache);}return cache;}// 設置 Cache 的默認實現類為 PerpetualCacheprivate void setDefaultImplementations() {if (implementation == null) {implementation = PerpetualCache.class;if (decorators.isEmpty()) {decorators.add(LruCache.class);}}}// 添加裝飾器private Cache setStandardDecorators(Cache cache) {try {// 添加 ScheduledCache 裝飾器if (clearInterval != null) {cache = new ScheduledCache(cache);((ScheduledCache) cache).setClearInterval(clearInterval);}// 添加SerializedCache裝飾器if (readWrite) {cache = new SerializedCache(cache);}// 添加 LoggingCache 裝飾器cache = new LoggingCache(cache);// 添加  SynchronizedCache 裝飾器，保證線程安全cache = new SynchronizedCache(cache);if (blocking) {// 添加 BlockingCache 裝飾器cache = new BlockingCache(cache);}return cache;}
}