MyBatis 入门（第一讲）

1.1 框架

框架（Framework）是整个或部分系统的可重用设计，表现为一组抽象构件及构件实例间交互的方法；另一种定义认为，框架是可被应用开发者定制的应用骨架。

可以说，一个框架是一个可复用的设计构件，它规定了应用的体系结构，阐明了整个设计、协作构件之间的依赖关系、责任分配和控制流程，表现为一组抽象类以及其实例之间协作的方法，它为构件复用提供了上下文(Context)关系。

对于程序员来说，框架是一套资源，这套资源中会包含 Jar 包、文档，还有些会包含源码、代码示例等。这套资源从相关的官网上可以下载。一般是以压缩文件的形式出现。

1.1.1 MyBatis 的下载

MyBatis 可以在 github 官网下载：https://github.com/mybatis
备注：大家自行下载就行

1.1.2 MyBatis 的的 Jar 包

MyBatis 框架的解压目录中只有一个 Jar 包，它是 MyBatis 的核心 Jar 包。另外，还有个lib 目录，其中存放着 MyBatis 所依赖的 Jar 包。所以，使用MyBatis，需要将其核心 Jar 包，及 lib 下的所有 Jar 包导入。

1.2 MyBatis 概述

MyBatis本是apache的一个开源项目iBatis，2010年这个项目由apache迁移到了google，并更名为 MyBatis。2013 年迁移到 Github。

1.2.1 MyBatis 简介

MyBatis 是一个优秀的基于 Java 的持久层框架，它内部封装了 JDBC，使开发者只需关注SQL 语句本身，而不用再花费精力去处理诸如注册驱动、创建 Connection、配置 Statement等繁杂过程。

Mybatis通过xml或注解的方式将要执行的各种statement （statement、preparedStatement等）配置起来，并通过 Java 对象和 Statement 中 SQL 的动态参数进行映射生成最终执行的SQL 语句，最后由 MyBatis 框架执行 SQL 并将结果映射成 Java 对象并返回。

1.2.2 MyBatis 与与 Hibernate

Hibernate 框架是提供了全面的数据库封装机制的“全自动”ORM，即实现了 POJO 和数据库表之间的映射，以及 SQL 的自动生成和执行。

相对于此，MyBatis 只能算作是“半自动”ORM。其着力点，是在 POJO 类与 SQL 语句之间的映射关系。也就是说，MyBatis 并不会为程序员自动生成 SQL 语句。具体的 SQL 需要程序员自己编写，然后通过 SQL 语句映射文件，将 SQL 所需的参数，以及返回的结果字段映射到指定 POJO。因此，MyBatis 成为了“全自动”ORM 的一种有益补充。

与与 Hibernate 相比，MyBatis 具有以下几个特点：
① 在 XML 文件中配置 SQL 语句，实现了 SQL 语句与代码的分离，给程序的维护带来
了很大便利。
② 因为需要程序员自己去编写 SQL 语句，程序员可以结合数据库自身的特点灵活控
制 SQL 语句，因此能够实现比 Hibernate 等全自动 ORM 框架更高的查询效率，能够完成复
杂查询。
③ 简单，易于学习，易于使用，上手快。

1.2.3 MyBatis 体系结构

1.3 MyBatis 工作原理

1.4 第一个 MyBatis 程序

需求：实现将 Student 信息写入到数据库（MySQL）中

1.4.1 基本程序

项目：MyFirstMyBatis

① 入导入 Jar 包

除了需要导入 MyBatis 的核心 Jar 包及依赖 Jar 包外，还需要导入 MySql 的驱动 Jar 包，JUnit 测试的 Jar 包。核心 Jar 包与依赖 Jar 包，均在 MyBatis 框架的解压目录下。

② 定义实体类

package com.mybatis.bean;
/**
 * 定义学生实体类
 * @author 清水三千尺
 *
 */
public class Student {
    //属性
    private Integer id;//ID
    private String name;//学生姓名
    private Integer age;//学生年龄
    private Double score;//学生成绩
    
    //访问器
    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;
    }
    public Double getScore() {
        return score;
    }
    public void setScore(Double score) {
        this.score = score;
    }
    
    //构造器
    public Student() {
        
    }

    public Student(Integer id, String name, Integer age, Double score) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.score = score;
    }

      public Student(String name, Integer age, Double score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }
    
    //toString()方法
    @Override
    public String toString() {
        return "Student [id=" + id + ", name=" + name + ", age=" + age + ", score=" + score + "]";
    }
    
}

