Mybatis源码剖析(一）

最新推荐文章于 2024-01-21 00:07:58 发布

痛冕

最新推荐文章于 2024-01-21 00:07:58 发布

阅读量106

点赞数 1

分类专栏：持久层框架设计实现及Mybatis源码分析文章标签： mybatis java

本文链接：https://blog.csdn.net/qq_40977467/article/details/116927529

版权

持久层框架设计实现及Mybatis源码分析专栏收录该内容

15 篇文章 0 订阅

订阅专栏

Mybatis源码剖析(一）

传统方式源码剖析：

源码剖析-初始化

InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
//开始初始话工作
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);

build方法

public SqlSessionFactory build(InputStream inputStream){
	//调用重载方法
	return build(inputSteam,null,null)
}

public SqlSessionFactory build(InputStream inputStream,String environment,Properties properties){
	try{
		// XMLConfigBuilder是专门解析mybatis的配置文件的类
		XMLConfigBuilder parser = new XMLConfigBuilder(inputstream,environment, properties);
		//这里又调用了一个重载方法。parser.parse()的返回值是Configuration对象
		return build(parser.parse());
	}catch (Exception e) {
			throw ExceptionFactory.wrapException("Error building SqlSession.", e)
}
}

MyBatis在初始化的时候，会将MyBatis的配置信息全部加载到内存中，使用org.apache.ibatis.session.Configuratio n 实例来维护

下面进入对配置文件解析部分：

首先对Configuration对象进行介绍：
在这里插入图片描述

/**
 * 解析 XML 成 Configuration 对象。
*/
public Configuration parse () {
	//若已解析，抛出BuilderException异常
	if (parsed) {
		throw new BuilderException("Each XMLConfigBuilder can only be used once.");
	}
	//标记已解析
	parsed = true;
	// 解析 XML configuration 节点
	parseConfiguration(parser.evalNode("/configuration"));
	return configuration;
}
/**
*解析XML
*/
private void parseConfiguration (XNode root){
	try {
		//issue #117 read properties first
		// 解析 <properties /> 标签
		propertiesElement(root.evalNode("properties"));
		// 解析〈settings /> 标签
		Properties settings =
		settingsAsProperties(root.evalNode("settings"));
		//加载自定义的VFS实现类
		loadCustomVfs(settings);
		// 解析 <typeAliases /> 标签
		typeAliasesElement(root.evalNode("typeAliases"));
		//解析<plugins />标签
		pluginElement(root.evalNode("plugins"));
		// 解析 <objectFactory /> 标签
		objectFactoryElement(root.evalNode("objectFactory"));
		// 解析 <objectWrapperFactory /> 标签
		objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
		// 解析 <reflectorFactory /> 标签
		reflectorFactoryElement(root.evalNode("reflectorFactory"));
		// 赋值 <settings /> 至 Configuration 属性
		settingsElement(settings);
		// read it after objectFactory and objectWrapperFactory issue
		#631
		// 解析〈environments /> 标签
		environmentsElement(root.evalNode("environments"));
		// 解析 <databaseIdProvider /> 标签
		databaseldProviderElement(root.evalNode("databaseldProvider"));
		// 解析 <typeHandlers /> 标签
		typeHandlerElement(root.evalNode("typeHandlers"));
		//解析<mappers />标签
		mapperElement(root.evalNode("mappers"));
	} catch (Exception e) {
		throw new BuilderException("Error parsing SQL MapperConfiguration.Cause:" + e, e);
	}
}

介绍一下 MappedStatement ：
作用：MappedStatement与Mapper配置文件中的一个select/update/insert/delete节点相对应。
mapper中配置的标签都被封装到了此对象中，主要用途是描述一条SQL语句。
初始化过程：回顾刚开始介绍的加载配置文件的过程中，会对mybatis-config.xm l中的各个标签都进行解析，其中有mappers 标签用来引入mapper.xml文件或者配置mapper接口的目录。一个select标签会在初始化配置文件时被解析封装成一个MappedStatement对象，然后存储在
Configuration对象的mappedStatements属性中，mappedStatements 是一个HashMap，存储时key=全限定类名+方法名，value =对应的MappedStatement对象。
在configuration中对应的属性为：

Map<String, MappedStatement> mappedStatements = new StrictMap<MappedStatement>
("Mapped Statements collection")

在 XMLConfigBuilder 中的处理：

private void parseConfiguration(XNode root) {
	try {
		//省略其他标签的处理
		mapperElement(root.evalNode("mappers"));
	} catch (Exception e) {
		throw new BuilderException("Error parsing SQL Mapper Configuration.Cause:" + e, e);
	}
}

到此对xml配置文件的解析就结束了，回到步骤2.中调用的重载build方法

// 5.调用的重载方法
public SqlSessionFactory build(Configuration config) {
	//创建了 DefaultSqlSessionFactory 对象，传入 Configuration 对象。
	return new DefaultSqlSessionFactory(config);
}

源码剖析-执行SQL流程

先简单介绍SqlSession ：

SqlSession是一个接口，它有两个实现类：DefaultSqlSession (默认)和
SqlSessionManager (弃用，不做介绍)
SqlSession是MyBatis中用于和数据库交互的顶层类，通常将它与ThreadLocal绑定，一个会话使用一个
SqlSession,并且在使用完毕后需要close

public class DefaultSqlSession implements SqlSession {
	private final Configuration configuration;
	private final Executor executor;

SqlSession中的两个最重要的参数，configuration与初始化时的相同，Executor为执行器
Executor：

Executor也是一个接口，他有三个常用的实现类：
BatchExecutor (重用语句并执行批量更新)
ReuseExecutor (重用预处理语句 prepared statements)
SimpleExecutor (普通的执行器，默认)
继续分析，初始化完毕后，我们就要执行SQL 了

SqlSession sqlSession = factory.openSession();
List<User> list = sqlSession.selectList("com.lagou.mapper.UserMapper.getUserByName");

获得 sqlSession：

//6. 进入 o penSession 方法。
public SqlSession openSession() {
	//getDefaultExecutorType()传递的是SimpleExecutor
	return openSessionFromDataSource(configuration.getDefaultExecutorType(),
	null, false);
}
//7. 进入penSessionFromDataSource。
//ExecutorType 为Executor的类型，TransactionIsolationLevel为事务隔离级别，autoCommit是否开启事务
//openSession的多个重载方法可以指定获得的SeqSession的Executor类型和事务的处理
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);
		//根据参数创建指定类型的Executor
		final Executor executor = configuration.newExecutor(tx, execType);
		//返回的是 DefaultSqlSession
		return new DefaultSqlSession(configuration, executor, autoCommit);
	} catch(Exception e){
		closeTransaction(tx); // may have fetched a connection so lets call
		close()
	}

