主頁 > 後端開發 > MyBatis詳細原始碼決議（上篇）

MyBatis詳細原始碼決議（上篇）

2020-12-15 12:37:22 後端開發

前言

我會一步一步帶你剖析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="https://www.cnblogs.com/SunnyGao/p/${driver}"/>
        <property name="url" value="https://www.cnblogs.com/SunnyGao/p/${url}"/>
        <property name="username" value="https://www.cnblogs.com/SunnyGao/p/${username}"/>
        <property name="password" value="https://www.cnblogs.com/SunnyGao/p/${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組態檔加載進記憶體中，

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 = https://www.cnblogs.com/SunnyGao/p/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映射檔案中可以直接使用這些默認別名：

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);
        }
    }
}
```[]()

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/234986.html

標籤：Java

上一篇：Spring簡單介紹

下一篇：MyBatis詳細原始碼決議（中篇）

標籤雲
其他(157675) Python(38076) JavaScript(25376) Java(17977) C(15215) 區塊鏈(8255) C＃(7972) AI(7469) 爪哇(7425) MySQL(7132) html(6777) 基礎類(6313) sql(6102) 熊猫(6058) PHP(5869) 数组(5741) R(5409) Linux(5327) 反应(5209) 腳本語言(PerlPython)(5129) 非技術區(4971) Android(4554) 数据框(4311) css(4259) 节点.js(4032) C語言(3288) json(3245) 列表(3129) 扑(3119) C++語言(3117) 安卓(2998) 打字稿(2995) VBA(2789) Java相關(2746) 疑難問題(2699) 细绳(2522) 單片機工控(2479) iOS(2429) ASP.NET(2402) MongoDB(2323) 麻木的(2285) 正则表达式(2254) 字典(2211) 循环(2198) 迅速(2185) 擅长(2169) 镖(2155) 功能(1967) .NET技术(1958) Web開發(1951) python-3.x(1918) HtmlCss(1915) 弹簧靴(1913) C++(1909) xml(1889) PostgreSQL(1872) .NETCore(1853) 谷歌表格(1846) Unity3D(1843) for循环(1842)

熱門瀏覽
  • 【C++】Microsoft C++、C 和匯編程式檔案

    ......

    uj5u.com 2020-09-10 00:57:23 more
  • 例外宣告

    相比于斷言適用于排除邏輯上不可能存在的狀態，例外通常是用于邏輯上可能發生的錯誤。 例外宣告 Item 1：當函式不可能拋出例外或不能接受拋出例外時，使用noexcept 理由 如果不打算拋出例外的話，程式就會認為無法處理這種錯誤，并且應當盡早終止，如此可以有效地阻止例外的傳播與擴散。 示例 //不可 ......

    uj5u.com 2020-09-10 00:57:27 more
  • Codeforces 1400E Clear the Multiset(貪心 + 分治)

    鏈接：https://codeforces.com/problemset/problem/1400/E 來源：Codeforces 思路：給你一個陣列，現在你可以進行兩種操作，操作1：將一段沒有 0 的區間進行減一的操作，操作2：將 i 位置上的元素歸零。最終問：將這個陣列的全部元素歸零后操作的最少 ......

    uj5u.com 2020-09-10 00:57:30 more
  • UVA11610 【Reverse Prime】

    本人看到此題沒有翻譯，就附帶了一個自己的翻譯版本 思考 這一題，它的第一個要求是找出所有 $7$ 位反向質數及其質因數的個數。 我們應該需要質數篩篩選1~$10^{7}$的所有數，這里就不慢慢介紹了。但是，重讀題，我們突然發現反向質數都是 $7$ 位，而將它反過來后的數字卻是 $6$ 位數，這就說明 ......

    uj5u.com 2020-09-10 00:57:36 more
  • 統計區間素數數量

    1 #pragma GCC optimize(2) 2 #include <bits/stdc++.h> 3 using namespace std; 4 bool isprime[1000000010]; 5 vector<int> prime; 6 inline int getlist(int ......

    uj5u.com 2020-09-10 00:57:47 more
  • C/C++編程筆記：C++中的 const 變數詳解，教你正確認識const用法

    1、C中的const 1、區域const變數存放在堆疊區中，會分配記憶體（也就是說可以通過地址間接修改變數的值）。測驗代碼如下： 運行結果： 2、全域const變數存放在只讀資料段（不能通過地址修改，會發生寫入錯誤）， 默認為外部聯編，可以給其他源檔案使用（需要用extern關鍵字修飾） 運行結果： ......

    uj5u.com 2020-09-10 00:58:04 more
  • 【C++犯錯記錄】VS2019 MFC添加資源不懂如何修改資源宏ID

    1. 首先在資源視圖中，添加資源 2. 點擊新添加的資源，復制自動生成的ID 3. 在解決方案資源管理器中找到Resource.h檔案，編輯，使用整個專案搜索和替換的方式快速替換 宏宣告 4. Ctrl+Shift+F 全域搜索，點擊查找全部，然后逐個替換 5. 為什么使用搜索替換而不使用屬性視窗直 ......

    uj5u.com 2020-09-10 00:59:11 more
  • 【C++犯錯記錄】VS2019 MFC不懂的批量添加資源

    1. 打開資源頭檔案Resource.h，在其中預先定義好宏 ID（不清楚其實ID值應該設定多少，可以先新建一個相同的資源項，再在這個資源的ID值的基礎上遞增即可） 2. 在資源視圖中選中專案資源，按F7編輯資源檔案，按 ID 型別 相對路徑的形式添加 資源。（別忘了先把檔案拷貝到專案中的res檔案 ......

    uj5u.com 2020-09-10 01:00:19 more
  • C/C++編程筆記：關于C++的參考型別，專供新手入門使用

    今天要講的是C++中我最喜歡的一個用法——參考，也叫別名。 參考就是給一個變數名取一個變數名，方便我們間接地使用這個變數。我們可以給一個變數創建N個參考，這N + 1個變數共享了同一塊記憶體區域。(參考型別的變數會占用記憶體空間，占用的記憶體空間的大小和指標型別的大小是相同的。雖然參考是一個物件的別名，但 ......

    uj5u.com 2020-09-10 01:00:22 more
  • 【C/C++編程筆記】從頭開始學習C ++：初學者完整指南

    眾所周知，C ++的學習曲線陡峭，但是花時間學習這種語言將為您的職業帶來奇跡，并使您與其他開發人員區分開。您會更輕松地學習新語言，形成真正的解決問題的技能，并在編程的基礎上打下堅實的基礎。 C ++將幫助您養成良好的編程習慣（即清晰一致的編碼風格，在撰寫代碼時注釋代碼，并限制類內部的可見性），并且由 ......

    uj5u.com 2020-09-10 01:00:41 more
最新发布
  • Rust中的智能指標:Box<T> Rc<T> Arc<T> Cell<T> RefCell<T> Weak

    Rust中的智能指標是什么 智能指標（smart pointers）是一類資料結構，是擁有資料所有權和額外功能的指標。是指標的進一步發展 指標（pointer）是一個包含記憶體地址的變數的通用概念。這個地址參考，或 ” 指向”（points at）一些其 他資料 。參考以 & 符號為標志并借用了他們所 ......

    uj5u.com 2023-04-20 07:24:10 more
  • Java的值傳遞和參考傳遞

    值傳遞不會改變本身，參考傳遞（如果傳遞的值需要實體化到堆里）如果發生修改了會改變本身。 1.基本資料型別都是值傳遞 package com.example.basic; public class Test { public static void main(String[] args) { int ......

    uj5u.com 2023-04-20 07:24:04 more
  • [2]SpinalHDL教程——Scala簡單入門

    第一個 Scala 程式 shell里面輸入 $ scala scala> 1 + 1 res0: Int = 2 scala> println("Hello World!") Hello World! 檔案形式 object HelloWorld { /* 這是我的第一個 Scala 程式 * 以 ......

    uj5u.com 2023-04-20 07:23:58 more
  • 理解函式指標和回呼函式

    理解 函式指標 指向函式的指標。比如： 理解函式指標的偽代碼 void (*p)(int type, char *data); // 定義一個函式指標p void func(int type, char *data); // 宣告一個函式func p = func; // 將指標p指向函式func ......

    uj5u.com 2023-04-20 07:23:52 more
  • Django筆記二十五之資料庫函式之日期函式

    本文首發于公眾號：Hunter后端 原文鏈接：Django筆記二十五之資料庫函式之日期函式 日期函式主要介紹兩個大類，Extract() 和 Trunc() Extract() 函式作用是提取日期，比如我們可以提取一個日期欄位的年份，月份，日等資料 Trunc() 的作用則是截取，比如 2022-0 ......

    uj5u.com 2023-04-20 07:23:45 more
  • 一天吃透JVM面試八股文

    什么是JVM？ JVM，全稱Java Virtual Machine（Java虛擬機），是通過在實際的計算機上仿真模擬各種計算機功能來實作的。由一套位元組碼指令集、一組暫存器、一個堆疊、一個垃圾回收堆和一個存盤方法域等組成。JVM屏蔽了與作業系統平臺相關的資訊，使得Java程式只需要生成在Java虛擬機 ......

    uj5u.com 2023-04-20 07:23:31 more
  • 使用Java接入小程式訂閱訊息！

    更新完微信服務號的模板訊息之后，我又趕緊把微信小程式的訂閱訊息給實作了！之前我一直以為微信小程式也是要企業才能申請，沒想到小程式個人就能申請。 訊息推送平臺🔥推送下發【郵件】【短信】【微信服務號】【微信小程式】【企業微信】【釘釘】等訊息型別。 https://gitee.com/zhongfuch ......

    uj5u.com 2023-04-20 07:22:59 more
  • java -- 緩沖流、轉換流、序列化流

    緩沖流 緩沖流, 也叫高效流, 按照資料型別分類： 位元組緩沖流：BufferedInputStream，BufferedOutputStream 字符緩沖流：BufferedReader，BufferedWriter 緩沖流的基本原理，是在創建流物件時，會創建一個內置的默認大小的緩沖區陣列，通過緩沖 ......

    uj5u.com 2023-04-20 07:22:49 more
  • Java-SpringBoot-Range請求頭設定實作視頻分段傳輸

    老實說，人太懶了，現在基本都不喜歡寫筆記了，但是網上有關Range請求頭的文章都太水了 下面是抄的一段StackOverflow的代碼...自己大修改過的，寫的注釋挺全的，應該直接看得懂，就不解釋了 寫的不好...只是希望能給視頻網站開發的新手一點點幫助吧. 業務場景：視頻分段傳輸、視頻多段傳輸（理 ......

    uj5u.com 2023-04-20 07:22:42 more
  • Windows 10開發教程_編程入門自學教程_菜鳥教程-免費教程分享

    教程簡介 Windows 10開發入門教程 - 從簡單的步驟了解Windows 10開發，從基本到高級概念，包括簡介，UWP，第一個應用程式，商店，XAML控制元件，資料系結，XAML性能，自適應設計，自適應UI，自適應代碼，檔案管理，SQLite資料庫，應用程式到應用程式通信，應用程式本地化，應用程式 ......

    uj5u.com 2023-04-20 07:22:35 more

Copyright © 2010-2020 有解無憂