关闭

Mybatis动态SQL

313人阅读 评论(0) 收藏 举报
分类:

  1. MyBatis的动态SQL是基于OGNL表达式的,它可以帮助我们方便的在SQL语句中实现某些逻辑。  
  2.   
  3. MyBatis中用于实现动态SQL的元素主要有:  
  4.   
  5.     if  
  6.     choose(when,otherwise)  
  7.     trim  
  8.     where  
  9.     set  
  10.     foreach  
  11.   
  12. if就是简单的条件判断,利用if语句我们可以实现某些简单的条件选择。先来看如下一个例子:  
  13. 01  <select id="dynamicIfTest" parameterType="Blog" resultType="Blog">  
  14. 02      select * from t_blog where 1 = 1  
  15. 03      <if test="title != null">  
  16. 04     
  17. 05          and title = #{title}  
  18. 06      </if>  
  19. 07      <if test="content != null">  
  20. 08          and content = #{content}  
  21. 09      </if>  
  22. 10      <if test="owner != null">  
  23. 11          and owner = #{owner}  
  24. 12      </if>  
  25. 13     
  26. 14  </select>  
  27. 这条语句的意思非常简单,如果你提供了title参数,那么就要满足title=#{title},同样如果你提供了Content和Owner的时候,它们也需要满足相应的条件,之后就是返回满足这些条件的所有Blog,这是非常有用的一个功能,以往我们使用其他类型框架或者直接使用JDBC的时候, 如果我们要达到同样的选择效果的时候,我们就需要拼SQL语句,这是极其麻烦的,比起来,上述的动态SQL就要简单多了。  
  28.   
  29. choose元素的作用就相当于JAVA中的switch语句,基本上跟JSTL中的choose的作用和用法是一样的,通常都是与when和otherwise搭配的。看如下一个例子:  
  30. 01  <select id="dynamicChooseTest" parameterType="Blog" resultType="Blog">  
  31. 02      select * from t_blog where 1 = 1  
  32. 03      <choose>  
  33. 04     
  34. 05          <when test="title != null">  
  35. 06              and title = #{title}  
  36. 07          </when>  
  37. 08          <when test="content != null">  
  38. 09              and content = #{content}  
  39. 10          </when>  
  40. 11          <otherwise>  
  41. 12     
  42. 13              and owner = "owner1"  
  43. 14          </otherwise>  
  44. 15      </choose>  
  45. 16  </select>  
  46. when元素表示当when中的条件满足的时候就输出其中的内容,跟JAVA中的switch效果差不多的是按照条件的顺序,当when中有条件满足的时候,就会跳出choose,即所有的when和otherwise条件中,只有一个会输出,当所有的我很条件都不满足的时候就输出otherwise中的内容。所以上述语句的意思非常简单, 当title!=null的时候就输出and titlte = #{title},不再往下判断条件,当title为空且content!=null的时候就输出and content = #{content},当所有条件都不满足的时候就输出otherwise中的内容。  
  47.   
  48. where语句的作用主要是简化SQL语句中where中的条件判断的,先看一个例子,再解释一下where的好处。  
  49. 01  <select id="dynamicWhereTest" parameterType="Blog" resultType="Blog">  
  50. 02      select * from t_blog  
  51. 03      <where>  
  52. 04          <if test="title != null">  
  53. 05              title = #{title}  
  54. 06          </if>  
  55. 07          <if test="content != null">  
  56. 08     
  57. 09              and content = #{content}  
  58. 10          </if>  
  59. 11          <if test="owner != null">  
  60. 12              and owner = #{owner}  
  61. 13          </if>  
  62. 14      </where>  
  63. 15  </select>  
  64. where元素的作用是会在写入where元素的地方输出一个where,另外一个好处是你不需要考虑where元素里面的条件输出是什么样子的,MyBatis会智能的帮你处理,如果所有的条件都不满足那么MyBatis就会查出所有的记录,如果输出后是and 开头的,MyBatis会把第一个and忽略,当然如果是or开头的,MyBatis也会把它忽略;此外,在where元素中你不需要考虑空格的问题,MyBatis会智能的帮你加上。像上述例子中,如果title=null, 而content != null,那么输出的整个语句会是select * from t_blog where content = #{content},而不是select * from t_blog where and content = #{content},因为MyBatis会智能的把首个and 或 or 给忽略。  
  65.   
  66. trim元素的主要功能是可以在自己包含的内容前加上某些前缀,也可以在其后加上某些后缀,与之对应的属性是prefix和suffix;可以把包含内容的首部某些内容覆盖,即忽略,也可以把尾部的某些内容覆盖,对应的属性是prefixOverrides和suffixOverrides;正因为trim有这样的功能,所以我们也可以非常简单的利用trim来代替where元素的功能,示例代码如下:  
  67. 01  <select id="dynamicTrimTest" parameterType="Blog" resultType="Blog">  
  68. 02      select * from t_blog  
  69. 03      <trim prefix="where" prefixOverrides="and |or">  
  70. 04     
  71. 05          <if test="title != null">  
  72. 06              title = #{title}  
  73. 07          </if>  
  74. 08          <if test="content != null">  
  75. 09              and content = #{content}  
  76. 10          </if>  
  77. 11          <if test="owner != null">  
  78. 12     
  79. 13              or owner = #{owner}  
  80. 14          </if>  
  81. 15      </trim>  
  82. 16  </select>  
  83. set元素主要是用在更新操作的时候,它的主要功能和where元素其实是差不多的,主要是在包含的语句前输出一个set,然后如果包含的语句是以逗号结束的话将会把该逗号忽略,如果set包含的内容为空的话则会出错。有了set元素我们就可以动态的更新那些修改了的字段。下面是一段示例代码:  
  84. 01  <update id="dynamicSetTest" parameterType="Blog">  
  85. 02      update t_blog  
  86. 03      <set>  
  87. 04          <if test="title != null">  
  88. 05              title = #{title},  
  89. 06          </if>  
  90. 07          <if test="content != null">  
  91. 08     
  92. 09              content = #{content},  
  93. 10          </if>  
  94. 11          <if test="owner != null">  
  95. 12              owner = #{owner}  
  96. 13          </if>  
  97. 14      </set>  
  98. 15      where id = #{id}  
  99. 16  </update>  
  100. 上述示例代码中,如果set中一个条件都不满足,即set中包含的内容为空的时候就会报错。  
  101.   
  102. foreach的主要用在构建in条件中,它可以在SQL语句中进行迭代一个集合。foreach元素的属性主要有item,index,collection,open,separator,close。item表示集合中每一个元素进行迭代时的别名,index指定一个名字,用于表示在迭代过程中,每次迭代到的位置,open表示该语句以什么开始,separator表示在每次进行迭代之间以什么符号作为分隔符,close表示以什么结束,在使用foreach的时候最关键的也是最容易出错的就是collection属性,该属性是必须指定的,但是在不同情况下,该属性的值是不一样的,主要有一下3种情况:  
  103.   
  104.     如果传入的是单参数且参数类型是一个List的时候,collection属性值为list  
  105.     如果传入的是单参数且参数类型是一个array数组的时候,collection的属性值为array  
  106.     如果传入的参数是多个的时候,我们就需要把它们封装成一个Map了,当然单参数也可以封装成map,实际上如果你在传入参数的时候,在MyBatis里面也是会把它封装成一个Map的,map的key就是参数名,所以这个时候collection属性值就是传入的List或array对象在自己封装的map里面的key  
  107.     
  108. 下面分别来看看上述三种情况的示例代码:  
  109. 1.单参数List的类型:  
  110. 1   <select id="dynamicForeachTest" resultType="Blog">  
  111. 2       select * from t_blog where id in  
  112. 3       <foreach collection="list" index="index" item="item" open="(" separator="," close=")">  
  113. 4           #{item}  
  114. 5       </foreach>  
  115. 6      
  116. 7   </select>  
  117. 上述collection的值为list,对应的Mapper是这样的  
  118. 1   public List<Blog> dynamicForeachTest(List<Integer> ids);  
  119. 测试代码:  
  120. 01  @Test  
  121. 02  public void dynamicForeachTest() {  
  122. 03      SqlSession session = Util.getSqlSessionFactory().openSession();  
  123. 04      BlogMapper blogMapper = session.getMapper(BlogMapper.class);  
  124. 05      List<Integer> ids = new ArrayList<Integer>();  
  125. 06      ids.add(1);  
  126. 07      ids.add(3);  
  127. 08      ids.add(6);  
  128. 09      List<Blog> blogs = blogMapper.dynamicForeachTest(ids);  
  129. 10      for (Blog blog : blogs)  
  130. 11          System.out.println(blog);  
  131. 12      session.close();  
  132. 13  }  
  133. 2.单参数array数组的类型:  
  134. 1   <select id="dynamicForeach2Test" resultType="Blog">  
  135. 2       select * from t_blog where id in  
  136. 3       <foreach collection="array" index="index" item="item" open="(" separator="," close=")">  
  137. 4           #{item}  
  138. 5       </foreach>  
  139. 6   </select>  
  140. 上述collection为array,对应的Mapper代码:  
  141. 1   public List<Blog> dynamicForeach2Test(int[] ids);  
  142. 对应的测试代码:  
  143. 01  @Test  
  144. 02  public void dynamicForeach2Test() {  
  145. 03      SqlSession session = Util.getSqlSessionFactory().openSession();  
  146. 04      BlogMapper blogMapper = session.getMapper(BlogMapper.class);  
  147. 05      int[] ids = new int[] {1,3,6,9};  
  148. 06      List<Blog> blogs = blogMapper.dynamicForeach2Test(ids);  
  149. 07      for (Blog blog : blogs)  
  150. 08          System.out.println(blog);  
  151. 09      session.close();  
  152. 10  }  
  153. 3.自己把参数封装成Map的类型  
  154. 1   <select id="dynamicForeach3Test" resultType="Blog">  
  155. 2       select * from t_blog where title like "%"#{title}"%" and id in  
  156. 3       <foreach collection="ids" index="index" item="item" open="(" separator="," close=")">  
  157. 4           #{item}  
  158. 5       </foreach>  
  159. 6      
  160. 7   </select>  
  161. 上述collection的值为ids,是传入的参数Map的key,对应的Mapper代码:  
  162. 1   public List<Blog> dynamicForeach3Test(Map<String, Object> params);  
  163. 对应测试代码:  
  164.  
  165. 01  @Test  
  166. 02  public void dynamicForeach3Test() {  
  167. 03      SqlSession session = Util.getSqlSessionFactory().openSession();  
  168. 04      BlogMapper blogMapper = session.getMapper(BlogMapper.class);  
  169. 05      final List<Integer> ids = new ArrayList<Integer>();  
  170. 06      ids.add(1);  
  171. 07      ids.add(2);  
  172. 08      ids.add(3);  
  173. 09      ids.add(6);  
  174. 10      ids.add(7);  
  175. 11      ids.add(9);  
  176. 12      Map<String, Object> params = new HashMap<String, Object>();  
  177. 13      params.put("ids", ids);  
  178. 14      params.put("title""中国");  
  179. 15      List<Blog> blogs = blogMapper.dynamicForeach3Test(params);  
  180. 16      for (Blog blog : blogs)  
  181. 17          System.out.println(blog);  
  182. 18      session.close();  
  183. 19  }  
  184. 当然,collection可以指定为自己定义的数组或者集合的变量名,如:
  185. <select id="findByIds" parameterType="cn.edu.tju.entity.Condition" resultType="cn.edu.tju.entity.Emp">
    		select * from EMP where empno in 
    		<foreach collection="empnos" open="(" separator="," close=")" item="id" >
    			#{id}
    		
    		</foreach>
    	</select>
    这里empnos则是为我们自己定义的Condition类的一个变量,如下:
public class Condition {
	private Integer deptno;
	private List<Integer> empnos;
	private Double salary;
	public Double getSalary() {
		return salary;
	}
	public void setSalary(Double salary) {
		this.salary = salary;
	}
	public Integer getDeptno() {
		return deptno;
	}
	public void setDeptno(Integer deptno) {
		this.deptno = deptno;
	}
	public List<Integer> getEmpnos() {
		return empnos;
	}
	public void setEmpnos(List<Integer> empnos) {
		this.empnos = empnos;
	}
	
}
那么最通用的foreach格式如下:

<select …>

select 字段 from 表 where 字段 in

<foreach collection=“集合”  item=“迭代变量"

open="(" separator="," close=")">

#{迭代变量}

</foreach>

</select>



0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:31835次
    • 积分:704
    • 等级:
    • 排名:千里之外
    • 原创:32篇
    • 转载:38篇
    • 译文:0篇
    • 评论:10条
    最新评论