mybatis源码阅读与设计模式分析

最新推荐文章于 2023-01-11 23:35:19 发布
最新推荐文章于 2023-01-11 23:35:19 发布
阅读量215 收藏 1
点赞数
分类专栏： mysql java 文章标签： java mybatis 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hhy107107/article/details/115314758
版权
java 同时被 2 个专栏收录
18 篇文章 0 订阅
订阅专栏
mysql
7 篇文章 0 订阅
订阅专栏

mybatis源码阅读与设计模式分析

1、目标

orm框架…一直在用，不解释

  1. 了解mybatis实现原理
  2. 梳理用到的设计模式，思考中这个场景使用该设计模式到好处以及是否有弊端。
  3. 对于框架里面遇到的一些有意思的方案（如果有的话），思考是否有其它替代到方案，并横向对比优劣。

2、阅读官方文档

习惯性到官网瞅瞅…突然发下一些以前不知道的特性，故而记录下～

2.1、文档中读到到

  1. MyBatis 3.4.2 开始，可以为占位符指定一个默认值(默认关闭，需要开启)。例如 <property name="username" value="${username:ut_user}"/>，默认username为ut_user
  2. 当返回行结果所有列是空到时，mybatis默认返回null; 如果配置了returnInstanceForEmptyRow=true, mybatis会返回一个空实例[或空列表]。
  3. shrinkWhitespacesInSql=true从SQL中删除多余的空格字符。请注意，这也会影响SQL中的文字字符串。 (新增于 3.5.5) 【这条特性有什么用？把字符串到空格都删了？？】
  4. xml允许使用别名。例如一条sql的返回类型是：Author，中xml中可以直接写成<... resultType="author"> java bean的别名默认为首字母小写的非限定类名。所以xml里面，java.util.List可以直接写成list
  5. mybatis从参数或者结果集取值的时候，用不同类型处理器将取到的值转换成java类型（BooleanTypeHandler，ShortTypeHandler等）。可以重写已有的类型处理器或者新增自己的类型处理器以支持更多类型（实现org.apache.ibatis.type.TypeHandler或者继承org.apache.ibatis.type.BaseTypeHandler）。
  6. mybatis允许使用插件对sql语句执行过程的某一点做拦截调用。实现Interceptor接口，指定要拦截等方法。

允许拦截的方法调用包括（这个记录下，写代码的时候可能要用到）：
Executor (update, query, flushStatements, commit, rollback,
getTransaction, close, isClosed)
ParameterHandler (getParameterObject, setParameters)
ResultSetHandler (handleResultSets, handleOutputParameters)
StatementHandler (prepare, parameterize, batch, update, query)

  1. mybatis xml中 <select>支持配置 timeout属性

3. 源码

3.1. 总览

3.1.1. 包结构

org.apache.ibatis.annotations  -- 注解
org.apache.ibatis.binding      -- 生成mapper接口的动态代理
org.apache.ibatis.builder      -- 包含Configuration对象所有构建器，xml和注解两种方式配置的解析
org.apache.ibatis.cache        -- 缓存
org.apache.ibatis.cursor       -- 游标
org.apache.ibatis.datasource   -- 数据源
org.apache.ibatis.exceptions   -- 异常
org.apache.ibatis.executor     -- sql执行器 核心
org.apache.ibatis.io           -- io
org.apache.ibatis.jdbc         -- jdbc
org.apache.ibatis.lang         --
org.apache.ibatis.logging      -- 日志
org.apache.ibatis.mapping      -- 配置文件与实体文件映射
org.apache.ibatis.parsing      -- 解析
org.apache.ibatis.plugin       -- 拦截器
org.apache.ibatis.reflection   -- 反射
org.apache.ibatis.scripting    -- 动态sql语言 <if> <where>等
org.apache.ibatis.session      -- sql session 核心
org.apache.ibatis.transaction  -- 事务
org.apache.ibatis.type         -- 类型处理器

3.1.2. 流程

