MyBatis源碼解析(一)——MyBatis初始化過程解

1. 準備工作

為了看清楚MyBatis的整個初始化過程，先建立一個簡單的Java項目，目錄結構如下圖所示：

MyBatis源碼解析(一)——MyBatis初始化過程解MyBatis源碼解析(一)——MyBatis初始化過程解1. 準備工作2. MyBatis初始化過程

1.1 Product 産品實體類

public class Product {
    private long id;
    private String productName;
    private String productContent;
    private String price;
    private int sort;
    private int falseSales;
    private long category_id;
    private byte type;
    private byte state;
    // PS：省略setter、getter函數
}

1.2 ProductMapper 産品持久化接口

public interface ProductMapper {
    /**
     * 查詢所有的産品
     * @return
     */
    List<Product> selectProductList();
}

1.3 ProductMapper.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="team.njupt.mapper.ProductMapper">
    <select id="selectProductList" resultType="team.njupt.entity.Product">
        select * from product
    </select>
</mapper>

1.4 db.properties 資料庫配置檔案

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/waimai?useUnicode=true&characterEncoding=utf8
username=root
password=xxxxxx

1.5 mybatis.xml MyBatis的配置檔案

<?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 resource="db.properties">
        <!--<property name="username" value="dev_user"/>-->
        <!--<property name="password" value="F2Fa3!33TYyg"/>-->
    </properties>

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <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>
    <mappers>
        <mapper resource="team/njupt/mapper/ProductMapper.xml"/>
    </mappers>
</configuration>

1.6 Main 主函數

public class Main {
    public static void main(String[] args) throws IOException {

        String resource = "mybatis.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        SqlSession sqlSession = sqlSessionFactory.openSession();
        try {
            ProductMapper productMapper = sqlSession.getMapper(ProductMapper.class);
            List<Product> productList = productMapper.selectProductList();
            for (Product product : productList) {
                System.out.printf(product.toString());
            }
        } finally {
            sqlSession.close();
        }
    }
}

2. MyBatis初始化過程

2.1 擷取配置檔案

當系統初始化時，首先會讀取配置檔案，并将其解析成InputStream

String resource = "mybatis.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);

2.2 建立SqlSessionFactoryBuilder對象

從

SqlSessionFactoryBuilder

的名字中可以看出，

SqlSessionFactoryBuilder

是用來建立

SqlSessionFactory

對象的。

來看一下SqlSessionFactoryBuilder源碼：

MyBatis源碼解析(一)——MyBatis初始化過程解MyBatis源碼解析(一)——MyBatis初始化過程解1. 準備工作2. MyBatis初始化過程

SqlSessionFactoryBuilder中隻有一些重載的build函數，這些build函數的入參都是MyBatis配置檔案的輸入流，傳回值都是SqlSessionFactory；由此可見，SqlSessionFactoryBuilder的作用很純粹，就是用來通過配置檔案建立SqlSessionFactory對象的。

2.3 SqlSessionFactory建立過程

下面具體來看一下，build函數是如何建立SqlSessionFactory對象的。

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

2.3.1 構造XMLConfigBuilder對象

build函數首先會構造一個

XMLConfigBuilder

對象，從名字上大緻可以猜到，該對象是用來解析XML配置檔案的。下面來看一下

XMLConfigBuilder

的體系結構。

MyBatis源碼解析(一)——MyBatis初始化過程解MyBatis源碼解析(一)——MyBatis初始化過程解1. 準備工作2. MyBatis初始化過程

XMLxxxBuilder 是用來解析XML配置檔案的，不同類型 XMLxxxBuilder 用來解析MyBatis配置檔案的不同部位。比如： XMLConfigBuilder 用來解析MyBatis的配置檔案， XMLMapperBuilder 用來解析MyBatis中的映射檔案（如上文提到的 ProductMapper.xml ）， XMLStatementBuilder 用來解析映射檔案中的SQL語句。
這些 XMLxxxBuilder 都有一個共同的父類—— BaseBuilder 。這個父類維護了一個全局的 Configuration 對象，MyBatis的配置檔案解析後就以 Configuration 對象的形式存儲。

當建立

