前言
mybatis多表關聯查詢和懶查詢,這篇文章通過一對一和一對多的例項來展示多表查詢。不過需要掌握資料輸出的這方面的知識。之前整理過了mybatis入門案例和mybatis資料輸出,多表查詢是在前面的基礎上完成的。如果不熟練的先回去鞏固一下。
準備工作
這裡先將兩個查詢要完成的共同步驟先完成
1.物理建模
建立兩個表,一個customer表,一個order表。
CREATE TABLE `t_customer` (
`customer_id` INT NOT NULL AUTO_INCREMENT,
`customer_name` VARCHAR(100),
PRIMARY KEY (`customer_id`)
);
CREATE TABLE `t_order` (
`order_id` INT NOT NULL AUTO_INCREMENT,
`order_name` VARCHAR(100),
`customer_id` INT,
PRIMARY KEY (`order_id`)
);
INSERT INTO `t_customer` (`customer_name`) VALUES ('tom');
INSERT INTO `t_order` (`order_name`, `customer_id`) VALUES ('筆記本', '1');
INSERT INTO `t_order` (`order_name`, `customer_id`) VALUES ('電腦', '1');
INSERT INTO `t_order` (`order_name`, `customer_id`) VALUES ('桌子', '1');
表關係分析
建立後的表為:
簡單來說,
- 一個顧客可以有多個訂單,所以
t_customer
表和t_order
表示一對多關係 - 一個訂單對應一個客戶或者多個訂單對應一個客戶,所以
t_order
表和t_customer
表可以看成一對一或者多對一關係
2.引入依賴
在pom.xml中引入相關依賴,並將log4j的配置檔案複製到resources路徑下。
<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.example</groupId>
<artifactId>day02-mybatis02</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<dependencies>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.8</version>
<scope>provided</scope>
</dependency>
<!-- Mybatis核心 -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.7</version>
</dependency>
<!-- junit測試 -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<!-- MySQL驅動 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.3</version>
<scope>runtime</scope>
</dependency>
<!-- log4j日誌 -->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
</dependencies>
</project>
3.全域性配置檔案
這裡設定駝峰對映,別名配置,環境配置和路徑對映,別名和路徑用的是包掃描,因此在對映配置檔案中做相應的修改即可。
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<!--駝峰對映-->
<settings>
<setting name="mapUnderscoreToCamelCase" value="true"/>
</settings>
<!--類型別名配置-->
<typeAliases>
<!-- <typeAlias type="pojo.Employee" alias="employee"></typeAlias>-->
<!--
採用包掃描的方式,一次性對某個包中的所有類配置別名,每個類的別名就是它的類名,不區分大小寫
-->
<package name="pojo"/>
</typeAliases>
<environments default="dev">
<environment id="dev">
<transactionManager type="JDBC"></transactionManager>
<dataSource type="POOLED">
<!--
dataSource:資料來源
1. POOLED 表示使用內建連線池
2. UNPOOLED 表示不使用連線池
3. JNDI
-->
<property name="username" value="root"></property>
<property name="password" value="888888"></property>
<property name="driver" value="com.mysql.jdbc.Driver"></property>
<property name="url" value="jdbc:mysql://localhost:3306/mybatis-example"></property>
</dataSource>
</environment>
</environments>
<mappers>
<!--resource=對映路徑-->
<!-- <mapper resource="mappers/EmployeeMapper.xml"/>-->
<package name="mappers"/>
</mappers>
</configuration>
(一)一對一查詢
第一種:關聯查詢
為了方便我直接在一個模組裡進行一對一和一對多關聯查詢,先看一下我的目錄結構,對要建立的相關檔案有一個瞭解,畫框框的為一對一查詢。,其餘的為一對多查詢。
目標
根據訂單ID查詢出訂單資訊,並且查詢出該訂單所屬的顧客資訊,將查詢到的結果集封裝到Order物件中,所以要有一個order和customer類,將客戶資訊轉成customer物件,然後封裝到Order物件中。
1、邏輯建模
在pojo類下建order和customer,要注意的是,因為我們的目標是要根據訂單Id查詢出訂單資訊和顧客資訊,而訂單資訊中有一個cutomer_id是和顧客表關聯的,查詢出來的是一條資訊,所以我們在order類中要宣告屬性customer,將客戶資訊轉成customer物件,封裝到訂單中。
package pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Customer {
private Integer customerId;
private String customerName;
}
package pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Order {
private Integer orderId;
private String orderName;
//表示Order和Customer的對一關係
private Customer customer;
}
2、建立持久層介面
因為在全域性檔案中配置的對映路徑是包掃描<package name="mappers"/>
,所以持久層介面在建在mappers包下
package mappers;
import pojo.Order;
public interface OrderMapper {
/*根據orderId查詢訂單資訊並且查詢該訂單的顧客資訊查詢出來,結果集封裝到Order物件中*/
Order selectOrderWithCustomerByOrderId(Integer orderId);
}
3、建立對映配置檔案
對映配置檔名字和在resources下的位置要與介面一致。
<?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="mappers.OrderMapper">
<!--
手動對映,
autoMapping屬性:對於可以自動對映的欄位進行自動對映
-->
<resultMap id="OrderMap" type="Order" autoMapping="true">
<!--
association標籤進行一對一對映,型別是javaType
property屬性:表示要對POJO的哪個屬性進行一對一對映
javaType屬性:表示要進行一對一對映的那個屬性的型別(全限定名)
-->
<association property="customer" javaType="Customer" autoMapping="true"></association>
</resultMap>
<select id="selectOrderWithCustomerByOrderId" resultMap="OrderMap">
select * from t_order `to`,t_customer tc where `to`.customer_id=tc.customer_id and `to`.order_id=#{orderId}
</select>
</mapper>
這裡有三點需要注意:
- ①多表查詢都需要用到手動對映,之前的資料輸出是resulType,手動對映的資料輸出是resultMap,在這裡設定
autoMapping=ture
,表示能自動對映的自動對映,就不必要寫id,result屬性。 - ②在手動對映中,association標籤進行一對一對映,型別是javaType,javaType寫要封裝的型別(這裡注意要和一對多查詢區分開)
- ③select標籤,要引用前面寫的手動對映,準備sql語句。
4、測試程式
import mappers.OrderMapper;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import java.io.InputStream;
public class Test1v1 {
private OrderMapper orderMapper ;
private InputStream is;
private SqlSession sqlSession;
@Before
public void init() throws Exception{
//目標:獲取EmployeeMapper介面的代理物件,並且使用該物件呼叫selectEmployee(1)方法,然後返回Employee物件
//1. 將全域性配置檔案轉成位元組輸入流
is = Resources.getResourceAsStream("mybatis-config.xml");
//2. 建立SqlSessionFactoryBuilder物件
SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
//3. 使用構建者模式建立SqlSessionFactory物件
SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
//4. 使用工廠模式建立一個SqlSession物件
sqlSession = sqlSessionFactory.openSession();
//5. 使用動態代理模式,建立EmployeeMapper介面的代理物件
orderMapper = sqlSession.getMapper(OrderMapper.class);
}
@After
public void after() throws Exception{
//提交事務!!!
sqlSession.commit();
//7. 關閉資源
is.close();
sqlSession.close();
}
@Test
public void testSelectOrderWithCustomerByOrderId(){
System.out.println(orderMapper.selectOrderWithCustomerByOrderId(2));
}
}
第二種:分佈查詢(懶查詢)
分佈查詢則需要查詢分佈兩張表,將第二步查詢到的結果賦值給Order物件的customer屬性。這種情況下避免了資源浪費,在查詢某些欄位的值的時候不用每次都查詢兩張表。
我這裡還是將一對一和一對多查詢放在一個模組下,但是建議分開放,思路相對會清晰一點,框住的還是一對一查詢需要建立的表。
可以對比一對一關聯查詢,分佈查詢多了介面的CustomerMapper以及對映檔案的CustomerMapper.xml檔案。
目標
- 第一步:根據order_id查詢出訂單資訊,得到customer_id
- 第二步:根據customer_id查詢出顧客資訊
- 第三步:將第二步查詢到的結果賦值給Order物件的customer屬性
1.邏輯建模
和一對一關聯查詢一樣
2.建立永續性介面
- OrderMapper介面,根據order_id查詢出訂單資訊:
public interface OrderMapper {
Order selectOrderByOrderId(Integer orderId);
}
- CustomerMapper介面,根據customer_id查詢出顧客資訊:
public interface CustomerMapper {
Customer selectCustomerByCustomerId(Integer customerId);
}
3.建立對映配置檔案
OrderMapper.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="mapper.OrderMapper">
<resultMap id="OrderWithCustomerMap" type="order" autoMapping="true">
<!--
將第二步查詢到的結果賦值給Order物件的customer屬性
select屬性:表示呼叫第二步查詢,獲取查詢結果
column屬性:表示將本次查詢到的結果集中的哪個欄位傳給第二步查詢
-->
<association property="customer" javaType="Customer"
autoMapping="true" column="customer_id"
select="mapper.CustomerMapper.selectCustomerByCustomerId"
fetchType="lazy"
></association>
</resultMap>
<!--第一步查詢-->
<select id="selectOrderByOrderId" resultMap="OrderWithCustomerMap">
SELECT * FROM t_order WHERE order_id =#{orderId};
</select>
</mapper>
CustomerMapper.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="mapper.CustomerMapper">
<select id="selectCustomerByCustomerId" resultType="customer">
SELECT * FROM t_customer WHERE customer_id=#{customerId};
</select>
</mapper>
說明:
- ①第二步只需要查詢根據customer_id查詢出顧客資訊,我們重點放在如何在OrderMapper.xml中將第二步查詢到的資訊封裝給Order的customer屬性。
- ②OrderMapper.xml中:我們知道,只要涉及多表查詢,我們都必須設定手動對映,而一對一的手動對映是association
- select屬性:表示呼叫第二步查詢,獲取查詢結果 ,要寫第二步的全限定名
- column屬性:表示將本次查詢到的結果集中的哪個欄位傳給第二步查詢,根據customer_id查詢顧客資訊。
- fetchType="lazy"表示使用懶查詢,也就是分佈查詢。
4.測試程式
import mapper.OrderMapper;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import java.io.InputStream;
public class Test1v1 {
private OrderMapper orderMapper ;
private InputStream is;
private SqlSession sqlSession;
@Before
public void init() throws Exception{
//目標:獲取EmployeeMapper介面的代理物件,並且使用該物件呼叫selectEmployee(1)方法,然後返回Employee物件
//1. 將全域性配置檔案轉成位元組輸入流
is = Resources.getResourceAsStream("mybatisConfig.xml");
//2. 建立SqlSessionFactoryBuilder物件
SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
//3. 使用構建者模式建立SqlSessionFactory物件
SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
//4. 使用工廠模式建立一個SqlSession物件
sqlSession = sqlSessionFactory.openSession();
//5. 使用動態代理模式,建立EmployeeMapper介面的代理物件
orderMapper = sqlSession.getMapper(OrderMapper.class);
}
@After
public void after() throws Exception{
//提交事務!!!
sqlSession.commit();
//7. 關閉資源
is.close();
sqlSession.close();
}
@Test
public void testSelectOrderByOrderId(){
System.out.println(orderMapper.selectOrderByOrderId(1));
}
}
(二)一對多查詢
第一種 關聯查詢
目標
根據顧客id查詢顧客資訊和訂單資訊
1.邏輯建模
一個顧客對應多個訂單,查詢出來的有多條資料。所以需要在顧客中宣告一個泛型為Order的集合:
- Customer1
package pojo;
import java.util.List;
public class Customer1 {
private Integer customerId;
private String customerName;
private List<Order1> orderList;
@Override
public String toString() {
return "Customer1{" +
"customerId=" + customerId +
", customerName='" + customerName + ''' +
", orderList=" + orderList +
'}';
}
}
- Order1
package pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Order1 {
private Integer orderId;
private String orderName;
}
2. 建立永續性介面
package mappers;
import pojo.Customer1;
public interface CustomerMapper {
Customer1 selectCustomerWithOrderList(Integer customerId);
}
3. 編寫配置檔案
<?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="mappers.CustomerMapper">
<!--
一對多對映:collection標籤
property屬性表示要對POJO的哪個屬性進行一對多對映
ofType屬性表示POJO中要進行一對多對映的那個屬性的泛型的全限定名
-->
<resultMap id="customerMap" type="Customer1" autoMapping="true">
<!--這裡不能省略-->
<id column="customer_id" property="customerId"></id>
<result column="customer_name" property="customerName"></result>
<collection property="orderList" ofType="Order1" autoMapping="true"></collection>
</resultMap>
<select id="selectCustomerWithOrderList" resultMap="customerMap">
select * from t_order `to`,t_customer tc where `to`.customer_id=tc.customer_id and tc.customer_id=#{customerId}
</select>
</mapper>
注意:
- ①在手動對映中,collection標籤進行一對多對映(一對一是association,javaType)
- ofType**,表示POJO中要進行一對多對映的那個屬性的泛型的全限定名
- property屬性表示要對POJO的哪個屬性進行一對多對映。
- ②這裡和一對一查詢不同還有:手動對映中的id是不可以省略的,
因為我們查詢時結果有多行,自動對映先看方法的返回值,返回值是Customer1,底層會呼叫一個物件方法selectOne,多條資料底層呼叫的是selectList方法,根據介面的方法可以看到返回值是一個物件,只有一條資料,呼叫selectOne方法,而我們查詢出來的有多條,所以手動對映的id,result一定要加上。
但是注意:如果我們沒有設定自動對映的情況下,result屬性一定要寫,不然只能列印一個空值。
4.測試程式
import mappers.CustomerMapper;
import mappers.OrderMapper;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import java.io.InputStream;
public class Test1vn {
private CustomerMapper customerMapper ;
private InputStream is;
private SqlSession sqlSession;
@Before
public void init() throws Exception{
//目標:獲取EmployeeMapper介面的代理物件,並且使用該物件呼叫selectEmployee(1)方法,然後返回Employee物件
//1. 將全域性配置檔案轉成位元組輸入流
is = Resources.getResourceAsStream("mybatis-config.xml");
//2. 建立SqlSessionFactoryBuilder物件
SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
//3. 使用構建者模式建立SqlSessionFactory物件
SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
//4. 使用工廠模式建立一個SqlSession物件
sqlSession = sqlSessionFactory.openSession();
//5. 使用動態代理模式,建立EmployeeMapper介面的代理物件
customerMapper = sqlSession.getMapper(CustomerMapper.class);
}
@After
public void after() throws Exception{
//提交事務!!!
sqlSession.commit();
//7. 關閉資源
is.close();
sqlSession.close();
}
@Test
public void testSelectCustomerWithOrderList(){
System.out.println(customerMapper.selectCustomerWithOrderList(1));
}
}
第二種 分佈查詢(懶查詢)
目標
- 第一步:根據customer_id查詢出顧客資訊
- 第二步:根據customer_id查詢出訂單資訊
- 第三步:將查詢到的訂單資訊封裝到orderList集合中
1.邏輯建模
和一對多關聯查詢一樣
2.建立永續性介面
CustomerMapper1介面:
package mapper;
import pojo.Customer;
import pojo.Customer1;
public interface CustomerMapper1 {
Customer1 selectCustomer1ByCustomerId(Integer customerId);
}
OrderMapper1 介面:
package mapper;
import pojo.Order1;
import java.util.List;
public interface OrderMapper1 {
List<Order1> selectOrder1ByOrderId(Integer OrderId);
}
3. 對映配置檔案
CustomerMapper1.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="mapper.CustomerMapper1">
<resultMap id="customerWithOrderMap" type="customer1" autoMapping="true">
<id column="customer_id" property="customerId" ></id>
<collection property="orderList1" ofType="Order1"
select="mapper.OrderMapper1.selectOrder1ByOrderId"
column="customer_id" fetchType="lazy"></collection>
</resultMap>
<select id="selectCustomer1ByCustomerId" resultMap="customerWithOrderMap">
SELECT * FROM t_customer WHERE customer_id = #{customerId};
</select>
</mapper>
OrderMapper1.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="mapper.OrderMapper1">
<select id="selectOrder1ByOrderId" resultType="order1">
SELECT * FROM t_order WHERE customer_id = #{customerId};
</select>
</mapper>
注意:
- ①第二步只需要查詢根據customer_id查詢出訂單資訊,其餘同一對多的關聯查詢
- ②CustomerMapper.xml中:一對多的手動對映是collection
- select屬性:表示呼叫第二步查詢,獲取查詢結果 ,要寫第二步的全限定名
- column屬性:表示將本次查詢到的結果集中的哪個欄位傳給第二步查詢,根據customer_id查詢訂單資訊。
- fetchType="lazy"表示使用懶查詢,也就是分佈查詢。