MyBatis初級實戰之五：一對一關聯查詢

歡迎訪問個人GitHub

https://github.com/zq2599/blog_demos

內容：全部原創文章分類彙總及配套源碼，涉及Java、Docker、Kubernetes、DevOPS等；

本篇概覽

• 本文是《MyBatis初級實戰》系列的第五篇，從多表獲取數據是個常見的場景，通常有如下兩種方式：
• 聯表查詢：join操做，一次查詢完成
• 屢次查詢：用第一次查詢的結果做爲條件，再作查詢（MyBatis中叫作嵌套查詢）
• 本篇的內容就是學習MyBatis對上述兩種查詢的支持，全文由如下章節組成：

1. 準備數據；
2. 本次實戰的java工程
3. 最簡單的聯表(兩個表的數據保存在一個實體類的不一樣字段)；
4. 一對一聯表查詢(兩個表的數據分別保存在不一樣實體類，假設是A和B，A是B的成員變量)
5. 一對一嵌套查詢(兩個表的數據分別保存在不一樣實體類，假設是A和B，A是B的成員變量)

源碼下載

1. 若是您不想編碼，能夠在GitHub下載全部源碼，地址和連接信息以下表所示(https://github.com/zq2599/blog_demos)：

名稱	連接	備註
項目主頁	https://github.com/zq2599/blog_demos	該項目在GitHub上的主頁
git倉庫地址(https)	https://github.com/zq2599/blog_demos.git	該項目源碼的倉庫地址，https協議
git倉庫地址(ssh)	git@github.com:zq2599/blog_demos.git	該項目源碼的倉庫地址，ssh協議

2. 這個git項目中有多個文件夾，本章的應用在mybatis文件夾下，以下圖紅框所示：

3. mybatis是個父工程，裏面有數個子工程，本篇的源碼在relatedoperation子工程中，以下圖紅框所示：

準備數據

1. 本次實戰，在名爲mybatis的數據庫中創建兩個表(和前面幾篇文章中的表結構如出一轍)：user和log表；
2. user表記錄用戶信息，很是簡單，只有三個字段：主鍵、名稱、年齡
3. log表記錄用戶行爲，四個字段：主鍵、用戶id、行爲描述、行爲時間
4. user和log的關係以下圖：

5. 建表和添加數據的語句以下：

use mybatis;

DROP TABLE IF EXISTS `user`;

CREATE TABLE `user` (
  `id` int(32) NOT NULL AUTO_INCREMENT,
  `name` varchar(32) NOT NULL,
  `age` int(32) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;

DROP TABLE IF EXISTS `log`;

CREATE TABLE `log` (
  `id` int(32) NOT NULL AUTO_INCREMENT,
  `user_id` int(32),
  `action` varchar(255) NOT NULL,
  `create_time` datetime not null,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;

INSERT INTO mybatis.user (id, name, age) VALUES (3, 'tom', 11);

INSERT INTO mybatis.log (id, user_id, action, create_time) VALUES (3, 3, 'read book', '2020-08-07 08:18:16');
INSERT INTO mybatis.log (id, user_id, action, create_time) VALUES (4, 3, 'go to the cinema', '2020-09-02 20:00:00');
INSERT INTO mybatis.log (id, user_id, action, create_time) VALUES (5, 3, 'have a meal', '2020-10-05 12:03:36');
INSERT INTO mybatis.log (id, user_id, action, create_time) VALUES (6, 3, 'have a sleep', '2020-10-06 13:00:12');
INSERT INTO mybatis.log (id, user_id, action, create_time) VALUES (7, 3, 'write', '2020-10-08 09:21:11');

本次實戰的java工程

1. 在父工程mybatis下新建子工程relatedoperation，pom.xml以下：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.bolingcavalry</groupId>
        <artifactId>mybatis</artifactId>
        <version>1.0-SNAPSHOT</version>
        <relativePath>../pom.xml</relativePath>
    </parent>

    <groupId>com.bolingcavalry</groupId>
    <artifactId>relatedoperation</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>relatedoperation</name>
    <description>Demo project for Mybatis related operation in Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
        </dependency>
        <!-- swagger-ui -->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

2. 基本配置文件application.yml：

server:
  port: 8080

spring:
  #1.JDBC數據源
  datasource:
    username: root
    password: 123456
    url: jdbc:mysql://192.168.50.43:3306/mybatis?useUnicode=true&characterEncoding=utf-8&useSSL=true&serverTimezone=UTC
    driver-class-name: com.mysql.cj.jdbc.Driver
    #2.鏈接池配置
    druid:
      #初始化鏈接池的鏈接數量 大小，最小，最大
      initial-size: 5
      min-idle: 5
      max-active: 20
      #配置獲取鏈接等待超時的時間
      max-wait: 60000
      #配置間隔多久才進行一次檢測，檢測須要關閉的空閒鏈接，單位是毫秒
      time-between-eviction-runs-millis: 60000
      # 配置一個鏈接在池中最小生存的時間，單位是毫秒
      min-evictable-idle-time-millis: 30000
      # 配置一個鏈接在池中最大生存的時間，單位是毫秒
      max-evictable-idle-time-millis: 300000
      validation-query: SELECT 1 FROM user
      test-while-idle: true
      test-on-borrow: true
      test-on-return: false
      # 是否緩存preparedStatement，也就是PSCache  官方建議MySQL下建議關閉   我的建議若是想用SQL防火牆 建議打開
      pool-prepared-statements: true
      max-pool-prepared-statement-per-connection-size: 20
      # 配置監控統計攔截的filters，去掉後監控界面sql沒法統計，'wall'用於防火牆
      filters: stat,wall,slf4j
      filter:
        stat:
          merge-sql: true
          slow-sql-millis: 5000
      #3.基礎監控配置
      web-stat-filter:
        enabled: true
        url-pattern: /*
        #設置不統計哪些URL
        exclusions: "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*"
        session-stat-enable: true
        session-stat-max-count: 100
      stat-view-servlet:
        enabled: true
        url-pattern: /druid/*
        reset-enable: true
        #設置監控頁面的登陸名和密碼
        login-username: admin
        login-password: admin
        allow: 127.0.0.1
        #deny: 192.168.1.100

# mybatis配置
mybatis:
  # 配置文件所在位置
  config-location: classpath:mybatis-config.xml
  # 映射文件所在位置
  mapper-locations: classpath:mappers/*Mapper.xml

# 日誌配置
logging:
  level:
    root: INFO
    com:
      bolingcavalry:
        relatedoperation:
          mapper: debug

3. 再準備名爲application-test.yml的配置文件，這是執行單元測試時用到的，和application.yml的不一樣之處是spring.datasource.druid.web-stat-filter.enabled配置設置成false；
4. mybatis的配置文件mybatis-config.xml以下：

<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <typeAliases>
        <!-- 映射文件中的類不用寫全路徑了-->
        <package name="com.bolingcavalry.relatedoperation.entity"/>
    </typeAliases>
</configuration>

5. 數據源配置類DruidConfig.java：

package com.bolingcavalry.relatedoperation;

import com.alibaba.druid.pool.DruidDataSource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class DruidConfig {

    private static final Logger logger = LoggerFactory.getLogger(DruidConfig.class);

    @Value("${spring.datasource.url}")
    private String dbUrl;
    @Value("${spring.datasource.username}")
    private String username;
    @Value("${spring.datasource.password}")
    private String password;
    @Value("${spring.datasource.driver-class-name}")
    private String driverClassName;
    @Value("${spring.datasource.druid.initial-size}")
    private int initialSize;
    @Value("${spring.datasource.druid.max-active}")
    private int maxActive;
    @Value("${spring.datasource.druid.min-idle}")
    private int minIdle;
    @Value("${spring.datasource.druid.max-wait}")
    private int maxWait;
    @Value("${spring.datasource.druid.pool-prepared-statements}")
    private boolean poolPreparedStatements;
    @Value("${spring.datasource.druid.max-pool-prepared-statement-per-connection-size}")
    private int maxPoolPreparedStatementPerConnectionSize;
    @Value("${spring.datasource.druid.time-between-eviction-runs-millis}")
    private int timeBetweenEvictionRunsMillis;
    @Value("${spring.datasource.druid.min-evictable-idle-time-millis}")
    private int minEvictableIdleTimeMillis;
    @Value("${spring.datasource.druid.max-evictable-idle-time-millis}")
    private int maxEvictableIdleTimeMillis;
    @Value("${spring.datasource.druid.validation-query}")
    private String validationQuery;
    @Value("${spring.datasource.druid.test-while-idle}")
    private boolean testWhileIdle;
    @Value("${spring.datasource.druid.test-on-borrow}")
    private boolean testOnBorrow;
    @Value("${spring.datasource.druid.test-on-return}")
    private boolean testOnReturn;
    @Value("${spring.datasource.druid.filters}")
    private String filters;
    @Value("{spring.datasource.druid.connection-properties}")
    private String connectionProperties;

    /**
     * Druid 鏈接池配置
     */
    @Bean
    public DruidDataSource dataSource() {
        DruidDataSource datasource = new DruidDataSource();
        datasource.setUrl(dbUrl);
        datasource.setUsername(username);
        datasource.setPassword(password);
        datasource.setDriverClassName(driverClassName);
        datasource.setInitialSize(initialSize);
        datasource.setMinIdle(minIdle);
        datasource.setMaxActive(maxActive);
        datasource.setMaxWait(maxWait);
        datasource.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
        datasource.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
        datasource.setMaxEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
        datasource.setValidationQuery(validationQuery);
        datasource.setTestWhileIdle(testWhileIdle);
        datasource.setTestOnBorrow(testOnBorrow);
        datasource.setTestOnReturn(testOnReturn);
        datasource.setPoolPreparedStatements(poolPreparedStatements);
        datasource.setMaxPoolPreparedStatementPerConnectionSize(maxPoolPreparedStatementPerConnectionSize);
        try {
            datasource.setFilters(filters);
        } catch (Exception e) {
            logger.error("druid configuration initialization filter", e);
        }
        datasource.setConnectionProperties(connectionProperties);
        return datasource;
    }

}

6. swagger配置類：

package com.bolingcavalry.relatedoperation;

import springfox.documentation.service.Contact;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.service.Tag;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

@Configuration
@EnableSwagger2
public class SwaggerConfig {

    @Bean
    public Docket createRestApi() {
        return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())
                .tags(new Tag("UserController", "用戶服務"), new Tag("LogController", "日誌服務"))
                .select()
                // 當前包路徑
                .apis(RequestHandlerSelectors.basePackage("com.bolingcavalry.relatedoperation.controller"))
                .paths(PathSelectors.any())
                .build();
    }

    //構建 api文檔的詳細信息函數,注意這裏的註解引用的是哪一個
    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                //頁面標題
                .title("MyBatis CURD操做")
                //建立人
                .contact(new Contact("程序員欣宸", "https://github.com/zq2599/blog_demos", "zq2599@gmail.com"))
                //版本號
                .version("1.0")
                //描述
                .description("API 描述")
                .build();
    }
}

