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

本章将涵盖以下话题：

• ž  MyBatis是什么?
• ž  为什么选择MyBatis?
• ž  MyBatis安装配置
• ž  域模型样例

1.1 MyBatis是什么

MyBatis是一个简化和实现了Java数据持久化层(persistencelayer)的开源框架，它抽象了大量的JDBC冗余代码，并提供了一个简单易用的API和数据库交互。

MyBatis的前身是iBATIS，iBATIS于2002年由ClintonBegin创建。MyBatis 3 是iBATIS的全新设计，支持注解和Mapper。

MyBatis 流行的主要原因在于它的简单性和易使用性。在Java应用程序中，数据持久化层涉及到的工作有：将从数据库查询到的数据生成所需要的Java对象；将Java对象中的数据通过SQL持久化到数据库中。

MyBatis 通过抽象底层的JDBC代码，自动化SQL结果集产生Java对象、Java对象的数据持久化数据库中的过程使得对SQL的使用变得容易。

如果你正在使用iBATIS，并且想将iBATIS移植到MyBatis上，你可以在MyBatis 的官方网站（
https://code.google.com/p/mybatis/wiki/DocUpgrade）上找到详细的指导步骤。

1.2 为什么选择MyBatis？

当前有很多Java实现的持久化框架，而MyBatis流行起来有以下原因：

• l   它消除了大量的JDBC冗余代码
• l   它有低的学习曲线
• l   它能很好地与传统数据库协同工作
• l   它可以接受SQL语句
• l   它提供了与Spring 和Guice框架的集成支持
• l   它提供了与第三方缓存类库的集成支持
• l   它引入了更好的性能

1.2.1 消除大量的JDBC冗余代码

Java通过Java数据库连接（Java DataBase Connectivity,JDBC）API来操作关系型数据库，但是JDBC是一个非常底层的API，我们需要书写大量的代码来完成对数据库的操作。

让我们演示一下我们是怎样使用纯的JDBC来对表STUDENTS实现简单的 select和 insert操作的。

假设表STUDENTS有STUD_ID，NAME，EMAIL 和DOB字段。对应的Student JavaBean 定义如下：

package com.mybatis3.domain;
import java.util.Date;
public class Student
{
    private Integer studId;
    private String name;
    private String email;
    private Date dob;
    // setters and getters
}

下面的StudentService.java实现了 通过JDBC对表STUDENTS的SELECT 和INSERT操作：

public Student findStudentById(int studId)
{
    Student student = null;
    Connection conn = null;
    try
    {
        //获得数据库连接
        conn = getDatabaseConnection();
        String sql = "SELECT * FROM STUDENTS WHERE STUD_ID=?";
        //创建  PreparedStatement
        PreparedStatement pstmt = conn.prepareStatement(sql);
        //设置输入参数
        pstmt.setInt(1, studId);
        ResultSet rs = pstmt.executeQuery();
        //从数据库中取出结果并生成 Java 对象
        if(rs.next())
        {
            student = new Student();
            student.setStudId(rs.getInt("stud_id"));
            student.setName(rs.getString("name"));
            student.setEmail(rs.getString("email"));
            student.setDob(rs.getDate("dob"));
        }
    }
    catch (SQLException e)
    {
        throw new RuntimeException(e);
    }
    finally
    {
        //关闭连接
        if(conn != null)
        {
            try
            {
                conn.close();
            }
            catch (SQLException e) { }
        }
    }
    return student;
}

public void createStudent(Student student)
{
    Connection conn = null;
    try
    {
        //获得数据库连接
        conn = getDatabaseConnection();
        String sql = "INSERT INTO STUDENTS(STUD_ID,NAME,EMAIL,DOB)
                     VALUES(?,?,?,?)";
        //创建 PreparedStatement
        PreparedStatement pstmt = conn.prepareStatement(sql);
        //设置输入参数
        pstmt.setInt(1, student.getStudId());
        pstmt.setString(2, student.getName());
        pstmt.setString(3, student.getEmail());
        pstmt.setDate(4, new
                      java.sql.Date(student.getDob().getTime()));
        pstmt.executeUpdate();
    }
    catch (SQLException e)
    {
        throw new RuntimeException(e);
    }
    finally
    {
        //关闭连接
        if(conn != null)
        {
            try
            {
                conn.close();
            }
            catch (SQLException e) { }
        }
    }
}
protected Connection getDatabaseConnection() throws SQLException
{
    try
    {
        Class.forName("com.mysql.jdbc.Driver");
        return DriverManager.getConnection
               ("jdbc:mysql://localhost:3306/test", "root", "admin");
    }
    catch (SQLException e)
    {
        throw e;
    }
    catch (Exception e)
    {
        throw new RuntimeException(e);
    }
}

