arthas源码分析

作者: 相远相连 | 来源:发表于2019-02-12 21:09 被阅读1804次

arthas简介

arthas 是Alibaba开源的Java诊断工具，基于jvm Agent方式，使用Instrumentation方式修改字节码方式以及使用java.lang.management包提供的管理接口的方式进行java应用诊断。详细的介绍可以参考官方文档。
官方文档地址：https://alibaba.github.io/arthas/
GitHub地址：https://github.com/alibaba/arthas/
本文主要分析arthas源码，主要分成下面几个部分：

arthas组成模块
arthas服务端代码分析
arthas客户端代码分析

arthas组成模块

arthas有多个模块组成，如下图所示：

arthas模块图.png

arthas-boot.jar和as.sh模块功能类似，分别使用java和shell脚本，下载对应的jar包，并生成服务端和客户端的启动命令，然后启动客户端和服务端。服务端最终生成的启动命令如下：

${JAVA_HOME}"/bin/java \
     ${opts}  \
     -jar "${arthas_lib_dir}/arthas-core.jar" \
         -pid ${TARGET_PID} \             要注入的进程id
         -target-ip ${TARGET_IP} \       服务器ip地址
         -telnet-port ${TELNET_PORT} \  服务器telnet服务端口号
         -http-port ${HTTP_PORT} \      websocket服务端口号
         -core "${arthas_lib_dir}/arthas-core.jar" \      arthas-core目录
         -agent "${arthas_lib_dir}/arthas-agent.jar"    arthas-agent目录

arthas-core.jar是服务端程序的启动入口类，会调用virtualMachine#attach到目标进程，并加载arthas-agent.jar作为agent jar包。
arthas-agent.jar既可以使用premain方式（在目标进程启动之前，通过-agent参数静态指定），也可以通过agentmain方式（在进程启动之后attach上去）。arthas-agent会使用自定义的classloader(ArthasClassLoader)加载arthas-core.jar里面的com.taobao.arthas.core.config.Configure类以及com.taobao.arthas.core.server.ArthasBootstrap。同时程序运行的时候会使用arthas-spy.jar。
arthas-spy.jar里面只包含Spy类，目的是为了将Spy类使用BootstrapClassLoader来加载，从而使目标进程的java应用可以访问Spy类。通过ASM修改字节码，可以将Spy类的方法ON_BEFORE_METHOD， ON_RETURN_METHOD等编织到目标类里面。Spy类你可以简单理解为类似spring aop的Advice，有前置方法，后置方法等。
arthas-client.jar是客户端程序，用来连接arthas-core.jar启动的服务端代码，使用telnet方式。一般由arthas-boot.jar和as.sh来负责启动。

arthas服务端代码分析

前置准备

看服务端启动命令可以知道从 arthas-core.jar开始启动，arthas-core的pom.xml文件里面指定了mainClass为com.taobao.arthas.core.Arthas，使得程序启动的时候从该类的main方法开始运行。Arthas源码如下：

public class Arthas {

    private Arthas(String[] args) throws Exception {
        attachAgent(parse(args));
    }

    private Configure parse(String[] args) {
        // 省略非关键代码，解析启动参数作为配置，并填充到configure对象里面
        return configure;
    }

    private void attachAgent(Configure configure) throws Exception {
           // 省略非关键代码，attach到目标进程
          virtualMachine = VirtualMachine.attach("" + configure.getJavaPid());
          virtualMachine.loadAgent(configure.getArthasAgent(),
                            configure.getArthasCore() + ";" + configure.toString());
    }


    public static void main(String[] args) {
            new Arthas(args);
    }
}

Arthas首先解析入参，生成com.taobao.arthas.core.config.Configure类，包含了相关配置信息
使用jdk-tools里面的VirtualMachine.loadAgent，其中第一个参数为agent路径，第二个参数向jar包中的agentmain()方法传递参数（此处为agent-core.jar包路径和config序列化之后的字符串），加载arthas-agent.jar包，并运行
arthas-agent.jar包，指定了Agent-Class为com.taobao.arthas.agent.AgentBootstrap，同时可以使用Premain的方式和目标进程同时启动

