MyBatis最关键的组成部分是SqlSessionFactory，我们可以从中获取SqlSession，并执行映射的SQL语句。SqlSessionFactory对象可以通过基于XML的配置信息或者Java API 创建。

我们将探索各种MaBatis配置元素，如dataSource，environments,全局参数设置,typeAlias，typeHandlers，SQL映射；接着我们将实例化SqlSessionFactory。

本章将涵盖一下内容：

• l  使用 XML配置MyBatis
• l  使用Java API配置MyBatis
• l  自定义MyBatis日志

2.1 使用XML配置MyBatis

构建SqlSessionFactory最常见的方式是基于XML配置（的构造方式）。下面的mybatis-config.xml展示了一个典型的MyBatis配置文件的样子：

1. <?xml version="1.0" encoding="utf-8"?>
2. <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
3. "http://mybatis.org/dtd/mybatis-3-config.dtd">
4. <configuration>
5. <properties resource="application.properties">
6. <property name="username" value="db_user" />
7. <property name="password" value="verysecurepwd" />
8. </properties>
9. <settings>
10. <setting name="cacheEnabled" value="true" />
11. </settings>
12. <typeAliases>
13. <typeAlias alias="Tutor" type="com.mybatis3.domain.Tutor" />
14. <package name="com.mybatis3.domain" />
15. </typeAliases>
16. <typeHandlers>
17. <typeHandler handler="com.mybatis3.typehandlers. PhoneTypeHandler" />
18. <package name="com.mybatis3.typehandlers" />
19. </typeHandlers>
20. <environments default="development">
21. <environment id="development">
22. <transactionManager type="JDBC" />
23. <dataSource type="POOLED">
24. <property name="driver" value="${jdbc.driverClassName}" />
25. <property name="url" value="${jdbc.url}" />
26. <property name="username" value="${jdbc.username}" />
27. <property name="password" value="${jdbc.password}" />
28. </dataSource>
29. </environment>
30. <environment id="production">
31. <transactionManager type="MANAGED" />
32. <dataSource type="JNDI">
33. <property name="data_source" value="java:comp/jdbc/MyBatisDemoDS" />
34. </dataSource>
35. </environment>
36. </environments>
37. <mappers>
38. <mapper resource="com/mybatis3/mappers/StudentMapper.xml" />
39. <mapper url="file:///D:/mybatisdemo/mappers/TutorMapper.xml" />
40. <mapper class="com.mybatis3.mappers.TutorMapper" />
41. </mappers>
42. </configuration>

下面让我们逐个讨论上述配置文件的组成部分，先从最重要的部分开始，即environments:

2.1.1 environment

MyBatis支持配置多个dataSource 环境，可以将应用部署到不同的环境上，如DEV(开发环境)，TEST（测试换将），QA（质量评估环境）,UAT(用户验收环境),PRODUCTION（生产环境），可以通过将默认environment值设置成想要的 environment id 值。

在上述的配置中，默认的环境environment被设置成development。当需要将程序部署到生产服务器上时，你不需要修改什么配置，只需要将默认环境environment值设置成生产环境的  environment id 属性即可。

有时候，我们可能需要在相同的应用下使用多个数据库。比如我们可能有SHOPPING-CART数据库来存储所有的订单明细；使用REPORTS数据库存储订单明细的合计，用作报告。

如果你的应用需要连接多个数据库，你需要将每个数据库配置成独立的环境，并且为每一个数据库创建一个SqlSessionFactory。

1. <environments default="shoppingcart">
2. <environment id="shoppingcart">
3. <transactionManager type="MANAGED" />
4. <dataSource type="JNDI">
5. <property name="data_source" value="java:comp/jdbc/ ShoppingcartDS" />
6. </dataSource>
7. </environment>
8. <environment id="reports">
9. <transactionManager type="MANAGED" />
10. <dataSource type="JNDI">
11. <property name="data_source" value="java:comp/jdbc/ReportsDS" />
12. </dataSource>
13. </environment>
14. </environments>

我们可以如下为每个环境创建一个SqlSessionFactory:

