Mybatis源码学习-缓存模块分析

使用的设计模式：

1. 装饰器模式

为什么要用装饰器模式？
Mybatis缓存的核心模块就是在缓存中读写数据，但是除了在缓存中读写数据wait，还有其他的附加功能，这些附加功能可以任意的加在缓存这个核心功能上。

加载附加功能可以有很多种方法，动态代理或者继承都可以实现，但是附加功能存在多种组合，用这两种方法，会导致生成大量的子类，所以mybatis选择使用装饰器模式.(灵活性、扩展性)

装饰器模式

装饰器模式是一种用于代替继承的技术，无需通过继承增加子类就能扩展对象的新功能。使
用对象的关联关系代替继承关系，更加灵活，同时避免类型体系的快速膨胀。
类图：

Component：组件。组件接口定义了全部组件类和装饰器实现的行为。
ConcreteComponent：组件实现类。实现Component接口，被装饰器装饰的原始对象（增强的对象），新功能（附加功能）都是通过装饰器添加到该类的对象上的。
Decorator：装饰器抽象类。实现Component接口的抽象类，包含一个被装饰的对象

ConreteDecorator1： 具体装饰器类。实现了附加功能的装饰器类

IO输入输出流就是明显的一个装饰器模式的使用

装饰器在Mybatis缓存模块的使用

Cache：Cache 接口是缓存模块的核心接口，定义了缓存的基本操作

public interface Cache {

  String getId();//缓存实现类的id

  void putObject(Object key, Object value);//往缓存中添加数据，key一般是CacheKey对象

  Object getObject(Object key);//根据指定的key从缓存获取数据

  Object removeObject(Object key);//根据指定的key从缓存删除数据

  void clear();//清空缓存

  int getSize();//获取缓存的个数

  ReadWriteLock getReadWriteLock();//获取读写锁

}

PerpetualCache：在缓存模块中扮演ConcreteComponent 角色，使用 HashMap来实现 cache 的相关操作

public class PerpetualCache implements Cache {

  private final String id;

  private Map<Object, Object> cache = new HashMap<>(); // 存储数据

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

}

BlockingCache：阻塞版本的缓存装饰器，保证只有一个线程到数据库去查找指定的 key 对应的数据

防止缓存雪崩，用ConcurrentHashMap来进行细粒度加锁，其相关源码如下

public class BlockingCache implements Cache {

  //阻塞的超时时长
  private long timeout;
  //被装饰的底层对象，一般是PerpetualCache
  private final Cache delegate;
  //锁对象集，粒度到key值
  private final ConcurrentHashMap<Object, ReentrantLock> locks;

  public BlockingCache(Cache delegate) {
    this.delegate = delegate;
    this.locks = new ConcurrentHashMap<>();
  }

  @Override
  public void putObject(Object key, Object value) {
    try {
      delegate.putObject(key, value);
    } finally {
      releaseLock(key);
    }
  }

  @Override
  public Object getObject(Object key) {
    acquireLock(key);//根据key获得锁对象，获取锁成功加锁，获取锁失败阻塞一段时间重试
    Object value = delegate.getObject(key);
    if (value != null) {//获取数据成功的，要释放锁
      releaseLock(key);
    }        
    return value;
  }

  @Override
  public Object removeObject(Object key) {
    // despite of its name, this method is called only to release locks
    releaseLock(key);
    return null;
  }

  private ReentrantLock getLockForKey(Object key) {
    ReentrantLock lock = new ReentrantLock();//创建锁
    ReentrantLock previous = locks.putIfAbsent(key, lock);//把新锁添加到locks集合中，如果添加成功使用新锁，如果添加失败则使用locks集合中的锁
    return previous == null ? lock : previous;
  }
  
//根据key获得锁对象，获取锁成功加锁，获取锁失败阻塞一段时间重试
  private void acquireLock(Object key) {
	//获得锁对象
    Lock lock = getLockForKey(key);
    if (timeout > 0) {//使用带超时时间的锁
      try {
        boolean acquired = lock.tryLock(timeout, TimeUnit.MILLISECONDS);
        if (!acquired) {//如果超时抛出异常
          throw new CacheException("Couldn't get a lock in " + timeout + " for the key " +  key + " at the cache " + delegate.getId());  
        }
      } catch (InterruptedException e) {
        throw new CacheException("Got interrupted while trying to acquire lock for key " + key, e);
      }
    } else {//使用不带超时时间的锁
      lock.lock();
    }
  }
  
