mybatis入门及mybatis原理简介

           在今天这篇博文中，我将要介绍一下mybatis的框架原理，以及mybatis的入门程序，实现用户的增删改查，她有什么优缺点以及mybatis和hibernate之间存在着怎么样的关系，希望对小伙伴们有帮助，不足之处，还请多多指教。
什么是mybatis？
MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis 。2013年11月迁移到Github。
MyBatis 是支持定制化 SQL、存储过程以及高级映射的优秀的持久层框架。MyBatis 避免了几乎所有的 JDBC 代码和手工设置参数以及抽取结果集。MyBatis 使用简单的 XML 或注解来配置和映射基本体，将接口和 Java 的 POJO(Plain Old Java Objects,普通的 Java对象)映射成数据库中的记录。简单来说，mybatis就是一个持久层的框架，mybatis让程序将主要精力放在sql上，通过mybatis提供的映射方式，自由灵活生成满足需要的sql语句，mybatis可以将向preparedStatement中的输入参数自动进行输入映射，将查询结果集灵活映射成java对象。

接着，我们通过一张图，来了解一下mybatis的框架原理：

       

框架架构讲解：

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

b、SQL解析：当api接口层接收到调用请求时，会接收到传入slq的id和传入对象（可以是map或者基本数据类型），mybatis会根据sql的id找到对应的MappedStatement，然后根据传入参数对象对MappedStatement进行解析，解析后可以得到最终要执行的sql语句和参数。

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

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

mybatis入门程序解析

接着，小编结合demo来具体介绍一下，需求如下：
根据用户id查询用户信息；
根据用户名称模糊查询用户信息；
添加、删除、更新用户。
第一步、建立各种包和类，工程目录如下所示：

第二步、编写SqlMapConfig.xml中的内容，配置mybatis的运行环境，数据源，事务等。代码如下所示：

[java]  view plain  copy

 print ?

1. <span style="font-family:Comic Sans MS;font-size:18px;"><?xml version="1.0" encoding="UTF-8" ?>  
2. <!DOCTYPE configuration  
3. PUBLIC "-//mybatis.org//DTD Config 3.0//EN"  
4. "http://mybatis.org/dtd/mybatis-3-config.dtd">  
5. <configuration>     
6.     <!-- 将spring整合后environments配置将废除 -->  
7.     <environments default="developent">  
8.     <!-- 使用jdbc事务管理，事务控制由mybatis -->  
9.         <transactionManager type="JDBC"/>  
10.     <!-- 数据库连接池，由mybatis管理 -->  
11.         <dataSource type="POLLED">  
12.             <property name="driver" value="${jdbc.driver}"/>  
13.             <property name="url" value="${jdbc.url}"/>  
14.             <property name="username" value="${jdbc.username}"/>  
15.             <property name="password" value="${jdbc.password}"/>  
16.         </dataSource>  
17.     </environments>  
18.     <!-- 加载 映射文件 -->  
19.     <mappers>  
20.         <mapper resource="sqlmap/User.xml"/>  
21.     </mappers>  
22. </configuration>  
23. </span>  

第三步、编写User.java中的内容，如下所示：

[java]  view plain  copy

 print ?

1. <span style="font-family:Comic Sans MS;font-size:18px;">package cn.itcast.mybatis.po;  
2.   
3. import java.util.Date;  
4.   
5. /** 
6.  *  
7.  * <p>Title: User</p> 
8.  * <p>Description:用户po </p> 
9.  * @author  丁国华 
10.  * @date    2016年7月31日 15:39:04 
11.  * @version 1.0 
12.  */  
13. public class User {  
14.       
15.     //属性名和数据库表的字段对应  
16.     private int id;  
17.     private String username;// 用户姓名  
18.     private String sex;// 性别  
19.     private Date birthday;// 生日  
20.     private String address;// 地址  
21.     public int getId() {  
22.         return id;  
23.     }  
24.     public void setId(int id) {  
25.         this.id = id;  
26.     }  
27.     public String getUsername() {  
28.         return username;  
29.     }  
30.     public void setUsername(String username) {  
31.         this.username = username;  
32.     }  
33.     public String getSex() {  
34.         return sex;  
35.     }  
36.     public void setSex(String sex) {  
37.         this.sex = sex;  
38.     }  
39.     public Date getBirthday() {  
40.         return birthday;  
41.     }  
42.     public void setBirthday(Date birthday) {  
43.         this.birthday = birthday;  
44.     }  
45.     public String getAddress() {  
46.         return address;  
47.     }  
48.     public void setAddress(String address) {  
49.         this.address = address;  
50.     }  
51.     @Override  
52.     public String toString() {  
53.         return "User [id=" + id + ", username=" + username + ", sex=" + sex  
54.                 + ", birthday=" + birthday + ", address=" + address + "]";  
55.     }  
56.   
57.   
58. }  
59. </span>  

