java-mybaits-00502-案例-映射分析-一对一、一对多、多对多

1、一对一查询【类属性即可，association 】

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

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

1.1、方法一【resultType】：

使用resultType，定义订单信息po类，此po类中包括了订单信息和用户信息：

1.1.1、Sql语句：

SELECT orders.*,

  user.username,  user.address

FROM

  orders, user

WHERE orders.user_id = user.id

1.1.2、定义pojo类

将上边sql查询的结果映射到pojo中，pojo中必须包括所有查询列名。

原始的Orders.java不能映射全部字段，需要新创建的pojo。

创建一个pojo继承包括查询字段较多的po类，如下：

package com.lhx.mybatis.po;

import java.util.Date;

public class Order {

    private Integer id;

    private String user_id;

    private Double number;

    private String note;

    private Date createtime;

    public Integer getId() {

        return id;

    }

    public void setId(Integer id) {

        this.id = id;

    }

    public String getUser_id() {

        return user_id;

    }

    public void setUser_id(String user_id) {

        this.user_id = user_id;

    }

    public Double getNumber() {

        return number;

    }

    public void setNumber(Double number) {

        this.number = number;

    }

    public String getNote() {

        return note;

    }

    public void setNote(String note) {

        this.note = note;

    }

    public Date getCreatetime() {

        return createtime;

    }

    public void setCreatetime(Date createtime) {

        this.createtime = createtime;

    }

}

package com.lhx.mybatis.po;

public class OrdersCustom extends Order {

    private String username;

    private String address;

    public String getUsername() {

        return username;

    }

    public void setUsername(String username) {

        this.username = username;

    }

    public String getAddress() {

        return address;

    }

    public void setAddress(String address) {

        this.address = address;

    }

    @Override

    public String toString() {

        return "OrdersCustom [username=" + username + ", address=" + address + ", getId()=" + getId()

                + ", getUser_id()=" + getUser_id() + ", getNumber()=" + getNumber() + ", getNote()=" + getNote()

                + ", getCreatetime()=" + getCreatetime() + ", getClass()=" + getClass() + ", hashCode()=" + hashCode()

                + ", toString()=" + super.toString() + "]";

    }

}

OrdersCustom类继承Orders类后OrdersCustom类包括了Orders类的所有字段，只需要定义用户的信息字段即可。

1.1.3、Mapper.xml

<mapper namespace="com.lhx.mybatis.mapperproxy.OrderMapper">

    <!-- 查询所有订单信息 -->

    <select id="findOrdersList" resultType="com.lhx.mybatis.po.OrdersCustom">

        SELECT

        orders.*,

        user.username,

        user.address

        FROM

        orders, user

        WHERE orders.user_id = user.id

    </select>

</mapper>

1.1.4、Mapper接口：

    public List<OrdersCustom> findOrdersList() throws Exception;

1.1.5、测试：

package com.lhx.mybatis.mapperproxy;

import java.io.InputStream;

import java.util.List;

import org.apache.ibatis.io.Resources;

import org.apache.ibatis.session.SqlSession;

import org.apache.ibatis.session.SqlSessionFactory;

import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import com.lhx.mybatis.po.OrdersCustom;

import junit.framework.TestCase;

public class OrderMapperTest extends TestCase {

    private SqlSessionFactory sqlSessionFactory;

    protected void setUp() throws Exception {

        // mybatis配置文件

        String resource = "SqlMapConfig-MapperProxy.xml";

        InputStream inputStream = Resources.getResourceAsStream(resource);

        // 使用SqlSessionFactoryBuilder创建sessionFactory

        sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

    }

    public void testfindOrdersList() throws Exception {

        // 获取session

        SqlSession session = sqlSessionFactory.openSession();

        // 获限mapper接口实例

        OrderMapper orderMapper = session.getMapper(OrderMapper.class);

        // 查询订单信息

        List<OrdersCustom> list = orderMapper.findOrdersList();

        System.out.println(list);

        for(int i=0,len = list.size();i<len;i++){

            System.out.println(list.get(i));

        }

        // 关闭session

        session.close();

    }

}

