11、配置环境（environments）

环境的作用

yBatis 可以配置成适应多种环境，这种机制有助于将 SQL 映射应用于多种数据库之中， 现实情况下有多种理由需要这么做。例如，开发、测试和生产环境需要有不同的配置；或者共享相同 Schema 的多个生产数据库， 想使用相同的 SQL 映射。许多类似的用例。

不过要记住：尽管可以配置多个环境，每个 SqlSessionFactory 实例只能选择其一。

所以，如果你想连接两个数据库，就需要创建两个 SqlSessionFactory 实例，每个数据库对应一个。而如果是三个数据库，就需要三个实例，依此类推，记起来很简单：

每个数据库对应一个 SqlSessionFactory 实例

怎么理解呢？

假如我们系统的开发环境和正式环境所用的数据库不一样（这是肯定的）， 那么可以设置两个environment, 两个id分别对应开发环境（dev）和正式环境（final），那么通过配置environments的default属性就能选择对应的environment了， 例如，我将environments的deault属性的值配置为dev, 那么就会选择dev的environment。

环境的配置

<environments default="development">        <environment id="development">            <transactionManager type="JDBC"/>            <dataSource type="POOLED">                <!--                如果上面没有指定数据库配置的properties文件，那么此处可以这样直接配置              <property name="driver" value="com.mysql.jdbc.Driver"/>              <property name="url" value="jdbc:mysql://localhost:3306/test1"/>              <property name="username" value="root"/>              <property name="password" value="adminter"/>               -->                <!-- 上面指定了数据库配置文件， 配置文件里面也是对应的这四个属性 -->                <property name="driver" value="${driver}"/>                <property name="url" value="${url}"/>                <property name="username" value="${username}"/>                <property name="password" value="${password}"/>            </dataSource>        </environment>        <!-- 我再指定一个environment -->        <environment id="test">            <transactionManager type="JDBC"/>            <dataSource type="POOLED">                <property name="driver" value="com.mysql.jdbc.Driver"/>                <!-- 与上面的url不一样 -->                <property name="url" value="jdbc:mysql://localhost:3306/demo"/>                <property name="username" value="root"/>                <property name="password" value="adminter"/>            </dataSource>        </environment>    </environments>

注意这里的关键点:
- 默认的环境 ID（比如:default=”development”）。
- 每个 environment 元素定义的环境 ID（比如:id=”development”）。
- 事务管理器的配置（比如:type=”JDBC”）。
- 数据源的配置（比如:type=”POOLED”）。

事务管理器（transactionManager）

在 MyBatis 中有两种类型的事务管理器（也就是 type=”[JDBC|MANAGED]”）：
- JDBC – 这个配置就是直接使用了 JDBC 的提交和回滚设置，它依赖于从数据源得到的连接来管理事务作用域。
- MANAGED – 这个配置几乎没做什么。它从来不提交或回滚一个连接，而是让容器来管理事务的整个生命周期（比如 JEE 应用服务器的上下文）。 默认情况下它会关闭连接，然而一些容器并不希望这样，因此需要将 closeConnection 属性设置为 false 来阻止它默认的关闭行为。

<transactionManager type="MANAGED">  <property name="closeConnection" value="false"/></transactionManager>

如果你正在使用 Spring + MyBatis，则没有必要配置事务管理器， 因为 Spring 模块会使用自带的管理器来覆盖前面的配置。

这两种事务管理器类型都不需要任何属性。它们不过是类型别名，换句话说，你可以使用 TransactionFactory 接口的实现类的完全限定名或类型别名代替它们。

任何在 XML 中配置的属性在实例化之后将会被传递给 setProperties() 方法。你也需要创建一个 Transaction 接口的实现类，

数据源（dataSource）

dataSource 元素使用标准的 JDBC 数据源接口来配置 JDBC 连接对象的资源。

许多 MyBatis 的应用程序将会按示例中的例子来配置数据源。然而它并不是必须的。要知道为了方便使用延迟加载，数据源才是必须的。
有三种内建的数据源类型（也就是 type=”[UNPOOLED|POOLED|JNDI]”）：