③ 在 MySQL 中生成表结构，即创建空表

注意：由于后面要创建的 MyBatis 映射文件映射的是 SQL 语句，而非像Hibernate 一样，是类到表，属性到字段的映射。所以，MyBatis 要求，在创建数据库表时，字段名要与属性名一致（当然，不一致时，还可通过 resultMap 解决，后面会讲）。

④ 定义 Dao 接口

package com.mybatis.dao;

import com.mybatis.bean.Student;

/**
 * 定义学生接口
 * @author 清水三千尺
 *
 */
public interface IStudentDao {
    //添加学生
    void insertStudent(Student student);
}

⑤ 定义映射文件

映射文件，简称为 mapper，主要完成 Dao 层中 SQL 语句的映射。具体映射的配置，后面会详细讲解。映射文件名随意，一般放在 dao 包中。这里映射文件名称定为 mapper.xml。

映射文件的约束文件 mybatis-3-mapper.dtd 文件，在 MyBatis 的核心 Jar 包的org.apache.ibatis.builder.xml 包中存放。当然，主配置文件的约束 dtd 文件也在该位置存放。

在映射文件中添加约束，即配置文件头，可以从 MyBatis 框架中的文档 mybatis-3.3.0.pdf中找到：

在 pdf 中搜索“mybatis-3-mapper.dtd”关键字，即可找到映射文件的约束。

