mybatis源码解析之初始化（解析mapper文件）

阳光穿透心脏的1/2处 2022-08-31 11:23 266阅读 0赞

> 原创不易，转载请注明出处

### 文章目录 ###

*   *   *  前言
         *  1.入口引导
         *  2. 解析mapper标签
         *  3.解析cache-ref标签
         *  4.解析cache标签
         *  5.解析parameterMap标签
         *  6.解析resultMap标签
         *  7.解析sql标签
         *  8.解析insert|update|delete|select 标签
         *  总结

--------------------

### 前言 ###

我们在介绍springboot与mybatis整合原理的时候，说过spring自动装配mybatis的时候会干三件事，创建SqlSessionFactory ，创建SqlSessionTemplate对象和扫描mapper 接口，为其创建动态代理实现类，这里推荐阅读《springboot整合mybatis原理分析》一文，在创建SqlSessionFactory的时候，会做一些配置信息解析，配置文件，mapper文件解析的工作，将解析到的东西封装塞到Configuration这个配置类中。本文主要是看看我们常用的mapper xml文件是怎样被解析的。

### 1.入口引导 ###

在MybatisAutoConfiguration 自动装配类中，SqlSessionFactory是通过SqlSessionFactoryBean构建出来的，在构建之前，给SqlSessionFactoryBean设置了一堆配置信息，其中就有这么一行

//MybatisAutoConfiguration#sqlSessionFactory
    if (!ObjectUtils.isEmpty(this.properties.resolveMapperLocations())) { 
          factory.setMapperLocations(this.properties.resolveMapperLocations());
    }

这段话就是将我们在application.properties中配置的mapper xml地址解析成spring 的Resource，然后塞到了SqlSessionFactoryBean中。

