MyBatis

简介

MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis 。2013年11月迁移到Github。

iBATIS一词来源于“internet”和“abatis”的组合，是一个基于Java的持久层框架。iBATIS提供的持久层框架包括SQL Maps和Data Access Objects（DAOs）

1）MyBATIS 目前提供了三种语言实现的版本，包括：Java、.NET以及Ruby。（我主要学习java，就讲java的使用）
  2）它提供的持久层框架包括SQL Maps和Data Access Objects（DAO）。
  3）mybatis与hibernate的对比？

   mybatis提供一种“半自动化”的ORM实现。
   这里的“半自动化”，是相对Hibernate等提供了全面的数据库封装机制的“全自动化”ORM实现而言，“全自动”ORM实现了POJO和数据库表之间的映射，以及 SQL 的自动生成和执行。

而mybatis的着力点，则在于POJO与SQL之间的映射关系。

基本信息

MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的 POJOs(Plain Old Java Objects,普通的 Java对象)映射成数据库中的记录。 ^[1] 

背景介绍

MyBatis ^[2]  是支持普通 SQL查询，存储过程和高级映射的优秀持久层框架。MyBatis 消除了几乎所有的JDBC代码和参数的手工设置以及结果集的检索。MyBatis 使用简单的 XML或注解用于配置和原始映射，将接口和 Java 的POJOs（Plain Ordinary Java Objects，普通的 Java对象）映射成数据库中的记录。

每个MyBatis应用程序主要都是使用SqlSessionFactory实例的，一个SqlSessionFactory实例可以通过SqlSessionFactoryBuilder获得。SqlSessionFactoryBuilder可以从一个xml配置文件或者一个预定义的配置类的实例获得。

用xml文件构建SqlSessionFactory实例是非常简单的事情。推荐在这个配置中使用类路径资源（classpath resource)，但你可以使用任何Reader实例，包括用文件路径或file://开头的url创建的实例。MyBatis有一个实用类----Resources，它有很多方法，可以方便地从类路径及其它位置加载资源。

特点

• 简单易学：本身就很小且简单。没有任何第三方依赖，最简单安装只要两个jar文件+配置几个sql映射文件易于学习，易于使用，通过文档和源代码，可以比较完全的掌握它的设计思路和实现。
• 灵活：mybatis不会对应用程序或者数据库的现有设计强加任何影响。 sql写在xml里，便于统一管理和优化。通过sql基本上可以实现我们不使用数据访问框架可以实现的所有功能，或许更多。
• 解除sql与程序代码的耦合：通过提供DAO层，将业务逻辑和数据访问逻辑分离，使系统的设计更清晰，更易维护，更易单元测试。sql和代码的分离，提高了可维护性。
• 提供映射标签，支持对象与数据库的orm字段关系映射
• 提供对象关系映射标签，支持对象关系组建维护
• 提供xml标签，支持编写动态sql。 ^[3] 

总体流程

(1)加载配置并初始化

触发条件：加载配置文件

处理过程：将SQL的配置信息加载成为一个个MappedStatement对象（包括了传入参数映射配置、执行的SQL语句、结果映射配置），存储在内存中。

(2)接收调用请求

触发条件：调用Mybatis提供的API

传入参数：为SQL的ID和传入参数对象

处理过程：将请求传递给下层的请求处理层进行处理。

(3)处理操作请求

触发条件：API接口层传递请求过来

传入参数：为SQL的ID和传入参数对象

处理过程：

(A)根据SQL的ID查找对应的MappedStatement对象。

(B)根据传入参数对象解析MappedStatement对象，得到最终要执行的SQL和执行传入参数。

(C)获取数据库连接，根据得到的最终SQL语句和执行传入参数到数据库执行，并得到执行结果。

(D)根据MappedStatement对象中的结果映射配置对得到的执行结果进行转换处理，并得到最终的处理结果。

(E)释放连接资源。

(4)返回处理结果将最终的处理结果返回。

功能架构

我们把Mybatis的功能架构分为三层：

(1)API接口层：提供给外部使用的接口API，开发人员通过这些本地API来操纵数据库。接口层一接收到调用请求就会调用数据处理层来完成具体的数据处理。

(2)数据处理层：负责具体的SQL查找、SQL解析、SQL执行和执行结果映射处理等。它主要的目的是根据调用的请求完成一次数据库操作。

(3)基础支撑层：负责最基础的功能支撑，包括连接管理、事务管理、配置加载和缓存处理，这些都是共用的东西，将他们抽取出来作为最基础的组件。为上层的数据处理层提供最基础的支撑。 ^[3] 

