Mybatis配置文件分析

Mybatis配置文件分析

Configuration
properties说明

<properties resource="org/mybatis/example/config.properties">
  <property name="username" value="dev_user"/>
  <property name="password" value="F2Fa3!33TYyg"/>
</properties>

数据库的配置肯定也是可以配置在外部文件的，如上面代码所示，配置在org/mybatis/example/config.properties文件中。然后在XML配置文件中引用，引用方式如下：

<dataSource type="POOLED">
  <property name="driver" value="${driver}"/>
  <property name="url" value="${url}"/>
  <property name="username" value="${username}"/>
  <property name="password" value="${password}"/>
</dataSource>

settings说明


TypeAliases
这个可以设置类的别名，如下：

<typeAliases>
  <typeAlias alias="Author" type="domain.blog.Author"/>
  <typeAlias alias="Blog" type="domain.blog.Blog"/>
  <typeAlias alias="Comment" type="domain.blog.Comment"/>
  <typeAlias alias="Post" type="domain.blog.Post"/>
  <typeAlias alias="Section" type="domain.blog.Section"/>
  <typeAlias alias="Tag" type="domain.blog.Tag"/>
</typeAliases>

上面是XML的指定，也可以使用注解的方式来设置：
先设置哪些包将用于扫描，获得注解的bean

<typeAliases>
  <package name="domain.blog"/>
</typeAliases>

然后在要设置别名的类上注解别名：

@Alias("author")
public class Author {
    ...
}

 

typeHandlers 的作用是将Java类型与数据库中类型进行匹配，在statement设值和ResultSet检索值时可以正确的转换，可以实现TypeHandler接口实现自己的类型处理器。mybatis中内建的类型处理器(Type Handler )


当然，我们也可以实现我们自己的类型转化器：

@MappedJdbcTypes(JdbcType.VARCHAR)
public class ExampleTypeHandler extends BaseTypeHandler<String> {
  @Override
  public void setNonNullParameter(PreparedStatement ps, int i, String parameter, Jd
    ps.setString(i, parameter);
  }
  @Override
  public String getNullableResult(ResultSet rs, String columnName) throws SQLExcept
    return rs.getString(columnName);
  }
  @Override
  public String getNullableResult(ResultSet rs, int columnIndex) throws SQLExceptio
    return rs.getString(columnIndex);
  }
  @Override
  public String getNullableResult(CallableStatement cs, int columnIndex) throws SQL
    return cs.getString(columnIndex);
  }
}

然后在配置文件中引入：

<!-- mybatis-config.xml -->
<typeHandlers>
  <typeHandler handler="org.mybatis.example.ExampleTypeHandler"/>
</typeHandlers>

ObjectFactory
查询结果映射成java类的时候，java对象实例是通过ObjectFactory来初始化生成的。默认的objectFactory包含默认构造函数的和带参数构造函数的初始化，我们也可以通过集成DefaultObjectFactory来重写：

public class ExampleObjectFactory extends DefaultObjectFactory {
  public Object create(Class type) {
    return super.create(type);
  }
  public Object create(Class type, List<Class> constructorArgTypes, List<Object> co
    return super.create(type, constructorArgTypes, constructorArgs);
  }
  public void setProperties(Properties properties) {
    super.setProperties(properties);
  }
}

然后在配置文件中引入：

<!-- mybatis-config.xml -->
<objectFactory type="org.mybatis.example.ExampleObjectFactory">
  <property name="someProperty" value="100"/>
</objectFactory>

environment
支持在不同环境下，使用不同数据库配置。
注意：每个SqlSessionFactory只能对应使用一个配置。

<environments default="development">
  <environment id="development">
    <transactionManager type="JDBC">
      <property name="..." value="..."/>
    </transactionManager>
    <dataSource type="POOLED">
      <property name="driver" value="${driver}"/>
      <property name="url" value="${url}"/>
      <property name="username" value="${username}"/>
      <property name="password" value="${password}"/>
    </dataSource>
  </environment>
</environments>

上面的代码设置了一个environment，并且设置为默认的环境。
事物的管理有两种，一种是上面的JDBC另一种是MANAGED。
JDBC：简单的使用了JDBC的事物提交和回滚机制。
MANAGED：不做任何事情，默认情况下会关闭连接。为了使用别的东西来管理事务，需要关闭这个机制

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

JDBC和MANAGED是两种事务管理的别名，如果你想取代这两种事务管理，可以自己实现两个事务管理接口，并且type上写上TransactionFactory实现类的全名。
要想实现自己的事务管理，必须实现两个接口一个是TransactionFactory，另一个是Transaction，我们来看一下JDBC事务管理是如何实现的：

TransactionFactory实现类

public class JdbcTransactionFactory implements TransactionFactory {
                             
  public void setProperties(Properties props) {
  }
                             
  public Transaction newTransaction(Connection conn) {
    return new JdbcTransaction(conn);
  }
                             
  public Transaction newTransaction(DataSource ds, TransactionIsolationLevel level, boolean autoCommit) {
    return new JdbcTransaction(ds, level, autoCommit);
  }
}

Transaction实现类：

/**
 * {@link Transaction} that makes use of the JDBC commit and rollback facilities directly.
 * It relies on the connection retrieved from the dataSource to manage the scope of the transaction.
 * Delays connection retrieval until getConnection() is called.
 * Ignores commit or rollback requests when autocommit is on.
 *
 * @see JdbcTransactionFactory
 */
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;
  }
                              
  public Connection getConnection() throws SQLException {
    if (connection == null) {
      openConnection();
    }
    return connection;
  }
                              
  public void commit() throws SQLException {
    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();
    }
  }
                              
  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) {
      log.debug("Error resetting autocommit to true "
          + "before closing the connection.  Cause: " + e);
    }
  }
                              
  protected void openConnection() throws SQLException {
    if (log.isDebugEnabled()) {
      log.debug("Openning JDBC Connection");
    }
    connection = dataSource.getConnection();
    if (level != null) {
      connection.setTransactionIsolation(level.getLevel());
    }
    setDesiredAutoCommit(autoCommmit);
  }
                              
}

我们可以看到JdbcTransactionFactory只是用来获得一个实际管理事务的JDBCransaction。而JdbcTransaction则实现了获得连接，事务提交|事务回滚，关闭连接等操作。看了上面的例子，自己重新写一个应该知道怎么写了把。

dataSource
定义了Unpooled不带连接池的，每次都简单的创建和关闭，这种性能低
POOLED带连接池的，JNDI使用外部定义的。

Mappers
Mapper用来定义sql语句,而mappers就是用来引入mapper映射文件。

XML配置方式：

<!-- Using classpath relative resources -->
<mappers>
  <mapper resource="org/mybatis/builder/AuthorMapper.xml"/>
  <mapper resource="org/mybatis/builder/BlogMapper.xml"/>
  <mapper resource="org/mybatis/builder/PostMapper.xml"/>
</mappers>

<!-- Using url fully qualified paths -->
<mappers>
  <mapper url="file:///var/mappers/AuthorMapper.xml"/>
  <mapper url="file:///var/mappers/BlogMapper.xml"/>
  <mapper url="file:///var/mappers/PostMapper.xml"/>
</mappers>

注解的方式：

<!-- Using mapper interface classes -->
<mappers>
  <mapper class="org.mybatis.builder.AuthorMapper"/>
  <mapper class="org.mybatis.builder.BlogMapper"/>
  <mapper class="org.mybatis.builder.PostMapper"/>
</mappers>

<!-- Register all interfaces in a package as mappers -->
<mappers>
  <package name="org.mybatis.builder"/>
</mappers>

© Programmer's life_海舰. Themed by WheatV Themes. Powered by 点点网