MyBatis 动态SQL和缓存机制实例详解

有的时候需要根据要查询的参数动态的拼接SQL语句

常用标签:

- if:字符判断

- choose【when...otherwise】:分支选择

- trim【where,set】:字符串截取,其中where标签封装查询条件,set标签封装修改条件

- foreach:

if案例

1)在EmployeeMapper接口文件添加一个方法

public Student getStudent(Student student);

2)如果要写下列的SQL语句,只要是不为空,就作为查询条件,如下所示,这样写实际上是有问题的,所以我们要写成动态SQL语句:

<select id="getEmployeeByConditionIf" resultType="com.neuedu.entity.Employee">
    select *from tbl_employee where id = #{id} and user_name = #{userName} and email = #{email} and gender = #{gender}
</select>

3)用if标签改写为动态SQL,如下所示:

test:判断表达式(OGNL):OGNL参照PPT或者官方文档。

test从参数中取值进行判断

遇见特殊符号,应该去写转义字符:如<>分别为&lt,&gt

<select id="getStudent" resultType="com.neuedu.mybatis.entity.Student">
   SELECT *
   FROM student
    where
      <if test="id != null">
         id=#{id}
      </if>
      <if test="name !=null and name!=''">
         and name=#{name}
      </if>
      <if test="password !=null and password !=''">
         and password=#{password}
      </if>
      <if test="email !=null and email !=''">
         and email=#{email}
      </if>
</select>

4)测试代码

@Test
public void TestgetStudent(){
   StudentMapper bean = ioc.getBean(StudentMapper.class);
   Student student = new Student(4,"jack", "111", "jack@qq.com");
   System.out.println(student);
   Student student2 = bean.getStudent(student);
   System.out.println(student2);
}
 #测试结果没问题,

但是仔细来说,上面的sql语句是有问题的,当我们不给动态sql语句传递id值的时候,sql语句的拼装就会有问题!【name前有一个and】

- where 标签

解决办法

1.给where后面加上1=1,以后的条件都可以使用and xxx了

2.可以使用 where 标签来将所有的查询条件包括在内

mybatis就会将where标签中拼装的sql,多出来的and或者or去掉!

<select id="getStudent" resultType="com.neuedu.mybatis.entity.Student">
   SELECT *
   FROM student
   <where>
      <if test="id != null">
         id=#{id}
      </if>
      <if test="name !=null and name!=''">
         and name=#{name}
      </if>
      <if test="password !=null and password !=''">
         and password=#{password}
      </if>
      <if test="email !=null and email !=''">
         and email=#{email}
      </if>
   </where>
</select>

3.需要注意:where标签只会去掉第一个多出来的and或者or

也就是说使用where标签有时候还是不能解决问题的,那怎么办呢?我们这里可以使用trim标签!

- trim标签:可以自定义字符串的截取规则

后面多出的and或者or where标签不能够解决
    prefix="":前缀:trim标签体是整个字符串拼串后的结果。
    prefix给拼串后的整个字符串加一个前缀
    prefixOverrides="":前缀覆盖:去掉整个字符串前面多余的字符
    suffix="":后缀
    suffix给拼串后的整个字符串加一个后缀
    suffixOverrides="":后缀覆盖:去掉整个字符串后面多余的字符

<select id="getStudent" resultType="com.neuedu.mybatis.entity.Student">
   SELECT *
   FROM student
   <trim prefix="where" prefixOverrides="and">
      <if test="id != null">
         id=#{id}
      </if>
      <if test="name !=null and name!=''">
         and name=#{name}
      </if>
      <if test="password !=null and password !=''">
         and password=#{password}
      </if>
      <if test="email !=null and email !=''">
         and email=#{email}
      </if>
   </trim>
</select>

- choose标签:分支选择,类似于Java中的带了break的switch...case

相当于确保了第一个case 符合之后,就跳出

案例演示:

1.在EmployeeMapper接口中添加一个方法

public List<Student> getStus(Student student);

2.sql映射文件

<select id="getStus" resultType="com.neuedu.mybatis.entity.Student">
   select * from student
   <where>
      <choose>
         <when test="id !=null">
            id = #{id}
         </when>
         <when test="name !=null and name!=''">
            name = #{name}
         </when>
         <when test="password !=null and password!=''">
            password = #{password}
         </when>
         <when test="email !=null and email!=''">
            email = #{email}
         </when>
         <otherwise>
            1 = 1
         </otherwise>
      </choose>
   </where>
