总体三部分，创建sessionfactory，创建session，执行sql获取结果
1，创建sessionfactory
这里其实主要做的事情就是将xml的所有配置信息转换成一个Configuration对象，然后用这个对象组装成factory返回。
//mybatis配置文件
String resource = "conf.xml"; InputStream is = TestMybatis.class.getClassLoader().getResourceAsStream(resource); SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(is);
1，xml转换成Configuration对象
根据方法找到源码，这里可以多接受两个参数，一会有用到
public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) { try {
//environment表示要使用哪个db，properties 表示资源信息 XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
return build(parser.parse()); } catch (Exception e) { throw ExceptionFactory.wrapException("Error building SqlSession.", e); } finally { ErrorContext.instance().reset(); try { inputStream.close(); } catch (IOException e) { // Intentionally ignore. Prefer previous error. } } }
继续往里找源码，找到这里，这里就是将xml中所有配置信息转换成对象的具体方法了
//将xml中的所有节点都解析成对象信息
private void parseConfiguration(XNode root) { try { propertiesElement(root.evalNode("properties")); //issue #117 read properties first typeAliasesElement(root.evalNode("typeAliases")); pluginElement(root.evalNode("plugins")); objectFactoryElement(root.evalNode("objectFactory")); objectWrapperFactoryElement(root.evalNode("objectWrapperFactory")); settingsElement(root.evalNode("settings")); environmentsElement(root.evalNode("environments")); // read it after objectFactory and objectWrapperFactory issue #631 databaseIdProviderElement(root.evalNode("databaseIdProvider")); typeHandlerElement(root.evalNode("typeHandlers")); mapperElement(root.evalNode("mappers")); } catch (Exception e) { throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e); } }
主要看三个吧
properties的转换，从这里的逻辑可以看出来资源信息的加载顺序，在之前的章节里有说过。
private void propertiesElement(XNode context) throws Exception { if (context != null) {
//获取xml里面设置的 Properties defaults = context.getChildrenAsProperties();
//获取指定的资源文件里的 String resource = context.getStringAttribute("resource"); String url = context.getStringAttribute("url"); if (resource != null && url != null) { throw new BuilderException("The properties element cannot specify both a URL and a resource based property file reference. Please specify one or the other."); }
//覆盖掉了xml里配置的 if (resource != null) { defaults.putAll(Resources.getResourceAsProperties(resource)); } else if (url != null) { defaults.putAll(Resources.getUrlAsProperties(url)); } Properties vars = configuration.getVariables();
//覆盖掉了上面的 if (vars != null) { defaults.putAll(vars); } parser.setVariables(defaults); configuration.setVariables(defaults); } }
environments的转换，这里首先会看是否传进来了一个id，如果么有，那么用默认的。
private void environmentsElement(XNode context) throws Exception { if (context != null) {
//如果没有指定，那么直接使用默认的 if (environment == null) { environment = context.getStringAttribute("default"); } for (XNode child : context.getChildren()) { String id = child.getStringAttribute("id"); if (isSpecifiedEnvironment(id)) {
//获取事物factory TransactionFactory txFactory = transactionManagerElement(child.evalNode("transactionManager"));
//获取datasourcefactory DataSourceFactory dsFactory = dataSourceElement(child.evalNode("dataSource"));
DataSource dataSource = dsFactory.getDataSource(); Environment.Builder environmentBuilder = new Environment.Builder(id) .transactionFactory(txFactory) .dataSource(dataSource); configuration.setEnvironment(environmentBuilder.build()); } } } }
其次，获取事物factory的时候，会根据配置的transactionManager属性来获取看是用JdbcTransactionFactory还是ManagedTransactionFactory，这里会涉及到事物的一些处理机制，两种类处理方法不一样的。
private TransactionFactory transactionManagerElement(XNode context) throws Exception { if (context != null) {
//根据type来决定要实例化哪个factory出来 String type = context.getStringAttribute("type"); Properties props = context.getChildrenAsProperties(); TransactionFactory factory = (TransactionFactory) resolveClass(type).newInstance(); factory.setProperties(props); return factory; } throw new BuilderException("Environment declaration requires a TransactionFactory."); }
再次，获取datasourcefactory的时候，会根据配置的dataSource属性来看是使用UnpooledDataSourceFactory 还是pooledDataSourceFactory ，还是JndiDataSourceFactory。这里会涉及到数据源的获取方式，是连接池，还是单次链接，还是jndi。
private DataSourceFactory dataSourceElement(XNode context) throws Exception { if (context != null) {
//根据type来决定实例化哪个factory String type = context.getStringAttribute("type"); Properties props = context.getChildrenAsProperties(); DataSourceFactory factory = (DataSourceFactory) resolveClass(type).newInstance(); factory.setProperties(props); return factory; } throw new BuilderException("Environment declaration requires a DataSourceFactory."); }
最重要的是mappers的转换，这里的方法就把所有的sql语句就转换过来了，将来要找的话，也是这里的源泉。
2，将这个转换好的configuration对象组装成一个DefaultSqlSessionFactory，就可以供外部使用了。
//返回sessionfactory public SqlSessionFactory build(Configuration config) { return new DefaultSqlSessionFactory(config); }
2，创建sqlsession
1，首先从confinguration对象中，找到对应的事物factory，这里有两种facroty。
一种JdbcTransactionFactory，直观地讲，就是JdbcTransaction是使用的java.sql.Connection 上的commit和rollback功能，JdbcTransaction只 是相当于对java.sql.Connection事务处理进行了一次包装（wrapper），Transaction的事务管理都是通过java.sql.Connection实现的。
public void commit() throws SQLException { if (connection != null && !connection.getAutoCommit()) { if (log.isDebugEnabled()) { log.debug("Committing JDBC Connection [" + connection + "]"); }
//这里就是直接使用的jdbc的提交 connection.commit(); } } public void rollback() throws SQLException { if (connection != null && !connection.getAutoCommit()) { if (log.isDebugEnabled()) { log.debug("Rolling back JDBC Connection [" + connection + "]"); }
//这里就是直接使用的jdbc的回滚
connection.rollback(); } }
一种是ManagedTransactionFactory， ManagedTransaction让容器来管理事务Transaction的整个生命周期，意思就是说，使用ManagedTransaction的commit和rollback功能不会对事务有任何的影响，它什么都不会做，它将事务管理的权利移交给了容器来实现。
//提交和回滚什么都不做，让别人来管理
public void commit() throws SQLException { // Does nothing } public void rollback() throws SQLException { // Does nothing }
2，然后从configuration中获取到对应的datasource，这里就可能有三种了
一种是UnpooledDataSourceFactory，这种的话，每次调用都会产生一次连接。耗费资源。
private Connection doGetConnection(Properties properties) throws SQLException {
//初始化驱动 initializeDriver();
//jdbc直接获取一个连接 Connection connection = DriverManager.getConnection(url, properties); configureConnection(connection); return connection; }
一种是pooledDataSourceFactory，这种的话，会有一个连接池的东西在里面，使用的时候每次就从连接池里用就行，
//方法内容过多，可以自己去看 这里是从一个集合中pop出来一个连接直接使用。
private PooledConnection popConnection(String username, String password) throws SQLException {
一种是JndiDataSourceFactory， 对于JNDI类型的数据源DataSource的获取就比较简单，MyBatis定义了一个JndiDataSourceFactory工厂来创建通过JNDI形式生成的DataSource。
//从jndi上下文中直接获取数据源并返回
if (properties.containsKey(INITIAL_CONTEXT) && properties.containsKey(DATA_SOURCE)) { Context ctx = (Context) initCtx.lookup(properties.getProperty(INITIAL_CONTEXT)); dataSource = (DataSource) ctx.lookup(properties.getProperty(DATA_SOURCE)); } else if (properties.containsKey(DATA_SOURCE)) { dataSource = (DataSource) initCtx.lookup(properties.getProperty(DATA_SOURCE)); }
3，将得到的datasource和事物facroty一起用来，获取一个tx。
然后用这个tx重新组装成mybatis自己的一个执行器Executor，这里需要注意，如果二级缓存的开关开启了，那么得到的会是一个CachingExecutor，将来执行查询的时候，就会使用这个去执行，会先使用二级缓存，然后在一级缓存，然后再db查询。
public Executor newExecutor(Transaction transaction, ExecutorType executorType, boolean autoCommit) { 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, autoCommit); } executor = (Executor) interceptorChain.pluginAll(executor); return executor; }
4，得到这个执行器之后，组装成sqlsession然后返回供外部使用。
private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) { Transaction tx = null; try { //得到db信息
final Environment environment = configuration.getEnvironment();
//得到事物factory final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
//根据数据源得到事物 tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
//得到执行器 final Executor executor = configuration.newExecutor(tx, execType, autoCommit);
//执行器和配置信息对象一起组装了session返回。 return new DefaultSqlSession(configuration, executor); } 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(); } }
3，执行sql查询。
1，首先会根据sql的id去configuration对象中找到对应的sql，返回的是一个 MappedStatement，这里面有所有这个sql的信息，
public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) { try {
//根据id找到对应的sql的封装对象 statement MappedStatement ms = configuration.getMappedStatement(statement);
//这里的执行器有可能是缓存执行器也可能是默认执行器 List<E> result = executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER); return result; } catch (Exception e) { throw ExceptionFactory.wrapException("Error querying database. Cause: " + e, e); } finally { ErrorContext.instance().reset(); } }
2，执行执行器的查询方法，如果二级缓存开启了那么会使用CachingExecutor的query，这里会先去这个MappedStatement里的缓存里找，如果找不到，在去执行sql，
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException { Cache cache = ms.getCache(); if (cache != null) { flushCacheIfRequired(ms); if (ms.isUseCache() && resultHandler == null) { ensureNoOutParams(ms, parameterObject, boundSql); if (!dirty) { cache.getReadWriteLock().readLock().lock(); try {
//这里从二级缓存中找一下 @SuppressWarnings("unchecked") List<E> cachedList = (List<E>) cache.getObject(key); if (cachedList != null) return cachedList; } finally { cache.getReadWriteLock().readLock().unlock(); } }
//执行sql查询 List<E> list = delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql); tcm.putObject(cache, key, list); // issue #578. Query must be not synchronized to prevent deadlocks return list; } } return delegate.<E>query(ms, parameterObject, rowBounds, resultHandler, key, boundSql); }
3，二级缓存里如果找不到
也不会直接执行sql，会先从一级缓存里找，除非这里专门设置了flush，如果找到了，那么直接使用，找不到，执行sql查找，然后将结果设置到缓存中。这里查到数据之后，会根据自己定义的映射关系，来组装对象并返回。
//一级缓存查找
list = resultHandler == null ? (List<E>) localCache.getObject(key) : null; if (list != null) { handleLocallyCachedOutputParameters(ms, key, parameter, boundSql); } else {
//sqldb查找 list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql); }
这样一个简单的流程就走完了，当然还有其他很多东西，需要继续往源码深处研究。