亲宝软件园·资讯

展开

SqlSessionFactory的openSession方法

服务器端的cookie 人气:0

SqlSessionFactory的openSession方法

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

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

创建Sqlsession的地方只有一个

那就是SqlsessionFactory的openSession方法

public SqlSessionopenSession() {  
    returnopenSessionFromDataSource(configuration.getDefaultExecutorType(),null, false);  
}  

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

是openSessionFromDataSource,如下:

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 param = 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(内存当中的数据与数据库中

以上为个人经验,希望能给大家一个参考,也希望大家多多支持。

加载全部内容

相关教程
猜你喜欢
用户评论