第四步、实现增删改查的功能，首先编写User.xml中的内容，如下所示：

[java]  view plain  copy

 print ?

1. <span style="font-family:Comic Sans MS;font-size:18px;"><?xml version="1.0" encoding="UTF-8" ?>  
2. <!DOCTYPE mapper  
3. PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"  
4. "http://mybatis.org/dtd/mybatis-3-mapper.dtd">  
5.   
6. <!-- namespace命名空间，作用就是对sql进行分类化管理，理解sql隔离   
7. 注意：使用mapper代理方法开发，namespace有特殊重要的作用-->  
8. <mapper namespace="test">  
9.   
10.     <!-- 在 映射文件中配置很多sql语句 -->  
11.     <!-- 需求：通过id查询用户表的记录 -->  
12.     <!-- 通过 select执行数据库查询  
13.     id：标识 映射文件中的 sql  
14.     将sql语句封装到mappedStatement对象中，所以将id称为statement的id  
15.     parameterType：指定输入 参数的类型，这里指定int型   
16.     #{}表示一个占位符号  
17.     #{id}：其中的id表示接收输入 的参数，参数名称就是id，如果输入 参数是简单类型，#{}中的参数名可以任意，可以value或其它名称  
18.       
19.     resultType：指定sql输出结果 的所映射的java对象类型，select指定resultType表示将单条记录映射成的java对象。  
20.      -->  
21.         <select id="findUserById" parameterType="int" resultType="cn.itcast.mybatis.po.User">  
22.         SELECT * FROM USER WHERE id=#{value}  
23.     </select>  
24.       
25.       
26.       
27.     <!-- 根据用户名称模糊查询用户信息，可能返回多条  
28.     resultType：指定就是单挑记录所映射的java对象类型  
29.     ${}:表示拼接sql串，将接收到参数的内容不加任何修饰拼接到sql中。  
30.     使用${}拼接sql，引起sql注入  
31.     ${value}:接收输入参数的内容，如果传入类型是简单类型，${}中只能使用value -->  
32.     <select id="findUserByName" parameterType="java.lang.String" resultType="cn.itcast.mybatis.po.User">  
33.         SELECT * FROM USER WHERE username LIKE '%${value}%'  
34.     </select>   
35.       
36.     <!-- 添加用户  
37.     parameterType：指定输入参数类型是pojo（包括用户信息）  
38.     #{}中指定pojo的属性名，接收到pojo对象的属性值，mybatis通过OGNL获取对象的属性值 -->  
39.     <insert id="insertUser" parameterType="cn.itcast.mybatis.po.User">  
40.     <!-- 将插入数据的主键返回，返回到user对象中  
41.     SELECT LAST_INSERT_ID():得到刚刚insert进去记录的主键值，只适用于自增主键  
42.     keyProperty：将查询得到主键值设置到parameterType指定的对象的那个属性  
43.     order:SELECT LAST_INSERT_ID()执行顺序，相对于insert语句来说她的执行顺序  
44.     resultType：指定SELECT LAST_INSERT_ID()的结果类型  
45.      -->  
46.      <selectKey keyProperty="id" order="AFTER" resultType="java.lang.Integer">  
47.         SELECT LAST_INSER_ID()        
48.      </selectKey>  
49.         insert into user(username,birthday,sex,address) value(#{username},#{birthday},#{sex},#{address})  
50.         <!-- 使用mysql的uuid（）函数生成主键  
51.         执行过程，首先通过uuid得到主键，将主键设置到user对象的id属性中  
52.         其次，在insert执行的时候，从user对象中，取出id属性值 -->  
53.         <selectKey keyProperty="id" order="BEFORE" resultType="java.lang.String">  
54.             SELECT uuid()         
55.         </selectKey>  
56.         insert into user(username,birthday,sex,address) value(#{username},#{birthday},#{sex},#{address});  
57.     </insert>  
58.     <!-- 删除用户  
59.     根据id删除用户，需要输入id值 -->  
60.     <delete id="deleteUser" parameterType="java.lang.Integer">  
61.         delete from user where id=#{id}  
62.     </delete>  
63.       
64.     <!-- 根据id更新用户  
65.     分析：  
66.     需要传入用户的id  
67.     需要传入用户的更新信息  
68.     parameterType指定user对象，包括 id和更新信息，注意：id必须存在  
69.     #{id}：从输入 user对象中获取id属性值  
70.      -->  
71.     <update id="updateUser" parameterType="cn.itcast.mybatis.po.User">  
72.         update user set username=#{username},birthday=#{birthday},sex=#{sex},address=#{address}   
73.          where id=#{id}  
74.     </update>  
75.       
76.   
77. </mapper></span>  

第五步、编写具体的方法，如下所示：

[java]  view plain  copy

 print ?

1. <span style="font-family:Comic Sans MS;font-size:18px;">package cn.itcast.mybatis.first;  
2.   
3. import java.io.IOException;  
4. import java.io.InputStream;  
5. import java.util.Date;  
6. import java.util.List;  
7.   
8. import org.apache.ibatis.io.Resources;  
9. import org.apache.ibatis.session.SqlSession;  
10. import org.apache.ibatis.session.SqlSessionFactory;  
11. import org.apache.ibatis.session.SqlSessionFactoryBuilder;  
12. import org.junit.Test;  
13.   
14. import cn.itcast.mybatis.po.User;  
15.   
16. public class MybatisFirst {  
17.   
18.     // 根据id查询用户信息，得到一条记录结果  
19.     @Test  
20.     public void findUserByIdTest() throws IOException {  
21.   
22.         // mybatis配置文件  
23.         String resource = "SqlMapConfig.xml";  
24.         // 得到配置文件流  
25.         InputStream inputStream = Resources.getResourceAsStream(resource);  
26.   
27.         // 创建会话工厂，传入mybatis的配置文件信息  
28.         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder()  
29.                 .build(inputStream);  
30.   
31.         // 通过工厂得到SqlSession  
32.         SqlSession sqlSession = sqlSessionFactory.openSession();  
33.   
34.         // 通过SqlSession操作数据库  
35.         // 第一个参数：映射文件中statement的id，等于=namespace+"."+statement的id  
36.         // 第二个参数：指定和映射文件中所匹配的parameterType类型的参数  
37.         // sqlSession.selectOne结果 是与映射文件中所匹配的resultType类型的对象  
38.         // selectOne查询出一条记录  
39.         User user = sqlSession.selectOne("test.findUserById", 1);  
40.   
41.         System.out.println(user);  
42.   
43.         // 释放资源  
44.         sqlSession.close();  
45.           
46.           
47.     }  
48.       
49.       
50.     //根据用户名称模糊查询用户列表  
51.     @Test  
52.     public void findUserByNameTest() throws IOException{  
53.         //mybatis配置文件  
54.         String resource ="SqlMapConfig.xml";  
55.         //得到配置文件  
56.         InputStream inputStream = Resources.getResourceAsStream(resource);  
57.           
58.         //创建会话工厂，传入mybatis的配置文件信息  
59.         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);  
60.           
61.         //通过工厂得到SqlSession  
62.         SqlSession sqlSession = sqlSessionFactory.openSession();  
63.           
64.         //List中的user和映射文件中德resultType所指定的类型一致  
65.         List<User> list = sqlSession.selectList("test.findUserByName","小明");  
66.         System.out.println(list);  
67.         sqlSession.close();  
68.     }  
69.   
70.     public void insertUserTest() throws IOException{  
71.         //mybatis配置文件  
72.         String resource ="SqlMapConfig";  
73.         //得到配置文件流  
74.         InputStream inputStream = Resources.getResourceAsStream(resource);  
75.           
76.         //创建会话工厂，传入mybatis的配置文件信息  
77.         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);  
78.           
79.         //通过工厂得到sqlsession  
80.         SqlSession sqlSession = sqlSessionFactory.openSession();  
81.         //插入用户对象  
82.         User user = new User();  
83.         user.setUsername("丁国华");  
84.         user.setBirthday(new Date());  
85.         user.setSex("1");  
86.         user.setAddress("安徽合肥");  
87.           
88.         //list中的user和映射文件中的resultType所指定的类型一直  
89.         sqlSession.insert("test.insertUser",user);  
90.           
91.         //提交事物  
92.         sqlSession.commit();  
93.           
94.         //关闭会话  
95.         sqlSession.close();  
96.           
97.     }  
98.   
99.     //根据id删除用户信息  
100.     @Test  
101.     public void deleteUserTest() throws IOException{  
102.         //mybatis配置文件  
103.         String resource = "SqlMapConfig.xml";  
104.         //得到配置文件流  
105.         InputStream inputStream = Resources.getResourceAsStream(resource);  
106.         //创建工厂，传入mybatis的配置文件信息  
107.         SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);  
108.         //通过工厂得到SqlSession  
109.         SqlSession sqlSession = sqlSessionFactory.openSession();  
110.         //传入id删除用户  
111.         sqlSession.delete("test.deleteUser",39);  
112.           
113.         //提交事物  
114.         sqlSession.commit();  
115.         //关闭会话  
116.         sqlSession.close();  
117.           
118.     }  
119.       
120.     // 更新用户信息  
121.         @Test  
122.         public void updateUserTest() throws IOException {  
123.             // mybatis配置文件  
124.             String resource = "SqlMapConfig.xml";  
125.             // 得到配置文件流  
126.             InputStream inputStream = Resources.getResourceAsStream(resource);  
127.   
128.             // 创建会话工厂，传入mybatis的配置文件信息  
129.             SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder()  
130.                     .build(inputStream);  
131.   
132.             // 通过工厂得到SqlSession  
133.             SqlSession sqlSession = sqlSessionFactory.openSession();  
134.             // 更新用户信息  
135.               
136.             User user = new User();  
137.             //必须设置id  
138.             user.setId(41);  
139.             user.setUsername("丁国华");  
140.             user.setBirthday(new Date());  
141.             user.setSex("2");  
142.             user.setAddress("安徽合肥");  
143.   
144.             sqlSession.update("test.updateUser", user);  
145.               
146.             // 提交事务  
147.             sqlSession.commit();  
148.   
149.             // 关闭会话  
150.             sqlSession.close();  
151.   
152.         }  
153.   
154. }  
155. </span>  