1. inputStream = Resources.getResourceAsStream("mybatis-config.xml");
2. defaultSqlSessionFactory = new SqlSessionFactoryBuilder().
3. build(inputStream);
4. cartSqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStre
5. am, "shoppingcart");
6. reportSqlSessionFactory = new SqlSessionFactoryBuilder().
7. build(inputStream, "reports");

创建SqlSessionFactory时，如果没有明确指定环境environmentid，则会使用默认的环境environment来创建。在上述的源码中，默认的SqlSessionFactory便是使用shoppingcart 环境设置创建的。

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

2.1.2 数据源DataSource

dataSource 元素被用来配置数据库连接属性。

1. <dataSource type="POOLED">
2. <property name="driver" value="${jdbc.driverClassName}" />
3. <property name="url" value="${jdbc.url}" />
4. <property name="username" value="${jdbc.username}" />
5. <property name="password" value="${jdbc.password}" />
6. </dataSource>

dataSource的类型可以配置成其内置类型之一，如 UNPOOLED，POOLED，JNDI。

• l  如果将类型设置成UNPOOLED，MyBatis会为每一个数据库操作创建一个新的连接，并关闭它。该方式适用于只有小规模数量并发用户的简单应用程序上。
• l   如果将属性设置成POOLED，MyBatis会创建一个数据库连接池，连接池中的一个连接将会被用作数据库操作。一旦数据库操作完成，MyBatis会将此连接返回给连接池。在开发或测试环境中，经常使用此种方式。
• 如果将类型设置成JNDI，MyBatis从在应用服务器向配置好的JNDI数据源dataSource获取数据库连接。在生产环境中，优先考虑这种方式。

2.1.3 事务管理器TransactionManager

MyBatis 支持两种类型的事务管理器： JDBC and MANAGED.

• l   JDBC事务管理器被用作当应用程序负责管理数据库连接的生命周期（提交、回退等等）的时候。当你将TransactionManager属性设置成JDBC，MyBatis内部将使用JdbcTransactionFactory类创建TransactionManager。例如，部署到Apache Tomcat的应用程序，需要应用程序自己管理事务。
• l   MANAGED 事务管理器是当由应用服务器负责管理数据库连接生命周期的时候使用。当你将TransactionManager 属性设置成MANAGED时，MyBatis内部使用ManagedTransactionFactory 类创建事务管理器TransactionManager。例如，当一个JavaEE的应用程序部署在类似 JBoss，WebLogic，GlassFish应用服务器上时，它们会使用EJB进行应用服务器的事务管理能力。在这些管理环境中，你可以使用MANAGED事务管理器。
• （译者注：Managed是托管的意思，即是应用本身不去管理事务，而是把事务管理交给应用所在的服务器进行管理。）

2.1.4  属性Properties

属性配置元素可以将配置值具体化到一个属性文件中，，并且使用属性文件的key名作为占位符。在上述的配置中，我们将数据库连接属性具体化到了application.properties文件中，并且为driver，URL等属性使用了占位符。

1. 在applications.properties文件中配置数据库连接参数，如下所示：

1. jdbc.driverClassName=com.mysql.jdbc.Driver
2. jdbc.url=jdbc:mysql://localhost:3306/mybatisdemo
3. jdbc.username=root
4. jdbc.password=admin

2. 在mybatis-config.xml文件中，为属性使用application.properties文件中定义的占位符：

1. <properties resource="application.properties">
2. <property name="jdbc.username" value="db_user" />
3. <property name="jdbc.password" value="verysecurepwd" />
4. </properties>
5. <dataSource type="POOLED">
6. <property name="driver" value="${jdbc.driverClassName}" />
7. <property name="url" value="${jdbc.url}" />
8. <property name="username" value="${jdbc.username}" />
9. <property name="password" value="${jdbc.password}" />
10. </dataSource>

并且，你可以在<properties>元素中配置默认参数的值。如果<properties>中定义的元素和属性文件定义元素的key值相同，它们会被属性文件中定义的值覆盖。

1. <properties resource="application.properties">
2. <property name="jdbc.username" value="db_user" />
3. <property name="jdbc.password" value="verysecurepwd" />
4. </properties>

