MyBatis 的一级缓存和二级缓存

public interface Cache {
  String getId();
  int getSize();
  void putObject(Object key, Object value);
  Object getObject(Object key);
  boolean hasKey(Object key);
  Object removeObject(Object key);
  void clear();
}

package org.apache.ibatis.cache.impl;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReadWriteLock;
import org.apache.ibatis.cache.Cache;
import org.apache.ibatis.cache.CacheException;
/**
 * @author Clinton Begin
 */
public class PerpetualCache implements Cache {
  private String id;
  private Map<Object, Object> cache = new HashMap<Object, Object>();
  public PerpetualCache(String id) {
    this.id = id;
  }
  @Override
  public String getId() {
    return id;
  }
  @Override
  public int getSize() {
    return cache.size();
  }
  @Override
  public void putObject(Object key, Object value) {
    cache.put(key, value);
  }
  @Override
  public Object getObject(Object key) {
    return cache.get(key);
  }
  @Override
  public Object removeObject(Object key) {
    return cache.remove(key);
  }
  @Override
  public void clear() {
    cache.clear();
  }
  @Override
  public ReadWriteLock getReadWriteLock() {
    return null;
  }
  @Override
  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());
  }
  @Override
  public int hashCode() {
    if (getId() == null) {
      throw new CacheException("Cache instances require an ID.");
    }
    return getId().hashCode();
  }
}

@Test
public void testCacheOne(){
  /*set auto commit ,which equals to the above*/
  SqlSession session = MybatisUtils.getFactory().openSession(true);
  String statement = "com.web.mapper.userMapper.getUser";
  /*return the effect rows*/
  User user = session.selectOne(statement, 1);
  System.out.println("result.."+user);
//    session.clearCache();
  //测试缓存肯定针对同样的数据，如果id变为2，缓存里面没有。缓存测试无从谈起。
  user = session.selectOne(statement, 1);
  System.out.println("result.."+user);
  System.out.println("***************************************************");
}

@Test
public void testCacheOne(){
  /*set auto commit ,which equals to the above*/
  SqlSession session = MybatisUtils.getFactory().openSession(true);
  String statement = "com.web.mapper.userMapper.getUser";
  User user = session.selectOne(statement, 1);
  System.out.println("result.."+user);
//    session.clearCache();
  user = session.selectOne(statement, 1);
  System.out.println("result.."+user);
  System.out.println("***************************************************");
}

@Test
public void testCacheOne(){
  /*set auto commit ,which equals to the above*/
  SqlSession session = MybatisUtils.getFactory().openSession(true);
  String statement = "com.web.mapper.userMapper.getUser";
  /*return the effect rows*/
  User user = session.selectOne(statement, 1);
  System.out.println("result.."+user);
  session.clearCache();
  user = session.selectOne(statement, 1);
  System.out.println("result.."+user);
  System.out.println("***************************************************");
}

session.update("com.web.mapper.userMapper.updateUser",new User(1, "mili", 21));
session.commit();
user = session.selectOne(statement, 1);
System.out.println("result.."+user);

<!-- flushCache="true" useCache="false" -->
 <select id="getUser" parameterType="int" resultMap="UserMap"  flushCache="true">
   select * from t_user where id=#{id}
 </select>

public @interface CacheNamespace {
  Class<? extends org.apache.ibatis.cache.Cache> implementation() default PerpetualCache.class;
  Class<? extends org.apache.ibatis.cache.Cache> eviction() default LruCache.class;
  long flushInterval() default 0;
  int size() default 1024;
  boolean readWrite() default true;
  boolean blocking() default false;
  /**
   * Property values for a implementation object.
   * @since 3.4.2
   */
  Property[] properties() default {};
}

<mapper namespace="com.web.mapper.userMapper">
  <cache >
    <property name="eviction" value="LRU"/>//回收策略为LRU
    <property name="flushInterval" value="60000"/>//自动刷新时间间隔为60S
    <property name="size" value="1024"/>//最多缓存1024个引用对象
    <property name="readOnly" value="true"/>//只读
  </cache>

public void testCacheTwo(){
  SqlSessionFactory factory = MybatisUtils.getFactory();
  /*注意此处是从一个Factory 获取两个session*/
  SqlSession session1 = factory.openSession();
  SqlSession session2 = factory.openSession();
  String statement = "com.web.mapper.userMapper.getUser";
  /*return the effect rows*/
  User user = session1.selectOne(statement, 1);
  System.out.println("result.."+user);
  //进行提交或者关闭将其数据写入二级缓存，否则将不会写入二级缓存
//    session1.commit();
  session1.close();
  user = session2.selectOne(statement, 1);
  System.out.println("result.."+user);
//    session2.commit();
}

