动态SQL的实现原理

最新推荐文章于 2024-09-29 21:25:15 发布

wjz748305545

最新推荐文章于 2024-09-29 21:25:15 发布

阅读量7.8k

点赞数 1

分类专栏： Java Ibatis

Java 同时被 2 个专栏收录

23 篇文章 0 订阅

订阅专栏

Ibatis

4 篇文章 0 订阅

订阅专栏

转自：http://learnworld.iteye.com/blog/1473491

动态SQL是ibatis框架的一个重要特性，本文将深入分析ibatis框架中动态SQL的实现原理。动态sql的使用参见官方文档:Dynamic SQL。本文使用的ibatis版本为2.3.4。

问题
在介绍动态SQL的实现原理之前，让我们先来思考几个问题。
1. 为什么需要动态SQL？
通过动态sql可以提高运行程序的灵活性，使我们可以方便地实现多条件下的数据库操作。

2. 如何描述动态SQL？
对于变化的数据，通常是封装在配置文件中。对于动态SQL中的不同条件，可以采用不同标签表示其含义。通过各种条件标签的组合，描述需要表达的语义。

3. 如何实现动态SQL？
首先采用条件标签描述需要表达的语义，维护在配置文件中；初始化过程中，解析配置文件中的标签，生成sql配置对应的抽象语法树；请求处理过程中，根据参数对象解释该抽象语法树，生成当前请求的动态SQL语句。

核心类图

1. SqlResource
该接口含义是作为sql对象的来源，通过该接口可以获取sql对象。其唯一的实现类是XmlSqlResource，表示通过xml文件生成sql对象。

2. Sql
该接口可以生成sql语句和获取sql相关的上下文环境(如ParameterMap、ResultMap等)，有三个实现类: RawSql表示为原生的sql语句，在初始化即可确定sql语句；SimpleDynamicSql表示简单的动态sql，即sql语句中参数通过$property$方式指定，参数在sql生成过程中会被替换，不作为sql执行参数；DynamicSql表示动态sql，即sql描述文件中包含isNotNull、isGreaterThan等条件标签。

3. SqlChild
该接口表示sql抽象语法树的一个节点，包含sql语句的片段信息。该接口有两个实现类: SqlTag表示动态sql片段，即配置文件中的一个动态标签，内含动态sql属性值(如prepend、property值等)；SqlText表示静态sql片段，即为原生的sql语句。每条动态sql通过SqlTag和SqlText构成相应的抽象语法树。

4. SqlTagHandler
该接口表示SqlTag(即不同的动态标签)对应的处理方式。比如实现类IsEmptyTagHandler用于处理<isEmpty>标签，IsEqualTagHandler用于处理<isEqual>标签等。

5. SqlTagContext
用于解释sql抽象语法树时使用的上下文环境。通过解释语法树每个节点，将生成的sql存入SqlTagContext。最终通过SqlTagContext获取完整的sql语句。

从整体上看，动态sql的生成过程包含两步: 初始化过程用于解析sql配置，生成由SqlChild节点组成的抽象语法树；请求处理过程通过运行期的参数对象解释抽象语法树，生成实际的sql语句。下面通过源码分析整个过程。

初始化过程
在初始化和配置文件解析一文中我们提到过，配置文件解析的核心逻辑是: sql配置文件 ->s ql映射文件 -> SqlStatement语句，本文将从SqlStatement的解析过程开始进行分析。

1. SqlStatementParser.parseGeneralStatement()用于解析映射文件中的Sql配置，生成MappedStatement对象。部分源码如下:

    Java代码   
    
  
 public void parseGeneralStatement(Node node, MappedStatement statement) {  
         ...  
         MappedStatementConfig statementConf = state.getConfig().newMappedStatementConfig(id, statement,  
         new XMLSqlSource(state, node), parameterMapName, parameterClass, resultMapName, additionalResultMapNames,  
         resultClass, additionalResultClasses, resultSetType, fetchSizeInt, allowRemappingBool, timeoutInt, cacheModelName,  
         xmlResultName);  
         ...  
 }  

上面这段代码核心逻辑是用于生成MappedStatement的相关配置信息，其中包含Sql配置的解析过程。

2. MappedStatementConfig.newMappedStatementConfig()调用了构造方法，部分源码如下:

    Java代码   
    
  
 MappedStatementConfig(...){  
     ...  
     //sql处理过程  
     Sql sql = processor.getSql(); //processor是XmlSqlSource对象  
     setSqlForStatement(statement, sql);  
     ...  
 }  

上面这两行就是初始化过程中sql处理的核心逻辑，首先通过配置文件生成Sql对象，接着将生成的Sql对象放入statement对象中。下面重点看一下processor.getSql()的实现过程。

