MyBatis的配置方式

MyBatis的配置方式有两种，一种是XML，一种是代码方式，下面我们都简单介绍下，先从xml方式开始：
构建 SqlSessionFactory 最常见的方式是基于 XML 配置的构造方式 。下面的 mybatis-config.xml 展示了一个典型的 MyBatis 配置文件的样子：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <properties resource="mysql.properties"/>
    <settings>
        <setting name="cacheEnabled" value="true" />
    </settings>
    <typeAliases>
        <typeAlias alias="Student" type="com.neucloud.domain.Student"/>
        <package name="com.neucloud.domain"/>
    </typeAliases>
    <typeHandlers>
        <typeHandler handler="com.neucloud.typehandlers.MyTypeHandler" />
        <package name="com.neucloud.typehandlers" />
    </typeHandlers>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driverClassName}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="com/neucloud/mappers/StudentMapper.xml"/>
    </mappers>
</configuration>

下面让我们逐个讨论上述配置文件的组成部分，先从最重要的部分开始，即 environments:
environment
MyBatis 支持配置多个 dataSource 环境， 可以将应用部署到不同的环境上， 如 DEV(开发环境)， TEST （测试环境） ，QA（质量评估环境）,UAT(用户验收环境),PRODUCTION（生产环境） ，可以通过将默认 environment 值设置成想要的 environment id 值。
在上述的配置中，默认的环境 environment 被设置成 development。当需要将程序部署到生产服务器上时，你不需要修改什么配置，只需要将默认环境 environment 值设置成生产环境的 environment id 属性即可。 有时候，我们可能需要在相同的应用下使用多个数据库。比如我们可能有 SHOPPING-CART 数据库来存储所有的订单明细；使用 REPORTS 数据库存储订单明细的合计，用作报告。
如果你的应用需要连接多个数据库，你需要将每个数据库配置成独立的环境，并且为每一个数据库创建一个SqlSessionFactory。
XML Code：

<environments default="development"> 
  <environment id="development"> 
    <transactionManager type="JDBC" /> 
    <dataSource type="POOLED"> 
      <property name="driver" value="${jdbc.driverClassName}"/>
<property name="url" value="${jdbc.url}"/>
<property name="username" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
    </dataSource> 
  </environment> 
  <environment id="development2"> 
    <transactionManager type="MANAGED" /> 
    <dataSource type="JNDI"> 
      <property name="data_source" value="java:comp/jdbc/ReportsDS" /> 
    </dataSource> 
  </environment> 
</environments> 

我们可以如下为每个环境创建一个 SqlSessionFactory
创建 SqlSessionFactory 时，如果没有明确指定环境 environment id，则会使用默认的环境 environment 来创建。在上述的源码中，默认的 SqlSessionFactory 便是使用 development环境设置创建的。

对于每个环境 environment,我们都需要配置 dataSource 和 transactionManager 元素

数据源 DataSource
dataSource 元素被用来配置数据库连接属性，dataSource 的类型可以配置成其内置类型之一，如 UNPOOLED，POOLED，JNDI。
● 如果将类型设置成 UNPOOLED，MyBatis 会为每一个数据库操作创建一个新的连接，并关闭它。该方式适用于只有小规模数量并发用户的简单应用程序上，在多用户并发应用中， 不建议使用。
● 如果将属性设置成 POOLED，MyBatis 会创建一个数据库连接池，对用户的每一个请求，会使用缓冲池中的一个可用的Connection对 象 ， 这样可以提高应用的性能。一旦数据库操作完成，MyBatis 会将此连接返回给连接池。在开发或测试环境中，经常使用此种方式。

● 如果将类型设置成 JNDI，MyBatis使用应用服务器的数据库连接池，并且使用JNDI查找来获取数据库连接。在生产环境中，优先考虑这种方式。

事务管理器 TransactionManager
MyBatis 支持两种类型的事务管理器： JDBC and MANAGED.
● JDBC 事务管理器被用作当应用程序负责管理数据库连接的生命周期（提交、回退等等）的时候。当你将TransactionManager 属性设置成 JDBC，MyBatis 内部将使用 JdbcTransactionFactory 类创建TransactionManager。例如，部署到 Apache Tomcat 的应用程序，需要应用程序自己管理事务。

