MyBatis詳細原始碼解析（上篇）

Nyantocat發表於2020-12-15
MyBatis原始碼

前言

我會一步一步帶你剖析MyBatis這個經典的半ORM框架的原始碼！

我是使用Spring Boot + MyBatis的方式進行測試，但並未進行整合，還是使用最原始的方式。

專案結構

匯入依賴：

  1. mybatis：mybatis

  2. mysql-connector-java：mysql-connector-java

Payment表：

Payment實體類：

@Data
public class Payment implements Serializable {
    private Integer id;
    private String serial;
}

PaymentMapper介面：

@Repository
public interface PaymentMapper {
    // 根據Id查詢支付資訊
    Payment getPaymentById(@Param("id") Integer id);
}

配置檔案目錄：

Payment.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.gzy.mybatistest.mapper.PaymentMapper">
  <select id="getPaymentById" parameterType="integer" resultType="com.gzy.mybatistest.entity.Payment">
    SELECT * FROM payment WHERE id = #{id}
  </select>
</mapper>

database.properties：

# 配置資料庫資訊
driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/spring_cloud?serverTimezone=Asia/Shanghai
username=username
password=password

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>
  <!-- 匯入外部的資料庫Properties配置檔案 -->
  <properties resource="database.properties"/>

  <!-- 配置MyBatis的環境變數 -->
  <environments default="dev">
    <environment id="dev">
      <!-- 配置事務管理器 -->
      <transactionManager type="JDBC"></transactionManager>
      <!-- 配置資料來源 -->
      <dataSource type="POOLED">
        <property name="driver" value="${driver}"/>
        <property name="url" value="${url}"/>
        <property name="username" value="${username}"/>
        <property name="password" value="${password}"/>
      </dataSource>
    </environment>
  </environments>

  <!-- 配置SQL對映檔案 -->
  <mappers>
    <mapper resource="Payment.xml"/>
  </mappers>
</configuration>

測試類：

