一次Mybatis sql解析故障分析

最新推荐文章于 2024-01-15 19:56:06 发布
最新推荐文章于 2024-01-15 19:56:06 发布
阅读量122 收藏
点赞数
原文链接：https://my.oschina.net/odetteisgorgeous/blog/3010296
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

现象

<select id="listOrderDetail" resultMap="OrderDTOResultMap">
        SELECT
        a.id,
        a.order_number,
        a.is_pay
        FROM (
        SELECT aa.*
        FROM ord_order aa
        WHERE aa.del_flag = '0'
        LIMIT #{pageStart}, #{pageSize}
        ) a
        LEFT JOIN ord_order_detail b ON a.id = b.ord_order_id
        <choose>
            <when test="sortord!='0'">
                ORDER BY a.create_date DESC
            </when>
            <otherwise>
                ORDER BY a.create_date ASC
            </otherwise>
        </choose>
    </select>

在测试中发现，以上sql在mybatis解析后，sortord无论是"0"或者"1"单个字符串，都会倒序执行。

源码分析原因

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.apache.ibatis.scripting.xmltags;

public class IfSqlNode implements SqlNode {
    private ExpressionEvaluator evaluator;
    private String test;
    private SqlNode contents;

    public IfSqlNode(SqlNode contents, String test) {
        this.test = test;
        this.contents = contents;
        this.evaluator = new ExpressionEvaluator();
    }

    public boolean apply(DynamicContext context) {
        if (this.evaluator.evaluateBoolean(this.test, context.getBindings())) {
            this.contents.apply(context);
            return true;
        } else {
            return false;
        }
    }
}

sql节点调用apply方法中this.evaluator.evaluateBoolean方法

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.apache.ibatis.scripting.xmltags;

import java.lang.reflect.Array;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import org.apache.ibatis.builder.BuilderException;

public class ExpressionEvaluator {
    public ExpressionEvaluator() {
    }

    public boolean evaluateBoolean(String expression, Object parameterObject) {
        Object value = OgnlCache.getValue(expression, parameterObject);
        if (value instanceof Boolean) {
            return (Boolean)value;
        } else if (value instanceof Number) {
            return !(new BigDecimal(String.valueOf(value))).equals(BigDecimal.ZERO);
        } else {
            return value != null;
        }
    }

    public Iterable<?> evaluateIterable(String expression, Object parameterObject) {
        Object value = OgnlCache.getValue(expression, parameterObject);
        if (value == null) {
            throw new BuilderException("The expression '" + expression + "' evaluated to a null value.");
        } else if (value instanceof Iterable) {
            return (Iterable)value;
        } else if (!value.getClass().isArray()) {
            if (value instanceof Map) {
                return ((Map)value).entrySet();
            } else {
                throw new BuilderException("Error evaluating expression '" + expression + "'.  Return value (" + value + ") was not iterable.");
            }
        } else {
            int size = Array.getLength(value);
            List<Object> answer = new ArrayList();

            for(int i = 0; i < size; ++i) {
                Object o = Array.get(value, i);
                answer.add(o);
            }

            return answer;
        }
    }
}

Object value = OgnlCache.getValue(expression, parameterObject);行使用ognl方式获取test中表达式test='sortord!="0"'的值

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.apache.ibatis.scripting.xmltags;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import org.apache.ibatis.builder.BuilderException;
import org.apache.ibatis.ognl.Ognl;
import org.apache.ibatis.ognl.OgnlException;

public final class OgnlCache {
    private static final Map<String, Object> expressionCache = new ConcurrentHashMap();

    private OgnlCache() {
    }

    public static Object getValue(String expression, Object root) {
        try {
            Map<Object, OgnlClassResolver> context = Ognl.createDefaultContext(root, new OgnlClassResolver());
            return Ognl.getValue(parseExpression(expression), context, root);
        } catch (OgnlException var3) {
            throw new BuilderException("Error evaluating expression '" + expression + "'. Cause: " + var3, var3);
        }
    }

    private static Object parseExpression(String expression) throws OgnlException {
        Object node = expressionCache.get(expression);
        if (node == null) {
            node = Ognl.parseExpression(expression);
            expressionCache.put(expression, node);
        }

        return node;
    }
}


package org.apache.ibatis.ognl;

import java.io.StringReader;
import java.lang.reflect.Member;
import java.util.Map;