框架架构

框架架构讲解：

(1)加载配置：配置来源于两个地方，一处是配置文件，一处是Java代码的注解，将SQL的配置信息加载成为一个个MappedStatement对象（包括了传入参数映射配置、执行的SQL语句、结果映射配置），存储在内存中。

(2)SQL解析：当API接口层接收到调用请求时，会接收到传入SQL的ID和传入对象（可以是Map、JavaBean或者基本数据类型），Mybatis会根据SQL的ID找到对应的MappedStatement，然后根据传入参数对象对MappedStatement进行解析，解析后可以得到最终要执行的SQL语句和参数。

(3)SQL执行：将最终得到的SQL和参数拿到数据库进行执行，得到操作数据库的结果。

(4)结果映射：将操作数据库的结果按照映射的配置进行转换，可以转换成HashMap、JavaBean或者基本数据类型，并将最终结果返回。

动态SQL

MyBatis 最强大的特性之一就是它的动态语句功能。如果您以前有使用JDBC或者类似框架的经历，您就会明白把SQL语句条件连接在一起是多么的痛苦，要确保不能忘记空格或者不要在columns列后面省略一个逗号等。动态语句能够完全解决掉这些痛苦。
　　尽管与动态SQL一起工作不是在开一个party，但是MyBatis确实能通过在任何映射SQL语句中使用强大的动态SQL来改进这些状况。动态SQL元素对于任何使用过JSTL或者类似于XML之类的文本处理器的人来说，都是非常熟悉的。在上一版本中，需要了解和学习非常多的元素，但在MyBatis 3 中有了许多的改进，现在只剩下差不多二分之一的元素。MyBatis使用了基于强大的OGNL表达式来消除了大部分元素。

集成

单独使用mybatis ^[4]  是有很多限制的（比如无法实现跨越多个session的事务），而且很多业务系统本来就是使用spring来管理的事务，因此mybatis最好与spring集成起来使用 ^[4]  。

spring事务配置

1. <!--自动扫描业务包-->
2. <context:component-scanbase-package="com.xxx.service"/>
3. <!--数据源-->
4. <jee:jndi-lookupid="jndiDataSource"jndi-name="java:comp/env/jdbc/datasource"/>
5. <!--配置事务-->
6. <beanid="txManager"
7. class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
8. <propertyname="dataSource"ref="jndiDataSource"/>
9. </bean>
10. <!--配置基于注解的事物aop-->
11. <tx:annotation-driventransaction-manager="txManager"proxy-target-class="true"/>

Mybatis使用示例

 1）首先建立项目java web

  

2）导入mybatis所需的jar包

mybatis需要jar包：mybatis-3.3.0.jar

mysql驱动jar包：mysql-connector-java-5.1.15.-bin.jar

日志记录jar包：log4j.jar

3)创建数据库数据（mysql）

4）mysql驱动配置文件（这样可以优化性能） 

 我个人喜欢把所需要使用到的包先建立好。配置文件先创建好。

5）添加mybatis配置文件mybatis.cfg.xml

 1 <?xml version="1.0" encoding="UTF-8"?>

 2 <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">

 3 <configuration>

 4 

 5   <!-- 引入外部配置文件 -->

 6   <properties resource="mysql.properties"></properties>

 7    

 8    <!-- 配置mybatis运行环境 -->

 9      <environments default="cybatis">

10         <environment id="cybatis">

11             <!-- type="JDBC" 代表使用JDBC的提交和回滚来管理事务 -->

12             <transactionManager type="JDBC" />

13             

14             <!-- mybatis提供了3种数据源类型，分别是：POOLED,UNPOOLED,JNDI -->

15             <!-- POOLED 表示支持JDBC数据源连接池 -->

16             <!-- UNPOOLED 表示不支持数据源连接池 -->

17             <!-- JNDI 表示支持外部数据源连接池 -->

18             <dataSource type="POOLED">

19                 <property name="driver" value="${jdbc.driver}" />

20                 <property name="url" value="${jdbc.url}" />

21                 <property name="username" value="${jdbc.username}" />

22                 <property name="password" value="${jdbc.password}" />

23             </dataSource>

24         </environment>

25     </environments> 

26     

27 </configuration>

6)创建对应的实体对象

对应的java代码：

         View Code

           

7）创建方法接口UserMapper.java和定义操作t_user表的sql映射文件UserMapper.xml

 提供简单的增删改查数据信息。

 1 package com.cy.mybatis.mapper;

 2 

 3 import java.util.List;

 4 

 5 import com.cy.mybatis.beans.UserBean;

 6 

 7 public interface UserMapper {

 8     /**

 9      * 新增用戶

10      * @param user

11      * @return

12      * @throws Exception

13      */

14     public int insertUser(UserBean user) throws Exception;

15     /**

16      * 修改用戶

17      * @param user

18      * @param id

19      * @return

20      * @throws Exception

21      */

22     public int updateUser (UserBean user,int id) throws Exception;

23      /**

24       * 刪除用戶

25       * @param id

26       * @return

27       * @throws Exception

28       */

29     public int deleteUser(int id) throws Exception;

30     /**

31      * 根据id查询用户信息

32      * @param id

33      * @return

34      * @throws Exception

35      */

36     public UserBean selectUserById(int id) throws Exception;

37      /**

38       * 查询所有的用户信息

39       * @return

40       * @throws Exception

41       */

42     public List<UserBean> selectAllUser() throws Exception;

43 }

UserMapper.xml

 1 <?xml version="1.0" encoding="UTF-8"?>

 2 <!DOCTYPE mapper PUBLIC "-//mybatis.org/DTD Mapper 3.0" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

 3 <mapper namespace="com.cy.mybatis.mapper.UserMapper">

 4 <!-- 自定义返回结果集 -->

 5    <resultMap id="userMap" type="UserBean">

 6         <id property="id" column="id" javaType="java.lang.Integer"></id>

 7         <result property="username" column="username" javaType="java.lang.String"></result>

 8         <result property="password" column="password" javaType="java.lang.String"></result>

 9         <result property="account" column="account" javaType="java.lang.Double"></result>

10     </resultMap>

11 <!-- 在各种标签中的id属性必须和接口中的方法名相同 ， id属性值必须是唯一的，不能够重复使用。parameterType属性指明查询时使用的参数类型，resultType属性指明查询返回的结果集类型-->    

12 <!-- useGeneratedKeys：（ 仅 对 insert 有 用 ） 这 会 告 诉 MyBatis 使 用 JDBC 的getGeneratedKeys 

13             方法来取出由数据（比如：像 MySQL 和 SQLServer 这样的数据库管理系统的自动递增字段）内部生成的主键。默认值： false。 -->    

14 <!--keyProperty： （仅对 insert有用）标记一个属性， MyBatis 会通过 getGeneratedKeys或者通过 insert 语句的 selectKey 子元素设置它的值。默认：不设置。 -->

15 <!--#{}中的内容，为占位符，当参数为某个JavaBean时，表示放置该Bean对象的属性值  -->

16 

17 

18     <insert id="insertUser" useGeneratedKeys="true" keyProperty="id">

