《Mybatis源码》第19章 parsing解析

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

介绍一下org.apache.ibatis.parsing包下面负责解析的类

TokenHandler 令牌处理

public interface TokenHandler {
  // 处理令牌  并且返回处理结果
  String handleToken(String content);
}

GenericTokenParser

通用的令牌解析，该类的主要作用就是将被openToken 和 closeToken包含的内容，替换成TokenHandler返回的内容

例如: 将 #{} 替换成 ？ 将 ${} 替换成对应的参数

public class GenericTokenParser {
  
  // 开始token
  private final String openToken;
  // 结束token
  private final String closeToken;
  private final TokenHandler handler;

  public GenericTokenParser(String openToken, String closeToken, TokenHandler handler) {
    this.openToken = openToken;
    this.closeToken = closeToken;
    this.handler = handler;
  }

  // 解析
  public String parse(String text) {
    if (text == null || text.isEmpty()) {
      return "";
    }
    // search open token
    // 出现openToken的索引
    int start = text.indexOf(openToken);
    if (start == -1) {
      return text;
    }
    char[] src = text.toCharArray();
    int offset = 0;
    // 结果 把处理后的拼接上来
    final StringBuilder builder = new StringBuilder();
    StringBuilder expression = null;
    // 循环  因为可能由多个
    do {
      if (start > 0 && src[start - 1] == '\\') {
        // this open token is escaped. remove the backslash and continue.
        builder.append(src, offset, start - offset - 1).append(openToken);
        offset = start + openToken.length();
      } else {
        // found open token. let's search close token.
        if (expression == null) {
          expression = new StringBuilder();
        } else {
          expression.setLength(0);
        }
        // 拼接上
        builder.append(src, offset, start - offset);
        offset = start + openToken.length();
        int end = text.indexOf(closeToken, offset);
        while (end > -1) {
          if (end > offset && src[end - 1] == '\\') {
            // this close token is escaped. remove the backslash and continue.
            expression.append(src, offset, end - offset - 1).append(closeToken);
            offset = end + closeToken.length();
            end = text.indexOf(closeToken, offset);
          } else {
            expression.append(src, offset, end - offset);
            break;
          }
        }
        if (end == -1) {
          // close token was not found.
          builder.append(src, start, src.length - start);
          offset = src.length;
        } else {
          // 拼接上替换的内容
          builder.append(handler.handleToken(expression.toString()));
          offset = end + closeToken.length();
        }
      }
      start = text.indexOf(openToken, offset);
    } while (start > -1);
    if (offset < src.length) {
      builder.append(src, offset, src.length - offset);
    }
    return builder.toString();
  }
}

XPathParser

public class XPathParser {
  
  // 文档
  private final Document document;
  private boolean validation;
  private EntityResolver entityResolver;
  private Properties variables;
  private XPath xpath;

  // 省略一些 XPathParser构造方法，根据不同的参数来构造

  public XPathParser(Document document, boolean validation, Properties variables, EntityResolver entityResolver) {
    commonConstructor(validation, variables, entityResolver);
    this.document = document;
  }

  public String evalString(String expression) {
    return evalString(document, expression);
  }

  public String evalString(Object root, String expression) {
    String result = (String) evaluate(expression, root, XPathConstants.STRING);
    result = PropertyParser.parse(result, variables);
    return result;
  }

  public Boolean evalBoolean(String expression) {
    return evalBoolean(document, expression);
  }

  public Boolean evalBoolean(Object root, String expression) {
    return (Boolean) evaluate(expression, root, XPathConstants.BOOLEAN);
  }

  public Short evalShort(String expression) {
    return evalShort(document, expression);
  }

  public Short evalShort(Object root, String expression) {
    return Short.valueOf(evalString(root, expression));
  }

  public Integer evalInteger(String expression) {
    return evalInteger(document, expression);
  }

  public Integer evalInteger(Object root, String expression) {
    return Integer.valueOf(evalString(root, expression));
  }

  public Long evalLong(String expression) {
    return evalLong(document, expression);
  }

  public Long evalLong(Object root, String expression) {
    return Long.valueOf(evalString(root, expression));
  }

  public Float evalFloat(String expression) {
    return evalFloat(document, expression);
  }

  public Float evalFloat(Object root, String expression) {
    return Float.valueOf(evalString(root, expression));
  }

  public Double evalDouble(String expression) {
    return evalDouble(document, expression);
  }

