成都创新互联网站制作重庆分公司

MyBatis保姆级理解与使用，动态SQL（核心）

1.动态SQL（核心）

1.1简介

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

创新互联专注为客户提供全方位的互联网综合服务，包含不限于成都网站设计、成都做网站、且末网络推广、成都小程序开发、且末网络营销、且末企业策划、且末品牌公关、搜索引擎seo、人物专访、企业宣传片、企业代运营等，从售前售中售后，我们都将竭诚为您服务，您的肯定，是我们最大的嘉奖；创新互联为所有大学生创业者提供且末建站搭建服务，24小时服务热线：18980820575，官方网址：www.cdcxhl.com

比如: 我们在多条件查询的时候会写这样的语句：

select * from sys_user where 1=1 and

再比如：做更新的时候，我们没有修改的数据列也执行了更新操作。

1.2 if和where标签

select emp_id,emp_name,emp_salary from sys_emp

or emp_name=#{empName}

2000">

or emp_salary>#{empSalary}

1.3 set标签

需求：实际开发时，对一个实体类对象进行更新。往往不是更新所有字段，而是更新一部分字段。此时页面上的表单往往不会给不修改的字段提供表单项。

例如：上面的表单，如果服务器端接收表单时，使用的是User这个实体类，那么userName、userBalance、userGrade接收到的数据就是null。

如果不加判断，直接用User对象去更新数据库，在Mapper配置文件中又是每一个字段都更新，那就会把userName、userBalance、userGrade设置为null值，从而造成数据库表中对应数据被破坏。

此时需要我们在Mapper配置文件中，对update语句的set子句进行定制，此时就可以使用动态SQL的set标签。


update sys_emp

emp_name=#{empName},

emp_salary=#{empSalary},

where emp_id=#{empId}

第一种情况：所有条件都满足 SET emp_name=?, emp_salary=?

第二种情况：部分条件满足 SET emp_salary=?

第三种情况：所有条件都不满足 update t_emp where emp_id=?

没有set子句的update语句会导致SQL语法错误

1.4trim标签

使用trim标签控制条件部分两端是否包含某些字符

prefix属性：指定要动态添加的前缀内容

suffix属性：指定要动态添加的后缀

prefixOverrides属性：指定要动态去掉的前缀，使用“|”分隔有可能的多个值

suffixOverrides属性：指定要动态去掉的后缀，使用“|”分隔有可能的多个值

下面例子中，trim标签内部如果有条件，则where会出现，否则where不出现。

suffixOverrides=“and|or”：整个条件部分，如果在后面有多出来的“and或or”会被自动去掉。

select emp_id,emp_name,emp_age,emp_salary,emp_gender

from sys_emp

emp_name=#{empName} and

>3000">

emp_salary > #{empSalary} and

emp_age=#{empAge} or

emp_gender=#{empGender}

1.5choose/when/otherwise标签

在多个分支条件中，仅执行一个。

select emp_id,emp_name,emp_salary from sys_emp

where

emp_name=#{empName}

3000">emp_salary >3000

1=1

1.6 foreach标签

1.6.1 基本用法

比如：批量插入

abstract public void insertBatch(@Param(“empList”)List empList));

"insertBatch">

INSERT INTO `sys_emp`(emp_id,emp_name,emp_gender)

"empList"item="emp"separator=","open="VALUES">