public static void main(String[] args) throws IOException {
    InputStream inputStream = Resources.getResourceAsStream("mybatis.xml");
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    try (SqlSession sqlSession = sqlSessionFactory.openSession();) {
        DemoMapper demoMapper = sqlSession.getMapper(DemoMapper.class);
        List<Demo> list = demoMapper.selectProductList();
    }
}

<configuration>
    <properties resource="db.properties" />
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="me/hhy/mapper/DemoMapper.xml"/>
    </mappers>
</configuration>

从上面的使用实例可以看出mybatis运行的流程:

  1. 根据配置文件，创建SqlSessionFactory。-- 这里解析配置文件并根据配置文件创建一个SqlSessionFactory
  2. 打开一个mysql会话 – sqlSessionFactory.openSession
  3. 获取mapper接口
  4. 调用接口方法 – 执行sql

3.2. 细读

3.2.1. 创建SqlSessionFactory（配置[xml]解析部分）

3.2.1.1 加载配置文件mybatis.xml

按前面的使用示例显示，加载配置文件使用的是Resource.getResourceAsStream(“filename”)，返回一个InputStream。功能比较简单，但有值得学习的点：

public class Resources {

  private static ClassLoaderWrapper classLoaderWrapper = new ClassLoaderWrapper();
  public static InputStream getResourceAsStream(String resource) throws IOException {
    return getResourceAsStream(null, resource);
  }
  
  public static InputStream getResourceAsStream(ClassLoader loader, String resource) throws IOException {
    InputStream in = classLoaderWrapper.getResourceAsStream(resource, loader);
    if (in == null) {
      throw new IOException("Could not find resource " + resource);
    }
    return in;
  }
}

public class ClassLoaderWrapper {
  public InputStream getResourceAsStream(String resource) {
    return getResourceAsStream(resource, getClassLoaders(null));
  }
  public InputStream getResourceAsStream(String resource, ClassLoader classLoader) {
    return getResourceAsStream(resource, getClassLoaders(classLoader));
  }
  
  InputStream getResourceAsStream(String resource, ClassLoader[] classLoader) {
    for (ClassLoader cl : classLoader) {
      // 从classloader加载指定资源  cl.getResourceAsStream(resource);
    }
  }

