2. 程式人生 > 程式設計 >老生常談 MyBatis 複雜查詢

老生常談 MyBatis 複雜查詢

阿新 • • 發佈：2021-01-21

一對一查詢

在實際開發中，經常會遇到一對一查詢，一對多查詢等。這裡我們先來看一對一查詢。例如：每本書都有一個作者，作者都有自己的屬性，根據這個，我來定義兩個實體類：

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,`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.*,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','0');
INSERT INTO `user` VALUES ('3','sang','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');
INSERT INTO `user_role` VALUES ('2','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 複雜查詢內容請搜尋我們以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援我們！

相關推薦

老生常談 MyBatis 複雜查詢

一對一查詢 在實際開發中，經常會遇到一對一查詢，一對多查詢等。這裡我們先來看一對一查詢。例如：每本書都有一個作者，作者都有自己的屬性，根據這個，我來定義兩個實體類：

Mybatis 複雜查詢-association和collection 對比說明

本篇記錄一下Mybatis association和collection 查詢說明 1.首先上一個實際專案中是mapper 藉此註釋說明

Mybatis -- 複雜查詢環境搭建，多對一的處理，一對多的處理、按結果巢狀查詢（推薦）、按照查詢巢狀處理

技術標籤：Mybatismybatisxml 文章目錄 一. 複雜查詢環境搭建1） 搭建資料表 Teacher、Student2） 匯入lombok3） 新建實體類 Teacher，Student4） 建立Mapper介面5） 建立Mapper.XML檔案6） 在核心配置檔案中繫

Mybatis-複雜查詢

1.環境搭建 Student.java: package com.kakafa.pojo; import lombok.Data; @Data public class Student { private int id;

Mybatis基礎，複雜查詢環境的搭建

多個學生對應一個老師 對於學生這邊而言，關聯..多個學生，關聯一個老師【多對一】

MyBatis巢狀查尋&巢狀結果查詢--複雜查詢

兩張表： student，teacher 多對一 studentMapper public interface StudentMapper { public List<Student> getStudent();

Mybatis知識小匯（10）——複雜查詢環境搭建 ( 一對多處理)

技術標籤：mybatis 文章目錄 一對多處理（比如一個老師對應多個學生）測試環境搭建按照結果巢狀處理按照查詢巢狀處理

mybatis-註解實現複雜查詢-多表查詢-（2）

實現複雜關係對映之前我們可以在對映檔案中通過配置來實現，使用註解開發後，我們可以使用@Results註解，@Result註解，@One註解，@Many註解組合完成複雜關係的配置

MyBatis Plus 在複雜查詢條件Where中加括號，多個查詢條件在括號內

一、MyBatis Plus 在複雜查詢條件Where中加括號，多個查詢條件在括號內 使用and()方法

Mybatis學習_複雜查詢環境搭建

測試環境搭建 1.建立資料表，並插入資料 #建立老師表 create table tb_teacher( tea_id int(12) primary key auto_increment,

mybatis學習15：複雜查詢環境搭建

mybatis學習15：複雜查詢環境搭建 多對一處理： 流程圖：   多個學生對應一個老師；

mybatis複雜sql查詢——多對一和一對多處理

mybatis複雜sql查詢——多對一和一對多處理 sforeverd 於 2021-04-25 16:17:44 釋出 180 收藏分類專欄： mybatis 文章標籤： sql mysql mybatis版權

JPA的多表複雜查詢

最近工作中由於要求只能用hibernate+jpa 與資料庫進行互動，在簡單查詢中，jpa繼承CrudRepository介面 ，然後利用jpa的方法命名規範進行jpql查詢，然而在進行復雜查詢時，需要繼承JpaSpecificationExecutor介面 利用

mybatis 模糊查詢的實現方法

mybatis 模糊查詢的實現方法 mybatis的逆向助手確實好用，可以省去很多編寫常規sql語句的時間，但是它沒辦法自動生成模糊查詢語句，但開發中模糊查詢是必不可少的，所以，需要手動對mapper編寫模糊查詢功能。

Mybatis模糊查詢及自動對映實現詳解

這篇文章主要介紹了Mybatis模糊查詢及自動對映實現詳解,文中通過示例程式碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下

Mybatis複雜sql總結

1.mybatis中插入list引數，舉例： sql層級的需求是：在in中插入的list sql程式碼如下：(當然這個函式也要注意mysql的LPAD函式的學習，以及關於時間函式的學習)

5、手寫程式碼實現MyBatis的查詢所有功能

專案準備 1、新增相關依賴 <dependencies> <dependency> <groupId>mysql</groupId>

MySql查詢，聚合函式，分組，分頁，排序等複雜查詢

--聚合（分組）函式 count(*)：統計個數 max(列名)：最大值 min(列名)：最小值 sum(列名)：求和

mybatis關聯查詢時 兩張表有相同欄位導致對映錯誤

表1 表2 兩張表都存在name欄位 xml中的配置 <?xml version=\"1.0\" encoding=\"UTF-8\" ?> <!DOCTYPE mapper

oracle系列學習----複雜查詢的優化

實驗資料和表 createtabletest1 ( FIDNUMBER(6) NOT NULL, FBillNo VARCHAR2(10), FDateDATEDEFAULT to_date(to_char(SYSDATE,\'yyyy-mm-dd\'),\'yyyy-mm-dd\')