《Mybatis源码》第14章 LanguageDriver

最新推荐文章于 2022-11-15 12:54:01 发布
最新推荐文章于 2022-11-15 12:54:01 发布
阅读量1k 收藏 1
点赞数
分类专栏： 《Mybatis从0到1》 文章标签： mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44051038/article/details/121550304
版权

总结

  1. LanguageDriver借助XMLScriptBuilder解析标签，创建SqlSource
  2. XMLScriptBuilder负责解析XML标签，也就是这里负责解析，封装成SqlNode，然后在调用的时候，再根据参数解析，拼接成最后的SQL

引入

在执行器执行query()方法的时候，会直接在MappedStatement里面获取BoundSql

  @Override
  public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
    // 直接从MappedStatement获取BoundSql
    BoundSql boundSql = ms.getBoundSql(parameterObject);
    CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);
    return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
  }

接下来进入到MappedStatement里面的getBoundSql()

public BoundSql getBoundSql(Object parameterObject) {
    // 获取BoundSql  这个流程在之前讲过，中间会经历 动态编译/静态编译 在加上参数映射处理
    BoundSql boundSql = sqlSource.getBoundSql(parameterObject);
    List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
    // 参数映射为空,重新创建
    if (parameterMappings == null || parameterMappings.isEmpty()) {
      boundSql = new BoundSql(configuration, boundSql.getSql(), parameterMap.getParameterMappings(), parameterObject);
    }

    // check for nested result maps in parameter mappings (issue #30)
    for (ParameterMapping pm : boundSql.getParameterMappings()) {
      String rmId = pm.getResultMapId();
      if (rmId != null) {
        ResultMap rm = configuration.getResultMap(rmId);
        if (rm != null) {
          hasNestedResultMaps |= rm.hasNestedResultMaps();
        }
      }
    }

    return boundSql;
  }

上面看到我们之前使用的sqlSource是直接存在的，然后会进行编译，那么就代表我们解析完DML标签，生成MapperStatement的时候，SqlSource就已经创建好了，那么接下来就来看一下如何创建的SqlSource，以及如何把SQL语句变成对应的SqlNode

接下来又回来了XMLStatementBuilder的parseStatementNode()，在其中会获取DML标签的各种属性，然后创建MapperStatement，其中SqlSource就是借助LanguageDriver来解析的

public void parseStatementNode() {
    String id = context.getStringAttribute("id");
    String databaseId = context.getStringAttribute("databaseId");

    if (!databaseIdMatchesCurrent(id, databaseId, this.requiredDatabaseId)) {
      return;
    }

    Integer fetchSize = context.getIntAttribute("fetchSize");
    Integer timeout = context.getIntAttribute("timeout");
    String parameterMap = context.getStringAttribute("parameterMap");
    String parameterType = context.getStringAttribute("parameterType");
    Class<?> parameterTypeClass = resolveClass(parameterType);
    String resultMap = context.getStringAttribute("resultMap");
    String resultType = context.getStringAttribute("resultType");
    String lang = context.getStringAttribute("lang");
    // 1.获取到语言驱动
    LanguageDriver langDriver = getLanguageDriver(lang);

    Class<?> resultTypeClass = resolveClass(resultType);
    String resultSetType = context.getStringAttribute("resultSetType");
    StatementType statementType = StatementType.valueOf(context.getStringAttribute("statementType", StatementType.PREPARED.toString()));
    ResultSetType resultSetTypeEnum = resolveResultSetType(resultSetType);

    String nodeName = context.getNode().getNodeName();
    SqlCommandType sqlCommandType = SqlCommandType.valueOf(nodeName.toUpperCase(Locale.ENGLISH));
    boolean isSelect = sqlCommandType == SqlCommandType.SELECT;
    boolean flushCache = context.getBooleanAttribute("flushCache", !isSelect);
    boolean useCache = context.getBooleanAttribute("useCache", isSelect);
    boolean resultOrdered = context.getBooleanAttribute("resultOrdered", false);

    // Include Fragments before parsing
    XMLIncludeTransformer includeParser = new XMLIncludeTransformer(configuration, builderAssistant);
    includeParser.applyIncludes(context.getNode());

    // Parse selectKey after includes and remove them.
    processSelectKeyNodes(id, parameterTypeClass, langDriver);
    
    // Parse the SQL (pre: <selectKey> and <include> were parsed and removed)
    // 2.创建SqlSource
    SqlSource sqlSource = langDriver.createSqlSource(configuration, context, parameterTypeClass);
    String resultSets = context.getStringAttribute("resultSets");
    String keyProperty = context.getStringAttribute("keyProperty");
    String keyColumn = context.getStringAttribute("keyColumn");
    KeyGenerator keyGenerator;
    String keyStatementId = id + SelectKeyGenerator.SELECT_KEY_SUFFIX;
    keyStatementId = builderAssistant.applyCurrentNamespace(keyStatementId, true);
    if (configuration.hasKeyGenerator(keyStatementId)) {
      keyGenerator = configuration.getKeyGenerator(keyStatementId);
    } else {
      keyGenerator = context.getBooleanAttribute("useGeneratedKeys",
          configuration.isUseGeneratedKeys() && SqlCommandType.INSERT.equals(sqlCommandType))
          ? Jdbc3KeyGenerator.INSTANCE : NoKeyGenerator.INSTANCE;
    }

    builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType,
        fetchSize, timeout, parameterMap, parameterTypeClass, resultMap, resultTypeClass,
        resultSetTypeEnum, flushCache, useCache, resultOrdered, 
        keyGenerator, keyProperty, keyColumn, databaseId, langDriver, resultSets);
  }

  // 获取语言驱动
  private LanguageDriver getLanguageDriver(String lang) {
    Class<? extends LanguageDriver> langClass = null;
    if (lang != null) {
      langClass = resolveClass(lang);
    }
    // lang一般为空 所以直接会获取
    return configuration.getLanguageDriver(langClass);
  }

