测试博客

自定义持久层框架
- mybatis 简介
  - sqlMapConfig.xml 节点说明
- mybatis 注解开发

2020年8月25日20:55:29

自定义持久层框架

持久层框架是对jdbc 的封装，并解决了jdbc存在的问题

jdbc 代码基础回顾

try{
    Class.formName("com.mysql.jdbc.Driver");
    connection = .....
}cache(Exception e){
    
}

传统jdbc 存在数据库配置信息存在硬编码问题当更换数据库后需要再次对数据库驱动信息进行更改
频繁创建释放数据库连接
sql语句设置参数获取结果集等参数均存在硬编码问题
手动封装结果集较为繁琐

解决传统jdbc存在的问题

硬编码 –> 配置文件
硬编码 –> 连接池
手动封装结果集 –> 反射内省

自定义持久层框架设计思路

使用端 –> 项目

引入自定义持久层jar
提供数据库配置信息及sql配置信息
- sql配置信息
  - sql语句
  - 参数类型
  - 返回值类型
使用配置文件提供外上述两种配置信息
sqlMapConfig.xml 存放数据库的配置信息,存入mapper.xml全路径
mapper.xml 存放sql配置信息

自定义持久层框架本身

创建为项目工程,本质是对jdbc代码进行封装-->底层为传统的jdbc

数据库配置信息
sql 配置信息占位符参数 sql语句等
根据调用处传递的配置信息进行解析
- 加载配置文件 --> 以字节输入流的形式加载 --> 存储在内存中
- 创建Resource类,getResourceAsStream(String path)
- 创建2个javaBean(容器对象),存放的是对配置文件解析出的内容
  - Configuration：核心配置类：存放sqlMapperConfig.xml解析的内容
  - MappedStrement:映射配置类：存放mapper.xml解析的内容
- 解析配置文件：Dom4j
  - 创建类：SqlSessionFactoryBuilder，存在方法：build(InputStream in)
  - build方法实现逻辑：
    - 使用dom4j解析配置文件，将解析结果封装到容器对象内
    - 创建sqlSessionFactory对象,生产sqlSession(会话对象),避免重复创建连接 --> 工厂模式降低耦合
- 创建sqlSessionFactory接口及实现类DefaultSqlSessionFactory
  - openSession方法 : 创建 sqlSession对象
- 创建SqlSession 接口及实现类DefaultSqlSession 定义对数据库的CRUD方法
  - selectList()
  - selectOne()
  - update()
  - delete()
- 创建Excutor接口及实现类 SimpleExcutor 实现类
  - query(Configuration conf,MappedStatement mapped，Object …params):执行JDBC代码

graph TB
b("工程项目")

subgraph 工程项目
d("mapper.xml") --"mapper.xml全路径"--> c("sqlMapConfig.xml")
b --"sql执行语句"--> d
b --"数据库配置"--> c
end

b --"引用"--> a

subgraph 自定义持久层
tip("本质是对jdbc代码的封装")
a("自定义持久层")

tip --> a
a --"1. 创建"--> a1("Resources类")
a1 --> a1a("InputStream()")
a1 --"加载配置文件为字节输入流"--> a1b("getResourceAsStream(String path)")


a --"2. 创建"--> a2("容器javaBean")

subgraph 容器
a2 --"创建核心配置类"--> a2a("Configuration")
a2a --"存放"--> a21a("sqlMapConfig.xml 解析的内容")
a2 --"创建核心配置类"--> a2b("MappedStatement")
a2b --"映射配置类"--> a2b1("mapper.xml 解析的内容")
end

a --"3. 创建"--> a3("SqlSessionFactory")
a3 --"实现类"--> a3a("DefaultSqlSessionFactory")
a3a --"方法"--> a3a1("openSession()")
a3a1 --"生产"--> a3a1a("Sqlsession")