XMLConfigBuilder

對象時，就會初始化

Configuration

對象，并且在初始化

Configuration

對象的時候，一些别名會被注冊到

Configuration

的

typeAliasRegistry

容器中。

private XMLConfigBuilder(XPathParser parser, String environment, Properties props) {
super(new Configuration());
ErrorContext.instance().resource("SQL Mapper Configuration");
this.configuration.setVariables(props);
this.parsed = false;
this.environment = environment;
this.parser = parser;
}

public Configuration() {
typeAliasRegistry.registerAlias("JDBC", JdbcTransactionFactory.class);
typeAliasRegistry.registerAlias("MANAGED", ManagedTransactionFactory.class);

typeAliasRegistry.registerAlias("JNDI", JndiDataSourceFactory.class);
typeAliasRegistry.registerAlias("POOLED", PooledDataSourceFactory.class);
typeAliasRegistry.registerAlias("UNPOOLED", UnpooledDataSourceFactory.class);

typeAliasRegistry.registerAlias("PERPETUAL", PerpetualCache.class);
typeAliasRegistry.registerAlias("FIFO", FifoCache.class);
typeAliasRegistry.registerAlias("LRU", LruCache.class);
typeAliasRegistry.registerAlias("SOFT", SoftCache.class);
typeAliasRegistry.registerAlias("WEAK", WeakCache.class);
……
}

2.3.2 解析配置檔案

當有了

XMLConfigBuilder

對象之後，接下來就可以用它來解析配置檔案了。

private void parseConfiguration(XNode root) {
  try {
    // 解析<properties>節點
    propertiesElement(root.evalNode("properties"));
    // 解析<settings>節點
    Properties settings = settingsAsProperties(root.evalNode("settings"));
    loadCustomVfs(settings);
    // 解析<typeAliases>節點
    typeAliasesElement(root.evalNode("typeAliases"));
    // 解析<plugins>節點
    pluginElement(root.evalNode("plugins"));
    // 解析<objectFactory>節點
    objectFactoryElement(root.evalNode("objectFactory"));
    objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
    // 解析<reflectorFactory>節點
    reflectorFactoryElement(root.evalNode("reflectorFactory"));
    settingsElement(settings);
    // 解析<environments>節點
    environmentsElement(root.evalNode("environments"));
    databaseIdProviderElement(root.evalNode("databaseIdProvider"));
    typeHandlerElement(root.evalNode("typeHandlers"));
    // 解析<mappers>節點
    mapperElement(root.evalNode("mappers"));
  } catch (Exception e) {
    throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
  }
}

從上述代碼中可以看到，

XMLConfigBuilder

會依次解析配置檔案中的

<properties>

、

< settings >

、

< environments>

、

< typeAliases >

、

< plugins >

、

< mappers >

等屬性。下面介紹下幾個重要屬性的解析過程。

2.3.2.1 <properties>節點的解析過程

<properties>節點的定義如下：

<properties resource="org/mybatis/example/config.properties">
  <property name="username" value="dev_user"/>
  <property name="password" value="F2Fa3!33TYyg"/>
</properties>

<properties>節點的解析過程：

/**
  * @Param context <properties>節點
  */
private void propertiesElement(XNode context) throws Exception {
  if (context != null) {
    // 擷取<properties>節點的所有子節點
    Properties defaults = context.getChildrenAsProperties();
    // 擷取<properties>節點上的resource屬性
    String resource = context.getStringAttribute("resource");
    // 擷取<properties>節點上的url屬性
    String url = context.getStringAttribute("url");
    // resource和url不能同時存在
    if (resource != null && url != null) {
      throw new BuilderException("The properties element cannot specify both a URL and a resource based property file reference.  Please specify one or the other.");
    }
    if (resource != null) {
      // 擷取resource屬性值對應的properties檔案中的鍵值對，并添加至defaults容器中        
      defaults.putAll(Resources.getResourceAsProperties(resource));
    } else if (url != null) {
      // 擷取url屬性值對應的properties檔案中的鍵值對，并添加至defaults容器中
      defaults.putAll(Resources.getUrlAsProperties(url));
    }
    // 擷取configuration中原本的屬性，并添加至defaults容器中
    Properties vars = configuration.getVariables();
    if (vars != null) {
      defaults.putAll(vars);
    }
    parser.setVariables(defaults);
    // 将defaults容器添加至configuration中
    configuration.setVariables(defaults);
  }
}