上面的代码中会经历两步，

  1. 通过lang属性来配置语言驱动，但是我在官网上并没有找到关于该属性的配置，可以推测，该属性已经不建议使用，但是代码还保留，我们用的时候肯定直接创建默认的
  2. 通过langDriver来创建SqlSource

LanguageDriver

public interface LanguageDriver {

  // 创建参数映射
  ParameterHandler createParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql);

  // 创建数据源
  SqlSource createSqlSource(Configuration configuration, XNode script, Class<?> parameterType);

  // 创建数据源
  SqlSource createSqlSource(Configuration configuration, String script, Class<?> parameterType);

}

LanguageDriverRegistry 驱动注册

用于语言驱动注册，提供了一些简答的方法，包括注册、获取等，内容很简单

public class LanguageDriverRegistry {
  
  // 注册的语言驱动Map
  // key为Class value为对象
  private final Map<Class<? extends LanguageDriver>, LanguageDriver> LANGUAGE_DRIVER_MAP = new HashMap<>();
  // 默认的语言驱动 默认为XMLLanguageDriver
  private Class<? extends LanguageDriver> defaultDriverClass;

  // 注册  已有class 根据反射实例化 然后存入Map
  public void register(Class<? extends LanguageDriver> cls) {
    if (cls == null) {
      throw new IllegalArgumentException("null is not a valid Language Driver");
    }
    MapUtil.computeIfAbsent(LANGUAGE_DRIVER_MAP, cls, k -> {
      try {
        return k.getDeclaredConstructor().newInstance();
      } catch (Exception ex) {
        throw new ScriptingException("Failed to load language driver for " + cls.getName(), ex);
      }
    });
  }
  // 注册 已有实体对象 获取class 然后存入Map
  public void register(LanguageDriver instance) {
    if (instance == null) {
      throw new IllegalArgumentException("null is not a valid Language Driver");
    }
    Class<? extends LanguageDriver> cls = instance.getClass();
    if (!LANGUAGE_DRIVER_MAP.containsKey(cls)) {
      LANGUAGE_DRIVER_MAP.put(cls, instance);
    }
  }
  
  public LanguageDriver getDriver(Class<? extends LanguageDriver> cls) {
    return LANGUAGE_DRIVER_MAP.get(cls);
  }

  public LanguageDriver getDefaultDriver() {
    return getDriver(getDefaultDriverClass());
  }

  public Class<? extends LanguageDriver> getDefaultDriverClass() {
    return defaultDriverClass;
  }

  public void setDefaultDriverClass(Class<? extends LanguageDriver> defaultDriverClass) {
    register(defaultDriverClass);
    this.defaultDriverClass = defaultDriverClass;
  }
}

初始化

我们的LanguageDriver 只有2个实现字类，那么注册类里面的Map最多也只有2个，那么它在哪里初始化的呢 答案在Configuration的构造方法里面

