Mybatis源码解析
文章内容输出来源：JAVA拉勾高薪训练营
传统方式源码流程
一、初始化源码
在我们开始使用mybatis的时候，是不是会有 这么两句代码？
InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
SqlSessionFactory sqlSessionFactory = new
SqlSessionFactoryBuilder().build(resourceAsStream);
这被称为mybatis的初始化流程。它主要是做了加载配置文件并且解析配置生成sqlSessionFactory的工作。那么它是如何工作的呢？且看一步一步分析：
- 首先点击进入getResourceAsStream方法，会有如下的方法：
public static InputStream getResourceAsStream(String resource) throws IOException {
return getResourceAsStream(null, resource);
}
我们可以看到这是一个重载方法，那么继续点入这个方法
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;
}
现在知道了，它的底层是调用的类加载器去加载的资源对象，返回一个字节输入流。
- 返回输入流之后呢？说明第一步的作用就是加载文件并且返回输入流，此时还没有解析。接着点击build方法，这里才是解析。
public SqlSessionFactory build(InputStream inputStream) {
return build(inputStream, null, null);
}
诶，发现build方法还是一个重载方法，那么继续进入这个方法
public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
try {
// XML解析器
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.
}
}
}
这个方法也不难理解，首先生成一个XML的解析器，然后调用解析方法。现在主要看build(parser.parse())
public Configuration parse() {
if (parsed) {
throw new BuilderException("Each XMLConfigBuilder can only be used once.");
}
parsed = true;
parseConfiguration(parser.evalNode("/configuration"));
return configuration;
}
首先判断文件是否被解析，如果被解析了就抛出异常。如果没有就先把标志位设置为true，然后解析/configuration标签。mybatis的核心xml配置都是parseConfiguration.
private void parseConfiguration(XNode root) {
try {
//issue #117 read properties first
propertiesElement(root.evalNode("properties"));
Properties settings = settingsAsProperties(root.evalNode("settings"));
loadCustomVfs(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);
}
}
是不是看到一堆熟悉的标签名字？对了，这里就是按照标签名字来进行解析的方法。比如propertiesElement方法就是解析
二、SQL执行流程
解析好配置文件后，是不是就要写如下代码：
SqlSession sqlSession = sqlSessionFactory.openSession();
List<Object> objects = sqlSession1.selectList("namespace.id");
首先来看openSession()方法。由于是个接口，我么去找DefaultSqlSessionFactory实现类，有如下实现:
@Override
public SqlSession openSession() {
return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false);
}
一行代码不多说，点进去看看。
private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
// 事务
Transaction tx = null;
try {
// 获取环境
final Environment environment = configuration.getEnvironment();
final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
// 创建执行器
final Executor executor = configuration.newExecutor(tx, execType);
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();
}
}
这里就可以 看到，openSession()的时候创建了执行器Excutor。接着看下一句代码，进入selectList()方法。
@Override
public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
try {
// 获取ms
MappedStatement ms = configuration.getMappedStatement(statement);
// query执行
return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
} catch (Exception e) {
throw ExceptionFactory.wrapException("Error querying database. Cause: " + e, e);
} finally {
ErrorContext.instance().reset();
}
}
其实selectList()内部是调用了Excutor的query方法来执行。那么query()又是如何执行的呢？
三、Excutor源码解析
进入query
public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
if (closed) {
throw new ExecutorException("Executor was closed.");
}
if (queryStack == 0 && ms.isFlushCacheRequired()) {
clearLocalCache();
}
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--;
}
if (queryStack == 0) {
for (DeferredLoad deferredLoad : deferredLoads) {
deferredLoad.load();
}
// issue #601
deferredLoads.clear();
if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
// issue #482
clearLocalCache();
}
}
return 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);
}
接着我们看看从数据库查询的方法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 {
// 查询
list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
} finally {
// 移除占位符
localCache.removeObject(key);
}
// 把刚查询的结果放进去缓存
localCache.putObject(key, list);
if (ms.getStatementType() == StatementType.CALLABLE) {
localOutputParameterCache.putObject(key, parameter);
}
return list;
}
进入查询的doQuery()，是一个接口，找到实现类SimpleExcutor如下代码：
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();
// 真正是交给StatementHandler来处理
StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
stmt = prepareStatement(handler, ms.getStatementLog());
return handler.<E>query(stmt, resultHandler);
} finally {
closeStatement(stmt);
}
}
可以看到查询处理并不是doQuery直接做了，而是交给了StatementHandler来做。那么又来，继续看StatementHandler.
四、StatementHandler源码
进入StatementHandler接口的实现类PreparedStatementHandler。
@Override
public void parameterize(Statement statement) throws SQLException {
parameterHandler.setParameters((PreparedStatement) statement);
}
这一行代码可以看到，其实设置参数是由parameterHandler来做的。那么继续进入设置方法。
public void setParameters(PreparedStatement ps) {
ErrorContext.instance().activity("setting parameters").object(mappedStatement.getParameterMap().getId());
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;
String propertyName = parameterMapping.getProperty();
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);
}
TypeHandler typeHandler = parameterMapping.getTypeHandler();
JdbcType jdbcType = parameterMapping.getJdbcType();
if (value == null && jdbcType == null) {
jdbcType = configuration.getJdbcTypeForNull();
}
try {
typeHandler.setParameter(ps, i + 1, value, jdbcType);
} catch (TypeException e) {
throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + e, e);
} catch (SQLException e) {
throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + e, e);
}
}
}
}
}
这个方法其实就是进行了参数的设置，把?替换为参数。参数设置好了，可以查询，那么返回的结果怎么封装呢？
进入``StatementHandler的query`方法。
@Override
public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
PreparedStatement ps = (PreparedStatement) statement;
ps.execute();
return resultSetHandler.<E> handleResultSets(ps);
}
我们发现了结果集的封装是由resultSetHandler来完成的。那么继续进入handleResultSets()
public List<Object> handleResultSets(Statement stmt) throws SQLException {
ErrorContext.instance().activity("handling results").object(mappedStatement.getId());
// 多Result的结果集合，一个Result就是List<E>,一般我们普通查询就是返回一个List<E>
final List<Object> multipleResults = new ArrayList<Object>();
int resultSetCount = 0;
// 获得首个Result对象
ResultSetWrapper rsw = getFirstResultSet(stmt);
List<ResultMap> resultMaps = mappedStatement.getResultMaps();
int resultMapCount = resultMaps.size();
validateResultMapsCount(rsw, resultMapCount);
while (rsw != null && resultMapCount > resultSetCount) {
// 获得ResultMap对象
ResultMap resultMap = resultMaps.get(resultSetCount);
// 处理Result将其添加到multipleResults
handleResultSet(rsw, resultMap, multipleResults, null);
rsw = getNextResultSet(stmt);
cleanUpAfterHandlingResultSet();
resultSetCount++;
}
String[] resultSets = mappedStatement.getResultSets();
if (resultSets != null) {
while (rsw != null && resultSetCount < resultSets.length) {
ResultMapping parentMapping = nextResultMaps.get(resultSets[resultSetCount]);
if (parentMapping != null) {
String nestedResultMapId = parentMapping.getNestedResultMapId();
ResultMap resultMap = configuration.getResultMap(nestedResultMapId);
handleResultSet(rsw, resultMap, null, parentMapping);
}
rsw = getNextResultSet(stmt);
cleanUpAfterHandlingResultSet();
resultSetCount++;
}
}
return collapseSingleResultList(multipleResults);
}
StatementHandler的功能就是处理结果集返回结果，那么到此结束。传统方法下开发使用mybatis的大概流程源码就分析完了。接下来分析一下使用Mapper代理方式开发的源码，扩展技能。
Mapper代理方式源码流程
一、getMapper源码分析
当我们调用getMapper()方法的时候，其实是内部采用JDK动态代理生成了一个mapper的代理对象，之后的操作都是由代理对象来完成。为什么这么说呢？且看源码分析：
首先找到Configuration类里的getMapper()
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
return mapperRegistry.getMapper(type, sqlSession);
}
mapperRegistry来调用getMapper,继续进入:
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
// 代理工厂
final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
if (mapperProxyFactory == null) {
throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
}
try {
// 生成一个代理对象
return mapperProxyFactory.newInstance(sqlSession);
} catch (Exception e) {
throw new BindingException("Error getting mapper instance. Cause: " + e, e);
}
}
点击进入newInstance
public T newInstance(SqlSession sqlSession) {
final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache);
// 产生代理
return newInstance(mapperProxy);
}
继续进入:
protected T newInstance(MapperProxy<T> mapperProxy) {
// JDK动态代理
return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
}
层层进入，终于真相大白。原来底层就是JDK的动态代理。
二、invoke()方法源码
知道是动态代理产生的代理对象，那么代理对象是如何执行方法的呢？很明显就是invoke()方法了。那咱们直接进去invoke一探究竟.
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
try {
if (Object.class.equals(method.getDeclaringClass())) {
return method.invoke(this, args);
} else if (isDefaultMethod(method)) {
return invokeDefaultMethod(proxy, method, args);
}
} catch (Throwable t) {
throw ExceptionUtil.unwrapThrowable(t);
}
final MapperMethod mapperMethod = cachedMapperMethod(method);
// 代理执行在这里
return mapperMethod.execute(sqlSession, args);
}
最后一句才是执行方法进入看看：
public Object execute(SqlSession sqlSession, Object[] args) {
Object result;
switch (command.getType()) {
// 插入方法
case INSERT: {
Object param = method.convertArgsToSqlCommandParam(args);
// 其实还是调用了sqlSession.insert
result = rowCountResult(sqlSession.insert(command.getName(), param));
break;
}
// 更新方法
case UPDATE: {
Object param = method.convertArgsToSqlCommandParam(args);
result = rowCountResult(sqlSession.update(command.getName(), param));
break;
}
case DELETE: {
Object param = method.convertArgsToSqlCommandParam(args);
result = rowCountResult(sqlSession.delete(command.getName(), param));
break;
}
case SELECT:
// 如果返回值为空
if (method.returnsVoid() && method.hasResultHandler()) {
executeWithResultHandler(sqlSession, args);
result = null;
} else if (method.returnsMany()) {
// 查询many
result = executeForMany(sqlSession, args);
} else if (method.returnsMap()) {
// 返回map
result = executeForMap(sqlSession, args);
} else if (method.returnsCursor()) {
result = executeForCursor(sqlSession, args);
} else {
// 其实还是调用的sqlSession.selectOne
Object param = method.convertArgsToSqlCommandParam(args);
result = sqlSession.selectOne(command.getName(), param);
}
break;
case FLUSH:
result = sqlSession.flushStatements();
break;
default:
throw new BindingException("Unknown execution method for: " + command.getName());
}
if (result == null && method.getReturnType().isPrimitive() && !method.returnsVoid()) {
throw new BindingException("Mapper method '" + command.getName()
+ " attempted to return null from a method with a primitive return type (" + method.getReturnType() + ").");
}
return result;
}
那么通过这个源码我们可以知道，其实invoke内部还是执行了sqlSession的增删改查操作。
那么本次Mybatis基本的源码解析就到这里了。
浙公网安备 33010602011771号