一.MyBatis介绍 

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

MyBatis是一个优秀的持久层框架，它对jdbc的操作数据库的过程进行封装，使开发者只需要关注 SQL 本身，而不需要花费精力去处理例如注册驱动、创建connection、创建statement、手动设置参数、结果集检索等jdbc繁杂的过程代码。

Mybatis通过xml或注解的方式将要执行的statement配置起来，并通过java对象和statement中的sql进行映射生成最终执行的sql语句，最后由mybatis框架执行sql并将结果映射成java对象并返回。

二.Mybatis的工作原理

1.使用连接池,datasource在驱动并连接的这个过程中优化并解耦JDBC第一步其实从效率角度来看是不合适的,因为无论什么数据库都不可能支撑随机和庞大的连接数,而且不可避免的存在链接浪费的情况,Mybatis就封装了这些优化的方法。

2.同意SQL存取到XML,如果代码写在java中，在团队合作中和可能出现两个交叉业务的代码使用类似的SQL语句,而开发人员的工作本身没有交集，那就代表SQL语句肯定是无法复用的，而且对SQL的修改，就代表对java文件的修改，需要重新编译和打包部署（比如常见的状态值更改，SQL修改随着业务变化必然存在修改）。

3.参数和结果集映SQL的方式需要传入参数，如果存在多条件“或类型”的查询（列表查询的查询条件允许空），那就代表你必须传参进行SQL拼接，就算使用xml的方式也不行。要么每个业务独立配置xml中的sql，要么还是写入java代码中，或者以工具的方式进行自动拼接。

Mybatis使用映射的方式，方便model管理参数，同时以解析器的方式将参数动态拼接到sql（sqlmaper里那些标签），由于是model映射，连查询结果都可以统一映射，方便取出和运算。而且mybatis对查询结果集进行了缓存处理，使得重复查询进一步进行了优化。

4.对多重复SQL进行复用封装比如模板方法，将常用sql模块化，直接调用。比如通用的save和getID之类的，只有表名和字段名有变化。

三.Mybatis架构

四.MyBatis的搭建

         1.mybatis配置SqlMapConfig.xml，此文件作为mybatis的全局配置文件，配置了mybatis的运行环境等信息。

        mapper.xml文件即sql映射文件，文件中配置了操作数据库的sql语句。此文件需要在SqlMapConfig.xml中加载。

      2.通过mybatis环境等配置信息构造SqlSessionFactory即会话工厂。

      3.由会话工厂创建sqlSession即会话，操作数据库需要通过sqlSession进行。

      4.mybatis底层自定义了Executor执行器接口操作数据库，Executor接口有两个实现，一个是基本执行器、一个是缓存执行器。

      5.Mapped Statement也是mybatis一个底层封装对象，它包装了mybatis配置信息及sql映射信息等。mapper.xml文件中一个sql对应一个MappedStatement对象，sql的id即是Mapped statement的id。

      6.Mapped Statement对sql执行输入参数进行定义，包括HashMap、基本类型、pojo，Executor通过Mapped Statement在执行sql前将输入的java对象映射至sql中，输入参数映射就是jdbc编程中对preparedStatement设置参数。

       7.Mapped Statement对sql执行输出结果进行定义，包括HashMap、基本类型、pojo，Executor通过Mapped Statement在执行sql后将输出结果映射至java对象中，输出结果映射过程相当于jdbc编程中对结果的解析处理过程。

五.实例

1.namespace的作用

 命名空间除了对sql进行隔离，mybatis中对命名空间有特殊的作用，用于定义mapper接口地址。

 问题:

 没有使用接口编程，java是面向接口编程语言，对数据库的操作应该定义一些操作接口，如：用户添加、用户删除、用户查询等，调用dao接口完成数据库操作。

上边代码，该调用selectOne、selectList，完全由人工判断不方便，selectList和selectOne方法参数是一个object类型，如果程序员在编码如果设置参数错误不会在编译阶段报错。
设想：
能否mybatis封装 方法实现体,
方法名：和mapper.xml中的statement的id保持一致。
方法输入参数类型：和mapper.xml中parameterType指定类型一致。
方法返回值：可以根据dao接口的 返回值的类型决定是调用selectOne还是selectList，类型和mapper.xml中的resulttype类型保持 一致
采用mybatis提供动态代理方式生成接口实现对象。
mapper.xml知道mapper.java,对应关系通过namespace进行配置。

改为mapper接口实现：

第一步：定义mapper.xml

Mapper.xml文件不变还用原来的。

第二步：定义mapper接口

