Mybatis官方文档及使用简记

Mybatis官方文档及使用简记

文档部分摘抄英文官方文档和中文官方文档（在线的）

中文的官方文档后面翻译有点烂，做了一些改动，这里面有很多的用法我也没用过，欢迎指出内容的错误

数据库建表

create DATABASE mybatis
show create DATABASE mybatis;
use mybatis;
create table class(
    id varchar(32) not null PRIMARY KEY,
    name varchar(20) not null,
    lead varchar(32),
    monitor varchar(30)
)
ALTER table class add UNIQUE(name)#增加索引
alter table class MODIFY lead varchar(20);#修改字段
alter table class MODIFY monitor varchar(20);
desc class
insert into class values('159d60faf16c11e78c3f9a214cf093ae','A','laowang','xiaowang');
create table teacher(
    id VARCHAR(32) not null primary key,
    name varchar(20) UNIQUE,
    gender varchar(10),
    age INT,
    course varchar(20),
    classfor varchar(20)
)
desc teacher;
insert into teacher values('159d63a2f16c11e78c3f9a214cf093ae','laowang','man','40','chinese','A');
create table student(
    id VARCHAR(32) not null primary key,
    name varchar(20) UNIQUE,
    gender varchar(10),
    age INT,
    classin varchar(20)
)
#alter table student MODIFY classin varchar(20) UNIQUE;
desc student;

入门案例：

先上案例，Mybatis有多种使用方式，大致有如下几种：

无mapper类，最传统的用法

maven依赖：

<dependency>
  <groupId>mysqlgroupId>
  <artifactId>mysql-connector-javaartifactId>
  <version>6.0.6version>
dependency>
<dependency>
  <groupId>org.mybatisgroupId>
  <artifactId>mybatisartifactId>
  <version>3.4.2version>
dependency>

配置文件

<configuration>
  
  
  <properties resource="db.properties"/>
  <environments default="development">
    <environment id="development">
      <transactionManager type="JDBC"/>
      <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>
  <mappers>
    
    <mapper resource="mymapper.xml"/>
  mappers>
configuration>

properties配置文件：

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8
username=root
password=guanhang

mapper配置文件：

<mapper namespace="test">
  
  <select id="findStudent" parameterType="string" resultType="com.guanhang.pjo.Student">
    select * FROM student WHERE name = #{name}
  select>
mapper>

测试：

public static void main(String[] args) throws IOException {
    InputStream resourceAsStream = Resources.getResourceAsStream("config.xml");
    SqlSessionFactory build = new SqlSessionFactoryBuilder().build(resourceAsStream);
    SqlSession sqlSession = build.openSession();
    Object xiaozhang = sqlSession.selectOne("test.findStudent", "xiaozhang");
    System.out.println(xiaozhang);
}

使用mybatis generator

一键生成所有相关代码（bean,sql语句,mapper接口）

generator的配置：

<generatorConfiguration>
  
  <classPathEntry location="/Users/guanhang/Soft/mysql-connector-java-5.1.8.jar"/>

  <context id="context" targetRuntime="MyBatis3">
    <commentGenerator>
      <property name="suppressAllComments" value="true"/>
      <property name="suppressDate" value="true"/>
    commentGenerator>

    <jdbcConnection userId="root" password="guanhang" driverClass="com.mysql.jdbc.Driver" connectionURL="jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8"/>

    <javaTypeResolver>
      <property name="forceBigDecimals" value="false"/>
    javaTypeResolver>
    
    <javaModelGenerator targetPackage="com.guanhang" targetProject="src/main/java">
      <property name="enableSubPackages" value="false"/>
      <property name="trimStrings" value="true"/>
    javaModelGenerator>

    <sqlMapGenerator targetPackage="resources" targetProject="src/main">
      <property name="enableSubPackages" value="false"/>
    sqlMapGenerator>

    <javaClientGenerator targetPackage="com.guanhang.mapper" type="XMLMAPPER" targetProject="src/main/java">
      <property name="enableSubPackages" value="false"/>
    javaClientGenerator>
    
    <table schema="mybatis" tableName="student" enableCountByExample="true" enableDeleteByExample="true"
           enableSelectByExample="true" enableUpdateByExample="true"/>
  context>
generatorConfiguration>

pom中添加generator插件

<build>
  <plugins>
    <plugin>
      <groupId>org.mybatis.generatorgroupId>
      <artifactId>mybatis-generator-maven-pluginartifactId>
      <version>1.3.3version>
      <configuration>
        
        <configurationFile>src/main/resources/mygenerator.xmlconfigurationFile>
        <overwrite>trueoverwrite>
      configuration>
    plugin>
  plugins>
build>

在maven的插件列表中，运行该插件就会生成需要的文件

测试代码：

public static void main(String[] args) throws IOException {
    StudentExample student = new StudentExample();
    student.createCriteria().andNameEqualTo("xiaozhang");
    InputStream resourceAsStream = Resources.getResourceAsStream("config.xml");
    SqlSessionFactory build = new SqlSessionFactoryBuilder().build(resourceAsStream);
    SqlSession sqlSession = build.openSession();
    StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
    List students = mapper.selectByExample(student);
    System.out.println(students);
}

注意事项：

测试时，config中的mapper文件要对应上

多次运行generateor插件会继续在原有xml内容上再添加生成的内容，不会覆盖，这会导致xml中的内容重复，解析出错

使用mybatis-generator, mybatis-spring整合

实际开发最常用方法

使用spring后，数据库的链接配置可以放在spring中,SqlSession的获取也不用手动new出来

首先中pom中增加依赖：

