sqlsession、sqlsessionManager以及sqlsessionTemplate的理解
sqlSession
是mybatis的核心操作类，其中对数据库的crud都封装在这个中，是一个顶级接口，其中默认实现类是DefaultSqlSession这个类，
为什么说DefaultSqlsession不是线程安全的？
首先我们都知道mybatis在底层都是使用的JDBC，而JDBC这本来就是线程不安全的(连接对象Connection只有一个)，所以我们只要关注session和connnect的关系就好了
首先是一段最普通的mybatis生成sqlSession的代码:
SqlSession session = null;
String resource = "configuration.xml";
// 使用io流读取配置
InputStream inputStream;
inputStream = Resources.getResourceAsStream(resource);
//这里是解析配置文件
sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
// 得到了一个会话，有了这个会话，你就可以对数据进行增，删，改，查的操作
session = sqlSessionFactory.openSession();
在此时sqlsessionFactory打开(创建了一个sqlsession会话)，下面我们来看看这个session是怎么产生的:
//这个是org.apache.ibatis.session.defaults.DefaultSqlSessionFactory
@Override
public SqlSession openSession() {
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();
//开始创建事物
final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
//将事物传递给执行器Executor，这个是session执行数据库操作的核心(有三种执行器类型)
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();
}
}
最后sqlsession执行都是通过执行器执行的，默认执行器是SimpleExecutor，她通过连接Connection这个类创建了Statement这个JDBC要用到的对象，开始走JDBC的流程：
//查询方法
@Override
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 handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
// 这里创建statement对象,这个方法中就用到了Connection连接对象，此时我们主要看这个方法中Connection的创建时怎么样的
stmt = prepareStatement(handler, ms.getStatementLog());
return handler.query(stmt, resultHandler);
} finally {
closeStatement(stmt);
}
}
prepareStatement(handler, ms.getStatementLog())方法解析(重点看Connection他是怎么拿的)
private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
Statement stmt;
// 看下面的方法，此时只需要看这个方法
Connection connection = getConnection(statementLog);
stmt = handler.prepare(connection, transaction.getTimeout());
handler.parameterize(stmt);
return stmt;
}
//由这个方法可以看出，具体实现是transaction.getConnection();
protected Connection getConnection(Log statementLog) throws SQLException {
// 这里最终同通过创建Executor时传入的transcation进行了连接获取
Connection connection = transaction.getConnection();
if (statementLog.isDebugEnabled()) {
return ConnectionLogger.newInstance(connection, statementLog, queryStack);
} else {
return connection;
}
}
继续看transaction.getConnection();
//可以看出他只会产生一个连接
@Override
public Connection getConnection() throws SQLException {
// 这里只要有连接了就不重新打开连接了（从数据源中再次获取），说明只能有一个连接在一个org.apache.ibatis.transaction.Transaction中
if (connection == null) {
openConnection();
}
return connection;
}
最终可以看出一次SqlSession的执行最终只会产生一个connection，所以我们设想一下，在两个线程通过同一个sqlsession来执行crud，那么就有可能，我先跑完的线程，把唯一的这一个连接给关闭掉，从而造成另一条线程的逻辑不被成功执行，所以通过DefaultSqlSession来执行数据库操作是线程不安全的。
sqlsessionTemplate
为什么说sqlsessionTemplate是线程安全的？
public class SqlSessionTemplate implements SqlSession, DisposableBean {
private final SqlSessionFactory sqlSessionFactory;
private final ExecutorType executorType;
private final SqlSession sqlSessionProxy;
private final PersistenceExceptionTranslator exceptionTranslator;
private final PersistenceExceptionTranslator exceptionTranslator;
public SqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
this(sqlSessionFactory, sqlSessionFactory.getConfiguration().getDefaultExecutorType());
}
..........
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());
}
}
从这个构造方法可以看出，sqlsessionTemplate传参是必须需要一个sqlsessionfactory的，sqlsessionTemplate在执行crud操作时，都不是通过唯一的一个sqlsession来执行的，他都是通过动态代理来执行具体的操作的，所以多个线程持有同一个sqlsessionTemplate是不会产生线程安全问题的。
sqlSessionManager
首先我们来看看这个类实现的接口
public class SqlSessionManager implements SqlSessionFactory, SqlSession {
private final SqlSessionFactory sqlSessionFactory;
private final SqlSession sqlSessionProxy;
private final ThreadLocal<SqlSession> localSqlSession = new ThreadLocal<>();
private SqlSessionManager(SqlSessionFactory sqlSessionFactory) {
this.sqlSessionFactory = sqlSessionFactory;
this.sqlSessionProxy = (SqlSession) Proxy.newProxyInstance(
SqlSessionFactory.class.getClassLoader(),
new Class[]{SqlSession.class},
new SqlSessionInterceptor());
}
.....
public static SqlSessionManager newInstance(Reader reader) {
return new SqlSessionManager(new SqlSessionFactoryBuilder().build(reader, null, null));
}
public static SqlSessionManager newInstance(Reader reader, String environment) {
return new SqlSessionManager(new SqlSessionFactoryBuilder().build(reader, environment, null));
}
public static SqlSessionManager newInstance(Reader reader, Properties properties) {
return new SqlSessionManager(new SqlSessionFactoryBuilder().build(reader, null, properties));
}
}
可以看出他的一个必要的参数也是sqlsessionFactory，SqlSessionManager既实现了SqlSessionFactory，也实现了SqlSession，具备生产SqlSession的能力，也具备SqlSession的能力，SqlSession的作用是执行具体的Sql语句。
sqlsessionManager他把构造方法私有化了，想要创建一个sqlsessionManager对象，你只能调用newInstance()来创建一个SqlsessionManager对象，下面来看连接对象Connection他是怎么获取的
public Connection getConnection() {
SqlSession sqlSession = (SqlSession)this.localSqlSession.get();
if (sqlSession == null) {
throw new SqlSessionException("Error: Cannot get connection. No managed session is started.");
} else {
return sqlSession.getConnection();
}
}
首先我解释一下localSqlSession，这个属性其实就是一个ThreadLocal类，可以为每一个线程分配一个副本对象，来保证线程安全。
从这个方法我们可以看出每个线程都会被分配一个对应的对象副本，而且这个是保证了Connection对象线程的安全性，下面我们来看看具体执行是什么样子的：
private SqlSessionManager(SqlSessionFactory sqlSessionFactory) {
this.sqlSessionFactory = sqlSessionFactory;
this.sqlSessionProxy = (SqlSession)Proxy.newProxyInstance(SqlSessionFactory.class.getClassLoader(), new Class[]{SqlSession.class}, new SqlSessionManager.SqlSessionInterceptor());
}
public <K, V> Map<K, V> selectMap(String statement, Object parameter, String mapKey, RowBounds rowBounds) {
return this.sqlSessionProxy.selectMap(statement, parameter, mapKey, rowBounds);
}
public <T> Cursor<T> selectCursor(String statement) {
return this.sqlSessionProxy.selectCursor(statement);
}
public <T> Cursor<T> selectCursor(String statement, Object parameter) {
return this.sqlSessionProxy.selectCursor(statement, parameter);
}
眼熟吧，标准的代理模式，和sqlsessionTemplate类似，具体操作数据库的都是通过产生的动态代理对象去执行的。
测试
@Component
public class TestSqlSessionManager {
@Autowired
private SqlSessionTemplate sqlSessionTemplate;
// @Autowired
// private SqlSessionFactory sqlSessionFactory;//这个是一个接口，别想多了你
@Autowired
private SqlSessionManager sqlSessionManager;
private static ApplicationContext context;
private static String namespace = "com.swjd.dao.DashboardDao";
static {
TestSqlSessionManager.context = new ClassPathXmlApplicationContext(
"spring/applicationContext-dao.xml","spring/applicationContext-service.xml",
"spring/applicaitonContext-transaction.xml");
}
@Test
public void bTest(){
//三个类
SqlSessionTemplate sqlSessionTemplate = context.getBean(SqlSessionTemplate.class);
SqlSessionFactory sqlSessionFactory = sqlSessionTemplate.getSqlSessionFactory();
SqlSessionManager sqlSessionManager = context.getBean(SqlSessionManager.class);
List<Object> list = sqlSessionTemplate.selectList(namespace + ".selectByExample");
// SqlSession sqlSession = sqlSessionManager.openSession();
// List<Object> objects = sqlSession.selectList(namespace + ".selectByExample");
//使用多线程测试
//测试sqlsessionFactory
for (int i=0;i<4;i++){
int index = i;
Thread thread=new Thread(() ->{
try {
Class<? extends SqlSessionTemplate> aClass = sqlSessionTemplate.getClass();
Field sqlSessionProxy = aClass.getDeclaredField("sqlSessionProxy");
sqlSessionProxy.setAccessible(true);
Object o1 = sqlSessionProxy.get(sqlSessionTemplate);
System.out.println("A第"+ index +"个===================="+o1.hashCode());
} catch (Exception e) {
e.printStackTrace();
}
List<Object> objects = sqlSessionTemplate.selectList(namespace + ".selectByExample");
});
thread.start();
}
//测试sqlsessionManager
for (int i=0;i<4;i++){
int index = i;
Thread thread=new Thread(() ->{
SqlSession sqlSession = sqlSessionManager.openSession();
try {
Class<? extends SqlSessionManager> aClass = sqlSessionManager.getClass();
Field sqlSessionProxy = aClass.getDeclaredField("sqlSessionProxy");
sqlSessionProxy.setAccessible(true);
Object o2 = sqlSessionProxy.get(sqlSessionManager);
System.out.println("B第"+ index +"个===================="+o2.hashCode());
} catch (Exception e) {
e.printStackTrace();
}
List<Object> objects = sqlSessionManager.selectList(namespace + ".selectByExample");
});
thread.start();
}
}
}
测试结果如图：
总结
- DefaultSqlSession的内部没有提供像SqlSessionManager一样通过ThreadLocal的方式来保证线程的安全性；
- SqlSessionManager是通过localSqlSession这个ThreadLocal变量，记录与当前线程绑定的SqlSession对象，供当前线程循环使用，从而避免在同一个线程多次创建SqlSession对象造成的性能损耗；
- DefaultSqlSession不是线程安全的，我们在进行原生开发的时候想要达到线程安全的话，那就需要每次为一个操作都创建一个SqlSession对象，其性能可想而知
疑惑
JDK动态代理创建的对象会占用内存吗？如果会占用内存的话，那么创建动态代理对象也会是一个吃内存的操作，那么在内存方面，sqlsessionTemplate和sqlsessionManager都会是特别不友好的。