<manifestEntries>
    <Premain-Class>com.taobao.arthas.agent.AgentBootstrap</Premain-Class>
    <Agent-Class>com.taobao.arthas.agent.AgentBootstrap</Agent-Class>
</manifestEntries>

其中Premain-Class的premain和Agent-Class的agentmain都调用main方法。
main方法主要做4件事情：

找到arthas-spy.jar路径，并调用Instrumentation#appendToBootstrapClassLoaderSearch方法，使用bootstrapClassLoader来加载arthas-spy.jar里的Spy类。
arthas-agent路径传递给自定义的classloader(ArthasClassloader)，用来隔离arthas本身的类和目标进程的类。
使用 ArthasClassloader#loadClass方法，加载com.taobao.arthas.core.advisor.AdviceWeaver类，并将里面的methodOnBegin、methodOnReturnEnd、methodOnThrowingEnd等方法取出赋值给Spy类对应的方法。同时Spy类里面的方法又会通过ASM字节码增强的方式，编织到目标代码的方法里面。使得Spy 间谍类可以关联由AppClassLoader加载的目标进程的业务类和ArthasClassloader加载的arthas类，因此Spy类可以看做两者之间的桥梁。根据classloader双亲委派特性，子classloader可以访问父classloader加载的类。源码如下：

    private static ClassLoader getClassLoader(Instrumentation inst, File spyJarFile, File agentJarFile) throws Throwable {
        // 将Spy添加到BootstrapClassLoader
        inst.appendToBootstrapClassLoaderSearch(new JarFile(spyJarFile));

        // 构造自定义的类加载器ArthasClassloader，尽量减少Arthas对现有工程的侵蚀
        return loadOrDefineClassLoader(agentJarFile);
    }

    private static void initSpy(ClassLoader classLoader) throws ClassNotFoundException, NoSuchMethodException {
        // 该classLoader为ArthasClassloader
        Class<?> adviceWeaverClass = classLoader.loadClass(ADVICEWEAVER);
        Method onBefore = adviceWeaverClass.getMethod(ON_BEFORE, int.class, ClassLoader.class, String.class,
                String.class, String.class, Object.class, Object[].class);
        Method onReturn = adviceWeaverClass.getMethod(ON_RETURN, Object.class);
        Method onThrows = adviceWeaverClass.getMethod(ON_THROWS, Throwable.class);
        Method beforeInvoke = adviceWeaverClass.getMethod(BEFORE_INVOKE, int.class, String.class, String.class, String.class);
        Method afterInvoke = adviceWeaverClass.getMethod(AFTER_INVOKE, int.class, String.class, String.class, String.class);
        Method throwInvoke = adviceWeaverClass.getMethod(THROW_INVOKE, int.class, String.class, String.class, String.class);
        Method reset = AgentBootstrap.class.getMethod(RESET);
        Spy.initForAgentLauncher(classLoader, onBefore, onReturn, onThrows, beforeInvoke, afterInvoke, throwInvoke, reset);
    }

classloader关系如下：

+-BootstrapClassLoader                                                                                                                                                                               
+-sun.misc.Launcher$ExtClassLoader@7bf2dede                                                                                                                                                          
  +-com.taobao.arthas.agent.ArthasClassloader@51a10fc8                                                                                                                                               
  +-sun.misc.Launcher$AppClassLoader@18b4aac2

