mybatis源码解析核心配置文件

一，mybatis源码解析核心配置文件

1.1传统的jdbc

先看一看传统的jdbc，这样有助于学习mybatis：

@Test
public void test() throws SQLException {
   
	Connection conn=null;
	PreparedStatement pstmt=null;
	try {
   
		// 1.加载驱动
		Class.forName("com.mysql.jdbc.Driver");
		// 2.创建连接
		conn= DriverManager.
		getConnection("jdbc:mysql://localhost:3306/mybatis_example", "root", "123456");
		// SQL语句
		String sql="select id,user_name,create_time from t_user where id=?";
		// 获得sql执行者
		pstmt=conn.prepareStatement(sql);
		pstmt.setInt(1,1);
		// 执行查询
		pstmt.execute();
		ResultSet rs= pstmt.getResultSet();
		rs.next();
		User user =new User();
		user.setId(rs.getLong("id"));
		user.setUserName(rs.getString("user_name"));
		user.setCreateTime(rs.getDate("create_time"));
		System.out.println(user.toString());
	} catch (Exception e) {
   
		e.printStackTrace();
	}finally{
   
		// 关闭资源
		try {
   
			if(conn!=null){
   
				conn.close();
			}
			if(pstmt!=null){
   
				pstmt.close();
			}
		} catch (SQLException e) {
   
			e.printStackTrace();
		}
	}
}

jdbc问题总结如下：

1、 数据库连接创建、释放频繁造成系统资源浪费，从而影响系统性能。如果使用数据库连接池可解决此问题。

2、 Sql语句在代码中硬编码，造成代码不易维护，实际应用中sql变化的可能较大，sql变动需要改变java代码。

3、 使用preparedStatement向占有位符号传参数存在硬编码，因为sql语句的where条件不一定，可能多也可能少，修改sql还要修改代码，系统不易维护。

4、 对结果集解析存在硬编码（查询列名），sql变化导致解析代码变化，系统不易维护，如果能将数据库记录封装成pojo对象解析比较方便。

1.2mybatis案例

​ MyBatis简单介绍：MyBatis是一个持久层（ORM）框架，使用简单，学习成本较低。可以执行自己手写的SQL语句，比较灵活。但 是MyBatis的自动化程度不高，移植性也不高，有时从一个数据库迁移到另外一个数据库的时候需要自己修改配 置，所以称只为半自动ORM框架。

Mybatis最简单的使用列子如下：

public class App {
   
	public static void main(String[] args) {
   
		String resource = "mybatis‐config.xml";
		Reader reader;
		try {
   
			//将XML配置文件构建为Configuration配置类
			reader = Resources.getResourceAsReader(resource);
			// 通过加载配置文件流构建一个SqlSessionFactory DefaultSqlSessionFactory
			SqlSessionFactory sqlMapper = new SqlSessionFactoryBuilder().build(reader);
			// 数据源 执行器 DefaultSqlSession
			SqlSession session = sqlMapper.openSession();
			try {
   
				// 执行查询 底层执行jdbc
				//User user = (User)session.selectOne("com.tuling.mapper.selectById", 1);
				UserMapper mapper = session.getMapper(UserMapper.class);
				System.out.println(mapper.getClass());
				User user = mapper.selectById(1L);
				System.out.println(user.getUserName());
			} catch (Exception e) {
   
 				e.printStackTrace();
 			}finally {
   
 				session.close();
			}
		} catch (IOException e) {
   
			e.printStackTrace();
		}
	}
}

总结下就是分为下面四个步骤：

1. 从配置文件（通常是XML文件）得到SessionFactory;
2. 从SessionFactory得到SqlSession；
3. 通过SqlSession进行CRUD和事务的操作；
4. 执行完相关操作之后关闭Session。

1.3加载mybatis核心配置文件

mybatis核心配置文件加载流程分析：

String resource = "mybatis‐config.xml";
//将XML配置文件构建为Configuration配置类
reader = Resources.getResourceAsReader(resource);
// 通过加载配置文件流构建一个SqlSessionFactory DefaultSqlSessionFactory
SqlSessionFactory sqlMapper = new SqlSessionFactoryBuilder().build(reader);