1.1.6、总结：

定义专门的po类作为输出类型，其中定义了sql查询结果集所有的字段。此方法较为简单，企业中使用普遍。

1.2、方法二【resultMap】：

使用resultMap，定义专门的resultMap用于映射一对一查询结果。

1.2.1 Sql语句：

同上

1.2.2、定义po类

在Orders类中加入User属性，user属性中用于存储关联查询的用户信息，因为订单关联查询用户是一对一关系，所以这里使用单个User对象存储关联查询的用户信息。

1.2.3、Mapper.xml

    <select id="findOrdersListResultMap" resultMap="userordermap">

        SELECT

        orders.*,

        user.username,

        user.address

        FROM

        orders, user

        WHERE orders.user_id =

        user.id

    </select>

这里resultMap指定userordermap。

1.2.4、定义resultMap

需要关联查询映射的是用户信息，使用association将用户信息映射到订单对象的用户属性中。

    <!-- 订单信息resultmap -->

    <resultMap type="com.lhx.mybatis.po.Order" id="userordermap">

        <!-- 这里的id，是mybatis在进行一对一查询时将user字段映射为user对象时要使用，必须写 -->

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

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

        <result property="number" column="number" />

        <association property="user" javaType="com.lhx.mybatis.po.User">

            <!-- 这里的id为user的id，如果写上表示给user的id属性赋值 -->

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

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

            <result property="address" column="address" />

        </association>

    </resultMap>

association：表示进行关联查询单条记录

property：表示关联查询的结果存储在Order的user属性中

javaType：表示关联查询的结果类型

<id property="id" column="user_id"/>：查询结果的user_id列对应关联对象的id属性，这里是<id />表示user_id是关联查询对象的唯一标识。

<result property="username" column="username"/>：查询结果的username列对应关联对象的username属性。

1.2.5 Mapper接口：

    List<Order> findOrdersListResultMap() throws Exception;

1.2.6 测试：

    public void testfindOrdersListResultMap() throws Exception {

        // 获取session

        SqlSession session = sqlSessionFactory.openSession();

        // 获限mapper接口实例

        OrderMapper orderMapper = session.getMapper(OrderMapper.class);

        // 查询订单信息

        List<Order> list = orderMapper.findOrdersListResultMap();

        System.out.println(list);

        for (int i = 0, len = list.size(); i < len; i++) {

            System.out.println(list.get(i));

        }

        // 关闭session

        session.close();

    }

1.2.7、小结：

使用association完成关联查询，将关联查询信息映射到pojo对象中。

实现一对一查询：

resultType：使用resultType实现较为简单，如果pojo中没有包括查询出来的列名，需要增加列名对应的属性，即可完成映射。

如果没有查询结果的特殊要求建议使用resultType。

resultMap：需要单独定义resultMap，实现有点麻烦，如果对查询结果有特殊的要求，使用resultMap可以完成将关联查询映射pojo的属性中。

resultMap可以实现延迟加载，resultType无法实现延迟加载。

2、一对多查询【List<T>属性即可，collection 】

案例：查询所有订单信息及订单下的订单明细信息。

订单信息与订单明细为一对多关系。

使用resultMap实现如下：

2.1、Sql语句：

SELECT

        orders.*,

        user.username,

        user.address,

        orderdetail.id orderdetail_id,

        orderdetail.items_id,

        orderdetail.items_num

        FROM orders,user,orderdetail

        WHERE orders.user_id = user.id

        AND orders.id = orderdetail.orders_id

2.2、定义po类

在Orders类中加入User属性。

在Orders类中加入List<Orderdetail> orderdetails属性