这里，如果application.properties文件包含值jdbc.username和jdbc.password，则上述定义的username和password的值db_user 和verysecurepwd将会被application.properties中定义的对应的jdbc.username和jdbc.password值覆盖。

2.1.5 类型别名typeAliases

在SQLMapper配置文件中，对于resultType和parameterType属性值，我们需要使用JavaBean的完全限定名。如下例子所示：

1. <select id="findStudentById" parameterType="int"
2. resultType="com.mybatis3.domain.Student">
3. SELECT STUD_ID AS ID, NAME, EMAIL, DOB
4. FROM STUDENTS WHERE STUD_ID=#{Id}
5. </select>
6. <update id="updateStudent" parameterType="com.mybatis3.domain. Student">
7. UPDATE STUDENTS
8. SET NAME=#{name}, EMAIL=#{email}, DOB=#{dob}
9. WHERE STUD_ID=#{id}
10. </update>

这里我们为resultType 和parameterType属性值设置为Student类型的完全限定名：

com.mybatis3.domain.Student

我们可以为完全限定名取一个别名（alias），然后其需要使用完全限定名的地方使用别名，而不是到处使用完全限定名。如下例子所示，为完全限定名起一个别名：

1. <typeAliases>
2. <typeAlias alias="Student" type="com.mybatis3.domain.Student" />
3. <typeAlias alias="Tutor" type="com.mybatis3.domain.Tutor" />
4. <package name="com.mybatis3.domain" />
5. </typeAliases>

然后在 SQL Mapper 映射文件中, 如下使用Student的别名：

1. <select id="findStudentById" parameterType="int" resultType="Student">
2. SELECT STUD_ID AS ID, NAME, EMAIL, DOB
3. FROM STUDENTS WHERE STUD_ID=#{id}
4. </select>
5. <update id="updateStudent" parameterType="Student">
6. UPDATE STUDENTS
7. SET NAME=#{name}, EMAIL=#{email}, DOB=#{dob}
8. WHERE STUD_ID=#{id}
9. </update>

你可以不用为每一个JavaBean单独定义别名, 你可以为提供需要取别名的JavaBean所在的包(package)，MyBatis会自动扫描包内定义的JavaBeans，然后分别为JavaBean注册一个小写字母开头的非完全限定的类名形式的别名。如下所示，提供一个需要为JavaBeans起别名的包名：

1. <typeAliases>
2. <package name="com.mybatis3.domain" />
3. </typeAliases>

如果Student.java 和Tutor.java Bean定义在com.mybatis3.domain包中，则com.mybatis3.domain.Student的别名会被注册为student。而com.mybatis3.domain.Tutor别名将会被注册为tutor。示例如下：

1. <typeAliases>
2. <typeAlias alias="Student" type="com.mybatis3.domain.Student" />
3. <typeAlias alias="Tutor" type="com.mybatis3.domain.Tutor" />
4. <package name="com.mybatis3.domain" />
5. <package name="com.mybatis3.webservices.domain" />
6. </typeAliases>

还有另外一种方式为JavaBeans起别名，使用注解@Alias:

1. @Alias("StudentAlias")
2. public class Student
3. {
4. }

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

2.1.6 类型处理器typeHandlers

如上一章已经讨论过，MyBatis通过抽象JDBC来简化了数据持久化逻辑的实现。MyBatis在其内部使用JDBC，提供了更简洁的方式实现了数据库操作。

当MyBatis将一个Java对象作为输入参数执行INSERT语句操作时，它会创建一个PreparedStatement对象，并且使用setXXX()方式对占位符设置相应的参数值。

这里，XXX可以是Int，String，Date等Java对象属性类型的任意一个。示例如下：

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

为执行这个语句，MyBatis将采取以下一系列动作：

1.  创建一个有占位符的PreparedStatement 接口，如下：

1. PreparedStatement pstmt = connection.prepareStatement
2. ("INSERT INTO STUDENTS(STUD_ID,NAME,EMAIL,DOB) VALUES(?,?,?,?)");

2. 检查Student对象的属性studId的类型，然后使用合适setXXX方法去设置参数值。这里studId是integer类型，所以会使用setInt()方法：