public abstract class Ognl {
    public static Object parseExpression(String expression) throws OgnlException {
        try {
            OgnlParser parser = new OgnlParser(new StringReader(expression));
            return parser.topLevelExpression();
        } catch (ParseException var2) {
            throw new ExpressionSyntaxException(expression, var2);
        } catch (TokenMgrError var3) {
            throw new ExpressionSyntaxException(expression, var3);
        }
    }

    public static Map createDefaultContext(Object root) {
        return addDefaultContext(root, (ClassResolver)null, (TypeConverter)null, (MemberAccess)null, new OgnlContext());
    }

    public static Map createDefaultContext(Object root, ClassResolver classResolver) {
        return addDefaultContext(root, classResolver, (TypeConverter)null, (MemberAccess)null, new OgnlContext());
    }

    public static Map createDefaultContext(Object root, ClassResolver classResolver, TypeConverter converter) {
        return addDefaultContext(root, classResolver, converter, (MemberAccess)null, new OgnlContext());
    }

    public static Map createDefaultContext(Object root, ClassResolver classResolver, TypeConverter converter, MemberAccess memberAccess) {
        return addDefaultContext(root, classResolver, converter, memberAccess, new OgnlContext());
    }

    public static Map addDefaultContext(Object root, Map context) {
        return addDefaultContext(root, (ClassResolver)null, (TypeConverter)null, (MemberAccess)null, context);
    }

    public static Map addDefaultContext(Object root, ClassResolver classResolver, Map context) {
        return addDefaultContext(root, classResolver, (TypeConverter)null, (MemberAccess)null, context);
    }

    public static Map addDefaultContext(Object root, ClassResolver classResolver, TypeConverter converter, Map context) {
        return addDefaultContext(root, classResolver, converter, (MemberAccess)null, context);
    }

    public static Map addDefaultContext(Object root, ClassResolver classResolver, TypeConverter converter, MemberAccess memberAccess, Map context) {
        OgnlContext result;
        if (!(context instanceof OgnlContext)) {
            result = new OgnlContext();
            result.setValues(context);
        } else {
            result = (OgnlContext)context;
        }

        if (classResolver != null) {
            result.setClassResolver(classResolver);
        }

        if (converter != null) {
            result.setTypeConverter(converter);
        }

        if (memberAccess != null) {
            result.setMemberAccess(memberAccess);
        }

        result.setRoot(root);
        return result;
    }

    public static void setClassResolver(Map context, ClassResolver classResolver) {
        context.put("_classResolver", classResolver);
    }

    public static ClassResolver getClassResolver(Map context) {
        return (ClassResolver)context.get("_classResolver");
    }

    public static void setTypeConverter(Map context, TypeConverter converter) {
        context.put("_typeConverter", converter);
    }

    public static TypeConverter getTypeConverter(Map context) {
        return (TypeConverter)context.get("_typeConverter");
    }

    public static void setMemberAccess(Map context, MemberAccess memberAccess) {
        context.put("_memberAccess", memberAccess);
    }

    public static MemberAccess getMemberAccess(Map context) {
        return (MemberAccess)context.get("_memberAccess");
    }

    public static void setRoot(Map context, Object root) {
        context.put("root", root);
    }

    public static Object getRoot(Map context) {
        return context.get("root");
    }

    public static Evaluation getLastEvaluation(Map context) {
        return (Evaluation)context.get("_lastEvaluation");
    }

    public static Object getValue(Object tree, Map context, Object root) throws OgnlException {
        return getValue((Object)tree, context, root, (Class)null);
    }

    public static Object getValue(Object tree, Map context, Object root, Class resultType) throws OgnlException {
        OgnlContext ognlContext = (OgnlContext)addDefaultContext(root, context);
        Object result = ((Node)tree).getValue(ognlContext, root);
        if (resultType != null) {
            result = getTypeConverter(context).convertValue(context, root, (Member)null, (String)null, result, resultType);
        }

        return result;
    }

    public static Object getValue(String expression, Map context, Object root) throws OgnlException {
        return getValue((String)expression, context, root, (Class)null);
    }

    public static Object getValue(String expression, Map context, Object root, Class resultType) throws OgnlException {
        return getValue(parseExpression(expression), context, root, resultType);
    }

    public static Object getValue(Object tree, Object root) throws OgnlException {
        return getValue((Object)tree, (Object)root, (Class)null);
    }

    public static Object getValue(Object tree, Object root, Class resultType) throws OgnlException {
        return getValue(tree, createDefaultContext(root), root, resultType);
    }

    public static Object getValue(String expression, Object root) throws OgnlException {
        return getValue((String)expression, (Object)root, (Class)null);
    }