@SpringBootTest
class MybatisTestApplicationTests {
    @Test
    void contextLoads() {
        InputStream inputStream = null;
        try {
            inputStream = Resources.getResourceAsStream("mybatis-config.xml");
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
            SqlSession sqlSession = sqlSessionFactory.openSession();
            Payment payment = sqlSession.selectOne("com.gzy.mybatistest.mapper.PaymentMapper.getPaymentById", 1);
            System.out.println(payment);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

相關元件

Configuration：MyBatis所有的配置資訊都儲存在Configuration物件之中，配置檔案中的大部分配置都會儲存到該類中。

SqlSession：作為MyBatis工作的主要頂層API，表示和資料庫互動時的會話，完成必要資料庫增刪改查功能。

Executor：MyBatis執行器，是MyBatis 排程的核心，負責SQL語句的生成和查詢快取的維護。

StatementHandler：封裝了JDBC Statement操作，負責對JDBC Statement的操作，如設定引數等。

ParameterHandler：負責對使用者傳遞的引數轉換成JDBC Statement所對應的資料型別。

ResultSetHandler：負責將JDBC返回的ResultSet結果集物件轉換成List型別的集合。

TypeHandler：負責Java資料型別和Jdbc資料型別（也可以說是資料表列型別）之間的對映和轉換。

MappedStatement：MappedStatement維護一條<select|update|delete|insert>節點的封裝。

SqlSource：負責根據使用者傳遞的ParameterObject，動態地生成SQL語句，將資訊封裝到BoundSql物件中並返回。

BoundSql：表示動態生成的SQL語句以及相應的引數資訊。

MyBatis詳細原始碼解析（上篇）

執行步驟

第一步

這一步的主要目的就是將MyBatis配置檔案載入進記憶體中。

InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");

MyBatis的配置檔案主要有兩個：database.properties和mybatis-config.xml。database.properties用於配置資料庫的連線資訊，而mybatis-config.xml則是MyBatis的主配置檔案，mybatis-config.xml中引入了database.properties的資料庫連線資訊。

這裡MyBatis為我們封裝了一個資源讀取的工具類Resources，getResourceAsStream方法預設會使用系統類載入器（SystemClassLoader）從resources路徑下載入指定檔案並且返回一個輸入流。

// Resources類，從上至下依次呼叫
public static InputStream getResourceAsStream(String resource) throws IOException {
    return getResourceAsStream(null, resource);
}

// getResourceAsStream過載方法
public static InputStream getResourceAsStream(ClassLoader loader, String resource) throws IOException {
    // MyBatis在ClassLoader類基礎上封裝了一層ClassLoaderWrapper包裝類
    // 我們可以指定所使用類載入，預設為null
    InputStream in = classLoaderWrapper.getResourceAsStream(resource, loader);
    if (in == null) {
        throw new IOException("Could not find resource " + resource);
    }
    return in;
}

// ClassLoaderWrapper類
public InputStream getResourceAsStream(String resource, ClassLoader classLoader) {
    return getResourceAsStream(resource, getClassLoaders(classLoader));
}

ClassLoader[] getClassLoaders(ClassLoader classLoader) {
    return new ClassLoader[]{
        classLoader, // null
        defaultClassLoader, // null
        Thread.currentThread().getContextClassLoader(), // SystemClassLoader
        getClass().getClassLoader(), // SystemClassLoader
        systemClassLoader}; // SystemClassLoader
}

// getResourceAsStream過載方法
InputStream getResourceAsStream(String resource, ClassLoader[] classLoader) {
    for (ClassLoader cl : classLoader) {
        if (null != cl) {
            InputStream returnValue = cl.getResourceAsStream(resource);
            if (null == returnValue) {
                returnValue = cl.getResourceAsStream("/" + resource);
            }
            if (null != returnValue) {
                return returnValue;
            }
        }
    }
    return null;
}

第二步

這一步的主要目的就是解析MyBatis的XML主配置檔案，然後將配置資訊存入Configuration類中，最後通過Configuration類建立一個SqlSessionFactory介面的實現類DefaultSqlSessionFactory。

SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

MyBatis使用了建造者模式來建立一個SqlSessionFactory，在SqlSessionFactoryBuilder類中只有build方法（還包括多個過載方法），該方法會建立並返回一個SqlSessionFactory物件。

build方法裡面又會看到一個XMLConfigBuilder類，看名字就能知道它是通過XML主配置檔案來構建Configuration類。

最終build方法會返回一個SqlSessionFactory介面的實現類DefaultSqlSessionFactory，該類中儲存了之前解析出來的Configuration物件。

// SqlSessionFactoryBuilder類中的build方法
public SqlSessionFactory build(InputStream inputStream) {
    return build(inputStream, null, null);
}

// SqlSessionFactoryBuilder類中的build過載方法
public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
    try {
        // 解析XML主配置檔案
        XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
        // 返回DefaultSqlSessionFactory物件
        return build(parser.parse());
    } catch (Exception e) {
        throw ExceptionFactory.wrapException("Error building SqlSession.", e);
    } finally {
        // 清空ThreadLocal中儲存的ErrorContext
        ErrorContext.instance().reset();
        try {
            inputStream.close();
        } catch (IOException e) {
            // Intentionally ignore. Prefer previous error.
        }
    }
}

// 通過解析後的Configuration物件建立DefaultSqlSessionFactory物件
public SqlSessionFactory build(Configuration config) {
    return new DefaultSqlSessionFactory(config);
}

public class DefaultSqlSessionFactory implements SqlSessionFactory {
	// 儲存了之前解析出來的Configuration物件
    private final Configuration configuration;

    public DefaultSqlSessionFactory(Configuration configuration) {
        this.configuration = configuration;
    }

    @Override
    public SqlSession openSession() {
        return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);
    }
    
   	// 省略其他內容...
}

首先要做的是解析XML主配置檔案前的準備工作！

現在我們進入XMLConfigBuilder類的構造方法，多個過載構造方法層層呼叫，最終呼叫了父類BaseBuilder的構造方法。

ErrorContext類是用來記錄本次執行過程中相關上下文資訊，待發生Error時候其他元件就可以從本類例項中獲取到相關的上下文資訊，這對於排錯是非常有幫助的。

// 繼承了抽象類BaseBuilder
public class XMLConfigBuilder extends BaseBuilder {
    private boolean parsed;
    private final XPathParser parser;
    private String environment;
    private final ReflectorFactory localReflectorFactory = new DefaultReflectorFactory();
    