执行 sqlsession 中的 api

//8.进入selectList方法，多个重载方法。
	public <E > List < E > selectList(String statement) {
		return this.selectList(statement, null);
	}
	public <E > List < E > selectList(String statement, Object parameter) {
		return this.selectList(statement, parameter, RowBounds.DEFAULT);
	}
	public <E > List < E > selectList(String statement, Object parameter, RowBounds rowBounds) {
		try {
			//根据传入的全限定名+方法名从映射的Map中取出MappedStatement对象
			MappedStatement ms =
			configuration.getMappedStatement(statement);
			//调用Executor中的方法处理
			//RowBounds是用来逻辑分页
			// wrapCollection(parameter)是用来装饰集合或者数组参数
			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();
		}

源码剖析-executor

继续源码中的步骤，进入executor.query()

//此方法在SimpleExecutor的父类BaseExecutor中实现
public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds
rowBounds, ResultHandler resultHandler) throws SQLException {
	//根据传入的参数动态获得SQL语句，最后返回用BoundSql对象表示
	BoundSql boundSql = ms.getBoundSql(parameter);
	//为本次查询创建缓存的Key
	CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
	return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
}
//进入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;
	}
//从数据库查询
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;
	}
// 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();
			//传入参数创建StatementHanlder对象来执行查询
			StatementHandler handler =
			configuration.newStatementHandler(wrapper, ms, parameter, rowBounds,
			resultHandler, boundSql);
			//创建jdbc中的statement对象
			stmt = prepareStatement(handler, ms.getStatementLog());
			// StatementHandler 进行处理
			return handler.query(stmt, resultHandler);
		} finally {
			closeStatement(stmt);
		}
	}
	//创建Statement的方法
	private Statement prepareStatement(StatementHandler handler, Log
	statementLog) throws SQLException {
		Statement stmt;
		//条代码中的getConnection方法经过重重调用最后会调用openConnection方法，从连接池中
		获 得连接。
		Connection connection = getConnection(statementLog);
		stmt = handler.prepare(connection, transaction.getTimeout());
		handler.parameterize(stmt);
		return stmt;
	}
	//从连接池获得连接的方法
	protected void openConnection() throws SQLException {
	if (log.isDebugEnabled()) {
		log.debug("Opening JDBC Connection");
	}
	//从连接池获得连接
	connection = dataSource.getConnection();
	if (level != null) {
		connection.setTransactionIsolation(level.getLevel());
	}
}