    public static Object getValue(String expression, Object root, Class resultType) throws OgnlException {
        return getValue(parseExpression(expression), root, resultType);
    }

    public static void setValue(Object tree, Map context, Object root, Object value) throws OgnlException {
        OgnlContext ognlContext = (OgnlContext)addDefaultContext(root, context);
        Node n = (Node)tree;
        n.setValue(ognlContext, root, value);
    }

    public static void setValue(String expression, Map context, Object root, Object value) throws OgnlException {
        setValue(parseExpression(expression), context, root, value);
    }

    public static void setValue(Object tree, Object root, Object value) throws OgnlException {
        setValue(tree, createDefaultContext(root), root, value);
    }

    public static void setValue(String expression, Object root, Object value) throws OgnlException {
        setValue(parseExpression(expression), root, value);
    }

    public static boolean isConstant(Object tree, Map context) throws OgnlException {
        return ((SimpleNode)tree).isConstant((OgnlContext)addDefaultContext((Object)null, context));
    }

    public static boolean isConstant(String expression, Map context) throws OgnlException {
        return isConstant(parseExpression(expression), context);
    }

    public static boolean isConstant(Object tree) throws OgnlException {
        return isConstant(tree, createDefaultContext((Object)null));
    }

    public static boolean isConstant(String expression) throws OgnlException {
        return isConstant(parseExpression(expression), createDefaultContext((Object)null));
    }

    public static boolean isSimpleProperty(Object tree, Map context) throws OgnlException {
        return ((SimpleNode)tree).isSimpleProperty((OgnlContext)addDefaultContext((Object)null, context));
    }

    public static boolean isSimpleProperty(String expression, Map context) throws OgnlException {
        return isSimpleProperty(parseExpression(expression), context);
    }

    public static boolean isSimpleProperty(Object tree) throws OgnlException {
        return isSimpleProperty(tree, createDefaultContext((Object)null));
    }

    public static boolean isSimpleProperty(String expression) throws OgnlException {
        return isSimpleProperty(parseExpression(expression), createDefaultContext((Object)null));
    }

    public static boolean isSimpleNavigationChain(Object tree, Map context) throws OgnlException {
        return ((SimpleNode)tree).isSimpleNavigationChain((OgnlContext)addDefaultContext((Object)null, context));
    }

    public static boolean isSimpleNavigationChain(String expression, Map context) throws OgnlException {
        return isSimpleNavigationChain(parseExpression(expression), context);
    }

    public static boolean isSimpleNavigationChain(Object tree) throws OgnlException {
        return isSimpleNavigationChain(tree, createDefaultContext((Object)null));
    }

    public static boolean isSimpleNavigationChain(String expression) throws OgnlException {
        return isSimpleNavigationChain(parseExpression(expression), createDefaultContext((Object)null));
    }

    private Ognl() {
    }
}
调用getValue方法获取表达式的值

package org.apache.ibatis.ognl;

import java.lang.reflect.Member;
import java.util.Map;

public class DefaultTypeConverter implements TypeConverter {
    public DefaultTypeConverter() {
    }

    public Object convertValue(Map context, Object value, Class toType) {
        return OgnlOps.convertValue(value, toType);
    }

    public Object convertValue(Map context, Object target, Member member, String propertyName, Object value, Class toType) {
        return this.convertValue(context, value, toType);
    }
}

protected Object evaluateGetValueBody(OgnlContext context, Object source) throws OgnlException {
        context.setCurrentObject(source);
        context.setCurrentNode(this);
        if (!this.constantValueCalculated) {
            this.constantValueCalculated = true;
            this.hasConstantValue = this.isConstant(context);
            if (this.hasConstantValue) {
                this.constantValue = this.getValueBody(context, source);
            }
        }

        return this.hasConstantValue ? this.constantValue : this.getValueBody(context, source);
    }

以上getValueBody有多种AST开头的实现，如ASTList,ASTNotEq,ASTEq,ASTNotIn,ASTOr等，这里主要看ASTNotEq AST实现

package org.apache.ibatis.ognl;

class ASTNotEq extends ExpressionNode {
    public ASTNotEq(int id) {
        super(id);
    }

    public ASTNotEq(OgnlParser p, int id) {
        super(p, id);
    }

    protected Object getValueBody(OgnlContext context, Object source) throws OgnlException {
        Object v1 = super.children[0].getValue(context, source);
        Object v2 = super.children[1].getValue(context, source);
        return OgnlOps.equal(v1, v2) ? Boolean.FALSE : Boolean.TRUE;
    }

    public String getExpressionOperator(int index) {
        return "!=";
    }
}