</select>

- set标签:字符串截取,可以写在trim里面

set元素会动态前置set关键字,同时也会消除无关的逗号

1)在EmployeeMapper中添加一个更新的方法

public void updateStu(Student student);

2)在sql映射文件中,填写相应的sql语句,如下所示【set标签可以将字段后面的逗号去掉】

<update id="updateStu">
   update student
   <set>
      <if test="name !=null and name!=''">
         name=#{name},
      </if>
      <if test="password !=null and password !=''">
         password=#{password},
      </if>
      <if test="email !=null and email !=''">
         email=#{email}
      </if>
   </set>
      where id = #{id}
</update>

3)测试类代码为

@Test
public void TestUpdateStu(){
   StudentMapper bean = ioc.getBean(StudentMapper.class);
   bean.updateStu(new Student(4, "jackk", null, null));
}

将set标签用trim标签代替

<update id="updateStu">
   update student
   <trim prefix="set" suffixOverrides=",">
      <if test="name !=null and name!=''">
         name=#{name},
      </if>
      <if test="password !=null and password !=''">
         password=#{password},
      </if>
      <if test="email !=null and email !=''">
         email=#{email}
      </if>
   </trim>
      where id = #{id}
</update>

- foreach:遍历元素

动态SQL的另一个常用的操作是需要对一个集合进行遍历,通常在构建in条件语句的时候!

foreach元素允许指定一个集合,声明集合项和索引变量,并可以指定开闭匹配的字符串以及在迭代之间放置分隔符。

案例演示:

1.在EmployeeMapper接口中加入一个方法

public List<Student> getStuByIdForEach(@Param("ids")List<Integer> ids);

2.在MyBatis的sql映射文件中写相应的代码

<select id="getStuByIdForEach" resultType="com.neuedu.mybatis.entity.Student">
   select * from student
   where id
   in
   <foreach collection="ids" item="id" open="(" close=")" separator=",">
      #{id}
   </foreach>
</select>

3.测试类代码

@Test
public void getStuByIdForEach(){
   StudentMapper bean = ioc.getBean(StudentMapper.class);
   List<Integer> list = Arrays.asList(16,17,18,19);
   List<Student> stuByIdForEachlist = bean.getStuByIdForEach(list);
   for (Student student : stuByIdForEachlist) {
      System.out.println(student);
   }
}

foreach标签还可以用于批量保存数据,

1.在EmployeeMapper接口类中添加批量插入的方法

public void insertStus(@Param("stus")List<Student> student);

2.在EmployeeMapper.xml的sql映射文件中添加响应的语句

foreach 中用 collection,collection中是从Mapper接口传来的参数,separator是去掉中间符号

