如何快速閱讀源碼

時間 2019-11-07

標籤如何快速閱讀源碼简体版

原文原文鏈接

本文探討在須要瞭解一個開源項目時，如何快速的理清開源項目的代碼邏輯！html

如下是我的認爲行之有效的方法：java

先「跑起來」
自頂向下拆解
深刻細節
延伸改進

本文以Mybatis爲例來進行演示！sql

先「跑起來」

程序界有個老傳統，學習新技術時都是從「Hello World」開始的！不管是學習新語言時，打印「Hello World」；仍是學習新框架時編寫個demo！那爲何這裏的「跑起來」要打個引號呢？mybatis

實際上，當你想要閱讀一個開源項目的源碼時，絕大部分狀況下，你已經可以使用這個開源項目了！因此這裏的「跑起來」就不是寫個「Hello World」，也不是能跑起來的程序了！而是能__在你的腦子裏「跑起來」__！什麼意思？app

Mybatis你會用了吧？那麼請問Mybatis是如何執行的呢？仔細想一想，你可否用完整的語句把它描述出來？框架

這裏是Mybatis的官方入門文章！你是如何看這篇文章的？讀一遍就好了嗎？仍是跟着文章跑一遍就夠了嗎？從這篇文章裏你能得到多少信息？ide

咱們來理一下：學習

安裝ui
- 如何在項目中引入Mybatis?
- Mybatis的groupId是什麼？artifactId又是什麼？目前最新版本是多少？
從 XML 中構建 SqlSessionFactorythis
- 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> T selectOne(String statement);

  <E> List<E> selectList(String statement);

  <K, V> Map<K, V> selectMap(String statement, String mapKey);

  <T> Cursor<T> 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<BatchResult> flushStatements();

  <T> T getMapper(Class<T> 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的！

@Override
public <T> T getMapper(Class<T> type) {
    return configuration.<T>getMapper(type, this);
}

它直接委託給了Configuration的getMapper方法！

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

Configuration又委託給了MapperRegistry類的getMapper方法！

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

在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<T> mapperProxy = new MapperProxy<T>(sqlSession, 
                                        mapperInterface, methodCache);
    return newInstance(mapperProxy);
}

protected T newInstance(MapperProxy<T> mapperProxy) {
    return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), 
                                      new Class[] { mapperInterface }, 
                                      mapperProxy);
}

這裏幹了什麼？

經過sqlSession,mapperInterface和methodCache構建了一個MapperProxy對象
而後經過Java的動態代理，來生成了Mapper的代理類
將Mapper方法的執行都委託給了MapperProxy去執行

@Override
public 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