a --"4. 解析配置文件dom4j"--> a4("SqlSessionFactoryBuilder")
a4 --"方法"--> a41("build(inputStream in)")
a41 --"使用dom4j解析配置文件" --> a4a1a("解析结果")
a4a1a --"封装到容器对象"--> a2
a41 --"创建"--> a41b("SqlSessionFactory对象")
a41b  --"工厂模式生产"--> a41b1("sqlSession会话对象")

a --"5. 创建"--> a5("SqlSession接口")
a5 --"实现类"--> a5a("DefaultSession")
a5a --"列表查询"--> a5a1("selectList()")
a5a --"查询单个"--> a5a2("selectONe()")
a5a --"修改"--> a5a3("update()")
a5a --"删除"--> a5a4("delete()")

a --"6. 创建"--> a6("Excutor接口")
a6 --"实现类"--> a6a("SimpleExcutor")
a6a --"成员方法"--> a6a1("query(Configuration conf,MappedStatement st,Object ...params);")
a6a1 --"执行jdbc代码" -->a6a1a("sql语句")
end

`mybatis` 简介

持久层框架
基于orm:Object Relation Mapping 实体类和数据库表建立映射关联关系
半自动可以对sql进行优化 hibernate -> 全自动
轻量级：启动的过程中需要的资源比较少
底层：对jdbc执行代码进行封装规避硬编码,频繁开闭数据源

`sqlMapConfig.xml` 节点说明

environments 数据库环境的配置,支持多环境配置
environments.default--> 指定mybatis 使用的默认环境名称
environment.id-->当前环境的名称
environment – transcationManager.type=”JDBC” 指定事务管理类型为jdbc
environment – dataSource.type=”POOLED” 指定数据源类型为连接池
environment – dataSource
- property.driver 数据库驱动
- property.url 数据库地址注意连接编码格式
- property.user 数据库连接用户名
- property.password 数据库连接用密码
mapper 配置的四种方式：
- mapper.resource 相对于类路径的引用
- mapper.url 完全限定资源定位符
- mapper.class 接口对应的全路径
- package.name 批量加载 保证映射文件与接口同包同名

传统dao层开发方式

dao层开发方式

mybatis 外部properties 文件

设置mybatis xml配置文件的约束头
在resources下创建外部配置文件格式：对象.属性=值
加载外部配置文件
- 在 configutation 后第一个节点之前引入外部配置文件 <properties resource='路径'/>

mybatis `aliasType`

在mybatis 配置文件中的typeAliases 节点中设置

<typeAliases>
    <typeAlias type="pojo类路径的全限定名" alais="别名"></typeAlias>
</typeAliases>
// 对于基础数据类型 mybatis 已定义了别名
string ==> String
long ==> Long
int ==> Integer
double ==> Double
boolean ==> Boolean

当存在多个pojo时不适用以上方法,采用package模式[批量起别名]

package模式 不要单独指定alias属性默认为类本身的类名,且不区分大小写

<typeAliases>
    <package name="pojo类所在包的全限定名"></typeAlias>
    // 不要单独指定alias属性 默认为类本身的类名,且不区分大小写
</typeAliases>

mapper.xml

动态sql

if 标签判断入参是否符合条件，不符合不拼接
where 标签自动拼接where 同时去掉where后的第一个and 关键字
foreach 标签
- collection array 注意便携式不要使用#{}
- open 循环前追加
- close 循环结束后追加
- item 单次循环内的数据对象生成的变量
- separator 前后循环数据之间的分隔符
sql 标签抽取sql片段
- id sql语句的标识
- 内容为具体的sql语句可用于封装分页和查询某张表时的前面部分

mybatis复杂映射开发

sqlMapConfig.xml 内引入 mapper.xml

<package name="与接口同包同名的包名"><package>

一对一查询

resultMap 手动配置实体属性与表字段的映射关系可用于mybatis 的resultMMap

id
type 按照封装对象的全路径

<resultMap id="orderMap" type="com.lagou.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.lagou.pojo.User">
        <result property="id" column="uid"></result>
        <result property="username" column="username"></result>
    </association>
</resultMap>

<!--resultMap：手动来配置实体属性与表字段的映射关系-->
<select id="findOrderAndUser" resultMap="orderMap">
    select * from orders o,user u where o.uid = u.id