  public Double evalDouble(Object root, String expression) {
    return (Double) evaluate(expression, root, XPathConstants.NUMBER);
  }

  public List<XNode> evalNodes(String expression) {
    return evalNodes(document, expression);
  }

  public List<XNode> evalNodes(Object root, String expression) {
    List<XNode> xnodes = new ArrayList<XNode>();
    NodeList nodes = (NodeList) evaluate(expression, root, XPathConstants.NODESET);
    for (int i = 0; i < nodes.getLength(); i++) {
      xnodes.add(new XNode(this, nodes.item(i), variables));
    }
    return xnodes;
  }

  public XNode evalNode(String expression) {
    return evalNode(document, expression);
  }

  public XNode evalNode(Object root, String expression) {
    Node node = (Node) evaluate(expression, root, XPathConstants.NODE);
    if (node == null) {
      return null;
    }
    return new XNode(this, node, variables);
  }

  private Object evaluate(String expression, Object root, QName returnType) {
    try {
      return xpath.evaluate(expression, root, returnType);
    } catch (Exception e) {
      throw new BuilderException("Error evaluating XPath.  Cause: " + e, e);
    }
  }
  
  // 检验mybatis-config.xml，并将mybatis-config.xml转换成Doucument
  private Document createDocument(InputSource inputSource) {
    // important: this must only be called AFTER common constructor
    try {
      DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
      factory.setValidating(validation);

      factory.setNamespaceAware(false);
      factory.setIgnoringComments(true);
      factory.setIgnoringElementContentWhitespace(false);
      factory.setCoalescing(false);
      factory.setExpandEntityReferences(true);

      DocumentBuilder builder = factory.newDocumentBuilder();
      builder.setEntityResolver(entityResolver);
      builder.setErrorHandler(new ErrorHandler() {
        @Override
        public void error(SAXParseException exception) throws SAXException {
          throw exception;
        }

        @Override
        public void fatalError(SAXParseException exception) throws SAXException {
          throw exception;
        }

        @Override
        public void warning(SAXParseException exception) throws SAXException {
        }
      });
      return builder.parse(inputSource);
    } catch (Exception e) {
      throw new BuilderException("Error creating document instance.  Cause: " + e, e);
    }
  }

  // 通用的构造方法
  private void commonConstructor(boolean validation, Properties variables, EntityResolver entityResolver) {
    this.validation = validation;
    this.entityResolver = entityResolver;
    this.variables = variables;
    // 工厂
    XPathFactory factory = XPathFactory.newInstance();
    this.xpath = factory.newXPath();
  }
}

XNode

public class XNode {
  // 封装的节点Node
  private final Node node;
  // 节点名
  private final String name;
  // 
  private final String body;
  // 属性
  private final Properties attributes;
  // 值
  private final Properties variables;
  private final XPathParser xpathParser;

  // 构造方法
  public XNode(XPathParser xpathParser, Node node, Properties variables) {
    this.xpathParser = xpathParser;
    this.node = node;
    this.name = node.getNodeName();
    this.variables = variables;
    this.attributes = parseAttributes(node);
    this.body = parseBody(node);
  }

  public XNode newXNode(Node node) {
    return new XNode(xpathParser, node, variables);
  }

  // 获取父节点
  public XNode getParent() {
    Node parent = node.getParentNode();
    if (parent == null || !(parent instanceof Element)) {
      return null;
    } else {
      return new XNode(xpathParser, parent, variables);
    }
  }

  public String getPath() {
    StringBuilder builder = new StringBuilder();
    Node current = node;
    while (current != null && current instanceof Element) {
      if (current != node) {
        builder.insert(0, "/");
      }
      builder.insert(0, current.getNodeName());
      current = current.getParentNode();
    }
    return builder.toString();
  }

  public String getValueBasedIdentifier() {
    StringBuilder builder = new StringBuilder();
    XNode current = this;
    while (current != null) {
      if (current != this) {
        builder.insert(0, "_");
      }
      String value = current.getStringAttribute("id",
          current.getStringAttribute("value",
              current.getStringAttribute("property", null)));
      if (value != null) {
        value = value.replace('.', '_');
        builder.insert(0, "]");
        builder.insert(0,
            value);
        builder.insert(0, "[");
      }
      builder.insert(0, current.getName());
      current = current.getParent();
    }
    return builder.toString();
  }