  ClassLoaderWrapper() {
    try {
      systemClassLoader = ClassLoader.getSystemClassLoader();
    } catch (SecurityException ignored) {
      // AccessControlException on Google App Engine
    }
  }
  ...

1、对classloader进行了包装（ClassLoaderWrapper）
Java中资源加载绕不过classloader，而Java中默认提供了多个classloader，且允许用户自定义classloader。如果不做一层包装，找资源不方便。

这里一般都能想到要封装，区别就是如何做。可能第一时间想到的是直接在Resource类里面封装一个类似于ClassLoaderWrapper#getResourceAsStream的方法。但明显是把多classloader的逻辑抽离出一个新的类更合适。因为Resources只需要关心资源加载，多个classloader这个细节应该对Resource屏蔽【单一职责、最少知识原则】

2、 还有一个细节是定标准（接口）要充分考虑扩展。
比如ClassLoaderWrapper中有两个方法签名getResourceAsStream(String resource, ClassLoader classLoader)与 getResourceAsStream(String resource) 考虑了有无自定义classloader的场景。自己做设计的时候，也一定要尽量考虑全面。当然，也不要因为“扩展”，写很多可能一直不会用到的方法，需要有权衡。

3.2.1.2 SqlSessionFactory创建

通过SqlSessionFactory构建，build分为三步。1）根据配置文件，构建XMLConfigBuilder；2）XMLConfigBuilder解析出Configuration；3）根据Configuration返回SqlSessionFactory

1、构建XMLConfigBuilder
回忆下上面的mybatis.xml内容，配置文件里最重要的两部分：environments和mapper，一个定义了环境，一个定义了mapper。
XMLConfigBuilder 有几个关键属性

public class XMLConfigBuilder extends BaseBuilder {
  private final XPathParser parser; // 解析xml的，对jdk中的实现做了层封装
  private final ReflectorFactory localReflectorFactory = new DefaultReflectorFactory(); // 反射工厂
  protected final Configuration configuration; // BaseBuilder 中的
}
  1. localReflectorFactory有个细节，在mybatis中，ReflectorFactory是个接口，只有一个默认实现DefaultReflectorFactory。设计要考虑扩展，面向接口编程
  2. XPathParser 解析xml（调用的是jdk里面的实现parser.evalNode("/configuration")，读取节点，解析到Configuration）
  3. configuration 从xml解析出来的属性会设置到这个实例中

从configuration标签解析出后，主要读取了以下标签

// root为configuration节点
private void parseConfiguration(XNode root) {
    try {
      // issue #117 read properties first
      propertiesElement(root.evalNode("properties"));
      Properties settings = settingsAsProperties(root.evalNode("settings"));
      loadCustomVfs(settings);
      loadCustomLogImpl(settings);
      typeAliasesElement(root.evalNode("typeAliases"));
      pluginElement(root.evalNode("plugins"));
      objectFactoryElement(root.evalNode("objectFactory"));
      objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
      reflectorFactoryElement(root.evalNode("reflectorFactory"));
      settingsElement(settings);
      // read it after objectFactory and objectWrapperFactory issue #631
      environmentsElement(root.evalNode("environments"));
      databaseIdProviderElement(root.evalNode("databaseIdProvider"));
      typeHandlerElement(root.evalNode("typeHandlers"));
      mapperElement(root.evalNode("mappers"));
    } catch (Exception e) {
      throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
    }
}

挑选个比较关心的mapper节点看看, 例如以下配置

<mappers>
  <mapper resource="me/hhy/mapper/xxMapper.xml"/>
</mappers>

mapperElement(root.evalNode("mappers"));的解析步骤：

（1）使用Resources类读取文件，返回流（这块和前面读取mybatis.xml一样）
（2）根据文件流以及configure等配置生成XMLMapperBuilder（mybatis.mxl解析用的是XMLConfigBuilder）
（3）调用XMLMapperBuilder#parse（parser.evalNode("/mapper")）
（4）解析mapper节点下的子节点（例如：parameterMapElement(context.evalNodes("/mapper/parameterMap"));等）

2、构建SqlSessionFactory
得到Configuration后，直接new DefaultSqlSessionFactory(Configuration config))

3.2.1.2. mybatis初始化（SqlSessionFactory构建部分）总结
  1. 读取配置文件（由Resource类负责）
  2. 解析配置文件（XMLxxBuilder系列类负责）
  3. 解析完配置文件，将文件内容保存到Configuration, SqlSessionFactory 持有Configuration

读取配置文件部分个人感觉写的比较好，主要是前面提到的Resource中使用ClassLoaderWrapper、还有一些对于扩展的考虑。

解析配置文件部分结构也是比较清晰的（仅仅是比较清晰），XMLxxBuilder系列的类各自有不同的职责。总体感觉代码没上周看的soul框架的清爽，mybatis的代码风格一般，不过其中的设计思想还是值得学习的。

3.2.2. 打开一个mysql会话 – sqlSessionFactory.openSession

sqlSessionFactory.openSession操作涉及的关键类（接口）：

关键的类（接口）：

  1. Transaction，定义了事务的操作。关键的方法：Connection getConnection()、void commit()、void rollback() 等
  2. Executor，sql执行器。关键方法：update(MappedStatement ms, Object parameter)、query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler等
  3. SqlSession，openSession的返回值。关键方法：selectOne、selectList等

流程：

  1. 从环境配置中获取TransactionFactory
  2. 使用TransactionFactory创建事务（这里包含了dataSource信息，从Configuration）
  3. 生成执行器Excutor BatchExecutor，ReuseExecutor，SimpleExecutor, CachingExecutor
    newExecutor的时候根据不同executorType new不同的实现。（interceptorChain.pluginAll(executor)

看起来openSession并没有建立数据库连接…

3.2.3. sqlSession.getMapper(DemoMapper.class);