7. springboot引導類：

package com.bolingcavalry.relatedoperation;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan("com.bolingcavalry.relatedoperation.mapper")
public class RelatedOperationApplication {

    public static void main(String[] args) {
        SpringApplication.run(RelatedOperationApplication.class, args);
    }

}

8. 用戶表的實體類：

package com.bolingcavalry.relatedoperation.entity;

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@ApiModel(description = "用戶實體類")
public class User {

    @ApiModelProperty(value = "用戶ID")
    private Integer id;

    @ApiModelProperty(value = "用戶名", required = true)
    private String name;

    @ApiModelProperty(value = "用戶地址", required = false)
    private Integer age;
}

9. 日誌表的實體類：

package com.bolingcavalry.relatedoperation.entity;

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.sql.Date;

@Data
@NoArgsConstructor
@ApiModel(description = "日誌實體類")
public class Log {
    @ApiModelProperty(value = "日誌ID")
    private Integer id;

    @ApiModelProperty(value = "用戶ID")
    private Integer userId;

    @ApiModelProperty(value = "日誌內容")
    private String action;

    @ApiModelProperty(value = "建立時間")
    private Date createTime;
}

• 以上就是本篇的準備代碼，接下來在此基礎上實現各類多表關聯查詢

最簡單的聯表

• 先實戰的是最普通的聯表，以下圖所示，查詢結果是名爲LogExtend的實體類，這個類有5個字段，其中四個來自日誌表log，一個來自用戶表user：