异步调用bind方法，该方法最终启动server监听线程，监听客户端的连接，包括telnet和websocket两种通信方式。源码如下：

    Thread bindingThread = new Thread() {
        @Override
        public void run() {
            try {
                bind(inst, agentLoader, agentArgs);
            } catch (Throwable throwable) {
                throwable.printStackTrace(ps);
            }
        }
    };

    private static void bind(Instrumentation inst, ClassLoader agentLoader, String args) throws Throwable {
            /**
            * <pre>
            * Configure configure = Configure.toConfigure(args);
            * int javaPid = configure.getJavaPid();
            * ArthasBootstrap bootstrap = ArthasBootstrap.getInstance(javaPid, inst);
            * </pre>
            */
            Class<?> classOfConfigure = agentLoader.loadClass(ARTHAS_CONFIGURE);
            Object configure = classOfConfigure.getMethod(TO_CONFIGURE, String.class).invoke(null, args);
            int javaPid = (Integer) classOfConfigure.getMethod(GET_JAVA_PID).invoke(configure);
            Class<?> bootstrapClass = agentLoader.loadClass(ARTHAS_BOOTSTRAP);
            Object bootstrap = bootstrapClass.getMethod(GET_INSTANCE, int.class, Instrumentation.class).invoke(null, javaPid, inst);
            boolean isBind = (Boolean) bootstrapClass.getMethod(IS_BIND).invoke(bootstrap);
            if (!isBind) {
                try {
                    ps.println("Arthas start to bind...");
                    bootstrapClass.getMethod(BIND, classOfConfigure).invoke(bootstrap, configure);
                    ps.println("Arthas server bind success.");
                    return;
                } catch (Exception e) {
                    ps.println("Arthas server port binding failed! Please check $HOME/logs/arthas/arthas.log for more details.");
                    throw e;
                }
            }
            ps.println("Arthas server already bind.");
        }

主要做两件事情：

使用ArthasClassloader加载com.taobao.arthas.core.config.Configure类(位于arthas-core.jar)，并将传递过来的序列化之后的config，反序列化成对应的Configure对象。
使用ArthasClassloader加载com.taobao.arthas.core.server.ArthasBootstrap类（位于arthas-core.jar），并调用bind方法。

启动服务器，并监听客户端请求

下面重点看下com.taobao.arthas.core.server.ArthasBootstrap#bind方法

    /**
     * Bootstrap arthas server
     *
     * @param configure 配置信息
     * @throws IOException 服务器启动失败
     */
    public void bind(Configure configure) throws Throwable {

        long start = System.currentTimeMillis();

        if (!isBindRef.compareAndSet(false, true)) {
            throw new IllegalStateException("already bind");
        }

        try {
            ShellServerOptions options = new ShellServerOptions()
                            .setInstrumentation(instrumentation)
                            .setPid(pid)
                            .setSessionTimeout(configure.getSessionTimeout() * 1000);
            shellServer = new ShellServerImpl(options, this);
            BuiltinCommandPack builtinCommands = new BuiltinCommandPack();
            List<CommandResolver> resolvers = new ArrayList<CommandResolver>();
            resolvers.add(builtinCommands);
            // TODO: discover user provided command resolver
            if (configure.getTelnetPort() > 0) {
                // telnet方式的server
                shellServer.registerTermServer(new TelnetTermServer(configure.getIp(), configure.getTelnetPort(),
                                options.getConnectionTimeout()));
            } else {
                logger.info("telnet port is {}, skip bind telnet server.", configure.getTelnetPort());
            }
            if (configure.getHttpPort() > 0) {
                // websocket方式的server
                shellServer.registerTermServer(new HttpTermServer(configure.getIp(), configure.getHttpPort(),
                                options.getConnectionTimeout()));
            } else {
                logger.info("http port is {}, skip bind http server.", configure.getHttpPort());
            }

            for (CommandResolver resolver : resolvers) {
                shellServer.registerCommandResolver(resolver);
            }

            shellServer.listen(new BindHandler(isBindRef));

            logger.info("as-server listening on network={};telnet={};http={};timeout={};", configure.getIp(),
                    configure.getTelnetPort(), configure.getHttpPort(), options.getConnectionTimeout());
            // 异步回报启动次数
            UserStatUtil.arthasStart();

            logger.info("as-server started in {} ms", System.currentTimeMillis() - start );
        } catch (Throwable e) {
            logger.error(null, "Error during bind to port " + configure.getTelnetPort(), e);
            if (shellServer != null) {
                shellServer.close();
            }
            throw e;
        }
    }

