自学SSM第四天--MyBatis多参数处理
作者：互联网
注：
Servlet：就是和前端页面打交道
（接收请求+数据 ）
Service：调用mapper层进行增删改查
Person （person student teacher）
Mapper: 对pojo层进行增删改查操作
（对某一个对象的增删改查就在哪个mapper中进行）
附： 入参
返回值
（三） MyBatis多参数处理
MyBatis中方法中出现了多个参数的处理方式：
1、第一种使用方法索引
使用java方法的默认规范,参数是有索引，我们需要在sql中指定参数的的索引位置
<select>
select * from person where id=#{参数索引} and name=#{参数索引}
</select>
2、第二种map的key
使用map集合的方式传入多个参数值，在sql中我们使用map中的key来映射值
<select>
select * from person where id=#{map的key} and name=#{map的key}
</select>
3、第三种使用注解
使用MyBatis的注解 @Param("定义参数在sql中的应用名称")，在定义方法的时候声明sql中使用参数的名字
<select>
select * from person where id=#{ddi} and name=#{nnmae}
</select>
3、 第四种 使用自定义对象进行封装
<select>
select * from person where id=#{id} and name=#{name}
</select>
（四） 模糊查询
1、占位符方式
（1）构建PersonMapper接口
public interface PersonMapper {
public List<Person> findByName(String name);
}
（2）构建PersonMapper.xml
<mapper namespace="com.offcn.mapper.PersonMapper">
<select id="findByName" parameterType="string" resultType="person">
select * from person where name like #{name}
</select>
</mapper>
（3）测试
@Test
public void testFindByUsername() throws Exception {
PersonMapper personMapper= sqlSession.getMapper(PersonMapper.class);
List<Person> list = personMapper.findByName("%王%");
for (Person person: list) {
System.out.println(person);
}
}
2、字符串拼接方式
（1）构建PersonMapper接口
public interface PersonMapper{
public List<Person> findByName(String name);
}
（2）构建PersonMapper.xml
<mapper namespace="com.offcn.mapper.PersonMapper">
<!-- 不推荐使用，因为Oracle数据库 除了设置别名其余位置不能使用 双引号 -->
<select id="findByName" parameterType="string" resultType="person">
select * from person where name like "%"#{name}"%"
</select>
</mapper>
（3）测试
@Test
public void testFindByUsername() throws Exception {
PersonMapper personMapper= sqlSession.getMapper(PersonMapper.class);
List<Person> list = personMapper.findByName("王");
for (Person person: list) {
System.out.println(person);
}
}
3、$的拼接方式
(3)构建PersonMapper 接口
public interface PersonMapper {
public List<Person> findByName(String name);
}
构建PersonMapper.xml
<mapper namespace="com.offcn.mapper.PersonMapper ">
<!--不推荐使用，因为会出现sql注入问题-->
<select id="findByName" parameterType="string" resultType="person">
select * from person where name like '%${value}%'
</select>
</mapper>
测试
@Test
public void testFindByName() throws Exception {
PersonMapper personMapper= sqlSession.getMapper(PersonMapper.class);
List<Person> list = personMapper.findByName("王");
for (Person person: list) {
System.out.println(person);
}
}
4、使用函数拼接数据
（1）构建PersonMapper 接口
public interface PersonMapper {
public List<Person> findByName(String name);
}
（2）构建PersonMapper.xml
<mapper namespace="com.offcn.mapper.PersonMapper">
<!-- 推荐使用，concat() 字符串拼接函数 注意：在Oracle中，concat() 函数只能传递二次参数，我们解决方案是嵌套拼接 -->
<select id="findByName" parameterType="string" resultType="person">
select * from person where name like concat(concat('%',#{name}),'%');
</select>
</mapper>
（3）测试
@Test
public void testFindByName() throws Exception {
PersonMapper personMapper= sqlSession.getMapper(PersonMapper.class);
List<Person> list = personMapper.findByName("王");
for (Person person: list) {
System.out.println(person);
}
}
总结：${} 与 #{} 区别
#{} :表示一个占位符号
通过 #{} 可以实现preparedStatement向占位符中设置值，自动进行java类型和jdbc类型转换，#{}可以有效防止sql注入。#{} 可以接收简单类型值或pojo属性值。
如果parameterType传输单个简单类型值， #{} 括号中可以是value或其它名称。
${} :表示拼接sql串
通过 ${} 可以将parameterType 传入的内容拼接在sql中且不进行jdbc类型转换，会出现sql注入问题。
${} 可以接收简单类型值或pojo属性值。如果parameterType传输单个简单类型值， ${} 括号中可以使任意名称。
配置文件深入学习
（一）主键处理
应用场景
我们很多时候有这种需求，向数据库插入一条记录后，希望能立即拿到这条记录在数据库中的自动生成的主键值。以便后续业务的使用。
1、第一种方式使用属性useGeneratedKeys
<!-- useGeneratedKeys="true" 声明返回主键
keyProperty="id" 把返回主键的值，封装到实体的id属性中
注意：只适用于主键自增的数据库，MySQL和sqlserver支持，oracle不行 -->
<insert id="insert" parameterType="person" useGeneratedKeys="true" keyProperty="id">
INSERT INTO `person` (name,bir,address) values(#{name},#{bir},#{address})
</insert>
2、第二种方式使用标签selectKey
<!-- selectKey 适用范围广，支持所有类型数据库
keyColumn="id" 指定主键列名
keyProperty="id" 指定主键封装到javaBean中的id属性中
resultType="int" 指定主键类型
order="AFTER" 设置在sql语句执行前(后),执行此语句
-->
<insert id="insert" parameterType="person" useGeneratedKeys="true" keyProperty="id"> <selectKey keyColumn="id" keyProperty="id" resultType="int" order="AFTER">
SELECT LAST_INSERT_ID();
</selectKey>
INSERT INTO `person` (name,bir,address) values(#{name},#{bir},#{address})
</insert>
（二）sql片段
1、应用场景
映射文件中可将重复的 sql 提取出来，使用时用 include 引用即可，最终达到 sql 重用的目的
2、实现步骤
(1) 抽取的sql片段
<sql id="column_list">
Id,name,bir,address
</sql>
(2) 使用sql片段
<select id="findById" parameterType="int" resultType="person" >
<!--引入sql片段-->
select <include refid="column_list"></include> from person where id=#{id}
</select>
注：在我们需要使用公共sql的地方，使用标签 include 引入sql片段。
（三）plugins分页查询
1、应用场景
MyBatis可以使用第三方的插件来对功能进行扩展，分页助手PageHelper是将分页的复杂操作进行封装，使用简单的方式即可获得分页的相关数据，分页功能只需要在配置文件中引入plugins标签。
2、代码实现
(1) 导入PageHelper分页插件坐标
<!--分页插件-->
<dependency>
<groupId>com.github.pagehelper</groupId>
<artifactId>pagehelper</artifactId>
<version>5.1.3</version>
</dependency>
(2) 在MyBatis核心配置文件配置PageHelper分页插件
<!--设置分页插件-->
<plugins>
<plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin>
</plugins>
(3) 测试代码
// 分页插件测试
@Test
public void testPageHelper() throws Exception {
PersonMapper personMapper = sqlSession.getMapper(PersonMapper.class);
// 指定查询页码和每页显示条数
PageHelper.startPage(1, 3);
List<Person> list = PersonMapper.findByIdAndNameIf(null);
for (Person person: list) {
System.out.println(person);
}
// 获取其他分页数据
PageInfo<Person> pageInfo = new PageInfo<>(list);
System.out.println(pageInfo.getTotal()); //总记录数
System.out.println(pageInfo.getPages());//总页数
System.out.println(pageInfo.getPageNum()); //当前页
System.out.println(pageInfo.getPageSize());//每页显示条数
System.out.println(pageInfo.isIsFirstPage());//是否为第一页
System.out.println(pageInfo.isIsLastPage());//是否为最后一页
}
二、MyBatis的多表联合查询
（一） 一对一
一对一操作：通过一方可以关联查询出另外一方的关系数据
案例中是通过Person可以查询当前Person关联的唯一的证件Card的数据,在card表中我们设定了一个外键字段per_fk 关联peson表中的主键id字段。
1、创建数据库表
CREATE TABLE `person` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(32) DEFAULT NULL,
PRIMARY KEY (`id`)
)
CREATE TABLE `card` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(32) DEFAULT NULL,
`num` varchar(32) DEFAULT NULL,
`per_fk` int(11) DEFAULT NULL,
PRIMARY KEY (`id`)
)
2、创建类Person
public class Person implements Serializable {
private int id;
private String name;
private Card card ;
3、创建Person的关联类型 Card
public class Card implements Serializable {
private int id;
private String name;
private String num;
4、创建PersonMapper接口定义方法
public Person getInfoByName( @Param("name") String name);
5、创建文件 PersonMapper.xml
<resultMap type="person" id="newperson">
<id property="id" column="id"/>
<result property="name" column="name"/>
<!--
一对一操作的映射配置
column: 当前的主类，提供查询从表对象的依据.
javaType: 查询从表最终获取的结果类型.
property 当前类型中对应的属性
-->
<association property="card" column="id" javaType="com.offcn.bean.Card">
<id property="id" column="id"/>
<result property="name" column="name"/>
<result property="num" column="num"/>
</association>
</resultMap>
<select id="getInfoById" parameterType="string" resultMap="newperson">
<!-- 第一种和第二种配置方式的查询语句写法 -->
SELECT p.*,c.* FROM person p,card c WHERE p.id=c.per_fk AND p.name=#{name}
</select>
6、编写mybatis-config.xml
<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd"><configuration>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="${driver}"/>
<property name="url" value="${url}"/>
<property name="username" value="${username}"/>
<property name="password" value="${password}"/>
</dataSource>
</environment>
</environments>
<mappers>
<mapper resource="org/offcn/mapper/PersonMapper.xml"/>
</mappers>
</configuration>
7、编码测试
@Test
public void test() {
//使用MyBatis的内置工具类解析MyBatis-config.xml文件
String filename="MyBatis-config.xml";
try {
//使用流读取文件
InputStream is = Resources.getResourceAsStream(filename);
//根据流读取的内容创建一个MyBatis的核心对象
SqlSessionFactory build = new SqlSessionFactoryBuilder().build(is);
//生成session
SqlSession session = build.openSession();
PersonMapper mapper = session.getMapper(PersonMapper.class);
Person infoByName= mapper.getInfoByName("小黑");
System.out.println(infoByName);
//提交事务
session.commit();
//关闭session
session.close();
} catch (Exception e) {
e.printStackTrace();
}
（二） 一对多
本案例采用的是用户和订单来进行讲解，一个用户可以关联查询出自己的订单信息，在订单表中添加一个外键字段关联用户表中的主键。
1、创建对应的数据库表
订单表
CREATE TABLE `orders` (
`oid` varchar(64) NOT NULL,
`odis` varchar(32) DEFAULT NULL,
`onum` varchar(32) DEFAULT NULL,
`cus_fk` int(11) DEFAULT NULL,
PRIMARY KEY (`oid`),
);
用户表
CREATE TABLE `customer` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(32) DEFAULT NULL,
PRIMARY KEY (`id`)
);
2、构建bean类Customer
public class Customer implements Serializable {
private int id;
private String name;
private List<Orders> orders;
3、创建bean类Orders
public class Orders implements Serializable {
private int oid;
private String odis;
private String onum;
4、创建CustomerMapper接口并定义方法
public Customer getInfoByName( @Param("name") String name);
5、创建CustomerMapper接口对应的映射文件 CustomerMapper.xml
<resultMap type="customer" id="newCustomer">
<id property="id" column="id"/>
<result property="name" column="name"/>
<!-- 一对多第一种配置定义多方的映射关系 -->
<collection property="orders" column="id" ofType="com.offcn.bean.Orders" >
<id property="oid" column="oid" />
<result property="odis" column="odis"/>
<result property="onum" column="onum"/>
</collection>
</resultMap>
<select id="getInfoByName" parameterType="string" resultMap="newperson">
select c.*,o.* from customer c ,orders o where c.id=o.per_fk and c.name=#{name}
</select>
6、编写mybatis-config.xml
<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd"><configuration>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="${driver}"/>
<property name="url" value="${url}"/>
<property name="username" value="${username}"/>
<property name="password" value="${password}"/>
</dataSource>
</environment>
</environments>
<mappers>
<mapper resource="org/offcn/mapper/CustomerMapper.xml"/>
</mappers>
</configuration>
7、编码测试
@Test
public void test() {
//使用MyBatis的内置工具类解析MyBatis-config.xml文件
String filename="MyBatis-config.xml";
try {
//使用流读取文件
InputStream is = Resources.getResourceAsStream(filename);
//根据流读取的内容创建一个MyBatis的核心对象
SqlSessionFactory build = new SqlSessionFactoryBuilder().build(is);
//生成session
SqlSession session = build.openSession();
CustomerMapper mapper = session.getMapper(CustomerMapper .class);
Person info = mapper.getInfoByName("小黑");
List<Orders> cards = info.getOrders();
for(Orders ods:cards) {
System.out.println("订单信息为名称"+ods.getOnum()+ods.getOdis());
}
//提交事务
session.commit();
//关闭session
session.close();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
（三）多对多
物品(items)和订单(orders)是多对多映射.两者实际上是通过OrderDetails中间表完成了关联.
需求:查询用户.同时查询出用户所关联的所有的订单,同时查询出订单所对应的所有的订单项以及订单项所对应的物品.
1、创建实体bean对应的表
用户表
CREATE TABLE `customer` (
`cid` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(32) DEFAULT NULL,
PRIMARY KEY (`id`)
)
订单表
CREATE TABLE `orders` (
`oid` int(11) NOT NULL AUTO_INCREMENT,
`dis` varchar(32) DEFAULT NULL,
`cus_fk` int(11) DEFAULT NULL,
PRIMARY KEY (`id`)
FOREIGN KEY (`cus_fk`) REFERENCES `customer` (`id`)
)
商品表
CREATE TABLE `items ` (
`itemid` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(32) DEFAULT NULL,
`price` double DEFAULT NULL,
PRIMARY KEY (`id`)
)
订单详情表
CREATE TABLE `ordersdetail ` (
`odid` int(11) NOT NULL AUTO_INCREMENT,
`items_id` int(11) DEFAULT NULL,
`orders_id` int(11) DEFAULT NULL,
PRIMARY KEY (`id`)
FOREIGN KEY (`items_id`) REFERENCES `items` (`itemid`)
FOREIGN KEY (`orders_id`) REFERENCES `orders` (`oid`)
)
2、创建bean模型类 Customer
public class Customer implements Serializable {
private int cid;
private String name;
private List<Orders> orders;
3、创建订单模型Orders
public class Orders implements Serializable {
private int oid;
private String dis;
Private Customer customer;
Private List<Orderdetail> detailList
4、创建商品模型Items
public class Items implements Serializable {
private int itemid;
private String name;
private double price;
5、创建订单详情模型Ordersdetail
public class Ordersdetail implements Serializable {
private int odid;
private Orders orders;
private Items items;
6、创建接口 CustomerMapper
List<Customer> findCustomerById(Integer cid);
7、创建Mapper接口对应的配置文件 UserMapper.xml
<resultMap type="Customer" id="userManyToManyMap">
<!--配置customer-->
<id column="cid" property="cid"/>
<result column="name" property="name"/>
<!-- 配置user对应的Orders 一对多 -->
<collection property="orders" ofType="Orders">
<id column="oid" property="oid"/>
<result column="dis" property="dis"/>
<!-- 配置orders对应的orderdetail一对多 -->
<collection property="detailList" ofType="Orderdetail">
<id column="odid" property="odid"/>
<!-- 配置orderdetail对应的items 一对一-->
<association property="items" javaType="Items">
<id column="itemid" property="itemid"/>
<result column="name" property="name"/>
<result column="price" property="price"/>
</association>
</collection>
</collection>
</resultMap>
<select id="findAllUsers" parameterType="int" resultMap="userManyToManyMap">
SELECT c.*,o.*,od.*,i.*
FROM customer c,orders o,orderdetail od,items i
WHERE c.cid=o.cus_fk and o.oid=od.orders_id
AND od.items_id=i.itemid and c.cid=#{cid}
</select>
8、测试代码
@Test
public void test() {
//使用MyBatis的内置工具类解析MyBatis-config.xml文件
String filename="MyBatis-config.xml";
try {
//使用流读取文件
InputStream is = Resources.getResourceAsStream(filename);
//根据流读取的内容创建一个MyBatis的核心对象
SqlSessionFactory build = new SqlSessionFactoryBuilder().build(is);
//生成session
SqlSession session = build.openSession();
CustomerMapper mapper = session.getMapper(CustomerMapper .class);
Person info = mapper.getInfoByName(1);
System.out.println(info);
}catch(Exception e){
e.printStackTrace();
}
}
三、MyBatis的嵌套查询
什么是嵌套查询
嵌套查询就是将原来多表查询中的联合查询语句拆成单个表的查询，再使用MyBatis的语法嵌套在一起。
（一）一对一的嵌套
需求：查询一个订单，与此同时查询出该订单所属的用户
代码实现
1、OrdersMapper接口中定义方法
public interface OrderMapper {
public List<Order> findAllWithUser();
}
2、OrderMapper.xml映射
<!--一对一嵌套查询-->
<resultMap id="orderMap" type="orders">
<id column="oid" property="oid"></id>
<result column="dis" property="dis"></result>
<!--根据订单中cus_fk外键，查询用户表数据-->
<association
property="customer"
javaType="com.offcn.bean.Customer"
column="cus_fk"
select="com.offcn.mapper.CustomerMapper.findById"
</association>
</resultMap>
<select id="findAllWithCustomer" resultMap="orderMap" >
SELECT * FROM orders
</select>
3、CustomerMapper接口
Customer findById(Integer cid);
4、CustomerMapper.xml 映射
<select id="findById" parameterType="int" resultType="com.offcn.bean.Customer">
SELECT * FROM `customer` where cid = #{cid}
</select>
5、测试代码
@Test
public void testOrderWithCustomer() throws Exception {
OrderMapper orderMapper = sqlSession.getMapper(OrderMapper.class);
List<Order> list = orderMapper.findAllWithCustomer();
for (Order order : list) {
System.out.println(order);
}
}
（二）一对多的嵌套
需求：查询一个用户，与此同时查询出该用户具有的订单
1、CustomerMapper接口并定义方法
public Customer getInfoByName( @Param("name") String name);
2、CustomerMapper.xml映射文件
<resultMap type="Customer" id="newCustomer">
<id property="cid" column="cid"/>
<result property="name" column="name"/>
<collection
property="orders"
column="id"
ofType="com.offcn.bean.Orders"
select="com.offcn.mapper.OrdersMapper.getOneByfk">
</collection>
</resultMap>
<select id="getInfoByName" resultMap="newperson">
SELECT c.*FROM customer c WHERE c.name=#{name};
</select>
3、OrdersMapper接口
public Orders getOneByfk(int fk);
4、OrdersMapper.xml的映射文件
<select id="getOneByfk" resultType="com.offcn.bean.Orders">
select * from orders where cus_fk=#{cusid}
</select>
5、测试代码
@Test
public void testOrderWithCustomer() throws Exception {
CustomerMapper customerMapper= sqlSession.getMapper(CustomerMapper.class);
Customer customer = customerMapper.getInfoByName(“张三”);
System.out.println(customer );
}
四、MyBatis的动态sql
（一） 动态sql基本使用
1、 动态sql之 <if>、<where>
需求
根据id和username查询，但是不确定两个都有值。
（1）PersonMapper接口
public List<Person> findByIdAndNameIf(Person person);
（2）PersonMapper.xml映射
<!--
where标签相当于 where 1=1，但是如果没有条件，就不会拼接where关键字
同时where标签可以忽略我们成立条件前面的and 或者是or关键字
-->
<select id="findByIdAndNameIf" parameterType="person" resultType="person">
SELECT * FROM `person`
<where>
<if test="id != null">
AND id = #{id}
</if>
<if test="name != null">
AND name= #{name}
</if>
</where>
</select>
（3）测试代码
// if标签 where标签
@Test
public void testFindByIdAndUsernameIf() throws Exception {
PersonMapper personMapper = sqlSession.getMapper(PersonMapper .class);
Person param = new Person();
// param.setId(2);
// param.setName("张三");
List<User> list = personMapper .findByIdAndNameIf(param);
System.out.println(list);
}
2、 动态sql之<choose>
需求
如果有id只使用id做查询，没有id的话看是否有name，有name就根据name做查询，如果都没有，就不带条件查询全部内容。
（1）PersonMapper接口
public List<Person> findByIdAndNameChoose(Person person);
（2）PersonMapper.xml文件
<!-- choose标签相当于swtich语句 when标签相当于case语句 otherwise标签相当于default语句 -->
<select id="findByIdAndNameChoose" parameterType="person" resultType="person"> SELECT * FROM `person`
<where>
<choose>
<when test="id != null">
AND id = #{id}
</when>
<when test="name!= null">
AND name= #{name}
</when>
<otherwise>
AND 1=1
</otherwise>
</choose>
</where>
</select>
（3）测试代码
@Test
public void findByIdAndNameChoose() throws Exception {
PersonMapper personMapper = sqlSession.getMapper(PersonMapper .class);
Person param = new Person();
// param.setId(2);
// param.setName("张三");
List<User> list = personMapper .findByIdAndNameChoose(param);
System.out.println(list);
}
3、 动态sql之<set>
需求
动态更新user表数据，如果该属性有值就更新，没有值不做处理。
（1）PersonMapper接口
public void updateIf(Person person);
（2）PersonMapper.xml文件
<!-- set标签在更新的时候，自动加上set关键字，然后去掉最后一个条件的逗号 -->
<update id="updateIf" parameterType="person">
UPDATE `person`
<set>
<if test="name!= null"> name= #{name}, </if>
<if test="bir!= null"> bir= #{bir}, </if>
<if test="address !=null"> address = #{address}, </if>
</set>
WHERE id = #{id}
</update>
（3）测试代码
@Test
public void testUpdateIf()throws Exception{
PersonMapper personMapper= sqlSession.getMapper(PersonMapper.class);
Person person = new Person();
person .setId(1);
person .setName("李四");
personMapper.updateIf(person);
}
4、 动态sql之<trim>(了解)
（1）重写set标签
<update id="updateIf" parameterType="person">
UPDATE `person`
<trim prefix="set" suffixOverrides=",">
<if test="name!= null"> name= #{name}, </if>
<if test="bir!= null"> bir= #{bir}, </if>
<if test="address !=null"> address = #{address}, </if>
</trim>
WHERE id = #{id}
</update>
（2）重写where标签
<!-- prefix="where" 表示此标签前缀为 where prefixOverrides="and | or" 表示去掉sql语句中的第一个and 或者 or -->
<select id="findByIdAndNameIf" parameterType="person" resultType="person">
select * from person
<trim prefix="where" prefixOverrides="and | or">
<if test="id != null "> and id = #{id} </if>
<if test="name!= null"> and name= #{name} </if>
</trim>
</select>
（3）测试代码使用对应标签的测试代码就好，不需要更改，这里就省略了。
（二）动态sql的高级应用
1、动态sql之<foreach>
foreach主要是用来做数据的循环遍历
例如： select * from person where id in (1,2,3) 在这样的语句中,传入的参数部分必须依靠 foreach遍历才能实现。
标签简介
<foreach>标签用于遍历集合，它的属性：
collection：代表要遍历的集合元素
open：代表语句的开始部分
close：代表结束部分
item：代表遍历集合的每个元素，生成的变量名
sperator：代表分隔符
（1）集合类型参数
a.创建PersonMapper接口
public List<Person> findByList(List<Integer> ids);
b.PersonMapper.xml映射文件
<!-- 如果查询条件为list集合，collection属性值为：collection 或者 list -->
<select id="findByList" parameterType="list" resultType="person" >
SELECT * FROM `person`
<where>
<foreach collection="collection" open="id in(" close=")" item="id" separator=",">
#{id}
</foreach>
</where>
</select>
c.测试代码
// foreach标签 list
@Test
public void testFindByList() throws Exception {
PersonMapper personMapper= sqlSession.getMapper(PersonMapper.class);
List<Integer> ids = new ArrayList<>();
ids.add(46);
ids.add(48);
ids.add(51);
List<User> list = personMapper.findByList(ids);
System.out.println(list);
}
(2)数组
a.PersonMapper接口
public List<Person> findByArray(Integer[] ids);
b.PersonMapper.xml映射文件
<!-- 如果查询条件为array数组，coolection属性值为：array -->
<select id="findByArray" parameterType="int[]" resultType="person">
SELECT * FROM `person`
<where>
<foreach collection="array" open="id in(" close=")" item="id" separator=","> #{id} </foreach> </where>
</select>
c.测试代码
@Test
public void testFindByArray() throws Exception {
PersonMapper personMapper= sqlSession.getMapper(PersonMapper.class);
Integer[] ids = {12, 23, 34};
List<User> list = userMapper.findByArray(ids);
System.out.println(list);
}
标签：name,--,List,PersonMapper,public,SSM,person,MyBatis,id 来源： https://www.cnblogs.com/masterhxh/p/13810572.html