  public String evalString(String expression) {
    return xpathParser.evalString(node, expression);
  }

  public Boolean evalBoolean(String expression) {
    return xpathParser.evalBoolean(node, expression);
  }

  public Double evalDouble(String expression) {
    return xpathParser.evalDouble(node, expression);
  }

  public List<XNode> evalNodes(String expression) {
    return xpathParser.evalNodes(node, expression);
  }

  public XNode evalNode(String expression) {
    return xpathParser.evalNode(node, expression);
  }

  public Node getNode() {
    return node;
  }

  public String getName() {
    return name;
  }

  public String getStringBody() {
    return getStringBody(null);
  }

  public String getStringBody(String def) {
    if (body == null) {
      return def;
    } else {
      return body;
    }
  }

  public Boolean getBooleanBody() {
    return getBooleanBody(null);
  }

  public Boolean getBooleanBody(Boolean def) {
    if (body == null) {
      return def;
    } else {
      return Boolean.valueOf(body);
    }
  }

  public Integer getIntBody() {
    return getIntBody(null);
  }

  public Integer getIntBody(Integer def) {
    if (body == null) {
      return def;
    } else {
      return Integer.parseInt(body);
    }
  }

  public Long getLongBody() {
    return getLongBody(null);
  }

  public Long getLongBody(Long def) {
    if (body == null) {
      return def;
    } else {
      return Long.parseLong(body);
    }
  }

  public Double getDoubleBody() {
    return getDoubleBody(null);
  }

  public Double getDoubleBody(Double def) {
    if (body == null) {
      return def;
    } else {
      return Double.parseDouble(body);
    }
  }

  public Float getFloatBody() {
    return getFloatBody(null);
  }

  public Float getFloatBody(Float def) {
    if (body == null) {
      return def;
    } else {
      return Float.parseFloat(body);
    }
  }

  public <T extends Enum<T>> T getEnumAttribute(Class<T> enumType, String name) {
    return getEnumAttribute(enumType, name, null);
  }

  public <T extends Enum<T>> T getEnumAttribute(Class<T> enumType, String name, T def) {
    String value = getStringAttribute(name);
    if (value == null) {
      return def;
    } else {
      return Enum.valueOf(enumType, value);
    }
  }

  public String getStringAttribute(String name) {
    return getStringAttribute(name, null);
  }

  public String getStringAttribute(String name, String def) {
    String value = attributes.getProperty(name);
    if (value == null) {
      return def;
    } else {
      return value;
    }
  }

  public Boolean getBooleanAttribute(String name) {
    return getBooleanAttribute(name, null);
  }

  public Boolean getBooleanAttribute(String name, Boolean def) {
    String value = attributes.getProperty(name);
    if (value == null) {
      return def;
    } else {
      return Boolean.valueOf(value);
    }
  }

  public Integer getIntAttribute(String name) {
    return getIntAttribute(name, null);
  }

  public Integer getIntAttribute(String name, Integer def) {
    String value = attributes.getProperty(name);
    if (value == null) {
      return def;
    } else {
      return Integer.parseInt(value);
    }
  }

  public Long getLongAttribute(String name) {
    return getLongAttribute(name, null);
  }

  public Long getLongAttribute(String name, Long def) {
    String value = attributes.getProperty(name);
    if (value == null) {
      return def;
    } else {
      return Long.parseLong(value);
    }
  }

  public Double getDoubleAttribute(String name) {
    return getDoubleAttribute(name, null);
  }

  public Double getDoubleAttribute(String name, Double def) {
    String value = attributes.getProperty(name);
    if (value == null) {
      return def;
    } else {
      return Double.parseDouble(value);
    }
  }

  public Float getFloatAttribute(String name) {
    return getFloatAttribute(name, null);
  }

  public Float getFloatAttribute(String name, Float def) {
    String value = attributes.getProperty(name);
    if (value == null) {
      return def;
    } else {
      return Float.parseFloat(value);
    }
  }

  public List<XNode> getChildren() {
    List<XNode> children = new ArrayList<XNode>();
    NodeList nodeList = node.getChildNodes();
    if (nodeList != null) {
      for (int i = 0, n = nodeList.getLength(); i < n; i++) {
        Node node = nodeList.item(i);
        if (node.getNodeType() == Node.ELEMENT_NODE) {
          children.add(new XNode(xpathParser, node, variables));
        }
      }
    }
    return children;
  }

