mybatis(一) - 简介

1. 在了解myBatis之前，首先需要知道什么是ORM

ORM，即对象关系映射，为了解决 面对对象 和 数据库 存在的互不匹配的问题，简单来说就是将关系数据库中的数据转换成面向对象程序中的对象。
常用的ORM框架有：Hibernate 和 myBatis，也就是 ssh中的h 和 ssm中的m

1.1 Hibernate 和 myBatis 的特点和区别：

Hibernate提供了对数据库结构的完整的封装，不需要我们自己写sql语句，Hibernate能自动生成SQL语句，Hibernate符合JPA规范（JPA是Java持久层API，JavaEE提供）
myBatis简化了数据库交互的操作，封装了JDBC代码，其原理主要是通过映射文件配置，将SQL语句的参数和返回的结果字段映射到指定的对象中。myBatis需要自己定义sql语句。

这两个框架都是对JDBC操作的封装，简化了数据库的交互方式。Hibernate 要简化的更彻底一些，我们不再需要自己写sql语句。但对于程序员来说，sql语句控制在自己手里当然要好一些（当然具体使用因人而异），当然使用myBatis的第二个重要的原因就是 myBatis是一个轻量级框架，而 Hibernate 是一个重量级的框架。

2. 什么是MyBatis

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

在Java应用程序中，数据持久化层涉及到的工作有：
1）将从数据库查询到的数据封装成成所需要的Java对象；
2）将Java对象中的数据通SQL持久化到数据库中。

MyBatis通过抽象底层的JDBC代码，自动化SQL语句的结果集封装成的Java对象、自动化Java对象的数据持久化保存进数据库中的过程，从而使得SQL的使用变得容易。

2.1 myBatis的下载

MyBatis的前身是iBATIS，iBATIS于2002年由ClintonBegin创建
ibatis的官网 http://ibatis.apache.org/ 进去官网会看到下面提示:

apache ibatis is retired at the apache software foundation (2010/06/16)
     the original project team has moved to mybatis hosted at google code. see http://www.mybatis.org/ for more.

然而http://www.mybatis.org/这个地址一直处于打不开状态...

但是我们可以在github中找到mybatis的相关下载的:
mybatis在github中的地址：https://github.com/mybatis/mybatis-3
最新版本的mybatis的下载地址：https://github.com/mybatis/mybatis-3/releases
以及doc文档：http://www.mybatis.org/mybatis-3/

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

1）它消除了大量的JDBC冗余代码
Java通过JDBC的API来操作关系型数据库，但是JDBC是一个非常底层的API，我们需要书写大量的代码来完成对数据库的操作。例如一个插入操作，但是使用mybatis来完成相同的插入操作要简单方便灵活的多:

第一步：在XxxMapper映射配置文件中配置SQL语句，假定为StudentMapper.xml

