【笔记】拉勾Java工程师高薪训练营-第一阶段 开源框架源码解析-模块一 持久层框架涉及实现及MyBatis源码分析-任务二：Mybatis基础回顾及高级应用
- 2020 年 11 月 16 日
- 筆記
- Java高薪训练营笔记
以下笔记是我看完视频之后总结整理的，部分较为基础的知识点也做了补充，如有问题欢迎沟通。
目录
- 任务二：Mybatis基础回顾及高级应用
- 2.1 Mybatis相关概念回顾
- 2.2 Mybatis环境搭建回顾
- 2.3 MybatisCRUD回顾
- 2.4 Mybatic相关配置文件回顾
- 2.5 Mybatis相关API回顾
- 2.6 Mybatic的dao层传统开发方式
- 2.7 Mybatic的dao层代理开发方式
- 2.8 Mybatis的properties深入
- 2.9 Mybatis的typeAliases深入
- 2.10 Mybatis的动态SQL-if标签回顾
- 2.11 Mybatis的动态SQL-foreach标签回顾
- 2.12 Mybatis的复杂映射-一对一映射
- 2.13 Mybatis的复杂映射-一对多映射
- 2.14 Mybatis的复杂映射-多对多映射
- 2.15 Mybatis注解CRUD回顾
- {}的值要与实体的保持一致，这样才能调用get方法
- 2.16 Mybatis注解一对一回顾
- 2.17 Mybatis注解一对多回顾
- 2.18 Mybatis注解多对多回顾
- 2.19 Mybatis缓存概念回顾
- 2.20 Mybatis一级缓存回顾
- 2.21 Mybatis一级缓存原理与源码分析
- 2.22 Mybatis二级缓存回顾
- 2.23 Mybatis利用redis实现二级缓存
- 2.24 Mybatis-redisCache源码分析
- 2.25 Mybatis插件机制介绍与原理
- 2.26 Mybatis插件机制-自定义Mybatis插件
- 2.27 Mybatis插件机制-plugin源码分析
- 2.28 Mybatis插件机制-pageHelper
- 2.29 Mybatis插件机制-通用mapper
任务二：Mybatis基础回顾及高级应用
2.1 Mybatis相关概念回顾
基于ORM（对象/关系数据库映射）的半自动轻量级持久层框架
使用ORM的效果：操作实体类，等同于操作数据库表
半自动的效果：支持定制化SQL语句，拥有对SQL优化的权力
2.2 Mybatis环境搭建回顾
环境搭建包括以下六步：
1 添加Mybatis和MySql连接的依赖包到pom文件
2 创建user数据表
3 编写User实体类
4 编写映射文件Usermapper.xml
5 编写核心文件SqlMapConfig.xml
6 编写测试类
2.3 MybatisCRUD回顾
执行增删改操作之后，要提交事务，相应操作才能生效
@Test
public void test1() throws IOException {
// 1 Resources工具类，加载配置文件，将配置文件加载成字节输入流
InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
// 2 解析了配置文件，并创建SqlSessionFactory工厂
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
// 3 生产SqlSession，openSession默认会开启一个事务，但不会提交
SqlSession sqlSession = sqlSessionFactory.openSession();
// 4 sqlSession调用CRUD方法
List<User> users = sqlSession.selectList("user.findAll");
for (User user : users) {
System.out.println(user);
}
// 5 手动提交事务，如果要自动提交事务，创建sqlSession时需要sqlSessionFactory.openSession(true)
sqlSession.commit();
sqlSession.close();
}
2.4 Mybatic相关配置文件回顾
#{ }调用的就是对象的get方法
UserMapper.xml文件内容回顾：
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"//mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="user">
<!--
namespace : 名称空间，与id组成sql的唯一标识
parameterType : 参数类型
resultType ： 返回值类型
-->
<!--查询用户-->
<select id="findAll" resultType="com.jlgl.pojo.User">
select * from user
</select>
<!--添加用户-->
<insert id="saveUser" parameterType="com.jlgl.pojo.User">
insert into user values(#{id},#{username},#{password},#{birthday})
</insert>
<!--修改-->
<update id="updateUser" parameterType="com.jlgl.pojo.User">
update user set username=#{username} where id= #{id}
</update>
<!--删除-->
<!--只有一个参数传入，且为基本类型时，形参可以随便写-->
<delete id="deleteUser" parameterType="java.lang.Integer" >
delete from user where id=#{id}
</delete>
</mapper>
sqlMapConfig.xml文件内容回顾：
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"//mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<!--配置运行环境-->
<environments default="development">
<environment id="development">
<!--当前事务交由JDBC管理-->
<transactionManager type="JDBC"/>
<!--当前使用Mybatis提供的连接池-->
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://120.48.8.213:3306/audio_2020"/>
<property name="username" value="root"/>
<property name="password" value="root1028*1"/>
</dataSource>
</environment>
</environments>
<!--引入映射配置文件-->
<mappers>
<mapper resource="UserMapper.xml"/>
</mappers>
</configuration>
2.5 Mybatis相关API回顾
// 1 Resources工具类，加载配置文件，将配置文件加载成字节输入流
InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
// 2 解析了配置文件，并创建SqlSessionFactory工厂
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
// 3 生产SqlSession，openSession默认会开启一个事务，但不会提交
SqlSession sqlSession = sqlSessionFactory.openSession();
// 4 sqlSession调用CRUD方法
List<User> users = sqlSession.selectList("user.findAll");
for (User user : users) {
System.out.println(user);
}
// 5 手动提交事务，如果要自动提交事务，创建sqlSession时需要sqlSessionFactory.openSession(true)
sqlSession.commit();
sqlSession.close();
2.6 Mybatic的dao层传统开发方式
具体包括以下三步：
1 创建接口IUserDao，声明CRUD方法
2 创建实现类UserDaoImpl，实现IUserDao接口，完成CRUD方法的重写
3 在业务逻辑中调用对应CRUD方法
2.7 Mybatic的dao层代理开发方式
只用编写持久层接口即可，不需要编写接口实现类，是通过动态代理对象完成CRUD操作
（下面的截图中有个错误，接口名和mapper的namespace里面应该同名，都为UserDao或UserMapper）
1) Mapper.xm文件中的 namespace 与 mapper 接口的全限定名相同
2) Mapper 接口方法名和 Mapper.xml中定义的每个 statement 的 id 相同
3) Mapper 接口方法的输入参数类型和 mapper.xml 中定义的每个 sql 的 parameterType 的类型相同
4) Mapper 接口方法的输出参数类型和 mapper.xml 中定义的每个 sql 的 resultType 的类型相同
2.8 Mybatis的properties深入
加载外部配置文件，必须放在第一行
2.9 Mybatis的typeAliases深入
XXXMapper.xml的resultType和parameterType必须要写全限定类名比较麻烦，可以给一个别名
如果pojo数量较大，采用package批量起别名，别名就是包下的类名，且别名不区分大小写
别名的配置是写在sqlMapConfig.xml文件里
<typeAliases>
<!--给一个类起别名-->
<!--<typeAlias type="com.jlgl.pojo.User" alias="user"></typeAlias>-->
<!--批量起别名，别名就是包下的类名，切别名不区分大小写-->
<package name="com.jlgl.pojo"/>
</typeAliases>
对于常用类型，Mybatis已经起好了别名
2.10 Mybatis的动态SQL-if标签回顾
直接使用if标签，需要在sql语句的最后先加一个where 1=1，然后再跟
select * from user where;
但是where 1=1 的写法虽然能行，但还是不太优雅，所以可以用
<!--多条件组合查询-->
<select id="findByCondition" 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>
2.11 Mybatis的动态SQL-foreach标签回顾
多值查询，就是比如要查多个id的user，然后将他们封装进一个List
<!--多值查询-->
<select id="findByIds" parameterType="list" resultType="user">
select * from user
<where>
<foreach collection="array" open="id in (" close=")" item="id" separator=",">
#{id}
</foreach>
</where>
</select>
SQL片段抽取，由于” select * from user “这段内容频繁出现，因此可以将这一片段抽取出来以便复用
<!--抽取SQL片段-->
<sql id="selectUser">
select * from user
</sql>
<!--多值查询-->
<select id="findByIds" parameterType="list" resultType="user">
<include refid="selectUser"></include>
<where>
<foreach collection="array" open="id in (" close=")" item="id" separator=",">
#{id}
</foreach>
</where>
</select>
2.12 Mybatis的复杂映射-一对一映射
一个订单对应一个用户，查询一个订单并查出对应用户信息
希望将User信息封装到Order的User属性里，resultType=”order”直接这么写，无法实现查询结果到Order的封装，因为User对象封装不进去，所以要使用resultMap
<select id="findOrderAndUser" resultType="order">
SELECT * from orders o,user u WHERE o.uid=u.id
</select>
resultMap：手动配置实体属性与表字段的映射关系
resultMap各个属性的含义：
id：给这个resultMap起一个名字，用于之后引用
type：被封装数据所对应的全限定类名
result各个属性的含义：
property：封装对象的类属性名
column：对应表的字段名
association（resultMap里面某个属性类的相关信息）各个属性含义：
property：对应属性名
javaType：属性对应的Java类全限定类名
<resultMap id="orderMap" type="com.jlgl.pojo.Order">
<result property="id" column="id"></result>
<result property="ordertime" column="ordertime"></result>
<result property="total" column="total"></result>
<association property="user" javaType="com.jlgl.pojo.User">
<result property="id" column="uid"></result>
<result property="username" column="username"></result>
</association>
</resultMap>
引入映射文件，也可以用
org.apache.ibatis.binding.BindingException: Invalid bound statement (not found): com.jlgl.dao.IUserMapper.findOrderAndUser
at org.apache.ibatis.binding.MapperMethod$SqlCommand.<init>(MapperMethod.java:225)
at org.apache.ibatis.binding.MapperMethod.<init>(MapperMethod.java:48)
at org.apache.ibatis.binding.MapperProxy.cachedMapperMethod(MapperProxy.java:65)
at org.apache.ibatis.binding.MapperProxy.invoke(MapperProxy.java:58)
at com.sun.proxy.$Proxy5.findOrderAndUser(Unknown Source)
2.13 Mybatis的复杂映射-一对多映射
因为封装的是集合，就不能使用association，而是collection
user和order都有id，那么在IUserMapper.xml里面如何知道哪个id封装给对应的id呢？需要做个区分column=”uid”
<resultMap id="userMap" type="com.jlgl.pojo.User">
<result property="id" column="uid"></result>
<result property="username" column="username"></result>
<!-- 因为封装的是集合，就不能使用association，而是collection -->
<collection property="orderList" ofType="com.jlgl.pojo.Order">
<result property="id" column="id"></result>
<result property="ordertime" column="ordertime"></result>
<result property="total" column="total"></result>
<result property="uid" column="uid"></result>
</collection>
</resultMap>
2.14 Mybatis的复杂映射-多对多映射
用户角色模型，一个用户有多个角色，一个角色被多个用户使用，查询需求是查询所有用户的同时查到关联的所有角色
user表
role表
user_role表，用户角色中间表，至少两个字段，这两个字段作为联合主键，也作为外键，分别指向另外两张表的主键
2.15 Mybatis注解CRUD回顾
使用注解开发，无需再编写配置文件
@Insert：：实现新增
@Update：实现更新
@Delete：实现删除
@Select：实现ັ查询
@Result：实现结果封装
@Resultsғ：可以和@Result一起使用，封装多个结果集
@One：实现一对一结果集封装
@Many：实现一对多结果集封装
{}的值要与实体的保持一致，这样才能调用get方法
Junit的@Before的作用是在执行@Test之前执行一些逻辑
2.16 Mybatis注解一对一回顾
@One对应的是association
one=@One(select = “namespace.id”)要做的就是根据uid，再去查询关联的用户
所以要在IUserMapper里面写好根据id查询的语句
即用了注解，也使用了xml配置文件，就会引起冲突，所以只能用一个
// 查询订单的同时还查询该订单所属用户
@Results({
@Result(property = "id", column = "id"),
@Result(property = "ordertime", column = "ordertime"),
@Result(property = "total", column = "total"),
@Result(property = "user", column = "uid", javaType = User.class,
one = @One(select = "com.jlgl.dao.IUserMapper.findUserById"))})
@Select("select * from orders")
List<Order> findOrderAndUser();
2.17 Mybatis注解一对多回顾
较为基础，不再赘述
2.18 Mybatis注解多对多回顾
较为基础，不再赘述
2.19 Mybatis缓存概念回顾
缓存就是内存中的一些数据，数据来自对数据库查询结果的缓存，可以避免与数据库的直接交互
一级缓存的级别就是sqlSession，底层结构就是一个Map
二级缓存的范围跨sqlSession，是mapper级别（namespace级别）
2.20 Mybatis一级缓存回顾
一级缓存默认是开启的
public void firstLevelCache(){
// 使用debug，看控制台的日志输出
// 第一次查询
User userById1 = userMapper.findUserById(1);
// 第二次查询
User userById2 = userMapper.findUserById(1);
System.out.println(userById1 == userById2);
}
结论1：第一次查询，若缓存中没有，则会从数据库查询，然后存到缓存中
结论2：做增删改操作，并进行了事务提交，就会刷新一级缓存
结论3:sqlSession.clearCache()也可以直接清空以及缓存，从而直接从数据库查询
2.21 Mybatis一级缓存原理与源码分析
看源码之前，要带着这几个问题：
问题1：一级缓存究竟是什么
问题2：什么时候被创建
问题3:一级缓存的工作流程是什么
分析源码的时候要先找到入口，这里就是SqlSession
翻阅源码的时候，要注意类与类之间的关系，比如从SqlSession接口里面的clearCache，我们要找到对应的实现类，
问题1：一级缓存究竟是什么
答案：缓存就是一个HashMap对象
能够看到private Map<Object, Object> cache = new HashMap();，所以缓存就是一个HashMap对象
private Map<Object, Object> cache = new HashMap();
问题2：什么时候被创建
答案：
Executor就是执行器，所以一般应该在这里创建
CacheKey cacheKey = new CacheKey();
// 其实就是statementId
cacheKey.update(ms.getId());
// 分页参数
cacheKey.update(rowBounds.getOffset());
cacheKey.update(rowBounds.getLimit());
// 底层的sql语句
cacheKey.update(boundSql.getSql());
// 还有一个获取environment的代码也值得关注一下
if (this.configuration.getEnvironment() != null) {
cacheKey.update(this.configuration.getEnvironment().getId());
}
问题3:一级缓存的工作流程是什么
答案：Executor的query方法里面具体创建、查询了一级缓存
list = resultHandler == null ? (List)this.localCache.getObject(key) : null;
if (list != null) {
this.handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
} else {
list = this.queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
}
2.22 Mybatis二级缓存回顾
二级缓存需要配置才会开启，一级缓存是默认开启的
配置需要两步：
1 sqlMapConfig.xml里面配置
2 在xxxMapper.xml或接口配置开启二级缓存
<!--开启二级缓存-->
<settings>
<setting name="cacheEnabled" value="true"/>
</settings>
// 开启二级缓存
@CacheNamespace
public interface IUserMapper {
}
//如果要禁用缓存，要求每次都从数据库查询
@Options(useCache = false)
@Select("select * from user where id=#{id}")
public User findUserById(Integer id);
2.23 Mybatis利用redis实现二级缓存
利用redis实现二级缓存需要三步：
1 启动redis
2 导入Mybatis实现的redisCache或自己编写redisCache
3 连接redis
4 更换注解里面的implemention
5 执行代码
PerpetualCache这个类就是Mybatis默认实现缓存的类
不管是PerpetualCache，还是我们要自定义缓存类，都要实现Cache接口
@CacheNamespace(implementation = PerpetualCache.class)可以指定实现类
public interface IUserMapper {
}
Mybatis自带的二级缓存，是为单服务器工作的，无法实现分布式缓存，所以我们要通过redis实现分布式二级缓存，不过Mybatis已经实现好了
@CacheNamespace(implementation = RedisCache.class)
public interface IUserMapper {
}
2.24 Mybatis-redisCache源码分析
看源码之前，要带着这几个问题：
问题1：如何进行缓存的存取
问题2：存储使用的是怎样的数据结构
redis.properties，且必须在resources文件夹下
通过代码可以看出，使用的是hset，即哈希表
public void putObject(final Object key, final Object value) {
this.execute(new RedisCallback()
{
public Object doWithRedis(Jedis jedis) {
jedis.hset(RedisCache.this.id.toString().getBytes(), key.toString().getBytes(), SerializeUtil.serialize(value));
return null;
}});
}
2.25 Mybatis插件机制介绍与原理
一般情况下，开源框架都会提供插件或其他形式的拓展点，供开发者自行拓展。这样的好处是显而易见的，一是增加了框架的灵活性开发者可以结合实际需求，对框架进行拓展，使其能够更好的工作。
Mybatis的四大组件分别是：
Executor̵
StatementHandler̵
ParameterHandler̵
ResultSetHandler
插件就是通过对四大核心组件进行拦截，然后增强功能，而底层使用的就是动态代理
如果我们需要自定义插件，可以如此定义：
2.26 Mybatis插件机制-自定义Mybatis插件
自定义插件编写步骤：
1 编写代码
2 sqlMapConfig注册插件
@Intercepts({
// 可以配置多个
@Signature(type = StatementHandler.class,
method = "prepare",
args = {Connection.class, Integer.class})
})
public class Myplugin implements Interceptor {
/**
* 拦截方法：只要拦截的目标对象的目标方法被执行，就会执行intercept方法
*
* @param invocation
* @return
* @throws Throwable
*/
@Override
public Object intercept(Invocation invocation) throws Throwable {
System.out.println("对方法进行了增强");
// 这句话就是让原方法执行
return invocation.proceed();
}
/**
* 把当前的拦截器生成代理对象，存到拦截器中
*
* @param o
* @return
*/
@Override
public Object plugin(Object o) {
Object wrap = Plugin.wrap(o, this);
return wrap;
}
/**
* 获取配置文件的参数
*
* @param properties
*/
@Override
public void setProperties(Properties properties) {
System.out.println("获取到的配置文件的参数是："+properties);
}
}
sqlMapConfig注册插件
<!--配置插件-->
<plugins>
<plugin interceptor="com.jlgl.plugin.Myplugin">
<property name="name" value="tom"/>
</plugin>
</plugins>
控制台输出：
获取到的配置文件的参数是：{name=tom}
对方法进行了增强
2.27 Mybatis插件机制-plugin源码分析
入口Plugin，通过implements InvocationHandler能够看出，这个对象就是动态代理对象处理类，并一定是重写了invoke方法
public class Plugin implements InvocationHandler {
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
try {
Set<Method> methods = (Set)this.signatureMap.get(method.getDeclaringClass());
return methods != null && methods.contains(method) ? this.interceptor.intercept(new Invocation(this.target, method, args)) : method.invoke(this.target, args);
} catch (Exception var5) {
throw ExceptionUtil.unwrapThrowable(var5);
}
}
}
2.28 Mybatis插件机制-pageHelper
分页插件使用需要三步：
1 导入pageHelper到pom
2 sqlMapConfig注册插件，需要配置方言
3 编写查询代码
sqlMapConfig注册插件，需要配置方言
<plugin interceptor="com.github.pagehelper">
<!--因为不同数据库的sql分页语句不同，所以要配置对应的方言-->
<property name="dialect" value="mysql"/>
</plugin>
Java查询代码
@Test
public void pageHelperTest(){
PageHelper.startPage(1,2);
List<User> users = userMapper.selectUser();
for (User user : users) {
System.out.println(user);
}
// 可以查询获得很多分页相关的数据
PageInfo<User> userPageInfo = new PageInfo<>(users);
userPageInfo.getFirstPage();
}
2.29 Mybatis插件机制-通用mapper
单表增删改查的数据重复书写没有意义，可以直接使用通用mapper，只要写好实体类就可以了（当然实体类的生成也不需要手写，也有对应的自动化生成方法）
注意Example和Criteria的操作
此部分较为基础，不再赘述
