mybatis3.4.1源代码 - 对 ＜if＞、${} 等标签的擦除

最新推荐文章于 2023-04-29 15:14:30 发布
最新推荐文章于 2023-04-29 15:14:30 发布
阅读量231 收藏
点赞数
分类专栏： mybatis Java 文章标签： java mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhouzhiande/article/details/113630399
版权
Java 同时被 2 个专栏收录
133 篇文章 1 订阅
订阅专栏
mybatis
14 篇文章 0 订阅
订阅专栏 
1、使用ognl表达式，替换掉 ${...} 类型的值
2、根据调用数据《擦除》xml标签
3、替换占位符 井{..} 为 占位符 ?，同时解析出绑定的参数
4、创建 BoundSql 对象
org.apache.ibatis.scripting.xmltags.DynamicSqlSource

org.apache.ibatis.scripting.xmltags.TrimSqlNode
org.apache.ibatis.scripting.xmltags.IfSqlNode
org.apache.ibatis.scripting.xmltags.ForEachSqlNode
。。。。

 

package cn.java.demo.ibatis.internal.sqlnode;


import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.builder.BuilderException;
import org.apache.ibatis.builder.SqlSourceBuilder;
import org.apache.ibatis.builder.xml.XMLMapperEntityResolver;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.SqlSource;
import org.apache.ibatis.parsing.XNode;
import org.apache.ibatis.parsing.XPathParser;
import org.apache.ibatis.scripting.xmltags.*;
import org.apache.ibatis.session.Configuration;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import java.util.*;

/**
 */
@Slf4j
public class SqlNodeDemo {

    public static void main(String[] args) {
        Configuration configuration = new Configuration();
        configuration.setDatabaseId("");

        String xmlStr =
                "<update id=\"updateByExampleSelective\" parameterType=\"map\">\n" +
                        "    update orders\n" +
                        "    <set>\n" +
                        "      <if test=\"record.id != null\">\n" +
                        "        id = #{record.id,jdbcType=BIGINT},\n" +
                        "      </if>\n" +
                        "      <if test=\"record.userId != null\">\n" +
                        "        user_id = #{record.userId,jdbcType=BIGINT},\n" +
                        "      </if>\n" +
                        "      <if test=\"record.orderNo != null\">\n" +
                        "        order_no = #{record.orderNo,jdbcType=VARCHAR},\n" +
                        "      </if>\n" +
                        "      lock_version = lock_version + 1,\n" +
                        "      <if test=\"record.updatedAt != null\">\n" +
                        "        updated_at = #{record.updatedAt,jdbcType=TIMESTAMP},\n" +
                        "      </if>\n" +
                        "    </set>\n" +
                        "    <if test=\"_parameter != null\">\n" +
                        "      <where>\n" +
                        "        <foreach collection=\"example.oredCriteria\" item=\"criteria\" separator=\"or\">\n" +
                        "          <if test=\"criteria.valid\">\n" +
                        "            <trim prefix=\"(\" prefixOverrides=\"and\" suffix=\")\">\n" +
                        "              <foreach collection=\"criteria.criteria\" item=\"criterion\">\n" +
                        "                <choose>\n" +
                        "                  <when test=\"criterion.noValue\">\n" +
                        "                    and ${criterion.condition}\n" +
                        "                  </when>\n" +
                        "                  <when test=\"criterion.singleValue\">\n" +
                        "                    and ${criterion.condition} #{criterion.value}\n" +
                        "                  </when>\n" +
                        "                  <when test=\"criterion.betweenValue\">\n" +
                        "                    and ${criterion.condition} #{criterion.value} and #{criterion.secondValue}\n" +
                        "                  </when>\n" +
                        "                  <when test=\"criterion.listValue\">\n" +
                        "                    and ${criterion.condition}\n" +
                        "                    <foreach close=\")\" collection=\"criterion.value\" item=\"listItem\" open=\"(\" separator=\",\">\n" +
                        "                      #{listItem}\n" +
                        "                    </foreach>\n" +
                        "                  </when>\n" +
                        "                </choose>\n" +
                        "              </foreach>\n" +
                        "            </trim>\n" +
                        "          </if>\n" +
                        "        </foreach>\n" +
                        "      </where>\n" +
                        "    </if>\n" +
                        "  </update>";

        /**
         * @see org.apache.ibatis.scripting.xmltags.XMLLanguageDriver#createSqlSource(org.apache.ibatis.session.Configuration, java.lang.String, java.lang.Class)
         */
        XPathParser parser = new XPathParser(xmlStr, false, null, new XMLMapperEntityResolver());
        XNode contents = parser.evalNode("/update");

        /**
         * @see org.apache.ibatis.scripting.xmltags.XMLScriptBuilder
         */
        XMLScriptBuilder xmlScriptBuilder = new XMLScriptBuilder(configuration, contents);
        SqlSource sqlSource = xmlScriptBuilder.parseScriptNode();

        /**
         * 获取BoundSql
         */
        Map parameterObject = getParameterObject();
        sqlSource.getBoundSql(parameterObject);
    }

    static Map getParameterObject() {
        String parameterObjectStr = "{\"record\":{\"id\":1,\"userId\":1,\"orderNo\":\"orderNo_1\",\"updatedAt\":\"2020-01-01 01:01:01\"},\"example\":{\"oredCriteria\":[{\"valid\":true,\"criteria\":[{\"noValue\":true,\"condition\":\"id is not null\"},{\"singleValue\":true,\"condition\":\"userId = \",\"value\":\"1\"},{\"betweenValue\":true,\"condition\":\"id between\",\"value\":\"1\",\"secondValue\":\"2\"},{\"listValue\":true,\"condition\":\"order_no in\",\"value\":[\"1\",\"2\"]}]}]}}";
        Map parameterObject = JSON.parseObject(parameterObjectStr, Map.class);

        return parameterObject;
    }


    /**
     * @see org.apache.ibatis.scripting.xmltags.DynamicSqlSource
     */
    static class DynamicSqlSource implements SqlSource {
        private Configuration configuration;
        private SqlNode rootSqlNode;

        public DynamicSqlSource(Configuration configuration, SqlNode rootSqlNode) {
            this.configuration = configuration;
            this.rootSqlNode = rootSqlNode;
        }

        @Override
        public BoundSql getBoundSql(Object parameterObject) {
            /**
             * 1、使用ognl表达式，替换掉 ${...} 类型的值
             * 2、根据调用数据《擦除》xml标签
             */
            DynamicContext context = new DynamicContext(configuration, parameterObject);
            rootSqlNode.apply(context);
            log.info("sql after do ognl, sql = {}", context.getSql());

            /**
             *  3、替换占位符 井{..} 为 占位符 ?，同时解析出绑定的参数
             */
            SqlSourceBuilder sqlSourceParser = new SqlSourceBuilder(configuration);
            Class<?> parameterType = parameterObject == null ? Object.class : parameterObject.getClass();
            SqlSource sqlSource = sqlSourceParser.parse(context.getSql(), parameterType, context.getBindings());

            /**
             * 4、创建 BoundSql 对象
             */
            BoundSql boundSql = sqlSource.getBoundSql(parameterObject);
            for (Map.Entry<String, Object> entry : context.getBindings().entrySet()) {
                boundSql.setAdditionalParameter(entry.getKey(), entry.getValue());
            }

            return boundSql;
        }
    }

    /**
     * @see org.apache.ibatis.scripting.xmltags.XMLScriptBuilder
     */
    static class XMLScriptBuilder {
        protected final Configuration configuration;
        private XNode context;
        private boolean isDynamic;

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

        public SqlSource parseScriptNode() {
            List<SqlNode> contents = parseDynamicTags(context);
            MixedSqlNode rootSqlNode = new MixedSqlNode(contents);

            SqlSource sqlSource = null;
            sqlSource = new DynamicSqlSource(configuration, rootSqlNode);

            return sqlSource;
        }

        private List<SqlNode> parseDynamicTags(XNode node) {
            List<SqlNode> contents = new ArrayList<SqlNode>();
            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("");
                    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) { // issue #628
                    // 解析标签
                    String nodeName = child.getNode().getNodeName();

                    // 节点处理器
                    NodeHandler handler = nodeHandlers(nodeName);
                    if (handler == null) {
                        throw new BuilderException("Unknown element <" + nodeName + "> in SQL statement.");
                    }
                    handler.handleNode(child, contents);
                    isDynamic = true;
                }
            }

            return contents;
        }

        NodeHandler nodeHandlers(String nodeName) {
            Map<String, NodeHandler> map = new HashMap<String, NodeHandler>();
            map.put("trim", new TrimHandler());
            map.put("where", new WhereHandler());
            map.put("set", new SetHandler());
            map.put("foreach", new ForEachHandler());
            map.put("if", new IfHandler());
            map.put("choose", new ChooseHandler());
            map.put("when", new IfHandler());
            map.put("otherwise", new OtherwiseHandler());
            map.put("bind", new BindHandler());

            return map.get(nodeName);
        }

        private interface NodeHandler {
            void handleNode(XNode nodeToHandle, List<SqlNode> targetContents);
        }

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

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

            @Override
            public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) {
                List<SqlNode> contents = parseDynamicTags(nodeToHandle);  // 递归
                MixedSqlNode mixedSqlNode = new MixedSqlNode(contents);
                String prefix = nodeToHandle.getStringAttribute("prefix");
                String prefixOverrides = nodeToHandle.getStringAttribute("prefixOverrides");
                String suffix = nodeToHandle.getStringAttribute("suffix");
                String suffixOverrides = nodeToHandle.getStringAttribute("suffixOverrides");
                TrimSqlNode trim = new TrimSqlNode(configuration, mixedSqlNode, prefix, prefixOverrides, suffix, suffixOverrides);
                targetContents.add(trim);
            }
        }

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

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

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

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

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

            @Override
            public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) {
                List<SqlNode> contents = parseDynamicTags(nodeToHandle);  // 递归
                MixedSqlNode mixedSqlNode = new MixedSqlNode(contents);
                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);
            }
        }

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

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

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

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

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

            @Override
            public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) {
                List<SqlNode> whenSqlNodes = new ArrayList<SqlNode>();
                List<SqlNode> otherwiseSqlNodes = new ArrayList<SqlNode>();
                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 = nodeHandlers(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;
            }
        }
    }

}

 

 

 

 

 

 

 

_jan_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
mybatis-3.4.1源码
10-29
mybatis-3.4.1源码包，内含源码和jar包，学习分析的首选
MyBatis-03动态SQL-01.<if>元素的使用
11-14
MyBatis-03动态SQL-01.<if>元素的使用
系列学习 SpringBoot 整合 Mybatis 之第 8 篇 —— 轻松搞定 Mybatis 分页查询（完结）
流放深圳
05-19 837
很多博客或者自学网站都有讲解 mybatis 如何使用，但是往往忽略了如何使用 mybatis 做分页查询。分页查询是开发中一项重要的技能，处理好的话能让开发简化很多，处理不好就要重复造轮子了。 我们先下载之前课程学习的代码：https://pan.baidu.com/s/1Ly7cH3Vq0tCb1cPS32-A_A 提取码：4ntj OK，既然要分页，我们先搞好分页需要的类，为了方便，统一都放在 config 包下创建的 mybatis 包下。 如图，我们依次按顺序创建类：Sear...
Mybatis拦截器实现分页和存储过程实现分页
qq_38053426的博客
12-12 609
Mybatis拦截器和存储过程的数据库分页 1.1Mybatis拦截器实现分页 主要思路：Mybatis拦截器常常会被用来进行分页处理。我们知道要利用JDBC对数据库进行操作就必须要有一个对应的Statement对象，Mybatis在执行Sql语句前也会产生一个包含Sql语句的Statement对象，而且对应的Sql语句是在Statement之前产生的，所以我们就可以在它成Statemen...
mybatis总结
wlkylhw123的博客
12-26 92
组件 SqlSessionFactoryBuilder：构造器 SqlSessionFactory：工厂接口，由Builder生成 基础文件配置，用于配置数据库信息等 typeAlias:定义元素别名，代表com.learn.ssm.chapter3.pojo.Role类可以使用自定义别名 environment:配置使用数据库的链接信息 dataSource:设置mubatis内部提供连接池的方式 mapper:引入自定的映射器配置文件 映射文件配置，配置结合业务所实现的SQL语句关系 SqlSessi.
MyBatis:The expression 'list' evaluated to a null value
weixin_33836874的博客
11-03 709
完整错误信息： 严重: Servlet.service() for servlet [springmvc] in context with path [/xinghe-platform-web] threw exception [Request processing failed; nested exception is org.my...
mybatis-3.4.1
05-19
mybatis-3.4.1，没有现成的，自己动手编译了一版。
mybatis3.4.1
11-18
无法访问此网站 github-production-release-asset-2e65be.s3.amazonaws.com 拒绝了我们的连接请求。
mybatis-3.4.1-all & mybatis-spring-1.3.0
10-27
Mybatis 3.4.1，mybatis-spring-1.3.0， MySQL 5.7 平台可以跑起来， 内附说明书。
mybatis-plus-code-generator-3.4.1-3.jar
07-14
MyBatis-Plus 代码生成器
Mybatis源码解析之标签的解析
0xZzzz的博客
12-31 2485
阅读须知研究了半天markdown也没发现怎么为代码块中的重点代码做特殊标记，所以这里使用//单行注释做代码的简单注释，而/**/多行注释的代码会做深入分析，同时为了避免篇幅过长，删掉了Mybatis原来的注释和空行，建议配合Mybatis源代码进行阅读，本文对应的Mybatis源码的版本为3.4.4。正文Mybatis是我们日常开发过程中经常使用的ORM框架，读者可以首先参考Mybatis中文官方
mybatis foreach多次遍历问题
試毅-思伟_技术博客
12-20 356
mybatis foreach多次遍历问题: 使用MyBatis foreach循环的时候出现了个问题，第一次循环使用的变量 第二次再次循环使用的时候 出现了报错 Caused by: org.apache.ibatis.builder.BuilderException: Error evaluating expression 'status'. ...
你必须要知道Mybatis中的OGNL表达式
抓娃攻城师
11-13 2758
OGNL是个什么东西？很多刚入门Java的同学会有点陌生。但是在Structs流行的时代OGNL可是必会的数据渲染技术。它全称Object Graph Navigation Language，作用是降低对数据层访问的难度，它拥有类型转换、访问对象方法、操作集合对象等功能。目前已经很少通过OGNL来访问数据层了，写这篇文章主要是因为目前国内大部分的ORM框架是**Mybatis**，而Mybatis中的动态SQL技术运用了OGNL。
MyBatis参数格式化异常解决方案：MyBatisSystemException:
热门推荐
大大的微笑的专栏
08-17 1万+
MyBatis参数格式化异常解决方案：MyBatisSystemException:         问题:今天使用MyBatis开发查询功能时，前台传入查询条件明明是String类型，到后台就报错，提示格式化数值错误，我在传入的参数对象中定义的字段类型是String，在mybaits的xml配置文件中指定的格式是CHAR，可还是报错，参数在mybaits的xml文件中会进行test判断，然
【Mybatis源码分析】动态标签的底层原理，DynamicSqlSource源码分析
qq_63691275的博客
04-29 1833
DynamicSqlSource 是用 DynamicContext 对象中的 sqlBuilder 对象进行动态Sql片段拼接的，它是一个StringJoiner对象，以空格分隔开片段。 解析映射xml中的动态sql标签是封装在SqlNode对象中，其中是通过 MixedSqlNode 混合 SqlNode 进行遍历，然后通过递归的一种形式进行处理的。 SqlSourceBuilder.parse 进行了sql 最后的处理，处理了#{}，并对参数进行了封装。
Mybatis解析存储在数据库中的动态SQL
YKCCCHEN的博客
01-07 495
从数据库中读取存储的动态SQL 根据传入参数解析标签，Sql存在了map的queryScript中 private void replaceMybatisTags(Map<String, Object> parameterMap) { String sql = "<script>" + parameterMap.get("queryScript") + "</script>"; SqlSource queryScript = iac.
MyBatis 源码解读 一讲到底
北堂飘霜_记录
11-28 732
前面大概的介绍了一下mybatis的一些东西，那么现在我们来解析一下Mybatis的源码，就从demo开始 第一步，我们通过建造者模式创建一个工厂类，配置文件的解析就是在这一步完成的，包括 mybatis-config.xml 和 Mapper 适配器文件。问题：解析的时候怎么解析的，做了什么，产生了什么对象，结果存放到了哪里。解析的结果决定着我们后面有什么对象可以使用，和到哪里去取。第二步，通过 SqlSessionFactory 创建一个 SqlSession。问题：SqlSession 是用来操作数据
<dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.4.1</version> </dependency> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis-spring</artifactId> <version>1.3.1</version> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.45</version> </dependency>如何在这段代码内配置配置"tomcat8"的插件
最新发布
06-03
<version>3.4.1</version> </dependency> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis-spring</artifactId> <version>1.3.1</version> </dependency> <dependency> <groupId>mysql</...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值