private void parseConfiguration(XNode root) {
    try {
      // issue #117 read properties first
      propertiesElement(root.evalNode("properties")); //解析properties標簽，并把他放在 parser和config的 Variables 里面
      Properties settings = settingsAsProperties(root.evalNode("settings"));//加載setting標簽
      loadCustomVfs(settings); //lcnote 這里的vfs是啥？怎么用 我知道這個
      //我現(xiàn)在知道他的vfs是什么了，vfs（virtual file system）他抽象出了幾個api，通過這些api就可以訪問文件系統(tǒng)上的資源；比如在
      // 在解析   mapperElement(root.evalNode("mappers"));的時候，如果指定package，就可以通過VFS來獲取包路徑下面所有的class文件。
      // 并且會將他添加到mappe里面，和spring中的classPathSacnner一樣差不多，可以指定過濾器。
      loadCustomLogImpl(settings);
      typeAliasesElement(root.evalNode("typeAliases"));
      //從這里開始，都是解析具體的標簽，new出對象，將標簽下面的屬性設置進去，
      // 從解析的這里基本也能看出mybatis里面重要的幾個點，首先是objectFactory，objectFactory。objectFactory，plugins
      pluginElement(root.evalNode("plugins"));
      objectFactoryElement(root.evalNode("objectFactory"));
      objectWrapperFactoryElement(root.evalNode("objectFactory"));
      reflectorFactoryElement(root.evalNode("objectFactory"));
      //這里就具體設置setting標簽了
      settingsElement(settings);
      // read it after objectFactory and objectWrapperFactory issue #631
      environmentsElement(root.evalNode("environments"));
      databaseIdProviderElement(root.evalNode("databaseIdProvider"));
      typeHandlerElement(root.evalNode("typeHandlers"));
      //lcnote 這里是重點，解析mapper文件，
      mapperElement(root.evalNode("mappers"));
    } catch (Exception e) {
      throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
    }
  }

if ("package".equals(child.getName())) {
          String mapperPackage = child.getStringAttribute("name");
          configuration.addMappers(mapperPackage);
        }
//下面是 configuration.addMappers(mapperPackage)的方法
public void addMappers(String packageName) {
  //mapperRegistry是一個注冊mapper的注冊器，并且里面維護了很多的所有的mapper組成的對象。
    mapperRegistry.addMappers(packageName);
  }
//下面是mapperRegistry.addMappers(packageName);
  public void addMappers(String packageName) {
    addMappers(packageName, Object.class);
  }
//    addMappers(packageName, Object.class); 方法，
//packageName表示要掃描的包的路徑
//superType表示要找的類是這個類的子類。
  public void addMappers(String packageName, Class<?> superType) 
  {
    //resolverUtil就是一個在指定包下，找指定的類的子類集合的一個工具類。
    ResolverUtil<Class<?>> resolverUtil = new ResolverUtil<>();
    resolverUtil.find(new ResolverUtil.IsA(superType), packageName);
    //找到了合適的Class，將他添加到mapper里面。
    Set<Class<? extends Class<?>>> mapperSet = resolverUtil.getClasses();
    for (Class<?> mapperClass : mapperSet) {
      addMapper(mapperClass);
    }
  }
//resolverUtil.find(new ResolverUtil.IsA(superType), packageName);
//掃描給定包下（包括子路徑下面的所有的類。調用Test方法來匹配，匹配到的class調用getClasses就可以獲取的到。）
  public ResolverUtil<T> find(Test test, String packageName) {
    String path = getPackagePath(packageName);
    try {
      List<String> children = VFS.getInstance().list(path);
      for (String child : children) {
        if (child.endsWith(".class")) {
          //加載class對象，調用ResolverUtil里面的靜態(tài)內部類IsA（實現(xiàn)了Test接口）做匹配。
          addIfMatching(test, child);
        }
      }
    } catch (IOException ioe) {
      log.error("Could not read package: " + packageName, ioe);
    }
    return this;
  }
//addIfMatching(test, child);
  protected void addIfMatching(Test test, String fqn) {
    try {
      String externalName = fqn.substring(0, fqn.indexOf('.')).replace('/', '.');
      ClassLoader loader = getClassLoader();
      if (log.isDebugEnabled()) {
        log.debug("Checking to see if class " + externalName + " matches criteria [" + test + "]");
      }
      Class<?> type = loader.loadClass(externalName);
      if (test.matches(type)) {
        matches.add((Class<T>) type);
      }
    } catch (Throwable t) {
      log.warn("Could not examine class '" + fqn + "'" + " due to a "
          + t.getClass().getName() + " with message: " + t.getMessage());
    }
  }