    public XMLConfigBuilder(InputStream inputStream, String environment, Properties props) {
        // 建立了一個XPahParser物件
        this(new XPathParser(inputStream, true, props, new XMLMapperEntityResolver()), environment, props);
    }

    private XMLConfigBuilder(XPathParser parser, String environment, Properties props) {
        // 呼叫父類的構造方法，同時初始化了一個Configuration物件
        super(new Configuration());
        ErrorContext.instance().resource("SQL Mapper Configuration");
        this.configuration.setVariables(props);
        // 表示當前還並未解析完成
        this.parsed = false;
        // 指定MyBatis所使用環境
        this.environment = environment;
        // 指定MyBatis所使用的XML解析器
        this.parser = parser;
    }
    
    // 省略其他內容...
}

在BaseBuilder構造方法中建立了兩個物件：

  1. TypeAliasRegistry。
  2. TypeHandlerRegistry。
public abstract class BaseBuilder {
    protected final Configuration configuration;
    // 型別別名註冊中心
    protected final TypeAliasRegistry typeAliasRegistry;
    // 型別處理註冊中心
    protected final TypeHandlerRegistry typeHandlerRegistry;

    public BaseBuilder(Configuration configuration) {
        this.configuration = configuration;
        this.typeAliasRegistry = this.configuration.getTypeAliasRegistry();
        this.typeHandlerRegistry = this.configuration.getTypeHandlerRegistry();
    }
    
    // 省略其他內容...
}

TypeAliasRegistry：看類名很容易知道它用於註冊一些預設的型別別名。這些別名全都儲存在一個名為typeAliases的Map集合中，全部都為小寫，包括基本資料型別、基本資料型別的包裝類、陣列類、集合類等。

public class TypeAliasRegistry {
	// 儲存型別別名
    private final Map<String, Class<?>> typeAliases = new HashMap<>();

    //
    public TypeAliasRegistry() {
        registerAlias("string", String.class);

        registerAlias("byte", Byte.class);
        registerAlias("long", Long.class);
        registerAlias("short", Short.class);
        registerAlias("int", Integer.class);
        registerAlias("integer", Integer.class);
        registerAlias("double", Double.class);
        registerAlias("float", Float.class);
        registerAlias("boolean", Boolean.class);
        
        // 省略其他內容...
    }
    
    // 別名的註冊方法，MyBatis預設註冊和我們自己註冊都是使用該方法
    public void registerAlias(String alias, Class<?> value) {
        if (alias == null) {
            throw new TypeException("The parameter alias cannot be null");
        }
        // 設定別名為小寫字串
        String key = alias.toLowerCase(Locale.ENGLISH);
        // 如果別名已存在就丟擲異常
        if (typeAliases.containsKey(key) && typeAliases.get(key) != null && !typeAliases.get(key).equals(value)) {
            throw new TypeException("The alias '" + alias + "' is already mapped to the value '" + typeAliases.get(key).getName() + "'.");
        }
        // 將別名存入集合
        typeAliases.put(key, value);
    }
}

因此我們在XML對映檔案中可以直接使用這些預設別名：

MyBatis詳細原始碼解析（上篇）

TypeHandlerRegistry：看類名很容易知道它用於資料庫型別與Java型別之間的轉換（雙向轉換），以及與資料庫之間資料的傳送和獲取。例如在獲取結果時將資料庫中的VARCHAR型別轉換為Java的String型別、在傳送SQL時將Java的Double或double型別轉換為資料庫中的Double型別等。

型別轉換的原理也很簡單，就是使用原生JDBC ResultSet結果集中不同資料型別所對應的獲取方法和設定方法，例如getSring(String columnLabel)、setString(int parameterIndex, String x)、getByte(String columnLabel)等。

public class StringTypeHandler extends BaseTypeHandler<String> {
    // 在向資料傳送SQL時由資料庫驅動將Java型別轉為對應的資料庫型別
    @Override
    public void setNonNullParameter(PreparedStatement ps, int i, String parameter, JdbcType jdbcType)
        throws SQLException {
        ps.setString(i, parameter);
    }