  public Properties getChildrenAsProperties() {
    Properties properties = new Properties();
    for (XNode child : getChildren()) {
      String name = child.getStringAttribute("name");
      String value = child.getStringAttribute("value");
      if (name != null && value != null) {
        properties.setProperty(name, value);
      }
    }
    return properties;
  }

  @Override
  public String toString() {
    StringBuilder builder = new StringBuilder();
    builder.append("<");
    builder.append(name);
    for (Map.Entry<Object, Object> entry : attributes.entrySet()) {
      builder.append(" ");
      builder.append(entry.getKey());
      builder.append("=\"");
      builder.append(entry.getValue());
      builder.append("\"");
    }
    List<XNode> children = getChildren();
    if (!children.isEmpty()) {
      builder.append(">\n");
      for (XNode node : children) {
        builder.append(node.toString());
      }
      builder.append("</");
      builder.append(name);
      builder.append(">");
    } else if (body != null) {
      builder.append(">");
      builder.append(body);
      builder.append("</");
      builder.append(name);
      builder.append(">");
    } else {
      builder.append("/>");
    }
    builder.append("\n");
    return builder.toString();
  }

  private Properties parseAttributes(Node n) {
    Properties attributes = new Properties();
    NamedNodeMap attributeNodes = n.getAttributes();
    if (attributeNodes != null) {
      for (int i = 0; i < attributeNodes.getLength(); i++) {
        Node attribute = attributeNodes.item(i);
        String value = PropertyParser.parse(attribute.getNodeValue(), variables);
        attributes.put(attribute.getNodeName(), value);
      }
    }
    return attributes;
  }

  private String parseBody(Node node) {
    String data = getBodyData(node);
    if (data == null) {
      NodeList children = node.getChildNodes();
      for (int i = 0; i < children.getLength(); i++) {
        Node child = children.item(i);
        data = getBodyData(child);
        if (data != null) {
          break;
        }
      }
    }
    return data;
  }

  private String getBodyData(Node child) {
    if (child.getNodeType() == Node.CDATA_SECTION_NODE
        || child.getNodeType() == Node.TEXT_NODE) {
      String data = ((CharacterData) child).getData();
      data = PropertyParser.parse(data, variables);
      return data;
    }
    return null;
  }

}

PropertyParser

属性解析，将 ${} 解析属性

public class PropertyParser { 
  
  // 前缀
  private static final String KEY_PREFIX = "org.apache.ibatis.parsing.PropertyParser.";
  
  public static final String KEY_ENABLE_DEFAULT_VALUE = KEY_PREFIX + "enable-default-value";

  /**
   * The special property key that specify a separator for key and default value on placeholder.
   * <p>
   *   The default separator is {@code ":"}.
   * </p>
   * @since 3.4.2
   */
  public static final String KEY_DEFAULT_VALUE_SEPARATOR = KEY_PREFIX + "default-value-separator";

  // 默认值false
  private static final String ENABLE_DEFAULT_VALUE = "false";
  // 默认分隔符
  private static final String DEFAULT_VALUE_SEPARATOR = ":";

  private PropertyParser() {
    // Prevent Instantiation
  }

  // 转换
  public static String parse(String string, Properties variables) {
    // 1.创建静态内部类
    VariableTokenHandler handler = new VariableTokenHandler(variables);
    // 2.转换 
    GenericTokenParser parser = new GenericTokenParser("${", "}", handler);
    return parser.parse(string);
  }

  private static class VariableTokenHandler implements TokenHandler {
    // 属性
    private final Properties variables;
    // 使用默认值
    private final boolean enableDefaultValue;
    // 默认值分隔符
    private final String defaultValueSeparator;

    private VariableTokenHandler(Properties variables) {
      this.variables = variables;
      this.enableDefaultValue = Boolean.parseBoolean(getPropertyValue(KEY_ENABLE_DEFAULT_VALUE, ENABLE_DEFAULT_VALUE));
      this.defaultValueSeparator = getPropertyValue(KEY_DEFAULT_VALUE_SEPARATOR, DEFAULT_VALUE_SEPARATOR);
    }

    private String getPropertyValue(String key, String defaultValue) {
      return (variables == null) ? defaultValue : variables.getProperty(key, defaultValue);
    }

