MyBatis多参数处理(第二天)

注：

Servlet：就是和前端页面打交道

（接收请求+数据）

Service：调用mapper层进行增删改查

Person （person student teacher）

Mapper: 对pojo层进行增删改查操作

（对某一个对象的增删改查就在哪个mapper中进行）

附：入参

返回值

（三） MyBatis多参数处理

MyBatis中方法中出现了多个参数的处理方式：

1、第一种使用方法索引

使用java方法的默认规范,参数是有索引，我们需要在sql中指定参数的的索引位置

select * from person where id=#{参数索引} and name=#{参数索引}

</select>

2、第二种map的key

使用map集合的方式传入多个参数值，在sql中我们使用map中的key来映射值

select * from person where id=#{map的key} and name=#{map的key}

</select>

3、第三种使用注解

使用MyBatis的注解 @Param("定义参数在sql中的应用名称")，在定义方法的时候声明sql中使用参数的名字

select * from person where id=#{ddi} and name=#{nnmae}

</select>

3、第四种使用自定义对象进行封装

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

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

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

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

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 INTO `person` (name,bir,address) values(#{name},#{bir},#{address})

</insert>

2、第二种方式使用标签selectKey

<!-- selectKey 适用范围广，支持所有类型数据库

keyColumn="id" 指定主键列名

keyProperty="id" 指定主键封装到javaBean中的id属性中

resultType="int" 指定主键类型

order="AFTER" 设置在sql语句执行前(后),执行此语句

-->

SELECT LAST_INSERT_ID();

</selectKey>

INSERT INTO `person` (name,bir,address) values(#{name},#{bir},#{address})

</insert>

（二）sql片段

1、应用场景

映射文件中可将重复的 sql 提取出来，使用时用 include 引用即可，最终达到 sql 重用的目的

2、实现步骤

(1) 抽取的sql片段

Id,name,bir,address

</sql>

(2) 使用sql片段

select <include refid="column_list"></include> from person where id=#{id}

</select>

注：在我们需要使用公共sql的地方，使用标签 include 引入sql片段。

（三）plugins分页查询

1、应用场景

MyBatis可以使用第三方的插件来对功能进行扩展，分页助手PageHelper是将分页的复杂操作进行封装，使用简单的方式即可获得分页的相关数据，分页功能只需要在配置文件中引入plugins标签。

2、代码实现

(1) 导入PageHelper分页插件坐标

<groupId>com.github.pagehelper</groupId>

<artifactId>pagehelper</artifactId>

</dependency>

(2) 在MyBatis核心配置文件配置PageHelper分页插件

</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

<!--

一对一操作的映射配置

column: 当前的主类，提供查询从表对象的依据.

javaType: 查询从表最终获取的结果类型.

property 当前类型中对应的属性

-->

</association>

</resultMap>

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>

</dataSource>

</environment>

</environments>

</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

</collection>

</resultMap>

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>

</dataSource>

</environment>

</environments>

</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

</association>

</collection>

</resultMap>

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映射

<association

property="customer"

javaType="com.offcn.bean.Customer"

column="cus_fk"

select="com.offcn.mapper.CustomerMapper.findById"

</association>

</resultMap>

SELECT * FROM orders

</select>

3、CustomerMapper接口

Customer findById(Integer cid);

4、CustomerMapper.xml 映射

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映射文件

<collection

property="orders"

column="id"

ofType="com.offcn.bean.Orders"

select="com.offcn.mapper.OrdersMapper.getOneByfk">

</collection>

</resultMap>

SELECT c.*FROM customer c WHERE c.name=#{name};

</select>

3、OrdersMapper接口

public Orders getOneByfk(int fk);

4、OrdersMapper.xml的映射文件

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 * FROM `person`

<where>

AND id = #{id}

</if>

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文件

<select id="findByIdAndNameChoose" parameterType="person" resultType="person"> SELECT * FROM `person`

<where>

AND id = #{id}

</when>

AND name= #{name}

</when>

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文件

UPDATE `person`

<set>

<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 `person`

<if test="address !=null"> address = #{address}, </if>

</trim>

WHERE id = #{id}

</update>

（2）重写where标签

select * from person

</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映射文件

SELECT * FROM `person`

<where>

#{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映射文件

SELECT * FROM `person`

<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);

}