    // 在獲取結果時將資料庫型別轉換為對應的Java型別
    @Override
    public String getNullableResult(ResultSet rs, String columnName)
        throws SQLException {
        return rs.getString(columnName);
    }
    
    // 省略其他內容...
}

Configuration類非常簡單，就是用來儲存MyBatis所有配置資訊的類，例如所使用的資料庫環境、是否啟動駝峰對映、是否啟動主鍵生成策略、是否啟動一級快取等。

// 用於儲存MyBatis的配置資訊
public class Configuration {
  protected Environment environment;
  protected boolean safeRowBoundsEnabled;
  protected boolean safeResultHandlerEnabled = true;
  protected boolean mapUnderscoreToCamelCase;
  protected boolean aggressiveLazyLoading;
  protected boolean multipleResultSetsEnabled = true;
  protected boolean useGeneratedKeys;
  protected boolean useColumnLabel = true;
  protected boolean cacheEnabled = true; //預設開啟一級快取
  protected boolean callSettersOnNulls;
    
    // 省略其他內容...
}

XMLConfigBuilder構造方法中建立了一個XML解析器，就是XPathParser，它的作用是通過XPath語言來解析XML主配置檔案。

XPath：是一門在XML文件中查詢資訊的語言。XPath可用來在XML文件中對元素和屬性進行遍歷，XPath是W3C XSLT標準的主要元素，並且XQuery和XPointer都構建於XPath表達之上。

可以看見在commonConstructor方法中通過XPathFactory類建立了一個XPath物件。

public class XPathParser {
    private final Document document;
    private boolean validation;
    private EntityResolver entityResolver;
    private Properties variables;
    private XPath xpath;
    
    // 構造方法
    public XPathParser(InputStream inputStream,
                       boolean validation, Properties variables, EntityResolver entityResolver) {
        commonConstructor(validation, variables, entityResolver);
        // 根據XML主配置檔案輸入流建立Document物件
        this.document = createDocument(new InputSource(inputStream));
    }

    private void commonConstructor(boolean validation,
                                   Properties variables, EntityResolver entityResolver) {
        this.validation = validation;
        this.entityResolver = entityResolver;
        this.variables = variables;
        XPathFactory factory = XPathFactory.newInstance();
        this.xpath = factory.newXPath();
    }
    
    // 省略其他內容...
}

InputSource：表示XML實體的單個輸入源。

Document：Document介面表示整個HTML或XML文件。從概念上講，它是文件樹的根，並提供對文件資料的基本訪問。

EntityResolver：這個介面主要用於處理本地的XML約束檔案（DTD或Schema），MyBatis中使用的是XMLMapperEntityResolver實現類。

XMLMapperEntityResolver類中指明瞭MyBatis本地的的DTD約束檔案路徑，並且提供了載入約束檔案的方法實現。

public class XMLMapperEntityResolver implements EntityResolver {
    private static final String IBATIS_CONFIG_SYSTEM = "ibatis-3-config.dtd";
    private static final String IBATIS_MAPPER_SYSTEM = "ibatis-3-mapper.dtd";
    private static final String MYBATIS_CONFIG_SYSTEM = "mybatis-3-config.dtd";
    private static final String MYBATIS_MAPPER_SYSTEM = "mybatis-3-mapper.dtd";

    // MyBatis本地的DTD檔案路徑
    private static final String MYBATIS_CONFIG_DTD = "org/apache/ibatis/builder/xml/mybatis-3-config.dtd";
    private static final String MYBATIS_MAPPER_DTD = "org/apache/ibatis/builder/xml/mybatis-3-mapper.dtd";

