Mybatis中的mapper是如何和XMl关联起来的

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是啥？怎么用 我知道这个
      //我现在知道他的vfs是什么了，vfs（virtual file system）他抽象出了几个api，通过这些api就可以访问文件系统上的资源；比如在
      // 在解析   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里面的静态内部类IsA（实现了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
  }
构造函数没有什么可说的，重点是下面的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())) {
        //这个很简单了，通过构造方法来设置参数
        processConstructorElement(resultChild, typeClass, resultMappings);
      } else if ("discriminator".equals(resultChild.getName())) {
        // lcnote 对应的Discriminator对象，现实中Discriminator标签没有用过，之后看看，看起来这个标签能实现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里面也是要写动态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代理对象的创建工厂
 */
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操作，没有啥特殊的，就简单的调用创建代理对象的方法来创建。
  @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调用的时候实现的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参数。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;
   // 这只是实现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来创建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;