上述的Executor.query()方法几经转折，最后会创建一个StatementHandler对象，然后将必要的参数传递给StatementHandler，使用StatementHandler来完成对数据库的查询，最终返回List结果集。
从上面的代码中我们可以看出，Executor的功能和作用是：

根据传递的参数，完成SQL语句的动态解析，生成BoundSql对象，供StatementHandler使用；
为查询创建缓存，提高想能
创建JDBC的statement对象，传递给StatementHandler对象，返回List查询结果

源码剖析-StatementHandler

StatementHandler对象主要完成两个工作：

对于JDBC的PreparedStatement类型的对象，创建的过程中，我们使用的是SQL语句字符串会包含若干个？占位符，我们其后再对占位符进行设值。StatementHandler通过parameterize(statement)方法对 S tatement 进行设值；
StatementHandler 通过 List query(Statement statement, ResultHandler resultHandler)方法来完成执行Statement，和将Statement对象返回的resultSet封装成List；
进入到 StatementHandler 的 parameterize(statement)方法的实现：

public void parameterize(Statement statement) throws SQLException {
	//使用ParameterHandler对象来完成对Statement的设值
	parameterHandler.setParameters((PreparedStatement) statement);
}

/** ParameterHandler 类的 setParameters(PreparedStatement ps) 实现
 * 对某一个Statement进行设置参数
 * */
public void setParameters(PreparedStatement ps) throws SQLException {
	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); }
					// 每一个 Mapping都有一个 TypeHandler，根据 TypeHandler 来对
					preparedStatement 进 行设置参数
					TypeHandler typeHandler = parameterMapping.getTypeHandler();
					JdbcType jdbcType = parameterMapping.getJdbcType();
					if (value == null && jdbcType == null)
				 	jdbcType =configuration.getJdbcTypeForNull();
					//设置参数
					typeHandler.setParameter(ps, i + 1, value, jdbcType);
				}
			}
		}
	}

从上述的代码可以看到,StatementHandler的parameterize(Statement)方法调用了
ParameterHandler的setParameters(statement)方法，ParameterHandler的setParameters(Statement )方法负责根据我们输入的参数，对statement对象的 ?
占位符处进行赋值。进入到StatementHandler 的 List query(Statement statement, ResultHandler resultHandler)方法的实现：

public <E> List<E> query(Statement statement, ResultHandler resultHandler)
throws SQLException {
	// 1.调用preparedStatemnt。execute()方法，然后将resultSet交给ResultSetHandler处理
	PreparedStatement ps = (PreparedStatement) statement;
	ps.execute();
	//2.使用 ResultHandler 来处理 ResultSet
	return resultSetHandler.<E> handleResultSets(ps);
}

从上述代码我们可以看出，StatementHandler 的List query(Statement statement, ResultHandler，resultHandler)方法的实现，是调用了 ResultSetHandler 的 handleResultSets(Statement)方法。ResultSetHandler 的 handleResultSets(Statement)方法会将 Statement 语句执行后生成的 resultSet结果集转换成List结果集

public List<Object> handleResultSets(Statement stmt) throws SQLException {
	ErrorContext.instance().activity("handlingresults").object(mappedStatement.getId());
	//多ResultSet的结果集合，每个ResultSet对应一个Object对象。而实际上，每 个 Object 是
	List<Object> 对象。
	//在不考虑存储过程的多ResultSet的情况，普通的查询，实际就一个ResultSet，也 就是说，multipleResults最多就一个元素。
	final List<Object> multipleResults = new ArrayList<>();
	int resultSetCount = 0;
	//获得首个ResultSet对象，并封装成ResultSetWrapper对象
	ResultSetWrapper rsw = getFirstResultSet(stmt);
	//获得ResultMap数组
	//在不考虑存储过程的多ResultSet的情况，普通的查询，实际就一个ResultSet，也 就是说，resultMaps就一个元素。
	List<ResultMap> resultMaps = mappedStatement.getResultMaps();
	int resultMapCount = resultMaps.size();
	validateResultMapsCount(rsw, resultMapCount); // 校验
	while (rsw != null && resultMapCount > resultSetCount) {
		//获得ResultMap对象
		ResultMap resultMap = resultMaps.get(resultSetCount);
		//处理ResultSet，将结果添加到multipleResults中
		handleResultSet(rsw, resultMap, multipleResults, null);
		//获得下一个ResultSet对象，并封装成ResultSetWrapper对象
		rsw = getNextResultSet(stmt);
		//清理
		cleanUpAfterHandlingResultSet();
		// resultSetCount ++
		resultSetCount++;
	}
}
//因为'mappedStatement.resultSets'只在存储过程中使用，本系列暂时不考虑，忽略即可
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++;
		}
	}
	//如果是multipleResults单元素，则取首元素返回
	return collapseSingleResultList(multipleResults);
}