public SqlSessionTemplate(SqlSessionFactory sqlSessionFactory, ExecutorType executorType, PersistenceExceptionTranslator exceptionTranslator) {
        Assert.notNull(sqlSessionFactory, "Property 'sqlSessionFactory' is required");
        Assert.notNull(executorType, "Property 'executorType' is required");
        this.sqlSessionFactory = sqlSessionFactory;
        this.executorType = executorType;
        this.exceptionTranslator = exceptionTranslator;
        this.sqlSessionProxy = (SqlSession)Proxy.newProxyInstance(SqlSessionFactory.class.getClassLoader(), new Class[]{SqlSession.class}, new SqlSessionTemplate.SqlSessionInterceptor());
    }

/**
   * Proxy needed to route MyBatis method calls to the proper SqlSession got from Spring's Transaction Manager It also
   * unwraps exceptions thrown by {@code Method#invoke(Object, Object...)} to pass a {@code PersistenceException} to the
   * {@code PersistenceExceptionTranslator}.
   */
  private class SqlSessionInterceptor implements InvocationHandler {
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
      SqlSession sqlSession = getSqlSession(SqlSessionTemplate.this.sqlSessionFactory,
          SqlSessionTemplate.this.executorType, SqlSessionTemplate.this.exceptionTranslator);
      try {
        Object result = method.invoke(sqlSession, args);
        if (!isSqlSessionTransactional(sqlSession, SqlSessionTemplate.this.sqlSessionFactory)) {
          // force commit even on non-dirty sessions because some databases require
          // a commit/rollback before calling close()
          sqlSession.commit(true);
        }
        return result;
      } catch (Throwable t) {
        Throwable unwrapped = unwrapThrowable(t);
        if (SqlSessionTemplate.this.exceptionTranslator != null && unwrapped instanceof PersistenceException) {
          // release the connection to avoid a deadlock if the translator is no loaded. See issue #22
          closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);
          sqlSession = null;
          Throwable translated = SqlSessionTemplate.this.exceptionTranslator
              .translateExceptionIfPossible((PersistenceException) unwrapped);
          if (translated != null) {
            unwrapped = translated;
          }
        }
        throw unwrapped;
      } finally {
        if (sqlSession != null) {
          closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);
        }
      }
    }
  }

public static SqlSession getSqlSession(SqlSessionFactory sessionFactory, ExecutorType executorType,
      PersistenceExceptionTranslator exceptionTranslator) {
    notNull(sessionFactory, NO_SQL_SESSION_FACTORY_SPECIFIED);
    notNull(executorType, NO_EXECUTOR_TYPE_SPECIFIED);
//在开启事务的情况之下，spring使用`ThreadLocal`获取当前资源绑定同一个`sqlSession`，
//因此此时`一级缓存是有效的`
    SqlSessionHolder holder = (SqlSessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);
    SqlSession session = sessionHolder(executorType, holder);
    if (session != null) {
      return session;
    }
    LOGGER.debug(() -> "Creating a new SqlSession");
    session = sessionFactory.openSession(executorType);
    registerSessionHolder(sessionFactory, executorType, exceptionTranslator, session);
    return session;
  }

  private static SqlSession sessionHolder(ExecutorType executorType, SqlSessionHolder holder) {
    SqlSession session = null;
    if (holder != null && holder.isSynchronizedWithTransaction()) {
      if (holder.getExecutorType() != executorType) {
        throw new TransientDataAccessResourceException(
            "Cannot change the ExecutorType when there is an existing transaction");
      }
      holder.requested();
      LOGGER.debug(() -> "Fetched SqlSession [" + holder.getSqlSession() + "] from current transaction");
      session = holder.getSqlSession();
    }
    return session;
  }

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:noNamespaceSchemaLocation="../config/ehcache.xsd">
 <!-- 磁盘保存路径 -->
 <diskStore path="D:\ehcache" />
 <defaultCache 
   maxElementsInMemory="10000" 
   maxElementsOnDisk="10000000"
   eternal="false" 
   overflowToDisk="true" 
   timeToIdleSeconds="120"
   timeToLiveSeconds="120" 
   diskExpiryThreadIntervalSeconds="120"
   memoryStoreEvictionPolicy="LRU">
 </defaultCache>
</ehcache>