Jvm-Sandbox源码分析--增强目标类

前言

在前两篇文章Jvm-Sandbox源码分析--启动简析和Jvm-Sandbox源码分析--启动时加载模块中我们分析了jvm-sandbox启动及启动时加载模块的过程，这一篇我们来看一下如何使用模块增强目标类的流程。

执行脚本

在启动沙箱流程之后，执行如下命令。
sh sandbox/bin/sandbox.sh -p pid -d "broken-clock-tinker/repairCheckState"

 # -d debug
    if [[ ! -z ${OP_DEBUG} ]]; then
        sandbox_debug_curl "module/http/${ARG_DEBUG}"
        exit
    fi

通过ModuleHttpServlet doMethod方法进行http路由

ModuleHttpServlet是在启动流程中提到的 JettyCoreServer 类中通过 initJettyContextHandler 操作加入到jetty上下文的。

 // module-http-servlet
        final String pathSpec = "/module/http/*";
        logger.info("initializing http-handler. path={}", contextPath + pathSpec);
        context.addServlet(
                new ServletHolder(new ModuleHttpServlet(jvmSandbox.getCoreModuleManager())),
                pathSpec
        );

进入 ModuleHttpServlet 中，我们可以看到所有 http 相关请求都会进入 doMethod 方法。
关键步骤:
1.获取请求路径
2.获取模块ID
3.通过模块ID，获取模块

// 获取请求路径
        final String path = req.getPathInfo();

        // 获取模块ID
        final String uniqueId = parseUniqueId(path);
        if (StringUtils.isBlank(uniqueId)) {
            logger.warn("http request value={} was not found.", path);
            resp.sendError(HttpServletResponse.SC_NOT_FOUND);
            return;
        }

        // 获取模块
        final CoreModule coreModule = coreModuleManager.get(uniqueId);
        if (null == coreModule) {
            logger.warn("module[id={}] was not existed, value={};", uniqueId, path);
            resp.sendError(HttpServletResponse.SC_NOT_FOUND);
            return;
        }

4.获取目标类（模块）上加了@Command注解的方法

private Method matchingModuleMethod(final String path,
                                        final Http.Method httpMethod,
                                        final String uniqueId,
                                        final Class<?> classOfModule) {

        // 查找@Command注解的方法
        for (final Method method : MethodUtils.getMethodsListWithAnnotation(classOfModule, Command.class)) {
            final Command commandAnnotation = method.getAnnotation(Command.class);
            if (null == commandAnnotation) {
                continue;
            }
            final String pathOfCmd = "/" + uniqueId + "/" + commandAnnotation.value();
            if (StringUtils.equals(path, pathOfCmd)) {
                return method;
            }
        }

        // 找不到匹配方法，返回null
        return null;
    }

5.使用ModuleJarClassLoader invoke目标模块的方法

//关键代码
// 生成方法调用参数
final Object[] parameterObjectArray = generateParameterObjectArray(method, req, resp);

//使用ModuleJarClassLoader invoke目标模块的方法
final ClassLoader oriThreadContextClassLoader = Thread.currentThread().getContextClassLoader();
Thread.currentThread().setContextClassLoader(coreModule.getLoader());
method.invoke(coreModule.getModule(), parameterObjectArray);
Thread.currentThread().setContextClassLoader(oriThreadContextClassLoader);

观察调用链

我们可以看到调用进入了我们自定义的Module中。

官方示例模块代码

修复一个损坏了的钟

@MetaInfServices(Module.class)
@Information(id = "broken-clock-tinker")
public class BrokenClockTinkerModule implements Module {

    @Resource
    private ModuleEventWatcher moduleEventWatcher;

    @Command("repairCheckState")
    public void repairCheckState() {

        new EventWatchBuilder(moduleEventWatcher)
                .onClass("com.taobao.demo.Clock")
                .onBehavior("checkState")
                .onWatch(new AdviceListener() {

                    /**
                     * 拦截{@code com.taobao.demo.Clock#checkState()}方法，当这个方法抛出异常时将会被
                     * AdviceListener#afterThrowing()所拦截
                     */
                    @Override
                    protected void afterThrowing(Advice advice) throws Throwable {
                        
                        // 在此，你可以通过ProcessController来改变原有方法的执行流程
                        // 这里的代码意义是：改变原方法抛出异常的行为，变更为立即返回；void返回值用null表示
                        ProcessController.returnImmediately(null);
                    }
                });

    }

}

