MyBatis详细源码解析（上篇）

前言

我会一步一步带你剖析MyBatis这个经典的半ORM框架的源码！

我是使用Spring Boot + MyBatis的方式进行测试，但并未进行整合，还是使用最原始的方式。

项目结构

导入依赖：

1. mybatis：mybatis

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

Payment表：

Payment实体类：

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

PaymentMapper接口：

@Repositorypublic interface PaymentMapper { // 根据Id查询支付信息 Payment getPaymentById(@Param("id") Integer id);}

配置文件目录：

Payment.

<?

database.properties：

# 配置数据库信息driver=com.mysql.cj.jdbc.Driverurl=jdbc:mysql://localhost:3306/spring_cloud?serverTimezone=Asia/Shanghaiusername=usernamepassword=password

mybatis-config.

<?

测试类：

@SpringBootTestclass MybatisTestApplicationTests { @Test void contextLoads() {  InputStream inputStream = null;  try {   inputStream = Resources.getResourceAsStream("mybatis-config.

相关组件

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.

MyBatis的配置文件主要有两个：database.properties和mybatis-config.

这里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的

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

MyBatis使用了建造者模式来创建一个SqlSessionFactory，在SqlSessionFactoryBuilder类中只有build方法（还包括多个重载方法），该方法会创建并返回一个SqlSessionFactory对象。

build方法里面又会看到一个

最终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 {  // 解析

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); }  	// 省略其他内容...}

---

首先要做的是解析准备工作！

现在我们进入

ErrorContext类是用来记录本次执行过程中相关上下文信息，待发生Error时候其他组件就可以从本类实例中获取到相关的上下文信息，这对于排错是非常有帮助的。

// 继承了抽象类BaseBuilderpublic class 

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

因此我们在

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;  // 省略其他内容...}

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);  // 根据

InputSource：表示

Document：Document接口表示整个HTML或

EntityResolver：这个接口主要用于处理本地的

public class 

---

准备工作完成后就开始真正的解析工作！

先说明一下，我们可以看出主配置文件的最外层节点是<configuration>标签，mybatis的初始化就是把这个标签以及他的所有子标签进行解析，把解析好的数据封装在Configuration这个类中。

public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) { try {  

我们进入到XPathBuilder类parse方法中，可以看到它会先进行一个判断，判断MyBatis的

parseConfiguration方法开始解析

XNode参数的由来：XPathParser对XPath路径表达式"/configuration"对之前保存的Document对象（代表整个

public Configuration parse() { if (parsed) {  throw new BuilderException("Each 

我们可以看出这个方法是对<configuration>的所有子标签轮流解析。比如常在配置文件中出现的settings属性配置，在settings会配置缓存，日志之类的，还有typeAliases是配置别名，environments是配置数据库链接和事务。这些子节点会被一个个解析并且把解析后的数据封装在Configuration这个类中，可以看第二步方法的返回值就是Configuration对象。

在这里我们重点分析的解析mappers这个子标签，这个标签里面还会有一个个的mapper标签去映射mapper所对应的mapper.

这个方法一开始是一个循环，因为一个<mappers>节点下面可能会有很多<mapper>节点。在应用中肯定不止一个mapper.

我们看下面的三行代码，发现单文件映射有三种方式：

1. 第一种使用<mapper>节点的resource属性直接映射

2. 第二种是使用<mapper>节点url属性映射网络或者磁盘路径下的某个

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

---

实际上映射

第一行代码的意思是实例化一个错误上下文对象，我们回忆一下我们使用MyBatis的过程中如果出现错误会不会提示这个错误在哪个

然后就跟一开始解析

if (resource != null && url == null && mapperClass == null) { // resource的方式 ErrorContext.instance().resource(resource); InputStream inputStream = Resources.getResourceAsStream(resource); 

public class 

我们再进入

如果还未解析过，就会获取一个代表<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 

在末尾我们可以看到有一个buildStatementFromContext方法，它解析了<select>、<insert>、<update>、<delete>四个节点，构建了一个存有所有关联了SQL语句节点的XNode集合。在buildStatementFromContext方法中，它会先判断是否指定了所使用的数据库。然后就是遍历解析List集合，这个List集合里装的是

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 

原文转载：http://www.shaoqun.com/a/499934.html

livingsocial：https://www.ikjzd.com/w/714.html

欧舒丹：https://www.ikjzd.com/w/1756

patents：https://www.ikjzd.com/w/857

前言我会一步一步带你剖析MyBatis这个经典的半ORM框架的源码！我是使用SpringBoot+MyBatis的方式进行测试，但并未进行整合，还是使用最原始的方式。项目结构导入依赖：mybatis：mybatismysql-connector-java：mysql-connector-javaPayment表：Payment实体类：@DatapublicclassPaymentimplement
环球市场：环球市场
泛亚班拿：泛亚班拿
澳门旅游淡季是什么时候？：澳门旅游淡季是什么时候？
武汉再增２万辆免费自行车 ：武汉再增２万辆免费自行车
韶关丹霞山门票是多少？：韶关丹霞山门票是多少？