mapper.xml标签使用

一、为什么要使用mybaits框架？

       1）效率上最优：相比hibernate而言，mybatis的体积如同九牛一毛，加载速度快，运行速度快，极大的提供和程序和数据库之间的交互效率；

       2）灵活性最强：mybatis框架的实现是基于开发者对SQL语句的使用，因此开发者可以非常灵活的对SQL语句进行编写和修改已到达需要的结果；

       3）学习性强：通过对mybaits框架的时候，开发者可以更好更多的结合数据库进行SQL语句的编写，在完成功能开发的同时也进一步练习和提高了对数据库常用技术的使用，可谓一石二鸟。

二、mybatis在项目中扮演什么角色？以什么形式存在？mybatis的事物管理机制是怎样的？

1）mybatis是一个ORM框架，属于DAO层，负责和数据库进行交互；

2）DAO层文件夹中分别存放了mapper.Java 和 mapper.xml ；

3）mapper.xml 是对 mapper.java 接口的实现。他们之间的关联通过mapper.xml 中的<mapper ></mapper> 标签中的namespace属性实现绑定

[html] view plain copy

1. <?xml version="1.0" encoding="UTF-8" ?>  
2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >  
3. <mapper namespace="mapper.OrderitemMapper" >  
4. </mapper>  

4）检验是否绑定成功：如果按住ctrl键点击namespace中的值，可以直接跳转到对应的接口，则表示跳转成功

5）mybatis框架独立运行时，需要手动控制事物，进行打开、提交、回滚、关闭操作。若集成了spring框架，则可以将其托管到Spring中自动管理

[java] view plain copy

1. SqlSession session= MyBatisSessionFactory.getSession(); //获取数据库连接  
2. session.commit(); //提交  
3. session.rollback(); //回滚  
4. session.close(); //关闭连接  

     

三、mybaits接口方法和接口方法的实现

1）mapper.xml  是 mapper.java 的实现，两者通过 <statementSql></statementSql> 的 id属性来关联 【statementSql 泛指xml文件中的sql执行语句片段】

mapper.java

[java] view plain copy

1. package mapper;  
2.   
3. import java.util.List;  
4.   
5. import pojo.CustomerAndOrder;  
6.   
7. public interface CustomerMapperOrder {  
8.     List<CustomerAndOrder> findCusAndOrderByCid ();     
9. }  

mapper.xml

[html] view plain copy

1. <?xml version="1.0" encoding="UTF-8" ?>  
2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >  
3. <mapper namespace="mapper.CustomerMapperOrder" >  
4.     <!-- 此mapper.xml 是作为一对一的关系表结果的映射管理 -->  
5.     <sql id="cusAndOrder">  
6.         c.*,  
7.         o.order_id as orderId,  
8.         o.create_date as createDate  
9.     </sql>  
10.       
11.     <select id="findCusAndOrderByCid"  resultType="pojo.CustomerAndOrder">  
12.         select  
13.         <include refid="cusAndOrder"/>  
14.         from  
15.         customer c,ordertable o  
16.         WHERE  
17.         c.cid = o.cid  
18.         </select>  
19. </mapper>  

可以看到<select id = " finCusAndOrderByCid" > 中 id 的值 就是 mapper.java 中的方法名

四、接口方法和接口实现中 出入参 类型的定义

1）接口实现中可用的类型：java中的普通类型 和 自定义的pojo类型

2）定义入参的的属性：在 parameterType = " " 属性中定义【注意：入参是可选属性，根据需求设定】

[html] view plain copy

1. <select id="selectByPrimaryKey" resultMap="BaseResultMap" parameterType="java.lang.String" >    
2.     select   
3.     <include refid="Base_Column_List" />  
4.     from product  
5.     where product_id = #{productId,jdbcType=VARCHAR}  
6.   </select>  

3）定义出参的属性：出参定义的是mapper.xml中的重点。

     对于增删改语句，返回值是可选参数，如果要求有返回值，则他们的返回值默认为 int 型，这是由mybatis的底层定义的

     如：mapper.xml 

[html] view plain copy

