一、相关类及对象

• XMLLanguageDriver
• XMLScriptBuilder
• SqlSource接口
• SqlSourceBuilder
• DynamicSqlSource主要是封装动态SQL标签解析之后的SQL语句和带有${}的SQL语句
• RawSqlSource主要封装带有#{}的SQL语句
• StaticSqlSource是BoundSql中要存储SQL语句的一个载体，上面两个SqlSource
  的SQL语句，最终都会存储到该SqlSource实现类中。

二、流程图

image

三、SqlSource创建流程

• 入口：XMLLanguageDriver#createSqlSource

创建SqlSource，解析SQL，封装SQL语句（未参数绑定）和入参信息

@Override
    public SqlSource createSqlSource(Configuration configuration, XNode script, Class<?> parameterType) {
        // 初始化了动态SQL标签处理器
        XMLScriptBuilder builder = new XMLScriptBuilder(configuration, script, parameterType);
        // 解析动态SQL
        return builder.parseScriptNode();
    }

• XMLScriptBuilder#构造函数

初始化了动态SQL标签处理器

public XMLScriptBuilder(Configuration configuration, XNode context, Class<?> parameterType) {
        super(configuration);
        this.context = context;
        this.parameterType = parameterType;
        // 初始化动态SQL中的节点处理器集合
        initNodeHandlerMap();
    }

1.XMLScriptBuilder#initNodeHandlerMap

初始化动态SQL中的节点处理器集合

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());
    }

• XMLScriptBuilder#parseScriptNode

解析动态SQL

public SqlSource parseScriptNode() {
        // 解析selectinsert updatedelete标签中的SQL语句，最终将解析到的SqlNode封装到MixedSqlNode中的List集合中
        // ****将带有${}号的SQL信息封装到TextSqlNode
        // ****将带有#{}号的SQL信息封装到StaticTextSqlNode
        // ****将动态SQL标签中的SQL信息分别封装到不同的SqlNode中
        MixedSqlNode rootSqlNode = parseDynamicTags(context);
        SqlSource sqlSource = null;
        // 如果SQL中包含${}和动态SQL语句，则将SqlNode封装到DynamicSqlSource
        if (isDynamic) {
            sqlSource = new DynamicSqlSource(configuration, rootSqlNode);
        } else {
            // 如果SQL中包含#{}，则将SqlNode封装到RawSqlSource中，并指定parameterType
            sqlSource = new RawSqlSource(configuration, rootSqlNode, parameterType);
        }
        return sqlSource;
    }

• 1 XMLScriptBuilder#parseDynamicTags

解析selectinsert updatedelete标签中的SQL语句，最终将解析到的SqlNode封装到MixedSqlNode中的List集合中。

• 将带有${}号的SQL信息封装到TextSqlNode；
• 将带有#{}号的SQL信息封装到StaticTextSqlNode
• 将动态SQL标签中的SQL信息分别封装到不同的SqlNode中

protected MixedSqlNode parseDynamicTags(XNode node) {
        List contents = new ArrayList<>();
        //获取等4个标签的子节点，子节点包括元素节点和文本节点
        NodeList children = node.getNode().getChildNodes();
        for (int i = 0; i < children.getLength(); i++) {
            XNode child = node.newXNode(children.item(i));
            // 处理文本节点
            if (child.getNode().getNodeType() == Node.CDATA_SECTION_NODE
                    || child.getNode().getNodeType() == Node.TEXT_NODE) {
                String data = child.getStringBody("");
                // 将文本内容封装到SqlNode中
                TextSqlNode textSqlNode = new TextSqlNode(data);
                // SQL语句中带有${}的话，就表示是dynamic的
                if (textSqlNode.isDynamic()) {
                    contents.add(textSqlNode);
                    isDynamic = true;
                } else {
                    // SQL语句中（除了${}和下面的动态SQL标签），就表示是static的
                    // StaticTextSqlNode的apply只是进行字符串的追加操作
                    contents.add(new StaticTextSqlNode(data));
                }

                //处理元素节点
            } else if (child.getNode().getNodeType() == Node.ELEMENT_NODE) { // issue #628
                String nodeName = child.getNode().getNodeName();
                // 动态SQL标签处理器
                // 思考，此处使用了哪种设计模式？---策略模式
                NodeHandler handler = nodeHandlerMap.get(nodeName);
                if (handler == null) {
                    throw new BuilderException("Unknown element <" + nodeName + "> in SQL statement.");
                }
                handler.handleNode(child, contents);
                // 动态SQL标签是dynamic的
                isDynamic = true;
            }
        }
        return new MixedSqlNode(contents);
    }

2. DynamicSqlSource#构造函数如果SQL中包含${}和动态SQL语句，则将SqlNode封装到DynamicSqlSource
public DynamicSqlSource(Configuration configuration, SqlNode rootSqlNode) {
    this.configuration = configuration;
    this.rootSqlNode = rootSqlNode;
}