● MANAGED 事务管理器是当由应用服务器负责管理数据库连接生命周期的时候使用。当你将TransactionManager 属性设置成 MANAGED 时， MyBatis 内部使用ManagedTransactionFactory 类创建事务管理器TransactionManager。 例如， 当一个JavaEE的应用程序部署在类似 JBoss， WebLogic，GlassFish 应用服务器上时，它们会使用 EJB 进行应用服务器的事务管理能力。在这些管理环境中，你可以使用 MANAGED 事务管理器。（Managed 可以理解为托管的意思，即是应用本身不去管理事务，而是把事务管理交给应用所在的服务器进行管理）

属性 Properties
属性配置元素可以将配置值具体化到一个属性文件中，并且使用属性文件的 key 名作为占位符。在上述的配置中，我们将数据库连接属性具体化到了 mysql.properties 文件中，并且为 driver，URL 等属性使用了占位符。
1. 在 mysql.properties 文件中配置数据库连接参数，如下所示：
jdbc.driverClassName=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/first_db
jdbc.username=root
jdbc.password=9958
2.在 mybatis-config.xml 文件中，为属性使用 mysql.properties 文件中定义的占位符：

<properties resource="mysql.properties"> 
  <property name="jdbc.username" value="root" /> 
  <property name="jdbc.password" value="9958" /> 
</properties> 
<dataSource type="POOLED"> 
  <property name="driver" value="${jdbc.driverClassName}" /> 
  <property name="url" value="${jdbc.url}" /> 
  <property name="username" value="${jdbc.username}" /> 
  <property name="password" value="${jdbc.password}" /> 
</dataSource>

在<properties>元素中可以配置默认参数的值。 如果<properties>中定义的元素和属性文件定义元素的 key值相同，它们会被属性文件中定义的值覆盖，也就是如果mysql.properties 文件包含值 jdbc.username 和 jdbc.password，则上述定义的 username 和password 的值 root和 9958将会被 mysql.properties 中定义的对应的 jdbc.username 和jdbc.password 值覆盖。

类型别名 typeAliases
在 SQLMapper 配置文件中，对于 resultType 和 parameterType 属性值，我们需要使用 JavaBean 的完全限定名：

<select id="findStudentById" parameterType="int"  
    resultType="com.neucloud.domain.Student"> 
       select stud_id as studId, name, email, dob from Students where stud_id=#{studId}
</select> 
<update id="updateStudent" parameterType="com.neucloud.domain.Student"> 
  UPDATE STUDENTS SET NAME=#{name}, EMAIL=#{email}, DOB=#{dob} WHERE STUD_ID=#{studId}
</update> 

这里我们为 resultType 和 parameterType 属性值设置为 Student 类型的完全限定名：
com.neucloud.domain.Student
我们可以为完全限定名取一个别名（alias） ，然后其需要使用完全限定名的地方使用别名，而不是到处使用完全限定名。如下例子所示，为完全限定名起一个别名：

<typeAliases>
    <typeAlias alias="Student" type="com.neucloud.domain.Student"/>
    <package name="com.neucloud.domain"/>
</typeAliases> 

然后在 SQL Mapper 映射文件中, 直接使用 Student就可以了
通过提供需要取别名的 JavaBean 所在的包(package)，你可以不用为每一个 JavaBean 单独定义别名, MyBatis会自动扫描包内定义的 JavaBeans，然后分别为 JavaBean 注册一个小写字母开头的非完全限定的类名形式的别名。
还有另外一种方式为 JavaBeans 起别名，使用注解@Alias:

@Alias("StudentAlias") 
public class Student 
{ 
} 

@Alias 注解将会覆盖配置文件中的<typeAliases>定义。

类型处理器 typeHandlers
MyBatis 通过抽象 JDBC 来简化了数据持久化逻辑的实现。MyBatis 在其内部使用 JDBC，提供了更简洁的方式实现了数据库操作。
当 MyBatis 将一个 Java 对象作为输入参数执行 INSERT 语句操作时，它会创建一个 PreparedStatement 对象，并且使用 setXXX()方式对占位符设置相应的参数值。
这里，XXX 可以是 Int，String，Date 等 Java 对象属性类型的任意一个。示例如下：