可以看到有两种类型的server，TelnetTermServer和HttpTermServer。同时会在BuiltinCommandPack里添加所有的命令Command，添加命令的源码如下：

public class BuiltinCommandPack implements CommandResolver {

    private static List<Command> commands = new ArrayList<Command>();

    static {
        initCommands();
    }

    @Override
    public List<Command> commands() {
        return commands;
    }

    private static void initCommands() {
        commands.add(Command.create(HelpCommand.class));
        commands.add(Command.create(KeymapCommand.class));
        commands.add(Command.create(SearchClassCommand.class));
        commands.add(Command.create(SearchMethodCommand.class));
        commands.add(Command.create(ClassLoaderCommand.class));
        commands.add(Command.create(JadCommand.class));
        commands.add(Command.create(GetStaticCommand.class));
        commands.add(Command.create(MonitorCommand.class));
        commands.add(Command.create(StackCommand.class));
        commands.add(Command.create(ThreadCommand.class));
        commands.add(Command.create(TraceCommand.class));
        commands.add(Command.create(WatchCommand.class));
        commands.add(Command.create(TimeTunnelCommand.class));
        commands.add(Command.create(JvmCommand.class));
        // commands.add(Command.create(GroovyScriptCommand.class));
        commands.add(Command.create(OgnlCommand.class));
        commands.add(Command.create(DashboardCommand.class));
        commands.add(Command.create(DumpClassCommand.class));
        commands.add(Command.create(JulyCommand.class));
        commands.add(Command.create(ThanksCommand.class));
        commands.add(Command.create(OptionsCommand.class));
        commands.add(Command.create(ClsCommand.class));
        commands.add(Command.create(ResetCommand.class));
        commands.add(Command.create(VersionCommand.class));
        commands.add(Command.create(ShutdownCommand.class));
        commands.add(Command.create(SessionCommand.class));
        commands.add(Command.create(SystemPropertyCommand.class));
        commands.add(Command.create(SystemEnvCommand.class));
        commands.add(Command.create(RedefineCommand.class));
        commands.add(Command.create(HistoryCommand.class));
    }
}

调用shellServer.registerTermServer，shellServer.registerTermServer，shellServer.registerCommandResolve 注册到ShellServer里，ShellServer是整个服务端的门面类，调用listen方法启动ShellServer。
ShellServer会使用一系列的类，细节比较复杂，可以见下面的类图。

