老生常谈 MyBatis 复杂查询

一对一查询

在实际开发中,经常会遇到一对一查询,一对多查询等。这里我们先来看一对一查询。例如:每本书都有一个作者,作者都有自己的属性,根据这个,我来定义两个实体类:

public class Book {

 private Integer id;
 private String name;
 private Author author;

 // 省略 getter/setter
}
public class Author {

 private Integer id;
 private String name;
 private Integer age;

 // 省略 getter/setter
}

然后,在数据库中,添加两张表:

CREATE DATABASE /*!32312 IF NOT EXISTS*/`test01` /*!40100 DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci */ /*!80016 DEFAULT ENCRYPTION='N' */;

USE `test01`;

/*Table structure for table `author` */

DROP TABLE IF EXISTS `author`;

CREATE TABLE `author` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 `name` varchar(255) COLLATE utf8mb4_general_ci DEFAULT NULL,
 `age` int(11) DEFAULT NULL,
 PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;

/*Data for the table `author` */

/*Table structure for table `book` */

DROP TABLE IF EXISTS `book`;

CREATE TABLE `book` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 `name` varchar(255) COLLATE utf8mb4_general_ci DEFAULT NULL,
 `aid` int(11) DEFAULT NULL,
 PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;

添加成功后,我们新建一个 BookMapper,BookMapper 中定义了一个查询 Book 的方法,但是我希望查出来 Book 的同时,也能查出来它的 Author:

public interface BookMapper {

 Book getBookById(Integer id);
}

再定义一个 BookMapper.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">
<mapper namespace="com.antonio.hello.mybatis.mapper.BookMapper">

 <resultMap id="BookWithAuthor" type="com.antonio.hello.mybatis.entity.Book">
  <id column="id" property="id"/>
  <result column="name" property="name"/>
  <association property="author" javaType="com.antonio.hello.mybatis.entity.Author">
   <id column="aid" property="id"/>
   <result column="aname" property="name"/>
   <result column="aage" property="age"/>
  </association>
 </resultMap>

 <select id="getBookById" resultMap="BookWithAuthor">
  SELECT b.*,a.`age` AS aage,a.`id` AS aid,a.`name` AS aname FROM book b,author a WHERE b.`aid`=a.`id` AND b.`id`=#{id}
 </select>
</mapper>

在这个查询 SQL 中,首先应该做好一对一查询,然后,返回值一定要定义成 resultMap,注意,这里千万不能写错。然后,在 resultMap 中,来定义查询结果的映射关系。其中,association 节点用来描述一对一的关系。这个节点中的内容,和 resultMap 一样,也是 id,result 等,在这个节点中,我们还可以继续描述一对一。

由于在实际项目中,每次返回的数据类型可能都会有差异,这就需要定义多个 resultMap,而这多个 resultMap 中,又有一部份属性是相同的,所以,我们可以将相同的部分抽出来,做成一个公共的模板,然后被其他 resultMap 继承,优化之后的 mapper 如下:

<?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.antonio.hello.mybatis.mapper.BookMapper">

 <resultMap id="BaseResultMap" type="com.antonio.hello.mybatis.entity.Book">
  <id column="id" property="id"/>
  <result column="name" property="name"/>
 </resultMap>

 <resultMap id="BookWithAuthor" type="com.antonio.hello.mybatis.entity.Book" extends="BaseResultMap">
  <association property="author" javaType="ocom.antonio.hello.mybatis.entity.Author">
   <id column="aid" property="id"/>
   <result column="aname" property="name"/>
   <result column="aage" property="age"/>
  </association>
 </resultMap>

 <select id="getBookById" resultMap="BookWithAuthor">
  SELECT b.*,a.`age` AS aage,a.`id` AS aid,a.`name` AS aname FROM book b,author a WHERE b.`aid`=a.`id` AND b.`id`=#{id}
 </select>
</mapper>

懒加载

上面这种加载方式,是一次性的读取到所有数据。然后在 resultMap 中做映射。如果一对一的属性使用不是很频繁,可能偶尔用一下,这种情况下,我们也可以启用懒加载。