<dependencies>
  <dependency>
    <groupId>junitgroupId>
    <artifactId>junitartifactId>
    <version>4.12version>
    <scope>testscope>
  dependency>
  <dependency>
    <groupId>mysqlgroupId>
    <artifactId>mysql-connector-javaartifactId>
    <version>6.0.6version>
  dependency>
  <dependency>
    <groupId>org.mybatisgroupId>
    <artifactId>mybatisartifactId>
    <version>3.4.2version>
  dependency>
  
  <dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-contextartifactId>
    <version>4.3.12.RELEASEversion>
  dependency>
  
  <dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-coreartifactId>
    <version>4.3.12.RELEASEversion>
  dependency>
  
  <dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-beansartifactId>
    <version>4.3.12.RELEASEversion>
  dependency>
  
  <dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-testartifactId>
    <version>4.3.12.RELEASEversion>
    <scope>testscope>
  dependency>
  
  <dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-aopartifactId>
    <version>4.3.12.RELEASEversion>
  dependency>
  <dependency>
    <groupId>org.aspectjgroupId>
    <artifactId>aspectjweaverartifactId>
    <version>1.8.6version>
  dependency>
  
  <dependency>
    <groupId>org.apache.commonsgroupId>
    <artifactId>commons-dbcp2artifactId>
    <version>2.2.0version>
  dependency>
  
  <dependency>
    <groupId>org.mybatisgroupId>
    <artifactId>mybatis-springartifactId>
    <version>1.3.0version>
  dependency>
  
  <dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-jdbcartifactId>
    <version>4.3.8.RELEASEversion>
  dependency>
dependencies>
<build>
  <plugins>
    <plugin>
      <groupId>org.mybatis.generatorgroupId>
      <artifactId>mybatis-generator-maven-pluginartifactId>
      <version>1.3.3version>
      <configuration>
        <configurationFile>src/main/resources/mygenerator.xmlconfigurationFile>
        <overwrite>trueoverwrite>
      configuration>
    plugin>
  plugins>
build>

spring的配置：

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">
  <context:component-scan base-package="com.guanhang"/>
  
  <context:property-placeholder location="classpath:db.properties" />
  
  <bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource"
        destroy-method="close">
    <property name="driverClassName" value="${driver}" />
    <property name="url" value="${url}" />
    <property name="username" value="${username}" />
    <property name="password" value="${password}" />
    <property name="maxTotal" value="10" />
    <property name="maxIdle" value="5" />
  bean>
  
  
  <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    
    <property name="dataSource" ref="dataSource" />
    <property name="mapperLocations" value="classpath:mapper/StudentMapper.xml"/>
  bean>
  
  <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <property name="basePackage" value="com.guanhang.mapper"/>
  bean>
beans>

新增Service类（下面的类名字虽然为Dao，实际是个Service类，和Spring整合后，不需要自己写Dao）

@Component
public class MybatisDao {
    @Autowired
    public StudentMapper mapper;//自动生成的mapper类

    public void quey(StudentExample student) {
        List students = mapper.selectByExample(student);
        System.out.println(students.toString());

    }
    public StudentMapper getMapper() {
        return mapper;
    }
    public void setMapper(StudentMapper mapper) {
        this.mapper = mapper;
    }
}

测试类：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:spring/mybatisspring.xml")
public class MybatisTest {
    @Autowired
    private MybatisDao mybatisDao;
    @Test
    public void test() {
        StudentExample studentExample = new StudentExample();
        studentExample.createCriteria().andNameEqualTo("xiaowang");
        mybatisDao.quey(studentExample);

    }
}

可以看到整个过程非常简洁，而且代码上没有和mybatis的耦合。同时也注意到这里没有了mybatis的配置（config) 文件（除非有一些定制的setting，不然不用配置文件)

番外篇

一些问题的延伸

数据库N+1查询问题

比如查询用户，用户关联部门，会查出n个用户，需要查询n次部门，查询用户是1次，因此机会出现n+1问题

问题：

虽然我们调用了批量查询的接口，但可能实际上我们只是用其中一条数据，这就会导致性能浪费

解决办法：

在association标签中加上 fetchType=lazy

这样从查询结果中取值时(user.getName等操作)才会实际去查询数据库

官方文档

主要分成三部分：

1. Mybatis基本知识及使用
2. Mybatis和Spring整合
3. Mybatis generator的使用

Mybatis Generator

简单翻译一下官网的东西，http://www.mybatis.org/generator/quickstart.html

作用

能够自动生成MyBatis的相关代码和配置文件，如：

1. java pojos 即相关的java bean
2. mybatis的mapper配置文件以及其需要的SQL语句
3. java client类文件（就是mapper的接口类，可选）

注意事项：

1. 自动生成机制会合并XML文件，并且对于你在该文件中修改的东西不会覆盖（接续写入）
2. 自动生成机制不会合并java 文件，会覆盖或者创建一个新的类（重新写入）

简单入门

配置