• 下圖是開發步驟：

1. 實體類LogExtend的源碼以下，可見和Log相比多了個userName字段：

package com.bolingcavalry.relatedoperation.entity;

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@ApiModel(description = "日誌實體類(含用戶表的字段)")
public class LogExtend extends Log {

    @ApiModelProperty(value = "用戶名")
    private String userName;
}

2. 新建log表對應的映射文件LogMapper.xml，以下所示，裏面是經過left join語法執行的簡單的聯表查詢，以及查詢結果對應的resultMap定義：

<?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.bolingcavalry.relatedoperation.mapper.LogMapper">

    <!--聯表查詢，返回log對象，該對象有個userName字段，值是user表的user_name字段-->
    <select id="oneObjectSel" parameterType="int" resultMap="logExtendResultMap">
        select l.id as id,
               l.user_id as user_id,
               l.action as action,
               l.create_time as create_time,
               u.name as user_name
        from log as l
                 left join user as u
                           on l.user_id = u.id
        where l.id = #{id}
    </select>

    <resultMap id="logExtendResultMap" type="logExtend">
        <id property="id" column="id"/>
        <result column="user_id" jdbcType="INTEGER" property="userId"/>
        <result column="action" jdbcType="VARCHAR" property="action"/>
        <result column="create_time" jdbcType="TIMESTAMP" property="createTime"/>
        <result column="user_name" jdbcType="VARCHAR" property="userName"/>
    </resultMap>
</mapper>

3. mapper接口代碼：

package com.bolingcavalry.relatedoperation.mapper;

import com.bolingcavalry.relatedoperation.entity.LogAssociateUser;
import com.bolingcavalry.relatedoperation.entity.LogExtend;
import org.springframework.stereotype.Repository;

@Repository
public interface LogMapper {

    LogExtend oneObjectSel(int id);
}

4. service層的代碼在LogService.java文件中：

package com.bolingcavalry.relatedoperation.service;

import com.bolingcavalry.relatedoperation.entity.LogAssociateUser;
import com.bolingcavalry.relatedoperation.entity.LogExtend;
import com.bolingcavalry.relatedoperation.mapper.LogMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class LogService {
    @Autowired
    LogMapper logMapper;

    public LogExtend oneObjectSel(int id){
        return logMapper.oneObjectSel(id);
    }
}

5. controller層的代碼在LogController.java文件中：

@RestController
@RequestMapping("/log")
@Api(tags = {"LogController"})
public class LogController {
    @Autowired
    private LogService logService;

    @ApiOperation(value = "根據ID查找日誌記錄，帶userName字段，該字段經過聯表查詢實現", notes="根據ID查找日誌記錄，帶userName字段，該字段經過聯表查詢實現")
    @ApiImplicitParam(name = "id", value = "日誌ID", paramType = "path", required = true, dataType = "Integer")
    @RequestMapping(value = "/aggregate/{id}", method = RequestMethod.GET)
    public LogExtend oneObjectSel(@PathVariable int id){
        return logService.oneObjectSel(id);
    }

6. 編寫單元測試的代碼ControllerTest.java，因爲今天的測試涉及到user和log兩個表，所以在測試類ControllerTest的內部準備了兩個內部類，分別用於測試user和log表：

package com.bolingcavalry.relatedoperation.controller;

import lombok.extern.slf4j.Slf4j;
import org.junit.jupiter.api.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.MediaType;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;

import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

@SpringBootTest
@DisplayName("Web接口的單元測試")
@AutoConfigureMockMvc
@ActiveProfiles("test")
@Slf4j
public class ControllerTest {
    /**
     * 查詢方式：聯表
     */
    final static String SEARCH_TYPE_LEFT_JOIN = "leftjoin";

    /**
     * 查詢方式：嵌套
     */
    final static String SEARCH_TYPE_NESTED = "nested";

    final static int TEST_USER_ID = 3;

    final static String TEST_USER_NAME = "tom";

    @Autowired MockMvc mvc;

    @Nested
    @TestMethodOrder(MethodOrderer.OrderAnnotation.class)
    @DisplayName("用戶服務")
    class User {
    
    }
    
    @Nested
    @TestMethodOrder(MethodOrderer.OrderAnnotation.class)
    @DisplayName("日誌服務")
    class Log {
        final static int TEST_LOG_ID = 5;

        @Test
        @DisplayName("經過日誌ID獲取日誌信息,帶userName字段，該字段經過聯表查詢實現")
        @Order(1)
        void oneObjectSel() throws Exception {
            mvc.perform(MockMvcRequestBuilders.get("/log/aggregate/" + TEST_LOG_ID)
                    .accept(MediaType.APPLICATION_JSON))
                    .andExpect(status().isOk())
                    .andExpect(jsonPath("$.id").value(TEST_LOG_ID))
                    .andExpect(jsonPath("$.userName").value(TEST_USER_NAME))
                    .andDo(print());
        }
    }
}

7. 執行上述單元測試方法，結果以下圖，紅框中就是controller層返回的數據，可見已經過Mybatis成功取得LogExtend實例：

• 下一站是一對一聯表查詢；

關於一對一關聯的兩種方式

• 前面的查詢有個特色：儘管查詢了兩個表，但結果都在同一實體類的不一樣字段，而更符合業務邏輯的關係應該是log類中有個user類的成員變量，即以下形式：

@Data
@NoArgsConstructor
@ApiModel(description = "日誌實體類")
public class LogAssociateUser {
    @ApiModelProperty(value = "日誌ID")
    private Integer id;