(null,#{emp.empName},#{emp.empGender})

我们这里写的批量插入的例子本质上是一条SQL语句。

collection属性：要遍历的集合，如果接口中方法中使用了@Param ，collection属性中要用这个名字。

item属性：遍历集合的过程中能得到每一个具体对象，在item属性中设置一个名字，将来通过这个名字引用遍历出来的对象

separator属性：指定当foreach标签的标签体重复拼接字符串时，各个标签体字符串之间的分隔符

open属性：指定整个foreach循环把字符串拼好后，这个字符串整体的前面要添加的字符串

close属性：指定整个foreach循环把字符串拼好后，这个字符串整体的后面要添加的字符串

index属性：这里起一个名字，便于后面引用

遍历List集合，这里能够得到List集合的索引值

遍历Map集合，这里能够得到Map集合的key

如果接口形参位置没有使用@Param注解，而且foreach标签也没有使用默认的名称，则会抛出异常

Causedby:org.apache.ibatis.binding.BindingException: Parameter ‘empList’ not found. Available parameters are[arg0,collection, list]

1.6.2 批量更新

而实现批量更新则需要多条update SQL语句拼起来，并且用分号分开。也就是一次性发送多条SQL语句让数据库执行。

此时需要在数据库连接信息的URL地址中设置

?allowMultiQueries=true

对应的foreach标签如下：

update sys_emp set emp_name=#{emp.empName} where emp_id=#{emp.empId}

1.6.3 关于foreach标签的collection属性

如果没有给接口中List类型的参数使用@Param注解指定一个具体的名字，那么在collection属性中默认可以使用collection或list来引用这个list集合。这一点可以通过异常信息看出来：

Parameter'empList'notfound. Availableparametersare[collection, list]

在实际开发中，为了避免隐晦的表达造成一定的误会，建议使用@Param注解明确声明变量的名称，然后在foreach标签的collection属性中按照@Param注解指定的名称来引用传入的参数。

1.7 sql标签

1.7.1 抽取重复的SQL片段

select emp_id,emp_name,emp_age,emp_salary,emp_gender from t_emp

1.7.2 引用已抽取的SQL片段

2．缓存

2.1 缓存机制

比如：以前农村装水的水缸

2.2 一级缓存和二级缓存

二级缓存被所有的SqlSession共享，也就是能被访问的。

一级缓存是SqlSession级别的缓存。在操作数据库时需要构造 sqlSession对象，在对象中有一个数据结构（HashMap）用于存储缓存数据。不同的sqlSession之间的缓存数据区域（HashMap）是互相不影响的。

二级缓存是Mapper（namespace）级别的缓存。多个SqlSession去操作同一个Mapper的sql语句，多个SqlSession可以共用二级缓存，二级缓存是跨SqlSession的。

第一次查询，先将结果放入到一级缓存，等SqlSession提交事务后，再将数据放入到二级缓存。

2.2.1 一级缓存和二级缓存的使用顺序

查询的顺序是：

1）先查询二级缓存，因为二级缓存中可能会有其他程序已经查出来的数据，可以拿来直接使用。

2）如果二级缓存没有命中，再查询一级缓存

3）如果一级缓存也没有命中，则查询数据库

SqlSession关闭之前，会将一级缓存中的数据会写入二级缓存

2.2.2 效用范围

一级缓存：SqlSession级别

二级缓存：SqlSessionFactory级别

它们之间范围的大小参考下面图：

一个请求中可能包含多个事务------一个service方法（一个SqlSession）对应一个事务

注意：缓存是用再查询过程中的，增删改，反而会破坏缓存。造成缓存和数据库不一致，所以很多情况，执行了一个增删改操作，他会把缓存清空。

3. 一级缓存

Mybatis默认开启了一级缓存

3.1 案例1：测试一级缓存是否存在

为了测试缓存失效，我们需要修改测试类中的代码。需要关闭SqlSessioin对象，然后重新开，再重新开的话，需要操作SqlSessionFactory。

如何测试一级缓存是否存在？？？同一个数据查两次，但是只发了一条SQL语句[给数据库]。

3.1.1 证明一级缓存存在

packagecom.hy.mybatis.test;

importjava.io.IOException;

importorg.apache.ibatis.io.Resources;

importorg.apache.ibatis.session.SqlSession;

importorg.apache.ibatis.session.SqlSessionFactory;

importorg.apache.ibatis.session.SqlSessionFactoryBuilder;

importorg.junit.Before;

importorg.junit.Test;

importcom.hy.bean.Emp;

importcom.hy.mapper.EmpMapper;

publicclassTestLevelOneCache1 {

privateSqlSessionFactory sqlSessionFactory;

privateLogger logger= null;

@Before

publicvoidinit() throwsIOException {

logger= LoggerFactory.getLogger(this.getClass());

sqlSessionFactory= newSqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis-config.xml"));

}

@Test

publicvoidtestLevelOneCache1_01() throwsIOException {

SqlSession session= sqlSessionFactory.openSession();

EmpMapper empMapper= session.getMapper(EmpMapper.class);

Emp emp1= empMapper.selectById(1);

Emp emp2= empMapper.selectById(1); // 第二次是从缓存中查询出来的。

logger.info("是否相等:"+ (emp1== emp2)); //true

session.commit();

session.close();

}

}

只发一条SQL语句。一级缓存默认开启，不需要做额外的配置。二级缓存需要开启才有，现在没有开，所以只有一级缓存。

3.2 案例2：一级缓存失效的情况：

1）同一个SqlSession两次查询期间提交了事务

2）同一个SqlSession两次查询期间执行了任何一次增删改操作，不论是够提交事务，都清空一级缓存

3）同一个SqlSession但是查询条件发生了变化

4）同一个SqlSession两次查询期间手动清空了缓存

5）不是同一个SqlSession

总结：在执行commit，rollback时会清空一级缓存

一级缓存的清除还有以下两个地方：

1、就是获取缓存之前会先进行判断用户是否配置了flushCache=true属性（参考一级缓存的创建代码截图），如果配置了则会清除一级缓存。

2、MyBatis全局配置属性localCacheScope配置为Statement时，那么完成一次查询就会清除缓存。

3.2.1 同一个SqlSession两次查询期间提交了事务

publicclassTestLevelCache1 {

privateSqlSessionFactory sqlSessionFactory;

privateLogger logger= null;

@Before

publicvoidinit() throwsIOException {

logger= LoggerFactory.getLogger(this.getClass());

sqlSessionFactory= newSqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis-config.xml"));

}

//1) 同一个SqlSession两次查询期间提交了事务

//1.1 没有提交事务，使用一级缓存

@Test

publicvoidtestLevelOneCache1_01() throwsIOException {

SqlSession session= sqlSessionFactory.openSession();

EmpMapper empMapper= session.getMapper(EmpMapper.class);

Emp emp1= empMapper.selectById(1);

Emp emp2= empMapper.selectById(1); // 第二次是从缓存中查询出来的。

logger.info("是否相等:"+ (emp1== emp2)); //true

session.commit();

session.close();

}

//1.2 两次查询中间，提交了事务，清空一级缓存

@Test

publicvoidtestLevelOneCache1_02() throwsIOException {

SqlSession session= sqlSessionFactory.openSession();

EmpMapper empMapper= session.getMapper(EmpMapper.class);

Emp emp1= empMapper.selectById(1);

session.commit();

Emp emp2= empMapper.selectById(1); // 由于进行了事务的提交，所以又发送了一条查询语句。

logger.info("是否相等:"+ (emp1== emp2)); //false

session.close();

}

}

3.2.2 同一个SqlSession两次查询期间执行了任何一次增删改操作，并且提交了事务

@Test

publicvoidtestLevelOneCache01_4() {

SqlSession sqlSession= sqlSessionFactory.openSession();

EmpMapper empMapper= sqlSession.getMapper(EmpMapper.class);

Emp emp1= empMapper.selectById(1);

//EmpnewEmp = new Emp(2L, "范冰冰ILoveYou", null, null, null, null);

//empMapper.updateById(newEmp); //更新但是不提交事务

empMapper.deleteById(8); //执行了删除没有，提交事务也，重新一遍

Emp emp2= empMapper.selectById(1);

//logger.debug(emp2.toString());

logger.debug("是否相等:"+ (emp1== emp2));

sqlSession.commit();

sqlSession.close();

}

// 2.2

@Test

publicvoidtestLevelOneCache2_02() throwsIOException {

SqlSession session= sqlSessionFactory.openSession();

EmpMapper empMapper= session.getMapper(EmpMapper.class);

Emp emp1= empMapper.selectById(1); //查询后，将对象放入一级缓存

empMapper.deleteById(7); //执行了delete操作，但是并没有提交

session.commit();

Emp emp11= empMapper.selectById(1); //提交了事务，一级缓存清空

logger.info("是否相等:"+ (emp1== emp11)); //false

session.commit();

session.close();

}

第一次发起查询用户id为1的用户信息，先去找缓存中是否有id为1的用户信息，如果没有，从数据库查询用户信息，将查询到的用户信息存储到一级缓存中。

如果中间sqlSession去执行插入、更新、删除，并且commit，清空SqlSession中的一级缓存，这样做的目的为了让缓存中存储的是最新的信息，避免脏读。

第二次发起查询用户id为1的用户信息，先去找缓存中是否有id为1的用户信息，缓存中有，直接从缓存中获取用户信息。如果没有，则重新发出一条查询语句。

3.2.3 同一个SqlSession但是查询条件发生了变化

// 3. 同一个SqlSession但是查询条件发生了变化

@Test

publicvoidtestLevelOneCache3_01() throwsIOException {

SqlSession session= sqlSessionFactory.openSession();

EmpMapper empMapper= session.getMapper(EmpMapper.class);

Emp emp1= empMapper.selectById(1); //查询后，将对象放入一级缓存

//查询的是emp_id为2的员工信息，一级缓存中并没有所以重新发出一条SQL语句

Emp emp2= empMapper.selectById(2);

session.commit();

session.close();

}

3.2.4 同一个SqlSession两次查询期间手动清空了缓存

// 4）同一个SqlSession两次查询期间手动清空了缓存

@Test

publicvoidtestLevelOneCache4() throwsIOException {

SqlSession session= sqlSessionFactory.openSession();

EmpMapper empMapper= session.getMapper(EmpMapper.class);

Emp emp1= empMapper.selectById(1);

session.clearCache();

Emp emp2= empMapper.selectById(1); // 由于两次查询中间清空了一级缓存，所以又发送了一条查询语句。

logger.info("是否相等:"+ (emp1== emp2)); //false

session.commit();

session.close();

}

3.2.5 不是同一个SqlSession

// 5）不是同一个SqlSession

@Test

publicvoidtestLevelOneCache1_05() throwsIOException {

SqlSession session01= sqlSessionFactory.openSession();

SqlSession session02= sqlSessionFactory.openSession();

EmpMapper empMapper01= session01.getMapper(EmpMapper.class);

EmpMapper empMapper02= session02.getMapper(EmpMapper.class);

Emp emp1= empMapper01.selectById(1);

// 由于是不同的SqlSession，所以又发送了一条查询语句。各自有各自的一级缓存。

Emp emp2= empMapper02.selectById(1);

logger.info("是否相等:"+ (emp1== emp2)); //false

session01.commit();

session02.commit();

session01.close();

session02.close();

}

4. 二级缓存[mybatis自带的二级缓存]

4.1 使用二级缓存步骤

1）在想要使用二级缓存的EmpMapper映射文件中加入cache标签

开启全局二级缓存配置：

2）让实体类支持序列化

publicclassEmp implementsSerializable{

privatestaticfinallongserialVersionUID= 1L;

这里我们使用mybaits自带的二级缓存，后面我们使用第三方的二级缓存EHCache。

3）SqlSession提交事务时才会将查询到的数据存入二级缓存

@Test

publicvoidtestLevelTwoCache() {

// 测试二级缓存存在：使用两个不同SqlSession执行查询

//说明：SqlSession提交事务时才会将查询到的数据存入二级缓存

// 所以本例并没有能够成功从二级缓存获取到数据

SqlSessionsqlSession01=sqlSessionFactory.openSession();

SqlSessionsqlSession02=sqlSessionFactory.openSession();

EmpMapperempMapper01=sqlSession01.getMapper(EmpMapper.class);

EmpMapperempMapper02=sqlSession02.getMapper(EmpMapper.class);

//[00:01:07.699] [DEBUG] [main] [com.hy.mapper.EmpMapper] [Cache Hit Ratio [com.hy.mapper.EmpMapper]: 0.0]

Empemp01=empMapper01.selectById(1);

//[00:01:07.746] [DEBUG] [main] [com.hy.mapper.EmpMapper] [Cache Hit Ratio [com.hy.mapper.EmpMapper]: 0.0]

Empemp02=empMapper02.selectById(1);

logger.info("是否相等:"+ (emp1== emp2)); //false

sqlSession01.commit();

sqlSession01.close();

sqlSession02.commit();

sqlSession02.close();

}

修改代码；

@Test

publicvoidtestSecondLevelCache2() {

SqlSessionsqlSession01=sqlSessionFactory.openSession();

SqlSessionsqlSession02=sqlSessionFactory.openSession();

EmpMapperempMapper01=sqlSession01.getMapper(EmpMapper.class);

EmpMapperempMapper02=sqlSession02.getMapper(EmpMapper.class);

Empemp01=empMapper01.selectById(1);

sqlSession01.commit();

sqlSession01.close();

Empemp02=empMapper02.selectById(1);

//false注意，从二级缓存中new了一个新的对象，所以emp01和emp02不是同一个对象

logger.info("是否相等:"+ (emp1== emp2));

sqlSession02.commit();

sqlSession02.close();

}

虽然两个对象不相等，但是注意：只发出了一条查询语句。

日志中打印的Cache Hit Ratio叫做缓存命中率

缓存命中率=命中缓存的次数/查询的总次数

4）mybatis序列化的特点

mybatis的二级缓存是属于序列化，序列化的意思就是从内存中的数据传到硬盘中，这个过程就是序列化；

反序列化意思就是相反而已；

也就是说，mybatis的二级缓存，实际上就是将数据放进了硬盘文件中去了；

现在呢，你仅仅的将Emp类给序列化了，如果有父类Person、级联属性，它们是不会跟着被序列化的，所以光这些是不够的；

很简单，如果Emp需要序列化，但是这个类中还有其他类的属性，仅需将其他类也实现序列化接口即可！

比如Emp类继承了Person父类，那么父类也需要实现Serializable这个接口；

4.2 二级缓存失效的条件

与一级缓存一样，二级缓存也会存在失效的条件的，下面我们就来探究一下哪些情况会造成二级缓存失效。

4.2.1 第一次SqlSession未提交

SqlSession在未提交的时候，SQL语句产生的查询结果还没有放入二级缓存中，这个时候SqlSession2在查询的时候是感受不到二级缓存的存在的

4.2.2 更新对二级缓存影响

与一级缓存一样，更新操作对二级缓存造成影响，下面用三个 SqlSession来进行模拟，第一个SqlSession只是单纯的查询并提交，第二个SqlSession用于查询二级缓存是否失效，第三个SqlSession2用于执行更新操作。

@Test

publicvoidtestLevelTwoCache01_03() {

SqlSession sqlSession1= sqlSessionFactory.openSession();

SqlSession sqlSession2= sqlSessionFactory.openSession();

SqlSession sqlSession3= sqlSessionFactory.openSession();

EmpMapper empMapper1= sqlSession1.getMapper(EmpMapper.class);

EmpMapper empMapper2= sqlSession2.getMapper(EmpMapper.class);

EmpMapper empMapper3= sqlSession3.getMapper(EmpMapper.class);

Emp emp1= empMapper1.selectById(1);

logger.info(emp1.toString());

sqlSession1.commit(); //清空一级缓存，加入二级缓存

Emp emp2= empMapper2.selectById(1);

logger.info(emp2.toString()); //从二级缓存中查询出来

logger.info("是否是同一个对象:"+(emp1==emp2));

sqlSession2.commit();

Emp newEmp= newEmp(1L,"垃圾张文宏",null,null,null,null);

empMapper3.updateById(newEmp);

sqlSession3.commit();

Emp emp22= empMapper2.selectById(1);

logger.info(emp22.toString()); //从二级缓存中查询出来

logger.info("是否是同一个对象:"+(emp1==emp22));

sqlSession2.commit();

sqlSession1.close();

sqlSession2.close();

}

因为所有的insert,delete,uptede都会触发缓存的刷新，从而导致二级缓存失效，所以二级缓存适合在读多写少的场景中开启。


当前题目：MyBatis保姆级理解与使用，动态SQL（核心）
浏览路径：http://cxhlcq.com/article/dscgeho.html

其他资讯

全国免费咨询:

400-028-6601

业务咨询：028-86922220 / 13518219792

节假值班：18980820575 / 13518219792

联系地址：成都市太升南路288号锦天国际A幢1002号

Copyright © 成都创新互联科技有限公司重庆分公司 渝ICP备2021005571号
友情链接:： 成都网站建设 重庆网站建设 四川网站建设 重庆建设网站 移动服务器托管 成都服务器托管 云服务器 广告设计制作 重庆网页设计 重庆做网站 重庆网站制作 重庆网站建设 重庆网站公司 渝中网站制作 重庆网站设计

在线咨询

微信咨询

电话咨询

028-86922220（工作日）

18980820575（7×24）

提交需求

返回顶部