Mapper代理方式：

源码剖析-getmapper()

进入 sqlSession.getMapper(UserMapper.class )中

//DefaultSqlSession 中的 getMapper
public <T> T getMapper(Class<T> type) {
	return configuration.<T>getMapper(type, this);
}
//configuration 中的给 g etMapper
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
	return mapperRegistry.getMapper(type, sqlSession);
}
//MapperRegistry 中的 g etMapper
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
	//从 MapperRegistry 中的 HashMap 中拿 MapperProxyFactory
	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);
	}
}
//MapperProxyFactory 类中的 newInstance 方法
public T newInstance(SqlSession sqlSession) {
	//创建了 JDK动态代理的Handler类
	final MapperProxy<T> mapperProxy = new MapperProxy<>(sqlSession,
	mapperInterface, methodCache);
	//调用了重载方法
	return newInstance(mapperProxy);
}
//MapperProxy 类，实现了 InvocationHandler 接口
public class MapperProxy<T> implements InvocationHandler, Serializable {
	//省略部分源码
	private final SqlSession sqlSession;
	private final Class<T> mapperInterface;
	private final Map<Method, MapperMethod> methodCache;
	//构造，传入了 SqlSession，说明每个session中的代理对象的不同的！
	public MapperProxy(SqlSession sqlSession, Class<T> mapperInterface,
	Map<Method, MapperMethod> methodCache) {
		this.sqlSession = sqlSession;
		this.mapperInterface = mapperInterface;
		this.methodCache = methodCache;
	}
	//省略部分源码
	}

源码剖析-invoke()

在动态代理返回了示例后，我们就可以直接调用mapper类中的方法了，但代理对象调用方法，执行是在MapperProxy中的invoke方法中

	public Object invoke(Object proxy, Method method, Object[] args) throws
	Throwable {
		try {
			//如果是Object定义的方法，直接调用
			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);
		}
		// 获得 MapperMethod 对象
		final MapperMethod mapperMethod = cachedMapperMethod(method);
		//重点在这：MapperMethod最终调用了执行的方法
		return mapperMethod.execute(sqlSession, args);
	}

进入execute方法：

public Object execute(SqlSession sqlSession, Object[] args) {
	Object result;
	//判断mapper中的方法类型，最终调用的还是SqlSession中的方法
	 switch(command.getType()) {
		case INSERT: {
			//转换参数
			Object param = method.convertArgsToSqlCommandParam(args);
			//执行INSERT操作
			// 转换 rowCount
			result = rowCountResult(sqlSession.insert(command.getName(),
param));
			break;
		}
		case UPDATE: {
			//转换参数
			Object param = method.convertArgsToSqlCommandParam(args);
			// 转换 rowCount 
			result = rowCountResult(sqlSession.update(command.getName(),
	param));
			break;
		}
		case DELETE: {
			//转换参数
			Object param = method.convertArgsToSqlCommandParam(args);
			// 转换 rowCount 
			result = rowCountResult(sqlSession.delete(command.getName(),
			param));
			break;
		}
		case SELECT:
			//无返回，并且有ResultHandler方法参数，则将查询的结果，提交给 ResultHandler 进行处理
			if (method.returnsVoid() && method.hasResultHandler()) {
				executeWithResultHandler(sqlSession, args);
				result = null;
				//执行查询，返回列表
			} else if (method.returnsMany()) {
				result = executeForMany(sqlSession, args);
				//执行查询，返回Map
			} else if (method.returnsMap()) {
				result = executeForMap(sqlSession, args);
				//执行查询，返回Cursor
			} else if (method.returnsCursor()) {
				result = executeForCursor(sqlSession, args);
			//执行查询，返回单个对象
			} else {
				//转换参数
				Object param = method.convertArgsToSqlCommandParam(args);
				//查询单条
				result = sqlSession.selectOne(command.getName(), param);
				if (method.returnsOptional() &&
				(result == null ||
				!method.getReturnType().equals(result.getClass())))
				{
					result = Optional.ofNullable(result);
				}
			}
			break;
		case FLUSH:
			result = sqlSession.flushStatements();
			break;
		default:
			throw new BindingException("Unknown execution method for: " +command.getName());
}
//返回结果为null，并且返回类型为基本类型，则抛出BindingException异常
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;
}

二级缓存源码剖析：