2.3、Mapper.xml

    <select id="findOrdersDetailList" resultMap="userorderdetailmap">

        SELECT

        orders.*,

        user.username,

        user.address,

        orderdetail.id orderdetail_id,

        orderdetail.items_id,

        orderdetail.items_num

        FROM orders,user,orderdetail

        WHERE orders.user_id = user.id

        AND orders.id = orderdetail.orders_id

    </select>

2.4、定义resultMap

    <resultMap type="com.lhx.mybatis.po.Order" id="userorderdetailmap">

        <!-- 这里的id，是mybatis在进行一对一查询时将user字段映射为user对象时要使用，必须写 -->

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

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

        <result property="number" column="number" />

        <association property="user" javaType="com.lhx.mybatis.po.User">

            <!-- 这里的id为user的id，如果写上表示给user的id属性赋值 -->

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

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

            <result property="address" column="address" />

        </association>

        <collection property="orderDetails" ofType="com.lhx.mybatis.po.OrderDetail">

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

            <result property="itemsId" column="items_id" />

            <result property="itemsNum" column="items_num" />

        </collection>

    </resultMap>

collection部分定义了查询订单明细信息。

collection：表示关联查询结果集

property="orderdetails"：关联查询的结果集存储在com.lhx.mybatis.po.Order上哪个属性。

ofType="com.lhx.mybatis.po.OrderDetail"：指定关联查询的结果集中的对象类型即List中的对象类型。

<id />及<result/>的意义同一对一查询。

2.4.1 resultMap使用继承

上边定义的resultMap中部分和一对一查询订单信息的resultMap相同，这里使用继承可以不再填写重复的内容，如下：

可以使用继承

<!-- 继承 -->

    <resultMap extends="userordermap" type="com.lhx.mybatis.po.Order"

        id="userorderdetailmap">

        <collection property="orderDetails" ofType="com.lhx.mybatis.po.OrderDetail">

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

            <result property="itemsId" column="items_id" />

            <result property="itemsNum" column="items_num" />

        </collection>

    </resultMap>

使用extends继承订单信息userordermap。

2.5、Mapper接口：

    List<Order> findOrdersDetailList() throws Exception;

2.6、测试：

    public void testfindOrdersDetailList() throws Exception {

        // 获取session

        SqlSession session = sqlSessionFactory.openSession();

        // 获限mapper接口实例

        OrderMapper orderMapper = session.getMapper(OrderMapper.class);

        // 查询订单信息

        List<Order> list = orderMapper.findOrdersDetailList();

        System.out.println(list);

        for (int i = 0, len = list.size(); i < len; i++) {

            System.out.println(list.get(i));

            for (int j = 0, len2 = list.get(i).getOrderDetails().size(); j < len; j++) {

                System.out.println(list.get(i).getOrderDetails().get(j));

            }

        }

        // 关闭session

        session.close();

    }

2.7、小结

使用collection完成关联查询，将关联查询信息映射到集合对象。

mybatis使用resultMap的collection对关联查询的多条记录映射到一个list集合属性中。

使用resultType实现：

将订单明细映射到order中的orderdetails中，需要自己处理，使用双重循环遍历，去掉重复记录，将订单明细放在orderdetails中。

3、多对多查询

3.1、查询用户购买的商品信息

3.1.1、需求

查询用户购买的商品信息。

3.1.2、sql

需要查询所有用户信息，关联查询订单及订单明细信息，订单明细信息中关联查询商品信息

3.1.3、po定义

在User中添加List<Orders> orders 属性，在Orders类中加入List<Orderdetail> orderdetails属性

3.1.4、resultMap

需要关联查询映射的信息是：订单、订单明细、商品信息

订单：一个用户对应多个订单，使用collection映射到用户对象的订单列表属性中

订单明细：一个订单对应多个明细，使用collection映射到订单对象中的明细属性中