3. RawSqlSource#构造函数如果SQL中包含#{}，则将SqlNode封装到RawSqlSource中，并指定parameterType
private final SqlSource sqlSource;

    //先调用 getSql(configuration, rootSqlNode)获取sql,再走下面的构造函数
    public RawSqlSource(Configuration configuration, SqlNode rootSqlNode, Class<?> parameterType) {
        this(configuration, getSql(configuration, rootSqlNode), parameterType);
    }

    public RawSqlSource(Configuration configuration, String sql, Class<?> parameterType) {
        // 解析SQL语句
        SqlSourceBuilder sqlSourceParser = new SqlSourceBuilder(configuration);
        // 获取入参类型
        Class<?> clazz = parameterType == null ? Object.class : parameterType;
        // 开始解析
        sqlSource = sqlSourceParser.parse(sql, clazz, new HashMap());
    }

    private static String getSql(Configuration configuration, SqlNode rootSqlNode) {
        DynamicContext context = new DynamicContext(configuration, null);
        rootSqlNode.apply(context);
        return context.getSql();
    }

3.1 SqlSourceBuilder#parse解析SQL语句
public SqlSource parse(String originalSql, Class<?> parameterType, Map additionalParameters) {
        ParameterMappingTokenHandler handler = new ParameterMappingTokenHandler(configuration, parameterType,
                additionalParameters);
        // 创建分词解析器
        GenericTokenParser parser = new GenericTokenParser("#{", "}", handler);
        // 解析#{}
        String sql = parser.parse(originalSql);
        // 将解析之后的SQL信息，封装到StaticSqlSource对象中
        // SQL字符串是带有?号的字符串，?相关的参数信息，封装到ParameterMapping集合中
        return new StaticSqlSource(configuration, sql, handler.getParameterMappings());
    }

3.1.1 ParameterMappingTokenHandler#构造函数
public ParameterMappingTokenHandler(Configuration configuration, Class<?> parameterType,Map additionalParameters) {
    super(configuration);
    this.parameterType = parameterType;
    this.metaParameters = configuration.newMetaObject(additionalParameters);
}

3.1.2 GenericTokenParser#构造函数创建分词解析器，指定待分析的openToken和closeToken，并指定处理器
 public GenericTokenParser(String openToken, String closeToken, TokenHandler handler) {
    this.openToken = openToken;
    this.closeToken = closeToken;
    this.handler = handler;
  }

3.1.3 GenericTokenParser#parse解析SQL语句，处理openToken和closeToken中的内容
/**
   * 解析${}和#{}
   * @param text
   * @return
   */
  public String parse(String text) {
    if (text == null || text.isEmpty()) {
      return "";
    }
    // search open token
    int start = text.indexOf(openToken, 0);
    if (start == -1) {
      return text;
    }
    char[] src = text.toCharArray();
    int offset = 0;
    final StringBuilder builder = new StringBuilder();
    StringBuilder expression = null;
    while (start > -1) {
      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);
            offset = end + closeToken.length();
            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);
    }
    if (offset < src.length) {
      builder.append(src, offset, src.length - offset);
    }
    return builder.toString();
  }

3.1.3.1 ParameterMappingTokenHandler#handleToken处理token（#{}/${}）
@Override
public String handleToken(String content) {
    parameterMappings.add(buildParameterMapping(content));
    return "?";
}

3.1.3.1.1 ParameterMappingTokenHandler#buildParameterMapping创建ParameterMapping对象
private ParameterMapping buildParameterMapping(String content) {
    Map propertiesMap = parseParameterMapping(content);
    String property = propertiesMap.get("property");
    Class<?> propertyType;
    if (metaParameters.hasGetter(property)) { // issue #448 get type from additional params
        propertyType = metaParameters.getGetterType(property);
    } else if (typeHandlerRegistry.hasTypeHandler(parameterType)) {
        propertyType = parameterType;
    } else if (JdbcType.CURSOR.name().equals(propertiesMap.get("jdbcType"))) {
        propertyType = java.sql.ResultSet.class;
    } else if (property == null || Map.class.isAssignableFrom(parameterType)) {
        propertyType = Object.class;
    } else {
        MetaClass metaClass = MetaClass.forClass(parameterType, configuration.getReflectorFactory());
        if (metaClass.hasGetter(property)) {
            propertyType = metaClass.getGetterType(property);
        } else {
            propertyType = Object.class;
        }
    }
    ParameterMapping.Builder builder = new ParameterMapping.Builder(configuration, property, propertyType);
    Class<?> javaType = propertyType;
    String typeHandlerAlias = null;
    for (Map.Entry entry : propertiesMap.entrySet()) {
        String name = entry.getKey();
        String value = entry.getValue();
        if ("javaType".equals(name)) {
            javaType = resolveClass(value);
            builder.javaType(javaType);
        } else if ("jdbcType".equals(name)) {
            builder.jdbcType(resolveJdbcType(value));
        } else if ("mode".equals(name)) {
            builder.mode(resolveParameterMode(value));
        } else if ("numericScale".equals(name)) {
            builder.numericScale(Integer.valueOf(value));
        } else if ("resultMap".equals(name)) {
            builder.resultMapId(value);
        } else if ("typeHandler".equals(name)) {
            typeHandlerAlias = value;
        } else if ("jdbcTypeName".equals(name)) {
            builder.jdbcTypeName(value);
        } else if ("property".equals(name)) {
            // Do Nothing
        } else if ("expression".equals(name)) {
            throw new BuilderException("Expression based parameters are not supported yet");
        } else {
            throw new BuilderException("An invalid property '" + name + "' was found in mapping #{" + content
                    + "}.  Valid properties are " + parameterProperties);
        }
    }
    if (typeHandlerAlias != null) {
        builder.typeHandler(resolveTypeHandler(javaType, typeHandlerAlias));
    }
    return builder.build();
}

