MyBatis使用大全(3)------XML映射文件配置

MyBatis真正的强大，在于其映射语句的魔力。

SQL 映射文件有很少的几个顶级元素（按照它们应该被定义的顺序）：

（1）cache  给定命名空间的配置缓存。

（2）cache-ref  其他命名空间缓存配置的引用。

（3）resultMap  是最复杂也是最强大的元素，用来描述如何从数据库结果集中来加载对象

（4）sql 可被其他语句引用的可重用语句块。

（5）insert 映射插入语句

（6）update  映射更新语句

（7）delete   映射删除语句

（8）select   映射查询语句

在我们描述每个元素细节之前，我们先感受一些元素的使用实例，

以下实例分为UserMainMapper.XML配置的XML版本和Java注解版本，

也可以根据实际情况两种都用，但是同名方法只能用XML或java注解，

先不多少，看实例，这里将入门体验文章做简化，分析元素。

一，准备条件

--jar

mybatis-3.2.2.jar --mybatisjar

ojdbc6.jar --数据库驱动，这个地方用的是Oracle,而入门体验中用的是MySQL，所以驱动不一样

junit-4.4.jar --单元测试

--数据库表

[sql] view plain copy

1. --建表  
2. CREATE TABLE t_user_main(  
3.        f_id NUMBER(3) PRIMARY KEY,  
4.        f_username VARCHAR(4),  
5.        f_age NUMBER(3)  
6. );  
7. --设置主键自增长  
8. CREATE SEQUENCE user_sequence  
9. INCREMENT BY 1 -- 每次加几个  
10. START WITH 1 -- 从1开始计数  
11. NOMAXVALUE -- 不设置最大值  
12. NOCYCLE -- 一直累加，不循环  
13. --插入测试数据  
14. INSERT INTO t_user_main(f_id,f_username,f_age)VALUES(1,'one',25);  
15. INSERT INTO t_user_main(f_id,f_username,f_age)VALUES(2,'two',25);  
16. COMMIT;  
17. --查询  
18. SELECT * FROM t_user_main;  

二，项目结构

三，test-jdbc.properties和mybatis-config.xml配置

test-jdbc.properties：

[java] view plain copy

1. jdbc.driver=oracle.jdbc.driver.OracleDriver  
2. jdbc.url=jdbc:oracle:thin:@localhost:1521/XE  
3. jdbc.username=system  
4. jdbc.password=123456  

mybatis-config：

[html] view plain copy

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.     <!-- 属性（properties） -->  
5.     <properties resource="test-jdbc.properties"/>  
6.     <!-- 设置（settings） -->  
7.     <!-- <settings>  
8.       <setting name="cacheEnabled" value="true"/>  
9.       <setting name="lazyLoadingEnabled" value="true"/>  
10.       <setting name="multipleResultSetsEnabled" value="true"/>  
11.       <setting name="useColumnLabel" value="true"/>  
12.       <setting name="useGeneratedKeys" value="false"/>  
13.       <setting name="autoMappingBehavior" value="PARTIAL"/>  
14.       <setting name="autoMappingUnknownColumnBehavior" value="WARNING"/>  
15.       <setting name="defaultExecutorType" value="SIMPLE"/>  
16.       <setting name="defaultStatementTimeout" value="25"/>  
17.       <setting name="defaultFetchSize" value="100"/>  
18.       <setting name="safeRowBoundsEnabled" value="false"/>  
19.       <setting name="mapUnderscoreToCamelCase" value="false"/>  
20.       <setting name="localCacheScope" value="SESSION"/>  
21.       <setting name="jdbcTypeForNull" value="OTHER"/>  
22.       <setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode,toString"/>  
23.     </settings> -->  
24.     <!-- 别名（typeAliases） -->  
25.     <!-- <typeAliases>  
26.         <typeAlias alias="User" type="com.lanhuigu.mybatis.entity.User"/>  
27.     </typeAliases> -->  
28.     <!--   
29.         environments环境  
30.             *environment 环境变量   
31.                 *transactionManager 事务管理器  
32.                 *dataSource 数据源  
33.      -->  
34.      <environments default="development">  
35.         <environment id="development">  
36.             <transactionManager type="JDBC"/>  
37.             <dataSource type="POOLED">  
38.                 <property name="driver" value="${jdbc.driver}"/>  
39.                 <property name="url" value="${jdbc.url}"/>  
40.                 <property name="username" value="${jdbc.username}"/>  
41.                 <property name="password" value="${jdbc.password}"/>  
42.             </dataSource>  
43.         </environment>  
44.      </environments>  
45.     <!-- mappers映射器 -->  
46.     <mappers>  
47.         <!-- <mapper resource="com/lanhuigu/mybatis/map/UserMainMapper.xml"/> -->  
48.         <package name="com.lanhuigu.mybatis.map"/>  
49.     </mappers>  
50. </configuration>  