//mapper接口类路径和mapper.xml中的namespace一致
public interface UserMapper {
    //根据mapper.xml中定义statement来方法
    //方法名：和mapper.xml中的statement的id一致
    //输入参数：和mapper.xml中的parametertype一致
    //输入结果：和mapper.xml中的resulttype一致
    public  User findUserById(int id)throws Exception;
    //自定义条件查询用户信息
    public List<User> findUserList(User user)throws Exception;
    //查询用户列表输出map
    public List<Map> findUserListReturnMap(User user)throws Exception;
    //查询用户列表使用resultmap
    public List<User> findUserListResultMap(User user)throws Exception;
    //插入用户
    public void insertUser(User user)throws Exception;
    //查询用户列表的总数
    public int findUserCount(User user)throws Exception;
    //查询用户传map
    public List<User>  findUserListByMap(Map map)throws Exception;
}

接口定义有如下特点：

1、 Mapper接口方法名和mapper.xml中定义的每个sql的id相同

2、 Mapper接口方法的输入参数类型和mapper.xml中定义的每个sql的parameterType的类型相同

3、 Mapper接口方法的输出参数类型和mapper.xml中定义的每个sql的resultType的类型相同

第三步：修改namespace

Mapper.xml映射文件中的namepace改为如下：

<mapper namespace="cn.itcast.mybatis.mapper.UserMapper">

修改后namespace即是mapper接口的地址。

第四步：通过mapper接口调用statement

public class UserMapperTest {
    SqlSessionFactory sqlSessionFactory;
    @Before
    public void setUp() throws Exception {
        // 创建会话工厂
        // 创建的会话工厂SqlsessionFactory
        String resource = "SqlMapConfig.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        // 创建的会话工厂SqlsessionFactory
        sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    }
    @Test
    public void testFindUserById() throws Exception {
            SqlSession sqlSession = sqlSessionFactory.openSession();
            //生成mapper接口的代理对象
            UserMapper userMapper =  sqlSession.getMapper(UserMapper.class);
            //调用 mapper接口的方法
            User user = userMapper.findUserById(1);
            System.out.println(user);
    }
    @Test
    public void testInsertUser() throws Exception {
            SqlSession sqlSession = sqlSessionFactory.openSession();
            //生成mapper接口的代理对象
            UserMapper userMapper =  sqlSession.getMapper(UserMapper.class);
            //构造查询条件
            User user_insert  = new User();
            user_insert.setUsername("张三四");
            user_insert.setSex("1");
            //调用 mapper接口的方法
            userMapper.insertUser(user_insert);
            //提交事务
            sqlSession.commit();
            sqlSession.close();
    }    
}    

 session.getMapper(UserMapper.class)生成一个代理对象作为UserMapper的接口实现对象。

总结：
mapper接口动态代理对象生成规则：
1、mapper接口类路径和mapper.xml中的namespace一致
2、方法名：和mapper.xml中的statement的id一致
3、输入参数：和mapper.xml中的parametertype一致
4、输入结果：和mapper.xml中的resulttype一致
两个文件：mapper.xml(mapper映射文件)和mapper.java（mapper接口文件）

2.SqlMapConfig.xml

配置内容

SqlMapConfig.xml中配置的内容和顺序如下：

properties（属性）

settings（全局配置参数）

typeAliases（类型别名）

typeHandlers（类型处理器）

objectFactory（对象工厂）

plugins（插件）

environments（环境集合属性对象）

environment（环境子属性对象）

transactionManager（事务管理）

dataSource（数据源）

mappers（映射器）

properties（属性）

SqlMapConfig.xml可以引用java属性文件中的配置信息如下：

在classpath下定义db.properties文件，

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis
jdbc.username=root
jdbc.password=mysql

 SqlMapConfig.xml引用如下：

<properties resource="db.properties" />
    <environments default="development">
        <environment id="development">
            <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配置的几种方法：
<mapper resource=" " />
使用相对于类路径的资源
如：<mapper resource="sqlmap/user.xml" />

<mapper url=" " />
使用完全限定路径
如：<mapper url="file:///D:\workspace_spingmvc\mybatis_01\config\sqlmap\user.xml" />

<mapper class=" " />
使用mapper接口类路径
如：<mapper class="cn.itcast.mybatis.mapper.UserMapper"/>

注意：此种方法要求mapper接口名称和mapper映射文件名称相同，且放在同一个目录中。

<package name=""/>
注册指定包下的所有mapper接口
如：<package name="cn.itcast.mybatis.mapper"/>
注意：此种方法要求mapper接口名称和mapper映射文件名称相同，且放在同一个目录中。

3. Mapper.xml

 Mapper.xml映射文件中定义了操作数据库的sql，每个sql是一个statement，映射文件是mybatis的核心。

 parameterType (输入类型)