<insert id="insertStus">
   insert into student (name,password,email) values
   <foreach collection="stus" item="stu" separator=",">
      (#{stu.name},#{stu.password},#{stu.email})
   </foreach>
</insert>

3.测试代码

@Test
public void TestInsertStus(){
   StudentMapper bean = ioc.getBean(StudentMapper.class);
   List<Student> list = new ArrayList<Student>();
   list.add(new Student("123","123", "123"));
   list.add(new Student("123","123", "123"));
   list.add(new Student("123","123", "123"));
   bean.insertStus(list);
}

MyBatis-缓存机制  

MyBatis 包含一个非常强大的查询缓存特性,它可以非常方便地配置和定制。缓存可以极大的提升查询效率。

只在MyBatis中,在SSM整合文件中没用,因为SqlSession 定义在 bean.xml中,无法重新定义SqlSession

MyBatis系统中默认定义了两级缓存。

一级缓存和二级缓存

一级缓存:(本地缓存):SqlSession级别的缓存,一级缓存是一直开启的,没法关闭。方法之间不共用!

与数据库同一次会话期间查询到的数据放在本地缓存中。

以后如果需要获取相同的数据,直接从缓存中拿,没必要再去查询数据库;

    二级缓存(全局缓存): 

–1、默认情况下,只有一级缓存(SqlSession级别的缓存,也称为本地缓存)开启。

–2、二级缓存需要手动开启和配置,他是基于namespace级别的缓存。

–3、为了提高扩展性。MyBatis定义了缓存接口Cache。我们可以通过实现Cache接口来自定义二级缓存。

一级缓存:

案例:测试一级缓存【默认是开启的】

将返回一条select查询语句,

将返回true,说明emp与emp2是缓存,而不是重新查找

@Test
public void TestFirstCache(){
   SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
   session = sqlSessionFactory.openSession();
   mapper = session.getMapper(EmployeeMapper.class);
   Employee emp = mapper.getEmpInfoById(4);
   System.out.println(emp);
   Employee emp2 = mapper.getEmpInfoById(4);
   System.out.println(emp2);
   System.out.println(emp == emp2);
   session.commit();
   session.close();
}

一级缓存失效的情况【4种】(没有使用到当前一级缓存的情况,效果就是,还需要再向数据库发出查询)

1.sqlSession不同,重新定义SqlSession

将返回两条select语句

将返回false,说明emp2不是emp的缓存

@Test
public void TestFirstCache(){
   SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
   session = sqlSessionFactory.openSession();
   mapper = session.getMapper(EmployeeMapper.class);
   Employee emp = mapper.getEmpInfoById(4);
   System.out.println(emp);
   SqlSession session2 = sqlSessionFactory.openSession();
   EmployeeMapper mapper2 = session2.getMapper(EmployeeMapper.class);
   Employee emp2 = mapper2.getEmpInfoById(4);
   System.out.println(emp2);
   System.out.println(emp == emp2);
   session.commit();
   session.close();
}

2.SqlSession相同,但是查询条件不一样[当前缓存中还没有这个数据]

就是相当于根据不同条件再次查找

@Test
public void TestFirstCache(){
   SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
   session = sqlSessionFactory.openSession();
   mapper = session.getMapper(EmployeeMapper.class);
   Employee emp = mapper.getEmpInfoById(4);
   System.out.println(emp);
   Employee emp2 = mapper.getEmpInfoById(16);
   System.out.println(emp2);
   System.out.println(emp == emp2);
   session.commit();
   session.close();
}

3.SqlSession相同,但是两次查询之间执行了增删改操作【这次增删改可能对当前数据有影响】

因为默认自动刷新了缓存

@Test
public void TestFirstCache(){
   SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
   session = sqlSessionFactory.openSession();
   mapper = session.getMapper(EmployeeMapper.class);
   Employee emp = mapper.getEmpInfoById(4);
   System.out.println(emp);
   mapper.deleteEmp(16);
   Employee emp2 = mapper.getEmpInfoById(4);
   System.out.println(emp2);
   System.out.println(emp == emp2);
   session.commit();
   session.close();
}

4.SqlSession相同,手动清除了一级缓存[缓存清空]

手动清除了缓存,所以得重新查找

@Test
public void TestFirstCache(){
   SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
   session = sqlSessionFactory.openSession();
   mapper = session.getMapper(EmployeeMapper.class);
   Employee emp = mapper.getEmpInfoById(4);
   System.out.println(emp);
   session.clearCache();
   Employee emp2 = mapper.getEmpInfoById(4);
   System.out.println(emp2);
   System.out.println(emp == emp2);
   session.commit();
   session.close();
}

二级缓存:

【全局缓存】:基于namespace级别的缓存:一个namespace对应一个二级缓存。

【一级缓存的范围还是太小了,每次SqlSession一关闭,一级缓存中的数据就消失】

所以从这个角度讲:能跨sqlSession的缓存为二级缓存!

工作机制:

1.一个会话,查询一条数据,这个数据就会被放在当前会话的一级缓存中。

2.如果会话关闭,一级缓存中的数据会被保存到二级缓存中;新的会话查询信息,就可以参照二级缓存中。

不同namespace查出的数据会放在自己对应的缓存中(map)

效果:数据会从二级缓存中获取

查出的数据都会被默认先放在一级缓存中。

只有会话提交或者关闭之后,一级缓存中的数据才会转移到二级缓存中。

需要注意的是:在哪个Mapper.xml文件中开启了<cache>缓存标签,哪个Mapper中就开启了二级缓存。

案例:

1)开启全局二级缓存配置:

<setting name="cacheEnabled" value="true"/>

2)去mapper.xml中配置使用二级缓存

<cache eviction="FIFO" size="100" readOnly="false"/>

其中属性:

eviction=“FIFO”:缓存回收策略:

LRU –最近最少使用的:移除最长时间不被使用的对象。

FIFO –先进先出:按对象进入缓存的顺序来移除它们。

