其他分享
首页 > 其他分享> > 自学SSM第四天--MyBatis多参数处理

自学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