映射文件内容为：
<?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="test">

  <insert id="insertStudent" parameterType="com.mybatis.bean.Student">
      INSERT INTO student(name,age,score)
      VALUES (#{name},#{age},#{score})
  </insert>

</mapper>
注意，#{ }中写入的是 Student 类的属性名。

对于 parameterType 属性，框架会自动根据用户执行的 SqlSession 方法中的参数自动检测到，所以一般我们不用指定 parameterType 属性。一般写为如下形式：
<mapper namespace="test">
  
   
   <insert id="insertStudent">
      INSERT INTO student(name,age,score)
      VALUES (#{name},#{age},#{score})
   </insert>

</mapper>

⑥ 定义主配置文件

在主配置文件中添加约束，即配置文件头，可以从 MyBatis 框架中的文档
mybatis-3.3.0.pdf 中找到：

在 pdf 中搜索“mybatis-3-config.dtd”关键字，即可找到映射文件的约束。

主配置文件名也可以随意命名，本例定义为 SqlMapConfig.xml。而对于<dataSource/>标签中<property/>的 name 属性名称，需要从帮助文档中查找。如上图所示。
<?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="test">
  
      <environment id="test">
          <transactionManager type="JDBC" />
          
          <dataSource type="POOLED">
              <property name="driver" value="com.mysql.jdbc.Driver"/>
              <property name="url" value="jdbc:mysql://localhost:3306/mybatis"/>
              <property name="username" value="root"/>
              <property name="password" value="root"/>
          </dataSource>
      
      </environment>
  
  </environments>
  
  
  <mappers>
      <mapper resource="com.mybatis.dao.StudentMapper.xml"/>
  </mappers>

</configuration>

⑦ 定义 Dao 实现类

package com.mybatis.dao.impl;

import java.io.IOException;
import java.io.InputStream;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import com.mybatis.bean.Student;
import com.mybatis.dao.IStudentDao;

public class StudentDaoImpl implements IStudentDao {
    private SqlSession session;
    
    public void insertStudent(Student student) {
        
        try {
            //1.读取主配置文件
            InputStream inputStream = Resources.getResourceAsStream("config/SqlMapConfig.xml");
            //2.创建SQLSessionFactory对象
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
            //3.创建SqlSession对象
            session = sqlSessionFactory.openSession();
            //4.操作
            session.insert("insertStudent",student);
            //5.SQLSession提交
            session.commit();
            
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //6.关闭SqlSession
            if(session != null){
                session.close();
            }
        }
    
    }

}

⑧ 定义测试类

package com.mybatis.test;

import static org.junit.Assert.*;

import org.junit.Test;

import com.mybatis.bean.Student;
import com.mybatis.dao.IStudentDao;
import com.mybatis.dao.impl.StudentDaoImpl;

public class MyTest {
    
    @Test
    public void testInsertStudent() throws Exception {
        //准备实现类
        IStudentDao isd = new StudentDaoImpl();
        //准备学生对象
        Student student = new Student("赵四", 18, 90.1);
        //实现学生的添加
        isd.insertStudent(student);
    }

}

测试结果如下：

⑨ 添加日志控制文件

MyBatis 使用 Log4j 进行日志处理，而 Login4j2 对其支持并不好，所以在 MyBatis 中需要将 log4j.properties 放入到项目的 src 目录下。

若将日志级别设置为 debug，则可以显示出所执行的 SQL 语句、参数值、对 DB 的影响条数等信息。若将级别设置为 trace，则还可显示出查询出的每条记录的每个字段名及值。
# Global logging configuration
log4j.rootLogger=DEBUG, stdout
# Console output...
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

1.5 主配置文件详解

主配置文件名可以随意命名，其主要完成以下几个功能：
① 注册存放 DB 连接四要素的属性文件
② 注册实体类的全限定性类名的别名
③ 配置 MyBatis 运行环境，即数据源与事务管理器
④ 注册映射文件

注册存放 DB 连接四要素的属性文件
为了方便对数据库连接的管理，DB 连接四要素数据一般都是存放在一个专门的属性文件中的。MyBatis 主配置文件需要从这个属性文件中读取这些数据。

⑴ 定义属性文件
在 src 下定义属性文件 jdbc.properties。

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

⑵ 修改主配置文件
对主配置文件，第一，需要注册属性文件。第二，需要从属性文件中通过 key，将其 value读取出来。

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

  <!-- 注册属性文件  -->
  <properties resource="jdbc.properties" />

  <!-- 配置MyBatis运行环境 （暂时的，以后学了Spring之后就不在使用了） -->
  <environments default="test">
  
      <environment id="test">
          <transactionManager type="JDBC" />
          
          <dataSource type="POOLED">
              <property name="driver" value="${jdbc.driver}"/>
              <property name="url" value="${jdbc.url}"/>
              <property name="username" value="${jdbc.username}"/>
              <property name="password" value="${jdbc.password}"/>
          </dataSource>
      
      </environment>
  
  </environments>
  
  <!-- 注册映射文件 -->
  <mappers>
      <mapper resource="com/mybatis/dao/StudentMapper.xml"/>
  </mappers>
  
</configuration>

注册实体类的全限定性类名的别名

1、对于实体类的全限定性类名的别名指定方式，一般使用<package/>方式。这样做的好处是会将该包中所有实体类的简单类名指定为别名，写法简单方便。

  <typeAliases>
      <package name="com.mybatis.bean"/>
  </typeAliases>
2、不过，还有另外的指定方式：通过<typealias/>指定。
type：全限定性类名
alias：别名
该方式的好处是，可以指定别名为简单类名以外的其它名称。当然，弊端是，必须逐个指定，比较繁琐。
  <typeAliases>
      <typeAlias type="com.mybatis.bean.Student" alias="Student"/>
  </typeAliases>
3、除了自定义的类型的别名外，MyBatis 还提供了内置的类型别名：
基本类型：

常用包装类型：

配置 MyBatis 运行环境，即数据源与事务管理器

配置 MyBatis 的运行环境，主要是配置数据源与事务管理器。
A 、 <environments/>
在<environments/>中可以包含多个运行环境<environment/>，但其 default 属性指定了当前 MyBatis 运行时所选择使用的环境。

<environment/>的 id 属性为当前定义的运行环境的名称，可以任意命名。该名称会作为<environments/>的 default 属性的值出现。

B 、 <transactionManager/>

该标签用于指定 MyBatis 所使用的事务管理器。MyBatis 支持两种事务管理器类型：JDBC与 MANAGED。

JDBC：使用 JDBC 的事务管理机制。即，通过 Connection 的 commit()方法提交，通过rollback()方法回滚。但默认情况下，MyBatis 将自动提交功能关闭了，改为了手动提交。即程序中需要显式的对事务进行提交或回滚。从日志的输出信息中可以看到。

MANAGED：由容器来管理事务的整个生命周期（如 Spring 容器）。

C 、 <dataSource/>

该标签用于配置 MyBatis 使用的数据源类型与数据库连接基本属性。常见有类型有：UNPOOLED、POOLED、JDNI 等。

UNPOOLED ：不使用连接池。即每次请求，都会为其创建一个 DB 连接，使用完毕后，会马上将此连接关闭。

POOLED：使用数据库连接池来维护连接。

JNDI：数据源可以定义到应用的外部，通过 JNDI 容器获取数据库连接。

若要从属性文件中读取 DB 连接四要素信息，则使用如下方式：

注册映射文件
指定映射文件的方式有多种。但所有的方式，都是指定在<mappers/>标签中的。
A 、 <mapper resource=””/> 指定映射文件
若映射文件只有一个，则可直接使用如下形式：

若映射文件有多个，则可使用如下形式：

B 、 <mapper url=””/>
该方式的好处是，可以将映射文件放在本地或网络的任意位置，通过其 url 地址即可直接访问。但通常映射文件是存放在当前应用中的，所以该方式不常用。

C 、 <mapper class=””/> 指定映射文件
class 属性值为 Dao 接口的全类名。

该方式的使用，需要满足以下几个要求：
（1）映射文件名要与 Dao 接口名称相同
（2）映射文件要与接口在同一包中
（3）映射文件中<mapper/>的 namespace 属性值为 Dao 接口的全类名

D 、 <package name=””/> 指定映射文件
当映射文件较多时，也可以使用如下形式。其中 package 的 name 属性指定映射文件所存放的包。

但，这种方式的使用需要满足以下几个条件：
（1）dao 使用 mapper 动态代理实现（后面讲）
（2）映射文件名要与 Dao 接口名称相同
（3）映射文件要与接口在同一包中
（4）映射文件中<mapper/>的 namespace 属性值为 Dao 接口的全类名

1.6 API 介绍

Dao 中需要通过 SqlSession 对象来操作 DB。而 SqlSession 对象的创建，需要其工厂对象SqlSessionFactory。SqlSessionFactory 对象，需要通过其构建器对象 SqlSessionFactoryBuilder的 build()方法，在加载了主配置文件的输入流对象后创建。
public class StudentDaoImpl implements IStudentMapper {
  private SqlSession session;
  
  public void insertStudent(Student student) {
      
      try {
          //1.读取主配置文件
          InputStream inputStream = Resources.getResourceAsStream("config/SqlMapConfig.xml");
          //2.创建SQLSessionFactory对象
          SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
          //3.创建SqlSession对象
          session = sqlSessionFactory.openSession();
          //4.操作
          session.insert("insertStudent",student);
          //5.SQLSession提交
          session.commit();
          
      } catch (IOException e) {
          e.printStackTrace();
      } finally {
          //6.关闭SqlSession
          if(session != null){
              session.close();
          }
      }       
  }
}
（1 ） Resources 类
Resources 类，顾名思义就是资源，用于读取资源文件。其有很多方法通过加载并解析资源文件，返回不同类型的 IO 流对象。

（2 ） SqlSessionFactoryBuilder 类
SqlSessionFactory 的创建，需要使用 SqlSessionFactoryBuilder 对象的 build()方法。由于SqlSessionFactoryBuilder 对象在创建完工厂对象后，就完成了其历史使命，即可被销毁。所以，一般会将该 SqlSessionFactoryBuilder 对象创建为一个方法内的局部对象，方法结束，对象销毁。
其被重载的 build()方法较多：

（3 ） SqlSessionFactory 接口
SqlSessionFactory 接口对象是一个重量级对象（系统开销大的对象），是线程安全的，所以一个应用只需要一个该对象即可。创建 SqlSession 需要使用 SqlSessionFactory 接口的的openSession()方法。
① openSession(true)：创建一个有自动提交功能的 SqlSession
② openSession(false)：创建一个非自动提交功能的 SqlSession，需手动提交
③ openSession()：同 openSession(false)

（4 ） SqlSession 接口
SqlSession 接口对象用于执行持久化操作。一个 SqlSession 对应着一次数据库会话，一次会话以 SqlSession 对象的创建开始，以 SqlSession 对象的关闭结束。
SqlSession 接口对象是线程不安全的，所以每次数据库会话结束前，需要马上调用其close()方法，将其关闭。再次需要会话，再次创建。而在关闭时会判断当前的 SqlSession 是否被提交：若没有被提交，则会执行回滚后关闭；若已被提交，则直接将 SqlSession 关闭。所以，SqlSession 无需手工回滚。
SqlSession 接口常用的方法有：

MyBatis 入门（第一讲）

1.1 框架

1.2 MyBatis 概述

1.3 MyBatis 工作原理

1.4 第一个 MyBatis 程序

1.5 主配置文件详解

1.6 API 介绍

猜你喜欢