SOFT –软引用:移除基于垃圾回收器状态和软引用规则的对象。

WEAK –弱引用:更积极地移除基于垃圾收集器状态和弱引用规则的对象。

默认的是LRU。

flushInterval:缓存刷新间隔 ?缓存多长时间清空一次,默认不清空,设置一个毫秒值。

size:引用数目,正整数,默认1024

代表缓存最多可以存储多少个对象,太大容易导致内存溢出

readOnly:是否只读,true/false

true:只读缓存;mybatis认为所有从缓存中获取数据的操作都是只读操作,不会修改数据。

mybatis为了加快获取速度,直接就会将数据在缓存中的引用交给用户。不安全,速度快。

false:非只读:mybatis觉得获取的数据可能会被修改。

mybatis会利用序列化&反序列化的技术克隆一份。安全,速度慢。
type:指定自定义缓存的全类名 实现cache接口即可!

3)我们的POJO需要实现序列化接口[implements Serializable]

4)必须先关闭之前的sqlsession对象

测试:

可以看到只发送了一次SQL语句,第二次查询时从二级缓存中拿到的数据,并没有发送新的sql语句。

@Test
public void TestFirstCache(){
   SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
   session = sqlSessionFactory.openSession();
   mapper = session.getMapper(EmployeeMapper.class);
   Employee emp = mapper.getEmpInfoById(4);
   System.out.println(emp);
   session.close();
   SqlSession session2 = sqlSessionFactory.openSession();
   EmployeeMapper mapper2 = session2.getMapper(EmployeeMapper.class);
   Employee emp2 = mapper2.getEmpInfoById(4);
   System.out.println(emp2);
   session2.close();
}

需要注意的是:只有一级缓存中关闭的情况下,二级缓存才会被使用。

需要注意的是:在哪个Mapper.xml文件中开启了<cache>缓存标签,哪个Mapper中就开启了二级缓存。

和缓存有关的设置/属性:

1)cacheEnabled="true": false:关闭缓存(二级缓存关闭)【一级缓存一直可用】

2)每个select标签都有useCache="true";

false:不使用缓存(一级缓存依然使用,二级缓存不使用)

3)每个增删改标签都有一个flushCache="true":增删改执行完成后就会清楚缓存【一级二级缓存都会被清空】

查询标签:flushCache = "false"

如果flushCache = true;每次查询之前都会清空缓存,缓存是没有被使用!

总结

以上所述是小编给大家介绍的MyBatis 动态SQL和缓存机制实例详解,希望对大家有所帮助,如果大家有任何疑问请给我留言,小编会及时回复大家的。在此也非常感谢大家对我们网站的支持!

时间: 2017-09-06

详解Java的MyBatis框架中动态SQL的基本用法

有些时候,sql语句where条件中,需要一些安全判断,例如按某一条件查询时如果传入的参数是空,此时查询出的结果很可能是空的,也许我们需要参数为空时,是查出全部的信息.使用Oracle的序列.mysql的函数生成Id.这时我们可以使用动态sql.下文均采用mysql语法和函数(例如字符串链接函数CONCAT). selectKey 标签 在insert语句中,在Oracle经常使用序列.在MySQL中使用函数来自动生成插入表的主键,而且需要方法能返回这个生成主键.使用myBatis的select

MyBatis 动态拼接Sql字符串的问题

MyBatis 的一个强大的特性之一通常是它的动态 SQL 能力.如果你有使用 JDBC 或其他 相似框架的经验,你就明白条件地串联 SQL 字符串在一起是多么的痛苦,确保不能忘了空格或在列表的最后省略逗号.动态 SQL 可以彻底处理这种痛苦. 动态SQL MyBatis的动态SQL,解决了SQL字符串拼接的痛苦. 1.if <select id="findActiveBlogWithTitleLike" parameterType="Blog" result

Mybatis动态SQL之if、choose、where、set、trim、foreach标记实例详解

动态SQL就是动态的生成SQL. if标记 假设有这样一种需求:查询用户,当用户名不等于"admin"的时候,我们还需要密码为123456. 数据库中的数据为: MyBatisConfig.xml <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"

MyBatis使用动态SQL标签的小陷阱

