06_mybatis关系映射

喜欢ヅ旅行 2024-04-19 11:36 62阅读 0赞

## 1.数据库表分析 ##

**表与表之间的业务关系：**

在分析表与表之间的业务关系时需要建立 在某个业务意义基础上去分析;

先分析数据级别之间有关系的表之间的业务关系;

**usre和orders：**

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

orders—>user：一个订单只由一个用户创建，一对一

**orders和orderdetail：**

orders—>orderdetail：一个订单可以包括 多个订单明细，因为一个订单可以购买多个商品，每个商品的购买信息在orderdetail记录，一对多关系

orderdetail–> orders：一个订单明细只能包括在一个订单中，一对一

**orderdetail和itesm：**

orderdetail—>itesms：一个订单明细只对应一个商品信息，一对一

items–> orderdetail:一个商品可以包括在多个订单明细 ，一对多

**再分析数据库级别没有关系的表之间是否有业务关系：**

**orders和items：**

orders和items之间可以通过orderdetail表建立 关系。

## 2. 一对一查询 ##

如：查询订单信息，关联查询创建订单的用户信息

### 2.1 resultType ###

#### 2.1.1 sql语句 ####

1.  确定查询的主表：订单表
2.  确定查询的关联表：用户表
3.  关联查询使用内链接？还是外链接？
4.  由于orders表中有一个外键（user\_id），通过外键关联查询用户表只能查询出一条记录，可以使用内链接。

SELECT orders.*,USER.username,USER.sex,USER.address FROM orders,USER 
    	WHERE orders.user_id = user.id

#### 2.1.2 创建pojo ####

将上边sql查询的结果映射到pojo中，pojo中必须包括所有查询列名。原始的Orders.java不能映射全部字段，需要新创建的pojo。

创建 一个pojo继承包括查询字段较多的po类。

package com.mybatis.po;
    
    /** * Description:OrdersCustom 订单的扩展类，通过此类映射订单和用户查询的结果，让此类继承包括字段较多的pojo类 * User: jiatp * Date:2019/9/4 0004 下午 4:29 */
    public class OrdersCustom extends Orders{ 
    // 添加用户属性，username,sex,address
        private String username;
        private String sex;
        private String address;
    
        public String getUsername() { 
            return username;
        }
    
        public void setUsername(String username) { 
            this.username = username;
        }
    
        public String getSex() { 
            return sex;
        }
    
        public void setSex(String sex) { 
            this.sex = sex;
        }
    
        public String getAddress() { 
            return address;
        }
    
        public void setAddress(String address) { 
            this.address = address;
        }
    }

#### 2.1.3 mapper.xml ####

<select id="findOrdersUser" resultType="OrdersCustom">
            SELECT
                orders.*,
                USER.username,
                USER.sex,
                USER.address
            FROM
                orders,
            USER
            WHERE
                orders.user_id = USER.id
        </select>

#### 2.1.4 mapper.java ####

//查询订单的关联用户
        public List<OrdersCustom> findOrdersUser()throws Exception;//使用resultType

### 2.2 resultMap ###

#### 2.2.1 sql语句 ####

SELECT orders.*,USER.username,USER.sex,USER.address FROM orders,USER 
    	WHERE orders.user_id = user.id

#### 2.2.2 Orders类中添加user属性 ####