3. XmlSqlSource.getSql()的完整源码如下:

    Java代码   
    
  
 public Sql getSql() {  
   boolean isDynamic = false;  
   StringBuffer sqlBuffer = new StringBuffer();  
   DynamicSql dynamic = new DynamicSql(state.getConfig().getClient().getDelegate());  
   //通过配置文件生成DynamicSql  
   isDynamic = parseDynamicTags(parentNode, dynamic, sqlBuffer, isDynamic, false);  
   String sqlStatement = sqlBuffer.toString();  
   //根据是否动态sql返回不同结果对象  
   if (isDynamic) {  
     return dynamic;  
   } else {  
     return new RawSql(sqlStatement);  
   }  
 }  

这段代码的核心逻辑是生成DynamicSql对象，并根据是否动态sql返回不同结果对象。该方法的核心是parseDynamicTags()的实现。

4. sql解析过程中最关键的一步，通过配置文件生成Sql对象，parseDynamicTags()的完整实现如下:

    Java代码   
    
  
 private boolean parseDynamicTags(Node node, DynamicParent dynamic, StringBuffer sqlBuffer, boolean isDynamic, boolean postParseRequired) {  
   NodeList children = node.getChildNodes();  
   //依次处理每个子节点  
   for (int i = 0; i < children.getLength(); i++) {  
     Node child = children.item(i);  
     String nodeName = child.getNodeName();  
     // 1. 处理sql文本  
     if (child.getNodeType() == Node.CDATA_SECTION_NODE  
         || child.getNodeType() == Node.TEXT_NODE) {  
   
       String data = ((CharacterData) child).getData();  
       data = NodeletUtils.parsePropertyTokens(data, state.getGlobalProps());  
   
       //通过sql文本生成SqlText对象  
       SqlText sqlText;  
   
       if (postParseRequired) {  
         sqlText = new SqlText();  
         sqlText.setPostParseRequired(postParseRequired);  
         sqlText.setText(data);  
       } else {  
         //核心逻辑，解析sql文本  
         sqlText = PARAM_PARSER.parseInlineParameterMap(state.getConfig().getClient().getDelegate().getTypeHandlerFactory(), data, null);  
         sqlText.setPostParseRequired(postParseRequired);  
       }  
   
       dynamic.addChild(sqlText); //当前节点加入父节点  
   
       sqlBuffer.append(data);  
     // 2. 处理include标签  
     } else if ("include".equals(nodeName)) {  
       Properties attributes = NodeletUtils.parseAttributes(child, state.getGlobalProps());  
       String refid = (String) attributes.get("refid");  
       Node includeNode = (Node) state.getSqlIncludes().get(refid);  
       if (includeNode == null) {  
         String nsrefid = state.applyNamespace(refid);  
         includeNode = (Node) state.getSqlIncludes().get(nsrefid);  
         if (includeNode == null) {  
           throw new RuntimeException("Could not find SQL statement to include with refid '" + refid + "'");  
         }  
       }  
       //递归处理include节点  
       isDynamic = parseDynamicTags(includeNode, dynamic, sqlBuffer, isDynamic, false);  
     // 3. 处理动态标签  
     } else {  
       //获取动态标签对应的SqlTagHandler   
       SqlTagHandler handler = SqlTagHandlerFactory.getSqlTagHandler(nodeName);  
       if (handler != null) {  
         isDynamic = true;  
   
         // 通过动态节点配置信息生成SqlTag对象  
         SqlTag tag = new SqlTag();  
         tag.setName(nodeName);  
         tag.setHandler(handler);  
   
         Properties attributes = NodeletUtils.parseAttributes(child, state.getGlobalProps());  
   
         tag.setPrependAttr(attributes.getProperty("prepend"));  
         tag.setPropertyAttr(attributes.getProperty("property"));  
         tag.setRemoveFirstPrepend(attributes.getProperty("removeFirstPrepend"));  
   
         tag.setOpenAttr(attributes.getProperty("open"));  
         tag.setCloseAttr(attributes.getProperty("close"));  
   
         tag.setComparePropertyAttr(attributes.getProperty("compareProperty"));  
         tag.setCompareValueAttr(attributes.getProperty("compareValue"));  
         tag.setConjunctionAttr(attributes.getProperty("conjunction"));  
   
         ...  
         dynamic.addChild(tag);  //当前节点加入父节点  
   
         //递归处理子节点  
         if (child.hasChildNodes()) {  
           isDynamic = parseDynamicTags(child, tag, sqlBuffer, isDynamic, tag.isPostParseRequired());  
         }  
       }  
     }  
   }  
   
   return isDynamic;  
 }  

这段代码比较长，核心逻辑如下:
依次处理当前节点的每个子节点，判断当前子节点类型，根据不同类型采用不同处理方式:
4.1 处理sql文本节点
对于sql文本节点，生成SqlText对象。这个过程需要解析sql语句，将其中的参数#param#替换为?，生成sql语句和ParameterMapping对象。sql文本解析的核心逻辑是InlineParameterMapParser.parseInlineParameterMap()，这里不再详述。

