Mybatis源码

一.

SqlSessionFactoryBuilder源码片段：

SqlSessionFactoryBuilder.build()主要参数类型包括(Reader reader,String environment,Properties properties)/(InputStream inputStream,String environment, Properties properties)

public class SqlSessionFactoryBuilder {

 

  //Reader读取mybatis配置文件，传入构造方法

  //除了Reader外，其实还有对应的inputStream作为参数的构造方法，

  //这也体现了mybatis配置的灵活性

  public SqlSessionFactory build(Reader reader) {

    return build(reader, null, null);

  }

 

  public SqlSessionFactory build(Reader reader, String environment) {

    return build(reader, environment, null);

  }

  

  //mybatis配置文件 + properties, 此时mybatis配置文件中可以不配置properties，也能使用${}形式

  public SqlSessionFactory build(Reader reader, Properties properties) {

    return build(reader, null, properties);

  }

  

  //通过XMLConfigBuilder解析mybatis配置，然后创建SqlSessionFactory对象

  public SqlSessionFactory build(Reader reader, String environment, Properties properties) {

    try {

      XMLConfigBuilder parser = new XMLConfigBuilder(reader, environment, properties);

      //下面看看这个方法的源码

      return build(parser.parse());

    } catch (Exception e) {

      throw ExceptionFactory.wrapException("Error building SqlSession.", e);

    } finally {

      ErrorContext.instance().reset();

      try {

        reader.close();

      } catch (IOException e) {

        // Intentionally ignore. Prefer previous error.

      }

    }

  }

  

  

  //InputStream 读入

  public SqlSessionFactory build(InputStream inputStream) {

    return build(inputStream, null, null);

  }

 

  public SqlSessionFactory build(InputStream inputStream, String environment) {

    return build(inputStream, environment, null);

  }

 

  public SqlSessionFactory build(InputStream inputStream, Properties properties) {

    return build(inputStream, null, properties);

  }

 

  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.

      }

    }

  }

 

  public SqlSessionFactory build(Configuration config) {

    return new DefaultSqlSessionFactory(config);

  }

}

 

解析Mybatis主要用XMLConfigBuilder。

 XMLConfigBuilder parser = new XMLConfigBuilder(reader, environment, properties);

 parser.parse();

 

 XMLConfigBuilder的源码：

 public class XMLConfigBuilder extends BaseBuilder {

 

  //Reader读取mybatis配置文件

  public XMLConfigBuilder(Reader reader, String environment, Properties props) {

    this(new XPathParser(reader, true, props, new XMLMapperEntityResolver()), environment, props);

  }

  

  //InputStream读取mybatis配置文件

   public XMLConfigBuilder(InputStream inputStream, String environment, Properties props) {

    this(new XPathParser(inputStream, true, props, new XMLMapperEntityResolver()), environment, props);

  }

  

  //构造函数

  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;

  }

 

  // //外部调用此方法对mybatis配置文件进行解析

  public Configuration parse() {

    if (parsed) {

      throw new BuilderException("Each XMLConfigBuilder can only be used once.");

    }

    parsed = true;

从根节点configuration

    parseConfiguration(parser.evalNode("/configuration"));

    return configuration;

  }

 

    //此方法就是依次解析configuration节点下的子节点

   //由此也可看出，我们在configuration下面能配置的节点为以下10个节点

  private void parseConfiguration(XNode root) {

    try {

      //issue #117 read properties first

      propertiesElement(root.evalNode("properties"));//read properties first

      typeAliasesElement(root.evalNode("typeAliases"));

      pluginElement(root.evalNode("plugins"));

      objectFactoryElement(root.evalNode("objectFactory"));

      objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));

      reflectionFactoryElement(root.evalNode("reflectionFactory"));

      settingsElement(root.evalNode("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);

    }

  }

 }

 

 <?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> //从根节点configuration

 <settings>

<!--changes from the defaults -->

<setting name="cacheEnabled" value="false"/>

<setting name="lazyLoadingEnabled" value="false"/>

<setting name="mapUnderscoreToCamelCase" value="true"/>

<setting name="useColumnLabel" value="true"/>