二级缓存构建在一级缓存之上，在收到查询请求时，MyBatis 首先会查询二级缓存，若二级缓存未命中，再去查询一级缓存，一级缓存没有，再查询数据库。
二级缓存------》一级缓存------》数据库
与一级缓存不同，二级缓存和具体的命名空间绑定，一个Mapper中有一个Cache，相同Mapper中的MappedStatement共用一个Cache，一级缓存则是和 SqlSession 绑定。

启用二级缓存

查看专栏下Mybatis缓存文章

标签 < cache/> 的解析

// 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中添加的，那么我们就直接看关于mappers标签的解析
private void parseConfiguration(XNode root) {
	try {
		Properties settings = settingsAsPropertiess(root.evalNode("settings"));
		propertiesElement(root.evalNode("properties"));
		loadCustomVfs(settings);
		typeAliasesElement(root.evalNode("typeAliases"));
		pluginElement(root.evalNode("plugins"));
		objectFactoryElement(root.evalNode("objectFactory"));
		objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
		reflectionFactoryElement(root.evalNode("reflectionFactory"));
		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);
	}
}
// mapperElement()
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 {
				String resource = child.getStringAttribute("resource");
				String url = child.getStringAttribute("url");
				String mapperClass = child.getStringAttribute("class");
				// 按照我们本例的配置，则直接走该if判断
				if (resource != null && url == null && mapperClass == null) {
					ErrorContext.instance().resource(resource);
					InputStream inputStream =
					Resources.getResourceAsStream(resource);
					XMLMapperBuilder mapperParser = new
					XMLMapperBuilder(inputStream, configuration, resource,
					configuration.getSqlFragments());
					// 生成XMLMapperBuilder，并执行其parse方法
					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.");
				}
			}
		}
	}
}

解析Mapper.xml

// XMLMapperBuilder.parse()
public void parse() {
	if (!configuration.isResourceLoaded(resource)) {
		// 解析mapper属性
		configurationElement(parser.evalNode("/mapper"));
		configuration.addLoadedResource(resource);
		bindMapperForNamespace();
	}
	parsePendingResultMaps();
	parsePendingChacheRefs();
	parsePendingStatements();
}
// configurationElement()
private void configurationElement(XNode context) {
	try {
		String namespace = context.getStringAttribute("namespace");
		if (namespace == null || namespace.equals("")) {
			throw new BuilderException("Mapper's namespace cannot be empty");
		}
		builderAssistant.setCurrentNamespace(namespace);
		cacheRefElement(context.evalNode("cache-ref"));
		// 最终在这里看到了关于cache属性的处理
		cacheElement(context.evalNode("cache"));
		parameterMapElement(context.evalNodes("/mapper/parameterMap"));
		resultMapElements(context.evalNodes("/mapper/resultMap"));
		sqlElement(context.evalNodes("/mapper/sql"));
		// 这里会将生成的Cache包装到对应的MappedStatement
		buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
	} catch (Exception e) {
		throw new BuilderException("Error parsing Mapper XML. Cause: " + e, e);
	}
}
// cacheElement()
private void cacheElement(XNode context) throws Exception {
	if (context != null) {
		//解析<cache/>标签的type属性，这里我们可以自定义cache的实现类，比如redisCache，如果没有自定义，这里使用和一级缓存相同的PERPETUAL
		String type = context.getStringAttribute("type", "PERPETUAL");
		Class<? extends Cache> typeClass = typeAliasRegistry.resolveAlias(type);
		String eviction = context.getStringAttribute("eviction", "LRU");
		Class<? extends Cache> evictionClass =
		typeAliasRegistry.resolveAlias(eviction);
		Long flushInterval = context.getLongAttribute("flushInterval");
		Integer size = context.getIntAttribute("size");
		boolean readWrite = !context.getBooleanAttribute("readOnly", false);
		boolean blocking = context.getBooleanAttribute("blocking", false);
		Properties props = context.getChildrenAsProperties();
		// 构建Cache对象
		builderAssistant.useNewCache(typeClass, evictionClass, flushInterval,
		size, readWrite, blocking, props);
	}
}

构建Cache对象的MapperBuilderAssistant.useNewCache()

public Cache useNewCache(Class<? extends Cache> typeClass,Class<? extends Cache> evictionClass,
Long flushInterval,
Integer size,
boolean readWrite,
boolean blocking,
Properties props) {
	// 1.生成Cache对象
	Cache cache = new CacheBuilder(currentNamespace)
	//这里如果我们定义了<cache/>中的type，就使用自定义的Cache,否则使用和一级缓存相同的
	PerpetualCache.implementation(valueOrDefault(typeClass, PerpetualCache.class)).addDecorator(valueOrDefault(evictionClass, LruCache.class)).clearInterval(flushInterval).size(size).readWrite(readWrite).blocking(blocking).properties(props).build();
	// 2.添加到Configuration中
	configuration.addCache(cache);
	// 3.并将cache赋值给MapperBuilderAssistant.currentCache
	currentCache = cache;
	return cache;
}