小标题的代码会返回了一个DemoMapper对象，我们调用接口方法，即执行了sql语句。DemoMapper是一个接口，并没有实现，不难想到，通过动态代理实现功能。

这边返回的其实是一个代理类：MapperProxy。
代理类的选择：在sql解析阶段，会将mapper add进来，维护在MapperRegistry的Map<Class<?>, MapperProxyFactory<?>> knownMappers属性中。getMapper的时候，会从knownMappers中获取。

重点看代理类的实现(类和方法中的代码均经过省略)，调用mapper的方法，会调用代理类的invoke方法。在invoke里面，封装参数、执行sql调用、构建返回结果。

3.2.3.1 动态代理对象invoke关键步骤总览
  1. 解析出真实的sql SqlSource#getBoundSql，这里包含动态参数解析
    mybatis中使用DynamicSqlSource处理动态sql, 实现了SqlSource接口。getBoundSql就是调用的SqlSource#getBoundSql。DynamicSqlSource里有个SqlNode类型动属性rootSqlNode，是用户传入动动态sql参数。SqlNode这边有个组合模式下小节会讲到。
  2. 构建StatementHandler对象，如果有插件的话，会生成插件的代理对象。例如sql拦截器就是一个插件
    根据类型构建StatementHandler，遍历插件（如果有的话），调用插件的plugin方法，传入hanlder，返回插件生成的动态代理对象（InvokeHandler被指定为Plugin类）StatementHandler这有一个装饰器模式下小节会讲到
    这里生成StatementHandler还有个细节特别妙，生成完StatementHandler后，会作为插件处理的入参，根据插件再生成StatementHandler的代理对象。下小节讲(StatementHandler) interceptorChain.pluginAll(statementHandler);
  3. 打开数据库连接最终调用的是dataSource.getConnection();，例如mybatis自带的PooledDataSource 的getConnection就是通过java.sql包里的DriverManager.getConnection()方法实现的。
    DataSource是一个接口，解析阶段从xml中来的。mybatis实现了UnpooledDataSource和PooledDataSource, 也可以使用第三方的链接池或者自定义。【面向接口编程真香】
  4. 调用StatementHandler的query方法，传入 Statement 与 resultHandler。这里有一点要注意，statementHandler其实是一个动态代理对象, 并且InvokeHandler为Plugin类。Plugin的invoke会调用拦截器方法interceptor.intercept。之后就是调用statement执行真正的sql语句，使用ResultHandler解析结果。
3.2.3.2 动态代理对象invoke关键步骤设计亮点
3.2.3.2.1 SqlNode-组合模式【组合模式】，

组合模式：将对象组合成树形结构以表示“部分-整体”的层次结构，使得用户对单个对象和组合对象的使用具有一致性。

public class DynamicSqlSource implements SqlSource {
  private final SqlNode rootSqlNode;
  public DynamicSqlSource(Configuration configuration, SqlNode rootSqlNode) { ... }

  @Override
  public BoundSql getBoundSql(Object parameterObject) {
    DynamicContext context = new DynamicContext(configuration, parameterObject);
    rootSqlNode.apply(context);
    ...
  }
}

节点抽象

public interface SqlNode {
  boolean apply(DynamicContext context);
}

组合对象：DynamicSqlSource里的rootSqlNode对象类型一般为MixedSqlNode。包含了多个Node

public class MixedSqlNode implements SqlNode {
  private final List<SqlNode> contents;

  public MixedSqlNode(List<SqlNode> contents) {
    this.contents = contents;
  }

  @Override
  public boolean apply(DynamicContext context) {
    contents.forEach(node -> node.apply(context));
    return true;
  }
}

组合对象：ChooseSqlNode包含多个SqlNode 对应mybatis xml里标签

public class ChooseSqlNode implements SqlNode {
  private final SqlNode defaultSqlNode;
  private final List<SqlNode> ifSqlNodes;

  public ChooseSqlNode(List<SqlNode> ifSqlNodes, SqlNode defaultSqlNode) {...}