上述的每个方法中有大量的重复代码：创建一个连接，创建一个Statement对象，设置输入参数，关闭资源（如connection，statement，resultSet）。

MyBatis抽象了上述的这些相同的任务，如准备需要被执行的SQL statement对象并且将Java对象作为输入数据传递给statement对象的任务，进而开发人员可以专注于真正重要的方面。

另外，MyBatis 自动化了将从输入的Java对象中的属性设置成查询参数、从SQL结果集上生成Java对象这两个过程。

现在让我们看看怎样通过MyBatis实现上述的方法：

1.  在 SQL Mapper 映射配置文件中配置SQL语句，假定为StudentMapper.xml

<select id="findStudentById" parameterType="int" resultType="Student">
    SELECT STUD_ID AS studId, NAME, EMAIL, DOB
        FROM STUDENTS WHERE STUD_ID=#{Id}
</select>
<insert id="insertStudent" parameterType="Student">
    INSERT INTO STUDENTS(STUD_ID,NAME,EMAIL,DOB)
        VALUES(#{studId},#{name},#{email},#{dob})
</insert>

2.  创建一个StudentMapper接口.

public interface StudentMapper
{
    Student findStudentById(Integer id);
    void insertStudent(Student student);
}

3. 在Java代码中，你可以使用如下代码触发SQL语句：

SqlSession session = getSqlSessionFactory().openSession();
StudentMapper mapper = session.getMapper(StudentMapper.class);
// Select Student by Id
Student student = mapper.selectStudentById(1);
//To insert a Student record
mapper.insertStudent(student);

就是这么简单！你不需要创建Connection连接，PreparedStatement，不需要自己对每一次数据库操作进行手动设置参数和关闭连接。只需要配置数据库连接属性和SQL语句，MyBatis会处理这些底层工作。

现在你不用担心SqlSessionFactory、SqlSession、Mapper XML文件是什么，这些概念我们会在接下来的章节中详细解释。

另外，MyBatis还提供了其他的一些特性来简化持久化逻辑的实现:

• l   它支持复杂的SQL结果集数据映射到嵌套对象图结构
• l   它支持一对一和一对多的结果集和Java对象的映射
• l   它支持根据输入的数据构建动态的SQL语句

1.2.2 它有低的学习曲线

MyBatis能够流行的首要原因之一在于它学习和使用起来非常简单，它取决于你Java和SQL方面的知识。如果开发人员很熟悉Java和SQL，他们会发现MyBatis入门非常简单。

1.2.3 它能很好地与传统数据库协同工作

有时我们可能需要用不正规形式与传统数据库协同工作，使用成熟的ORM框架（如Hibernate）有可能、但是很难跟传统数据库很好地协同工作，因为他们尝试将Java对象静态地映射到数据库的表上(译者注：这一类型的框架都尝试将一张表的一条记录映射成一个JavaBean，这种方式一定程度上丧失了SQL语句的灵活性)。

而MyBatis是将查询的结果与Java对象映射起来，这使得MyBatis可以很好地与传统数据库协同工作。你可以根据面相对象的模型创建Java 域对象，执行传统数据库的查询，然后将结果映射到对应的Java对象上。

1.2.4 它可以接受SQL语句

成熟的ORM框架（如Hibernate）鼓励使用实体对象（EntityObjects）和在其底层自动产生SQL语句。由于这种的SQL生成方式，我们有可能不能够利用到数据库的一些特有的特性。Hibernate允许执行本地SQL，但是这样会打破持久层和数据库独立的原则。

MyBatis框架接受SQL语句，而不是将其对开发人员隐藏起来。由于MyBatis不会产生任何的SQL语句，所以开发人员就要准备SQL语句，这样就可以充分利用数据库特有的特性并且可以准备自定义的查询。另外，MyBatis对存储过程也提供了支持。

1.2.5 它提供了与Spring 和Guice框架的集成支持

MyBatis提供了与 流行的依赖注入框架Spring和Guice的开包即用的集成支持，这将进一步简化MyBatis的使用

1.2.6 它提供了与第三方缓存类库的集成支持

MyBatis有内建的SqlSession级别的缓存机制，用于缓存Select语句查询出来的结果。除此之外，MyBatis提供了与多种第三方缓存类库的集成支持，如EHCache，OSCache，Hazelcast。

1.2.7 它引入了更好的性能

性能问题是关乎软件应用成功与否的关键因素之一。为了达到更好的性能，需要考虑很多事情，而对很多应用而言，数据持久化层是整个系统性能的关键。

MyBatis支持数据库连接池，消除了为每一个请求创建一个数据库连接的开销

MyBatis 提供了内建的缓存机制，在SqlSession级别提供了对SQL查询结果的缓存。即:如果你调用了相同的select查询，MyBatis会将放在缓存的结果返回，而不会去再查询数据库。

MyBatis框架并没有大量地使用代理机制(译者注：一些ORM框架使用了大量的动态代理模式来产生实体对象等，由于动态代理本身有很大的内存消耗，大量使用动态代理，会使整个系统性能变得很差)，因此对于其他的过度地使用代理的ORM 框架而言，MyBatis可以获得更好的性能。

1.3 MyBatis安装和配置

我们假设你的系统上已经安装了JDK1.6+和MySQL5。JDK和MySQL安装过程不在本书的叙述范围。

在写本书时，MyBatis最新版是MyBatis 3.2.2。贯穿本书，我们将使用MyBatis3.2.2版本。

本文并不限定你使用什么类型的IDE（如Eclipse，NetBeans IDE，或者IntelliJ IDEA，它们通过提供自动完成，重构，调试特性来很大程度上简化了开发）来编码，你可以选择你喜欢的IDE。

本节将（通过以下步骤）说明如何使用MyBatis开发一个简单的Java项目：

• l   新建表STUDENTS，插入样本数据
• l   新建一个Java项目，将MyBatis-3.2.2.jar添加到classpath中
• l   新建mybatis-config.xml 和映射器StudentMapper.xml配置文件
• l   新建建MyBatisSqlSessionFactory单例模式类
• l   新建映射器StudentMapper 接口和 StudentService 类
• l   新建一个JUnit 测试类来测试 StudentService

1.3.1 新建表STUDENTS，插入样本数据

使用以下SQL脚本往MySQL数据库中创建STUDENTS表插入样本数据：

CREATE TABLE STUDENTS
(
stud_id int(11) NOT NULL AUTO_INCREMENT,
name varchar(50) NOT NULL,
email varchar(50) NOT NULL,
dob date DEFAULT NULL,
PRIMARY KEY (stud_id)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=latin1;
/*Sample Data for the students table */
insert into students(stud_id,name,email,dob)
values (1,'Student1','[email protected]','1983-06-25');
insert into students(stud_id,name,email,dob)
values (2,'Student2','[email protected]','1983-06-25');

1.3.2 新建一个Java项目，将MyBatis-3.2.2.jar添加到classpath中

让我们创建一个Java项目，并被指MyBatis JAR 包依赖：

1.  创建一个Java项目，名为mybatis-demo.

2.  如果你没有使用类似于Maven和Gradle之类的依赖管理构建工具，你需要手动下载这些依赖的JAR包，手动添加到classpath中.

3.  你可以从 http://code.google.com/p/mybatis 上下载MyBatis的发布包mybatis-3.2.2.zip。这个包包含了mybatis-3.2.2.jar文件和它的可选的依赖包如slf4j/log4j 日志jar包.

4.  我们将使用SLF4J 日志记录框架 和log4j一起记录日志。mybatis-3.2.2.zip包含了slf4j这个依赖jar包。

5.  解压mybatis-3.2.2.zip文件,将mybatis-3.2.2.jar,lib/slf4j-api-1.7.5.jar,lib/slf-log4j12-1.7.5.jar,和lib/log4j-1.2.17.jar 这些jar包添加到classpath中

6.  你可以从http://junit.org 上下载JUnit JAR文件，从http://www.mysql.com/downloads/connector/j/ 上下载MySQL数据库驱动

7.  将 junit-4.11.jar 和 mysql-connector-java-5.1.22.jar 添加到classpath中

如果你正在使用maven，配置这些jar包依赖就变得简单多了。在你的pom.xml中添加以下依赖即可：

<dependencies>
  <dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.2.2</version>
  </dependency>
  <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.22</version>
    <scope>runtime</scope>
  </dependency>
  <dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.7.5</version>
  </dependency>
  <dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
    <version>1.7.5</version>
    <scope>runtime</scope>
  </dependency>
  <dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
    <scope>runtime</scope>
  </dependency>
  <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.11</version>
    <scope>test</scope>
  </dependency>
</dependencies>

9.  新建log4j.properties文件，添加到 classpath中.

log4j.rootLogger=DEBUG, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d [%-5p] %c - %m%n

1.3.3 新建mybatis-config.xml 和映射器StudentMapper.xml配置文件

让我们来创建MyBatis 的主要配置文件 mybatis-config.xml，其中包括数据库连接信息，类型别名等等；然后创建一个包含了映射的SQL语句的StudentMapper.xml文件。

1. 创建MyBatis 的主要配置文件 mybatis-config.xml，其中包括数据库连接信息，类型别名等等，然后将其加到classpath中；

<?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>
  <typeAliases>
    <typeAlias alias="Student" type="com.mybatis3.domain.Student" />
  </typeAliases>
  <environments default="development">
    <environment id="development">
      <transactionManager type="JDBC" />
      <dataSource type="POOLED">
        <property name="driver" value="com.mysql.jdbc.Driver" />
        <property name="url" value="jdbc:mysql://localhost:3306/test" />
        <property name="username" value="root" />
        <property name="password" value="admin" />
      </dataSource>
    </environment>
  </environments>
  <mappers>
    <mapper resource="com/mybatis3/mappers/StudentMapper.xml" />
  </mappers>
</configuration>

2. 创建SQL 映射器XML配置文件StudentMapper.xml 并且将它放在com.mybatis3.mappers包中；

<?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.mybatis3.mappers.StudentMapper">
  <resultMap type="Student" id="StudentResult">
    <id property="studId" column="stud_id" />
    <result property="name" column="name" />
    <result property="email" column="email" />
    <result property="dob" column="dob" />
  </resultMap>
  <select id="findAllStudents" resultMap="StudentResult">
     SELECT * FROM STUDENTS
  </select>
  <select id="findStudentById" parameterType="int" resultType="Student">
     SELECT STUD_ID AS STUDID, NAME, EMAIL, DOB
         FROM STUDENTS WHERE STUD_ID=#{Id}
  </select>
  <insert id="insertStudent" parameterType="Student">
     INSERT INTO STUDENTS(STUD_ID,NAME,EMAIL,DOB)
         VALUES(#{studId },#{name},#{email},#{dob})
  </insert>
</mapper>

上述的StudentMapper,xml 文件包含的映射的SQL语句可以通过ID加上名空间调用。

1.3.4 新建建MyBatisSqlSessionFactory单例模式类

新建 MyBatisSqlSessionFactory.java 类文件，实例化它，使其持有一个SqlSessionFactory单例对象：

package com.mybatis3.util;
import java.io.*;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.*;
public class MyBatisSqlSessionFactory
{
    private static SqlSessionFactory sqlSessionFactory;
    public static SqlSessionFactory getSqlSessionFactory()
    {
        if(sqlSessionFactory == null)
        {
            InputStream inputStream;
            try
            {
                inputStream = Resources.
                              getResourceAsStream("mybatis-config.xml");
                sqlSessionFactory = new
                SqlSessionFactoryBuilder().build(inputStream);
            }
            catch (IOException e)
            {
                throw new RuntimeException(e.getCause());
            }
        }
        return sqlSessionFactory;
    }
    public static SqlSession openSession()
    {
        return getSqlSessionFactory().openSession();
    }
}

上述的代码段中，我们创建了一个SqlSessionFactory对象，我们将使用它来获得SqlSession对象和执行映射的SQL语句。

1.3.5 新建映射器StudentMapper 接口和 StudentService 类

让我们创建一个StudentMapper接口，其定义的方法名和在Mapper XML配置文件定义的SQL映射语句名称相同；在创建一个StudentService.java 类，包含了一些业务操作的实现。

1. 首先, 创建 JavaBean Student.java：

package com.mybatis3.domain;
import java.util.Date;
public class Student
{
    private Integer studId;
    private String name;
    private String email;
    private Date dob;
    // setters and getters
}

2. 创建映射器Mapper接口StudentMapper.java 其方法签名和StudentMapper.xml中定义的SQL映射定义名相同：

package com.mybatis3.mappers;
import java.util.List;
import com.mybatis3.domain.Student;
public interface StudentMapper
{
    List<Student> findAllStudents();
    Student findStudentById(Integer id);
    void insertStudent(Student student);
}

3.  现在创建StudentService.java 实现对表STUDENTS的数据库操作：

package com.mybatis3.services;
import java.util.List;
import org.apache.ibatis.session.SqlSession;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.mybatis3.domain.Student;
import com.mybatis3.mappers.StudentMapper;
import com.mybatis3.util.MyBatisSqlSessionFactory;
public class StudentService
{
    private Logger logger =
        LoggerFactory.getLogger(getClass());
    public List<Student> findAllStudents()
    {
        SqlSession sqlSession =
            MyBatisSqlSessionFactory.openSession();
        try
        {
            StudentMapper studentMapper =
                sqlSession.getMapper(StudentMapper.class);
            return studentMapper.findAllStudents();
        }
        finally
        {
            //If sqlSession is not closed
            //then database Connection associated this sqlSession will not be
            returned to pool
            //and application may run out of connections.
            sqlSession.close();
        }
    }
    public Student findStudentById(Integer studId)
    {
        logger.debug("Select Student By ID :{}", studId);
        SqlSession sqlSession =
            MyBatisSqlSessionFactory.openSession();
        try
        {
            StudentMapper studentMapper =
                sqlSession.getMapper(StudentMapper.class);
            return studentMapper.findStudentById(studId);
        }
        finally
        {
            sqlSession.close();
        }
    }
    public void createStudent(Student student)
    {
        SqlSession sqlSession =
            MyBatisSqlSessionFactory.openSession();
        try
        {
            StudentMapper studentMapper =
                sqlSession.getMapper(StudentMapper.class);
            studentMapper.insertStudent(student);
            sqlSession.commit();
        }
        finally
        {
            sqlSession.close();
        }
    }
}

你也可以通过不通过Mapper接口执行映射的SQL语句。

Student student = (Student)sqlSession.
                  selectOne("com.mybatis3.mappers.StudentMapper.findStudentById",
                            studId);

然而，使用Mapper接口是最佳实践，我们可以以类型安全的方式调用映射的SQL语句。

1.3.6 新建一个JUnit 测试类来测试 StudentService

新建一个JUnit测试类测试StudentSerivce.java中定义的方法。

package com.mybatis3.services;
import java.util.*;
import org.junit.*;
import com.mybatis3.domain.Student;
public class StudentServiceTest
{
    private static StudentService studentService;
    @BeforeClass
    public static void setup()
    {
        studentService = new StudentService();
    }
    @AfterClass
    public static void teardown()
    {
        studentService = null;
    }
    @Test
    public void testFindAllStudents()
    {
        List<Student> students = studentService.findAllStudents();
        Assert.assertNotNull(students);
        for (Student student : students)
        {
            System.out.println(student);
        }
    }
    @Test
    public void testFindStudentById()
    {
        Student student = studentService.findStudentById(1);
        Assert.assertNotNull(student);
        System.out.println(student);
    }
    @Test
    public void testCreateStudent()
    {
        Student student = new Student();
        int id = 3;
        student.setStudId(id);
        student.setName("student_" + id);
        student.setEmail("student_" + id + "gmail.com");
        student.setDob(new Date());
        studentService.createStudent(student);
        Student newStudent = studentService.findStudentById(id);
        Assert.assertNotNull(newStudent);
    }
}

1.3.7 它是怎么工作的

首先，我们配置了MyBatis最主要的配置文件-mybatis-config.xml,里面包含了JDBC连接参数；配置了映射器Mapper XML配置文件文件，里面包含了SQL语句的映射。

我们使用mybatis-config.xml内的信息创建了SqlSessionFactory对象。每个数据库环境应该就一个SqlSessionFactory对象实例，所以我们使用了单例模式只创建一个SqlSessionFactory实例。

我们创建了一个映射器Mapper接口-StudentMapper，其定义的方法签名和在StudentMapper.xml中定义的完全一样（即映射器Mapper接口中的方法名跟StudentMapper.xml中的id的值相同）。注意StudentMapper.xml中namespace的值被设置成com.mybatis3.mappers.StudentMapper，是StudentMapper接口的完全限定名。这使我们可以使用接口来调用映射的SQL语句。

在StudentService.java中，我们在每一个方法中创建了一个新的SqlSession，并在方法功能完成后关闭SqlSession。每一个线程应该有它自己的SqlSession实例。SqlSession对象实例不是线程安全的，并且不被共享。所以SqlSession的作用域最好就是其所在方法的作用域。从Web应用程序角度上看，SqlSession应该存在于request级别作用域上。

1.4 域模型样例

在这一节，我们将讨论一个表示在线学习系统应用的域模型样例，该模型的使用会贯穿全书。

在线学习系统中，学生可以选择课程，并且通过基于Web的传播媒介上课，日虚拟课堂或者是桌面共享系统。

有兴趣通过在线学习系统上课的导师可以在系统中注册，声明他们要教的课程明细。

课程明细包括课程名称，课程描述，课程时长。全球的学生都可以注册和选择他们想学的课程。

下面的图表表示了我们在线学习系统的数据库结构：

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

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

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

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

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