精华内容
下载资源
问答
  • MyBatis 一对多嵌套查询

    千次阅读 2021-01-15 13:49:51
    标题MyBatis 一对多结果集嵌套查询 嵌套查询的实现原理为两次查询,比如产品表为主表,图片表为从表通过product_id字段与产品表id字段关联实现一对多嵌套查询查询两次 首先查询 主表的数据 然后将主表id字段赋值给...

    MyBatis 一对多结果集嵌套查询

    嵌套查询的实现原理为两次查询,比如产品表为主表图片表为从表通过product_id字段与产品表id字段关联实现一对多,嵌套查询 首先查询 主表的数据 然后将主表id字段赋值给从表实体类中product_id 字段(productId)然后通过dao接口路径映射找到对应的MyBatis XMl文件SQL语句ID如:com.liao.dao.DImgMapper.selectDImgByProductId 进行子查询也就是第二次查询。然后返回数据

    数据库建表语句和测试数据如下:

    数据库版本为 MySQL 8.0

    产品表

    DROP TABLE IF EXISTS `d_product`;
    CREATE TABLE `d_product`  (
      `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '产品ID',
      `product_name` varchar(255) CHARACTER SET utf8 COLLATE utf8_bin NULL DEFAULT NULL COMMENT '产品名称',
      `product_introduction` text CHARACTER SET utf8 COLLATE utf8_bin NULL COMMENT '产品介绍',
      `product_category` int(11) NULL DEFAULT NULL COMMENT '产品ID',
      `product_status` int(1) NULL DEFAULT NULL COMMENT '产品状态',
      `create_time` datetime(0) NULL DEFAULT NULL COMMENT '创建时间',
      PRIMARY KEY (`id`) USING BTREE
    ) ENGINE = InnoDB AUTO_INCREMENT = 18 CHARACTER SET = utf8 COLLATE = utf8_bin COMMENT = '产品表' ROW_FORMAT = Dynamic;
    
    INSERT INTO `d_product` VALUES (1, '测试产品名称修改', '测试产品介绍修改', NULL, 1, '2020-02-02 12:40:06');
    INSERT INTO `d_product` VALUES (2, '产品名称', '产品介绍', NULL, 1, '2020-03-02 18:15:07');
    INSERT INTO `d_product` VALUES (3, 'bbb', 'bbb', NULL, 1, '2020-03-01 22:18:40');
    

    图片表

    DROP TABLE IF EXISTS `d_img`;
    CREATE TABLE `d_img`  (
      `id` int(11) NOT NULL AUTO_INCREMENT COMMENT 'id',
      `product_id` int(11) NULL DEFAULT NULL COMMENT '产品图片ID',
      `img` varchar(500) CHARACTER SET utf8 COLLATE utf8_bin NULL DEFAULT NULL COMMENT '图片',
      `create_time` datetime(0) NULL DEFAULT NULL COMMENT '创建时间',
      PRIMARY KEY (`id`) USING BTREE,
      INDEX `product_id`(`product_id`) USING BTREE,
      CONSTRAINT `d_img_ibfk_1` FOREIGN KEY (`product_id`) REFERENCES `d_product` (`id`) ON DELETE RESTRICT ON UPDATE RESTRICT
    ) ENGINE = InnoDB AUTO_INCREMENT = 86 CHARACTER SET = utf8 COLLATE = utf8_bin COMMENT = '产品图片' ROW_FORMAT = Dynamic;
    
    INSERT INTO `d_img` VALUES (40, 1, '1491803633034_683819.jpg', '2020-03-03 17:21:20');
    INSERT INTO `d_img` VALUES (40, 1, '1491803633034_683819.jpg', '2020-03-03 17:21:20');
    INSERT INTO `d_img` VALUES (41, 1, '1568950881751_702421.jpg', '2020-03-03 17:21:20');
    

    Java实体类:

    // 将这个注解写在类上之后,就会忽略类中不存在的字段,否则可能会报错
    @JsonIgnoreProperties(value = {"handler"})
    /**
     * 
     * TODO: 产品类
     * @author LiAo
     * @date 2020/5/20 17:04
     */
    public class DProduct {
        private Integer id;
    
        private String productName;
    
        private Integer productCategory;
    
        private Integer productStatus;
    
        private Date createTime;
    
        private String productIntroduction;
    
        private List<DImg> dImgs;     // 用于存放图片集合
        
        // .. get set toString
    }
        
    /**
     * 
     * TODO: 产品图片类
     * @author LiAo
     * @date 2020/5/20 17:05
     */
    @JsonIgnoreProperties(value = {"handler"})
    public class DImg {
        private Integer id;
    
        private Integer productId;
    
        private String img;
    
        private Date createTime;
        
        // .. get set toString
    }
    

    实体类创建好后要编写Dao接口 和Mapper XML了

    持久层接口DAO:

    /**
     *
     * TODO: 产品 Dao接口
     * @author LiAo
     * @date 2020/5/20 17:08
     */
    public interface DProductMapper {
        /**
         * 产品图片一对多嵌套
         * @param record 查询条件
         * @return 返回参数
         */
        List<DProduct> productSelect(DProduct record);
    }
    

    产品MyBatis xml:

    <!--映射的Dao接口类 可以通过这个路径找到先关的SQL语句和resultMap 映射-->
    <mapper namespace="com.liao.dao.DProductMapper">
        <resultMap id="BaseResultMap" type="com.liao.entity.DProduct">
            <id column="id" property="id" jdbcType="INTEGER"/>
            <result column="product_name" property="productName" jdbcType="VARCHAR"/>
            <result column="product_category" property="productCategory" jdbcType="INTEGER"/>
            <result column="product_status" property="productStatus" jdbcType="INTEGER"/>
            <result column="create_time" property="createTime" jdbcType="TIMESTAMP"/>
            <result column="product_introduction" property="productIntroduction" jdbcType="LONGVARCHAR"/>
        </resultMap>
        <!--产品图片一对多查询映射-->
        <!--id:配置映射的名称-->
        <!--type:返回值类型 -->
        <!--extends:继承id为BaseResultMap的映射 -->
        <!--select:子查询所在的XML绑定的DAO接口路径.SQL语句id -->
        <!--column="{productId = id} productId:从表关联主表的实体类属性,作为子查询的条件  id:主表中被关联的数据库字段-->
        <resultMap id="dProductResultMap" type="com.liao.entity.DProduct" extends="BaseResultMap">
            <collection property="dImgs" fetchType="lazy"
                        select="com.liao.dao.DImgMapper.selectDImgByProductId" column="{productId = id}"/>
        </resultMap>
        
        <!--查询语句-->
        <select id="productSelect" parameterType="com.liao.entity.DProduct" resultMap="dProductListMapSelect">
        select
        d.id,
        d.product_name,
        d.product_category,
        d.product_status,
        d.create_time,
        d.product_introduction
        from d_product d
        where 1 = 1
        <!-- 使用if标签拼接条件语句 实现动态SQL-->
        <if test="id != null and id != ''">
            and d.id = #{id}
        </if>
        <if test="productName != null and productName != ''">
            and d.product_name like concat(#{productName},'%')
        </if>
        <if test="productStatus != null and productStatus != ''">
            and d.product_status = #{productStatus}
        </if>
        <if test="createTime != null and createTime != ''">
            and d.create_time like concat(#{createTime},'%')
        </if>
        <if test="productIntroduction != null and productIntroduction != ''">
            and d.product_introduction like concat(#{productIntroduction},'%')
        </if>
    </select>
    </mapper>
    

    图片MyBatis xml:

    <mapper namespace="com.liao.dao.DImgMapper">
        <resultMap id="BaseResultMap" type="com.liao.entity.DImg">
            <id column="did" property="id" jdbcType="INTEGER"/>
            <result column="product_id" property="productId" jdbcType="INTEGER"/>
            <result column="img" property="img" jdbcType="VARCHAR"/>
            <result column="create_time" property="createTime" jdbcType="TIMESTAMP"/>
        </resultMap>
        <!--一对多嵌套查询 子查询语句-->
        <select id="selectDImgByProductId" resultMap="BaseResultMap">
            select i.id as did,
                   i.product_id,
                   i.img,
                   i.create_time
            from d_img i
            where i.product_id = #{productId}
        </select>
    </mapper>
    

    测试查询结果
    查询结果为一个产品对象里有若干个产品图片对象。

     			{
     				"id": 18,
                    "productName": "产品添加图片上传测试",
                    "productCategory": null,
                    "productStatus": 1,
                    "createTime": "2020-04-14T13:40:40.000+0000",
                    "productIntroduction": "产品添加图片上传测试",
                    "dImgs": [
                        {
                            "id": 92,
                            "productId": 18,
                            "img": "01.jpg",
                            "createTime": "2020-04-26T02:33:04.000+0000"
                        },
                        {
                            "id": 93,
                            "productId": 18,
                            "img": "1554103835292_610234.jpg",
                            "createTime": "2020-04-26T02:33:04.000+0000"
                        },
                        {
                            "id": 94,
                            "productId": 18,
                            "img": "1555484699771_582172.jpg",
                            "createTime": "2020-04-26T02:33:04.000+0000"
                        },
                        {
                            "id": 95,
                            "productId": 18,
                            "img": "1554103835292_610234.jpg",
                            "createTime": "2020-04-26T02:33:04.000+0000"
                        }
                    ]
                },
    
    展开全文
  • mybatis一对多嵌套查询: 嵌套查询特点:发送1+n条sql语句 步骤: 新建domain类: 数据库设计: 定义一个domainMapper接口: 新建一个domainMapper.xml文件 本例中为DepartmentMapper.xml: &lt;?xml version=...

    mybatis一对多嵌套查询:
    嵌套查询特点:发送1+n条sql语句
    在这里插入图片描述在这里插入图片描述
    步骤:
    新建domain类:
    在这里插入图片描述在这里插入图片描述数据库设计:
    在这里插入图片描述
    在这里插入图片描述定义一个domainMapper接口:
    在这里插入图片描述新建一个domainMapper.xml文件 本例中为DepartmentMapper.xml:

    <?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">
    <!--
    namespace:命名空间 -> 要求:一个项目中命名空间必须唯一;
    -->
    <mapper namespace="cn.itsource.mybatis.onetomany01.DepartmentMapper">
        <!--
          select:标签名字:  CRUD的时候对应的名字
          id:这个语句的唯一标识;   【必须和接口的方法名字一样】;
          parameterType:传入参数类型
          resultType:返回值类型
          #{id}:参数的接收
          List<Employee> findAll();
        -->
        <select id="findAll" resultMap="DepartmentMap">
            select * from department
        </select>
        <!-- private Long id;
        private String name;
        private List<Employee> list = new ArrayList<>();
    -->
        <resultMap id="DepartmentMap" type="cn.itsource.mybatis.onetomany01.Department">
    
            <id column="id" property="id"/>
            <result column="name" property="name"/>
    
            <!--
                当关联的对象是一个集合的时候,用collection
                property: 表示domain类中对应的集合的字段值
                javaType: 表示该字段的类型
                ofType:    表示此集合中所存储的对应的类型
            -->
            <collection property="list"
                        javaType="list"
                        ofType="cn.itsource.mybatis.onetomany01.Employee"
                        select="findOneById"
                        column="id"
                        >
            </collection>
            
        </resultMap>
        <select id="findOneById" resultType="cn.itsource.mybatis.onetomany01.Employee">
            select * from employee where dept_id=#{id}
        </select>
    
    </mapper>
    

    在DepartmentMapper.xml中的注意事项:
    在这里插入图片描述最后注意在 mybatis的主配置文件中引入 DepartmentMapper.xml的路径
    在这里插入图片描述
    注意连接数据库和mybatis主配置文件和自定义mybatis工具类步骤省略,详细步骤请看 mybatis学习笔记01
    测试:
    在这里插入图片描述测试结果:
    在这里插入图片描述

    展开全文
  • 图片表为从表通过product_id字段与产品表id字段关联实现一对多嵌套查询 首先查询 主表的数据 然后将主表id字段赋值给从表实体类中product_id 字段(productId)然后通过dao接口路径映射找到对应的MyBatis XMl文件SQL...

    前言

    嵌套查询的实现原理为两次查询,比如产品表为主表,图片表为从表通过product_id字段与产品表id字段关联实现一对多,嵌套查询 首先查询 主表的数据 然后将主表id字段赋值给从表实体类中product_id 字段(productId)然后通过dao接口路径映射找到对应的MyBatis XMl文件SQL语句ID如:com.liao.dao.DImgMapper.selectDImgByProductId 进行子查询也就是第二次查询。然后返回数据

    数据库建表语句和测试数据如下:

    数据库版本为 MySQL 8.0

    产品表

    DROP TABLE IF EXISTS `d_product`;

    CREATE TABLE `d_product` (

    `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '产品ID',

    `product_name` varchar(255) CHARACTER SET utf8 COLLATE utf8_bin NULL DEFAULT NULL COMMENT '产品名称',

    `product_introduction` text CHARACTER SET utf8 COLLATE utf8_bin NULL COMMENT '产品介绍',

    `product_category` int(11) NULL DEFAULT NULL COMMENT '产品ID',

    `product_status` int(1) NULL DEFAULT NULL COMMENT '产品状态',

    `create_time` datetime(0) NULL DEFAULT NULL COMMENT '创建时间',

    PRIMARY KEY (`id`) USING BTREE

    ) ENGINE = InnoDB AUTO_INCREMENT = 18 CHARACTER SET = utf8 COLLATE = utf8_bin COMMENT = '产品表' ROW_FORMAT = Dynamic;

    INSERT INTO `d_product` VALUES (1, '测试产品名称修改', '测试产品介绍修改', NULL, 1, '2020-02-02 12:40:06');

    INSERT INTO `d_product` VALUES (2, '产品名称', '产品介绍', NULL, 1, '2020-03-02 18:15:07');

    INSERT INTO `d_product` VALUES (3, 'bbb', 'bbb', NULL, 1, '2020-03-01 22:18:40');

    图片表

    DROP TABLE IF EXISTS `d_img`;

    CREATE TABLE `d_img` (

    `id` int(11) NOT NULL AUTO_INCREMENT COMMENT 'id',

    `product_id` int(11) NULL DEFAULT NULL COMMENT '产品图片ID',

    `img` varchar(500) CHARACTER SET utf8 COLLATE utf8_bin NULL DEFAULT NULL COMMENT '图片',

    `create_time` datetime(0) NULL DEFAULT NULL COMMENT '创建时间',

    PRIMARY KEY (`id`) USING BTREE,

    INDEX `product_id`(`product_id`) USING BTREE,

    CONSTRAINT `d_img_ibfk_1` FOREIGN KEY (`product_id`) REFERENCES `d_product` (`id`) ON DELETE RESTRICT ON UPDATE RESTRICT

    ) ENGINE = InnoDB AUTO_INCREMENT = 86 CHARACTER SET = utf8 COLLATE = utf8_bin COMMENT = '产品图片' ROW_FORMAT = Dynamic;

    INSERT INTO `d_img` VALUES (40, 1, '1491803633034_683819.jpg', '2020-03-03 17:21:20');

    INSERT INTO `d_img` VALUES (40, 1, '1491803633034_683819.jpg', '2020-03-03 17:21:20');

    INSERT INTO `d_img` VALUES (41, 1, '1568950881751_702421.jpg', '2020-03-03 17:21:20');

    Java实体类:

    // 将这个注解写在类上之后,就会忽略类中不存在的字段,否则可能会报错

    @JsonIgnoreProperties(value = {"handler"})

    /**

    *

    * TODO: 产品类

    * @author LiAo

    * @date 2020/5/20 17:04

    */

    public class DProduct {

    private Integer id;

    private String productName;

    private Integer productCategory;

    private Integer productStatus;

    private Date createTime;

    private String productIntroduction;

    private List dImgs; // 用于存放图片集合

    // .. get set toString

    }

    /**

    *

    * TODO: 产品图片类

    * @author LiAo

    * @date 2020/5/20 17:05

    */

    @JsonIgnoreProperties(value = {"handler"})

    public class DImg {

    private Integer id;

    private Integer productId;

    private String img;

    private Date createTime;

    // .. get set toString

    }

    实体类创建好后要编写Dao接口 和Mapper XML了

    持久层接口DAO:

    /**

    *

    * TODO: 产品 Dao接口

    * @author LiAo

    * @date 2020/5/20 17:08

    */

    public interface DProductMapper {

    /**

    * 产品图片一对多嵌套

    * @param record 查询条件

    * @return 返回参数

    */

    List productSelect(DProduct record);

    }

    产品MyBatis xml:

    select="com.liao.dao.DImgMapper.selectDImgByProductId" column="{productId = id}"/>

    select

    d.id,

    d.product_name,

    d.product_category,

    d.product_status,

    d.create_time,

    d.product_introduction

    from d_product d

    where 1 = 1

    and d.id = #{id}

    and d.product_name like concat(#{productName},'%')

    and d.product_status = #{productStatus}

    and d.create_time like concat(#{createTime},'%')

    and d.product_introduction like concat(#{productIntroduction},'%')

    图片MyBatis xml:

    select i.id as did,

    i.product_id,

    i.img,

    i.create_time

    from d_img i

    where i.product_id = #{productId}

    测试查询结果

    查询结果为一个产品对象里有若干个产品图片对象。

    {

    "id": 18,

    "productName": "产品添加图片上传测试",

    "productCategory": null,

    "productStatus": 1,

    "createTime": "2020-04-14T13:40:40.000+0000",

    "productIntroduction": "产品添加图片上传测试",

    "dImgs": [

    {

    "id": 92,

    "productId": 18,

    "img": "01.jpg",

    "createTime": "2020-04-26T02:33:04.000+0000"

    },

    {

    "id": 93,

    "productId": 18,

    "img": "1554103835292_610234.jpg",

    "createTime": "2020-04-26T02:33:04.000+0000"

    },

    {

    "id": 94,

    "productId": 18,

    "img": "1555484699771_582172.jpg",

    "createTime": "2020-04-26T02:33:04.000+0000"

    },

    {

    "id": 95,

    "productId": 18,

    "img": "1554103835292_610234.jpg",

    "createTime": "2020-04-26T02:33:04.000+0000"

    }

    ]

    },

    总结

    到此这篇关于MyBatis一对多嵌套查询的文章就介绍到这了,更多相关MyBatis一对多嵌套查询内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!

    展开全文
  • Mybatis一对多嵌套查询和分页

    千次阅读 2019-09-06 21:04:17
    文章目录定义模型方式1:结果查询方式2:嵌套查询todo 需求:根据分类ID查询分类下所属的商品集合,每个商品又有个图片集合。 类似的需求有很,比如经典的个用户有N个角色,个角色有N个权限,那么通过用户的...


    需求:根据分类ID查询分类下所属的商品集合,每个商品又有一个图片集合。

    类似的需求有很多,比如经典的一个用户有N个角色,一个角色有N个权限,那么通过用户的id来查询角色和权限数据等等。

    至于分页插件,无论是Mybatis-PageHelper还是Mybatis-Plus都可以辅助,这里主要记录不同查询方式对分页的影响。

    先展示结果:

    {
        "code": 0,
        "msg": "success",
        "data": {
            "total": 9,
            "size": 2,
            "pages": 5,
            "current": 1,
            "records": [
                {
                    "id": 1,
                    "code": "1410854032",
                    "name": "Esmeralda Kilback",
                    "categoryId": "1",
                    "originPrice": 359,
                    "price": 103,
                    "sales": 299,
                    "commentCount": 0,
                    "freight": 1,
                    "detail": "这里是商品详情",
                    "createdAt": "2018-04-09 18:52:05",
                    "updatedAt": "2018-04-24 23:41:49",
                    "images": [
                        {
                            "id": 40,
                            "productId": "1",
                            "link": "uploads/product/201804/18/78a6e4e4d73bfc64b7aef88a90e7f192.png",
                            "createdAt": "2018-04-09 18:52:05",
                            "updatedAt": "2018-04-18 16:37:09"
                        },
                        {
                            "id": 41,
                            "productId": "1",
                            "link": "uploads/product/201804/18/fffdccaa36a8475ed3d2c71c2f43cb86.png",
                            "createdAt": "2018-04-09 18:52:05",
                            "updatedAt": "2018-04-18 16:37:09"
                        },
                        {
                            "id": 301,
                            "productId": "1",
                            "link": "uploads/product/201804/18/68b18cbcb090a94123abd9d729528370.png",
                            "createdAt": "2018-04-18 16:35:56",
                            "updatedAt": "2018-04-18 16:35:56"
                        }
                    ]
                },
                {
                    "id": 8,
                    "code": "1925117917",
                    "name": "Edgardo Osinski",
                    "categoryId": "1",
                    "originPrice": 389,
                    "price": 154,
                    "sales": 199,
                    "commentCount": 0,
                    "freight": 14,
                    "detail": "这里是商品详情...5052 Kyler Walk Suite 921",
                    "createdAt": "2018-04-09 18:52:05",
                    "updatedAt": "2018-04-09 18:52:05",
                    "images": [
                        {
                            "id": 58,
                            "productId": "8",
                            "link": "uploads/default.png",
                            "createdAt": "2018-04-09 18:52:05",
                            "updatedAt": "2018-04-09 18:52:05"
                        },
                        {
                            "id": 59,
                            "productId": "8",
                            "link": "uploads/default2.png",
                            "createdAt": "2018-04-09 18:52:05",
                            "updatedAt": "2018-04-09 18:52:05"
                        },
                        {
                            "id": 60,
                            "productId": "8",
                            "link": "uploads/default3.png",
                            "createdAt": "2018-04-09 18:52:05",
                            "updatedAt": "2018-04-09 18:52:05"
                        }
                    ]
                }
            ]
        }
    }
    
    

    定义模型

    Product用于数据库映射,为了保持其简洁,其他的二次封装不在Product里进行,而用继承的方式。

    定义模型ProductVo

    @Data
    public class ProductVo extends Product {
    
        private List<ProductImage> images;
    }
    
    

    方式1:结果查询

    1. 在ProductsMapper.xml中定义select语句,一次性将关联数据全部查询出来,然后进行结果映射
        <select id="selectProductsBycategoryId"  resultMap="productsListMap">
            select
                p.id,
                p.name,
                p.code,
                ...
                i.id images_id,
                i.product_id images_product_id,
                ...
            from products p
            inner join product_images i on p.id = i.product_id
            where p.category_id = #{id}
        </select>
    
    1. 定义productsListMap结果映射
        <resultMap id="productsListMap" type="com.longke.mallb2c.entity.vo.ProductVo" extends="BaseResultMap">-->
            <collection property="images" columnPrefix="images_" resultMap="com.longke.mallb2c.mapper.ProductImagesMapper.BaseResultMap"/>
        </resultMap>
    
    

    注意:

    • property就是在ProductVo中定义的商品图片集合images字段
    • 用到了columnPrefix列前缀,只是别名前缀,跟数据库内的字段无关,这个images_别名前缀跟select中定义别名时要保持一致。
    • 用到了extends继承已有的BaseResultMap,不用在这里再重新写Product表的每个字段的映射了。mapper.xml自动生成工具都会帮我们生成这个BaseResultMap,直接继承即可。
    • collection用于一对多查询,查询的结果映射直接复用ProductImagesMapper中定义的BaseResultMap

    总结

    优点

    • 一次性查询,集中映射,简单,效率

    缺点

    • 会将collection中查询到的条数作为分页的约束条件,导致分页数据不准确。

    比如想查page=1,limit=10的数据,本来期望的是查询出10个商品,然后这10个商品分别再嵌套查询出自己的商品图片集合。但是会发现,可能商品只有两三个,每个下面都带了自己的商品图片集合。

    原因:

    先通过表连接把表记录关联进来了,如果有3个商品,关联图片表之后每个商品有4条图片记录,那么其实这时候虽然只有三个商品,但是这个内存中的临时表已经有12条记录了,在语句的最后加上 limit 0,10,其实分页的时候分的是这12条记录。最终就会导致最终的映射结果只出现了3个商品,而非我们期望的10个商品。

    方式2:嵌套查询

    1. 在ProductsMapper.xml中定义select语句
       <select id="selectProductsBycategoryId"  resultMap="productsListMap">
            select <include refid="Base_Column_List"/>
            from products
            where category_id = #{id}
        </select>
    
    1. 定义productsListMap结果映射
        <resultMap id="productsListMap" type="com.longke.mallb2c.entity.vo.ProductVo" extends="BaseResultMap">
            <collection property="images"  ofType="com.longke.mallb2c.entity.ProductImage"
                        column="{productId=id}" select="com.longke.mallb2c.mapper.ProductImagesMapper.selectByProductId">
            </collection>
        </resultMap>
    
    

    注意:

    • column是参数传递,即将Product的哪个属性传递给嵌套的查询语句,{productId=id}代表将Product的id属性传递给参数productId
    • select直接使用ProductImagesMapper中定义的select语句
    1. ProductImagesMapper定义selectByProductId查询语句
        <select id="selectByProductId" resultMap="BaseResultMap">
            SELECT <include refid="Base_Column_List"/>
            from product_images
            where product_id = #{productId}
        </select>
    

    总结

    优点

    • 准确分页

    缺点

    • 没有解决N+1的问题,多条SQL查询语句,效率太差

    todo

    使用方式1结果查询,并完成准确分页。

    感谢:

    https://blog.csdn.net/isea533/article/details/28921533

    https://blog.csdn.net/baidu_38116275/article/details/78622669

    展开全文
  • Mybatis的多对一和一对多嵌套查询

    千次阅读 2020-11-24 11:01:14
    嵌套查询建表多对一一对多 建表 CREATE TABLE `teacher` ( `id` INT(10) NOT NULL, `name` VARCHAR(30) DEFAULT NULL, PRIMARY KEY (`id`) ) ENGINE=INNODB DEFAULT CHARSET=utf8 INSERT INTO teacher(`id`, `name`...
  • mybatis一对多嵌套查询: 嵌套查询特点:发送1+n条sql语句 步骤: 新建domain类:数据库设计:定义一个domainMapper接口:新建一个domainMapper.xml文件 本例中为DepartmentMapper.xml: <?xml version="1.0" ...
  • 今天在做项目的时候有个地方需要用到嵌套查询,之前实现过类似的功能,但是在某些地方看到过类似的实现思路,自己试着实现了下发现行得通,于是就有了本文 首先是数据库,在这里我新建了两张表,一张用户表,一张...
  • `一个用户有多个商品 每个商品有又绑定了很多的评论 基于 idea 的springboot、mybatis...因为是一对多 所有要写成List debug一下 看下数据结构 list里面有一个用户 用户里面有多个good 每个good里面有多个remark ...
  • 有时候数据库的某个字段可能是多个id或多个值,这个时候我们想拿到里面的所有值并且映射到对应实体集合里应该怎么做呢? 例子 mapper文件中 <resultMap id=...//确定映射关系一对多 <id property=...
  • Mybatis left join 一对一、一对多、多对多查询 <!-- 一对一查询 ,一个订单对应一个用户--> <resultMap type="com.Orders" id="OrdersUserResultMap"> <id column="id" property="id"/> <...
  • mybatis一对多嵌套结果: 一对多嵌套结果的特点:只发送一条sql语句 步骤: 新建domain类: 数据库设计: 新建domainMapper接口:在本例中为DepartmentMapper 新建domainMapper.xml在本例中为:DepartmentMapper....
  • Mybatis多表查询嵌套查询

    千次阅读 2020-09-07 12:28:47
    嵌套查询 延迟(懒)加载【了解】 内置缓存【了解】 级缓存 二级缓存 第Mybatis动态SQL1 什么是动态SQL先来看个需求 把页面输入的id和username封装到User实体中,并作为条件查询数据库 这个...
  • 复杂环境(一对多,多对一)实现 一对多 多对一 多个学生和一个老师的问题 不同的角度分析问题, 对于学生而言,关联,多个学生关联一个老师(多对一) 对于老师而言,集合,一个老师,有多个学生(一对多 )...
  • 一对多分页处理示例: SELECT FROM insurance_product pro LEFT JOIN insurance_clause cla ON pro.id = cla.product_id pro.id IN (SELECT ip.id FROM ( SELECT id FROM insurance_product WHERE 1 = 1 AND id IN ...
  • 用的是window上面的画图板,没法以文字的方式展示出来,见谅 嵌套查询 嵌套结果
  • 在实际的开发中,数据库的操作常常会涉及张表,这在面向对象中就涉及了对象与对象之间的关联关系 针对表之间的操作, MyBatis 提供了关联映射,通过关联映射就可以很好地处理对象与对象间的关联关系 ...
  • 这是mybatis的官方例子,基本上看遍就会了,一定要先去看官方例子,这里介绍的不详细 http://www.mybatis.org/mybatis-3/zh/sqlmap-xml.html#select 我自己用的联表查询 实体类 public class ...
  • myBatis 实现一对一有几种方式?具体怎么操作的? 有联合查询和嵌套查询: 联合查询是几个表联合查询,只查询一次,通过在 resultMap里面配置 association 节点配置一 对一的类就可以完成; 嵌套查询是先查一个表,...
  • mybatis 一对多查询 按结果嵌套处理、按查询嵌套处理 最近用到一对多查询,记录一下 实体类 public class RegionEntity implements Serializable { private Long rid; private String regionName; private String ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 17,909
精华内容 7,163
关键字:

mybatis一对多嵌套查询

友情链接: rs485.rar