mybatis总结 | 易学教程

1.mybatis的工作原理

1：使用连接池，datasource，在驱动并连接的这个过程中优化并解耦

JDBC第一步其实从效率角度来看是不合适的，因为无论什么数据库都不可能支撑随机和庞大的连接数，而且不可避免的存在连接浪费的情况，Mybatis就封装了这些优化的方法。

2：统一sql存取到XML

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

mybatis将sql统一存取到xml中，就算存在业务交叉，但因为统一配置的缘故，sql在xml中一目了然，两个跨team的程序员可以看到对方的sql，来判断自己是否需要重用。并且使用xml配置可以减少代码编译。

3：参数和结果集映射

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

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

4：对多重复sql进行复用封装

比如模板方法，将常用sql模块化，直接调用。比如通用的save和getID之类的，只有表名和字段名有变化。

2.mybatis跟hibante的比较, 优缺点.

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：智能机器人，但研发它（学习、熟练度）的成本很高，工作都可以摆脱他了，但仅限于它能做的事。??

3.mybatis跟jdbc的比较,优缺点;
1. DAO层代码可以通过现有插件直接生成，大大提高编码效率和准确性。
2. mybatis已有的连接池管理，缓存管理等所带来的代码性能优势和可靠性。
3. 一致的编码风格大大减少代码的沟通成本；
4. mybatis提供了一级和二级缓存（需要配置打开），强大的动态sql，自动化的session管理，都比手工维护来的方便和安全。
5. 不用重复写resultset到domain的转化了。
6. 相似的sql不需要重复写。

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

5.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 动态参数时需要注意，用$而不是#

字符串替换
默认情况下，使用#{}格式的语法会导致MyBatis创建预处理语句属性并以它为背景设置安全的值（比如?）。
这样做很安全，很迅速也是首选做法，有时你只是想直接在SQL语句中插入一个不改变的字符串。
比如，像ORDER BY，你可以这样来使用：
ORDER BY ${columnName}
这里MyBatis不会修改或转义字符串。
重要：接受从用户输出的内容并提供给语句中不变的字符串，这样做是不安全的。
这会导致潜在的SQL注入攻击，因此你不应该允许用户输入这些字段，或者通常自行转义并检查。

6.mybatis中如何使用动态sql
MyBatis的强大特性之一便是它的动态 SQL。如果你有使用 JDBC 或其他类似框架的经验，你就能体会到根据不同条件拼接 SQL 语句有多么痛苦。拼接的时候要确保不能忘了必要的空格，还要注意省掉列名列表最后的逗号。有些时候，SQL语句where条件中，需要一些安全判断，例如按某一条件查询时如果传入的参数是空，此时查询出的结果很可能是空的，也许我们需要参数为空时，是查出全部的信息。使用Oracle的序列、mySQL的函数生成Id。这时我们可以使用动态SQL。利用动态 SQL 这一特性可以彻底摆脱这种痛苦。通常使用动态 SQL 不可能是独立的一部分,MyBatis 当然使用一种强大的动态 SQL 语言来改进这种情形,这种语言可以被用在任意的 SQL 映射语句中。动态 SQL 元素和使用 JSTL 或其他类似基于 XML 的文本处理器相似。MyBatis 采用功能强大的基于 OGNL 的表达式来消除其他元素。
MyBatis中用于实现动态SQL的元素主要有：
1、if和where
2、choose（when，otherwise）
3、trim
4、set
5、foreach
下面将逐一进行介绍。

二、动态SQL的元素详解
首先来介绍一下SQL片段，它可以把动态SQL的判断部分独立处理，以便其他查询进行复用。
SQL片段定义方式：
[java] view plain copy print?

<sql id="query_user_where">

<if >

</if>
<foreach >

</foreach>



</sql>

引用SQL片段
[java] view plain copy print?
<where>

<include refid="query_user_where"></include>

</where>

1、if和where
if就是简单的条件判断，利用if语句我们可以实现某些简单的条件选择。动态 SQL 通常要做的事情是有条件地包含 where 子句的一部分。
使用示例：
查询语句块：
[java] view plain copy print?
<select id="findUserList" parameterType="com.kang.pojo.UserQueryVo"
resultType="com.kang.pojo.UserCustom">
SELECT * FROM USER