public Configuration() {
    // 上面省略一些代码...

    // 默认语言驱动为 XMLLanguageDriver
    languageRegistry.setDefaultDriverClass(XMLLanguageDriver.class);
    // 注册另一个驱动
    languageRegistry.register(RawLanguageDriver.class);
  }

XMLLanguageDriver 动态SQL语言驱动

// Mybatis默认XML驱动类为XMLLanguageDriver
// 其主要作用于解析select|update|insert|delete节点为完整的SQL语句
public class XMLLanguageDriver implements LanguageDriver {

  @Override
  public ParameterHandler createParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) {
    // 创建默认的DefaultParameterHandler
    // 我们之前使用的参数处理器 都是在这里创建返回的
    return new DefaultParameterHandler(mappedStatement, parameterObject, boundSql);
  }
  
  // 我们在 XMLStatementBuilder 里面创建SqlSource的时候，会调用该方法
  @Override
  public SqlSource createSqlSource(Configuration configuration, XNode script, Class<?> parameterType) {
    // 这里创建了建造类
    XMLScriptBuilder builder = new XMLScriptBuilder(configuration, script, parameterType);
    //  当sql中包含有${} 或者 动态SQL标签名 就认为是动态SQL
    //  如果是动态返回 {@link DynamicSqlSource} ，否则 {@link RawSqlSource}
    return builder.parseScriptNode();
  }
  
  // 上面的参数是XNode  这里面是String 需要先转成XNode
  @Override
  public SqlSource createSqlSource(Configuration configuration, String script, Class<?> parameterType) {
    // issue #3
    // 此处兼容XML方式的解析，条件以<script>为头结点
    if (script.startsWith("<script>")) {// 将内容转换成XNode 然后在创建
      XPathParser parser = new XPathParser(script, false, configuration.getVariables(), new XMLMapperEntityResolver());
      return createSqlSource(configuration, parser.evalNode("/script"), parameterType);
    } else {
      // issue #127
      // 解析Configuration#variable变量,将有${...}形式的字符串转换成对应字符串
      script = PropertyParser.parse(script, configuration.getVariables());
      // 根据TextSqlNode的内部属性isDynamic来进行解析帮助类的分配
      TextSqlNode textSqlNode = new TextSqlNode(script);
      if (textSqlNode.isDynamic()) {
        return new DynamicSqlSource(configuration, textSqlNode);
      } else {
        return new RawSqlSource(configuration, script, parameterType);
      }
    }
  }

}

RawLanguageDriver 静态SQL语句驱动

默认XML语言是能够识别静态语句并创建一个{@link RawSqlSource}，所以没有需要使用原始的,除非你想确保没有任何动态标记任何理由。

所以该类的使用频率比较少

// 继承了XMLLanguageDriver
public class RawLanguageDriver extends XMLLanguageDriver {

  @Override
  public SqlSource createSqlSource(Configuration configuration, XNode script, Class<?> parameterType) {
    SqlSource source = super.createSqlSource(configuration, script, parameterType);
    checkIsNotDynamic(source);
    return source;
  }

  @Override
  public SqlSource createSqlSource(Configuration configuration, String script, Class<?> parameterType) {
    SqlSource source = super.createSqlSource(configuration, script, parameterType);
    checkIsNotDynamic(source);
    return source;
  }

  private void checkIsNotDynamic(SqlSource source) {
    if (!RawSqlSource.class.equals(source.getClass())) {
      throw new BuilderException("Dynamic content is not allowed when using RAW language");
    }
  }

}

XMLScriptBuilder XML解析

SqlSource 是基于XML解析而来，解析的底层是使用Dom4j 把XML解析成一个个子节点，在通过 XMLScriptBuilder 遍历这些子节点最后生成对应的SqlSource。其解析流程如下图：

从图中可以看出这是一种递归式的访问 所有节点，如果是文本节点就会直接创建TextNode 或StaticSqlNode。否则就会创建动态脚本节点如IfSqlNode等。这里每种动态节点都会对应的处理器(NodeHandler)来创建。创建好之后又会继续访问子节点，让递归继续下去。

public class XMLScriptBuilder extends BaseBuilder {
  