<setting name="defaultExecutorType" value="REUSE"/>

<setting name="defaultStatementTimeout" value="25000"/>

<setting name="jdbcTypeForNull" value="NULL"/>

</settings>

</configuration>

 

通过以上源码，我们就能看出，在mybatis的配置文件中：

1. configuration节点为根节点。

2. 在configuration节点之下，我们可以配置10个子节点， 分别为：properties、typeAliases、plugins、objectFactory、objectWrapperFactory、settings、environments、databaseIdProvider、typeHandlers、mappers。

 

 

二.properties节点和environments节点

<configuration>

 

<!-- 方法一： 从外部指定properties配置文件, 除了使用resource属性指定外，还可通过url属性指定url  

<properties resource="dbConfig.properties"></properties> 

 -->

 <!-- 方法二： 直接配置为xml -->

<properties>

 <property name="driver" value="com.mysql.jdbc.Driver"/>

 <property name="url" value="jdbc:mysql://localhost:3306/test1"/>

 <property name="username" value="root"/>

 <property name="password" value="root"/>

</properties>

 

   <!--environments节点 -->

<environments default="development">

<environment id="development">

 <transactionManager type="JDBC"/>

 <dataSource type="POOLED">

<!--

 如果上面没有指定数据库配置的properties文件，那么此处可以这样直接配置 

<property name="driver" value="com.mysql.jdbc.Driver"/>

<property name="url" value="jdbc:mysql://localhost:3306/test1"/>

<property name="username" value="root"/>

<property name="password" value="root"/>

-->

 

<!-- 上面指定了数据库配置文件， 配置文件里面也是对应的这四个属性 -->

<property name="driver" value="${driver}"/>

<property name="url" value="${url}"/>

<property name="username" value="${username}"/>

<property name="password" value="${password}"/>

 

 </dataSource>

</environment>

 

<!-- 我再指定一个environment -->

<environment id="test">

 <transactionManager type="JDBC"/>

 <dataSource type="POOLED">

<property name="driver" value="com.mysql.jdbc.Driver"/>

<!-- 与上面的url不一样 -->

<property name="url" value="jdbc:mysql://localhost:3306/demo"/>

<property name="username" value="root"/>

<property name="password" value="root"/>

 </dataSource>

</environment>

</environments>

</configuration>

 

那么，外部指定properties配置文件,直接配置为xmlp这两种方法都同时用了，那么哪种方法优先？当以上两种方法都用xml配置优先， 外部指定properties配置其次。

 

environments元素节点可以配置多个environment子节点， 怎么理解呢？ 

假如我们系统的开发环境和正式环境所用的数据库不一样（这是肯定的）， 那么可以设置两个environment,               两个id分别对应开发环境（dev）和正式环境（final），那么通过配置environments的default属性就能选择对应的environment了， 

将environments的deault属性的值配置为dev, 那么就会选择dev的environment。

 

XMLConfigBuilder对于properties和environments的解析：

public class XMLConfigBuilder extends BaseBuilder {

private boolean parsed;

//xml解析器

private XPathParser parser;

private String environment;

 

//上次说到这个方法是在解析mybatis配置文件中能配置的元素节点

//今天首先要看的就是properties节点和environments节点

private void parseConfiguration(XNode root) {

try {

 //优先解析properties元素 

 propertiesElement(root.evalNode("properties")); //issue #117 read properties first

 typeAliasesElement(root.evalNode("typeAliases"));

 pluginElement(root.evalNode("plugins"));

 objectFactoryElement(root.evalNode("objectFactory"));

 objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));

 settingsElement(root.evalNode("settings"));

 //解析environments元素

 environmentsElement(root.evalNode("environments")); // read it after objectFactory and objectWrapperFactory issue #631

 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);

}

}

 

 

//下面就看看解析properties的具体方法

