如何快速阅读源码

阅读量：6520 次

发布时间：2019-06-24

本文共 8487 字，大约阅读时间需要 28 分钟。

本文探讨在需要了解一个开源项目时，如何快速的理清开源项目的代码逻辑！

以下是个人认为行之有效的方法：

先「跑起来」

自顶向下拆解

深入细节

延伸改进

本文以Mybatis为例来进行演示！

先“跑起来”

程序界有个老传统，学习新技术时都是从「Hello World」开始的！无论是学习新语言时，打印「Hello World」；还是学习新框架时编写个demo！那为什么这里的「跑起来」要打个引号呢？

实际上，当你想要阅读一个开源项目的源码时，绝大部分情况下，你已经能够使用这个开源项目了！所以这里的“跑起来”就不是写个「Hello World」，也不是能跑起来的程序了！而是能__在你的脑子里「跑起来」__！什么意思？

Mybatis你会用了吧？那么请问Mybatis是如何执行的呢？仔细想想，你能否用完整的语句把它描述出来？

这里是文章！你是如何看这篇文章的？读一遍就行了吗？还是跟着文章跑一遍就够了吗？从这篇文章里你能获得多少信息？

我们来理一下：

安装
- 如何在项目中引入Mybatis?
- Mybatis的groupId是什么？artifactId又是什么？目前最新版本是多少？

从 XML 中构建 SqlSessionFactory
- SqlSessionFactoryBuilder可以通过xml或者Configuration来构建SqlSessionFactory，那是如何构建的呢？
- xml配置了哪些信息？既然使用了xml，那肯定有xml解析，用什么方式解析的？
- xml里的标签都是什么意思：configuration，environments，transactionManager，dataSource，mappers。以及这些标签的属性分别是什么意思？
- SqlSessionFactory的作用是什么？

不使用 XML 构建 SqlSessionFactory
- BlogDataSourceFactory，DataSource，TransactionFactory，Environment，Configuration这些类的作用是什么？
- *Mapper的作用是什么？
- 为什么提供基于XML和Java的两种配置方式？这两种配置方式的优缺点是什么？

从 SqlSessionFactory 中获取 SqlSession
- SqlSession的作用是什么？
- selectOne和getMapper的执行方式有什么区别？

探究已映射的 SQL 语句
- *Mapper.xml的配置是什么？
- 命名空间，id的作用是什么？
- *Mapper.xml是如何和*Mapper.java进行匹配的？
- 匹配规则是什么？
- 基于注解的映射配置如何使用？
- 为什么提供基于XML和基于注解的两种映射配置？有什么优劣？

作用域（Scope）和生命周期
- SqlSessionFactoryBuilder应该在哪个作用域使用？为什么？
- SqlSessionFactory应该在哪个作用域使用？为什么？
- SqlSession应该在哪个作用域使用？为什么？
- Mapper实例应该在哪个作用域使用？为什么？

回答出了上面这些问题！你也就基本能在脑子里把Mybatis「跑起来」了！之后，你才能正真的开始阅读源码！

当你能把一个开源项目「跑起来」后，实际上你就有了对开源项目最初步的了解了！就像「__书的索引__」一样！基于这个索引，我们一步步的进行拆解，来细化出下一层的结构和流程，期间可能需要深入技术细节，考量实现，考虑是否有更好的实现方案！也就是说后面的三步并不是线性的，而是__不断交替执行__的一个过程！最终就形成一个完整的源码执行流程！

自顶向下拆解

继续通过Mybatis来演示（限于篇幅，我只演示一个大概流程）！我们现在已经有了一个大概的流程了：

SqlSessionFactoryBuilder通过xml或者Configuration构建出SqlSessionFactory

可以从SqlSessionFactory中获取SqlSession

SqlSession则是真正执行sql的类

虽说每个点都可以往下细化，但是也分个轻重缓急！

我们是先了解怎么构建SqlSessionFactory呢？

还是了解如何获取SqlSession呢？

还是了解SqlSession如何执行sql的呢？

很明显，SqlSession去执行 sql才是Mybatis的核心！我们先从这个点入手！

首先，你当然得先下载Mybatis的源码了（请自行下载）！

我们直接去看SqlSession！它是个接口，里面有一堆执行sql的方法！

这里只列出了一部分方法：

public interface SqlSession extends Closeable {  
    
      T selectOne(String statement);  
     
       List
      
        selectList(String statement);  
       
         Map
        
          selectMap(String statement, String mapKey);  
         
           Cursor
          
            selectCursor(String statement); void select(String statement, Object parameter, ResultHandler handler); int insert(String statement); int update(String statement); int delete(String statement); void commit(); void rollback(); List
           
             flushStatements(); 
            
              T getMapper(Class
             
               type); ...}

SqlSession就是通过这些方法来执行sql的！我们直接看我们常用的，也是Mybatis推荐的用法，就是基于Mapper的执行！也就是说「SqlSession通过Mapper来执行具体的sql」！上面的流程也就细化成了：