四，User.java,UserMainMapper.java接口和UserMainMapper.xml配置（Mapper）

User.java

[java] view plain copy

1. package com.lanhuigu.mybatis.entity;  
2.   
3. import java.io.Serializable;  
4.   
5. public class User implements Serializable{  
6.   
7.     private static final long serialVersionUID = -3412068097348759984L;  
8.       
9.     private Integer id;  
10.     private String username;  
11.     private Integer age;  
12.     public Integer getId() {  
13.         return id;  
14.     }  
15.     public void setId(Integer id) {  
16.         this.id = id;  
17.     }  
18.     public String getUsername() {  
19.         return username;  
20.     }  
21.     public void setUsername(String username) {  
22.         this.username = username;  
23.     }  
24.     public Integer getAge() {  
25.         return age;  
26.     }  
27.     public void setAge(Integer age) {  
28.         this.age = age;  
29.     }  
30.   
31. }  

UserMainMapper.java（接口）

[java] view plain copy

1. package com.lanhuigu.mybatis.map;  
2.   
3. import java.util.List;  
4. import java.util.Map;  
5.   
6. import org.apache.ibatis.annotations.Delete;  
7. import org.apache.ibatis.annotations.Insert;  
8. import org.apache.ibatis.annotations.Options;  
9. import org.apache.ibatis.annotations.Param;  
10. import org.apache.ibatis.annotations.Select;  
11. import org.apache.ibatis.annotations.Update;  
12.   
13. import com.lanhuigu.mybatis.entity.User;  
14.   
15. public interface UserMainMapper {  
16.     //=======================XML版=======================  
17.     /** 
18.      * 查询用户对象--返回User对象 
19.      */  
20.     public User queryUserMainById(int id);  
21.     /** 
22.      * 查询用户对象--返回多个--List<User> 
23.      */  
24.     public List<User> queryUserMainList();  
25.     /** 
26.      * 查询用户对象--返回map 
27.      */  
28.     public Map<String,Object> queryUserMainResultMap(int id);  
29.     /** 
30.      * 查询用户对象--返回多个--List<Map<String,Object>> 
31.      */  
32.     public List<Map<String,Object>> queryUserMainResultListMap();  
33.     /** 
34.      * 插入用户对象 
35.      */  
36.     public int insertUser(User user);  
37.     /** 
38.      * 更新用户对象 
39.      */  
40.     public int updateUser(User user);  
41.     /** 
42.      * 删除用户对象 
43.      */  
44.     public int deleteUser(int id);  
45.       
46.     //=======================注解版==========================  
47.     /** 
48.      * 查询用户对象--返回User对象 
49.      */  
50.     @Select(" select f_id id,f_username username,f_age age from t_user_main where f_id = #{id} ")  
51.     @Options(flushCache=true)  
52.     public User queryUserMainByIdNew(@Param("id") int id);  
53.     /** 
54.      * 查询用户对象--返回多个--List<User> 
55.      */  
56.     @Select("select f_id id,f_username username,f_age age from t_user_main ")  
57.     @Options(flushCache=true)  
58.     public List<User> queryUserMainListNew();  
59.     /** 
60.      * 查询用户对象--返回map 
61.      */  
62.     @Select("select f_id id,f_username username,f_age age from t_user_main where f_id = #{id}")  
63.     @Options(flushCache=true)  
64.     public Map<String,Object> queryUserMainResultMapNew(@Param("id") int id);  
65.     /** 
66.      * 查询用户对象--返回多个--List<Map<String,Object>> 
67.      */  
68.     @Select("select f_id id,f_username username,f_age age from t_user_main")  
69.     @Options(flushCache=true)  
70.     public List<Map<String,Object>> queryUserMainResultListMapNew();  
71.     /** 
72.      * 插入用户对象 
73.      */  
74.     @Insert("insert into t_user_main (f_id,f_username,f_age) "  
75.             + " values(#{id},#{username},#{age}) ")  
76.     @Options(useGeneratedKeys=false)  
77.     public int insertUserNew(User user);  
78.     /** 
79.      * 更新用户对象 
80.      */  
81.     @Update("update t_user_main set f_username=#{username},f_age=#{age} "  
82.             + " where f_id=#{id} ")  
83.     public int updateUserNew(User user);  
84.     /** 
85.      * 删除用户对象 
86.      */  
87.     @Delete("delete from t_user_main where f_id=#{id}")  
88.     @Options(flushCache=true)  
89.     public int deleteUserNew(@Param("id") int id);  
90. }  