我们看到一个Mapper.xml只会解析一次标签，也就是只创建一次Cache对象，放进configuration中，
并将cache赋值给MapperBuilderAssistant.currentCache
buildStatementFromContext(context.evalNodes(“select|insert|update|delete”));将Cache包装到MappedStatement

// buildStatementFromContext()
private void buildStatementFromContext(List<XNode> list) {
	if (configuration.getDatabaseId() != null) {
		buildStatementFromContext(list, configuration.getDatabaseId());
	}
	buildStatementFromContext(list, null);
}
//buildStatementFromContext()
private void buildStatementFromContext(List<XNode> list, String
requiredDatabaseId) {
	for (XNode context : list) {
		final XMLStatementBuilder statementParser = new
		XMLStatementBuilder(configuration, builderAssistant, context,
		requiredDatabaseId);
		try {
			// 每一条执行语句转换成一个MappedStatement
			statementParser.parseStatementNode();
		} catch (IncompleteElementException e) {
			configuration.addIncompleteStatement(statementParser);
		}
	}
}
// XMLStatementBuilder.parseStatementNode();
public void parseStatementNode() {
	String id = context.getStringAttribute("id");
	String databaseId = context.getStringAttribute("databaseId");
	...
	Integer fetchSize = context.getIntAttribute("fetchSize");
	Integer timeout = context.getIntAttribute("timeout");
	String parameterMap = context.getStringAttribute("parameterMap");
	String parameterType = context.getStringAttribute("parameterType");
	Class<?> parameterTypeClass = resolveClass(parameterType);
	String resultMap = context.getStringAttribute("resultMap");
	String resultType = context.getStringAttribute("resultType");
	String lang = context.getStringAttribute("lang");
	LanguageDriver langDriver = getLanguageDriver(lang);
	...
	// 创建MappedStatement对象
	builderAssistant.addMappedStatement(id, sqlSource, statementType,
	sqlCommandType,
	fetchSize, timeout, parameterMap,
	parameterTypeClass, resultMap, resultTypeClass,
	resultSetTypeEnum, flushCache, useCache,
	resultOrdered,
	keyGenerator, keyProperty, keyColumn,
	databaseId, langDriver, resultSets);
}
// builderAssistant.addMappedStatement()
public MappedStatement addMappedStatement(
	String id,
...) {
if (unresolvedCacheRef) {
	throw new IncompleteElementException("Cache-ref not yet resolved");
}
	id = applyCurrentNamespace(id, false);
	boolean isSelect = sqlCommandType == SqlCommandType.SELECT;
	//创建MappedStatement对象
	MappedStatement.Builder statementBuilder = new
	MappedStatement.Builder(configuration, id, sqlSource, sqlCommandType)
...
	.flushCacheRequired(valueOrDefault(flushCache, !isSelect))
	.useCache(valueOrDefault(useCache, isSelect))
	.cache(currentCache);// 在这里将之前生成的Cache封装到MappedStatement
	ParameterMap statementParameterMap = getStatementParameterMap(parameterMap,
	parameterType, id);
	if (statementParameterMap != null) {
		statementBuilder.parameterMap(statementParameterMap);
	}
	MappedStatement statement = statementBuilder.build();
	configuration.addMappedStatement(statement);
	return statement;
}

查询源码分析

CachingExecutor

// CachingExecutor
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
	BoundSql boundSql = ms.getBoundSql(parameterObject);
	// 创建 CacheKey
	CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);
	return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)throws SQLException {
	// 从 MappedStatement 中获取 Cache，注意这里的 Cache 是从MappedStatement中获取的
	// 也就是我们上面解析Mapper中<cache/>标签中创建的，它保存在Configration中
	// 我们在上面解析blog.xml时分析过每一个MappedStatement都有一个Cache对象，就是这里
	Cache cache = ms.getCache();
	// 如果配置文件中没有配置 <cache>，则 cache 为空
	if (cache != null) {
		//如果需要刷新缓存的话就刷新：flushCache="true"
		flushCacheIfRequired(ms);
		if (ms.isUseCache() && resultHandler == null) {
			ensureNoOutParams(ms, boundSql);
			// 访问二级缓存
			List<E> list = (List<E>) tcm.getObject(cache, key);
			// 缓存未命中
			if (list == null) {
				// 如果没有值，则执行查询，这个查询实际也是先走一级缓存查询，一级缓存也没有的话，则进行DB查询
				list = delegate.<E>query(ms, parameterObject, rowBounds,
				resultHandler, key, boundSql);
				// 缓存查询结果
				tcm.putObject(cache, key, list);
			}
			return list;
		}
	}
	return delegate.<E>query(ms, parameterObject, rowBounds, resultHandler, key,boundSql);
}