通过上面代码发现，创建SqlSessionFactory的代码在SqlSessionFactoryBuilder中，进去一探究竟：

 public SqlSessionFactory build(Reader reader) {
   
        return this.build((Reader)reader, (String)null, (Properties)null);
    }

继续跟进this.build((Reader)reader, (String)null, (Properties)null)方法：

public SqlSessionFactory build(Reader reader, String environment, Properties properties) {
   
        SqlSessionFactory var5;
        try {
   
            // 创建一个XML配置类解析类XMLConfigBuilder
            XMLConfigBuilder parser = new XMLConfigBuilder(reader, environment, properties);
            // 通XML配置类解析类的parse方法解析配置文件，build方法返回DefaultSqlSessionFactory
            var5 = this.build(parser.parse());
        } catch (Exception var14) {
   
            throw ExceptionFactory.wrapException("Error building SqlSession.", var14);
        } finally {
   
            ErrorContext.instance().reset();

            try {
   
                reader.close();
            } catch (IOException var13) {
   
            }

        }

        return var5;
    }

XMLConfigBuilder：

public class XMLMapperBuilder extends BaseBuilder 

XMLConfigBuilder是继承抽象类BaseBuilder,BaseBuilder有很多子类，每个子类都有自己特定的责任：

常见的XMLConfigBuilder是用来解析mybatis的核心配置文件的、XMLMapperBuilder是用来解析mapper的配置文件的、XMLStatementBuilder是用来解析mapper的配置文件中的节点元素的比如select标签等等。

继续查看XMLConfigBuilder的parse()方法:

public Configuration parse() {
   
       // 通过parsed判断是否解析过配置类
        if (this.parsed) {
   
            // 如果解析过直接抛出异常
            throw new BuilderException("Each XMLConfigBuilder can only be used once.");
        } else {
   
            // 没有解析过，开始解析之前，将parsed置为true
            this.parsed = true;
            // 开始解析configuration节点
            this.parseConfiguration(this.parser.evalNode("/configuration"));
            return this.configuration;
        }
    }

继续跟进this.parseConfiguration(this.parser.evalNode("/configuration"));方法：

private void parseConfiguration(XNode root) {
   
        try {
   
            // 解析properties标签，并set到Configration对象中
            this.propertiesElement(root.evalNode("properties"));
            // 解析setting标签
            Properties settings = this.settingsAsProperties(root.evalNode("settings"));
            // 添加vfs的自定义实现，这个功能不怎么用
            this.loadCustomVfs(settings);
            // 配置日志实现类，这个功能也不怎么用
            this.loadCustomLogImpl(settings);
            // 解析typeAliases标签，配置类的别名，配置后就可以用别名来替代全限定名
            this.typeAliasesElement(root.evalNode("typeAliases"));
            // 解析plugins标签，将解析拦截器和拦截器的属性，set到Configration的interceptorChain中
            this.pluginElement(root.evalNode("plugins"));
            // Mybatis创建对象是会使用objectFactory来创建对象，一般情况下不会自己配置这个objectFactory，使用系统默认的
            this.objectFactoryElement(root.evalNode("objectFactory"));
            this.objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
            this.reflectorFactoryElement(root.evalNode("reflectorFactory"));
            // 设置在setting标签中配置的配置
            this.settingsElement(settings);
            // 解析环境信息，包括事物管理器和数据源，SqlSessionFactoryBuilder在解析时需要指定环境id，如果不指定的话，会选择默认的环境；
            //最 后将这些信息set到Configration的Environment属性里面
            this.environmentsElement(root.evalNode("environments"));
            this.databaseIdProviderElement(root.evalNode("databaseIdProvider"));
            // 无论是 MyBatis 在预处理语句（PreparedStatement）中设置一个参数时，还是从结果集中取出一个值时，都会用类型处理器将获取的值以合适的方式转换成 Java 类型。解析typeHandler。            
            this.typeHandlerElement(root.evalNode("typeHandlers"));
            // 解析Mapper文件
            this.mapperElement(root.evalNode("mappers"));
        } catch (Exception var3) {
   
            throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + var3, var3);
        }
    }