1. <delete id="deleteByPrimaryKey" parameterType="java.lang.String" >  
2.     delete from product  
3.     where product_id = #{productId,jdbcType=VARCHAR}  
4.   </delete>  
5.   
6.  <insert id="insert" parameterType="pojo.Product" >  
7.     insert into product (product_id, product_factroy, product_store,   
8.       product_descript)  
9.     values (#{productId,jdbcType=VARCHAR}, #{productFactroy,jdbcType=VARCHAR}, #{productStore,jdbcType=INTEGER},   
10.       #{productDescript,jdbcType=VARCHAR})  
11.   </insert>  

[html] view plain copy

1. <pre name="code" class="html"><update id="updateByPrimaryKey" parameterType="pojo.Product" >  
2.     update product  
3.     set product_factroy = #{productFactroy,jdbcType=VARCHAR},  
4.       product_store = #{productStore,jdbcType=INTEGER},  
5.       product_descript = #{productDescript,jdbcType=VARCHAR}  
6.     where product_id = #{productId,jdbcType=VARCHAR}  
7.   </update>  

mapper.java

[java] view plain copy

1. int deleteByPrimaryKey(String productId) throws Exception;  
2.   
3. int insert(Product record) throws Exception ;  
4.    
5. int updateByPrimaryKey(Product record) throws Exception;  

而对于查询语句<select > 而言，返回值是查询语句得到每一条结果的映射。

查询结果的数据类型，决定了出参的类型；查询结果的条目数，决定了是否采用集合或者数组。换言之：如果返回单个值，外部用单值的方式接收；如果是多个值，就需要用List<?> 来接收

mapper.java

[java] view plain copy

1. //通过主键查询结果，只可能是一个对象，所以直接用自定义对象接收  
2.    Product selectByPrimaryKey(String productId) throws Exception;     
3.   
4. //通过条件进行查询的结果，可能是返回对个对象，因此需要用List<Product> 来接收  
5.    List<Product> selectProByConditions(Product product);  

mapper.xml 【在xml中的返回值类型为pojo.Product ，返回值的条目数决定了外部接收的单个值类型还是多个值类型】

[html] view plain copy

1. <select id="selectByPrimaryKey" resultMap="pojo.Product" parameterType="java.lang.String" >    
2.     select   
3.     <include refid="Base_Column_List" />  
4.     from product  
5.     where product_id = #{productId,jdbcType=VARCHAR}  
6.   </select>  
7.   
8.  <select id="selectProByConditions" parameterType="<span style="font-family:Arial, Helvetica, sans-serif;">java.lang.String</span>" resultMap="pojo.Product">  
9.     select * from product  
10.     <where>  
11.         <if test="productId!=null and productId!=''">  
12.             and product_id = #{productId}  
13.         </if>  
14.         <if test="productFactroy!=null and productFactroy!='' ">  
15.             and product_factroy = #{productFactroy}  
16.         </if>  
17.         <if test="productStore!=null">  
18.             and product_store = #{productStore}  
19.         </if>  
20.         <if test="productDescript!=null">  
21.             and product_descript = #{productDescript}  
22.         </if>  
23.     </where>   
24.   </select>  

管理结果映射的标签有两种，分别是resultType和 resultMap 。通过这两个标签建立数据库查询结果的列和程序中实体类或java类型的映射关系

resultType 和 resultMap 之间的关系和区别，一直是mybatis开发者关心的问题。但其实通过几个小的练习，就可以将两者的关系和使用场景搞明白了。

resultType:是属性，可以管理普通返回值类型，也可以返回自定义的pojo包装类。

如：

[html] view plain copy

1. <sql id="cusAndOrder">  
2.         c.*,  
3.         o.order_id as orderId,  
4.         o.create_date as createDate  
5.     </sql>  
6.       
7.     <select id="findCusAndOrderByCid"  resultType="pojo.CustomerAndOrder">  
8.     select  
9.     <include refid="cusAndOrder"/>  
10.     from  
11.     customer c,ordertable o  
12.     WHERE  
13.     c.cid = o.cid  
14.     </select>  

其中pojo.CustomerAndOrder是笔者自定义的类型，继承与Customer 类，并加入了几条Order的属性【注意：在声明自定义类时，一定要生成getter、setter、还有两构造方法 】

有了构造方法，对象才能被初始化，查询结果才能被映射到对应字段

[java] view plain copy

1. package pojo;  
2.   
3. import java.math.BigDecimal;  
4. import java.util.Date;  
5.   
6. public class CustomerAndOrder extends Customer {  
7.       
8.     private String orderId;  
9.       
10.     private Date createDate;  
11.   
12.     public String getOrderId() {  
13.         return orderId;  
14.     }  
15.   
16.     public void setOrderId(String orderId) {  
17.         this.orderId = orderId;  
18.     }  
19.   
20.     public Date getCreateDate() {  
21.         return createDate;  
22.     }  
23.   
24.     public void setCreateDate(Date createDate) {  
25.         this.createDate = createDate;  
26.     }  
27.   
28.     public CustomerAndOrder(String cid, String cname, String address,  
29.             String clevel, String email, BigDecimal balance, String orderId,  
30.             Date createDate) {  
31.         super(cid, cname, address, clevel, email, balance);  
32.         this.orderId = orderId;  
33.         this.createDate = createDate;  
34.     }  
35.   
36.     public CustomerAndOrder() {  
37.         super();  
38.         // TODO Auto-generated constructor stub  
39.     }  
40.   
41.     public CustomerAndOrder(String cid, String cname, String address,  
42.             String clevel, String email, BigDecimal balance) {  
43.         super(cid, cname, address, clevel, email, balance);  
44.         // TODO Auto-generated constructor stub  
45.     }  
46.   
47.       
48.        
49. }<strong>  
50. </strong>  

操作技巧：通过resultType定义返回值的时候，一定要注意查询结果的列名和属性名要一致才能被映射到。如果列名和字段名不一致，可以通过对字段名起别名，将值映射到自定义的属性中

从上方的两段代码中可以发现<sql>片段中将order_id 起别名为 orderId 的目的就是为了映射关联

resultMap：是属性，也是标签；它可以定义返回值类型，也可以作为映射管理器标签独立存在

[html] view plain copy

1. <resultMap id="BaseResultMap" type="pojo.OrderTable" >  
2.    <id column="order_id" property="orderId" jdbcType="VARCHAR" />  
3.    <result column="cid" property="cid" jdbcType="VARCHAR" />  
4.    <result column="address" property="address" jdbcType="VARCHAR" />  
5.    <result column="create_date" property="createDate" jdbcType="TIMESTAMP" />  
6.    <result column="orderitem_id" property="orderitemId" jdbcType="VARCHAR" />  
7.      <!--维护一对多的关系  -->  
8.     <collection property="orderitemList" ofType="pojo.Orderitem">  
9.         <id column="orderitem_id" property="orderitemId"/>  
10.         <result column="product_id" property="productId"/>  
11.         <result column="count" property="count"/>  
12.     </collection>   
13.  </resultMap>  
14.   
15. lt;select id="selectByPrimaryKey" resultMap="BaseResultMap" parameterType="java.lang.String" >  
16.    <!--  
17.      WARNING - @mbggenerated  
18.      This element is automatically generated by MyBatis Generator, do not modify.  
19.      This element was generated on Fri May 06 15:49:42 CST 2016.  
20.    -->  
21.    select   
22.    <include refid="Base_Column_List" />  
23.    from ordertable  
24.    where ordertable.order_id = #{orderId,jdbcType=VARCHAR}  
25.  </select>  

从上面的代码块中可以发现：resultMap 作为映射管理器标签独立使用 ，其中id属性的值作为映射管理器的标识码，可以被statementSql引用

而映射管理器的作用在于可以用来维护实体类之间的关系，如代码片段中所示：resultMap中通过<collection>标签维护了一个一对多的关系，在pojo.OrderTable中有一个以List存在的Orderitem 类，和OrderTable是一对多的关系。

一、SQL语句标签：

[html] view plain copy

1. <!--查询语句-->  
2. <select id="selectByPrimaryKey" resultMap="BaseResultMap" parameterType="java.lang.String" >  
3.     select   
4.   </select>  
5.   
6. <!--插入语句-->  
7. <insert id="insert" parameterType="pojo.OrderTable" >  
8.  insert into ordertable (order_id, cid, address,   
9.       create_date, orderitem_id)  
10.     values (#{orderId,jdbcType=VARCHAR}, #{cid,jdbcType=VARCHAR}, #{address,jdbcType=VARCHAR},   
11.       #{createDate,jdbcType=TIMESTAMP}, #{orderitemId,jdbcType=VARCHAR})  
12.   </insert>  
13.   
14. <!--删除语句-->  
15. <delete id="deleteByPrimaryKey" parameterType="java.lang.String" >  
16. delete from ordertable  
17.     where order_id = #{orderId,jdbcType=VARCHAR}  
18. </delete>  
19.   
20. <!--修改语句-->  
21.  <update id="updateByPrimaryKey" parameterType="pojo.OrderTable" >  
22.   update ordertable  
23.     set cid = #{cid,jdbcType=VARCHAR},  
24.       address = #{address,jdbcType=VARCHAR},  
25.       create_date = #{createDate,jdbcType=TIMESTAMP},  
26.       orderitem_id = #{orderitemId,jdbcType=VARCHAR}  
27.     where order_id = #{orderId,jdbcType=VARCHAR}  
28.   </update>  

需要配置的属性：id="xxxx" >>> 表示此段sql执行语句的唯一标识，也是接口的方法名称【必须一致才能找到】

parameterType="" >>>表示该sql语句中需要传入的参数， 类型要与对应的接口方法的类型一致【可选】

resultMap=“ ”>>> 定义出参，调用已定义的<resultMap>映射管理器的id值

resultType=“ ”>>>定义出参，匹配普通Java类型或自定义的pojo【出参类型若不指定，将为语句类型默认类型，如<insert>语句返回值为int】

p.s： 至于为何<insert><delete><update> 语句的返回值类型为什么是int，有过JDBC操作经验的朋友可能会有印象，增删改操作实际上返回的是操作的条数。而Mybatis框架本身是基于JDBC的，所以此处也沿袭这种返回值类型。

传参和取值：mapper.xml 的灵活性还体现在SQL执行语句可以传参，参数类型通过parameterType= “” 定义

取值方式1：#{value jdbcType = valuetype}：jdbcType 表示该属性的数据类型在数据库中对应的类型，如 #{user jdbcType=varchar} 等价于 String username；

取值方式2：${value } : 这种方式不建议大量使用，可能会发送sql注入而导致安全性问题。一般该取值方式可用在非经常变化的值上，如orderby ${columnName}；

二、sql片段标签<sql>：通过该标签可定义能复用的sql语句片段，在执行sql语句标签中直接引用即可。这样既可以提高编码效率，还能有效简化代码，提高可读性

     需要配置的属性：id="" >>>表示需要改sql语句片段的唯一标识

     引用：通过<include refid="" />标签引用，refid="" 中的值指向需要引用的<sql>中的id=“”属性

[html] view plain copy

1. <!--定义sql片段-->  
2. <sql id="orderAndItem">  
3.     o.order_id,o.cid,o.address,o.create_date,o.orderitem_id,i.orderitem_id,i.product_id,i.count  
4.   </sql>  
5.   
6.  <select id="findOrderAndItemsByOid" parameterType="java.lang.String" resultMap="BaseResultMap">  
7.     select  
8. <!--引用sql片段-->  
9.     <include refid="orderAndItem" />  
10.     from ordertable o  
11.     join orderitem i on o.orderitem_id = i.orderitem_id  
12.     where o.order_id = #{orderId}  
13.   </select>  

三、映射管理器resultMap：映射管理器，是Mybatis中最强大的工具，使用其可以进行实体类之间的关系，并管理结果和实体类间的映射关系

     需要配置的属性：<resultMap id="  " type="  "></resutlMap>   id=" ">>>表示这个映射管理器的唯一标识，外部通过该值引用； type = " ">>> 表示需要映射的实体类；

     需要配置的参数：<id column = " " property= " " />    <id>标签指的是：结果集中结果唯一的列【column】 和 实体属性【property】的映射关系，注意：<id>标签管理的列未必是主键列，需要根据具体需求指定；

    <result column= " " property=" " />  <result>标签指的是：结果集中普通列【column】 和 实体属性【property】的映射关系；

            需要维护的关系：所谓关系维护是值在主表查询时将其关联子表的结果也查询出来

   1）一对一关系<assocation property = " " javaType=" ">   property = “ ” 被维护实体在宿主实体中的属性名，javaType = " " 被维护实体的类型

Orderitem.java

[java] view plain copy

1. package pojo;  
2.   
3. public class Orderitem {  
4.     
5.     private String orderitemId;  
6.   
7.     private String productId;  
8.   
9.     private Integer count;  
10.       
11.     private Product product;     

从上方代码段可以看出：Product 对象在 Orderitem 实体中以 product 属性存在 

Orderitemmapper.xml

[html] view plain copy

1. <resultMap id="BaseResultMap" type="pojo.Orderitem" >  
2.    <id column="orderitem_id" property="orderitemId" jdbcType="VARCHAR" />  
3.    <result column="product_id" property="productId" jdbcType="VARCHAR" />  
4.    <result column="count" property="count" jdbcType="INTEGER" />  
5.    <!-- 通过association 维护 一对一关系 -->  
6.    <association property="product" javaType="pojo.Product">  
7.     <id column="product_id" property="productId"/>  
8.     <result column="product_factroy" property="productFactroy"/>  
9.     <result column="product_store" property="productStore"/>  
10.     <result column="product_descript" property="productDescript"/>  
11.    </association>  
12.  </resultMap>  

通过xml的配置可以看出，在resultMap映射管理器中，通过<association> 进行了维护，也就是在查询Orderitem对象时，可以把关联的Product对象的信息也查询出来

2）一对多关系的维护<collection property=" " ofType=" "> property = “ ” 被维护实体在宿主实体中的属性名 ，ofType=“ ”是被维护方在宿主类中集合泛型限定类型

【由于在一对多关系中，多的一放是以List形式存在，因此ofType的值取用Lsit<?> 的泛型对象类型】

OrderTable.java

[java] view plain copy

1. public class OrderTable {  
2.    
3.     private String orderId;  
4.   
5.     private String cid;  
6.   
7.     private String address;  
8.   
9.     private Date createDate;  
10.   
11.     private String orderitemId;  
12.      
13.     private List<Orderitem> orderitemList ;  

[java] view plain copy

1. }  

OrderTableMapper.xml;

[html] view plain copy

1. <resultMap id="BaseResultMap" type="pojo.OrderTable" >  
2.    <!--  
3.      WARNING - @mbggenerated  
4.      This element is automatically generated by MyBatis Generator, do not modify.  
5.      This element was generated on Fri May 06 15:49:42 CST 2016.  
6.    -->  
7.    <id column="order_id" property="orderId" jdbcType="VARCHAR" />  
8.    <result column="cid" property="cid" jdbcType="VARCHAR" />  
9.    <result column="address" property="address" jdbcType="VARCHAR" />  
10.    <result column="create_date" property="createDate" jdbcType="TIMESTAMP" />  
11.    <result column="orderitem_id" property="orderitemId" jdbcType="VARCHAR" />  
12.      <!--维护一对多的关系  -->  
13.     <collection property="orderitemList" ofType="pojo.Orderitem">  
14.         <id column="orderitem_id" property="orderitemId"/>  
15.         <result column="product_id" property="productId"/>  
16.         <result column="count" property="count"/>  
17.     </collection>   
18.  </resultMap>  

3）在resultMap 中需要注意两点：

3.1）关联关系的维护可以根据实体类之间的实际情况进行嵌套维护

[html] view plain copy

1. <resultMap id="BaseResultMap" type="pojo.OrderTable" >  
2.     <id column="order_id" property="orderId" jdbcType="VARCHAR" />  
3.     <result column="cid" property="cid" jdbcType="VARCHAR" />  
4.     <result column="address" property="address" jdbcType="VARCHAR" />  
5.     <result column="create_date" property="createDate" jdbcType="TIMESTAMP" />  
6.     <result column="orderitem_id" property="orderitemId" jdbcType="VARCHAR" />  
7.          <!--维护一对多的关系  -->  
8.         <collection property="orderitemList" ofType="pojo.Orderitem">  
9.             <id column="orderitem_id" property="orderitemId"/>  
10.             <result column="product_id" property="productId"/>  
11.             <result column="count" property="count"/>  
12. <span style="white-space:pre">        </span><!--嵌套一对一关系-->  
13.             <association property="customer" javaType="pojo.Customer">  
14.                 <id column="cid" property="cid"/>  
15.                 <result column="cname" property="cname"/>  
16.             </association>  
17.         </collection>   
18.   </resultMap>  

【读者只用参考上方代码段的写法，实体关系仅为笔者举例没有必然的逻辑联系】

3.2）关于出现重复列名的处理：在实际操作过程中，查询到的结果可能会出现相同的列名，这样会对映射到实体属性带来影响甚至出现报错，那么对待这个问题可以通过对列取别名的方式处理

四：常用的动态语句标签：通过动态sql标签可以进行条件判断，条件遍历等操作从而满足结果的需要

 <where> ： 使用其可以代替sql语句中的where关键字，一般防止在条件查询的最外层

         <if >：条件判断标签，配置属性test=" 条件字符串 "，判断是否满足条件，满足则执行，不满足则跳过

[html] view plain copy

1. <select id="findOrderItemDetail" parameterType="pojo.Orderitem" resultMap="BaseResultMap">  
2.         select orderitem.orderitem_id,product.*   
3.         from orderitem,product  
4.         <where>  
5.             <if test="orderitemId!=null and orderitemId!=''">  
6.                 and orderitem.orderitem_id = #{orderitemId}  
7.             </if>  
8.             <if test="productId!=null and productId!=''">  
9.                 and orderitem.product_id = #{productId}  
10.             </if>  
11.             <if test="count!=null">  
12.                 and orderitem.count = #{count}  
13.             </if>  
14.         </where>  
15.   </select>  

<set>：常用于<update>更新语句中，替代 sql中的“set”关键字，特别是在联合<if>进行判断是，可以有效方式当某个参数为空或者不合法是错误的更新到数据库中

[html] view plain copy

1. <update id="updateByPrimaryKeySelective" parameterType="pojo.Orderitem" >  
2.    update orderitem  
3.    <set >  
4.      <if test="productId != null" >  
5.        product_id = #{productId,jdbcType=VARCHAR},  
6.      </if>  
7.      <if test="count != null" >  
8.        count = #{count,jdbcType=INTEGER},  
9.      </if>  
10.    </set>  
11.    where orderitem_id = #{orderitemId,jdbcType=VARCHAR}  
12.  </update>  

<choose><when></when><otherwise></otherwise></choose> 标签组：也是一个用于条件判断的标签组，和<if>的不同之处在于条件从<choose>进入，去匹配<when>中的添加，一旦匹配马上结束；若到找不到匹配项，将执行<other>中的语句；可以理解为<if>是 && 关系 <choose>是 || 关系

[html] view plain copy

1. <!-- 查询学生list，like姓名、或=性别、或=生日、或=班级，使用choose -->       
2. <select id="getStudentListChooseEntity" parameterType="StudentEntity" resultMap="studentResultMap">       
3.     SELECT * from STUDENT_TBL ST        
4.     <where>       
5.         <choose>       
6.             <when test="studentName!=null and studentName!='' ">       
7.                     ST.STUDENT_NAME LIKE CONCAT(CONCAT('%', #{studentName}),'%')        
8.             </when>       
9.             <when test="studentSex!= null and studentSex!= '' ">       
10.                     AND ST.STUDENT_SEX = #{studentSex}        
11.             </when>       
12.             <when test="studentBirthday!=null">       
13.                 AND ST.STUDENT_BIRTHDAY = #{studentBirthday}        
14.             </when>       
15.             <when test="classEntity!=null and classEntity.classID !=null and classEntity.classID!='' ">       
16.                 AND ST.CLASS_ID = #{classEntity.classID}        
17.             </when>       
18.             <otherwise>       
19.                         
20.             </otherwise>       
21.         </choose>       
22.     </where>       
23. </select>     

【注：以上代码段转载自：http://blog.csdn.net/zenson_g/article/details/10137665】

<foreach>标签：该标签的作用是遍历集合类型的条件 

  属性：collection=“array” / collection = “list”  ----->是数组类型，还是集合类型

              item=“ productId ”------> 参数名

      open="(" separator="," close=")"  ------>开始符号，分隔符号，结束符号 

      index=“ ” ---->结束下标位置，不配置该参数时，默认为全部遍历

[html] view plain copy

1. <delete id="deleteByPriKeys" parameterType="java.lang.String">  
2.      delete from product where product_Id in  
3.      <foreach collection="list" item="productId" open="(" separator="," close=")">  
4.          #{productId,jdbcType = VARCHAR}  
5.      </foreach>  
6.  </delete>