  private void releaseLock(Object key) {
    ReentrantLock lock = locks.get(key);
    if (lock.isHeldByCurrentThread()) {
      lock.unlock();
    }
  }
  // 此处有省略代码......
}

LoggingCache：日志能力的缓存 — 当使用缓存查询的时候，打印相关日志

public class LoggingCache implements Cache {

  private final Log log;
  private final Cache delegate;
  protected int requests = 0; // 请求次数
  protected int hits = 0; // 命中次数

  public LoggingCache(Cache delegate) {
    this.delegate = delegate;
    this.log = LogFactory.getLog(getId());
  }

  @Override
  public Object getObject(Object key) {
    requests++;
    final Object value = delegate.getObject(key);
    if (value != null) {
      hits++; // 命中
    }
    if (log.isDebugEnabled()) {
      // 如果开启了DEBUG模式，则输出命中率
      log.debug("Cache Hit Ratio [" + getId() + "]: " + getHitRatio());
    }
    return value;
  }
  // 获取命中率
  private double getHitRatio() {
    return (double) hits / (double) requests;
  }
  // 此处有省略代码......
}

ScheduledCache：定时清空的缓存

public class ScheduledCache implements Cache {

  private final Cache delegate;
  protected long clearInterval; // 清除的时间间隔
  protected long lastClear; // 上一次清除的时间

  public ScheduledCache(Cache delegate) {
    this.delegate = delegate;
    this.clearInterval = 60 * 60 * 1000; // 1 hour
    this.lastClear = System.currentTimeMillis();
  }

  public void setClearInterval(long clearInterval) {
    this.clearInterval = clearInterval;
  }
  @Override
  public int getSize() {
    clearWhenStale();
    return delegate.getSize();
  }

  @Override
  public void putObject(Object key, Object object) {
    clearWhenStale();
    delegate.putObject(key, object);
  }


  @Override
  public Object removeObject(Object key) {
    clearWhenStale();
    return delegate.removeObject(key);
  }

  @Override
  public void clear() {
    // 更新清空时间
    lastClear = System.currentTimeMillis();
    delegate.clear();
  }

  private boolean clearWhenStale() {
    // 判断是否到清空时间
    if (System.currentTimeMillis() - lastClear > clearInterval) {
      clear();
      return true;
    }
    return false;
  }
 // 此处有省略代码......
}

SerializedCache：序列化缓存。用于保证线程安全

为什么会线程不安全？
因为在取出数据的时候，并不是真正的将对象取出，而是取出对象的引用，当多个线程同时操作这个数据对象时，就会出现线程不安全的状态 （一个线程修改后，其他线程拿到的都是修改后的对象）
而字节在反序列化时，会创建一个新的对象，所以每个线程拿到反序列化后的对象都是唯一的。

public class SerializedCache implements Cache {

  private final Cache delegate;

  public SerializedCache(Cache delegate) {
    this.delegate = delegate;
  }

 

  @Override
  public void putObject(Object key, Object object) {
    if (object == null || object instanceof Serializable) {
      // 先序列化后再存放到缓存中
      delegate.putObject(key, serialize((Serializable) object));
    } else {
      throw new CacheException("SharedCache failed to make a copy of a non-serializable object: " + object);
    }
  }

  @Override
  public Object getObject(Object key) {
    Object object = delegate.getObject(key);
    // 不为空，则反序列化，生成一份Copy
    return object == null ? null : deserialize((byte[]) object);
  }

  private byte[] serialize(Serializable value) {

    try (
      // 序列化
      ByteArrayOutputStream bos = new ByteArrayOutputStream();
      ObjectOutputStream oos = new ObjectOutputStream(bos)) {
      oos.writeObject(value);
      oos.flush();
      return bos.toByteArray();
    } catch (Exception e) {
      throw new CacheException("Error serializing object.  Cause: " + e, e);
    }
  }