行为匹配实现器BuildingForBehavior

这是事件观察者类构建器 EventWatchBuilder的一个内部类。

@Override
        public EventWatcher onWatch(final AdviceListener adviceListener) {
            return build(new AdviceAdapterListener(adviceListener), null, BEFORE, RETURN, THROWS, IMMEDIATELY_RETURN, IMMEDIATELY_THROWS);
        }

事件观察者类构建器 EventWatchBuilder的build方法

其实到这里可以看出通过 HTTP 请求来调用模块的方法增强目标类，最终是调用了 moduleEventWatcher的watch方法。
关键步骤：
1.调用 moduleEventWatcher.watch 去修改目标类的字节码
2.创建事件观察条件，过滤类和方法

private EventWatcher build(final EventListener listener,
                               final Progress progress,
                               final Event.Type... eventTypes) {
        // 调用 moduleEventWatcher.watch 去修改目标类的字节码
        final int watchId = moduleEventWatcher.watch(
                toEventWatchCondition(),// 创建事件观察条件，过滤类和方法
                listener,
                progress,
                eventTypes
        );

        return new EventWatcher() {

            final List<Progress> progresses = new ArrayList<Progress>();

            @Override
            public int getWatchId() {
                return watchId;
            }

            @Override
            // 流程监控回调类
            public IBuildingForUnWatching withProgress(Progress progress) {
                if (null != progress) {
                    progresses.add(progress);
                }
                return this;
            }

            @Override
            // 取消监听操作
            public void onUnWatched() {
                moduleEventWatcher.delete(watchId, toProgressGroup(progresses));
            }

        };
    }
    
    
    // 创建事件观察条件，过滤类和方法
    private EventWatchCondition toEventWatchCondition() {
        final List<Filter> filters = new ArrayList<Filter>();
        for (final BuildingForClass bfClass : bfClasses) {
            final Filter filter = new Filter() {
                @Override
                public boolean doClassFilter(final int access,
                                             final String javaClassName,
                                             final String superClassTypeJavaClassName,
                                             final String[] interfaceTypeJavaClassNameArray,
                                             final String[] annotationTypeJavaClassNameArray) {
                    return (access & bfClass.withAccess) == bfClass.withAccess
                            && patternMatching(javaClassName, bfClass.pattern, patternType)
                            && bfClass.hasInterfaceTypes.patternHas(interfaceTypeJavaClassNameArray)
                            && bfClass.hasAnnotationTypes.patternHas(annotationTypeJavaClassNameArray);
                }

                @Override
                public boolean doMethodFilter(final int access,
                                              final String javaMethodName,
                                              final String[] parameterTypeJavaClassNameArray,
                                              final String[] throwsTypeJavaClassNameArray,
                                              final String[] annotationTypeJavaClassNameArray) {
                    // nothing to matching
                    if (bfClass.bfBehaviors.isEmpty()) {
                        return false;
                    }

                    // matching any behavior
                    for (final BuildingForBehavior bfBehavior : bfClass.bfBehaviors) {
                        if ((access & bfBehavior.withAccess) == bfBehavior.withAccess
                                && patternMatching(javaMethodName, bfBehavior.pattern, patternType)
                                && bfBehavior.withParameterTypes.patternWith(parameterTypeJavaClassNameArray)
                                && bfBehavior.hasExceptionTypes.patternHas(throwsTypeJavaClassNameArray)
                                && bfBehavior.hasAnnotationTypes.patternHas(annotationTypeJavaClassNameArray)) {
                            return true;
                        }//if
                    }//for

                    // non matched
                    return false;
                }
            };//filter

            filters.add(makeExtFilter(filter, bfClass));
        }
        return new EventWatchCondition() {
            @Override
            public Filter[] getOrFilterArray() {
                return filters.toArray(new Filter[0]);
            }
        };
    }
   

ModuleEventWatcher.watch方法逻辑

public int watch(final EventWatchCondition condition,
                     final EventListener listener,
                     final Progress progress,
                     final Event.Type... eventType) 

1.生成watchId,其本质是使用了一个全局的AtomicInteger

final int watchId = watchIdSequencer.next();

2.给对应的模块追加 ClassFileTransformer
这是 JDK 提供的一个接口ClassFileTransformer，其主要实现了 transform 方法用于修改类的字节码，通过这个方法，可以得到虚拟机载入的类的字节码。