    @ApiModelProperty(value = "用戶對象")
    private User user;

    @ApiModelProperty(value = "日誌內容")
    private String action;

    @ApiModelProperty(value = "建立時間")
    private Date createTime;
}

• 接下來的實戰就是如何用MyBatis查詢獲得上述LogAssociateUser 類型的結果；
• 一對一關聯的實現有聯表和嵌套查詢兩種，它們的差別在Mybatis中體如今association的子節點上：

1. 聯表時，association內使用result子節點，將聯表查詢的結果映射到關聯對象；
2. 嵌套時，association內使用select子節點，觸發一次新的查詢；

一對一（聯表）

所謂一對一，就是一個對象關聯了另外一個對象，例如一條log記錄中，帶有對應的user信息；

1. 下面是新的實體類LogAssociateUser，該類對應的是log表記錄，有個user字段，類型是User對象：

@Data
@NoArgsConstructor
@ApiModel(description = "日誌實體類")
public class LogAssociateUser {
    @ApiModelProperty(value = "日誌ID")
    private Integer id;

    @ApiModelProperty(value = "用戶對象")
    private User user;

    @ApiModelProperty(value = "日誌內容")
    private String action;

    @ApiModelProperty(value = "建立時間")
    private Date createTime;
}

2. 映射文件LogMapper.xml中，sql和resultMap以下，可見查詢的時候將user表的字段都查出來了，而後在resultMap中用association節點去處理sql中查出的user表的數據，經過javaType屬性轉爲User類的實例：

<!--聯表查詢，返回log對象，它的成員變量中有user對象-->
    <select id="leftJoinSel" parameterType="int" resultMap="leftJoinResultMap">
        select l.id as log_id,
               l.action as log_action,
               l.create_time as log_create_time,
               u.id as user_id,
               u.name as user_name,
               u.age as user_age
        from log as l
               left join user as u
               on l.user_id = u.id
        where l.id = #{id}
    </select>

    <resultMap id="leftJoinResultMap" type="LogAssociateUser">
        <id property="id" column="log_id"/>

        <result  property="action" column="log_action" jdbcType="VARCHAR"/>

        <result property="createTime" column="log_create_time" jdbcType="TIMESTAMP" />

        <association property="user" javaType="User">
            <id property="id" column="user_id"/>
            <result property="name" column="user_name"/>
            <result property="age" column="user_age"/>
        </association>
    </resultMap>

3. 以上就是一對一（聯表）的關鍵點，接下來循序漸進的在LogMapper、LogService、LogController中添加方法便可，下面是LogController中對應的web接口，稍後會在單元測試中調用這個接口進行驗證：

@ApiOperation(value = "根據ID查找日誌記錄，帶用戶對象，聯表查詢實現", notes="根據ID查找日誌記錄，帶用戶對象，聯表查詢實現")
    @ApiImplicitParam(name = "id", value = "日誌ID", paramType = "path", required = true, dataType = "Integer")
    @RequestMapping(value = "/leftjoin/{id}", method = RequestMethod.GET)
    public LogAssociateUser leftJoinSel(@PathVariable int id){
        return logService.leftJoinSel(id);
    }

4. 最後是單元測試的代碼（ControllerTest.java文件），用來測試上述代碼是否有效，注意下面的queryAndCheck私有方法，該方法中發起請求並驗證結果：

/**
         * 經過日誌ID獲取日誌信息有兩種方式：聯表和嵌套查詢，
         * 從客戶端來看，僅一部分path不一樣，所以將請求和檢查封裝到一個通用方法中，
         * 調用方法只須要指定不一樣的那一段path
         * @param subPath
         * @throws Exception
         */
        private void queryAndCheck(String subPath) throws Exception {
            String queryPath = "/log/" + subPath + "/" + TEST_LOG_ID;

            log.info("query path [{}]", queryPath);

            mvc.perform(MockMvcRequestBuilders.get(queryPath)
                    .accept(MediaType.APPLICATION_JSON))
                    .andExpect(status().isOk())
                    .andExpect(jsonPath("$.id").value(TEST_LOG_ID))
                    .andExpect(jsonPath("$.user.id").value(TEST_USER_ID))
                    .andDo(print());
        }

