原生Mybatis框架源码解析
前言：
mybatis是我们常用的一种操作数据库的框架。
我们在使用的mybatis有多种方式：原生mybatis、与Spring结合使用的mybatis、与SprinBoot结合使用的mybatis。
使用的方式越来越简单，需要我们配置的项也越来越少，但是原理都是通用的，底层都是mybatis框架，而mybatis框架的底层也就是我们熟悉的JDBC。
万变不离其宗，下面请随着笔者来以对照JDBC的方式来剖析mybatis源码，看完其源码可以发现其实框架没有我们想象中的那么难，只是封装的好一点，考虑的情况多一点
1.JDBC操作数据库的方式
String url = "jdbc:mysql://localhost:3306/test"; String username = "root"; String password = "root"; String sql = "update blog set name = ? where id=?"; try { // 1.获取连接 Connection connection = DriverManager.getConnection(url, username, password); // 2.创建 preparedStatement PreparedStatement prepareStatement = connection.prepareStatement(sql); // 3.初始化参数 prepareStatement.setString(1, "lucy"); prepareStatement.setInt(2, 1); // 4.执行update prepareStatement.executeUpdate(); } catch (SQLException e) { e.printStackTrace();
主要分四步：获取连接、创建preparedStatement、封装参数、执行
下面我们也按照这四步来分析Mybatis
2.使用原生mybatis方式来操作数据库
关于mybatis的详细使用读者可参考 易佰教程 https://www.yiibai.com/mybatis/install_configure.html
笔者直接摘录其中使用mybatis的经典方式，代码如下（注意：以下代码来自 易佰教程）：
public class HelloWord { private static SqlSessionFactory sqlSessionFactory; private static Reader reader; static { try { // 1.读取mybatis配置文件，并生成SQLSessionFactory reader = Resources.getResourceAsReader("config/Configure.xml"); sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader); } catch (Exception e) { e.printStackTrace(); } } public static SqlSessionFactory getSession() { return sqlSessionFactory; } /** * @param args */ public static void main(String[] args) { // 2.获取session，主要的CRUD操作均在SqlSession中提供 SqlSession session = sqlSessionFactory.openSession(); try { // 3.执行查询操作 // 该方法包括三个步骤：封装入参数、执行查询、封装结果为对象类型 User user = (User) session.selectOne( "com.yiibai.mybatis.models.UserMapper.GetUserByID", 1); if(user!=null){ String userInfo = "名字："+user.getName()+", 所属部门："+user.getDept()+", 主页："+user.getWebsite(); System.out.println(userInfo); } } finally { session.close(); } } }
通过上面的使用可知，最关键的代码就是session.selectOne()，里面包括了入参的封装、查询的执行、结果封装。这句话基本对应了JDBC中全部的四步关键操作。下面我们先来看下SqlSession的获取，然后再对其方法进行分析。
3.SqlSession的获取
// 1.读取config目录下Configure.xml文件 Reader reader = Resources.getResourceAsReader("config/Configure.xml"); // 2.使用SqlSessionFactoryBuilder创建SqlSessionFactory SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader); // 3.在SqlSessionFactory中创建SqlSession SqlSession session = sqlSessionFactory.openSession();
1）Resources.getResourceAsReader("config/Configure.xml")读取文件
public static Reader getResourceAsReader(String resource) throws IOException { Reader reader; if (charset == null) { // 默认为null，走该步骤 reader = new InputStreamReader(getResourceAsStream(resource)); } else { reader = new InputStreamReader(getResourceAsStream(resource), charset); } return reader; } //getResourceAsStream() public static InputStream getResourceAsStream(String resource) throws IOException { return getResourceAsStream(null, resource); } //getResourceAsStream() public static InputStream getResourceAsStream(ClassLoader loader, String resource) throws IOException { // ClassLoaderWrapper classLoaderWrapper = new ClassLoaderWrapper(); InputStream in = classLoaderWrapper.getResourceAsStream(resource, loader); if (in == null) throw new IOException("Could not find resource " + resource); return in; } //classLoaderWrapper.getResourceAsStream(resource, loader) InputStream getResourceAsStream(String resource, ClassLoader[] classLoader) { for (ClassLoader cl : classLoader) { if (null != cl) { // 关键就是这句话 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; }
总结1）：主要就是通过ClassLoader.getResourceAsStream()来获取指定classpath路径下的Resource
2）new SqlSessionFactoryBuilder().build(reader)获取SessionFactory
public SqlSessionFactory build(Reader reader) { return build(reader, null, null); } //build() public SqlSessionFactory build(Reader reader, String environment, Properties properties) { try { XMLConfigBuilder parser = new XMLConfigBuilder(reader, environment, properties); // 主要就是这句话 // 实现了两个功能parse.parse()解析了xml；build(configuration)创建了SqlSessionFactory 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. } } }
* 下面看下parse.parse()方法如何进行xml解析
//XMLConfigBuilder.parse() public Configuration parse() { if (parsed) { throw new BuilderException("Each XMLConfigBuilder can only be used once."); } parsed = true; parseConfiguration(parser.evalNode("/configuration")); return configuration; } // parseConfiguration() // 可以看到主要是对xml各节点的分析，我们重点关注下mapperElement()方法 private void parseConfiguration(XNode root) { try { 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")); 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); } } // mapperElement(root.evalNode("mappers")) 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.addMappers(mapperPackage); } else { // 1.获取resource信息，也就是对应的mapper.xml对应路径 String resource = child.getStringAttribute("resource"); String url = child.getStringAttribute("url"); String mapperClass = child.getStringAttribute("class"); if (resource != null && url == null && mapperClass == null) { // 2.解析对应的mapper.xml文件， ErrorContext.instance().resource(resource); InputStream inputStream = Resources.getResourceAsStream(resource); XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments()); // 3.将解析出来的Mapper对象添加到Configuration中 mapperParser.parse(); } 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(); } else if (resource == null && url == null && mapperClass != null) { Class<?> mapperInterface = Resources.classForName(mapperClass); configuration.addMapper(mapperInterface); } else { throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one."); } } } } }
可以看到，通过解析configuration.xml文件，获取其中的Environment、Setting，重要的是将<mappers>下的所有<mapper>解析出来之后添加到Configuration，Configuration类似于配置中心，所有的配置信息都在这里
* 解析完成之后，我们来看下parse(configuration)如何生成一个SQLSessionFactory
public SqlSessionFactory build(Configuration config) { return new DefaultSqlSessionFactory(config); }
非常简单，直接把Configuration当做参数，直接new一个DefaultSqlSessionFactory
3）sqlSessionFactory.openSession()开启一个SqlSession
public SqlSession openSession() { //configuration.getDefaultExecutorType() = ExecutorType.SIMPLE; return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false); } // openSessionFromDataSource() private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) { Transaction tx = null; try { final Environment environment = configuration.getEnvironment(); // 1.transactionFactory默认为 ManagedTransactionFactory final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment); // 2.创建一个Transaction，注意该Transaction是org.apache.ibatis.transaction.Transaction // Connection即从此处获取的 tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit); // 3.创建一个Executor，默认为SimpleExecutor，参考Executor代码可知，主要的CRUD操作就是再此处完成的 final Executor executor = configuration.newExecutor(tx, execType); // 4.将Executor和Configuration做为参数封装到DefaultSqlSession，默认返回该SqlSession return new DefaultSqlSession(configuration, executor, autoCommit); } catch (Exception e) { closeTransaction(tx); // may have fetched a connection so lets call close() throw ExceptionFactory.wrapException("Error opening session. Cause: " + e, e); } finally { ErrorContext.instance().reset(); } }
总结3）：该方法中有许多新的类出现，下面我们集中看下这些类，简单了解下这些类的作用，以便我们更好的理解代码
* TransactionFactory
类似于我们的SessionFactory，主要是用来生产Transaction的，注意这个Transaction是org.apache.ibatis.transaction.Transaction
public interface TransactionFactory { void setProperties(Properties props); Transaction newTransaction(Connection conn); Transaction newTransaction(DataSource dataSource, TransactionIsolationLevel level, boolean autoCommit); }
* org.apache.ibatis.transaction.Transaction
可以看到getConnection()方法返回的就是我们梦寐以求的java.sql.Connection，后续的操作都是基于此的
并且还有一些关于事务的操作commit、rollback等
public interface Transaction { // java.sql.Connection Connection getConnection() throws SQLException; void commit() throws SQLException; void rollback() throws SQLException; void close() throws SQLException; }
* Executor
根据其接口方法可以看到CRUD操作在这里被实现，看来SqlSession将具体的操作都委托为Executor了
public interface Executor { ... int update(MappedStatement ms, Object parameter) throws SQLException; <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey cacheKey, BoundSql boundSql) throws SQLException; <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException; Transaction getTransaction(); ... }
总结3：
* 解析configuration.xml文件，生成对应的Environment、Setting、Mapper，并注册到Configuration。Configuration相当于配置管理中心，所有的配置都在这里体现
* 生成org.apache.ibatis.transaction.Transaction实现类，里面我们需要的java.sql.Connection
* 根据Transaction封装Executor，Executor负责主要的CRUD操作
* 将Configuration和Executor封装到SqlSession中，SqlSession对外提供统一操作入口，内部委托为Executor来执行
4.SqlSession.selectOne()方法的执行过程
SqlSession默认实现为DefaultSqlSession
public <T> T selectOne(String statement, Object parameter) { // 直接调用了selectList()方法 List<T> list = this.<T>selectList(statement, parameter); if (list.size() == 1) { return list.get(0); } else if (list.size() > 1) { throw new TooManyResultsException("Expected one result (or null) to be returned by selectOne(), but found: " + list.size()); } else { return null; } } //selectList() public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) { try { // 1.获取对应的MappedStatement // MappedStatement包装了每一个CRUD操作对应的详细信息 MappedStatement ms = configuration.getMappedStatement(statement); // 2.executor默认实现为CachingExecutor List<E> result = executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER); return result; } catch (Exception e) { throw ExceptionFactory.wrapException("Error querying database. Cause: " + e, e); } finally { ErrorContext.instance().reset(); } }
注意：有关于Cache的笔者就不分析了，网络上有很多关于Cache的文章，读者可自行查看
可以看到主要的实现都委托给executor了，下面我们重点来看其query()方法的实现
5.CachingExecutor.query()
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException { BoundSql boundSql = ms.getBoundSql(parameterObject); CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql); return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql); } //query() public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException { ... // 重点就是这句，默认实现在BaseExecutor return delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql); } //BaseExecutor.query() public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException { ... List<E> list; try { queryStack++; list = resultHandler == null ? (List<E>) localCache.getObject(key) : null; if (list != null) { handleLocallyCachedOutputParameters(ms, key, parameter, boundSql); } else { // 重要实现在这里 list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql); } } finally { queryStack--; } ... return list; } //queryFromDatabase() private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException { List<E> list; localCache.putObject(key, EXECUTION_PLACEHOLDER); try { // 主要在这里，该方法是一个抽象方法，由子类实现，当前项目子类为SimpleExecutor list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql); } finally { localCache.removeObject(key); } ... } //SimpleExecutor.doQuery() public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException { Statement stmt = null; try { Configuration configuration = ms.getConfiguration(); // 1.StatementHandler封装了JDBC Statement操作，如设置参数、将Statement结果集转换成List集合 StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql); // 2.封装preparedStatement的参数（主要功能就在这里实现） stmt = prepareStatement(handler, ms.getStatementLog()); // 3.执行execute操作 return handler.<E>query(stmt, resultHandler); } finally { closeStatement(stmt); } }
总结：分析可知，主要的功能实现在StatementHandler中。
* StatementHandler创建了PreparedStatement；
* 封装了其所需要的参数；
* 并且对其结果进行处理，封装为对象
下面我们逐个方法来看
1）configuration.newStatementHandler()获取StatementHandler
public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) { StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql); statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler); return statementHandler; } //RoutingStatementHandler构造方法 public RoutingStatementHandler(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) { switch (ms.getStatementType()) { case STATEMENT: delegate = new SimpleStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql); break; case PREPARED: // 我们的默认实现为这个 delegate = new PreparedStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql); break; case CALLABLE: delegate = new CallableStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql); break; default: throw new ExecutorException("Unknown statement type: " + ms.getStatementType()); } }
返回的StatementHandler为PreparedStatementHandler
2）prepareStatement(handler, ms.getStatementLog())
功能：获取Statement；封装PreparedStatement参数；
private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException { Statement stmt; // 1.获取java.sql.Connection // Connection connection = transaction.getConnection(); Connection connection = getConnection(statementLog); // 2.获取对应的Statement stmt = handler.prepare(connection); // 3.封装参数 handler.parameterize(stmt); return stmt; }
* handler.prepare()获取Statement
在这里，最终还是通过java.sql.Connection.prepareStatement(sql)的方式来创建Statement
public Statement prepare(Connection connection) throws SQLException { ErrorContext.instance().sql(boundSql.getSql()); Statement statement = null; try { // 重点在这里 statement = instantiateStatement(connection); setStatementTimeout(statement); setFetchSize(statement); return statement; ... } //PreparedStatementHandler.instantiateStatement() protected Statement instantiateStatement(Connection connection) throws SQLException { String sql = boundSql.getSql(); if (mappedStatement.getKeyGenerator() instanceof Jdbc3KeyGenerator) { String[] keyColumnNames = mappedStatement.getKeyColumns(); if (keyColumnNames == null) { return connection.prepareStatement(sql, PreparedStatement.RETURN_GENERATED_KEYS); } else { return connection.prepareStatement(sql, keyColumnNames); } } else if (mappedStatement.getResultSetType() != null) { return connection.prepareStatement(sql, mappedStatement.getResultSetType().getValue(), ResultSet.CONCUR_READ_ONLY); } else { // 采用了默认实现， // 直接对应了我们传统JDBC方式的从connection中获取PreparedStatement return connection.prepareStatement(sql); } }
* handler.parameterize(stmt)封装参数
public void parameterize(Statement statement) throws SQLException { parameterHandler.setParameters((PreparedStatement) statement); } // public void setParameters(PreparedStatement ps) throws SQLException { ErrorContext.instance().activity("setting parameters").object(mappedStatement.getParameterMap().getId()); // 1.parameterMappings包含了需要拼装的参数 List<ParameterMapping> parameterMappings = boundSql.getParameterMappings(); if (parameterMappings != null) { for (int i = 0; i < parameterMappings.size(); i++) { ParameterMapping parameterMapping = parameterMappings.get(i); if (parameterMapping.getMode() != ParameterMode.OUT) { Object value; // 2.获取参数名称 String propertyName = parameterMapping.getProperty(); // 3.获取参数值 if (boundSql.hasAdditionalParameter(propertyName)) { // issue #448 ask first for additional params value = boundSql.getAdditionalParameter(propertyName); } else if (parameterObject == null) { value = null; } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) { value = parameterObject; } else { MetaObject metaObject = configuration.newMetaObject(parameterObject); value = metaObject.getValue(propertyName); } // 4.获取参数对应的类型处理器 TypeHandler typeHandler = parameterMapping.getTypeHandler(); JdbcType jdbcType = parameterMapping.getJdbcType(); if (value == null && jdbcType == null) jdbcType = configuration.getJdbcTypeForNull(); // 5.对应的封装参数操作还是要委托给TypeHandler来处理 typeHandler.setParameter(ps, i + 1, value, jdbcType); } } } } //BaseTypeHandler.setParameter() public void setParameter(PreparedStatement ps, int i, T parameter, JdbcType jdbcType) throws SQLException { if (parameter == null) { if (jdbcType == null) { throw new TypeException("JDBC requires that the JdbcType must be specified for all nullable parameters."); } try { ps.setNull(i, jdbcType.TYPE_CODE); } catch (SQLException e) { throw new TypeException("Error setting null for parameter #" + i + " with JdbcType " + jdbcType + " . " + "Try setting a different JdbcType for this parameter or a different jdbcTypeForNull configuration property. " + "Cause: " + e, e); } } else { // 由于参数值非空，会走该方法 setNonNullParameter(ps, i, parameter, jdbcType); } }
本例中参数类型为Integer，则对应的typeHandler为IntegerTypeHandler，我们可以看到
// IntegerTypeHandler.setNonNullParameter() public void setNonNullParameter(PreparedStatement ps, int i, Integer parameter, JdbcType jdbcType) throws SQLException { ps.setInt(i, parameter); }
对应于JDBC的处理为preparedStatement.setInt(index,value)
总结2）：进过详细分析，我们可以看到，最终的处理还是JDBC那一套，通过connection创建preparedStatement；对preparedStatement进行参数封装；
下面就是最终执行
3）handler.<E>query(stmt, resultHandler)执行execute操作
//PreparedStatementHandler.query() public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException { PreparedStatement ps = (PreparedStatement) statement; // 1.进行execute操作 ps.execute(); // 2.对结果进行封装 return resultSetHandler.<E> handleResultSets(ps); }
preparedStatement.execute()这个是常规操作，直接进行执行操作
最后是对结果进行封装，交由resultSetHandler来操作
写这篇博客太累了，哈哈，笔者就不打算继续分析resultSetHandler的操作了，但其核心操作也会与JDBC封装结果集一致的
总结：分析下mybatis核心操作如下
* 解析configuration.xml，生成Environment、Setting、Mapper等对象，并注册到Configuration
* 从SqlSessionFactory中获取SqlSession，SqlSession作为操作入口，接收用户的数据库操作，并委托给内部的Executor来实现
* Executor内部StatementHandler负责Statement的创建；PreparedStatement参数的注入；execute方法的执行，所以，可以说重要的执行操作都在StatementHandler中
* execute方法执行过会，ResultSetHandler进行结果的封装
推荐一篇很不错的博客 https://blog.csdn.net/luanlouis/article/details/40422941
以下内容来自该博客
Mybatis的核心部件：
SqlSession 作为MyBatis工作的主要顶层API，表示和数据库交互的会话，完成必要数据库增删改查功能
Executor MyBatis执行器，是MyBatis 调度的核心，负责SQL语句的生成和查询缓存的维护
StatementHandler 封装了JDBC Statement操作，负责对JDBC statement 的操作，如设置参数、将Statement结果集转换成List集合。
ParameterHandler 负责对用户传递的参数转换成JDBC Statement 所需要的参数，
ResultSetHandler 负责将JDBC返回的ResultSet结果集对象转换成List类型的集合；
TypeHandler 负责java数据类型和jdbc数据类型之间的映射和转换
MappedStatement MappedStatement维护了一条<select|update|delete|insert>节点的封装，
SqlSource 负责根据用户传递的parameterObject，动态地生成SQL语句，将信息封装到BoundSql对象中，并返回
BoundSql 表示动态生成的SQL语句以及相应的参数信息
Configuration MyBatis所有的配置信息都维持在Configuration对象之中。
参考地址：https://blog.csdn.net/qq_26323323/article/details/81335058