UserMainMapper.xml

[html] view plain copy

1. <?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. <mapper namespace="com.lanhuigu.mybatis.map.UserMainMapper">  
6.   <!-- 查询用户对象,返回User对象 -->  
7.   <select id="queryUserMainById"   
8.     parameterType="int"   
9.     flushCache="true"   
10.     resultType="com.lanhuigu.mybatis.entity.User">  
11.     select   
12.         f_id id,  
13.         f_username username,  
14.         f_age age  
15.     from t_user_main   
16.     where f_id = #{id}  
17.   </select>  
18.   <!-- 查询用户对象,返回list<User> -->  
19.   <select id="queryUserMainList"   
20.     flushCache="true"   
21.     resultType="com.lanhuigu.mybatis.entity.User">  
22.     select   
23.         f_id id,  
24.         f_username username,  
25.         f_age age  
26.     from t_user_main   
27.   </select>  
28.   <!-- 查询用户对象,返回Map -->  
29.   <select id="queryUserMainResultMap"   
30.     parameterType="int"   
31.     flushCache="true"  
32.     resultType="java.util.HashMap">  
33.     select   
34.         f_id id,  
35.         f_username username,  
36.         f_age age  
37.     from t_user_main   
38.     where f_id = #{id}  
39.   </select>  
40.  <!--  查询用户对象,返回List<Map<String,Object>> -->  
41.   <select id="queryUserMainResultListMap"   
42.     flushCache="true"  
43.     resultType="java.util.HashMap">  
44.     select   
45.         f_id id,  
46.         f_username username,  
47.         f_age age  
48.     from t_user_main   
49.   </select>  
50.   <!-- 插入用户对象(insert) -->  
51.   <insert id="insertUser"   
52.     parameterType="com.lanhuigu.mybatis.entity.User"  
53.     useGeneratedKeys="false">  
54.     insert into t_user_main (f_id,f_username,f_age)   
55.     values(#{id},#{username},#{age})  
56.   </insert>  
57.     
58.   <!-- 更新用户对象(update) -->  
59.   <update id="updateUser"  
60.         parameterType="com.lanhuigu.mybatis.entity.User"  
61.        flushCache="true">  
62.     update t_user_main set f_username=#{username},f_age=#{age}  
63.     where f_id=#{id}  
64.   </update>  
65.     
66.  <!--  删除用户对象(delete) -->  
67.   <delete id="deleteUser"  
68.         parameterType="int"  
69.        flushCache="true">  
70.     delete from t_user_main where f_id=#{id}  
71.   </delete>  
72.     
73. </mapper>  

五，测试代码

[java] view plain copy

1. package com.lanhuigu.mybatis;  
2.   
3. import java.io.InputStream;  
4. import java.util.List;  
5. import java.util.Map;  
6.   
7. import org.apache.ibatis.io.Resources;  
8. import org.apache.ibatis.session.SqlSession;  
9. import org.apache.ibatis.session.SqlSessionFactory;  
10. import org.apache.ibatis.session.SqlSessionFactoryBuilder;  
11. import org.junit.Test;  
12.   
13. import com.lanhuigu.mybatis.entity.User;  
14. import com.lanhuigu.mybatis.map.UserMainMapper;  
15.   
16. public class MyBatisTest {  
17.     @Test  
18.     public void testMyBatis() {  
19.         String resource = "mybatis-config.xml";  
20.         SqlSessionFactory sqlSessionFactory = null;  
21.         SqlSession session = null;  
22.         try {  
23.             //读取资源文件  
24.             InputStream is = Resources.getResourceAsStream(resource);  
25.             sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);  
26.             session = sqlSessionFactory.openSession();  
27.             //mapper调用  
28.             UserMainMapper userMainMapper = session.getMapper(UserMainMapper.class);  
29.             //================XML测试=================  
30.             //查询--select--返回User对象  
31.             User user = userMainMapper.queryUserMainById(1);  
32.             System.out.println("user="+user);  
33.             System.out.println(user.getUsername());  
34.             //查询--select--返回多个User对象--List<User>  
35.             /*List<User> list = userMainMapper.queryUserMainList(); 
36.             for(int i=0;i<list.size();i++ ){ 
37.                 User user = list.get(i); 
38.                 System.out.println(user.getUsername()); 
39.             }*/  
40.             //查询--select--返回map  
41.             /*Map<String,Object> userMap = userMainMapper.queryUserMainResultMap(1); 
42.             System.out.println("userMap="+userMap); 
43.             System.out.println(userMap.get("USERNAME"));*/  
44.             //查询--select--返回List<Map<String,Object>>  
45.             /*List<Map<String,Object>> list = userMainMapper.queryUserMainResultListMap(); 
46.             System.out.println("ListMap="+list); 
47.             for (int i=0;i<list.size();i++) { 
48.                 Map<String,Object> userMap = list.get(i); 
49.                 System.out.println(userMap.get("USERNAME")); 
50.             }*/  
51.               
52.             //插入--insert  
53.             /*User user = new User(); 
54.             user.setId(3); 
55.             user.setUsername("three"); 
56.             user.setAge(25); 
57.              
58.             int result = userMainMapper.insertUser(user); 
59.             if (result > 0) { 
60.                 System.out.println("添加用户成功"); 
61.                 //事务提交 
62.                 session.commit(); 
63.             } else { 
64.                 System.out.println("添加用户失败"); 
65.                 //事务回滚 
66.                 session.rollback(); 
67.             }*/  
68.               
69.             //更新--update  
70.             /*User user = new User(); 
71.             user.setId(3); 
72.             user.setUsername("this three update"); 
73.             user.setAge(25); 
74.              
75.             int result = userMainMapper.updateUser(user); 
76.             if (result > 0) { 
77.                 System.out.println("更新成功"); 
78.                 //事务提交 
79.                 session.commit(); 
80.             } else { 
81.                 System.out.println("更新失败"); 
82.                 //事务回滚 
83.                 session.rollback(); 
84.             }*/  
85.               
86.             //删除--delete  
87.             /*int result = userMainMapper.deleteUser(3); 
88.             if (result > 0) { 
89.                 System.out.println("删除成功"); 
90.                 //事务提交 
91.                 session.commit(); 
92.             } else { 
93.                 System.out.println("删除失败"); 
94.                 //事务回滚 
95.                 session.rollback(); 
96.             }*/  
97.               
98.             //=================注解测试===================  
99.             /* 
100.              * 只需将xml测试代码copy一份，然后将方法名都加上一个New即可 
101.              * 在UserMainMapper.java映射器中原本可以将xml部分注释， 
102.              * 注解部分方法用同名，但是这样做我们就得将UserMainMapper.xml删掉， 
103.              * 或者改名，否则注解不能查询出数值，着跟命名空间和class,xml加载有关系. 
104.              * 总之class中和xml中不能出现注解和xml同时使用，对于单个方法，二者 
105.              * 只能存在其一，否则mybatis不知道你到底想干啥，只能什么都不做了 
106.              */  
107.             //eg.  
108.             /*User user = userMainMapper.queryUserMainByIdNew(1); 
109.             System.out.println("user="+user); 
110.             System.out.println(user.getUsername());*/  
111.         } catch (Exception e) {  
112.             if (session != null) {  
113.                 session.close();  
114.             }  
115.         }  
116.     }     
117. }  

