MyBatis之一对一和一对多及分页问题，实现文章列表+分类列表+标签列表+用户的关联查询

avatar 2019年06月21日21:35:01 6 7263 views
博主分享免费Java教学视频，B站账号：Java刘哥
本文主要介绍 MyBatis 一对一和一对多相关使用，还有就是分页的简单介绍。

一、背景

之前我在做文章列表，如下图1这种后台文章列表的时候，通常都是从数据库将文章表查出来，然后遍历往文章列表里填用户信息、分类列表信息、标签信息

图1 文章后台图示例图

代码 实现如下

  1. for (Post p : page.getRecords()) {
  2.     //封装分类，标签，用户详细信息
  3.     List<Category> categories = categoryService.findByPostId(p.getId());
  4.     List<Tag> tags = tagService.findByPostId(p.getId());
  5.     User user = userService.get(p.getId());
  6.     p.setCategories(categories);
  7.     p.setTags(tags);
  8.     p.setUser(user);
  9. }
我们发现这种写法，如果按照一页显示10篇文章，需要查询数据库(在不用redis缓存情况下) 1+10+10+10 = 31 次，这个消耗是很多的，光数据库往返消耗就不少。 基于上面的痛点，我们不得不考虑减少数据库查询，即便是关联查询需要关联5张表，一条SQL语句需要查询6张表，我们也要考虑一下。 just do it！  

二、文章、分类、标签和用户的关系

一篇文章通常只有一个用户，多个分类，多个标签。 直接用 navicat 查看几张表的结构，从左到右，自上而下分别是 用户表、文章表、分类表、标签表、文章和标签关联表、文章和分类关联表   文章实体类 Post.java
  1. package com.liuyanzhao.sens.modules.blog.entity;
  3. import com.baomidou.mybatisplus.annotations.TableField;
  4. import com.baomidou.mybatisplus.annotations.TableId;
  5. import com.baomidou.mybatisplus.annotations.TableName;
  6. import com.fasterxml.jackson.annotation.JsonFormat;
  7. import com.liuyanzhao.sens.common.constant.CommonConstant;
  8. import com.liuyanzhao.sens.common.utils.SnowFlakeUtil;
  9. import lombok.Data;
  10. import org.springframework.format.annotation.DateTimeFormat;
  12. import java.util.Date;
  13. import java.util.List;
  15. /**
  16.  * @author 言曌
  17.  */
  18. @Data
  19. @TableName("t_blog_post")
  20. public class Post {
  22.     private static final long serialVersionUID = 1L;
  24.     @TableId
  25.     private String id = String.valueOf(SnowFlakeUtil.getFlowIdInstance().nextId());
  28.     /**
  29.      * 用户ID
  30.      */
  31.     private String userId;
  33.     /**
  34.      * 文章标题
  35.      */
  36.     private String title;
  38.     /**
  39.      * 文章类型
  40.      * post  文章
  41.      * page  页面
  42.      */
  43.     private String type = "post";
  45.     /**
  46.      * 文章内容 html格式
  47.      */
  48.     private String content;
  50.     /**
  51.      * 文章路径
  52.      */
  53.     private String url;
  55.     /**
  56.      * 文章摘要
  57.      */
  58.     private String summary;
  61.     /**
  62.      * 缩略图
  63.      */
  64.     private String thumbnail;
  66.     /**
  67.      * 0 已发布
  68.      * 1 草稿
  69.      * 3 待审核
  70.      * 4 回收站
  71.      */
  72.     private Integer status = 0;
  74.     /**
  75.      * 文章访问量
  76.      */
  77.     private Long views;
  79.     /**
  80.      * 点赞访问量
  81.      */
  82.     private Long likes;
  84.     /**
  85.      * 评论数量(冗余字段，加快查询速度)
  86.      */
  87.     private Long comments;
  89.     /**
  90.      * 文章来源（原创1，转载2，翻译3）
  91.      */
  92.     private Integer source = 1;
  94.     /**
  95.      * 是否允许评论（允许1，禁止0）
  96.      */
  97.     private Integer commentFlag = 1;
  101.     private String createBy;
  103.     @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
  104.     private Date createTime;
  106.     private String updateBy;
  108.     @JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
  109.     @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
  110.     private Date updateTime;
  112.     /**
  113.      * 删除标志 默认0正常, 1删除
  114.      */
  115.     private Integer delFlag = CommonConstant.STATUS_NORMAL;
  117.     @TableField(exist = false)
  118.     private List<Category> categories;
  120.     @TableField(exist = false)
  121.     private List<Tag> tags;
  123.     @TableField(exist = false)
  124.     private User user;
  127. }
 

三、Mapper

