= = = =MyBatis整理= = = =

篇一.MyBatis环境搭建与增删改查
 篇二.MyBatis查询与特殊SQL
篇三.自定义映射resultMap和动态SQL
篇四.MyBatis缓存和逆向工程

文章目录

1、自定义映射
2、动态SQL

1、自定义映射

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

P1:测试数据准备

员工表：

部门表：

定义对应的实体类：（注意，字段名是下划线命名，属性名是驼峰命名，不再一致了）

定义Mapper接口和映射文件：

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

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

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

<!--List<Emp> getAllEmp();-->
<select id="getAllEmp" resultType="Emp">
	select eid,emp_name empName,age,sex,email from t_emp
</select>

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

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

<settings>
        <!--将表中字段的下划线自动转换为驼峰-->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
</settings>

<!--注意这种只能转换规范命名，即emp_name映射为empName-->

此时，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>
<!--List<Emp> getAllEmp();-->
<select id="getAllEmp" resultMap="empResultMap">
	select * from t_emp
</select>

<!--注意别只写不一样的属性，一样的也得写一遍-->

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

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

运行结果：

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>
<!--Emp getEmpAndDept(@Param("eid")Integer eid);-->
<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>
<!--Emp getEmpAndDept(@Param("eid")Integer eid);-->
<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>
<!--Emp getEmpAndDeptByStepOne(@Param("eid") Integer eid);-->
<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仅是处理字段和属性的映射关系,不想写就开启setting后使用resultType-->
<resultMap id="EmpAndDeptByStepTwoResultMap" type="Dept">
	<id property="did" column="did"></id>
	<result property="deptName" column="dept_name"></result>
</resultMap>
<!--Dept getEmpAndDeptByStepTwo(@Param("did") Integer did);-->
<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);
}

运行结果：

梳理下逻辑：

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

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

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

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

<settings>
	<!--开启延迟加载-->
	<setting name="lazyLoadingEnabled" value="true"/>
	<setting name="aggressiveLazyLoading" value="false"/>
</settings>

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

而当获取部门信息的时候，两句就都会执行。为了清晰看到效果，先关掉延迟加载，可以看到是两句SQL都执行完了，再拿数据：

再开启延迟加载，可以看到是先执行了一句SQL，拿到了员工姓名，后面需要部门信息的时候，又执行了第二句SQL，这就是按需加载！！！

更改了全局设置，是否延迟加载则是对所有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>
<!--Dept getDeptAndEmp(@Param("did") Integer did);-->
<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>
<!--Dept getDeptAndEmpByStepOne(@Param("did") Integer did);-->
<select id="getDeptAndEmpByStepOne" resultMap="DeptAndEmpByStepOneResultMap">
	select * from t_dept where did = #{did}
</select>

第二步：

public interface EmpMapper{

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

<!--List<Emp> getDeptAndEmpByStepTwo(@Param("did") Integer did);-->
<select id="getDeptAndEmpByStepTwo" resultType="Emp">
	select * from t_emp where did = #{did}
</select>

结果：

当然，分布查询在这儿也可以得到验证：

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语法错误

<!--List<Emp> getEmpByCondition(Emp emp);-->
<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>

测试：

2.2 where标签

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

<!--List<Emp> getEmpByCondition(Emp emp);-->
<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去掉

<!--这种用法是错误的，只能去掉条件前面的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标签也没有任何效果

<!--List<Emp> getEmpByCondition(Emp emp);-->
<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);
}

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>
<!--注意这里不用加and或者or了，没意义，if分支中一个就结束了-->

测试程序：

@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);
}

结果：

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的实现：

优化一下：

<!--int deleteMoreByArray(Integer[] eids);-->
<delete id="deleteMoreByArray">
	delete from t_emp where 
	<foreach collection="eids" item="eid" separator="or">
		eid = #{eid}
	</foreach>
</delete>

关于第二种SQL的实现：

<!--int deleteMoreByArray(Integer[] eids);-->
<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);
}

结果：

通过集合实现批量插入

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

只说SQL，写法应该是：

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

使用foreach动态实现：

<!--int insertMoreByList(@Param("emps") List<Emp> emps);-->
<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);
}

结果：

2.6 SQL标签

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

声明

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

引用

<!--List<Emp> getEmpByCondition(Emp emp);-->
<select id="getEmpByCondition" resultType="Emp">
	select <include refid="empColumns"></include> from t_emp
</select>