<where>
<include refid="query_user_where"></include>
</where>
</select>

where元素的作用是会在写入where元素的地方输出一个where，另外一个好处是你不需要考虑where元素里面的条件输出是什么样子的，MyBatis会智能的帮你处理。如果所有的条件都不满足那么MyBatis就会查出所有的记录；如果输出后是and这个单词开头的，MyBatis会把第一个单词and忽略，当然如果是or开头的，MyBatis也会把它忽略。此外，在where元素中你不需要考虑空格的问题，MyBatis会智能的帮你加上。
SQL片段：
[java] view plain copy print?
<sql id="query_user_where">
<if test="userCustom!=null">
<if test="userCustom.sex!=null and userCustom.sex!=''">
and user.sex = #{userCustom.sex}
</if>
<if test="userCustom.username!=null and userCustom.username!=''">
and user.username LIKE '%${userCustom.username}%'
</if>
</if>
</sql>
上述配置意思非常简单，如果你提供了sex参数，那么就要满足sex!=null和sex!=''两个条件，同样如果你提供了username参数的时候，也需要满足相应的条件，之后就是返回满足这些条件的所有user，这是非常有用的一个功能，以往我们使用其他类型框架或者直接使用JDBC的时候，如果我们要达到同样的选择效果的时候，我们就需要拼SQL语句，这是极其麻烦的，比起来，上述的动态SQL就要简单多了。
如果输入是sex=1和username=null,那么上述配置产生的SQL语句就是：
SELECT * FROM USER where user.sex = #{userCustom.sex}
而不是：
SELECT * FROM USER and user.sex = #{userCustom.sex}
因为where标签自动加入了"where"这个关键字，而且去掉了"and"这个单词，并在where的前后自动加入了空格，最终组合成相应的SQL语句。

2、choose
choose元素的作用就相当于JAVA中的switch语句，基本上跟JSTL中的choose的作用和用法是一样的，通常都是与when和otherwise搭配的。
使用示例：
[java] view plain copy print?
<select id="findUserList" parameterType="com.kang.pojo.UserQueryVo"
resultType="com.kang.pojo.UserCustom">
SELECT * FROM USER
<choose>
<when test="userCustom.sex!=null and userCustom.sex!=''">
and user.sex = #{userCustom.sex}
</when>
<when test="userCustom.username!=null and userCustom.username!=''">
and user.username LIKE '%${userCustom.username}%'
</when>
<otherwise>
and user.id = 1
</otherwise>
</choose>
</select>

上述配置中，when元素表示当when中的条件满足的时候就输出其中的内容，跟JAVA中的switch效果差不多的是按照条件的顺序，当when中有条件满足的时候，就会跳出choose，即所有的when和otherwise条件中，只有一个会输出，当所有的条件都不满足的时候就输出otherwise中的内容。

3、trim
trim元素的主要功能是可以在自己包含的内容前加上某些前缀，也可以在其后加上某些后缀，与之对应的属性是prefix和suffix；可以把包含内容的首部某些内容覆盖，即忽略，也可以把尾部的某些内容覆盖，对应的属性是prefixOverrides和suffixOverrides；正因为trim有这样的功能，所以我们也可以非常简单的利用trim来代替where元素的功能。
使用示例：
[java] view plain copy print?
<select id="findUserList" parameterType="com.kang.pojo.UserQueryVo"
resultType="com.kang.pojo.UserCustom">
SELECT * FROM USER
<trim prefix="where" prefixOverrides="and |or">
<if test="userCustom!=null">
<if test="userCustom.sex!=null and userCustom.sex!=''">
and user.sex = #{userCustom.sex}
</if>
<if test="userCustom.username!=null and userCustom.username!=''">
and user.username LIKE '%${userCustom.username}%'
</if>
</if>
</trim>
</select>

