MyBatis入门demo

最近要学习使用MyBatis，参照网上的资料和官方的教程，根据自己的理解，记录一下。

MyBatisJar包下载地址：http://download.youkuaiyun.com/detail/jolingogo/5220163

官方教程：http://mybatis.github.com/mybatis-3/zh/index.htm

一.什么是MyBatis

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

     以前学习过Hibernate，在网上查了一下，说MyBatis是半自动化的，需要自己写SQL语句，这样就可以根据需要自己优化SQL了。

     Hibernate可以根据配置文件或者注解自动生成表，省去了自己写建表语句，在网上找了一下，MyBatis好像不可以。Google提供了generator，可以根据表结构生成实体类和映射文件，试了一下，还不错，以后会写一下。

二.配置文件

     这些框架什么的，基本上都需要配置文件。MyBatis的XML 配置文件包含对 MyBatis 系统的核心设置,包含获取数据库连接实例的数据源和 决定事务范围和控制的事务管理器。

mybatis-config.xml

[html]  view plain copy

1. <?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.     
6. <configuration>  
7.     <!-- 数据库相关属性文件，这里不写的话，也会自动加载 -->  
8.     <properties resource="config.properties"></properties>  
9.       
10.     <!-- 环境配置 -->  
11.     <environments default="development">  
12.         <environment id="development">  
13.             <transactionManager type="JDBC"/>  
14.             <!-- 数据库连接相关配置 ,这里动态获取config.properties文件中的内容-->  
15.             <dataSource type="POOLED">  
16.                 <property name="driver" value="${driver}"/>  
17.                 <property name="url" value="${url}"/>  
18.                 <property name="username" value="${username}"/>  
19.                 <property name="password" value="${password}"/>  
20.             </dataSource>  
21.         </environment>  
22.     </environments>  
23.     
24.     <!-- 映射文件 ,我们还没有，这里什么都不写-->  
25.     <mappers>  
26.     </mappers>  
27.     
28. </configuration>  

config.properties

三.从 XML 中构建 SqlSessionFactory

        每 一 个 MyBatis 的 应 用 程 序 都 以 一 个 SqlSessionFactory 对 象 的 实 例 为 核 心 。 SqlSessionFactory 对 象 的 实 例 可 以 通 过 SqlSessionFactoryBuilder 对 象 来 获 得 。 SqlSessionFactoryBuilder 对象可以从 XML 配置文件,或从 Configuration 类的习惯准备的实 例中构建 SqlSessionFactory 对象。 

      这里的SqlSessionFactory和Hibernate中的SessionFactory是一样的，我们可以通过factory,获取session。

[java]  view plain copy

1. package org.ygy.util;  
2.   
3. import java.io.IOException;  
4. import java.io.InputStream;  
5.   
6. import org.apache.ibatis.io.Resources;  
7. import org.apache.ibatis.session.SqlSession;  
8. import org.apache.ibatis.session.SqlSessionFactory;  
9. import org.apache.ibatis.session.SqlSessionFactoryBuilder;  
10.   
11. /** 
12.  * MyBatis的工具类 
13.  * @author yuguiyang 
14.  * 
15.  */  
16. public class MyBatisUtil {  
17.     private static SqlSessionFactory sqlSessionFactory = null;  
18.       
19.     /** 
20.      * 初始化Session工厂 
21.      * @throws IOException 
22.      */  
23.     private static void initialFactory() throws IOException {  
24.         String resource = "mybatis-config.xml";  
25.         InputStream inputStream = Resources.getResourceAsStream(resource);  
26.         sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);  
27.     }  
28.       
29.     /** 
30.      * 获取Session 
31.      * @return 
32.      */  
33.     public static SqlSession getSession() {  
34.         if(sqlSessionFactory == null) {  
35.             try {  
36.                 initialFactory();  
37.             } catch (IOException e) {  
38.                 e.printStackTrace();  
39.             }  
40.         }  
41.           
42.         return  sqlSessionFactory.openSession();  
43.     }  
44.       
45.       
46. }  

接下来，我们测试一下，看看配置是否正确：

[java]  view plain copy