</select>

一对多查询

    <resultMap id="userMap" type="com.lagou.pojo.User">
        <result property="id" column="uid"></result>
        <result property="username" column="username"></result>
        <collection property="orderList" ofType="com.lagou.pojo.Order">
            <result property="id" column="id"></result>
            <result property="orderTime" column="orderTime"></result>
            <result property="total" column="total"></result>
        </collection>
    </resultMap>

    <select id="findAll" resultMap="userMap">
        select * from user u left join orders o on u.id = o.uid
    </select>

多对多查询

查询用户的同时查询出用户的角色

   <resultMap id="userRoleMap" type="com.lagou.pojo.User">
       <result property="id" column="userid"></result>
       <result property="username" column="username"></result>
       <collection property="roleList" ofType="com.lagou.pojo.Role">
           <result property="id" column="roleid"></result>
           <result property="roleName" column="roleName"></result>
           <result property="roleDesc" column="roleDesc"></result>
       </collection>
   </resultMap>

   <select id="findAllUserAndRole" resultMap="userRoleMap">
       select * from user u left join sys_user_role ur on u.id = ur.userid
   		left join sys_role r on r.id = ur.roleid
   </select>

mybatis 注解开发

使用注解开发无需编写任何配置文件

@Insert 增
@Update 删
@Delete 改
@Select 查
@Result 实现对结果集的封装替代result标签节点
@Results 替代resultMap 标签节点
@One 替代单个pojo对象替代 association 标签节点
@Many 如果属性为集合时则采用此注解

注解一对多

@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.lagou.mapper.IUserMapper.findUserById"))
})
@Select("select * from orders")
public List<Order> findOrderAndUser();

注解多对多

# IUserMapper
    //查询所有用户、同时查询每个用户关联的角色信息
    @Select("select * from user")
    @Results({
            @Result(property = "id",column = "id"),
            @Result(property = "username",column = "username"),
            @Result(property = "roleList",column = "id",javaType = List.class,
             many = @Many(select = "com.lagou.mapper.IRoleMapper.findRoleByUid"))
    })
    public List<User> findAllUserAndRole();
# IRoleMapper
    @Select("select * from sys_role r,sys_user_role ur where r.id = ur.roleid and ur.userid = #{uid}")
    public List<Role> findRoleByUid(Integer uid);

mybatis 缓存

一级缓存

使用同一个sqlSession 对象时,数据会被缓存
mybatis 一级缓存过程图解

第一次发起查询用户id为1的用户信息，先去找缓存中是否有id为1的用户信息，如果没有，从
数据库查询用户信息。得到用户信息，将用户信息存储到一级缓存中。
如果中间sqlSession去执行commit操作(执行插入、更新、删除)，则会清空SqlSession中的
一级缓存，这样做的目的为了让缓存中存储的是最新的信息，避免脏读。
第二次发起查询用户id为1的用户信息，先去找缓存中是否有id为1的用户信息，缓存中有，直
接从缓存中获取用户信息

一级缓存分析

一级缓存分析流程图

一级缓存到底是什么

底层是一个hashMap 参照上述流程图

一级缓存什么时候被创建

缓存key创建类： Excustor.class.createCacheKey()
BaseExcutor.createCacheKey() //创建一级缓存的key

CacheKey.update()
  - updateList.add(configuration.getEnviroment().getId());

一级缓存的工作流程是怎样的
一级缓存的清空 sqlSession.close() 或者执行带有事务的操作
在分布式环境下也会存在脏读问题 解决:禁用一级缓存或调整缓存为statement 级别

二级缓存

原理类似一级缓存
操作的sqlSession 执行了事务操作后会清空二级缓存
一级缓存默认开启

二级缓存需要手动配置开启

1. xml开发形式
<setting>
    <setting name="cacheEnabled" value="true" />
</setting>
2. 注解形式
在dao接口上添加注解 @CacheNamespace