1. pstmt.setInt(1,student.getStudId());

3. 类似地，对于name 和email 属性都是String类型，MyBatis使用setString()方法设置参数。

1. pstmt.setString(2, student.getName());
2. pstmt.setString(3, student.getEmail());

4. 至于dob属性, MyBatis 会使用 setDate() 方法设置dob处占位符位置的值。

5. MyBaits会将java.util.Date类型转换为into java.sql.Timestamp 并设值：

1. pstmt.setTimestamp(4, new Timestamp((student.getDob()).getTime()));

厉害！但MyBatis是怎么知道对于Integer类型属性使用setInt() 和String类型属性使用setString()方法呢？其实MyBatis是通过使用类型处理器（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属性。

1. public class PhoneNumber
2. {
3. private String countryCode;
4. private String stateCode;
5. private String number;
6. public PhoneNumber()
7. {
8. }
9. public PhoneNumber(String countryCode, String stateCode, String
10. number)
11. {
12. this.countryCode = countryCode;
13. this.stateCode = stateCode;
14. this.number = number;
15. }
16. public PhoneNumber(String string)
17. {
18. if(string != null)
19. {
20. String[] parts = string.split("-");
21. if(parts.length > 0) this.countryCode = parts[0];
22. if(parts.length > 1) this.stateCode = parts[1];
23. if(parts.length > 2) this.number = parts[2];
24. }
25. }
26. public String getAsString()
27. {
28. return countryCode + "-" + stateCode + "-" + number;
29. }
30. // Setters and getters
31. }
32. public class Student
33. {
34. private Integer id;
35. private String name;
36. private String email;
37. private PhoneNumber phone;
38. // Setters and getters
39. }

