概述
上一篇我们讲了configuation.xml中几个标签的解析，例如<properties>,<typeAlises>,<settings>等，今天我们来介绍剩下的两个比较重要的标签之一，<environments>，这个标签主要用于我们访问数据库的配置进行设置。
<environments>解析
我们先来看下configuation.xml中<environments>元素的配置：
1 <environments default="development">
2 <environment id="development">
3 <transactionManager type="JDBC" />
4 <dataSource type="POOLED">
5 <property name="driver" value="${driveClass}" />
6 <property name="url" value="${url}" />
7 <property name="username" value="${userName}" />
8 <property name="password" value="${password}" />
9 </dataSource>
10 </environment>
11 </environments>
从上面的具体配置我们可以看出一些东西来：首先我们可以配置多个<environment>标签，它的下面主要配置两个东西，transactionManager和datasource，但是真正起作用的是<environments>标签中default元素标出的那个。下面我们看下具体的解析流程：
1 private void environmentsElement(XNode context) throws Exception {
2 if (context != null) {
3 if (environment == null) {
4 environment = context.getStringAttribute("default");
5 }
6 for (XNode child : context.getChildren()) {
7 String id = child.getStringAttribute("id");
8 if (isSpecifiedEnvironment(id)) {
9 TransactionFactory txFactory = transactionManagerElement(child.evalNode("transactionManager"));
10 DataSourceFactory dsFactory = dataSourceElement(child.evalNode("dataSource"));
11 DataSource dataSource = dsFactory.getDataSource();
12 Environment.Builder environmentBuilder = new Environment.Builder(id)
13 .transactionFactory(txFactory)
14 .dataSource(dataSource);
15 configuration.setEnvironment(environmentBuilder.build());
16 }
17 }
18 }
19 }我们从代码中的for 循环遍历可以看出，<environments>标签下面是可以配置多个<environment>子标签的，每个子标签用id来区分，具体使用哪一个，看<environments>的default值，这也印证了我们一开始的分析。第3到5行代码，就是去获取<environments>的default属性，第7行代码，获取子标签<environment>的id属性，判断是不是上面default配置的那个，如果是，第9行代码，根据<transactionManager>标签获取事物管理器：
1 private TransactionFactory transactionManagerElement(XNode context) throws Exception {
2 if (context != null) {
3 String type = context.getStringAttribute("type");
4 Properties props = context.getChildrenAsProperties();
5 TransactionFactory factory = (TransactionFactory) resolveClass(type).newInstance();
6 factory.setProperties(props);
7 return factory;
8 }
9 throw new BuilderException("Environment declaration requires a TransactionFactory.");
10 }这边重点看下第5行代码，跟到最后可以发现，它其实是从typeAliasRegistry 这个map中根据type去获取class，进而得到实例，代码如下：
1 protected Class<?> resolveAlias(String alias) {
2 return typeAliasRegistry.resolveAlias(alias);
3 }那这么的根据获取到是哪个类呢？其实我们上面说到过，其实一些默认的typeAlias，我们再看下关于这边的：
1 typeAliasRegistry.registerAlias("JDBC", JdbcTransactionFactory.class);
2 typeAliasRegistry.registerAlias("MANAGED", ManagedTransactionFactory.class);
3
4 typeAliasRegistry.registerAlias("JNDI", JndiDataSourceFactory.class);
5 typeAliasRegistry.registerAlias("POOLED", PooledDataSourceFactory.class);
6 typeAliasRegistry.registerAlias("UNPOOLED", UnpooledDataSourceFactory.class);这部分是在configuation中的，类初始化的时候就会加载，我们可以看到，transactionManager有两种配置，JDBC和MANAGED，分别对应于JdbcTransactionFactory和ManagedTransactionFactory。下面我们就来分析下这两个类，首先看下这两个类所在的目录解结构：
我们可以看出这边使用了工厂模式，其中
Transaction是事物接口，主要定义了如下接口：
Connection getConnection() throws SQLException; // 获取数据库连接
void commit() throws SQLException; // 提交
void rollback() throws SQLException; // 回滚
void close() throws SQLException; // 关闭数据库连接
Integer getTimeout() throws SQLException; // 获取设置的事物超时时间
TransactionFactory是事物工厂接口，主要定义了如下接口：
void setProperties(Properties props); // 设置属性
Transaction newTransaction(Connection conn); // 根据连接创建事物实例
Transaction newTransaction(DataSource dataSource, TransactionIsolationLevel level, boolean autoCommit); // 根据数据源，事物隔离级别，是否自动提交创建事物实例。
这样设计的目的就是为了便于扩展，以后要实现不同类型的事物只要实现这两个接口就行了。
上面配置文件中的JDBC和MANAGED其实就是对应于mybatis内置两种事物类型，JDBCTransaction和ManagedTransaction，
二者的不同之处在于：前者是直接使用JDK提供的JDBC来管理事务的各个环节：提交、回滚、关闭等操作，而后者则什么都不做，那么后者有什么意义呢，当然很重要。当我们单独使用MyBatis来构建项目时，我们要在Configuration配置文件中进行环境（environment）配置，在其中要设置事务类型为JDBC，意思是说MyBatis被单独使用时就需要使用JDBC类型的事务模型，因为在这个模型中定义了事务的各个方面，使用它可以完成事务的各项操作。而MANAGED类型的事务模型其实是一个托管模型，也就是说它自身并不实现任何事务功能，而是托管出去由其他框架来实现，你可能还不明白，这个事务的具体实现就交由如Spring之类的框架来实现，而且在使用SSM整合框架后已经不再需要单独配置环境信息（包括事务配置与数据源配置），因为在在整合jar包（mybatis-spring.jar）中拥有覆盖mybatis里面的这部分逻辑的代码，实际情况是即使你显式设置了相关配置信息，系统也会视而不见......托管的意义显而易见，正是为整合而设。我们学习MyBatis的目的正是由于其灵活性和与Spring等框架的无缝整合的能力，所以有关JDBC事务模块的内容明显不再是MyBatis功能中的重点，也许只有在单独使用MyBatis的少量系统中才会使用到。
但是还是得去了解下，我们先看下JdbcTransactionFactory，这个实现了TransactionFactory，将获取JDBCTransaction实例的过程隐藏了起来，其主要代码如下：
public class JdbcTransactionFactory implements TransactionFactory {
@Override
public void setProperties(Properties props) {
}
@Override
public Transaction newTransaction(Connection conn) {
return new JdbcTransaction(conn);
}
@Override
public Transaction newTransaction(DataSource ds, TransactionIsolationLevel level, boolean autoCommit) {
return new JdbcTransaction(ds, level, autoCommit);
}
}我们先看setProperties方法，参数是Properties，这个方法是在解析事物标签的时候，如果有属性设置，就要执行，用于覆盖默认的配置，但是对于JdbcTransaction，即使你设置了，也不起作用，因为这边是是一个空方法，当然，我们一般不会设置。
下面两个方法名字一样，只是参数不一样，一个是根据连接去获取JdbcTransaction的实例，一个是根据数据源，事物隔离级别，是否自动提交来获取，讲这两个方法之前，我们先来看下，JdbcTransaction中相关提交、回滚、关闭操作的实现：
提交：
if (connection != null && !connection.getAutoCommit()) {
if (log.isDebugEnabled()) {
log.debug("Committing JDBC Connection [" + connection + "]");
}
connection.commit();
}
}回滚：
public void rollback() throws SQLException {
if (connection != null && !connection.getAutoCommit()) {
if (log.isDebugEnabled()) {
log.debug("Rolling back JDBC Connection [" + connection + "]");
}
connection.rollback();
}
}关闭：
public void close() throws SQLException {
if (connection != null) {
resetAutoCommit();
if (log.isDebugEnabled()) {
log.debug("Closing JDBC Connection [" + connection + "]");
}
connection.close();
}
}我们可以看到，执行这些方法的时候都是针对connection来操作的，首先我们就要获取connection，
获取连接：
1 public Connection getConnection() throws SQLException {
2 if (connection == null) {
3 openConnection();
4 }
5 return connection;
6 }我们接着看openConnection方法：
protected void openConnection() throws SQLException {
if (log.isDebugEnabled()) {
log.debug("Opening JDBC Connection");
}
connection = dataSource.getConnection();
if (level != null) {
connection.setTransactionIsolation(level.getLevel());
}
setDesiredAutoCommit(autoCommmit);
}setDesiredAutoCommit的具体内容如下：
protected void setDesiredAutoCommit(boolean desiredAutoCommit) {
try {
if (connection.getAutoCommit() != desiredAutoCommit) {
if (log.isDebugEnabled()) {
log.debug("Setting autocommit to " + desiredAutoCommit + " on JDBC Connection [" + connection + "]");
}
connection.setAutoCommit(desiredAutoCommit);
}
} catch (SQLException e) {
// Only a very poorly implemented driver would fail here,
// and there's not much we can do about that.
throw new TransactionException("Error configuring AutoCommit. "
+ "Your driver may not support getAutoCommit() or setAutoCommit(). "
+ "Requested setting: " + desiredAutoCommit + ". Cause: " + e, e);
}
}从这个两个方法我们可以看出，connection可以从datasource中获取，并补充设置它的事物隔离级别，是否自动提交等属性。现在我们再来看一下JdbcTransactionFactory中那两个方法就不难理解了，说到底就是为了获得connection，进而去操作事物。
最后，我们再来看一个JdbcTransaction中的方法，
protected void resetAutoCommit() {
try {
if (!connection.getAutoCommit()) {
// MyBatis does not call commit/rollback on a connection if just selects were performed.
// Some databases start transactions with select statements
// and they mandate a commit/rollback before closing the connection.
// A workaround is setting the autocommit to true before closing the connection.
// Sybase throws an exception here.
if (log.isDebugEnabled()) {
log.debug("Resetting autocommit to true on JDBC Connection [" + connection + "]");
}
connection.setAutoCommit(true);
}
} catch (SQLException e) {
if (log.isDebugEnabled()) {
log.debug("Error resetting autocommit to true "
+ "before closing the connection. Cause: " + e);
}
}
}这个方法是在关闭连接的时候调用的，mybatis默认的自动提交为true，如果将其设置为了false，就需要将其复位。那么自动提交的初始值是在哪边设置的呢？