商品信息：一个订单明细对应一个商品，使用association映射到订单明细对象的商品属性中。

    <!-- 查询用户及购买的商品 -->

    <resultMap type="com.lhx.mybatis.po.User" id="UserAndItemsResultMap">

        <!-- 用户信息 -->

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

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

        <result column="sex" property="sex" />

        <result column="address" property="address" />

        <!-- 订单信息 一个用户对应多个订单，使用collection映射 -->

        <collection property="ordersList" ofType="com.lhx.mybatis.po.Order">

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

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

            <result column="number" property="number" />

            <result column="createtime" property="createtime" />

            <result column="note" property="note" />

            <!-- 订单明细 一个订单包括 多个明细 -->

            <collection property="orderDetails" ofType="com.lhx.mybatis.po.OrderDetail">

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

                <result column="items_id" property="itemsId" />

                <result column="items_num" property="itemsNum" />

                <result column="orders_id" property="ordersId" />

                <!-- 商品信息 一个订单明细对应一个商品 -->

                <association property="item" javaType="com.lhx.mybatis.po.Item">

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

                    <result column="items_name" property="name" />

                    <result column="items_detail" property="detail" />

                    <result column="items_price" property="price" />

                </association>

            </collection>

        </collection>

    </resultMap>

添加sqlmapper

    <select id="findMutli" resultMap="UserAndItemsResultMap">

        SELECT

        orders.*,

        USER.username,

        USER.address,

        orderdetail.id orderdetail_id,

        orderdetail.items_id,

        orderdetail.items_num,

        items.name items_name,

        items.detail items_detail

        FROM

        orders,

        USER,

        orderdetail,

        items

        WHERE

        orders.user_id = USER .id

        AND

        orders.id = orderdetail.orders_id

        AND orderdetail.items_id = items.id

    </select>

mapper接口

List<User> findMutli()throws Exception;

测试

    public void testFindMulti() throws Exception {

        // 获取session

        SqlSession session = sqlSessionFactory.openSession();

        // 获限mapper接口实例

        UserMapper userMapper = session.getMapper(UserMapper.class);

        // 传递user对象查询用户列表

        List<User> list = userMapper.findMutli();

        // 关闭session

        session.close();

    }

3.2、小结

一对多是多对多的特例，如下需求：

查询用户购买的商品信息，用户和商品的关系是多对多关系。

需求1：

查询字段：用户账号、用户名称、用户性别、商品名称、商品价格(最常见)

企业开发中常见明细列表，用户购买商品明细列表，

使用resultType将上边查询列映射到pojo输出。

需求2：

查询字段：用户账号、用户名称、购买商品数量、商品明细（鼠标移上显示明细）

使用resultMap将用户购买的商品明细列表映射到user对象中。

4、resultMap小结

resultType：

作用：

将查询结果按照sql列名pojo属性名一致性映射到pojo中。

场合：

常见一些明细记录的展示，比如用户购买商品明细，将关联查询信息全部展示在页面时，此时可直接使用resultType将每一条记录映射到pojo中，在前端页面遍历list（list中是pojo）即可。

resultMap：

使用association和collection完成一对一和一对多高级映射（对结果有特殊的映射要求）。

association：

作用：

将关联查询信息映射到一个pojo对象中。

场合：

为了方便查询关联信息可以使用association将关联订单信息映射为用户对象的pojo属性中，比如：查询订单及关联用户信息。

使用resultType无法将查询结果映射到pojo对象的pojo属性中，根据对结果集查询遍历的需要选择使用resultType还是resultMap。

collection：

作用：

将关联查询信息映射到一个list集合中。

场合：

为了方便查询遍历关联信息可以使用collection将关联信息映射到list集合中，比如：查询用户权限范围模块及模块下的菜单，可使用collection将模块映射到模块list中，将菜单列表映射到模块对象的菜单list属性中，这样的作的目的也是方便对查询结果集进行遍历查询。

如果使用resultType无法将查询结果映射到list集合中

巴特西