private void propertiesElement(XNode context) throws Exception {

if (context != null) {

 //将子节点的 name 以及value属性set进properties对象

 //这儿可以注意一下顺序，xml配置优先， 外部指定properties配置其次

 Properties defaults = context.getChildrenAsProperties();

 //获取properties节点上 resource属性的值

 String resource = context.getStringAttribute("resource");

 //获取properties节点上 url属性的值, resource和url不能同时配置

 String url = context.getStringAttribute("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.");

 }

 //把解析出的properties文件set进Properties对象

 if (resource != null) {

defaults.putAll(Resources.getResourceAsProperties(resource));

 } else if (url != null) {

defaults.putAll(Resources.getUrlAsProperties(url));

 }

 //将configuration对象中已配置的Properties属性与刚刚解析的融合

 //configuration这个对象会装载所解析mybatis配置文件的所有节点元素，以后也会频频提到这个对象

 //既然configuration对象用有一系列的get/set方法， 那是否就标志着我们可以使用java代码直接配置？ 

 //答案是肯定的， 不过使用配置文件进行配置，优势不言而喻

 Properties vars = configuration.getVariables();

 if (vars != null) {

defaults.putAll(vars);

 }

 //把装有解析配置propertis对象set进解析器， 因为后面可能会用到

 parser.setVariables(defaults);

 //set进configuration对象

 configuration.setVariables(defaults);

}

}

 

//下面再看看解析enviroments元素节点的方法

private void environmentsElement(XNode context) throws Exception {

if (context != null) {

if (environment == null) {

//解析environments节点的default属性的值

//例如: <environments default="development">

environment = context.getStringAttribute("default");

}

//递归解析environments子节点

for (XNode child : context.getChildren()) {

//<environment id="development">, 只有enviroment节点有id属性，那么这个属性有何作用？

//environments 节点下可以拥有多个 environment子节点

//类似于这样： <environments default="development"><environment id="development">...</environment><environment id="test">...</environments>

//意思就是我们可以对应多个环境，比如开发环境，测试环境等， 由environments的default属性去选择对应的enviroment

String id = child.getStringAttribute("id");

//isSpecial就是根据由environments的default属性去选择对应的enviroment

if (isSpecifiedEnvironment(id)) {

//事务， mybatis有两种：JDBC 和 MANAGED, 配置为JDBC则直接使用JDBC的事务，配置为MANAGED则是将事务托管给容器， 

TransactionFactory txFactory = transactionManagerElement(child.evalNode("transactionManager"));

//enviroment节点下面就是dataSource节点了，解析dataSource节点（下面会贴出解析dataSource的具体方法）

DataSourceFactory dsFactory = dataSourceElement(child.evalNode("dataSource"));

DataSource dataSource = dsFactory.getDataSource();

Environment.Builder environmentBuilder = new Environment.Builder(id)

 .transactionFactory(txFactory)

 .dataSource(dataSource);

//老规矩，会将dataSource设置进configuration对象

configuration.setEnvironment(environmentBuilder.build());

}

}

}

}

 

//下面看看dataSource的解析方法

private DataSourceFactory dataSourceElement(XNode context) throws Exception {

if (context != null) {

//dataSource的连接池

String type = context.getStringAttribute("type");

//子节点 name, value属性set进一个properties对象

Properties props = context.getChildrenAsProperties();

//创建dataSourceFactory

DataSourceFactory factory = (DataSourceFactory) resolveClass(type).newInstance();

factory.setProperties(props);

return factory;

}

throw new BuilderException("Environment declaration requires a DataSourceFactory.");

} 

}

 

在配置dataSource的时候使用了 ${driver} 这种表达式， 这种形式是怎么解析的？其实，是通过PropertyParser这个类解析：

/**

 * 这个类解析${}这种形式的表达式

 */

public class PropertyParser {

 

  public static String parse(String string, Properties variables) {

    VariableTokenHandler handler = new VariableTokenHandler(variables);

    GenericTokenParser parser = new GenericTokenParser("${", "}", handler);

    return parser.parse(string);

  }

 

  private static class VariableTokenHandler implements TokenHandler {

    private Properties variables;

 

    public VariableTokenHandler(Properties variables) {

      this.variables = variables;

    }

 

    public String handleToken(String content) {

      if (variables != null && variables.containsKey(content)) {

        return variables.getProperty(content);

      }

      return "${" + content + "}";

    }

  }

}