Mybatis工作机制源码分析—一次insert请求处理流程

      本文从源码分析的角度分析Mybatis一次insert请求处理流程。

insert整体处理流程

时序图

相关源码

/** SqlSessionTemplate.java */
public int insert(String statement, Object parameter) {
	return this.sqlSessionProxy.insert(statement, parameter);
}

// jdk动态代理
private class SqlSessionInterceptor implements InvocationHandler {
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		// 获取SqlSession
		SqlSession sqlSession = getSqlSession(
			SqlSessionTemplate.this.sqlSessionFactory,
			SqlSessionTemplate.this.executorType,
			SqlSessionTemplate.this.exceptionTranslator);
		try {
			// 请求（select|insert|update|delete）处理，这里采用动态代理
			Object result = method.invoke(sqlSession, args);
			if (!isSqlSessionTransactional(sqlSession, SqlSessionTemplate.this.sqlSessionFactory)) {
			  // force commit even on non-dirty sessions because some databases require
			  // a commit/rollback before calling close()
			  sqlSession.commit(true); // 非Spring管理的事务，手工提交
			}
			return result;
		} catch (Throwable t) {
			Throwable unwrapped = unwrapThrowable(t);
			if (SqlSessionTemplate.this.exceptionTranslator != null && unwrapped instanceof PersistenceException) {
			  // release the connection to avoid a deadlock if the translator is no loaded. See issue #22
			  closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);
			  sqlSession = null;
			  Throwable translated = SqlSessionTemplate.this.exceptionTranslator.translateExceptionIfPossible((PersistenceException) unwrapped);
			  if (translated != null) {
				unwrapped = translated;
			  }
			}
			throw unwrapped;
		} finally {
			if (sqlSession != null) {
			  // 请求处理完成后，sqlSession释放或保留
			  closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);
			}
		}
	}
}

// 对使用后的SqlSession进行相关处理
public static void closeSqlSession(SqlSession session, SqlSessionFactory sessionFactory) {
	notNull(session, NO_SQL_SESSION_SPECIFIED);
	notNull(sessionFactory, NO_SQL_SESSION_FACTORY_SPECIFIED);

	SqlSessionHolder holder = (SqlSessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);
	if ((holder != null) && (holder.getSqlSession() == session)) {
	  // Spring Transactional下的SqlSession，不真正关闭sqlSession
	  if (LOGGER.isDebugEnabled()) {
		LOGGER.debug("Releasing transactional SqlSession [" + session + "]");
	  }
	  // 只进行sqlSessionHolder的referenceCount--
	  holder.released();
	} else {
	  if (LOGGER.isDebugEnabled()) {
		LOGGER.debug("Closing non transactional SqlSession [" + session + "]");
	  }
	  // 非Spring Transactional下的SqlSession，则SqlSession——>Executor——>Transaction——>DataSource——>Connection的close操作
	  session.close();
	}
}

SqlSessionUtils.getSqlSession工作流程

时序图

相关类结构图

SqlSession类结构图：

Executor类结构图：

Transaction类结构图：

SqlSession构建过程中的组件支持

相关源码

/** SqlSessionUtils.java */
public static SqlSession getSqlSession(SqlSessionFactory sessionFactory, ExecutorType executorType, PersistenceExceptionTranslator exceptionTranslator) {

	notNull(sessionFactory, NO_SQL_SESSION_FACTORY_SPECIFIED);
	notNull(executorType, NO_EXECUTOR_TYPE_SPECIFIED);
	
	// 先从TransactionSynchronizationManager的事务资源缓存resources获取sessionFactory对应的SqlSessionHolder
	SqlSessionHolder holder = (SqlSessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);

	// 从SqlSessionHolder中提取SqlSession
	SqlSession session = sessionHolder(executorType, holder);
	if (session != null) {
	  return session;
	}

	if (LOGGER.isDebugEnabled()) {
	  LOGGER.debug("Creating a new SqlSession");
	}

	// 打开新的SqlSession
	session = sessionFactory.openSession(executorType);

	// SpringManagedTransactionFactory下，缓存sessionHolder，进行Transaction synchronizations准备工作
	registerSessionHolder(sessionFactory, executorType, exceptionTranslator, session);

	return session;
}