1. <insert id="insertStudent" parameterType="Student">
2. insert into students(name,email,phone)
3. values(#{name},#{email},#{phone})
4. </insert>

这里，phone参数需要传递给#{phone}；而phone对象是PhoneNumber类型。然而，MyBatis并不知道该怎样来处理这个类型的对象。

为了让MyBatis明白怎样处理这个自定义的Java对象类型，如PhoneNumber，我们可以创建一个自定义的类型处理器，如下所示：

1. MyBatis 提供了抽象类BaseTypeHandler<T> ，我们可以继承此类创建自定义类型处理器。

1. packagecom.mybatis3.typehandlers;
2. importjava.sql.CallableStatement;
3. importjava.sql.PreparedStatement;
4. importjava.sql.ResultSet;
5. importjava.sql.SQLException;
6. importorg.apache.ibatis.type.BaseTypeHandler;
7. importorg.apache.ibatis.type.JdbcType;
8. importcom.mybatis3.domain.PhoneNumber;
9. public class PhoneTypeHandler extends BaseTypeHandler<PhoneNumber>
10. {
11. @Override
12. public void setNonNullParameter(PreparedStatement ps, int i,
13. PhoneNumber parameter, JdbcType jdbcType) throws
14. SQLException
15. {
16. ps.setString(i, parameter.getAsString());
17. }
18. @Override
19. public PhoneNumber getNullableResult(ResultSet rs, String
20. columnName)
21. throws SQLException
22. {
23. return new PhoneNumber(rs.getString(columnName));
24. }
25. @Override
26. public PhoneNumber getNullableResult(ResultSet rs, int
27. columnIndex)
28. throws SQLException
29. {
30. return new PhoneNumber(rs.getString(columnIndex));
31. }
32. @Override
33. public PhoneNumber getNullableResult(CallableStatement cs, int
34. columnIndex)
35. throws SQLException
36. {
37. return new PhoneNumber(cs.getString(columnIndex));
38. }
39. }

2.  我们使用ps.setString()和rs.getString()方法是因为phone列是VARCHAR类型。

3. 一旦我们实现了自定义的类型处理器，我们需要在mybatis-config.xml中注册它：

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

注册PhoneTypeHandler后,MyBatis 就能够将Phone类型的对象值存储到VARCHAR类型的列上。

2.1.7 全局参数设置Settings

为满足应用特定的需求，MyBatis默认的全局参数设置可以被覆盖(overridden)掉，如下所示：

1. <settings>
2. <setting name="cacheEnabled" value="true" />
3. <setting name="lazyLoadingEnabled" value="true" />
4. <setting name="multipleResultSetsEnabled" value="true" />
5. <setting name="useColumnLabel" value="true" />
6. <setting name="useGeneratedKeys" value="false" />
7. <setting name="autoMappingBehavior" value="PARTIAL" />
8. <setting name="defaultExecutorType" value="SIMPLE" />
9. <setting name="defaultStatementTimeout" value="25000" />
10. <setting name="safeRowBoundsEnabled" value="false" />
11. <setting name="mapUnderscoreToCamelCase" value="false" />
12. <setting name="localCacheScope" value="SESSION" />
13. <setting name="jdbcTypeForNull" value="OTHER" />
14. <setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode ,toString" />
15. </settings>

2.1.8 SQL映射定义Mappers

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

1. <mappers>
2. <mapper resource="com/mybatis3/mappers/StudentMapper.xml" />
3. <mapper url="file:///D:/mybatisdemo/app/mappers/TutorMapper.xml" />
4. <mapper class="com.mybatis3.mappers.TutorMapper" />
5. <package name="com.mybatis3.mappers" />
6. </mappers>

以上每一个<mapper> 标签的属性有助于从不同类型的资源中加载映射mapper：

• l   resource属性用来指定在classpath中的mapper文件。
• l   url属性用来通过完全文件系统路径或者web URL地址来指向mapper文件
• l   class属性用来指向一个mapper接口
• l   package属性用来指向可以找到Mapper接口的包名

2.2 使用Java API配置MyBatis

上一节中，我们已经讨论了各种MyBatis配置元素，如envronments,typeAlias,和typeHandlers，以及如何使用XML配置它们。即使你想使用基于JavaAPI的MyBatis配置，经历上一节的学习是大有好处的，它可以帮你对这些配置元素有更好的理解。在本节中，我们会引用到前一节中描述的一些类。

MyBatis的SqlSessionFactory接口除了使用基于XML的配置创建外也可以通过Java API 编程式地被创建。每个在XML中配置的元素，都可以编程式的创建。

使用Java API创建SqlSessionFactory，代码如下：

1. public static SqlSessionFactory getSqlSessionFactory()
2. {
3. SqlSessionFactory sqlSessionFactory = null;
4. try
5. {
6. DataSource dataSource = DataSourceFactory.getDataSource();
7. TransactionFactory transactionFactory = new
8. JdbcTransactionFactory();
9. Environment environment = new Environment("development",
10. transactionFactory, dataSource);
11. Configuration configuration = new Configuration(environment);
12. configuration.getTypeAliasRegistry().registerAlias("student",
13. Student.class);
14. configuration.getTypeHandlerRegistry().register(PhoneNumber.
15. class, PhoneTypeHandler.class);
16. configuration.addMapper(StudentMapper.class);
17. sqlSessionFactory = new SqlSessionFactoryBuilder().
18. build(configuration);
19. }
20. catch (Exception e)
21. {
22. throw new RuntimeException(e);
23. }
24. return sqlSessionFactory;
25. }

2.2.1 环境配置 environment

我们需要为想使用MaBatis连接的每一个数据库创建一个 Enviroment对象。为了使用每一个环境，我们需要为每一个环境environment创建一个SqlSessionFactory对象。而创建Environment对象，我们需要java.sql.DataSource和TransactionFactory实例。下面让我们看看如何创建DataSource 和TransactionFactory对象。

2.2.2 数据源DataSource

MyBatis支持三种内建的DataSource类型: UNPOOLED, POOLED, 和JNDI.

• l   UNPOOLED类型的数据源dataSource为每一个用户请求创建一个数据库连接。在多用户并发应用中，不建议使用。
• l   POOLED类型的数据源dataSource创建了一个数据库连接池，对用户的每一个请求，会使用缓冲池中的一个可用的Connection对象，这样可以提高应用的性能。MyBatis提供了org.apache.ibatis.datasource.pooled.PooledDataSource 实现javax.sql.DataSource来创建连接池。
• l   JNDI类型的数据源dataSource使用了应用服务器的数据库连接池，并且使用JNDI查找来获取数据库连接。

让我们看一下怎样通过MyBatis的PooledDataSource获得DataSource对象，如下：

1. public class DataSourceFactory
2. {
3. public static DataSource getDataSource()
4. {
5. String driver = "com.mysql.jdbc.Driver";
6. String url = "jdbc:mysql://localhost:3306/mybatisdemo";
7. String username = "root";
8. String password = "admin";
9. PooledDataSource dataSource = new PooledDataSource(driver, url,
10. username, password);
11. return dataSource;
12. }
13. }

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

1. public class DataSourceFactory
2. {
3. public static DataSource getDataSource()
4. {
5. String jndiName = "java:comp/env/jdbc/MyBatisDemoDS";
6. try
7. {
8. InitialContext ctx = new InitialContext();
9. DataSource dataSource = (DataSource) ctx.lookup(jndiName);
10. return dataSource;
11. }
12. catch (NamingException e)
13. {
14. throw new RuntimeException(e);
15. }
16. }
17. }

当前有一些流行的第三方类库，如commons-dbcp和c3p0实现了java.sql.DataSource,你可以使用它们来创建dataSource。

2.2.3 事务工厂TransactionFactory

MyBatis支持一下两种TransactionFactory实现：

• l   JdbcTransactionFactory
• l   ManagedTransactionFactory

如果你的应用程序运行在未托管（non-managed）的环境中，你应该使用JdbcTransactionFactory。

1. DataSource dataSource = DataSourceFactory.getDataSource();
2. TransactionFactory txnFactory = new JdbcTransactionFactory();
3. Environment environment = new Environment("development", txnFactory,
4. dataSource);

如果你的应用程序运行在未托管（non-managed）的环境中,并且使用容器支持的事务管理服务，你应该使用ManagedTransactionFactory。

1. DataSource dataSource = DataSourceFactory.getDataSource();
2. TransactionFactory txnFactory = new ManagedTransactionFactory();
3. Environment environment = new Environment("development", txnFactory,
4. dataSource);

2.2.4 类型别名typeAliases

MyBatis 提供以下几种通过Configuration对象注册类型别名的方法：

1.  根据默认的别名规则，使用一个类的首字母小写、非完全限定的类名作为别名注册，可使用以下代码：

1. configuration.getTypeAliasRegistry().registerAlias(Student.class);

2.  指定指定别名注册，可使用以下代码：

1. configuration.getTypeAliasRegistry().registerAlias("Student",Student.class);

3. 通过类的完全限定名注册相应类别名，可使用一下代码：

1. configuration.getTypeAliasRegistry().registerAlias("Student",
2. "com.mybatis3.domain.Student");

4.  为某一个包中的所有类注册别名，可使用以下代码：

1. configuration.getTypeAliasRegistry().registerAliases("com.
2. mybatis3.domain");

5. 为在com.mybatis3.domain package包中所有的继承自Identifiable类型的类注册别名，可使用以下代码：

1. configuration.getTypeAliasRegistry().registerAliases("com.
2. mybatis3.domain", Identifiable.class);

2.2.5 类型处理器typeHandlers

MyBatis提供了一系列使用Configuration对象注册类型处理器（type handler）的方法。我们可以通过以下方式注册自定义的类处理器：

1.  为某个特定的类注册类处理器:

1. configuration.getTypeHandlerRegistry().register(PhoneNumber.class, PhoneTypeHandler.class);

2.  注册一个类处理器:

1. configuration.getTypeHandlerRegistry().register(PhoneTypeHandler.class);

3.  注册com.mybatis3.typehandlers包中的所有类型处理器：

1. configuration.getTypeHandlerRegistry().register("com.mybatis3.typehandlers");

2.2.6 全局参数设置Settings

MyBatis提供了一组默认的，能够很好地适用大部分的应用的全局参数设置。然而，你可以稍微调整这些参数，让它更好地满足你应用的需要。你可以使用下列方法将全局参数设置成想要的值。

1. configuration.setCacheEnabled(true);
2. configuration.setLazyLoadingEnabled(false);
3. configuration.setMultipleResultSetsEnabled(true);
4. configuration.setUseColumnLabel(true);
5. configuration.setUseGeneratedKeys(false);
6. configuration.setAutoMappingBehavior(AutoMappingBehavior.PARTIAL);
7. configuration.setDefaultExecutorType(ExecutorType.SIMPLE);
8. configuration.setDefaultStatementTimeout(25);
9. configuration.setSafeRowBoundsEnabled(false);
10. configuration.setMapUnderscoreToCamelCase(false);
11. configuration.setLocalCacheScope(LocalCacheScope.SESSION);
12. configuration.setAggressiveLazyLoading(true);
13. configuration.setJdbcTypeForNull(JdbcType.OTHER);
14. Set<String> lazyLoadTriggerMethods = new HashSet<String>();
15. lazyLoadTriggerMethods.add("equals");
16. lazyLoadTriggerMethods.add("clone");
17. lazyLoadTriggerMethods.add("hashCode");
18. lazyLoadTriggerMethods.add("toString");
19. configuration.setLazyLoadTriggerMethods(lazyLoadTriggerMethods );

2.2.7 Mappers

MyBatis提供了一些使用Configuration对象注册Mapper XML文件和Mappe接口的方法。

1.  添加一个Mapper接口，可使用以下代码:

1. configuration.addMapper(StudentMapper.class);

2.  添加 com.mybatis3.mappers包中的所有Mapper XML文件或者Mapper接口，可使用以下代码：

1. configuration.addMappers("com.mybatis3.mappers");

3. 添加所有com.mybatis3.mappers包中的拓展了特定Mapper接口的Maper接口，如 aseMapper,可使用如下代码：

1. configuration.addMappers("com.mybatis3.mappers", BaseMapper.class);

2.3 自定义MyBatis 日志

MyBatis使用其内部LoggerFactory作为真正的日志类库使用的门面。其内部的LaggerFactory会将日志记录任务委托给如下的所示某一个日志实现，日志记录优先级由上到下顺序递减：

• l  SLF4J
• l  ApacheCommons Logging
• l  Log4j2
• l  Log4j
• l  JDKlogging

如果MyBatis未发现上述日志记录实现，则MyBatis的日志记录功能无效。

如果你的运行环境中，在classpath中有多个可用的日志类库，并且你希望MyBaits使用某个特定的日志实现，你可以通过调用以下其中一个方法：

• ž  org.apache.ibatis.logging.LogFactory.useSlf4jLogging();
• ž  org.apache.ibatis.logging.LogFactory.useLog4JLogging();
• ž  org.apache.ibatis.logging.LogFactory.useLog4J2Logging();
• ž  org.apache.ibatis.logging.LogFactory.useJdkLogging();
• ž  org.apache.ibatis.logging.LogFactory.useCommonsLogging();
• ž  org.apache.ibatis.logging.LogFactory.useStdOutLogging();

2.4 总结

在本章中我们学习了怎样使用XML配置和基于Java API配置的方式引导MyBatis。我们还学习了各种配置选项，如类型别名 type alias,类型处理器type handlers,以及全局参数设置。在接下来的一章里，我们会讨论SQL Mappers(SQL 映射定义)，它们是MyBaBatis的核心元素。

《Java Persistence with MyBatis 3(中文版)》导航：

Java Persistence with MyBatis 3(中文版)

Java Persistence with MyBatis 3(中文版) 前言

Java Persistence with MyBatis 3(中文版) 第一章 MyBatis入门

Java Persistence with MyBatis 3(中文版) 第二章 引导MyBatis

Java Persistence with MyBatis 3(中文版) 第三章 使用XML配置SQL映射器

Java Persistence with MyBatis 3(中文版) 第四章 使用注解配置SQL映射器

Java Persistence with MyBatis 3(中文版) 第五章 与Spring集成

-------------------------------------------------------------------------------------------------------------------------------

作者声明：本文出处是http://blog.csdn.net/luanlouis，如需转载，请注明出处！