Mybatis输入输出映射_动态sql_关联关系（一对一、一对多、多对多）

Mybatis输入输出映射_动态sql_关联关系（一对一、一对多、多对多）
输入输出映射
parameterType完成输入映射
parameterType可以传入的参数有，基本数据类型（根据id查询用户的信息）、pojo类型（保存客户信息）、也可以传递pojo包装对象

可以定义pojo包装类型扩展mapper接口输入参数的内容。

需求：

自定义查询条件查询用户信息，需要向statement输入查询条件，查询条件user信息

编写包装数据类型

public class OrderUser extends Order {
// 自定义user的扩展信息
private String username;
private String address;
get/set方法
}
1
2
3
4
5
6
配置mapper.xml

<select id="findUserByQureyVo" parameterType="queryVo" resultType="user">
SELECT
`id`,
`username`,
`birthday`,
`sex`,
`address`,
`uuid2`
FROM
USER
WHERE username like '%${user.username}%'
</select>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
mapper.java Mapper接口

// 包装类型的测试（模糊查询）
public List<User> findUserByQureyVo(QueryVo vo) throws Exception;
1
2
测试：

private SqlSessionFactory sqlSessionFactory;

// 创建回话工厂
@Before
public void init() throws IOException {
// 1、Mybatis的核心配置文件
String resource = "SqlMapConfig.xml";
// 2、加载Mybatis的配置文件
InputStream is = Resources.getResourceAsStream(resource);
// 3、获取SqlSessionFactory对象，创建会话工厂，加载配置文件到输入流
sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
}

@Test
/**
*
* @Title: testFindUserByQueryVo
* @Description: 模糊插叙用户信息
* @param
* @return void
*/
public void testFindUserByQueryVo() throws Exception {
SqlSession sqlSession = sqlSessionFactory.openSession();
// 根据接口得到实现类的代理对象
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
QueryVo queryVo = new QueryVo();
User user = new User();
user.setUsername("张");

queryVo.setUser(user);

List<User> list = userMapper.findUserByQureyVo(queryVo);
for (User user2 : list) {
System.out.println(user2);
}
sqlSession.close();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
resultType输出
返回的是pojo或者List<pojo>返回的类型都是pojo

返回简单数据类型

1、mapper.xml

<select id="findUSerCount" resultType="int">
SELECT COUNT(*) FROM USER
</select>
1
2
3
4
2、配置接口：

// 查询记录总数
public Integer findUSerCount() throws Exception;
1
2
3、测试

public void testFindUserCount() throws Exception {
SqlSession sqlSession = sqlSessionFactory.openSession();
// 根据接口得到实现类的代理对象
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
Integer count = userMapper.findUSerCount();
System.out.println(count);
sqlSession.close();
}
1
2
3
4
5
6
7
8
返回pojo或者List<pojo>

1、mapper.xml

<select id="findUserByName" parameterType="String" resultType="user">
SELECT * FROM USER WHERE username like '%${value}%';
</select>
1
2
3
4
2、配置接口：

// 根据id查询用户的信息
public User findUserById(int id) throws Exception;
1
2
3、测试：

// 测试根据Id查询用户信息（得到单个数据）
@Test
public void findUserById() {
// 1、通过sqlSessionFactory创建sqlSession
SqlSession sqlSession = sqlSessionFactory.openSession();
// 通过sqlSession操作数据库
// 第一个参数：statement的位置，等于namespace+statement的id
// 第二个参数：传入的参数
User user = null;
try {
user = sqlSession.selectOne("user.findUserById", 16);
} catch (Exception e) {
e.printStackTrace();
} finally {
sqlSession.close();
}
System.out.println(user);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
resultMap输出
resultType（列名和属性名必须一致）：指定输出结果的类型（pojo、简单类型、hashmap…），将sql查询结果映射为java对象（可以自定义）。

使用resultType注意：sql查询的列名要和resultType指定pojo的属性名相同，指定相同属性方可映射成功，如果sql查询的列名要和resultType指定pojo的属性名全部不相同，list中无法创建pojo对象的。

resultMap（列名和属性名可以不一致使用映射完成）：将sql查询结果映射为java对象。

如果sql查询列名和最终要映射的pojo的属性名不一致，使用resultMap将列名和pojo的属性名做一个对应关系（列名和属性名映射配置）

需求: 查询出订单的所有信息

问题： Orders的pojo中属性字段和表中的orders的字段有不一致的（user_id和userId）

**分析：**此时我们就不可以简单的说过resultType类型进行返回值的接收，我们可以只用resultMap映射用于接收返回值

1、resultMap配置

<resultMap type="order" id="find_order_list">

<id property="id" column="id" />

<result property="userId" column="user_id" />
<result property="number" column="number" />
<result property="createtime" column="createtime" />
<result property="note" column="note" />
</resultMap>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
2、使用resultMap

<select id="findOrderListResultMap" resultMap="find_order_list">
SELECT
`id`,
`user_id`,
`number`,
`createtime`,
`note`
FROM
`order`
</select>
1
2
3
4
5
6
7
8
9
10
11
12
3、编写接口：

// 使用resultMap
public List<Order> findOrderListResultMap() throws Exception;
1
2
总结resultType和resultMap

resultType：pojo中的字段和表中字段一致的，或者我们可以很方便的自己构建一个pojo类型并解决问题时使用resultType

resultMap：字段和pojo字段不一致，表结构和关联关系比较复杂的

动态Sql
mybatis重点是对sql的灵活解析和处理。

将自定义查询条件查询用户列表和查询用户列表总记录数改为动态sql

根据传入不同的字段返回结果（名字或者性别查询）传入什么就根据什么进行查询

if和where

<select id="findUserByPojo" parameterType="queryVo" resultType="user">
<include refid="user_sql"/>

<where>

<if test="user.username != null and user.username != '' " >
and username like '%${user.username}%'
</if>
<if test="user.sex != null and user.sex != '' ">
and sex = #{user.sex}
</if>

</where>
</select>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
sql片段
通过sql片段可以将通用的sql语句抽取出来，单独定义，在其它的statement中可以引用sql片段。
通用的sql语句，常用：where条件、查询列

<sql id="user_sql">
SELECT
`id`,
`username`,
`birthday`,
`sex`,
`address`,
`uuid2`
FROM
USER
</sql>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
sql片段的引用

foreach的使用

在statement通过foreach遍历parameterType中的集合类型。

需求：根据多个用户id查询用户信息。

<select id="findUserByIds" parameterType="queryVo" resultType="user">
<include refid="user_sql"/>
<where>

<foreach collection="ids" open="id IN(" item="uid" separator="," close=")" >
#{uid}
</foreach>
</where>
</select>
1
2
3
4
5
6
7
8
9
10
11
12
关联关系
首先创建四张表，字段和关系如下图：

user表：

CREATE TABLE `user` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`username` varchar(32) NOT NULL COMMENT '用户名称',
`birthday` date DEFAULT NULL COMMENT '生日',
`sex` char(1) DEFAULT NULL COMMENT '性别',
`address` varchar(256) DEFAULT NULL COMMENT '地址',
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=27 DEFAULT CHARSET=utf8;
1
2
3
4
5
6
7
8
orders表：

CREATE TABLE `orders` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`user_id` int(11) NOT NULL COMMENT '下单用户id',
`number` varchar(32) NOT NULL COMMENT '订单号',
`createtime` datetime NOT NULL COMMENT '创建订单时间',
`note` varchar(100) DEFAULT NULL COMMENT '备注',
PRIMARY KEY (`id`),
KEY `FK_orders_1` (`user_id`),
CONSTRAINT `FK_orders_id` FOREIGN KEY (`user_id`) REFERENCES `user` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION
) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;
1
2
3
4
5
6
7
8
9
10
orderdetail表：

CREATE TABLE `orderdetail` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`orders_id` int(11) NOT NULL COMMENT '订单id',
`items_id` int(11) NOT NULL COMMENT '商品id',
`items_num` int(11) DEFAULT NULL COMMENT '商品购买数量',
PRIMARY KEY (`id`),
KEY `FK_orderdetail_1` (`orders_id`),
KEY `FK_orderdetail_2` (`items_id`),
CONSTRAINT `FK_orderdetail_1` FOREIGN KEY (`orders_id`) REFERENCES `orders` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION,
CONSTRAINT `FK_orderdetail_2` FOREIGN KEY (`items_id`) REFERENCES `items` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8;
1
2
3
4
5
6
7
8
9
10
11
items表：

CREATE TABLE `items` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(32) NOT NULL COMMENT '商品名称',
`price` float(10,1) NOT NULL COMMENT '商品定价',
`detail` text COMMENT '商品描述',
`pic` varchar(64) DEFAULT NULL COMMENT '商品图片',
`createtime` datetime NOT NULL COMMENT '生产日期',
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;
1
2
3
4
5
6
7
8
9
表关系

表关联关系

表分析

用户表user：

记录了购买商品的用户

订单表orders：

记录了用户所创建的订单信息

订单明细表orderdetail：

记录了用户创建订单的详细信息

商品信息表items：

记录了商家提供的商品信息

分析表与表之间的关系：

用户user和订单orders：

user---->orders：一个用户可以创建多个订单一对多

orders–>user：一个订单只能由一个用户创建一对一

订单orders和订单明细orderdetail：

orders–>orderdetail：一个订单可以包括多个订单明细一对多

orderdetail–>orders：一个订单明细只属于一个订单一对

订单明细orderdetail和商品信息items：

orderdetail–>items：一个订单明细对应一个商品信息一对一

items–> orderdetail：一个商品对应多个订单明细一对多

一、查询订单信息关联查询用户信息一对一 resultType
sql语句的编写

-- 首先确定主表：user
-- 找到关联的从表：orders
-- 找出两者之间的关系 orders.`user_id`= user.`id`
SELECT
o.* ,
u.`username`,
u.`address`
FROM
orders o,
USER u
WHERE
o.`user_id`= u.`id`
1
2
3
4
5
6
7
8
9
10
11
12
使用resultType实现

首先实现基础的pojo

一对一查询映射的pojo：

创建pojo包括订单信息和用户信息，resultType才可以完成映射。

创建OrderCustom作为自定义pojo，继承sql查询列多的po类。

public class OrderCustomer extends Orders {
//补充用户信息
private String username;
private String address;
}
1
2
3
4
5
6
定义mapper.xml文件

<select id="findOrderMapperCustomer" resultType="orderCustomer" >
SELECT
o.* ,
u.`username`,
u.`address`
FROM
orders o,
USER u
WHERE
o.`user_id`= u.`id`
</select>
1
2
3
4
5
6
7
8
9
10
11
12
mapper.java

// 一、查询订单信息关联查询用户信息一对一使用resultType
public List<OrderCustomer> findOrderMapperCustomer() throws Exception;
1
2
二、查询订单信息关联查询用户信息一对一使用resultMap
resultMap映射思路

resultMap提供一对一关联查询的映射和一对多关联查询映射，一对一映射思路：将关联查询的信息映射到pojo中，如下：

在Orders类中创建一个User属性，将关联查询的信息映射到User属性中。

sql语句的编写

SELECT
o.* ,
u.`username`,
u.`address`
FROM
orders o,
USER u
WHERE
o.`user_id`= u.`id`
1
2
3
4
5
6
7
8
9
定义resultMap

<resultMap type="orders" id="order_mapper_customer">


<id property="id" column="id" />
<result property="userId" column="user_id" />
<result property="number" column="number" />
<result property="createtime" column="createtime" />
<result property="note" column="note" />

<association property="user" javaType="com.syj.mybatis.pojo.User" >


<id property="id" column="user_id" />

<result property="username" column="username" />
<result property="address" column="address" />
</association>
</resultMap>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
在mapper.xml使用定义的resultMap

<select id="findOrderMapperCustomerResultMap" resultMap="order_mapper_customer">
SELECT
o.* ,
u.`username`,
u.`address`
FROM
orders o,
USER u
WHERE
o.`user_id`= u.`id`
</select>
1
2
3
4
5
6
7
8
9
10
11
12
编写mapper接口

// 二、查询订单信息关联查询用户信息一对一使用resultMap
public List<Orders> findOrderMapperCustomerResultMap() throws Exception;
1
2
小结

resultType：要自定义pojo 保证sql查询列和pojo的属性对应，这种方法相对较简单，所以应用广泛。

resultMap：使用association完成一对一映射需要配置一个resultMap，过程有点复杂，如果要实现延迟加载就只能用resultMap实现，如果为了方便对关联信息进行解析，也可以用association将关联信息映射到pojo中方便解析。

三、查询订单信息关联用户信息的订单详情一对多使用resultMap
sql语句的编写

SELECT
o.* ,
u.`username`,
u.`address`,
od.`orders_id` ordersid,
od.`items_id` itemsid,
od.`items_num` itemsnum
FROM
orders o,
USER u,
orderdetail od
WHERE
o.`user_id`= u.`id` AND od.`orders_id`= o.`id`
1
2
3
4
5
6
7
8
9
10
11
12
13
定义resultMap

<resultMap type="orders" id="order_mapper_orderDetail" extends="order_mapper_customer">


<collection property="orderdetails" ofType="Orderdetail">

<id property="id" column="ordersid" />
<result property="itemsId" column="itemsid" />
<result property="itemsNum" column="itemsnum" />
</collection>
</resultMap>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
在mapper.xml使用定义的resultMap

<select id="findOrderMapperOrderDetailResultMap" resultMap="order_mapper_orderDetail">
SELECT
o.* ,
u.`username`,
u.`address`,
od.`orders_id` ordersid,
od.`items_id` itemsid,
od.`items_num` itemsnum
FROM
orders o,
USER u,
orderdetail od
WHERE
o.`user_id`= u.`id` AND od.`orders_id`= o.`id`
</select>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
编写mapper接口

// 三、查询订单信息关联用户信息的订单详情一对多使用resultMap
public List<Orders> findOrderMapperOrderDetailResultMap() throws Exception;
1
2
四、查询所有用户信息，关联查询订单及订单明细信息及商品信息，订单明细信息中关联查询商品信息
用户中包含订单，一个用户对应多个订单

订单中包含订单详情，一个订单详情对应多个订单详情

订单详情中包含商品，一个订单详情中包含一个商品

sql语句的编写

SELECT
u.*,
o.`id` order_id,
o.`number`,
o.`createtime`,
od.`id` orderdetail_id,
od.`items_id`,
od.`items_num`,
i.`name` ,
i.`detail`
FROM
`user` u,
orders o,
orderdetail od,
items i
WHERE u.`id` = o.`user_id` AND o.`id` = od.`orders_id` AND od.`items_id` = i.`id`
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
定义resultMap

<resultMap type="user" id="user_orders_ordersdetail_item">


<id property="id" column="id" />
<result property="username" column="username" />
<result property="sex" column="sex" />
<result property="birthday" column="birthday" />
<result property="address" column="address" />

<collection property="orders" ofType="Orders" >
<id property="id" column="order_id" />
<result property="number" column="number" />
<result property="createtime" column="createtime" />

<collection property="orderdetails" ofType="Orderdetail" >
<id property="id" column="orderdetail_id" />
<result property="itemsId" column="items_id" />
<result property="itemsNum" column="items_num" />

<association property="items" javaType="Items" >
<id property="id" column="items_id" />
<result property="name" column="name" />
<result property="detail" column="detail" />
</association>
</collection>
</collection>
</resultMap>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
在mapper.xml使用定义的resultMap

<select id="findUserOrdersOrderDetailItem" resultMap="user_orders_ordersdetail_item">
SELECT
u.*,
o.`id` order_id,
o.`number`,
o.`createtime`,
od.`id` orderdetail_id,
od.`items_id`,
od.`items_num`,
i.`name` ,
i.`detail`
FROM
`user` u,
orders o,
orderdetail od,
items i
WHERE u.`id` = o.`user_id` AND o.`id` = od.`orders_id` AND od.`items_id` = i.`id`
</select>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
编写mapper接口

// 四、查询所有用户信息，关联查询订单及订单明细信息及商品信息，订单明细信息中关联查询商品信息
public List<User> findUserOrdersOrderDetailItem() throws Exception;
1
2
练习一：用户账号、用户名称、用户性别、商品名称、商品价格(最常见)resultType类型
sql语句的编写

SELECT
u.`id`,
u.`username`,
u.`sex`,
i.`name`,
i.`price`
FROM
USER u,
orders o,
orderdetail od,
items i
WHERE u.`id` = o.`user_id` AND o.`id` = od.`orders_id` AND od.`items_id` = i.`id`

1
2
3
4
5
6
7
8
9
10
11
12
13
在mapper.xml使用

<select id="findUserItem" resultType="UserItem">
SELECT
u.`id`,
u.`username`,
u.`sex`,
i.`name`,
i.`price`
FROM
USER u,
orders o,
orderdetail od,
items i
WHERE u.`id` = o.`user_id` AND o.`id` = od.`orders_id` AND od.`items_id` = i.`id`
</select>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
编写mapper接口

// 练习一：用户账号、用户名称、用户性别、商品名称、商品价格(最常见)
public List<UserItem> findUserItem() throws Exception;
1
2
练习二：用户账号、用户名称、购买商品数量、商品明细
sql语句的编写

SELECT
u.`id`,
u.`username`,
od.`items_num` num,
i.`name`,
i.`price`,
i.`detail`,
i.`createtime`

FROM
USER u,
orders o,
orderdetail od,
items i
WHERE
u.`id` = o.`user_id` AND o.`id` = od.`orders_id` AND od.`items_id` = i.`id`
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
定义resultMap

<resultMap type="user" id="user_items">

<id property="id" column="id" />
<result property="username" column="username" />

<collection property="orders" ofType="Orders" >

<collection property="orderdetails" ofType="Orderdetail">
<result property="itemsNum" column="num" />

<association property="items" javaType="Items">
<result property="name" column="name" />
<result property="price" column="price" />
<result property="detail" column="detail" />
<result property="createtime" column="createtime" />
</association>
</collection>
</collection>
</resultMap>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
在mapper.xml使用定义的resultMap

<select id="findUserItems" resultMap="user_items" >
SELECT
u.`id`,
u.`username`,
od.`items_num` num,
i.`name`,
i.`price`,
i.`detail`,
i.`createtime`

FROM
USER u,
orders o,
orderdetail od,
items i
WHERE
u.`id` = o.`user_id` AND o.`id` = od.`orders_id` AND od.`items_id` = i.`id`
</select>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
编写mapper接口

// 练习二：用户账号、用户名称、购买商品数量、商品明细（
public List<User> findUserItems() throws Exception;
1
2
resultMap：也是对查询结果集进行输出映射，根据自己需求可以通过resultMap将查询结果集映射到pojo中pojo属性中，还可以将多条记录结果集映射到pojo中List集合属性中。一对多、多对多、一对多这是针对业务来说的，可以写成符合一对一、一对多、多对多业务的sql语句，sql语句的结果集的映射由mybatis完成。写成一个复杂的多对多的sql语句，使用resultMap或resultType完成结果集映射。

---------------------

Mybatis输入输出映射_动态sql_关联关系（一对一、一对多、多对多）

猜你喜欢