#{}与${}

#{}实现的是向prepareStatement中的预处理语句中设置参数值，sql语句中#{}表示一个占位符即?。

<!-- 根据id查询用户信息 -->

<select id="selectUserById"  parameterType="int" resultType="user">

select * from user where id = #{id}

</select>

使用占位符#{}可以有效防止sql注入，在使用时不需要关心参数值的类型，mybatis会根据参数值的类型调用不同的statement设置参数值的方法。可以想象为：如果参数值是一个字符串则自动映射生成的sql中参数值两边自动有单引号，如果参数值是一个数字型则自动映射生成的sql中参数值两边没有单引号。

注意：当传递单个值时#{}中的参数名称通常和mapper接口的形参名称相同，也可以设置成任意值。

${}和#{}不同，${}是将参数值不加修饰的拼在sql中，相当中用jdbc的statement拼接sql，使用${}不能防止sql注入，但是有时用${}会非常方便，如下的例子：

<!-- 根据名称模糊查询用户信息 -->

<select id="selectUserByName" parameterType="string" resultType="user">

   select * from user where username like '%${value}%'

</select>

如果本例子使用#{}则传入的字符串中必须有%号，而%是人为拼接在参数中，显然有点麻烦，如果采用${}在sql中拼接为%的方式则在调用mapper接口传递参数就方便很多。

//如果使用占位符号则必须人为在传参数中加%

List<User> list = userMapper.selectUserByName("%管理员%");

//如果使用${}原始符号则不用人为在参数中加%

List<User> list = userMapper.selectUserByName("管理员");

再比如order by排序，如果将列名通过参数传入sql，根据传的列名进行排序，应该写为：

ORDER BY ${columnName} 

如果使用#{}将无法实现此功能。

注意：${}不能防止sql注入，对系统安全性有很大的影响，如果使用${}建议传入参数尽量不让用户自动填写，即使要用户填写也要对填写的数据进行校验，保证安全性。

另外，当传递单个值时${}中填写的参数名称经过测试填写value不错报。

传递pojo对象

Mybatis使用ognl表达式解析对象字段的值，如下例子：

<!—传递pojo对象综合查询用户信息 -->
    <select id="selectUserByUser" parameterType="user" resultType="user">
       select * from user where id=#{id} and username like '%${username}%'
    </select>

上边大括号标注的是user对象中的字段名称。

测试：

public void testselectUserByUser()throws Exception{
        //获取session
        SqlSession session = sqlSessionFactory.openSession();
        //获限mapper接口实例
        UserMapper userMapper = session.getMapper(UserMapper.class);
        //构造查询条件user对象
        User user = new User();
        user.setId(1);
        user.setUsername("管理员");
        //传递user对象查询用户列表
        List<User> list = userMapper.selectUserByUser(user);
        //关闭session
        session.close();
    }

 异常测试：

Sql中字段名输入错误后测试，username输入dusername测试结果报错：

org.apache.ibatis.exceptions.PersistenceException: 
### Error querying database.  Cause: org.apache.ibatis.reflection.ReflectionException: There is no getter for property named 'dusername' in 'class cn.itcast.mybatis.po.User'
### Cause: org.apache.ibatis.reflection.ReflectionException: There is no getter for property named 'dusername' in 'class cn.itcast.mybatis.po.User'

 传递hashmap

Sql映射文件定义如下：

<!-- 传递hashmap综合查询用户信息 -->

<select id="selectUserByHashmap" parameterType="hashmap" resultType="user">

   select * from user where id=#{id} and username like '%${username}%'

</select>

 上边红色标注的是hashmap的key。

 测试：

public void testselectUserByHashmap()throws Exception{
        //获取session
        SqlSession session = sqlSessionFactory.openSession();
        //获限mapper接口实例
        UserMapper userMapper = session.getMapper(UserMapper.class);
        //构造查询条件Hashmap对象
        HashMap<String, Object> map = new HashMap<String, Object>();
        map.put("id", 1);
        map.put("username", "管理员");
        
        //传递Hashmap对象查询用户列表
        List<User> list = userMapper.selectUserByHashmap(map);
        //关闭session
        session.close();
    }

异常测试：

传递的map中的key和sql中解析的key不一致。

测试结果没有报错，只是通过key获取值为空。

resultType(输出类型)

输出简单类型

参考getnow输出日期类型，看下边的例子输出整型：

 Mapper.xml文件

<!-- 获取用户列表总数 -->

<select id="selectUserCount" parameterType="user" resultType="int">

   select count(1) from user

</select>