有了上面的体验，我们在对每个元素等等进行分析，然后在参考实例，能体验更深。

结合上面的实例对元素进行分析和补充。

select元素

查询语句是MyBatis中最常用的元素，作为一个持久层框架，把数据放入数据库是一个方面，

把数据取一条或多条更是重中之重。简单查询语句：

[html] view plain copy

1. <select id="queryUserMainById"   
2.   parameterType="int"   
3.   flushCache="true"   
4.     resultType="com.lanhuigu.mybatis.entity.User">  
5.   select   
6.     f_id id,  
7.     f_username username,  
8.     f_age age  
9.   from t_user_main   
10.   where f_id = #{id}  
11. </select>  

这个语句称之为queryUserMainById,接受一个int或Integer的参数，

返回一个com.lanhuigu.mybatis.entity.User的对象，这个如果嫌写起来长，

可以在mybatis-config.xml中配置别名，这个地方直接用别名替代。

别名配置：

[html] view plain copy

1. <typeAliases>  
2.     <typeAlias alias="User" type="com.lanhuigu.mybatis.entity.User"/>  
3. </typeAliases>  

select语句中参数id符号：

#{id}获取传入的参数。

这样MyBatis处理时底层用JDBC生产预编译语句，JDBC底层MyBatis替我们做了，