final SandboxClassFileTransformer sandClassFileTransformer = new SandboxClassFileTransformer(
                watchId, coreModule.getUniqueId(), matcher, listener, isEnableUnsafe, eventType, namespace);

3.将 SandboxClassFileTransformer 注册到 coreModule 中

这个coreModule 就是我们自己定义的BrokenClockTinkerModule

// 注册到CoreModule中
coreModule.getSandboxClassFileTransformers().add(sandClassFileTransformer);

4.注册到JVM加载上ClassFileTransformer处理新增的类
inst是最开始启动时候通过 sandbox-agent 所传递的Instrumentation，通过其 addTransformer方法来修改类的字节码

// 注册到JVM加载上ClassFileTransformer处理新增的类
inst.addTransformer(sandClassFileTransformer, true);

5.查找需要渲染的类集合

这里会调用iteratorForLoadedClasses这个方法，这个方法中执行了inst.getAllLoadedClasses()这个方法，最终会调用sandbox自己实现的类加载器SandboxClassLoader的loadClass方法。

// 查找需要渲染的类集合
final List<Class<?>> waitingReTransformClasses = classDataSource.findForReTransform(matcher);

@Override
    public List<Class<?>> findForReTransform(final Matcher matcher) {
        return find(matcher, true);
    }

    private List<Class<?>> find(final Matcher matcher,
                                final boolean isRemoveUnsupported) {
        final List<Class<?>> classes = new ArrayList<Class<?>>();
        if (null == matcher) {
            return classes;
        }

        final Iterator<Class<?>> itForLoaded = iteratorForLoadedClasses();
        while (itForLoaded.hasNext()) {
            final Class<?> clazz = itForLoaded.next();
            // 过滤掉对于JVM认为不可修改的类
            if (isRemoveUnsupported
                    && !inst.isModifiableClass(clazz)) {
                // logger.debug("remove from findForReTransform, because class:{} is unModifiable", clazz.getName());
                continue;
            }
            try {
                if (isRemoveUnsupported) {
                    if (new UnsupportedMatcher(clazz.getClassLoader(), isEnableUnsafe)
                            .and(matcher)
                            .matching(ClassStructureFactory.createClassStructure(clazz))
                            .isMatched()) {
                        classes.add(clazz);
                    }
                } else {
                    if (matcher.matching(ClassStructureFactory.createClassStructure(clazz)).isMatched()) {
                        classes.add(clazz);
                    }
                }

            } catch (Throwable cause) {
                // 在这里可能会遇到非常坑爹的模块卸载错误
                // 当一个URLClassLoader被动态关闭之后，但JVM已经加载的类并不知情（因为没有GC）
                // 所以当尝试获取这个类更多详细信息的时候会引起关联类的ClassNotFoundException等未知的错误（取决于底层ClassLoader的实现）
                // 这里没有办法穷举出所有的异常情况，所以catch Throwable来完成异常容灾处理
                // 当解析类出现异常的时候，直接简单粗暴的认为根本没有这个类就好了
                logger.debug("remove from findForReTransform, because loading class:{} occur an exception", clazz.getName(), cause);
            }
        }
        return classes;
    }
    
    @Override
    public Iterator<Class<?>> iteratorForLoadedClasses() {
        return new Iterator<Class<?>>() {

            final Class<?>[] loaded = inst.getAllLoadedClasses();
            int pos = 0;

            @Override
            public boolean hasNext() {
                return pos < loaded.length;
            }

            @Override
            public Class<?> next() {
                return loaded[pos++];
            }

            @Override
            public void remove() {
                throw new UnsupportedOperationException();
            }

        };
    }

6.调用reTransformClasses方法

// 应用JVM
reTransformClasses(watchId, waitingReTransformClasses, progress);

//reTransformClasses 中重要步骤
//转换待转换的类
inst.retransformClasses(waitingReTransformClass);

7.到这一步我们来看一下调用路径

8.我们看到经过一系列调用，最终会执行SandboxClassFileTransformer的transform方法。