  // 整个的DML标签  包括标签名 内容  也就是未解析之前的内容
  private final XNode context;
  // 是否动态SQL
  private boolean isDynamic;
  // 参数类型
  private final Class<?> parameterType;
  // 节点处理Map
  private final Map<String, NodeHandler> nodeHandlerMap = new HashMap<>();

  public XMLScriptBuilder(Configuration configuration, XNode context) {
    this(configuration, context, null);
  }

  public XMLScriptBuilder(Configuration configuration, XNode context, Class<?> parameterType) {
    super(configuration);
    this.context = context;
    this.parameterType = parameterType;
    initNodeHandlerMap();
  }

  private void initNodeHandlerMap() {
    nodeHandlerMap.put("trim", new TrimHandler());
    nodeHandlerMap.put("where", new WhereHandler());
    nodeHandlerMap.put("set", new SetHandler());
    nodeHandlerMap.put("foreach", new ForEachHandler());
    nodeHandlerMap.put("if", new IfHandler());
    nodeHandlerMap.put("choose", new ChooseHandler());
    nodeHandlerMap.put("when", new IfHandler());
    nodeHandlerMap.put("otherwise", new OtherwiseHandler());
    nodeHandlerMap.put("bind", new BindHandler());
  }
  
  public SqlSource parseScriptNode() {
    // 转换动态标签
    MixedSqlNode rootSqlNode = parseDynamicTags(context);
    SqlSource sqlSource;
    // 动态则创建 DynamicSqlSource
    // 静态则创建 RawSqlSource
    if (isDynamic) {
      sqlSource = new DynamicSqlSource(configuration, rootSqlNode);
    } else {
      sqlSource = new RawSqlSource(configuration, rootSqlNode, parameterType);
    }
    return sqlSource;
  }

  protected MixedSqlNode parseDynamicTags(XNode node) {
    // 结果集合
    List<SqlNode> contents = new ArrayList<>();
    // 子节点集合
    NodeList children = node.getNode().getChildNodes();
    // 循环处理
    for (int i = 0; i < children.getLength(); i++) {
      // XNode.newXNode(Node node)：新建一个XNode,XNode只是mybatis对Node实例的封装，用于方便操作
      // 并不是添加node节点的功能
      XNode child = node.newXNode(children.item(i));
      /**
       * Node.CDATA_SECTION_NODE:代表文档中的 CDATA 部（不会由解析器解析的文本）
       * Node.TEXT_NODE:代表元素或属性中的文本内容
       */
      if (child.getNode().getNodeType() == Node.CDATA_SECTION_NODE || child.getNode().getNodeType() == Node.TEXT_NODE) {
        // 文本数据
        String data = child.getStringBody("");
        // 创建TextSqlNode
        TextSqlNode textSqlNode = new TextSqlNode(data);
        // 判断是否为动态节点 也就是判断是否包含 ${} 
        if (textSqlNode.isDynamic()) {
          contents.add(textSqlNode);
          isDynamic = true;
        } else {
          // 添加静态文本节点
          contents.add(new StaticTextSqlNode(data));
        }
      } else if (child.getNode().getNodeType() == Node.ELEMENT_NODE) { // Node.ELEMENT_NODE:代表元素
        // 获取到子节点名
        String nodeName = child.getNode().getNodeName();
        NodeHandler handler = nodeHandlerMap.get(nodeName);
        if (handler == null) {
          throw new BuilderException("Unknown element <" + nodeName + "> in SQL statement.");
        }
        // 处理节点
        handler.handleNode(child, contents);
        // 并且标记为动态SQL
        isDynamic = true;
      }
    }
    return new MixedSqlNode(contents);
  }
}

NodeHandler 标签节点处理器

private interface NodeHandler {
    // nodeToHandle 子节点
    // targetContents 目标节点
	void handleNode(XNode nodeToHandle, List<SqlNode> targetContents);
}

BindHandler

private class BindHandler implements NodeHandler {
  public BindHandler() {
    // Prevent Synthetic Access
  }

  @Override
  public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) {
    final String name = nodeToHandle.getStringAttribute("name");
    final String expression = nodeToHandle.getStringAttribute("value");
    final VarDeclSqlNode node = new VarDeclSqlNode(name, expression);
    targetContents.add(node);
  }
}