MyBatis是一个支持普通SQL查询,存储过程和高级映射的优秀持久层框架.MyBatis消除了几乎所有的JDBC代码和参数的手工设置以及对结果集的检索封装.MyBatis可以使用简单的XML或注解用于配置和原始映射,将接口和Java的POJO(Plain Old Java Objects,普通的Java对象)映射成数据库中的记录. 现在MyBatis越来越受大家的喜爱了,它的优势大家都知道,我就不多说了,直接说重点. MyBatis中提供动态SQL功能,我们可以使用<if><when&

MyBatis 执行动态 SQL语句详解

大家基本上都知道如何使用 MyBatis 执行任意 SQL,使用方法很简单,例如在一个 XXMapper.xml 中: <select id="executeSql" resultType="map"> ${_parameter} </select> 你可以如下调用: sqlSession.selectList("executeSql", "select * from sysuser where enabled

MySQL存储过程中实现执行动态SQL语句的方法

本文实例讲述了MySQL存储过程中实现执行动态SQL语句的方法.分享给大家供大家参考.具体实现方法如下: mysql> mysql> delimiter $$ mysql> mysql> CREATE PROCEDURE set_col_value -> (in_table VARCHAR(128), -> in_column VARCHAR(128), -> in_new_value VARCHAR(1000), -> in_where VARCHAR(4

查看当前mysql使用频繁的sql语句(详解)

#mysql -uroot -p 输入密码 mysql> show full processlist;    查看完全的SQL语句 mysql> show processlist;         查看整体情况 这样子可以针对SQL语句进行优化. 以上这篇查看当前mysql使用频繁的sql语句(详解)就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持我们.

MyBatis执行动态SQL的方法

大家基本上都知道如何使用 MyBatis 执行任意 SQL,使用方法很简单,例如在一个 XXMapper.xml 中: <select id="executeSql" resultType="map"> ${_parameter} </select> 你可以如下调用: sqlSession.selectList("executeSql", "select * from sysuser where enabled

SQL SERVER 中构建执行动态SQL语句的方法

1 :普通SQL语句可以用exec执行 Select * from tableName exec('select * from tableName') exec sp_executesql N'select * from tableName' -- 请注意字符串前一定要加N 2:字段名,表名,数据库名之类作为变量时,必须用动态SQL declare @fname varchar(20) set @fname = 'FiledName' --Select @fname from tableName

Mybatis中输入输出映射与动态Sql图文详解

一.输入映射 我们通过配置parameterType的值来指定输入参数的类型,这些类型可以是简单数据类型.POJO.HashMap等数据类型 1.简单类型 2.POJO包装类型 ①这是单表查询的时候传入的POJO包装类型,即可以直接传入实体类,但是当多表查询的时候,就需要自定义POJO类型 ②我们使用自定义POJO类型来具体的了解一下 先设计 包装类型如下,其中UserPOJO是除了User本身之外的添加的其他跟User相关的属性的包装类,UserVo是用于视图层面的包装类型,同样也是作为Map

MyBatis的动态SQL语句实现

1. 动态SQL之<if>标签 我们根据实体类的不同取值,使用不同的SQL语句来进行查询.比如在id如果不为空时可以根据id查询,如果username不为空时还要加入用户名作为条件,这种情况在我们的多条件组合查询中经常会碰到. <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN&qu

ORACLE中如何找到未提交事务的SQL语句详解

在Oracle数据库中,我们能否找到未提交事务(uncommit transactin)的SQL语句或其他相关信息呢? 关于这个问题,我们先来看看实验测试吧.实践出真知. 首先,我们在会话1(SID=63)中构造一个未提交的事务,如下所: SQL> create table test 2 as 3 select * from dba_objects; Table created. SQL> select userenv('sid') from dual; USERENV('SID') ----

SQL语句详解 MySQL update的正确用法

单表的MySQL UPDATE语句: UPDATE [LOW_PRIORITY] [IGNORE] tbl_name SET col_name1=expr1 [, col_name2=expr2 ...] [WHERE where_definition] [ORDER BY ...] [LIMIT row_count] 多表的UPDATE语句: UPDATE [LOW_PRIORITY] [IGNORE] table_references SET col_name1=expr1 [, col_n

MySQL 存储过程中执行动态SQL语句的方法

drop PROCEDURE if exists my_procedure; create PROCEDURE my_procedure() BEGIN declare my_sqll varchar(500); set my_sqll='select * from aa_list'; set @ms=my_sqll; PREPARE s1 from @ms; EXECUTE s1; deallocate prepare s1; end;