Arthas-服务端类图.png
ShellServer#listen会调用所有注册的TermServer的listen方法，比如TelnetTermServer。然后TelnetTermServer的listen方法会注册一个回调类，该回调类在有新的客户端连接时会调用TermServerTermHandler的handle方法处理。

        bootstrap = new NettyTelnetTtyBootstrap().setHost(hostIp).setPort(port);
        try {
            bootstrap.start(new Consumer<TtyConnection>() {
                @Override
                public void accept(final TtyConnection conn) {
                    termHandler.handle(new TermImpl(Helper.loadKeymap(), conn));
                }
            }).get(connectionTimeout, TimeUnit.MILLISECONDS);
            listenHandler.handle(Future.<TermServer>succeededFuture());

该方法会接着调用ShellServerImpl的handleTerm方法进行处理，ShellServerImpl的handleTerm方法会调用ShellImpl的readline方法。该方法会注册ShellLineHandler作为回调类，服务端接收到客户端发送的请求行之后，会回调ShellLineHandler的handle方法处理请求。readline方法源码如下：

    public void readline(String prompt, Handler<String> lineHandler, Handler<Completion> completionHandler) {
        if (conn.getStdinHandler() != echoHandler) {
            throw new IllegalStateException();
        }
        if (inReadline) {
            throw new IllegalStateException();
        }
        inReadline = true;
        // 注册回调类RequestHandler，该类包装了ShellLineHandler，处理逻辑还是在ShellLineHandler类里面
        readline.readline(conn, prompt, new RequestHandler(this, lineHandler), new CompletionHandler(completionHandler, session));
    }

处理客户端请求

ShellLineHandler的handle方法会根据不同的请求命令执行不同的逻辑：

如果是exit,logout,quit, jobs,fg,bg,kill等直接执行。
如果是其他的命令，则创建Job，并运行。创建Job的类图如下：

服务端-创建job类图.png

步骤比较多，就不一一细讲，总之：
创建Job时，会根据具体客户端传递的命令，找到对应的Command，并包装成Process, Process再被包装成Job。
运行Job时，反向先调用Process，再找到对应的Command，最终调用Command的process处理请求。

Command处理流程

Command主要分为两类：

不需要使用字节码增强的命令
其中JVM相关的使用 java.lang.management 提供的管理接口，来查看具体的运行时数据。比较简单，就不介绍了。
需要使用字节码增强的命令
字节码增强的命令，可以参考下图：

arthas-command相关类图.png

字节码增加的命令统一继承EnhancerCommand类，process方法里面调用enhance方法进行增强。调用Enhancer类enhance方法，该方法内部调用inst.addTransformer方法添加自定义的ClassFileTransformer，这边是Enhancer类。

Enhancer类使用AdviceWeaver(继承ClassVisitor)，用来修改类的字节码。重写了visitMethod方法，在该方法里面修改类指定的方法。visitMethod方法里面使用了AdviceAdapter（继承了MethodVisitor类），在onMethodEnter方法, onMethodExit方法中，把Spy类对应的方法（ON_BEFORE_METHOD， ON_RETURN_METHOD， ON_THROWS_METHOD等）编织到目标类的方法对应的位置。

在前面Spy初始化的时候可以看到，这几个方法其实指向的是AdviceWeaver类的methodOnBegin， methodOnReturnEnd等。在这些方法里面都会根据adviceId查找对应的AdviceListener，并调用AdviceListener的对应的方法，比如before,afterReturning, afterThrowing。

通过这种方式，可以实现不同的Command使用不同的AdviceListener，从而实现不同的处理逻辑。下面找几个常用的AdviceListener介绍下:

StackAdviceListener
在方法执行前，记录堆栈和方法的耗时。
WatchAdviceListener
满足条件时打印打印参数或者结果，条件表达式使用Ognl语法。
TraceAdviceListener
在每个方法前后都记录，并维护一个调用树结构。

arthas客户端代码分析

客户端代码在arthas-client模块里面，入口类是com.taobao.arthas.client.TelnetConsole。主要使用apache commons-net jar进行telnet连接，关键的代码有下面几步：

构造TelnetClient对象，并初始化
构造ConsoleReader对象，并初始化
调用IOUtil.readWrite(telnet.getInputStream(), telnet.getOutputStream(), System.in, consoleReader.getOutput())处理各个流，一共有四个流：

telnet.getInputStream()
telnet.getOutputStream()
System.in
consoleReader.getOutput()

请求时：从本地System.in读取，发送到 telnet.getOutputStream()，即发送给远程服务端。
响应时：从telnet.getInputStream()读取远程服务端发送过来的响应，并传递给 consoleReader.getOutput()，即在本地控制台输出。

arthas源码分析

arthas简介

arthas组成模块

arthas服务端代码分析

前置准备

启动服务器，并监听客户端请求

处理客户端请求

Command处理流程

arthas客户端代码分析

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

jvm

技术杂谈

中间件研究