mybatis.mapper-locations=classpath:mapper/*.xml

这个Resource你可以理解为对资源的一种抽象，这里的话就是文件，File，比如说我mapper 路径下有UserMapper.xml , OrderMapper.xml 这两个xml文件，它就能够转成两个Resource 资源。  
在真正构建SqlSessionFactory方法中（也就是SqlSessionFactoryBean的buildSqlSessionFactory 方法），有这么一段代码，就是解析我们mapper xml文件的。

// 如果mapper xml地址不是空，进行解析
        if (this.mapperLocations != null) { 
          if (this.mapperLocations.length == 0) { 
            LOGGER.warn(() -> "Property 'mapperLocations' was specified but matching resources are not found.");
          } else { 
            //遍历
            for (Resource mapperLocation : this.mapperLocations) { 
                // 这里解析xml文件
                XMLMapperBuilder xmlMapperBuilder =
                  new XMLMapperBuilder(
                    mapperLocation.getInputStream(),
                    targetConfiguration,
                    mapperLocation.toString(),
                    targetConfiguration.getSqlFragments()  //将configuration中的sql片段集合放入了解析器中
                  );
                xmlMapperBuilder.parse();
              }
            }
          }
        }

可以看到，就是遍历我们那些Resource资源集合，创建XMLMapperBuilder 对象，调用parse解析，XMLMapperBuilder是专门解析mapper xml文件的。这里直接看下parse方法实现

public void parse() { 
        //如果之前没有加载过的话
        if (!configuration.isResourceLoaded(resource)) { 
          // 解析我们写的mapper.xml文件
          configurationElement(parser.evalNode("/mapper"));
          //记录当前resource 已经加载
          configuration.addLoadedResource(resource);
          //绑定mapper
          bindMapperForNamespace();
        }
        // 这里其实是做一些重试的事情
        parsePendingResultMaps();
        parsePendingCacheRefs();
        parsePendingStatements();
      }

首先是判断下之前有没有解析过这个resource ，如果没有的话就进行解析，configuration里面维护着一个resource set集合，当解析完成后就会将resource塞进去。  
这里这个parser 对象，是专门解析xml文件的，里面它是怎么将文件流转成java对象的我们不用过多的关注。  
`configurationElement(parser.evalNode("/mapper"))` 这行代码就是具体mapper文件了，也就是解析mapper标签

### 2. 解析mapper标签 ###

private void configurationElement(XNode context) { 
        try { 
          // TODO 1.解析namespace
          //获取namespace
          String namespace = context.getStringAttribute("namespace");
          if (namespace == null || namespace.isEmpty()) { 
            throw new BuilderException("Mapper's namespace cannot be empty");
          }
          //设置到构建助手中
          builderAssistant.setCurrentNamespace(namespace);
          //TODO 2.解析cache-ref 标签
          cacheRefElement(context.evalNode("cache-ref"));
          //TODO 3.解析cache 标签
          cacheElement(context.evalNode("cache"));
          //TODO 4.解析parameterMap 标签
          parameterMapElement(context.evalNodes("/mapper/parameterMap"));
          //TODO 5.解析resultMap标签
          resultMapElements(context.evalNodes("/mapper/resultMap"));
          //TODO 6.解析sql标签
          sqlElement(context.evalNodes("/mapper/sql"));
          //TODO 7.解析dql，dml语句 也就是insert，update，delete,select 标签
          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);
        }
      }

可以看到步骤还是很清晰的，大概分为7步

1.  解析mapper 标签上的namespace， 塞到构建助手builderAssistant中，每个mapper文件有一个构建助手。
2.  解析cache-ref 标签 ，这个标签说实话不怎么用，其实就是引用别人一级缓存的，引用别的namespace的一级缓存。
3.  解析cache 标签，为当前这个namespace创建一级缓存 ，这个也不怎么用，说白了，一级缓存就不怎么用。
4.  解析parameterMap 标签，这个parameterMap没怎么用过。一般就用parameterType了
5.  解析resultMap标签，这个不用说了，经常用的一个标签。
6.  解析sql标签 ，这个也是经常用的。  
    7.解析 insert，update，delete,select 标签  
    下面我们就挨个来看看

### 3.解析cache-ref标签 ###

它的用法是这样子的

<cache-ref namespace="xxxx"/>

指定使用哪个namespace中一级缓存。

// 解析cache-ref 标签
      private void cacheRefElement(XNode context) { 
        if (context != null) { 
          // 添加到configuration中
          configuration.addCacheRef(builderAssistant.getCurrentNamespace(), context.getStringAttribute("namespace"));
         
          CacheRefResolver cacheRefResolver = new CacheRefResolver(builderAssistant, context.getStringAttribute("namespace"));
          try { 
            cacheRefResolver.resolveCacheRef();
          } catch (IncompleteElementException e) { 
            //异常的话就添加到incompleteCacheRefs 链表中
            configuration.addIncompleteCacheRef(cacheRefResolver);
          }
        }
      }

首先往configuration 中引用关系map中添加一条引用对应关系  
我的namespace -> 要引用的namespace  
接着就是去configuration 中那 引用的namespace 对应的那个缓存对象，拿到后就设置到自己的构建助手中。  
异常添加到configuration的一个链表中，等着后面会重新试下。  
为啥会异常呢？  
你要引用的那个namespace 对应的mapper xml文件还没有解析，串行的嘛，是有先后顺序的。

### 4.解析cache标签 ###

在mapper文件中最简单的用法就是加个 标签，就表示使用一级缓存了。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1YW5zaGFuZ3NoZW5naHVv_size_16_color_FFFFFF_t_70]  
它还有一堆的属性，我们先看看代码

/** * 解析cache标签 * @param context */
      private void cacheElement(XNode context) { 
        if (context != null) { 
          // 类型 默认是PERPETUAL 没有过期时间的
          String type = context.getStringAttribute("type", "PERPETUAL");
          //PERPETUAL 对应的类其实就是 PerpetualCache
          Class<? extends Cache> typeClass = typeAliasRegistry.resolveAlias(type);
          // 淘汰算法 ，默认是LRU 对应的类就是LruCache
          String eviction = context.getStringAttribute("eviction", "LRU");
          Class<? extends Cache> evictionClass = typeAliasRegistry.resolveAlias(eviction);
          // flush间隔
          Long flushInterval = context.getLongAttribute("flushInterval");
          // 大小
          Integer size = context.getIntAttribute("size");
          // 是否只读，默认是false
          boolean readWrite = !context.getBooleanAttribute("readOnly", false);
          // 是否是blocking的，默认是false
          boolean blocking = context.getBooleanAttribute("blocking", false);
          // 获取kv
          Properties props = context.getChildrenAsProperties();
          // 使用构建助手创建一个新的cache
          builderAssistant.useNewCache(typeClass, evictionClass, flushInterval, size, readWrite, blocking, props);
        }
      }