如果设置了flushCache=“true”，则每次查询都会刷新缓存

<!-- 执行此语句清空缓存 -->
<select id="findbyId" resultType="com.lagou.pojo.user" useCache="true" flushCache="true" >
	select * from t_demo
</select>

如上，注意二级缓存是从 MappedStatement 中获取的。由于 MappedStatement 存在于全局配置中，可以多个 CachingExecutor 获取到，这样就会出现线程安全问题。除此之外，若不加以控制，多个事务共用一个缓存实例，会导致脏读问题。至于脏读问题，需要借助其他类来处理，也就是上面代码中 tcm变量对应的类型。下面分析一下。
TransactionalCacheManager

/** 事务缓存管理器 */
public class TransactionalCacheManager {
	// Cache 与 TransactionalCache 的映射关系表
	private final Map<Cache, TransactionalCache> transactionalCaches = new HashMap<Cache, TransactionalCache>();
	public void clear(Cache cache) {
		// 获取 TransactionalCache 对象，并调用该对象的 clear 方法，下同
		getTransactionalCache(cache).clear();
	}
	public Object getObject(Cache cache, CacheKey key) {
		// 直接从TransactionalCache中获取缓存
		return getTransactionalCache(cache).getObject(key);
	}
	public void putObject(Cache cache, CacheKey key, Object value) {
		// 直接存入TransactionalCache的缓存中
		getTransactionalCache(cache).putObject(key, value);
	}
	public void commit() {
		for (TransactionalCache txCache : transactionalCaches.values()) {
			txCache.commit();
		}
	}
	public void rollback() {
		for (TransactionalCache txCache : transactionalCaches.values()) {
			txCache.rollback();
		}
	}
	private TransactionalCache getTransactionalCache(Cache cache) {
		// 从映射表中获取 TransactionalCache
		TransactionalCache txCache = transactionalCaches.get(cache);
		if (txCache == null) {
			// TransactionalCache 也是一种装饰类，为 Cache 增加事务功能
			// 创建一个新的TransactionalCache，并将真正的Cache对象存进去
			txCache = new TransactionalCache(cache);
			transactionalCaches.put(cache, txCache);
		}
		return txCache;
	}
}

TransactionalCacheManager 内部维护了 Cache 实例与 TransactionalCache 实例间的映射关系，该类也仅负责维护两者的映射关系，真正做事的还是 TransactionalCache。TransactionalCache 是一种缓存装饰器，可以为 Cache 实例增加事务功能。我在之前提到的脏读问题正是由该类进行处理的。下面分析一下该类的逻辑。
TransactionalCache

public class TransactionalCache implements Cache {
	//真正的缓存对象，和上面的Map<Cache, TransactionalCache>中的Cache是同一个
	private final Cache delegate;
	private boolean clearOnCommit;
	// 在事务被提交前，所有从数据库中查询的结果将缓存在此集合中
	private final Map<Object, Object> entriesToAddOnCommit;
	// 在事务被提交前，当缓存未命中时，CacheKey 将会被存储在此集合中
	private final Set<Object> entriesMissedInCache;
	@Override
	public Object getObject(Object key) {
		// 查询的时候是直接从delegate中去查询的，也就是从真正的缓存对象中查询
		Object object = delegate.getObject(key);
		if (object == null) {
			// 缓存未命中，则将 key 存入到 entriesMissedInCache 中
			entriesMissedInCache.add(key);
		}
		if (clearOnCommit) {
			return null;
		} else {
			return object;
		}
	}
	@Override
	public void putObject(Object key, Object object) {
		// 将键值对存入到 entriesToAddOnCommit 这个Map中中，而非真实的缓存对象 delegate中
		entriesToAddOnCommit.put(key, object);
	}
	@Override
	public Object removeObject(Object key) {
		return null;
	}
	@Override
	public void clear() {
		clearOnCommit = true;
		// 清空 entriesToAddOnCommit，但不清空 delegate 缓存
		entriesToAddOnCommit.clear();
	}
	public void commit() {
		// 根据 clearOnCommit 的值决定是否清空 delegate
		if (clearOnCommit) {
			delegate.clear();
		}
		// 刷新未缓存的结果到 delegate 缓存中
		flushPendingEntries();
		// 重置 entriesToAddOnCommit 和 entriesMissedInCache
		reset();
	}
	public void rollback() {
		unlockMissedEntries();
		reset();
	}
	private void reset() {
		clearOnCommit = false;
		// 清空集合
		entriesToAddOnCommit.clear();
		entriesMissedInCache.clear();
	}
	private void flushPendingEntries() {
		for (Map.Entry<Object, Object> entry : entriesToAddOnCommit.entrySet())
		{
			// 将 entriesToAddOnCommit 中的内容转存到 delegate 中
			delegate.putObject(entry.getKey(), entry.getValue());
		}
		for (Object entry : entriesMissedInCache) {
			if (!entriesToAddOnCommit.containsKey(entry)) {
				// 存入空值
				delegate.putObject(entry, null);
			}
		}
	}
	private void unlockMissedEntries() {
		for (Object entry : entriesMissedInCache) {
			try {
				// 调用 removeObject 进行解锁
				delegate.removeObject(entry);
			} catch (Exception e) {
				log.warn("...");
			}
		}
	}
}