1. package org.ygy.model;  
2.   
3. import static org.junit.Assert.*;  
4.   
5. import org.apache.ibatis.session.SqlSession;  
6. import org.junit.Test;  
7. import org.ygy.util.MyBatisUtil;  
8.   
9. public class ModelTest {  
10.       
11.     @Test  
12.     public void testGetSession() {  
13.         SqlSession session = MyBatisUtil.getSession();  
14.           
15.         assertNotNull(session);  
16.           
17.         if(session != null) {  
18.             session.close();  
19.             session = null;  
20.         }  
21.     }  
22. }  

貌似，想当然的悲剧了，这样测试好像不行，刚才忘记添加数据库驱动了，结果运行一样成功了，如果不执行SQL语句的话，MyBatis好像不会去连接数据库，测试还是等一下吧 。

既然这样的话，我们就先写一个映射文件。

首先，我们要建一张表，就来一个用户表吧（t_user）,我用的SqlServer，语句就省略了吧

然后，和表对应的实体类：

[java]  view plain copy

1. package org.ygy.model;  
2.   
3. /** 
4.  * 用户 
5.  * @author yuguiyang 
6.  * 
7.  */  
8. public class User {  
9.     private Integer id;//自动增长的ID  
10.     private String name;//用户名  
11.     private String password;//密码  
12.     private String email;//邮箱  
13.     private Integer age;//年龄  
14.     private Integer gender;//性别，0-男 ； 1-女  
15.   
16.     public Integer getId() {  
17.         return id;  
18.     }  
19.   
20.     public void setId(Integer id) {  
21.         this.id = id;  
22.     }  
23.   
24.     public String getName() {  
25.         return name;  
26.     }  
27.   
28.     public void setName(String name) {  
29.         this.name = name;  
30.     }  
31.   
32.     public String getPassword() {  
33.         return password;  
34.     }  
35.   
36.     public void setPassword(String password) {  
37.         this.password = password;  
38.     }  
39.   
40.     public String getEmail() {  
41.         return email;  
42.     }  
43.   
44.     public void setEmail(String email) {  
45.         this.email = email;  
46.     }  
47.   
48.     public Integer getAge() {  
49.         return age;  
50.     }  
51.   
52.     public void setAge(Integer age) {  
53.         this.age = age;  
54.     }  
55.   
56.     public Integer getGender() {  
57.         return gender;  
58.     }  
59.   
60.     public void setGender(Integer gender) {  
61.         this.gender = gender;  
62.     }  
63.   
64.     @Override  
65.     public String toString() {  
66.         return "User [id=" + id + ", name=" + name + ", password=" + password  
67.                 + ", email=" + email + ", age=" + age + ", gender=" + gender  
68.                 + "]";  
69.     }  
70.   
71. }  