这堆代码其实就是获取cache标签中的属性值， PERPETUAL 和LRU 都是别名，对应的类分别是PerpetualCache ，LruCache  
最后调用助手的useNewCache 创建了一个cache缓存对象。

public Cache useNewCache(Class<? extends Cache> typeClass,
          Class<? extends Cache> evictionClass,
          Long flushInterval,
          Integer size,
          boolean readWrite,
          boolean blocking,
          Properties props) { 
    
        // 建造者模式 创建cache对象
        Cache cache = new CacheBuilder(currentNamespace)
            .implementation(valueOrDefault(typeClass, PerpetualCache.class))
            // 装饰者
            .addDecorator(valueOrDefault(evictionClass, LruCache.class))
            //清除间隔
            .clearInterval(flushInterval)
            .size(size)
            .readWrite(readWrite)
            .blocking(blocking)
            .properties(props)
            .build();
        // 塞到configuration中
        configuration.addCache(cache);
        currentCache = cache;
        return cache;
      }

使用建造者设计模式，构建出来一个Cache ，最后将cache对象放到了configuration中的一个map里，key是namespace ， value就是我们那个cache对象。

public Cache build() { 
        // 设置一些默认的东西。比如说是 implementation ，更新装饰者
        setDefaultImplementations();
        // 创建cache
        Cache cache = newBaseCacheInstance(implementation, id);
        setCacheProperties(cache);
        // issue #352, do not apply decorators to custom caches
        if (PerpetualCache.class.equals(cache.getClass())) { // 如果是PerpetualCache
          // 进行装饰
          for (Class<? extends Cache> decorator : decorators) { 
            cache = newCacheDecoratorInstance(decorator, cache);
            setCacheProperties(cache);
          }
          cache = setStandardDecorators(cache);
          //就是这里面没有LoggingCache 的话，就使用LoggingCache 包一层
        } else if (!LoggingCache.class.isAssignableFrom(cache.getClass())) { 
          cache = new LoggingCache(cache);
        }
        return cache;
      }

这里就是创建最基础的那个cache对象，然后使用装饰者进行装饰，功能增强。  
就是一层一层的包装，装饰。  
mybatis中用的超级的设计模式就是 建造者设计模式，装饰者设计模式，代理模式

### 5.解析parameterMap标签 ###

这个说实话我工作中没怎么用过，包括我那些同事，也没见他们用过（可能没有出现第一个同事来用，大家没得抄）。  
我们稍微看下parameterMapElement 这个方法，看看干了些啥  
看代码之前我们先看xml中怎么用的