TrimHandler

 private class TrimHandler implements NodeHandler {
    public TrimHandler() {
      // Prevent Synthetic Access
    }

    @Override
    public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) {
      // 递归处理子节点
      MixedSqlNode mixedSqlNode = parseDynamicTags(nodeToHandle);
      String prefix = nodeToHandle.getStringAttribute("prefix");
      String prefixOverrides = nodeToHandle.getStringAttribute("prefixOverrides");
      String suffix = nodeToHandle.getStringAttribute("suffix");
      String suffixOverrides = nodeToHandle.getStringAttribute("suffixOverrides");
      // 创建后存入targetContents
      TrimSqlNode trim = new TrimSqlNode(configuration, mixedSqlNode, prefix, prefixOverrides, suffix, suffixOverrides);
      targetContents.add(trim);
    }
  }

WhereHandler

private class WhereHandler implements NodeHandler {
    public WhereHandler() {
      // Prevent Synthetic Access
    }

    @Override
    public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) {
      // 递归
      MixedSqlNode mixedSqlNode = parseDynamicTags(nodeToHandle);
      WhereSqlNode where = new WhereSqlNode(configuration, mixedSqlNode);
      targetContents.add(where);
    }
  }

SetHandler

private class SetHandler implements NodeHandler {
    public SetHandler() {
      // Prevent Synthetic Access
    }

    @Override
    public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) {
      // 递归
      MixedSqlNode mixedSqlNode = parseDynamicTags(nodeToHandle);
      SetSqlNode set = new SetSqlNode(configuration, mixedSqlNode);
      targetContents.add(set);
    }
  }

ForEachHandler

private class ForEachHandler implements NodeHandler {
    public ForEachHandler() {
      // Prevent Synthetic Access
    }

    @Override
    public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) {
      MixedSqlNode mixedSqlNode = parseDynamicTags(nodeToHandle);
      String collection = nodeToHandle.getStringAttribute("collection");
      String item = nodeToHandle.getStringAttribute("item");
      String index = nodeToHandle.getStringAttribute("index");
      String open = nodeToHandle.getStringAttribute("open");
      String close = nodeToHandle.getStringAttribute("close");
      String separator = nodeToHandle.getStringAttribute("separator");
      ForEachSqlNode forEachSqlNode = new ForEachSqlNode(configuration, mixedSqlNode, collection, index, item, open, close, separator);
      targetContents.add(forEachSqlNode);
    }
  }

IfHandler

private class IfHandler implements NodeHandler {
    public IfHandler() {
      // Prevent Synthetic Access
    }

    @Override
    public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) {
      MixedSqlNode mixedSqlNode = parseDynamicTags(nodeToHandle);
      String test = nodeToHandle.getStringAttribute("test");
      IfSqlNode ifSqlNode = new IfSqlNode(mixedSqlNode, test);
      targetContents.add(ifSqlNode);
    }
  }

OtherwiseHandler

private class OtherwiseHandler implements NodeHandler {
    public OtherwiseHandler() {
      // Prevent Synthetic Access
    }

    @Override
    public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) {
      MixedSqlNode mixedSqlNode = parseDynamicTags(nodeToHandle);
      targetContents.add(mixedSqlNode);
    }
  }

ChooseHandler

private class ChooseHandler implements NodeHandler {
    public ChooseHandler() {
      // Prevent Synthetic Access
    }

    @Override
    public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) {
      List<SqlNode> whenSqlNodes = new ArrayList<>();
      List<SqlNode> otherwiseSqlNodes = new ArrayList<>();
      handleWhenOtherwiseNodes(nodeToHandle, whenSqlNodes, otherwiseSqlNodes);
      SqlNode defaultSqlNode = getDefaultSqlNode(otherwiseSqlNodes);
      ChooseSqlNode chooseSqlNode = new ChooseSqlNode(whenSqlNodes, defaultSqlNode);
      targetContents.add(chooseSqlNode);
    }

    private void handleWhenOtherwiseNodes(XNode chooseSqlNode, List<SqlNode> ifSqlNodes, List<SqlNode> defaultSqlNodes) {
      List<XNode> children = chooseSqlNode.getChildren();
      for (XNode child : children) {
        String nodeName = child.getNode().getNodeName();
        NodeHandler handler = nodeHandlerMap.get(nodeName);
        if (handler instanceof IfHandler) {
          handler.handleNode(child, ifSqlNodes);
        } else if (handler instanceof OtherwiseHandler) {
          handler.handleNode(child, defaultSqlNodes);
        }
      }
    }

    private SqlNode getDefaultSqlNode(List<SqlNode> defaultSqlNodes) {
      SqlNode defaultSqlNode = null;
      if (defaultSqlNodes.size() == 1) {
        defaultSqlNode = defaultSqlNodes.get(0);
      } else if (defaultSqlNodes.size() > 1) {
        throw new BuilderException("Too many default (otherwise) elements in choose statement.");
      }
      return defaultSqlNode;
    }
  }

