前言：
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进行结果的封装
---------------------
作者：恐龙弟旺仔
来源：CSDN
原文：https://blog.csdn.net/qq_26323323/article/details/81335058
版权声明：本文为博主原创文章，转载请附上博文链接！