mybatis的优缺点
优点：
a、易于上手和掌握。
b、sql写在xml里，便于统一管理和优化。
c、 解除sql与程序代码的耦合。
d、提供映射标签，支持对象与数据库的orm字段关系映射
e、提供对象关系映射标签，支持对象关系组建维护
f、提供xml标签，支持编写动态sql。
缺点：
a、 sql工作量很大，尤其是字段多、关联表多时，更是如此。
b、sql依赖于数据库，导致数据库移植性差。
c、 由于xml里标签id必须唯一，导致DAO中方法不支持方法重载。
d、DAO层过于简单，对象组装的工作量较大。
e、 缓存使用不当，容易产生脏数据。

mybatis和hibernate的对比
相同点：Hibernate和mybatis都可以是通过SessionFactoryBuilder由xml配置文件生成SessionFactory，然后由

SessionFactroy生成Session，最后由Session来开启执行事物和SQL语句，其中SessionFactoryBuider、

SessionFactory、Session的生命周期都是差不多的。

不同点：

mybatis：小巧、方便、高效、简单、直接、半自动；

hibernate：强大、方便、高效、复杂、绕弯子、全自动；

mybatis：

a、入门简单，即学即用，提供了数据库查询的自动对象绑定功能，而且延续了很多的SQL使用经验，对于没有