二级缓存缓存的不是对象而是对象中的数据
- pojo类需要实现 Serializable 接口
- 二级缓存的存储机制是多样的,可能存储在硬盘上或者内存中
当执行带有事务的操作后,二级缓存会被清空
当基于xml配置时还可以配置
- useCache 属性 false 禁用二级缓存每次查询都发送sql去数据库查询默认为true
- 注解形式：@select 注解之前添加 @Options(cache="false")
- flushCache 属性: 每次增删改操作后清空缓存默认true

二级缓存整合redis

mybatis二级缓存结构示意图

PerpetualCache 是mybatis默认实现缓存功能的类
二级缓存的底层数据结构还是 HashMap org.apache.ibatis.cache.impl.PerpetualCache --> private Map<Object, Object> cache = new HashMap()

指定mybatis二级缓存的实现类

在dao接口上添加注解 
@CacheNamespace(implementation=PerpetualCache.class) 
PerpetualCache.class 更换为自定义缓存实现类
如 : @CacheNamespace(implementation = RedisCache.class)

二级缓存存在的问题
- 单服务器下 –> 没问题
- 分布式 –> 无法实现分布式缓存

分布式缓存技术

redis 官方提供有mybatis-redis实现类

<dependency>
    <groupId>org.mybatis.caches</groupId>
    <artifactId>mybatis-redis</artifactId>
    <version>1.0.0-beta2</version>
</dependency>

配置配置文件 ： redis.properties
配置以下属性：
  host=localhost
  port=6379
  connectionTimeout=5000
  password=123456
  database=0

memcached
ehcache

二级缓存存在的脏读问题分析

redis-cache 分析

redis-cache 是如何存取值的

1. 必须实现mybatis 的cache 接口
2. 使用 jedis.hget 进行取值

redis-cache 使用的是哪种redis 数据结构
- redis 的 hash 数据类型

mybatis的插件

一种形式的拓展点
- 增加灵活性
- 根据实际需求自行拓展
mybatis 的四大组件及允许拦截的方法
- Executor 执行器
  - update
  - query
  - commit
  - rollback 等
- StatementHandler sql语法构建器
  - prepare
  - parameterize
  - batch
  - update
  - query 等
- ParameterHandler 参数处理器
  - getParameterObject
  - setParameterObject
- ResultSetHandler 结果集处理器
  - handleResultSets
  - handleOutputParameters
插件拦截器底层是对以上四个组件的拦截,采用动态代理实现

以上组件的创建原理

每个创建出来的对象不是直接返回的，而是interceptorChain.pluginAll(parameterHandler)
获取到所有的Interceptor(拦截器)(插件需要实现的接口);调用interceptor.plugin(target);返回target包装后的对象
插件机制，我们可以使用插件为目标对象创建一个代理对象；AOP（面向切面）我们的插件可以为四大对象创建出代理对象，代理对象就可以拦截到四大对象的每一个执行;
由于使用了jdk动态代理,那么就回去执行 invoke 方法,可以在拦截器的前置和后置处理器内做相应的处理操作

@Intercepta({
    @signature(
        type=Executor.class,
        method="query",
        args=(MappedStatement.class,Object.class,RowBounds.class,ResultHandler.class}
    )
})
public class ExamplePlugin implements Interceptor{
//省略逻辑
}

自定义mybatis 插件

插件 –> 拦截器

org.apache.ibatis.plugin.Interceptor 类
# 拦截方法：只要被拦截的目标对象的目标方法被执行时，每次都会执行intercept方法
Interceptor.intercept 
# 主要为了把当前的拦截器生成代理存到拦截器链中
Interceptor.plugin
# 获取配置文件的参数
Interceptor.setProperties

定义


import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.executor.statement.StatementHandler;
import org.apache.ibatis.plugin.*;

import java.sql.Connection;
import java.util.Properties;