4、set
set元素主要是用在更新操作的时候，它的主要功能和where元素其实是差不多的，主要是在set标签包含的语句前输出一个set。如果包含的语句是以逗号结束的话将会把该逗号忽略。如果set包含的内容为空的话则会出错。有了set元素我们就可以动态的更新那些修改了的字段，而不用每次更新全部字段。
使用示例：
[java] view plain copy print?
<update id="updateUser" parameterType="com.kang.pojo.User">
update user
<set>
<if test="username != null">
username=#{username},
</if>
<if test="birthday != null">
birthday=#{birthday},
</if>
<if test="sex != null">
sex=#{sex},
</if>
<if test="address != null">
address=#{address}
</if>
</set>
where id = #{id}
</update>

5、foreach
foreach的主要用在构建in条件中，它可以在SQL语句中迭代一个集合。foreach元素的属性主要有item，index，collection，open，separator，close。
item表示集合中每一个元素进行迭代时的别名，index指定一个名字，用于表示在迭代过程中，每次迭代到的位置，open表示该语句以什么开始，separator表示在每次进行迭代之间以什么符号作为分隔符，close表示以什么结束。
collection属性用于指定传入参数的类型。该属性是必须指定的，在不同情况下，该属性的值是不一样的，主要有一下3种情况：
如果传入的是单参数且参数类型是一个List类型的时候，collection属性值为list。
如果传入的是单参数且参数类型是一个array数组的时候，collection的属性值为array。
如果传入的参数是多个的时候，我们就需要把它们封装成一个Map了，当然单参数也可以封装成map。实际上在传入参数的时候，MyBatis也是把它封装成一个Map的，List实例将会以“list”作为键，而数组实例将会以“array”作为键。这个时候collection属性值就是传入的List或array对象在封装自身的map里面中的对应key。
传入List的使用示例：
首先是查询接口：
public List<User> findUserList(List<Integer> ids);
对应xml文件中的配置：
[java] view plain copy print?
<select id="findUserList" resultType="com.kang.pojo.UserCustom">
SELECT * FROM USER WHERE id IN
<foreach collection="list" index="index" item="item" open="(" separator="," close=")">
#{ids}
</foreach>
</select>
可以看到，foreach标签描述中的参数和接口中的输入参数保持一致。
具体代码使用：
[java] view plain copy print?
//前述代码略
UserMapper userMapper = session.getMapper(UserMapper.class);
List<Integer> ids = new ArrayList<Integer>();
ids.add(1);
ids.add(3);
ids.add(6);
List<user> users = userMapper.findUserList(ids);
for (User user : users)
System.out.println(user);
session.close();

传入array数组的使用示例：
接口定义：
public List<User> findUserList(int[] ids);
对应xml文件中的配置：
[java] view plain copy print?
<select id="findUserList" resultType="com.kang.pojo.UserCustom">
SELECT * FROM USER WHERE id IN
<foreach collection="array" index="index" item="item" open="(" separator="," close=")">
#{ids}
</foreach>
</select>

具体代码使用：
//前述代码略
[java] view plain copy print?
UserMapper userMapper = session.getMapper(UserMapper.class);
int[] ids = {1,3,6,9};
List<user> users = userMapper.findUserList(ids);
for (User user : users)
System.out.println(user);
session.close();
传入array数组的使用示例：
接口定义：
public List<User> findUserList(Map<String, Object> params);
对应xml文件中的配置：
[java] view plain copy print?
<select id="findUserList" resultType="com.kang.pojo.UserCustom">
SELECT * FROM USER WHERE id IN
<foreach collection="ids" index="index" item="item" open="(" separator="," close=")">
#{params}
</foreach>
</select>

具体代码使用：
[java] view plain copy print?
//前述代码略
UserMapper userMapper = session.getMapper(UserMapper.class);
final List<Integer> ids = new ArrayList<Integer>();
ids.add(1);
ids.add(2);
ids.add(3);
ids.add(6);
ids.add(7);
ids.add(9);
Map<String, Object> params = new HashMap<String, Object>();
params.put("ids", ids);
List<user> users = userMapper.findUserList(ids);
for (User user : users)
System.out.println(user);
session.close();