    // 省略其他內容...
}

準備工作完成後就開始真正的解析工作！

先說明一下，我們可以看出主配置檔案的最外層節點是<configuration>標籤，mybatis的初始化就是把這個標籤以及他的所有子標籤進行解析，把解析好的資料封裝在Configuration這個類中。

public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
    try {
        XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
        // 真正地解析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.
        }
    }
}

我們進入到XPathBuilder類parse方法中，可以看到它會先進行一個判斷，判斷MyBatis的XML主配置檔案是否已經被解析過，這個parsed屬性預設為false。

parseConfiguration方法開始解析XML主配置檔案。該方法傳入的是一個XNode引數，這個XNode類其實是MyBatis對官方提供的Node類的一層封裝。

XNode引數的由來：XPathParser對XPath路徑表示式“/configuration”對之前儲存的Document物件（代表整個XML主配置檔案）進行解析，解析出一個代表著<Configuration>節點的Node，然後將Node封裝成XNode。

public Configuration parse() {
    if (parsed) {
        throw new BuilderException("Each XMLConfigBuilder can only be used once.");
    }
    parsed = true;
    // 構建了一個XNode物件
    parseConfiguration(parser.evalNode("/configuration"));
    return configuration;
}

private void parseConfiguration(XNode root) {
    try {
        // issue #117 read properties first
        // 這裡依次解析XML主配置檔案的各個標籤
        propertiesElement(root.evalNode("properties"));
        Properties settings = settingsAsProperties(root.evalNode("settings"));
        loadCustomVfs(settings);
        loadCustomLogImpl(settings);
        typeAliasesElement(root.evalNode("typeAliases"));
        pluginElement(root.evalNode("plugins"));
        objectFactoryElement(root.evalNode("objectFactory"));
        objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
        reflectorFactoryElement(root.evalNode("reflectorFactory"));
        settingsElement(settings);
        // read it after objectFactory and objectWrapperFactory issue #631
        environmentsElement(root.evalNode("environments"));
        databaseIdProviderElement(root.evalNode("databaseIdProvider"));
        typeHandlerElement(root.evalNode("typeHandlers"));
        mapperElement(root.evalNode("mappers"));
    } catch (Exception e) {
        throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
    }
}

我們可以看出這個方法是對<configuration>的所有子標籤輪流解析。比如常在配置檔案中出現的settings屬性配置，在settings會配置快取，日誌之類的，還有typeAliases是配置別名，environments是配置資料庫連結和事務。這些子節點會被一個個解析並且把解析後的資料封裝在Configuration這個類中，可以看第二步方法的返回值就是Configuration物件。

在這裡我們重點分析的解析mappers這個子標籤，這個標籤裡面還會有一個個的mapper標籤去對映mapper所對應的mapper.xml，可以回頭看看主配置檔案。

這個方法一開始是一個迴圈，因為一個<mappers>節點下面可能會有很多<mapper>節點。在應用中肯定不止一個mapper.xml。所以他會去遍歷每一個<mapper>節點去解析該節點所對映的XML檔案。迴圈下面是一個判斷，它先判斷<mappers>下面的子節點是不是package節點，因為在實際開發中有很多的XML檔案，有時我們會乾脆用一個<package>節點去對映一個包下面的所有的XML檔案，這是多檔案對映。如果不是<package>節點那肯定就是<mapper>節點做單檔案對映。

我們看下面的三行程式碼，發現單檔案對映有三種方式：

  1. 第一種使用<mapper>節點的resource屬性直接對映XML檔案。

  2. 第二種是使用<mapper>節點url屬性對映網路或者磁碟路徑下的某個XML檔案。

  3. 第三種是使用<mapper>節點的class屬性直接對映某個mapper介面。

private void mapperElement(XNode parent) throws Exception {
    if (parent != null) {
        for (XNode child : parent.getChildren()) {
            // 判斷是否為多檔案對映
            if ("package".equals(child.getName())) {
                String mapperPackage = child.getStringAttribute("name");
                // 解析出要對映的包路徑並新增至Configuration物件中
                configuration.addMappers(mapperPackage);
            } else {
                // 單檔案對映
                // 先解析出三種對映方式的路徑
                String resource = child.getStringAttribute("resource");
                String url = child.getStringAttribute("url");
                String mapperClass = child.getStringAttribute("class");
                
                if (resource != null && url == null && mapperClass == null) { // resource的方式
                    ErrorContext.instance().resource(resource);
                    InputStream inputStream = Resources.getResourceAsStream(resource);
                    XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
                    mapperParser.parse();
                } else if (resource == null && url != null && mapperClass == 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) { // 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.");
                }
            }
        }
    }
}

