Mybatis篇-（四）映射文件

﹏ヽ暗。殇╰゛Y 2023-10-04 12:35 35阅读 0赞

## 四、Mybatis-映射文件 ##

### 增删改查 ###

mapper.xml

<mapper namespace="com.cvzhanshi.mybatis.dao.EmployeeMapper">
    
    	<select id="getEmpById" resultType="com.cvzhanshi.mybatis.entity.Employee">
    		select id,last_name lastName,email,gender from employee where id = #{id}
    	</select>
    	
    	
    	
    	<update id="updateEmp">
    		update employee
    		set last_name=#{lastName},email=#{email},gender=#{gender}
    		where id=#{id}
    	</update>
    
    	
    	<delete id="deleteEmpById">
    		delete from employee where id=#{id}
    	</delete>
    
    </mapper>

EmployeeMapper.java接口

public interface EmployeeMapper {
        
    	
    	public Employee getEmpById(Integer id);
    
    	public Long addEmp(Employee employee);
    
    	public boolean updateEmp(Employee employee);
    
    	public void deleteEmpById(Integer id);
    }

测试：

@Test
    	public void test03() throws IOException{
    
    		SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
    		//1、获取到的SqlSession不会自动提交数据
    		SqlSession openSession = sqlSessionFactory.openSession();
    
    		try{
    			EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
    			//测试添加
    //			Employee employee = new Employee(null, "jerry4",null, "1");
    //			mapper.addEmp(employee);
    //			System.out.println(employee.getId());
    
    			//测试修改
    //			Employee employee = new Employee(1, "Tom", "jerry@atguigu.com", "0");
    //			boolean updateEmp = mapper.updateEmp(employee);
    //			System.out.println(updateEmp);
    			//测试删除
    			mapper.deleteEmpById(2);
    			//2、手动提交数据
    			openSession.commit();
    		}finally{
    			openSession.close();
    		}
    
    	}

> 说明：
> 
>  *  mybatis允许增删改直接定义以下类型返回值
>     
>      *  Integer（影响的行数）、Long（影响的行数）、Boolean（操作是否成功）、void
>  *  我们需要手动提交数据
>     
>      *  sqlSessionFactory.openSession();===》手动提交
>      *  sqlSessionFactory.openSession(true);===》自动提交

### 获取自增主键的值 ###

> 若数据库支持自动生成主键的字段（比如 MySQL 和 SQL Server），则可以设置 useGeneratedKeys=”true”，然后再把 keyProperty 设置到目标属性上

mapper.xml

<insert id="addEmp" parameterType="com.cvzhanshi.mybatis.entity.Employee"
    			useGeneratedKeys="true" keyProperty="id" databaseId="mysql">
    		insert into employee(last_name,email,gender)
    		values(#{lastName},#{email},#{gender})
    	</insert>

> 说明：
> 
>  *  mysql支持自增主键，自增主键值的获取，mybatis也是利用statement.getGenreatedKeys()；
>  *  useGeneratedKeys=“true”；使用自增主键获取主键值策略
>  *  keyProperty；指定对应的主键属性，也就是mybatis获取到主键值以后，将这个值封装给javaBean的哪个属性

测试：

@Test
    	public void test03() throws IOException{
        
    
    		SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
    		//1、获取到的SqlSession不会自动提交数据
    		SqlSession openSession = sqlSessionFactory.openSession();
    		try{
        
    			EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
    			//测试添加
    			Employee employee = new Employee(null, "cvzhanshi","cvzhanshi@qq.com", "1");
    			System.out.println("操作前-----" + employee.getId());
    			mapper.addEmp(employee);
    			System.out.println("操作后-----" + employee.getId());
    			//2、手动提交数据
    			openSession.commit();
    		}finally{
        
    			openSession.close();
    		}
    
    	}

运行效果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDA4Mzkw_size_16_color_FFFFFF_t_70]

### 获取非自增主键的值 ###