接下来，是映射文件：UserMapper.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.     
6. <mapper namespace="org.ygy.mapper.UserMapper">  
7.   
8.     <insert id="insert" parameterType="org.ygy.model.User" useGeneratedKeys="true">  
9.         insert into t_user(name , password , email , gender , age)  
10.         values(#{name} , #{password} , #{email} , #{gender} , #{age})  
11.     </insert>  
12.       
13.     <select id="selectUser" resultType="org.ygy.model.User">  
14.         select * from t_user  
15.     </select>  
16.     
17. </mapper>  

最后，在mybatis-config.xml配置文件中添加映射文件：

[html]  view plain copy

1. <!-- 映射文件 -->  
2.     <mappers>  
3.         <mapper resource="org/ygy/mapper/UserMapper.xml"/>  
4.     </mappers>  

好了，这下，我们可以测试了：

[java]  view plain copy

1. package org.ygy.model;  
2.   
3. import static org.junit.Assert.assertEquals;  
4. import static org.junit.Assert.assertNotNull;  
5.   
6. import java.util.List;  
7.   
8. import org.apache.ibatis.session.SqlSession;  
9. import org.junit.After;  
10. import org.junit.Before;  
11. import org.junit.Test;  
12. import org.ygy.util.MyBatisUtil;  
13.   
14. public class ModelTest {  
15.     private SqlSession session = null;  
16.       
17.     @Before  
18.     public void before() {  
19.         session = MyBatisUtil.getSession();  
20.     }  
21.       
22.     @After  
23.     public void after() {  
24.         session.commit();  
25.         session.close();  
26.     }  
27.       
28.     @Test  
29.     public void testGetSession() {  
30.         assertNotNull(session);  
31.           
32.         if(session != null) {  
33.             session.close();  
34.             session = null;  
35.         }  
36.     }  
37.       
38.     @Test  
39.     public void testSelectUser() {  
40.         List<User> userList = session.selectList("org.ygy.mapper.UserMapper.selectUser");  
41.           
42.         for(User each : userList) {  
43.             System.out.println("each->" + each);  
44.         }  
45.           
46.     }  
47.       
48.     @Test  
49.     public void testInsert() {  
50.         User user = new User();  
51.         user.setName("路飞");  
52.         user.setPassword("lufei");  
53.         user.setEmail("lufei@op.com");  
54.         user.setAge(23);  
55.         user.setGender(0);  
56.           
57.         int result = session.insert("org.ygy.mapper.UserMapper.insert" , user);  
58.         assertEquals(1 , result);  
59.     }  
60. }  

，这样，一个入门的示例，就差不多了。

拓展：

1.别名

在mybatis-config.xml中可以配置别名 （typeAliases）

类型别名是为 Java 类型命名一个短的名字。它只和 XML 配置有关,只用来减少类完全限定名的多余部分。

看看上面UserMapper.xml中

只要在mybatis-config.xml中添加

[html]  view plain copy

1. <!-- 配置别名 -->  
2.     <typeAliases>  
3.         <typeAlias type="org.ygy.model.User" alias="User"/>  
4.     </typeAliases>  

就可以了。

-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

(2)

发现一个MyBatis博客，讲的挺好的：http://legend2011.blog.51cto.com/3018495/908956

官方教程：http://mybatis.github.com/mybatis-3/zh/sqlmap-xml.html

官方的教程是中文的，讲的很好，一定要看啊。

一.Mapper XML 文件

MyBatis 真正的力量是在映射语句中。这里是奇迹发生的地方。对于所有的力量,SQL映射的 XML 文件是相当的简单。当然如果你将它们和对等功能的 JDBC 代码来比较,你会发现映射文件节省了大约 95%的代码量。MyBatis 的构建就是聚焦于 SQL 的,使其远离于普通的方式。

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

• cache – 配置给定命名空间的缓存。
• cache-ref – 从其他命名空间引用缓存配置。
• resultMap – 最复杂,也是最有力量的元素,用来描述如何从数据库结果集中来加载你的对象。
• parameterMap – 已经被废弃了!老式风格的参数映射。内联参数是首选,这个元素可能在将来被移除。这里不会记录。
• sql – 可以重用的 SQL 块,也可以被其他语句引用。
• insert – 映射插入语句
• update – 映射更新语句
• delete – 映射删除语句
• select – 映射查询语句

二.示例

这里就简单的实现以下增删改查：

UserMapper.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.     
6. <mapper namespace="org.ygy.mapper.UserMapper">  
7.   
8.     <!-- 插入，参数是User对象，使用自动增长的ID -->  
9.     <insert id="insert" parameterType="User" useGeneratedKeys="true" keyProperty="id">  
10.         <!-- 就是普通的插入语句，这里使用#{xxx}的方式赋值，这里的xxx要和实体类中的属性对应 -->  
11.         insert into t_user(name , password , email , gender , age)  
12.         values(#{name} , #{password} , #{email} , #{gender} , #{age})  
13.     </insert>  
14.       
15.     <!-- 更新用户信息 -->  
16.     <update id="update" parameterType="User">  
17.         update t_user set  
18.         name=#{name},password=#{password},email=#{email},gender=#{gender},age=#{age}  
19.         where id=#{id}    
20.     </update>  
21.       
22.     <!-- 根据用户ID，删除一个用户 -->  
23.     <delete id="delete" parameterType="int">  
24.         delete from t_user where id=#{id}  
25.     </delete>  
26.       
27.     <!-- 查询所有用户 -->  
28.     <select id="selectUser" resultType="User">  
29.         select * from t_user  
30.     </select>  
31.       
32.     <!-- 根据用户ID，查询用户 -->  
33.     <select id="queryById" parameterType="int" resultType="User">  
34.         select * from t_user where id=#{id}  
35.     </select>  
36.       
37.     <!-- 根据用户名，查找用户 -->  
38.     <select id="queryByName" parameterType="String" resultType="User">  
39.         select *from t_user where name=#{name}  
40.     </select>  
41.     
42. </mapper>  

UserDao.java

[java]  view plain copy

1. package org.ygy.dao;  
2.   
3. import java.util.List;  
4.   
5. import org.ygy.model.User;  
6.   
7. /**  
8.  * User类Dao接口 
9.  * @author yuguiyang 
10.  * 
11.  */  
12. public interface UserDao {  
13.     /** 
14.      * 添加一个用户 
15.      * @param user 
16.      * @return 
17.      */  
18.     public int insert(User user);  
19.       
20.     /** 
21.      * 修改用户信息 
22.      * @param user 
23.      * @return 
24.      */  
25.     public int update(User user);  
26.       
27.     /** 
28.      * 修改用户 
29.      * @param id 
30.      * @return 
31.      */  
32.     public int delete(int id);  
33.       
34.     /** 
35.      * 获取所有用户 
36.      * @return 
37.      */  
38.     public List<User> selectUser();  
39.       
40.     /** 
41.      * 根据用户ID查找用户 
42.      * @param id 
43.      * @return 
44.      */  
45.     public User queryById(int id);  
46.       
47.     /** 
48.      * 根据用户名查找用户 
49.      * @param name 
50.      * @return 
51.      */  
52.     public User queryByName(String name);  
53. }  

UserDaoImpl.java

[java]  view plain copy

1. package org.ygy.dao.impl;  
2.   
3. import java.util.List;  
4.   
5. import org.apache.ibatis.session.SqlSession;  
6. import org.ygy.dao.UserDao;  
7. import org.ygy.model.User;  
8. import org.ygy.util.MyBatisUtil;  
9.   
10. /** 
11.  * User类Dao实现类 
12.  * @author yuguiyang 
13.  * 
14.  */  
15. public class UserDaoImpl implements UserDao {  
16.   
17.     @Override  
18.     public int insert(User user) {  
19.         //获取session  
20.         SqlSession session = MyBatisUtil.getSession();  
21.           
22.         //调用UserMapper.xml中的insert，并返回受影响的行数  
23.         int affectedRows = session.insert("org.ygy.mapper.UserMapper.insert" , user);  
24.           
25.         //提交事务,执行insert，update，delete时，一定要提交，不然数据库中不会修改  
26.         session.commit();  
27.         //关闭session  
28.         session.close();  
29.           
30.         return affectedRows;  
31.     }  
32.   
33.     @Override  
34.     public int update(User user) {  
35.         SqlSession session = MyBatisUtil.getSession();  
36.           
37.         int affectedRows = session.update("org.ygy.mapper.UserMapper.update" , user);  
38.           
39.         session.commit();  
40.         session.close();  
41.           
42.         return affectedRows;  
43.     }  
44.   
45.     @Override  
46.     public int delete(int id) {  
47.         SqlSession session = MyBatisUtil.getSession();  
48.           
49.         int affectedRows = session.delete("org.ygy.mapper.UserMapper.delete" , id);  
50.           
51.         session.commit();  
52.         session.close();  
53.           
54.         return affectedRows;  
55.     }  
56.   
57.     @Override  
58.     public List<User> selectUser() {  
59.         SqlSession session = MyBatisUtil.getSession();  
60.           
61.         List<User> userList = session.selectList("org.ygy.mapper.UserMapper.selectUser");  
62.           
63.         session.commit();  
64.         session.close();  
65.           
66.         return userList;  
67.     }  
68.   
69.     @Override  
70.     public User queryById(int id) {  
71.         SqlSession session = MyBatisUtil.getSession();  
72.           
73.         User user = session.selectOne("org.ygy.mapper.UserMapper.queryById" , id);  
74.           
75.         session.commit();  
76.         session.close();  
77.           
78.         return user;  
79.     }  
80.   
81.     @Override  
82.     public User queryByName(String name) {  
83.         SqlSession session = MyBatisUtil.getSession();  
84.           
85.         User user = session.selectOne("org.ygy.mapper.UserMapper.queryByName" , name);  
86.           
87.         session.commit();  
88.         session.close();  
89.           
90.         return user;  
91.     }  
92.   
93. }  

UserDaoTest.java

[java]  view plain copy

1. package org.ygy.dao;  
2.   
3. import static org.junit.Assert.assertEquals;  
4.   
5. import java.util.List;  
6.   
7. import org.junit.Before;  
8. import org.junit.Test;  
9. import org.ygy.dao.impl.UserDaoImpl;  
10. import org.ygy.model.User;  
11.   
12. public class UserDaoTest {  
13.     private UserDao userDao = null;  
14.       
15.     @Before  
16.     public void before() {  
17.         userDao = new UserDaoImpl();  
18.     }  
19.       
20.     @Test  
21.     public void testInsert() {  
22.         User user = new User();  
23.         user.setName("乔巴");  
24.         user.setPassword("qiaoba");  
25.         user.setAge(23);  
26.         user.setGender(0);  
27.         user.setEmail("qiaoba@op.com");  
28.           
29.         assertEquals(1 , userDao.insert(user));  
30.     }  
31.       
32.     @Test  
33.     public void testQueryByName() {  
34.         User user = userDao.queryByName("乔巴");  
35.           
36.         System.out.println("user->" + user);  
37.     }  
38.       
39.     @Test  
40.     public void testQueryById() {  
41.         User user = userDao.queryById(4);  
42.           
43.         System.out.println("user->" + user);  
44.     }  
45.       
46.     @Test  
47.     public void testUpdate() {  
48.         User user = userDao.queryByName("乔巴");  
49.         user.setName("七段变身-乔巴");  
50.           
51.         userDao.update(user);  
52.     }  
53.       
54.     @Test  
55.     public void testDelete() {  
56.         assertEquals(1 , userDao.delete(3));  
57.     }  
58.       
59.     @Test  
60.     public void testSelectUser() {  
61.         List<User> userList = userDao.selectUser();  
62.           
63.         for(User each : userList) {  
64.             System.out.println("each->" + each);  
65.         }  
66.     }  
67.   
68. }  

-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

（3）总结

这里整理一下，使用MyBatis时遇到的一些问题：

1.主键

官方讲解：

首先,如果你的数据库支持自动生成主键的字段(比如 MySQL 和 SQL Server),那么你可以设置 useGeneratedKeys=”true”,而且设置 keyProperty 到你已经做好的目标属性上。例如,如果上面的 Author 表已经对 id 使用了自动生成的列类型,那么语句可以修改为:

[html]  view plain copy

1. <insert id="insertAuthor" parameterType="domain.blog.Author" useGeneratedKeys="true"  
2.     keyProperty="id">  
3.   insert into Author (username,password,email,bio)  
4.   values (#{username},#{password},#{email},#{bio})  
5. </insert>  

MyBatis 有另外一种方法来处理数据库不支持自动生成类型,或者可能 JDBC 驱动不支持自动生成主键时的主键生成问题。

这里有一个简单(甚至很傻)的示例,它可以生成一个随机 ID(可能你不会这么做,但是这展示了 MyBatis 处理问题的灵活性,因为它并不真的关心 ID 的生成): 

[html]  view plain copy

1. <insert id="insertAuthor" parameterType="domain.blog.Author">  
2.   <selectKey keyProperty="id" resultType="int" order="BEFORE">  
3.     select CAST(RANDOM()*1000000 as INTEGER) a from SYSIBM.SYSDUMMY1  
4.   </selectKey>  
5.   insert into Author  
6.     (id, username, password, email,bio, favourite_section)  
7.   values  
8.     (#{id}, #{username}, #{password}, #{email}, #{bio}, #{favouriteSection,jdbcType=VARCHAR})  
9. </insert>  

个人理解：在mapper.xml中，使用insert时，MySql和SqlServer都有主键自动增长的设置，我们可以这样配置

[html]  view plain copy

1. <insert id="insert" parameterType="User" useGeneratedKeys="true" keyProperty="id">  
2.         <!-- 就是普通的插入语句，这里使用#{xxx}的方式赋值，这里的xxx要和实体类中的属性对应 -->  
3.         insert into t_user(name , password , email , gender , age)  
4.         values(#{name} , #{password} , #{email} , #{gender} , #{age})  
5.     </insert>  

在Oracle中，自动增长的话，需要使用序列

[html]  view plain copy

1. <insert id="insert" parameterType="User">  
2.         <!-- 这里查询序列 -->  
3.         <selectKey keyProperty="id" order="BEFORE" resultType="int">  
4.             select s_demo_userId.nextval from dual  
5.         </selectKey>  
6.         insert into t_user(id , name , password , email , gender , age)  
7.         values(#{id} , #{name} , #{password} , #{email} , #{gender} , #{age})  
8.     </insert>  

-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

(4)续

我们先来看一下，之前的UserMapper.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.     
6. <mapper namespace="org.ygy.mapper.UserMapper">  
7.   
8.     <!-- 插入，参数是User对象，使用自动增长的ID -->  
9.     <insert id="insert" parameterType="User" useGeneratedKeys="true" keyProperty="id">  
10.         <!-- 就是普通的插入语句，这里使用#{xxx}的方式赋值，这里的xxx要和实体类中的属性对应 -->  
11.         insert into t_user(name , password , email , gender , age)  
12.         values(#{name} , #{password} , #{email} , #{gender} , #{age})  
13.     </insert>  
14.       
15.     <!-- 更新用户信息 -->  
16.     <update id="update" parameterType="User">  
17.         update t_user set  
18.         name=#{name},password=#{password},email=#{email},gender=#{gender},age=#{age}  
19.         where id=#{id}    
20.     </update>  
21.       
22.     <!-- 根据用户ID，删除一个用户 -->  
23.     <delete id="delete" parameterType="int">  
24.         delete from t_user where id=#{id}  
25.     </delete>  
26.       
27.     <!-- 查询所有用户 -->  
28.     <select id="selectUser" resultType="User">  
29.         select * from t_user  
30.     </select>  
31.       
32.     <!-- 根据用户ID，查询用户 -->  
33.     <select id="queryById" parameterType="int" resultType="User">  
34.         select * from t_user where id=#{id}  
35.     </select>  
36.       
37.     <!-- 根据用户名，查找用户 -->  
38.     <select id="queryByName" parameterType="String" resultType="User">  
39.         select *from t_user where name=#{name}  
40.     </select>  
41.       
42. </mapper>  

主要看一下，插入，和更新，可能会发现一些问题，例如：在插入的时候用户信息可能并不全，在更新的时候，我们并不像更新所有的信息。

其实，如果用查询来说明的话，会更好理解。

那该怎么办呢？

MyBatis提供了很方便的做法：

        MyBatis 的一个强大的特性之一通常是它的动态 SQL 能力。如果你有使用 JDBC 或其他相似框架的经验,你就明白条件地串联 SQL 字符串在一起是多么的痛苦,确保不能忘了空格或在列表的最后省略逗号。动态 SQL 可以彻底处理这种痛苦。

        通常使用动态 SQL 不可能是独立的一部分,MyBatis 当然使用一种强大的动态 SQL 语言来改进这种情形,这种语言可以被用在任意映射的 SQL 语句中。

        动态 SQL 元素和使用 JSTL 或其他相似的基于 XML 的文本处理器相似。在 MyBatis 之前的版本中,有很多的元素需要来了解。MyBatis 3 大大提升了它们,现在用不到原先一半的元素就能工作了。MyBatis 采用功能强大的基于 OGNL 的表达式来消除其他元素。 

• if
• choose (when, otherwise)
• trim (where, set)
• foreach

我们来修改一下update：

[html]  view plain copy

1. <!-- 更新用户信息 -->  
2.     <update id="update" parameterType="User">  
3.         update t_user  
4.         <set>  
5.             <if test="name != null">name=#{name},</if>  
6.             <if test="password != null">password=#{password}</if>  
7.             <if test="email != null">email=#{email}</if>  
8.             <if test="age != null">age=#{age}</if>  
9.             <if test="gender != null">gender=#{gender}</if>   
10.         </set>  
11.         where id=#{id}  
12.     </update>