<insert id="addUser" useGeneratedKeys="true" keyProperty="id" parameterMap="userParam">
       insert into user  (username,password)  values (#{ userName},#{ password})
    </insert>
    <parameterMap id="userParam" type="com.example.testcanal.model.UserEntity">
       <parameter property="id" jdbcType="INTEGER"/>
       <parameter property="userName" jdbcType="VARCHAR"/>
       <parameter property="password" jdbcType="VARCHAR"/>
    </parameterMap>

其实就是参数类型的映射，指定jdbcType，javaType，typeHandler这些。  
接着看下代码

private void parameterMapElement(List<XNode> list) { 
        for (XNode parameterMapNode : list) { 
          String id = parameterMapNode.getStringAttribute("id");
          String type = parameterMapNode.getStringAttribute("type");
          Class<?> parameterClass = resolveClass(type);
          List<XNode> parameterNodes = parameterMapNode.evalNodes("parameter");
          List<ParameterMapping> parameterMappings = new ArrayList<>();
          for (XNode parameterNode : parameterNodes) { 
            String property = parameterNode.getStringAttribute("property");
            String javaType = parameterNode.getStringAttribute("javaType");
            String jdbcType = parameterNode.getStringAttribute("jdbcType");
            String resultMap = parameterNode.getStringAttribute("resultMap");
            String mode = parameterNode.getStringAttribute("mode");
            String typeHandler = parameterNode.getStringAttribute("typeHandler");
            Integer numericScale = parameterNode.getIntAttribute("numericScale");
            ParameterMode modeEnum = resolveParameterMode(mode);
            Class<?> javaTypeClass = resolveClass(javaType);
            JdbcType jdbcTypeEnum = resolveJdbcType(jdbcType);
            Class<? extends TypeHandler<?>> typeHandlerClass = resolveClass(typeHandler);
            ParameterMapping parameterMapping = builderAssistant.buildParameterMapping(parameterClass, property, javaTypeClass, jdbcTypeEnum, resultMap, modeEnum, typeHandlerClass, numericScale);
            parameterMappings.add(parameterMapping);
          }
          builderAssistant.addParameterMap(id, parameterClass, parameterMappings);
        }
      }

一个mapper文件中 不止有一个parameterMap ，所以这里是遍历，里面其实就是获取子标签， 属性值啥的进行封装，封装成ParameterMapping对象，放到一个集合中，然后添加到configuration 中专门放的parameterMap的 map中，key是namespace.id，vlaue就是parameterMap。

### 6.解析resultMap标签 ###

resultMap标签，我们开发中常用的一个功能，它就是进行返回值映射的

/** * 解析resultMap * @param list */
      private void resultMapElements(List<XNode> list) { 
        for (XNode resultMapNode : list) { 
          try { 
            resultMapElement(resultMapNode);
          } catch (IncompleteElementException e) { 
            // ignore, it will be retried
          }
        }
      }

一个mapper xml文件中不止一个resultMap，遍历这个mapper xml中的所有resultMap标签  
然后调用resultMapElement 方法来解析

private ResultMap resultMapElement(XNode resultMapNode, List<ResultMapping> additionalResultMappings, Class<?> enclosingType) { 
        ErrorContext.instance().activity("processing " + resultMapNode.getValueBasedIdentifier());
        // 获取type
        String type = resultMapNode.getStringAttribute("type",
            resultMapNode.getStringAttribute("ofType",
                resultMapNode.getStringAttribute("resultType",
                    resultMapNode.getStringAttribute("javaType"))));
        // 转成class对象
        Class<?> typeClass = resolveClass(type);
        if (typeClass == null) { 
          typeClass = inheritEnclosingType(resultMapNode, enclosingType);
        }
        Discriminator discriminator = null;
        List<ResultMapping> resultMappings = new ArrayList<>(additionalResultMappings);
        // 获取resultMap 的子标签
        List<XNode> resultChildren = resultMapNode.getChildren();
        for (XNode resultChild : resultChildren) { 
          // constructor 标签
          if ("constructor".equals(resultChild.getName())) { 
            // 构造方法
            processConstructorElement(resultChild, typeClass, resultMappings);
            //discriminator 标签
          } else if ("discriminator".equals(resultChild.getName())) { 
            discriminator = processDiscriminatorElement(resultChild, typeClass, resultMappings);
          } else { 
            List<ResultFlag> flags = new ArrayList<>();
            //id 的话添加 id标志
            if ("id".equals(resultChild.getName())) { 
              flags.add(ResultFlag.ID);
            }
            // 封装ResultMapping 然后放到resultMappings这个map中
            resultMappings.add(buildResultMappingFromContext(resultChild, typeClass, flags));
          }
        }
        // id
        String id = resultMapNode.getStringAttribute("id",
                resultMapNode.getValueBasedIdentifier());
        // extends
        String extend = resultMapNode.getStringAttribute("extends");
        // autoMapping
        Boolean autoMapping = resultMapNode.getBooleanAttribute("autoMapping");
        
        ResultMapResolver resultMapResolver = new ResultMapResolver(builderAssistant, id, typeClass, extend, discriminator, resultMappings, autoMapping);
        try { 
          return resultMapResolver.resolve();
        } catch (IncompleteElementException e) { 
          configuration.addIncompleteResultMap(resultMapResolver);
          throw e;
        }
      }

先是获取类型type，就是结果类型，先是拿type，没有用ofType，再没有用resultType ，再没有用javaType。  
再就是解析resultMap的子标签了。你要是用的都是简单功能的话，还是很简单的，最后构建出一个ResultMap 来，然后放到了configuration的一个map中。key是namespace.id，value是ResultMap 。

### 7.解析sql标签 ###

<sql id="userField">
       id,username,password
    </sql>
    <select id="selectAll" resultType="com.example.testcanal.dao.UserDao">
       select <include refid="userField"/> from user;
    </select>

使用的话，就是这么个用法。

/** * sql * @param list * @param requiredDatabaseId */
      private void sqlElement(List<XNode> list, String requiredDatabaseId) { 
        for (XNode context : list) { 
          String databaseId = context.getStringAttribute("databaseId");
          //id
          String id = context.getStringAttribute("id");
          // 将id 拼装上namespace
          id = builderAssistant.applyCurrentNamespace(id, false);
          if (databaseIdMatchesCurrent(id, databaseId, requiredDatabaseId)) { 
            //放到sqlFragments map中
            sqlFragments.put(id, context);
          }
        }
      }

这里就是讲内容与id取出来，然后塞到sqlFragments 这个map里面了，当然这个id进行了处理，前面拼装上了namespace

### 8.解析insert|update|delete|select 标签 ###

这个就非常的复杂了。

private void buildStatementFromContext(List<XNode> list, String requiredDatabaseId) { 
    
        for (XNode context : list) { 
    
          // 创建statement解析构建器
          final XMLStatementBuilder statementParser = new XMLStatementBuilder(configuration, builderAssistant, context, requiredDatabaseId);
          try { 
    
            //进行解析
            statementParser.parseStatementNode();
          } catch (IncompleteElementException e) { 
            // 出现异常，放入到集合中
            configuration.addIncompleteStatement(statementParser);
          }
        }
      }

拿到这个mapper中所有的insert|update|delete|select 标签节点 ，然后遍历为每个节点创建一个XMLStatementBuilder 解析器，调用parseStatementNode方法进行解析。

public void parseStatementNode() { 
       // id
       String id = context.getStringAttribute("id");
       String databaseId = context.getStringAttribute("databaseId");
    
       if (!databaseIdMatchesCurrent(id, databaseId, this.requiredDatabaseId)) { 
         return;
       }
       // TODO 这里就是看看 这个sql 是什么类型的
       // 根据node 获取下 sqlcommand类型
       String nodeName = context.getNode().getNodeName();
       SqlCommandType sqlCommandType = SqlCommandType.valueOf(nodeName.toUpperCase(Locale.ENGLISH));
       // 判断是不是 查询语句
       boolean isSelect = sqlCommandType == SqlCommandType.SELECT;
       // flushCache 这个玩意就是刷新缓存的意思，清楚缓存的意思
       // 如果 是查询语句 flushCache 就是false ，dml语句的话就需要刷新缓存 flushCache =true
       boolean flushCache = context.getBooleanAttribute("flushCache", !isSelect);
       //如果是查询语句，默认useCache就是true ，也就是默认使用cache ，它这个cache是二级缓存
       boolean useCache = context.getBooleanAttribute("useCache", isSelect);
       // 默认false 结果集嵌套使用
       boolean resultOrdered = context.getBooleanAttribute("resultOrdered", false);
       // Include Fragments before parsing
       XMLIncludeTransformer includeParser = new XMLIncludeTransformer(configuration, builderAssistant);
       includeParser.applyIncludes(context.getNode());
       // parameterType
       String parameterType = context.getStringAttribute("parameterType");
       // 转成class
       Class<?> parameterTypeClass = resolveClass(parameterType);
       String lang = context.getStringAttribute("lang");
       LanguageDriver langDriver = getLanguageDriver(lang);
       // Parse selectKey after includes and remove them.
       processSelectKeyNodes(id, parameterTypeClass, langDriver);
       // Parse the SQL (pre: <selectKey> and <include> were parsed and removed)
       KeyGenerator keyGenerator;
       //SELECT_KEY_SUFFIX = !selectKey
       String keyStatementId = id + SelectKeyGenerator.SELECT_KEY_SUFFIX;
       keyStatementId = builderAssistant.applyCurrentNamespace(keyStatementId, true);
       if (configuration.hasKeyGenerator(keyStatementId)) { 
         keyGenerator = configuration.getKeyGenerator(keyStatementId);
       } else {  //获取keyGenerator 判断是否使用GeneratedKeys 需要设置useGeneratedKeys=true
         keyGenerator = context.getBooleanAttribute("useGeneratedKeys",
             configuration.isUseGeneratedKeys() && SqlCommandType.INSERT.equals(sqlCommandType))
             ? Jdbc3KeyGenerator.INSTANCE : NoKeyGenerator.INSTANCE;
       }
       // 创建sql source，这里面其实就是解析动态sql
       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);// resultType
       String resultMap = context.getStringAttribute("resultMap");
       String resultSetType = context.getStringAttribute("resultSetType");// 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");
       // 添加statement
       builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType,
           fetchSize, timeout, parameterMap, parameterTypeClass, resultMap, resultTypeClass,
           resultSetTypeEnum, flushCache, useCache, resultOrdered,
           keyGenerator, keyProperty, keyColumn, databaseId, langDriver, resultSets);
     }