# 可以多个Signature 
@Intercepts({
    @Signature(type= StatementHandler.class,method = "prepare",args = {Connection.class,Integer.class}),
    @Signature(type= Executor.class,method = "prepare",args = {Connection.class,Integer.class})
})
public class MyPlugin implements Interceptor {
    /*
        拦截方法：只要被拦截的目标对象的目标方法被执行时，每次都会执行intercept方法
     */
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        System.out.println("对方法:" + invocation.getMethod().getName() + " 进行了增强...." );
        return invocation.proceed(); //原方法执行
    }
    /*
       主要为了把当前的拦截器生成代理存到拦截器链中
     */
    @Override
    public Object plugin(Object target) { Object wrap = Plugin.wrap(target, this); return wrap; }
    /*
        获取配置文件的参数
     */
    @Override
    public void setProperties(Properties properties) { System.out.println("获取到的配置文件的参数是："+properties); }
}

配置

<plugins>
    <plugin interceptor="com.lagou.plugin.MyPlugin">
        <property name="name" value="tom"/> <!-- 设置参数 -->
    </plugin>
</plugins>

使用

1. MyPlugin.plugin --> MyPlugin.intercept  --> MyPlugin.setProperties

mybatis的第三方插件

PageHelper

导入maven 依赖

<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper</artifactId>
    <version>3.7.5</version>
</dependency>

在mybatis配置文件中配置PageHelper

在 plugins 节点内 添加 plugin 并设置属性 `property` 方言 `dialect` 值设 `mysql`
<plugin interceptor="com.github.pagehelper.PageHelper">
    <property name="dialect" value="mysql"/>
</plugin>

通用 mapper

导入依赖

<dependency>
    <groupId>tk.mybatis</groupId>
    <artifactId>mapper</artifactId>
    <version>3.1.2</version>
</dependency>

mybatis 的配置文件内配置通用mapper 的plugin

<plugin interceptor="tk.mybatis.mapper.mapperhelper.MapperInterceptor">
    <!--指定当前通用mapper接口使用的是哪一个-->
    <property name="mappers" value="tk.mybatis.mapper.common.Mapper"/>
</plugin>

实体类设置关联

@Table(name = "user")
public class User implements Serializable {

    @Id //对应的是注解id
    @GeneratedValue(strategy = GenerationType.IDENTITY) 
    // @GeneratedValue strategy 设置主键的生成策略
    // GenerationType.IDENTITY 底层必须支持自增长
    // GenerationType.SEQUENCY 底层不支持自增长
    // GenerationType.TABLE 从表中取值 生成主键
    // GenerationType.AUTO 自动选择合适的生成主键
    private Integer id;
    
    @Column(name="123") 当与表的字段不同时,采用@Column 保持同步
    private String username;
    // Get Set 略
}

创建dao接口继承tk.mybatis.mapper.common.Mapper传入泛型

egg: public interface UserMapper  extends Mapper<User> {}

使用

传统调用

InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
User user = new User();
user.setId(1);
User user1 = mapper.selectOne(user);
System.out.println(user1);

Example 方式调用

InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
// example 方式调用
Example example = new Example(User.class);
// 查询User表中的全部记录
example.createCriteria().andEqualTo("id",1);
// 执行查询,获得结果
List<User> users = mapper.selectByExample(example);
for (User user2 : users) {
    System.out.println(user2);
}

随堂测试01 自定义持久层框架