当使用test="sorted !='0' "时，解析出结果如下 '0'被解析成Charactor字符类型

当使用test='sorted !="0"'时,'0'被解析成String字符串类型

当！=后面的值时''时，解析结果如下 即能解析出正确的结果

结论

变量与单个常量字符比较 需要使用test='sorted !="0"'，变量与空字符常量比较，test="sorted !='0'"即可

转载于:https://my.oschina.net/odetteisgorgeous/blog/3010296

weixin_33858336
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Mybatis | 动态 SQL 基石 —— Ognl
u010141779的博客
12-30 2172
动态 SQL 是 MyBatis 的强大特性之一。如果使用过 JDBC 或其它类似的框架，应该能理解根据不同条件拼接 SQL 语句有多痛苦，例如拼接时要确保不能忘记添加必要的空格，还要注意去掉列表最后一个列名的逗号。利用动态 SQL，可以彻底摆脱这种痛苦。除了 if， Mybatis 还支持 choose，when，otherwise，trim，where 等动态 SQL 元素，值得注意的是，这些元素中有些属性是需要通过表达式计算的，比如 if 元素的 test 属性。
Mybatis映射文件之 Select 元素使用及详细解析
weixin_45538589的博客
01-04 4882
Mybatis映射文件之 Select 元素使用及详细解析
Mybatis查询数据库数据的报错原因
2201_75392632的博客
01-15 557
这个错误提示表明在执行selectOne()方法时，期望返回一个结果（或null），但实际上返回了5个结果。这可能是由于查询条件不准确或数据库中存在重复数据导致的。student1是我要查询的数据表名称，这里的意思是查询该表里的所有信息，所以查询出来有五条。这是因为student对象没有生成toString方法，找到问题就能轻松解决了。
MyBatis 的秘密动态SQL
12-30 154
动态SQL 说到动态SQL,就不得不提Script,Java作为一个静态语音，代码需要先编译，然后再运行，虽然带来了效率，但是却损失了灵活性。 Spring为此还专门提供了一套SpEL用来封装Java脚本语言API 在MyBatis中，也支持动态SQL，想要将简单的String字符串编译成能运行的代码，需要其他的库的支持，MyBatis内部使用的是OGNL库。 在OgnlCache中，是MyBat...
OGNL (Object-Graph Navigation Language) 表达式 极简教程
禅与计算机程序设计艺术
08-01 8818
OGNL 术语说明OGNL stands for Object-Graph Navigation Language; it is an expression language for getting and setting properties of Java objects, plus other extras such as list projection and selection and ...
Ognl 使用实例手册
程序员高级码农的博客
01-09 1215
现在的问题主要集中在如何构建一个 Aemo 对象，当做参数丢进去，通过前面的语法篇我们知道 ognl 是支持 new 来创建对象的， 如果 ADemo 恰好提供了全属性的构造方法，那么可以如下操作。下面我们进入实例演示。虽说上面实现了我们的需求场景，但是这里有个坑，我们创建的这个属性会丢到 OgnlContext 上下文中，所以这种操作非常有可能导致我们自己创建的临时对象覆盖了原有的对象。我们这里可以直接访问私有成员，访问私有方法，访问父类的私有成员，这些都得益于我们自定义的。
mybatis逆向工具
08-30
- 动态SQL可视化：动态SQL是MyBatis的一大特色，逆向工具可以呈现其生成的最终SQL语句，便于理解和分析。 3. 使用MyBatis逆向工具的场景： - 故障排查：当遇到数据库相关问题时，逆向工具可以帮助快速定位问题，...
read:学习笔记dubbo，spring，mybatis，netty源码解析-源码解析
03-24
这是一份关于深入理解Java领域四大热门框架——Dubbo、Spring、Mybatis和Netty的源码分析学习笔记。这四个框架在现代Java开发中扮演着至关重要的角色，它们各自解决了不同的问题并优化了软件的性能和可维护性。 1. ...
基于springboot+mybatis-plus+vue的家电家具维修系统
最新发布
03-28
本文将深入探讨一个基于SpringBoot+Mybatis-Plus+Vue技术栈的维修系统，分析其核心功能和实现原理，旨在帮助读者理解和掌握这一领域的前沿技术。 1. **SpringBoot框架** SpringBoot是Spring框架的简化版，它通过...
SpringMVC+MyBatis+druid+Dubbo+Zookpper案例.zip
02-02
3. **Druid**：Druid是阿里巴巴开源的数据库连接池组件，它不仅提供了监控、扩展性、性能等功能，还包含了SQL解析和执行计划等功能。Druid能有效地管理数据库连接，防止资源浪费，提高系统的并发处理能力，并且其...
mybatis-readwrite.zip
02-03
这种方式的好处是配置简单，但可能需要对SQL语句进行额外的解析。 2. **基于Spring注解和AOP实现**：Spring的AOP（面向切面编程）可以让我们在执行方法前或后插入自定义逻辑。通过在Service层的方法上添加特定的...
struts2的OGNL的使用
topMan'blog
04-29 131
要谈OGNL在Struts2中的应用，首先得明白OGNL到底是什么 在值栈中的对象，可以直接访问，但是用#.对象的时候却又访问不到，但用#this.对象的时候又可以访问得到，用%所有的没关系的 OGNL 的历史 OGNL 最初是为了能够使用对象的属性名来建立 UI 组件 (component) 和 控制器 (controllers) 之间的联系，简单来说就是：视图 与 控制器 之间数据的联...
妙用ognl表达式来控制工作流的分支流转
油葫芦的专栏
03-02 3606
 OGNL是Object-Graph Navigation Language的缩写，它是一种功能强大的表达式语言（Expression Language，简称为EL），通过它简单一致的表达式语法，可以存取对象的任意属性，调用对象的方法，遍历整个对象的结构图，实现字段类型转化等功能。 第一次接触OGNL是因为tapestry，tapestry使用ognl在页面中绑定业务数据。。。 关于ogn
