Object's Blog

MyBatis源码解析(一)—构造篇

字数统计: 6.2k阅读时长: 27 min
2020/02/18 分享

前言

好久不见,从上一篇文章过后,休整了两个月,又逢疫情特殊时期,天天宅在家里挺尸,真是见证了一个人可以懒惰到什么境界。好吧废话不多说了,今天会给大家分享我们常用的持久层框架——MyBatis的工作原理和源码解析。

说实话MyBatis是我第一个接触的持久层框架,在这之前我也没有用过Hibernate,从Java原生的Jdbc操作数据库之后就直接过渡到了这个框架上,当时给我的第一感觉是,有一个框架太方便了,举一个例子吧,我们在Jdbc操作的时候,对于对象的封装,我们是需要通过ResultSet.getXXX(index)来获取值,然后在通过对象的setXXX()方法进行手动注入,这种重复且无任何技术含量的工作一直以来都是被我们程序猿所鄙视的一环,而MyBatis就可以直接将我们的SQL查询出来的数据与对象直接进行映射然后直接返回一个封装完成的对象,这节省了程序猿大部分的时间,当然其实JdbcTemplate也可以做到,但是这里先不说。MyBatis的优点有非常多,当然这也只有同时使用过Jdbc和MyBatis之后,产生对比,才会有这种巨大的落差感,但这并不是今天要讨论的重点,今天的重心还是放在MyBatis是如何做到这些的。

对于MyBatis,给我个人的感受,其工作流程实际上分为两部分:第一,构建,也就是解析我们写的xml配置,将其变成它所需要的对象。第二,就是执行,在构建完成的基础上,去执行我们的SQL,完成与Jdbc的交互。而这篇的重点会先放在构建上。

Xml配置文件

玩过这个框架的同学都知道,我们在单独使用它的时候,会需要两个配置文件,分别是mybatis-config.xml和mapper.xml,在官网上可以直接看到,当然这里为了方便,我就直接将我的xml配置复制一份。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
<!-- mybatis-config.xml -->
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<!-- 和spring整合后 environments配置将废除 -->
<environments default="development">
<environment id="development">
<!-- 使用jdbc事务管理 -->
<transactionManager type="JDBC" />
<!-- 数据库连接池 -->
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver" />
<property name="url"
value="jdbc:mysql://xxxxxxx:3306/test?characterEncoding=utf8"/>
<property name="username" value="username" />
<property name="password" value="password" />
</dataSource>
</environment>
</environments>

<!-- 加载mapper.xml -->
<mappers>
<!-- <package name=""> -->
<mapper resource="mapper/DemoMapper.xml" ></mapper>
</mappers>
</configuration>
1
2
3
4
5
6
7
8
<!-- DemoMapper.xml -->
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.DemoMapper">
<select id="queryTest" parameterType="Map" resultType="Map">
select * from test WHERE id =#{id}
</select>
</mapper>

我们不难看出,在mybatis-config.xml这个文件主要是用于配置数据源、配置别名、加载mapper.xml,并且我们可以看到这个文件的<mappers>节点中包含了一个<mapper>,而这个mapper所指向的路径就是另外一个xml文件:DemoMapper.xml,而这个文件中写了我们查询数据库所用的SQL。

而,MyBatis实际上就是将这两个xml文件,解析成配置对象,在执行中去使用它