自定义持久层框架IPersistence是如何解决JDBC存在的问题：() [多选题]
- [x] A. 用配置文件解决了硬编码问题
- [x] B.使用了C3P0连接池解决了频繁创建释放数据库连接问题
- [x] C.在simpleExecute中使用到了反射进行了参数的设置
- [x] D.在simpleExecute中使用了内省进行了返回结果集的封装
在进行自定义持久层框架IPersistence优化时，主要为了解决那些问题：（） [多选题]
- [x] A．应用在Dao层，整个操作的模板代码重复
- [x] B．调用sqlSession方法时、参数statementId硬编码
- [ ] C．无法保证statementId的唯一性
- [ ] D．参数存在硬编码
下列关于Configuration及MappedStatement配置类，说法正确的是：（） [多选题]
- [x] A．使用dom4j对sqlMapConfig.xml解析时，会将解析出来的内容以不同形式封装到Configuration对象中
- [ ] B．使用dom4j对mapper.xml解析时，每个标签的内容均对应一个MappedStatement对象
  [x] C．Configuration中包含了MappedStatement的引用
  [ ] D．MappedStatement对象对应Mapper.xml，一个Mapper.xml对应一个MappedStatement对象
  
  下列关于GenericTokenParser类，说法正确的是：（） [多选题]
  
  [x] A．该类只能通过有参构造进行创建
  [x] B．GenericTokenParser是通用的标记解析类
  [x] C．GenericTokenParser在解析#{}占位符时必须要通过标记处理类TokenHandler的配合
  [x] D．GenericTokenParse三个构造参数分别为开始标记、结束标记、标记处理器
  
  随堂测试02 MyBatis基础回顾及高级应用
  
  在一个MyBatis的应用中，关于SlqessionFactoyfBuilder，SqlsessionFactory以及Sqlsession的应用范围和生命周期，以下说法错误的是：（）
  
  [ ] A．SqlSessionFactoryBuilder的最佳范围为方法范围，即可要定义为本地方法变量
  [ ] B．SqlSessionFactory的最佳范围是应用范围
  [ ] C．SqlSession的最佳范围是方法范围或请求范围
  [x] D．SqlSession执行CRUD操作，不同线程可以共享使用
  
  在Mybatis中，下列关于ResultType说法错误的是：（）
  
  [ ] A．ResultType表示返回值类型为：完整类名或别名，Mybatis也允许使用基本的数据类型，包括String、int类型
  [ ] B．ResultType和ResultMap的数据结构是一样的，都是Map结构
  [x] C．如果POJO的属性名与SQL语句查询出来的字段名不一致的话，也可使用resultType来进行结果的自动映射
  [ ] D．ResultType和ResultMap不能同时使用
  
  使用MyBatis的时候,除了可以使用@Param注解来实现多参数入参,还可以用()传递多个参数值：（）
  
  [x] A．用Map对象可以实现传递多参数值
  [ ] B．用List对象可以实现传递多参数值
  [ ] C．用数组的方式传递
  [ ] D．用Set集合的方式传递
  
  Mapper接口开发需要遵循下列哪些规范？ [多选题]
  
  [x] A．Mapper.xml文件中的namespace与mapper接口的类路径相同
  [x] B．Mapper接口方法名和Mapper.xml 中定义的每个statement的id相同
  [x] C．Mapper接口方法的输入参数类型和mapper.xml中定义的每个sql的parameterType的类型相同
  [x] D．Mapper接口方法的输出参数类型和mapper.xml中定义的每个sql的resultType的类型相同
  
  mybatis架构原理
  2020年8月25日21:20:04
  
  接口层
  
  传统方式 –> sqlSession.selectList()…
  mapper代理方式 –> 代理对象 –> 内省
  
  数据处理层
  框架支撑层
  
  层次结构示意图
  
  mybatis传统方式源码分析
  
  Configuration
  SqlSession 是Mybatis 中用于和数据库交互的顶层类,通常与ThreadLocal绑定,一个会话使用一个SqlSession,并且在使用完毕后需要close
  
  DefaultSqlSession 默认
  SqlSession中较为重要的两个参数 configuration与初始化时相同,Executor为执行器
  openSession 生产DefaultSqlSession实例对象,设置事务不自动提交,完成Executor对象的创建
  
  Mapper代理方式
  
  如何对mapper接口产生代理对象
  代理对象在调用方法时,底层的invoke方法是如何执行的
  
  设计模式
  
  Builder模式(构建者模式) –>
  
  如果某个对象的构建比较复杂或超出了构建函数所能包含的范围时,就可以使用工厂模式和构建者模式
  使用多个简单对象一步一步构建出一个复杂的对象
  egg: 构建电脑 –> 各个组件的构建
  
  工厂方法模式
  
  简单工厂模式根据传入的参数不同创建其他不同的实例
  被创建的实例一般都具有相同父类
  
  单例模式
  代理模式
  组合模式
  模板方法模式
  适配器模式
  装饰者模式
  迭代器模式
  
  mybatis 执行流程图解
  
  mybatis延迟加载
  
  一对多，延迟加载，多对一立即加载当同时配置了局部和全局，那么局部优先于全局
  主要通过动态代理的方式实现的,通过代理拦截到指定的方法，执行数据加载
  
  局部延迟
  
  <1–关闭一对一延迟加载–>
  <resultMap id=”orderMap”type=”order”>
  <id column=”id”property=”id”></id>
  <result column=”ordertime”property=”ordertime”></result>
  <result column=”total”property=”total”></result>
  <!–
  fetchrype=”lazy”懒加载策略
  fetchType=”eager”立即加载策略
  –>
  <association property=”user”column=”uid”javarype=”user”
  select=”com.lagou.dao.UserMapper.findById”fetchrype=”eager”I
  </association>
  </resultMap>
  
  全局延迟
  在核心配置文件中的setting 标签
  
  <settings>
  <1–开启全局延迟加载功能–>
  <setting name=”lazytoadingEnabled”value=”true”/>
  </settings>I
  
  idea 调试延迟加载的注意点
  
  mybatis 动态sql相关类
  
  SqlNode 接口
  SqlSource Sql 源接口
  BoundSql 类
  
  XMLConfigBuilder 在执行过程中会调用 XMLMapperBuilder
  
  XMLMapperBuilder 内部使用XMLStatementBuilder 处理xml中的各个节点
  
  XMLStatementBuilder
  
  解析xml文件中的各个节点,如select,insert,update,delete节点，
  内部会使用XMLScriptBuilder处理节点的sql部分，
  遍历产生的数据会丢到Configuration的mappedStatements中。
  
  XMLScriptBuilder 解析sql内容,会使用到LanguageDriver接口极其实现类，该接口的主要作用是构建SQL
  
  LanguageDriver –> 追踪 mybatis 拼接sql的具体执行部分
  
  mybatis 四大对象的生命周期及应用范围
  
  SqlSession :现成不安全,作用于请求或方法期间
  
  常用的数据库连接池
  
  c3p0 架构复杂
  dbcp 迭代了一个版本
  druid 功能全面中文文档
  
  mybatis 查询数据量大的时候会造成oom 如何处理
  
  ?

