Gemeinschaft
Lernen
Tools-Bibliothek
KI-Tools
Freizeit
suchen
Deutsch
Heim Java javaLernprogramm [MyBatis-Quellcode-Analyse] MyBatis-Cache der ersten und zweiten Ebene

[MyBatis-Quellcode-Analyse] MyBatis-Cache der ersten und zweiten Ebene

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

MyBatis Cache

Wir wissen, dass häufige Datenbankoperationen sehr leistungsintensiv sind (hauptsächlich, weil bei DB die Daten dauerhaft gespeichert werden Festplatte, sodass die Abfrageoperation über E/A erfolgen muss und die E/A-Operationsgeschwindigkeit um mehrere Größenordnungen langsamer ist als die Speicheroperationsgeschwindigkeit. Insbesondere bei einigen identischen Abfrageanweisungen können die Abfrageergebnisse gespeichert werden, und die nächste Abfrage wird gespeichert Dasselbe Beim Abfragen des Inhalts können Sie die Daten direkt aus dem Speicher abrufen, was in bestimmten Szenarien die Abfrageeffizienz erheblich verbessern kann.

Der Cache von MyBatis ist in zwei Typen unterteilt:

  1. Cache der ersten Ebene, der Cache der ersten Ebene ist SqlSession-Ebene Cache, für dieselbe Abfrage werden die Ergebnisse aus dem Cache zurückgegeben, anstatt die Datenbank abzufragen

  2. Second-Level-Cache: Der Second-Level-Cache ist ein Mapper-Level -Cache, der im -Tag definiert ist und Multiple Mapper aktiviert werden muss Dateien können sich je nach -Tag-Konfiguration einen Cache teilen.

MyBatis First-Level-Cache-Workflow

Dann werfen Sie zunächst einen Blick auf MyBatis -Level-Cache-Arbeitsprozess. Wie bereits erwähnt, ist der Cache der ersten Ebene von MyBatis ein Cache der SqlSession-Ebene. Wenn die openSession()-Methode abgeschlossen ist oder die Close-Methode von SqlSession aktiv aufgerufen wird, wird die SqlSession recycelt, und der Cache der ersten Ebene wird ebenfalls recycelt zur gleichen Zeit. Wie im vorherigen Artikel erwähnt, werden in MyBatis sowohl die selectOne- als auch die selectList-Methode schließlich zur Ausführung in die selectList-Methode konvertiert. Schauen Sie sich also die Implementierung der selectList-Methode von SqlSession an:

Verfolgen Sie weiterhin den Code in Zeile 4 auf die Abfragemethode von BaseExeccutor: 

 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 }
Nach dem Login kopieren
Nach dem Login kopieren

Zeile 3 erstellt die Cache-Bedingung CacheKey What Handelt es sich hier um die gleiche Bedingung wie bei der vorherigen Abfrage, da dieselbe Bedingung das vorherige Ergebnis zurückgeben kann. Dieser Teil des Codes wird im nächsten Teil analysiert. 

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 }
Nach dem Login kopieren
Schauen Sie sich als Nächstes die Implementierung der Abfragemethode in Zeile 4 an. Der Code befindet sich in CachingExecutor:

Nein. Ignorieren Sie den Code in den Zeilen 3 bis 16 und fahren Sie mit der Abfragemethode in Zeile 17 fort. Der Code befindet sich in BaseExecutor: 

 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 }
Nach dem Login kopieren
Nach dem Login kopieren

看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 }
Nach dem Login kopieren
Nach dem Login kopieren

执行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 }
Nach dem Login kopieren

继续跟第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 }
Nach dem Login kopieren
Nach dem Login kopieren

从这里看到，执行第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又和每一个、、、Der Namespace des Mapper, wo sich die Beschriftung befindet+