解析

  • MyBatis需要什么配置对象?

    虽然在这里我们并没有进行源码的阅读,但是作为一个程序猿,我们可以凭借日常的开发经验做出一个假设。假设来源于问题,那么问题就是:为什么要将配置和SQL语句分为两个配置文件而不是直接写在一起?

    是不是就意味着,这两个配置文件会被MyBatis分开解析成两个不同的Java对象?

    不妨先将问题搁置,进行源码的阅读。

  • 环境搭建

    首先我们可以写一个最基本的使用MyBatis的代码,我这里已经写好了。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    public static void main(String[] args) throws Exception {
    String resource = "mybatis-config.xml";
    InputStream inputStream = Resources.getResourceAsStream(resource);
    //创建SqlSessionFacory
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    /******************************分割线******************************/
    SqlSession sqlSession = sqlSessionFactory.openSession();
    //获取Mapper
    DemoMapper mapper = sqlSession.getMapper(DemoMapper.class);
    Map<String,Object> map = new HashMap<>();
    map.put("id","123");
    System.out.println(mapper.selectAll(map));
    sqlSession.close();
    sqlSession.commit();
    }

    看源码重要的一点就是要找到源码的入口,而我们可以从这几行程序出发,来看看构建究竟是在哪开始的。

    首先不难看出,这段程序显示通过字节流读取了mybatis-config.xml文件,然后通过SqlSessionFactoryBuilder.build()方法,创建了一个SqlSessionFactory(这里用到了工厂模式和构建者模式),前面说过,MyBatis就是通过我们写的xml配置文件,来构建配置对象的,那么配置文件所在的地方,就一定是构建开始的地方,也就是build方法。

  • 构建开始

    进入build方法,我们可以看到这里的确有解析的意思,这个方法返回了一个SqlSessionFactory,而这个对象也是使用构造者模式创建的,不妨继续往下走。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
    try {
    //解析mybatis-config.xml
    //XMLConfigBuilder 构造者
    XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
    //parse(): 解析mybatis-config.xml里面的节点
    return build(parser.parse());
    } catch (Exception e) {
    throw ExceptionFactory.wrapException("Error building SqlSession.", e);
    } finally {
    ErrorContext.instance().reset();
    try {
    inputStream.close();
    } catch (IOException e) {
    // Intentionally ignore. Prefer previous error.
    }
    }
    }

    进入parse():

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    public Configuration parse() {
    //查看该文件是否已经解析过
    if (parsed) {
    throw new BuilderException("Each XMLConfigBuilder can only be used once.");
    }
    //如果没有解析过,则继续往下解析,并且将标识符置为true
    parsed = true;
    //解析<configuration>节点
    parseConfiguration(parser.evalNode("/configuration"));
    return configuration;
    }

    注意parse的返回值,Configuration,这个似曾相识的单词好像在哪见过,是否与mybatis-config.xml中的<configuration>节点有所关联呢?

    答案是肯定的,我们可以接着往下看。

    看到这里,虽然代码量还不是特别多,但是至少现在我们可以在大脑中得到一个大致的主线图,也如下图所示:

    大致构建图

    沿着这条主线,我们进入parseConfiguration(XNode)方法,接着往下看。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    private void parseConfiguration(XNode root) {
    try {
    //解析<Configuration>下的节点
    //issue #117 read properties first
    //<properties>
    propertiesElement(root.evalNode("properties"));
    //<settings>
    Properties settings = settingsAsProperties(root.evalNode("settings"));
    loadCustomVfs(settings);
    loadCustomLogImpl(settings);
    //别名<typeAliases>解析
    // 所谓别名 其实就是把你指定的别名对应的class存储在一个Map当中
    typeAliasesElement(root.evalNode("typeAliases"));
    //插件 <plugins>
    pluginElement(root.evalNode("plugins"));
    //自定义实例化对象的行为<objectFactory>
    objectFactoryElement(root.evalNode("objectFactory"));
    //MateObject 方便反射操作实体类的对象
    objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
    reflectorFactoryElement(root.evalNode("reflectorFactory"));
    settingsElement(settings);
    // read it after objectFactory and objectWrapperFactory issue #631
    //<environments>
    environmentsElement(root.evalNode("environments"));
    databaseIdProviderElement(root.evalNode("databaseIdProvider"));
    // typeHandlers
    typeHandlerElement(root.evalNode("typeHandlers"));
    //主要 <mappers> 指向我们存放SQL的xxxxMapper.xml文件
    mapperElement(root.evalNode("mappers"));
    } catch (Exception e) {
    throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
    }
    }

    可以看到这个方法已经在解析<configuration>下的节点了,例如<settings>,<typeAliases>,<environments><mappers>

    这里主要使用了分步构建每个解析不同标签的方法内部都对Configuration对象进行了set或者其它类似的操作,经过这些操作之后,一个Configuration对象就构建完毕了,这里由于代码量比较大,而且大多数构建都是些细节,大概知道怎么用就可以了,就不在文章中说明了,我会挑一个主要的说,当然有兴趣的同学可以自己去pull MyBatis的源码看看。

  • Mappers

    上文中提到,mybatis-config.xml文件中我们一定会写一个叫做<mappers>的标签,这个标签中的<mapper>节点存放了我们对数据库进行操作的SQL语句,所以这个标签的构建会作为今天分析的重点。

    首先在看源码之前,我们先回忆一下我们在mapper标签内通常会怎样进行配置,通常有如下几种配置方式。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
      <mappers>
    <!-- 通过配置文件路径 -->
    <mapper resource="mapper/DemoMapper.xml" ></mapper>
    <!-- 通过Java全限定类名 -->
    <mapper class="com.mybatistest.TestMapper"/>
    <!-- 通过url 通常是mapper不在本地时用 -->
    <mapper url=""/>
    <!-- 通过包名 -->
    <package name="com.mybatistest"/>
    <!-- 注意 mapper节点中,可以使用resource/url/class三种方式获取mapper-->
    </mappers>

    这是<mappers>标签的几种配置方式,通过这几种配置方式,可以帮助我们更容易理解mappers的解析。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
      private void mapperElement(XNode parent) throws Exception {
    if (parent != null) {
    //遍历解析mappers下的节点
    for (XNode child : parent.getChildren()) {
    //首先解析package节点
    if ("package".equals(child.getName())) {
    //获取包名
    String mapperPackage = child.getStringAttribute("name");
    configuration.addMappers(mapperPackage);
    } else {
    //如果不存在package节点,那么扫描mapper节点
    //resource/url/mapperClass三个值只能有一个值是有值的
    String resource = child.getStringAttribute("resource");
    String url = child.getStringAttribute("url");
    String mapperClass = child.getStringAttribute("class");
    //优先级 resource>url>mapperClass
    if (resource != null && url == null && mapperClass == null) {
    //如果mapper节点中的resource不为空
    ErrorContext.instance().resource(resource);
    //那么直接加载resource指向的XXXMapper.xml文件为字节流
    InputStream inputStream = Resources.getResourceAsStream(resource);
    //通过XMLMapperBuilder解析XXXMapper.xml,可以看到这里构建的XMLMapperBuilde还传入了configuration,所以之后肯定是会将mapper封装到configuration对象中去的。
    XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
    //解析
    mapperParser.parse();
    } else if (resource == null && url != null && mapperClass == null) {
    //如果url!=null,那么通过url解析
    ErrorContext.instance().resource(url);
    InputStream inputStream = Resources.getUrlAsStream(url);
    XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments());
    mapperParser.parse();
    } else if (resource == null && url == null && mapperClass != null) {
    //如果mapperClass!=null,那么通过加载类构造Configuration
    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.");
    }
    }
    }
    }
    }

    通过resource解析

    我们的配置文件中写的是通过resource来加载mapper.xml的,所以会通过XMLMapperBuilder来进行解析,我们可以进去他的parse方法中看一下:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
      public void parse() {
    //判断文件是否之前解析过
    if (!configuration.isResourceLoaded(resource)) {
    //解析mapper文件节点(主要)(下面贴了代码)
    configurationElement(parser.evalNode("/mapper"));
    configuration.addLoadedResource(resource);
    //绑定Namespace里面的Class对象
    bindMapperForNamespace();
    }
    //重新解析之前解析不了的节点,先不看,最后填坑。
    parsePendingResultMaps();
    parsePendingCacheRefs();
    parsePendingStatements();
    }


    //解析mapper文件里面的节点
    // 拿到里面配置的配置项 最终封装成一个MapperedStatemanet
    private void configurationElement(XNode context) {
    try {
    //获取命名空间 namespace,这个很重要,后期mybatis会通过这个动态代理我们的Mapper接口
    String namespace = context.getStringAttribute("namespace");
    if (namespace == null || namespace.equals("")) {
    //如果namespace为空则抛一个异常
    throw new BuilderException("Mapper's namespace cannot be empty");
    }
    builderAssistant.setCurrentNamespace(namespace);
    //解析缓存节点
    cacheRefElement(context.evalNode("cache-ref"));
    cacheElement(context.evalNode("cache"));

    //解析parameterMap(过时)和resultMap <resultMap></resultMap>
    parameterMapElement(context.evalNodes("/mapper/parameterMap"));
    resultMapElements(context.evalNodes("/mapper/resultMap"));
    //解析<sql>节点
    //<sql id="staticSql">select * from test</sql> (可重用的代码段)
    //<select> <include refid="staticSql"></select>
    sqlElement(context.evalNodes("/mapper/sql"));
    //解析增删改查节点<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);
    }
    }

    在这个parse()方法中,调用了一个configuationElement代码,用于解析XXXMapper.xml文件中的各种节点,包括<cache><cache-ref><paramaterMap>(已过时)、<resultMap><sql>、还有增删改查节点,和上面相同的是,我们也挑一个主要的来说,因为解析过程都大同小异。

    毋庸置疑的是,我们在XXXMapper.xml中必不可少的就是编写SQL,与数据库交互主要靠的也就是这个,所以着重说说解析增删改查节点的方法——buildStatementFromContext()。

    在没贴代码之前,根据这个名字就可以略知一二了,这个方法会根据我们的增删改查节点,来构造一个Statement,而用过原生Jdbc的都知道,Statement就是我们操作数据库的对象。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    private void buildStatementFromContext(List<XNode> list) {
    if (configuration.getDatabaseId() != null) {
    buildStatementFromContext(list, configuration.getDatabaseId());
    }
    //解析xml
    buildStatementFromContext(list, null);
    }

    private void buildStatementFromContext(List<XNode> list, String requiredDatabaseId) {
    for (XNode context : list) {
    final XMLStatementBuilder statementParser = new XMLStatementBuilder(configuration, builderAssistant, context, requiredDatabaseId);
    try {
    //解析xml节点
    statementParser.parseStatementNode();
    } catch (IncompleteElementException e) {
    //xml语句有问题时 存储到集合中 等解析完能解析的再重新解析
    configuration.addIncompleteStatement(statementParser);
    }
    }
    }


    public void parseStatementNode() {
    //获取<select id="xxx">中的id
    String id = context.getStringAttribute("id");
    //获取databaseId 用于多数据库,这里为null
    String databaseId = context.getStringAttribute("databaseId");

    if (!databaseIdMatchesCurrent(id, databaseId, this.requiredDatabaseId)) {
    return;
    }
    //获取节点名 select update delete insert
    String nodeName = context.getNode().getNodeName();
    //根据节点名,得到SQL操作的类型
    SqlCommandType sqlCommandType = SqlCommandType.valueOf(nodeName.toUpperCase(Locale.ENGLISH));
    //判断是否是查询
    boolean isSelect = sqlCommandType == SqlCommandType.SELECT;
    //是否刷新缓存 默认:增删改刷新 查询不刷新
    boolean flushCache = context.getBooleanAttribute("flushCache", !isSelect);
    //是否使用二级缓存 默认值:查询使用 增删改不使用
    boolean useCache = context.getBooleanAttribute("useCache", isSelect);
    //是否需要处理嵌套查询结果 group by

    // 三组数据 分成一个嵌套的查询结果
    boolean resultOrdered = context.getBooleanAttribute("resultOrdered", false);

    // Include Fragments before parsing
    XMLIncludeTransformer includeParser = new XMLIncludeTransformer(configuration, builderAssistant);
    //替换Includes标签为对应的sql标签里面的值
    includeParser.applyIncludes(context.getNode());

    //获取parameterType名
    String parameterType = context.getStringAttribute("parameterType");
    //获取parameterType的Class
    Class<?> parameterTypeClass = resolveClass(parameterType);

    //解析配置的自定义脚本语言驱动 这里为null
    String lang = context.getStringAttribute("lang");
    LanguageDriver langDriver = getLanguageDriver(lang);

    // Parse selectKey after includes and remove them.
    //解析selectKey
    processSelectKeyNodes(id, parameterTypeClass, langDriver);

    // Parse the SQL (pre: <selectKey> and <include> were parsed and removed)
    //设置主键自增规则
    KeyGenerator keyGenerator;
    String keyStatementId = id + SelectKeyGenerator.SELECT_KEY_SUFFIX;
    keyStatementId = builderAssistant.applyCurrentNamespace(keyStatementId, true);
    if (configuration.hasKeyGenerator(keyStatementId)) {
    keyGenerator = configuration.getKeyGenerator(keyStatementId);
    } else {
    keyGenerator = context.getBooleanAttribute("useGeneratedKeys",
    configuration.isUseGeneratedKeys() && SqlCommandType.INSERT.equals(sqlCommandType))
    ? Jdbc3KeyGenerator.INSTANCE : NoKeyGenerator.INSTANCE;
    }
    /************************************************************************************/
    //解析Sql(重要) 根据sql文本来判断是否需要动态解析 如果没有动态sql语句且 只有#{}的时候 直接静态解析使用?占位 当有 ${} 不解析
    SqlSource sqlSource = langDriver.createSqlSource(configuration, context, parameterTypeClass);
    //获取StatementType,可以理解为Statement和PreparedStatement
    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
    Class<?> resultTypeClass = resolveClass(resultType);
    //获取resultMap的id
    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");

    //将刚才获取到的属性,封装成MappedStatement对象(代码贴在下面)
    builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType,
    fetchSize, timeout, parameterMap, parameterTypeClass, resultMap, resultTypeClass,
    resultSetTypeEnum, flushCache, useCache, resultOrdered,
    keyGenerator, keyProperty, keyColumn, databaseId, langDriver, resultSets);
    }

    //将刚才获取到的属性,封装成MappedStatement对象
    public MappedStatement addMappedStatement(
    String id,
    SqlSource sqlSource,
    StatementType statementType,
    SqlCommandType sqlCommandType,
    Integer fetchSize,
    Integer timeout,
    String parameterMap,
    Class<?> parameterType,
    String resultMap,
    Class<?> resultType,
    ResultSetType resultSetType,
    boolean flushCache,
    boolean useCache,
    boolean resultOrdered,
    KeyGenerator keyGenerator,
    String keyProperty,
    String keyColumn,
    String databaseId,
    LanguageDriver lang,
    String resultSets) {

    if (unresolvedCacheRef) {
    throw new IncompleteElementException("Cache-ref not yet resolved");
    }

    //id = namespace
    id = applyCurrentNamespace(id, false);
    boolean isSelect = sqlCommandType == SqlCommandType.SELECT;

    //通过构造者模式+链式变成,构造一个MappedStatement的构造者
    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)
    .flushCacheRequired(valueOrDefault(flushCache, !isSelect))
    .useCache(valueOrDefault(useCache, isSelect))
    .cache(currentCache);

    ParameterMap statementParameterMap = getStatementParameterMap(parameterMap, parameterType, id);
    if (statementParameterMap != null) {
    statementBuilder.parameterMap(statementParameterMap);
    }

    //通过构造者构造MappedStatement
    MappedStatement statement = statementBuilder.build();
    //将MappedStatement对象封装到Configuration对象中
    configuration.addMappedStatement(statement);
    return statement;
    }

    这个代码段虽然很长,但是一句话形容它就是繁琐但不复杂,里面主要也就是对xml的节点进行解析。举个比上面简单的例子吧,假设我们有这样一段配置:

    1
    2
    3
      <select id="selectDemo" parameterType="java.lang.Integer" resultType='Map'>
    SELECT * FROM test
    </select>

    MyBatis需要做的就是,先判断这个节点是用来干什么的,然后再获取这个节点的id、parameterType、resultType等属性,封装成一个MappedStatement对象,由于这个对象很复杂,所以MyBatis使用了构造者模式来构造这个对象,最后当MappedStatement对象构造完成后,将其封装到Configuration对象中。

    代码执行至此,基本就结束了对Configuration对象的构建,MyBatis的第一阶段:构造,也就到这里结束了,现在再来回答我们在文章开头提出的那两个问题:MyBatis需要构造什么对象?以及是否两个配置文件对应着两个对象?,似乎就已经有了答案,这里做一个总结:

    MyBatis需要对配置文件进行解析,最终会解析成一个Configuration对象,但是要说两个配置文件对应了两个对象实际上也没有错:

    1. Configuration对象,保存了mybatis-config.xml的配置信息。
    2. MappedStatement,保存了XXXMapper.xml的配置信息。

    但是最终MappedStatement对象会封装到Configuration对象中,合二为一,成为一个单独的对象,也就是Configuration。

    最后给大家画一个构建过程的流程图:

    MyBatis构建流程图

