communauté
Apprendre
Bibliothèque d'outils
Outils d'IA
Loisirs
recherche
Français
Maison Java javaDidacticiel [Analyse du code source MyBatis] Cache MyBatis de premier et deuxième niveaux

[Analyse du code source MyBatis] Cache MyBatis de premier et deuxième niveaux

巴扎黑
巴扎黑
Jun 26, 2017 am 10:00 AM
mybatis 源码 解析

Cache MyBatis

Nous savons que les opérations fréquentes de base de données sont très gourmandes en performances (principalement parce que pour la base de données, les données persistantes sont stockées dans le disque, donc l'opération de requête doit passer par IO, et la vitesse d'opération IO est plusieurs ordres de grandeur plus lente que la vitesse d'opération de mémoire), en particulier pour certaines instructions de requête identiques, les résultats de la requête peuvent être stockés et la requête suivante sera la même chose Lorsque vous interrogez le contenu, vous pouvez obtenir directement les données de la mémoire, ce qui peut considérablement améliorer l'efficacité des requêtes dans certains scénarios.

Le cache de MyBatis est divisé en deux types :

  1. Cache de premier niveau, le cache de premier niveau est Niveau SQLSession cache, pour une même requête, les résultats seront renvoyés depuis le cache au lieu d'interroger la base de données

  2. cache de deuxième niveau, le cache de deuxième niveau est un cache niveau Mapper , qui est défini dans la balise les fichiers peuvent partager un cache, en fonction de la configuration des balises < cache-ref>

Examinons en détail le cache de premier et de deuxième niveau de MyBatis.

Workflow de cache de premier niveau MyBatis

Ensuite, jetez d'abord un œil à MyBatis Processus de travail du cache au niveau du cache. Comme mentionné précédemment, le cache de premier niveau de MyBatis est un cache de niveau SqlSession. Lorsque la méthode openSession() termine son exécution ou que la méthode close de SqlSession est activement appelée, la SqlSession est recyclée et le cache de premier niveau est également recyclé. en même temps. Comme mentionné dans l'article précédent, dans MyBatis, les méthodes selectOne et selectList sont finalement converties en méthode selectList pour l'exécution, alors jetez un œil à l'implémentation de la méthode selectList de SqlSession : 

 1 public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) { 2     try { 3       MappedStatement ms = configuration.getMappedStatement(statement); 4       return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER); 5     } catch (Exception e) { 6       throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e); 7     } finally { 8       ErrorContext.instance().reset(); 9     }10 }
Copier après la connexion
Copier après la connexion

Continuez à tracer le code de la ligne 4 jusqu'à la méthode de requête de BaseExecutor : 

1 public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {2     BoundSql boundSql = ms.getBoundSql(parameter);3     CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);4     return query(ms, parameter, rowBounds, resultHandler, key, boundSql);5 }
Copier après la connexion

La ligne 3 construit la condition de cache CacheKey What. est impliqué ici ? La condition est considérée comme la même condition que la requête précédente, car la même condition peut renvoyer le résultat précédent. Cette partie du code sera analysée dans la partie suivante.

Ensuite, regardez l'implémentation de la méthode de requête à la ligne 4. Le code se trouve dans CachingExecutor : 

 1 public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) 2       throws SQLException { 3     Cache cache = ms.getCache(); 4     if (cache != null) { 5       flushCacheIfRequired(ms); 6       if (ms.isUseCache() && resultHandler == null) { 7         ensureNoOutParams(ms, parameterObject, boundSql); 8         @SuppressWarnings("unchecked") 9         List<E> list = (List<E>) tcm.getObject(cache, key);10         if (list == null) {11           list = delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);12           tcm.putObject(cache, key, list); // issue #578 and #11613         }14         return list;15       }16     }17     return delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);18 }
Copier après la connexion
Copier après la connexion

Non. Ignorez le code des lignes 3 à 16 et continuez avec la méthode de requête à la ligne 17. Le code se trouve dans BaseExecutor : 

 1 public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException { 2     ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId()); 3     if (closed) { 4       throw new ExecutorException("Executor was closed."); 5     } 6     if (queryStack == 0 && ms.isFlushCacheRequired()) { 7       clearLocalCache(); 8     } 9     List<E> list;10     try {11       queryStack++;12       list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;13       if (list != null) {14         handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);15       } else {16         list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);17       }18     } finally {19       queryStack--;20     }21     ...22 }