  private Serializable deserialize(byte[] value) {
    Serializable result;
    try (
      // 反序列化
      ByteArrayInputStream bis = new ByteArrayInputStream(value);
     ObjectInputStream ois = new CustomObjectInputStream(bis)) {
      result = (Serializable) ois.readObject();
    } catch (Exception e) {
      throw new CacheException("Error deserializing object.  Cause: " + e, e);
    }
    return result;
  }

  public static class CustomObjectInputStream extends ObjectInputStream {

    public CustomObjectInputStream(InputStream in) throws IOException {
      super(in);
    }

    @Override
    protected Class<?> resolveClass(ObjectStreamClass desc) throws IOException, ClassNotFoundException {
      // 此方法只有在待序列化的类第一次序列化的时候才会被调用
      // 遍历所支持的ClassLoader，加载对应的Class
      return Resources.classForName(desc.getName());
    }
    
  }

 // 此处有省略代码......
}

SynchronizedCache：进行同步控制的缓存 相关方法都加了synchronized 关键字

ps：Mybatis中的二级缓存使用了HashMap，却不会引起线程不安全就是因为添加了这个装饰器

public class SynchronizedCache implements Cache {

  private final Cache delegate;
  
  public SynchronizedCache(Cache delegate) {
    this.delegate = delegate;
  }

  @Override
  public synchronized int getSize() {
    return delegate.getSize();
  }

  @Override
  public synchronized void putObject(Object key, Object object) {
    delegate.putObject(key, object);
  }

  @Override
  public synchronized Object getObject(Object key) {
    return delegate.getObject(key);
  }

  @Override
  public synchronized Object removeObject(Object key) {
    return delegate.removeObject(key);
  }

  @Override
  public synchronized void clear() {
    delegate.clear();
  }
 // 此处有省略代码......

}

LruCache：LRU回收策略的缓存

public class LruCache implements Cache {

  private final Cache delegate;
  private Map<Object, Object> keyMap;
  private Object eldestKey;

  public LruCache(Cache delegate) {
    this.delegate = delegate;
    // 初始化设置LRU回收的边界容量
    setSize(1024);
  }

  public void setSize(final int size) {
    keyMap = new LinkedHashMap<Object, Object>(size, .75F, true) {
      private static final long serialVersionUID = 4267176411845948333L;

      // 键值移除策略，当大于指定容量时则移除最近最少使用的key/value
      protected boolean removeEldestEntry(Map.Entry<Object, Object> eldest) {
        boolean tooBig = size() > size;
        if (tooBig) {
          // 保存需要移除的键，因为在被包装的类中并不知道什么键需要移除
          eldestKey = eldest.getKey();
        }
        return tooBig;
      }
    };
  }

  @Override
  public void putObject(Object key, Object value) {
    delegate.putObject(key, value);
    // 将当前Key放到LRU的Map中，如果大于指定容量，则移除筛选的键值对
    cycleKeyList(key);
  }

  @Override
  public Object getObject(Object key) {
    // 让当前LRU的Map知道使用过
    keyMap.get(key); //touch
    return delegate.getObject(key);
  }

  @Override
  public Object removeObject(Object key) {
    // 这里没有移除当前维护的key，不过在后续也会被回收，可以忽略
    return delegate.removeObject(key);
  }

  private void cycleKeyList(Object key) {
    keyMap.put(key, key);
    if (eldestKey != null) {
      // 从Cache中移除掉LRU筛选出的键值对
      delegate.removeObject(eldestKey);
      eldestKey = null;
    }
  }
  // 省略部分代码...
}

FifoCache ：FIFO回收策略的缓存

public class FifoCache implements Cache {

  // 被包装的类
  private final Cache delegate;
  // 队列，用来维持FIFO
  private LinkedList<Object> keyList;
  // 最大可容纳的大小
  private int size;

  public FifoCache(Cache delegate) {
    this.delegate = delegate;
    this.keyList = new LinkedList<Object>();
    this.size = 1024;
  }

