MyBatis 关键代码分析
如何创建 SqlSession
org.apache.ibatis.session.defaults.DefaultSqlSessionFactory1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28// 在应用程序中通过sqlSessionFactory获取一个SqlSession对象执行CRUD操作
SqlSession sqlSession = sqlSessionFactory.openSession(true);
// 在DefaultSqlSessionFactory中获取SqlSession对象
@Override
public SqlSession openSession(boolean autoCommit) {
return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, autoCommit);
}
// 通过MyBatis配置参数构建SqlSession对象
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);
// 根据配置的Executor类型装配具体的实现类
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();
}
}
缓存问题
xml 配置
1 | |
org.apache.ibatis.executor.BaseExecutor
1 | |
- 参数cacheEnabled控制MyBatis使用的执行器类型，cacheEnabled 为 false 使用 BaseExecutor，里面一样有一个 localCache。
- 参数localCacheScope控制的是BaseExecutor内部的缓存策略，确定 localCache 是否真的要被使用-它可以优化同一个 session 内的重复查询。
org.apache.ibatis.cache.CacheKey1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101public class CacheKey implements Cloneable, Serializable {
private final int multiplier;
private int hashcode;
private long checksum;
private int count;
private transient List<Object> updateList;
@Override
public int hashCode() {
// hashCode值为内部保存的hashcode属性
return hashcode;
}
@Override
public boolean equals(Object object) {
// 判断两个CacheKey实例通过equals()方法比较时返回true必须同时满足如下条件：
// 1.hashcode属性值相等
// 2.checksum属性值相等
// 3.count属性值相等
// 4.updateList列表属性中存放的每一个对象通过equals()方法比较时返回true
if (this == object) {
return true;
}
if (!(object instanceof CacheKey)) {
return false;
}
final CacheKey cacheKey = (CacheKey) object;
if (hashcode != cacheKey.hashcode) {
return false;
}
if (checksum != cacheKey.checksum) {
return false;
}
if (count != cacheKey.count) {
return false;
}
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 <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
BoundSql boundSql = ms.getBoundSql(parameter);
// 在查询之前构造CacheKey缓存Key对象
CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
}
// cache key 的构造算法，把所有的关联值对象化，再列表化，再组装起来
@Override
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()方法将一个对象放在其内部的updateList列表中
// 只要是查询同一条数据的相同SQL语句，可以保证如下参数的相同的：
// ms.getId()，rowBounds.getOffset()，rowBounds.getLimit()，boundSql.getSql()，boundSql.getParameterMappings()
// 也就是说，只要是在相同的SqlSession中查询同一条数据时都会命中BaseExecutor的本地缓存
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();
// mimic DefaultParameterHandler logic
for (ParameterMapping parameterMapping : parameterMappings) {
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);
}
}
if (configuration.getEnvironment() != null) {
// issue #176
cacheKey.update(configuration.getEnvironment().getId());
}
return cacheKey;
}
org.apache.ibatis.executor.CachingExecutor
1 | |
- localCacheScope 控制的是一级缓存的配置，这是一个经常忘记被关闭的缓存的配置。
- cacheEnabled 控制的是二级缓存的配置，人们往往记得关闭它。
- 这两个缓存可以被同时激活。