  @Override
  public boolean apply(DynamicContext context) {
    for (SqlNode sqlNode : ifSqlNodes) {
      if (sqlNode.apply(context)) {
        return true;
      }
    } ...
    return false;
  }
}

单个对象：TextSqlNode就是一个简单的SqlNode

public class TextSqlNode implements SqlNode {
  private final String text;
  public TextSqlNode(String text) {...}
  @Override
  public boolean apply(DynamicContext context) {
    GenericTokenParser parser = createParser(new BindingTokenParser(context, injectionFilter));
    context.appendSql(parser.parse(text));
    return true;
  }
}

从上面代码可以看出DynamicSqlSource只持有一个rootSqlNode节点。多节点也是封装成一个MixedSqlNode节点。对于SqlSource来说，Node结构是无感知的。它只需要调用rootSqlNode.apply(context);将动态动入参应用到上下文。而MixedSqlNode#apply会遍历持有的node list，分别调用各自的SqlNode#apply。TextSqlNode就是简单的对string做处理。ChooseSqlNode就比较复杂，因为里面还包括子标签等。所以ChooseSqlNode里也有一个node list, 也需要对自己所有的子标签做处理。

3.2.3.2.2 StatementHandler的装饰器模式

上小节讲到构建StatementHandler对象有个装饰器模式
构建StatementHandler一般是如下调用，StatementHandler是抽象接口，RoutingStatementHandler是包装类。
这里的RoutingStatementHandler有点拿来当工厂用的感觉… 虽然他是一个包装类，对RoutingStatementHandler做实际调用的时候，其实调用的是实际对象SimpleStatementHandler、PreparedStatementHandler、CallableStatementHandler的方法。
我理解的装饰器模式，应该是更倾向与包装类装饰实际对象的方法实现。例如实际对象的A方法从db查数据，缓存包装对象的A方法先从缓存查，找不到再从db查。但并不是说他这里用的不合适，代码整洁明了即可。

StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);

public class RoutingStatementHandler implements StatementHandler {

  private final StatementHandler delegate;

  public RoutingStatementHandler(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {

    switch (ms.getStatementType()) {
      case STATEMENT:
        delegate = new SimpleStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
        break;
      case PREPARED:
        delegate = new PreparedStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
        break;
      case CALLABLE:
        delegate = new CallableStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
        break;
      default:
        throw new ExecutorException("Unknown statement type: " + ms.getStatementType());
    }

  }

  @Override
  public Statement prepare(Connection connection, Integer transactionTimeout) throws SQLException {
    return delegate.prepare(connection, transactionTimeout);
  }

  @Override
  public void parameterize(Statement statement) throws SQLException {
    delegate.parameterize(statement);
  }
  ...
}
3.2.3.2.3 构建StatementHandler，处理插件的部分

首先，构建StatementHandler的代码如下。interceptorChain.pluginAll(statementHandler);是根据插件返回动态代理对象部分。

  public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
    StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);
    statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
    return statementHandler;
  }

细看pluginAll方法：调用的第一次，我们new 出来的statementHandler（也就是target）被作为plugin的入参，返回的是一个代理对象，也同样给target赋值。

public class InterceptorChain {

  private final List<Interceptor> interceptors = new ArrayList<>();

  public Object pluginAll(Object target) {
    for (Interceptor interceptor : interceptors) {
      target = interceptor.plugin(target);
    }
    return target;
  }

  public void addInterceptor(Interceptor interceptor) {
    interceptors.add(interceptor);
  }

  public List<Interceptor> getInterceptors() {
    return Collections.unmodifiableList(interceptors);
  }

}

例如现在有a,b,c三个插件。
StatementHandler mHandler = …;
mHandler = interceptorChain.pluginAll(mHandler)的过程就是:
a代理对象 = a插件.plugin(mHandler);
b代理对象 = b插件.plugin(a代理对象);
c代理对象 = c插件.plugin(b代理对象);
在插件里面，可以选择要不要继续传递调用

总结

这个框架里面好多源码没细看，只看了大体流程

