商品订单数据模型
一对一查询
需求:查询所有订单信息,关联查询下单用户信息。
注意:因为一个订单信息只会是一个人下的订单,所以从查询订单信息出发关联查询用户信息为一对一查询。如果从用户信息出发查询用户下的订单信息则为一对多查询,因为一个用户可以下多个订单。
sql语句:
SELECT
o.id,
o.user_id userId,
o.number,
o.createtime,
o.note,
u.username,
u.address
FROM
`order` o
LEFT JOIN `user` u ON o.user_id = u.id
方法一:使用resultType
使用resultType,改造订单pojo类,此pojo类中包括了订单信息和用户信息
这样返回对象的时候,mybatis自动把用户信息也注入进来了
改造pojo类
OrderUser类继承Order类后OrderUser类包括了Order类的所有字段,只需要定义用户的信息字段即可,如下图:
Mapper.xml
<!-- 查询订单,同时包含用户数据 -->
<select id="queryOrderUser" resultType="orderUser">
SELECT
o.id,
o.user_id
userId,
o.number,
o.createtime,
o.note,
u.username,
u.address
FROM
`order` o
LEFT JOIN `user` u ON o.user_id = u.id
</select>
Mapper接口
在UserMapper接口添加方法,如下图:
测试方法
@Test
public void testQueryOrderUser() {
// mybatis和spring整合,整合之后,交给spring管理
SqlSession sqlSession = this.sqlSessionFactory.openSession();
// 创建Mapper接口的动态代理对象,整合之后,交给spring管理
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
// 使用userMapper执行根据条件查询用户
List<OrderUser> list = userMapper.queryOrderUser();
for (OrderUser ou : list) {
System.out.println(ou);
}
// mybatis和spring整合,整合之后,交给spring管理
sqlSession.close();
}
方法总结
定义专门的pojo类作为输出类型,其中定义了sql查询结果集所有的字段。此方法较为简单,企业中使用普遍。
方法二:使用resultMap
使用resultMap,定义专门的resultMap用于映射一对一查询结果,同名的情况也需要一个个手动映射不然没有结果输出。
改造pojo类
在Order类中加入User属性,user属性中用于存储关联查询的用户信息,因为订单关联查询用户是一对一关系,所以这里使用单个User对象存储关联查询的用户信息。
改造Order如下图:
Mapper.xml
这里resultMap指定orderUserResultMap,如下:
<resultMap type="order" id="orderUserResultMap">
<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:order里面的User属性名 -->
<!-- javaType:属性类型 -->
<association property="user" javaType="user">
<!-- id:声明主键,表示user_id是关联查询对象的唯一标识-->
<id property="id" column="user_id" />
<result property="username" column="username" />
<result property="address" column="address" />
</association>
</resultMap>
<!-- 一对一关联,查询订单,订单内部包含用户属性 -->
<select id="queryOrderUserResultMap" resultMap="orderUserResultMap">
SELECT
o.id,
o.user_id,
o.number,
o.createtime,
o.note,
u.username,
u.address
FROM
`order` o
LEFT JOIN `user` u ON o.user_id = u.id
</select>
Mapper接口
编写UserMapper如下图:
测试方法
在UserMapperTest增加测试方法,如下:
@Test
public void testQueryOrderUserResultMap() {
// mybatis和spring整合,整合之后,交给spring管理
SqlSession sqlSession = this.sqlSessionFactory.openSession();
// 创建Mapper接口的动态代理对象,整合之后,交给spring管理
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
// 使用userMapper执行根据条件查询用户
List<Order> list = userMapper.queryOrderUserResultMap();
for (Order o : list) {
System.out.println(o);
}
// mybatis和spring整合,整合之后,交给spring管理
sqlSession.close();
}
一对多查询
案例:查询所有用户信息及用户关联的订单信息。
用户信息和订单信息为一对多关系。
sql语句:
SELECT
u.id,
u.username,
u.birthday,
u.sex,
u.address,
o.id oid,
o.number,
o.createtime,
o.note
FROM
`user` u
LEFT JOIN `order` o ON u.id = o.user_id
修改pojo类
在User类中加入List 泛型为orders属性,如下图:
Mapper.xml
在UserMapper.xml添加sql,如下:
<resultMap type="user" id="userOrderResultMap">
<id property="id" column="id" />
<result property="username" column="username" />
<result property="birthday" column="birthday" />
<result property="sex" column="sex" />
<result property="address" column="address" />
<!-- 配置一对多的关系 -->
<collection property="orders" javaType="list" ofType="order">
<!-- 配置主键,是关联Order的唯一标识 -->
<id property="id" column="oid" />
<result property="number" column="number" />
<result property="createtime" column="createtime" />
<result property="note" column="note" />
</collection>
</resultMap>
<!-- 一对多关联,查询订单同时查询该用户下的订单 -->
<select id="queryUserOrder" resultMap="userOrderResultMap">
SELECT
u.id,
u.username,
u.birthday,
u.sex,
u.address,
o.id oid,
o.number,
o.createtime,
o.note
FROM
`user` u
LEFT JOIN `order` o ON u.id = o.user_id
</select>
Mapper接口
编写UserMapper接口,如下图: ![这里写图片描述](https://img-blog.csdn.net/20180422124510166?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RyZWFtenVvcmE=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70)
测试方法
在UserMapperTest增加测试方法,如下
@Test
public void testQueryUserOrder() {
// mybatis和spring整合,整合之后,交给spring管理
SqlSession sqlSession = this.sqlSessionFactory.openSession();
// 创建Mapper接口的动态代理对象,整合之后,交给spring管理
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
// 使用userMapper执行根据条件查询用户
List<User> list = userMapper.queryUserOrder();
for (User u : list) {
System.out.println(u);
}
// mybatis和spring整合,整合之后,交给spring管理
sqlSession.close();
}
练习代码保存
UserDemo
package pojo;
import java.util.List;
public class UserDemo {
private Integer id;
private String uname;
private List<OrderDemo> order;
public List<OrderDemo> getOrder() {
return order;
}
public void setOrder(List<OrderDemo> order) {
this.order = order;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getUname() {
return uname;
}
public void setUname(String uname) {
this.uname = uname;
}
@Override
public String toString() {
return "UserDemo [id=" + id + ", uname=" + uname + ", order=" + order + "]";
}
}
OrderDemo
package pojo;
public class OrderDemo {
private Integer id;
private Integer userId;
private String ordername;
private UserDemo user;
public UserDemo getUser() {
return user;
}
public void setUser(UserDemo user) {
this.user = user;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getUserId() {
return userId;
}
public void setUserId(Integer userId) {
this.userId = userId;
}
public String getOrdername() {
return ordername;
}
public void setOrdername(String ordername) {
this.ordername = ordername;
}
@Override
public String toString() {
return "OrderDemo [id=" + id + ", userId=" + userId + ", ordername=" + ordername + ", user=" + user + "]";
}
}
mapper
package com.mapper;
import java.util.List;
import com.firtDay.sqlMapconFig.Order;
import com.firtDay.sqlMapconFig.User;
import com.queryVo.QueryVo;
import pojo.OrderDemo;
import pojo.UserDemo;
public interface mapper {
User queryUserById(Integer id);
User queryUserByIdQueryVo(QueryVo vo);
Integer queryUserCount();
User queryUserByName(User user);
List<User> queryUserByIds(QueryVo vo);
List<User> queryUserByIds(List<Integer> ids);
List<User> queryUserByIds(Integer[] ids);
List<OrderDemo> queryOrders();//一对一
List<UserDemo> queryOrdersDemo();//一对多
}
mapper.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.mapper.mapper">
<!-- <select id="queryUserByIdQueryVo" parameterType="com.queryVo.QueryVo"
resultType="User"> select * from t_user where id = #{user.id} </select> -->
<!-- 提取公共的sql片段 -->
<select id="queryUserById" parameterType="Integer" resultType="User">
select * from t_user where id = #{id}
</select>
<!-- 查询表中数据条数 -->
<select id="queryUserCount" resultType="Integer">
<!-- 另一种sql语句求出列行数与count*结果一样 -->
select count(1) from t_user
</select>
<sql id="selector">
select * from t_user
</sql>
<select id="queryUserByName" resultType="User" parameterType="User">
<!-- <include refid="select"></include> -->
select * from t_user
<!-- 为了避免 where _name = #{name} and id = #{id}这种情况中当参数值为空所出现的异常,因此可以利用if、where来解决此问题 -->
<where>
<!-- 在使用test值的时候与#里面的参数名无关它只是起到标记作用而已 -->
<if test="_name != null and _name != ''">
and _name = #{_name}
</if>
</where>
</select>
<select id="queryUserByIds" resultType="User" parameterType="QueryVo">
<include refid="selector"></include>
where
<!-- 通过foreach逐个遍历ids集合里面的id值,返回每次所遍历的对象,其中item是为集合中的每个值取别名 -->
<foreach collection="list" separator="," open="id in (" close=")" item="id">
#{id}
</foreach>
</select>
<!-- 一对一关联 用association-->
<resultMap type="pojo.OrderDemo" id="order">
<result column="id" property="id"/>
<result column="ordername" property="ordername"/>
<result column="userId" property="userId"/>
<association property="user" javaType="pojo.UserDemo">
<result column="id" property="id"/>
<result column="_name" property="uname"/>
</association>
</resultMap>
<select id="queryOrders" resultMap="order">
select `user`.id,`user`._name,`order`.id,`order`.userId,`order`.ordername from `order` LEFT JOIN `user` ON `user`.id=`order`.userId
</select>
<!-- 一对多关联 -->
<resultMap type="pojo.UserDemo" id="user1">
<result column="id" property="id"/>
<result column="_name" property="uname"/>
<!-- 集合中的泛型为OrderDemo 注意一对多的时候用collection-->
<collection property="order" ofType="pojo.OrderDemo">
<result column="id" property="id"/>
<result column="ordername" property="ordername"/>
<result column="userId" property="userId"/>
</collection>
</resultMap>
<select id="queryOrdersDemo" resultMap="user1">
select `user`.id,`user`._name,`order`.id,`order`.userId,`order`.ordername from `user` LEFT JOIN `order` ON `user`.id=`order`.userId
</select>
</mapper>
test类
//一对一关联查询
@Test
public void testDemo6(){
SqlSession openSession = sqlSessionFactory.openSession();
mapper m = openSession.getMapper(mapper.class);
List<OrderDemo> list = m.queryOrders();
for (OrderDemo orderDemo : list) {
System.out.println(orderDemo);
}
openSession.close();
}
//一对多关联查询
@Test
public void testDemo7(){
SqlSession openSession = sqlSessionFactory.openSession();
mapper m = openSession.getMapper(mapper.class);
List<UserDemo> list = m.queryOrdersDemo();
for (UserDemo userDemo : list) {
System.out.println(userDemo);
}
openSession.close();
}