当前位置：首页 > article >正文

MyBatis 源码解析：OGNL 表达式解析与使用

article 2024/12/26 1:24:31

摘要

OGNL（Object-Graph Navigation Language）为 MyBatis 提供了强大的表达式解析能力，使 SQL 语句能根据业务需求动态生成。本文将深入解析 MyBatis 中如何通过 OGNL 进行动态 SQL 的生成，并通过自定义实现简化的 OGNL 解析器，探讨其工作原理，详细解读源码中的关键实现，帮助开发者更好理解这一功能。

前言

在 MyBatis 中，OGNL 被用于动态生成 SQL 语句，其核心优势在于能根据输入参数的不同，执行不同的查询逻辑。OGNL 表达式可以访问对象的属性、方法、集合等内容，帮助我们灵活地构建 SQL 语句。MyBatis 使用 OGNL 的能力极大简化了 SQL 语句拼接的复杂性，使其在复杂查询场景中得到了广泛应用。本文将从源码角度详细解析 OGNL 表达式的使用，并实现一个简化版的解析器。

自定义实现：OGNL 表达式解析器

目标与功能

为了更好理解 OGNL 的原理，我们将实现一个简化版的解析器，支持以下功能：

对象属性访问：根据输入表达式访问对象的属性值。
方法调用：解析表达式时能够自动调用对象的方法。
逻辑判断：根据逻辑表达式返回布尔结果。

实现过程

1. 定义 OgnlExpressionParser 类

我们首先定义 OgnlExpressionParser 类，支持根据表达式动态访问对象的属性，并通过反射机制调用相应的方法。

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

public class OgnlExpressionParser {
    
    /**
     * 解析 OGNL 表达式
     * @param expression 表达式字符串
     * @param context 上下文对象（包含数据）
     * @return 解析结果
     */
    public Object parseExpression(String expression, Object context) throws Exception {
        String[] tokens = expression.split("\\.");
        Object currentObject = context;
        
        for (String token : tokens) {
            currentObject = invokeGetterOrMethod(currentObject, token);
        }
        return currentObject;
    }

    /**
     * 通过反射获取对象的属性值或调用其方法
     * @param object 目标对象
     * @param fieldOrMethod 表达式中的字段或方法名
     * @return 属性值或方法返回值
     */
    private Object invokeGetterOrMethod(Object object, String fieldOrMethod) throws Exception {
        Method method = null;
        try {
            method = object.getClass().getMethod("get" + capitalize(fieldOrMethod));
        } catch (NoSuchMethodException e) {
            // 如果不存在对应的 getter 方法，尝试直接调用方法
            method = object.getClass().getMethod(fieldOrMethod);
        }
        return method.invoke(object);
    }

    private String capitalize(String str) {
        return str.substring(0, 1).toUpperCase() + str.substring(1);
    }
}

代码解析

OgnlExpressionParser 的核心功能是通过 parseExpression 方法解析字符串表达式，通过递归的方式依次访问对象的属性或调用其方法。例如，表达式 "user.name" 将首先通过 user 对象调用 getName 方法，最终返回 name 的值。

2. 测试 OgnlExpressionParser

我们通过一个简单的 User 类来测试 OgnlExpressionParser，验证它是否能正确解析和执行表达式。

public class OgnlTest {
    public static void main(String[] args) throws Exception {
        User user = new User("Alice", 25);
        OgnlExpressionParser parser = new OgnlExpressionParser();
        
        // 解析表达式 "name" 并获取结果
        Object result = parser.parseExpression("name", user);
        System.out.println("Result: " + result);  // 输出: Alice
    }
}

class User {
    private String name;
    private int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

输出结果：

Result: Alice

自定义实现类图

代码执行流程图

源码解析：MyBatis 中的 OGNL 表达式解析

1. MyBatis 中的 SqlNode 设计

在 MyBatis 中，OGNL 主要用于 <if> 和 <foreach> 标签，通过这些标签，MyBatis 能够根据表达式的结果动态生成 SQL 语句。每个标签被封装为一个 SqlNode 对象，SqlNode 负责拼接 SQL 片段。

public interface SqlNode {
    boolean apply(DynamicContext context);
}

其中，apply 方法负责根据上下文中的 OGNL 表达式，决定是否拼接 SQL 语句。

2. IfSqlNode 与 OGNL 的结合

IfSqlNode 负责处理 <if> 标签，它通过 OGNL 表达式来判断是否执行其内部的 SQL 片段。其核心实现如下：

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

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

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

3. ExpressionEvaluator 的作用

ExpressionEvaluator 是 MyBatis 中负责解析 OGNL 表达式的类，它通过 OGNL 表达式计算布尔值，从而决定是否执行 SqlNode 的 apply 方法。

public class ExpressionEvaluator {
    public boolean evaluateBoolean(String expression, Object parameterObject) {
        OgnlContext context = new OgnlContext();
        Object parsedExpression = Ognl.parseExpression(expression);
        return (Boolean) Ognl.getValue(parsedExpression, context, parameterObject);
    }
}