• UNPOOLED– 这个数据源的实现只是每次被请求时打开和关闭连接。虽然一点慢，它对在及时可用连接方面没有性能要求的简单应用程序是一个很好的选择。 不同的数据库在这方面表现也是不一样的，所以对某些数据库来说使用连接池并不重要，这个配置也是理想的。UNPOOLED 类型的数据源仅仅需要配置以下 5 种属性：
  
  • driver – 这是 JDBC 驱动的 Java 类的完全限定名（并不是JDBC驱动中可能包含的数据源类）。
  • url – 这是数据库的 JDBC URL 地址。
  • username – 登录数据库的用户名。
  • password – 登录数据库的密码。
  • defaultTransactionIsolationLevel – 默认的连接事务隔离级别。
    作为可选项，你也可以传递属性给数据库驱动。要这样做，属性的前缀为“driver.”driver.encoding=UTF8

这将通过DriverManager.getConnection(url,driverProperties)方法传递值为 UTF8 的 encoding 属性给数据库驱动。

• POOLED– 这种数据源的实现利用“池”的概念将 JDBC 连接对象组织起来，避免了创建新的连接实例时所必需的初始化和认证时间。 这是一种使得并发 Web 应用快速响应请求的流行处理方式。除了上述提到 UNPOOLED 下的属性外，会有更多属性用来配置 POOLED 的数据源：
  
  • poolMaximumActiveConnections – 在任意时间可以存在的活动（也就是正在使用）连接数量，默认值：10
  • poolMaximumIdleConnections – 任意时间可能存在的空闲连接数。
  • poolMaximumCheckoutTime – 在被强制返回之前，池中连接被检出（checked out）时间，默认值：20000 毫秒（即 20 秒）
  • poolTimeToWait – 这是一个底层设置，如果获取连接花费的相当长的时间，它会给连接池打印状态日志并重新尝试获取一个连接（避免在误配置的情况下一直安静的失败），默认值：20000 毫秒（即 20 秒）。
  • poolPingQuery – 发送到数据库的侦测查询，用来检验连接是否处在正常工作秩序中并准备接受请求。默认是“NO PING QUERY SET”，这会导致多数数据库驱动失败时带有一个恰当的错误消息。
  • poolPingEnabled – 是否启用侦测查询。若开启，也必须使用一个可执行的 SQL 语句设置 poolPingQuery 属性（最好是一个非常快的 SQL），默认值：false。
  • poolPingConnectionsNotUsedFor – 配置 poolPingQuery 的使用频度。这可以被设置成匹配具体的数据库连接超时时间，来避免不必要的侦测，默认值：0（即所有连接每一时刻都被侦测 — 当然仅当 poolPingEnabled 为 true 时适用）。
• JNDI– 这个数据源的实现是为了能在如 EJB 或应用服务器这类容器中使用，容器可以集中或在外部配置数据源，然后放置一个 JNDI 上下文的引用。这种数据源配置只需要两个属性：
  
  • initial_context – 这个属性用来在 InitialContext 中寻找上下文（即，initialContext.lookup(initial_context)）。这是个可选属性，如果忽略，那么 data_source 属性将会直接从 InitialContext 中寻找。
  • data_source – 这是引用数据源实例位置的上下文的路径。提供了 initial_context 配置时会在其返回的上下文中进行查找，没有提供时则直接在 InitialContext 中查找。
    和其他数据源配置类似，可以通过添加前缀“env.”直接把属性传递给初始上下文。比如：

源码解析

环境的组成

环境是有事物工厂和DataSource组成，通过build构建出来

     Environment.Builder environmentBuilder = new Environment.Builder(id)                            .transactionFactory(txFactory)                            .dataSource(dataSource);  configuration.setEnvironment(environmentBuilder.build());

package org.apache.ibatis.mapping;import javax.sql.DataSource;import org.apache.ibatis.transaction.TransactionFactory;/** * @author Clinton Begin */public final class Environment {  private final String id;  private final TransactionFactory transactionFactory;  private final DataSource dataSource;  public Environment(String id, TransactionFactory transactionFactory, DataSource dataSource) {    if (id == null) {      throw new IllegalArgumentException("Parameter 'id' must not be null");    }    if (transactionFactory == null) {        throw new IllegalArgumentException("Parameter 'transactionFactory' must not be null");    }    this.id = id;    if (dataSource == null) {      throw new IllegalArgumentException("Parameter 'dataSource' must not be null");    }    this.transactionFactory = transactionFactory;    this.dataSource = dataSource;  }  public static class Builder {      private String id;      private TransactionFactory transactionFactory;      private DataSource dataSource;    public Builder(String id) {      this.id = id;    }    public Builder transactionFactory(TransactionFactory transactionFactory) {      this.transactionFactory = transactionFactory;      return this;    }    public Builder dataSource(DataSource dataSource) {      this.dataSource = dataSource;      return this;    }    public String id() {      return this.id;    }    public Environment build() {      return new Environment(this.id, this.transactionFactory, this.dataSource);    }  }  public String getId() {    return this.id;  }  public TransactionFactory getTransactionFactory() {    return this.transactionFactory;  }  public DataSource getDataSource() {    return this.dataSource;  }}

