mybatis 映射結果集

映射結果集

1、全局setting設置

– autoMappingBehavior默認是PARTIAL，開啓自動映射 的功能。唯一的要求是列名和javaBean屬性名一致

– 如果autoMappingBehavior設置爲null則會取消自動映射

– 數據庫字段命名規範，POJO屬性符合駝峯命名法，如 A_COLUMNaColumn，我們可以開啓自動駝峯命名規 則映射功能，mapUnderscoreToCamelCase=true。

2、resultType用來自動映射javabean對象，往往對象中只有基本數據類型，如果有引用數據類型通常使用自定義resultMap。

3、自定義resultMap(重難點)，實現高級結果集映射，往往在javabean對象中有引用類型。
 

Select元素來定義查詢操作

Id：唯一標識符。
– 用來引用這條語句，需要和接口的方法名一致

parameterType：參數類型。
– 可以不傳，MyBatis會根據TypeHandler自動推斷

resultType：返回值類型。

– 別名或者全類名，如果返回的是集合，定義集合中元素的類型。不能和resultMap同時使用。

– 常使用自動映射

 

resultMap：也是返回值類型與resultType相似
– 外部自定義的返回值
– 手動實現自定義結果集映射

 

以resultType舉例

javabean：

public class Employee {
	
	private Integer id;
	private String lastName;
	private String email;
	private String gender;
}

數據庫：

Dao層接口：

public interface EmployeeMapperSelect {
	//測試：resultType
	public Employee getEmployeeById(Integer id);	
	public List<Employee> getEmpsByLastNameLike(String lastName);	
	public Map<String, Object> getEmpByIdReturnMap(Integer id);		
	//mybatis封裝這個map的時候使用哪個屬性作爲主鍵
	@MapKey("id")
	public Map<Integer, Employee> getEmpByLastNameLikeReturnMap(String lastName);
}

案例：
1）簡單查詢

<select id="getEmployeeById" resultType="com.bean.Employee">
 	 select * from tbl_employee where id=#{id}
 </select>

//簡單查詢
@Test
public void test01() throws IOException{
	SqlSessionFactory sqlSessionFactory=getSqlSessionFactory();
	SqlSession openSession=sqlSessionFactory.openSession();
	EmployeeMapperSelect mapper=openSession.getMapper(EmployeeMapperSelect.class);
	Employee employee=mapper.getEmployeeById(16);
	System.out.println(employee);	
}

2）模糊查詢返回List<Employee>

<select id="getEmpsByLastNameLike"	resultType="com.bean.Employee">
 	select * from tbl_employee where last_name like #{lastName}
</select>

@Test
public void test02() throws IOException{
	SqlSessionFactory sqlSessionFactory=getSqlSessionFactory();
	SqlSession openSession=sqlSessionFactory.openSession();
	EmployeeMapperSelect mapper=openSession.getMapper(EmployeeMapperSelect.class);
	List<Employee> employee=mapper.getEmpsByLastNameLike("%a%");
	System.out.println(employee);	
}

3）Map返回單條記錄->key是數據庫列名，value是對應的值

<select id="getEmpByIdReturnMap"	resultType="map">
 	select * from tbl_employee where id=#{id}
</select>

@Test
public void test03() throws IOException{
	SqlSessionFactory sqlSessionFactory=getSqlSessionFactory();
	SqlSession openSession=sqlSessionFactory.openSession();
	EmployeeMapperSelect mapper=openSession.getMapper(EmployeeMapperSelect.class);
	Map<String, Object> map=mapper.getEmpByIdReturnMap(14);
	System.out.println(map);	
}

4）Map返回多條記錄->key是該條記錄的鍵(自定義)，value是封裝後的javabean

如何指定key？在dao層接口上添加註解-->告訴mybatis封裝這個map的時候使用哪個屬性作爲鍵。
例如：@MapKey("id") 用封裝employee後中的id屬性作爲鍵。