首先讀取 <resources> 節點下的所有 <resource> 節點，并将每個節點的 name 和 value 屬性存入 Properties 中。
然後讀取 <resources> 節點上的 resource 、 url 屬性，并擷取指定配置檔案中的 name 和 value ，也存入 Properties 中。（PS：由此可知，如果resource節點上定義的屬性和properties檔案中的屬性重名，那麼properties檔案中的屬性值會覆寫resource節點上定義的屬性值。）
最終，攜帶所有屬性的 Properties 對象會被存儲在 Configuration 對象中。

2.3.2.2 <settings>節點的解析過程

<settings>節點的定義如下：

<settings>
  <setting name="cacheEnabled" value="true"/>
  <setting name="lazyLoadingEnabled" value="true"/>
  <setting name="multipleResultSetsEnabled" value="true"/>
</settings>

<settings>節點的解析過程： <settings> 屬性的解析過程和 <properties> 屬性的解析過程極為類似，這裡不再贅述。最終，所有的setting屬性都被存儲在 Configuration 對象中。

2.3.2.3 <typeAliases>屬性的解析過程

<typeAliases>

屬性的定義方式有如下兩種：

方式1：

<typeAliases>
  <typeAlias alias="Author" type="domain.blog.Author"/>
  <typeAlias alias="Blog" type="domain.blog.Blog"/>
</typeAliases>

方式2：
```
<typeAliases>
  <package name="domain.blog"/>
</typeAliases>
           
```
采用這種方式時，MyBatis會為指定包下的所有類起一個别名，該别名為首字母小寫的類名。

<typeAliases>

節點的解析過程如下：

private void typeAliasesElement(XNode parent) {
  if (parent != null) {
    // 周遊<typeAliases>下的所有子節點
    for (XNode child : parent.getChildren()) {
      // 若目前結點為<package>
      if ("package".equals(child.getName())) {
        // 擷取<package>上的name屬性（包名）
        String typeAliasPackage = child.getStringAttribute("name");
        // 為該包下的所有類起個别名，并注冊進configuration的typeAliasRegistry中          
        configuration.getTypeAliasRegistry().registerAliases(typeAliasPackage);
      } 
      // 如果目前結點為< typeAlias >
      else {
        // 擷取alias和type屬性
        String alias = child.getStringAttribute("alias");
        String type = child.getStringAttribute("type");
        // 注冊進configuration的typeAliasRegistry中
        try {
          Class<?> clazz = Resources.classForName(type);
          if (alias == null) {
            typeAliasRegistry.registerAlias(clazz);
          } else {
            typeAliasRegistry.registerAlias(alias, clazz);
          }
        } catch (ClassNotFoundException e) {
          throw new BuilderException("Error registering typeAlias for '" + alias + "'. Cause: " + e, e);
        }
      }
    }
  }
}

如果 <typeAliases> 節點下定義了 <package> 節點，那麼MyBatis會給該包下的所有類起一個别名（以類名首字母小寫作為别名）
如果 <typeAliases> 節點下定義了 <typeAlias> 節點，那麼MyBatis就會給指定的類起指定的别名。
這些别名都會被存入 configuration 的 typeAliasRegistry 容器中。

2.3.2.4 <mappers>節點的解析過程

<mappers>

節點的定義方式有如下四種：

方式1：

<mappers>
  <package name="org.mybatis.builder"/>
</mappers>

方式2：

<mappers>
  <mapper resource="org/mybatis/builder/AuthorMapper.xml"/>
</mappers>

方式3：

<mappers>
  <mapper url="file:///var/mappers/AuthorMapper.xml"/>
</mappers>

方式4：

<mappers>
  <mapper class="org.mybatis.builder.AuthorMapper"/>
</mappers>

<mappers>

節點的解析過程如下：