        @Test
        @DisplayName("經過日誌ID獲取日誌信息（關聯了用戶），聯表查詢")
        @Order(2)
        void leftJoinSel() throws Exception {
            queryAndCheck(SEARCH_TYPE_LEFT_JOIN);
        }

5. 執行單元測試結果以下，可見：內部嵌套了一個json對象，就是user表的數據：

一對一（嵌套）

1. 接下來試試嵌套的方式；
2. LogMapper.xml中對應的sql：

<!--嵌套-->
    <select id="nestedSel" parameterType="int" resultMap="nestedResultMap">
        select
            l.id as log_id,
            l.user_id as log_user_id,
            l.action as log_action,
            l.create_time as log_create_time
        from mybatis.log as l
        where l.id = #{id}
    </select>

3. 上述sql對應的resultMap以下，可見association節點中有個select屬性，這就是MyBatis支持嵌套查詢的關鍵，該屬性的值是個select節點：

<!-- association節點的select屬性會觸發嵌套查詢-->
    <resultMap id="nestedResultMap" type="LogAssociateUser">
        <!-- column屬性中的log_id，來自前面查詢時的"l.id as log_id" -->
        <id property="id" column="log_id"/>
        <!-- column屬性中的log_action，來自前面查詢時的"l.action as log_action" -->
        <result  property="action" column="log_action" jdbcType="VARCHAR"/>
        <!-- column屬性中的log_create_time，來自前面查詢時的"l.create_time as log_create_time" -->
        <result property="createTime" column="log_create_time" jdbcType="TIMESTAMP" />
        <!-- select屬性，表示這裏要執行嵌套查詢，將log_user_id傳給嵌套的查詢 -->
        <association property="user" column="log_user_id" select="selectUserByUserId"></association>
    </resultMap>

4. 上述節點中select屬性的值，對應一個select節點，以下：

<select id="selectUserByUserId" parameterType="int" resultType="User">
        select
            u.id,
            u.name,
            u.age
        from mybatis.user as u
        where u.id = #{log_user_id}
    </select>

5. 以上就是一對一（嵌套）的關鍵點，接下來循序漸進的在LogMapper、LogService、LogController中添加方法便可，下面是LogController中對應的web接口，稍後會在單元測試中調用這個接口進行驗證：

@ApiOperation(value = "根據ID查找日誌記錄，帶用戶對象，嵌套查詢實現", notes="根據ID查找日誌記錄，帶用戶對象，嵌套查詢實現")
    @ApiImplicitParam(name = "id", value = "日誌ID", paramType = "path", required = true, dataType = "Integer")
    @RequestMapping(value = "/nested/{id}", method = RequestMethod.GET)
    public LogAssociateUser nestedSel(@PathVariable int id){
        return logService.nestedSel(id);
    }

6. 最後是單元測試的代碼（ControllerTest.java文件），用來測試上述代碼是否有效，以下可見，直接調用了前面的queryAndCheck來驗證：

@Test
        @DisplayName("經過日誌ID獲取日誌信息（關聯了用戶），嵌套查詢")
        @Order(3)
        void nestedSel() throws Exception {
            queryAndCheck(SEARCH_TYPE_NESTED);
        }

7. 執行上述單元測試代碼，結果以下，可見嵌套查詢的方式也能將user表的數據成功獲取，放入log實例的成員變量中：

8. 最後是對比聯表和嵌套查詢的差別，先看聯表查詢的MyBatis日誌，以下圖紅框所示，只有一次sql查詢：

9. 再看嵌套查詢的日誌，以下圖，紅框是第一次查詢，結果中的userid做爲綠框中的第二次查詢的條件：

• 至此，一對一的多表查詢實戰就完成了，本篇的邏輯是一條log記錄關聯一條user記錄，下一篇文章，我們學習一對多關聯，即一個user有多條log記錄；

你不孤單，欣宸原創一路相伴

1. Java系列
2. Spring系列
3. Docker系列
4. kubernetes系列
5. 數據庫+中間件系列
6. DevOps系列

歡迎關注公衆號：程序員欣宸

微信搜索「程序員欣宸」，我是欣宸，期待與您一同暢遊Java世界...
https://github.com/zq2599/blog_demos