@MapKey("id")
public Map<Integer, Employee> getEmpByLastNameLikeReturnMap(String lastName);

<select id="getEmpByLastNameLikeReturnMap"	resultType="com.bean.Employee">
    select * from tbl_employee where last_name like #{lastName}
</select>  

@Test
public void test04() throws IOException{
	SqlSessionFactory sqlSessionFactory=getSqlSessionFactory();
	SqlSession openSession=sqlSessionFactory.openSession();
	EmployeeMapperSelect mapper=openSession.getMapper(EmployeeMapperSelect.class);
	Map<Integer, Employee> map=mapper.getEmpByLastNameLikeReturnMap("%a%");
	System.out.println(map);		
}

以resultMap舉例(重難點)：

加大難度後的需求1：聯表查詢部門信息

新的數據庫字段:

新的javabean字段:

public class Employee2 {
	private Integer id;
	private String lastName;
	private String email;
	private String gender;
	private Department dept;
    ......
}

public class Department {
	
	private Integer id;
	private String departmentName;
	private List<Employee> emps;
    .......
}

Dao層接口()：

//測試：resultMap
public Employee2 getEmpAndDept(Integer id);
public Employee2 getEmpAndDeptAssociation(Integer id);
public Employee2 getEmpByIdStep(Integer id);

手動設置映射關係-->指定數據庫字段名與javabean字段名 封裝規則: 

<id />爲主鍵屬性
<result />爲其餘屬性

1）嵌套結果集(級聯屬性封裝結果集，例如dept.id)：

<!-- id  last_name gender did dept_name -->
<resultMap type="com.bean.Employee2" id="MyDifEmp">
	<id column="id" property="id"/>
	<result column="last_name" property="lastName"/>
	<result column="email" property="email"/>
	<result column="gender" property="gender"/>
	<result column="did" property="dept.id"/>	
	<result column="dept_name" property="dept.departmentName"/>
</resultMap>

<select id="getEmpAndDept" resultMap="MyDifEmp">
 	select e.id id,e.last_name last_name,e.email email,e.gender gender,e.d_id d_id
 	,d.id did,d.dept_name dept_name	
 	from tbl_employee e,tbl_dept d where e.d_id=d.id AND e.id=#{id};
</select>

id=17，sql語句執行結果： 

@Test
public void test05() throws IOException{
	SqlSessionFactory sqlSessionFactory=getSqlSessionFactory();
	SqlSession openSession=sqlSessionFactory.openSession();
	EmployeeMapperSelect mapper=openSession.getMapper(EmployeeMapperSelect.class);
	Employee2 employee2=mapper.getEmpAndDept(17);
	System.out.println(employee2);	
	System.out.println(employee2.getDept());	
}

2） 嵌套結果集(association定義單個對象封裝規則）

association可以指定聯合的javabean對象：
property：指定哪個屬性是聯合對象
javaType：指定這個屬性對象的類型

<resultMap type="com.bean.Employee2" id="MyDifEmp2">
	<id column="id" property="id"/>
	<result column="last_name" property="lastName"/>
	<result column="email" property="email"/>
	<result column="gender" property="gender"/>
		
	<association property="dept" javaType="com.bean.Department">
		<id column="did" property="id"/>
		<result column="dept_name" property="departmentName"/>
	</association>
</resultMap>

<select id="getEmpAndDeptAssociation" resultMap="MyDifEmp2">
 	 select e.id id,e.last_name last_name,e.email email,e.gender gender,e.d_id d_id
 	 ,d.id did,d.dept_name dept_name	
 	from tbl_employee e,tbl_dept d where e.d_id=d.id AND e.id=#{id};
</select>

<select id="getDeptById" resultType="com.bean.Department">
	select id,dept_name departmentName from tbl_dept where id=#{id}
</select>

3）分步查詢(association定義單個對象封裝規則）

思路：
1、先按照員工id查詢員工信息
2、根據查詢員工信息中的d_id值去部門表查出部門信息
3、將部門設置到員工當中

新添加的Dao層：

package com.dao;

import com.bean.Department;

public interface DepartmentMapper {
	
	public Department getDeptById(Integer id);//此案例的方法
	
	public Department getDeptByIdPlus(Integer id);

	public Department getDeptByIdStep(Integer id);
}

新添加的DepartmentMapperMapper.xml：

<select id="getDeptById" resultType="com.bean.Department">
	select id,dept_name departmentName from tbl_dept where id=#{id}
</select>

執行流程：調用用getEmpByIdStemp方法，返回員工信息，再使用select指定的方法(傳入column指定的這列參數的值)查出對象，並封裝給property指定的屬性。
分步的核心： property(屬性值)調用select(查詢方法)利用column(傳遞參數) 

 	 <resultMap type="com.bean.Employee2" id="MyEmpByStep">
		<id column="id" property="id"/>
		<result column="last_name" property="lastName"/>
		<result column="email" property="email"/>
		<result column="gender" property="gender"/>
		<!-- property(屬性值)調用select(查詢方法)利用column(傳遞參數) -->
		<!-- 流程：使用select指定的方法(傳入column指定的這列參數的值)查出對象，並封裝給property指定的屬性 -->
		 <association property="dept" 
		 	select="com.dao.DepartmentMapper.getDeptById"
		 	column="d_id">
		 </association>
	 </resultMap>

    <select id="getEmpByIdStep" resultMap="MyEmpByStep">
		select * from tbl_employee where id=#{id}
    </select>

	//分步查詢association
	@Test
	public void test06() throws IOException{
		SqlSessionFactory sqlSessionFactory=getSqlSessionFactory();
		SqlSession openSession=sqlSessionFactory.openSession();
		EmployeeMapperSelect mapper=openSession.getMapper(EmployeeMapperSelect.class);
		Employee2 employee2=mapper.getEmpByIdStep(17);
		System.out.println(employee2);	
		System.out.println(employee2.getDept());	
	}

可以分析得出：發送了兩條sql語句，只要執行就是兩條，有時候可能不需要部門信息，這樣容易帶來不必要的資源消耗，下面將介紹延遲加載技術！

4）分步查詢的延遲加載
實質就是-按需加載，減少資源消耗。

在案例3）中稍作修改：
1、添加兩個全局配置

<settings>		
	<!--顯示的指定每個我們需要更改的配置的值，即使他是默認的。防止版本更新帶來的問題  -->
	<setting name="lazyLoadingEnabled" value="true"/>
	<setting name="aggressiveLazyLoading" value="false"/><!-- 屬性按需加載 -->		
</settings> 

2、測試類少寫一行：

	//分步查詢(延遲加載)
	@Test
	public void test07() throws IOException{
		SqlSessionFactory sqlSessionFactory=getSqlSessionFactory();
		SqlSession openSession=sqlSessionFactory.openSession();
		EmployeeMapperSelect mapper=openSession.getMapper(EmployeeMapperSelect.class);
		Employee2 employee2=mapper.getEmpByIdStep(17);
		System.out.println(employee2.getEmail());	
		//System.out.println(employee2.getDept());	
	}

結果分析：只發送了一條sql語句！因爲我們現在不需要Department相關信息，因此分步查詢第二條語句不會發送。

再次加大難度需求2：查詢部門對應的所有員工信息也查詢出來

增加後的Dao層(DepartmentMapper)：

public interface DepartmentMapper {
	//association 演示分步查詢
	public Department getDeptById(Integer id);
	//嵌套查詢
	public Department getDeptByIdPlus(Integer id);
    //分步查詢
	public Department getDeptByIdStep(Integer id);
}

修改後的javabean：

public class Department {
	
	private Integer id;
	private String departmentName;
	private List<Employee> emps;
}

5）嵌套的方式(collection定義關聯的集合類型的屬性封裝規則)

collection定義關聯集合類型的屬性的封裝規則 
ofType:指定集合裏面元素的類型 

	<!--嵌套結果集的方式，使用collection標籤定義關聯的集合類型的屬性封裝規則  -->
	<resultMap type="com.bean.Department" id="MyDept">
		<id column="did" property="id"/>
		<result column="dept_name" property="departmentName"/>
		<!-- 
			collection定義關聯集合類型的屬性的封裝規則 
			ofType:指定集合裏面元素的類型
		-->
		<collection property="emps" ofType="com.bean.Employee">
			<!-- 定義這個集合中元素的封裝規則 -->
			<id column="eid" property="id"/>
			<result column="last_name" property="lastName"/>
			<result column="email" property="email"/>
			<result column="gender" property="gender"/>
		</collection>
	</resultMap>
	<!-- public Department getDeptByIdPlus(Integer id); -->
	<select id="getDeptByIdPlus" resultMap="MyDept">
		SELECT d.id did,d.dept_name dept_name,
				e.id eid,e.last_name last_name,e.email email,e.gender gender
		FROM tbl_dept d
		LEFT JOIN tbl_employee e
		ON d.id=e.d_id
		WHERE d.id=#{id}
	</select>

	//分步查詢返回集合(collection)
	@Test
	public void test08() throws IOException{
		SqlSessionFactory sqlSessionFactory=getSqlSessionFactory();
		SqlSession openSession=sqlSessionFactory.openSession();
		DepartmentMapper mapper=openSession.getMapper(DepartmentMapper.class);
		Department department=mapper.getDeptByIdPlus(1);
		System.out.println(department);	
		System.out.println(department.getEmps());	
	}

	//分步查詢返回帶有的集合(collection)
	@Test
	public void test09() throws IOException{
		SqlSessionFactory sqlSessionFactory=getSqlSessionFactory();
		SqlSession openSession=sqlSessionFactory.openSession();
		DepartmentMapper mapper=openSession.getMapper(DepartmentMapper.class);
		Department department=mapper.getDeptByIdStep(1);
		System.out.println(department);	
		System.out.println(department.getEmps());	
	}

 6）分步查詢(collection)

EmployeeMapperSelect.java多添加一行(Dao層)

public Employee2 getEmpsByDeptId(Integer id);//測試collection分步查詢

 	 <!-- collection分步查詢 -->
	<select id="getEmpsByDeptId" resultType="com.bean.Employee2">
			select * from tbl_employee where d_id=#{deptId};
 	 </select>

	<!-- collection：分段查詢 -->
	<resultMap type="com.bean.Department" id="MyDeptStep">
		<id column="id" property="id"/>
		<id column="dept_name" property="departmentName"/>
		<collection property="emps" 
			select="com.dao.EmployeeMapperSelect.getEmpsByDeptId"
			column="{deptId=id}" >
		</collection>
	</resultMap>
	<!-- public Department getDeptByIdStep(Integer id); -->
	<select id="getDeptByIdStep" resultMap="MyDeptStep">
		select id,dept_name from tbl_dept where id=#{id}
	</select>

	//分步查詢返回帶有的集合(collection)
	@Test
	public void test09() throws IOException{
		SqlSessionFactory sqlSessionFactory=getSqlSessionFactory();
		SqlSession openSession=sqlSessionFactory.openSession();
		DepartmentMapper mapper=openSession.getMapper(DepartmentMapper.class);
		Department department=mapper.getDeptByIdStep(1);
		System.out.println(department);	
		System.out.println(department.getEmps());	
	}

 

擴展：
1)分步查詢中傳遞多個值得時候

<collection property=" " select=" " column="{key1=column1,key2=column2}" >

2)分步查詢中局部開啓延遲加載

fetchType="lazy" ：表示延遲加載
fetchType="lazy"：表示立即查詢

<collection property=" " select=" " column="{key1=column1,key2=column2}" fetchType="lazy">