表达式支持使用qlexpress4.0

core/pom.xml

@@ -211,6 +211,10 @@
             <groupId>ognl</groupId>
             <artifactId>ognl</artifactId>
         </dependency>
+        <dependency>
+            <groupId>com.alibaba</groupId>
+            <artifactId>qlexpress4</artifactId>
+        </dependency>
         <dependency>
             <groupId>org.junit.vintage</groupId>
             <artifactId>junit-vintage-engine</artifactId>
@@ -263,6 +267,10 @@
             <scope>provided</scope>
             <optional>true</optional>
         </dependency>
+        <dependency>
+            <groupId>ognl</groupId>
+            <artifactId>ognl</artifactId>
+        </dependency>
     </dependencies>
 
 </project>

core/src/main/java/com/taobao/arthas/core/GlobalOptions.java

@@ -142,6 +142,15 @@ public class GlobalOptions {
             description = STRICT_MESSAGE
     )
     public static volatile boolean strict = true;
+    /**
+     * 是否切换使用表达式ognl/qlexpress开关
+     */
+    @Option(level = 1,
+            name = "el",
+            summary = "expression language",
+            description = "Option to use ognl/qlexpress in commands, default ognl, can change to qlexpress"
+    )
+    public static volatile String ExpressType = "ognl";
 
     public static void updateOnglStrict(boolean strict) {
         try {

core/src/main/java/com/taobao/arthas/core/command/BuiltinCommandPack.java

@@ -77,6 +77,7 @@ private void initCommands(List<String> disabledCommands) {
         commandClassList.add(PerfCounterCommand.class);
         // commandClassList.add(GroovyScriptCommand.class);
         commandClassList.add(OgnlCommand.class);
+        commandClassList.add(QLExpressCommand.class);
         commandClassList.add(MemoryCompilerCommand.class);
         commandClassList.add(RedefineCommand.class);
         commandClassList.add(RetransformCommand.class);

core/src/main/java/com/taobao/arthas/core/command/basic1000/QLExpressCommand.java

@@ -0,0 +1,111 @@
+package com.taobao.arthas.core.command.basic1000;
+
+import com.alibaba.arthas.deps.org.slf4j.Logger;
+import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
+import com.taobao.arthas.core.command.Constants;
+import com.taobao.arthas.core.command.express.Express;
+import com.taobao.arthas.core.command.express.ExpressException;
+import com.taobao.arthas.core.command.express.ExpressFactory;
+import com.taobao.arthas.core.command.model.ClassLoaderVO;
+import com.taobao.arthas.core.command.model.ObjectVO;
+import com.taobao.arthas.core.command.model.OgnlModel;
+import com.taobao.arthas.core.command.model.QLExpressModel;
+import com.taobao.arthas.core.shell.command.AnnotatedCommand;
+import com.taobao.arthas.core.shell.command.CommandProcess;
+import com.taobao.arthas.core.util.ClassLoaderUtils;
+import com.taobao.arthas.core.util.ClassUtils;
+import com.taobao.middleware.cli.annotations.*;
+
+import java.lang.instrument.Instrumentation;
+import java.util.Collection;
+import java.util.List;
+
+/**
+ * @Author TaoKan
+ * @Date 2025/3/23 8:59 PM
+ */
+@Name("qlexpress")
+@Summary("Execute qlexpress expression.")
+@Description(Constants.EXAMPLE
+        + "  qlexpress 'java.lang.System.out.println(\"hello~\")' \n"
+        + "  qlexpress -x 2 'java.lang.Math.abs(1)' \n"
+        + "  qlexpress -c 5d113a51 'com.taobao.arthas.core.GlobalOptions.isDump' \n"
+        + Constants.WIKI + Constants.WIKI_HOME + "qlexpress\n"
+        + "  https://github.com/alibaba/QLExpress/tree/v4.0.0-beta.1")
+public class QLExpressCommand extends AnnotatedCommand {
+    private static final Logger logger = LoggerFactory.getLogger(QLExpressCommand.class);
+
+    private String express;
+    private String hashCode;
+    private String classLoaderClass;
+    private int expand = 1;
+
+    @Argument(argName = "express", index = 0, required = true)
+    @Description("The qlexpress expression.")
+    public void setExpress(String express) {
+        this.express = express;
+    }
+
+    @Option(shortName = "c", longName = "classLoader")
+    @Description("The hash code of the special class's classLoader, default classLoader is SystemClassLoader.")
+    public void setHashCode(String hashCode) {
+        this.hashCode = hashCode;
+    }
+
+
+    @Option(longName = "classLoaderClass")
+    @Description("The class name of the special class's classLoader.")
+    public void setClassLoaderClass(String classLoaderClass) {
+        this.classLoaderClass = classLoaderClass;
+    }
+
+
+    @Option(shortName = "x", longName = "expand")
+    @Description("Expand level of object (1 by default).")
+    public void setExpand(Integer expand) {
+        this.expand = expand;
+    }
+    @Override
+    public void process(CommandProcess process) {
+        Instrumentation inst = process.session().getInstrumentation();
+        ClassLoader classLoader = null;
+        if (hashCode != null) {
+            classLoader = ClassLoaderUtils.getClassLoader(inst, hashCode);
+            if (classLoader == null) {
+                process.end(-1, "Can not find classloader with hashCode: " + hashCode + ".");
+                return;
+            }
+        } else if (classLoaderClass != null) {
+            List<ClassLoader> matchedClassLoaders = ClassLoaderUtils.getClassLoaderByClassName(inst, classLoaderClass);
+            if (matchedClassLoaders.size() == 1) {
+                classLoader = matchedClassLoaders.get(0);
+            } else if (matchedClassLoaders.size() > 1) {
+                Collection<ClassLoaderVO> classLoaderVOList = ClassUtils.createClassLoaderVOList(matchedClassLoaders);
+                QLExpressModel qlModel = new QLExpressModel()
+                        .setClassLoaderClass(classLoaderClass)
+                        .setMatchedClassLoaders(classLoaderVOList);
+                process.appendResult(qlModel);
+                process.end(-1, "Found more than one classloader by class name, please specify classloader with '-c <classloader hash>'");
+                return;
+            } else {
+                process.end(-1, "Can not find classloader by class name: " + classLoaderClass + ".");
+                return;
+            }
+        } else {
+            classLoader = ClassLoader.getSystemClassLoader();
+        }
+
+        Express unpooledExpress = ExpressFactory.unpooledExpressByQL(classLoader);
+        try {
+            Object value = unpooledExpress.bind(new Object()).get(express);
+            QLExpressModel qlModel = new QLExpressModel()
+                    .setValue(new ObjectVO(value, expand));
+            process.appendResult(qlModel);
+            process.end();
+        } catch (ExpressException e) {
+            logger.warn("qlexpress: failed execute express: " + express, e);
+            process.end(-1, "Failed to execute qlexpress, exception message: " + e.getMessage()
+                    + ", please check $HOME/logs/arthas/arthas.log for more details. ");
+        }
+    }
+}

core/src/main/java/com/taobao/arthas/core/command/express/ExpressFactory.java

@@ -1,29 +1,50 @@
 package com.taobao.arthas.core.command.express;
 
+import com.taobao.arthas.core.GlobalOptions;
+import com.taobao.arthas.core.command.model.ExpressTypeEnum;
+
+
 /**
  * ExpressFactory
  * @author ralf0131 2017-01-04 14:40.
  * @author hengyunabc 2018-10-08
  */
 public class ExpressFactory {
 
-    private static final ThreadLocal<Express> expressRef = new ThreadLocal<Express>() {
-        @Override
-        protected Express initialValue() {
-            return new OgnlExpress();
-        }
-    };
+    private static final ThreadLocal<Express> expressRef = ThreadLocal.withInitial(() -> new OgnlExpress());
+    private static final ThreadLocal<Express> expressRefQLExpress = ThreadLocal.withInitial(() -> new QLExpress());
 
     /**
      * get ThreadLocal Express Object
      * @param object
      * @return
      */
     public static Express threadLocalExpress(Object object) {
+        if (GlobalOptions.ExpressType.equals(ExpressTypeEnum.QLEXPRESS.getExpressType())) {
+            return expressRefQLExpress.get().reset().bind(object);
+        }
         return expressRef.get().reset().bind(object);
     }
 
     public static Express unpooledExpress(ClassLoader classloader) {
+        if (classloader == null) {
+            classloader = ClassLoader.getSystemClassLoader();
+        }
+        if (GlobalOptions.ExpressType.equals(ExpressTypeEnum.QLEXPRESS.getExpressType())) {
+            return new QLExpress(new QLExpressClassLoaderClassResolver(classloader));
+        }
+        return new OgnlExpress(new ClassLoaderClassResolver(classloader));
+    }
+
+
+    public static Express unpooledExpressByQL(ClassLoader classloader) {
+        if (classloader == null) {
+            classloader = ClassLoader.getSystemClassLoader();
+        }
+        return new QLExpress(new QLExpressClassLoaderClassResolver(classloader));
+    }
+
+    public static Express unpooledExpressByOGNL(ClassLoader classloader) {
         if (classloader == null) {
             classloader = ClassLoader.getSystemClassLoader();
         }

core/src/main/java/com/taobao/arthas/core/command/express/QLExpress.java

@@ -0,0 +1,78 @@
+package com.taobao.arthas.core.command.express;
+
+import com.alibaba.arthas.deps.org.slf4j.Logger;
+import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
+import com.alibaba.qlexpress4.*;
+import com.alibaba.qlexpress4.security.QLSecurityStrategy;
+
+
+/**
+ * @Author TaoKan
+ * @Date 2024/9/17 6:01 PM
+ */
+public class QLExpress implements Express {
+    private static final Logger logger = LoggerFactory.getLogger(QLExpress.class);
+    private Express4Runner expressRunner;
+    private QLGlobalContext qlGlobalContext;
+
+    private QLOptions qlOptions;
+
+    private InitOptions initOptions;
+
+    public QLExpress() {
+        this(QLExpressCustomClassResolver.customClassResolver);
+    }
+
+    public QLExpress(ClassSupplier classResolver) {
+        this.initOptions = initQLExpress(classResolver);
+        this.expressRunner = QLExpressRunner.getInstance(initOptions);
+        this.qlOptions = initConfig();
+        this.qlGlobalContext = new QLGlobalContext(expressRunner);
+    }
+
+    private QLOptions initConfig() {
+        return QLOptions.DEFAULT_OPTIONS;
+    }
+
+    private InitOptions initQLExpress(ClassSupplier classResolver) {
+        InitOptions.Builder initOptionsBuilder = InitOptions.builder();
+        initOptionsBuilder.securityStrategy(QLSecurityStrategy.open());
+        initOptionsBuilder.allowPrivateAccess(true);
+        initOptionsBuilder.classSupplier(classResolver);
+        return initOptionsBuilder.build();
+    }
+
+    @Override
+    public Object get(String express) throws ExpressException {
+        try {
+            return expressRunner.execute(express, qlGlobalContext, qlOptions).getResult();
+        } catch (Exception e) {
+            logger.error("Error during evaluating the expression with QLExpress:", e);
+            throw new ExpressException(express, e);
+        }
+    }
+
+    @Override
+    public boolean is(String express) throws ExpressException {
+        final Object ret = get(express);
+        return ret instanceof Boolean && (Boolean) ret;
+    }
+
+    @Override
+    public Express bind(Object object) {
+        qlGlobalContext.bindObj(object);
+        return this;
+    }
+
+    @Override
+    public Express bind(String name, Object value) {
+        qlGlobalContext.put(name, value);
+        return this;
+    }
+
+    @Override
+    public Express reset() {
+        qlGlobalContext.clear();
+        return this;
+    }
+}

core/src/main/java/com/taobao/arthas/core/command/express/QLExpressClassLoaderClassResolver.java

@@ -0,0 +1,40 @@
+package com.taobao.arthas.core.command.express;
+
+import com.alibaba.qlexpress4.ClassSupplier;
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * @Author TaoKan
+ * @Date 2024/12/1 7:07 PM
+ */
+public class QLExpressClassLoaderClassResolver implements ClassSupplier {
+
+    private ClassLoader classLoader;
+
+    private final Map<String, Optional<Class<?>>> cache = new ConcurrentHashMap<>();
+
+    public QLExpressClassLoaderClassResolver(ClassLoader classLoader) {
+        this.classLoader = classLoader;
+    }
+
+    private Optional<Class<?>> loadClsInner(String clsQualifiedName) {
+        try {
+            Class<?> aClass = null;
+            if (classLoader != null) {
+                aClass = classLoader.loadClass(clsQualifiedName);
+            }else {
+                aClass = Class.forName(clsQualifiedName);
+            }
+            return Optional.of(aClass);
+        } catch (ClassNotFoundException | NoClassDefFoundError e) {
+            return Optional.empty();
+        }
+    }
+    @Override
+    public Class<?> loadCls(String className) {
+        Optional<Class<?>> clsOp = cache.computeIfAbsent(className, this::loadClsInner);
+        return clsOp.orElse(null);
+    }
+}

core/src/main/java/com/taobao/arthas/core/command/express/QLExpressCustomClassResolver.java

@@ -0,0 +1,44 @@
+package com.taobao.arthas.core.command.express;
+
+import com.alibaba.arthas.deps.org.slf4j.Logger;
+import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
+import com.alibaba.qlexpress4.ClassSupplier;
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * @Author TaoKan
+ * @Date 2024/12/1 7:06 PM
+ */
+public class QLExpressCustomClassResolver implements ClassSupplier {
+
+    public static final QLExpressCustomClassResolver customClassResolver = new QLExpressCustomClassResolver();
+
+    private final Map<String, Optional<Class<?>>> cache = new ConcurrentHashMap<>();
+
+    private QLExpressCustomClassResolver() {
+
+    }
+
+    private Optional<Class<?>> loadClsInner(String clsQualifiedName) {
+        try {
+            ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
+            Class<?> aClass = null;
+            if (classLoader != null) {
+                aClass = classLoader.loadClass(clsQualifiedName);
+            } else {
+                aClass = Class.forName(clsQualifiedName);
+            }
+            return Optional.of(aClass);
+        } catch (ClassNotFoundException | NoClassDefFoundError e) {
+            return Optional.empty();
+        }
+    }
+    @Override
+    public Class<?> loadCls(String clsQualifiedName) {
+        Optional<Class<?>> clsOp = cache.computeIfAbsent(clsQualifiedName, this::loadClsInner);
+        return clsOp.orElse(null);
+    }
+
+}