實際上對映XML的方式看原始碼可以得出有三種方式，我們先看resource方式。

第一行程式碼的意思是例項化一個錯誤上下文物件，我們回憶一下我們使用MyBatis的過程中如果出現錯誤會不會提示這個錯誤在哪個XML中，還提示這個錯誤在XML中的哪個SQL中。這個物件的作用就是把錯誤資訊封裝起來，如果出現錯誤就會呼叫這個物件的toString方法。

然後就跟一開始解析XML主配置檔案十分相似，使用流的形式讀取類路徑下的Mapper對映檔案，再XMLMapperBuilder類解析。而且XMLMapperBuilder類的構造和XMLConfigBuilder十分相似，只是多了一個用於儲存SQL片段XNode的Map集合。

if (resource != null && url == null && mapperClass == null) { // resource的方式
    ErrorContext.instance().resource(resource);
    InputStream inputStream = Resources.getResourceAsStream(resource);
    XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
    mapperParser.parse();
}

public class XMLMapperBuilder extends BaseBuilder {
    private final XPathParser parser;
    private final MapperBuilderAssistant builderAssistant;
    private final Map<String, XNode> sqlFragments;
    private final String resource;
    
    // 省略其他內容...
}

我們再進入XMLMapperBuilder類的parse方法，一開始就判斷這個XML是否被解析過了。因為Configuration物件會維護一個String型別的Set集合loadedResources，這個集合中存放了所有已經被解析過的XML的名字。

如果還未解析過，就會獲取一個代表<mapper>節點的XNode物件，然後對<mapper>節點下的所有子節點輪流解析，比如常用的有<resultMap>節點、<sql>節點等。

public void parse() {
    if (!configuration.isResourceLoaded(resource)) {
        
        configurationElement(parser.evalNode("/mapper"));
        configuration.addLoadedResource(resource);
        bindMapperForNamespace();
    }

    parsePendingResultMaps();
    parsePendingCacheRefs();
    parsePendingStatements();
}

// 依次對mapper節點下的所有子節點進行解析
private void configurationElement(XNode context) {
    try {
        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"));
        cacheElement(context.evalNode("cache"));
        parameterMapElement(context.evalNodes("/mapper/parameterMap"));
        resultMapElements(context.evalNodes("/mapper/resultMap"));
        sqlElement(context.evalNodes("/mapper/sql"));
        // 根據select、insert、update和delete節點構建statement
        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);
    }
}

在末尾我們可以看到有一個buildStatementFromContext方法，它解析了<select>、<insert>、<update>、<delete>四個節點，構建了一個存有所有關聯了SQL語句節點的XNode集合。在buildStatementFromContext方法中，它會先判斷是否指定了所使用的資料庫。然後就是遍歷解析List集合，這個List集合裡裝的是XML中的所有SQL節點，比如“select insert update delete” ，每一個SQL是一個節點。

XMLStatementBuilder類是會話解析器，用於解析每個SQL節點。

private void buildStatementFromContext(List<XNode> list) {
    if (configuration.getDatabaseId() != null) {
        buildStatementFromContext(list, configuration.getDatabaseId());
    }
    buildStatementFromContext(list, null);
}


private void buildStatementFromContext(List<XNode> list, String requiredDatabaseId) {
    // 遍歷存有SQL節點的集合
    for (XNode context : list) {
        final XMLStatementBuilder statementParser = new XMLStatementBuilder(configuration, builderAssistant, context, requiredDatabaseId);
        try {
            // 對SQL節點進行解析
            statementParser.parseStatementNode();
        } catch (IncompleteElementException e) {
            configuration.addIncompleteStatement(statementParser);
        }
    }
}
```[]()

相關文章