Home >Java >javaTutorial >Analysis of Mybatis's session mechanism from the perspective of source code (details)
The content of this article is about analyzing the session mechanism of Mybatis from the perspective of source code (details). It has certain reference value. Friends in need can refer to it. I hope it will be useful to you. helped.
Zhong, who was sitting next to me, heard that I was proficient in Mybatis source code (I couldn’t figure out who leaked the news), so he asked me a question by the way: In the same method, Mybatis Do you want to create multiple SqlSession sessions when requesting the database multiple times?
Maybe I masturbated too much recently. At that time, my mind was blurry and my eyes were blurred. Although I answered him at the time: If multiple requests are in the same transaction, then multiple requests are sharing the same transaction. SqlSession, otherwise each request will create a SqlSession. This is common sense that we all take for granted in daily development, but I did not analyze it from a principle point of view to Mr. Zhong, which led to Mr. Zhong not thinking about food and drink. As an experienced driver, I felt deeply self-blame, so I secretly made up my mind Determined to give an explanation to classmate Zhong.
If you don’t agree, run a demo
Test whether each request will create a SqlSession when no transaction is added to the method:
It can be seen from the log that without adding a transaction, Mapper will indeed create a SqlSession to interact with the database every time it requests the database. Let's take a look at adding a transaction below. Situation:
As can be seen from the log, after adding the transaction in the method, only one SqlSession was created for the two requests, which once again proves my answer above, but Just answering like this does not reflect the professionalism that an experienced driver should have, so I am going to start the car.
What is SqlSession
Before starting, we must first understand, what is SqlSession?
Simply put, SqlSession is the top-level API session interface for Mybatis work. All database operations are implemented through it. Because it is a session, that is, a SqlSession should only survive in one business request. It can be said that a SqlSession corresponds to this database session. It is not permanently alive and needs to be created every time the database is accessed.
Therefore, SqlSession is not thread-safe. Each thread should have its own SqlSession instance. You must not make a SqlSession into a singleton form, or the form of static fields and instance variables will cause SqlSession to appear. Transaction problem, which is why multiple requests share a SqlSession session in the same transaction. We illustrate this from the creation process of SqlSession:
Every time a SqlSession session is created, a connection management object exclusive to the SqlSession will be created. If the SqlSession is shared, transaction problems will occur.
Analysis from the perspective of source code
Which step is the entry point for source code analysis? If you have read the source code analysis of mybatis that I wrote before, I believe you will not linger in front of the Mybatis source code and still cannot find the entrance.
As mentioned in the previous article, the implementation class of Mapper is a proxy. What actually executes the logic is MapperProxy.invoke(). This method ultimately executes sqlSessionTemplate.
org.mybatis.spring.SqlSessionTemplate:
private final SqlSession sqlSessionProxy;
public SqlSessionTemplate(SqlSessionFactory sqlSessionFactory, ExecutorType executorType,
PersistenceExceptionTranslator exceptionTranslator) {
notNull(sqlSessionFactory, "Property 'sqlSessionFactory' is required");
notNull(executorType, "Property 'executorType' is required");
this.sqlSessionFactory = sqlSessionFactory;
this.executorType = executorType;
this.exceptionTranslator = exceptionTranslator;
this.sqlSessionProxy = (SqlSession) newProxyInstance(
SqlSessionFactory.class.getClassLoader(),
new Class[] { SqlSession.class },
new SqlSessionInterceptor());
}
This is the final construction method to create SqlSessionTemplate. It can be seen that SqlSession is used in sqlSessionTemplate, which is a dynamic proxy class implemented by SqlSessionInterceptor, so we Go straight into the fortress:
private class SqlSessionInterceptor implements InvocationHandler {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
SqlSession sqlSession = getSqlSession(
SqlSessionTemplate.this.sqlSessionFactory,
SqlSessionTemplate.this.executorType,
SqlSessionTemplate.this.exceptionTranslator);
try {
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);
}
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) {
closeSqlSession(sqlSession, SqlSessionTemplate.this.sqlSessionFactory);
}
}
}
}
All methods of Mapper will eventually use this method to handle all database operations. The eyes of classmate Zhong, who is not thinking about food and rice, are blurred. He doesn’t know if he has given up on himself and masturbated too much. His eyes are empty. Ask me if there is any difference between spring integrating mybatis and using mybatis alone. In fact, there is no difference. The difference is that spring encapsulates all processing details, so you don't have to write a lot of redundant code and focus on business development.
This dynamic proxy method mainly performs the following processing:
org.mybatis.spring.SqlSessionUtils#getSqlSession：
public static SqlSession getSqlSession(SqlSessionFactory sessionFactory, ExecutorType executorType, PersistenceExceptionTranslator exceptionTranslator) {
notNull(sessionFactory, NO_SQL_SESSION_FACTORY_SPECIFIED);
notNull(executorType, NO_EXECUTOR_TYPE_SPECIFIED);
SqlSessionHolder holder = (SqlSessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);
SqlSession session = sessionHolder(executorType, holder);
if (session != null) {
return session;
}
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("Creating a new SqlSession");
}
session = sessionFactory.openSession(executorType);
registerSessionHolder(sessionFactory, executorType, exceptionTranslator, session);
return session;
}
是不是看到了不服跑个demo时看到的日志“Creating a new SqlSession”了，那么证明我直接深入的地方挺准确的，没有丝毫误差。在这个方法当中，首先是从TransactionSynchronizationManager（以下称当前线程事务管理器）获取当前线程threadLocal是否有SqlSessionHolder，如果有就从SqlSessionHolder取出当前SqlSession，如果当前线程threadLocal没有SqlSessionHolder，就从sessionFactory中创建一个SqlSession，具体的创建步骤上面已经说过了，接着注册会话到当前线程threadLocal中。
先来看看当前线程事务管理器的结构：
public abstract class TransactionSynchronizationManager {
// ...
// 存储当前线程事务资源，比如Connection、session等
private static final ThreadLocal<map>> resources =
new NamedThreadLocal("Transactional resources");
// 存储当前线程事务同步回调器
// 当有事务，该字段会被初始化，即激活当前线程事务管理器
private static final ThreadLocal<set>> synchronizations =
new NamedThreadLocal("Transaction synchronizations");
// ...
}</set></map>
这是spring的一个当前线程事务管理器，它允许将当前资源存储到当前线程ThreadLocal中，从前面也可看出SqlSessionHolder是保存在resources中。
org.mybatis.spring.SqlSessionUtils#registerSessionHolder：
private static void registerSessionHolder(SqlSessionFactory sessionFactory, ExecutorType executorType,
PersistenceExceptionTranslator exceptionTranslator, SqlSession session) {
SqlSessionHolder holder;
// 判断当前是否有事务
if (TransactionSynchronizationManager.isSynchronizationActive()) {
Environment environment = sessionFactory.getConfiguration().getEnvironment();
// 判断当前环境配置的事务管理工厂是否是SpringManagedTransactionFactory（默认）
if (environment.getTransactionFactory() instanceof SpringManagedTransactionFactory) {
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("Registering transaction synchronization for SqlSession [" + session + "]");
}
holder = new SqlSessionHolder(session, executorType, exceptionTranslator);
// 绑定当前SqlSessionHolder到线程ThreadLocal中
TransactionSynchronizationManager.bindResource(sessionFactory, holder);
// 注册SqlSession同步回调器
TransactionSynchronizationManager.registerSynchronization(new SqlSessionSynchronization(holder, sessionFactory));
holder.setSynchronizedWithTransaction(true);
// 会话使用次数+1
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");
}
}
}
注册SqlSession到当前线程事务管理器的条件首先是当前环境中有事务，否则不注册，判断是否有事务的条件是synchronizations的ThreadLocal是否为空：
public static boolean isSynchronizationActive() {
return (synchronizations.get() != null);
}
每当我们开启一个事务，会调用initSynchronization()方法进行初始化synchronizations，以激活当前线程事务管理器。
public static void initSynchronization() throws IllegalStateException {
if (isSynchronizationActive()) {
throw new IllegalStateException("Cannot activate transaction synchronization - already active");
}
logger.trace("Initializing transaction synchronization");
synchronizations.set(new LinkedHashSet<transactionsynchronization>());
}</transactionsynchronization>
所以当前有事务时，会注册SqlSession到当前线程ThreadLocal中。
Mybatis自己也实现了一个自定义的事务同步回调器SqlSessionSynchronization，在注册SqlSession的同时，也会将SqlSessionSynchronization注册到当前线程事务管理器中，它的作用是根据事务的完成状态回调来处理线程资源，即当前如果有事务，那么当每次状态发生时就会回调事务同步器，具体细节可移步至Spring的org.springframework.transaction.support包。
回到SqlSessionInterceptor代理类的逻辑，发现判断会话是否需要提交要调用以下方法：
org.mybatis.spring.SqlSessionUtils#isSqlSessionTransactional：
public static boolean isSqlSessionTransactional(SqlSession session, SqlSessionFactory sessionFactory) {
notNull(session, NO_SQL_SESSION_SPECIFIED);
notNull(sessionFactory, NO_SQL_SESSION_FACTORY_SPECIFIED);
SqlSessionHolder holder = (SqlSessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);
return (holder != null) && (holder.getSqlSession() == session);
}
取决于当前SqlSession是否为空并且判断当前SqlSession是否与ThreadLocal中的SqlSession相等，前面也分析了，如果当前没有事务，SqlSession是不会保存到事务同步管理器的，即没有事务，会话提交。
org.mybatis.spring.SqlSessionUtils#closeSqlSession：
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)) {
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("Releasing transactional SqlSession [" + session + "]");
}
holder.released();
} else {
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("Closing non transactional SqlSession [" + session + "]");
}
session.close();
}
}
方法无论执行结果如何都需要执行关闭会话逻辑，这里的判断也是判断当前是否有事务，如果SqlSession在事务当中，则减少引用次数，没有真实关闭会话。如果当前会话不存在事务，则直接关闭会话。
写在最后
虽说钟同学问了我一个Mybatis的问题，我却中了Spring的圈套，猛然发现整个事务链路都处在Spring的管控当中，这里涉及到了Spring的自定义事务的一些机制，其中当前线程事务管理器是整个事务的核心与中轴，当前有事务时，会初始化当前线程事务管理器的synchronizations，即激活了当前线程同步管理器，当Mybatis访问数据库会首先从当前线程事务管理器获取SqlSession，如果不存在就会创建一个会话，接着注册会话到当前线程事务管理器中，如果当前有事务，则会话不关闭也不commit，Mybatis还自定义了一个TransactionSynchronization，用于事务每次状态发生时回调处理。
本篇文章到这里就已经全部结束了，更多其他精彩内容可以关注PHP中文网的Java教程视频栏目！
The above is the detailed content of Analysis of Mybatis's session mechanism from the perspective of source code (details). For more information, please follow other related articles on the PHP Chinese website!