懒加载:就是先查询 book,查询 book 的过程中,不去查询 author,当用户第一次调用了 book 中的 author 属性后,再去查询 author。例如,我们再来定义一个 Book 的查询方法:

Book getBookById2(Integer id);

Author getAuthorById(Integer id);

接下来,在 mapper 中定义相应的 SQL:

<resultMap id="BaseResultMap" type="com.antonio.hello.mybatis.entity.Book">
 <id column="id" property="id"/>
 <result column="name" property="name"/>
</resultMap>

<resultMap id="BookWithAuthor2" type="com.antonio.hello.mybatis.entity.Book" extends="BaseResultMap">
 <association property="author" javaType="com.antonio.hello.mybatis.entity.Author"
     select="com.antonio.hello.mybatis.mapper.BookMapper.getAuthorById" column="aid" fetchType="lazy"/>
</resultMap>

<select id="getBookById2" resultMap="BookWithAuthor2">
 select * from book where id=#{id};
</select>

<select id="getAuthorById" resultType="com.antonio.hello.mybatis.entity.Author">
 select * from author where id=#{aid};
</select>

这里,定义 association 的时候,不直接指定映射的字段,而是指定要执行的方法,通过 select 字段来指定,column 表示执行方法时传递的参数字段,最后的 fetchType 表示开启懒加载。当然,要使用懒加载,还需在全局配置中开启:

<settings>
 <setting name="lazyLoadingEnabled" value="true"/>
 <setting name="aggressiveLazyLoading" value="false"/>
</settings>

一对多查询

一对多查询,也是一个非常典型的使用场景。比如用户和角色的关系,一个用户可以具备多个角色。首先我们准备三个表:

SET FOREIGN_KEY_CHECKS=0;

-- ----------------------------
-- Table structure for role
-- ----------------------------
DROP TABLE IF EXISTS `role`;
CREATE TABLE `role` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 `name` varchar(32) DEFAULT NULL,
 `nameZh` varchar(32) DEFAULT NULL,
 PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of role
-- ----------------------------
INSERT INTO `role` VALUES ('1', 'dba', '数据库管理员');
INSERT INTO `role` VALUES ('2', 'admin', '系统管理员');
INSERT INTO `role` VALUES ('3', 'user', '用户');

-- ----------------------------
-- Table structure for user
-- ----------------------------
DROP TABLE IF EXISTS `user`;
CREATE TABLE `user` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 `username` varchar(32) DEFAULT NULL,
 `password` varchar(255) DEFAULT NULL,
 `enabled` tinyint(1) DEFAULT NULL,
 `locked` tinyint(1) DEFAULT NULL,
 PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of user
-- ----------------------------
INSERT INTO `user` VALUES ('1', 'root', '$2a$10$RMuFXGQ5AtH4wOvkUqyvuecpqUSeoxZYqilXzbz50dceRsga.WYiq', '1', '0');
INSERT INTO `user` VALUES ('2', 'admin', '$2a$10$RMuFXGQ5AtH4wOvkUqyvuecpqUSeoxZYqilXzbz50dceRsga.WYiq', '1', '0');
INSERT INTO `user` VALUES ('3', 'sang', '$2a$10$RMuFXGQ5AtH4wOvkUqyvuecpqUSeoxZYqilXzbz50dceRsga.WYiq', '1', '0');