> 对于不支持自增型主键的数据库（例如 Oracle），则可以使用 selectKey 子元素： selectKey 元素将会首先运行，id 会被设置，然 后插入语句会被调用

mapper.xml

<insert id="addEmp" databaseId="oracle">
    		<selectKey keyProperty="id" order="BEFORE" resultType="Integer">
    			
    			
    			select EMPLOYEES_SEQ.nextval from dual 
    			
    		</selectKey>
    		
    		
    		
    		insert into employees(EMPLOYEE_ID,LAST_NAME,EMAIL) 
    		values(#{id},#{lastName},#{email}) 
    		
    	</insert>

**selectKey**

<table> 
 <thead> 
  <tr> 
   <th>属性</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>keyProperty</td> 
   <td>查出的主键值封装给javaBean的哪个属性</td> 
  </tr> 
  <tr> 
   <td>order</td> 
   <td>“BEFORE”:当前sql在插入sql之前运行<br>AFTER：当前sql在插入sql之后运行</td> 
  </tr> 
  <tr> 
   <td>resultType</td> 
   <td>查出的数据的返回值类型</td> 
  </tr> 
 </tbody> 
</table>

BEFORE运行顺序：  
先运行selectKey查询id的sql；查出id值封装给javaBean的id属性  
在运行插入的sql；就可以取出id属性对应的值  
AFTER运行顺序：  
先运行插入的sql（从序列中取出新值作为id）；  
再运行selectKey查询id的sql；

### 参数处理 ###

#### 参数的传递 ####

*  单个参数：mybatis不会做特殊处理
    
     *  \#\{参数名/任意名\}：取出参数值
 *  多个参数：mybatis会做特殊处理
    
     *  任意多个参数，都会被MyBatis重新包装成一个Map传入。 Map的key是param1，param2，0，1…，值就是参数的值
     *  操作时的异常
    
        异常：
        	org.apache.ibatis.binding.BindingException: 
        	Parameter 'id' not found. 
        	Available parameters are [1, 0, param1, param2]
            操作：
                方法：public Employee getEmpByIdAndLastName(Integer id,String lastName);
                取值：#{
              id},#{
              lastName}
 *  命名参数
    
     *  为参数使用@Param起一个名字，MyBatis就会将这些参数封 装进map中，key就是我们自己指定的名字
     *  使用：@Param(“id”)------> \#\{指定的key\}取出对应的参数值（key：使用@Param注解指定的值、value：参数值）
 *  POJO
    
     *  当这些参数属于我们业务POJO时，我们直接传递POJO
     *  \#\{属性名\}：取出传入的pojo的属性值
 *  Map
    
     *  如果多个参数不是业务模型中的数据，没有对应的pojo，不经常使用，为了方便，我们也可以传入map
     *  \#\{key\}：取出map中对应的值
 *  TO
    
     *  如果多个参数不是业务模型中的数据，但是经常要使用，推荐来编写一个TO（Transfer Object）数据传输对象
    
        Page{
              
        	int index;
        	int size;
        }

**思考案例**

*  public Employee getEmp(@Param(“id”)Integer id,String lastName);
    
     *  取值：id==>\#\{id/param1\} lastName==>\#\{param2\}
 *  public Employee getEmp(Integer id,@Param(“e”)Employee emp);
    
     *  取值：id==>\#\{param1\} lastName===>\#\{param2.lastName/e.lastName\}

> 特别注意：如果是Collection（List、Set）类型或者是数组，  
> 也会特殊处理。也是把传入的list或者数组封装在map中。  
> key：Collection（collection）,如果是List还可以使用这个key(list)、数组(array)

*  public Employee getEmpById(List`<Integer>`ids);
    
     *  取值：取出第一个id的值： \#\{list\[0\]\}

#### **结合源码，看看mybatis如何处理参数** ####

> 总结：参数多时会封装map，为了不混乱，我们可以使用@Param来指定封装时使用的key  
> \#\{key\}就可以取出map中的值；

解析：

传入的参数 (@Param(“id”)Integer id,@Param(“lastName”)String lastName);

ParamNameResolver解析参数封装map的；

*  names：\{0=id, 1=lastName\}；构造器的时候就确定好了
    
     *  确定流程
        
         *  获取每个标了param注解的参数的@Param的值：id，lastName； 赋值给name
         *  每次解析一个参数给map中保存信息：（key：参数索引，value：name的值）
            
             *  name的值：
                
                 *  标注了param注解：注解的值
                 *  没有标注
                    
                     *  全局配置：useActualParamName（jdk1.8）：name=参数名
                     *  name=map.size()；相当于当前元素的索引
             *  > 类似于\{0=id, 1=lastName,2=2\}

// 传入的参数   args【1，"Tom",'hello'】:
    //1、参数为null直接返回
    //2、如果只有一个元素，并且没有Param注解；args[0]：单个参数直接返回
    //3、多个元素或者有Param标注
    //3.1、遍历names集合；{0=id, 1=lastName,2=2}
    	//names集合的value作为key;  names集合的key又作为取值的参考args[0]:args【1，"Tom"】:
        //eg:{id=args[0]:1,lastName=args[1]:Tom,2=args[2]}
    	//额外的将每一个参数也保存到map中，使用新的key：param1...paramN
        //效果：有Param注解可以#{指定的key}，或者#{param1}
    
    public Object getNamedParams(Object[] args) {
        
        final int paramCount = names.size();
        //1、参数为null直接返回
        if (args == null || paramCount == 0) {
        
          return null;
         
        //2、如果只有一个元素，并且没有Param注解；args[0]：单个参数直接返回
        } else if (!hasParamAnnotation && paramCount == 1) {
        
          return args[names.firstKey()];
          
        //3、多个元素或者有Param标注
        } else {
        
          final Map<String, Object> param = new ParamMap<Object>();
          int i = 0;
          
          //4、遍历names集合；{0=id, 1=lastName,2=2}
          for (Map.Entry<Integer, String> entry : names.entrySet()) {
        
          
          	//names集合的value作为key;  names集合的key又作为取值的参考args[0]:args【1，"Tom"】:
          	//eg:{id=args[0]:1,lastName=args[1]:Tom,2=args[2]}
            param.put(entry.getValue(), args[entry.getKey()]);
            
            
            // add generic param names (param1, param2, ...)param
            //额外的将每一个参数也保存到map中，使用新的key：param1...paramN
            //效果：有Param注解可以#{指定的key}，或者#{param1}
            final String genericParamName = GENERIC_NAME_PREFIX + String.valueOf(i + 1);
            // ensure not to overwrite parameter named with @Param
            if (!names.containsValue(genericParamName)) {
        
              param.put(genericParamName, args[entry.getKey()]);
            }
            i++;
          }
          return param;
        }
      }
    }

#### $和\#的取值区别 ####

*  \#\{\}：可以获取map中的值或者pojo对象属性的值
 *  $\{\}：可以获取map中的值或者pojo对象属性的值

select * from tbl_employee where id=${id} and last_name=#{lastName}
    Preparing: select * from tbl_employee where id=2 and last_name=?

**区别**

*  \#\{\}:是以预编译的形式，将参数设置到sql语句中；PreparedStatement；防止sql注入
 *  $\{\}:取出的值直接拼装在sql语句中；会有安全问题（sql注入问题，和starment差不多）

> 大多情况下，我们去参数的值都应该去使用\#\{\}
> 
> 原生jdbc不支持占位符的地方我们就可以使用$\{\}进行取值
> 
> 比如分表、排序。。。；按照年份分表拆分
> 
> select \* from $\{year\}\_salary where xxx;  
> select \* from tbl\_employee order by $\{f\_name\} $\{order\}

#### \#\{\}:更丰富的用法–jdbcType ####

> 规定参数的一些规则：
> 
> javaType、 jdbcType、 mode（存储过程）、 numericScale、  
> resultMap、 typeHandler、 jdbcTypeName、 expression（未来准备支持的功能）

jdbcType通常需要在某种特定的条件下被设置：

在我们数据为null的时候，有些数据库可能不能识别mybatis对null的默认处理。比如Oracle（报错）

JdbcType OTHER：无效的类型；因为mybatis对所有的null都映射的是原生Jdbc的OTHER类型，oracle不能正确处理

由于全局配置中：jdbcTypeForNull=OTHER；oracle不支持；两种办法

*  \#\{email,jdbcType=OTHER\}
 *  jdbcTypeForNull=NULL  
    在全局配置文件中配置`<setting name="jdbcTypeForNull" value="NULL"/>`

### Select ###

*  Select元素来定义查询操作
 *  Id：唯一标识符
    
     *  – 用来引用这条语句，需要和接口的方法名一致
 *  parameterType：参数类型
    
     *  可以不传，MyBatis会根据TypeHandler自动推断
 *  resultType：返回值类型
    
     *  别名或者全类名，如果返回的是集合，定义集合中元 素的类型。不能和resultMap同时使用

#### selcet返回list ####

> resultType：如果返回的是一个集合，要写集合中元素的类型

示例：

marpper.xml

<select id="getEmpsByLastNameLike" resultType="com.cvzhanshi.mybatis.entity.Employee">
    		select * from employee where last_name like #{lastName}
    	</select>

测试

@Test
    	public void test04() throws IOException{
        
    
    		SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
    		//1、获取到的SqlSession不会自动提交数据
    		SqlSession openSession = sqlSessionFactory.openSession();
    
    		try{
        
    			EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
    
    			List<Employee> like = mapper.getEmpsByLastNameLike("%s%");
    			for (Employee employee : like) {
        
    				System.out.println(employee);
    			}
    		}finally{
        
    			openSession.close();
    		}
    	}

测试结果：  
![在这里插入图片描述][2021050700181199.png]

#### 记录封装成map ####

##### 返回一条记录的map；key就是列名，值就是对应的值 #####

> resultType为map

mapper.xml

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

测试：

测试结果  
![在这里插入图片描述][20210507001757704.png]

##### 多条记录封装一个map：Map<Integer,Employee>:键是这条记录的一个属性名，值是记录封装后的javaBean #####

> @MapKey:告诉mybatis封装这个map的时候使用哪个属性作为map的key
> 
> resultType为javaBean的全类名

接口方法中

//多条记录封装一个map：Map<Integer,Employee>:键是这条记录的主键，值是记录封装后的javaBean
    	//@MapKey:告诉mybatis封装这个map的时候使用哪个属性作为map的key
    	@MapKey("lastName")
    	public Map<String, Employee> getEmpByLastNameLikeReturnMap(String lastName);

mapper.xml

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

测试

@Test
    	public void test04() throws IOException{
        
    
    		SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
    		//1、获取到的SqlSession不会自动提交数据
    		SqlSession openSession = sqlSessionFactory.openSession();
    
    		try{
        
    			EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
    
    			Map<String, Employee> map = mapper.getEmpByLastNameLikeReturnMap("%s%");
    			Set<String> strings = map.keySet();
    			Iterator<String> iterator = strings.iterator();
    			while ((iterator.hasNext())){
        
    				String next = iterator.next();
    				System.out.println(next+ "=" +map.get(next));
    			}
    		}finally{
        
    			openSession.close();
    		}
    	}

测试效果：  
![在这里插入图片描述][20210507001740561.png]

#### resultMap-自定义结果映射规则 ####

> 使用场景：当mysql中表的列名与javaBean的属性名不对应时有两种解决方法：
> 
>  *  数据库字段命名规范，POJO属性符合驼峰命名法，如 A\_COLUMNaColumn，我们可以开启自动驼峰命名规 则映射功能，mapUnderscoreToCamelCase=true
>  *  使用resultMap自定义映射规则

*  resultMap
    
     *  type：自定义规则的Java类型
     *  id:唯一id方便引用

<resultMap type="com.atguigu.mybatis.bean.Employee" id="MySimpleEmp">
    		
    		<id column="id" property="id"/>
    		
    		<result column="last_name" property="lastName"/>
    		
    		<result column="email" property="email"/>
    		<result column="gender" property="gender"/>
    	</resultMap>
    
    	
    	
    	<select id="getEmpById"  resultMap="MySimpleEmp">
    		select * from employee where id=#{id}
    	</select>

测试

使用了resultMap  
![在这里插入图片描述][20210507001727925.png]

未使用则lastName为Null

#### resultMap-关联查询 ####

##### 级联属性封装结果 #####

> 场景一：
> 
> 查询Employee的同时查询员工对应的部门 Employee===Department 一个员工有与之对应的部门信息； id last\_name gender d\_id did dept\_name (private Department dept;)

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

xml

<resultMap type="com.cvzhanshi.mybatis.entity.Employee" id="MyDifEmp">
            <id column="id" property="id"/>
            <result column="last_name" property="lastName"/>
            <result column="gender" property="gender"/>
            <result column="did" property="dept.id"/>
            <result column="dept_name" property="dept.departmentName"/>
        </resultMap>
        
        
        <select id="getEmpAndDept" resultMap="MyDifEmp2">
            SELECT e.id id,e.last_name last_name,e.gender gender,e.d_id d_id,
    		d.id did,d.dept_name dept_name FROM employee e,dept d
    		WHERE e.d_id=d.id AND e.id=#{id}
    	</select>

测试

@Test
    	public void test05() throws IOException{
        
    		SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
    		SqlSession sqlSession = sqlSessionFactory.openSession();
    
            try{
        
                EmployeeMapperPlus mapper = sqlSession.getMapper(EmployeeMapperPlus.class);
    
                Employee empById = mapper.getEmpAndDept(1);
                System.out.println(empById);
            }finally{
        
                sqlSession.close();
            }
    	}

运行效果  
![在这里插入图片描述][202105070017107.png]

##### association定义关联的单个对象的封装规则 #####

<resultMap type="com.cvzhanshi.mybatis.entity.Employee" id="MyDifEmp2">
            <id column="id" property="id"/>
            <result column="last_name" property="lastName"/>
            <result column="gender" property="gender"/>
    
            
            <association property="dept" javaType="com.cvzhanshi.mybatis.entity.Department">
                <id column="did" property="id"/>
                <result column="dept_name" property="departmentName"/>
            </association>
        </resultMap>
        
        <select id="getEmpAndDept" resultMap="MyDifEmp2">
            SELECT e.id id,e.last_name last_name,e.gender gender,e.d_id d_id,
    		d.id did,d.dept_name dept_name FROM employee e,dept d
    		WHERE e.d_id=d.id AND e.id=#{id}
    	</select>

运行结果：  
![在这里插入图片描述][20210507001655858.png]

##### association进行分步查询 #####

xml

<resultMap type="com.cvzhanshi.mybatis.entity.Employee" id="MyEmpByStep">
            <id column="id" property="id"/>
            <result column="last_name" property="lastName"/>
            <result column="email" property="email"/>
            <result column="gender" property="gender"/>
            
            <association property="dept"
                         select="com.cvzhanshi.mybatis.dao.DepartmentMapper.getDeptById"
                         column="d_id">
            </association>
        </resultMap>
        
        <select id="getEmpByIdStep" resultMap="MyEmpByStep">
            select * from employee where id=#{id}
        </select>

DepartmentMapper.java

public interface DepartmentMapper {
        
    
        public Department getDeptById(Integer id);
    
    }

DepartmentMapper.xml

<mapper namespace="com.cvzhanshi.mybatis.dao.DepartmentMapper">
    
        
        <select id="getDeptById" resultType="com.cvzhanshi.mybatis.entity.Department">
    		select id,dept_name departmentName from dept where id=#{id}
    	</select>
    </mapper>

测试

@Test
    	public void test05() throws IOException{
        
    		SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
    		SqlSession sqlSession = sqlSessionFactory.openSession();
    
            try{
        
                EmployeeMapperPlus mapper = sqlSession.getMapper(EmployeeMapperPlus.class);
                Employee empByIdStep = mapper.getEmpByIdStep(4);
                System.out.println(empByIdStep);
                System.out.println(empByIdStep.getDept());
            }finally{
        
                sqlSession.close();
            }
    	}

运行结果  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDA4Mzkw_size_16_color_FFFFFF_t_70 1]

##### association-分段查询&延迟加载 #####

用分段查询的代码 只需要在全局文件中配置一下属性

> Employee==>Dept：  
> 我们每次查询Employee对象的时候，都将一起查询出来。  
> 部门信息在我们使用的时候再去查询；  
> 分段查询的基础之上加上两个配置：

测试

@Test
    	public void test05() throws IOException{
        
    		SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
    		SqlSession sqlSession = sqlSessionFactory.openSession();
    
            try{
        
                EmployeeMapperPlus mapper = sqlSession.getMapper(EmployeeMapperPlus.class);
                Employee empByIdStep = mapper.getEmpByIdStep(4);
                //只要employee的lastname属性
                System.out.println(empByIdStep.getLastName());
            }finally{
        
                sqlSession.close();
            }
    	}

未配置  
![在这里插入图片描述][2021050700162997.png]

> 发送了两条查询sql，并没有按需加载

配置了  
![在这里插入图片描述][20210507001620997.png]

> 只发送了一条查询employee的sql，达到了按需加载延迟加载

##### collection定义关联集合封装规则 #####

> 场景二： 查询部门的时候将部门对应的所有员工信息也查询出来

Department.java

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

DepartmentMapper.xml

<resultMap type="com.cvzhanshi.mybatis.entity.Department" id="MyDept">
            <id column="did" property="id"/>
            <result column="dept_name" property="departmentName"/>
            
            <collection property="emps" ofType="com.cvzhanshi.mybatis.entity.Employee">
                
                <id column="eid" property="id"/>
                <result column="last_name" property="lastName"/>
                <result column="email" property="email"/>
                <result column="gender" property="gender"/>
            </collection>
        </resultMap>
        
        <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 dept d
    		LEFT JOIN employee e
    		ON d.id=e.d_id
    		WHERE d.id=#{id}
    	</select>

测试

@Test
        public void test06() throws IOException{
        
            SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
            SqlSession sqlSession = sqlSessionFactory.openSession();
    
            try{
        
                DepartmentMapper mapper = sqlSession.getMapper(DepartmentMapper.class);
                Department deptByIdPlus = mapper.getDeptByIdPlus(1);
                System.out.println(deptByIdPlus);
                System.out.println(deptByIdPlus.getEmps());
    
            }finally{
        
                sqlSession.close();
            }
        }

运行效果  
![在这里插入图片描述][20210507001602280.png]

##### collection分段查询&延迟加载 #####

DepartmentMapper.xml

<resultMap type="com.cvzhanshi.mybatis.entity.Department" id="MyDeptStep">
            <id column="id" property="id"/>
            <id column="dept_name" property="departmentName"/>
            <collection property="emps"
                        select="com.cvzhanshi.mybatis.dao.EmployeeMapperPlus.getEmpsByDeptId"
                        column="{deptId=id}" fetchType="lazy"></collection>
        </resultMap>
        
        <select id="getDeptByIdStep" resultMap="MyDeptStep">
    		select id,dept_name from dept where id=#{id}
    	</select>

EmployeeMapperPlus.xml

<select id="getEmpsByDeptId" resultType="com.cvzhanshi.mybatis.entity.Employee">
    		select * from employee where d_id=#{deptId}
    	</select>

测试