这样我们只需关注MyBatis的应用，避免写大量的JDBC代码，提高工作效率，调用时直接执行。

select元素有很多属性可供选择，如下：

[html] view plain copy

1. <select  
2.   id="queryUserMainById"  
3.   parameterType="int"  
4.   parameterMap="deprecated"  
5.   resultType="hashmap"  
6.   resultMap="userMainResultMap"  
7.   flushCache="false"  
8.   useCache="true"  
9.   timeout="10000"  
10.   fetchSize="256"  
11.   statementType="PREPARED"  
12.   resultSetType="FORWARD_ONLY">  

select元素相关属性的描述，如下：

属性描述id在命名空间中唯一的标识符，可以被用来引用这条语句。parameterType将会传入这条语句的参数类的完全限定名或别名。这个属性是可选的，因为 MyBatis 可以通过 TypeHandler 推断出具体传入语句的参数，默认值为 unset。parameterMap这是引用外部 parameterMap 的已经被废弃的方法。使用内联参数映射和 parameterType 属性。 resultType从这条语句中返回的期望类型的类的完全限定名或别名。注意如果是集合情形，那应该是集合可以包含的类型，而不能是集合本身。使用 resultType 或 resultMap，但不能同时使用。resultMap外部 resultMap 的命名引用。结果集的映射是 MyBatis 最强大的特性，对其有一个很好的理解的话，许多复杂映射的情形都能迎刃而解。使用 resultMap 或 resultType，但不能同时使用。flushCache将其设置为 true，任何时候只要语句被调用，都会导致本地缓存和二级缓存都会被清空，默认值：false。useCache将其设置为 true，将会导致本条语句的结果被二级缓存，默认值：对 select 元素为 true。timeout这个设置是在抛出异常之前，驱动程序等待数据库返回请求结果的秒数。默认值为 unset（依赖驱动）。fetchSize这是尝试影响驱动程序每次批量返回的结果行数和这个设置值相等。默认值为 unset（依赖驱动）。statementTypeSTATEMENT，PREPARED 或 CALLABLE 的一个。这会让 MyBatis 分别使用 Statement，PreparedStatement 或 CallableStatement，默认值：PREPARED。resultSetTypeFORWARD_ONLY，SCROLL_SENSITIVE 或 SCROLL_INSENSITIVE 中的一个，默认值为 unset （依赖驱动）。databaseId如果配置了 databaseIdProvider，MyBatis 会加载所有的不带 databaseId 或匹配当前 databaseId 的语句；如果带或者不带的语句都有，则不带的会被忽略。resultOrdered这个设置仅针对嵌套结果 select 语句适用：如果为 true，就是假设包含了嵌套结果集或是分组了，这样的话当返回一个主结果行的时候，就不会发生有对前面结果集的引用的情况。这就使得在获取嵌套的结果集的时候不至于导致内存不够用。默认值：false。resultSets这个设置仅对多结果集的情况适用，它将列出语句执行后返回的结果集并每个结果集给一个名称，名称是逗号分隔的。