3.1.2 StaticSqlSource#构造函数将解析之后的SQL信息，封装到StaticSqlSource
  private final String sql;
  private final List parameterMappings;
  private final Configuration configuration;

  public StaticSqlSource(Configuration configuration, String sql) {
    this(configuration, sql, null);
  }

  public StaticSqlSource(Configuration configuration, String sql, List parameterMappings) {
    this.sql = sql;
    this.parameterMappings = parameterMappings;
    this.configuration = configuration;
  }

1人点赞
架构师



展开阅读全文

页面更新：2024-05-24

标签：都会   流程图   节点   初始化   绑定   语句   载体   函数   处理器   源码   入口   元素   流程   对象   标签   动态   科技   信息


1
2
3
4
5




	

		

		
		
		

			

			
Spark Core源码精读：与存储相关的内存池及内存管理器的具体实现
			
			

			 前言我们用两篇文章的时间搞清楚了Spark存储中的“块”到底是怎么一回事，接下来我们就可以放心来看Spark Core存储子系统的细节了。前面已经提到过，Spark会同时利用内存和外存，尤其是积极地利用内存作为存储媒介。这点
			
		
	
	

		

		
		
		

			

			
Flink源码阅读——Flink 内存模型
			
			

			 本篇文章主要介绍下FLink的内存模型，在介绍Flink内存模型之前，我们首先学习下JVM内存结构1. JVM内存结构Java7 升级为 Java8的时候，JVM内存结构发生了改变，咱们看下区别是什么。这部分内容原文 Java8 JVM内存结构1.1 Jav
			
		
	
	

		

		
		
		

			

			
Apache Spark 内存管理详解
			
			

			 Spark 作为一个基于内存的分布式计算引擎，其内存管理模块在整个系统中扮演着非常重要的角色。理解 Spark 内存管理的基本原理，有助于更好地开发 Spark 应用程序和进行性能调优。本文旨在梳理出 Spark 内存管理的脉络，抛
			
		
	
	

		

		
		
		

			

			
如何利用好Redis、Redisson使用实现分布式锁？
			
			

			 前言1.为什么要使用分布式锁使用分布式锁的目的，无外乎就是保证同一时间只有一个客户端可以对共享资源进行操作。1.1举一个很长的例子系统 A 是一个电商系统，目前是一台机器部署，系统中有一个用户下订单的接口，但是用户
			
		
	
	

		

		
		
		

			

			
Spark的两种内存管理机制：静态内存管理与统一内存管理
			
			

			 在利用Spark开发各类计算任务时，Executor内存的配置永远是重中之重，因此了解Spark的内存管理机制是非常有益的。 在1.6版本之前，Spark只有一种内存管理机制，即静态内存管理（StaticMemoryManager），1.6版本以后又引入了新的统
			
		
	
	

		

		
		
		

			

			
Flink源码阅读——Calcite 语法拓展
			
			

			 Calcite主要是做SQL解析、校验、优化等工作，比如Flink、Hive底层都是使用的calcite。本文内容是基于Flink 1.12来讲解。首先从整体上对Calcite使用做个了解，Calcite 使用 javacc作为语法解析器，并且使用freemarker作为
			
		
	
	

		

		
		
		

			

			
使用Python+Scrapy爬取并保存QQ群空间帖子
			
			

			 首先声明，在Python和爬虫这方面，我是业余的那一卦，只是平时玩一玩，不能当真的，请各位大佬轻拍。虽然爬虫与传统意义上的大数据技术不属于同一类，但大概也只能放在大数据分类下面了。 今天接到了 @小阿妩 的一个需求（她是做
			
		
	
	

		

		
		
		

			

			