Copier après la connexion

看12行，query的时候会尝试从localCache中去获取查询结果，如果获取到的查询结果为null，那么执行16行的代码从DB中捞数据，捞完之后会把CacheKey作为key，把查询结果作为value放到localCache中。

MyBatis一级缓存存储流程看完了，接着我们从这段代码中可以得到三个结论：

  1. MyBatis的一级缓存是SqlSession级别的，但是它并不定义在SqlSessio接口的实现类DefaultSqlSession中，而是定义在DefaultSqlSession的成员变量Executor中，Executor是在openSession的时候被实例化出来的，它的默认实现为SimpleExecutor

  2. MyBatis中的一级缓存，与有没有配置无关，只要SqlSession存在，MyBastis一级缓存就存在，localCache的类型是PerpetualCache，它其实很简单，一个id属性+一个HashMap属性而已，id是一个名为"localCache"的字符串，HashMap用于存储数据，Key为CacheKey，Value为查询结果

  3. MyBatis的一级缓存查询的时候默认都是会先尝试从一级缓存中获取数据的，但是我们看第6行的代码做了一个判断，ms.isFlushCacheRequired()，即想每次查询都走DB也行，将标签所在的Mapper的Namespace+标签中定义的sql语句

即只要两次查询满足以上三个条件且没有定义flushCache="true"，那么第二次查询会直接从MyBatis一级缓存PerpetualCache中返回数据，而不会走DB。

 

MyBatis二级缓存

上面说完了MyBatis，接着看一下MyBatis二级缓存，还是从二级缓存工作流程开始。还是从DefaultSqlSession的selectList方法进去：

 1 public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) { 2     try { 3       MappedStatement ms = configuration.getMappedStatement(statement); 4       return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER); 5     } catch (Exception e) { 6       throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e); 7     } finally { 8       ErrorContext.instance().reset(); 9     }10 }
Copier après la connexion
Copier après la connexion

执行query方法，方法位于CachingExecutor中：

1 public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {2     BoundSql boundSql = ms.getBoundSql(parameterObject);3     CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);4     return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);5 }
Copier après la connexion

继续跟第4行的query方法，同样位于CachingExecutor中：

 1 public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) 2       throws SQLException { 3     Cache cache = ms.getCache(); 4     if (cache != null) { 5       flushCacheIfRequired(ms); 6       if (ms.isUseCache() && resultHandler == null) { 7         ensureNoOutParams(ms, parameterObject, boundSql); 8         @SuppressWarnings("unchecked") 9         List<E> list = (List<E>) tcm.getObject(cache, key);10         if (list == null) {11           list = delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);12           tcm.putObject(cache, key, list); // issue #578 and #11613         }14         return list;15       }16     }17     return delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);18 }
Copier après la connexion
Copier après la connexion

从这里看到，执行第17行的BaseExecutor的query方法之前，会先拿Mybatis二级缓存，而BaseExecutor的query方法会优先读取MyBatis一级缓存，由此可以得出一个重要结论：假如定义了MyBatis二级缓存，那么MyBatis二级缓存读取优先级高于MyBatis一级缓存。

而第3行~第16行的逻辑：

  • 第5行的方法很好理解，根据flushCache=true或者flushCache=false判断是否要清理二级缓存

  • 第7行的方法是保证MyBatis二级缓存不会存储存储过程的结果

  • 第9行的方法先尝试从tcm中获取查询结果，这个tcm解释一下，这又是一个装饰器模式（数数MyBatis用到了多少装饰器模式了），创建一个事物缓存TranactionalCache，持有Cache接口，Cache接口的实现类就是根据我们在Mapper文件中配置的创建的Cache实例

  • 第10行~第12行，如果没有从MyBatis二级缓存中拿到数据，那么就会查一次数据库，然后放到MyBatis二级缓存中去

至于如何判定上次查询和这次查询是一次查询？由于这里的CacheKey和MyBatis一级缓存使用的是同一个CacheKey，因此它的判定条件和前文写过的MyBatis一级缓存三个维度的判定条件是一致的。

最后再来谈一点，"Cache cache = ms.getCache()"这句代码十分重要，这意味着Cache是从MappedStatement中获取到的，而MappedStatement又和每一个、、、L'espace de noms du Mappeur où se trouve l'étiquette+