基于SqlSessionFactory的openSession方法使用

基于SqlSessionFactory的openSession方法使用

目录SqlSessionFactory的openSession方法创建Sqlsession的地方只有一个我们可以看到实际创建SqlSession的地方Executor的创建MapperMapperProxy的invokeopenSession()到底做了什么

SqlSessionFactory的openSession方法

正如其名，Sqlsession对应着一次数据库会话。

由于数据库回话不是永久的，因此Sqlsession的生命周期也不应该是永久的，相反，在你每次访问数据库时都需要创建它（当然并不是说在Sqlsession里只能执行一次sql，你可以执行多次，当一旦关闭了Sqlsession就需要重新创建它）。

创建Sqlsession的地方只有一个

那就是SqlsessionFactory的openSession方法

public SqlSessionopenSession() {

returFAXyUcYInopenSessionFromDataSource(configuration.getDefaultExecutorType(),null, false);

}

我们可以看到实际创建SqlSession的地方

是openSes

sionFromDataSource，如下：

private SqlSessionopenSessionFromDataSource(ExecutorType execType, TransactionIsolationLevellevel, boolean autoCommit) {

Connectionconnection = null;

try {

finalEnvironment environment = configuration.getEnvironment();

final DataSourcedataSource = getDataSourceFromEnvironment(environment);

TransactionFactory transactionFactory =getTransactionFactoryFromEnvironment(environment);

connection = dataSource.getConnection();

if (level != null) {

connection.setTransactionIsolation(level.getLevel());

}

connection = wrapConnection(connection);

Transaction tx = transactionFactory.newTransaction(connection,autoCommit);

Executorexecutor = configuration.newExecutor(tx, execType);

returnnewDefaultSqlSession(configuration, executor, autoCommit);

} catch (Exceptione) {

closeConnection(connection);

throwExceptionFactory.wrapException("Error opening session. Cause: " + e, e);

} finally {

ErrorContext.instance().reset();

}

}

可以看出，创建sqlsession经过了以下几个主要步骤：

1) 从配置中获取Environment；

2) 从Environment中取得DataSource；

3) 从Environment中取得TransactionFactory；

4) 从DataSource里获取数据库连接对象Connection；

5) 在取得的数据库连接上创建事务对象Transaction；

6) 创建Executor对象（该对象非常重要，事实上sqlsession的所有操作都是通过它完成的）；

7) 创建sqlsession对象。

Executor的创建

Executor与Sqlsession的关系就像市长与书记，Sqlsession只是个门面，真正干事的是Executor，Sqlsession对数据库的操作都是通过Executor来完成的。与Sqlsession一样，Executor也是动态创建的：

public ExecutornewExecutor(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);

} elseif(ExecutorType.REUSE == executorType) {

executor = new ReuseExecutor(this,transaction);

} else {

executor = newSimpleExecutor(this, transaction);

}

if (cacheEnabled) {

executor = new CachingExecutor(executor);

}

executor =(Executor) interceptorChain.pluginAll(executor);

return executor;

}

可以看出，如果不开启cache的话，创建的Executor只是3中基础类型之一，BatchExecutor专门用于执行批量sql操作，ReuseExecutor会重用statement执行sql操作，SimpleExecutor只是简单执行sql没有什么特别的。开启cache的话（默认是开启的并且没有任何理由去关闭它），就会创建CachingExecutor，它以前面创建的Executor作为唯一参数。CachingExecutor在查询数据库前先查找缓存，若没找到的话调用delegate（就是构造时传入的Executor对象）从数据库查询，并将查询结果存入缓存中。

Executor对象是可以被插件拦截的，如果定义了针对Executor类型的插件，最终生成的Executor对象是被各个插件插入后的代理对象

Mapper

Mybatis官方手册建议通过mapper对象访问mybatis，因为使用mapper看起来更优雅，就像下面这样：

session = sqlSessionFactory.openSession();

UserDao userDao= session.getMapper(UserDao.class);

UserDto user =new UserDto();

user.setUsername("iMbatis");

user.setPassword("iMbatis");

userDao.insertUser(user);

看起来没什么特别的，和其他代理类的创建一样，我们重点关注一下MapperProxy的invoke方法

MapperProxy的invoke

我们知道对被代理对象的方法的访问都会落实到代理者的invoke上来，MapperProxy的invoke如下：

public Objectinvoke(Object proxy, Method method, Object[] args) throws Throwable{

if (method.getDeclaringClass()== Object.class) {

return method.invoke(this, args);

}

finalClass> declaringInterface = findDeclaringInterface(proxy, method);

finalMapperMethod mapperMethod = newMapperMethod(declaringInterface, method, sqlSession);

final Objectresult = mapperMethod.execute(args);

if (result ==null && method.getReturnType().isPrimitive()&& !method.getReturnType().equals(Void.TYPE)) {

thrownewBindingException("Mapper method '" + method.getName() + "'(" + method.getDeclaringClass()

+ ") attempted toreturn null from a method with a primitive return type ("

+ method.getReturnType() + ").");

}

return result;

}

可以看到invoke把执行权转交给了MapperMethod，我们来看看MapperMethod里又是怎么运作的：

public Objectexecute(Object[] args) {

Objectresult = null;

if(SqlCommandType.INSERT == type) {

Objectparam = getParam(args);

result= sqlSession.insert(commandName, param);

} elseif(SqlCommandType.UPDATE == type) {

Object param = getParam(args);

result= sqlSession.update(commandName, param);

} elseif(SqlCommandType.DELETE == type) {

Objectparam = getParam(args);

result= sqlSession.delete(commandName, param);

} elseif(SqlCommandType.SELECT == type) {

if (returnsVoid &&resultHandlerIndex != null) {

executeWithResultHandler(args);

} elseif (returnsList) {

result = executeForList(args);

} elseif (returnsMap) {

result = executeForMap(args);

} else {

Object FAXyUcYIparam = getParam(args);

result = sqlSession.selectOne(commandName, param);

}

} else {

thrownewBindingException("Unknown execution method for: " + commandName);

}

return result;

}

可以看到， MapperMethod 就像是一个分发者，他根据参数和返回值类型选择不同的 sqlsession 方法来执行。这样 mapper 对象与 sqlsession 就真正的关联起来了

openSession()到底做了什么

从环境中获取事务的工厂，返回一个environment对象获取事务工厂

事务工厂创建事务

通过configuration拿到一个执行器传入事务(Transaction)和类型(execType(枚举))

最后返回一个DefaultSqlSession

openSession底层就是做各种成员变量的初始化

例如：configuration，executor，dirty(内存当中的数据与数据库中

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。