  @Override
  public void putObject(Object key, Object value) {
    // 将Key放入队列中，并且检查一遍，如果满了则移除队列头部的元素
    cycleKeyList(key);
    // 执行真正的操作
    delegate.putObject(key, value);
  }

  private void cycleKeyList(Object key) {
    // 将Key放入队列
    keyList.addLast(key);
    if (keyList.size() > size) {
      // 超出指定容量，移除队列头部Key
      Object oldestKey = keyList.removeFirst();
      // 从缓存中移除Key对应的值
      delegate.removeObject(oldestKey);
    }
  }
  
  // 此处有省略代码......
}

CacheKey— 用来标识是否存在缓存

为什么不能通过String类型的key来当做缓存的key值？
因为Mybatis存在动态sql的缘故，所以不能单单用String来作为缓存的key （如果用String作为key，因为条件不同，sql不同，此时查询会有问题）

CacheKey构成：
1.mappedStatement的id
2.指定查询结果集的范围（分页信息）
3.查询所使用的的sql语句
4.用户传递给sql语句的实际参数值

CacheKey源码：

public class CacheKey implements Cloneable, Serializable {

  private static final long serialVersionUID = 1146682552656046210L;

  public static final CacheKey NULL_CACHE_KEY = new NullCacheKey();

  private static final int DEFAULT_MULTIPLYER = 37;
  private static final int DEFAULT_HASHCODE = 17;

  private final int multiplier;//参与hash计算的乘数
  private int hashcode;//CacheKey的hash值，在update函数中实时运算出来的
  private long checksum;//校验和，hash值的和
  private int count;//updateList的中元素个数
  // 8/21/2017 - Sonarlint flags this as needing to be marked transient.  While true if content is not serializable, this is not always true and thus should not be marked transient.
  //该集合中的元素觉得两个CacheKey是否相等
  private List<Object> updateList;

  public CacheKey() {
    this.hashcode = DEFAULT_HASHCODE;
    this.multiplier = DEFAULT_MULTIPLYER;
    this.count = 0;
    this.updateList = new ArrayList<>();
  }

  public CacheKey(Object[] objects) {
    this();
    updateAll(objects);
  }

  public int getUpdateCount() {
    return updateList.size();
  }

  public void update(Object object) {
	//获取object的hash值
    int baseHashCode = object == null ? 1 : ArrayUtil.hashCode(object); 
    //更新count、checksum以及hashcode的值
    count++;
    checksum += baseHashCode;
    baseHashCode *= count;
    hashcode = multiplier * hashcode + baseHashCode;
    //将对象添加到updateList中
    updateList.add(object);
  }

  public void updateAll(Object[] objects) {
    for (Object o : objects) {
      update(o);
    }
  }

  @Override
  public boolean equals(Object object) {
    if (this == object) {//比较是不是同一个对象
      return true;
    }
    if (!(object instanceof CacheKey)) {//是否类型相同
      return false;
    }

    final CacheKey cacheKey = (CacheKey) object;

    if (hashcode != cacheKey.hashcode) {//hashcode是否相同
      return false;
    }
    if (checksum != cacheKey.checksum) {//checksum是否相同
      return false;
    }
    if (count != cacheKey.count) {//count是否相同
      return false;
    }

    //以上都不相同，才按顺序比较updateList中元素的hash值是否一致
    for (int i = 0; i < updateList.size(); i++) {
      Object thisObject = updateList.get(i);
      Object thatObject = cacheKey.updateList.get(i);
      if (!ArrayUtil.equals(thisObject, thatObject)) {
        return false;
      }
    }
    return true;
  }

  @Override
  public int hashCode() {
    return hashcode;
  }

  @Override
  public String toString() {
    StringBuilder returnValue = new StringBuilder().append(hashcode).append(':').append(checksum);
    for (Object object : updateList) {
      returnValue.append(':').append(ArrayUtil.toString(object));
    }
    return returnValue.toString();
  }