    @Override
    public String handleToken(String content) {
      if (variables != null) {
        String key = content;
        if (enableDefaultValue) {
          final int separatorIndex = content.indexOf(defaultValueSeparator);
          String defaultValue = null;
          if (separatorIndex >= 0) {
            key = content.substring(0, separatorIndex);
            defaultValue = content.substring(separatorIndex + defaultValueSeparator.length());
          }
          if (defaultValue != null) {
            return variables.getProperty(key, defaultValue);
          }
        }
        // 一般就是在这里 获取到值
        if (variables.containsKey(key)) {
          return variables.getProperty(key);
        }
      }
      return "${" + content + "}";
    }
  }
}
为人师表好少年
关注
专栏目录
第四章 MyBatis源码分析笔记2
hankin的博客
09-10 756
一、binding模块分析 1、为什么使用mapper接口就能操作数据库？ 配置文件解读 +动态代理的增强 @Test// 快速入门public void quickStart() throws IOException {SqlSession sqlSession = sqlSessionFactory.openSession();TUserMapper mapp...
mybatis源码解读(二)——构建Configuration对象
06-29 288
目录 1、读取配置文件 2、初始化基础配置 ①、properties 全局参数 ②、setting 设置 ③、typeAliases 别名 ④、typeHandlers 类型处理器 ⑤、Mapper 映射器 　　Configuration 对象保存了所有mybatis的配置信息，主要包括： 　　①、 mybatis-configuration.xml 基础配置文件 　　②、mapper.xml 映射器配置文件 回到顶部 1、读取配置文件 　　前面例子有这么一段代码..
Mybatis的源码解析之处理占位符相关的类TokenHandler和GenericTokenParser
Swing_wingS的博客
03-27 1383
前言 Mybatis在处理${}和#{}占位符时，底层使用到了GenericTokenParser类和TokenHandler的实现类。它的实现原理及其简单。 GenericTokenParser package org.apache.ibatis.parsing; /** * 通用属性解析器 用于解析占位符标签 */ public class GenericTokenParser { /** * 占位符开始标志 */ private final Str
MyBatis源码分析（三）：解析器模块
最新发布
小徐的博客
01-03 1280
本篇来分享Mybatis解析器模块。
Mybatis 源码学习(十一) —— parsing 包
三岁丫的博客
05-18 357
Mybatis parsing 包详解 XNode 详解 XPathParser 详解 PropertyParser 详解 TokenHandler 和 VariableTokenHandler 的作用详解
Mybatis技术内幕（2.1）：解析器模块
weixin_34080571的博客
03-05 354
1.0 概述 MyBatis 的解析器模块，源码对应 parsing 包。如下图： 该模块主要提供两个功能： 1.对Java XPath 进行封装，为MyBatis初始化时解析mybatis-config.xml配置文件以及映射配置文件提供支持。 2.为处理动态 SQL 语句中的占位符提供支持 2.0 XPathParser org.apache.ibatis.parsing.XPathPa...
mybatis学习之路----#{}, ${}两种传参数方式的区别--附源码解读
小菜鸟的专栏
09-09 4828
点滴记载，点滴进步，愿自己更上一层楼。
源码学习之 MyBatis 的底层查询原理
Q54665642ljf的博客
10-06 390
MyBatis 源代码的目录是比较清晰的，基本上每个相同功能的模块都在一起，但是如果直接去阅读源码的话，可能还是有一定的难度，没法理解它的运行过程，本次通过一个简单的查询流程从头到尾跟下来，可以看到 MyBatis 的设计以及处理流程，例如其中用到的设计模式：图 25 MyBatis 代码结构图组合模式：如 ChooseSqlNode，IfSqlNode 等。
Mybatis运行原理（我保证全宇宙最详细）
xhbzl的博客
09-06 1926
最近几天通过看源码来研究了一下mybatis的运行步骤，本篇文章以最基础的mybatis利用sqlSession操作数据库来讲解。我相信只要各位跟着我的节奏看完这篇文章就会对mybatis的运行步骤有个大体的认识（希望大家像我一样编写一个简单例子，然后跟着我的步骤看源码，不明白的地方debug)。这篇绝对是全网最详细的介绍mybatis运行原理的文章，当然如果你没有耐心看完的话，我也没任何办法，毕竟研究源码是一种枯燥的行为。如果你真的想去了解mybatis背后是怎么运行的，我相信这篇文章肯定会帮助到你。
Mybaits 源码解析 （九）----- 全网最详细，没有之一：一级缓存和二级缓存源码分析
kkkkk0826的专栏
11-09 306
像Mybatis、Hibernate这样的ORM框架，封装了JDBC的大部分操作，极大的简化了我们对 数据库的操作。 在实际项目中，我们发现在一个事务中查询同样的语句两次的时候，第二次没有进行数据库查询，直接返回了结果，实际这种情况我们就可以称为缓存。 Mybatis的缓存级别 一级缓存 MyBatis的一级查询缓存（也叫作本地缓存）是基于org.apache.ibatis.cache....
Mybaits 源码解析 （三）----- Mapper接口底层原理（为什么Mapper不用写实现类就能访问到数据库？）
微赚开发者技术分享博客
10-29 821
上一篇我们讲解到mapperElement方法用来解析mapper，我们这篇文章具体来 看看mapper.xml的解析过程 mappers配置方式 mappers 标签下有许多 mapper 标签，每一个 mapper 标签中配置的都是一个独立的映射配置文件的路径，配置方式有以下几种。 接口信息进行配置 <mappers> <mapper class="or...
mybatis TypeHandler详解
荒野孤鹰
11-22 5144
1.TypeHandler概念 TypeHandler,类型转换器,在mybatis中用于实现java类型和JDBC类型的相互转换. mybatis使用prepareStatement来进行参数设置的时候,需要通过typeHandler将传入的java参数设置成合适的jdbc类型参数,这个过程实际上是通过 调用PrepareStatement不同的set方法实现的;在获取结果返回之后,也需要将
MyBatis源码解析(二) 解析器模块
Let_me_tell_you的博客
07-17 337
mybatis源码解析系列源码基于 3.5.2-SNAPSHOT 版本，截至笔者开始写第一篇源码解析时这是官方的最新master分支。 写文章的过程中参考了很多大佬的文章和思路，以及一些为了解释清楚所必须的图。如有侵权，请联系删除。 参考内容：芋道源码博客 《MyBatis技术内幕》以及其他很多文章及书籍，以及开源项目，不一一列举。 引言：在之前的项目结构概览里提到了初始化项目的时候解析 my...
MyBatis--解析器模块
azto的博客
05-20 717
MyBatis--解析器模块解析器模块概述XPathParser构造方法 解析器模块概述 解析器模块 对应着 parsing 包 解析器模块，主要提供了两个功能 对XPath进行封装，为MyBatis初始化时解析mybatis - config.xml 配置文件以及映射配置文件提供支持 对了处理动态 sql 语句中的占位符提供支持 XPathParser 基于 Java XPath 解析器，用于解析 MyBatis mybatis-config.xml 和 **Mapper.xml 等 XML 配置文
spring不同包下的类命名冲突_Spring 源码第三弹！EntityResolver 是个什么鬼？
weixin_42255060的博客
01-19 171
松哥原创的 Spring Boot 视频教程已经杀青，感兴趣的小伙伴戳这里-->Spring Boot+Vue+微人事视频教程上篇文章和小伙伴们说了 Spring 源码中 XML 文件的解析流程，本来可以继续往下走看加载核心类了，但是松哥还是希望能够慢一点，既然要学就学懂，在 XML 文件解析的过程中还涉及到一些其他的类和概念，因此我就先用几篇文章介绍一下这些涉及到的概念或者类，然...
MyBatis源码解析----parsing包
xl3379307903的博客
06-19 404
0.先来看看Mybatis的配置文件mybatis-config.xml中 &amp;amp;amp;amp;amp;amp;amp;amp;amp;lt;dataSource type=&amp;amp;amp;amp;amp;amp;amp;amp;quot;POOLED&amp;amp;amp;amp;amp;amp;amp;amp;quot;&amp;amp;amp;amp;amp;amp;amp;amp;amp;gt; &amp;amp;amp;amp
手撕MyBatis源码实现自定义持久层框架
weixin_44191814的博客
05-27 306
手撕MyBatis源码实现自定义持久层框架
MyBatis源码揭秘：日志记录与设计模式深度解析
MyBatis本身并不直接提供内置的日志实现，而是鼓励开发者集成第三方的日志组件，如SLF4J、Commons Logging、Log4j2、Log4j和JdkLog等，这些组件各自有不同的日志级别，但MyBatis统一支持trace、debug、warn和error这...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

为人师表好少年

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

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

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

打赏作者

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

抵扣说明：

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

余额充值