传统方式源码解析
源码解析-初始化
1 | Inputstream inputstream = Resources.getResourceAsStream("mybatisconfig.xml"); |
进入源码分析：
1 | // 1.我们最初调用的build |
MyBatis在初始化的时候，会将MyBatis的配置信息全部加载到内存中，使用org.apache.ibatis.session.Configuration实例来维护
下面进入对配置文件解析部分：
首先对Configuration对象进行介绍：
Configuration对象的结构和xml配置文件的对象几乎相同。
回顾一下xml中的配置标签有哪些：
properties (属性)，settings (设置)，typeAliases (类型别名)，typeHandlers (类型处理器)，objectFactory (对象工厂)，mappers (映射器)等 Configuration也有对应的对象属性来封装它们
也就是说，初始化配置文件信息的本质就是创建Configuration对象，将解析的xml数据封装到Configuration内部属性中
1 | /** |
介绍一下 MappedStatement ：
作用：MappedStatement与Mapper配置文件中的一个select/update/insert/delete节点相对应。mapper中配置的标签都被封装到了此对象中，主要用途是描述一条SQL语句。
初始化过程：回顾刚开始介绍的加载配置文件的过程中，会对mybatis-config.xml中的各个标签都进行解析，其中有mappers标签用来引入mapper.xml文件或者配置mapper接口的目录。
1 | <select id="getUser" resultType="user" > |
一个select标签会在初始化配置文件时被解析封装成一个MappedStatement对象，然后存储在Configuration对象的mappedStatements属性中，mappedStatements 是一个HashMap，存储时key=全限定类名+方法名，value =对应的MappedStatement对象。
在configuration中对应的属性为
1 | Map<String, MappedStatement> mappedStatements = new StrictMap<MappedStatement>("Mapped Statements collection") |
在XMLConfigBuilder中的处理：
1 | private void parseConfiguration(XNode root) { |
到此对xml配置文件的解析就结束了，回到步骤2中调用的重载build方法
1 | // 5.调用的重载方法 |
源码剖析-执行SQL流程
先简单介绍SqlSession ：
SqlSession是一个接口，它有两个实现类：DefaultSqlSession(默认)和SqlSessionManager(弃用，不做介绍)
SqlSession是MyBatis中用于和数据库交互的顶层类，通常将它与ThreadLocal绑定，一个会话使用一个SqlSession,并且在使用完毕后需要close
1 | public class DefaultSqlSession implements SqlSession { |
SqlSession中的两个最重要的参数，configuration与初始化时的相同，Executor为执行器
Executor：
Executor也是一个接口，他有三个常用的实现类：
BatchExecutor (重用语句并执行批量更新)
ReuseExecutor (重用预处理语句 prepared statements)
SimpleExecutor (普通的执行器，默认)
继续分析，初始化完毕后，我们就要执行SQL了
1 | SqlSession sqlSession = factory.openSession(); |
获得 sqlSession
1 | //6. 进入openSession方法 |
执行 sqlsession 中的 api
1 | //8.进入selectList方法，多个重载方法 |
源码剖析-executor
继续源码中的步骤，进入executor.query()
1 | //此方法在SimpleExecutor的父类BaseExecutor中实现 |
上述的Executor.query()方法几经转折，最后会创建一个StatementHandler对象，然后将必要的参数传递给StatementHandler，使用StatementHandler来完成对数据库的查询，最终返回List结果集。
从上面的代码中我们可以看出，Executor的功能和作用是：
- 根据传递的参数，完成SQL语句的动态解析，生成BoundSql对象，供StatementHandler使用；
- 为查询创建缓存，以提高性能
- 创建JDBC的Statement连接对象，传递给StatementHandler对象，返回List查询结果。
源码剖析-StatementHandler
StatementHandler对象主要完成两个工作： - 对于JDBC的PreparedStatement类型的对象，创建的过程中，我们使用的是SQL语句字符串会包含若干个？占位符，我们其后再对占位符进行设值。StatementHandler通过parameterize(statement)方法对Statement进行设值；
- StatementHandler通过List query(Statement statement, ResultHandler resultHandler)方法来完成执行Statement，和将Statement对象返回的resultSet封装成List；
进入到 StatementHandler 的 parameterize(statement)方法的实现：从上述的代码可以看到,StatementHandler的parameterize(Statement)方法调用了ParameterHandler的setParameters(statement)方法，ParameterHandler的setParameters(Statement)方法负责根据我们输入的参数，对statement对象的?占位符处进行赋值。1
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
40public void parameterize(Statement statement) throws SQLException {
//使用ParameterHandler对象来完成对Statement的设值
parameterHandler.setParameters((PreparedStatement) statement);
}
/**
* ParameterHandler 类的 setParameters(PreparedStatement ps) 实现
* 对某一个Statement进行设置参数
*/
public void setParameters(PreparedStatement ps) throws SQLException {
ErrorContext.instance().activity("setting parameters").object(mappedStatement.getParameterMap().getId());
List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
if (parameterMappings != null) {
for (int i = 0; i < parameterMappings.size(); i++) {
ParameterMapping parameterMapping = parameterMappings.get(i);
if (parameterMapping.getMode() != ParameterMode.OUT) {
Object value;
String propertyName = parameterMapping.getProperty();
if (boundSql.hasAdditionalParameter(propertyName)) { // issue #448 ask first for additional params
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);
}
// 每一个Mapping都有一个TypeHandler根据TypeHandler来对preparedStatement进行设置参数
TypeHandler typeHandler = parameterMapping.getTypeHandler();
JdbcType jdbcType = parameterMapping.getJdbcType();
if (value == null && jdbcType == null)
jdbcType = configuration.getJdbcTypeForNull();
//设置参数
typeHandler.setParameter(ps, i + 1, value, jdbcType);
}
}
}
}
进入到StatementHandler 的 List query(Statement statement, ResultHandler resultHandler)方法的实现：从上述代码我们可以看出，StatementHandler 的List query(Statement statement, ResultHandler resultHandler)方法的实现，是调用了 ResultSetHandler 的 handleResultSets(Statement)方法。1
2
3
4
5
6
7public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
// 1.调用preparedStatemnt。execute()方法，然后将resultSet交给ResultSetHandler处理
PreparedStatement ps = (PreparedStatement) statement;
ps.execute();
//2.使用 ResultHandler 来处理 ResultSet
return resultSetHandler.<E> handleResultSets(ps);
}
ResultSetHandler 的 handleResultSets(Statement)方法会将 Statement 语句执行后生成的 resultSet结果集转换成List结果集1
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
44public List<Object> handleResultSets(Statement stmt) throws SQLException {
ErrorContext.instance().activity("handling results").object(mappedStatement.getId());
//多ResultSet的结果集合，每个ResultSet对应一个Object对象。而实际上，每 个 Object 是 List<Object> 对象。
//在不考虑存储过程的多ResultSet的情况，普通的查询，实际就一个ResultSet，也 就是说，multipleResults最多就一个元素。
final List<Object> multipleResults = new ArrayList<>();
int resultSetCount = 0;
//获得首个ResultSet对象，并封装成ResultSetWrapper对象
ResultSetWrapper rsw = getFirstResultSet(stmt);
//获得ResultMap数组
//在不考虑存储过程的多ResultSet的情况，普通的查询，实际就一个ResultSet，也就是说，resultMaps就一个元素。
List<ResultMap> resultMaps = mappedStatement.getResultMaps();
int resultMapCount = resultMaps.size();
validateResultMapsCount(rsw, resultMapCount); // 校验
while (rsw != null && resultMapCount > resultSetCount) {
//获得ResultMap对象
ResultMap resultMap = resultMaps.get(resultSetCount);
//处理ResultSet，将结果添加到multipleResults中
handleResultSet(rsw, resultMap, multipleResults, null);
//获得下一个ResultSet对象，并封装成ResultSetWrapper对象
rsw = getNextResultSet(stmt);
//清理
cleanUpAfterHandlingResultSet();
// resultSetCount ++
resultSetCount++;
}
//因为'mappedStatement.resultSets'只在存储过程中使用，本系列暂时不考虑，忽略即可
String[] resultSets = mappedStatement.getResultSets();
if (resultSets != null) {
while (rsw != null && resultSetCount < resultSets.length) {
ResultMapping parentMapping = nextResultMaps.get(resultSets[resultSetCount]);
if (parentMapping != null) {
String nestedResultMapId = parentMapping.getNestedResultMapId();
ResultMap resultMap = configuration.getResultMap(nestedResultMapId);
handleResultSet(rsw, resultMap, null, parentMapping);
}
rsw = getNextResultSet(stmt);
cleanUpAfterHandlingResultSet();
resultSetCount++;
}
}
//如果是multipleResults单元素，则取首元素返回
return collapseSingleResultList(multipleResults);
}Mapper代理方式
回顾下写法:思考一个问题，通常的Mapper接口我们都没有实现的方法却可以使用，是为什么呢？答案很简单动态代理1
2
3
4
5
6
7
8
9public static void main(String[] args) {
//前三步都相同
InputStream inputStream = Resources.getResourceAsStream("sqlMapConfig.xml");
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);
SqlSession sqlSession = factory.openSession();
//这里不再调用SqlSession的api,而是获得了接口对象，调用接口中的方法。
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
List<User> list = mapper.getUserByName("tom");
}
开始之前介绍一下MyBatis初始化时对接口的处理：MapperRegistry是Configuration中的一个属性，它内部维护一个HashMap用于存放mapper接口的工厂类，每个接口对应一个工厂类。mappers中可以配置接口的包路径，或者某个具体的接口类。当解析mappers标签时，它会判断解析到的是mapper配置文件时，会再将对应配置文件中的增删改查标签封装成MappedStatement对象，存入mappedStatements中。(上文介绍了)当判断解析到接口时，会建此接口对应的MapperProxyFactory对象，存入HashMap中，key =接口的字节码对象，value =此接口对应的MapperProxyFactory对象。1
2
3
4<mappers>
<mapper class="com.lagou.mapper.UserMapper"/>
<package name="com.lagou.mapper"/>
</mappers>源码剖析-getmapper()
进入sqlSession.getMapper(UserMapper.class)中1
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//DefaultSqlSession 中的 getMapper
public <T> T getMapper(Class<T> type) {
return configuration.<T>getMapper(type, this);
}
//configuration 中的给 g etMapper
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
return mapperRegistry.getMapper(type, sqlSession);
}
//MapperRegistry 中的 g etMapper
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
//从 MapperRegistry 中的 HashMap 中拿 MapperProxyFactory
final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
if (mapperProxyFactory == null) {
throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
}
try {
//通过动态代理工厂生成示例。
return mapperProxyFactory.newInstance(sqlSession);
} catch (Exception e) {
throw new BindingException("Error getting mapper instance. Cause: " + e, e);
}
}
//MapperProxyFactory 类中的 newInstance 方法
public T newInstance(SqlSession sqlSession) {
//创建了 JDK动态代理的Handler类
final MapperProxy<T> mapperProxy = new MapperProxy<>(sqlSession, mapperInterface, methodCache);
//调用了重载方法
return newInstance(mapperProxy);
}
//MapperProxy 类，实现了 InvocationHandler 接口
public class MapperProxy<T> implements InvocationHandler, Serializable {
//省略部分源码
private final SqlSession sqlSession;
private final Class<T> mapperInterface;
private final Map<Method, MapperMethod> methodCache;
//构造，传入了 SqlSession，说明每个session中的代理对象的不同的！
public MapperProxy(SqlSession sqlSession, Class<T> mapperInterface, Map<Method, MapperMethod> methodCache) {
this.sqlSession = sqlSession;
this.mapperInterface = mapperInterface;
this.methodCache = methodCache;
}
//省略部分源码
}源码剖析-invoke()
在动态代理返回了示例后，我们就可以直接调用mapper类中的方法了，但代理对象调用方法，执行是在MapperProxy中的invoke方法中进入execute方法：1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
try {
//如果是Object定义的方法，直接调用
if (Object.class.equals(method.getDeclaringClass())) {
return method.invoke(this, args);
} else if (isDefaultMethod(method)) {
return invokeDefaultMethod(proxy, method, args);
}
} catch (Throwable t) {
throw ExceptionUtil.unwrapThrowable(t);
}
// 获得 MapperMethod 对象
final MapperMethod mapperMethod = cachedMapperMethod(method);
//重点在这：MapperMethod最终调用了执行的方法
return mapperMethod.execute(sqlSession, args);
}1
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
65public Object execute(SqlSession sqlSession, Object[] args) {
Object result;
//判断mapper中的方法类型，最终调用的还是SqlSession中的方法 switch
(command.getType()) {
case INSERT: {
//转换参数
Object param = method.convertArgsToSqlCommandParam(args);
//执行INSERT操作
// 转换 rowCount
result = rowCountResult(sqlSession.insert(command.getName(), param));
break;
}
case UPDATE: {
//转换参数
Object param = method.convertArgsToSqlCommandParam(args);
// 转换 rowCount
result = rowCountResult(sqlSession.update(command.getName(), param));
break;
}
case DELETE: {
//转换参数
Object param = method.convertArgsToSqlCommandParam(args);
// 转换 rowCount
result = rowCountResult(sqlSession.delete(command.getName(), param));
break;
}
case SELECT:
//无返回，并且有ResultHandler方法参数，则将查询的结果，提交给 ResultHandler 进行处理
if (method.returnsVoid() && method.hasResultHandler()) {
executeWithResultHandler(sqlSession, args);
result = null;//执行查询，返回列表
} else if (method.returnsMany()) {
result = executeForMany(sqlSession, args);
//执行查询，返回Map
} else if (method.returnsMap()) {
result = executeForMap(sqlSession, args);
//执行查询，返回Cursor
} else if (method.returnsCursor()) {
result = executeForCursor(sqlSession, args);
//执行查询，返回单个对象
} else {
//转换参数
Object param = method.convertArgsToSqlCommandParam(args);
//查询单条
result = sqlSession.selectOne(command.getName(), param);
if (method.returnsOptional() &&
(result == null || !method.getReturnType().equals(result.getClass())))
{
result = Optional.ofNullable(result);
}
}
break;
case FLUSH:
result = sqlSession.flushStatements();
break;
default:
throw new BindingException("Unknown execution method for: " + command.getName());
}
//返回结果为null，并且返回类型为基本类型，则抛出BindingException异常
if(result ==null&&method.getReturnType().isPrimitive() &&!method.returnsVoid()){
throw new BindingException("Mapper method '" + command.getName() + "attempted to return null from a method with a primitive return type(" + method.getReturnType() + "). ");
}
//返回结果
return result;
}