//****************************重點***********************************
//   public <T> void addMapper(Class<T> type) 方法，將上面找的，合適的class實例化之后要加載到mapperRegistry里面去。
// 并且這個方法是mapperRegistry里面的。
  public <T> void addMapper(Class<T> type) {
    if (type.isInterface()) {
      if (hasMapper(type)) {//mapper只能注冊一次
        throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
      }
      boolean loadCompleted = false;
      try {
        // 用mapper new出MapperProxyFactory，放在knownMappers里面
        knownMappers.put(type, new MapperProxyFactory<>(type));
        // It's important that the type is added before the parser is run
        // otherwise the binding may automatically be attempted by the
        // mapper parser. If the type is already known, it won't try.
        // 這個是很重要的，在解析之前的添加類型，因此，他會自動嘗試綁定解析mapper。如果類型知道，沒啥事，
        // 這里我覺得是解析mapper里面的注解。
        MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);
        parser.parse();
        loadCompleted = true;
      } finally {
        if (!loadCompleted) {
          knownMappers.remove(type);
        }
      }
    }
  }

{		
          String resource = child.getStringAttribute("resource");
          String url = child.getStringAttribute("url");
          String mapperClass = child.getStringAttribute("class");
          if (resource != null && url == null && mapperClass == null) {
            ErrorContext.instance().resource(resource);
            //resource和url的加載操作是一直的，就是resource的來源不一樣。
            // 這里就會加載resource，解析mapper文件，構建mapperStatement對象，
            try(InputStream inputStream = Resources.getResourceAsStream(resource)) {
              XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
              mapperParser.parse();//lcnote 這里的解析操作和配置文件解析操作是一樣的。都是構建XMLMapperBuilder，然后調用parse方法
            }
          } else if (resource == null && url != null && mapperClass == null) {
            ErrorContext.instance().resource(url);
            try(InputStream inputStream = Resources.getUrlAsStream(url)){
              XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments());
              mapperParser.parse();
            }
          } else if (resource == null && url == null && mapperClass != null) {
            //這里沒有什么特殊，就是什么解析package標簽，得到mapper之后加載的過程，
            Class<?> mapperInterface = Resources.classForName(mapperClass);
            configuration.addMapper(mapperInterface);
          } else {
            throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one.");
          }
        }

XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());

public class MapperBuilderAssistant extends BaseBuilder {
  private String currentNamespace; // 當前解析的nameSpace
  private final String resource;  // 當前nameSpace對應的resource文件
  private Cache currentCache;     // 當前的緩存，對應的mapper標簽里面的cache標簽。
  private boolean unresolvedCacheRef; // issue #676
}

// 看看構造類
  public XMLMapperBuilder(InputStream inputStream, Configuration configuration, String resource, Map<String, XNode> sqlFragments) {
    this(new XPathParser(inputStream, true, configuration.getVariables(), new XMLMapperEntityResolver()),
        configuration, resource, sqlFragments);
  }
  private XMLMapperBuilder(XPathParser parser, Configuration configuration, String resource, Map<String, XNode> sqlFragments) {
    super(configuration);
    this.builderAssistant = new MapperBuilderAssistant(configuration, resource);
    this.parser = parser;
    this.sqlFragments = sqlFragments;
    this.resource = resource;
  }
//super的構造方法
 public BaseBuilder(Configuration configuration) {
    this.configuration = configuration;
    this.typeAliasRegistry = this.configuration.getTypeAliasRegistry();//從配置文件中獲取 typeAliases標簽相關內容
    this.typeHandlerRegistry = this.configuration.getTypeHandlerRegistry();//從配置文件中獲取typeHandlers
  }
構造函數(shù)沒有什么可說的，重點是下面的Parse方法

public void parse() {
     //configuration里面保存了加載過的resource集合，這里先判斷一下
    if (!configuration.isResourceLoaded(resource)) { //會去configuration里面的一個set里面去查找
      // 這里是重點，重點就是解析mapper標簽
      configurationElement(parser.evalNode("/mapper"));//解析mapper標簽
      configuration.addLoadedResource(resource);//添加到已經加載過的集合中
      bindMapperForNamespace(); //嘗試通過nameSpace來加載配置文件。
      //注意，這里說的是嘗試，nameSpace并不必須和Mapper接口保持一致。
    }
    //下面的操作也很有意思。
    //解析xml的時候，如果報錯（IncompleteElementException）不會立即拋出，而是會將這些報錯的緩存起來，在上面的都解析完成之后，在嘗試一下。
    // 
    parsePendingResultMaps(); 
    parsePendingCacheRefs(); 
    parsePendingStatements(); 
  }