本文链接：https://www.cnblogs.com/Yount/p/13902939.html

测试博客

自定义持久层框架

jdbc 代码基础回顾

解决传统jdbc存在的问题

自定义持久层框架设计思路

使用端 –> 项目

自定义持久层框架本身

`mybatis` 简介

`sqlMapConfig.xml` 节点说明

传统dao层开发方式

dao层开发方式

mybatis 外部properties 文件

mybatis `aliasType`

mapper.xml

动态sql

mybatis复杂映射开发

一对一查询

一对多查询

多对多查询

mybatis 注解开发

注解一对多

注解多对多

mybatis 缓存

一级缓存

一级缓存分析

二级缓存

redis-cache 分析

mybatis的插件

以上组件的创建原理

自定义mybatis 插件

mybatis的第三方插件

测试博客的更多相关文章

随机推荐

热门专题

目录导航

测试博客

自定义持久层框架

jdbc 代码基础回顾

解决传统jdbc存在的问题

自定义持久层框架设计思路

使用端 –> 项目

自定义持久层框架本身

mybatis 简介

sqlMapConfig.xml 节点说明

传统dao层开发方式

dao层开发方式

mybatis 外部properties 文件

mybatis aliasType

mapper.xml

动态sql

mybatis复杂映射开发

一对一查询

一对多查询

多对多查询

mybatis 注解开发

注解一对多

注解多对多

mybatis 缓存

一级缓存

一级缓存分析

二级缓存

redis-cache 分析

mybatis的插件

以上组件的创建原理

自定义mybatis 插件

mybatis的第三方插件

测试博客的更多相关文章

随机推荐

热门专题

目录导航

`mybatis` 简介

`sqlMapConfig.xml` 节点说明

mybatis `aliasType`