SqlSessionFactoryBuilder通过xml或者Configuration构建出SqlSessionFactory

可以从SqlSessionFactory中获取SqlSession

SqlSession则是真正执行sql的类
- SqlSession获取对应的Mapper实例
- Mapper实例来执行相应的sql

那SqlSession是如何获取Mapper的呢？Mapper又是如何执行sql的呢？

深入细节

我们来看SqlSession的实现！SqlSession有两个实现类SqlSessionManager和DefaultSqlSession！通过IDE的引用功能可以查看两个类的使用情况。你会发现SqlSessionManager实际并没有使用！而DefaultSqlSession是通过DefaultSqlSessionFactory构建的！所以我们来看DefaultSqlSession是如何构建Mapper的！

@Overridepublic 
    
      T getMapper(Class
     
       type) {    return configuration.
      
       getMapper(type, this);}

它直接委托给了Configuration的getMapper方法！

public 
    
      T getMapper(Class
     
       type, SqlSession sqlSession) {    return mapperRegistry.getMapper(type, sqlSession);}

Configuration又委托给了MapperRegistry类的getMapper方法！

public 
    
      T getMapper(Class
     
       type, SqlSession sqlSession) {    final MapperProxyFactory
      
        mapperProxyFactory =                     (MapperProxyFactory
       
        ) 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);    }}

在MapperRegistry类的getMapper中：

通过type从knownMappers中获取对应的MapperProxyFactory实例

如果不存在则抛出异常

如果存在则调用mapperProxyFactory.newInstance(sqlSession)创建对应的Mapper

在这里knowMappers是什么？MapperProxyFactory又是什么？mapperProxyFactory.newInstance(sqlSession)具体做了什么？

其实很简单，knowMappers是个Map，里面包含了class与对应的MapperProxyFactory的对应关系！MapperProxyFactory通过newInstance来构建对应的Mapper（实际上是Mapper的代理）！

快接近真相了，看mapperProxyFactory.newInstance(sqlSession)里的代码：

public T newInstance(SqlSession sqlSession) {    final MapperProxy
    
      mapperProxy = new MapperProxy
     
      (sqlSession,                                         mapperInterface, methodCache);    return newInstance(mapperProxy);}protected T newInstance(MapperProxy
      
        mapperProxy) {    return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(),                                       new Class[] { mapperInterface },                                       mapperProxy);}

这里干了什么？

通过sqlSession,mapperInterface和methodCache构建了一个MapperProxy对象

然后通过Java的动态代理，来生成了Mapper的代理类

将Mapper方法的执行都委托给了MapperProxy去执行

@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {    try {      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);    }    final MapperMethod mapperMethod = cachedMapperMethod(method);    return mapperMethod.execute(sqlSession, args);}

如果是Object里的方法则直接执行

否则执行MapperMethod的execute方法

public Object execute(SqlSession sqlSession, Object[] args) {    Object result;    switch (command.getType()) {      case INSERT: {        Object param = method.convertArgsToSqlCommandParam(args);        result = rowCountResult(sqlSession.insert(command.getName(), param));        break;      }      case UPDATE: {        Object param = method.convertArgsToSqlCommandParam(args);        result = rowCountResult(sqlSession.update(command.getName(), param));        break;      }      case DELETE: {        Object param = method.convertArgsToSqlCommandParam(args);        result = rowCountResult(sqlSession.delete(command.getName(), param));        break;      }      case SELECT:        if (method.returnsVoid() && method.hasResultHandler()) {          executeWithResultHandler(sqlSession, args);          result = null;        } else if (method.returnsMany()) {          result = executeForMany(sqlSession, args);        } else if (method.returnsMap()) {          result = executeForMap(sqlSession, args);        } 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 = OptionalUtil.ofNullable(result);          }        }        break;      case FLUSH:        result = sqlSession.flushStatements();        break;      default:        throw new BindingException("Unknown execution method for: " + command.getName());    }    return result;  }

最终实际还是委托给了sqlSession去执行具体的sql！后面具体怎么实现的就自行查看吧！

延伸改进

现在我们的流程大概是这样的一个过程：

SqlSessionFactoryBuilder通过xml或者Configuration构建出SqlSessionFactory

可以从SqlSessionFactory中获取SqlSession

SqlSession则是真正执行sql的类
- SqlSession获取对应的Mapper实例
  - DefaultSqlSession.getMapper
  - Configuration.getMapper
  - MapperRegistry.getMapper
  - mapperProxyFactory.newInstance(sqlSession)
  - 通过sqlSession,mapperInterface和methodCache构建了一个MapperProxy对象
  - 然后通过Java的动态代理，来生成了Mapper的代理类
- Mapper实例来执行相应的sql
  - 将Mapper方法的执行都委托给了MapperProxy去执行
  - 如果是Object里的方法则直接执行
  - 否则执行MapperMethod的execute方法
  - 最终还是委托给sqlSession去执行sql