private void mapperElement(XNode parent) throws Exception {
  if (parent != null) {
    // 周遊<mappers>下所有子節點
    for (XNode child : parent.getChildren()) {
      // 如果目前節點為<package>
      if ("package".equals(child.getName())) {
        // 擷取<package>的name屬性（該屬性值為mapper class所在的包名）
        String mapperPackage = child.getStringAttribute("name");
        // 将該包下的所有Mapper Class注冊到configuration的mapperRegistry容器中
        configuration.addMappers(mapperPackage);
      } 
      // 如果目前節點為<mapper>
      else {
        // 依次擷取resource、url、class屬性
        String resource = child.getStringAttribute("resource");
        String url = child.getStringAttribute("url");
        String mapperClass = child.getStringAttribute("class");
        // 解析resource屬性（Mapper.xml檔案的路徑）
        if (resource != null && url == null && mapperClass == null) {
          ErrorContext.instance().resource(resource);
          // 将Mapper.xml檔案解析成輸入流
          InputStream inputStream = Resources.getResourceAsStream(resource);
          // 使用XMLMapperBuilder解析Mapper.xml，并将Mapper Class注冊進configuration對象的mapperRegistry容器中
          XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
          mapperParser.parse();
        } 
        // 解析url屬性（Mapper.xml檔案的路徑）
        else if (resource == null && url != null && mapperClass == null) {
          ErrorContext.instance().resource(url);
          InputStream inputStream = Resources.getUrlAsStream(url);
          XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments());
          mapperParser.parse();
        } 
        // 解析class屬性（Mapper Class的全限定名）
        else if (resource == null && url == null && mapperClass != null) {
          // 将Mapper Class的權限定名轉化成Class對象
          Class<?> mapperInterface = Resources.classForName(mapperClass);
          // 注冊進configuration對象的mapperRegistry容器中
          configuration.addMapper(mapperInterface);
        } else {
          throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one.");
        }
      }
    }
  }
}

MyBatis會周遊 <mappers> 下所有的子節點，如果目前周遊到的節點是 <package> ，則MyBatis會将該包下的所有Mapper Class注冊到 configuration 的 mapperRegistry 容器中。
如果目前節點為 <mapper> ，則會依次擷取resource、url、class屬性，解析映射檔案，并将映射檔案對應的Mapper Class注冊到 configuration 的 mapperRegistry 容器中。

其中，

<mapper>

節點的解析過程如下：

XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
mapperParser.parse();

在解析前，首先需要建立

XMLMapperBuilder

，建立過程如下：

private XMLMapperBuilder(XPathParser parser, Configuration configuration, String resource, Map<String, XNode> sqlFragments) {
  // 将configuration賦給BaseBuilder
  super(configuration);
  // 建立MapperBuilderAssistant對象（該對象為MapperBuilder的協助者）
  this.builderAssistant = new  MapperBuilderAssistant(configuration, resource);
  this.parser = parser;
  this.sqlFragments = sqlFragments;
  this.resource = resource;
}

首先會初始化父類 BaseBuilder ，并将 configuration 賦給BaseBuilder；
然後建立 MapperBuilderAssistant 對象，該對象為 XMLMapperBuilder 的協助者，用來協助 XMLMapperBuilder 完成一些解析映射檔案的動作。

當有了

XMLMapperBuilder

後，便可進入解析

<mapper>

的過程：