Mapper接口

public int selectUserCount(User user) throws Exception;

调用：

public void testselectUserCount() throws Exception{
        //获取session
        SqlSession session = sqlSessionFactory.openSession();
        //获取mapper接口实例
        UserMapper userMapper = session.getMapper(UserMapper.class);
    
        User user = new User();
        user.setUsername("管理员");

        //传递Hashmap对象查询用户列表
        int count = userMapper.selectUserCount(user);
        
        //使用session实现
        //int count = session.selectOne("cn.itcast.mybatis.mapper.UserMapper.selectUserCount", user);
        //关闭session
        session.close();
    }

总结：

输出简单类型必须查询出来的结果集有一条记录，最终将第一个字段的值转换为输出类型。

使用session的selectOne可查询单条记录。

Sql片段

Sql中可将重复的sql提取出来，使用时用include引用即可，最终达到sql重用的目的，如下：

<!-- 传递pojo综合查询用户信息 -->
    <select id="selectUserByUser" parameterType="user" resultType="user">
        select * from user 
        <where> 
        <if test="id!=null and id!=''">
        and id=#{id}
        </if>
        <if test="username!=null and username!=''">
        and username like '%${username}%'
        </if>
        </where>
    </select>

把where条件抽取出来:

<sql id="query_user_where">
    <if test="id!=null and id!=''">
        and id=#{id}
    </if>
    <if test="username!=null and username!=''">
        and username like '%${username}%'
    </if>
    </sql>

使用include引用:

<select id="selectUserByUser" parameterType="user" resultType="user">
        select * from user 
        <where> 
        <include refid="query_user_where"/>
        </where>
    </select>

注意：如果引用其它mapper.xml的sql片段，则在引用时需要加上namespace，如下：

<include refid="namespace.sql片段”/>

resultMap

当输出pojo的字段和sql查询出来的字段名称不对应时而还想用这个pojo类作为输出类型这时就需要使用resultMap了。

另外，resultMap也解决了一对一关联查询、一对多关联查询等常见需求。

创建Person类:

public class Person {
    private int id;
    private String name;// 用户姓名，名称和User表的字段名称不一样
    private String sex;// 性别
    private Date birthday;// 出生日期
    private String addr;// 地址，名称和User表的字段名称不一样
    private String detail;// 详细信息
    private Float score;// 成绩
get/set。。。。

定义resultMap

在mapper.xml文件中定义resultMap：

<!-- resultMap定义 -->
    <resultMap type="cn.itcast.mybatis.po.Person" id="personmap">
       <id property="id" column="id"/>
       <result property="name" column="username" />
       <result property="addr" column="address" />
    </resultMap>

<id />：此属性表示查询结果集的唯一标识，非常重要。如果是多个字段为复合唯一约束则定义多个<id />。

Property：表示person类的属性。

Column：表示sql查询出来的字段名。

Column和property放在一块儿表示将sql查询出来的字段映射到指定的pojo类属性上。

<result />：普通结果，即pojo的属性。

这里只将sql查询出来的字段与pojo属性名不一致的进行了定义，通过后边的测试pojo属性名和sql字段相同的自动进行映射。

Mapper.xml定义

<!-- 获取用户列表返回resultMap -->
    <select id="selectUserListResultMap" resultMap="personmap">
        select * from user
    </select>

使用resultMap指定上边定义的personmap。

Mapper接口定义

public List<Person> selectUserListResultMap() throws Exception;

实际返回的类型是Person类型。

测试

public void testselectUserListResultMap() throws Exception{
        //获取session
        SqlSession session = sqlSessionFactory.openSession();
        //获限mapper接口实例
        UserMapper userMapper = session.getMapper(UserMapper.class);
    
        User user = new User();
        user.setUsername("管理员");

        //查询用户列表返回resultMap
        List<Person> list = userMapper.selectUserListResultMap();
        System.out.println(list);
        //关闭session
        session.close();
    }

六.Mybatis与Hibernate的比较

1.hibernate是全自动，而mybatis是半自动。

hibernate完全可以通过对象关系模型实现对数据库的操作，拥有完整的JavaBean对象与数据库的映射结构来自动生成sql。

而mybatis仅有基本的字段映射，对象数据以及对象实际关系仍然需要通过手写sql来实现和管理。

2. hibernate数据库移植性远大于mybatis。

hibernate通过它强大的映射结构和hql语言，大大降低了对象与数据库（Oracle、MySQL等）的耦合性，而mybatis由于需要手写sql，因此与数据库的耦合性直接取决于程序员写sql的方法，如果sql不具通用性而用了很多某数据库特性的sql语句的话，移植性也会随之降低很多，成本很高。

3. hibernate拥有完整的日志系统，mybatis则欠缺一些。

hibernate日志系统非常健全，涉及广泛，包括：sql记录、关系异常、优化警告、缓存提示、脏数据警告等；

而mybatis则除了基本记录功能外，功能薄弱很多。

4. mybatis相比hibernate需要关心很多细节

hibernate配置要比mybatis复杂的多，学习成本也比mybatis高。但也正因为mybatis使用简单，才导致它要比hibernate关心很多技术细节。

mybatis由于不用考虑很多细节，开发模式上与传统jdbc区别很小，因此很容易上手并开发项目，

但忽略细节会导致项目前期bug较多，因而开发出相对稳定的软件很慢，而开发出软件却很快。

hibernate则正好与之相反。但是如果使用hibernate很熟练的话，实际上开发效率丝毫不差于甚至超越mybatis。

5. sql直接优化上，mybatis要比hibernate方便很多

由于mybatis的sql都是写在xml里，因此优化sql比hibernate方便很多。

而hibernate的sql很多都是自动生成的，无法直接维护sql；

虽有hql，但功能还是不及sql强大，见到报表等变态需求时，hql也歇菜，也就是说hql是有局限的；

hibernate虽然也支持原生sql，但开发模式上却与orm不同，需要转换思维，因此使用上不是非常方便。

总之写sql的灵活度上hibernate不及mybatis。

总结：
mybatis：小巧、方便、高效、简单、直接、半自动
hibernate：强大、方便、高效、复杂、绕弯子、全自动

mybatis：
1. 入门简单，即学即用，提供了数据库查询的自动对象绑定功能，而且延续了很好的SQL使用经验，对于没有那么高的对象模型要求的项目来说，相当完美。
2. 可以进行更为细致的SQL优化，可以减少查询字段。
3. 缺点就是框架还是比较简陋，功能尚有缺失，虽然简化了数据绑定代码，但是整个底层数据库查询实际还是要自己写的，工作量也比较大，而且不太容易适应快速数据库修改。
4. 二级缓存机制不佳。

hibernate：
1. 功能强大，数据库无关性好，O/R映射能力强，如果你对Hibernate相当精通，而且对Hibernate进行了适当的封装，那么你的项目整个持久层代码会相当简单，需要写的代码很少，开发速度很快，非常爽。
2. 有更好的二级缓存机制，可以使用第三方缓存。
3. 缺点就是学习门槛不低，要精通门槛更高，而且怎么设计O/R映射，在性能和对象模型之间如何权衡取得平衡，以及怎样用好Hibernate方面需要你的经验和能力都很强才行。
举个形象的比喻：
mybatis：机械工具，使用方便，拿来就用，但工作还是要自己来作，不过工具是活的，怎么使由我决定。
hibernate：智能机器人，但研发它（学习、熟练度）的成本很高，工作都可以摆脱他了，但仅限于它能做的事。

七.相关知识

• 1）如何理解"全自动"和"半自动"的概念;
  hibernate完全可以通过对象关系模型实现对数据库的操作，拥有完整的JavaBean对象与数据库的映射结构来自动生成sql。
  而mybatis仅有基本的字段映射，对象数据以及对象实际关系仍然需要通过手写sql来实现和管理。

2）mybatis中的#和$的区别?

1. #将传入的数据都当成一个字符串，会对自动传入的数据加一个双引号。

如：order by #user_id#，如果传入的值是111,那么解析成sql时的值为order by "111",

如果传入的值是id，则解析成的sql为order by "id"

2. $将传入的数据直接显示生成在sql中。

如：order by $user_id$，如果传入的值是111,那么解析成sql时的值为order by user_id,

如果传入的值是id，则解析成的sql为order by id.

3. #方式能够很大程度防止sql注入　

　

4.$方式无法防止Sql注入。

5.$方式一般用于传入数据库对象，例如传入表名.

6.一般能用#的就别用$.

MyBatis排序时使用order by 动态参数时需要注意，用$而不是#

3）字符串替换

默认情况下，使用#{}格式的语法会导致MyBatis创建预处理语句属性并以它为背景设置安全的值（比如?）。

这样做很安全，很迅速也是首选做法，有时你只是想直接在SQL语句中插入一个不改变的字符串。

比如，像ORDER BY，你可以这样来使用：

ORDER BY ${columnName}

这里MyBatis不会修改或转义字符串。

重要：接受从用户输出的内容并提供给语句中不变的字符串，这样做是不安全的。

这会导致潜在的SQL注入攻击，因此你不应该允许用户输入这些字段，或者通常自行转义并检查。