Mybatis学习之路01 Mybatis搭建

一、Mybatis

1.Mybatis简介

MyBatis 是支持普通 SQL 查询，存储过程和高级映射的优秀持久层框架，MyBatis 使用简单的 XML 或注解用于配置和原始映射，将接口和 Java 的 POJOs（Plain Old Java Objects，普通的 Java对象）映射成数据库中的记录。

MyBatis 应用程序大都使用 SqlSessionFactory 实例，SqlSessionFactory 实例可以通过 SqlSessionFactoryBuilder 获得，而　SqlSessionFactoryBuilder 则可以从一个 XML 配置文件或者一个预定义的配置类的实例获得。

2. 搭建项目

我们采用maven框架搭建Mybatis，整个流程如下：

• 创建一个maven项目
• 导入Mybatis框架所需以及项目所需依赖
• 新建实体类Person
• mysql创建Person表并插入数据
• 创建核心配置文件sqlMapConfig.xml
• 创建映射文件UserMapper.xml
• 创建测试类

2.1 导入依赖

mybatis,mysql-connector,log4j,junit

<dependencies>
        <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.0</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.15</version>
        </dependency>

        <!-- 日志依赖 实现slf4j接口并整合 -->

        <!-- https://mvnrepository.com/artifact/org.apache.logging.log4j/log4j-core -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>


        <!--junit测试依赖-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>RELEASE</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>

2.2创建用户类Person

整个项目结构如下：

package com.sxy;

public class Person {
    private Integer id;
    private String name;
    private Integer age;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

2.3设计接口类UserDao

public interface UserDao {

    public void insert(User user);

    public User findUserById(int userId);

    public List<User> findAllUsers();
}

2.4新建数据库表Person

2.5创建核心配置文件sqlMapConfig.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

全局配置文件：

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

<!-- XML 配置文件包含对mybatis 系统核心的设置 -->
<configuration>
    <!--指定Mybatis 数据库配置文件 -->
    <properties resource="db.properties"/>

    <!--指定Mybatis 所用日志的具体实现 -->
    <settings>
        <setting name="logImpl" value="LOG4J"/>
     </settings>

    <environments default="mysql">

        <!--环境配置，即连接的数据库-->
        <environment id="mysql">

            <!-- 指定事务的管理类型,type = JDBC表示使用了JDBC的提交和回滚-->
            <transactionManager type="JDBC"></transactionManager>

            <!--dasource数据源配置，POOLED是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告诉Mybatis去哪里找持久化类的映射文件（xml方式）-->

    <mappers>
        <!--XML方式用"/"/-->
        <mapper resource="UserMapper.xml" />
    </mappers>


    <!-- mappers告诉了MyBatis去哪里找持久化类的映射类（注解形式） -->
    <!--
   <mappers>
       <mapper class="sxy.mybatis.mydemo6.mapper.ArticleMapper" />
   </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属性来指定。

mappers有两种方式设置，一种通过xml另一种通过注解。property标签通过读db.properties配置文件来获取用户名和密码

db.properties

driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/test?characterEncoding=UTF-8&serverTimezone=GMT%2B8
username=root
password=sxy123

2.6创建映射文件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="UserMapper">  <!-- 命名空间，名字可以随意起，只要不冲突即可 -->
    <!-- 对象映射，可以不写-->
    <!--查询功能，resultType 设置返回值类型 -->
    <select id="selectById" parameterType="int" resultType="com.sxy.Person">
        SELECT id,name,age FROM person where id = #{id}
    </select>
    <select id="selectAll" resultType="com.sxy.Person">
        SELECT * FROM Person
    </select> <!-- 书写SQL -->
    <!-- 插入功能,插入一个Person类 -->
    <insert id="insert" parameterType="com.sxy.Person">
        INSERT INTO person(id,name,age) VALUES (#{id},#{name},#{age})
    </insert>
    <!-- update-->
    <update id="updateById" parameterType="com.sxy.Person">
        UPDATE person SET name=#{name},age=#{age} WHERE id=#{id}
    </update>
    <!-- delete-->
    <delete id="deleteById" parameterType="int">
        DELETE FROM person WHERE id=#{id}
    </delete>
    <delete id="deleteAll">
        DELETE * FROM person
    </delete>
</mapper>

配置说明：

mapper元素：

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

​ 例如现在还有另外一个mapper文件UserAccountMapper.xml，用于操作user_account表，其也要进行相应的增删改查。在这个配置文件中的元素中，我们可能也设置了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属性指定，这两个属性只能出现在元素中。在上面的UserMapper.xml配置中，只出现了resultType，resultMap我们将在之后讲解。

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

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

2.7 SqlSessionFactory& SqlSession介绍

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

2.7.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);

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

2.7.2 SqlSession

SqlSession可以认为是在数据库连接(Connection)的基础上做的一层封装。其提供我们操作数据库相关的API，一个SqlSession实例从创建到销毁整个过程中执行的所有sql，都是通过同一个Connection对象进行

需要注意的是，SqlSession 的实例不是线程安全的，因此我们不应该使用多个线程来操作同一个Sqlsession对象。最佳实践是：每次需要操作数据库时，都创建一个新的SqlSession实例，使用完成之后，将其关闭。相关代码片段如下所示：

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

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

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、针对、、、元素，SqlSession中都提供了对应方法的多种重载形式

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

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