OGNL简介
gentlezuo的博客
11-29 2241
Ognl 文章目录Ognl数据结构访问属性实例属性静态属性赋值调用方法实例方法静态方法操作符集合操作构造访问投影选择选择第一个选择最后一个索引机制官方文档例子 Ognl (Object-Graph Navigation Language)是对象图导航语言，用于访问一个容器中的对象的属性，调用对象的方法。主要是为了方便访问对象的属性和方法。 应用 Struts2 arthas中，命令参数 数据结构 OgnlContext是一个容器，本质是一个Map，key是String类型的值，value是对象。因此它具
OGNL 表达式简介
owen_008的专栏
07-25 1238
OGNL是Object-Graph Navigation Language的缩写，它是一种功能强大的表达式语言（Expression Language，简称为EL），通过它简单一致的表达式语法，可以存取对象的任意属性，调用对象的方法，遍历整个对象的结构图，实现字段类型转化等功能。它使用相同的表达式去存取对象的属性。 OGNL特性：1，一个OGNL      表达式的基本组成是：naviga
目录 1. Java中使用Ognl表达式引擎 1 1.1.1. 一、Ognl简介 1 1.1.2. 二、Ognl应用场景 1 1.2. 基本介绍 vs 模板语言 2 1.Java中使用Ognl表达
attilax的专栏
01-15 520
目录 1. Java中使用Ognl表达式引擎 1 1.1.1. 一、Ognl简介 1 1.1.2. 二、Ognl应用场景 1 1.2. 基本介绍 vs 模板语言 2     Java中使用Ognl表达式引擎 2018年08月19日 22:54:51 脱线宅 阅读数：253 一、Ognl简介 OGNL是Object-Graph Navigation Langu...
Struts2_ValueStack,OGNL详解
Java_小峰峰的专栏
12-05 851
引言： 闲话不多说，最近项目结束，天天泡在CSDN论坛上，不乏看到一些好的文章，在此与君共勉... 原文地址：http://blog.csdn.net/wyply115/article/details/8257140 ，有兴趣的朋友可以去他博客学习学习...   一、ValueStack     1.ValueStack是一个接口，在struts2中使用OGNL（Object-Graph
压测中提高并发数后服务端处理时间增长的原因分析
u011734144的专栏
11-20 2847
后端逻辑：  接收请求、分词匹配、读redis做一些过滤策略 在不断提高并发数的压测过程中，发现一个问题，后台服务对一个请求的处理时间也在增高， 而且增高的主要时间是消耗在读redis过滤那块 过滤那块的主要逻辑是：从redis中读数据，并基于这些数据做一些过滤的策略 为什么这块的耗时会增长呢？难道是redis的线程池不够用？导致有些redis的io请求要等待一会？ 应该不会，因为redi...
Mybatis入门指南：持久层框架解析
Mybatis 是一款强大的持久层框架，主要针对Java开发人员，它简化了数据库操作，使开发者能够专注于编写SQL语句和映射Java对象到数据库记录，而无需处理繁琐的JDBC代码。Mybatis 提供了XML或注解配置方式，可以方便地...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值