// 从SqlSessionHolder中提取SqlSession，与Spring事务同步条件下才能提取
private static SqlSession sessionHolder(ExecutorType executorType, SqlSessionHolder holder) {
	SqlSession session = null;
	if (holder != null && holder.isSynchronizedWithTransaction()) { // sqlSessionHolder与Spring事务同步
	  if (holder.getExecutorType() != executorType) {
		throw new TransientDataAccessResourceException("Cannot change the ExecutorType when there is an existing transaction");
	  }

	  holder.requested(); // 引用次数加1

	  if (LOGGER.isDebugEnabled()) {
		LOGGER.debug("Fetched SqlSession [" + holder.getSqlSession() + "] from current transaction");
	  }

	  session = holder.getSqlSession(); // 获取sqlSession
	}
	return session;
}

/** TransactionSynchronizationManager.java */
public static Object getResource(Object key) {
	Object actualKey = TransactionSynchronizationUtils.unwrapResourceIfNecessary(key);
	Object value = doGetResource(actualKey);
	if (value != null && logger.isTraceEnabled()) {
		logger.trace("Retrieved value [" + value + "] for key [" + actualKey + "] bound to thread [" +
				Thread.currentThread().getName() + "]");
	}
	return value;
}

// 从TransactionSynchronizationManager的事务资源缓存ThreadLocal> resources获取actualKey对应的资源
// ThreadLocal模式，线程安全
private static Object doGetResource(Object actualKey) {
	Map map = resources.get();
	if (map == null) {
		return null;
	}
	Object value = map.get(actualKey);
	// Transparently remove ResourceHolder that was marked as void...
	if (value instanceof ResourceHolder && ((ResourceHolder) value).isVoid()) {
		map.remove(actualKey);
		// Remove entire ThreadLocal if empty...
		if (map.isEmpty()) {
			resources.remove();
		}
		value = null;
	}
	return value;
}

/** DefaultSqlSessionFactory.java */
public SqlSession openSession(ExecutorType execType) {
	return openSessionFromDataSource(execType, null, false);
}

private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
	Transaction tx = null;
	try {
	  // configuration属性获取environment
	  final Environment environment = configuration.getEnvironment();
	  // 从environment获取transactionFactory
	  final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
	  // 打开新transaction，基于environment的dataSource
	  tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
	  // 基于transaction、execType实例化executor
	  final Executor executor = configuration.newExecutor(tx, execType);
	  // 基于configuration、executor创建DefaultSqlSession
	  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();
	}
}

// environment获取TransactionFactory
private TransactionFactory getTransactionFactoryFromEnvironment(Environment environment) {
	if (environment == null || environment.getTransactionFactory() == null) {
	  // 默认为ManagedTransactionFactory
	  return new ManagedTransactionFactory();
	}
	return environment.getTransactionFactory();
}

/** SpringManagedTransactionFactory.java */
// Spring容器管理下的transaction
public Transaction newTransaction(DataSource dataSource, TransactionIsolationLevel level, boolean autoCommit) {
	return new SpringManagedTransaction(dataSource);
}

/** Configuration.java */
public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
	executorType = executorType == null ? defaultExecutorType : executorType;
	executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
	Executor executor;
	if (ExecutorType.BATCH == executorType) {
	  executor = new BatchExecutor(this, transaction);
	} else if (ExecutorType.REUSE == executorType) {
	  executor = new ReuseExecutor(this, transaction);
	} else {
	  executor = new SimpleExecutor(this, transaction);
	}
	if (cacheEnabled) {
	  executor = new CachingExecutor(executor);
	}
	executor = (Executor) interceptorChain.pluginAll(executor);
	return executor;
}

