最近由於受工作中業務需要和現有工程中dao層非orm思想的影響，覺得在有些業務場景下，並不一定非要去使用ORM框架，畢竟寫大量的實體類也是一件麻煩的事，於是著手編寫一個非ORM框架。初步完成後，底層的session並沒能像mybatis那樣能支援session的一級快取（雖然在和Spring整合之後，Mybatis的session的一級快取並沒起什麼作用），so，通過看原始碼大致瞭解一哈Mybatis中session的一級快取實現。

Mybatis是一個很輕量也很強大的ORM框架（這並不影響我學習來開發非ORM框架），但她的一級快取的實現則不是那麼複雜。首先我們知道，Mybatis在每次開啟資料庫會話時，都會建立一個sqlsession物件，下面看一段預設sessionfactory建立預設session時的程式碼

private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
    Transaction tx = null;
    try {
      final Environment environment = configuration.getEnvironment();
      final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
      tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
      final Executor executor = configuration.newExecutor(tx, execType);
      return new DefaultSqlSession(configuration, executor, autoCommit);
    } catch (Exception e) {
      closeTransaction(tx); // may have fetched a connection so lets call close()
      throw ExceptionFactory.wrapException("Error opening session.  Cause: " + e, e);
    } finally {
      ErrorContext.instance().reset();
    }
  }
 

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;
  }

public class PerpetualCache implements Cache {

  private String id;

  private Map<Object, Object> cache = new HashMap<Object, Object>();

  public PerpetualCache(String id) {
    this.id = id;
  }

  public String getId() {
    return id;
  }

  public int getSize() {
    return cache.size();
  }

  public void putObject(Object key, Object value) {
    cache.put(key, value);
  }

  public Object getObject(Object key) {
    return cache.get(key);
  }

  public Object removeObject(Object key) {
    return cache.remove(key);
  }

  public void clear() {
    cache.clear();
  }

  public ReadWriteLock getReadWriteLock() {
    return null;
  }

  public boolean equals(Object o) {
    if (getId() == null) throw new CacheException("Cache instances require an ID.");
    if (this == o) return true;
    if (!(o instanceof Cache)) return false;

    Cache otherCache = (Cache) o;
    return getId().equals(otherCache.getId());
  }

  public int hashCode() {
    if (getId() == null) throw new CacheException("Cache instances require an ID.");
    return getId().hashCode();
  }

}

是不是有點驚訝，就這點程式碼，內部其實就是一個HashMap來簡單實現的，回想一下，常說session的一級快取是執行緒不安全的，看到這裡就有點恍然了，HashMap可不就是執行緒不安全的嗎，類中的方法也基本上是對hashmap的操作，id屬性其實一個標識。。比如上面的程式碼中new PerpetualCache("LocalCache")，僅僅就是告訴你這是本地的一級快取。好，既然涉及到了hashmap，那麼就不得不想到如何保證鍵即key的唯一性，也由於查詢的一些東西存在key中，結果存在value裡，也進而要問，對啊，你一級快取不就是為了讓我重複查的時候直接從快取裡取唄，那你怎麼判斷兩次查詢是完全相同的查詢？帶著疑問，我們繼續看BaseExecutor，由於是隻有在查詢時才會去快取裡找，所以去找關於查詢的程式碼：

public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
    BoundSql boundSql = ms.getBoundSql(parameter);
    CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
    return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
 }

public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) {
    if (closed) throw new ExecutorException("Executor was closed.");
    CacheKey cacheKey = new CacheKey();
    cacheKey.update(ms.getId());
    cacheKey.update(rowBounds.getOffset());
    cacheKey.update(rowBounds.getLimit());
    cacheKey.update(boundSql.getSql());
    List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
    TypeHandlerRegistry typeHandlerRegistry = ms.getConfiguration().getTypeHandlerRegistry();
    for (int i = 0; i < parameterMappings.size(); i++) { // mimic DefaultParameterHandler logic
      ParameterMapping parameterMapping = parameterMappings.get(i);
      if (parameterMapping.getMode() != ParameterMode.OUT) {
        Object value;
        String propertyName = parameterMapping.getProperty();
        if (boundSql.hasAdditionalParameter(propertyName)) {
          value = boundSql.getAdditionalParameter(propertyName);
        } else if (parameterObject == null) {
          value = null;
        } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
          value = parameterObject;
        } else {
          MetaObject metaObject = configuration.newMetaObject(parameterObject);
          value = metaObject.getValue(propertyName);
        }
        cacheKey.update(value);
      }
    }
    return cacheKey;
  }  

我們看到定義了一個CacheKey物件，並呼叫update方法，再點進去看下CacheKey中的update方法：

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);
    }
  }

  private void doUpdate(Object object) {
    int baseHashCode = object == null ? 1 : object.hashCode();

    count++;
    checksum += baseHashCode;
    baseHashCode *= count;

    hashcode = multiplier * hashcode + baseHashCode;

    updateList.add(object);
  }

在這個類中，還有兩個屬性，就是hashcode和updateList，hashcode就是這個key的hashcode，而updateList則儲存影響hashcode計算的條件，從上面可以看到有ms.getId()、getOffSet()、getLimit()、getSql()、parameter，即mybatis的mapper對應的statement的id、分頁的範圍、sql語句、設定的引數，即判斷兩次查詢是相同的查詢的條件就是以上四個條件，通過這四個條件來生成key，對應查詢的結果，在查詢的時候通過list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;來獲取。

     以上基本上就是mybatis的session一級快取的基本實現原理，當然除了存取快取之外，mybatis還提供瞭如clearLocalCache()這樣的介面方法來手動清除快取。在瞭解了上面的原理之後，其實mybatis的一級快取還是有不少不完善的地方，比如這個在資料庫資料通過別的途徑發生更改時，快取不能做到更新，所以資料的操作最好只能在一個session中，還有前面說的session執行緒不安全的問題，不過這個在spring整合時得到了解決，spring注入了一個執行緒安全的session，這個以後有時間再仔細看看原始碼再寫篇部落格來討論。