package com.mybatis.po;
    
    import java.util.Date;
    import java.util.List;
    
    public class Orders { 
        private Integer id;
    
        private Integer userId;
    
        private String number;
    
        private Date createtime;
    
        private String note;
        //用户信息
        private User user;
        //订单明细
        private List<Orderdetail> Orderdetais;
    
        public List<Orderdetail> getOrderdetais() { 
            return Orderdetais;
        }
    
        public void setOrderdetais(List<Orderdetail> orderdetais) { 
            Orderdetais = orderdetais;
        }
    
        public User getUser() { 
            return user;
        }
    
        public void setUser(User 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 getNumber() { 
            return number;
        }
    
        public void setNumber(String number) { 
            this.number = number == null ? null : number.trim();
        }
    
        public Date getCreatetime() { 
            return createtime;
        }
    
        public void setCreatetime(Date createtime) { 
            this.createtime = createtime;
        }
    
        public String getNote() { 
            return note;
        }
    
        public void setNote(String note) { 
            this.note = note == null ? null : note.trim();
        }
    
        @Override
        public String toString() { 
            return "Orders{" + "id=" + id + ", userId=" + userId + ", number='" + number + '\'' + ", createtime=" + createtime + ", note='" + note + '\'' + '}';
        }
    }

#### 2.2.3 resultMap ####

使用resultMap将查询结果中的订单信息映射到Orders对象中，在orders类中添加User属性，将关联查询出来的用户信息映射到orders对象中的user属性中。

<resultMap id="Orders_user" type="com.mybatis.po.Orders">
            
            <id column="id" property="id"></id>
            <result column="user_id" property="userId"></result>
            <result column="number" property="number"></result>
            <result column="createtime" property="createtime"></result>
            <result column="note" property="note"></result>
            
            
            <association property="user" javaType="com.mybatis.po.User">
                <id column="user_id" property="id"></id>
                <result column="username" property="username"></result>
                <result column="address" property="address"></result>
                <result column="sex" property="sex"></result>
            </association>
        </resultMap>
        <select id="findOrdersUserResultMap" resultMap="Orders_user">
        SELECT
            orders.*,
            USER.username,
            USER.sex,
            USER.address
        FROM
            orders,
        USER
        WHERE
            orders.user_id = USER.id
        </select>

#### 2.2.4 mapper.java ####

package com.mybatis.test;
    
    import com.mybatis.mapper.OrdersMapperCustom;
    import com.mybatis.po.Orderdetail;
    import com.mybatis.po.Orders;
    import com.mybatis.po.OrdersCustom;
    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 org.junit.Before;
    import org.junit.Test;
    
    import java.io.IOException;
    import java.io.InputStream;
    import java.util.List;
    
    /** * Description:高级映射一对一 * User: jiatp * Date:2019/9/4 0004 下午 4:56 */
    public class onetoone { 
        private SqlSessionFactory sqlSessionFactory;
        @Before
        public void setUp() throws IOException { 
            String resource = "com/mybatis/config/sqlMapConfig.xml";
            InputStream resourceAsStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        }
        //查询订单关联的用户信息（不使用resultMap）
        @Test
        public void testFindOrdersUser() throws Exception { 
            SqlSession sqlSession = sqlSessionFactory.openSession();
            OrdersMapperCustom mapper = sqlSession.getMapper(OrdersMapperCustom.class);
            List<OrdersCustom> list = mapper.findOrdersUser();
            for(OrdersCustom ordersCustom:list) { 
                System.out.println(ordersCustom.getUsername());
            }
            sqlSession.close();
        }
        //查询订单关联的用户信息（使用resultMap）
        @Test
        public void testFindOrdersUserResultMap() throws Exception { 
            SqlSession sqlSession = sqlSessionFactory.openSession();
            OrdersMapperCustom mapper = sqlSession.getMapper(OrdersMapperCustom.class);
            List<Orders> list = mapper.findOrdersUserResultMap();
            for(Orders orders:list) { 
                System.out.println(orders.getUser().getUsername());
            }
            sqlSession.close();
        }
    
    }

### 2.3 resultType和resultMap实现一对一查询小结 ###

**实现一对一查询：**

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

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

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

## 3. 一对多查询 ##

如：查询订单及订单明细的信息。

### 3.1 sql语句 ###

1.  确定主查询表：订单表
2.  确定关联查询表：订单明细表
3.  在一对一查询基础上添加订单明细表关联即可。

SELECT 
    
      orders.*,
    
      USER.username,
    
      USER.sex,
    
      USER.address,
    
      orderdetail.id orderdetail_id,
    
      orderdetail.items_id,
    
      orderdetail.items_num,
    
      orderdetail.orders_id
    
    FROM
    
      orders,
    
      USER,
    
      orderdetail
    
    WHERE orders.user_id = user.id AND orderdetail.orders_id=orders.id

### 3.2 分析 ###

当使用resultType将上边的 查询结果映射到pojo中，***订单信息的就是重复***

**要求**：

对orders映射不能出现重复记录。

**在orders.java类中添加List orderDetails属性。**

最终会将订单信息映射到orders中，订单所对应的订单明细映射到orders中的orderDetails属性中。

映射成的orders记录数为两条（orders信息不重复）

每个orders中的orderDetails属性存储了该 订单所对应的订单明细。

### 3.3 orders中添加list订单明细属性 ###

### 3.4 mapper.xml ###

<resultMap id="findOrdersAndOrderDetailUserResultMap" type="com.mybatis.po.Orders" extends="Orders_user">
            
            
            
    
            
            
            <collection property="Orderdetais" ofType="com.mybatis.po.Orderdetail" >
                
                <id column="orderdetail_id" property="id"></id>
                <result column="orderdetail.items_id" property="itemsId"></result>
                <result column="orderdetail.items_num" property="itemsNum"></result>
                <result column="orderdetail.orders_id" property="ordersId"></result>
            </collection>
    
        </resultMap>
        
        <select id="findOrdersAndOrderDetailUserResultMap" resultMap="findOrdersAndOrderDetailUserResultMap">
            SELECT
            orders.*,
            USER.username,
            USER.sex,
            USER.address,
            orderdetail.id 	orderdetail_id,
            orderdetail.items_id,
            orderdetail.items_num,
            orderdetail.orders_id
        FROM
            orders,
            USER,
            orderdetail
        WHERE
            orders.user_id = USER.id
            AND orderdetail.orders_id = orders.id
        </select>

### 3.5 mapper.java ###

//一对多 !--查询订单,用户及订单明细-->
        public List<Orders> findOrdersAndOrderDetailUserResultMap()throws Exception;//使用resultMap

### 3.6 测试 ###

package com.mybatis.test;
    
    import com.mybatis.mapper.OrdersMapperCustom;
    import com.mybatis.po.Orders;
    import com.mybatis.po.OrdersCustom;
    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 org.junit.Before;
    import org.junit.Test;
    
    import java.io.IOException;
    import java.io.InputStream;
    import java.util.List;
    
    /** * Description:一对多查询 * User: jiatp * Date:2019/9/4 0004 下午 5:34 */
    public class onetomany
    { 
        private SqlSessionFactory sqlSessionFactory;
        @Before
        public void setUp() throws IOException { 
            String resource = "com/mybatis/config/sqlMapConfig.xml";
            InputStream resourceAsStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        }
        @Test
        public void  testfindOrdersAndOrderDetailUserResultMap() throws Exception { 
            SqlSession sqlSession = sqlSessionFactory.openSession();
            OrdersMapperCustom mapper = sqlSession.getMapper(OrdersMapperCustom.class);
            List<Orders> list = mapper.findOrdersAndOrderDetailUserResultMap();
            for(Orders orders:list) { 
                System.out.println(orders);
            }
            sqlSession.close();
        }
    
    }

### 3.6 小结 ###

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

**使用resultType实现：**

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

## 4. 多对多查询 ##

如：查询用户及用户购买商品信息。

### 4.1 sql语句 ###

**查询主表是：用户表**

**关联表：由于用户和商品没有直接关联，通过订单和订单明细进行关联，所以关联表：**

**orders、orderdetail、items**

SELECT orders.*,USER.username, USER.sex,USER.address,orderdetail.id orderdetail_id,
    
      orderdetail.items_id,orderdetail.items_num,orderdetail.orders_id,
    
      items.name items_name,items.detail items_detail,items.price items_price
    
    FROM orders,USER,orderdetail,items
    WHERE orders.user_id = user.id AND orderdetail.orders_id=orders.id AND orderdetail.items_id = items.id

### 4.2 映射思路 ###

1.  将用户信息映射到user中。
2.  在user类中添加订单列表属性List orderslist，将用户创建的订单映射到orderslist
3.  在Orders中添加订单明细列表属性Listorderdetials，将订单的明细映射到orderdetials
4.  在OrderDetail中添加Items属性，将订单明细所对应的商品映射到Items

### 4.3 pojo类 ###

**User.java**

package com.mybatis.po;
    
    import java.io.Serializable;
    import java.util.Date;
    import java.util.List;
    
    public class User implements Serializable { 
    	private int id;
    	private String username;// 用户姓名
    	private String sex;// 性别
    	private Date birthday;// 生日
    	private String address;// 地址
    	private List<Orders> ordersList;
    
    	public List<Orders> getOrdersList() { 
    		return ordersList;
    	}
    
    	public void setOrdersList(List<Orders> ordersList) { 
    		this.ordersList = ordersList;
    	}
    
    	public int getId() { 
    		return id;
    	}
    	public void setId(int id) { 
    		this.id = id;
    	}
    	public String getUsername() { 
    		return username;
    	}
    	public void setUsername(String username) { 
    		this.username = username;
    	}
    	public String getSex() { 
    		return sex;
    	}
    	public void setSex(String sex) { 
    		this.sex = sex;
    	}
    	public Date getBirthday() { 
    		return birthday;
    	}
    	public void setBirthday(Date birthday) { 
    		this.birthday = birthday;
    	}
    	public String getAddress() { 
    		return address;
    	}
    	public void setAddress(String address) { 
    		this.address = address;
    	}
    	@Override
    	public String toString() { 
    		return "User [id=" + id + ", username=" + username + ", sex=" + sex
    				+ ", birthday=" + birthday + ", address=" + address + "]";
    	}
    
    }

**Orders.java**

**Orderdetail.java**

package com.mybatis.po;
    
    public class Orderdetail { 
        private Integer id;
    
        private Integer ordersId;
    
        private Integer itemsId;
    
        private Integer itemsNum;
        //订单详情
    
        private Items items;
    
        public Items getItems() { 
            return items;
        }
    
        public void setItems(Items items) { 
            this.items = items;
        }
        public Integer getId() { 
            return id;
        }
    
        public void setId(Integer id) { 
            this.id = id;
        }
    
        public Integer getOrdersId() { 
            return ordersId;
        }
    
        public void setOrdersId(Integer ordersId) { 
            this.ordersId = ordersId;
        }
    
        public Integer getItemsId() { 
            return itemsId;
        }
    
        public void setItemsId(Integer itemsId) { 
            this.itemsId = itemsId;
        }
    
        public Integer getItemsNum() { 
            return itemsNum;
        }
    
        public void setItemsNum(Integer itemsNum) { 
            this.itemsNum = itemsNum;
        }
    
    	@Override
    	public String toString() { 
    		return "Orderdetail [id=" + id + ", ordersId=" + ordersId
    				+ ", itemsId=" + itemsId + ", itemsNum=" + itemsNum + "]";
    	}
        
    }

### 4.4 mapper.xml ###

<resultMap id="findUsesAndItemsResultMap" type="com.mybatis.po.User">
            
            <id column="user_id" property="id"></id>
            <result column="username" property="username"></result>
            <result column="address" property="address"></result>
            <result column="sex" property="sex"></result>
            
            <collection property="ordersList" ofType="com.mybatis.po.Orders" >
                
                <id column="id" property="id"></id>
                <result column="user_id" property="userId"></result>
                <result column="number" property="number"></result>
                <result column="createtime" property="createtime"></result>
                <result column="note" property="note"></result>
    
                
                <collection property="Orderdetais" ofType="com.mybatis.po.Orderdetail">
                    
                    <id column="orderdetail_id" property="id"></id>
                    <result column="orderdetail.items_id" property="itemsId"></result>
                    <result column="orderdetail.items_num" property="itemsNum"></result>
                    <result column="orderdetail.orders_id" property="ordersId"></result>
    
                    <association property="items" javaType="com.mybatis.po.Items">
                        
                        <id column="items_id" property="id"></id>
                        <result column="items_name" property="name"></result>
                        <result column="items_detail" property="detail"></result>
                        <result column="items_price" property="price"></result>
                    </association>
                </collection>
            </collection>
            
    
        </resultMap>
        
        <select id="findUsesAndItemsResultMap" resultMap="findUsesAndItemsResultMap">
        SELECT
            orders.*,
            USER.username,
            USER.sex,
            USER.address,
            orderdetail.id 	orderdetail_id,
            orderdetail.items_id,
            orderdetail.items_num,
            orderdetail.orders_id,
            items.name items_name,
            items.detail items_detail,
            items.price items_price
        FROM
            orders,
            USER,
            orderdetail,
            items
        WHERE
            orders.user_id = USER.id
            AND orderdetail.orders_id = orders.id and orderdetail.items_id=items.id
        </select>
        <select id="findUserById" parameterType="int" resultType="user">
            select * from user where id=#{id}
        </select>

### 4.5 mapper.java ###

//多对多 查询用户及用户购买商品信息
        public List<User> findUsesAndItemsResultMap();

### 4.6 多对多查询总结 ###

将查询用户购买的商品信息明细清单，（用户名、用户地址、购买商品名称、购买商品时间、购买商品数量）

针对上边的需求就使用resultType将查询到的记录映射到一个扩展的pojo中，很简单实现明细清单的功能。

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

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

需求1：

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

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

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

需求2：

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

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

**总结：使用resultMap是针对那些对查询结果映射有特殊要求的功能，，比如特殊要求映射成list中包括 多个list。**

## 5. 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集合中。***