Mybatis 输入映射 输出映射 高级映射

超、凢脫俗 2022-09-29 02:01 334阅读 0赞

1.输出映射

  1. 通过parameterType指定输入参数的类型，类型可以是简单类型、 hashmap 、 pojo 的包装类型。
  3. **\[1\]简单类型**

例如入门程序里的根据用户ID查询用户信息的映射文件，输入Int值。

[2]POJO类型

例如入门程序里的添加用户文件，就是输入POJO类型的USER

[3]包装POJO类型

综合查询时，需要传入的查询条件可能很复杂，可能会根据用户信息、商品信息、订单信息等作为条件进行查询，用户信息中的查询条件由：用户的名称和性别进行查询。

POJO包装类：针对上边的需求，建议使用自定义的包装类型pojo，在包装类型的pojo中将复杂的查询条件包装进去。

例如：当我们要用用户的名称和性别进行查询时

1.创建包装POJO

  1. public class UserQueryVO {
  3.     //用户信息
  4.     private User user;
  6.     public User getUser() {
  7.         return user;
  8.     }
  10.     public void setUser(User user) {
  11.         this.user = user;
  12.     }
  14. }

2.在UserMapper中添加映射文件

  1. #{user.sex}:取出pojo包装对象中性别值 ${user.username}：取出pojo对象中姓名值

20170313161045002

3.UserMapper 接口文件

输出pojo对象list，方法返回值是List

  1. //综合查询
  2.    public List<User> findUserList(UserQueryVO vo);

4.测试代码

20170313162244823

2.输出映射

[1]resultType

使用要求：使用resultType进行结果映射时，需要查询出的列名和映射的对象的属性名一致，才能映射成功。

  1.                    如果查询的列名和对象的属性名全部不一致，那么映射的对象为空。
  3.                    如果查询的列名和对象的属性名有一个一致，那么映射的对象不为空，但是只有映射正确那一个属性才有值。
  5.     如果查询的sql的列名有别名，那么这个别名就是和属性映射的列名。
  10. **（1）简单类型**

注意，对简单类型的结果映射也是有要求的，查询的列必须是一列，才能映射为简单类型。

  1.    例如：

综合查询时 ，根据需求 综合查询符合用户条件的总数

1.映射文件

20170313163810688

  1.  2.  Mapper接口

20170313163826219

  1.   3.测试代码

20170313163927064

（2）POJO对象和POJO列表

例如：根据用户ID查询用户信息和根据用户名称模糊查询用户列表

[2]resultMap

使用resultMap进行结果映射时，不需要查询的列名和映射的属性名必须一致。但是需要声明一个resultMap，来对列名和属性名进行映射。

  1.   例如：对以下SQL查询的结果集进行对象映射
  3.    Select id id\_,username username\_,sex sex\_ from user where id = 1;   
  4.    User类中属性名和上边的列名不一致。  
  6.   1.映射文件
  8.    resultMap:指定定义的resultMap的id，如果这个resultMap在其它的mapper.xml文件中，前边需要添加namespace命名空间
  10.   <!--id：订单关联用户查询的唯一标识  -->
  12.   <!--column: sql语句中查询的列，property：pojo中对应的属性\-->

20170313165355477

2.Mapper接口

  1. public User findUserRstMap(int id)

3.测试代码

20170313165834411

小结：

用 resultType 进行输出映射，只有查询出来的列名和 pojo 中的属性名一致，该列才可以映射成功。

如果查询出来的列名和 pojo 的属性名不一致，通过定义一个 resultMap 对列名和 pojo 属性名之间作一个映射关系。

3.动态SQL

在mybatis中，它提供了一些动态sql标签，可以让程序员更快的进行mybatis的开发，这些动态sql可以通过sql的可重用性。

常用的动态sql标签：if标签、where标签、sql片段、foreach标签

[1] if标签/where标签

  1.     综合查询时，查询条件由用户来输入，用户名称可以为空，需要满足这种情况下的sql编写。

1.映射文件

20170313171218110

  1. 2**.**测试代码

20170313171320135 

  1.   \[2\]Foreach标签
  3.   可以循环传入参数值
  5.   例如：综合查询时，会根据用户ID集合进行查询
  7.       SELECT \* FROM USER WHERE id IN (1,2,10)
  11. **    1.包装POJO**

20170313171806379

2.映射文件

20170313174303844

3.测试代码

  1.        ![20170313174335672][]

4.高级映射

　主要介绍了如何使用resultMap完成高级映射；分析数据库中表之间的关系（一对一、一对多、多对多

如何在mapper.xml文件中配置resultMap实现一对一、一对多、多对多

【1】数据模型

1、 明确每张表存储的信息

2、 明确每张表中关键字段（主键、外键、非空）

3、 明确数据库中表与表之间的外键关系

4、 明确业务中表与表的关系（建立在具体的业务）

数据库中有已经导入的四个表：items：(商品信息表)；orderdetail：(订单明细表)；orders：(订单表)；user：(用户表)

1） 用户表user：

记录了购买商品的用户

2） 订单表orders：

记录了用户所创建的订单信息

3） 订单明细表orderdetail：

记录了用户创建订单的详细信息

4） 商品信息表items：

记录了商家提供的商品信息

分析表与表之间的关系：

用户user和订单orders：

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

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

订单orders和订单明细orderdetail：

orders—>orderdetail：一个订单可以包括多个订单明细 一对多

orderdetail—>orders：一个订单明细只属于一个订单 一对一

订单明细orderdetail和商品信息items：

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

items—> orderdetail：一个商品对应多个订单明细 一对多

以下是这四个表的对应关系：

  1. ![20170314102309849][]

【2】一对一映射

  1. 1.需求
  3. 由上图我们可以看出，用户和订单表是一对一映射，所以我们以查询订单信息，关联查询用户信息为需求

2.sql语句

  1. 查询语句：
  3. 先确定主查询表：订单信息表
  5. 再确定关联查询表：用户信息
  7. 通过orders关联查询用户使用user\_id一个外键，只能关联查询出一条用户记录就可以使用内连接 
  9. SELECT 
  10.   orders.`id`,
  11.   orders.`user_id`,
  12.   orders.`number`,
  13.   user.`username`,
  14.   user.`sex` 
  15. FROM
  16.   orders,
  17.   USER 
  18. WHERE orders.`user_id` = user.`id`
  20.    **（1）使用resultType实现**

这里输出的结果包括 订单信息和用户信息，之前创建的pojo都是单表的实体类，所以这里需要自定义一个组合的pojo才能完成resultType的映射。

  1.   ** 创建OrderCustom作为自定义pojo，补充相应的get()和set()方法    **
  3. public class OrderCustom extends Orders {
  5.    //补充用户信息
  6.    private String username;
  8.    private String sex;
  10. }
  12.  ** **  **mapper.xml文件配置**

定义OrdersMapperCustom.xml文件 

  1. <!--一对一查询使用reusltType完成
  2.    查询订单关联查询用户信息使用resultType的方式
  3.     -->
  4.     <selectid="findOrderUserList"resultType="orderCustom">
  5.       SELECT
  6.         orders.*,
  7.         user.username,
  8.         user.sex
  9.       FROM
  10.         orders,
  11.         USER
  12.       WHERE orders.user_id = user.id
  13.     </select>

mapper接口 

  1. public interface OrdersMapperCustom {
  2.    // 一对一查询，查询订单关联查询用户，使用resultType
  3.    public List<OrderCustom> findOrderUserList() throws Exception;
  4. }

测试代码** **

  1. public void testFindOrderUserList() throws Exception {
  3.                    SqlSessionsqlSession = sqlSessionFactory.openSession();
  4.                    //创建mapper代理对象
  5.                    OrdersMapperCustomordersMapperCustom = sqlSession
  6.                                      .getMapper(OrdersMapperCustom.class);
  8.                    //调用方法
  9.                    List<OrderCustom> list = ordersMapperCustom.findOrderUserList();
  11.                    System.out.println(list);
  13.                    sqlSession.close();
  14.          }

使用resultType来进行一对一结果映射，查询出的列的个数和映射的属性的个数要一致。而且映射的属性要存在与一个大的对象中，它是一种平铺式的映射，即数据库查询出多少条记录，则映射成多少个对象。

  1.   **(2)使用resultMap实现**  
  2.   成一使用resultMap来进行一对一结果映射，它是将关联对象添加到主信息的对象中，具体说是对象嵌套对象的一种映射方式,使用association完对一映射需要配置一个resultMap，过程有点复杂，如果要实现延迟加载就只能用resultMap实现 ，如果为了方便对关联信息进行解析，也可以用association将关联信息映射到pojo中方便解析。

在一对一结果映射时，使用resultType更加简单方便，如果有特殊要求（对象嵌套对象）时，需要使用resultMap进行映射，比如：查询订单列表，然后在点击列表中的查看订单明细按钮，这个时候就需要使用resultMap进行结果映射。而resultType更适应于查询明细信息，比如，查询订单明细列表。

修改扩展类

20170314202423706

Mapper 映射文件

20170314202506352

Mapper接口

20170314202643770

测试代码

20170314202714980

【3】一对多映射

(1)需求

用mapper接口代理的方式查询所有订单信息（关联用户）及订单下的订单明细信息。

（2）SQL语句

  1. 主信息：orders

从信息：orderdetail、user

  1. 有两个id重复， 给orderdetail的id设置别名 detailid. 有别名时查询以别名为主 
  3. SELECT
  4.     orders.`id`,
  5.     orders.`user_id`,
  6.     orders.`number`,
  7.     user.`username`,
  8.     user.`sex`,
  9.     orderdetail.`id` detailid,
  10.     orderdetail.`items_id`,
  11.     orderdetail.`items_num`
  12.   FROM
  13.     orders,
  14.     user,
  15.     orderdetail
  16.   WHERE orders.`user_id` = user.`id`
  17.    AND orders.`id` = orderdetail.`orders_id`
  22. (3)resultMap进行一对多映射思路
  24.  **修改拓展类**
  26.  ![20170314205048922][]
  28.  **映射文件**
  30.  ![20170314210127974][]
  32.     ofType：集合中pojo的类型

20170314205117373

Mapper接口

20170314205413517

测试代码

  1.    ![20170314205437705][]
  3.     mybatis使用resultMap的collection对关联查询的多条记录映射到一个list集合属性中

【4】多对多映射

多对多映射是一对多映射的特例

（1）需求

  1.  查询用户信息，关联查询该用户购买的商品信息

（2）SQL语句

主信息：user

从信息：items、orders、orderdetail

  1. SELECT 
  2.   orders.`id`,
  3.   orders.`user_id`,
  4.   orders.`number`,
  5.   user.`username`,
  6.   user.`sex`,
  7.   orderdetail.`id` detailId,
  8.   orderdetail.`items_id`,
  9.   orderdetail.`items_num`,
  10.   items.`name`,
  11.   items.`price` 
  12. FROM
  13.   orders,
  14.   USER,
  15.   orderdetail,
  16.   items 
  17. WHERE orders.`user_id` = user.`id` 
  18.   AND orders.`id` = orderdetail.`orders_id` 
  19.   AND orderdetail.`items_id` = items.`id`

（3）修改拓展类

一对多映射是多对对映射的一个特殊例子，多对多映射思路如下：

在user.java中创建映射的属性：集合 Listorderlist

在Orders中创建映射的属性：集合List orderdetails

在Orderdetail中创建商品属性：pojo Items items

在User类中添加List orders;

20170314211249840

在Orders类中添加List detailList;

  1. ![20170314211328184][]
  3. 在Orderdetail中添加Items items；

20170314211353964

（4）Mapper接口

  1. ![20170314211437933][]

（5）映射文件

  1. ![20170314211536016][]
  3.   ![20170314211558735][]

（6）测试代码

  1. ![20170314211635872][]

发表评论

表情：
评论列表 （有 0 条评论，334人围观）

还没有评论，来说两句吧...

相关阅读

    相关 mybatis高级映射

       mybatis动态代理实现高级映射，主要整合了mybatis和mysql间的复杂查询方法。在本项目中主要在用户，订单，订单明细，商品明细间进行关联查询操作来理解高级映射

    Bertha 。Bertha 。/ 0 赞/ 303 阅读