<insert id="insertStudent" parameterType="Student"> 
    INSERT INTO STUDENTS(ID,NAME,EMAIL) 
    VALUES(#{id},#{name},#{email}) 
</insert> 

第二步：创建一个StudentMapper接口

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

第三步：编写java代码完成插入操作:

SqlSession session = getSqlSessionFactory().openSession(); 
StudentMapper mapper = session.getMapper(StudentMapper.class); 
mapper.insertStudent(student); `

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

3）它能很好地与传统数据库协同工作
类比其他ORM框架，例如 相比较于 hibernate，mybatis可以更加灵活的和数据库交互，sql语句掌握在自己手里，可以灵活修改，而hibernate框架则是需要将实体类完全映射到数据到表中，这使得修改起来比较麻烦。

4）它可以接受SQL语句
类比其他ORM框架，例如 hibernate，hibernate框架推荐让框架自动生成sql语句，这样以来就不能完全利用到数据库的一些特有的特性。
而mybatis框架则是推荐程序自己控制sql语句，这样就可以充分利用数据库特有的特性并且可以准备自定义的查询。

5）它提供了与Spring框架的集成支持
MyBatis提供了与Spring框架的集成支持，这将进一步简化MyBatis的使用

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

7）更好的性能
MyBatis支持数据库连接池，消除了为每一个请求创建一个数据库连接的开销。
MyBatis提供了内建的缓存机制，在SqlSession级别提供了对SQL查询结果的缓存。即：如果你调用了相同的select查询，MyBatis 会将放在缓存的结果返回，而不会去再查询数据库。

3. myBatis的使用

3.1 myBatis 使用三要素

1）在项目中导入mybatis的jar包
mybatis的核心包只有一个mybatis-3.x.x.jar，另外还有一些【可选】的依赖包(日志、代理等所需要的)，在下载的压缩包中可以找到.

2）mybatis框架中一般需要俩个配置文件（xml）:
1> mybatis的配置文件: mybatis-config.xml**
配置信息包括有：数据库连接信息，类型别名，映射文件路径等等
特点：名字一般是固定的，位置是src下面

示例：

<?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.briup.pojo.Student" /> 
  </typeAliases> 
  <environments default="development"> 
    <environment id="development"> 
      <transaction Manager type="JDBC" /> 
       <dataSource type="POOLED">
        <!--
        <property name="driver" value="com.mysql.jdbc.Driver" /> 
        <property name="url" value="jdbc:mysql://localhost:3306/test" /> 
        -->
        <property name="driver" value="oracle.jdbc.driver.OracleDriver" /> 
        <property name="url" value="jdbc:oracle:thin:@127.0.0.1:1521:XE" /> 
        <property name="username" value="test" /> 
        <property name="password" value="test" /> 
      </dataSource> 
    </environment> 
  </environments> 
  <mappers> 
    <mapper resource="com/briup/pojo/StudentMapper.xml" /> 
  </mappers> 
</configuration> 

2> mybatis的映射文件：XxxxMapper.xml
这个xml文件中包括Xxxx类所对应的数据库表的各种增删改查sql语句，例如：StudentMapper.xml文件中是Student类对应的表的各种select、insert、update、delete；
特点：名字一般为XxxxMapper.xml，Xxxx是对应类的名字，位置不固定，一般放到一个专门的package里面

示例：

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

3）mybatis中的映射接口XxxxMapper.java（对XxxxMapper.xml中的sql语句进行映射）
mybatis中除了必须的jar包、各种xml配置文件之外，一般还需要有调用sql语句执行的接口：XxxxMapper.java

示例：

public interface StudentMapper{
    List<Student> findAllStudents(); 
    Student findStudentById(Integer id); 
    void insertStudent(Student student); 
}

注意1：接口中的方法的名字和XML文件定义的SQL映射语句的名称要相同；
注意2：我们不需要去实现该接口，因为mybatis中提供了相应的方式在运行期间动态生成该接口的实现类对象。

3.2 mybatis中的 SqlSession接口 和 sqlSessionFactory接口

SqlSession接口的实现类对象是mybatis中最重要的一个对象，我们可以使用该对象动态获得XxxxMapper.java接口的实现类对象，然后就可以调用到XxxxMapper.java接口中方法所映射的sql语（(在xml文件中配置的sql语句）。

SqlSessionFactory接口的实现类对象是一个工厂对象,专门负责来产生SqlSession对象的
例如:

    InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml"); 

    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        
    SqlSession session = sqlSessionFactory.openSession();
        
    //第一种执行sql语句的方式  通过XxxxMapper接口的实现类对象来调用
    //动态获得XxxxMapper接口的实现类
    StudentMapper mapper = session.getMapper(StudentMapper.class);

    mapper.insertStudent(new Student(1,"tom","123@.qq.com"));
        
    //第二种执行sql语句的方式  执行调用XxxxMapper.xml中写好的sql语句
    //也可以【不通过】Mapper接口执行映射的SQL
    //但是，推荐使用 Mapper接口来执行
    //session.selectOne("com.briup.pojo.StudentMapper.findStudentById",1);

小结：

mybatis中几个中的组成部分：

1. 框架总配置文件：mybatis-config.xml，配置文件中最重要的是定义数据库连接四要素和sql映射文件的位置
2. sql语句映射文件：XxxxMapper.xml（Xxxx一般为实体类的名字）
   映射文件中定义sql语句标签，
   sql语句标签和 java中的映射接口通过命名空间一一对应，
   java的方法名和sql语句的id值一一对应
3. 映射接口XxxxMapper.java，接口中有定义方法，调用方法，执行XxxxMapper.xml文件中对应的sql语句
4. SqlSessionFactory类型对象，负责产生SqlSession对象，
5. SqlSession类型对象，负责动态创建映射接口XxxxMapper.java的实现类对象，使用该实现类对象，调用方法即可执行对应的sql语句。

   mybatis框架读取mybatis-config.xml文件即可创建出SqlSession对象。
   SqlSession工厂类创建出SqlSession类对象，SqlSession类里面的getMapper(接口.class)方法，负责动态产生映射接口 XxxxMapper.java的实现类对象，调用该类对象中的方法，即可执行映射文件中对应的sql语句

4. 编写一个简单的mybatis进行插入数据的实例

1）数据库建表 dob = Date of Birth

    drop table students;
    create table students ( 
        stud_id number PRIMARY KEY, 
        name varchar2(50) , 
        email varchar2(50) , 
        dob date 
    ); 

2）新建一个项目，创建好相应的package及class

    package com.briup.pojo;
    import java.util.Date;
    public class Student {
        private Integer studId; 
        private String name; 
        private String email; 
        private Date dob;
        get/set
    }

3）项目中引入mybatis的核心包以及可选的依赖包

必须的包  mybatis-3.4.6.jar、ojdbc8.jar
注意，ojdbc14.jar导入可以，但可能会版本不兼容
可选的包  junit-4.7.jar、log4j-1.2.17.jar

4）mybatis中的配置文件和映射文件分别引入到项目中

src下面的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>
        <typeAliases>
            <typeAlias type="com.briup.pojo.Student" alias="Student" />
        </typeAliases>

        <environments default="development">
            <environment id="development">
                <transactionManager type="JDBC"></transactionManager>
                <dataSource type="POOLED">
                    <property name="driver" value="oracle.jdbc.driver.OracleDriver" /> 
                    <property name="url" value="jdbc:oracle:thin:@127.0.0.1:1521:XE" /> 
                    <property name="username" value="briup" />
                    <property name="password" value="briup" />
                </dataSource>
            </environment>
        </environments>
                
        <mappers>
            <mapper resource="com/briup/mappers/StudentMapper.xml"/>
        </mappers>        
    </configuration>

com.briup.mappers包下面的StudentMapper.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">
    <!-- com.briup.mappers.StudentMapper是我们定义接口的全限定名字 这样就可以使用接口调用映射的SQL语句了 这个名字一定要和接口对应上-->
    <mapper namespace="com.briup.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>

5）配置log4j.properties文件中的日志输出:

位置src下面，内容:

    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
    #show sql
    log4j.logger.java.sql.ResultSet=INFO  
    log4j.logger.org.apache=INFO  
    log4j.logger.java.sql.Connection=DEBUG  
    log4j.logger.java.sql.Statement=DEBUG  
    log4j.logger.java.sql.PreparedStatement=DEBUG 

6）com.briup.mappers包下面新建一个接口StudentMapper.java，用来对应xml文件中的sql语句(映射)，从而方便我们调用

    package com.briup.mappers;
    import java.util.List;
    import com.briup.pojo.Student;

    //创建映射器Mapper接口StudentMapper
    //方法名和StudentMapper.xml中定义的SQL映射定义名相同
    //这个其实就是dao层接口(数据访问层,负责和数据库进行交互)
    public interface StudentMapper {
        List<Student> findAllStudents(); 
        Student findStudentById(Integer id); 
        void insertStudent(Student student);
    }

7）创建一个测试类StudentMapperTest.java

package test;
    import java.io.InputStream;
    import java.util.Date;

    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 org.junit.Test;

    import com.briup.mappers.StudentMapper;
    import com.briup.pojo.Student;

    public class StudentMapperTest {
                
        @Test
        public void test_insert(){
                    
            try {
                InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml"); 
                SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
                SqlSession sqlSession = sqlSessionFactory.openSession();
                        
                StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);
                Student s = new Student(1,"tom","[e-mail]",new Date());
                studentMapper.insertStudent(s);
                sqlSession.commit();
            } catch (Exception e) {
                e.printStackTrace();
            }
                    
        }
    }

8）运行成功后会在控制台中看到log4j日志输出的这个程序运行的相关信息

9）对mybatis的一些基本封装：
每次读取配置文件，产生一个工厂对象SqlSessionFactory，然后再生成出SqlSession对象，这个过程虽然并不复杂，但是也都是一些重复的代码流程，所以我们可以对其进行一个简单的封装:

package com.briup.utils;

    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;

    public class MyBatisSqlSessionFactory {
        private static SqlSessionFactory sqlSessionFactory;
                
        public static SqlSessionFactory getSqlSessionFactory(){
            if(sqlSessionFactory == null){
                InputStream inputStream = null;
                try {
                    inputStream = Resources.getResourceAsStream("mybatis-config.xml"); 
                    sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
                } catch (IOException e) {
                    e.printStackTrace();
                    throw new RuntimeException(e.getCause());
                }
            }
            return sqlSessionFactory;
        }
                
        public static SqlSession openSession() { 
            return openSession(false); 
        }
        public static SqlSession openSession(boolean autoCommit) { 
            return getSqlSessionFactory().openSession(autoCommit); 
        }            
    }

之后每次使用的时候只需要调用该类中的静态方法openSession即可。

上面的代码可简写为：

    //注意事务是自动提交还是手动提交
    MyBatisSqlSessionFactory.openSession().getMapper(StudentMapper.class).insertStudent(s);
        

注意：xml文件中写的sql语句，最后面不要写分号，否则会报错误，ORA-00911: 无效字符