运行阶段划分
根据上一篇MyBatis 源码学习 | Day 1 | 了解 MyBatis中最后使用 MyBatis 操作数据库的代码,我们可以把程序整体运行的流程划分为两个部分:
- MyBatis 初始化
- 数据读写阶段
/**
* 使用 MyBatis 操作数据库
*
* @author nx-xn2002
* @date 2024-08-02
*/
public class QueryWithMyBatis {
public static void main(String[] args) throws IOException {
//第一阶段:MyBatis初始化
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
//第二阶段:数据读写阶段
SqlSession sqlSession = sqlSessionFactory.openSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
List<User> users = mapper.listAll();
users.forEach(System.out::println);
User user = mapper.selectUserById(1L);
System.out.println(user);
sqlSession.close();
}
}
今天我们来探究第一阶段:MyBatis的初始化
MyBatis 初始化阶段
在 MyBatis 的初始化阶段,主要包含配置文件的解析和数据库连接等工作,可以看到,依次是调用了 Resource
类下的 getResourceAsStream
方法来把配置文件解析成 Stream
类对象,然后通过 SqlSessionFactoryBuilder
类下的 bulid
方法获取到 SqlSessionFactory
对象来管理数据库连接。我们深入到这两个方法中去
解析配置文件为输入流
Resource
类下的 getResourceAsStream
方法,试图获取到一个 InputStream
类的对象,核心方法的源代码如下:
/**
* Returns a resource on the classpath as a Stream object
*
* @param loader The classloader used to fetch the resource
* @param resource The resource to find
* @return The resource
* @throws java.io.IOException If the resource cannot be found or read
*/
public static InputStream getResourceAsStream(ClassLoader loader, String resource) throws IOException {
InputStream in = classLoaderWrapper.getResourceAsStream(resource, loader);
if (in == null) {
throw new IOException("Could not find resource " + resource);
}
return in;
}
可以看到,这里是调用了 classLoaderWrapper
对象的同名方法来获取返回值,这个对象是 Resource
类的静态变量,它是在 Resource
类被加载时初始化的,类的加载过程包括:加载 -> 验证 -> 准备 -> 解析 -> 初始化,而 classLoaderWrapper
对象的赋值,就发生在初始化阶段
继续向下定位,可以看到 classLoaderWrapper
对象的这个方法,实际上是调用了另一个重载方法,方法的参数中 ClassLoader
对象变成了 ClassLoader
数组
/**
* Get a resource from the classpath, starting with a specific class loader
*
* @param resource - the resource to find
* @param classLoader - the first class loader to try
* @return the stream or null
*/
public InputStream getResourceAsStream(String resource, ClassLoader classLoader) {
return getResourceAsStream(resource, getClassLoaders(classLoader));
}
/**
* Try to get a resource from a group of classloaders
*
* @param resource - the resource to get
* @param classLoader - the classloaders to examine
* @return the resource or null
*/
InputStream getResourceAsStream(String resource, ClassLoader[] classLoader) {
for (ClassLoader cl : classLoader) {
if (null != cl) {
// try to find the resource as passed
InputStream returnValue = cl.getResourceAsStream(resource);
// now, some class loaders want this leading "/", so we'll add it and try again if we didn't find the resource
if (null == returnValue) {
returnValue = cl.getResourceAsStream("/" + resource);
}
if (null != returnValue) {
return returnValue;
}
}
}
return null;
}
我们可以从 getClassLoaders
方法中,知道传入的 ClassLoader
数组的大致内容
ClassLoader[] getClassLoaders(ClassLoader classLoader) {
return new ClassLoader[]{
classLoader,
defaultClassLoader,
Thread.currentThread().getContextClassLoader(),
getClass().getClassLoader(),
systemClassLoader};
}
结合上下文可以知道,数组中 classLoader
就是我们可以选择传入的自定义 ClassLoader
,defaultClassLoader
也是自定义的 ClassLoader
可以在 Resource
类中通过 set 方法传入,这两个默认值都是 null
。Thread.currentThread().getContextClassLoader()
这个方法返回当前线程的上下文类加载器,上下文类加载器可以被设置为任何类加载器,但默认情况下,它通常是指向应用程序类加载 AppClassLoader
。getClass().getClassLoader()
这个方法返回加载当前类的类加载器,对于大多数非基本类来说,这将是应用程序类加载器 AppClassLoader
,而对于 Java 核心库中的类,如 java.lang.Object
,则会被引导类加载器 Bootstrap ClassLoader
加载。systemClassLoader
这个变量在当前类初始化是就被赋值了,通常是指向系统类加载器 AppClassLoader
的引用。
//systemClassLoader 的初始化
ClassLoaderWrapper() {
try {
systemClassLoader = ClassLoader.getSystemClassLoader();
} catch (SecurityException ignored) {
// AccessControlException on Google App Engine
}
}
以上就是解析配置文件的基本流程,最后通过尝试调用各个类加载器的解析配置文件的方法,来对配置文件进行解析,在这个过程中,大量使用了方法重载,使得程序变得灵活
获取 SqlSessionFactory
对象管理数据库连接
在这一步骤中,首先我们可以看到 SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
一句中使用 SqlSessionFactoryBuilder
类的 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.
}
}
}
在这里面,核心的两句代码是
XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
return build(parser.parse());
这里面的 parser.parse()
提供了一个 Configuration
类的对象供 SqlSessionFactory
类使用 SqlSessionFactory build(Configuration config)
方法来构造 SqlSessionFactory
对象
可以看 parse
方法的实现细节:
public Configuration parse() {
if (parsed) {
throw new BuilderException("Each XMLConfigBuilder can only be used once.");
}
parsed = true;
parseConfiguration(parser.evalNode("/configuration"));
return configuration;
}
private void parseConfiguration(XNode root) {
try {
//issue #117 read properties first
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
对象中,最后通过这个 Configuration
对象,构造 SqlSessionFactory
对象。
最后需要注意到的是,SqlSessionFactory
本身是一个接口,最终返回的还是它的一个默认的实现类 DefaultSqlSessionFactory
的对象,代码如下:
public SqlSessionFactory build(Configuration config) {
return new DefaultSqlSessionFactory(config);
}