/** SqlSessionUtils.java */
// 对于SpringManagedTransactionFactory，构建SqlSessionHolder，将其缓存到Transactional resources，且进行Transaction synchronizations标识
// 以便Spring容器进行事务管理
private static void registerSessionHolder(SqlSessionFactory sessionFactory, ExecutorType executorType,
  PersistenceExceptionTranslator exceptionTranslator, SqlSession session) {
	SqlSessionHolder holder;
	if (TransactionSynchronizationManager.isSynchronizationActive()) { // Transaction synchronizations至少已经初始化
	  Environment environment = sessionFactory.getConfiguration().getEnvironment();

	  // SpringManagedTransactionFactory才进行register SessionHolder工作
	  if (environment.getTransactionFactory() instanceof SpringManagedTransactionFactory) {
		if (LOGGER.isDebugEnabled()) {
		  LOGGER.debug("Registering transaction synchronization for SqlSession [" + session + "]");
		}
		
		// 构建SqlSessionHolder
		holder = new SqlSessionHolder(session, executorType, exceptionTranslator);
		// Transactional resources添加sessionFactory、holder键值对，resources为ThreadLocal>
		TransactionSynchronizationManager.bindResource(sessionFactory, holder);
		// Transaction synchronizations添加SqlSessionSynchronization，synchronizations为ThreadLocal>
		TransactionSynchronizationManager.registerSynchronization(new SqlSessionSynchronization(holder, sessionFactory));
		holder.setSynchronizedWithTransaction(true); // holder标识synchronizedWithTransaction为true
		holder.requested();
	  } else {
		if (TransactionSynchronizationManager.getResource(environment.getDataSource()) == null) {
		  if (LOGGER.isDebugEnabled()) {
			LOGGER.debug("SqlSession [" + session + "] was not registered for synchronization because DataSource is not transactional");
		  }
		} else {
		  throw new TransientDataAccessResourceException(
			  "SqlSessionFactory must be using a SpringManagedTransactionFactory in order to use Spring transaction synchronization");
		}
	  }
	} else {
	  if (LOGGER.isDebugEnabled()) {
		LOGGER.debug("SqlSession [" + session + "] was not registered for synchronization because synchronization is not active");
	  }
	}
}

DefaultSqlSession.insert工作流程

时序图

相关类结构图

ObjectWrapper类结构图：

相关Handler类结构图：

TypeHandler类结构图：

Mybatis一次请求处理核心流程（select|insert|update|delete）

相关源码

/** DefaultSqlSession.java */
// 处理insert请求
// @param statement：statement id；@param parameter：输入参数
public int insert(String statement, Object parameter) {
	// 转给update进行处理
	return update(statement, parameter);
}

// 处理sql写的请求，包括insert、update、delete
public int update(String statement, Object parameter) {
	try {
	  dirty = true;
	  // 根据id获取MappedStatement
	  MappedStatement ms = configuration.getMappedStatement(statement);
	  // 
	  return executor.update(ms, wrapCollection(parameter));
	} catch (Exception e) {
	  throw ExceptionFactory.wrapException("Error updating database.  Cause: " + e, e);
	} finally {
	  ErrorContext.instance().reset();
	}
}

/** Configuration.java */
// 从configuration Map mappedStatements，根据获取id获取MappedStatement；
public MappedStatement getMappedStatement(String id) {
	return this.getMappedStatement(id, true);
}

public MappedStatement getMappedStatement(String id, boolean validateIncompleteStatements) {
	if (validateIncompleteStatements) {
	  buildAllStatements();
	}
	return mappedStatements.get(id);
}

// 解析缓存中未处理的statement nodes，提供fail-fast statement验证
protected void buildAllStatements() {
	if (!incompleteResultMaps.isEmpty()) {
	  synchronized (incompleteResultMaps) {
		// This always throws a BuilderException.
		incompleteResultMaps.iterator().next().resolve();
	  }
	}
	if (!incompleteCacheRefs.isEmpty()) {
	  synchronized (incompleteCacheRefs) {
		// This always throws a BuilderException.
		incompleteCacheRefs.iterator().next().resolveCacheRef();
	  }
	}
	if (!incompleteStatements.isEmpty()) {
	  synchronized (incompleteStatements) {
		// This always throws a BuilderException.
		incompleteStatements.iterator().next().parseStatementNode();
	  }
	}
	if (!incompleteMethods.isEmpty()) {
	  synchronized (incompleteMethods) {
		// This always throws a BuilderException.
		incompleteMethods.iterator().next().resolve();
	  }
	}
}

/** DefaultSqlSession.java */
// 对Collection、List、Array进行StrictMap的wrap处理
private Object wrapCollection(final Object object) {
	if (object instanceof Collection) {
	  StrictMap