这里使用Mybatis-plus PostMapper.java
  1. package com.liuyanzhao.sens.modules.blog.dao.mapper;
  4. import com.baomidou.mybatisplus.mapper.BaseMapper;
  5. import com.liuyanzhao.sens.modules.blog.dto.PageDto;
  6. import com.liuyanzhao.sens.modules.blog.entity.Post;
  7. import org.apache.ibatis.annotations.Param;
  9. import java.util.List;
  11. /**
  12.  * @author 言曌
  13.  * @date 2019-06-19 21:06
  14.  */
  16. public interface PostMapper  extends BaseMapper<Post> {
  18.     /**
  19.      * 根据条件查询
  20.      * @param condition 条件
  21.      * @param pageDto 分页封装类
  22.      * @return 文章列表
  23.      */
  24.     List<Post> findByCondition(@Param("condition") Post condition,
  25.                                @Param("pageDto") PageDto pageDto);
  27. }
  PostMapper.xml
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  3. <mapper namespace="com.liuyanzhao.sens.modules.blog.dao.mapper.PostMapper">
  5.     <resultMap id="postWithCategoriesAndTags" type="com.liuyanzhao.sens.modules.blog.entity.Post">
  6.         <id column="id" property="id"/>
  7.         <result column="create_by" property="createBy"/>
  8.         <result column="create_time" property="createTime"/>
  9.         <result column="del_flag" property="delFlag"/>
  10.         <result column="update_by" property="updateBy"/>
  11.         <result column="update_time" property="updateTime"/>
  12.         <result column="comment_flag" property="commentFlag"/>
  13.         <result column="comments" property="comments"/>
  14.         <result column="content" property="content"/>
  15.         <result column="likes" property="likes"/>
  16.         <result column="source" property="source"/>
  17.         <result column="status" property="status"/>
  18.         <result column="summary" property="summary"/>
  19.         <result column="thumbnail" property="thumbnail"/>
  20.         <result column="title" property="title"/>
  21.         <result column="type" property="type"/>
  22.         <result column="url" property="url"/>
  23.         <result column="views" property="views"/>
  24.         <result column="user_id" property="userId"/>
  26.         <association property="user" javaType="com.liuyanzhao.sens.modules.base.entity.User">
  27.             <id column="user_id" property="id"/>
  28.             <result column="user_username" property="username"/>
  29.             <result column="user_nickName" property="nickName"/>
  30.             <result column="user_avatar" property="avatar"/>
  31.         </association>
  33.         <collection property="categories" ofType="com.liuyanzhao.sens.modules.blog.entity.Category">
  34.             <id column="category_id" property="id"/>
  35.             <result column="category_title" property="title"/>
  36.         </collection>
  38.         <collection property="tags" ofType="com.liuyanzhao.sens.modules.blog.entity.Tag">
  39.             <id column="tag_id" property="id"/>
  40.             <result column="tag_title" property="title"/>
  41.         </collection>
  42.     </resultMap>
  45.     <!-- 文章主要字段：不包括文章内容  -->
  46.     <sql id="mainPostColumns">
  47.         id, user_id, create_by, create_time, comment_flag, comments,
  48.         likes, source, status, summary, thumbnail, title, `type`, url, views
  49.     </sql>
  51.     <!-- 文章主要字段：不包括文章内容  -->
  52.     <sql id="mainPostColumnsWithTable">
  53.         post.id, post.user_id, post.create_by, post.create_time, post.comment_flag,
  54.         post.comments, post.likes, post.source, post.status, post.summary, post.thumbnail,
  55.         post.title, post.`type`, post.url, post.views
  56.     </sql>
  59.     <select id="findByCondition" resultMap="postWithCategoriesAndTags">
  60.        SELECT <include refid="mainPostColumnsWithTable"/>,
  61.           category.id as category_id, category.title as category_title,
  62.           tag.id as tag_id, tag.title as tag_title
  63.        FROM (
  64.         SELECT <include refid="mainPostColumns"/> FROM t_blog_post
  65.         <where>
  66.             del_flag = 0
  67.             <if test="condition.userId != null and condition.userId != ''">
  68.                 AND user_id = #{condition.userId}
  69.             </if>
  70.             <if test="condition.title != null and condition.title != ''">
  71.                 AND title LIKE CONCAT('%','${condition.title}','%')
  72.             </if>
  73.             <if test="condition.status != null and condition.status != ''">
  74.                 AND status = #{condition.status}
  75.             </if>
  76.             <if test="condition.source != null and condition.source != ''">
  77.                 AND source = #{condition.source}
  78.             </if>
  79.             <if test="searchDate.startDate != null and searchDate.startDate != ''">
  80.                 AND create_time &gt;= #{searchDate.startDate}
  81.             </if>
  82.             <if test="searchDate.endDate != null and searchDate.endDate != ''">
  83.                 AND create_time &lt;= #{searchDate.endDate}
  84.             </if>
  85.         </where>
  86.         LIMIT #{pageDto.from}, #{pageDto.pageSize}) post
  87.        LEFT JOIN t_blog_post_category as post_category ON post.id = post_category.post_id
  88.        LEFT JOIN t_blog_category as category ON post_category.category_id = category.id
  89.        LEFT JOIN t_blog_post_tag as post_tag ON post.id = post_tag.post_id
  90.        LEFT JOIN t_blog_tag as tag ON post_tag.tag_id = tag.id
  91.        LEFT JOIN t_user as user ON post.user_id = user.id
  92.     </select>
  93. </mapper>
  association 是一对一的关键字，collection是一对多的关键字   这里说明一下 一对多会导致分页出现数据缺失，比如我们目前有20篇文章，每篇文章都有1到两个分类和标签，这会导致查出100条数据，然后如果直接LIMIT 0,10 会导致最终的文章表只有三五个记录。 所以我们需要如shang'm'd
历史上的今天
六月
21日
  • 微信
  • 交流学习，有偿服务
  • weinxin
  • 博客/Java交流群
  • 资源分享，问题解决，技术交流。群号：590480292
  • weinxin
avatar

发表评论

avatar 登录者：匿名
匿名评论，评论回复后会有邮件通知

  

已通过评论：0   待审核评论数：0