4.2 处理include标签
SqlMapParaser在处理<sql>标签时，会将处理结果放入XmlParserState.sqlIncludes这个map对象中。这里主要通过当前include id在sqlIncludes中获取对应的包含节点信息，再递归处理包含节点。

4.3 处理动态标签
首先获取动态标签对应的SqlTagHandler，接着通过动态标签配置生成SqlTag对象，最后递归处理当前节点的每个子节点。

小结
动态sql初始化的核心目标是通过递归方式构建DynamicSql对象，它是一个抽象语法树，由SqlText和SqlTag节点构成。而请求处理过程正是通过参数对象解释该抽象语法树，生成sql语句。

请求处理过程
在整体设计和核心流程一文中的SQL执行过程中，最后通过调用MappedStatement.executeQueryWithCallback()执行sql语句，而正是在这里生成当前请求的sql语句。

1. MappedStatement.executeQueryWithCallback()的部分源码如下:

    Java代码   
    
  
 public Object executeQueryWithCallback(StatementScope statementScope, Transaction trans, Object parameterObject, Object resultObject)  
     throws SQLException {  
   ...  
   Sql sql = getSql();  
   ...  
   String sqlString = sql.getSql(statementScope, parameterObject);  
   ...  

这里首先获取当前MappedStatement对应的Sql对象，而Sql对象正是在上面初始化过程创建完成；接着调用Sql.getSql()方法，生成当前请求的sql语句。

2. Sql对象的类型可能是RawSql、StaticSql、SimpleDynamicSql或DynamicSql，这里我们重点关注DynamicSql，DynamicSql.getSql()的部分源码如下:

    Java代码   
    
  
 public String getSql(StatementScope statementScope, Object parameterObject) {  
     String sql = statementScope.getDynamicSql();  
     if (sql == null) {  
       // 生成sql语句  
       process(statementScope, parameterObject);  
       sql = statementScope.getDynamicSql();  
     }  
     return sql;  
   }  

该方法通过调用process()方法，生成sql语句。

3. process()方法的部分源码如下:

    Java代码   
    
  
 private void process(StatementScope statementScope, Object parameterObject) {  
   SqlTagContext ctx = new SqlTagContext();  
   List localChildren = children;  //抽象语法树，由SqlTag和SqlText组成  
   // 通过参数对象解释抽象语法树  
   processBodyChildren(statementScope, ctx, parameterObject, localChildren.iterator());  
   
   // 构建ParameterMap  
   ParameterMap map = new ParameterMap(delegate);  
   map.setId(statementScope.getStatement().getId() + "-InlineParameterMap");  
   map.setParameterClass(((MappedStatement) statementScope.getStatement()).getParameterClass());  
   map.setParameterMappingList(ctx.getParameterMappings());  
   
   //获取生成的sql语句  
   String dynSql = ctx.getBodyText();  
   
   ...  
   statementScope.setDynamicSql(dynSql);  
   statementScope.setDynamicParameterMap(map);  
 }  

上面这段代码目标是构建sql执行语句和ParameterMap，构建sql执行语句通过processBodyChildren()方法完成。

4. 构建sql执行语句过程中最关键的一步，解释抽象语法树。processBodyChildren()的完整源码如下:

    Java代码   
    
  
 private void processBodyChildren(StatementScope statementScope, SqlTagContext ctx, Object parameterObject, Iterator localChildren, PrintWriter out) {  
   while (localChildren.hasNext()) {  
     SqlChild child = (SqlChild) localChildren.next();  
     // 1. 解释SqlText节点  
     if (child instanceof SqlText) {  
       SqlText sqlText = (SqlText) child;  
       String sqlStatement = sqlText.getText();  
       if (sqlText.isWhiteSpace()) {  
         out.print(sqlStatement);  
       } else if (!sqlText.isPostParseRequired()) {  
   
         // 输出sqlStatement  
         out.print(sqlStatement);  
   
         ParameterMapping[] mappings = sqlText.getParameterMappings();  
         if (mappings != null) {  
           for (int i = 0, n = mappings.length; i < n; i++) {  
             ctx.addParameterMapping(mappings[i]);  
           }  
         }  
       } else {  
         ...  
       }  
     // 2. 解释SqlTag节点  
     } else if (child instanceof SqlTag) {  
       SqlTag tag = (SqlTag) child;  
       SqlTagHandler handler = tag.getHandler();  
       int response = SqlTagHandler.INCLUDE_BODY;  
       do {  
         StringWriter sw = new StringWriter();  
         PrintWriter pw = new PrintWriter(sw);  
         // 2.1 节点处理开始  
         response = handler.doStartFragment(ctx, tag, parameterObject);  
         if (response != SqlTagHandler.SKIP_BODY) {  
           //递归处理子节点  
           processBodyChildren(statementScope, ctx, parameterObject, tag.getChildren(), pw);  
           pw.flush();  
           pw.close();  
           StringBuffer body = sw.getBuffer();  
           // 2.2 节点处理结束  
           response = handler.doEndFragment(ctx, tag, parameterObject, body);  
           // 2.3 prepend处理  
           handler.doPrepend(ctx, tag, parameterObject, body);  
             
           if (response != SqlTagHandler.SKIP_BODY) {  
             if (body.length() > 0) {  
               out.print(body.toString());  
             }  
           }  
   
         }  
       } while (response == SqlTagHandler.REPEAT_BODY);  
       ...   
     }  
   }  
 }  

这段代码是抽象语法树的解释过程，核心逻辑如下:
4.1 处理SqlText节点
SqlText节点主要包含sql语句和ParameterMapping信息，这些信息在初始化阶段已经处理完毕，解释时直接输出即可。

4.2 处理SqlTag节点
SqlTag节点包含sql动态配置信息，通过调用节点对应的SqlTagHandler进行解释处理。解释的流程控制通过response返回值完成，该常量在SqlTagHandler中定义，有以下三种值: INCLUDE_BODY表示当前节点生效；SKIP_BODY表示当前节点无效；REPEAT_BODY表示节点需要重复处理。下面以<isNull>标签举例，说明SqlTag节点处理过程。
1) 节点处理开始

    Java代码   
    
  
 public int doStartFragment(SqlTagContext ctx, SqlTag tag, Object parameterObject) {  
     
   ctx.pushRemoveFirstPrependMarker(tag);  
   // 判断条件是否满足  
   if (isCondition(ctx, tag, parameterObject)) {  
     return SqlTagHandler.INCLUDE_BODY;  
   } else {  
     return SqlTagHandler.SKIP_BODY;  
   }  
 }  

