1.动态Sql
1.1:判断元素:if元素,choose元素
1.2:拼关键字:where元素,set元素,trim元素
1.3:循环:foreach元素(list,array,Map)
eg:<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="dao.TstudentMapper">
<!--配置resultmap结果集-->
<resultMap id="tstudentMap" type="bean.Tstudent">
<id column="sid" jdbcType="INTEGER" property="sid" />
<result column="sname" jdbcType="VARCHAR" property="sname" />
<result column="sage" jdbcType="INTEGER" property="sage" />
<result column="sex" jdbcType="CHAR" property="sex" />
<result column="address" jdbcType="VARCHAR" property="address" />
<result column="cid" jdbcType="INTEGER" property="cid" />
</resultMap>
<select id="findBystudent1" parameterType="bean.Tstudent" resultMap="tstudentMap">
<!-- select sid,sname,sage,sex,address,cid from t_student where 1=1-->
<!-- <!–test后面条件判断的是传入参数的属性名–>-->
<!-- <if test="sage!=null">-->
<!-- and sage=#{sage}-->
<!-- </if>-->
<!-- <if test="sex!=null">-->
<!-- and sex=#{sex}-->
<!-- </if>-->
select sid,sname,sage,sex,address,cid from t_student
<!--where标签可以去除多余and关键字-->
<where>
<!--test后面条件判断的是传入参数的属性名-->
<if test="sage!=null">
and sage=#{sage}
</if>
<if test="sex!=null">
and sex=#{sex}
</if>
</where>
</select>
<select id="findByAgeAndSex" parameterType="bean.Tstudent" resultMap="tstudentMap">
select sid,sname,sage,sex,address,cid from t_student where sname=#{sname}
<!--test后面条件判断的是传入参数的属性名-->
<choose>
<when test="sage!=null">
and sage=#{sage}
</when>
<when test="sex!=null">
and sex=#{sex}
</when>
</choose>
</select>
<update id="updateStudent" parameterType="bean.Tstudent">
update t_student
<!--set标签可以去掉多余逗号,set标签中所有条件都不满足,就会报错-->
<set>
<if test="sname!=null">
sname=#{sname},
</if>
<if test="sage!=null">
sage=#{sage},
</if>
<if test="sex!=null">
sex=#{sex},
</if>
<if test="address!=null">
address=#{address},
</if>
<if test="cid!=null">
cid=#{cid},
</if>
</set>
where sid=#{sid}
</update>
<insert id="insertStudent" parameterType="bean.Tstudent">
insert into t_student
<!--trim标签可以拼sql,prefix表示拼接开始,suffix拼接结束,suffixOverrides表示可以忽略条件中结尾多余逗号,prefixOverrides表示可以忽略条件中开始多余xx-->
<trim prefix="(" suffix=")" suffixOverrides=",">
<if test="sname!=null">
sname,
</if>
<if test="sage!=null">
sage,
</if>
<if test="sex!=null">
sex,
</if>
<if test="address!=null">
address,
</if>
<if test="cid!=null">
cid,
</if>
</trim>
<trim prefix="values(" suffix=")" suffixOverrides=",">
<if test="sname!=null">
#{sname},
</if>
<if test="sage!=null">
#{sage},
</if>
<if test="sex!=null">
#{sex},
</if>
<if test="address!=null">
#{address},
</if>
<if test="cid!=null">
#{cid},
</if>
</trim>
</insert>
<!--用foreach操作list集合的参数-->
<select id="findStudentByIds1" parameterType="java.util.ArrayList" resultMap="tstudentMap">
select sid,sname,sage,sex,address,cid from t_student where sid in
<!--collection指定是参数是集合,还是数组,还map集合.如果是list集合,collection的值为list;如果是数组,collection的值为array;如果是map集合,collection的值为map的key;-->
<!--item属性表示集合或数组中每个遍历的当前元素,index当前遍历的元素的索引,open参数开始拼接,close参数结束拼接,separator参数与参数之间分隔符-->
<foreach collection="list" item="item1" index="index1" open="(" close=")" separator="," >
#{item1}
</foreach>
</select>
<select id="findStudentByIds2" resultMap="tstudentMap">
select sid,sname,sage,sex,address,cid from t_student where sid in
<foreach collection="array" item="item2" index="index2" open="(" close=")" separator=",">
#{item2}
</foreach>
</select>
<select id="findStudentByIds3" parameterType="java.util.Map" resultMap="tstudentMap">
select sid,sname,sage,sex,address,cid from t_student where sid in
<foreach collection="mapkey1" item="item3" index="index3" open="(" close=")" separator=",">
#{item3}
</foreach>
</mapper>
/**
* 根据条件(指定几个sid)查询学生信息,参数list集合
*/
@Test
public void findStudentByIds1(){
//准备集合存要查询学生编号
List<Integer> ids=new ArrayList<>();
ids.add(1);
ids.add(11);
ids.add(21);
ids.add(31);
//创建会话对象
SqlSession session=factory.openSession();
//创建接口映射器
TstudentMapper tm=session.getMapper(dao.TstudentMapper.class);
//用映射器调用接口方法
List<Tstudent> slist=tm.findStudentByIds1(ids);
slist.stream().forEach(System.out::println);
}
/**
* 根据条件(指定几个sid)查询学生信息,参数数组
*/
@Test
public void findStudentByIds2(){
//准备数组存要查询学生编号
Integer[] ids={2,12,22,32};
//创建会话对象
SqlSession session=factory.openSession();
//创建接口映射器
TstudentMapper tm=session.getMapper(dao.TstudentMapper.class);
//用映射器调用接口方法
List<Tstudent> slist=tm.findStudentByIds2(ids);
slist.stream().forEach(System.out::println);
}
/**
* 根据条件(指定几个sid)查询学生信息,参数map集合
*/
@Test
public void findStudentByIds3(){
//准备集合存要查询学生编号
List<Integer> ids=new ArrayList<>();
ids.add(1);
ids.add(11);
ids.add(21);
ids.add(31);
Map<String,List<Integer>> hmap=new HashMap();
hmap.put("mapkey1",ids);
//创建会话对象
SqlSession session=factory.openSession();
//创建接口映射器
TstudentMapper tm=session.getMapper(dao.TstudentMapper.class);
//用映射器调用接口方法
List<Tstudent> slist=tm.findStudentByIds3(hmap);
slist.stream().forEach(System.out::println);
}
2.MyBatis关联映射
2.1:主键映射：在插入数据时,获得主键.
注意:为了保证sql效率,如果不需要自动生成的主键,可以不用主键.如果需要 主键,用主键映射.
<!--第一种:主键映射,在插入数据时,获得刚生成的主键-->
<insert id="insertStudent1" parameterType="bean.Tstudent">
<selectKey keyProperty="sid" resultType="int" order="AFTER">
select last_insert_id()
</selectKey>
insert into t_student(sname,sage,sex,address,cid)
values(#{sname},#{sage},#{sex},#{address},#{tclass.cid});<!--tclass是传入参数Tstudent的属性,也是班级对象,tclass.cid调出的是班级编号-->
</insert>
<!--第二种:主键映射,在插入数据时,获得刚生成的主键-->
<insert id="insertStudent2" parameterType="bean.Tstudent" useGeneratedKeys="true" keyProperty="sid">
insert into t_student(sname,sage,sex,address,cid)
values(#{sname},#{sage},#{sex},#{address},#{tclass.cid});<!--tclass是传入参数Tstudent的属性,也是班级对象,tclass.cid调出的是班级编号-->
</insert>
2.2:关联映射:根据表中公共列,将公共列映射成当前类的一个对象属性.在查询当前对象时, 顺带查询对象属性.eg:查询学生信息时,顺带查询与学生相关班级信息
2.2.1:嵌套查询:查询多次.缺点:n+1查询,查询效率比较低.
eg:<!--配置resultmap结果集-->
<resultMap id="tstudentMap" type="bean.Tstudent">
<id column="sid" jdbcType="INTEGER" property="sid" />
<result column="sname" jdbcType="VARCHAR" property="sname" />
<result column="sage" jdbcType="INTEGER" property="sage" />
<result column="sex" jdbcType="CHAR" property="sex" />
<result column="address" jdbcType="VARCHAR" property="address" />
<!--关联映射第一种:嵌套查询-->
<!--association表示当前的属性是一个对象属性,property属性名,javaType属性全限制类型,column表示当前的属性是通过这个列映射过来,select表示查询当前这个对象属性的sql语句的id名-->
<association property="tclass" javaType="bean.Tclass" column="cid" select="selectClassByCid">
</association>
</resultMap>
<!--关联映射第一种:嵌套查询--><!--前提:Tclass的属性名与查询出列名一致-->
<select id="selectClassByCid" parameterType="int" resultType="bean.Tclass">
select cid,cname from t_class where cid=#{cid}
</select>
<select id="findStudentByid1" parameterType="int" resultMap="tstudentMap">
select sid,sname,sage,sex,address,cid from t_student where sid=#{sid}
</select>
2.2.2:嵌套结果:只查询一次,联表查询.
<!--配置resultmap结果集-->
<resultMap id="tstudentMap" type="bean.Tstudent">
<id column="sid" jdbcType="INTEGER" property="sid" />
<result column="sname" jdbcType="VARCHAR" property="sname" />
<result column="sage" jdbcType="INTEGER" property="sage" />
<result column="sex" jdbcType="CHAR" property="sex" />
<result column="address" jdbcType="VARCHAR" property="address" />
<!--关联映射第二种:嵌套结果-->
<!--association表示当前的属性是一个对象属性,property属性名,javaType属性全限制类型,column表示当前的属性是通过这个列映射过来,select表示查询当前这个对象属性的sql语句的id名-->
<association property="tclass" javaType="bean.Tclass" column="cid">
<id column="cid" property="cid"></id>
<result column="cname" property="cname"></result>
</association>
</resultMap>
<select id="findStudentByid2" parameterType="int" resultMap="tstudentMap">
select s.sid,s.sname,s.sage,s.sex,s.address,c.cid,c.cname
from t_student s
inner join t_class c on s.cid=c.cid
where sid=#{sid}
</select>
2.3:集合映射
2.3.1:嵌套查询:执行n+1查询,效率低.
eg:<!--配置resultmap结果集-->
<resultMap id="tclassMap" type="bean.Tclass">
<id column="cid" jdbcType="INTEGER" property="cid" />
<result column="cname" jdbcType="VARCHAR" property="cname" />
<!--集合映射的第一种:嵌套查询-->
<!--collection标签表示当前属性是集合属性,property表示属性名,javaType表示当前属性类型,ofType表示当前集合属性中每个元素的类型,column公共列名,select表示查询关联数据时调用sql的名-->
<collection property="slist" javaType="java.util.ArrayList" ofType="bean.Tstudent" column="cid" select="selectStudentsByCid">
</collection>
</resultMap>
<!--集合映射的第一种:嵌套查询-->
<select id="selectStudentsByCid" parameterType="int" resultType="bean.Tstudent">
select sid,sname,sage,sex,address,cid from t_student where cid=#{cid}
</select>
<select id="findClassById1" parameterType="int" resultMap="tclassMap">
select cid,cname from t_class where cid=#{cid}
</select>
2.3.2:嵌套结果:联表查询
eg:<!--配置resultmap结果集-->
<resultMap id="tclassMap" type="bean.Tclass">
<id column="cid" jdbcType="INTEGER" property="cid" />
<result column="cname" jdbcType="VARCHAR" property="cname" />
<!--集合映射的第二种:嵌套结果-->
<!--collection标签表示当前属性是集合属性,property表示属性名,javaType表示当前属性类型,ofType表示当前集合属性中每个元素的类型,column公共列名,select表示查询关联数据时调用sql的名-->
<collection property="slist" javaType="java.util.ArrayList" ofType="bean.Tstudent" column="cid">
<id column="sid" jdbcType="INTEGER" property="sid" />
<result column="sname" jdbcType="VARCHAR" property="sname" />
<result column="sage" jdbcType="INTEGER" property="sage" />
<result column="sex" jdbcType="CHAR" property="sex" />
<result column="address" jdbcType="VARCHAR" property="address" />
</collection>
</resultMap>
<select id="findClassById2" parameterType="int" resultMap="tclassMap">
select c.cid,c.cname,s.sid,s.sname,s.sage,s.sex,s.address
from t_class c
inner join t_student s on c.cid=s.cid
where c.cid=#{cid}
</select>
2.4:在Mybatis连表查询的结果有几种接收结果的方式:
2.4.1:对象接收结果:输出模板对象.pojo对象(与表对象实体对象,公共列映射成对象 或集合).
2.4.2:用Map接收结果:List<Map<String,Object>>第一行结果对应一个Map集合,有多 行结果就有多个map集合,共同组成list集合.
3.性能优化
3.1:延迟加载:只查询主要数据,在真正使用相关联数据的时候才发起查询，不用的时候不查询关联的数据，延迟加载又叫按需查询（懒加载）
第一步:在核心配置文件中设置延迟加载
<!-- 全局参数配置：延迟加载 -->
<settings>
<!--配置相关联的懒加载-->
<setting name="lazyLoadingEnabled" value="true"/>
<!--属性按需要加载-->
<setting name="aggressiveLazyLoading" value="false"/>
</settings>
第二步:在sql映射文件中,用嵌套查询来实现延迟加载.
注意:在输出对象时,或者调用toString时会触发及时加载,失懒加载失效
<!--指定对象的方法(默认值：equals,clone,hashCode,toString)触发一次延迟加载。-->
<setting name="lazyLoadTriggerMethods" value="" />
3.2:使用association和collection进行延迟加载:嵌套查询,先查询主要数据,如果需要关联数据时,再调用嵌套的sql来查询关联数据.
3.3:一级缓存(SqlSession):默认启动
3.3.1:一级缓存的执行原理图
3.3.2:一级缓存区原理:
3.3.3:一级缓存的失效:
当用户执行添加,修改,删除sql后调用commit时,清空一级缓存;
当调用sqlSession对象的close()时,清空一级缓存.
eg:/**
* 测试一级缓存
*/
@Test
public void sessionMethod1(){
//创建会话对象
SqlSession session=factory.openSession();
//创建接口映射器
TstudentMapper tm=session.getMapper(dao.TstudentMapper.class);
//第一次查询编号为3的学生信息,缓存中没有,从数据库中查询,执行查询的sql语句
Tstudent stu3=tm.findStudentByid1(3);
System.out.println("学生信息为:"+stu3);
/*因为执行插入语句后调用了commit,清空了一级缓存sqlSession*/
//准备学生对象
Tstudent stu1=new Tstudent();
stu1.setSname("亮哥");
stu1.setSage(20);
stu1.setSex("男");
stu1.setAddress("深圳");
Tclass tclass=new Tclass();
tclass.setCid(1);
stu1.setTclass(tclass);
//用映射器调用接口方法
int result=tm.insertStudent2(stu1);
//提交事务
session.commit();
//第二次查询编号为3的学生信息,如果缓存中有,就直接从缓存拿数据,不执行sql语句
Tstudent stu2=tm.findStudentByid1(3);
System.out.println("学生信息为:"+stu2);
}
3.4:二级缓存(Mapper):手动开启.作用:减少应用程序与数据交互的次数,提高访问速度和性能.
3.4.1:二级缓存的工作原理
3.4.2:二级缓存区的原理
注意:为什么执行insert,update,delete的sql语句之后会清空二级缓存区,原因是 在MyBatis的insert,update,delete的sql语句的flashCache="true",如果你不想在执行insert,update,delete的sql语句之后清空二级缓存区,那么你需要手动在当前sql语句中设置flashCache="false".
3.4.3:二级缓存的使用步骤:
第一步:在mybatis的核心配置文件中配置二级缓存
<settings>
<!-- 开启二级缓存总开关 -->
<setting name="cacheEnabled" value="true"/>
</settings>
第二步:在映射文件中配置<cache></cache>
cache 标签有多个属性
eviction: 缓存回收策略，有这几种回收策略
LRU - 最近最少回收，移除最长时间不被使用的对象
FIFO - 先进先出，按照缓存进入的顺序来移除它们
SOFT - 软引用，移除基于垃圾回收器状态和软引用规则的对象
WEAK - 弱引用，更积极的移除基于垃圾收集器和弱引用规则的对象
默认是 LRU 最近最少回收策略
flushinterval 缓存刷新间隔，缓存多长时间刷新一次，默认不清空，设置一个毫秒值
readOnly: 是否只读；true 只读，MyBatis 认为所有从缓存中获取数据的操作都是只读操作，不会修改数据。MyBatis 为了加快获取数据，直接就会将数据在缓存中的引用交给用户。不安全，速度快。读写(默认)：MyBatis 觉得数据可能会被修改
size : 缓存存放多少个元素
type: 指定自定义缓存的全类名(实现Cache 接口即可)
blocking：阻塞缓存, 若缓存中找不到对应的key，是否会一直blocking，直到有对应的数据进入缓存。
第三步:只有实现序列化接口(java.io.Serializable)的类的对象才能进行二级缓存.
3.4.4:禁用二级缓存:在mybatis的sql语句中用属性useCache=false，可以禁用当前 select语句的二级缓存,默认是true.
eg:<!--在sql中用useCache="false"属性设置二级缓存失效,表示这条sql语句查询出的数据不会保存到 二级缓存区中-->
<select id="findStudentByid1" parameterType="int" resultMap="tstudentMap" useCache="false">
select sid,sname,sage,sex,address,cid from t_student where sid=#{sid}
</select>
3.4.5:刷新二级缓存:在mybatis的sql语句中用属性flushCache=true可以刷新当前的二级缓存,默认情况下如果是select语句，那么flushCache是false。
如果是insert、update、delete语句，那么flushCache是true。
注意:在查询的sql语句中用useCache=false禁用sql的二级缓存时,它是查询数据后,不将数据存在二级缓存区中;在查询的sql语句中用flushCache=true刷新当前的二级缓存区,查询时会将数据存在二级缓存区,只是每次执行这个查询时,先清二级缓存区再查询.但是他们达到的效果都可以使用二级缓存失效.
3.4.6:二级缓存的应用场景:对于访问响应速度要求高，但是实时性不高的查询，可以采用二级缓存技术。(表中数据增加,修改,删除比较少,查询比较频繁,且 要求查询效率高时就用二级缓存技术.)
注意：在使用二级缓存的时候，要设置一下刷新间隔（cache标签中有一个 flashInterval属性）来定时刷新二级缓存，这个刷新间隔根据具体需 求来设置，比如设置30分钟、60分钟等，单位为毫秒,防止产生脏数 据。
3.4.7:二级缓存的局限:Mybatis二级缓存对细粒度的数据级别的缓存实现不好.(如果当前数据比较多,访问比较频繁(查询),不方便用二级缓存.因为每次刷新缓存区时,会将整个缓存区所有数据全刷新,不能实现只刷新更改的数据,这时就可以用第三方缓存容器,eg:redis).
4.扩展:
4.1:查询sql的简写:
eg:<!--将要查询的列存在一个sql标签中,哪个sql语句要用这些列,在sql中引入-->
<sql id="studentColum">
sid,sname,sage,sex,address,cid
</sql>
<select id="findStudentByid1" parameterType="int" resultMap="tstudentMap">
select
<!--用include标签引入要查询的列-->
<include refid="studentColum"></include>
from t_student where sid=#{sid}
</select>
4.2:在mybatis的核心配置文件中给全限定类名取别名
<!--给类或包取别名-->
<typeAliases>
<!--第一种:给限定类名取别名
<typeAlias type="bean.Tclass" alias="tc1"></typeAlias>-->
<!--第二种:扫描包,可以直接用类名作为别名,用作sql的返回类型-->
<package name="bean"/>
<!--第三种:如果当前扫描包中及其子包中有相同类名时,直接用类名作为别名会冲突,配合在类上用注解 @alias("别名")-->
</typeAliases>
@Alias("tc2")
public class Tclass implements Serializable {
}
<!--关联映射第一种:嵌套查询-->
<select id="selectClassByCid" parameterType="int" resultType="别名(tc1/Tclass/tc2)">
select cid,cname from t_class where cid=#{cid}
</select>