我们这里大体的介绍下，其实都是些获取属性值的工作。  
获取id，标签上面的唯一标识符，接着就是根据你这个标签类型，判断它的sql类型，接着获取flushCache ，useCache这两个属性，  
flushCache 是刷缓存， useCache 是使用缓存，这个是关于mybatis二级缓存的属性，我们开发的时候很少配置这个东西  
默认二级缓存是开启的，当时sql是select 语句就使用二级缓存， 其他语句，update，delete，insert就会刷新缓存，flushCache 就是true，毕竟你修改了东西，缓存肯定是要清理的。再往下就是替换 `<incloud>`标签，我们incloud标签中不是引用的sql语句段，也就是`<sql>`标签嘛，将`<incloud>`标签 替换成sql语句段里面的内容。  
再接着往下就是keyGenerator 一些属性配置了，我们常用的就是insert语句，插入一条数据，然后将插入这条数据的id会写到原来的对象中。

<insert id="addUser" useGeneratedKeys="true" keyProperty="id" parameterMap="userParam">
        insert into user  (username,password)  values (#{userName},#{password})
    </insert>

再往下就是创建SqlSource ，这个玩意老复杂了，解析你里面sql，将sql进行区分，动态的封装成动态的，静态的封装成静态的，这里就不看里面具体的内容了。  
下面就是找找resultMap，resultSetType，parameterMap 这些属性了。  
最后调用构建助手 添加MappedStatement。

// 构造id
        id = applyCurrentNamespace(id, false);
        boolean isSelect = sqlCommandType == SqlCommandType.SELECT;
    
        MappedStatement.Builder statementBuilder = new MappedStatement.Builder(configuration, id, sqlSource, sqlCommandType)
            .resource(resource)
            .fetchSize(fetchSize)
            .timeout(timeout)
            .statementType(statementType)
            .keyGenerator(keyGenerator)
            .keyProperty(keyProperty)
            .keyColumn(keyColumn)
            .databaseId(databaseId)
            .lang(lang)
            .resultOrdered(resultOrdered)
            .resultSets(resultSets)
            .resultMaps(getStatementResultMaps(resultMap, resultType, id))
            .resultSetType(resultSetType)
            // 默认不是select 语句就要刷新缓存
            .flushCacheRequired(valueOrDefault(flushCache, !isSelect))
            .useCache(valueOrDefault(useCache, isSelect))
            .cache(currentCache);
        // parameterMap
        ParameterMap statementParameterMap = getStatementParameterMap(parameterMap, parameterType, id);
        if (statementParameterMap != null) { 
          statementBuilder.parameterMap(statementParameterMap);
        }
    
        MappedStatement statement = statementBuilder.build();
        configuration.addMappedStatement(statement);// 添加到configuration中
        return statement;

先是处理id，将原来id前面加上namespace，再就是使用statementBuilder 构建MappedStatement 。在构建之前我们看到他还处理了一下ParameterMap ， 这个就是看看你用没有 parameterMap ，没有的话就用parameterType 封装成ParameterMap 。  
最后将这个MappedStatement 塞到configuration 中的一个map中，key是id，value就是MappedStatement 。

### 总结 ###

本文主要是看看mybatis是怎样解析我们写的那个mapper xml文件的，无非就是获取属性值，封装对象，塞到configuration 中的某个map中。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1YW5zaGFuZ3NoZW5naHVv_size_16_color_FFFFFF_t_70]: /images/20220829/0918dac11904414eac7ab552d4a56f66.png