private void configurationElement(XNode context) {
    try {
      // 解析namespace
      String namespace = context.getStringAttribute("namespace");
      if (namespace == null || namespace.isEmpty()) {
        throw new BuilderException("Mapper's namespace cannot be empty");
      }
      builderAssistant.setCurrentNamespace(namespace);
      cacheRefElement(context.evalNode("cache-ref"));//解析各個標簽元素
      // 解析cache標簽
      cacheElement(context.evalNode("cache"));
      parameterMapElement(context.evalNodes("/mapper/parameterMap"));
      resultMapElements(context.evalNodes("/mapper/resultMap"));
      //解析sql
      sqlElement(context.evalNodes("/mapper/sql"));
      //waring 這里很重要，真正的開始解析select|insert|update|delete標簽
      buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
    } catch (Exception e) {
      throw new BuilderException("Error parsing Mapper XML. The XML location is '" + resource + "'. Cause: " + e, e);
    }
  }

for (XNode resultChild : resultChildren) {
      if ("constructor".equals(resultChild.getName())) {
        //這個很簡單了，通過構造方法來設置參數(shù)
        processConstructorElement(resultChild, typeClass, resultMappings);
      } else if ("discriminator".equals(resultChild.getName())) {
        // lcnote 對應的Discriminator對象，現(xiàn)實中Discriminator標簽沒有用過，之后看看，看起來這個標簽能實現(xiàn)swtich case的功能，而且還可以搭配resultMap
        // 來做一些有趣的事情。之前這個確實么有用過
        discriminator = processDiscriminatorElement(resultChild, typeClass, resultMappings);
      } else {
        List<ResultFlag> flags = new ArrayList<>();
        if ("id".equals(resultChild.getName())) {
          flags.add(ResultFlag.ID);
        }
        resultMappings.add(buildResultMappingFromContext(resultChild, typeClass, flags));
      }
    }