其中isCondition()方法实现如下:

    Java代码   
    
  
 public boolean isCondition(SqlTagContext ctx, SqlTag tag, Object parameterObject) {  
   if (parameterObject == null) {  
     return true;  
   } else {  
     // 获取参数值  
     String prop = getResolvedProperty(ctx, tag);  
     Object value;  
     if (prop != null) {  
       value = PROBE.getObject(parameterObject, prop);  
     } else {  
       value = parameterObject;  
     }  
     return value == null;  //判断是否为null  
   }  
 }  

首先获取参数值，再判断参数值是否满足条件，最后确定当前节点是否生效(即是否是当前请求的sql语句的组成部分)。

2) 节点处理结束

    Java代码   
    
  
 public int doEndFragment(SqlTagContext ctx, SqlTag tag, Object parameterObject, StringBuffer bodyContent) {  
   if (tag.isCloseAvailable()  && !(tag.getHandler() instanceof IterateTagHandler)) {  
     if (bodyContent.toString().trim().length() > 0) {  
       bodyContent.append(tag.getCloseAttr());  
     }  
   }  
   return SqlTagHandler.INCLUDE_BODY;  
 }  

该步功能是在sql中增加动态标签对应的close属性值。

3) prepend处理

    Java代码   
    
  
 public void doPrepend(SqlTagContext ctx, SqlTag tag, Object parameterObject, StringBuffer bodyContent) {  
     
   if (tag.isOpenAvailable() && !(tag.getHandler() instanceof IterateTagHandler)) {  
     if (bodyContent.toString().trim().length() > 0) {  
       bodyContent.insert(0, tag.getOpenAttr());  
     }  
   }  
     
   if (tag.isPrependAvailable()) {  
     if (bodyContent.toString().trim().length() > 0) {  
       if (tag.getParent() != null && ctx.peekRemoveFirstPrependMarker(tag)) {  
         ctx.disableRemoveFirstPrependMarker();  
       }else {  
         bodyContent.insert(0, tag.getPrependAttr());  
       }  
     }  
   }  

该步功能是在sql中增加动态标签对应的open和prepend属性值。

小结
请求处理过程核心目标是通过参数对象解释抽象语法树，生成当前请求的sql语句。该过程重点是对SqlTag节点的解析，通过调用该节点对应的SqlTagHandler完成处理。

总结
从设计上看，dynamic sql的实现主要涉及三个模式:
解释器模式 : 初始化过程中构建出抽象语法树，请求处理时根据参数对象解释语法树，生成sql语句。
工厂模式: : 为动态标签的处理方式创建工厂类(SqlTagHandlerFactory)，根据标签名称获取对应的处理方式。
策略模式: : 将动态标签处理方式抽象为接口，针对不同标签有相应的实现类。解释抽象语法树时，定义统一的解释流程，再调用标签对应的处理方式完成解释中的各个子环节。
最后，以一张图总结动态sql的实现原理: