【MyBatis】篇三.自定义映射resultMap和动态SQL

谁借莪１个温暖的怀抱￠ 2023-10-08 19:13 43阅读 0赞

> = = = =MyBatis整理= = = =  
>   
> [篇一.MyBatis环境搭建与增删改查][.MyBatis]  
> [篇二.MyBatis查询与特殊SQL][.MyBatis_SQL]  
> [篇三.自定义映射resultMap和动态SQL][._resultMap_SQL]  
> [篇四.MyBatis缓存和逆向工程][.MyBatis 1]

#### 文章目录 ####

*  1、自定义映射
 *   *  P1:测试数据准备
     *  P2:字段和属性的映射关系
     *  P3:多对一的映射关系
     *  P4:一对多的映射关系
 *  2、动态SQL
 *   *  2.1 IF标签
     *  2.2 where标签
     *  2.3 trim标签
     *  2.4 choose、when、otherwise标签
     *  2.5 foreach标签
     *  2.6 SQL标签

## 1、自定义映射 ##

若字段名和实体类的属性名不一致，则需要自定义映射。

### P1:测试数据准备 ###

员工表：  
![在这里插入图片描述][4b72fae3c4324a2fba233256fe6502b9.png]  
部门表：  
![在这里插入图片描述][14c8caa0d4624a9e8fb984875973a020.png]

定义对应的实体类：（注意，字段名是下划线命名，属性名是驼峰命名，不再一致了）  
![在这里插入图片描述][556ac4db770440eda291b7a83edbf941.png]

定义Mapper接口和映射文件：

![在这里插入图片描述][d4880973fb5540c0b7d5f04354013339.png]

### P2:字段和属性的映射关系 ###

当字段名和实体类中的属性名不一致，但是字段名符合数据库的规则（使用\_），实体类中的属性名符合Java的规则（使用驼峰），此时使用之前的自动映射resultType，则命名不一致的属性值为null，解决思路有三种：

> **`思路一：给字段名起别名，使其和属性名保持一致`**

<select id="getAllEmp" resultType="Emp">
    	select eid,emp_name empName,age,sex,email from t_emp
    </select>

> **`思路二：设置全局配置`**，将下划线\_自动映射为驼峰

在核心配置文件mybatis-config.xml中：

此时，SQL语句正常写即可。

> **`思路三：使用resultMap`**，不再使用之前的resultType做自动映射

<resultMap id="empResultMap" type="Emp">
    	<id property="eid" column="eid"></id>
    	<result property="empName" column="emp_name"></result>
    	<result property="age" column="age"></result>
    	<result property="sex" column="sex"></result>
    	<result property="email" column="email"></result>
    </resultMap>
    
    <select id="getAllEmp" resultMap="empResultMap">
    	select * from t_emp
    </select>

resultMap即设置自定义映射关系：

*  属性：  
    。 id：我定义的映射的唯一标识，不能重复，给select标签中的resultMap属性用  
    。 type：查询的数据要映射的实体类的类型
 *  子标签：  
    。 id：设置主键的映射关系  
    。 result：设置普通字段的映射关系
 *  子标签属性：  
    。 property：设置映射关系中实体类中的属性名  
    。 column：设置映射关系中表中的字段名

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

### P3:多对一的映射关系 ###

多对一的时候，在’多’的这边设置，设置’一’所对应的对象；在’一’那边，设置’多’的对象集合 。处理多对一的映射关系（如查询企业员工信息及其部门）有三种实现方式：

public class Emp {
          
    	private Integer eid;  
    	private String empName;  
    	private Integer age;  
    	private String sex;  
    	private String email;  
    	/**
    	* 这里设置'一'所对应的对象
    	*/
    	private Dept dept;
    	//...构造器、get、set方法等
    }

> **`思路一：使用级联属性赋值`**

<resultMap id="empAndDeptResultMapOne" type="Emp">
    	<id property="eid" column="eid"></id>
    	<result property="empName" column="emp_name"></result>
    	<result property="age" column="age"></result>
    	<result property="sex" column="sex"></result>
    	<result property="email" column="email"></result>
    	<result property="dept.did" column="did"></result>
    	<result property="dept.deptName" column="dept_name"></result>
    </resultMap>
    
    <select id="getEmpAndDept" resultMap="empAndDeptResultMapOne">
    	select * from t_emp left join t_dept on t_emp.did = t_dept.did where t_emp.eid = #{eid}
    </select>

> **`思路二：通过association处理多对一的映射`**

*  association：处理多对一映射关系
 *  property：需要处理多对一映射关系的属性名
 *  javaType：该属性的类型

<resultMap id="empAndDeptResultMapTwo" type="Emp">
    	<id property="eid" column="eid"></id>
    	<result property="empName" column="emp_name"></result>
    	<result property="age" column="age"></result>
    	<result property="sex" column="sex"></result>
    	<result property="email" column="email"></result>
    	<association property="dept" javaType="Dept">
    		<id property="did" column="did"></id>
    		<result property="deptName" column="dept_name"></result>
    	</association>
    </resultMap>
    
    <select id="getEmpAndDept" resultMap="empAndDeptResultMapTwo">
    	select * from t_emp left join t_dept on t_emp.did = t_dept.did where t_emp.eid = #{eid}
    </select>

`以上的逻辑是：`在association中写要处理多对一关系的属性名dept，再说明该属性的Java类---->知道类型，通过反射拿到该类型的属性did和deptName---->将查询出来的字段赋值给属性---->Dept类的对象有了---->赋值给属性dept

> **`思路三：分步查询处理多对一的映射`**

先查询员工信息–>拿到部门id–>根据部门id查询部门信息—>将信息赋值给dept属性

引用属性--那个属性的值也是一个对象，丈夫是一个对象:
    有姓名属性、年龄属性、妻子属性。妻子属性就是一个引用属性，里面是个对象，有它自己的属性

//EmpMapper里的方法
    /**
     * 通过分步查询，员工及所对应的部门信息
     * 分步查询第一步：查询员工信息
     */
    Emp getEmpAndDeptByStepOne(@Param("eid") Integer eid);

*  property：即要处理多对一映射关系的属性名
 *  `select`：即设置分布查询的sql的唯一标识（namespace.SQLId或mapper接口的全类名.方法名）
 *  `column`：设置分布查询的条件，要根据员工表的did去查询部门信息，即第二个SQL要根据什么去查

<resultMap id="empAndDeptByStepResultMap" type="Emp">
    	<id property="eid" column="eid"></id>
    	<result property="empName" column="emp_name"></result>
    	<result property="age" column="age"></result>
    	<result property="sex" column="sex"></result>
    	<result property="email" column="email"></result>
    	<association property="dept"
    				 select="com.llg.mybatis.mapper.DeptMapper.getEmpAndDeptByStepTwo"
    				 column="did"></association>
    </resultMap>
    
    <select id="getEmpAndDeptByStepOne" resultMap="empAndDeptByStepResultMap">
    	select * from t_emp where eid = #{eid}
    </select>

第二步：

//DeptMapper里的方法
    /**
     * 通过分步查询，员工及所对应的部门信息
     * 分步查询第二步：通过did查询员工对应的部门信息
     * 这里的查询结果要给Emp的dept属性赋值，所以返回类型Dept
     */
    Dept getEmpAndDeptByStepTwo(@Param("did") Integer did);

<resultMap id="EmpAndDeptByStepTwoResultMap" type="Dept">
    	<id property="did" column="did"></id>
    	<result property="deptName" column="dept_name"></result>
    </resultMap>
    
    <select id="getEmpAndDeptByStepTwo" resultMap="EmpAndDeptByStepTwoResultMap">
    	select * from t_dept where did = #{did}
    </select>

测试类：

@Test
    public void testGetEmpAndDeptByStep() {
        
    	SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    	EmpMapper empMapper = sqlSession.getMapper(EmpMapper.class);
    	Emp emp = emmpMapper.getEmpAndDeptByStepOne(5);
    	System.out.println(emp);
    }

运行结果：  
![在这里插入图片描述][c7be91f456c64cb485fcc9d3d57f9ef4.png]  
梳理下逻辑：  
![在这里插入图片描述][05d0eeb1afc748268f365482bcdfc691.png]

> **分步查询的好处–延迟加载**

分步查询，实现一个功能分了两步，但这两步各自也是一个单独的功能。这就分步查询的好处—`实现延迟加载`

在核心配置文件中配置全局信息（setting标签）：

*  **lazyLoadingEnabled**：延迟加载的全局开关。当开启时，所有关联对象都会延迟加载
 *  **aggressiveLazyLoading**：当开启时，任何方法的调用都会加载该对象的所有属性。 否则，每个属性会按需加载

此时：我只获取员工名称，可以发现第二句SQL并未执行，这就是按需加载，获取的数据是什么，就只会执行相应的sql

![在这里插入图片描述][7b4391b7b59a47f4924aa727f83855c7.png]

而当获取部门信息的时候，两句就都会执行。为了清晰看到效果，先关掉延迟加载，可以看到是两句SQL都执行完了，再拿数据：  
![在这里插入图片描述][71bfa7bdc1124ec1b96d77f8f203f7b2.png]

再开启延迟加载，可以看到是先执行了一句SQL，拿到了员工姓名，后面需要部门信息的时候，又执行了第二句SQL，这就是按需加载！！！  
![在这里插入图片描述][478a173d5f2744b99063f2ef090cdce7.png]  
更改了全局设置，是否延迟加载则是对所有SQL的。**当开启了全局的延迟加载（注意fetchType的前提是开启全局）**，要想单独控制某一个，可通过association和collection中的fetchType属性设置当前的分步查询是否使用延迟加载：

*  **fetchType**=“lazy(延迟加载)”
 *  **fetchType**=“eager(立即加载)”

### P4:一对多的映射关系 ###

多对一的时候，在’多’的这边设置，设置’一’所对应的对象；在’一’那边，设置’多’的对象集合 。

public class Dept {
        
        private Integer did;
        private String deptName;
        //'多'的类型的集合
        private List<Emp> emps;
    	//...构造器、get、set方法等
    }

> **`思路一：使用collection`**

*  collection：处理一对多的映射关系
 *  ofType：表示该属性所对应的集合中存储的数据的类型

public interface DeptMapper{
        
    	/**
    	* 查询部门即其下的所有员工信息
    	*/
    	Dept getDeptAndEmp(@Param("did") Integer did);
    }

<resultMap id="DeptAndEmpResultMap" type="Dept">
    	<id property="did" column="did"></id>
    	<result property="deptName" column="dept_name"></result>
    	<collection property="emps" ofType="Emp">
    		<id property="eid" column="eid"></id>
    		<result property="empName" column="emp_name"></result>
    		<result property="age" column="age"></result>
    		<result property="sex" column="sex"></result>
    		<result property="email" column="email"></result>
    	</collection>
    </resultMap>
    
    <select id="getDeptAndEmp" resultMap="DeptAndEmpResultMap">
    	select * from t_dept left join t_emp on t_dept.did = t_emp.did where t_dept.did = #{did}
    </select>

> **`思路二：分步查询`**

第一步：

public interface DeptMapper{
        
    	/**
     	* 通过分步查询，查询部门及对应的所有员工信息
     	* 分步查询第一步：查询部门信息
     	*/
    	Dept getDeptAndEmpByStepOne(@Param("did") Integer did);
    }

<resultMap id="DeptAndEmpByStepOneResultMap" type="Dept">
    	<id property="did" column="did"></id>
    	<result property="deptName" column="dept_name"></result>
    	<collection property="emps"
    				select="com.llg.mybatis.mapper.EmpMapper.getDeptAndEmpByStepTwo"
    				column="did"></collection>
    </resultMap>
    
    <select id="getDeptAndEmpByStepOne" resultMap="DeptAndEmpByStepOneResultMap">
    	select * from t_dept where did = #{did}
    </select>

第二步：

public interface EmpMapper{
        
    
    	/**
    	 * 通过分步查询，查询部门及对应的所有员工信息
    	 * 分步查询第二步：根据部门id查询部门中的所有员工
    	 */
    	List<Emp> getDeptAndEmpByStepTwo(@Param("did") Integer did);
    }

<select id="getDeptAndEmpByStepTwo" resultType="Emp">
    	select * from t_emp where did = #{did}
    </select>

结果：  
![在这里插入图片描述][222c9d1e8a2240e1a3db869caa318048.png]  
当然，分布查询在这儿也可以得到验证：  
![在这里插入图片描述][dd3339d936cf4e938f832537fcf65380.png]

--------------------

## 2、动态SQL ##

Mybatis框架的动态SQL技术是一种**根据特定条件动态拼装SQL语句**的功能，它存在的意义是为了解决拼接SQL语句字符串时的痛点问题

### 2.1 IF标签 ###

public interface DynamicSQLMapper{
        
    	/**
    	* 多条件查询
    	*/
    	List<Emp> getEmpByCondition(Emp emp);
    }

*  if标签可通过`test属性`对表达式进行判断，若表达式的结果为true，则标签中的内容会拼接到SQL中，反之标签中的内容不会拼接。
 *  在where后面添加一个`恒成立条件1=1`，这个条件不会影响查询结果，而又可以很好的拼接后面的SQL：当empName传过来为空，select \* from t\_emp where and age = ? and sex = ? and email = ?，此时where与and连用，SQL语法错误

<select id="getEmpByCondition" resultType="Emp">
    	select * from t_emp where 1=1
    	<if test="empName != null and empName !=''">
    		and emp_name = #{empName}
    	</if>
    	<if test="age != null and age !=''">
    		and age = #{age}
    	</if>
    	<if test="sex != null and sex !=''">
    		and sex = #{sex}
    	</if>
    	<if test="email != null and email !=''">
    		and email = #{email}
    	</if>
    </select>

测试：  
![在这里插入图片描述][9716cca42e8e4db09f23e4c076416571.png]

### 2.2 where标签 ###

当where标签中有内容时，会自动生成where关键字，并将内容前多余的and或者or去掉，而当where标签中没内容时，where关键字也就不再生成。

<select id="getEmpByCondition" resultType="Emp">
    	select * from t_emp
    	<where>
    		<if test="empName != null and empName !=''">
    			emp_name = #{empName}
    		</if>
    		<if test="age != null and age !=''">
    			and age = #{age}
    		</if>
    		<if test="sex != null and sex !=''">
    			and sex = #{sex}
    		</if>
    		<if test="email != null and email !=''">
    			and email = #{email}
    		</if>
    	</where>
    </select>

where标签和if标签一般配合使用：

*  若where标签中的if条件都不满足，则where标签没有任何功能，即不会添加where关键字
 *  若where标签中的if条件满足，则where标签会自动添加where关键字，并将条件最前方多余的and/or去掉

<if test="empName != null and empName !=''">
    emp_name = #{empName} and
    </if>
    <if test="age != null and age !=''">
    	age = #{age}
    </if>

当empName有值，age为空，则SQL为：

select * from d_emp where emp_name="llg" and
    //此处where标签去不掉and了

### 2.3 trim标签 ###

trim用于去掉或添加标签中的内容，当标签中有内容的时候：

*  prefix：在trim标签中的内容的前面添加某些指定内容
 *  suffix：在trim标签中的内容的后面添加某些指定内容
 *  prefixOverrides：在trim标签中的内容的前面去掉某些指定内容
 *  suffixOverrides：在trim标签中的内容的后面去掉某些指定内容

当标签中没有内容的时候，trim标签也没有任何效果

<select id="getEmpByCondition" resultType="Emp">
    	select * from t_emp
    	<trim prefix="where" suffixOverrides="and|or">
    		<if test="empName != null and empName !=''">
    			emp_name = #{empName} and
    		</if>
    		<if test="age != null and age !=''">
    			age = #{age} and
    		</if>
    		<if test="sex != null and sex !=''">
    			sex = #{sex} or
    		</if>
    		<if test="email != null and email !=''">
    			email = #{email}
    		</if>
    	</trim>
    </select>

测试类：

//测试类
    @Test
    public void getEmpByCondition() {
        
    	SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    	DynamicSQLMapper mapper = sqlSession.getMapper(DynamicSQLMapper.class);
    	List<Emp> emps= mapper.getEmpByCondition(new Emp(null, "甲", null, null, null, null));
    	System.out.println(emps);
    }

![在这里插入图片描述][c5bfd7ec89ee44a9be9a0bd67e4bc8f0.png]

### 2.4 choose、when、otherwise标签 ###

choose…when…otherwise相当于if…else if…else

*  when即if或者else if，至少要有一个，when后面的test条件成立，则拼接
 *  otherwise相当于else，最多只能有一个

<select id="getEmpByChoose" resultType="Emp">
    	select * from t_emp
    	<where>
    		<choose>
    			<when test="empName != null and empName != ''">
    				emp_name = #{empName}
    			</when>
    			<when test="age != null and age != ''">
    				age = #{age}
    			</when>
    			<when test="sex != null and sex != ''">
    				sex = #{sex}
    			</when>
    			<when test="email != null and email != ''">
    				email = #{email}
    			</when>
    			<otherwise>
    				did = 1
    			</otherwise>
    		</choose>
    	</where>
    </select>

测试程序：

@Test
    public void getEmpByChoose() {
        
    	SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    	DynamicSQLMapper mapper = sqlSession.getMapper(DynamicSQLMapper.class);
    	List<Emp> emps = mapper.getEmpByChoose(new Emp(null, "", null, "", "", null));
    	System.out.println(emps);
    }

结果：  
![在这里插入图片描述][0a4e4281e35e4873817b6aee1c6d78ce.png]

### 2.5 foreach标签 ###

`foreeach标签`的属性有：

*  collection：设置要循环的数组或集合
 *  item：表示集合或数组中的每一个数据
 *  separator：设置循环体之间的分隔符，分隔符前后默认有一个空格，如,
 *  open：设置foreach标签中的内容的开始符
 *  close：设置foreach标签中的内容的结束符

> **通过数组实现批量删除**

public interface DynamicSQLMapper{
        
    	/**
    	* 通过数组实现批量删除
    	*/
    	int deleteMoreByArray(List<Integer> eids);
    }

只论SQL，批量删除的实现可以通过以下两种写法：

delete from t_emp where eid in (6,7,8);

delte from t_emp where eid=6 or eid=7 or eid=8;

**关于第一种SQL的实现：**

![在这里插入图片描述][5d7694e19dc44f8ead2f220e6b239682.png]  
优化一下：

<delete id="deleteMoreByArray">
    	delete from t_emp where 
    	<foreach collection="eids" item="eid" separator="or">
    		eid = #{eid}
    	</foreach>
    </delete>

**关于第二种SQL的实现：**

<delete id="deleteMoreByArray">
    	delete from t_emp where eid in
    	<foreach collection="eids" item="eid" separator="," open="(" close=")">
    		#{eid}
    	</foreach>
    </delete>

测试：

@Test
    public void deleteMoreByArray() {
        
    	SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    	DynamicSQLMapper mapper = sqlSession.getMapper(DynamicSQLMapper.class);
    	int result = mapper.deleteMoreByArray(new Integer[]{
        6, 7, 8});
    	System.out.println(result);
    }

结果：  
![在这里插入图片描述][3629e8eefeaf487488deebc47fbbf47e.png]

![在这里插入图片描述][6ba5fb93a16542208888b23df47489b7.png]

> **通过集合实现批量插入**

public interface DynamicSQLMapper{
        
    	/**
    	* 通过集合实现批量添加
    	*/
    	int insertMoreByList(List<Emp> emps);
    }

只说SQL，写法应该是：

insert into t_emp values
    	(a1,a2,a3),
    	(b1,b2,b3),
    	(v1,v2,v3);

使用foreach动态实现：

<insert id="insertMoreByList">
    	insert into t_emp values
    	<foreach collection="emps" item="emp" separator=",">
    		(null,#{emp.empName},#{emp.age},#{emp.sex},#{emp.email},null)
    	</foreach>
    </insert>

注意，这里不用open和close，批量插入的原SQL是每条数据中有括号，即每次循环有括号，而不是删除SQL中的开头和结尾有括号。

//测试程序
    @Test
    public void insertMoreByList() {
        
    	SqlSession sqlSession = SqlSessionUtils.getSqlSession();
    	DynamicSQLMapper mapper = sqlSession.getMapper(DynamicSQLMapper.class);
    	Emp emp1 = new Emp(null,"a",1,"男","123@321.com",null);
    	Emp emp2 = new Emp(null,"b",1,"男","123@321.com",null);
    	List<Emp> emps = Arrays.asList(emp1, emp2);
    	int result = mapper.insertMoreByList(emps);
    	System.out.println(result);
    }

结果：  
![在这里插入图片描述][06742449a9194b5dbe991a5e88158497.png]

### 2.6 SQL标签 ###

在映射文件中，声明一段SQL片段，把常用的一段SQL进行记录，在要使用的地方使用include标签进行引入。

*  声明

<sql id="empColumns">eid,emp_name,age,sex,email</sql>

*  引用

<select id="getEmpByCondition" resultType="Emp">
    	select <include refid="empColumns"></include> from t_emp
    </select>

[.MyBatis]: https://blog.csdn.net/llg___/article/details/129309486
[.MyBatis_SQL]: https://blog.csdn.net/llg___/article/details/129351560
[._resultMap_SQL]: https://blog.csdn.net/llg___/article/details/129389959
[.MyBatis 1]: https://blog.csdn.net/llg___/article/details/129426977
[4b72fae3c4324a2fba233256fe6502b9.png]: https://img-blog.csdnimg.cn/4b72fae3c4324a2fba233256fe6502b9.png
[14c8caa0d4624a9e8fb984875973a020.png]: https://img-blog.csdnimg.cn/14c8caa0d4624a9e8fb984875973a020.png
[556ac4db770440eda291b7a83edbf941.png]: https://img-blog.csdnimg.cn/556ac4db770440eda291b7a83edbf941.png
[d4880973fb5540c0b7d5f04354013339.png]: https://img-blog.csdnimg.cn/d4880973fb5540c0b7d5f04354013339.png
[658cd8a599cc42abac3141776dac9c88.png]: https://img-blog.csdnimg.cn/658cd8a599cc42abac3141776dac9c88.png
[c7be91f456c64cb485fcc9d3d57f9ef4.png]: https://img-blog.csdnimg.cn/c7be91f456c64cb485fcc9d3d57f9ef4.png
[05d0eeb1afc748268f365482bcdfc691.png]: https://img-blog.csdnimg.cn/05d0eeb1afc748268f365482bcdfc691.png
[7b4391b7b59a47f4924aa727f83855c7.png]: https://img-blog.csdnimg.cn/7b4391b7b59a47f4924aa727f83855c7.png
[71bfa7bdc1124ec1b96d77f8f203f7b2.png]: https://img-blog.csdnimg.cn/71bfa7bdc1124ec1b96d77f8f203f7b2.png
[478a173d5f2744b99063f2ef090cdce7.png]: https://img-blog.csdnimg.cn/478a173d5f2744b99063f2ef090cdce7.png
[222c9d1e8a2240e1a3db869caa318048.png]: https://img-blog.csdnimg.cn/222c9d1e8a2240e1a3db869caa318048.png
[dd3339d936cf4e938f832537fcf65380.png]: https://img-blog.csdnimg.cn/dd3339d936cf4e938f832537fcf65380.png
[9716cca42e8e4db09f23e4c076416571.png]: https://img-blog.csdnimg.cn/9716cca42e8e4db09f23e4c076416571.png
[c5bfd7ec89ee44a9be9a0bd67e4bc8f0.png]: https://img-blog.csdnimg.cn/c5bfd7ec89ee44a9be9a0bd67e4bc8f0.png
[0a4e4281e35e4873817b6aee1c6d78ce.png]: https://img-blog.csdnimg.cn/0a4e4281e35e4873817b6aee1c6d78ce.png
[5d7694e19dc44f8ead2f220e6b239682.png]: https://img-blog.csdnimg.cn/5d7694e19dc44f8ead2f220e6b239682.png
[3629e8eefeaf487488deebc47fbbf47e.png]: https://img-blog.csdnimg.cn/3629e8eefeaf487488deebc47fbbf47e.png
[6ba5fb93a16542208888b23df47489b7.png]: https://img-blog.csdnimg.cn/6ba5fb93a16542208888b23df47489b7.png
[06742449a9194b5dbe991a5e88158497.png]: https://img-blog.csdnimg.cn/06742449a9194b5dbe991a5e88158497.png