那么高的对象模型要求的项目来说，堪称perfect。

b、 可以进行更为细致的SQL优化，可以减少查询字段。

c、 缺点就是框架还是比较简陋，功能尚有缺失，虽然简化了数据绑定代码，但是整个底层数据库查询实际还是

要自己写的，工作量也比较大，而且不太容易适应快速数据库修改。
d、 二级缓存机制不佳。
       hibernate：
       a、功能强大，数据库无关性好，O/R映射能力强，如果你对Hibernate相当精通，而且对Hibernate进行了适当的

封装，那么你的项目整个持久层代码会相当简单，需要写的代码很少，开发速度很快，非常爽。
       b、有更好的二级缓存机制，可以使用第三方缓存。
       c、缺点就是学习门槛不低，要精通门槛更高，而且怎么设计O/R映射，在性能和对象模型之间如何权衡取得平衡

，以及怎样用好Hibernate方面需要你的经验和能力都很强才行。

       举个形象的比喻：
        mybatis：机械工具，使用方便，拿来就用，但工作还是要自己来作，不过工具是活的，怎么使由我决定。
        hibernate：智能机器人，但研发它（学习、熟练度）的成本很高，工作都可以摆脱他了，但仅限于它能做的事。

小编寄语：该博文，小编主要简单的介绍了mybatis的基本知识，包括一个简单的增删改查的demo，mybatis的

优缺点，以及hibernate和mybatis的对比，她们之间的相同点和不同点，mybatis简单来说，就是一个持久层的框架，

mybatis让程序将主要精力放在sql上，通过mybatis提供的映射方式，自由灵活生成满足需要的sql语句，mybatis可以

将向preparedStatement中的输入参数自动进行输入映射，将查询结果集灵活映射成java对象。