这里会调用SandboxClassFileTransformer 实现ClassFileTransformer接口的transform方法。
这个方法主要实现过滤sandbox相关的类和增强符合条件的字节码文件。

 @Override
    public byte[] transform(final ClassLoader loader,
                            final String internalClassName,
                            final Class<?> classBeingRedefined,
                            final ProtectionDomain protectionDomain,
                            final byte[] srcByteCodeArray) {

        try {

            // 这里过滤掉Sandbox所需要的类，防止ClassCircularityError的发生
            if (null != internalClassName
                    && internalClassName.startsWith("com/alibaba/jvm/sandbox/")) {
                return null;
            }

            // 这里过滤掉来自SandboxClassLoader的类，防止ClassCircularityError的发生
            if (loader == SandboxClassFileTransformer.class.getClassLoader()) {
                return null;
            }

            // 过滤掉来自ModuleJarClassLoader加载的类
            if (loader instanceof ModuleJarClassLoader) {
                return null;
            }

            return _transform(
                    loader,
                    internalClassName,
                    classBeingRedefined,
                    srcByteCodeArray
            );


        } catch (Throwable cause) {
            logger.warn("sandbox transform {} in loader={}; failed, module={} at watch={}, will ignore this transform.",
                    internalClassName,
                    loader,
                    uniqueId,
                    watchId,
                    cause
            );
            return null;
        }
    }

    private byte[] _transform(final ClassLoader loader,
                              final String internalClassName,
                              final Class<?> classBeingRedefined,
                              final byte[] srcByteCodeArray) {
        // 如果未开启unsafe开关，是不允许增强来自BootStrapClassLoader的类
        if (!isEnableUnsafe
                && null == loader) {
            logger.debug("transform ignore {}, class from bootstrap but unsafe.enable=false.", internalClassName);
            return null;
        }

        final ClassStructure classStructure = getClassStructure(loader, classBeingRedefined, srcByteCodeArray);
        final MatchingResult matchingResult = new UnsupportedMatcher(loader, isEnableUnsafe).and(matcher).matching(classStructure);
        final Set<String> behaviorSignCodes = matchingResult.getBehaviorSignCodes();

        // 如果一个行为都没匹配上也不用继续了
        if (!matchingResult.isMatched()) {
            logger.debug("transform ignore {}, no behaviors matched in loader={}", internalClassName, loader);
            return null;
        }

        // 开始进行类匹配
        try {
            // 类增强
            final byte[] toByteCodeArray = new EventEnhancer().toByteCodeArray(
                    loader,
                    srcByteCodeArray,
                    behaviorSignCodes,
                    namespace,
                    listenerId,
                    eventTypeArray
            );
            if (srcByteCodeArray == toByteCodeArray) {
                logger.debug("transform ignore {}, nothing changed in loader={}", internalClassName, loader);
                return null;
            }

            // statistic affect
            affectStatistic.statisticAffect(loader, internalClassName, behaviorSignCodes);

            logger.info("transform {} finished, by module={} in loader={}", internalClassName, uniqueId, loader);
            return toByteCodeArray;
        } catch (Throwable cause) {
            logger.warn("transform {} failed, by module={} in loader={}", internalClassName, uniqueId, loader, cause);
            return null;
        }
    }

9.经过一系列的过滤逻辑，最终会通过EventEnhancer对符合条件对类进行字节码的修改，这里也是jvm-sandbox的核心能力。

// 类增强
            final byte[] toByteCodeArray = new EventEnhancer().toByteCodeArray(
                    loader,
                    srcByteCodeArray,
                    behaviorSignCodes,
                    namespace,
                    listenerId,
                    eventTypeArray
            );
            

10.asm操作字节码
asm扫盲参考

接下来我们看jvm-sandbox是如何实现字节码修改的。

ClassReader读取字节码数据。

final ClassReader cr = new ClassReader(byteCodeArray);

ClassWriter 继承 ClassVisitor 抽象类，负责将对象化的 class 文件内容重构成一个二进制格式的 class 字节码文件。

final ClassWriter cw = createClassWriter(targetClassLoader, cr);

映射Java对象为对象ID(JVM唯一)

final int targetClassLoaderObjectID = ObjectIDs.instance.identity(targetClassLoader);

调用ClassReader的accept方法，接收一个实现了抽象类 ClassVisitor的EventWeaver（方法事件编织者）对象实例作为参数，EventWeaver对象实现了ClassVisitor 的各个visitxxxx方法。

cr.accept(
                new EventWeaver(
                        ASM7, cw, namespace, listenerId,
                        targetClassLoaderObjectID,
                        cr.getClassName(),
                        signCodes,
                        eventTypeArray
                ),
                EXPAND_FRAMES
        );

最终得到的cw.toByteArray() 即是我们重新transform之后的字节码。