2.1 mybatis快速入门

2017-06-04 13:18:14 9,386 4

1 开发环境搭建

1、项目使用maven构建，在pom.xml中引入以下依赖

<!-- mybatis -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.4.0</version>
</dependency>
<!-- mysql数据库驱动 -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.39</version>
</dependency>
<!-- juint测试框架 -->
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
</dependency>

在基础篇开篇中，我们提到过mybatis在工作过程中，依赖数据源(DataSource)，由于mybatis自带了几个简单的DataSource实现，这里我们直接使用mybatis自带的即可，不需要引入其他数据源的依赖。

2、建库建表

数据库使用mysql，在test库中新建一张user表，建表语句如下

CREATE TABLE  user(
  id int,
  name VARCHAR(255) not NULL ,
  age int ,
  PRIMARY KEY (id)
)ENGINE =INNODB DEFAULT CHARSET=utf8;

3、创建java类User，与user表对应

package com.tianshouzhi.mybatis.quickstart.domain;
public class User {
    private int id;
    private String name;
    private int age;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

2 基于XML的使用方式

mybatis的xml配置文件分为2类：

全局配置文件：

主要是进行一些全局配置(废话)，通常命名为mybatis-config.xml。例如前面提到mybatis在操作数据库时需要依赖DataSource获取数据库连接，DataSource应该是全局唯一的，此时就应该在mybatis-config.xml中编写。当然，mybatis-config.xml中还会包含一些mybatis其他全局属性的配置。

映射文件：

通常我们会针对一个表，就建立一个映射文件，因此映射文件可能会有多个。映射文件的命名习惯如下："类名+Mapper.xml"。例如这里要操作的User类，其映射文件名字就应该是UserMapper.xml，表示其是User类的映射文件。而如果还有一个UserAccount类的话，其映射文件名称则应该为UserAccountMapper.xml。下图表示了完整映射关系：

可以看到数据库表和Java实体类，本身都是独立的，我们映射文件来建立数据库表字段和和Java类属性之间的映射关系。

2.1 全局配置文件

在classpath下新建配置文件：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>
    <environments default="development">
        <environment id="development">
            <transactionManager type="MANAGED" />
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver" />
                <property name="url" value="jdbc:mysql://localhost:3306/test"/>
                <!--修改为你自己的用户名密码-->
                <property name="username" value="your username" />  
                <property name="password" value="your password" />
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="mappers/UserMapper.xml"/>
    </mappers>
</configuration>

说明：

cofiguration元素：

全局配置文件的根元素，作为mybatis对配置进行解析的入口

environments元素：

表示环境配置。在实际开发中，我们通常有多个环境，例如开发环境(development)、测试环境(test)、生产环境(production)等，不同的环境的配置都是不同的。因此在environments元素中，可以配置多个表示具体某个环境的environment子元素。而default属性用于指定默认的环境。

environment元素：表示具体的某个环境，以id属性作为标识。每个environment元素内部都必须要配置2个子元素：transactionManager和dataSource。

transactionManager:事务管理器，属性type取值有2个，JDBC|MANAGED。其中：JDBC表示任何对数据库的修改操作，mybatis都会自动开启事务。这里配置的是MANAGED，表示事务由应用程序来控制，也就是我们需要手动的开启事务和提交事务。和spring整合时，开启和提交事务的操作交由spring来管理。
dataSource：表示数据源配置。这个更好理解，因为不同的环境中，我们访问的数据库url、username、password都是不同的，因此在每个environment元素下面都有一个dataSource配置。属性type表示使用的数据源类型，取值有三个：UNPOOLED|POOLED|JNDI，这里指定POOLED，表示使用mybatis自带的PooledDataSource。而dataSource内部通过property元素配置的属性，都是PooledDataSource支持的。注意不同的数据源实现，可以配置的property是不同的。

mappers元素：

表示映射文件列表，前面提到通常我们针对数据库中每张表，都会建立一个映射文件。而在mappers元素中，就通过mapper元素，列出了所有配置文件的路径。例如mapper元素可以通过以下属性指定映射文件的路径：

resource属性：表示映射文件位于classpath下。例如上面的配置中就表示在classpath的mappers目录下，有一个UserMapper.xml映射文件

url属性：使用完全限定资源定位符指定映射文件路径，如file:///var/mappers/AuthorMapper.xml

class属性：通过java类来配置映射关系，可以一个java映射类对应一个xml映射文件

package：如果有多个java映射类，且位于同一个包下面，我们可以直接使用package属性指定包名，不需要为每个java映射配置一个class属性。

最常见的方式还是通过resource属性来指定。

2.2 XML映射文件

在classpath下创建目录mappers，并新建UserMapper.xml映射文件，内容如下：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.tianshouzhi.mybatis.quickstart.mapper.UserMapper">
       <insert id="insert" parameterType="com.tianshouzhi.mybatis.quickstart.domain.User">
             INSERT INTO user(id,name,age) VALUES (#{id},#{name},#{age})
       </insert>
       <select id="selectById" parameterType="int"
             resultType="com.tianshouzhi.mybatis.quickstart.domain.User">
             SELECT id,name,age FROM user where id= #{id}
       </select>
       <select id="selectAll" resultType="com.tianshouzhi.mybatis.quickstart.domain.User">
             SELECT id,name,age FROM user;
       </select>
       <update id="updateById" parameterType="com.tianshouzhi.mybatis.quickstart.domain.User">
             UPDATE user SET name=#{name},age=#{age} WHERE id=#{id}
       </update>
       <delete id="deleteById" parameterType="int">
             DELETE FROM user WHERE id=#{id}
       </delete>
       
       <delete id="deleteAll">
             DELETE * FROM user
       </delete>
</mapper>

配置说明：

mapper元素：

xml映射文件的根元素。namespace属性表示命名空间，不同的xml映射文件namespace必须不同。原因在于mybatis使用namespace.id的方式来唯一定位一个sql，id指的是<mapper>元素中内部包含对的insert、select、update、delete子元素中的id属性。

例如现在还有另外一个mapper文件UserAccountMapper.xml，用于操作user_account表，其也要进行相应的增删改查。在这个配置文件中的<select>元素中，我们可能也设置了id="selectById"，那么只通过id属性无法进行区分，因此有了namespace的概念。

insert、select、delete、update元素：

这四个元素都是mapper文件中表示增删改查操作的子元素，每个子元素都可以配置多个，例如这里配置了两个select元素，我们将sql直接写在这些子元素的内部。每个元素都有一个id属性，通过namespace.id唯一定位这个sql。

前面一直提到，mapper文件是用于定义数据库表字段和java实体属性的映射关系，但是这里好像只看到了一些xml元素中，编写了一些语法有点奇怪sql而已，事实上，映射关系就是通过这种方式已经确定的。关于映射，可以分为正向映射和反向映射(这是笔者自己提出的概念)：

正向映射：指的是，我们通过保存java对象，mybatis将java对象的属性名映射为数据库表字段名。
反向映射：指的是，我们从数据库查询数据，mybatis自动将数据库表字段名映射到对应的java对象属性名。

例如对于insert、update，使用了mybatis之后，我们在代码中插入和更新的都是一个java对象，由mybatis帮我们映射到数据库表的字段上，属于正向映射。对于select，我们是将数据库记录查出来封装到java对象中，属于反向映射。

正向映射：

正向映射通过parameterType属性指定，如insert和update元素，parameterType属性值为com.tianshouzhi.mybatis.quickstart.User，这是一个java对象。mybatis会自动帮我们将java对象的值取出来，来替换sql中的变量。例如insert和update中的#{name}和#{age}就分别会被User对象的name和age属性值替换，即mybatis会调用user.getName()来替换#{name}，调用user.getAge()来替换#{age}。

不过我们还看到了，delete和select元素也配置了parameterType属性，这是因为在删除和查询的时候，我们也是需要指定条件的。这两个元素指定parameterType类型都是int，对应java的包装数据类型Integer。

反向映射：

反向映射通过resultType或者resultMap属性指定，这两个属性只能出现在<select>元素中。在上面的UserMapper.xml配置中，只出现了resultType，resultMap我们将在之后讲解。

这里<select>元素配置的resultType属性值也是com.tianshouzhi.mybatis.quickstart.User，表示将数据库结果封装到这个类中。

resultType这种反向映射关系是基于数据库表字段与User类属性是完全对应的。例如对于数据库id、name、age字段，会自动调用User类的、setId、setName、setAge方法进行设置。如果表字段与实体属性不能一一对应的话，如数据库表字段为username，但是java类中定义的属性为name，则无法进行映射。

2.3 SqlSessionFactory&SqlSession介绍

在使用mybatis时，我们需要先创建一个SqlSessionFactory对象(在ibatis为SqlMapClient)，然后通过SqlSessionFactory来创建SqlSession，通过SqlSession提供的api去执行sql。

2.3.1 SqlSessionFactory

顾名思义，是创建SqlSession实例的工厂类。SqlSessionFactory，某种程度上可以认为其是在数据源(Datasouce)的基础上做的一层封装，因此在整个程序中，最好只保存一个SqlSessionFactory实例。SqlSessionFactory与SqlSession之间的关系，就好像是Datasouce与Connection之间的关系一样。在使用一个数据源的时候，我们可以通过Datasouce的getConnection方法来获取Connection对象，而在mybatis中，我们通过SqlSessionFactory的openSession方法来获取SqlSession对象来操作数据库。

mybatis提供了一个SqlSessionFactoryBuilder对象，用于读取mybatis配置文件，创建SqlSessionFactory实例。以下代码演示了如何通过配置文件创建一个SqlSessionFactory实例。

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

其中Resources是mybatis提供的一个工具类，用于读取classpath下的资源配置文件。

2.3.2 SqlSession

SqlSession可以认为是在数据库连接(Connection)的基础上做的一层封装。其提供我们操作数据库相关的API，一个SqlSession实例从创建到销毁整个过程中执行的所有sql，都是通过同一个Connection对象进行。需要注意的是，SqlSession 的实例不是线程安全的，因此我们不应该使用多个线程来操作同一个Sqlsession对象。最佳实践是：每次需要操作数据库时，都创建一个新的SqlSession实例，使用完成之后，将其关闭。相关代码片段如下所示：

SqlSession session = sqlSessionFactory.openSession();
try {
  // do work
} finally {
  session.close();
}

SqlSession中，为我们在xml映射文件中配置的<insert>、<update>、<delete>、<select>提供了相应的操作方法，如下所示：

public interface SqlSession extends Closeable {
  //<select>元素对应的相关方法
  <T> T selectOne(String statement);
  <T> T selectOne(String statement, Object parameter);
  <E> List<E> selectList(String statement);
  <E> List<E> selectList(String statement, Object parameter);
  <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds);
  <K, V> Map<K, V> selectMap(String statement, String mapKey);
  <K, V> Map<K, V> selectMap(String statement, Object parameter, String mapKey);
  <K, V> Map<K, V> selectMap(String statement, Object parameter, String mapKey, RowBounds rowBounds);
  <T> Cursor<T> selectCursor(String statement);
  <T> Cursor<T> selectCursor(String statement, Object parameter);
  <T> Cursor<T> selectCursor(String statement, Object parameter, RowBounds rowBounds);
  void select(String statement, Object parameter, ResultHandler handler);
  void select(String statement, ResultHandler handler);
  void select(String statement, Object parameter, RowBounds rowBounds, ResultHandler handler);
  
  //<insert>元素对应的相关方法
  int insert(String statement);
  int insert(String statement, Object parameter);
  
  //<update>元素对应的相关方法
  int update(String statement);
  int update(String statement, Object parameter);
  
  //<delete>元素对应的相关方法
  int delete(String statement);
  int delete(String statement, Object parameter);
  
  //事务操作相关方法
  void commit();
  void commit(boolean force);
  void rollback();
  void rollback(boolean force);
  //其他方法
  List<BatchResult> flushStatements();
  @Override
  void close();
  void clearCache();
  Configuration getConfiguration();
  <T> T getMapper(Class<T> type);
  Connection getConnection();
}

我们归纳一下增删改查相关方法的特点，眼神犀利的同学很快就会发现：

1、针对<insert>、<update>、<delete>、<select>元素，SqlSession中都提供了对应方法的多种重载形式

2、对应的方法，无一例外的都要接受一个String类型的statement参数。

前面提到过，mybatis是通过namespace.id的方式来唯一定位要执行哪个sql，这里的statement就是namespace.id的值。例如要执行UserMapper.xml文件中以下<select>元素中的sql

<select id="selectById" parameterType="int"
             resultType="com.tianshouzhi.mybatis.quickstart.domain.User">
             SELECT id,name,age FROM user where id= #{id}
</select>

那么statement的值为"com.tianshouzhi.mybatis.quickstart.domain.User.selectById"。

3、有些方法需要接受一个Object类型的parameter参数，而另一些不需要。

回顾在xml映射文件中，我们配置的<insert>、<update>、<delete>、<select>元素，每个都可以配置一个parameterType属性，就是与此处传入的parameter参数相呼应。

例如对于我们正在UserMapper.xml中配置的<insert>元素

<insert id="insert" parameterType="com.tianshouzhi.mybatis.quickstart.domain.User">
      INSERT INTO user(id,name,age) VALUES (#{id},#{name},#{age})
</insert>

我们配置的parameterType属性值为"com.tianshouzhi.mybatis.quickstart.domain.User"，表示执行这个元素内部的sql时，我们需要传递一个User对象。而以下<delete>元素中，我们配置的parameterType属性值为"int"，表示执行这个元素内部的sql时，我们需要传递一个Integer值。

<delete id="deleteById" parameterType="int">
       DELETE FROM user WHERE id=#{id}
</delete>

因为传递的参数类型是各种各样的，因此parameter的类型是Object。

对于另外一些sql执行时不需要参数的，此时我们可以调用不要传递parameter参数的方法重载形式。如：

<delete id="deleteAll">
       DELETE  FROM user
</delete>

4、insert、update、delete相关方法，调用后，返回值类型都是int

这些操作属于更新数据库的操作，int表示受影响的记录行数。如我们在mysql中插入一条语句：

mysql> insert into user(id,name,age) values(1,"tianshouzhi",27);
Query OK, 1 row affected (0.11 sec)

这里的1 row affected表示的就是有1行记录受到了影响。

5、对于select相关方法，比insert、update、delete提供的方法都要多。

<select>元素对应的相关方法大致可以归为这几类：selectOne、selectList、selectMap、selectCursor、没有返回值的select方法。

首先声明，对于映射文件中的一个<select>元素，从API层面，上述方法我们都可以调用，但是在实际使用中，却要注意。

例如，对于以下<select>元素：

<select id="selectAll" resultType="com.tianshouzhi.mybatis.quickstart.domain.User">
        SELECT id,name,age FROM user;
</select>

这个<select>元素中执行的sql可能会查询到多条记录，每条记录都会被封装成一个User对象。

当我们调用selectList方法执行这条sql时，表示将User对象放到一个List返回。
当我们调用selectMap方法执行这条sql时，表示将User对象放到一个Map返回。特别的，selectMap方法需要额外指定一个mapKey参数，表示用哪一个字段作为Map的key，一般我们会把主键字段当做Map的key，而Map的value显然就是对应的User对象。
而当我们调用selectOne方法来执行SQL时，如果数据库中没有记录，或者只有1条记录，那么没问题。但是如果数据库记录数>1，那么mybatis就会抛出一个TooManyResultsException异常，表示返回的结果记录数与预期不符。从selectOne方法的名字就可以看出来，我们希望的是执行了这个sql最终返回一条记录。

所以，当我们调用selectOne方法执行一条sql时，一定要保证这个sql最多执行返回一条记录。例如调用selectOne执行以下<select>元素中的sql，就是没问题的：

<select id="selectById" parameterType="int"
             resultType="com.tianshouzhi.mybatis.quickstart.domain.User">
             SELECT id,name,age FROM user where id= #{id}
</select>

selectCursor方法主要是为了处理超大结果集，这是mybatis 3.4.0版本中的新功能。例如数据库中有1000W条记录，selectMap和selectList方法会直接将所有的记录查询出来，封装到List或Map中，结果很显然是内存被撑爆掉。selectCursor是通过游标的方式来解决这个问题。

对于没有返回值的select方法，相比其他方法多接受一个ResultHandler参数，其作用很明显，对数据库返回的结果进行自定义的处理。

最后，除了selectOne方法，其他形式select方法中都可以接受一个RowBounds参数，这是mybatis对分页功能的支持。不过这里用的是逻辑分页，而不是物理分页，所以一般我们不会使用这种类型的重载形式。之后的章节中，我们会介绍物理分页和逻辑分页的区别。

2.4 测试代码编写

理解了SqlSession的用法之后，我们开始测试代码的编写。有两种使用方式：

直接操作SqlSession的相关方法：这种方式是最基础的使用方式，但是对于理解mybatis的工作原理，却是最重要的，其他使用方式建立在这个基础上。
通过Mapper接口。这是目前主流的使用方式。

2.4.1 基于SqlSession的测试代码

测试代码基于junit框架编写，如下所示：

public class QuickStartBasedSqlSession {
       public static SqlSessionFactory sqlSessionFactory;
       public static String namespace = "com.tianshouzhi.mybatis.quickstart.mapper.UserMapper";
       public SqlSession sqlSession;
       //通过SqlSessionFactoryBuilder构造SqlSessionFactory实例
       @BeforeClass
       public static void testBefore() throws IOException {
             InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
             sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
       }
       // 每个单元测试方法(添加@Test注解的方法)在执行前，此方法都会被juint框架回调，创建一个新的SqlSession实例
       @Before
       public void before() {
             sqlSession = sqlSessionFactory.openSession();
       }
       // 测试添加，调用sqlSession的insert方法
       @Test
       public void testInsert() {
             User user1 = new User();
             user1.setId(1);
             user1.setName("tianshouzhi");
             user1.setAge(27);
             User user2 = new User();
             user2.setId(2);
             user2.setName("wangxiaoxiao");
             user2.setAge(26);
             String statement = namespace + ".insert";
             sqlSession.insert(statement, user1);
             sqlSession.insert(statement, user2);
       }
       // 测试查询单条记录，调用sqlSession的selectOne方法
       @Test
       public void testSelectOne() {
             User user = sqlSession.selectOne(namespace + ".selectById", 1);
             assert user != null;
             System.out.println("id:" + user.getId() + ",name:" + user.getName() + ",age:" + user.getAge());
       }
       // 测试查询多条记录，并将结果封装到一个List中，调用sqlSession的selectList方法
       @Test
       public void testSelectList() {
             List<User> userlist = sqlSession.selectList(namespace + ".selectAll");
             System.out.println(userlist);
       }
       // 测试查询多条记录，并将结果封装到一个Map中，调用sqlSession的selectMap方法
       @Test
       public void testSelectMap() {
             Map<Integer, User> userMap = sqlSession.selectMap(namespace + ".selectAll", "id");
             System.out.println(userMap);
       }
       // 测试更新，调用sqlSession的update方法
       @Test
       public void testUpdate() {
             User user = sqlSession.selectOne(namespace + ".selectById", 2);
             assert user != null;
             user.setName("huhuamin");
             user.setAge(26);
             int updateCount = sqlSession.update(namespace + ".updateById", user);
             assert updateCount == 1;
       }
       // 测试删除，调用sqlSession的delete方法
       @Test
       public void testDelete() {
             int deleteCount = sqlSession.delete(namespace + ".deleteById", 1);
             assert deleteCount == 1;
       }
       
       // 测试删除，调用sqlSession的delete方法
             @Test
       public void testDeleteAll() {
             int deleteCount = sqlSession.delete(namespace + ".deleteAll");
             assert deleteCount == 1;
       }
       // 每个单元测试方法(添加@Test注解的方法)在执行后，此方法都会被juint框架回调，关闭SqlSession实例
       @After
       public void after() {
             sqlSession.close();
       }
}

1、执行testInsert方法后，数据库中会增加两条记录：

mysql> select * from user;
+----+--------------+------+
| id | name         | age  |
+----+--------------+------+
|  1 | tianshouzhi  |   27 |
|  2 | wangxiaoxiao |   26 |
+----+--------------+------+
2 rows in set (0.00 sec)

2、执行testSelectOne方法后，控制台输出

id:1,name:tianshouzhi,age:27

3、执行testSelectList方法后，控制台输出

[User{id=1, name='tianshouzhi', age=27}, User{id=2, name='wangxiaoxiao', age=26}]

4、执行selectMap后，控制台输出

{1=User{id=1, name='tianshouzhi', age=27}, 2=User{id=2, name='wangxiaoxiao', age=26}}

注意:testSelectList和testSelectMap调用的都是UserMapper.xml文件中，id值为"selectAll"这个<select>元素中的sql。

5、执行testUpdate方法后，数据库id为2的记录信息发生变更

mysql> select * from user;
+----+-------------+------+
| id | name        | age  |
+----+-------------+------+
|  1 | tianshouzhi |   27 |
|  2 | huhuamin    |   26 |
+----+-------------+------+
2 rows in set (0.00 sec)

6 执行testDelete方法后，1号记录被删除

mysql> select * from user;
+----+----------+------+
| id | name     | age  |
+----+----------+------+
|  2 | huhuamin |   26 |
+----+----------+------+
1 row in set (0.00 sec)

7 执行deleteAll方法，数据库中没有记录

mysql> select * from user;
Empty set (0.00 sec)

对于直接使用SqlSession可以帮助我们理解mybatis的内部工作原理，但是在实际开发中，直接使用SqlSession的情况越来越少，除非是老项目，或者老司机已经习惯了这种用法。

2.4.2 基于Mapper接口的测试代码

mybatis提供了一种更加直观的使用方式，通过Mapper接口。

首先我们定义一个接口UserMapper，如下所示：

package com.tianshouzhi.mybatis.quickstart.mapper;
import java.util.List;
import com.tianshouzhi.mybatis.quickstart.domain.User;
public interface UserMapper {
       public int insert(User user);
       public User selectById(int id);
       public List<User> selectAll();
       
       public int updateById(User user);
       public int deleteById(int id);
       
       public int deleteAll();
}

细心的读者会发现：

UserMapper接口的全路径com.tianshouzhi.mybatis.quickstart.mapper.UserMapper，与UserMapper.xml中的namespace属性的值完全相同。
在UserMapper.xml中定义的各个元素<insert>、<delete>、<update>、<select>的id属性值刚好是UserMapper接口中定义的几个方法的名字。

看到这里，读者可能已经知道mybatis想干啥了，我们不再需要在代码中，通过指定namespace.id方式，告诉SqlSession去执行哪条sql了。直接操作UserMapper接口即可，mybatis内部会通过动态代理+反射技术，获得当前执行的UserMapper接口的全路径，对应到UserMapper.xml中的namespace属性，获得方法名对应到<insert>、<delete>、<update>、<select>的id属性。这样就可以知道要执行哪条sql了。

对于查询操作，mybatis会根据方法返回值类型判断要调用SqlSession的哪个方法，如UserMapper接口中定义的selectById方法，其返回值是一个User对象，mybatis内部自动会调用SqlSession的selectOne方法，而对于selectAll这种返回值类型是List的情况，mybatis内部自动会调用SqlSession的selectList方法。

另外，根据接口的方法声明中，是否包含参数，mybatis也可以自动判断是否需要调用SqlSession有parameter参数的方法重载形式。

可以通过以下方式获得UserMapper接口的动态代理对象

SqlSession session = sqlSessionFactory.openSession();
try {
  UserMapper mapper = session.getMapper(UserMapper.class);
  User user= mapper.selectById(1);
} finally {
  session.close();
}

改造后的测试代码如下所示：

public class QuickStartBasedMapper {
       public static SqlSessionFactory sqlSessionFactory;
       public SqlSession sqlSession;
       //添加UserMapper接口
       public UserMapper userMapper;
       //通过SqlSessionFactoryBuilder构造SqlSessionFactory实例
       @BeforeClass
       public static void testBefore() throws IOException {
             InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
             sqlSessionFactory = new SqlSessionFactoryBuilder().build(in);
       }
       // 每个单元测试方法(添加@Test注解的方法)在执行前，创建一个新的SqlSession实例，并获得UserMapper接口的动态代理对象
       @Before
       public void before() {
             sqlSession = sqlSessionFactory.openSession();
             userMapper = sqlSession.getMapper(UserMapper.class);
       }
       // 测试添加，调用UserMapper的insert方法
       @Test
       public void testInsert() {
             User user1 = new User();
             user1.setId(1);
             user1.setName("tianshouzhi");
             user1.setAge(27);
             User user2 = new User();
             user2.setId(2);
             user2.setName("wangxiaoxiao");
             user2.setAge(26);
             userMapper.insert(user1);
             userMapper.insert(user2);
       }
       // 测试查询单条记录，调用UserMapper的selectById方法
       @Test
       public void testSelectOne() {
             User user = userMapper.selectById(1);
             assert user != null;
             System.out.println("id:" + user.getId() + ",name:" + user.getName() + ",age:" + user.getAge());
       }
       // 测试查询多条记录，并将结果封装到一个List中，调用userMapper的selectAll方法
       @Test
       public void testSelectAll() {
             List<User> userlist = userMapper.selectAll();
             System.out.println(userlist);
       }
       // 测试更新，调用userMapper的updateById方法
       @Test
       public void testUpdate() {
             User user = userMapper.selectById(2);
             assert user != null;
             user.setName("huhuamin");
             user.setAge(26);
             int updateCount = userMapper.updateById(user);
             assert updateCount == 1;
       }
       // 测试删除，调用userMapper的deleteById方法
       @Test
       public void testDelete() {
             int deleteCount = userMapper.deleteById(1);
             assert deleteCount == 1;
       }
       // 测试删除，调用userMapper的deleteAll方法
       @Test
       public void testDeleteAll() {
             int deleteCount = userMapper.deleteAll();
             assert deleteCount == 1;
       }
       // 每个单元测试方法(添加@Test注解的方法)在执行后，此方法都会被juint框架回调，关闭SqlSession实例
       @After
       public void after() {
             sqlSession.close();
       }
}

基于Mapper接口方式的mybatis代码，与直接操作SqlSession的效果类似，这里不再赘述。

需要注意的是，如果我们的UserMapper接口全路径与UserMapper.xml配置文件namespace属性值不匹配时，会抛出类似以下的异常

org.apache.ibatis.binding.BindingException: 
Type interface com.tianshouzhi.mybatis.quickstart.mapper.UserMapper is not known to the MapperRegistry.

3、基于注解的映射配置

在前面的讨论中，mybatis的全局配置文件(mybatis-config.xml)和映射器配置(UserMapper.xml)都是基于xml文件格式配置的。事实上mybatis也支持将映射配置直接配置在Mapper接口中。此时要做2点改动：

1、修改mybatis-config.xml的mappers元素配置，用注解配合代替xml映射配置

<mappers>
        <!-- <mapper resource="mappers/UserMapper.xml"/> -->
        <!--通过class属性指定UserMapper接口的全路径-->
        <mapper class="com.tianshouzhi.mybatis.quickstart.mapper.UserMapper"/>
</mappers>

2、在UserMapper接口的方法上，添加相关注解

public interface UserMapper {
       @Insert("INSERT INTO user(id,name,age) VALUES (#{id},#{name},#{age})")
       public int insert(User user);
       @Select(" select id,name,age from user where id= #{id}")
       public User selectById(int id);
       @Select(" select id,name,age from user")
       public List<User> selectAll();
       @Update("UPDATE user SET name=#{name},age=#{age} WHERE id=#{id}")
       public int updateById(User user);
       @Delete("DELETE FROM user WHERE id=#{id}")
       public int deleteById(int id);
       @Delete("DELETE FROM user")
       public int deleteAll();
}

其中@Insert、@Select、@Update、@Delete注解，分别对应xml配置中的<insert>、<update>、<delete>、<select>元素。而注解里的sql直接就是把UserMapper.xml文件中对应的元素中的sql搬过来。

此时，我们再去运行2.4节中的QuickStartBasedMapper相关测试代码，可以达到相同的结果。

当然，mybatis中提供的注解远远不止这几个，我们接触的只是冰山一角。mybatis提供的注解org.apache.ibatis.annotations包下面，在后面的章节中，我会对这些注解逐一进行讲述。

4 总结

本节总共介绍了2种mybatis的使用方式

1、通过xml映射文件，配置<insert>、<update>、<delete>、<select>元素

又细分为直接操作SqlSession
Mapper接口：通过SqlSession获得Mapper接口的动态代理，接口的全路径要与xml映射文件namespace属性值相匹配，接口中的方法名与映射文件中配置的<insert>、<update>、<delete>、<select>元素id属性值相匹配。

2、通过注解映射，在Mapper接口的相应方法上添加@Insert、@Update、@Delete、@Select注解。

总的来说，直接操作SqlSession是最基础的使用方式，也最能帮助我们了解mybatis内部的核心工作流程，其他都是在这个基础上的封装。从笔者的工作经验来看，目前还是xml映射文件+Mapper接口的方式使用的最多。对于基于注解的方式，笔者并不建议，因为经常会出现在一些xml映射文件中支持的功能，使用注解的方式就不支持了。

上一篇：2.0 基础篇下一篇：2.2 typeAlias别名

欢迎转载,请注明出处!!!