andleNode(child, ifSqlNodes);
} else if (handler instanceof OtherwiseHandler) {
handler.handleNode(child, defaultSqlNodes);
}
}
}

private SqlNode getDefaultSqlNode(List<SqlNode> defaultSqlNodes) {
  SqlNode defaultSqlNode = null;
  if (defaultSqlNodes.size() == 1) {
    defaultSqlNode = defaultSqlNodes.get(0);
  } else if (defaultSqlNodes.size() > 1) {
    throw new BuilderException("Too many default (otherwise) elements in choose statement.");
  }
  return defaultSqlNode;
}

}
为人师表好少年
关注
专栏目录
Mybatis增强型注解简化SQL语句(一)
ExcellentYuXiao的专栏
11-21 2万+
Mybatis增强型注解简化SQL语句
springboot-mybatis-custom-language-driver.zip
12-13
MyBatis自定义 循环查询、IN查询、if动态SQL语句书写方式。 文章参考：https://blog.csdn.net/Zereao/article/details/103527229
Mybatis—LanguageDriver
最新发布
乐只悠悠
11-15 1381
LanguageDriver主要用于构造SqlSource和ParameterHandler，从LanguageDriver在Mybatis中调用链路来看，Configuration#newParameterHandler通过调用LanguageDriver#createParameterHandler完成构建ParameterHandler，通过调用LanguageDriver#createSqlSource来完成构建SqlSource。
Mybatis - 自定义BaseMapper LanguageDriver（注解方式）
zhuwei_clark的博客
03-03 3178
在使用mybatis的注解的形式的时候我们都希望能封装一些基础的方法。本篇内容就是基于此，本篇内容的源码 源码 如果可以，欢迎点个star BaseMapper如下： /** * 基础base * @param <T> * @param <K> */ public interface BaseMapper<T, K> { /** ...
mybatis+mybatisplus源码学习（十二）XMLLanguageDriver
码易的博客
07-07 700
目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 XMLLanguageDriver用于对sql脚本进行解析，解析各种标签。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ （1） @Override public SqlSource createSqlSource(Configuration configuration, String script, Class<?> parameterType) { // issue ..
com.baomidou.mybatisplus.core.MybatisConfiguration.getLanguageDriver(Ljava/lang/Class;)
sinat_32421529的博客
04-30 1万+
Factory method 'sqlSessionFactory' threw exception; nested exception is java.lang.NoSuchMethodError: com.baomidou.mybatisplus.core.MybatisConfiguration.getLanguageDriver(Ljava/lang/Class;)Lorg/apache/...
MyBatis源码分析.pdf
05-23
MyBatis源码分析 MyBatis是一款流行的Java持久层框架，提供了强大的数据库访问能力，本文将对MyBatis的源码进行深入分析，从而帮助读者更好地理解MyBatis的工作机理。 1. MyBatis入门 MyBatis是一款基于Java的...
Mybatis源码分析.pdf
08-30
MyBatis是一款优秀的持久层框架，它的源码分析对于深入理解其工作原理和优化数据库操作至关重要。MyBatis的核心设计理念是简化SQL操作，通过XML或注解的方式将SQL与Java代码分离，同时提供强大的动态SQL功能。 首先...
5套完整springboot+mybatis源码下载只供学习之用.rar
08-21
通过学习这些源码，你可以深入理解SpringBoot如何启动、如何配置自动装配，以及MyBatis如何与数据库交互。同时，Shiro的使用也能帮助你掌握用户权限的控制。对于初学者，这是一个很好的实践平台，对于有经验的开发者...
MyBatis源码详解学习.zip
09-30
《MyBatis源码详解学习》是一份专为对MyBatis源码感兴趣的开发者准备的资料，它旨在帮助读者深入理解这个流行持久层框架的工作原理。MyBatis作为一个轻量级的ORM（对象关系映射）框架，因其简单易用、高度可定制化的...
mybatis源码分析视频
02-19
本资源“mybatis源码分析视频”是针对MyBatis框架进行深入剖析的教程，通过视频和文档的形式帮助学习者理解其内部工作机制。 1. **MyBatis简介** MyBatis消除了几乎所有的JDBC代码和手动设置参数以及获取结果集。...
mybatis之XMLLanguageDriver使用方式例子
lhever_的博客
08-15 8360
mybatis中的XMLLanguageDriver类出现的一大原因在于:使用注解配置sql语句没有使用xml的方式灵活和强大，为了弥补这种缺陷，XMLLanguageDriver出现了。下面只是简单的举个例子，贴点代码，不多做解释。因为对于使用过mybatis的人，一看就明白。SimpleSelectInLangDriverpackage com.core.mybatis.languageDriv
day52Mybatis标签
wzhty125的博客
08-30 161
1. 常用标签介绍 1.1 mybatis配置文件的标签 Properties resource: 直接可以获取类路径 url： 指定文件的绝对路径。 方式一： <properties> <property name="jdbc.driver" value="com.mysql.jdbc.Driver"/> ...
搭建spring boot+mybatis(plus)踩坑记录(二)：找不到方法getLanguageDriver
u011602668的博客
02-23 6223
服务启动不了，报错： 心得，不要盲目拷贝粘贴，要有自己的思考，配合工具的适当使用排查问题。 第一次学会在idea上查看项目依赖 依赖冲突，项目无法启动。
浅谈MyBatis
xiaomu_a的博客
06-13 370
四大组件：Executor、ParameterHandler、StatementHandler、ResultSetHandler项目启动时会加载MybatisAutoConfiguration类，在这个类中创建了SqlSessionFactory，并且会将XML文件或者注解配置的 SQL信息会被转换为 MappedStatement 对象注册到 Configuration 组件中。 SqlSessionFactoryBean Configuration组件中的......
MyBatis 源码学习4——Mybatis核心组件(下）
qq_39172525的博客
05-07 319
五、MappedStatement MappedStatement：描述<select|update|insert|delete>或者@Select、@Update等注解配置的SQL信息。 <select>标签中的常用属性： id：命名空间中唯一的标识符，可以被用来引用这条配置信息。 parameterType：用于指定这条语句的参数类的完全限定名或别名。MyBatis能...
mybatis源码分析2
qq_20161461的博客
11-30 176
一、mapper加载与初始化 前面说过mybatis mapper文件的加载主要有两大类，通过package加载和明确指定的方式。一般来说，对于简单语句来说，使用注解代码会更加清晰，然而Java注解对于复杂语句比如同时包含了构造器、鉴别器、resultMap来说就会非常混乱，应该限制使用，此时应该使用XML文件 我们先来回顾一下通过注解配置的典型mapper接口： @Select("select *from User where id=#{id} and userName like #{name}") pu
mybatis的xml中的标签详解
与其苟延残喘，不如纵情燃烧
03-21 2152
Mybatis #{}和${}和区别 #{}: - mybatis在处理的时候会将#{username} 处理成？，用于参数传递时占位 - 当传入的参数是字符串时，会自动加上''将传递的值括起来 - mapper接口方法中的参数与xml文件中是按照参数位置索引对应的，不是根据参数的名称，但是建议最好一致。 ${}: - 字符串拼接 - mapper接口方法中的参数与xml文件中是按照参数位置索引对应的，不是根据参数的名称，但是建议最好一致。 - mybatis在处理的时候会直接
MyBatis - 初始化（十）SQL初始化（上）
热门推荐
Zack_tzh的博客
01-06 2万+
MyBatis - 初始化（十）SQL初始化（上） 该系列文档是本人在学习 Mybatis 的源码过程中总结下来的，可能对各位读者会不太友好，阅读前需要对 MyBatis 和 Spring 有一定的了解。比较适合刚接触，会使用但是一直没去探究底层的同学。 MyBatis 版本：3.5.6 MyBatis-Spring 版本：2.0.3 MyBatis-Spring-Boot-Starter 版本：2.1.4 该系列其他文档请查看：《 MyBatis 系列 - 导读》 一、MyBatis的初始化 在MyB
揭秘Mybatis源码分析与高级实战策略
本资源是一份由James QQ（ID: 2904270631）主讲的咕泡学院JAVAVIP高级课程教案，名为《MyBatis源码分析专题之MyBatis源码分析与实现》。这份课程专注于深入剖析MyBatis框架的源码，适合咕泡学院JAVA高级VIP学员学习...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

为人师表好少年

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值