public void parse() {
  // 若目前的Mapper.xml尚未被解析，則開始解析
  // PS：若<mappers>節點下有相同的<mapper>節點，那麼就無需再次解析了
  if (!configuration.isResourceLoaded(resource)) {
    // 解析<mapper>節點
    configurationElement(parser.evalNode("/mapper"));
    // 将該Mapper.xml添加至configuration的LoadedResource容器中，下回無需再解析
    configuration.addLoadedResource(resource);
    // 将該Mapper.xml對應的Mapper Class注冊進configuration的mapperRegistry容器中
    bindMapperForNamespace();
  }

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

configurationElement

函數

private void configurationElement(XNode context) {
try {
  // 擷取<mapper>節點上的namespace屬性，該屬性必須存在，表示目前映射檔案對應的Mapper Class是誰
  String namespace = context.getStringAttribute("namespace");
  if (namespace == null || namespace.equals("")) {
    throw new BuilderException("Mapper's namespace cannot be empty");
  }
  // 将namespace屬性值賦給builderAssistant
  builderAssistant.setCurrentNamespace(namespace);
  // 解析<cache-ref>節點
  cacheRefElement(context.evalNode("cache-ref"));
  // 解析<cache>節點
  cacheElement(context.evalNode("cache"));
  // 解析<parameterMap>節點
  parameterMapElement(context.evalNodes("/mapper/parameterMap"));
  // 解析<resultMap>節點
  resultMapElements(context.evalNodes("/mapper/resultMap"));
  // 解析<sql>節點
  sqlElement(context.evalNodes("/mapper/sql"));
  // 解析sql語句      
  buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
} catch (Exception e) {
  throw new BuilderException("Error parsing Mapper XML. Cause: " + e, e);
}
}

resultMapElements

函數

該函數用于解析映射檔案中所有的

<resultMap>

節點，這些節點會被解析成

ResultMap

對象，存儲在

Configuration

對象的

resultMaps

容器中。

<resultMap> 節點定義如下：

<resultMap id="userResultMap" type="User">
  <constructor>
     <idArg column="id" javaType="int"/>
     <arg column="username" javaType="String"/>
  </constructor>
  <result property="username" column="user_name"/>
  <result property="password" column="hashed_password"/>
</resultMap>

<resultMap> 節點的解析過程：

private ResultMap resultMapElement(XNode resultMapNode, List<ResultMapping> additionalResultMappings) throws Exception {
  ErrorContext.instance().activity("processing " + resultMapNode.getValueBasedIdentifier());
  // 擷取<ResultMap>上的id屬性
  String id = resultMapNode.getStringAttribute("id",
    resultMapNode.getValueBasedIdentifier());
  // 擷取<ResultMap>上的type屬性（即resultMap的傳回值類型）
  String type = resultMapNode.getStringAttribute("type",
    resultMapNode.getStringAttribute("ofType",
        resultMapNode.getStringAttribute("resultType",
            resultMapNode.getStringAttribute("javaType"))));
  // 擷取extends屬性
  String extend = resultMapNode.getStringAttribute("extends");
  // 擷取autoMapping屬性
  Boolean autoMapping = resultMapNode.getBooleanAttribute("autoMapping");
  // 将resultMap的傳回值類型轉換成Class對象
  Class<?> typeClass = resolveClass(type);
  Discriminator discriminator = null;
  // resultMappings用于存儲<resultMap>下所有的子節點
  List<ResultMapping> resultMappings = new ArrayList<ResultMapping>();
  resultMappings.addAll(additionalResultMappings);
  // 擷取并周遊<resultMap>下所有的子節點
  List<XNode> resultChildren = resultMapNode.getChildren();
  for (XNode resultChild : resultChildren) {
    // 若目前節點為<constructor>，則将它的子節點們添加到resultMappings中去
    if ("constructor".equals(resultChild.getName())) {
      processConstructorElement(resultChild, typeClass, resultMappings);
    }
    // 若目前節點為<discriminator>，則進行條件判斷，并将命中的子節點添加到resultMappings中去
    else if ("discriminator".equals(resultChild.getName())) {
      discriminator = processDiscriminatorElement(resultChild, typeClass, resultMappings);
    }
    // 若目前節點為<result>、<association>、<collection>，則将其添加到resultMappings中去
    else {
      // PS:flags僅用于區分目前節點是否是<id>或<idArg>，因為這兩個節點的屬性名為name，而其他節點的屬性名為property
      List<ResultFlag> flags = new ArrayList<ResultFlag>();
      if ("id".equals(resultChild.getName())) {
        flags.add(ResultFlag.ID);
      }
      resultMappings.add(buildResultMappingFromContext(resultChild, typeClass, flags));
    }
  }
  // ResultMapResolver的作用是生成ResultMap對象，并将其加入到Configuration對象的resultMaps容器中（具體過程見下）
  ResultMapResolver resultMapResolver = new ResultMapResolver(builderAssistant, id, typeClass, extend, discriminator, resultMappings, autoMapping);
  try {
    return resultMapResolver.resolve();
  } catch (IncompleteElementException  e) {
    configuration.addIncompleteResultMap(resultMapResolver);
    throw e;
  }
}

ResultMapResolver

這個類很純粹，有且僅有一個函數

resolve

，用于構造

ResultMap

對象，并将其存入Configuration對象的resultMaps容器中；而這個過程是借助于

MapperBuilderAssistant.addResultMap

完成的。

public ResultMap resolve() {
  return assistant.addResultMap(this.id, this.type, this.extend,  this.discriminator, this.resultMappings, this.autoMapping);
}

sqlElement
函數

該函數用于解析映射檔案中所有的
<sql> 節點，并将這些節點存儲在目前映射檔案所對應的XMLMapperBuilder對象的sqlFragments容器中，供解析sql語句時使用。
```
<sql id="userColumns"> ${alias}.id,${alias}.username,${alias}.password </sql>
           
```

buildStatementFromContext
函數

該函數會将映射檔案中的sql語句解析成
MappedStatement 對象，并存在 configuration 的 mappedStatements 。

2.3.3 建立SqlSessionFactory對象

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

回過頭來再看一下

SqlSessionFactory

的

build

函數，剛才說了半天，介紹了

XMLConfigBuilder

解析映射檔案的過程，解析完成之後

parser.parse()

函數會傳回一個包含了映射檔案解析結果的

configuration

對象，緊接着，這個對象将作為參數傳遞給另一個build函數，如下：

public SqlSessionFactory build(Configuration config) {
    return new DefaultSqlSessionFactory(config);
  }

這個函數将

configuration

作為參數，建立了

DefaultSqlSessionFactory

對象。

DefaultSqlSessionFactory

是接口

SqlSessionFactory

的一個實作類，

SqlSessionFactory

的體系結構如下圖所示：

MyBatis源碼解析(一)——MyBatis初始化過程解MyBatis源碼解析(一)——MyBatis初始化過程解1. 準備工作2. MyBatis初始化過程

此時，

SqlSessionFactory

建立完畢！

MyBatis源碼解析(一)——MyBatis初始化過程解MyBatis源碼解析(一)——MyBatis初始化過程解1. 準備工作2. MyBatis初始化過程

MyBatis源碼解析(一)——MyBatis初始化過程解

1. 準備工作

1.1 Product 産品實體類

1.2 ProductMapper 産品持久化接口

1.3 ProductMapper.xml 産品映射檔案

1.4 db.properties 資料庫配置檔案

1.5 mybatis.xml MyBatis的配置檔案

1.6 Main 主函數

2. MyBatis初始化過程

2.1 擷取配置檔案

2.2 建立SqlSessionFactoryBuilder對象

2.3 SqlSessionFactory建立過程

2.3.2 解析配置檔案

2.3.3 建立SqlSessionFactory對象

繼續閱讀

Mybatis問答集

【附源碼】計算機畢業設計SSM網絡求職招聘系統

Mybatis源碼閱讀（一）：Mybatis初始化1.1 解析properties、settings前言入口引申結語

mybatis源碼解析（二）初始化SqlSessionFactory對象

Mybatis源碼閱讀（四）：核心接口4.2——Executor（上）

從你的WEB世界路過之--0.初識0) 前言1) WEB基本概念2) 響應資料3. 結語

《資料結構》（嚴蔚敏,吳偉民版）課本源碼+習題集解析使用說明先附上文檔歸類目錄：部落客有話說：(已遷移到部落格園 ☛☛☛ 新部落格連結)

一步一步解析集合架構ArrayList源碼（2）

Java 實作Gbase資料庫增删改查功能

mybatis——使用代理對象進行資料庫操作

mybatis中#{}和${}和差別，以及防止sql注入。

myeclipse 搭建mybatis架構時報錯（1）Communications link failure 通訊連結故障

如何提高個人開源網站源碼開發使用率

MyBatis學習筆記Mybatis學習筆記（maven、Idea版）

用mybatis的generator插件在項目中自動生成dao及entity

從mybatis到mybatis plus(mp)