1. 需要一个配置文件，并且起码需要以下几个配置

   1. A element to specify how to connect to the target database

      一个jdbcConnection元素来配置连接的数据库

   2. A element to specify target package and target project for generated Java model objects

      给生成的java模型配置目标项目的包路径

   3. A element to specify target package and target project for generated SQL map files

      给生成的xml配置文件指定目标项目的包路径

   4. (可选) A element to specify target package and target project for generated client interfaces and classes (you may omit the element if you don’t wish to generate Java client code)

      可选：给生成的java client接口以及类配置文件指定目标项目的包路径

   5. At least one database

      element

      至少一个数据库table的配置元素

      运行

      运行下面这句话来执行generator，产生相关的文件，注意-overwrite不加的话，如果java文件出现冲突，将会重命名生成的文件

      java -jar mybatis-generator-core-x.x.x.jar -configfile \temp\generatorConfig.xml -overwrite

      官方xml配置参考

      
      
      
      <generatorConfiguration>
      
        <classPathEntry location="/Program Files/IBM/SQLLIB/java/db2java.zip" />
      
        <context id="DB2Tables" targetRuntime="MyBatis3">
          <jdbcConnection driverClass="COM.ibm.db2.jdbc.app.DB2Driver"
              connectionURL="jdbc:db2:TEST"
              userId="db2admin"
              password="db2admin">
          jdbcConnection>
      
          <javaTypeResolver >
            <property name="forceBigDecimals" value="false" />
          javaTypeResolver>
          
          <javaModelGenerator targetPackage="test.model" targetProject="\MBGTestProject\src">
            <property name="enableSubPackages" value="true" />
            <property name="trimStrings" value="true" />
          javaModelGenerator>
      
          <sqlMapGenerator targetPackage="test.xml"  targetProject="\MBGTestProject\src">
            <property name="enableSubPackages" value="true" />
          sqlMapGenerator>
      
          <javaClientGenerator type="XMLMAPPER" targetPackage="test.dao"  targetProject="\MBGTestProject\src">
            <property name="enableSubPackages" value="true" />
          javaClientGenerator>
      
          <table schema="DB2ADMIN" tableName="ALLTYPES" domainObjectName="Customer" >
            <property name="useActualColumnNames" value="true"/>
            <generatedKey column="ID" sqlStatement="DB2" identity="true" />
            <columnOverride column="DATE_FIELD" property="startDate" />
            <ignoreColumn column="FRED" />
            <columnOverride column="LONG_VARCHAR_FIELD" jdbcType="VARCHAR" />
          table>
      
        context>
      generatorConfiguration>
      

      代码生成的generator案例：

      generator配置：

      
      
      
      <generatorConfiguration>
          <context id="testTables" targetRuntime="MyBatis3">
              <commentGenerator>
                  
                  <property name="suppressAllComments" value="true" />
              commentGenerator>
              
              <jdbcConnection driverClass="com.mysql.jdbc.Driver"
                  connectionURL="jdbc:mysql://localhost:3306/mybatis" userId="root"
                  password="admin">
              jdbcConnection>
              
      
              
              <javaTypeResolver>
                  <property name="forceBigDecimals" value="false" />
              javaTypeResolver>
      
              
              <javaModelGenerator targetPackage="cn.itheima.pojo"
                  targetProject=".\src">
                  
                  <property name="enableSubPackages" value="false" />
                  
                  <property name="trimStrings" value="true" />
              javaModelGenerator>
              
              <sqlMapGenerator targetPackage="cn.itheima.mapper" 
                  targetProject=".\src">
                  
                  <property name="enableSubPackages" value="false" />
              sqlMapGenerator>
              
              <javaClientGenerator type="XMLMAPPER"
                  targetPackage="cn.itheima.mapper" 
                  targetProject=".\src">
                  
                  <property name="enableSubPackages" value="false" />
              javaClientGenerator>
              
      
              <table tableName="orders">table>
      
              <table tableName="user">table>
              
      
              
          context>
      generatorConfiguration>
      

      使用java代码生成(非插件或者plugin形式)：

      package generator0523;
      
      import java.io.File;
      import java.util.ArrayList;
      import java.util.List;
      
      import org.mybatis.generator.api.MyBatisGenerator;
      import org.mybatis.generator.config.Configuration;
      import org.mybatis.generator.config.xml.ConfigurationParser;
      import org.mybatis.generator.internal.DefaultShellCallback;
      
      public class StartServer {
      
          public void generator() throws Exception{
              List warnings = new ArrayList();
              boolean overwrite = true;
              File configFile = new File("genarator.xml"); 
              ConfigurationParser cp = new ConfigurationParser(warnings);
              Configuration config = cp.parseConfiguration(configFile);
              DefaultShellCallback callback = new DefaultShellCallback(overwrite);
              MyBatisGenerator myBatisGenerator = new MyBatisGenerator(config,
                      callback, warnings);
              myBatisGenerator.generate(null);
          }
      
          public static void main(String[] args) throws Exception {
              try {
                  StartServer startServer = new StartServer();
                  startServer.generator();
              } catch (Exception e) {
                  e.printStackTrace();
              }
          }
      }

      Mybatis和Spring整合

      总体思路：

      核心思想：跟Spring结合，实际就是管理bean

      SqlSessionFactory等价于SqlSessionFactoryBean（变成了spirng里面的bean）

      SqlSessionTemplate包装了一层SqlSessionFactory, 也可以拿到Session（线程安全）

      MapperFactoryBean是创建Mapper的bean，它依赖sqlSessionFactory（SqlSessionTemplate）和mapper配置文件（毕竟这东西拿来就是直接访问数据库的，属于配置的最终的一环）

      但是创建MapperFactoryBean一个一个配不方便，于是有提供了三种自动扫描（自动装配sqlSessionFactory，SqlSessionTemplate，创建MapperFactoryBean）的方式

      总之最少需要2个东西就能玩转：

      SqlSessionFactory

      MapperFactoryBean（不用显式配置上面的SqlSessionFactory）

      简单使用

      首先要引入jar包

      <dependency>
        <groupId>org.mybatisgroupId>
        <artifactId>mybatis-springartifactId>
        <version>x.x.xversion>
      dependency>

      需要在Spring上下文中至少定义两个东西：

      1. SqlSessionFactory
      2. 数据映射器类

      注：其实一般还要配置连接池dataSource

      sqlSessionFactory的Spring配置

      
      <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
      bean>

      Mapper类：

      public interface UserMapper {
        @Select("SELECT * FROM users WHERE id = #{userId}")
        User getUser(@Param("userId") String userId);
      } 

      mapper的Spring配置：

      id="userMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
        <property name="mapperInterface" value="org.mybatis.spring.sample.mapper.UserMapper" />
        <property name="sqlSessionFactory" ref="sqlSessionFactory" />
      

      所指定的映射器类必须是一个接口,而不是具体的实现类(因为Mybatis会动态代理创建)

      如果使用 了 Spring 的事务,那么当事务完成时,session 将会提交或回滚。最终,任何异常都会被翻译成 Spring 的 DataAccessException 异常。

      调用 MyBatis 数据方法现在只需一行代码:

      public class FooServiceImpl implements FooService {
      
      private UserMapper userMapper;
      
      public void setUserMapper(UserMapper userMapper) {
        this.userMapper = userMapper;
      }
      
      public User doSomeBusinessStuff(String userId) {
        return this.userMapper.getUser(userId);
      }

      SqlSessionFactoryBean

      要注意 SqlSessionFactoryBean 实现了 Spring 的 FactoryBean 接口, 这就说明了由 Spring 最终创建的 bean 不是 SqlSessionFactoryBean 本身, 而是工厂类的 getObject()返回的方法的结果。这种情况下,Spring 将会在应用启动时为你创建 SqlSessionFactory 对象,然后将它以 SqlSessionFactory 为名来存储。在 Java 中, 相同的代码是:

      SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
      SqlSessionFactory sessionFactory = factoryBean.getObject();

      mybatis的配置文件

      SqlSessionFactory配置中，dataSource是必配的，还有一个常用的属性是 configLocation（不是必须）,它是用来指定 MyBatis 的 XML 配置文件路径的(注意不是SQL映射的XML的配置文件),一般 或的需要改动的时候才会用的上个配置。

      本人注： 难道其他的改动不需要用这个配置吗？

      实际上，这是由于configLocation可以不是完整的，因为dataSource、environments、以及mybatis的事务管理器的配置是在Spring中可以配置的（配置SqlSessionFactory的时候）。因此这些配置即使配了，也会被忽略，SqlSessionFactoryBean会创建属于自己的Mybatis Environment

      另外，如果mapper xml的配置文件和mapper接口类不是在同一个类路径下，也要对mapper的xml映射文件进行配置：

      <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="mapperLocations" value="classpath*:sample/config/mappers/**/*.xml" />
      bean>

      classpath 和 classpath* 区别：

      classpath：只会到你指定的class路径中查找找文件;

      classpath*：不仅包含class路径，还包括jar文件中(class路径)进行查找

      多数据库配置

      id="vendorProperties" class="org.springframework.beans.factory.config.PropertiesFactoryBean">
          <property name="properties">
              
                  <prop key="SQL Server">sqlserverprop>
                  <prop key="DB2">db2prop>
                  <prop key="Oracle">oracleprop>
                  <prop key="MySQL">mysqlprop>
              
          property>
      
      
      id="databaseIdProvider" class="org.apache.ibatis.mapping.VendorDatabaseIdProvider">
          <property name="properties" ref="vendorProperties"/>
      
      
      id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
          <property name="dataSource" ref="dataSource" />
          <property name="mapperLocations" value="classpath*:sample/config/mappers/**/*.xml" />
          <property name="databaseIdProvider" ref="databaseIdProvider"/>
      

      configuration属性

      1.3.0后新加的属性，可以在spring中进行配置

      <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="configuration">
          
          <bean class="org.apache.ibatis.session.Configuration">
            
            <property name="mapUnderscoreToCamelCase" value="true"/>
          bean>
        property>
      bean>

      事务配置

      一个使用 MyBatis-Spring 的主要原因是它允许 MyBatis 参与到 Spring 的事务管理中。而不是给 MyBatis 创建一个新的特定的事务管理器,MyBatis-Spring 利用了存在于 Spring 中的 DataSourceTransactionManager来管理事务. 事务执行期间，Spring会创建一个SqlSession来执行相关操作，这个session在事务结束时执行commit或者rollback

      标准配置：

      id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
      

      注意：这里面配置的dataSource要和SqlSessionFactoryBean中配置的一致

      容器事务管理

      如果你正使用一个 JEE 容器而且想让 Spring 参与到容器管理事务(Container managed transactions,CMT,译者注)中,那么 Spring 应该使用 JtaTransactionManager 或它的指定容器的子类来配置。做这件事情的最方便的方式是用 Spring 的事务命名空间:

      <tx:jta-transaction-manager />

      在这种配置中,MyBatis 将会和其它由 CMT 配置的 Spring 事务资源一样。Spring 会自动 使用任意存在的容器事务,然后附加一个 SqlSession。如果没有开始事务,但是需要基于事务配置,Spring 会开启一个新的容器管理事务。

      注 意 , 如 果 你 想 使 用 CMT , 而 不 想 使 用 Spring 的 事 务 管 理 , 你 就 必 须 配 置 SqlSessionFactoryBean 来使用基本的 MyBatis 的 ManagedTransactionFactory 而不是其 它任意的 Spring 事务管理器:

      id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="transactionFactory">
          class="org.apache.ibatis.transaction.managed.ManagedTransactionFactory" />
        property>  
      

      编程式事务管理：

      MyBatis 的 SqlSession 提供特定的方法来处理编程式的事务。 但是当使用 MyBatis-Spring 时, 将会注入 Spring 管理的 SqlSession 或映射器。 那就是说事务将由Spring来处理。

      你 不 能 在 Spring 管 理 的 SqlSession 上 调 用 SqlSession.commit() , SqlSession.rollback() 或 SqlSession.close() 方 法 。 如果这样做了 , 就会抛出UnsupportedOperationException异常。注意在使用注入的映射器时不能访问那些方法。

      无论 JDBC 连接是否设置为自动提交, SqlSession 数据方法的执行或在 Spring 事务之外任意调用映射器方法都将会自动被提交。

      如果你想编程式地控制事务,请参考后面的内容。这段代码展示了如何手动使用 PlatformTransactionManager 来处理事务。

      DefaultTransactionDefinition def = new DefaultTransactionDefinition();
      def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
      
      TransactionStatus status = txManager.getTransaction(def);
      try {
        userMapper.insertUser(user);
      }
      catch (MyException ex) {
        txManager.rollback(status);
        throw ex;
      }
      txManager.commit(status);

      注意这段代码展示了一个映射器,但它也能和 SqlSession 一起使用。

      使用SqlSession

      在 MyBatis 中,你可以使用 SqlSessionFactory 来创建 SqlSession。一旦你获得一个 session 之后,你可以使用它来执行映射语句,提交或回滚连接,最后,当不再需要它的时 候, 你可以关闭 session。 使用 MyBatis-Spring 之后, 你不再需要直接使用 SqlSessionFactory 了,因为会注入一个线程安全的 SqlSession ,基于 Spring 的事务配置来自动提交,回滚,关闭 session。

      SqlSessionTemplate

      SqlSessionTemplate是整合中的核心类，这个类负责管理 MyBatis 的 SqlSession, 调用 MyBatis 的 SQL 方法, 翻译异常。 SqlSessionTemplate 是线程安全的, 可以被多个 DAO 所共享使用。

      当调用 SQL 方法时, 包含从映射器 getMapper()方法返回的方法, SqlSessionTemplate 将会保证使用的 SqlSession是和当前Spring 的事务相关的。此外,它管理 session 的生命 周期,包含必要的关闭,提交或回滚操作

      SqlSessionTemplate 对象可以使用 SqlSessionFactory 作为构造方法的参数来创建。

      <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <constructor-arg index="0" ref="sqlSessionFactory" />
      bean>

      这个 bean 现在可以直接注入到 DAO bean 中。你需要在 bean 中添加一个 SqlSession 属性,就像下面的代码:

      public class UserDaoImpl implements UserDao {
        private SqlSession sqlSession;
        public void setSqlSession(SqlSession sqlSession) {
          this.sqlSession = sqlSession;
        }
        public User getUser(String userId) {
          return (User) sqlSession.selectOne("org.mybatis.spring.sample.mapper.UserMapper.getUser", userId);
        }
      }

      如下注入 SqlSessionTemplate:

      <bean id="userDao" class="org.mybatis.spring.sample.dao.UserDaoImpl">
        <property name="sqlSession" ref="sqlSession" />
      bean>

      SqlSessionTemplate 有一个使用 ExecutorType 作为参数的构造方法。这允许你用来创建对象,比如,一个批量 SqlSession，使用了下列 Spring 配置的 XML 文件:

      <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <constructor-arg index="0" ref="sqlSessionFactory" />
        <constructor-arg index="1" value="BATCH" />
      bean>

      现在你所有的语句可以批量操作了,下面的语句就可以在 DAO 中使用了。

      public void insertUsers(User[] users) {
         for (User user : users) {
           sqlSession.insert("org.mybatis.spring.sample.mapper.UserMapper.insertUser", user);
         }
       }

      一般是期望的执行方法和SqlSessionFactory默认的设置不匹配的情况下使用（比如上面的多个User insert）

      需要注意的是，使用该方法时，不能存在另一个，ExecutorType不一样的事务,要不保证使用不同ExecutorType调用SqlSessionTemplate时是在不同的事务中，要不完全在事务之外。

      SqlSessionDaoSupport

      SqlSessionDaoSupport是一个抽象类，能够提供一个SqlSession. 调用 getSqlSession()方法你会得到一个 SqlSessionTemplate,之后可以用于执行 SQL 方法, 就像下面这样:

      public class UserDaoImpl extends SqlSessionDaoSupport implements UserDao {
        public User getUser(String userId) {
          return (User) getSqlSession().selectOne("org.mybatis.spring.sample.mapper.UserMapper.getUser", userId);
        }
      }

      一般情况下会用MapperFactoryBean,但是如果有一些其他的事情需要做，可以使用这个抽象类，SqlSessionDaoSupprot依赖SqlSessionFactory或者一个SqlSessionFactoryTemplate的属性，如果两者都设置了，SqlSessionFactory属性将会被忽略。注入方法：

      id="userMapper" class="org.mybatis.spring.sample.mapper.UserDaoImpl">
        <property name="sqlSessionFactory" ref="sqlSessionFactory" />
      

      注入映射器

      为了代替手工使用 SqlSessionDaoSupport 或 SqlSessionTemplate 编写数据访问对象 (DAO)的代码,MyBatis-Spring 提供了一个动态代理的实现:MapperFactoryBean。这个类可以让你直接注入数据映射器接口到你的 service 层 bean 中。当使用映射器时,你仅仅如调 用你的DAO一样调用它们就可以了,但是你不需要编写任何 DAO 实现的代码,因为 MyBatis-Spring 将会为你创建代理。

      <bean id="fooService" class="org.mybatis.spring.sample.mapper.FooServiceImpl">
        
        <property name="userMapper" ref="userMapper" />
      bean>

      使用：

      注意：这里未使用任何MyBatis的API，起到了解耦的作用

      public class FooServiceImpl implements FooService {
        private UserMapper userMapper;
        public void setUserMapper(UserMapper userMapper) {
          this.userMapper = userMapper;
        }
        public User doSomeBusinessStuff(String userId) {
          return this.userMapper.getUser(userId);
        }
      }

      注册一个mapper

      如果使用的是spring XML的配置：

      UserMapper的相同类路径下应该有一个同名的mapper xml配置文件，如果位置不同，参考前面的configLocation属性：

      id="userMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
        <property name="mapperInterface" value="org.mybatis.spring.sample.mapper.UserMapper" />
        <property name="sqlSessionFactory" ref="sqlSessionFactory" />
      

      如果采用的是java注解的方式：

      可以从SqlSessionTemplate中拿到mapper，但是注意的是，不要从session中获取mapper，因为session是线程不安全的，要使用SqlSessionTemplate

      @Bean
      public SqlSessionFactory sqlSessionFactory() throws Exception {
          SqlSessionFactoryBean sqlSessionFactory = new SqlSessionFactoryBean();
          sqlSessionFactory.setDataSource(dataSource());
          return (SqlSessionFactory) sqlSessionFactory.getObject();
      }
      
      @Bean
      public UserMapper userMapper() throws Exception {
          SqlSessionTemplate sessionTemplate = new SqlSessionTemplate(sqlSessionFactory());
          return sessionTemplate.getMapper(UserMapper.class);
      }

      注意：MapperFactoryBean需要一个SqlSessionFactory或者一个SqlSessionTmplate，如果两者都设置了，SqlSessionFactory将会被忽略

      Mapper的扫描

      不需要一个一个配置mapper(手动配置MapperFactoryBean)，可以通过classpath来加载它们

      有三种方法来做：

      1. 使用
      2. 使用注解@MapperScan
      3. 使用xml配置文件：注册MapperScannerConfigurer

      第一种方法：

      <beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:mybatis="http://mybatis.org/schema/mybatis-spring"
        xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://mybatis.org/schema/mybatis-spring http://mybatis.org/schema/mybatis-spring.xsd">
      
        <mybatis:scan base-package="org.mybatis.spring.sample.mapper" />
      beans>

      Base-package可以设置多个，使用分号和逗号分隔

      注 意 , 没有必要去指定SqlSessionFactory或SqlSessionTemplate （第三种方法也一样）, 因为它将会创建 MapperFactoryBean,之后自动装配。但是,如果你使用了一个以上的DataSource ,那么自动装配可能会失效 。这种情况下 ,可以使用factory-ref或者template-ref属性来设置正确的bean

      scan标签是通过一个标记接口或者注解来过滤mapper的。annotation属性用来指定哪些注解要被过滤，marker-interface属性则是定一个父接口来扫描。如果两个都设置了，符合这两个条件的maper接口被当成mapper接口。默认的情况下，这两个属性都是null，这样，在给定包下的所有接口，都被当成mapper。

      mapper的发现类似于Spring的命名策略。默认是首字母小写，但是如果有@Component或者@Named的注解，mapper的名字将会由这些注解指定.也可以讲annotation属性设置为org.springframework.stereotype.Component,javax.inject.Named，这样这些注解既可以当spring的注解，又可以当mapper的扫描注解。

      第二种方法：

      如果使用了spring的Configuration标签，可以使用@MapperScan注解来配合使用

      @Configuration
      @MapperScan("org.mybatis.spring.sample.mapper")
      public class AppConfig {
      
        @Bean
        public DataSource dataSource() {
          return new EmbeddedDatabaseBuilder().addScript("schema.sql").build()
        }
      
        @Bean
        public SqlSessionFactory sqlSessionFactory() throws Exception {
          SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
          sessionFactory.setDataSource(dataSource());
          return sessionFactory.getObject();
        }
      }

      这和上面的scan标签使用方法差不多，可以配置markerInterface和annotationClass，也可以配置SqlSessionFactory或者SqlSessionTemplate

      第三种方法：

      创建 MapperScannerConfigurer,会自动会生成MapperFactoryBean(实际上跟第一种方法差不多，就是xml配置和注册类的区别)，可以在 Spring 的配置中添加如下代码:

      <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="org.mybatis.spring.sample.mapper" />
      bean>

      如果需要指定sqlSessionFactory或者sqlSessionTemplate属性时,注意bean的name是必须的，不是bean的引用，所这里使用的value而不是引用

      <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />

      注意：之前版本使用的sqlSessionFactoryBean和sqlSessionTemplate属性可能会导致一些bug，已经被废弃。

      可以使使用sqlSessionFactoryBeanName and sqlSessionTemplateBeanName来代替

      Mybatis基本知识

      入门

      每个基于 MyBatis 的应用都是以一个 SqlSessionFactory 的实例为中心的。SqlSessionFactory 的实例可以通过 SqlSessionFactoryBuilder 获得。而 SqlSessionFactoryBuilder 则可以从 XML 配置文件或一个预先定制的 Configuration 的实例构建出 SqlSessionFactory 的实例

      使用代码加载配置文件：

      String resource = "org/mybatis/example/mybatis-config.xml";
      InputStream inputStream = Resources.getResourceAsStream(resource);
      SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

      数据库配置文件写法：

      
      
      <configuration>
        <environments default="development">
          <environment id="development">
            <transactionManager type="JDBC"/>
            <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>
        <mappers>
          <mapper resource="org/mybatis/example/BlogMapper.xml"/>
        mappers>
      configuration>

      不使用xml构建SqlSessionFactory：

      DataSource dataSource = BlogDataSourceFactory.getBlogDataSource();
      TransactionFactory transactionFactory = new JdbcTransactionFactory();
      Environment environment = new Environment("development", transactionFactory, dataSource);
      Configuration configuration = new Configuration(environment);
      configuration.addMapper(BlogMapper.class);
      SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(configuration);

      说明：

      1. 从代码中可以看出来拿到一个SqlSession是一个怎样的过程，可见，通过XML配置的方式，内部肯定也是走的差不多的流程，方便看源码对应上
      2. configuration.addMapper(BlogMapper.class)获取了一个映射类，实际的目的是为了获取对应的sql语句。如果在该类的路径下有相同名称的xml配置文件（配置了sql），也将会被加载进来解析；如果没有，那么这个映射类应该有注解形式的sql语句

      获取和使用SqlSession：

      SqlSession 完全包含了面向数据库执行 SQL 命令所需的所有方法。你可以通过 SqlSession 实例来直接执行已映射的 SQL 语句

      //老版本的使用方法
      SqlSession session = sqlSessionFactory.openSession();
      try {
        Blog blog = (Blog) session.selectOne("org.mybatis.example.BlogMapper.selectBlog", 101);
      } finally {
        session.close();
      }
      //新版本的使用方法
      SqlSession session = sqlSessionFactory.openSession();
      try {
        BlogMapper mapper = session.getMapper(BlogMapper.class);
        Blog blog = mapper.selectBlog(101);
      } finally {
        session.close();
      }

      映射的sql语句

      有两种方式映射sql语句：

      1. 通过xml配置（**Mapper.xml）

         xml中的命名空间（namespace）要和mapper类一致，这样才能对应上

      2. 通过注解来映射

      注意：

      1. 命名空间（Namespaces）在之前版本的 MyBatis 中是可选的，容易引起混淆因此是没有益处的。现在的命名空间则是必须的，目的是希望能比只是简单的使用更长的完全限定名来更进一步区分语句。

      2. 所有的命名解析规则：

         完全限定名（比如“com.mypackage.MyMapper.selectAllThings”）将被直接查找并且找到即用；

         短名称（比如“selectAllThings”）如果全局唯一也可以作为一个单独的引用。如果不唯一，有两个或两个以上的相同名称（比如“com.foo.selectAllThings ”和“com.bar.selectAllThings”），那么使用时就会收到错误报告说短名称是不唯一的，这种情况下就必须使用完全限定名。

      java注解方式：

      package org.mybatis.example;
      public interface BlogMapper {
        @Select("SELECT * FROM blog WHERE id = #{id}")
        Blog selectBlog(int id);
      }

      作用域

      作用域在并发使用时很重要

      依赖注入框架可以创建线程安全的、基于事务的 SqlSession 和映射器（mapper）并将它们直接注入到你的 bean 中，因此可以直接忽略它们的生命周期

      SqlSessionFactoryBuilder: 作为方法的局部变量

      这个类可以被实例化、使用和丢弃，一旦创建了 SqlSessionFactory，就不再需要它.因此 SqlSessionFactoryBuilder 实例的最佳作用域是方法作用域（也就是局部方法变量）

      SqlSessionFactory:作为一个应用的单例对象

      SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在，没有任何理由对它进行清除或重建。使用 SqlSessionFactory 的最佳实践是在应用运行期间不要重复创建多次，多次重建 SqlSessionFactory 被视为一种代码“坏味道（bad smell）”。因此 SqlSessionFactory 的最佳作用域是应用作用域。有很多方法可以做到，最简单的就是使用单例模式或者静态单例模式

      SqlSession:不能共享，作用于方法区域

      映射器是创建用来绑定映射语句的接口。映射器接口的实例是从 SqlSession 中获得的。因此从技术层面讲，映射器实例的最大作用域是和 SqlSession 相同的，因为它们都是从 SqlSession 里被请求的。尽管如此，映射器实例的最佳作用域是方法作用域。也就是说，映射器实例应该在调用它们的方法中被请求，用过之后即可废弃。并不需要显式地关闭映射器实例，尽管在整个请求作用域（request scope）保持映射器实例也不会有什么问题，但是很快你会发现，像 SqlSession 一样，在这个作用域上管理太多的资源的话会难于控制。所以要保持简单，最好把映射器放在方法作用域（method scope）内

      XML配置

      配置Properties

      可以引入外部的properties，可以外部配置以及动态替换

      也可以不引入(不加resource)，直接在下面配置property

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

      优先级：

      • 在 properties 元素体内指定的属性首先被读取。
      • 然后根据 properties 元素中的 resource 属性读取类路径下属性文件或根据 url 属性指定的路径读取属性文件，并覆盖已读取的同名属性。
      • 最后读取作为方法参数传递的属性，并覆盖已读取的同名属性。

      因此，通过方法参数传递的属性具有最高优先级，resource/url 属性中指定的配置文件次之，最低优先级的是 properties 属性中指定的属性

      property指定属性的默认值：

      <dataSource type="POOLED">
        
        <property name="username" value="${username:ut_user}"/> 
      dataSource>

      但是这个特性是关闭，需要手动开启：

      <properties resource="org/mybatis/example/config.properties">
        
        <property name="org.apache.ibatis.parsing.PropertyParser.enable-default-value" value="true"/> 
      properties>

      也可以指定默认值的分隔符（：可能被用作其他含义）：

      <properties resource="org/mybatis/example/config.properties">
        
        <property name="org.apache.ibatis.parsing.PropertyParser.default-value-separator" value="?:"/> 
      properties>
      
      <dataSource type="POOLED">
        
        <property name="username" value="${db:username?:ut_user}"/>
      dataSource>

      settings

      指的是configuration中的settings，详细的参数设置键下面的链接

      链接：http://www.mybatis.org/mybatis-3/zh/configuration.html

      typeAliases

      为java类设置别名，减少限定名的写入，例如：

      <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>

      也可以给整个包设置别名，默认为类的首字母小写：

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

      也可以在java类的上添加注解新增别名：

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

      mybatis有一些内置的基本类型的别名，且大小写不敏感：

      Alias	Mapped Type
      _byte	byte
      _long	long
      _short	short
      _int	int
      _integer	int
      _double	double
      _float	float
      _boolean	boolean
      string	String
      byte	Byte
      long	Long
      short	Short
      int	Integer
      integer	Integer
      double	Double
      float	Float
      boolean	Boolean
      date	Date
      decimal	BigDecimal
      bigdecimal	BigDecimal
      object	Object
      map	Map
      hashmap	HashMap
      list	List
      arraylist	ArrayList
      collection	Collection
      iterator	Iterator

      TypeHandlers

      无论是 MyBatis 在预处理语句（PreparedStatement）中设置一个参数时，还是从结果集中取出一个值时， 都会用类型处理器将获取的值以合适的方式转换成 Java 类型。下表描述了一些默认的类型处理器

      可以重写类型处理器或创建你自己的类型处理器来处理不支持的或非标准的类型。 具体做法为：实现 org.apache.ibatis.type.TypeHandler 接口， 或继承类 org.apache.ibatis.type.BaseTypeHandler， 然后可以选择性地将它映射到一个 JDBC 类型

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

      配置：

      
      <typeHandlers>
        <typeHandler handler="org.mybatis.example.ExampleTypeHandler"/>
      typeHandlers>

      使用上面的TypeHandler会覆盖现有的java String属性和VARCHAR参数 的TypeHandler

      下面这段话原封保留，暂未深入了解

      通过类型处理器的泛型，MyBatis 可以得知该类型处理器处理的 Java 类型，不过这种行为可以通过两种方法改变：

      • 在类型处理器的配置元素（typeHandler element）上增加一个 javaType 属性（比如：javaType="String"）；
      • 在类型处理器的类上（TypeHandler class）增加一个 @MappedTypes 注解来指定与其关联的 Java 类型列表。 如果在 javaType 属性中也同时指定，则注解方式将被忽略。

      可以通过两种方式来指定被关联的 JDBC 类型：

      • 在类型处理器的配置元素上增加一个 jdbcType 属性（比如：jdbcType="VARCHAR"）；
      • 在类型处理器的类上（TypeHandler class）增加一个 @MappedJdbcTypes 注解来指定与其关联的 JDBC 类型列表。 如果在 jdbcType 属性中也同时指定，则注解方式将被忽略。

      当决定在ResultMap中使用某一TypeHandler时，此时java类型是已知的（从结果类型中获得），但是JDBC类型是未知的。 因此Mybatis使用javaType=[TheJavaType], jdbcType=null的组合来选择一个TypeHandler。 这意味着使用@MappedJdbcTypes注解可以*限制*TypeHandler的范围，同时除非显示的设置，否则TypeHandler在ResultMap中将是无效的。 如果希望在ResultMap中使用TypeHandler，那么设置@MappedJdbcTypes注解的includeNullJdbcType=true即可。 然而从Mybatis 3.4.0开始，如果只有一个注册的TypeHandler来处理Java类型，那么它将是ResultMap使用Java类型时的默认值（即使没有includeNullJdbcType=true）。

      自动注册类型处理器:

      注意在使用自动检索（autodiscovery）功能的时候，只能通过注解方式来指定 JDBC 的类型

      
      <typeHandlers>
        <package name="org.mybatis.example"/>
      typeHandlers>

      泛型的类型处理器：

      //GenericTypeHandler.java
      public class GenericTypeHandler<E extends MyObject> extends BaseTypeHandler<E> {
        private Class type;
        public GenericTypeHandler(Class type) {
          if (type == null) throw new IllegalArgumentException("Type argument cannot be null");
          this.type = type;
        }

      处理枚举类型：

      会从 EnumTypeHandler 或者 EnumOrdinalTypeHandler 中选一个来使用

      注意 EnumTypeHandler 在某种意义上来说是比较特别的，其他的处理器只针对某个特定的类，而它不同，它会处理任意继承了 Enum 的类

      不过，我们可能不想存储名字，相反我们的 DBA 会坚持使用整形值代码。那也一样轻而易举： 在配置文件中把 EnumOrdinalTypeHandler 加到 typeHandlers 中即可， 这样每个 RoundingMode 将通过他们的序数值来映射成对应的整形

      
      <typeHandlers>
        <typeHandler handler="org.apache.ibatis.type.EnumOrdinalTypeHandler" javaType="java.math.RoundingMode"/>
      typeHandlers>

      但是怎样能将同样的 Enum 既映射成字符串又映射成整形呢？

      自动映射器（auto-mapper）会自动地选用 EnumOrdinalTypeHandler 来处理， 所以如果我们想用普通的 EnumTypeHandler，就非要为那些 SQL 语句显式地设置要用到的类型处理器不可

      
      
      <mapper namespace="org.apache.ibatis.submitted.rounding.Mapper">
          <resultMap type="org.apache.ibatis.submitted.rounding.User" id="usermap">
              <id column="id" property="id"/>
              <result column="name" property="name"/>
              <result column="funkyNumber" property="funkyNumber"/>
              <result column="roundingMode" property="roundingMode"/>
          resultMap>
      
          <select id="getUser" resultMap="usermap">
              select * from users
          select>
          <insert id="insert">
              insert into users (id, name, funkyNumber, roundingMode) values (
                  #{id}, #{name}, #{funkyNumber}, #{roundingMode}
              )
          insert>
          
          <resultMap type="org.apache.ibatis.submitted.rounding.User" id="usermap2">
              <id column="id" property="id"/>
              <result column="name" property="name"/>
              <result column="funkyNumber" property="funkyNumber"/>
              <result column="roundingMode" property="roundingMode" typeHandler="org.apache.ibatis.type.EnumTypeHandler"/>
          resultMap>
          <select id="getUser2" resultMap="usermap2">
              select * from users2
          select>
          <insert id="insert2">
              insert into users2 (id, name, funkyNumber, roundingMode) values (
                  #{id}, #{name}, #{funkyNumber}, #{roundingMode, typeHandler=org.apache.ibatis.type.EnumTypeHandler}
              )
          insert>
      
      mapper>

      修改对象工厂行为

      MyBatis 每次创建结果对象的新实例时，它都会使用一个对象工厂（ObjectFactory）实例来完成。 默认的对象工厂需要做的仅仅是实例化目标类，要么通过默认构造方法，要么在参数映射存在的时候通过参数构造方法来实例化。 如果想覆盖对象工厂的默认行为，则可以通过创建自己的对象工厂来实现

      // ExampleObjectFactory.java
      public class ExampleObjectFactory extends DefaultObjectFactory {
        public Object create(Class type) {
          return super.create(type);
        }
        public Object create(Class type, List constructorArgTypes, List