填坑

  • SQL语句在哪解析?

    细心的同学可能已经发现了,上文中只说了去节点中获取一些属性从而构建配置对象,但是最重要的SQL语句并没有提到,这是因为这部分我想要和属性区分开单独说,由于MyBatis支持动态SQL和${}、#{}的多样的SQL,所以这里单独提出来说会比较合适。

    首先可以确认的是,刚才我们走完的那一整个流程中,包含了SQL语句的生成,下面贴代码(这一段代码相当绕,不好读)。

    1
    2
    //解析Sql(重要)  根据sql文本来判断是否需要动态解析 如果没有动态sql语句且 只有#{}的时候 直接静态解析使用?占位 当有 ${} 不解析
    SqlSource sqlSource = langDriver.createSqlSource(configuration, context, parameterTypeClass);

    这里就是生成Sql的入口,以单步调试的角度接着往下看。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    /*进入createSqlSource方法*/
    @Override
    public SqlSource createSqlSource(Configuration configuration, XNode script, Class<?> parameterType) {
    //进入这个构造
    XMLScriptBuilder builder = new XMLScriptBuilder(configuration, script, parameterType);
    //进入parseScriptNode
    return builder.parseScriptNode();
    }
    /**
    进入这个方法
    */
    public SqlSource parseScriptNode() {
    //#
    //会先解析一遍
    MixedSqlNode rootSqlNode = parseDynamicTags(context);
    SqlSource sqlSource;
    if (isDynamic) {
    //如果是${}会直接不解析,等待执行的时候直接赋值
    sqlSource = new DynamicSqlSource(configuration, rootSqlNode);
    } else {
    //用占位符方式来解析 #{} --> ?
    sqlSource = new RawSqlSource(configuration, rootSqlNode, parameterType);
    }
    return sqlSource;
    }
    protected MixedSqlNode parseDynamicTags(XNode node) {
    List<SqlNode> contents = new ArrayList<>();
    //获取select标签下的子标签
    NodeList children = node.getNode().getChildNodes();
    for (int i = 0; i < children.getLength(); i++) {
    XNode child = node.newXNode(children.item(i));
    if (child.getNode().getNodeType() == Node.CDATA_SECTION_NODE || child.getNode().getNodeType() == Node.TEXT_NODE) {
    //如果是查询
    //获取原生SQL语句 这里是 select * from test where id = #{id}
    String data = child.getStringBody("");
    TextSqlNode textSqlNode = new TextSqlNode(data);
    //检查sql是否是${}
    if (textSqlNode.isDynamic()) {
    //如果是${}那么直接不解析
    contents.add(textSqlNode);
    isDynamic = true;
    } else {
    //如果不是,则直接生成静态SQL
    //#{} -> ?
    contents.add(new StaticTextSqlNode(data));
    }
    } else if (child.getNode().getNodeType() == Node.ELEMENT_NODE) { // issue #628
    //如果是增删改
    String nodeName = child.getNode().getNodeName();
    NodeHandler handler = nodeHandlerMap.get(nodeName);
    if (handler == null) {
    throw new BuilderException("Unknown element <" + nodeName + "> in SQL statement.");
    }
    handler.handleNode(child, contents);
    isDynamic = true;
    }
    }
    return new MixedSqlNode(contents);
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    /*从上面的代码段到这一段中间需要经过很多代码,就不一段一段贴了*/
    public SqlSource parse(String originalSql, Class<?> parameterType, Map<String, Object> additionalParameters) {
    ParameterMappingTokenHandler handler = new ParameterMappingTokenHandler(configuration, parameterType, additionalParameters);
    //这里会生成一个GenericTokenParser,传入#{}作为开始和结束,然后调用其parse方法,即可将#{}换为 ?
    GenericTokenParser parser = new GenericTokenParser("#{", "}", handler);
    //这里可以解析#{} 将其替换为?
    String sql = parser.parse(originalSql);
    return new StaticSqlSource(configuration, sql, handler.getParameterMappings());
    }

    //经过一段复杂的解析过程
    public String parse(String text) {
    if (text == null || text.isEmpty()) {
    return "";
    }
    // search open token
    int start = text.indexOf(openToken);
    if (start == -1) {
    return text;
    }
    char[] src = text.toCharArray();
    int offset = 0;
    final StringBuilder builder = new StringBuilder();
    StringBuilder expression = null;
    //遍历里面所有的#{} select ? ,#{id1} ${}
    while (start > -1) {
    if (start > 0 && src[start - 1] == '\\') {
    // this open token is escaped. remove the backslash and continue.
    builder.append(src, offset, start - offset - 1).append(openToken);
    offset = start + openToken.length();
    } else {
    // found open token. let's search close token.
    if (expression == null) {
    expression = new StringBuilder();
    } else {
    expression.setLength(0);
    }
    builder.append(src, offset, start - offset);
    offset = start + openToken.length();
    int end = text.indexOf(closeToken, offset);
    while (end > -1) {
    if (end > offset && src[end - 1] == '\\') {
    // this close token is escaped. remove the backslash and continue.
    expression.append(src, offset, end - offset - 1).append(closeToken);
    offset = end + closeToken.length();
    end = text.indexOf(closeToken, offset);
    } else {
    expression.append(src, offset, end - offset);
    break;
    }
    }
    if (end == -1) {
    // close token was not found.
    builder.append(src, start, src.length - start);
    offset = src.length;
    } else {
    //使用占位符 ?
    //注意handler.handleToken()方法,这个方法是核心
    builder.append(handler.handleToken(expression.toString()));
    offset = end + closeToken.length();
    }
    }
    start = text.indexOf(openToken, offset);
    }
    if (offset < src.length) {
    builder.append(src, offset, src.length - offset);
    }
    return builder.toString();
    }

    //BindingTokenParser 的handleToken
    //当扫描到${}的时候调用此方法 其实就是不解析 在运行时候在替换成具体的值
    @Override
    public String handleToken(String content) {
    this.isDynamic = true;
    return null;
    }
    //ParameterMappingTokenHandler的handleToken
    //全局扫描#{id} 字符串之后 会把里面所有 #{} 调用handleToken 替换为?
    @Override
    public String handleToken(String content) {
    parameterMappings.add(buildParameterMapping(content));
    return "?";
    }

    这段代码相当绕,我们应该站在一个宏观的角度去看待它。所以我直接在这里概括一下:

    首先这里会通过<select>节点获取到我们的SQL语句,假设SQL语句中只有${},那么直接就什么都不做,在运行的时候直接进行赋值。

    而如果扫描到了#{}字符串之后,会进行替换,将#{}替换为 ?。

    那么他是怎么进行判断的呢?

    这里会生成一个GenericTokenParser,这个对象可以传入一个openToken和closeToken,如果是#{},那么openToken就是#{,closeToken就是 },然后通过parse方法中的handler.handleToken()方法进行替换。

    在这之前由于已经进行过SQL是否含有#{}的判断了,所以在这里如果是只有${},那么handler就是BindingTokenParser的实例化对象,如果存在#{},那么handler就是ParameterMappingTokenHandler的实例化对象。

    分别进行处理。

  • 上文中提到的解析不了的节点是什么意思?

    根据上文的代码我们可知,解析Mapper.xml文件中的每个节点是有顺序的。

    那么假设我写了这么几个节点:

    1
    2
    3
    4
    5
    6
    <select id="demoselect" paramterType='java.lang.Integer' resultMap='demoResultMap'>
    </select>
    <resultMap id="demoResultMap" type="demo">
    <id column property>
    <result coulmn property>
    </resultMap>

    select节点是需要获取resultMap的,但是此时resultMap并没有被解析到,所以解析到<select>这个节点的时候是无法获取到resultMap的信息的。

    我们来看看MyBatis是怎么做的:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    private void buildStatementFromContext(List<XNode> list, String requiredDatabaseId) {
    for (XNode context : list) {
    final XMLStatementBuilder statementParser = new XMLStatementBuilder(configuration, builderAssistant, context, requiredDatabaseId);
    try {
    //解析xml节点
    statementParser.parseStatementNode();
    } catch (IncompleteElementException e) {
    //xml语句有问题时 存储到集合中 等解析完能解析的再重新解析
    configuration.addIncompleteStatement(statementParser);
    }
    }
    }

    当解析到某个节点出现问题的时候,会抛一个异常,然后会调用configuration的addIncompleteStatement方法,将这个解析对象先暂存到这个集合中,等到所有的节点都解析完毕之后,在对这个集合内的解析对象继续解析:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    public void parse() {
    //判断文件是否之前解析过
    if (!configuration.isResourceLoaded(resource)) {
    //解析mapper文件
    configurationElement(parser.evalNode("/mapper"));
    configuration.addLoadedResource(resource);
    //绑定Namespace里面的Class对象
    bindMapperForNamespace();
    }

    //重新解析之前解析不了的节点
    parsePendingResultMaps();
    parsePendingCacheRefs();
    parsePendingStatements();
    }
    private void parsePendingResultMaps() {
    Collection<ResultMapResolver> incompleteResultMaps = configuration.getIncompleteResultMaps();
    synchronized (incompleteResultMaps) {
    Iterator<ResultMapResolver> iter = incompleteResultMaps.iterator();
    while (iter.hasNext()) {
    try {
    //添加resultMap
    iter.next().resolve();
    iter.remove();
    } catch (IncompleteElementException e) {
    // ResultMap is still missing a resource...
    }
    }
    }
    }
    public ResultMap resolve() {
    //添加resultMap
    return assistant.addResultMap(this.id, this.type, this.extend, this.discriminator, this.resultMappings, this.autoMapping);
    }

结语

至此整个MyBatis的查询前构建的过程就基本说完了,简单地总结就是,MyBatis会在执行查询之前,对配置文件进行解析成配置对象:Configuration,以便在后面执行的时候去使用,而存放SQL的xml又会解析成MappedStatement对象,但是最终这个对象也会加入Configuration中,至于Configuration是如何被使用的,以及SQL的执行部分,我会在下一篇说SQL执行的时候分享。

欢迎大家访问我的个人博客:Object’s Blog

原文作者:Object

原文链接:http://blog.objectspace.cn/2020/02/18/MyBatis源码解析(一)—构造篇/

发表日期:2020 February 18th, 11:37:00 am

更新日期:2020 February 18th, 12:18:19 pm

版权声明:未经作者授权请勿转载

目录
  1. 1. 前言
  2. 2. Xml配置文件
  3. 3. 解析
    1. 3.1. MyBatis需要什么配置对象?
    2. 3.2. 环境搭建
    3. 3.3. 构建开始
    4. 3.4. Mappers
  4. 4. 填坑
    1. 4.1. SQL语句在哪解析?
    2. 4.2. 上文中提到的解析不了的节点是什么意思?
  5. 5. 结语