19         insert into t_user (username,password,account) values (#{username},#{password},#{account})

20     </insert>

21     

22     <update id="updateUser" >

23       update t_user set username=#{username},password=#{password},account=#{account} where id=#{id}

24     </update>

25     

26     <delete id="deleteUser" parameterType="int">

27      delete from t_user where id=#{id}  

28     </delete>

29     

30     <select id="selectUserById" parameterType="int" resultMap="userMap">

31      select * from t_user where id=#{id}

32     </select>

33     

34     <select id="selectAllUser" resultMap="userMap">

35      select * from t_user

36     </select>

37     

38     

39 </mapper>    

这时需要为mybatis.cfg.xml里注册UserMapper.xml文件。

 1 <?xml version="1.0" encoding="UTF-8"?>

 2 <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">

 3 <configuration>

 4 

 5   <!-- 引入外部配置文件 -->

 6   <properties resource="mysql.properties"></properties>

 7   

 8   

 9    <!-- 为JAVA Bean起类别名 -->

10    <typeAliases >

11         <!-- 别名方式1，一个一个的配置 type中放置的是类的全路径，alias中放置的是类别名

12         <typeAliase type="com.cy.mybatis.beans.UserBean" alias="UserBean"/> -->

13         <!-- 别名方式2，自动扫描，将JAVA类的类名作为类的类别名 -->

14         <package name="com.cy.mybatis.beans"/>

15    </typeAliases>

16    

17    

18    <!-- 配置mybatis运行环境 -->

19      <environments default="cybatis">

20         <environment id="cybatis">

21             <!-- type="JDBC" 代表使用JDBC的提交和回滚来管理事务 -->

22             <transactionManager type="JDBC" />

23             

24             <!-- mybatis提供了3种数据源类型，分别是：POOLED,UNPOOLED,JNDI -->

25             <!-- POOLED 表示支持JDBC数据源连接池 -->

26             <!-- UNPOOLED 表示不支持数据源连接池 -->

27             <!-- JNDI 表示支持外部数据源连接池 -->

28             <dataSource type="POOLED">

29                 <property name="driver" value="${jdbc.driver}" />

30                 <property name="url" value="${jdbc.url}" />

31                 <property name="username" value="${jdbc.username}" />

32                 <property name="password" value="${jdbc.password}" />

33             </dataSource>

34         </environment>

35     </environments> 

36     

37     

38     <mappers>

39         <!-- 告知映射文件方式1，一个一个的配置

40         <mapper resource="com/cy/mybatis/mapper/UserMapper.xml"/>-->

41         <!-- 告知映射文件方式2，自动扫描包内的Mapper接口与配置文件 -->

42         <package name="com/cy/mybatis/mapper"/>

43     </mappers>

44 </configuration>

8）需要建立一个工具类文件

 1 package com.cy.mybatis.tools;

 2 

 3 import java.io.Reader;

 4 

 5 import org.apache.ibatis.io.Resources;

 6 import org.apache.ibatis.session.SqlSession;

 7 import org.apache.ibatis.session.SqlSessionFactory;

 8 import org.apache.ibatis.session.SqlSessionFactoryBuilder;

 9 

10 public class DBTools {

11     public static SqlSessionFactory sessionFactory;

12     

13     static{

14         try {

15             //使用MyBatis提供的Resources类加载mybatis的配置文件

16             Reader reader = Resources.getResourceAsReader("mybatis.cfg.xml");

17             //构建sqlSession的工厂

18             sessionFactory = new SqlSessionFactoryBuilder().build(reader);

19         } catch (Exception e) {

20             e.printStackTrace();

21         }

22         

23     }

24     //创建能执行映射文件中sql的sqlSession

25     public static SqlSession getSession(){

26         return sessionFactory.openSession();

27     }

28     

29 }

9）写个测试

 1 package com.cy.mybatis.service;

 2 

 3 import java.util.List;

 4 

 5 import org.apache.ibatis.session.SqlSession;

 6 

 7 import com.cy.mybatis.beans.UserBean;

 8 import com.cy.mybatis.tools.DBTools;

 9 import com.cy.mybatis.mapper.UserMapper;

10 

11 public class UserService {

12 

13    

14 15      

16     public static void main(String[] args) {

17           insertUser();

18 //        deleteUser();

19 //        selectUserById();

20 //        selectAllUser();

21     }

22 

23     

24     /**

25      * 新增用户

26      */

27     private static void insertUser() {

28         SqlSession session = DBTools.getSession();

29         UserMapper mapper = session.getMapper(UserMapper.class);

30         UserBean user = new UserBean("懿", "1314520", 7000.0);

31         try {

32             mapper.insertUser(user);

33             System.out.println(user.toString());

34              session.commit();

35         } catch (Exception e) {

36             e.printStackTrace();

37             session.rollback();

38         }

39     }

40     

41     

42     /**

43      * 删除用户

44      */

45     private static void deleteUser(){

46         SqlSession session=DBTools.getSession();

47         UserMapper mapper=session.getMapper(UserMapper.class);

48         try {

49             mapper.deleteUser(1);

50             session.commit();

51         } catch (Exception e) {

52             e.printStackTrace();

53             session.rollback();

54         }

55     }

56     

57     

58     /**

59      * 根据id查询用户

60      */

61     private static void selectUserById(){

62         SqlSession session=DBTools.getSession();

63         UserMapper mapper=session.getMapper(UserMapper.class);

64         try {

65         UserBean user=    mapper.selectUserById(2);

66         System.out.println(user.toString());

67             

68             session.commit();

69         } catch (Exception e) {

70             e.printStackTrace();

71             session.rollback();

72         }

73     }

74     

75     /**

76      * 查询所有的用户

77      */

78     private static void selectAllUser(){

79         SqlSession session=DBTools.getSession();

80         UserMapper mapper=session.getMapper(UserMapper.class);

81         try {

82         List<UserBean> user=mapper.selectAllUser();

83         System.out.println(user.toString());

84         session.commit();

85         } catch (Exception e) {

86             e.printStackTrace();

87             session.rollback();

88         }

89     }

90     

91 

92 }

测试结果