  @Override
  public CacheKey clone() throws CloneNotSupportedException {
    CacheKey clonedCacheKey = (CacheKey) super.clone();
    clonedCacheKey.updateList = new ArrayList<>(updateList);
    return clonedCacheKey;
  }

}

Mybatis 缓存的使用

分为一级缓存跟二级缓存
– 一级缓存默认开启
– 二级缓存开启要在mapper.xml 文件中 配置

ps:二级缓存建议不要开启 因为生命周期过长，而且是根据namespace走的，所以如果有两个namespace，查询相同的sql，缓存相同的数据。其中一个namespace对该对象进行增、删、改， 就会让改缓存失效，但是另一个缓存依旧存在。
结果会导致两个查询结果出现不一致的情况

一级缓存

默认开启，生命周期是sqlSession级别，方法级别

2019-09-04 22:00:58.673 [main] DEBUG org.apache.ibatis.transaction.jdbc.JdbcTransaction - Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@222114ba]
2019-09-04 22:00:58.679 [main] DEBUG c.e.m.mapper.TUserMapper.selectByEmailAndSex2 - ==>  Preparing: select id, userName, realName, sex, mobile, email, note, position_id from t_user a where a.email like CONCAT('%', ?, '%') and a.sex = ? 
2019-09-04 22:00:58.713 [main] DEBUG c.e.m.mapper.TUserMapper.selectByEmailAndSex2 - ==> Parameters: qq.com(String), 1(Byte)
2019-09-04 22:00:58.728 [main] DEBUG c.e.m.mapper.TUserMapper.selectByEmailAndSex2 - <==      Total: 1
第一次查询：[TUser [id=1, userName=zhangsan, realName=张三, sex=1, mobile=null, email=xxoo@qq.com, note=无, positionId=]]
2019-09-04 22:00:58.730 [main] DEBUG org.apache.ibatis.transaction.jdbc.JdbcTransaction - Opening JDBC Connection
2019-09-04 22:00:58.741 [main] DEBUG org.apache.ibatis.transaction.jdbc.JdbcTransaction - Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@43301423]
2019-09-04 22:00:58.742 [main] DEBUG c.e.m.mapper.TUserMapper.selectByEmailAndSex2 - ==>  Preparing: select id, userName, realName, sex, mobile, email, note, position_id from t_user a where a.email like CONCAT('%', ?, '%') and a.sex = ? 
2019-09-04 22:00:58.743 [main] DEBUG c.e.m.mapper.TUserMapper.selectByEmailAndSex2 - ==> Parameters: qq.com(String), 1(Byte)
2019-09-04 22:00:58.744 [main] DEBUG c.e.m.mapper.TUserMapper.selectByEmailAndSex2 - <==      Total: 1
第二次查询：[TUser [id=1, userName=zhangsan, realName=张三, sex=1, mobile=null, email=xxoo@qq.com, note=无, positionId=]]

可以看出，就算是相同的方法，不同sqlSession来调用，是不会走缓存的

缓存失效原因

1. 增删改操作会清空缓存
   （因为在Executor方法中的 update、commit等方法，会清空缓存 调用的是 clearLocalCache();这个方法）
   直接查询，未进行增删改操作
   代码：
   
   控制台：
   
   可以发现控制台只打印一次sql相关的日志，证明第二次查询是从缓存中取得值

进行了增删改操作，第二次查询缓存已经失效了，所以重新从数据库中查询
代码：

控制台：

从控制台中，可以看出，插入一条数据后，改缓存就已经失效了

2. 关闭sqlSession — 一级缓存失效
   代码：
   
   控制台：
   
   可以看出，当关闭sqlSession后，在开启，缓存也失效了

二级缓存

默认不开启，生命周期是SqlSessionFactory级别，类级别，但是每个二级缓存都是跟着namespace的
同一个namespaces
代码：

控制台