<insert id="insertStudent" parameterType="Student">
   INSERT INTO STUDENTS(STUD_ID,NAME,EMAIL,DOB) 
   VALUES(#{studId},#{name},#{email},#{dob})
</insert>

为执行这个语句，MyBatis 将采取以下一系列动作：
1. 创建一个有占位符的 PreparedStatement 接口，如下：
PreparedStatement pstmt = connection.prepareStatement
("INSERT INTO STUDENTS(STUD_ID,NAME,EMAIL,DOB) VALUES(?,?,?,?)");
2. 检查 Student 对象的属性 studId 的类型， 然后使用合适 setXXX 方法去设置参数值。 这里 studId 是 integer类型，所以会使用 setInt()方法：
pstmt.setInt(1,student.getStudId());
3. 类似地，对于 name 和 email 属性都是 String 类型，MyBatis 使用 setString()方法设置参数：
pstmt.setString(2, student.getName());
pstmt.setString(3, student.getEmail());
4. 至于 dob 属性, MyBatis 会使用 setDate() 方法设置 dob 处占位符位置的值。
5. MyBaits 会将 java.util.Date 类型转换为 into java.sql.Timestamp 并设值：
pstmt.setTimestamp(4, new Timestamp((student.getDob()).getTime()));
其原理就是通过使用类型处理器（type handlers）来决定这么做的。
MyBatis 对于以下的类型使用内建的类型处理器：所有的基本数据类型、基本类型的包裹类型、byte[]、java.util.Date、java.sql.Date、java,sql.Time、java.sql.Timestamp、java 枚举类型等。所以当 MyBatis 发现属性的类型属于上述类型，他会使用对应的类型处理器将值设置到 PreparedStatement 中，同样地，当从 SQL 结果集构建 JavaBean 时，也有类似的过程。
可如果我们有一个自定义的对象类型，来存储存储到数据库呢？
假设表 STUDENTS 有一个 PHONE 字段，类型为 VARCHAR(15)，而 JavaBean Student 有一个 PhoneNumber 类定义类型的 phoneNumber 属性。
<insert id="insertStudent" parameterType="Student">
insert into students(name,email,phone)
values(#{name},#{email},#{phone})
</insert>
这里，phone 参数需要传递给#{phone}；而 phone 对象是 PhoneNumber 类型。然而，MyBatis 并不知道该怎样来处理这个类型的对象。

为了让 MyBatis 明白怎样处理这个自定义的 Java 对象类型，如 PhoneNumber，我们可以创建一个自定义的类型处理器，如下所示：
1. MyBatis 提供了抽象类 BaseTypeHandler<T> ，我们可以继承此类创建自定义类型处理器。

public class PhoneTypeHandler extends BaseTypeHandler<PhoneNumber> { 
    @Override 
    public void setNonNullParameter(PreparedStatement ps, int i, 
                                    PhoneNumber parameter, JdbcType jdbcType) throws 
        SQLException { 
        ps.setString(i, parameter.getAsString()); 
    } 
    @Override 
    public PhoneNumber getNullableResult(ResultSet rs, String columnName) 
    throws SQLException { 
        return new PhoneNumber(rs.getString(columnName)); 
    } 
    @Override 
    public PhoneNumber getNullableResult(ResultSet rs, int columnIndex) 
    throws SQLException { 
        return new PhoneNumber(rs.getString(columnIndex));
} 
    @Override 
    public PhoneNumber getNullableResult(CallableStatement cs, int columnIndex) 
    throws SQLException { 
        return new PhoneNumber(cs.getString(columnIndex)); 
    } 
} 

2. 我们使用 ps.setString()和 rs.getString()方法是因为 phone 列是 VARCHAR 类型。
3. 一旦我们实现了自定义的类型处理器，我们需要在 mybatis-config.xml 中注册它：

<?xml version="1.0" encoding="utf-8"?> 
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" 
"http://mybatis.org/dtd/mybatis-3-config.dtd"> 
<configuration> 
  <properties resource="application.properties" /> 
  <typeHandlers> 
    <typeHandler handler="com.neucloud.typehandlers. PhoneTypeHandler" /> 
  </typeHandlers> 
</configuration> 

注册 PhoneTypeHandler 后, MyBatis 就能够将 Phone 类型的对象值存储到 VARCHAR 类型的列上。
全局参数设置 Settings
为满足应用特定的需求，MyBatis 默认的全局参数设置可以被覆盖(overridden)掉，如下所示：

<settings> 
  <setting name="cacheEnabled" value="true" /> 
  <setting name="lazyLoadingEnabled" value="true" /> 
  <setting name="multipleResultSetsEnabled" value="true" /> 
  <setting name="useColumnLabel" value="true" /> 
  <setting name="useGeneratedKeys" value="false" /> 
  <setting name="autoMappingBehavior" value="PARTIAL" /> 
  <setting name="defaultExecutorType" value="SIMPLE" /> 
  <setting name="defaultStatementTimeout" value="25000" /> 
  <setting name="safeRowBoundsEnabled" value="false" /> 
  <setting name="mapUnderscoreToCamelCase" value="false" /> 
  <setting name="localCacheScope" value="SESSION" /> 
  <setting name="jdbcTypeForNull" value="OTHER" /> 
  <setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode ,toString" /> 
</settings> 

SQL 映射定义 Mappers
Mapper XML 文件中包含的 SQL 映射语句将会被应用通过使用其 statementid 来执行。我们需要在 mybatis-config.xml 文件中配置 SQL Mapper 文件的位置。

<mappers> 
  <mapper resource="com/neucloud/mappers/StudentMapper.xml"/>
  <mapper url="file:///D:/Intellij/MyBatisDemo/src/main/resources/com/neucloud/mappersStudentMapper.xml" /> 
  <mapper class="com.neucloud.mappers.StudentMapper" /> 
  <package name="com.neucloud.mappers" /> 
</mappers> 

以上每一个<mapper> 标签的属性有助于从不同类型的资源中加载映射 mapper：
● resource 属性用来指定在 classpath 中的 mapper 文件。
● url 属性用来通过完全文件系统路径或者 web URL 地址来指向 mapper 文件
● class 属性用来指向一个 mapper 接口
● package 属性用来指向可以找到 Mapper 接口的包名

使用 Java API 配置 MyBatis
我们已经讨论了各种 MyBatis 配置元素，如 envronments,typeAlias,和 typeHandlers，以及如何使用
XML 配置它们。即使你想使用基于 Java API 的 MyBatis 配置，经历前面的学习是大有好处的，它可以帮你对这些配置元素有更好的理解。在本节中，我们会引用到前一节中描述的一些类。
MyBatis 的 SqlSessionFactory 接口除了使用基于 XML 的配置创建外也可以通过 Java API 编程式地被创建。每个在 XML 中配置的元素，都可以编程式的创建。
使用 Java API 创建 SqlSessionFactory，代码如下：

public static SqlSessionFactory getSqlSessionFactoryUsingJavaAPI() {
    if (javaSqlSessionFactory == null) {
        try {
            DataSource dataSource = DataSourceFactory.getDataSource();
            TransactionFactory transactionFactory = new JdbcTransactionFactory();
            Environment environment = new Environment("development", transactionFactory, dataSource);
            Configuration configuration = new Configuration(environment);
            configuration.getTypeAliasRegistry().registerAlias("student", Student.class);
            configuration.getTypeHandlerRegistry().register(PhoneTypeHandler.class);
            configuration.addMapper(StudentMapper.class);
            javaSqlSessionFactory = new SqlSessionFactoryBuilder().build(configuration);

        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    return javaSqlSessionFactory;
}

环境配置 Environment
我们需要为想使用 MaBatis 连接的每一个数据库创建一个 Enviroment 对象。为了使用每一个环境，我们需要为每一个环境 environment 创建一个 SqlSessionFactory 对象。 而创建 Environment 对象， 我们需要 java.sql.DataSource和 TransactionFactory 实例。下面让我们看看如何创建 DataSource 和 TransactionFactory 对象
数据源 DataSource
MyBatis 支持三种内建的 DataSource 类型: UNPOOLED, POOLED和 JNDI，下面通过 MyBatis 的 PooledDataSource 获得 DataSource 对象，如下：

public static DataSource getDataSource() {
    String driver = PROPERTIES.getProperty("jdbc.driverClassName");
    String url = PROPERTIES.getProperty("jdbc.url");
    String username = PROPERTIES.getProperty("jdbc.username");
    String password = PROPERTIES.getProperty("jdbc.password");
    PooledDataSource dataSource = new PooledDataSource(driver, url, username, password);
    return dataSource;
}

一般在生产环境中，DataSource 会被应用服务器配置，并通过 JNDI 获取 DataSource 对象，如下所示：

public static DataSource getJNDIDataSource() {
    String dataSourceJNDIName = "java:comp/env/jdbc/MyBatisDemoDS";
    try {
        InitialContext ctx = new InitialContext();
        DataSource dataSource = (DataSource) ctx.lookup(dataSourceJNDIName);
        return dataSource;
    } catch (NamingException e) {
        throw new RuntimeException(e);
    }
}

当前有一些流行的第三方类库，如 commons-dbcp 和 c3p0 实现了 java.sql.DataSource,你可以使用它们来创建dataSource。
事务工厂 TransactionFactory
MyBatis 支持一下两种 TransactionFactory 实现：
● JdbcTransactionFactory
● ManagedTransactionFactory
如果你的应用程序运行在未托管（non-managed）的环境中，你应该使用 JdbcTransactionFactory：
DataSource dataSource = DataSourceFactory.getDataSource();
TransactionFactory txnFactory = new JdbcTransactionFactory();
Environment environment = new Environment("development", txnFactory, dataSource);
如果你的应用程序运行在托管（managed）的环境中,并且使用容器支持的事务管理服务，你应该使用ManagedTransactionFactory：
DataSource dataSource = DataSourceFactory.getDataSource();
TransactionFactory txnFactory = new ManagedTransactionFactory();
Environment environment = new Environment("development", txnFactory, dataSource);
类型别名 typeAliases
MyBatis 提供以下几种通过 Configuration 对象注册类型别名的方法：
1. 根据默认的别名规则，使用一个类的首字母小写、非完全限定的类名作为别名注册，可使用以下代码：
configuration.getTypeAliasRegistry().registerAlias(Student.class);
2. 指定别名注册，可使用以下代码：
configuration.getTypeAliasRegistry().registerAlias("Student",Student.class);
3. 通过类的完全限定名注册相应类别名，可使用一下代码：
configuration.getTypeAliasRegistry().registerAlias("Student", "com.neucloud.domain.Student");
4. 为某一个包中的所有类注册别名，可使用以下代码：
configuration.getTypeAliasRegistry().registerAliases("com.neucloud.domain");
5. 为在 com.neucloud.domain package 包中所有的继承自 Identifiable 类型的类注册别名，可使用以下代码：
configuration.getTypeAliasRegistry().registerAliases("com.neucloud.domain", Identifiable.class);
类型处理器 typeHandlers
MyBatis 提供了一系列使用 Configuration 对象注册类型处理器（type handler）的方法。我们可以通过以下方式注册自定义的类处理器：
1. 为某个特定的类注册类处理器:
configuration.getTypeHandlerRegistry().register(PhoneNumber. class, PhoneTypeHandler.class);
2. 注册一个类处理器:
configuration.getTypeHandlerRegistry().register(PhoneTypeHandler.class);
3. 注册 com.mybatis3.typehandlers 包中的所有类型处理器：
configuration.getTypeHandlerRegistry().register("com.neucloud.typehandlers");
全局参数设置 Settings
MyBatis 提供了一组默认的，能够很好地适用大部分的应用的全局参数设置。然而，你可以稍微调整这些参数，让它更
好地满足你应用的需要。你可以使用下列方法将全局参数设置成想要的值。

configuration.setCacheEnabled(true); 
configuration.setLazyLoadingEnabled(false); 
configuration.setMultipleResultSetsEnabled(true); 
configuration.setUseColumnLabel(true); 
configuration.setUseGeneratedKeys(false); 
configuration.setAutoMappingBehavior(AutoMappingBehavior.PARTIAL); 
configuration.setDefaultExecutorType(ExecutorType.SIMPLE); 
configuration.setDefaultStatementTimeout(25); 
configuration.setSafeRowBoundsEnabled(false); 
configuration.setMapUnderscoreToCamelCase(false); 
configuration.setLocalCacheScope(LocalCacheScope.SESSION); 
configuration.setAggressiveLazyLoading(true); 
configuration.setJdbcTypeForNull(JdbcType.OTHER); 
Set<String> lazyLoadTriggerMethods = new HashSet<String>(); 
lazyLoadTriggerMethods.add("equals"); 
lazyLoadTriggerMethods.add("clone"); 
lazyLoadTriggerMethods.add("hashCode"); 
lazyLoadTriggerMethods.add("toString"); 
configuration.setLazyLoadTriggerMethods(lazyLoadTriggerMethods ); 

Mappers
MyBatis 提供了一些使用 Configuration 对象注册 Mapper XML 文件和 Mappe 接口的方法。
1. 添加一个 Mapper 接口，可使用以下代码:
configuration.addMapper(StudentMapper.class);
2. 添加 com.neucloud.mappers 包中的所有 Mapper XML 文件或者 Mapper 接口，可使用以下代码：
configuration.addMappers("com.neucloud.mappers");
3. 添加所有 com.neucloud.mappers 包中的拓展了特定 Mapper 接口的 Maper 接口， 如 aseMapper,可使用如下代码：
configuration.addMappers("com.neucloud.mappers", BaseMapper.class);