关于设计的收获（其实道理都懂…不过确实看别人的代码对这块能有更深的理解）：

  1. 面向接口编程- 定义标准与高扩展性
  2. 单一指责、最少知识
  3. 对组合模式应用的理解（树形结构的处理）
  4. 动态代理【代理模式】应用的理解（感觉动态代理在各种框架源码里用的比较多…这里有体会，但不太好说…）
  5. 装饰器模式 包装对象当工厂用…感觉是第一次见，但并没有感觉有啥不合适…
  6. 总感觉插件的处理（3.2.3.2.3小节）那块代码写得很好…眼前一亮的感觉。

框架里用到的其他设计模式（这些比较简单，就没拎出来写了）：
Builder模式、模版方法模式、单例模式、工厂方法模式

其他的收获：

  1. 了解mybatis的大体实现流程（以后面试问到应该不惧）

https://mybatis.org/mybatis-3/zh/index.html
https://www.jianshu.com/p/7bc6d3b7fb45
https://www.jianshu.com/p/46c6e56d9774

易（Master Yi）
关注
专栏目录
MyBatis官方文档——XML配置部分
持续Java学习中
01-27 840
文章目录XML配置1、属性(properties)2、设置(settings)3、类型别名(typeAliases)4、类型处理器(typeHandlers)5、对象工厂(objectFactory)6、插件(plugins)7、环境配置(environments)8、数据库厂商标识(databaseIdProvider)9、映射器(mappers) XML配置 MyBatis 的配置文件（MyBatis-config.xml）包含了会深深影响 MyBatis 行为的设置和属性信息。该层主要是对MyBa
聊聊Mybatis的动态Sql之SqlSource
Candyz7的博客
08-22 536
这篇文章讲了SqlSource的接口和它的几个实现类，其中DynamicSqlSource类和RawSqlSource类最最终生成StaticSqlSource类，由StaticSqlSource类调用getBoundSql()方法来创建BoundSql类，DynamicSqlSource是解析动态sql的类，RawSqlSource是解析静态sql的类，在程序启动的时候就生成sql了。
MyBatis settings属性详解
Call_Me_Dady的博客
10-20 806
settings 设置 settings 属性是mybatis中极为重要的调整测试，会改变mybatis的运行时行为。 在大部分情况下不需要大量配置它，只需要修改一些常用的规则即可，比如自动映射、驼峰命名映射、级联规则、是否启动缓存、执行器（Executor）类型等 一个完整的settings配置如下： <settings> <setting name="cacheEnabled" value="true"/> <setting name="lazyLoadingEna
使用MyBatisPlus报错
qq_47455677的博客
11-23 887
错误原因：MyBatis与MyBatis-Spring之间的版本冲突问题。解决：提高MyBatis和MyBatis-Spring的版本。亲测：这两个版本无冲突问题！
Mybatis 核心源码分析
Julie的博客
01-17 9174
一、Mybatis 整体执行流程 二、Mybatis 层次结构 三、源码分析
Mybatis 框架源码10种设计模式分析.pdf
09-12
Mybatis 框架源码 10 种设计模式分析 Mybatis 框架源码 10 种设计模式分析是小傅哥博客的一篇文章，旨在分享 Mybatis 框架源码中的设计模式应用。文章首先提醒读者，学习设计模式和框架源码的重要性，不仅仅是为了...
Mybatis源码分析.pdf
08-30
总结起来，MyBatis源码分析涵盖了从配置加载到数据库操作的全过程，涉及到了配置解析、SQL执行、结果映射等多个关键环节，以及Executor、StatementHandler等核心组件。通过深入学习MyBatis的源码，开发者不仅可以...
基于Java语言的Mybatis框架详细分解与设计源码
最新发布
10-04
本项目为基于Java语言的Mybatis框架设计源码，详细分解展示了框架的内部结构。包含101个文件，其中XML配置文件79个，Java源文件16个，属性文件2个，其他文件类型包括MD、AJ、JSP、IML等，旨在为开发者提供Mybatis...
Mybatis源码分析
02-20
Mybatis源码分析 Mybatis是一款流行的持久化框架，提供了强大的SQL映射和缓存机制。本文将对Mybatis的源码进行分析，探究其运行原理、缓存机制和设计模式。 Mybatis简介 Mybatis是一个第一类持久化框架，支持...
ssm框架 mybatis.xml 详解
kuirito的博客
05-16 826
m'y'batis.xml 说明
6）Mybatis启动流程
jaemy2011的博客
01-11 2610
Mybatis启动流程
MyBatis 从入门到放弃系列二【 详细配置】
钙片儿她二舅的博客
06-14 226
继续我们的 MyBatis 之旅，今天的内容主要是介绍一下MyBatis的配置信息，并没有太多有深度的内容，不感兴趣的朋友们可以直接选择跳过。 参考文档MyBatis官方文档 属性（properties） properties 作用类似于我们以前使用的 properties 文件，用来配置系统中固定的参数信息，比如 数据库连接地址、用户名、密码等。用法如下: <properties> <property name="driver" value="com.xxx.Driver"
【mybatis】 setting的用法和解释
编程学习集装箱
07-25 952
setting 用法 <!-- settings是 MyBatis 中极为重要的调整设置，它们会改变 MyBatis 的运行时行为。 --> <settings> <!-- 该配置影响的所有映射器中配置的缓存的全局开关。默认值true --> <setting name="cacheEnabled" value="true"/> <!--延迟加载的全局开关。当开启时，所有关联对象都会延迟.
mybatis之配置文件解析
lihaiyang_sz的博客
06-08 451
从MyBatis官网我们可以知道，MyBatis 的配置文件的所有标签如下： configuration（配置） properties（属性） settings（设置） typeAliases（类型别名） typeHandlers（类型处理器） objectFactory（对象工厂） plugins（插件） environments（环境配置） environment（环境变量） transactionMan
第二章 MyBatis配置
热心市民小王的博客
06-14 249
第二章 配置 下面是xml的全部配置元素 <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd"> <configuration> <!--配置--> <prop
Mybatis 处理 sql 语句
@Bean
08-09 1890
本文 mybatis 处理 sql 语句主要分为编译期间处理和执行期间处理 另外 sql 语句又分为 静态 sql 语句 和动态 sql 语句，用参数修饰符来区分。 静态 sql 语句：没有参数或者参数修饰符全部是 #{} 这种，并且没有其他标签 动态 sql 语句：参数其中之一被 ${} 修饰，或者有标签 Mybatis 对动态 sql 的定义 mybatis 初始化完成后 所有处理完的 sql 语句都存在 SqlSource Configuration —》 MappedStatement–》 SqlS
SpringBoot+Mybatis XML配置文件详解
stopping5的博客
09-16 2611
一、XMl配置标签等级信息 configuration（配置） properties（属性-用于映入properties文件使用该文件的变量） settings（设置） typaAliases（类型别名） typeHandlers（类型处理器） objectFactory（对象工厂） environments（环境配置） environment（环境变量） transactionManager（事务管理器） dataSource（数据源） databaseldProvider（数据库厂商标志
Java_MyBatis
写的不好之处,请指教
08-04 3105
Java开发加强 1. 目标 掌握主流的web开发框架，能够使用SSM（springMVC SpringBoot Mybatis）开发web应用 在学习web开发之前，有一些需要清楚的前置知识。 2. Java的用武之地 常见的软件架构体系主要分为两种：CS架构、BS架构 java主要用于开发BS架构的应用 2.1. CS架构 client客户端 server服务端 需要在本地安装客户端程序才能访问服务端 QQ 、杀毒软件、网游 2.2. BS架构 即浏览器/服务器（Browser/Server）；
深入解析Mybatis源码：设计模式与工作流程
"Mybatis源码分析主要涵盖了Mybatis的工作流程、设计模式应用以及源码解析，旨在深入理解Mybatis的内部机制。" 在Mybatis的源码分析中，我们可以看到以下几个关键知识点： 1. **Mybatis工作流程**： Mybatis的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值