结合JVM深入理解Java字符串
			
			

			 既然题目里就提到了JVM，那么首先必然要奉上两张图。imageimageHotSpot JVM内存模型已经是老生常谈的知识了，所以这里也就不再赘述。直接说String。 在String类的JavaDoc开头，就有这样一句话：Strings are constant; their
			
		
	
	

		

		
		
		

			

			
SimpleDateFormat线程不安全问题与ThreadLocal原理
			
			

			 SimpleDateFormat是JDK中长久以来自带的日期时间格式化类，但是它有线程安全性方面的问题，使用时要避免它带来的影响。SimpleDateFormat是线程不安全的写一个SimpleDateFormat在并发环境下简单的例子先。public class S
			
		
	
	

		

		
		
		

			

			
Flink SQL w/ Blink Planner执行流程解析（上篇）
			
			

			 Foreword大数据领域SQL化的风潮方兴未艾（所谓"Everybody knows SQL"），Flink自然也不能“免俗”。Flink SQL是Flink系统内部最高级别的API，也是流批一体思想的集大成者。用户可以通过简单明了的SQL语句像查表一样执行流任
			
		
	
	

		

		
		
		

			

			
设计HBase RowKey需要注意的二三事
			
			

			在HBase中，定位一条数据（即一个Cell）需要4个维度的限定：行键（RowKey）、列族（Column Family）、列限定符（Column Qualifier）、时间戳（Timestamp）。其中，RowKey是最容易出现问题的。除了根据业务和查询需求来设计之外，还需要注意以下三
			
		
	
	

		

		
		
		

			

			
Flink源码阅读- Flink 内存模型
			
			

			 本篇文章主要介绍下FLink的内存模型，在介绍Flink内存模型之前，我们首先学习下JVM内存结构1. JVM内存结构Java7 升级为 Java8的时候，JVM内存结构发生了改变，咱们看下区别是什么。这部分内容原文 Java8 JVM内存结构1.1 Jav
			
		
	
	

		

		
		
		

			

			
Hive/HiveQL常用优化方法全面总结（下篇）
			
			

			 优化SQL处理join数据倾斜上篇已经多次提到了数据倾斜，包括已经写过的sort by代替order by，以及group by代替distinct方法，本质上也是为了解决它。join操作更是数据倾斜的重灾区，需要多加注意。空值或无意义值这种情况很
			
		
	
	

		

		
		
		

			

			
基于Kafka+Flink+Redis的电商大屏实时计算案例
			
			

			 前言一年一度的双11又要到了，阿里的双11销量大屏可以说是一道特殊的风景线。实时大屏（real-time dashboard）正在被越来越多的企业采用，用来及时呈现关键的数据指标。并且在实际操作中，肯定也不会仅仅计算一两个维度。由于
			
		
	
	

		

		
		
		

			

			
HBase架构——全网最详细万字学习笔记
			
			

			 HBase Architectural Components（HBase架构组件）HBase架构也是主从架构，由三部分构成HRegionServer、HBase Master和ZooKeeper。RegionServer负责数据的读写与客户端交互，对于region的操作则是由HMaster处理，ZooKeeper则
			
		
	
上滑加载更多 ↓
所有内容加载完毕



	

	
推荐阅读：

	

		

		
		
		

			

			
Spark Core源码精读：与存储相关的内存池及内存管理器的
			
		
	

	

		

		
		
		

			

			
Flink源码阅读——Flink 内存模型
			
		
	

	

		

		
		
		

			

			
Flink源码阅读——Calcite 语法拓展
			
		
	

	

		

		
		
		

			

			
Flink SQL w/ Blink Planner执行流程解析（上篇）
			
		
	

	

		

		
		
		

			

			
Flink源码阅读- Flink 内存模型
			
		
	

	

		

		
		
		

			

			
Flink源码阅读（七）- Calcite 语法拓展
			
		
	

	

		

		
		
		

			

			
Java对象都是在堆上分配内存吗？
			
		
	

	

		

		
		
		

			

			
专业的助听器选配流程
			
		
	

	

		

		
		
		

			

			
小爱触屏音箱Pro 8，老少皆宜的科技产品
			
		
	

	

		

		
		
		

			

			
十一代i7处理器+3070显卡 华硕天选air创作本开售
			
		
	

	
	

	
友情链接：
	

		

品学网
奇文网
日志
作文
励志
美文
范文
教案
论文
		
	
	

	
更多：
	

		
本站资料均由网友自行发布提供，仅用于学习交流。如有版权问题，请与我联系，QQ：4156828  
		
© CopyRight 2020-2024 All Rights Reserved. Powered By 71396.com  闽ICP备11008920号-4
闽公网安备35020302034903号
	

	



Top