事务管理器（transactionManager）

此处使用了设计模式中的抽象工厂模式，这个模式的好处就是，如果你现在想增加一个功能，只用实现相应的接口和工厂接口

事物工厂

事物工厂为接口，实现有2种

package org.apache.ibatis.transaction;import java.sql.Connection;import java.util.Properties;import javax.sql.DataSource;import org.apache.ibatis.session.TransactionIsolationLevel;/** * Creates {@link Transaction} instances. * * @author Clinton Begin */public interface TransactionFactory {  /**   * Sets transaction factory custom properties.   * @param props   */  void setProperties(Properties props);  /**   * Creates a {@link Transaction} out of an existing connection.   * @param conn Existing database connection   * @return Transaction   * @since 3.1.0   */  Transaction newTransaction(Connection conn);  /**   * Creates a {@link Transaction} out of a datasource.   * @param dataSource DataSource to take the connection from   * @param level Desired isolation level   * @param autoCommit Desired autocommit   * @return Transaction   * @since 3.1.0   */  Transaction newTransaction(DataSource dataSource, TransactionIsolationLevel level, boolean autoCommit);}

JDBC事物工厂的实现

package org.apache.ibatis.transaction.jdbc;import java.sql.Connection;import java.util.Properties;import javax.sql.DataSource;import org.apache.ibatis.session.TransactionIsolationLevel;import org.apache.ibatis.transaction.Transaction;import org.apache.ibatis.transaction.TransactionFactory;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);  }}

MANAGED事物工厂的实现

package org.apache.ibatis.transaction.managed;import java.sql.Connection;import java.util.Properties;import javax.sql.DataSource;import org.apache.ibatis.session.TransactionIsolationLevel;import org.apache.ibatis.transaction.Transaction;import org.apache.ibatis.transaction.TransactionFactory;public class ManagedTransactionFactory implements TransactionFactory {  private boolean closeConnection = true;  @Override  public void setProperties(Properties props) {    if (props != null) {      String closeConnectionProperty = props.getProperty("closeConnection");      if (closeConnectionProperty != null) {        closeConnection = Boolean.valueOf(closeConnectionProperty);      }    }  }  @Override  public Transaction newTransaction(Connection conn) {    return new ManagedTransaction(conn, closeConnection);  }  @Override  public Transaction newTransaction(DataSource ds, TransactionIsolationLevel level, boolean autoCommit) {    // Silently ignores autocommit and isolation level, as managed transactions are entirely    // controlled by an external manager.  It's silently ignored so that    // code remains portable between managed and unmanaged configurations.    return new ManagedTransaction(ds, level, closeConnection);  }}

事物

事物接口，他的实现也有2个

package org.apache.ibatis.transaction;import java.sql.Connection;import java.sql.SQLException;/** * Wraps a database connection. * Handles the connection lifecycle that comprises: its creation, preparation, commit/rollback and close.  * * @author Clinton Begin */public interface Transaction {  /**   * Retrieve inner database connection   * @return DataBase connection   * @throws SQLException   */  Connection getConnection() throws SQLException;  /**   * Commit inner database connection.   * @throws SQLException   */  void commit() throws SQLException;  /**   * Rollback inner database connection.   * @throws SQLException   */  void rollback() throws SQLException;  /**   * Close inner database connection.   * @throws SQLException   */  void close() throws SQLException;  /**   * Get transaction timeout if set   * @throws SQLException   */  Integer getTimeout() throws SQLException;}

JDBC事物的实现

package org.apache.ibatis.transaction.jdbc;import java.sql.Connection;import java.sql.SQLException;import javax.sql.DataSource;import org.apache.ibatis.logging.Log;import org.apache.ibatis.logging.LogFactory;import org.apache.ibatis.session.TransactionIsolationLevel;import org.apache.ibatis.transaction.Transaction;import org.apache.ibatis.transaction.TransactionException;public class JdbcTransaction implements Transaction {  private static final Log log = LogFactory.getLog(JdbcTransaction.class);  protected Connection connection;  protected DataSource dataSource;  protected TransactionIsolationLevel level;  protected boolean autoCommmit;  public JdbcTransaction(DataSource ds, TransactionIsolationLevel desiredLevel, boolean desiredAutoCommit) {    dataSource = ds;    level = desiredLevel;    autoCommmit = desiredAutoCommit;  }  public JdbcTransaction(Connection connection) {    this.connection = connection;  }  @Override  public Connection getConnection() throws SQLException {    if (connection == null) {      openConnection();    }    return connection;  }  @Override  public void commit() throws SQLException {    if (connection != null && !connection.getAutoCommit()) {      if (log.isDebugEnabled()) {        log.debug("Committing JDBC Connection [" + connection + "]");      }      connection.commit();    }  }  @Override  public void rollback() throws SQLException {    if (connection != null && !connection.getAutoCommit()) {      if (log.isDebugEnabled()) {        log.debug("Rolling back JDBC Connection [" + connection + "]");      }      connection.rollback();    }  }  @Override  public void close() throws SQLException {    if (connection != null) {      resetAutoCommit();      if (log.isDebugEnabled()) {        log.debug("Closing JDBC Connection [" + connection + "]");      }      connection.close();    }  }  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);    }  }  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);      }    }  }  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);  }  @Override  public Integer getTimeout() throws SQLException {    return null;  }}

