# 1.查询补充
当你查询一条记录并且是简单查询时，情况相对简单，可以参考以下的例子：
`public Employee getEmpById(Integer id);`
对应的xml文件中：
```
<select id="getEmpById" resultType="com.mybatis.learn.bean.Employee">
select id, last_name lastName, gender, email from tbl_employee where id = #{id}
</select>
```
当查询多条记录时，可以参考以下方式：、
```
public List<Employee> getListByGender(String gender);
public Map<String, Object> getMapById(Integer id);
//该注解时指定封存记录的map的key
@MapKey("lastName")
public Map<String, Employee> getMap(String gender);
```
xml中：
```
<!-- 查询多条记录时，若是用list封装结果，resultType填写list中的每条记录的泛型的全类名 -->
<select id="getListByGender" resultType="com.mybatis.learn.bean.Employee">
select * from tbl_employee where gender=#{gender}
</select>
<!-- map存储查询结果时，单条记录可以直接在resultType中写map -->
<select id="getMapById" resultType="map">
select * from tbl_employee where id=#{id}
</select>
<!-- map存错多条查询结果时，reusltType指定的也是里面每条记录的泛型的全类名 -->
<select id="getMap" resultType="com.mybatis.learn.bean.Employee">
select * from tbl_employee where gender=#{gender}
</select>
```
# 2.resultType&resultMap
如果是简单查询，推荐使用resultType(resultMap也能使用，但是比较麻烦),使用方式在前面演示过了。
resultMap除了可以使用在简单查询情况下，也能使用在resultType不能胜任的地方，如：联合查询，关联查询等，举个例子：
查询员工信息时包含部门信息：
新建javaBean：
```
package com.mybatis.learn.bean;
import lombok.*;
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class Department {
private Integer deptId;
private String deptName;
}
```
在原来的Employee类添加新的属性department以及getter setter
`private Department deparment;`
建表sql:
```
CREATE TABLE `tbl_dept` (
`dept_id` int(11) unsigned NOT NULL,
`dept_name` varchar(255) DEFAULT NULL,
PRIMARY KEY (`dept_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
```
修改表tbl_employee ,新增字段dept_id;
此时，由于全部字段存在于两个表中，需要关联查询，已经创建的JavaBean没有一个能满足要
求，这时可以结合resultMap创建一个：
还是在EmployeeMapper.xml文件中：
```
<!--
场景一：
查询Employee的同时查询员工对应的部门
Employee===Department
一个员工有与之对应的部门信息；
id last_name gender dept_id dept_name (private Department dept;)
-->
<!--
联合查询：级联属性封装结果集
resultMap:
id标签：指定主键;
result标签：指定普通列
column:指定数据库中的列名
property:指定对应的JavaBean中的属性名
其实，指定id后再指定和数据库不一样的字段即可，不过推荐全部指定
-->
<!-- 方式一：关联查询-->
<resultMap id="myEmp" type="com.mybatis.learn.bean.Employee">
<id column="id" property="id"/>
<result column="last_name" property="lastName"/>
<result column="gender" property="gender"/>
<result column="email" property="email"/>
<result column="dept_id" property="dept.deptId"/>
<result column="dept_name" property="dept.deptName"/>
</resultMap>
<!-- 方式二：使用association定义关联的单个对象的封装规则；-->
<resultMap id="myEmp2" type="com.mybatis.learn.bean.Employee">
<id column="id" property="id"/>
<result column="last_name" property="lastName"/>
<result column="gender" property="gender"/>
<result column="email" property="email"/>
<!--
association可以指定联合的javaBean对象
property="dept"：指定哪个属性是联合的对象
javaType:指定这个属性对象的类型[不能省略]
-->
<association property="dept" javaType="com.mybatis.learn.bean.Department">
<id column="dept_id" property="deptId"/>
<result column="dept_name" property="deptName"/>
</association>
</resultMap>
<select id="getFullEmpById" resultMap="myEmp">
SELECT e.id, e.last_name, e.gender, e.email, d.dept_id, d.dept_name
FROM tbl_employee e LEFT JOIN tbl_dept d ON e.dept_id = d.dept_id
WHERE id = #{id}
</select>
<select id="getFullEmp2ById" resultMap="myEmp2">
SELECT e.id, e.last_name, e.gender, e.email, d.dept_id, d.dept_name
FROM tbl_employee e LEFT JOIN tbl_dept d ON e.dept_id = d.dept_id
WHERE id = #{id}
</select>
```
更改查询Mapper：
```
public Employee getFullEmp2ById(Integer id);
public Employee getFullEmpById(Integer id);
```
这时可以分别测试一下了。
当然，resultMap的意义还不止于此，比如你想分布查询时：
首先开启延迟加载：更改mybatis-config.xml文件:
```
<!--
设置延迟加载
显示的指定每个我们需要更改的配置的值，即使他是默认的。
防止版本更新带来的问题
-->
<setting name="lazyLoadingEnabled" value="true"/>
<setting name="aggressiveLazyLoading" value="false"/>
```
原理就是在一个查询中嵌套一个查询，并且在需要关联的字段时才去执行嵌套的查询：
```
//EmployeeMapper中新增的方法
public Employee getEmpByStep(Integer id);
//EmployeeMapper.xml中新增的内容：
<resultMap id="myEmpByStep" type="com.mybatis.learn.bean.Employee">
<id column="id" property="id"/>
<result column="last_name" property="lastName"/>
<result column="gender" property="gender"/>
<result column="email" property="email"/>
<association column="dept_id" property="dept"
select="com.mybatis.learn.dao.DepartmentMapper.getDeptById"/>
</resultMap>
<select id="getEmpByStep" resultMap="myEmpByStep">
select * from tbl_employee where id=#{id}
</select>
//你也发现了问题对不对，没有对应的嵌套的sql，OK，现在补齐：
//新增DepartmentMapper:
import com.mybatis.learn.bean.Department;
public interface DepartmentMapper {
public Department getDeptById(Integer deptId);
}
//以及对应的xml:
<select id="getDeptById" resultType="com.mybatis.learn.bean.Department">
select * from tbl_dept where dept_id=#{deptId}
</select>
```
ok,如何证明分布查询呢：
下面的例子将会证明：
```
@Test
public void testGetEmpByStep() {
String resources = "mybatis-config.xml";
InputStream inputStream = null;
try {
inputStream = Resources.getResourceAsStream(resources);
} catch (IOException e) {
e.printStackTrace();
}
SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
SqlSession session = sessionFactory.openSession(true);
EmployeeMapper mapper = session.getMapper(EmployeeMapper.class);
Employee emp = mapper.getEmpByStep(1);
System.out.println(emp.getEmail());
System.out.println(emp.getDept());
}
```
执行结果如下：
***第一次查询，不需要查询dept***
DEBUG 03-23 15:51:26,066 ==> Preparing: select * from tbl_employee where id=? (BaseJdbcLogger.java:159)
DEBUG 03-23 15:51:26,134 ==> Parameters: 1(Integer) (BaseJdbcLogger.java:159)
DEBUG 03-23 15:51:26,231 <== Total: 1 (BaseJdbcLogger.java:159)
***第一次的查询结果，打印了email***
eeee
***需要dept时，执行对应的sql***
DEBUG 03-23 15:51:26,232 ==> Preparing: select * from tbl_dept where dept_id=? (BaseJdbcLogger.java:159)
DEBUG 03-23 15:51:26,233 ==> Parameters: 1(Long) (BaseJdbcLogger.java:159)
DEBUG 03-23 15:51:26,236 <== Total: 1 (BaseJdbcLogger.java:159)
Department(deptId=1, deptName=组织部)