@Test
        public void test06() throws IOException{
        
            SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
            SqlSession sqlSession = sqlSessionFactory.openSession();
    
            try{
        
                DepartmentMapper mapper = sqlSession.getMapper(DepartmentMapper.class);
                Department deptByIdStep = mapper.getDeptByIdStep(1);
                System.out.println(deptByIdStep.getDepartmentName());
                System.out.println(deptByIdStep.getEmps());
            }finally{
        
                sqlSession.close();
            }
        }

运行效果  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDA4Mzkw_size_16_color_FFFFFF_t_70 2]

> 扩展：多列的值传递过去：
> 
> 将多列的值封装map传递； column="\{key1=column1,key2=column2\}
> 
> "fetchType=“lazy”：表示使用延迟加载； - lazy：延迟 - eager：立即

##### discriminator鉴别器 #####

> 情景：
> 
> 封装Employee：  
> 如果查出的是女生：就把部门信息查询出来，否则不查询；  
> 如果是男生，把last\_name这一列的值赋值给email;

EmployeeMapperPlus.xml

<resultMap type="com.cvzhanshi.mybatis.entity.Employee" id="MyEmpDis">
            <id column="id" property="id"/>
            <result column="last_name" property="lastName"/>
            <result column="email" property="email"/>
            <result column="gender" property="gender"/>
            
            <discriminator javaType="string" column="gender">
                
                <case value="0" resultType="com.cvzhanshi.mybatis.entity.Employee">
                    <association property="dept"
                                 select="com.cvzhanshi.mybatis.dao.DepartmentMapper.getDeptById"
                                 column="d_id">
                    </association>
                </case>
                
                <case value="1" resultType="com.cvzhanshi.mybatis.entity.Employee">
                    <id column="id" property="id"/>
                    <result column="last_name" property="lastName"/>
                    <result column="last_name" property="email"/>
                    <result column="gender" property="gender"/>
                </case>
            </discriminator>
        </resultMap>
    
    
    
        <select id="getEmpByIdStep" resultMap="MyEmpDis">
            select * from employee where id=#{id}
        </select>

测试

@Test
    	public void test05() throws IOException{
        
    		SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
    		SqlSession sqlSession = sqlSessionFactory.openSession();
    
            try{
        
                EmployeeMapperPlus mapper = sqlSession.getMapper(EmployeeMapperPlus.class);
                Employee empByIdStep = mapper.getEmpByIdStep(1);
                System.out.println(empByIdStep.getLastName());
                System.out.println(empByIdStep.getDept());
            }finally{
        
                sqlSession.close();
            }
    	}

运行效果

女生时：  
![在这里插入图片描述][20210507001458990.png]  
男生时：  
![在这里插入图片描述][20210507001448818.png]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDA4Mzkw_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20210507001903330.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDA4Mzkw,size_16,color_FFFFFF,t_70
[2021050700181199.png]: https://img-blog.csdnimg.cn/2021050700181199.png
[20210507001757704.png]: https://img-blog.csdnimg.cn/20210507001757704.png
[20210507001740561.png]: https://img-blog.csdnimg.cn/20210507001740561.png
[20210507001727925.png]: https://img-blog.csdnimg.cn/20210507001727925.png
[202105070017107.png]: https://img-blog.csdnimg.cn/202105070017107.png
[20210507001655858.png]: https://img-blog.csdnimg.cn/20210507001655858.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDA4Mzkw_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20210507001641243.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDA4Mzkw,size_16,color_FFFFFF,t_70
[2021050700162997.png]: https://img-blog.csdnimg.cn/2021050700162997.png
[20210507001620997.png]: https://img-blog.csdnimg.cn/20210507001620997.png
[20210507001602280.png]: https://img-blog.csdnimg.cn/20210507001602280.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDA4Mzkw_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20210507001549118.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NDA4Mzkw,size_16,color_FFFFFF,t_70
[20210507001458990.png]: https://img-blog.csdnimg.cn/20210507001458990.png
[20210507001448818.png]: https://img-blog.csdnimg.cn/20210507001448818.png