insert,update和delete元素

数据插入(insert),数据更新(update),数据删除(delete)实现大同小异。例如：

[html] view plain copy

1. <span style="color:#000000;"><!-- 插入用户对象(insert) -->  
2.   <insert id="insertUser"   
3.     parameterType="com.lanhuigu.mybatis.entity.User"  
4.     useGeneratedKeys="false">  
5.     insert into t_user_main (f_id,f_username,f_age)   
6.     values(#{id},#{username},#{age})  
7.   </insert>  
8.     
9.   <!-- 更新用户对象(update) -->  
10.   <update id="updateUser"  
11.     parameterType="com.lanhuigu.mybatis.entity.User"  
12.     flushCache="true">  
13.     update t_user_main set f_username=#{username},f_age=#{age}  
14.     where f_id=#{id}  
15.   </update>  
16.     
17.  <!--  删除用户对象(delete) -->  
18.   <delete id="deleteUser"  
19.     parameterType="int"  
20.     flushCache="true">  
21.     delete from t_user_main where f_id=#{id}  
22.   </delete></span>  

这三个元素的属性描述如下：

属性描述id命名空间中的唯一标识符，可被用来代表这条语句。parameterType将要传入语句的参数的完全限定类名或别名。这个属性是可选的，因为 MyBatis 可以通过 TypeHandler 推断出具体传入语句的参数，默认值为 unset。parameterMap这是引用外部 parameterMap 的已经被废弃的方法。使用内联参数映射和 parameterType 属性。 flushCache将其设置为 true，任何时候只要语句被调用，都会导致本地缓存和二级缓存都会被清空，默认值：true（对应插入、更新和删除语句）。timeout这个设置是在抛出异常之前，驱动程序等待数据库返回请求结果的秒数。默认值为 unset（依赖驱动）。statementTypeSTATEMENT，PREPARED 或 CALLABLE 的一个。这会让 MyBatis 分别使用 Statement，PreparedStatement 或 CallableStatement，默认值：PREPARED。useGeneratedKeys（仅对 insert 和 update 有用）这会令 MyBatis 使用 JDBC 的 getGeneratedKeys 方法来取出由数据库内部生成的主键（比如：像 MySQL 和 SQL Server 这样的关系数据库管理系统的自动递增字段），默认值：false。keyProperty（仅对 insert 和 update 有用）唯一标记一个属性，MyBatis 会通过 getGeneratedKeys 的返回值或者通过 insert 语句的 selectKey 子元素设置它的键值，默认：unset。如果希望得到多个生成的列，也可以是逗号分隔的属性名称列表。keyColumn（仅对 insert 和 update 有用）通过生成的键值设置表中的列名，这个设置仅在某些数据库（像 PostgreSQL）是必须的，当主键列不是表中的第一列的时候需要设置。如果希望得到多个生成的列，也可以是逗号分隔的属性名称列表。databaseId如果配置了 databaseIdProvider，MyBatis 会加载所有的不带 databaseId 或匹配当前 databaseId 的语句；如果带或者不带的语句都有，则不带的会被忽略。

sql元素

发

这个元素可以被用来定义可重用的 SQL 代码段，可以包含在其他语句中。

它可以被静态地(在加载参数) 参数化. 不同的属性值通过包含的实例变化。

把上面的实例中UserMainMapper.xml修改，来个简单实例：

[html] view plain copy

1. <!-- sql语句块 -->  
2. <sql id="queryConditionSql">  
3.     f_id = #{id}  
4. </sql>      
5. <!-- 查询用户对象,返回User对象 -->  
6. <select id="queryUserMainById"   
7.   parameterType="int"   
8.   flushCache="true"   
9.     resultType="com.lanhuigu.mybatis.entity.User">  
10.   select   
11.     f_id id,  
12.     f_username username,  
13.     f_age age  
14.   from t_user_main   
15.   <where>  
16.     <include refid="queryConditionSql"/>  
17.   </where>  
18. </select>  

将查询语句的条件由where f_id=#{id}修改成sql语句块替代。

这样整个xml中条件部分共同的地方都提出来，避免重复啰嗦。

当然，sql语句块除了可以用于条件部分，还可以用于其它任地方，

比如：

[html] view plain copy

1. <!-- sql语句块 -->  
2. <sql id="queryConditionSql">  
3.     f_id = #{id}  
4. </sql>      
5. <sql id="att">  
6.     f_username username,  
7.     f_age age  
8. </sql>  
9. <!-- 查询用户对象,返回User对象 -->  
10. <select id="queryUserMainById"   
11.   parameterType="int"   
12.   flushCache="true"   
13.     resultType="com.lanhuigu.mybatis.entity.User">  
14.   select   
15.     f_id id,  
16.     <include refid="att"/>  
17.   from t_user_main   
18.   <where>  
19.     <include refid="queryConditionSql"/>  
20.   </where>  
21. </select>  

查询时，效果一样。

总结：

（1）sql语句块用于提出xml共同sql

（2）sql语句块可以置于xml文件中查询语句前后，位置无关系，都能调用。

参数（parameters）

但是

MyBatis的参数功能是非常强大的，前面用到的sql中，如果parameterType="int"
只是进行一个简单的整数传入，但是，在插入语句中，我们传入的是类型User对象：

[html] view plain copy

1. <insert id="insertUser"   
2.     parameterType="com.lanhuigu.mybatis.entity.User"  
3.     useGeneratedKeys="false">  
4.     insert into t_user_main (f_id,f_username,f_age)   
5.     values(#{id},#{username},#{age})  
6.   </insert>  

如果 User 类型的参数对象传递到了语句中，id、username 和 password 属性将会被查找，然后将它们的值传入预处理语句的参数中。

这点对于向语句中传参是比较好的而且又简单，不过参数映射的功能远不止于此。

首先，像 MyBatis 的其他部分一样，参数也可以指定一个特殊的数据类型。

#{property,javaType=int,jdbcType=NUMERIC}

像 MyBatis 的剩余部分一样，javaType 通常可以从参数对象中来去确定，前提是只要对象不是一个 HashMap。那么 javaType 应该被确定来保证使用正确类型处理器。

NOTE 如果 null 被当作值来传递，对于所有可能为空的列，JDBC Type 是需要的。你可以自己通过阅读预处理语句的 setNull() 方法的 JavaDocs 文档来研究这种情况。

为了以后定制类型处理方式，你也可以指定一个特殊的类型处理器类（或别名），比如：

#{age,javaType=int,jdbcType=NUMERIC,typeHandler=MyTypeHandler}

尽管看起来配置变得越来越繁琐，但实际上是很少去设置它们。

对于数值类型，还有一个小数保留位数的设置，来确定小数点后保留的位数。

#{height,javaType=double,jdbcType=NUMERIC,numericScale=2}

最后，mode 属性允许你指定 IN，OUT 或 INOUT 参数。如果参数为 OUT 或 INOUT，参数对象属性的真实值将会被改变，就像你在获取输出参数时所期望的那样。如果 mode 为 OUT（或 INOUT），而且 jdbcType 为 CURSOR(也就是 Oracle 的 REFCURSOR)，你必须指定一个 resultMap 来映射结果集到参数类型。要注意这里的 javaType 属性是可选的，如果左边的空白是 jdbcType 的 CURSOR 类型，它会自动地被设置为结果集。

#{department, mode=OUT, jdbcType=CURSOR, javaType=ResultSet, resultMap=departmentResultMap}

MyBatis 也支持很多高级的数据类型，比如结构体，但是当注册 out 参数时你必须告诉它语句类型名称。比如（再次提示，在实际中要像这样不能换行）：

#{middleInitial, mode=OUT, jdbcType=STRUCT, jdbcTypeName=MY_TYPE, resultMap=departmentResultMap}

尽管所有这些强大的选项很多时候你只简单指定属性名，其他的事情 MyBatis 会自己去推断，最多你需要为可能为空的列名指定 jdbcType。

#{firstName}#{middleInitial,jdbcType=VARCHAR}#{lastName}

一个完整的配置,这个直接考用工作的xml：

[html] view plain copy

1. <insert id="addUser" parameterType="com.lanhuigu.core.dao.model.user.User"   
2.         useGeneratedKeys="true" keyColumn="f_userId" flushCache="true">  
3.         insert into t_user_main (  
4.         f_userId ,     
5.             f_userName ,      
6.             f_email ,     
7.             f_password ,     
8.             f_isPayPassword ,     
9.             f_mobile ,     
10.             f_registerTime ,     
11.             f_role ,     
12.             f_status ,     
13.             f_realAuth ,     
14.             f_redInviteCode,  
15.             f_redBeInviteCode,  
16.             f_version  )  
17.         values(  
18.             #{userId,jdbcType=VARCHAR},  
19.             #{userName,jdbcType=VARCHAR},  
20.             #{email,jdbcType=VARCHAR},  
21.             #{password,jdbcType=VARCHAR}        ,   
22.             #{isPayPassword,jdbcType=VARCHAR},  
23.             #{mobile,jdbcType=VARCHAR},  
24.             #{registerTime,jdbcType=VARCHAR},  
25.             #{roles,jdbcType=VARCHAR},  
26.             #{status,jdbcType=VARCHAR},  
27.             #{realAuth,jdbcType=VARCHAR},  
28.             #{redInviteCode,jdbcType=VARCHAR},  
29.             #{redBeInviteCode,jdbcType=VARCHAR},  
30.             #{version,jdbcType=VARCHAR}  
31.         )  
32. </insert>  

字符串替换

在上面中，很多地方用到#{},默认情况下,使用#{}格式的语法会导致 MyBatis 创建预处理语句属性并安全地设置值（比如?）。

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

或者在条件放一个字符串。比如：

f_id = ${id}

以这种方式接受从用户输出的内容并提供给语句中不变的字符串是不安全的，

会导致潜在的 SQL 注入攻击，因此要么不允许用户输入这些字段，要么自行转义并检验。