2019-09-04 22:13:39.998 [main] DEBUG org.apache.ibatis.transaction.jdbc.JdbcTransaction - Opening JDBC Connection
2019-09-04 22:13:40.224 [main] DEBUG org.apache.ibatis.transaction.jdbc.JdbcTransaction - Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@29176cc1]
2019-09-04 22:13:40.230 [main] DEBUG c.e.m.mapper.TUserMapper.selectByEmailAndSex2 - ==>  Preparing: select id, userName, realName, sex, mobile, email, note, position_id from t_user a where a.email like CONCAT('%', ?, '%') and a.sex = ? 
2019-09-04 22:13:40.262 [main] DEBUG c.e.m.mapper.TUserMapper.selectByEmailAndSex2 - ==> Parameters: qq.com(String), 1(Byte)
2019-09-04 22:13:40.281 [main] DEBUG c.e.m.mapper.TUserMapper.selectByEmailAndSex2 - <==      Total: 1
[TUser [id=1, userName=zhangsan, realName=张三, sex=1, mobile=null, email=xxoo@qq.com, note=无, positionId=]]
2019-09-04 22:13:40.288 [main] DEBUG org.apache.ibatis.transaction.jdbc.JdbcTransaction - Resetting autocommit to true on JDBC Connection [com.mysql.jdbc.JDBC4Connection@29176cc1]
2019-09-04 22:13:40.288 [main] DEBUG org.apache.ibatis.transaction.jdbc.JdbcTransaction - Closing JDBC Connection [com.mysql.jdbc.JDBC4Connection@29176cc1]
2019-09-04 22:13:40.339 [main] DEBUG com.enjoylearning.mybatis.mapper.TUserMapper - Cache Hit Ratio [com.enjoylearning.mybatis.mapper.TUserMapper]: 0.5
[TUser [id=1, userName=zhangsan, realName=张三, sex=1, mobile=null, email=xxoo@qq.com, note=无, positionId=]]

上图能看到，虽然不在同一个sqlSession中，但是因为开启了二级缓存。所以第二次查询，走的是缓存，没有在数据库中查询

不同namespaces
代码：

控制台：

2019-09-04 22:16:37.415 [main] DEBUG org.apache.ibatis.transaction.jdbc.JdbcTransaction - Opening JDBC Connection
2019-09-04 22:16:37.672 [main] DEBUG org.apache.ibatis.transaction.jdbc.JdbcTransaction - Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@29176cc1]
2019-09-04 22:16:37.677 [main] DEBUG c.e.m.mapper.TUserMapper.selectByEmailAndSex2 - ==>  Preparing: select id, userName, realName, sex, mobile, email, note, position_id from t_user a where a.email like CONCAT('%', ?, '%') and a.sex = ? 
2019-09-04 22:16:37.711 [main] DEBUG c.e.m.mapper.TUserMapper.selectByEmailAndSex2 - ==> Parameters: qq.com(String), 1(Byte)
2019-09-04 22:16:37.736 [main] DEBUG c.e.m.mapper.TUserMapper.selectByEmailAndSex2 - <==      Total: 1
[TUser [id=1, userName=zhangsan, realName=张三, sex=1, mobile=null, email=xxoo@qq.com, note=无, positionId=]]
2019-09-04 22:16:37.740 [main] DEBUG org.apache.ibatis.transaction.jdbc.JdbcTransaction - Opening JDBC Connection
2019-09-04 22:16:37.750 [main] DEBUG org.apache.ibatis.transaction.jdbc.JdbcTransaction - Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@51e5fc98]
2019-09-04 22:16:37.750 [main] DEBUG c.e.m.m.TJobHistoryMapper.selectByEmailAndSex2 - ==>  Preparing: select id, userName, realName, sex, mobile, email, note, position_id from t_user a where a.email like CONCAT('%', ?, '%') and a.sex = ? 
2019-09-04 22:16:37.751 [main] DEBUG c.e.m.m.TJobHistoryMapper.selectByEmailAndSex2 - ==> Parameters: qq.com(String), 1(Byte)
2019-09-04 22:16:37.753 [main] DEBUG c.e.m.m.TJobHistoryMapper.selectByEmailAndSex2 - <==      Total: 1
[TUser [id=1, userName=zhangsan, realName=张三, sex=1, mobile=null, email=xxoo@qq.com, note=无, positionId=]]

上图可以看出 虽然是相同sql，参数，但是因为namespace不同，所以不会走缓存，还是查询数据库