1.3.1解析properties标签

配置样例：

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

查看this.propertiesElement(root.evalNode("properties"));方法：

 private void propertiesElement(XNode context) throws Exception {
   
        if (context != null) {
   
        	// 读取properties标签中的property标签<property name="" value=""/>
            Properties defaults = context.getChildrenAsProperties();
            // 读取properties标签中的resource、url属性
            String resource = context.getStringAttribute("resource");
            String url = context.getStringAttribute("url");
            // resource和url属性不能同时出现在properties标签中
            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.");
            }
            // url或者resource对应要文件转化为InputStream，最后放到Properties对象，由于defaults是key-value结构，所以会覆盖相同key的值	
            if (resource != null) {
   
                defaults.putAll(Resources.getResourceAsProperties(resource));
            } else if (url != null) {
    
                defaults.putAll(Resources.getUrlAsProperties(url));
            }
			//获得configuration中的variables变量的值，此变量可以通过SqlSessionFactoryBuilder.build()传入properties属性值
            Properties vars = this.configuration.getVariables();
            // 如果调用build的时候传入了properties属性，放到defaults中
            if (vars != null) {
   
                defaults.putAll(vars);
            }
            // 放到XMLConfigBuilder和Configuration对象中
            this.parser.setVariables(defaults);
            this.configuration.setVariables(defaults);
        }

    }

1.3.2解析typeAliases标签

配置样例：

<typeAliases>
       <package name="cn.com.mybatis.bean"></package>
       <typeAlias alias="user" type="cn.com.mybatis.bean.User"></typeAlias>
</typeAliases>

查看 this.typeAliasesElement(root.evalNode("typeAliases"));方法：

private void typeAliasesElement(XNode parent) {
   
        if (parent != null) {
   
            // 获取typeAliases的所有子标签
            Iterator var2 = parent.getChildren().iterator();
            while(var2.hasNext()) {
   
                XNode child = (XNode)var2.next();
                String alias;
                // 方式一：通过包扫描批量起别名
                if ("package".equals(child.getName())) {
   
                    alias = child.getStringAttribute("name");
                    this.configuration.getTypeAliasRegistry().registerAliases(alias);
                } else {
   
                    // 方式二：通过typeAlias标签单独起别名
                    alias = child.getStringAttribute("alias");
                    String type = child.getStringAttribute("type");
                    try {
   
                        Class<?> clazz = Resources.classForName(type);
                        if (alias == null) {
   
                            this.typeAliasRegistry.registerAlias(clazz);
                        } else {
   
                            this.typeAliasRegistry.registerAlias(alias, clazz);
                        }
                    } catch (ClassNotFoundException var7) {
   
                        throw new BuilderException("Error registering typeAlias for '" + alias + "'. Cause: " + var7, var7);
                    }
                }
            }
        }

    }

方式一通过包扫描批量起别名，查看this.configuration.getTypeAliasRegistry().registerAliases(alias);方法：

public void registerAliases(String packageName){
   
    registerAliases(packageName, Object.class);
  }

可以看到从Configuration中获得TypeAliasRegistry，然后调用其registerAliases方法：

public void registerAliases(String packageName){
   
    registerAliases(packageName, Object.class);
}

继续跟进registerAliases(packageName, Object.class);方法：

public void registerAliases(String packageName, Class<?> superType) {
   
    	// 创建一个工具类对象
        ResolverUtil<Class<?>> resolverUtil = new ResolverUtil();
    	// 通过packageName把该包下的所有类进行加载，把其Class对象放到resolverUtil的matches中
        resolverUtil.find(new IsA(superType), packageName);
       // 获取到加载的Class对象
        Set<Class<? extends Class<?>>> typeSet = resolverUtil.getClasses();
    	// 遍历对象
        Iterator var5 = typeSet.iterator();
        while(var5.hasNext()) {
   
            Class<?> type = (Class)var5.next();
            // 判断不是匿名类，接口，枚举类，就调用registerAlias方法起别名
            if (!type.isAnonymousClass() && !type.isInterface() && !type.isMemberClass()) {
   
                this.registerAlias