    <select id="selectById" parameterType="int" resultType="com.sxy.Person">
        SELECT id,name,age FROM person where id = #{id}
    </select>

statement的值就是com.sxy.Person.selectById

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

回顾一下在xml映射文件中，我们配置的、、、元素，每个都可以配置一个parameterType属性，与此处传入的parameter参数相呼应，比如：

parameterType为com.sxy.Person,当执行内部Sql时，传入一个Person对象，

而比如元素中，我们配置的parameterType属性值为Int,表示要删除的id

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

因为传递的参数类型是各种各样的，因此parameter的类型是Object。有一些sql执行不需要传参数的，就可以不需要parameter

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

int表示受影响的行数

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

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

2.8创建测试类MybatisTest

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

• 直接操作SqlSession的相关方法:这种方法是最基础的使用方法，便于理解mybatis工作原理
• 通过Mapper接口。这是目前主流的使用方法

2.8.1 基于SqlSession的测试代码

public class MybatisTest {

    public static SqlSessionFactory sqlSessionFactory;
    public static String namespace = "UserMapper";
    public static String resource = "sqlMapConfig.xml";
    public SqlSession sqlSession;

    /**
     * 1.获得SqlSessionFactory
     * 2.获得SqlSession
     * 3.调用mapper文件中配置的SQL语句
     */

    @BeforeClass
    public static void testBefore() throws IOException {
        //定位核心配置文件
        InputStream inputStream = Resources.getResourceAsStream(resource);
        //通过SqlSessionFactoryBuilder创建SqlSessionFactory
        sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    }

    //获取到SqlSession
    //每个单元测试方法(添加@Test注解的方法)在执行前，此方法都会被juint框架回调，创建一个新的SqlSession实例
    @Before
    public void before() {
        sqlSession = sqlSessionFactory.openSession();
    }
    //测试添加，调用sqlSession的方法
    @Test
    public void testInsert() {

        //调用sqlSession的insert方法
        Person person1 = new Person();
        person1.setId(1);
        person1.setName("li");
        person1.setAge(22);

        Person person2 = new Person();
        person2.setId(2);
        person2.setName("sun");
        person2.setAge(32);

        String statement = namespace + ".insert";
        sqlSession.insert(statement,person1);
        sqlSession.insert(statement,person2);
        sqlSession.commit();
    }
    //测试查询单条记录，selectOne
    @Test
    public void testSelectOne() {
        Person person = sqlSession.selectOne(namespace + ".select",2);
        assert person!= null;
        System.out.println("id:" + person.getId() + ",name:" + person.getName() + ",age:" + person.getAge());
    }
    //测试查询多条记录，并将结果封装到一个List中，调用selectList
    @Test
    public void testSelectList() {
        //调用mapper中的方法：命名空间+id
        List<Person> personList = sqlSession.selectList("UserMapper.selectAll");

        for (Person p: personList) {
            System.out.println(p);
        }
    }
    //测试查询多条记录，并将结果封装到一个Map中，调用selectList
    @Test
    public void testSelectMap() {
        //调用mapper中的方法：命名空间+id
        Map<Integer,Person> personMap = sqlSession.selectMap(namespace+".selectAll","id");
        System.out.println(personMap);
    }
    //测试更新，调用sqlSession的update方法
    @Test
    public void testUpdate() {
     Person person = sqlSession.selectOne(namespace+".select",2);
     assert person!= null;
     person.setName("zhao");
     person.setAge(11);
     int updateCount = sqlSession.update(namespace+".updateById",person);
     assert updateCount ==1 ;
    }
    @Test
    public void testDeleteAll() {
        int deleteCount = sqlSession.delete(namespace+".deleteAll");
        sqlSession.commit();
//        assert deleteCount == 1;
    }

    @After
    public void after() {

        sqlSession.close();
    }
}

2.8.2 基于Mapper接口的测试代码（流行）

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

首先我们定义一个接口UserMapper：

public interface UserMapper {
    public int insert (Person person);
    public List<Person> selectAll();
    public Person selectById(int id);

    public int updateById(Person person);
    public int deleteById(int id);

    public int deleteAll();
}

对比之前，我们不需要通过指定namespace.id方式告诉SqlSession去执行哪条sql，直接操作UserMapper接口即可。

Mybatis内部通过动态代理和反射的技术，获取当前执行UserMapper接口全路径，对应到UserMapper.xml中的namespace属性，获得方法名对应到、、、的id属性。这样就可以知道要执行哪条sql了。

基于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.

测试程序改造成：

//添加UserMapper接口
public UserMapper userMapper;

@Before
public void before() {
  sqlSession = sqlSessionFactory.openSession();
  System.out.println(UserMapper.class);
  userMapper = sqlSession.getMapper(UserMapper.class);
}
@Test
 public void testSelectOne() {
   Person person = userMapper.selectById(1);
   assert person!= null;
   System.out.println("id:" + person.getId() + ",name:" + person.getName() + ",age:" + person.getAge());
    }

2.9 基于注解的映射配置

前面对核心配置文件中mappers元素的配置采用的是xml，其实也可以用注解配合替代xml映射配置

首先：

2.9.1 修改config.xml中mappers元素配置

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

2.9.2 在UserMapper接口文件的所有方法上，添加注释

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

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

与之前得到的结果一致

二、总结

1. 通过xml映射文件(两种配置方法：直接操作SqlSession和Mapper接口)，配置了、、、元素
2. 通过注解方法修改了映射配置