Mybatis关联查询

最新推荐文章于 2024-02-26 01:37:56 发布

成长的小牛233

最新推荐文章于 2024-02-26 01:37:56 发布

阅读量339

点赞数 1

分类专栏： # SSM

本文链接：https://blog.csdn.net/dreamzuora/article/details/80038010

版权

SSM 专栏收录该内容

29 篇文章 3 订阅

订阅专栏

商品订单数据模型

这里写图片描述

一对一查询

需求：查询所有订单信息，关联查询下单用户信息。

注意：因为一个订单信息只会是一个人下的订单，所以从查询订单信息出发关联查询用户信息为一对一查询。如果从用户信息出发查询用户下的订单信息则为一对多查询，因为一个用户可以下多个订单。

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>

测试方法

在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();
    }

成长的小牛233

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Mybatis关联查询

商品订单数据模型一对一查询需求：查询所有订单信息，关联查询下单用户信息。注意：因为一个订单信息只会是一个人下的订单，所以从查询订单信息出发关联查询用户信息为一对一查询。如果从用户信息出发查询用户下的订单信息则为一对多查询，因为一个用户可以下多个订单。sql语句：SELECT o.id, o.user_id userId, o.number, ...
复制链接

扫一扫