Mybatis框架的动态SQL技术是一种根据特定条件动态拼装SQL语句的功能,它存在的意义是为了解决拼接SQL语句字符串时的难点问题。
创新互联专注为客户提供全方位的互联网综合服务,包含不限于成都网站设计、成都做网站、且末网络推广、成都小程序开发、且末网络营销、且末企业策划、且末品牌公关、搜索引擎seo、人物专访、企业宣传片、企业代运营等,从售前售中售后,我们都将竭诚为您服务,您的肯定,是我们最大的嘉奖;创新互联为所有大学生创业者提供且末建站搭建服务,24小时服务热线:18980820575,官方网址:www.cdcxhl.com
比如: 我们在多条件查询的时候会写这样的语句:
select * from sys_user where 1=1 and
再比如:做更新的时候,我们没有修改的数据列也执行了更新操作。
select emp_id,emp_name,emp_salary from sys_emp
or emp_name=#{empName}
or emp_salary>#{empSalary}
|
需求:实际开发时,对一个实体类对象进行更新。往往不是更新所有字段,而是更新一部分字段。此时页面上的表单往往不会给不修改的字段提供表单项。
例如:上面的表单,如果服务器端接收表单时,使用的是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语法错误
使用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
emp_salary > #{empSalary} and
emp_age=#{empAge} or
emp_gender=#{empGender}
|
在多个分支条件中,仅执行一个。
select emp_id,emp_name,emp_salary from sys_emp where
|
比如:批量插入
abstract public void insertBatch(@Param(“empList”)List
INSERT INTO `sys_emp`(emp_id,emp_name,emp_gender) (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]
而实现批量更新则需要多条update SQL语句拼起来,并且用分号分开。也就是一次性发送多条SQL语句让数据库执行。
此时需要在数据库连接信息的URL地址中设置
?allowMultiQueries=true
对应的foreach标签如下:
update sys_emp set emp_name=#{emp.empName} where emp_id=#{emp.empId}
如果没有给接口中List类型的参数使用@Param注解指定一个具体的名字,那么在collection属性中默认可以使用collection或list来引用这个list集合。这一点可以通过异常信息看出来:
Parameter'empList'notfound. Availableparametersare[collection, list]
在实际开发中,为了避免隐晦的表达造成一定的误会,建议使用@Param注解明确声明变量的名称,然后在foreach标签的collection属性中按照@Param注解指定的名称来引用传入的参数。
select emp_id,emp_name,emp_age,emp_salary,emp_gender from t_emp
|
|
比如:以前农村装水的水缸
二级缓存被所有的SqlSession共享,也就是能被访问的。
一级缓存是SqlSession级别的缓存。在操作数据库时需要构造 sqlSession对象,在对象中有一个数据结构(HashMap)用于存储缓存数据。不同的sqlSession之间的缓存数据区域(HashMap)是互相不影响的。
二级缓存是Mapper(namespace)级别的缓存。多个SqlSession去操作同一个Mapper的sql语句,多个SqlSession可以共用二级缓存,二级缓存是跨SqlSession的。
第一次查询,先将结果放入到一级缓存,等SqlSession提交事务后,再将数据放入到二级缓存。
查询的顺序是:
1)先查询二级缓存,因为二级缓存中可能会有其他程序已经查出来的数据,可以拿来直接使用。
2)如果二级缓存没有命中,再查询一级缓存
3)如果一级缓存也没有命中,则查询数据库
SqlSession关闭之前,会将一级缓存中的数据会写入二级缓存
一级缓存:SqlSession级别
二级缓存:SqlSessionFactory级别
它们之间范围的大小参考下面图:
一个请求中可能包含多个事务------一个service方法(一个SqlSession)对应一个事务
注意:缓存是用再查询过程中的,增删改,反而会破坏缓存。造成缓存和数据库不一致,所以很多情况,执行了一个增删改操作,他会把缓存清空。
Mybatis默认开启了一级缓存
为了测试缓存失效,我们需要修改测试类中的代码。需要关闭SqlSessioin对象,然后重新开,再重新开的话,需要操作SqlSessionFactory。
如何测试一级缓存是否存在???同一个数据查两次,但是只发了一条SQL语句[给数据库]。
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语句。一级缓存默认开启,不需要做额外的配置。二级缓存需要开启才有,现在没有开,所以只有一级缓存。
1)同一个SqlSession两次查询期间提交了事务
2)同一个SqlSession两次查询期间执行了任何一次增删改操作,不论是够提交事务,都清空一级缓存
3)同一个SqlSession但是查询条件发生了变化
4)同一个SqlSession两次查询期间手动清空了缓存
5)不是同一个SqlSession
总结:在执行commit,rollback时会清空一级缓存
一级缓存的清除还有以下两个地方:
1、就是获取缓存之前会先进行判断用户是否配置了flushCache=true属性(参考一级缓存的创建代码截图),如果配置了则会清除一级缓存。 2、MyBatis全局配置属性localCacheScope配置为Statement时,那么完成一次查询就会清除缓存。 |
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(); } } |
@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. 同一个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(); } |
// 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(); } |
// 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(); } |
开启全局二级缓存配置:
publicclassEmp implementsSerializable{
privatestaticfinallongserialVersionUID= 1L;
这里我们使用mybaits自带的二级缓存,后面我们使用第三方的二级缓存EHCache。
@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叫做缓存命中率
缓存命中率=命中缓存的次数/查询的总次数
mybatis的二级缓存是属于序列化,序列化的意思就是从内存中的数据传到硬盘中,这个过程就是序列化;
反序列化意思就是相反而已;
也就是说,mybatis的二级缓存,实际上就是将数据放进了硬盘文件中去了;
现在呢,你仅仅的将Emp类给序列化了,如果有父类Person、级联属性,它们是不会跟着被序列化的,所以光这些是不够的;
很简单,如果Emp需要序列化,但是这个类中还有其他类的属性,仅需将其他类也实现序列化接口即可!
比如Emp类继承了Person父类,那么父类也需要实现Serializable这个接口;
与一级缓存一样,二级缓存也会存在失效的条件的,下面我们就来探究一下哪些情况会造成二级缓存失效。
SqlSession在未提交的时候,SQL语句产生的查询结果还没有放入二级缓存中,这个时候SqlSession2在查询的时候是感受不到二级缓存的存在的
与一级缓存一样,更新操作对二级缓存造成影响,下面用三个 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://cdkjz.cn/article/dscgeho.html |