精华内容
下载资源
问答
  • mybatis高级映射

    2017-11-08 23:08:13
    mybatis高级映射

    转载自   http://blog.csdn.net/zd836614437/article/details/51814108

    一、介绍 
    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 集合中。

    二、一对一查询

    resultType 和 resultMap 实现一对一查询小结:

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

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

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

    d.resultMap 可以实现延迟加载, resultType 无法实现延迟加载。

    2.1.需求:查询订单信息,关联查询用户信息;

    2.2 resultType实现

    public class Orders {
      /** 主键订单Id */
      private Integer id;
      /** 下单用户id */
      private Integer userid;
      /** 订单号 */
      private String number;
      /** 创建订单时间 */
      private Date createTime;
      /** 备注 */
      private String note;
      // 用户信息
      private User user;
      // 订单明细
      private List<OrderDetail> orderdetails;
         //  getter and setter ......
    }
    
    public class OrdersCustom extends Orders {
      // 添加用户的属性
      private String username;
      private String sex;
      private String address;
        // getter and setter......
    }
    
    
    public interface OrdersCustomMapper {
        /** 查询订单,关联查询用户信息 */
        public List<OrdersCustom> findOrdersUser();
    }
    <mapper namespace="com.mybatis.mapper.OrdersCustomMapper">
        <!-- 查询订单,关联查询用户信息 -->
      <select id="findOrdersUser" resultType="com.mybatis.entity.OrdersCustom">
      SELECT t1.*,
        t2.username,
        t2.sex,
        t2.address
      FROM
        orders t1,
        t_user t2
      WHERE t1.user_id=t2.id
      </select>
    </mapper>
    2.3 resultMap实现
    <resultMap type="com.mybatis.entity.Orders" id="OrdersUserResultMap">
              <!-- 配置映射的订单信息 -->
    
              <!-- id:查询列中的唯一标识,订单信息中的唯一标识,如果多列组成唯一标识(如:一般数据库设计中的字典表 使用联合主键),就需要配置多个id 
                  column:订单信息的唯一标识 列
                  property:订单信息的唯一标识列所映射到orders中的那个属性(假如:数据库中orders表中的主键为orders_id,而实体属性名称为ordersId,
                      则这个配置应为<id column="orders_id" property="ordersId"/>,类似hibernate实体映射文件配置)。
              -->
             <id column="id" property="id"/>
             <result column="user_id" property="userid"/>
             <result column="number" property="number"/>
             <result column="createtime" property="createTime"/>
             <result column="note" property="note"/>
    
             <!-- 配置映射的关联用户信息 -->
    
             <!--association:用于映射关联查询单个对象的信息
                 property:要将关联查询的用户信息映射到Orders中那个属性
               -->
             <association property="user" javaType="com.mybatis.entity.User">
                 <!-- id:关联查询用户的唯一标识 
                     column:指定唯一标识用户信息的列
                     property:映射到user的那个属性
                 -->
                 <id column="user_id" property="id"/>
                 <result column="username" property="username"/>
                 <result column="sex" property="sex"/>
                 <result column="address" property="address"/>
             </association>
    
         </resultMap>
    <!-- 查询订单,关联查询用户信息,使用resultMap实现 -->
          <select id="findOrdersUserResultMap" resultMap="OrdersUserResultMap">
                  SELECT t1.*,
                      t2.username,
                      t2.sex,
                      t2.address
                  FROM
                      orders t1,
                      t_user t2
                 WHERE t1.user_id=t2.id
         </select>

    三、一对多查询

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

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

    3.1 需求:查询订单(关联用户)及订单明细; 
    3.2 映射思路 
    3.2. 在 orders.java 类中添加 List orderDetails 属性(上面实体已添加) 。

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

    3.3 核心代码

    <!-- 查询订单关联查询用户及订单明细 -->
    <select id="findOrdersAndOrderDetailResultMap" resultMap="ordersAndOrderDetailResultMap">
        SELECT 
          t1.*,
          t2.username,
          t2.sex,
          t2.address,
          t3.id orderdetail_id,
          t3.items_id,
          t3.items_num,
          t3.orders_id
        FROM
          orders t1,
          t_user t2,
          orderdetail t3
        WHERE t1.user_id = t2.id AND t3.orders_id=t1.id
    </select>
    <!-- 查询订单(关联用户)及订单明细的resultMap -->
    <resultMap type="com.mybatis.entity.Orders" id="ordersAndOrderDetailResultMap" extends="OrdersUserResultMap">
      <!-- 订单信息 -->
      <!-- 关联用户信息 -->
      <!-- 使用extends继承,不用在中配置订单信息和用户信息的映射-->
      <!-- 关联订单明细信息 
        一个订单关联查询出了多条订单明细,要使用collection映射
        collection:对关联查询到的多条记录映射到集合中
        property:将关联查询到的多条记录映射到orders类的那个属性
        ofType:指定映射的集合属性中pojo的类型
      -->
      <collection property="orderdetails" ofType="com.mybatis.entity.OrderDetail">
        <!-- id:唯一标识
           property:要将订单明细的唯一标识映射到com.mybatis.entity.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"/>
      </collection>
    </resultMap>

    四、多对多查询

    4.1.需求:查询用户以及用户购买的商品信息

    4.2.映射思路

    将用户信息映射到 user 中。

    在 user 类中添加订单列表属性 List orderslist ,将用户创建的订单映射到 orderslist;

    在 Orders 中添加订单明细列表属性 Listorderdetials ,将订单的明细映射到 orderdetials;

    在 OrderDetail 中添加 Items 属性,将订单明细所对应的商品映射到 Item;

    4.3 核心代码

    <!-- 查询用户即购买的商品信息的ResultMap -->
      <resultMap type="com.mybatis.entity.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.mybatis.entity.Orders">
           <id column="id" property="id"/>
           <result column="user_id" property="userid"/>
          <result column="number" property="number"/>
          <result column="createtime" property="createTime"/>
          <result column="note" property="note"/>
         <!-- 订单明细
             一个订单包括 多个明细
            -->
            <collection property="orderdetails" ofType="com.mybatis.entity.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="items" javaType="com.mybatis.entity.Items">
                 <id column="items_id" property="id"/>
                 <result column="items_name" property="itemsName"/>
                 <result column="items_detail" property="detail"/>
                 <result column="items_price" property="price"/>
               </association>
            </collection>
          </collection>
      </resultMap>
    <!-- 查询用户及用户购买的商品信息,使用resulaMap-->
    <select id="findUserAndItemsResultMap" resultMap="userAndItemsResultMap">
        SELECT 
             t1.*,
             t2.username,
             t2.sex,
             t2.address,
             t3.id orderdetail_id,
             t3.items_id,
             t3.items_num,
             t3.orders_id,
             t4.itemsname items_name,
             t4.detail items_detail,
             t4.price items_price
        FROM
            orders t1,
            t_user t2,
            orderdetail t3,
            items t4
        WHERE t1.user_id =  t2.id AND  t3.orders_id=t1.id AND t3.items_id = t4.id
    </select>
    展开全文
  • MyBatis 高级映射

    2018-01-26 14:37:52
    什么是MyBatis高级映射? mybatis是一个持久层框架,不完全的ORM(对象关系映射)框架。有输入参数映射和输出结果映射,pojo通过映射数据库字段才能对数据进行增删改查。即mapper.xml(映射文件)。高级映射即是多...

    一.什么是MyBatis高级映射?

    mybatis是一个持久层框架,不完全的ORM(对象关系映射)框架。有输入参数映射输出结果映射pojo通过映射数据库字段才能对数据进行增删改查。即mapper.xml(映射文件)。高级映射即是多表关联映射,如下所示:

    • 将关联查询的列映射到一个pojo属性中。(一对一)
    • 将关联查询的列映射到一个List<pojo>中。(一对多)

    1、parameterType(输入映射)

    指定输入参数类型可以简单类型、pojo类、hashmap。

    2、输出映射

    (1)resultType

    查询到的列类型和resultType指定输出类型一致。

    (2)reusltMap

    可以通过resultMap 完成一些高级映射。如果查询到的列名和映射的pojo的属性名不一致时,通过resultMap设置列名和属性名之间的对应关系(映射关系),可以完成映射。resultMap元素中,允许有以下直接子元素:

    • constructor:类在实例化时,用来注入结果到构造方法中;作用与result相同,同时可以标识出用这个字段值可以区分其他对象实例。可以理解为数据表中的主键,可以定位数据表中唯一记录。
    • result:将数据表中的字段注入到Java对象属性中。
    • association:关联关系,如“用户”有一个“帐号”。其中select属性可以指定查询语句。
    • collection:集合,顾名思议,就是“有很多”关系,如“用户”有很多“订单”。

    result 标签的属性

    • property:对象属性的名称
    • jdbcType:对象属性的类型
    • column:所对应的字段名称

    二.为什么用MyBatis高级映射?

    在现实的项目中进行数据库建模时,我们要遵循数据库设计范式的要求,会对现实中的业务模型进行拆分,封装在不同的数据表中,表与表之间存在着一对多或是多对多的对应关系。进而,我们对数据库的增删改查操作的主体,也就从单表变成了多表。下面举例说明高级映射:

    1. 一个用户可以创建多个订单,一对多。
    2. 一个订单只由一个用户创建,一对一 。
    3. 一个订单可以包括多个订单明细,因为一个订单可以购买多个商品,每个商品的购买信息在orderdetail记录,一对多关系反过来多个订单明细对应一个订单,多对一关系。
    4. 多个用户创建多个订单,多对多关系。

    三.对应关系

    1、一对一关系

    <?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,namespace的值习惯上设置成包名+sql映射文件名,这样保证了namespace的值是唯一的-->
    <mapper namespace="com.yc.mybatis.test.classMapper">
        
            <!-- 
             方式一:嵌套结果:使用嵌套结果映射来处理重复的联合结果的子集
                     封装联表查询的数据(去除重复的数据)
             select * from class c, teacher t where c.teacher_id=t.t_id and c.c_id=1
         -->
        
        <select id="getClass" parameterType="int" resultMap="getClassMap">
            select * from class c, teacher t  where c.teacher_id = t.t_id and c.teacher_id=#{id}
        </select>
        
        <!-- resultMap:映射实体类和字段之间的一一对应的关系 -->
        <resultMap type="Classes" id="getClassMap">
            <id property="id" column="c_id"/>   
            <result property="name" column="c_name"/>
            <association property="teacher" javaType="Teacher">   
                <id property="id" column="t_id"/>
                <result property="name" column="t_name"/>
            </association>
        </resultMap>
        
         <!-- 
             方式二:嵌套查询:通过执行另外一个SQL映射语句来返回预期的复杂类型
             SELECT * FROM class WHERE c_id=1;
             SELECT * FROM teacher WHERE t_id=1   //1 是上一个查询得到的teacher_id的值
             property:别名(属性名)    column:列名 -->
              <!-- 把teacher的字段设置进去 -->
        <select id="getClass1" parameterType="int" resultMap="getClassMap1">
            select * from class where c_id=#{id}
        </select>
        
        <resultMap type="Classes" id="getClassMap1">
            <id property="id" column="c_id"/>   
            <result property="name" column="c_name"/>
            <association property="teacher" column="teacher_id" select="getTeacher"/>   
        </resultMap>
        <select id="getTeacher" parameterType="int" resultType="Teacher">
            select t_id id,t_name name from teacher where t_id =#{id}
        </select>
    </mapper>

    这里bean层会发生变化 这个classes的被bean层会多一个Teacher的属性,并且增加的get,set方法。

    2、一对多关系

    <?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.yc.mapper.CustomerMapper"> 
     
      <resultMap type="com.yc.m.Customer" id="resultCustomerMap"> 
        <id column="id" jdbcType="INTEGER" property="id" />
        <result property="address" column="address"/> 
        <result property="postcode" column="postcode"/> 
        <result property="sex" column="sex"/> 
        <result property="cname" column="cname"/> 
        <collection property="orders" ofType="com.yc.m.Orders">
              <id property="id" column="id"/>
              <result property="code" column="code"/>
        </collection>
      </resultMap> 
        
      <select id="getCustomer" resultMap="resultCustomerMap" parameterType="int"> 
        SELECT * 
        FROM t_customer 
        WHERE id=#{id} 
      </select>      
    </mapper> 

    在这里可以明显的看出多出了一个属性ofType,这个ofType的含义就是你collection所对应的是那个bean,当然在bean层中也会发生变化 ,这里在Customer的bean中嵌套一条语句:

    private List<Orders> orders;   //一个Customer 对应N多个Orders

     

    展开全文
  • 主要介绍了MyBatis高级映射学习教程的相关资料,需要的朋友可以参考下
  • Mybatis高级映射查询

    2017-07-22 12:36:41
    Mybatis高级映射查询
  • 主要介绍了MyBatis高级映射和查询缓存的相关资料,需要的朋友可以参考下
  • mybatis 高级映射实例

    2018-07-02 22:26:28
    基本编写mybatis 高级映射,使用xml方式编写mapper文件,关联嵌套和鉴别器的使用,内有sql文件,可以直接导入项目使用,注意:sql文件格式为UTF-8,项目格式为GBK
  • 本篇文章主要介绍了mybatis高级映射一对多查询实现代码,具有一定的参考价值,感兴趣的小伙伴们可以参考一下。
  • 下面小编就为大家带来一篇基于mybatis高级映射多对多查询的实现。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code,并且改名...这篇文章主要介绍了Mybatis高级映射、动态SQL及获得自增主键的相关资料,需要的朋友可以参考下
  • MyBatis高级映射(多对多查询)
  • MyBatis高级映射(一对一查询)
  • MyBatis高级映射(一对多查询)
  • Mybatis高级映射多对多查询

    千次阅读 2017-11-19 10:33:54
    紧接着上一篇文章:Mybatis高级映射一对多查询 写 一、开发准备 1、新建数据表(四张表)和添加测试数据 DROP TABLE IF EXISTS `items`;DROP TABLE IF EXISTS `orders`;DROP TABLE IF EXISTS ...

    紧接着上一篇文章:Mybatis高级映射一对多查询 写

    一、开发准备

    1、新建数据表(四张表)和添加测试数据

    1. DROP TABLE IF EXISTS `items`;
    2. DROP TABLE IF EXISTS `orders`;
    3. DROP TABLE IF EXISTS `user`;
    4. DROP TABLE IF EXISTS `orderdetail`;
    5. /*items是商品表*/
    6. CREATE TABLE `items` (
    7.   `id` INT(11) NOT NULL AUTO_INCREMENT,
    8.   `nameVARCHAR(32) NOT NULL COMMENT '商品名称',
    9.   `price` FLOAT(10,1) NOT NULL COMMENT '商品定价',
    10.   `detail` TEXT COMMENT '商品描述',
    11.   `pic` VARCHAR(64) DEFAULT NULL COMMENT '商品图片',
    12.   `createtime` DATETIME NOT NULL COMMENT '生产日期',
    13.   PRIMARY KEY (`id`)
    14. ) ENGINE=INNODB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;
    15. /*user是用户表*/
    16. CREATE TABLE `user` (
    17.   `id` INT(11) NOT NULL AUTO_INCREMENT,
    18.   `username` VARCHAR(32) NOT NULL COMMENT '用户名称',
    19.   `birthday` DATE DEFAULT NULL COMMENT '生日',
    20.   `gender` CHAR(1) DEFAULT NULL COMMENT '性别',
    21.   `address` VARCHAR(256) DEFAULT NULL COMMENT '地址',
    22.   PRIMARY KEY (`id`)
    23. ) ENGINE=INNODB AUTO_INCREMENT=27 DEFAULT CHARSET=utf8;
    24. /*orders是订单表*/
    25. CREATE TABLE `orders` (
    26.   `id` INT(11) NOT NULL AUTO_INCREMENT,
    27.   `user_id` INT(11) NOT NULL COMMENT '下单用户id',
    28.   `number` VARCHAR(32) NOT NULL COMMENT '订单号',
    29.   `createtime` DATETIME NOT NULL COMMENT '创建订单时间',
    30.   `note` VARCHAR(100) DEFAULT NULL COMMENT '备注',
    31.   PRIMARY KEY (`id`),
    32.   KEY `FK_orders_1` (`user_id`),
    33.   CONSTRAINT `FK_orders_id` FOREIGN KEY (`user_id`) REFERENCES `user` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION
    34. ) ENGINE=INNODB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;
    35. /*orderdetail是订单明细表*/
    36. DROP TABLE IF EXISTS orderdetail;
    37. CREATE TABLE `orderdetail` (
    38.   `id` INT(11) NOT NULL AUTO_INCREMENT,
    39.   `orders_id` INT(11) NOT NULL COMMENT '订单id',
    40.   `items_id` INT(11) NOT NULL COMMENT '商品id',
    41.   `items_num` INT(11) DEFAULT NULL COMMENT '商品购买数量',
    42.   PRIMARY KEY (`id`),
    43.   KEY `FK_orderdetail_1` (`orders_id`),
    44.   KEY `FK_orderdetail_2` (`items_id`),
    45.   CONSTRAINT `FK_orderdetail_1` FOREIGN KEY (`orders_id`) REFERENCES `orders` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION,
    46.   CONSTRAINT `FK_orderdetail_2` FOREIGN KEY (`items_id`) REFERENCES `items` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION
    47. ) ENGINE=INNODB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8;

    为了测试,我这里随便填了些数据





    2、思路分析


    订单项和订单明细是一对多的关系,所以本文主要来查询订单表,然后关联订单明细表,这样就有一对多的问题出来了。

    因为多对多比较复杂,总公共有四张表,我们先来分析一下思路:

    1、将用户信息映射到User中;

    2、在User类中添加订单列表属性List<Orders>ordersList,将用户创建的订单映射到ordersList中;

    3、在Orders中添加订单明细列表属性List<OrderDetail>orderDetails,将订单的明细映射到orderDetails中;

    4、在OrderDetail中添加Items属性,将订单明细所对应的商品映射到Items中。

    经过这样分析后,感觉虽然有点复杂,但是好像不是很难的样子,映射的方法也跟前面的一样,只不过这里表有点多,关系有点复杂。下面来写映射文件:

    1. <select id="findUserAndItemsResultMap" resultMap="UserAndItemsResultMap">
    2.     SELECT
    3.       orders.*,
    4.       user.`username`,
    5.       user.`sex`,
    6.       user.`address`,
    7.       orderdetail.`id` orderdetail_id,
    8.       orderdetail.`items_id`,
    9.       orderdetail.`items_num`,
    10.       orderdetail.`orders_id`,
    11.       items.`name` items_name,
    12.       items.`detail` items_detail,
    13.       items.`price` items_price
    14.     FROM
    15.       orders,
    16.       USER,
    17.       orderdetail,
    18.       items
    19.     WHERE orders.`user_id`=user.`id` AND orders.`id` = orderdetail.`orders_id` AND orderdetail.`items_id`=items.`id`
    20. </select>

    我们先看一下查询结果:


     

    二、代码实现

    1、四个持久化类

    ① User.java

    1. package com.liuyanzhao.mybatis.po;
    2. import java.util.Date;
    3. import java.util.List;
    4. /**
    5.  * 用户的持久类
    6.  */
    7. public class User {
    8.     private int id; //编号
    9.     private String username; //用户名
    10.     private String gender; //性别
    11.     private Date birthday; //生日
    12.     private String address; //地址
    13.     public List<Orders> getOrdersList() {
    14.         return ordersList;
    15.     }
    16.     public void setOrdersList(List<Orders> ordersList) {
    17.         this.ordersList = ordersList;
    18.     }
    19.     //用户创建的订单列表
    20.     private List<Orders> ordersList;
    21.     public int getId() {
    22.         return id;
    23.     }
    24.     public void setId(int id) {
    25.         this.id = id;
    26.     }
    27.     public String getUsername() {
    28.         return username;
    29.     }
    30.     public void setUsername(String username) {
    31.         this.username = username;
    32.     }
    33.     public String getGender() {
    34.         return gender;
    35.     }
    36.     public void setGender(String gender) {
    37.         this.gender = gender;
    38.     }
    39.     public Date getBirthday() {
    40.         return birthday;
    41.     }
    42.     public void setBirthday(Date birthday) {
    43.         this.birthday = birthday;
    44.     }
    45.     public String getAddress() {
    46.         return address;
    47.     }
    48.     public void setAddress(String address) {
    49.         this.address = address;
    50.     }
    51. }

    注意:需要在用户表中加入 订单列表

     

    ② Items.java

    1. package com.liuyanzhao.mybatis.po;
    2. import java.util.Date;
    3. /**
    4.  * 商品的持久类
    5.  */
    6. public class Items {
    7.     private int id;
    8.     private String name;
    9.     private double price;
    10.     private String detail;
    11.     private String pic;
    12.     private Date createTime;
    13.     public int getId() {
    14.         return id;
    15.     }
    16.     public void setId(int id) {
    17.         this.id = id;
    18.     }
    19.     public String getName() {
    20.         return name;
    21.     }
    22.     public void setName(String name) {
    23.         this.name = name;
    24.     }
    25.     public double getPrice() {
    26.         return price;
    27.     }
    28.     public void setPrice(double price) {
    29.         this.price = price;
    30.     }
    31.     public String getDetail() {
    32.         return detail;
    33.     }
    34.     public void setDetail(String detail) {
    35.         this.detail = detail;
    36.     }
    37.     public String getPic() {
    38.         return pic;
    39.     }
    40.     public void setPic(String pic) {
    41.         this.pic = pic;
    42.     }
    43.     public Date getCreateTime() {
    44.         return createTime;
    45.     }
    46.     public void setCreateTime(Date createTime) {
    47.         this.createTime = createTime;
    48.     }
    49. }

     

    ③ Orders.java

    1. package com.liuyanzhao.mybatis.po;
    2. import java.util.Date;
    3. import java.util.List;
    4. /**
    5.  * 订单的持久类和扩展类
    6.  */
    7. public class Orders {
    8.     private int id;
    9.     private int userId;
    10.     private String number;
    11.     private Date createTime;
    12.     private String note;
    13.     //订单明细
    14.     private List<Orderdetail> orderdetails;
    15.     public List<Orderdetail> getOrderdetails() {
    16.         return orderdetails;
    17.     }
    18.     public void setOrderdetails(List<Orderdetail> orderdetails) {
    19.         this.orderdetails = orderdetails;
    20.     }
    21.     public int getId() {
    22.         return id;
    23.     }
    24.     public void setId(int id) {
    25.         this.id = id;
    26.     }
    27.     public int getUserId() {
    28.         return userId;
    29.     }
    30.     public void setUserId(int userId) {
    31.         this.userId = userId;
    32.     }
    33.     public String getNumber() {
    34.         return number;
    35.     }
    36.     public void setNumber(String number) {
    37.         this.number = number;
    38.     }
    39.     public Date getCreateTime() {
    40.         return createTime;
    41.     }
    42.     public void setCreateTime(Date createTime) {
    43.         this.createTime = createTime;
    44.     }
    45.     public String getNote() {
    46.         return note;
    47.     }
    48.     public void setNote(String note) {
    49.         this.note = note;
    50.     }
    51. }

    注意:订单列表中,需要订单的详细信息,不需要用户信息

     

    ④ Orderdetail.java

    1. package com.liuyanzhao.mybatis.po;
    2. /**
    3.  * 订单明细的持久类
    4.  */
    5. public class Orderdetail {
    6.     private int id;
    7.     private int ordersId;
    8.     private int itemsId;
    9.     private int itemsNum;
    10.     //明细对应的商品信息
    11.     private Items items;
    12.     public Items getItems() {
    13.         return items;
    14.     }
    15.     public void setItems(Items items) {
    16.         this.items = items;
    17.     }
    18.     public int getId() {
    19.         return id;
    20.     }
    21.     public void setId(int id) {
    22.         this.id = id;
    23.     }
    24.     public int getOrdersId() {
    25.         return ordersId;
    26.     }
    27.     public void setOrdersId(int ordersId) {
    28.         this.ordersId = ordersId;
    29.     }
    30.     public int getItemsId() {
    31.         return itemsId;
    32.     }
    33.     public void setItemsId(int itemsId) {
    34.         this.itemsId = itemsId;
    35.     }
    36.     public int getItemsNum() {
    37.         return itemsNum;
    38.     }
    39.     public void setItemsNum(int itemsNum) {
    40.         this.itemsNum = itemsNum;
    41.     }
    42. }

    注意:订单明细里,需要 商品信息

     

    2、订单代理 即mapper.java

    OrdersMapperCustom.java

    1. package com.liuyanzhao.mybatis.mapper;
    2. import com.liuyanzhao.mybatis.po.User;
    3. import java.util.List;
    4. /**
    5.  * 订单 mapper
    6.  */
    7. public interface OrdersMapperCustom {
    8.     //查询用户购买的商品信息
    9.     public List<User> findUserAndItemsResultMap() throws Exception;
    10. }

     

    3、OrdersMapperCustom.xml    映射文件

    1. <?xml version="1.0" encoding="UTF-8" ?>
    2. <!DOCTYPE mapper
    3.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
    4.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    5. <mapper namespace="com.liuyanzhao.mybatis.mapper.OrdersMapperCustom">
    6.     <!--查询用户购买的商品-->
    7.     <resultMap id="UserAndItemsResultMap" type="com.liuyanzhao.mybatis.po.User">
    8.         <!--用户信息-->
    9.         <id column="user_id" property="id"></id>
    10.         <result column="username" property="username"></result>
    11.         <result column="gender" property="gender"></result>
    12.         <result column="address" property="address"></result>
    13.         <!--订单信息-->
    14.         <!--一个用户可以对应多个订单,故使用collection映射-->
    15.         <collection property="ordersList" ofType="com.liuyanzhao.mybatis.po.Orders">
    16.             <id column="id" property="id"></id>
    17.             <result column="user_id" property="userId"></result>
    18.             <result column="number" property="number"></result>
    19.             <result column="createtime" property="createTime"></result>
    20.             <result column="node" property="node"></result>
    21.             <!--订单明细-->
    22.             <!--一个订单包括多个明细,故使用collection-->
    23.             <collection property="orderdetails" ofType="com.liuyanzhao.mybatis.po.Orderdetail">
    24.                 <id column="orderdetail_id" property="id"></id>
    25.                 <result column="items_id" property="itemsId"></result>
    26.                 <result column="items_num" property="itemsNum"></result>
    27.                 <result column="orders_id" property="ordersId"></result>
    28.                 <!--商品信息-->
    29.                 <!--一个订单明细对应一个商品-->
    30.                 <association property="items" javaType="com.liuyanzhao.mybatis.po.Items">
    31.                     <id column="items_id" property="id"></id>
    32.                     <result column="items_name" property="name"></result>
    33.                     <result column="items_price" property="price"></result>
    34.                     <result column="items_detail" property="detail"></result>
    35.                 </association>
    36.             </collection>
    37.         </collection>
    38.     </resultMap>
    39.     <select id="findUserAndItemsResultMap" resultMap="UserAndItemsResultMap">
    40.         SELECT
    41.         orders.*,
    42.         user.username,
    43.         user.gender,
    44.         user.address,
    45.         orderdetail.id orderdetail_id,
    46.         orderdetail.items_id,
    47.         orderdetail.items_num,
    48.         orderdetail.orders_id,
    49.         items.name items_name,
    50.         items.detail items_detail,
    51.         items.price items_price
    52.         FROM
    53.         orders,
    54.         user,
    55.         orderdetail,
    56.         items
    57.         WHERE orders.user_id=user.id AND orders.id = orderdetail.orders_id AND orderdetail.items_id=items.id
    58.     </select>
    59. </mapper>

     

    4、测试类 OrderMapperCustomTest.java

    1. package com.liuyanzhao.mybatis.test;
    2. import com.liuyanzhao.mybatis.mapper.OrdersMapperCustom;
    3. import com.liuyanzhao.mybatis.po.User;
    4. import org.apache.ibatis.io.Resources;
    5. import org.apache.ibatis.session.SqlSession;
    6. import org.apache.ibatis.session.SqlSessionFactory;
    7. import org.apache.ibatis.session.SqlSessionFactoryBuilder;
    8. import org.junit.Before;
    9. import org.junit.Test;
    10. import java.io.InputStream;
    11. import java.util.List;
    12. /**
    13.  * Created by Liu_Yanzhao on 2017/8/12.
    14.  */
    15. public class OrderMapperCustomTest {
    16.     SqlSessionFactory sqlSessionFactory;
    17.     @Before
    18.     public void setUp() throws Exception {
    19.         String resource = "Configuration.xml";
    20.         InputStream inputStream = Resources.getResourceAsStream(resource);
    21.         sqlSessionFactory = new SqlSessionFactoryBuilder()
    22.             .build(inputStream);
    23.     }
    24.     @Test
    25.     public void testFindUserAndItemsResultMap() throws Exception {
    26.         SqlSession sqlSession = sqlSessionFactory.openSession();
    27.         //创建代理对象
    28.         OrdersMapperCustom ordersMapperCustom = sqlSession.getMapper(OrdersMapperCustom.class);
    29.         //调用mapper对象
    30.         List<User> list = ordersMapperCustom.findUserAndItemsResultMap();
    31.         System.out.println(list);
    32.         //释放资源
    33.         sqlSession.close();
    34.     }
    35. }

    还有其他文件就不补充了,如 mybatis 全局配置文件

     

    小结

    这样多对多的映射就搞定了。不过还有个问题,就是这里多对多的查询会把所有关联的表的信息都查询出来,然后放到pojo中的对应的List或者某个类中,所以即使我只查了个用户信息,但是这个用户里包含了订单,订单项,商品等信息,感觉装的有点多,好像有时候并不需要这么多冗余的数据出来,但是如果用resultType的话查询出来的字段必须对应pojo中的属性,如果有List等,需要手动装入才行。所以下面总结一下对于这种查询数据比较多的时候,resultType和resultMap各有什么作用?

    1. 比如我们只需要将查询用户购买的商品信息明细清单(如用户名、用户地址、购买商品名称、购买商品时间、购买商品数量),那么我们完全不需要其他的信息,这个时候就没必要使用resultMap将所有的信息都搞出来,我们可以自己定义一个pojo,包含我们需要的字段即可,然后查询语句只查询我们需要的字段,这样使用resultType会方便很多。
    2. 如果我们需要查询该用户的所有详细信息,比如用户点击该用户或者鼠标放上去,会出来跟该用户相关的订单啊,订单明细啊,商品啊之类的,然后我们要点进去看下详细情况的时候,那就需要使用resultMap了,必须将所有信息都装到这个User中,然后具体啥信息再从User中取,很好理解。
    3. 总结一点:使用resultMap是针对那些对查询结果映射有特殊要求的功能,,比如特殊要求映射成list中包括多个list。否则使用resultType比较直接。

    到这里,mybatis的多对多映射就总结完了。 

     

    参考:传智播客视频

    本文链接:https://liuyanzhao.com/5858.html

    展开全文
  • 一、什么是MyBatis高级映射  mybatis是一个持久层框架,不完全的ORM(对象关系映射)框架。sql语句需要程序员自己去写,都是mybatis也有映射(输入参数映射,输出结果映射)。pojo通过映射数据库字段才能对数据...

    一、什么是MyBatis高级映射

           mybatis是一个持久层框架,不完全的ORM(对象关系映射)框架。sql语句需要程序员自己去写,都是mybatis也有映射(输入参数映射,输出结果映射)。pojo通过映射数据库字段才能对数据进行增删改查操作,让程序员把精力放在写sql语句上,并对sql语句优化非常方便。即mapper.xml(映射文件)。

          1、输入映射:parameterType

                指定输入参数类型可以简单类型、pojjo、hashmap。对应综合查询,建议parameterType使用包装的pojo,有利于系统扩展。

          2、输出映射:

                1)resultType:查询到的列名和resultType指定的pojo的属性名一致,才能映射成功;

                2)resultMap:可以通过resultMap完成一些高级映射。如果查询的的列名和映射的pojo的属性名不一致时,通过resultMap设置列名和属性名之间的对应关系(映射关系),可以完成映射

          3、resultMap元素中,允许有以下直接子元素:

              1)constructor -- 类在实例化时,用来注入结果到构造方法中;作用与result相同,同时可以标识出用这个字段值可以区分其他对象实例。可以理解为数据表中的主键,可以定位数据表中唯一一笔记录;

              2)result -- 将数据表中的字段注入到Java对象属性中;

              3)association -- 关联,简单的讲,就是“有一个”关系,如“用户”有一个“帐号”;

              4)collection -- 集合,顾名思议,就是“有很多”关系,如“用户”有很多“订单”。

    二、为什么用MyBatis高级映射

           在现实的项目中进行数据库建模时,我们要遵循数据库设计范式的要求,会对现实中的业务模型进行拆分,封装在不同的数据表中,表与表之间存在着一对多或是多对多的对应关系。进而,我们对数据库的增删改查操作的主体,也就从单表变成了多表。下面举例说明高级映射:

           1、一个用户可以创建多个订单,一对多;

           2、一个订单只由一个用户创建,一对一 ;

           3、一个订单可以包括多个订单明细,因为一个订单可以购买多个商品,每个商品的购买信息在orderdetail记录,一对多关系

           4、反过来多个订单明细对应一个订单,多对一关系;

           5、多个用户创建多个订单,多对多关系。

    三、一对一映射

            1、pojo类

    public class Order {
        private int id;
        private String name;
        private int number;
        private Account account;
        private List<OrderDetail> orderDetails;
    }

    public class OrderDetail {
        private int id;
        private int orderId;
        private int itemNumber;
        private String name;
    }
    public class Account {
        private String id;
        private String userName;
    }

          2、Mapper映射文件

    <select id="findOrder" resultMap="orderUserMap">
       SELECT
          tto.ID,
          tto.`NAME`,
          tto.NUMBER,
          tu.ID AS UID,
          tu.`NAME` AS USERNAME
       FROM
          t_t_order tto,
          t_user tu
       WHERE
          tu.ID = tto.CREATE_ID
    </select>
    
    <resultMap id="orderUserMap" type="com.fh.entity.Order">
       <id property="id" column="ID"/>
       <result property="name" column="NAME"/>
       <result property="number" column="NUMBER"/>
       <association property="account" javaType="com.fh.entity.Account">
          <id property="id" column="UID"/>
          <result property="userName" column="USERNAME"/>
       </association>
    </resultMap>

    四、一对多映射

           1、非继承Mapper文件

    <resultMap id="orderDetailMap" type="com.fh.entity.Order">
       <id property="id" column="ID"/>
       <result property="name" column="NAME"/>
       <result property="number" column="NUMBER"/>
       <association property="account" javaType="com.fh.entity.Account">
          <id property="id" column="UID"/>
          <result property="userName" column="USERNAME"/>
       </association>
       <collection property="orderDetails" ofType="com.fh.entity.OrderDetail">
          <id property="id" column="DID"/>
          <result property="orderId" column="ORDER_ID"/>
          <result property="itemNumber" column="ITEM_NUMBER"/>
          <result property="name" column="DNAME"/>
       </collection>
    </resultMap>

           2、继承Mapper文件

    <resultMap id="orderDetailMapExtends" type="com.fh.entity.Order" extends="orderUserMap">
       <collection property="orderDetails" ofType="com.fh.entity.OrderDetail">
          <id property="id" column="DID"/>
          <result property="orderId" column="ORDER_ID"/>
          <result property="itemNumber" column="ITEM_NUMBER"/>
          <result property="name" column="DNAME"/>
       </collection>
    </resultMap>

    五、多对多映射

    <resultMap id="userOrder" type="com.fh.entity.Account">
       <id property="id" column="ID"/>
       <result property="userName" column="USERNAME"/>
       <collection property="orders" ofType="com.fh.entity.Order">
          <id property="id" column="ORDER_ID"/>
          <result property="name" column="NAME"/>
          <result property="number" column="NUMBER"/>
          <collection property="orderDetails" ofType="com.fh.entity.OrderDetail">
             <id property="id" column="DID"/>
             <result property="name" column="DNAME"/>
             <result property="itemNumber" column="ITEM_NUMBER"/>
          </collection>
       </collection>
    </resultMap>
    
    <select id="findUserOrder" resultMap="userOrder">
       SELECT
          tr.ID AS ORDER_ID,
          tr.`NAME`,
          tr.NUMBER,
          tod.ID AS DID,
          tod.ITEM_NUMBER,
          tod.`NAME` AS DNAME,
          tu.ID,
          tu.`NAME` AS USERNAME
       FROM
          t_t_order tr,
          t_t_order_detail tod,
          t_user tu
       WHERE
          tod.ORDER_ID = tr.ID
       AND tu.ID = tr.CREATE_ID
    </select>

     

    展开全文
  • mybatis 高级映射和spring整合之mybatis与Spring整合3.0 mybatis和spring整合(掌握) 3.1 整合思路 需求spring通过单例方式管理SqlSessionFactory。 spring和mybatis整合生成代理对象,使用SqlSessionFactory...
  • mybatis 高级映射和spring整合之逆向工程(7)4.0 逆向工程 4.1 mybatis需要程序员自己编写sql语句,mybatis官方提供逆向工程,可以针对单表自动生成mybatis执行所需的代码(mapper.java,mapper.xml,po..) 企业...
  • mybatis 高级映射和spring整合之查询缓存(5)2.0 查询缓存 2.0.1 什么是查询缓存 mybatis提供缓存,用于减轻数据压力,提高数据库性能。 mybatis提供一级缓存和二级缓存。 一级缓存是SqlSession级别的缓存: 在...
  • Java EE数据持久化框架 • 【第3章 MyBatis高级映射

    万次阅读 多人点赞 2021-04-20 11:23:49
    3.1 一对一映射 3.1.1 自动化一对一映射 3.1.2 标签配置一对一映射 3.1.3 标签配置一对一映射 3.1.4 实践练习 3.2 一对一映射中的嵌套查询 3.2.1 标签嵌套查询属性 3.2.2 标签嵌套查询实现 3.2.3 实践练习 ...
  • --高级映射需要配置resultMap,值为resultMap的id--> <!--根据用户查询所有订单条系--> SELECT c.cartItemId, c.quantity, b.bname, b.image_b, b.currPrice, u.loginname FROM t_cartitem c LEFT JOIN ...
  • mybatis高级映射总结

    千次阅读 2016-07-03 10:22:27
    使用 association 和 collection 完成一对一和一对多高级映射(对结果有特殊的映射要求)。 association : 作用:将关联查询信息映射到一个pojo对象中。 场合: 为了方便查询关联信息可以使用 ...
  • mybatis 高级映射,关联嵌套配置

    千次阅读 2018-07-02 23:38:36
    这里使用的是xml方式编写,提供两种方式进行映射封装数据 mybatis 基本表字段xml配置文件编写 用sql标签编写,不废话直接上代码 &lt;mapper namespace="baseCoulmnSpace"&gt; &lt;!-- 多...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 21,230
精华内容 8,492
关键字:

mybatis高级映射