public void parseStatementNode() {
    String id = context.getStringAttribute("id");
    String databaseId = context.getStringAttribute("databaseId");
    //知道的，在mybatis里面是可以指定dataBase的，并且也可以在標簽里面指定要應用的databaseid。
    // 這里就是一個判斷，如果不是當前要應用的，就不會解析。。
    if (!databaseIdMatchesCurrent(id, databaseId, this.requiredDatabaseId)) {
      return;
    }
    String nodeName = context.getNode().getNodeName();
    // 通過標簽的名字來判斷sql的類型。
    SqlCommandType sqlCommandType = SqlCommandType.valueOf(nodeName.toUpperCase(Locale.ENGLISH));
    boolean isSelect = sqlCommandType == SqlCommandType.SELECT;
    //如果沒有指定flushCache,并且是select類型，默認是false。
    boolean flushCache = context.getBooleanAttribute("flushCache", !isSelect);
    //如果沒有指定 useCache ,并且是select類型，默認是true。
    boolean useCache = context.getBooleanAttribute("useCache", isSelect);
    // 這個標簽是啥意思，我沒用過。這種還是建議看看mybatis的官方文檔。
    boolean resultOrdered = context.getBooleanAttribute("resultOrdered", false);
    // Include Fragments before parsing
    // 在解析sql之前，想將includ標簽解析?？催@個名字也能看得出來。這就是用來處理<include>標簽的。
    // 這也就解釋了，之前在解析sql標簽的時候為啥這么簡單了。sql標簽最終是要用在 Statement里面的。
    // 在Statement里面也是要寫動態(tài)sql的，所以，在真正開始解析標簽之前，就先把他包含進來。一塊放在
    // 后面的解析操作里面。一塊解析
    XMLIncludeTransformer includeParser = new XMLIncludeTransformer(configuration, builderAssistant);
    includeParser.applyIncludes(context.getNode());
    String parameterType = context.getStringAttribute("parameterType");
    Class<?> parameterTypeClass = resolveClass(parameterType);
    String lang = context.getStringAttribute("lang");
    LanguageDriver langDriver = getLanguageDriver(lang);
    // Parse selectKey after includes and remove them.
    // 解析selectkey
    processSelectKeyNodes(id, parameterTypeClass, langDriver);
    //lcnote 解析sql selectKey在解析之前已經remove掉了
    // Parse the SQL (pre: <selectKey> and <include> were parsed and removed)
    //這里判斷是否需要使用useGeneratedKeys，這里還維護了一個緩存?？梢钥纯?，id就是selcet標簽的id
    KeyGenerator keyGenerator;
    String keyStatementId = id + SelectKeyGenerator.SELECT_KEY_SUFFIX;
    keyStatementId = builderAssistant.applyCurrentNamespace(keyStatementId, true); // eg:org.apache.ibatis.domain.mybatis.mapper.StudentMapper.listAllStudent!selectKey
    if (configuration.hasKeyGenerator(keyStatementId)) {
      keyGenerator = configuration.getKeyGenerator(keyStatementId);
    } else {
      keyGenerator = context.getBooleanAttribute("useGeneratedKeys",
          configuration.isUseGeneratedKeys() && SqlCommandType.INSERT.equals(sqlCommandType))
          ? Jdbc3KeyGenerator.INSTANCE : NoKeyGenerator.INSTANCE;
    }
   //  說實話，Mybatis的langDriver我還真不知道是什么，之后在分析分析
    SqlSource sqlSource = langDriver.createSqlSource(configuration, context, parameterTypeClass);
    StatementType statementType = StatementType.valueOf(context.getStringAttribute("statementType", StatementType.PREPARED.toString()));
    Integer fetchSize = context.getIntAttribute("fetchSize");
    Integer timeout = context.getIntAttribute("timeout");
    String parameterMap = context.getStringAttribute("parameterMap");
    String resultType = context.getStringAttribute("resultType");
    Class<?> resultTypeClass = resolveClass(resultType);
    String resultMap = context.getStringAttribute("resultMap");
    String resultSetType = context.getStringAttribute("resultSetType");
    ResultSetType resultSetTypeEnum = resolveResultSetType(resultSetType);
    if (resultSetTypeEnum == null) {
      resultSetTypeEnum = configuration.getDefaultResultSetType();
    }
    String keyProperty = context.getStringAttribute("keyProperty");
    String keyColumn = context.getStringAttribute("keyColumn");
    String resultSets = context.getStringAttribute("resultSets");
    //看到這里就知道，肯定是通過builderAssistant，將組裝好的MappedStatement添加到
    // configuration里面維護了statement的map，key就是namespace+mapper的id、  
    builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType,
        fetchSize, timeout, parameterMap, parameterTypeClass, resultMap, resultTypeClass,
        resultSetTypeEnum, flushCache, useCache, resultOrdered,
        keyGenerator, keyProperty, keyColumn, databaseId, langDriver, resultSets);
  }

private void bindMapperForNamespace() {
     // 前面說過，builderAssistant對應的是一個mapper解析期間的工具類。拿到namespace
    String namespace = builderAssistant.getCurrentNamespace();
    if (namespace != null) {
      Class<?> boundType = null;
      try {
        //嘗試通過全限定類名加載
        boundType = Resources.classForName(namespace);
      } catch (ClassNotFoundException e) {
        // ignore, bound type is not required
      }
      if (boundType != null && !configuration.hasMapper(boundType)) {
        // Spring may not know the real resource name so we set a flag
        // to prevent loading again this resource from the mapper interface
        // look at MapperAnnotationBuilder#loadXmlResource
        configuration.addLoadedResource("namespace:" + namespace);
        configuration.addMapper(boundType);
      }
    }
  }

public <T> void addMapper(Class<T> type) {
    if (type.isInterface()) {
      if (hasMapper(type)) {//mapper只能注冊一次
        throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
      }
      boolean loadCompleted = false;
      try {
        knownMappers.put(type, new MapperProxyFactory<>(type));
        // It's important that the type is added before the parser is run
        // otherwise the binding may automatically be attempted by the
        // mapper parser. If the type is already known, it won't try.
        // 這個是很重要的，在解析之前的添加類型，因此，他會自動嘗試綁定解析mapper。如果類型知道，沒啥事，
        // 解析mapper里面的注解。
        MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);
        parser.parse();
        loadCompleted = true;
      } finally {
        if (!loadCompleted) {
          knownMappers.remove(type);
        }
      }
    }
  }

/**
 * @author Lasse Voss
 * lcnote mapper代理對象的創(chuàng)建工廠
 */