MANAGED事物的实现

package org.apache.ibatis.transaction.managed;import java.sql.Connection;import java.sql.SQLException;import javax.sql.DataSource;import org.apache.ibatis.logging.Log;import org.apache.ibatis.logging.LogFactory;import org.apache.ibatis.session.TransactionIsolationLevel;import org.apache.ibatis.transaction.Transaction;public class ManagedTransaction implements Transaction {  private static final Log log = LogFactory.getLog(ManagedTransaction.class);  private DataSource dataSource;  private TransactionIsolationLevel level;  private Connection connection;  private boolean closeConnection;  public ManagedTransaction(Connection connection, boolean closeConnection) {    this.connection = connection;    this.closeConnection = closeConnection;  }  public ManagedTransaction(DataSource ds, TransactionIsolationLevel level, boolean closeConnection) {    this.dataSource = ds;    this.level = level;    this.closeConnection = closeConnection;  }  @Override  public Connection getConnection() throws SQLException {    if (this.connection == null) {      openConnection();    }    return this.connection;  }  @Override  public void commit() throws SQLException {    // Does nothing  }  @Override  public void rollback() throws SQLException {    // Does nothing  }  @Override  public void close() throws SQLException {    if (this.closeConnection && this.connection != null) {      if (log.isDebugEnabled()) {        log.debug("Closing JDBC Connection [" + this.connection + "]");      }      this.connection.close();    }  }  protected void openConnection() throws SQLException {    if (log.isDebugEnabled()) {      log.debug("Opening JDBC Connection");    }    this.connection = this.dataSource.getConnection();    if (this.level != null) {      this.connection.setTransactionIsolation(this.level.getLevel());    }  }  @Override  public Integer getTimeout() throws SQLException {    return null;  }}

DataSourceFactory

DataSourceFactory采用的是工厂方法，他的实现有三种JNDI、POOLED、UNPOOLED
具体实现参考下面的三个类JndiDataSourceFactory、UnpooledDataSourceFactory、PooledDataSourceFactory

配置文件的源码解析

private void environmentsElement(XNode context) throws Exception {        if (context != null) {            if (environment == null) {                //解析environments节点的default属性的值                //例如: <environments default="development">                environment = context.getStringAttribute("default");            }            //递归解析environments子节点            for (XNode child : context.getChildren()) {                String id = child.getStringAttribute("id");                if (isSpecifiedEnvironment(id)) {//是否是default配置的id，是的话解析                    //事务， mybatis有两种：JDBC 和 MANAGED, 配置为JDBC则直接使用JDBC的事务，配置为MANAGED则是将事务托管给容器，                    TransactionFactory txFactory = transactionManagerElement(child.evalNode("transactionManager"));                    //enviroment节点下面就是dataSource节点了，解析dataSource节点（                    DataSourceFactory dsFactory = dataSourceElement(child.evalNode("dataSource"));                    DataSource dataSource = dsFactory.getDataSource();                    Environment.Builder environmentBuilder = new Environment.Builder(id)                            .transactionFactory(txFactory)                            .dataSource(dataSource);                    //老规矩，会将dataSource设置进configuration对象                    configuration.setEnvironment(environmentBuilder.build());                }            }        }    }

  private TransactionFactory transactionManagerElement(XNode context) throws Exception {        if (context != null) {            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.");    }

    private DataSourceFactory dataSourceElement(XNode context) throws Exception {        if (context != null) {            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.");    }