寒假学习13篇

### 3.1 多表映射概念
1. **多表查询结果映射思路**

上面课程中，我全面讲解了单表的mybatis操作！但是开发中更多的是**多表查询**需求，这种情况我们如何让进行处理？

MyBatis 思想是：数据库不可能永远是你所想或所需的那个样子。我们希望每个数据库都具备良好的第三范式或 BCNF 范式，可惜它们并不都是那样。如果能有一种数据库映射模式，完美适配所有的应用程序查询需求，那就太好了，而 ResultMap 就是 MyBatis 就是完美答案。

官方例子：我们如何映射下面这个语句？

```XML

<select id="selectBlogDetails" resultMap="detailedBlogResultMap">
select
B.id as blog_id,
B.title as blog_title,
B.author_id as blog_author_id,
A.id as author_id,
A.username as author_username,
A.password as author_password,
A.email as author_email,
A.bio as author_bio,
A.favourite_section as author_favourite_section,
P.id as post_id,
P.blog_id as post_blog_id,
P.author_id as post_author_id,
P.created_on as post_created_on,
P.section as post_section,
P.subject as post_subject,
P.draft as draft,
P.body as post_body,
C.id as comment_id,
C.post_id as comment_post_id,
C.name as comment_name,
C.comment as comment_text,
T.id as tag_id,
T.name as tag_name
from Blog B
left outer join Author A on B.author_id = A.id
left outer join Post P on B.id = P.blog_id
left outer join Comment C on P.id = C.post_id
left outer join Post_Tag PT on PT.post_id = P.id
left outer join Tag T on PT.tag_id = T.id
where B.id = #{id}
</select>
```

你可能想把它映射到一个智能的对象模型，这个对象表示了一篇博客，它由某位作者所写，有很多的博文，每篇博文有零或多条的评论和标签。我们先来看看下面这个完整的例子，它是一个非常复杂的结果映射（假设作者，博客，博文，评论和标签都是类型别名）。虽然它看起来令人望而生畏，但其实非常简单。

```Java

<resultMap id="detailedBlogResultMap" type="Blog">
<constructor>
<idArg column="blog_id" javaType="int"/>
</constructor>
<result property="title" column="blog_title"/>
<association property="author" javaType="Author">
<id property="id" column="author_id"/>
<result property="username" column="author_username"/>
<result property="password" column="author_password"/>
<result property="email" column="author_email"/>
<result property="bio" column="author_bio"/>
<result property="favouriteSection" column="author_favourite_section"/>
</association>
<collection property="posts" ofType="Post">
<id property="id" column="post_id"/>
<result property="subject" column="post_subject"/>
<association property="author" javaType="Author"/>
<collection property="comments" ofType="Comment">
<id property="id" column="comment_id"/>
</collection>
<collection property="tags" ofType="Tag" >
<id property="id" column="tag_id"/>
</collection>
</collection>
</resultMap>
```

你现在可能看不懂，接下来我们要学习将多表查询结果使用ResultMap标签映射到实体类对象上！

**我们的学习目标：**

多表查询语句使用

多表结果承接实体类设计

使用ResultMap完成多表结果映射
2. **实体类设计方案**

多表关系回顾：（双向查看）

- 一对一

夫妻关系，人和身份证号
- 一对多| 多对一

用户和用户的订单，锁和钥匙
- 多对多

老师和学生，部门和员工

实体类设计关系(查询)：（单向查看）

- 对一：夫妻一方对应另一方，订单对应用户都是对一关系

实体类设计：对一关系下，类中只要包含单个对方对象类型属性即可！

例如：

```Java
public class Customer {

private Integer customerId;
private String customerName;

}

public class Order {

private Integer orderId;
private String orderName;
private Customer customer;// 体现的是对一的关系

}

```
- 对多: 用户对应的订单，讲师对应的学生或者学生对应的讲师都是对多关系：

实体类设计：对多关系下，类中只要包含对方类型集合属性即可！

```Java
public class Customer {

private Integer customerId;
private String customerName;
private List<Order> orderList;// 体现的是对多的关系
}

public class Order {

private Integer orderId;
private String orderName;
private Customer customer;// 体现的是对一的关系

}

//查询客户和客户对应的订单集合不要管!
```

多表结果实体类设计小技巧：

对一，属性中包含对方对象

对多，属性中包含对方对象集合

只有真实发生多表查询时，才需要设计和修改实体类，否则不提前设计和修改实体类！

无论多少张表联查，实体类设计都是两两考虑!

在查询映射的时候，只需要关注本次查询相关的属性！例如：查询订单和对应的客户，就不要关注客户中的订单集合！
3. **多表映射案例准备**

数据库：

```SQL
CREATE TABLE `t_customer` (`customer_id` INT NOT NULL AUTO_INCREMENT, `customer_name` CHAR(100), PRIMARY KEY (`customer_id`) );

CREATE TABLE `t_order` ( `order_id` INT NOT NULL AUTO_INCREMENT, `order_name` CHAR(100), `customer_id` INT, PRIMARY KEY (`order_id`) );

INSERT INTO `t_customer` (`customer_name`) VALUES ('c01');

INSERT INTO `t_order` (`order_name`, `customer_id`) VALUES ('o1', '1');
INSERT INTO `t_order` (`order_name`, `customer_id`) VALUES ('o2', '1');
INSERT INTO `t_order` (`order_name`, `customer_id`) VALUES ('o3', '1');
```

实际开发时，一般在开发过程中，不给数据库表设置外键约束。
原因是避免调试不方便。
一般是功能开发完成，再加外键约束检查是否有bug。

实体类设计：

稍后会进行订单关联客户查询，也会进行客户关联订单查询，所以在这先练习设计

```Java
@Data
public class Customer {

private Integer customerId;
private String customerName;
private List<Order> orderList;// 体现的是对多的关系

}

@Data
public class Order {
private Integer orderId;
private String orderName;
private Customer customer;// 体现的是对一的关系

}

```

### 3.2 对一映射
1. 需求说明

根据ID查询订单，以及订单关联的用户的信息！
2. OrderMapper接口

```Java
public interface OrderMapper {
Order selectOrderWithCustomer(Integer orderId);
}
```
3. OrderMapper.xml配置文件

```XML



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

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

<association property="customer" javaType="customer">

<id column="customer_id" property="customerId"/>
<result column="customer_name" property="customerName"/>

</association>

</resultMap>

<select id="selectOrderWithCustomer" resultMap="selectOrderWithCustomerResultMap">

SELECT order_id,order_name,c.customer_id,customer_name
FROM t_order o
LEFT JOIN t_customer c
ON o.customer_id=c.customer_id
WHERE o.order_id=#{orderId}

</select>
```

对应关系可以参考下图：

4. Mybatis全局注册Mapper文件

```XML

<mappers>

<mapper resource="mappers/OrderMapper.xml"/>

</mappers>
```
5. junit测试程序

```Java
@Slf4j
public class MyBatisTest {

private SqlSession session;
// junit会在每一个@Test方法前执行@BeforeEach方法

@BeforeEach
public void init() throws IOException {
session = new SqlSessionFactoryBuilder()
.build(
Resources.getResourceAsStream("mybatis-config.xml"))
.openSession();
}

@Test
public void testRelationshipToOne() {

OrderMapper orderMapper = session.getMapper(OrderMapper.class);
// 查询Order对象，检查是否同时查询了关联的Customer对象
Order order = orderMapper.selectOrderWithCustomer(2);
log.info("order = " + order);

}

// junit会在每一个@Test方法后执行@@AfterEach方法
@AfterEach
public void clear() {
session.commit();
session.close();
}
}
```
6. 关键词

在“对一”关联关系中，我们的配置比较多，但是关键词就只有：**association**和**javaType**

### 3.3 对多映射
1. 需求说明

查询客户和客户关联的订单信息！
2. CustomerMapper接口

```Java
public interface CustomerMapper {

Customer selectCustomerWithOrderList(Integer customerId);

}
```
3. CustomerMapper.xml文件

```Java

<resultMap id="selectCustomerWithOrderListResultMap"

type="customer">

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

<collection property="orderList" ofType="order">

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

</collection>

</resultMap>

<select id="selectCustomerWithOrderList" resultMap="selectCustomerWithOrderListResultMap">
SELECT c.customer_id,c.customer_name,o.order_id,o.order_name
FROM t_customer c
LEFT JOIN t_order o
ON c.customer_id=o.customer_id
WHERE c.customer_id=#{customerId}
</select>
```

对应关系可以参考下图：

4. Mybatis全局注册Mapper文件

```XML

<mappers>

<mapper resource="mappers/OrderMapper.xml"/>
<mapper resource="mappers/CustomerMapper.xml"/>
</mappers>
```
5. junit测试程序

```Java
@Test
public void testRelationshipToMulti() {

CustomerMapper customerMapper = session.getMapper(CustomerMapper.class);
// 查询Customer对象同时将关联的Order集合查询出来
Customer customer = customerMapper.selectCustomerWithOrderList(1);
log.info("customer.getCustomerId() = " + customer.getCustomerId());
log.info("customer.getCustomerName() = " + customer.getCustomerName());
List<Order> orderList = customer.getOrderList();
for (Order order : orderList) {
log.info("order = " + order);
}
}
```
6. 关键词

在“对多”关联关系中，同样有很多配置，但是提炼出来最关键的就是：“collection”和“ofType”

posted @ 2024-01-26 17:47 摆烂达人阅读(1) 评论(0) 编辑收藏举报

刷新页面返回顶部

ewqewq

寒假学习13篇

公告