public class MapperProxyFactory<T> {
  // 需要代理的接口，也就是mapper
  private final Class<T> mapperInterface;
  //保存的緩存，避免new處重復對象。
  private final Map<Method, MapperMethodInvoker> methodCache = new ConcurrentHashMap<>();
  public MapperProxyFactory(Class<T> mapperInterface) {
    this.mapperInterface = mapperInterface;
  }
  public Class<T> getMapperInterface() {
    return mapperInterface;
  }
  public Map<Method, MapperMethodInvoker> getMethodCache() {
    return methodCache;
  }
   // 這個new操作，沒有啥特殊的，就簡單的調用創(chuàng)建代理對象的方法來創(chuàng)建。
  @SuppressWarnings("unchecked")
  protected T newInstance(MapperProxy<T> mapperProxy) {
    return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
  }
  public T newInstance(SqlSession sqlSession) {
    final MapperProxy<T> mapperProxy = new MapperProxy<>(sqlSession, mapperInterface, methodCache);
    return newInstance(mapperProxy);
  }
}

/** waring， 這也是比較重要的，在mapper調用的時候實現(xiàn)的InvocationHandler
 * @author Clinton Begin
 * @author Eduardo Macarron
 */
public class MapperProxy<T> implements InvocationHandler, Serializable {
  private static final long serialVersionUID = -4724728412955527868L;
  private static final int ALLOWED_MODES = MethodHandles.Lookup.PRIVATE | MethodHandles.Lookup.PROTECTED
      | MethodHandles.Lookup.PACKAGE | MethodHandles.Lookup.PUBLIC;
  private static final Constructor<Lookup> lookupConstructor;
  private final SqlSession sqlSession;
  private final Class<T> mapperInterface;
  private final Map<Method, MapperMethodInvoker> methodCache;
  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    try {
      if (Object.class.equals(method.getDeclaringClass())) {//如果是object類里面的方法，直接調用就好了
        return method.invoke(this, args);
      } else {
        return cachedInvoker(method).invoke(proxy, method, args, sqlSession);
      }
    } catch (Throwable t) {
      throw ExceptionUtil.unwrapThrowable(t);
    }
  }
  private MapperMethodInvoker cachedInvoker(Method method) throws Throwable {
    try {
      return MapUtil.computeIfAbsent(methodCache, method, m -> {
        if (m.isDefault()) {//如果接口里面的方法是default的
          try {
            if (privateLookupInMethod == null) {
              return new DefaultMethodInvoker(getMethodHandleJava8(method));
            } else {
              return new DefaultMethodInvoker(getMethodHandleJava9(method));
            }
          } catch (IllegalAccessException | InstantiationException | InvocationTargetException
              | NoSuchMethodException e) {
            throw new RuntimeException(e);
          }
        } else {
          //lcnote  MapperMethod代表一個mapper方法。里面包括方法對應的dataId，還有對應的sql類型，還有方法的具體的簽名信息，包括方法返回值，param參數(shù)。mapkey注解
          return new PlainMethodInvoker(new MapperMethod(mapperInterface, method, sqlSession.getConfiguration()));
        }
      });
    } catch (RuntimeException re) {
      Throwable cause = re.getCause();
      throw cause == null ? re : cause;
    }
  }
  // mapper方法調用接口，
  interface MapperMethodInvoker {
    Object invoke(Object proxy, Method method, Object[] args, SqlSession sqlSession) throws Throwable;
  }
  private static class PlainMethodInvoker implements MapperMethodInvoker {
    private final MapperMethod mapperMethod;
   // 這只是實現(xiàn)mapper調用的工具類而已.
    public PlainMethodInvoker(MapperMethod mapperMethod) {
      super();
      this.mapperMethod = mapperMethod;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args, SqlSession sqlSession) throws Throwable {
      return mapperMethod.execute(sqlSession, args);
    }
  }
}

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 {
      // 調用MapperProxyFactory來創(chuàng)建mapper實例。
      return mapperProxyFactory.newInstance(sqlSession);
    } catch (Exception e) {
      throw new BindingException("Error getting mapper instance. Cause: " + e, e);
    }
  }

private final boolean returnsMany; 
    private final boolean returnsMap; //返回值是不是一個map，只要mapKey不為null，這就是true
    private final boolean returnsVoid; //標志位，是否沒有返回值
    private final boolean returnsCursor; //是否返回了一個Cursor
    private final boolean returnsOptional;
    private final Class<?> returnType; //這個方法真正返回的類型，比如List<Student>真實返回的類型就是List
    private final String mapKey; //mapkey就是MapKey注解里面的value，關于這個MapKey的作用，之后可以寫一篇文章來分析分析
    private final Integer resultHandlerIndex;
    private final Integer rowBoundsIndex;
    private final ParamNameResolver paramNameResolver;