-- ----------------------------
-- Table structure for user_role
-- ----------------------------
DROP TABLE IF EXISTS `user_role`;
CREATE TABLE `user_role` (
 `id` int(11) NOT NULL AUTO_INCREMENT,
 `uid` int(11) DEFAULT NULL,
 `rid` int(11) DEFAULT NULL,
 PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of user_role
-- ----------------------------
INSERT INTO `user_role` VALUES ('1', '1', '1');
INSERT INTO `user_role` VALUES ('2', '1', '2');
INSERT INTO `user_role` VALUES ('3', '2', '2');
INSERT INTO `user_role` VALUES ('4', '3', '3');
SET FOREIGN_KEY_CHECKS=1;

这三个表中,有用户表,角色表以及用户角色关联表,其中用户角色关联表用来描述用户和角色之间的关系,他们是一对多的关系。然后,根据这三个表,创建两个实体类:

public class User {
 private Integer id;
 private String username;
 private String password;
 private List<Role> roles;

 // 省略 setter/getter
}
public class Role {
 private Integer id;
 private String name;
 private String nameZh;

 // 省略 setter/getter
}

接下来,定义一个根据 id 查询用户的方法:

User getUserById(Integer id);

然后,定义该方法的实现:

<resultMap id="UserWithRole" type="com.antonio.hello.mybatis.entity.User">
 <id column="id" property="id"/>
 <result column="username" property="username"/>
 <result column="password" property="password"/>
 <collection property="roles" ofType="com.antonio.hello.mybatis.entity.Role">
  <id property="id" column="rid"/>
  <result property="name" column="rname"/>
  <result property="nameZh" column="rnameZH"/>
 </collection>
</resultMap>

<select id="getUserById" resultMap="UserWithRole">
 SELECT u.*,r.`id` AS rid,r.`name` AS rname,r.`nameZh` AS rnameZh FROM USER u,role r,user_role ur WHERE u.`id`=ur.`uid` AND ur.`rid`=r.`id` AND u.`id`=#{id}
</select>

在 resultMap 中,通过 collection 节点来描述集合的映射关系。在映射时,会自动将一的一方数据集合并,然后将多的一方放到集合中,能实现这一点,靠的就是 id 属性。当然,这个一对多,也可以做成懒加载的形式,那我们首先提供一个角色查询的方法:

List<Role> getRolesByUid(Integer id);

然后,在 XML 文件中,处理懒加载:

<resultMap id="UserWithRole" type="com.antonio.hello.mybatis.entity.User">
 <id column="id" property="id"/>
 <result column="username" property="username"/>
 <result column="password" property="password"/>
 <collection property="roles" select="com.antonio.hello.mybatis.mapper.UserMapper.getRolesByUid" column="id" fetchType="lazy">
 </collection>
</resultMap>

<select id="getUserById" resultMap="UserWithRole">
 select * from user where id=#{id};
</select>

<select id="getRolesByUid" resultType="com.antonio.hello.mybatis.entity.Role">
 SELECT r.* FROM role r,user_role ur WHERE r.`id`=ur.`rid` AND ur.`uid`=#{id}
</select>

定义完成之后,我们的查询操作就实现了懒加载功能。

查询缓存

MyBatis 一级缓存

Mybatis 一级缓存的作用域是同一个 SqlSession,在同一个 sqlSession 中两次执行相同的 sql 语句,第一次执行完毕会将数据库中查询的数据写到缓存(内存),第二次会从缓存中获取数据将不再从数据库查询,从而提高查询效率。当一个 sqlSession 结束后该 sqlSession 中的一级缓存也就不存在了。Mybatis 默认开启一级缓存。

public class Main2 {
 public static void main(String[] args) {
  SqlSessionFactory instance = SqlSessionFactoryUtils.getInstance();
  SqlSession sqlSession = instance.openSession();
  BookMapper mapper = sqlSession.getMapper(BookMapper.class);
  UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
  User user = userMapper.getUserById(1);
  user = userMapper.getUserById(1);
  user = userMapper.getUserById(1);
  System.out.println(user.getUsername());
 }
}

多次查询,只执行一次 SQL。但是注意,如果开启了一个新的 SqlSession,则新的 SqlSession 无法就是之前的缓存,必须是同一个 SqlSession 中,缓存才有效。

MyBatis 二级缓存

Mybatis 二级缓存是多个 SqlSession 共享的,其作用域是 mapper 的同一个 namespace,不同的 sqlSession 两次执行相同 namespace 下的 sql 语句且向 sql 中传递参数也相同即最终执行相同的 sql 语句,第一次执行完毕会将数据库中查询的数据写到缓存(内存),第二次会从缓存中获取数据将不再从数据库查询,从而提高查询效率。Mybatis 默认没有开启二级缓存需要在 setting 全局参数中配置开启二级缓存。

到此这篇关于老生常谈 MyBatis 复杂查询的文章就介绍到这了,更多相关MyBatis 复杂查询内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • Mybatis查询多条记录并返回List集合的方法

    实体对象如下: /** 使用lobmok插件 */ @Getter @Setter @NoArgsConstructor @ToString @EqualsAndHashCode public class Vendor { private String vend_id; private String vend_name; private String vend_address; private String vend_city; private String vend_state; privat

  • mybatis Plus 多表联合查询的实现示例

    本文主要介绍了mybatis Plus 多表联合查询,分享给大家,具体如下: //实体类package com.sk.skkill.entity; import com.baomidou.mybatisplus.annotation.TableField; import com.baomidou.mybatisplus.annotation.TableName; import lombok.Data; import java.io.Serializable; import java.util.D

  • MyBatis-Plus 分页查询以及自定义sql分页的实现

    一.引言 分页查询每个人程序猿几乎都使用过,但是有部分同学不懂什么是物理分页和逻辑分页. 物理分页:相当于执行了limit分页语句,返回部分数据.物理分页只返回部分数据占用内存小,能够获取数据库最新的状态,实施性比较强,一般适用于数据量比较大,数据更新比较频繁的场景. 逻辑分页:一次性把全部的数据取出来,通过程序进行筛选数据.如果数据量大的情况下会消耗大量的内存,由于逻辑分页只需要读取数据库一次,不能获取数据库最新状态,实施性比较差,适用于数据量小,数据稳定的场合. 那么MP中的物理分页怎么实现

  • mybatis-plus QueryWrapper自定义查询条件的实现

    mybatis-plus框架功能很强大,把很多功能都集成了,比如自动生成代码结构,mybatis crud封装,分页,动态数据源等等,附上官网链接https://mp.baomidou.com/,github上有代码例子,国内小伙伴推荐码云https://gitee.com/baomidou/mybatis-plus.  但是,其中还是有些小坑,文档也没有涉及的很全面,碰到问题,百度或者发issue,能力强的还是直接看源码好,一切答案都在源码中. 版本推荐用3.1.0,3.1.1及以上版本有bu

  • mybatis-plus的selectById(或者selectOne)在根据主键ID查询实体对象的时候偶尔会出现null的问题记录

    mybatis-plus的selectById/selectOne查询结果偶尔出错(为null)的问题记录 错误截图: 亲测重复执行此段代码10次中大概会有连续的2次出现结果为null的情况. 由于后续还需引用到这个查询结果的某些字段信息,会导致程序出现空指针异常,故投机取巧做了如下处理(加了一个while循环让其一直执行selectById(或者selectOne)直到查询结果不为空): 但这终归不是从根本上解决了问题.我也不清白他出现这个问题的根本原因是什么. 到此这篇关于mybatis-p

  • springboot + mybatis-plus实现多表联合查询功能(注解方式)

    第一步:加入mybatis-plus依赖 第二步:配置数据源 spring: thymeleaf: cache: false encoding: utf-8 prefix: classpath:/templates/ suffix: .html enabled: true datasource: url: jdbc:mysql://192.168.1.152:3306/timo?useUnicode=true&characterEncoding=UTF-8&useSSL=false&

  • 老生常谈 MyBatis 复杂查询

    一对一查询 在实际开发中,经常会遇到一对一查询,一对多查询等.这里我们先来看一对一查询.例如:每本书都有一个作者,作者都有自己的属性,根据这个,我来定义两个实体类: public class Book { private Integer id; private String name; private Author author; // 省略 getter/setter } public class Author { private Integer id; private String name

  • mybatis 模糊查询的实现方法

    mybatis 模糊查询的实现方法 mybatis的逆向助手确实好用,可以省去很多编写常规sql语句的时间,但是它没办法自动生成模糊查询语句,但开发中模糊查询是必不可少的,所以,需要手动对mapper编写模糊查询功能. 这里先明确MyBatis/Ibatis中#和$的区别: 1. #将传入的数据都当成一个字符串,会对自动传入的数据加一个双引号.如:order by #user_id#,如果传入的值是111,那么解析成sql时的值为order by "111", 如果传入的值是id,则解

  • Mybatis 条件查询 批量增删改查功能

    模糊查询: @Select({ "SELECT * FROM account where account like CONCAT('%',#{query},'%') or email like CONCAT('%',#{query},'%')" }) Account findAccountByAccountOrMail(@Param("query") String query); 批量添加: @Insert({ "<script>"

  • mybatis一对一查询功能

    所谓的一对一查询,就是说我们在查询一个表的数据的时候,需要关联查询其他表的数据. 需求 首先说一个使用一对一查询的小需求吧:假设我们在查询某一个订单的信息的时候,需要关联查询出创建这个订单对应的用户信息.表模型如下( ResultType sql语句的书写 首先,我们要对我们的需求进行分析.1.我们需要确定这个需求需要涉及到哪两张表,其中哪个是主表,哪个是关联表.具体怎么确定,还是看需求--我们的需求是说,在查询订单的时候,顺带着查出创建这个订单的用户.那么,已经很显然了.我们的主表是订单表(o

  • Mybatis模糊查询和动态sql语句的用法

    Mybatis 模糊查询和动态sql语句 模糊查询 对数据库最常用的操作就是查询了,但是如何使用Mybatis进行模糊查询呢?下面先看一个简单的模糊查询 <select id="select01" resultMap="BasicResultMap"> SELECT * FROM oa_employee WHERE emp_name LIKE #{asd} </select> 这是一条伪模糊查询, 因为没有实现真正的模糊 "%&qu

  • mybatis中查询结果为空时不同返回类型对应返回值问题

    今天在别人的代码基础上实现新需求,看到对于mybatis查询结果的判断不是很正确,如果查询结果为空就会异常,不知道大家有没有这样的疑惑:mybatis中resultType有多种返回类型,对于每种不同类型,查询结果为空时dao接口的返回值是一样的吗?接下来我就总结一下常见的几种情况. 第一种:resultType为基本类型,如string(在此暂且把string归纳为基本类型) 如果select的结果为空,则dao接口返回结果为null 第二种,resultType为基本类型,如int 后台报异

  • Mybatis模糊查询及自动映射实现详解

    这篇文章主要介绍了Mybatis模糊查询及自动映射实现详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 Mybatis的模糊查询 1. 参数中直接加入%% 1 2 3 4 5 6 7 8 9 param.setUsername("%CD%"); param.setPassword("%11%"); <select id="selectPersons" resultType="p

  • mybatis模糊查询、分页和别名配置的方法

    mybatis模糊查询(3种) 第一种 select * from user where username like "%" #{name} "%" 第二种 select * from user where username like "%${value}%" 第三种 <!--concat拼接字符串 mysql独有的函数--> select * from user where username like concat("%&

  • mybatis Map查询结果下划线转驼峰的实例

    添加一个配置类MybatisCamelConfig 即可 package com.fpi.notify.config; import com.google.common.base.CaseFormat; import org.apache.ibatis.reflection.MetaObject; import org.apache.ibatis.reflection.wrapper.MapWrapper; import org.apache.ibatis.reflection.wrapper.

  • Mybatis关联查询之一对多和多对一XML配置详解

    平时在开发过程中dao.bean和XML文件都是自动生成的,很少写XML的配置关系,今天记录一下mybatis的关联查询中的多对一和一对多的情况. 首先是有两张表(学生表Student和老师Teacher表,注:这里只是为了演示一对多和多对一的情况,请不要杠),为了更易懂,这里只设置了最简单的几个必要字段.表结构如下图 Student表: Teacher表: 创建实体bean Teacher.java: import java.util.List; public class Teacher {

随机推荐