阶段六 模块一 Mybatis
三层架构
软件开发常用的架构是三层架构,之所以流行是因为有着清晰的任务划分。一般包括以下三层:
- 持久层:主要完成与数据库相关的操作,即对数据库的增删改查。
因为数据库访问的对象一般称为Data Access Object(简称DAO),所以有人把持久层叫做DAO层。
- 业务层:主要根据功能需求完成业务逻辑的定义和实现。
因为它主要是为上层提供服务的,所以有人把业务层叫做Service层或Business层。
因此,有人把表现层称之为web层或View层。
- 表现层:主要完成与最终软件使用用户的交互,需要有交互界面(UI)。
三层架构之间调用关系为:表现层调用业务层,业务层调用持久层。各层之间必然要进行数据交互,我们一般使用java实体对象来传递数据
什么是框架?
框架就是一套规范,既然是规范,你使用这个框架就要遵守这个框架所规定的约束。
框架可以理解为半成品软件,框架做好以后,接下来在它基础上进行开发。
为什么使用框架?
框架为我们封装好了一些冗余,且重用率低的代码。并且使用反射与动态代理机制,将代码实现了通用性,让 开发人员把精力专注在核心的业务代码实现上。
比如在使用servlet进行开发时,需要在servlet获取表单的参数,每次都要获取很麻烦,而框架底层就使用反射机制和拦截器机制帮助我们获取表单的值,使用jdbc每次做专一些简单的crud的时候都必须写sql,但使用框架就不需要这么麻烦了,直接调用方法就可以。当然,既然是使用框架,那么还是要遵循其一些规范进行配置
常见的框架
Java世界中的框架非常的多,每一个框架都是为了解决某一部分或某些问题而存在的。下面列出在目前企业中流行的几种框架(一定要注意他们是用来解决哪一层问题的):
- 持久层框架:专注于解决数据持久化的框架。常用的有mybatis、hibernate、spring jdbc等等。
- 表现层框架:专注于解决与用户交互的框架。常见的有struts2、spring mvc等等。
- 全栈框架: 能在各层都给出解决方案的框架。比较著名的就是spring。
Mybatis简介
MyBatis是一个优秀的基于ORM的半自动轻量级持久层框架,它对jdbc的操作数据库的过程进行封装,使开发者只需要关注 SQL 本身,而不需要花费精力去处理例如注册驱动、创建connection、创建statement、手动设置参数、结果集检索等jdbc繁杂的过程代码
ORM思想
ORM(Object Relational Mapping)对象关系映射
O(对象模型):
实体对象,即我们在程序中根据数据库表结构建立的一个个实体javaBean
R(关系型数据库的数据结构):
关系数据库领域的Relational(建立的数据库表)
M(映射):
从R(数据库)到O(对象模型)的映射,可通过XML文件映射
ORM作为是一种思想
帮助我们跟踪实体的变化,并将实体的变化翻译成sql脚本,执行到数据库中去,也就是将实体的变化映射到了表的变化。
mybatis采用ORM思想解决了实体和数据库映射的问题,对jdbc 进行了封装,屏蔽了jdbc api 底层访问细节,使我们不用与jdbc api 打交道,就可以完成对数据库的持久化操作
MyBatis开发步骤
案例需求:通过mybatis查询数据库user表的所有记录,封装到User对象中,打印到控制台上
步骤分析:
1. 创建数据库及user表
2. 创建maven工程,导入依赖(MySQL驱动、mybatis、junit)
3. 编写User实体类
4. 编写UserMapper.xml映射配置文件(ORM思想)
5. 编写SqlMapConfig.xml核心配置文件
数据库环境配置
映射关系配置的引入(引入映射配置文件的路径)
6. 编写测试代码
// 1.加载核心配置文件
// 2.获取sqlSessionFactory工厂对象
// 3.获取sqlSession会话对象
// 4.执行sql
// 5.打印结果
// 6.释放资源
Mybatis映射文件概述
Mybatis增删改查
新增注意事项
- 插入语句使用insert标签
- 在映射文件中使用parameterType属性指定要插入的数据类型
- Sql语句中使用#{实体属性名}方式引用实体中的属性值
- 插入操作使用的API是sqlSession.insert(“命名空间.id”,实体对象);
- 插入操作涉及数据库数据变化,所以要使用sqlSession对象显示的提交事务,即
sqlSession.commit()
修改注意事项
- 修改语句使用update标签
- 修改操作使用的API是sqlSession.update(“命名空间.id”,实体对象);
删除注意事项
- 删除语句使用delete标签
- Sql语句中使用#{任意字符串}方式引用传递的单个参数
- 删除操作使用的API是sqlSession.delete(“命名空间.id”,Object);
Mybatis核心文件概述
MyBatis 的配置文件包含了会深深影响 MyBatis 行为的设置和属性信息。
配置文档的顶层结构如下:
MyBatis常用配置解析
environments标签
数据库环境的配置,支持多环境配置
1. 其中,事务管理器(transactionManager)类型有两种:
- JDBC:
这个配置就是直接使用了JDBC 的提交和回滚设置,它依赖于从数据源得到的连接来管理事务作用域。
- MANAGED:
这个配置几乎没做什么。它从来不提交或回滚一个连接,而是让容器来管理事务的整个生命周期。
例如:mybatis与spring整合后,事务交给spring容器管理。
2. 其中,数据源(dataSource)常用类型有三种:
- UNPOOLED:这个数据源的实现只是每次被请求时打开和关闭连接。
- POOLED:
这种数据源的实现利用“池”的概念将 JDBC 连接对象组织起来。
- JNDI :
这个数据源实现是为了能在如 EJB 或应用服务器这类容器中使用,容器可以集中或在外部配置数据源,然后放置一个 JNDI 上下文的数据源引用
properties标签
实际开发中,习惯将数据源的配置信息单独抽取成一个properties文件,该标签可以加载额外配置的properties:
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql:///mybatis_db
jdbc.username=root
jdbc.password=root
typeAliases标签
类型别名是为 Java 类型设置一个短的名字。
为了简化映射文件 Java 类型设置,mybatis框架为我们设置好的一些常用的类型的别名:
mappers标签
该标签的作用是加载映射的,加载方式有如下几种:
1. 使用相对于类路径的资源引用,例如:
<mapper resource="org/mybatis/builder/userMapper.xml"/>
2. 使用完全限定资源定位符(URL),例如:
<mapper url="file:///var/mappers/userMapper.xml"/>
3. 使用映射器接口实现类的完全限定类名,例如:
<mapper class="org.mybatis.builder.userMapper"/>
4. 将包内的映射器接口实现全部注册为映射器,例如:
<package name="org.mybatis.builder"/>
Mybatis的API概述
SqlSession工厂构建器SqlSessionFactoryBuilder
常用API:SqlSessionFactory build(InputStream inputStream)
通过加载mybatis的核心文件的输入流的形式构建一个SqlSessionFactory对象
String resource = "org/mybatis/builder/mybatis-config.xml"; InputStream inputStream = Resources.getResourceAsStream(resource); SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder(); SqlSessionFactory factory = builder.build(inputStream);
其中, Resources 工具类,这个类在 org.apache.ibatis.io 包中。Resources 类帮助你从类路径下、文件系统或一个 web URL 中加载资源文件。
SqlSession工厂对象SqlSessionFactory
SqlSessionFactory 有多个个方法创建SqlSession 实例。常用的有如下两个:
SqlSession会话对象
SqlSession 实例在 MyBatis 中是非常强大的一个类。在这里你会看到所有执行语句、提交或回滚事务和获取映射器实例的方法。
执行语句的方法主要有:
<T> T selectOne(String statement, Object parameter) <E> List<E> selectList(String statement, Object parameter) int insert(String statement, Object parameter) int update(String statement, Object parameter) int delete(String statement, Object parameter)
操作事务的方法主要有:
void commit() void rollback()
Mybatis基本原理介绍
代理开发方式
采用 Mybatis 的基于接口代理方式实现 持久层 的开发,这种方式是我们后面进入企业的主流。
基于接口代理方式的开发只需要程序员编写 Mapper 接口,Mybatis 框架会为我们动态生成实现类的对象。
这种开发方式要求我们遵循一定的规范:
- Mapper.xml映射文件中的namespace与mapper接口的全限定名相同
- Mapper接口方法名和Mapper.xml映射文件中定义的每个statement的id相同
- Mapper接口方法的输入参数类型和mapper.xml映射文件中定义的每个sql的parameterType的类型相同
- Mapper接口方法的输出参数类型和mapper.xml映射文件中定义的每个sql的resultType的类型相同
Mapper 接口开发方法只需要程序员编写Mapper 接口(相当于Dao 接口),由Mybatis 框架根据接口定义创建接口的动态代理对象,代理对象的方法体同上边Dao接口实现类方法。
Mybatis基于接口代理方式的内部执行原理
1、通过追踪源码我们会发现,我们使用的mapper实际上是一个代理对象,是由MapperProxy代理产生的。
2、追踪MapperProxy的invoke方法会发现,其最终调用了mapperMethod.execute(sqlSession, args)
3、进入execute方法会发现,最终工作的还是sqlSession
Mybatis高级查询
ResutlMap属性
* resultType
如果实体的属性名与表中字段名一致,将查询结果自动封装到实体类中
* ResutlMap
如果实体的属性名与表中字段名不一致,可以使用ResutlMap实现手动封装到实体类中
多条件查询(三种)
1)方式一
使用 #{arg0}-#{argn} 或者 #{param1}-#{paramn} 获取参数
2)方式二
使用注解,引入 @Param() 注解获取参数
3)方式三(推荐)
使用pojo对象传递参数
模糊查询
1)方式一
<mapper namespace="com.lagou.mapper.UserMapper">
<select id="findByUsername1" parameterType="string" resultType="user">
select * from user where username like #{username}
</select>
</mapper>
@Test public void testFindByUsername() throws Exception { UserMapper userMapper = sqlSession.getMapper(UserMapper.class); List<User> list = userMapper.findByUsername1("%王%"); for (User user : list) { System.out.println(user); } }
2)方式二
<mapper namespace="com.lagou.mapper.UserMapper"> <!--不推荐使用,因为会出现sql注入问题--> <select id="findByUsername2" parameterType="string" resultType="user"> select * from user where username like '${value}' </select> </mapper> @Test public void testFindByUsername() throws Exception { UserMapper userMapper = sqlSession.getMapper(UserMapper.class); List<User> list = userMapper.findByUsername2("%王%"); for (User user : list) { System.out.println(user); } }
3)${} 与 #{} 区别【笔试题】
#{} :表示一个占位符号
- 通过 #{} 可以实现preparedStatement向占位符中设置值,自动进行java类型和jdbc类型转换,#{}可以有效防止sql注入。
- #{} 可以接收简单类型值或pojo属性值。
- 如果parameterType传输单个简单类型值, #{} 括号中名称随便写。
${} :表示拼接sql串
- 通过 ${} 可以将parameterType 传入的内容拼接在sql中且不进行jdbc类型转换,会出现sql注入问题。
- ${} 可以接收简单类型值或pojo属性值。
- 如果parameterType传输单个简单类型值, ${} 括号中只能是value。
返回主键
useGeneratedKeys
<!-- useGeneratedKeys="true" 声明返回主键 keyProperty="id" 把返回主键的值,封装到实体的id属性中 注意:只适用于主键自增的数据库,mysql和sqlserver支持,oracle不支持 --> <insert id="save" parameterType="user" useGeneratedKeys="true" keyProperty="id"> INSERT INTO `user`(username,birthday,sex,address) values(#{username},#{birthday},#{sex},#{address}) </insert>
selectKey
<!-- selectKey 适用范围广,支持所有类型数据库 keyColumn="id" 指定主键列名 keyProperty="id" 指定主键封装到实体的id属性中 resultType="int" 指定主键类型 order="AFTER" 设置在sql语句执行前(后),执行此语句 --> <insert id="save" parameterType="user"> <selectKey keyColumn="id" keyProperty="id" resultType="int" order="AFTER"> SELECT LAST_INSERT_ID(); </selectKey> INSERT INTO `user`(username,birthday,sex,address) values(#{username},#{birthday},#{sex},#{address}) </insert>
动态SQL
动态 SQL 之<if>
<!-- where标签相当于 where 1=1,但是如果没有条件,就不会拼接where关键字 --> <select id="findByIdAndUsernameIf" parameterType="user" resultType="user"> SELECT * FROM `user` <where> <if test="id != null"> AND id = #{id} </if> <if test="username != null"> AND username = #{username} </if> </where> </select>
动态 SQL 之<set>
<!-- set标签在更新的时候,自动加上set关键字,然后去掉最后一个条件的逗号 --> <update id="updateIf" parameterType="user"> UPDATE `user` <set> <if test="username != null"> username = #{username}, </if> <if test="birthday != null"> birthday = #{birthday}, </if> <if test="sex !=null"> sex = #{sex}, </if> <if test="address !=null"> address = #{address}, </if> </set> WHERE id = #{id} </update>
动态 SQL 之<foreach>
* <foreach>标签用于遍历集合,它的属性:
• collection:代表要遍历的集合元素
• open:代表语句的开始部分
• close:代表结束部分
• item:代表遍历集合的每个元素,生成的变量名
• sperator:代表分隔符
a) 集合
<!-- 如果查询条件为普通类型 List集合,collection属性值为:collection 或者 list --> <select id="findByList" parameterType="list" resultType="user" > SELECT * FROM `user` <where> <foreach collection="collection" open="id in(" close=")" item="id" separator=","> #{id} </foreach> </where> </select>
b)数组
<!-- 如果查询条件为普通类型 Array数组,collection属性值为:array --> <select id="findByArray" parameterType="int" resultType="user"> SELECT * FROM `user` <where> <foreach collection="array" open="id in(" close=")" item="id" separator=","> #{id} </foreach> </where> </select>
SQL片段
映射文件中可将重复的 sql 提取出来,使用时用 include 引用即可,最终达到 sql 重用的目的
<!--抽取的sql片段--> <sql id="selectUser"> SELECT * FROM `user` </sql> <select id="findByList" parameterType="list" resultType="user" > <!--引入sql片段--> <include refid="selectUser"></include> <where> <foreach collection="collection" open="id in(" close=")" item="id" separator=","> #{id} </foreach> </where> </select>
Mybatis核心配置文件深入
plugins标签
MyBatis可以使用第三方的插件来对功能进行扩展,分页助手PageHelper是将分页的复杂操作进行封装,使用简单的方式即可获得分页的相关数据
开发步骤:
①导入通用PageHelper的坐标
②在mybatis核心配置文件中配置PageHelper插件
③测试分页数据获取
①导入通用PageHelper坐标
<!-- 分页助手 --> <dependency> <groupId>com.github.pagehelper</groupId> <artifactId>pagehelper</artifactId> <version>3.7.5</version> </dependency> <dependency> <groupId>com.github.jsqlparser</groupId> <artifactId>jsqlparser</artifactId> <version>0.9.1</version> </dependency>
②在mybatis核心配置文件中配置PageHelper插件
<!-- 分页助手的插件 --> <plugin interceptor="com.github.pagehelper.PageHelper"> <!-- 指定方言 --> <property name="dialect" value="mysql"/> </plugin>
③测试分页代码实现
@Test public void testPageHelper(){ //设置分页参数 PageHelper.startPage(1,2); List<User> select = userMapper2.select(null); for(User user : select){ System.out.println(user); } }
获得分页相关的其他参数
//其他分页的数据 PageInfo<User> pageInfo = new PageInfo<User>(select); System.out.println("总条数:"+pageInfo.getTotal()); System.out.println("总页数:"+pageInfo.getPages()); System.out.println("当前页:"+pageInfo.getPageNum()); System.out.println("每页显示长度:"+pageInfo.getPageSize()); System.out.println("是否第一页:"+pageInfo.isIsFirstPage()); System.out.println("是否最后一页:"+pageInfo.isIsLastPage());
Mybatis多表查询
关系型数据库表关系分为
* 一对一
* 一对多
* 多对多
一对一(多对一)
<resultMap id="orderMap" type="com.lagou.domain.Order"> <id column="id" property="id"></id> <result column="ordertime" property="ordertime"></result> <result column="money" property="money"></result> <!-- 一对一(多对一)使用association标签关联 property="user" 封装实体的属性名 javaType="user" 封装实体的属性类型 --> <association property="user" javaType="com.lagou.domain.User"> <id column="uid" property="id"></id> <result column="username" property="username"></result> <result column="birthday" property="birthday"></result> <result column="sex" property="sex"></result> <result column="address" property="address"></result> </association> </resultMap>
一对多
<resultMap id="userMap" type="com.lagou.domain.User"> <id column="id" property="id"></id> <result column="username" property="username"></result> <result column="birthday" property="birthday"></result> <result column="sex" property="sex"></result> <result column="address" property="address"></result> <!-- 一对多使用collection标签关联 property="orderList" 封装到集合的属性名 ofType="order" 封装集合的泛型类型 --> <collection property="orderList" ofType="com.lagou.domain.Order"> <id column="oid" property="id"></id> <result column="ordertime" property="ordertime"></result> <result column="money" property="money"></result> </collection> </resultMap> <select id="findAllWithOrder" resultMap="userMap"> SELECT *,o.id oid FROM USER u LEFT JOIN orders o ON u.`id`=o.`uid`; </select>
多对多
<resultMap id="userAndRoleMap" type="com.lagou.domain.User"> <id column="id" property="id"></id> <result column="username" property="username"></result> <result column="birthday" property="birthday"></result> <result column="sex" property="sex"></result> <result column="address" property="address"></result> <collection property="orderList" ofType="com.lagou.domain.Role"> <id column="rid" property="id"></id> <result column="role_name" property="roleName"></result> <result column="role_desc" property="roleDesc"></result> </collection> </resultMap> <select id="findAllWithRole" resultMap="userAndRoleMap"> SELECT * FROM USER u LEFT JOIN user_role ur ON u.`id`=ur.`uid` INNER JOIN role r ON ur.`rid` = r.`id`; </select>
MyBatis多表配置方式
* 多对一(一对一)配置:使用<resultMap>+<association>做配置
* 一对多配置:使用<resultMap>+<collection>做配置
* 多对多配置:使用<resultMap>+<collection>做配置
* 多对多的配置跟一对多很相似,难度在于SQL语句的编写。
MyBatis嵌套查询
什么是嵌套查询
嵌套查询就是将原来多表查询中的联合查询语句拆成单个表的查询,再使用mybatis的语法嵌套在一起。
举个栗子
* 需求:查询一个订单,与此同时查询出该订单所属的用户
1. 联合查询
SELECT * FROM orders o LEFT JOIN USER u ON o.`uid`=u.`id`;
2. 嵌套查询
2.1 先查询订单
SELECT * FROM orders
2.2 再根据订单uid外键,查询用户
SELECT * FROM `user` WHERE id = #{根据订单查询的uid}
2.3 最后使用mybatis,将以上二步嵌套起来
...
一对一嵌套查询
<!--一对一嵌套查询--> <resultMap id="orderMap" type="order"> <id column="id" property="id"></id> <result column="ordertime" property="ordertime"></result> <result column="money" property="money"></result> <!--根据订单中uid外键,查询用户表--> <association property="user" javaType="user" column="uid" select="com.lagou.mapper.UserMapper.findById"></association> </resultMap> <select id="findAllWithUser" resultMap="orderMap" > SELECT * FROM orders </select>
一对多嵌套查询
<!--一对多嵌套查询--> <resultMap id="userMap" type="user"> <id column="id" property="id"></id> <result column="username" property="username"></result> <result column="birthday" property="birthday"></result> <result column="sex" property="sex"></result> <result column="address" property="address"></result> <!--根据用户id,查询订单表--> <collection property="orderList" column="id" ofType="order" select="com.lagou.mapper.OrderMapper.findByUid"></collection> </resultMap> <select id="findAllWithOrder" resultMap="userMap"> SELECT * FROM `user` </select>
多对多嵌套查询
<!--多对多嵌套查询--> <resultMap id="userAndRoleMap" type="user"> <id column="id" property="id"></id> <result column="username" property="username"></result> <result column="birthday" property="birthday"></result> <result column="sex" property="sex"></result> <result column="adress" property="address"></result> <!--根据用户id,查询角色列表--> <collection property="roleList" column="id" ofType="role" select="com.lagou.mapper.RoleMapper.findByUid"></collection> </resultMap> <select id="findAllWithRole" resultMap="userAndRoleMap"> SELECT * FROM `user` </select> <select id="findByUid" parameterType="int" resultType="role"> SELECT r.id,r.`role_name` roleName,r.`role_desc` roleDesc FROM role r INNER JOIN user_role ur ON r.`id` = ur.`rid` WHERE ur.`uid` = #{uid} </select>
一对一配置:使用<resultMap>+<association>做配置,通过column条件,执行select查询
一对多配置:使用<resultMap>+<collection>做配置,通过column条件,执行select查询
多对多配置:使用<resultMap>+<collection>做配置,通过column条件,执行select查询
优点:简化多表查询操作
缺点:执行多次sql语句,浪费数据库性能
MyBatis加载策略
什么是延迟加载?
在需要用到数据时才进行加载,不需要用到数据时就不加载数据。延迟加载也称懒加载。
* 优点:
先从单表查询,需要时再从关联表去关联查询,大大提高数据库性能,因为查询单表要比关联查询多张表速度要快。* 缺点:
因为只有当需要用到数据时,才会进行数据库查询,这样在大批量数据查询时,因为查询工作也要消耗时间,所以可能造成用户等待时间变长,造成用户体验下降。
* 在多表中:
一对多,多对多:通常情况下采用延迟加载
一对一(多对一):通常情况下采用立即加载
* 注意:
延迟加载是基于嵌套查询来实现的
局部延迟加载
在association和collection标签中都有一个fetchType属性,通过修改它的值,可以修改局部的加载策略。
<!-- 开启一对多 延迟加载 --> <resultMap id="userMap" type="user"> <id column="id" property="id"></id> <result column="username" property="username"></result> <result column="password" property="password"></result> <result column="birthday" property="birthday"></result> <!-- fetchType="lazy" 懒加载策略 fetchType="eager" 立即加载策略 --> <collection property="orderList" ofType="order" column="id" select="com.lagou.dao.OrderMapper.findByUid" fetchType="lazy"> </collection> </resultMap> <select id="findAll" resultMap="userMap"> SELECT * FROM `user` </select>
设置触发延迟加载的方法
大家在配置了延迟加载策略后,发现即使没有调用关联对象的任何方法,但是在你调用当前对象的equals、clone、hashCode、toString方法时也会触发关联对象的查询。
我们可以在配置文件中使用lazyLoadTriggerMethods配置项覆盖掉上面四个方法。
<settings> <!--所有方法都会延迟加载--> <setting name="lazyLoadTriggerMethods" value="toString()"/> </settings>
全局延迟加载
<settings> <!--开启全局延迟加载功能--> <setting name="lazyLoadingEnabled" value="true"/> </settings>
注意
局部的加载策略优先级高于全局的加载策略。
MyBatis缓存
为什么使用缓存?
当用户频繁查询某些固定的数据时,第一次将这些数据从数据库中查询出来,保存在缓存中。当用户再次查询这些数据时,不用再通过数据库查询,而是去缓存里面查询。减少网络连接和数据库查询带来的损耗,从而提高我们的查询效率,减少高并发访问带来的系统性能问题。
一句话概括:经常查询一些不经常发生变化的数据,使用缓存来提高查询效率。
像大多数的持久化框架一样,Mybatis也提供了缓存策略,通过缓存策略来减少数据库的查询次数,从而提高性能。 Mybatis中缓存分为一级缓存,二级缓存。
一级缓存
一级缓存是SqlSession级别的缓存,是默认开启的
所以在参数和SQL完全一样的情况下,我们使用同一个SqlSession对象调用一个Mapper方法,往往只执行一次SQL,因为使用SelSession第一次查询后,MyBatis会将其放在缓存中,以后再查询的时候,如果没有声明需要刷新,并且缓存没有超时的情况下,SqlSession都会取出当前缓存的数据,而不会再次发送SQL到数据库。
分析
一级缓存是SqlSession范围的缓存,执行SqlSession的C(增加)U(更新)D(删除)操作,或者调用clearCache()、commit()、close()方法,都会清空缓存。
1. 第一次发起查询用户id为41的用户信息,先去找缓存中是否有id为41的用户信息,如果没有,从数据库 查询用户信息。
2. 得到用户信息,将用户信息存储到一级缓存中。
3. 如果sqlSession去执行commit操作(执行插入、更新、删除),清空SqlSession中的一级缓存,这样做的目的为了让缓存中存储的是最新的信息,避免脏读。
4. 第二次发起查询用户id为41的用户信息,先去找缓存中是否有id为41的用户信息,缓存中有,直接从缓存中获取用户信息。
二级缓存
二级缓存是namspace级别(跨sqlSession)的缓存,是默认不开启的
二级缓存的开启需要进行配置,实现二级缓存的时候,MyBatis要求返回的POJO必须是可序列化的。也就是要求实现Serializable接口,配置方法很简单,只需要在映射XML文件配置 <cache/> 就可以开启二级缓存了。
<settings> <!-- 因为cacheEnabled的取值默认就为true,所以这一步可以省略不配置。 为true代表开启二级缓存;为false代表不开启二级缓存。 --> <setting name="cacheEnabled" value="true"/> </settings> <mapper namespace="com.lagou.dao.UserMapper"> <!--当前映射文件开启二级缓存--> <cache></cache> <!-- <select>标签中设置useCache=”true”代表当前这个statement要使用二级缓存。 如果不使用二级缓存可以设置为false 注意: 针对每次查询都需要最新的数据sql,要设置成useCache="false",禁用二级缓存。 --> <select id="findById" parameterType="int" resultType="user" useCache="true"> SELECT * FROM `user` where id = #{id} </select> </mapper>
二级缓存是mapper映射级别的缓存,多个SqlSession去操作同一个Mapper映射的sql语句,多个SqlSession可以共用二级缓存,二级缓存是跨SqlSession的。
1. 映射语句文件中的所有select语句将会被缓存。
2. 映射语句文件中的所有insert、update和delete语句会刷新缓存。
注意问题(脏读)
mybatis的二级缓存因为是namespace级别,所以在进行多表查询时会产生脏读问题
小结
1. mybatis的缓存,都不需要我们手动存储和获取数据。mybatis自动维护的。
2. mybatis开启了二级缓存后,那么查询顺序:二级缓存--》一级缓存--》数据库
3. 注意:mybatis的二级缓存会存在脏读问题,需要使用第三方的缓存技术解决问题。
MyBatis注解
* @Insert:实现新增,代替了<insert></insert>
* @Delete:实现删除,代替了<delete></delete>
* @Update:实现更新,代替了<update></update>
* @Select:实现查询,代替了<select></select>
* @Result:实现结果集封装,代替了<result></result>
* @Results:可以与@Result 一起使用,封装多个结果集,代替了<resultMap></resultMap>
* @One:实现一对一结果集封装,代替了<association></association>
* @Many:实现一对多结果集封装,代替了<collection></collection>
MyBatis注解的增删改查【重点】
public interface UserMapper { @Select("SELECT * FROM `user`") public List<User> findAll(); @Insert("INSERT INTO `user`(username,birthday,sex,address) VALUES(# {username},#{birthday},#{sex},#{address})") public void save(User user); @Update("UPDATE `user` SET username = #{username},birthday = #{birthday},sex = #{sex},address = #{address} WHERE id = #{id}") public void update(User user); @Delete("DELETE FROM `user` where id = #{id}") public void delete(Integer id); }
使用注解实现复杂映射开发
之前我们在映射文件中通过配置 <resultMap>、<association>、<collection> 来实现复杂关系映射。
使用注解开发后,我们可以使用 @Results、@Result,@One、@Many 注解组合完成复杂关系的配置。
一对一查询
public interface OrderMapper { @Select("SELECT * FROM orders") @Results({ @Result(id = true, column = "id", property = "id"), @Result(column = "ordertime", property = "ordertime"), @Result(column = "money", property = "money"), @Result(property = "user", javaType = User.class, column = "uid", one = @One(select = "com.lagou.mapper.UserMapper.findById", fetchType = FetchType.EAGER)) }) public List<Order> findAllWithUser(); }
一对多查询
public interface UserMapper { @Select("SELECT * FROM `user`") @Results({ @Result(id = true, column = "id", property = "id"), @Result(column = "brithday", property = "brithday"), @Result(column = "sex", property = "sex"), @Result(column = "address", property = "address"), @Result(property = "orderList", javaType = List.class, column = "id" , many = @Many(select = "com.lagou.mapper.OrderMapper.findByUid")) }) public List<User> findAllWithOrder(); }
多对多查询
public interface UserMapper { @Select("SELECT * FROM `user`") @Results({ @Result(id = true, column = "id", property = "id"), @Result(column = "brithday", property = "brithday"), @Result(column = "sex", property = "sex"), @Result(column = "address", property = "address"), @Result(property = "roleList", javaType = List.class, column = "id" , many = @Many(select = "com.lagou.mapper.RoleMapper.findByUid")) }) public List<User> findAllWithRole(); } public interface RoleMapper { @Select("SELECT * FROM role r INNER JOIN user_role ur ON r.`id` = ur.`rid` WHERE ur.`uid` = #{uid}") public List<Role> findByUid(Integer uid); }
基于注解的二级缓存
在Mapper接口中使用注解配置二级缓存
@CacheNamespace public interface UserMapper {...}
注解延迟加载
不管是一对一还是一对多 ,在注解配置中都有fetchType的属性
* fetchType = FetchType.LAZY 表示懒加载
* fetchType = FetchType.EAGER 表示立即加载
* fetchType = FetchType.DEFAULT 表示使用全局配置
小结
* 注解开发和xml配置优劣分析
1.注解开发和xml配置相比,从开发效率来说,注解编写更简单,效率更高。
2.从可维护性来说,注解如果要修改,必须修改源码,会导致维护成本增加。xml维护性更强。