存储二级缓存对象的时候是放到了TransactionalCache.entriesToAddOnCommit这个map中，但是每次查询的时候是直接从TransactionalCache.delegate中去查询的，所以这个二级缓存查询数据库后，设置缓存值是没有立刻生效的，主要是因为直接存到 delegate 会导致脏数据问题

为何只有SqlSession提交或关闭之后？

sqlSession

@Override
public void commit(boolean force) {
	try {
		// 主要是这句
		executor.commit(isCommitOrRollbackRequired(force));
		dirty = false;
	} catch (Exception e) {
		throw ExceptionFactory.wrapException("Error committing transaction.Cause: " + e, e);
	} finally {
		ErrorContext.instance().reset();
	}
}
// CachingExecutor.commit()
@Override
public void commit(boolean required) throws SQLException {
	delegate.commit(required);
	tcm.commit();// 在这里
}
// TransactionalCacheManager.commit()
public void commit() {
	for (TransactionalCache txCache : transactionalCaches.values()) {
		txCache.commit();// 在这里
	}
}
// TransactionalCache.commit()
public void commit() {
	if (clearOnCommit) {
		delegate.clear();
	}
	flushPendingEntries();//这一句
	reset();
}
// TransactionalCache.flushPendingEntries()
private void flushPendingEntries() {
	for (Map.Entry<Object, Object> entry : entriesToAddOnCommit.entrySet()) {
		// 在这里真正的将entriesToAddOnCommit的对象逐个添加到delegate中，只有这时，二级缓存才真正的生效
		delegate.putObject(entry.getKey(), entry.getValue());
	}
	for (Object entry : entriesMissedInCache) {
		if (!entriesToAddOnCommit.containsKey(entry)) {
			delegate.putObject(entry, null);
		}
	}
}

二级缓存的刷新

public int update(String statement, Object parameter) {
	int var4;
	try {
		this.dirty = true;
		MappedStatement ms = this.configuration.getMappedStatement(statement);
		var4 = this.executor.update(ms, this.wrapCollection(parameter));
	} catch (Exception var8) {
		throw ExceptionFactory.wrapException("Error updating database. Cause: "+ var8, var8);
	} finally {
		ErrorContext.instance().reset();
	}
	return var4;
}
public int update(MappedStatement ms, Object parameterObject) throws SQLException {
	this.flushCacheIfRequired(ms);
	return this.delegate.update(ms, parameterObject);
}
private void flushCacheIfRequired(MappedStatement ms) {
	//获取MappedStatement对应的Cache，进行清空
	Cache cache = ms.getCache();
	//SQL需设置flushCache="true" 才会执行清空
	if (cache != null && ms.isFlushCacheRequired()) {
		this.tcm.clear(cache);
	}
}

MyBatis二级缓存只适用于不常进行增、删、改的数据，比如国家行政区省市区街道数据。一但数据变更，MyBatis会清空缓存。因此二级缓存不适用于经常进行更新的数据。

总结

在二级缓存的设计上，MyBatis大量地运用了装饰者模式，如CachingExecutor, 以及各种Cache接口的装饰器。

二级缓存实现了Sqlsession之间的缓存数据共享，属于namespace级别
二级缓存具有丰富的缓存策略。
二级缓存可由多个装饰器，与基础缓存组合而成
二级缓存工作由一个缓存装饰执行器CachingExecutor和一个事务型预缓存TransactionalCache完成。

痛冕

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
2
评论
Mybatis源码剖析(一）

Mybatis源码剖析传统方式源码剖析：源码剖析-初始化InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");//开始初始话工作SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);build方法public SqlSessionFactory build(InputStream input
复制链接

扫一扫

专栏目录