• spring boot应用启动原理分析
• spring boot executable jar/war 原理
• 深入Spring Boot：ClassLoader的继承关系和影响
• 深入Spring Boot：Spring Context的继承关系和影响
• 深入Spring Boot：实现对Fat Jar jsp的支持
• 深入Spring Boot：快速集成Dubbo + Hystrix
• 正确实现用spring扫描自定义的annotation
• 深入Spring Boot：编写兼容Spring Boot1和Spring Boot2的Starter

排查问题

• 深入JVM分析spring-boot应用hibernate-validator NoClassDefFoundError
• 深入Spring Boot：那些注入不了的Spring占位符（${}表达式）
• 深入Spring Boot：怎样排查 java.lang.ArrayStoreException
• 深入Spring Boot：排查 Cannot determine embedded database driver class for database type NONE
• 深入Spring Boot：排查expected single matching bean but found 2的异常
• 深入Spring Boot：排查@Transactional引起的NullPointerException
• 深入Spring Boot：显式配置 @EnableWebMvc 导致静态资源访问失败
• 深入Spring Boot：利用Arthas排查NoSuchMethodError
• Arthas实践–快速排查Spring Boot应用404/401问题
• Alibaba Arthas实践–获取到Spring Context，然后为所欲为
• Alibaba Arthas实践–是哪个Controller处理了请求？

Arthas是Alibaba开源的Java诊断工具，深受开发者喜爱。

• Github： https://github.com/alibaba/arthas
• 文档：https://alibaba.github.io/arthas

Arthas 3.1.5版本带来下面全新的特性：

• 开箱即用的Profiler/火焰图功能
• grep命令支持更丰富的选项
• monitor/tt/trace等命令提供更精确的时间统计
• telnet/http协议共用3658端口

Profiler/Flame Graph/火焰图

火焰图的威名相信大家都有所耳闻，但可能因为使用比较复杂，所以望而止步。

在新版本的Arthas里集成了async-profiler，使用profiler命令就可以很方便地生成火焰图，并且可以在浏览器里直接查看。

• profiler命令wiki: https://alibaba.github.io/arthas/profiler.html

profiler 命令基本运行结构是 profiler action [actionArg]。 下面介绍如何使用。

启动profiler

1
2

$ profiler start
Started [cpu] profiling

默认情况下，生成的是cpu的火焰图，即event为cpu。可以用--event参数来指定。

获取已采集的sample的数量

1
2

$ profiler getSamples
23

查看profiler状态

1
2

$ profiler status
[cpu] profiling is running for 4 seconds

可以查看当前profiler在采样哪种event和采样时间。

生成svg格式结果

1
2
3

$ profiler stop
profiler output file: /tmp/demo/arthas-output/20191125-135546.svg
OK

默认情况下，生成的结果保存到应用的工作目录下的arthas-output目录里。

通过浏览器查看arthas-output下面的profiler结果

默认情况下，arthas使用3658端口，则可以打开： http://localhost:3658/arthas-output/ 查看到arthas-output目录下面的profiler结果：

点击可以查看具体的结果：

如果是chrome浏览器，可能需要多次刷新。

grep命令支持更丰富的选项

标准的linux grep命令支持丰富的选项，可以很方便地定位结果的上下文等。

新版本的grep命令支持更多标准的选项，下面是一些例子:

1
2
3
4
5
6

sysprop | grep java
sysprop | grep java -n
sysenv | grep -v JAVA
sysenv | grep -e "(?i)(JAVA|sun)" -m 3  -C 2
sysenv | grep JAVA -A2 -B3
thread | grep -m 10 -e  "TIMED_WAITING|WAITING"

感谢社区里 @qxo 的贡献。

telnet/http协议共用3658端口

默认情况下，Arthas的Telnet端口是3658，HTTP端口是8563，这个常常让用户迷惑。在新版本里，在3658端口同时支持Telnet/HTTP协议。

在浏览器里访问 http://localhost:3658/ 也可以访问到Web Console了。

在后续的版本里，考虑默认只侦听 3658端口，减少用户的配置项。

monitor/tt/trace等命令提供更精确的时间统计

以前Arthas被诟病比较多的一个问题是，monitor/tt/trace等命令时间统计误差大。因为以前只使用了一个int来保存时间，所以不精确。

在新版本里，改用一个高效的stack来保存数据，时间的准确度大大提升，欢迎大家反馈效果。

感谢社区里 @huangjIT 的贡献。

总结

总之，3.1.5版本的Arthas引入了开箱即用的Profiler/火焰图功能，欢迎大家使用反馈。

• Release Note: https://github.com/alibaba/arthas/releases/tag/arthas-all-3.1.5
• 火焰图的一个参考文章：https://openresty.org/posts/dynamic-tracing/

最近看到一个很流行的标题，《开源XX年，star XXX，我是如何坚持的》。

看到这样的标题，忽然发觉Arthas从2018年9月开源以来，刚好一年了，正好在这个秋高气爽的时节做下总结和回顾。

Arthas是Alibaba开源的Java诊断工具，深受开发者喜爱。

• Github： https://github.com/alibaba/arthas
• 文档：https://alibaba.github.io/arthas

回顾Arthas Star数的历史，一直保持快速增长，目前已经突破16K。

感谢用户的支持，既是压力也是动力。在过去开源的一年里，Arthas发布了7个Release版本，我们一直坚持三点：

• 持续改进易用性
• 持续增加好用的命令
• 从开源社区中获取力量，回报社区

持续改进易用性

Arthas一直把易用性放在第一位，在开源之后，我们做了下面的改进：

• 开发arthas boot，支持Windows/Linux/Mac统一体验
• 丝滑的自动补全，参考了jshell的体验
• 高效的历史命令匹配，Up/Down直达
• 改进类搜索匹配功能，更好支持lambda和内部类
• 完善重定向机制
• 支持JDK 9/10/11
• 支持Docker
• 支持rpm/deb包安装

尽管我们在易用性下了很大的功夫，但是发现很多时候用户比较难入门，因此，我们参考了k8s的 Interactive Tutorial，推出了Arthas的在线教程：

• Arthas基础教程
• Arthas进阶教程

通过基础教程，可以在交互终端里一步步入门，通过进阶教程可以深入理解Arthas排查问题的案例。

另外，为了方便用户大规模部署，我们实现了tunnel server和用户数据回报功能：

• 增加tunnel server，统一管理Agent连接
• 增加用户数据回报功能，方便做安全管控

持续增加好用的命令

Arthas号称是Java应用诊断利器，那么我们自己要对得起这个口号。在开源之后，Arthas持续增加了10多个命令。

• ognl 命令任意代码执行
• mc 线上内存编译器
• redefine 命令线上热更新代码
• logger 命令一键查看应用里的所有logger配置
• sysprop 查看更新System Properties
• sysenv 查看环境变量
• vmoption 查看更新VM option
• logger 查看logger配置，更新level
• mbean 查看JMX信息
• heapdump 堆内存快照

下面重点介绍两个功能。

jad/mc/redefine 一条龙热更新线上代码

以 Arthas在线教程 里的UserController为例：

1. 使用jad反编译代码

   1	jad --source-only com.example.demo.arthas.user.UserController > /tmp/UserController.java

2. 使用vim编译代码

   当 user id 小于1时，也正常返回，不抛出异常：

   1 2 3 4 5 6 7 8 9 10 11

   @GetMapping("/user/{id}") public User findUserById(@PathVariable Integer id) { logger.info("id: {}" , id); if (id != null && id < 1) { return new User(id, "name" + id); // throw new IllegalArgumentException("id < 1"); } else { return new User(id, "name" + id); } }

3. 使用mc命令编译修改后的UserController.java

   1 2 3 4

   $ mc /tmp/UserController.java -d /tmp Memory compiler output: /tmp/com/example/demo/arthas/user/UserController.class Affect(row-cnt:1) cost in 346 ms

4. 使用redefine命令，因为可以热更新代码

   1 2	$ redefine /tmp/com/example/demo/arthas/user/UserController.class redefine success, size: 1

通过logger命令查看配置，修改level

在网站压力大的时候（比如双11），有个缓解措施就是把应用的日志level修改为ERROR。 那么有两个问题：

• 复杂应用的日志系统可能会有多个，那么哪个日志系统配置真正生效了？
• 怎样在线上动态修改logger的level？

通过logger命令，可以查看应用里logger的详细配置信息，比如FileAppender输出的文件，AsyncAppender是否blocking。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

[arthas@2062]$ logger
 name                                   ROOT
 class                                  ch.qos.logback.classic.Logger
 classLoader                            sun.misc.Launcher$AppClassLoader@2a139a55
 classLoaderHash                        2a139a55
 level                                  INFO
 effectiveLevel                         INFO
 additivity                             true
 codeSource                             file:/Users/hengyunabc/.m2/repository/ch/qos/logback/logback-classic/1.2.3/logback-classic-1.2.3.jar
 appenders                              name            CONSOLE
                                        class           ch.qos.logback.core.ConsoleAppender
                                        classLoader     sun.misc.Launcher$AppClassLoader@2a139a55
                                        classLoaderHash 2a139a55
                                        target          System.out
                                        name            APPLICATION
                                        class           ch.qos.logback.core.rolling.RollingFileAppender
                                        classLoader     sun.misc.Launcher$AppClassLoader@2a139a55
                                        classLoaderHash 2a139a55
                                        file            app.log
                                        name            ASYNC
                                        class           ch.qos.logback.classic.AsyncAppender
                                        classLoader     sun.misc.Launcher$AppClassLoader@2a139a55
                                        classLoaderHash 2a139a55
                                        blocking        false
                                        appenderRef     [APPLICATION]

也可以在线修改logger的level：

1
2

[arthas@2062]$ logger --name ROOT --level debug
update logger level success.

从开源社区中获取力量，回报社区

感谢67位Contributors

Arthas开源以来，一共有67位 Contributors，感谢他们贡献的改进：

社区提交了一系列的改进，下面列出一些点（不完整）：

• 翻译了大部分英文文档的
• trace命令支持行号
• 打包格式支持rpm/deb
• 改进命令行提示符为 arthas@pid
• 改进对windows的支持
• 增加mbean命令
• 改进webconsole的体验

另外，有83个公司/组织登记了他们的使用信息，欢迎更多的用户来登记：

洐生项目

基于Arthas，还产生了一些洐生项目，下面是其中两个：

• Bistoury: 去哪儿网开源的集成了Arthas的项目
• arthas-mvel: 一个使用MVEL脚本的fork

用户案例分享

广大用户在使用Arthas排查问题过程中，分享了很多排查过程和心得，欢迎大家来分享。

回馈开源

Arthas本身使用了很多开源项目的代码，在开源过程中，我们给netty, ognl, cfr等都贡献了改进代码，回馈上游。

后记

在做Arthas宣传小册子时，Arthas的宣传语是：

“赠人玫瑰之手，经久犹有余香”

希望Arthas未来能帮助到更多的用户解决问题，也希望广大的开发者对Arthas提出更多的改进和建议。

最后是抽奖环节，大家可以转发文章，在公众号后台留言自己和Arthas的故事，或者给Arthas提出建议，奖品是Arthas的卫衣一件：

公众号

欢迎关注横云断岭的专栏，专注Java，Spring Boot，Arthas，Dubbo。

Arthas是Alibaba开源的Java诊断工具，深受开发者喜爱。

• Github： https://github.com/alibaba/arthas
• 文档：https://alibaba.github.io/arthas

Arthas 3.1.2版本持续增加新特性，下面重点介绍：

• logger/heapdump/vmoption/stop命令
• 通过tunnel server连接不同网络的arthas，方便统一管控
• 易用性持续提升：提示符修改为arthas@pid形式，支持ctrl + k清屏快捷键

logger/heapdump/vmoption/stop命令

logger命令

查看logger信息，更新logger level

• https://alibaba.github.io/arthas/logger.html

查看所有logger信息

以下面的logback.xml为例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <appender name="APPLICATION" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>app.log</file>
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <fileNamePattern>mylog-%d{yyyy-MM-dd}.%i.txt</fileNamePattern>
            <maxFileSize>100MB</maxFileSize>
            <maxHistory>60</maxHistory>
            <totalSizeCap>2GB</totalSizeCap>
        </rollingPolicy>
        <encoder>
            <pattern>%logger{35} - %msg%n</pattern>
        </encoder>
    </appender>

    <appender name="ASYNC" class="ch.qos.logback.classic.AsyncAppender">
        <appender-ref ref="APPLICATION" />
    </appender>

    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%-4relative [%thread] %-5level %logger{35} - %msg %n
            </pattern>
            <charset>utf8</charset>
        </encoder>
    </appender>

    <root level="INFO">
        <appender-ref ref="CONSOLE" />
        <appender-ref ref="ASYNC" />
    </root>
</configuration>

使用logger命令打印的结果是：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

[arthas@2062]$ logger
 name                                   ROOT
 class                                  ch.qos.logback.classic.Logger
 classLoader                            sun.misc.Launcher$AppClassLoader@2a139a55
 classLoaderHash                        2a139a55
 level                                  INFO
 effectiveLevel                         INFO
 additivity                             true
 codeSource                             file:/Users/hengyunabc/.m2/repository/ch/qos/logback/logback-classic/1.2.3/logback-classic-1.2.3.jar
 appenders                              name            CONSOLE
                                        class           ch.qos.logback.core.ConsoleAppender
                                        classLoader     sun.misc.Launcher$AppClassLoader@2a139a55
                                        classLoaderHash 2a139a55
                                        target          System.out
                                        name            APPLICATION
                                        class           ch.qos.logback.core.rolling.RollingFileAppender
                                        classLoader     sun.misc.Launcher$AppClassLoader@2a139a55
                                        classLoaderHash 2a139a55
                                        file            app.log
                                        name            ASYNC
                                        class           ch.qos.logback.classic.AsyncAppender
                                        classLoader     sun.misc.Launcher$AppClassLoader@2a139a55
                                        classLoaderHash 2a139a55
                                        appenderRef     [APPLICATION]

从appenders的信息里，可以看到

• CONSOLE logger的target是System.out
• APPLICATION logger是RollingFileAppender，它的file是app.log
• ASYNC它的appenderRef是APPLICATION，即异步输出到文件里

查看指定名字的logger信息

1
2
3
4
5
6
7
8
9

[arthas@2062]$ logger -n org.springframework.web
 name                                   org.springframework.web
 class                                  ch.qos.logback.classic.Logger
 classLoader                            sun.misc.Launcher$AppClassLoader@2a139a55
 classLoaderHash                        2a139a55
 level                                  null
 effectiveLevel                         INFO
 additivity                             true
 codeSource                             file:/Users/hengyunabc/.m2/repository/ch/qos/logback/logback-classic/1.2.3/logback-classic-1.2.3.jar

更新logger level

1
2

[arthas@2062]$ logger --name ROOT --level debug
update logger level success.

heapdump命令

dump java heap, 类似jmap命令的heap dump功能。

• https://alibaba.github.io/arthas/heapdump.html

dump到指定文件

1
2
3

[arthas@58205]$ heapdump /tmp/dump.hprof
Dumping heap to /tmp/dump.hprof...
Heap dump file created

只dump live对象

1
2
3

[arthas@58205]$ heapdump --live /tmp/dump.hprof
Dumping heap to /tmp/dump.hprof...
Heap dump file created

vmoption命令

查看，更新VM诊断相关的参数

• https://alibaba.github.io/arthas/vmoption.html

查看所有的option

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

[arthas@56963]$ vmoption
 KEY                    VALUE                   ORIGIN                 WRITEABLE
---------------------------------------------------------------------------------------------
 HeapDumpBeforeFullGC   false                   DEFAULT                true
 HeapDumpAfterFullGC    false                   DEFAULT                true
 HeapDumpOnOutOfMemory  false                   DEFAULT                true
 Error
 HeapDumpPath                                   DEFAULT                true
 CMSAbortablePrecleanW  100                     DEFAULT                true
 aitMillis
 CMSWaitDuration        2000                    DEFAULT                true
 CMSTriggerInterval     -1                      DEFAULT                true
 PrintGC                false                   DEFAULT                true
 PrintGCDetails         true                    MANAGEMENT             true
 PrintGCDateStamps      false                   DEFAULT                true
 PrintGCTimeStamps      false                   DEFAULT                true
 PrintGCID              false                   DEFAULT                true
 PrintClassHistogramBe  false                   DEFAULT                true
 foreFullGC
 PrintClassHistogramAf  false                   DEFAULT                true
 terFullGC
 PrintClassHistogram    false                   DEFAULT                true
 MinHeapFreeRatio       0                       DEFAULT                true
 MaxHeapFreeRatio       100                     DEFAULT                true
 PrintConcurrentLocks   false                   DEFAULT                true

查看指定的option

1
2
3
4

[arthas@56963]$ vmoption PrintGCDetails
 KEY                    VALUE                   ORIGIN                 WRITEABLE
---------------------------------------------------------------------------------------------
 PrintGCDetails         false                   MANAGEMENT             true

更新指定的option

1
2
3

[arthas@56963]$ vmoption PrintGCDetails true
Successfully updated the vm option.
PrintGCDetails=true

stop命令

之前有用户吐槽，不小心退出Arthas console之后，shutdown会关闭系统，因此增加了stop命令来退出arthas，功能和shutdown命令一致。

通过tunnel server连接不同网络的arthas

• https://alibaba.github.io/arthas/web-console.html

在新版本里，增加了arthas tunnel server的功能，用户可以通过tunnel server很方便连接不同网络里的arthas agent，适合做统一管控。

启动arthas时连接到tunnel server

在启动arthas，可以传递--tunnel-server参数，比如：

1

as.sh --tunnel-server 'ws://47.75.156.201:7777/ws'

目前47.75.156.201是一个测试服务器，用户可以自己搭建arthas tunnel server

• 如果有特殊需求，可以通过--agent-id参数里指定agentId。默认情况下，会生成随机ID。

attach成功之后，会打印出agentId，比如：

1
2
3
4
5
6
7
8
9
10
11
12
13

  ,---.  ,------. ,--------.,--.  ,--.  ,---.   ,---.
 /  O  \ |  .--. ''--.  .--'|  '--'  | /  O  \ '   .-'
|  .-.  ||  '--'.'   |  |   |  .--.  ||  .-.  |`.  `-.
|  | |  ||  |\  \    |  |   |  |  |  ||  | |  |.-'    |
`--' `--'`--' '--'   `--'   `--'  `--'`--' `--'`-----'


wiki      https://alibaba.github.io/arthas
tutorials https://alibaba.github.io/arthas/arthas-tutorials
version   3.1.2
pid       86183
time      2019-08-30 15:40:53
id        URJZ5L48RPBR2ALI5K4V

如果是启动时没有连接到 tunnel server，也可以在后续自动重连成功之后，通过 session命令来获取 agentId：

1
2
3
4
5
6
7

[arthas@86183]$ session
 Name           Value
-----------------------------------------------------
 JAVA_PID       86183
 SESSION_ID     f7273eb5-e7b0-4a00-bc5b-3fe55d741882
 AGENT_ID       URJZ5L48RPBR2ALI5K4V
 TUNNEL_SERVER  ws://47.75.156.201:7777/ws

以上面的为例，在浏览器里访问 http://47.75.156.201:8080/ ，输入 agentId，就可以连接到本机上的arthas了。

Arthas tunnel server的工作原理

1

browser <-> arthas tunnel server <-> arthas tunnel client <-> arthas agent

https://github.com/alibaba/arthas/blob/master/tunnel-server/README.md

易用性持续提升

• 提示符修改为arthas@pid形式，用户可以确定当前进程ID，避免多个进程时误操作

  1	[arthas@86183]$ help

• 增加ctrl + k清屏快捷键

总结

总之，3.1.2版本的Arthas新增加了logger/heapdump/vmoption/stop命令，增加了tunnel server，方便统一管控。另外还有一些bug修复等，可以参考

• Release Note: https://github.com/alibaba/arthas/releases/tag/3.1.2

最后，Arthas的在线教程考虑重新组织，欢迎大家参与，提出建议：

• https://github.com/alibaba/arthas/issues/847

本文介绍本人觉得最好用的bash配置技巧，一次配置，每天受益。

在bash里，最常见的搜索历史命令的办法是ctrl + r，但是这个步骤太多，比较麻烦。

下面介绍一种非常快捷的补全方式。

执行：

1
2

curl -L http://hengyunabc.github.io/bash_completion_install.sh | sh
bind -f  ~/.inputrc

这样子，先输入部分命令，再按键盘的Up/Down就可以自动补全出历史命令了。

工作原理

实际上给~/.inputrc文件添加了下面的内容：

1
2
3
4

"\e[A": history-search-backward
"\e[B": history-search-forward
set show-all-if-ambiguous on
set completion-ignore-case on

前面两行自然是绑定了快捷键，后面两行是什么意思呢？

show-all-if-ambiguous 是指tab补全时，按一次tab就会把最长匹配的自动补全。具体参考 https://stackoverflow.com/a/42193784

completion-ignore-case 是指tab补全时，忽略大小写，这点也非常方便。

注意，在修改完~/.inputrc文件，要显式执行bind -f ~/.inputrc才会生效。

题外话，在arthas里也支持了Up/Down自动补全历史命令这个特性，所以在arthas里自动补全历史命令非常的方便。

• https://github.com/alibaba/arthas

jad命令介绍

• https://alibaba.github.io/arthas/jad.html

jad即java decompiler，把JVM已加载类的字节码反编译成Java代码。比如反编译String类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

$ jad java.lang.String
 
ClassLoader:
 
Location:
 
/*
* Decompiled with CFR .
*/
package java.lang;
 
import java.io.ObjectStreamField;
...
public final class String
implements Serializable,
Comparable<String>,
CharSequence {
    private final char[] value;
    private int hash;
    private static final long serialVersionUID = -6849794470754667710L;
    private static final ObjectStreamField[] serialPersistentFields = new ObjectStreamField[0];
    public static final Comparator<String> CASE_INSENSITIVE_ORDER = new CaseInsensitiveComparator();
 
    public String(byte[] arrby, int n, int n2) {
        String.checkBounds(arrby, n, n2);
        this.value = StringCoding.decode(arrby, n, n2);
    }
...

获取到类的字节码

反编译有两部分工作：

1. 获取到字节码
2. 反编译为Java代码

那么怎么从运行的JVM里获取到字节码？

最常见的思路是，在classpaths下面查找，比如 ClassLoader.getResource("java/lang/String.class")，但是这样子查找到的字节码不一定对。比如可能有多个冲突的jar，或者有Java Agent修改了字节码。

ClassFileTransformer机制

从JDK 1.5起，有一套ClassFileTransformer的机制，Java Agent通过Instrumentation注册ClassFileTransformer，那么在类加载或者retransform时就可以回调修改字节码。

显然，在Arthas里，要增强的类是已经被加载的，所以它们的字节码都是在retransform时被修改的。
通过显式调用Instrumentation.retransformClasses(Class<?>...)可以触发回调。

Arthas里增强字节码的watch/trace/stack/tt等命令都是通过ClassFileTransformer来实现的。

ClassFileTransformer的接口如下：

1
2
3
4
5
6
7
8

public interface ClassFileTransformer {
    byte[]
    transform(  ClassLoader         loader,
                String              className,
                Class<?>            classBeingRedefined,
                ProtectionDomain    protectionDomain,
                byte[]              classfileBuffer)
        throws IllegalClassFormatException;

看到这里，读者应该猜到jad是怎么获取到字节码的了：

1. 注册一个ClassFileTransformer
2. 通过Instrumentation.retransformClasses触发回调
3. 在回调的transform函数里获取到字节码
4. 删掉注册的ClassFileTransformer

使用cfr来反编译

获取到字节码之后，怎样转换为Java代码呢？

以前大家使用比较多的反编译软件可能是jd-gui，但是它不支持JDK8的lambda语法和一些新版本JDK的特性。

后面比较成熟的反编译软件是cfr，它以前是不开源的。直到最近的0.145版本，作者终于开源了，可喜可贺。地址是

• https://github.com/leibnitz27/cfr

在Arthas jad命令里，通过调用cfr来完成反编译。

jad命令的缺陷

99%的情况下，jad命令dump下来的字节码是准确的，除了一些极端情况。

1. 因为JVM里注册的ClassFileTransformer可能有多个，那么在JVM里运行的字节码里，可能是被多个ClassFileTransformer处理过的。
2. 触发了retransformClasses之后，这些注册的ClassFileTransformer会被依次回，上一个处理的字节码传递到下一个。
   所以不能保证这些ClassFileTransformer第二次执行会返回同样的结果。
3. 有可能一些ClassFileTransformer会被删掉，触发retransformClasses之后，之前的一些修改就会丢失掉。

所以目前在Arthas里，如果开两个窗口，一个窗口执行watch/tt等命令，另一个窗口对这个类执行jad，那么可以观察到watch/tt停止了输出，实际上是因为字节码在触发了retransformClasses之后，watch/tt所做的修改丢失了。

精确获取JVM内运行的java字节码的办法

如果想精确获取到JVM内运行的Java字节码，可以使用这个dumpclass工具，它是通过sa-jdi.jar来实现的，保证dump下来的字节码是JVM内所运行的。

• https://github.com/hengyunabc/dumpclass

总结

总结jad命令的工作原理：

• 通过注册ClassFileTransformer，再触发retransformClasses来获取字节码
• 通过cfr来反编译
• ClassFileTransformer的方式来获取字节码有一定缺陷
• 通过dumpclass工具可以精确获取字节码

jad命令可以在线上快速检查运行时的代码，并且结合mc/redefine命令可以热更新代码：

• jad/mc/redefine线上热更新一条龙: http://hengyunabc.github.io/arthas-online-hotswap/

链接

• Arthas开源：https://github.com/alibaba/arthas
• dumpclass: https://github.com/hengyunabc/dumpclass
• https://docs.oracle.com/javase/8/docs/api/java/lang/instrument/ClassFileTransformer.html

最近排查一个JMX本地连接问题，记录一下。

我们的启动脚本在应用启动后，会通过JMX来动态检查应用状态，那么这里就需要动态启动JMX功能了。

动态打开Java进程的JMX端口

1. 通过下面的代码，可以动态的让目标进程加载management-agent
2. 打开JMX功能后，通过获取com.sun.management.jmxremote.localConnectorAddress的Agent Property，可以获取到JMX URL

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

public MBeanServerConnection connect(String pid) throws IOException {
    String address = attachJmx(pid);

    JMXServiceURL serviceURL = new JMXServiceURL(address);
    connector = JMXConnectorFactory.connect(serviceURL);
    return connector.getMBeanServerConnection();
}

private String attachJmx(String pid) throws IOException {
    try {
        virtualmachine = VirtualMachine.attach(pid);
    } catch (AttachNotSupportedException e) {
        throw new IOException(e);
    }
    String javaHome = virtualmachine.getSystemProperties().getProperty("java.home");
    String agentPath = javaHome + File.separator + "jre" + File.separator + "lib" + File.separator
                       + "management-agent.jar";
    File file = new File(agentPath);
    if (!file.exists()) {
        agentPath = javaHome + File.separator + "lib" + File.separator + "management-agent.jar";
        file = new File(agentPath);
        if (!file.exists()) {
            throw new IOException("Management agent not found");
        }
    }

    agentPath = file.getCanonicalPath();
    try {
        virtualmachine.loadAgent(agentPath, "com.sun.management.jmxremote");
    } catch (AgentLoadException e) {
        throw new IOException(e);
    } catch (AgentInitializationException agentinitializationexception) {
        throw new IOException(agentinitializationexception);
    }

    Properties properties = virtualmachine.getAgentProperties();
    String address = (String) properties.get("com.sun.management.jmxremote.localConnectorAddress");
    virtualmachine.detach();
    return address;
}

为什么JMX连接会失败？

在用上面的代码动态去连接目标进程时，抛出了下面的异常：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

java.rmi.ConnectException: Connection refused to host: 11.164.235.11; nested exception is:
  java.net.ConnectException: Connection refused
  at sun.rmi.transport.tcp.TCPEndpoint.newSocket(TCPEndpoint.java:619)
  at sun.rmi.transport.tcp.TCPChannel.createConnection(TCPChannel.java:216)
  at sun.rmi.transport.tcp.TCPChannel.newConnection(TCPChannel.java:202)
  at sun.rmi.server.UnicastRef.invoke(UnicastRef.java:130)
  at java.rmi.server.RemoteObjectInvocationHandler.invokeRemoteMethod(RemoteObjectInvocationHandler.java:227)
  at java.rmi.server.RemoteObjectInvocationHandler.invoke(RemoteObjectInvocationHandler.java:179)
  at com.sun.proxy.$Proxy0.newClient(Unknown Source)
  at javax.management.remote.rmi.RMIConnector.getConnection(RMIConnector.java:2430)
  at javax.management.remote.rmi.RMIConnector.connect(RMIConnector.java:308)
  at javax.management.remote.JMXConnectorFactory.connect(JMXConnectorFactory.java:270)
  at javax.management.remote.JMXConnectorFactory.connect(JMXConnectorFactory.java:229)
  at com.test.jmx.JmxLocalConnector.connect(JmxLocalConnector.java:28)
Caused by: java.net.ConnectException: Connection refused
  at java.net.PlainSocketImpl.socketConnect(Native Method)
  at java.net.AbstractPlainSocketImpl.doConnect(AbstractPlainSocketImpl.java:350)
  at java.net.AbstractPlainSocketImpl.connectToAddress(AbstractPlainSocketImpl.java:206)
  at java.net.AbstractPlainSocketImpl.connect(AbstractPlainSocketImpl.java:188)
  at java.net.SocksSocketImpl.connect(SocksSocketImpl.java:392)
  at java.net.Socket.connect(Socket.java:589)
  at java.net.Socket.connect(Socket.java:538)
  at java.net.Socket.<init>(Socket.java:434)
  at java.net.Socket.<init>(Socket.java:211)
  at sun.rmi.transport.proxy.RMIDirectSocketFactory.createSocket(RMIDirectSocketFactory.java:40)
  at sun.rmi.transport.proxy.RMIMasterSocketFactory.createSocket(RMIMasterSocketFactory.java:148)
  at sun.rmi.transport.tcp.TCPEndpoint.newSocket(TCPEndpoint.java:613)
  ... 13 more

• 检查本机IP是 11.164.234.171
• 为什么rmi连接的是一个外部的IP 11.164.235.11？

通过调试，发现management-agent加载成功了，localConnectorAddress的值是：

1

jmx:rmi://127.0.0.1/stub/rO0ABXN9AAAAAQAlamF2YXgubWFuYWdlbWVudC5yZW1vdGUucm1pLlJNSVNlcnZlcnhyABdqYXZhLmxhbmcucmVmbGVjdC5Qcm94eeEn2iDMEEPLAgABTAABaHQAJUxqYXZhL2xhbmcvcmVmbGVjdC9JbnZvY2F0aW9uSGFuZGxlcjt4cHNyAC1qYXZhLnJtaS5zZXJ2ZXIuUmVtb3RlT2JqZWN0SW52b2NhdGlvbkhhbmRsZXIAAAAAAAAAAgIAAHhyABxqYXZhLnJtaS5zZXJ2ZXIuUmVtb3RlT2JqZWN002G0kQxhMx4DAAB4cHc4AAtVbmljYXN0UmVmMgAADTExLjE2NC4yMzUuMTEAAIfoCEScYyGQodFlwEdFAAABawK/zE6AAQB4

为什么显示的是127.0.0.1，但实际连接的是11.164.235.11？是不是在连接时出的问题？

再仔细调试，发现

1. jmx是获取到stub后的字符串
2. 做base64解密，再通过ObjectInputStream解析
3. readObject得到RMIServer对象来连接的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

//javax.management.remote.rmi.RMIConnector.findRMIServer(JMXServiceURL, Map<String, Object>)

    //--------------------------------------------------------------------
    // Private stuff - RMIServer creation
    //--------------------------------------------------------------------

    private RMIServer findRMIServer(JMXServiceURL directoryURL,
            Map<String, Object> environment)
            throws NamingException, IOException {
        final boolean isIiop = RMIConnectorServer.isIiopURL(directoryURL,true);
        if (isIiop) {
            // Make sure java.naming.corba.orb is in the Map.
            environment.put(EnvHelp.DEFAULT_ORB,resolveOrb(environment));
        }

        String path = directoryURL.getURLPath();
        int end = path.indexOf(';');
        if (end < 0) end = path.length();
        if (path.startsWith("/jndi/"))
            return findRMIServerJNDI(path.substring(6,end), environment, isIiop);
        else if (path.startsWith("/stub/"))
            return findRMIServerJRMP(path.substring(6,end), environment, isIiop);
        else if (path.startsWith("/ior/")) {
            if (!IIOPHelper.isAvailable())
                throw new IOException("iiop protocol not available");
            return findRMIServerIIOP(path.substring(5,end), environment, isIiop);
        } else {
            final String msg = "URL path must begin with /jndi/ or /stub/ " +
                    "or /ior/: " + path;
            throw new MalformedURLException(msg);
        }
    }

    private RMIServer findRMIServerJRMP(String base64, Map<String, ?> env, boolean isIiop)
        throws IOException {
        // could forbid "iiop:" URL here -- but do we need to?
        final byte[] serialized;
        try {
            serialized = base64ToByteArray(base64);
        } catch (IllegalArgumentException e) {
            throw new MalformedURLException("Bad BASE64 encoding: " +
                    e.getMessage());
        }
        final ByteArrayInputStream bin = new ByteArrayInputStream(serialized);

        final ClassLoader loader = EnvHelp.resolveClientClassLoader(env);
        final ObjectInputStream oin =
                (loader == null) ?
                    new ObjectInputStream(bin) :
                    new ObjectInputStreamWithLoader(bin, loader);
        final Object stub;
        try {
            stub = oin.readObject();
        } catch (ClassNotFoundException e) {
            throw new MalformedURLException("Class not found: " + e);
        }
        return (RMIServer)stub;
    }

通过代码处理，发现

1

rO0ABXN9AAAAAQAlamF2YXgubWFuYWdlbWVudC5yZW1vdGUucm1pLlJNSVNlcnZlcnhyABdqYXZhLmxhbmcucmVmbGVjdC5Qcm94eeEn2iDMEEPLAgABTAABaHQAJUxqYXZhL2xhbmcvcmVmbGVjdC9JbnZvY2F0aW9uSGFuZGxlcjt4cHNyAC1qYXZhLnJtaS5zZXJ2ZXIuUmVtb3RlT2JqZWN0SW52b2NhdGlvbkhhbmRsZXIAAAAAAAAAAgIAAHhyABxqYXZhLnJtaS5zZXJ2ZXIuUmVtb3RlT2JqZWN002G0kQxhMx4DAAB4cHc4AAtVbmljYXN0UmVmMgAADTExLjE2NC4yMzUuMTEAAIfoCEScYyGQodFlwEdFAAABawK/zE6AAQB4

转换为了：

1

RMIServerImpl_Stub[UnicastRef2 [liveRef: [endpoint:[11.164.235.11:26449](remote),objID:[-5ddae53d:16b0887d710:-7fff, 7209064096623493021]]]]

可见RMI Server的IP的确是11.164.235.11。

那么现在问题变成了：

• 为什么JVM动态加载了management-agent，得到的JMX URL是指向外部IP的？

通过heap dump定位IP字符串

但是调试management-agent的加载过程可能会比较痛苦，于是考虑从别的地方入手。

从上面的调查里，发现management-agent启动之后，11.164.235.11这个外部IP就会出现在JVM内存里，那么考虑用heap dump的方式来定位。

通过执行heap dump，再用jvisualvm来分析。

用OQL来搜索所有包含11.164.235.11的String：

1

select s from java.lang.String s where s.toString().equals("11.164.235.11")

可以发现有好几个结果：

再依次点开，查看引用，发现其中一个引用的字段名是localHost：

因此可以猜测：是不是localHost域名解析有问题？

定位localHost域名解析问题

执行hostname命令，得到机器名，再ping一下：

1
2
3
4
5

$hostname
web-app201641.we42

$ping web-app201641.we42
PING web-app201641.we42 (11.164.235.11) 56(84) bytes of data.

发现本机被解析到11.164.235.11了，但是本机的IP是11.164.234.171：

1
2
3

$ifconfig
eth0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
        inet 11.164.234.171  netmask 255.255.255.0  broadcast 11.164.234.255

到这里，大概猜到原因了，检查下 /etc/hosts文件，果然发现有配置：

1

11.164.235.11  web-app201641.we42

把这个错误的host配置去掉之后，再执行jmx连接终于成功了。

为什么会有错误的hosts配置呢？据说是机器迁移时遗留的。

总结

动态JMX连接的工作原理：

1. 让目标VirtualMachine动态加载management-agent
2. 从Agent Properties里获取到JMX连接地址：com.sun.management.jmxremote.localConnectorAddress
3. JMX URL里带stub的字符串，实际上是base64转换为byte[]，再用ObjectInputStream转换为RMIServer
4. JMX实际上是通过RMI来连接的

排查问题的关键：

1. 定位错误连接的IP
2. heap dump
3. 用OQL从heap dump里查找IP字符串，再查看相关的引用来获取信息

链接

• ViauslVM
• Object Query Language (OQL)

Arthas是阿里巴巴开源的Java诊断利器，深受开发者喜爱。

• https://github.com/alibaba/arthas
• Arthas在线教程

之前分享了Arthas怎样排查 404/401 的问题: http://hengyunabc.github.io/arthas-spring-boot-404-401/

我们可以快速定位一个请求是被哪些Filter拦截的，或者请求最终是由哪些Servlet处理的。

但有时，我们想知道一个请求是被哪个Spring MVC Controller处理的。如果翻代码的话，会比较难找，并且不一定准确。

通过Arthas可以精确定位是哪个Controller处理请求。

Demo

还是以这个demo为例： https://github.com/hengyunabc/spring-boot-inside/tree/master/demo-404-401

启动之后，访问： http://localhost:8080/user/1 ，会返回一个user对象。那么这个请求是被哪个Controller处理的呢？

trace定位DispatcherServlet

我们先试下跟踪Servlet：

1

trace javax.servlet.Servlet *

从trace的结果可以看出来，请求最终是被DispatcherServlet#doDispatch()处理了，但是没有办法知道是哪个Controller处理。

1
2
3
4
5
6
7

`---[27.453122ms] org.springframework.web.servlet.DispatcherServlet:doDispatch()
    +---[0.005822ms] org.springframework.web.context.request.async.WebAsyncUtils:getAsyncManager() #929
    +---[0.107365ms] org.springframework.web.servlet.DispatcherServlet:checkMultipart() #936
    |   `---[0.062451ms] org.springframework.web.servlet.DispatcherServlet:checkMultipart()
    |       `---[0.016924ms] org.springframework.web.multipart.MultipartResolver:isMultipart() #1093
    +---[2.103935ms] org.springframework.web.servlet.DispatcherServlet:getHandler() #940
    |   `---[2.036042ms] org.springframework.web.servlet.DispatcherServlet:getHandler()

watch定位handler

trace结果里把调用的行号打印出来了，我们可以直接在IDE里查看代码（也可以用jad命令反编译）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

// org.springframework.web.servlet.DispatcherServlet
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
HttpServletRequest processedRequest = request;
HandlerExecutionChain mappedHandler = null;
boolean multipartRequestParsed = false;

WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

try {
ModelAndView mv = null;
Exception dispatchException = null;

try {
processedRequest = checkMultipart(request);
multipartRequestParsed = (processedRequest != request);

// Determine handler for the current request.
mappedHandler = getHandler(processedRequest);
if (mappedHandler == null || mappedHandler.getHandler() == null) {
noHandlerFound(processedRequest, response);
return;
}

• 仔细看代码，可以发现mappedHandler = getHandler(processedRequest);得到了处理请求的handler

下面用watch命令来获取getHandler函数的返回结果。

watch之后，再次访问 http://localhost:8080/user/1

1
2
3
4
5
6
7
8
9
10

$ watch org.springframework.web.servlet.DispatcherServlet getHandler returnObj
Press Q or Ctrl+C to abort.
Affect(class-cnt:1 , method-cnt:1) cost in 332 ms.
ts=2019-06-04 11:38:06; [cost=2.75218ms] result=@HandlerExecutionChain[
    logger=@SLF4JLocationAwareLog[org.apache.commons.logging.impl.SLF4JLocationAwareLog@665c08a],
    handler=@HandlerMethod[public com.example.demo.arthas.user.User com.example.demo.arthas.user.UserController.findUserById(java.lang.Integer)],
    interceptors=null,
    interceptorList=@ArrayList[isEmpty=false;size=2],
    interceptorIndex=@Integer[-1],
]

可以看到处理请求的handler是 com.example.demo.arthas.user.UserController.findUserById。

总结

• Spring MVC的请求是在DispatcherServlet分发，查找到对应的mappedHandler来处理
• 使用Arthas时，灵活结合代码，可以快速精确定位问题

链接

• https://github.com/alibaba/arthas
• https://alibaba.github.io/arthas/watch.html
• https://alibaba.github.io/arthas/trace.html

• https://github.com/alibaba/arthas

Arthas在阿里巴巴内部起源于2015年，当时微服务方兴未艾，我们团队一方面专注Spring Boot落地，提高开发效率，另外一方面，希望可以提高线上排查问题的能力和效率。当时我们经过选型讨论，选择基于Greys来开发，提供更好的应用诊断体验。

我们在用户体验上做了大量的改进：彩色UI，Web Console，内网一键诊断等。下面是内网一键在线诊断的截图，很多同事线上诊断问题的必备工具：

二、Arthas开源之后的工作

尽管Arthas在阿里内部广受好评，但它只是内部工具，很多离职同事都在一些文章里提到。做为Java开发的一员，我们使用到了很多开源的代码和工具，我们也希望可以提升广大开发人员的诊断效率，因此在2018年9月底，我们正式开源了Arthas。

在开源之后，Arthas多次登顶Github Trending，还被@Java官方twitter转发：

在开源之后，Arthas发布了3个release版本，做了大量的改进：

• 全新的LOGO
• arthas-boot统一跨平台体验
• Arthas在线教程
• 全新版本的Web Console
• 全新的中英文档，感谢社区的大力支持
• JDK11全面支持，lamda类支持
• Docker支持
• 灵活的ognl命令
• 增加内存编译器，实现jad/mc/redefine一条龙
• Q键退出，history匹配，快捷键支持
• 不断完善的自动补全支持
• 重构重定向的支持

目前，Arthas Github star数10000+，月下载量7000+。在开源中国2018开源软件排行榜里，Arthas获得国产新秀榜第一名。

这是对我们过去工作的支持和肯定，也是我们持续改进Arthas的动力。

三、感谢贡献者们

Arthas在开源以来，不断收获到国内外贡献者的支持，目前已有40+贡献者，非常感谢他们的工作：

特别感谢@Hearen贡献了大部分的英文翻译，@wetsion重构了新版本的Web Console。

参与贡献： https://github.com/alibaba/arthas/blob/master/CONTRIBUTING.md

四、Arthas实践系列文章

做为Arthas的用户，我们在实践中积累了很多经验，总结为一系列的文章，希望对大家线上排查问题有帮助：

• Arthas实践–jad/mc/redefine线上热更新一条龙
• Alibaba Arthas实践–获取到Spring Context，然后为所欲为
• Arthas实践–快速排查Spring Boot应用404/401问题
• 当Dubbo遇上Arthas：排查问题的实践
• 使用Arthas抽丝剥茧排查线上应用日志打满问题
• 深入Spring Boot：利用Arthas排查NoSuchMethodError

五、Arthas 4.0规划

• 提供一个新的字节码框架，名为bytekit
• 插件化支持
• view分层，支持Web白屏化

详细链接： https://github.com/alibaba/arthas/issues/536 ，同时希望大家可以提出建议和参与。

尽管在生产环境热更新代码，并不是很好的行为，很可能导致：热更不规范，同事两行泪。

但很多时候我们的确希望能热更新代码，比如：

线上排查问题，找到修复思路了，但应用重启之后，环境现场就变了，难以复现。怎么验证修复方案？

又比如：

本地开发时，发现某个开源组件有bug，希望修改验证。如果是自己编译开源组件再发布，流程非常的长，还不一定能编译成功。有没有办法快速测试？

Arthas是阿里巴巴开源的Java应用诊断利器，深受开发者喜爱。

下面介绍利用Arthas 3.1.0版本的 jad/mc/redefine 一条龙来热更新代码。

• Arthas: https://github.com/alibaba/arthas
• jad命令：https://alibaba.github.io/arthas/jad.html
• mc命令：https://alibaba.github.io/arthas/mc.html
• redefine命令：https://alibaba.github.io/arthas/redefine.html

Arthas在线教程

下面通过Arthas在线教程演示热更新代码的过程。

• Arthas进阶教程

在例子里，访问 curl http://localhost/user/0，会返回500错误：

1
2
3
4
5
6
7
8

{
    "timestamp": 1550223186170,
    "status": 500,
    "error": "Internal Server Error",
    "exception": "java.lang.IllegalArgumentException",
    "message": "id < 1",
    "path": "/user/0"
}

下面通过热更新代码，修改这个逻辑。

jad反编译代码

反编译UserController，保存到 /tmp/UserController.java文件里。

1

jad --source-only com.example.demo.arthas.user.UserController > /tmp/UserController.java

修改反编译出来的代码

用文本编辑器修改/tmp/UserController.java，把抛出异常改为正常返回：

1
2
3
4
5
6
7
8
9

@GetMapping(value={"/user/{id}"})
public User findUserById(@PathVariable Integer id) {
    logger.info("id: {}", (Object)id);
    if (id != null && id < 1) {
        return new User(id, "name" + id);
        // throw new IllegalArgumentException("id < 1");
    }
    return new User(id.intValue(), "name" + id);
}

sc查找加载UserController的ClassLoader

1
2

$ sc -d *UserController | grep classLoaderHash
 classLoaderHash   1be6f5c3

可以发现是spring boot的 LaunchedURLClassLoader@1be6f5c3 加载的。

mc内存编译代码

保存好/tmp/UserController.java之后，使用mc(Memory Compiler)命令来编译，并且通过-c参数指定ClassLoader：

1
2
3
4

$ mc -c 1be6f5c3 /tmp/UserController.java -d /tmp
Memory compiler output:
/tmp/com/example/demo/arthas/user/UserController.class
Affect(row-cnt:1) cost in 346 ms

redefine热更新代码

再使用redefine命令重新加载新编译好的UserController.class：

1
2

$ redefine /tmp/com/example/demo/arthas/user/UserController.class
redefine success, size: 1

检验热更新结果

再次访问 curl http://localhost/user/0，会正常返回：

1
2
3
4

{
    "id": 0,
    "name": "name0"
}

总结

Arthas里 jad/mc/redefine 一条龙来线上热更新代码，非常强大，但也很危险，需要做好权限管理。

比如，线上应用启动帐号是 admin，当用户可以切换到admin，那么

• 用户可以修改，获取到应用的任意内存值（不管是否java应用）
• 用户可以attach jvm
• attach jvm之后，利用jvm本身的api可以redefine class

所以：

• 应用的安全主要靠用户权限本身的管理
• Arthas主要是让jvm redefine更容易了。用户也可以利用其它工具达到同样的效果

最后，Arthas提醒您： 诊断千万条，规范第一条，热更不规范，同事两行泪。

Arthas实践系列

• Alibaba Arthas实践–获取到Spring Context，然后为所欲为
• Arthas实践–快速排查Spring Boot应用404/401问题
• 当Dubbo遇上Arthas：排查问题的实践
• Arthas实践–使用redefine排查应用奇怪的日志来源
• 使用Arthas抽丝剥茧排查线上应用日志打满问题
• 深入Spring Boot：利用Arthas排查NoSuchMethodError

Arthas是Alibaba开源的Java诊断工具，深受开发者喜爱。
从Arthas上个版本发布，已经过去两个多月了，Arthas 3.1.0版本不仅带来大家投票出来的新LOGO，还带来强大的新功能和更好的易用性，下面一一介绍。

• Github： https://github.com/alibaba/arthas
• 文档：https://alibaba.github.io/arthas

在线教程

在新版本Arthas里，增加了在线教程，用户可以在线运行Demo，一步步学习Arthas的各种用法，推荐新手尝试：

• Arthas基础教程
• Arthas进阶教程

非常欢迎大家来完善这些教程。

增加内存编译器支持，在线编辑热更新代码

3.1.0版本里新增命令mc，不是方块游戏mc，而是Memory Compiler。

在之前版本里，增加了redefine命令，可以热更新字节码。但是有个不方便的地方：需要把.class文件上传到服务器上。

在3.1.0版本里，结合jad/mc/redefine 可以完美实现热更新代码。

以 Arthas在线教程 里的UserController为例：

1. 使用jad反编译代码

   1	jad --source-only com.example.demo.arthas.user.UserController > /tmp/UserController.java

2. 使用vim编译代码

   当 user id 小于1时，也正常返回，不抛出异常：

   1 2 3 4 5 6 7 8 9 10 11

   @GetMapping("/user/{id}") public User findUserById(@PathVariable Integer id) { logger.info("id: {}" , id); if (id != null && id < 1) { return new User(id, "name" + id); // throw new IllegalArgumentException("id < 1"); } else { return new User(id, "name" + id); } }

3. 使用mc命令编译修改后的UserController.java

   1 2 3 4

   $ mc /tmp/UserController.java -d /tmp Memory compiler output: /tmp/com/example/demo/arthas/user/UserController.class Affect(row-cnt:1) cost in 346 ms

4. 使用redefine命令，因为可以热更新代码

   1 2	$ redefine /tmp/com/example/demo/arthas/user/UserController.class redefine success, size: 1

丝滑的自动补全

在新版本里，改进了很多命令的自动补全，比如 watch/trace/tt/monitor/stack等。

下面是watch命令的第一个Tab补全结果，用户可以很方便的一步步补全类名，函数名：

1
2

$ watch
com.   sun.   javax. ch.    io.    demo.  jdk.   org.   java.

另外，新增加了 jad/sc/sm/redefine 等命令的自动补全支持，多按Tab有惊喜。

新版本的Web console

新版本的Web Console切换到了xtermd.js，更好地支持现代浏览器。

• 支持Ctrl + C复制
• 支持全屏

Docker镜像支持

Arthas支持Docker镜像了

• 用户可以很方便地诊断Docker/k8s里的Java进程
• 也可以很方便地把Arthas加到自己的基础镜像里

参考： https://alibaba.github.io/arthas/docker.html

重定向重新设计

之前的版本里，Arthas的重定向是会放到一个~/logs/arthas-cache/目录里，违反直觉。

在新版本里，重定向和Linux下面的一致，>/>>的行为也和Linux下一致。

并且，增加了 cat/pwd命令，可以配置使用。

总结

总之，3.1.0版本的Arthas带了非常多的新功能，改进了很多的用户体验，欢迎大家使用反馈。

• Arthas在线教程可以学到很多技巧
• jad/mc/redefine 一条龙非常强大
• 丝滑的自动补全值得尝试
• 新版本的Web Console有惊奇

Release Note: https://github.com/alibaba/arthas/releases/tag/3.1.0

Arthas 是Alibaba开源的Java诊断工具，深受开发者喜爱。

• https://github.com/alibaba/arthas

Arthas提供了非常丰富的关于调用拦截的命令，比如 trace/watch/monitor/tt 。但是很多时候我们在排查问题时，需要更多的线索，并不只是函数的参数和返回值。
比如在一个spring应用里，想获取到spring context里的其它bean。如果能随意获取到spring bean，那就可以“为所欲为”了。

下面介绍如何利用Arthas获取到spring context。

Demo： https://github.com/hengyunabc/spring-boot-inside/tree/master/demo-arthas-spring-boot

Arthas快速开始：https://alibaba.github.io/arthas/quick-start.html

使用tt命令获取到spring context

Demo是一个spring mvc应用，请求会经过一系列的spring bean处理，那么我们可以在spring mvc的类里拦截到一些请求。

启动Demo： mvn spring-boot:run

使用Arthas Attach成功之后，执行tt命令来记录RequestMappingHandlerAdapter#invokeHandlerMethod的请求

1

tt -t org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter invokeHandlerMethod

然后访问一个网页： http://localhost:8080/

可以看到Arthas会拦截到这个调用，index是1000，并且打印出：

1
2
3
4
5
6
7
8
9

$ watch com.example.demo.Test * 'params[0]@sss'
$ tt -t org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter invokeHandlerMethod
Press Ctrl+C to abort.
Affect(class-cnt:1 , method-cnt:1) cost in 101 ms.
 INDEX  TIMESTAMP         COST(ms  IS-RE  IS-EX  OBJECT       CLASS                     METHOD
                          )        T      P
------------------------------------------------------------------------------------------------------------------
 1000   2019-01-27 16:31  3.66744  true   false  0x4465cf70   RequestMappingHandlerAda  invokeHandlerMethod
        :54                                                   pter

那么怎样获取到spring context？

可以用tt命令的-i参数来指定index，并且用-w参数来执行ognl表达式来获取spring context：

1
2
3
4
5
6
7
8

$ tt -i 1000 -w 'target.getApplicationContext()'
@AnnotationConfigEmbeddedWebApplicationContext[
    reader=@AnnotatedBeanDefinitionReader[org.springframework.context.annotation.AnnotatedBeanDefinitionReader@35dc90ec],
    scanner=@ClassPathBeanDefinitionScanner[org.springframework.context.annotation.ClassPathBeanDefinitionScanner@72078a14],
    annotatedClasses=null,
    basePackages=null,
]
Affect(row-cnt:1) cost in 7 ms.

从spring context里获取任意bean

获取到spring context之后，就可以获取到任意的bean了，比如获取到helloWorldService，并调用getHelloMessage()函数：

1
2
3

$ tt -i 1000 -w 'target.getApplicationContext().getBean("helloWorldService").getHelloMessage()'
@String[Hello World]
Affect(row-cnt:1) cost in 5 ms.

更多的思路

在很多代码里都有static函数或者static holder类，顺滕摸瓜，可以获取很多其它的对象。比如在Dubbo里通过SpringExtensionFactory获取spring context：

1
2
3
4
5
6

$ ognl '#context=@com.alibaba.dubbo.config.spring.extension.SpringExtensionFactory@contexts.iterator.next, 
#context.getBean("userServiceImpl").findUser(1)'
@User[
    id=@Integer[1],
    name=@String[Deanna Borer],
]

链接

• Arthas: https://github.com/alibaba/arthas
• https://alibaba.github.io/arthas/tt.html
• https://alibaba.github.io/arthas/ognl.html

在Java Web/Spring Boot开发时，很常见的问题是：

• 网页访问404了，为什么访问不到？
• 登陆失败了，请求返回401，到底是哪个Filter拦截了我的请求？

碰到这种问题时，通常很头痛，特别是在线上环境时。

本文介绍使用Alibaba开源的Java诊断利器Arthas，来快速定位这类Web请求404/401问题。

• https://github.com/alibaba/arthas

Java Web里一个请求被处理的流程

在进入正题之前，先温习下知识。一个普通的Java Web请求处理流程大概是这样子的：

1
2
3

Request  -> Filter1 -> Filter2 ... -> Servlet
                                        |
Response <- Filter1 <- Filter2 ... <- Servlet

Demo

本文的介绍基于一个很简单的Demo：https://github.com/hengyunabc/spring-boot-inside/tree/master/demo-404-401

• 访问 http://localhost:8080/ ，返回200，正常打印Welconme信息
• 访问 http://localhost:8080/a.txt ，返回404
• 访问 http://localhost:8080/admin ，返回401

是哪个Servlet返回了404？

Demo启动后，访问：http://localhost:8080/a.txt ，返回404：

1
2

$ curl http://localhost:8080/a.txt
{"timestamp":1546790485831,"status":404,"error":"Not Found","message":"No message available","path":"/a.txt"}

我们知道一个HTTP Request，大部分情况下都是由一个Servlet处理的，那么到底是哪个Servlet返回了404？

我们使用Arthas的trace命令来定位：

1
2
3

$ trace javax.servlet.Servlet *
Press Ctrl+C to abort.
Affect(class-cnt:7 , method-cnt:185) cost in 1018 ms.

然后访问 http://localhost:8080/a.txt ，Arthas会打印出整个请求树，完整的输出太长，这里只截取关键的一输出：

1
2
3
4
5
6
7
8

+---[13.087083ms] org.springframework.web.servlet.DispatcherServlet:resolveViewName()
|   `---[13.020984ms] org.springframework.web.servlet.DispatcherServlet:resolveViewName()
|       +---[0.002777ms] java.util.List:iterator()
|       +---[0.001955ms] java.util.Iterator:hasNext()
|       +---[0.001739ms] java.util.Iterator:next()
|       `---[12.891979ms] org.springframework.web.servlet.ViewResolver:resolveViewName()
|           +---[0.089811ms] javax.servlet.GenericServlet:<init>()
|           +---[min=0.037696ms,max=0.054478ms,total=0.092174ms,count=2] org.springframework.web.servlet.view.freemarker.FreeMarkerView$GenericServletAdapter:<init>()

可以看出请求经过Spring MVC的DispatcherServlet处理，最终由ViewResolver分派给FreeMarkerView$GenericServletAdapter处理。所以我们可以知道这个请求最终是被FreeMarker处理的。
后面再排查FreeMarker的配置就可以了。

这个神奇的trace javax.servlet.Servlet *到底是怎样工作的呢？

实际上Arthas会匹配到JVM里所有实现了javax.servlet.Servlet的类，然后trace它们的所有函数，所以HTTP请求会被打印出来。

这里留一个小问题，为什么只访问了http://localhost:8080/a.txt，但Arthas的trace命令打印出了两个请求树？

是哪个Filter返回了401？

在Demo里，访问 http://localhost:8080/admin ，会返回401，即没有权限。那么是哪个Filter拦截了请求？

1
2

$ curl http://localhost:8080/admin
{"timestamp":1546794743674,"status":401,"error":"Unauthorized","message":"admin filter error.","path":"/admin"}

我们还是使用Arthas的trace命令来定位，不过这次trace的是javax.servlet.Filter：

1
2
3

$ trace javax.servlet.Filter *
Press Ctrl+C to abort.
Affect(class-cnt:13 , method-cnt:75) cost in 278 ms.

再次访问admin，在Arthas里，把整个请求经过哪些Filter处理，都打印为树。这里截取关键部分：

1
2
3
4
5
6
7
8
9
10
11
12

+---[0.704625ms] org.springframework.web.filter.OncePerRequestFilter:doFilterInternal()
|   `---[0.60387ms] org.springframework.web.filter.RequestContextFilter:doFilterInternal()
|       +---[0.022704ms] org.springframework.web.context.request.ServletRequestAttributes:<init>()
|       +---[0.217636ms] org.springframework.web.filter.RequestContextFilter:initContextHolders()
|       |   `---[0.180323ms] org.springframework.web.filter.RequestContextFilter:initContextHolders()
|       |       +---[0.034656ms] javax.servlet.http.HttpServletRequest:getLocale()
|       |       +---[0.0311ms] org.springframework.context.i18n.LocaleContextHolder:setLocale()
|       |       +---[0.008691ms] org.springframework.web.context.request.RequestContextHolder:setRequestAttributes()
|       |       `---[0.014918ms] org.apache.commons.logging.Log:isDebugEnabled()
|       +---[0.215481ms] javax.servlet.FilterChain:doFilter()
|       |   `---[0.072186ms] com.example.demo404401.AdminFilterConfig$AdminFilter:doFilter()
|       |       `---[0.021945ms] javax.servlet.http.HttpServletResponse:sendError()

可以看到HTTP Request最终是被com.example.demo404401.AdminFilterConfig$AdminFilter处理的。

总结

• 通过trace Servlet/Filter，可以快速定位Java Web问题
• trace是了解应用执行流程的利器，只要trace到关键的接口或者类上
• 仔细观察trace的结果，可以学习到Spring MVC是处理Web请求细节

链接

• https://github.com/alibaba/arthas
• https://alibaba.github.io/arthas/trace.html

打个广告，Arthas正在征集使用者，您的使用是对我们最大的支持。
如果Arthas对您排查问题有帮助，请到这个Issue登记下，并在30分钟内成为Arthas Contributor：

https://github.com/alibaba/arthas/issues/395

https://book.douban.com/subject/27204181/

赋能，这个词经常听到，但不知道是啥意思。看了这本书，算是理解到了。

这本书讲的是在美国特种部队，在伊拉克应对各种“不确定性”事件，不得不把信息公开透明化，加强互动，从而提高应对速度和能力，打造应对不确定性的敏捷团队的故事。

在公司里，很多时候都是各种小团体，软件开发也是各种小群讨论。同一个大部门里，不同的组件都要互相打架。

感觉大部分人并没有意识到事情要公开，信息要流动，事情才能做好。也许是KPI导向的结果，也许是缺少共同目标，每个人都管自己的一亩三分地。

我个人感受是，尽量获取不同部门，不同组件的信息，把解决问题的过程记录下来，并公开化。

美国大城市的死与生

https://book.douban.com/subject/1870268/

这本书很早就知道了，但没有动机去看。真正起了兴趣去看，是因为看到一位美国留学生的Blog，里面提到了各种街区。所以去看了这本书。

感觉中国的城市设计者们受这本书的影响很深，城市基本都是混合功能的，并没有像美国那样子整齐的街区划分。之前还有传言说要把小区的墙都拆掉。

这本书是1961年出版的，所以我很好奇这本书到底在美国产生了怎样的影响。后面在《规模》里找到了一些答案。

这本书只看了三分之二，因为翻译真的不好。

也许中国人不能真正理解美国的街区，正如美国人不能理解中国人的户口。

规模：复杂世界的简单法则

https://book.douban.com/subject/30244461/

推荐。这本书是同事推荐的，里面谈的都是事物上了规模之后的一些统计学规律。看了可能有点沮丧，人逃脱不了这些规律。

不过看了这本书，明白了一个事情：城市化是不可逆转的，超大规模的城市群会越来越多。

书里提到很多《美国大城市的死与生》给美国人的影响。读书有乐趣的一点就是，两本书的互相印证。

新教伦理与资本主义精神

https://book.douban.com/subject/6436046/

推荐。这本书说的是新教怎么影响资本主义的。翻译的版本里有一些很不错的配图，导致我一开始以为是80/90年代的书，但看到中间时，感觉不太对，去查了下，发现是1905年出版的，十分惊讶。

无论这本书是否是给资本主义正名，但里面提到的一点比较有意思：新教的禁欲主义使得新教徒很勤奋，所以他们资本财富不断增加。但财富增长到一定程度之后，这种宗教的精神慢慢泯灭了。这点和现在的中国很像，70/80还比较能体会到艰苦奋斗，90/00对艰苦奋斗这种概念已经很淡薄了。日本也曾经如此。

还有一点，现代人可能不太能理解为什么当时的人对资本主义深恶痛绝。在《众病之王：癌症传》里提到有一种消失了的癌症：阴囊癌。18世纪的很多童工因为身体接触到这些煤烟而患上阴囊癌。一开始是立法禁止8岁以下儿童，后面才逐步完全禁止。

有关联的一本书：《非理性的人》，在看中，推荐。

见识：商业的本质和人生的智慧

https://book.douban.com/subject/27167992/

推荐。这本书里学到了一个观点：让用户充值不重要，重要的是要让用户花出去。

死人经

https://book.douban.com/subject/26365250/

一般，武侠小说，只看了不到一半，太啰嗦了。

高山下的花环

https://book.douban.com/subject/2159124/

很有时代特征，可以看到很多细节。但是都没有写到位。军队的腐败也只能带一下。现在的人对越战有认知的很少，希望未来可以有对越战争的电影。

搞懂金融的第一本书

https://book.douban.com/subject/10434287/

对小白来说，比较有意思。学到了点通货膨胀，钱币贬值的知识，不过现在已忘记了，哈哈。

你一生的故事

https://book.douban.com/subject/26295448/

因为《降临》电影不知所云，找的原著来看。书是由多个小故事组成的，只看了两个故事：《你一生的故事》和《巴比伦塔》。太多宗教色彩了，提不起兴趣再看。

断舍离

https://book.douban.com/subject/24749465/

囤积物品是人进化的天性，丢掉旧东西，也许是现代人的一种解脱方式。今年搬了一次家，把一些两三年都没用过的东西丢了，感觉有点爽。

还有一个关联的日剧《我的家里空无一物》，看了一两集，没追。

沉默的大多数

https://book.douban.com/subject/1054685/

王小波的杂文集。王小波的小说一直没有看进去，偶然看到这本杂文还挺有意思的。

黑色皮革手册

https://book.douban.com/subject/26301856/

因为同名日剧去看的，日剧本身没看，直接看的小说，还行。

对于历史，科学家有话说

https://book.douban.com/subject/26954748/

了解一些“知识分子”的历史，书里都是当事人的访谈。“知识分子”这个词，对于年青人是比较陌生的，没有经历过的人，可能真的没办法理解。

青年们，读马克思吧！

https://book.douban.com/subject/25728591/

日本人写的，怎样读马克思的书。感觉有点神奇。通过两个作者的书信来往，想讨论马克思是怎样思考的，马克思的方法论。

笑傲江湖 和 倚天屠龙记

金庸去世，把《笑傲江湖》和《倚天屠龙记》重新看了一遍。 为什么这两本呢？因为小学的时候，从角落里翻到《笑傲江湖》的第二本，《倚天屠龙记》的第一本。当时看完了又找不到后续，只能翻来覆去的看了好几遍。直到上高中，从图书馆借书才看了完本。

《笑傲江湖》有个点很有意思，岳不群和左冷禅争五岳盟主时，岳不群说：“只须方针一变，天下同道协力以赴，期之以五十年、一百年，决无不成之理。”金庸在后记里专门说明小说是早年写的，并非影射。不管真相是怎样，看到还是觉得挻搞笑的。

总结

2018年把今日头条卸载了，因为推的内容越来越单一，越来越八卦。发现这些软件都没有重置的功能，应该允许用户重新选择感兴趣的内容，重新开始推荐。大数据时代，每个人都只能看到自己圈子里的，越来越难看到另外领域的信息了。

五星推荐：

• 赋能：打造应对不确定性的敏捷团队
• 规模：复杂世界的简单法则
• 新教伦理与资本主义精神
• 见识：商业的本质和人生的智慧

• Github: https://github.com/apache/incubator-dubbo
• 文档：http://dubbo.incubator.apache.org/zh-cn/

Arthas是Alibaba开源的应用诊断利器，9月份开源以来，Github Star数三个月超过6000。

• Github: https://github.com/alibaba/arthas
• 文档：https://alibaba.github.io/arthas/
• Arthas开源交流QQ群: 916328269
• Arthas开源交流钉钉群: 21965291

当Dubbo遇上Arthas，会碰撞出什么样的火花呢？下面来分享Arthas排查Dubbo问题的一些经验。

dubbo-arthas-demo

下面的排查分享基于这个dubbo-arthas-demo，非常简单的一个应用，浏览器请求从Spring MVC到Dubbo Client，再发送到Dubbo Server。

Demo里有两个spring boot应用，可以先启动server-demo，再启动client-demo。

• https://github.com/hengyunabc/dubbo-arthas-demo

1
2

/user/{id}    ->   UserService    ->   UserServiceImpl 
 Browser           Dubbo Client          Dubbo Server

Client端：

1
2
3
4
5
6
7
8
9
10

@RestController
public class UserController {

@Reference(version = "1.0.0")
private UserService userService;

@GetMapping("/user/{id}")
public User findUserById(@PathVariable Integer id) {
return userService.findUser(id);
}

Server端：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

@Service(version = "1.0.0")
public class UserServiceImpl implements UserService {
@Override
public User findUser(int id) {
if (id < 1) {
throw new IllegalArgumentException("user id < 1, id: " + id);
}
for (User user : users) {
if (user.getId() == id) {
return user;
}
}
throw new RuntimeException("Can not find user, id: " + id);
}

Arthas快速开始

• https://alibaba.github.io/arthas/install-detail.html

1
2

$ wget https://alibaba.github.io/arthas/arthas-boot.jar
$ java -jar arthas-boot.jar

启动后，会列出所有的java进程，选择1，然后回车，就会连接上ServerDemoApplication

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

$ java -jar arthas-boot.jar
* [1]: 43523 ServerDemoApplication
  [2]: 22342
  [3]: 44108 ClientDemoApplication
1
[INFO] arthas home: /Users/hengyunabc/.arthas/lib/3.0.5/arthas
[INFO] Try to attach process 43523
[INFO] Attach process 43523 success.
[INFO] arthas-client connect 127.0.0.1 3658
  ,---.  ,------. ,--------.,--.  ,--.  ,---.   ,---.
 /  O  \ |  .--. ''--.  .--'|  '--'  | /  O  \ '   .-'
|  .-.  ||  '--'.'   |  |   |  .--.  ||  .-.  |`.  `-.
|  | |  ||  |\  \    |  |   |  |  |  ||  | |  |.-'    |
`--' `--'`--' '--'   `--'   `--'  `--'`--' `--'`-----'

wiki: https://alibaba.github.io/arthas
version: 3.0.5
pid: 43523
time: 2018-12-05 16:23:52

$

Dubbo线上服务抛出异常，怎么获取调用参数？

• https://alibaba.github.io/arthas/watch.html

当线上服务抛出异常时，最着急的是什么参数导致了抛异常？

在demo里，访问 http://localhost:8080/user/0 ，UserServiceImpl就会抛出一个异常，因为user id不合法。

在Arthas里执行 watch com.example.UserService * -e -x 2 '{params,throwExp}' ，然后再次访问，就可以看到watch命令把参数和异常都打印出来了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

$ watch com.example.UserService * -e -x 2 '{params,throwExp}'
Press Ctrl+C to abort.
Affect(class-cnt:1 , method-cnt:4) cost in 230 ms.
ts=2018-12-05 16:26:44; [cost=3.905523ms] result=@ArrayList[
    @Object[][
        @Integer[0],
    ],
    java.lang.IllegalArgumentException: user id < 1, id: 0
at com.example.UserServiceImpl.findUser(UserServiceImpl.java:24)
at com.alibaba.dubbo.common.bytecode.Wrapper1.invokeMethod(Wrapper1.java)
at com.alibaba.dubbo.rpc.proxy.javassist.JavassistProxyFactory$1.doInvoke(JavassistProxyFactory.java:45)
at com.alibaba.dubbo.rpc.proxy.AbstractProxyInvoker.invoke(AbstractProxyInvoker.java:71)
at com.alibaba.dubbo.config.invoker.DelegateProviderMetaDataInvoker.invoke(DelegateProviderMetaDataInvoker.java:48)
at com.alibaba.dubbo.rpc.protocol.InvokerWrapper.invoke(InvokerWrapper.java:52)
at com.alibaba.dubbo.rpc.filter.ExceptionFilter.invoke(ExceptionFilter.java:61)

怎样线上调试Dubbo服务代码?

• https://alibaba.github.io/arthas/redefine.html

在本地开发时，可能会用到热部署工具，直接改代码，不需要重启应用。但是在线上环境，有没有办法直接动态调试代码？比如增加日志。

在Arthas里，可以通过redefine命令来达到线上不重启，动态更新代码的效果。

比如我们修改下UserServiceImpl，用System.out打印出具体的User对象来：

1
2
3
4
5
6
7
8
9
10
11
12

public User findUser(int id) {
if (id < 1) {
throw new IllegalArgumentException("user id < 1, id: " + id);
}
for (User user : users) {
if (user.getId() == id) {
System.out.println(user);
return user;
}
}
throw new RuntimeException("Can not find user, id: " + id);
}

本地编绎后，把server-demo/target/classes/com/example/UserServiceImpl.class传到线上服务器，然后用redefine命令来更新代码：

1
2

$ redefine -p /tmp/UserServiceImpl.class
redefine success, size: 1

这样子更新成功之后，访问 http://localhost:8080/user/1 ，在ServerDemoApplication的控制台里就可以看到打印出了user信息。

怎样动态修改Dubbo的logger级别?

• https://alibaba.github.io/arthas/ognl.html
• https://alibaba.github.io/arthas/sc.html
• https://commons.apache.org/proper/commons-ognl/language-guide.html

在排查问题时，需要查看到更多的信息，如果可以把logger级别修改为DEBUG，就非常有帮助。

ognl是apache开源的一个轻量级表达式引擎。下面通过Arthas里的ognl命令来动态修改logger级别。

首先获取Dubbo里TraceFilter的一个logger对象，看下它的实现类，可以发现是log4j。

1
2
3
4
5

$ ognl '@com.alibaba.dubbo.rpc.protocol.dubbo.filter.TraceFilter@logger.logger'
@Log4jLogger[
    FQCN=@String[com.alibaba.dubbo.common.logger.support.FailsafeLogger],
    logger=@Logger[org.apache.log4j.Logger@2f19bdcf],
]

再用sc命令来查看具体从哪个jar包里加载的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

$ sc -d org.apache.log4j.Logger
 class-info        org.apache.log4j.Logger
 code-source       /Users/hengyunabc/.m2/repository/org/slf4j/log4j-over-slf4j/1.7.25/log4j-over-slf4j-1.7.25.jar
 name              org.apache.log4j.Logger
 isInterface       false
 isAnnotation      false
 isEnum            false
 isAnonymousClass  false
 isArray           false
 isLocalClass      false
 isMemberClass     false
 isPrimitive       false
 isSynthetic       false
 simple-name       Logger
 modifier          public
 annotation
 interfaces
 super-class       +-org.apache.log4j.Category
                     +-java.lang.Object
 class-loader      +-sun.misc.Launcher$AppClassLoader@5c647e05
                     +-sun.misc.Launcher$ExtClassLoader@59878d35
 classLoaderHash   5c647e05

Affect(row-cnt:1) cost in 126 ms.

可以看到log4j是通过slf4j代理的。

那么通过org.slf4j.LoggerFactory获取root logger，再修改它的level：

1
2
3
4

$ ognl '@org.slf4j.LoggerFactory@getLogger("root").setLevel(@ch.qos.logback.classic.Level@DEBUG)'
null
$ ognl '@org.slf4j.LoggerFactory@getLogger("root").getLevel().toString()'
@String[DEBUG]

可以看到修改之后，root logger的level变为DEBUG。

怎样减少测试小姐姐重复发请求的麻烦?

• https://alibaba.github.io/arthas/tt.html

在平时开发时，可能需要测试小姐姐发请求过来联调，但是我们在debug时，可能不小心直接跳过去了。这样子就尴尬了，需要测试小姐姐再发请求过来。

Arthas里提供了tt命令，可以减少这种麻烦，可以直接重放请求。

1
2
3
4
5
6
7
8

$ tt -t com.example.UserServiceImpl findUser
Press Ctrl+C to abort.
Affect(class-cnt:1 , method-cnt:1) cost in 145 ms.
 INDEX      TIMESTAMP              COST(ms)      IS-RET     IS-EXP    OBJECT       CLASS              METHOD
----------------------------------------------------------------------------------------------------------------
 1000       2018-12-05 17:47:52    1.56523       true       false     0x3233483    UserServiceImpl    findUser
 1001       2018-12-05 17:48:03    0.286176      false      true      0x3233483    UserServiceImpl    findUser
 1002       2018-12-05 17:48:11    90.324335     true       false     0x3233483    UserServiceImpl    findUser

上面的tt -t命令捕获到了3个请求。然后通过tt --play可以重放请求：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

$ tt --play -i 1000
 RE-INDEX       1000
 GMT-REPLAY     2018-12-05 17:55:50
 OBJECT         0x3233483
 CLASS          com.example.UserServiceImpl
 METHOD         findUser
 PARAMETERS[0]  @Integer[1]
 IS-RETURN      true
 IS-EXCEPTION   false
 RETURN-OBJ     @User[
                    id=@Integer[1],
                    name=@String[Deanna Borer],
                ]
Time fragment[1000] successfully replayed.
Affect(row-cnt:1) cost in 4 ms.

Dubbo运行时有哪些Filter? 耗时是多少?

• https://alibaba.github.io/arthas/trace.html

Dubbo运行时会加载很多的Filter，那么一个请求会经过哪些Filter处理，Filter里的耗时又是多少呢？

通过Arthas的trace命令，可以很方便地知道Filter的信息，可以看到详细的调用栈和耗时。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

$ trace com.alibaba.dubbo.rpc.Filter *
Press Ctrl+C to abort.
Affect(class-cnt:19 , method-cnt:59) cost in 1441 ms.
`---ts=2018-12-05 19:07:26;thread_name=DubboServerHandler-30.5.125.152:20880-thread-10;id=3e;is_daemon=true;priority=5;TCCL=sun.misc.Launcher$AppClassLoader@5c647e05
    `---[8.435844ms] com.alibaba.dubbo.rpc.filter.EchoFilter:invoke()
        +---[0.124572ms] com.alibaba.dubbo.rpc.Invocation:getMethodName()
        +---[0.065123ms] java.lang.String:equals()
        `---[7.762928ms] com.alibaba.dubbo.rpc.Invoker:invoke()
            `---[7.494124ms] com.alibaba.dubbo.rpc.filter.ClassLoaderFilter:invoke()
                +---[min=0.00355ms,max=0.049922ms,total=0.057637ms,count=3] java.lang.Thread:currentThread()
                +---[0.0126ms] java.lang.Thread:getContextClassLoader()
                +---[0.02188ms] com.alibaba.dubbo.rpc.Invoker:getInterface()
                +---[0.004115ms] java.lang.Class:getClassLoader()
                +---[min=0.003906ms,max=0.014058ms,total=0.017964ms,count=2] java.lang.Thread:setContextClassLoader()
                `---[7.033486ms] com.alibaba.dubbo.rpc.Invoker:invoke()
                    `---[6.869488ms] com.alibaba.dubbo.rpc.filter.GenericFilter:invoke()
                        +---[0.01481ms] com.alibaba.dubbo.rpc.Invocation:getMethodName()

Dubbo动态代理是怎样实现的?

• https://alibaba.github.io/arthas/jad.html
• com.alibaba.dubbo.common.bytecode.Wrapper

通过Arthas的jad命令，可以看到Dubbo通过javaassist动态生成的Wrappr类的代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

$ jad com.alibaba.dubbo.common.bytecode.Wrapper1

ClassLoader:
+-sun.misc.Launcher$AppClassLoader@5c647e05
  +-sun.misc.Launcher$ExtClassLoader@59878d35

Location:
/Users/hengyunabc/.m2/repository/com/alibaba/dubbo/2.5.10/dubbo-2.5.10.jar

package com.alibaba.dubbo.common.bytecode;

public class Wrapper1
extends Wrapper
implements ClassGenerator.DC {

    public Object invokeMethod(Object object, String string, Class[] arrclass, Object[] arrobject) throws InvocationTargetException {
        UserServiceImpl userServiceImpl;
        try {
            userServiceImpl = (UserServiceImpl)object;
        }
        catch (Throwable throwable) {
            throw new IllegalArgumentException(throwable);
        }
        try {
            if ("findUser".equals(string) && arrclass.length == 1) {
                return userServiceImpl.findUser(((Number)arrobject[0]).intValue());
            }
            if ("listUsers".equals(string) && arrclass.length == 0) {
                return userServiceImpl.listUsers();
            }
            if ("findUserByName".equals(string) && arrclass.length == 1) {
                return userServiceImpl.findUserByName((String)arrobject[0]);
            }
        }

获取Spring context

除了上面介绍的一些排查技巧，下面分享一个获取Spring Context，然后“为所欲为”的例子。

在Dubbo里有一个扩展com.alibaba.dubbo.config.spring.extension.SpringExtensionFactory，把Spring Context保存到了里面。
因此，我们可以通过ognl命令获取到。

1
2
3
4
5

$ ognl '#context=@com.alibaba.dubbo.config.spring.extension.SpringExtensionFactory@contexts.iterator.next, #context.getBean("userServiceImpl").findUser(1)'
@User[
    id=@Integer[1],
    name=@String[Deanna Borer],
]

• `SpringExtensionFactory@contexts.iterator.next获取到SpringExtensionFactory`里保存的spring context对象
• #context.getBean("userServiceImpl").findUser(1) 获取到userServiceImpl再执行一次调用

只要充分发挥想像力，组合Arthas里的各种命令，可以发挥出神奇的效果。

总结

本篇文章来自杭州Dubbo Meetup的分享《当DUBBO遇上Arthas - 排查问题的实践》，希望对大家线上排查Dubbo问题有帮助。

分享的PDF可以在 https://github.com/alibaba/arthas/issues/327 里下载。

1. Windows平台用户体验不好
2. Attach的进程和最终连接的进程不一致
3. 某些环境下没有安装Telnet，不能连接到Arthas Server
4. 本地启动，不需要下载远程（很多公司安全考虑）
5. 下载速度慢（默认从maven central repository下载）

在Arthas 3.0.5版本里，我们在用户体验方面做了很多改进，下面逐一介绍。

• Github: https://github.com/alibaba/arthas
• 文档：https://alibaba.github.io/arthas/

全平台通用的arthas-boot

arthas-boot是新增加的支持全平台的启动器，Windows/Mac/Linux下使用体验一致。下载后，直接java -jar命令启动：

1
2

wget https://alibaba.github.io/arthas/arthas-boot.jar
java -jar arthas-boot.jar

arthas-boot的功能比以前的as.sh更强大。

• 比如下载速度比较慢，可以指定阿里云的镜像。

  1	java -jar arthas-boot.jar --repo-mirror aliyun --use-http

• 比如可以通过session-timeout指定超时时间：

  1	java -jar arthas-boot.jar --session-timeout 3600

• 更多的功能可以通过java -jar arthas-boot.jar -h查看

arthas-boot在attach成功之后，会启动一个java telent client去连接Arthas Server，用户没有安装telnet的情况下也可以正常使用。

优先使用当前目录的Arthas

在新版本里，默认会从arthas-boot.jar和as.sh所在的目录下查找arthas home，这样子用户全量安装之后，不需要再从远程下载Arthas。

• 用户可以更方便地集成到自己的基础镜像，或者docker镜像里
• 对安全要求严格的公司，不用再担心从远程下载的问题

Attach之前先检测端口

在之前的版本里，用户困扰最多的是，明明选择了进程A，但是实际连接到的却是进程B。

原因是之前attach了进程B，没有执行shutdown，下次再执行时，还是连接到进程B。

在新版本里，做了改进：

• 在attach之前，检测使用3658端口的进程
• 在Attach时，如果端口和进程不匹配，会打印出ERROR信息

1
2
3
4
5
6
7
8
9
10

$ java -jar arthas-boot.jar
[INFO] Process 1680 already using port 3658
[INFO] Process 1680 already using port 8563
* [1]: 1680 Demo
  [2]: 35542
  [3]: 82334 Demo
3
[ERROR] Target process 82334 is not the process using port 3658, you will connect to an unexpected process.
[ERROR] If you still want to attach target process 82334, Try to set a different telnet port by using --telnet-port argument.
[ERROR] Or try to shutdown the process 1680 using the telnet port first.

更好的历史命令匹配功能

• 新版本对键盘Up/Down有了更好的匹配机制，试用有惊喜:)

  比如执行了多次trace，但是在命令行输入 trace后，想不起来之前trace的具体类名，那么按Up，可以很轻松地匹配到之前的历史命令，不需要辛苦翻页。

• 新版本增加了history命令

改进Web Console的体验

• 改进对Windows的字体支持

  之前Windows下面使用的是非等宽字体，看起来很难受。新版本里统一为等宽字体。

• 增大字体，不再伤害眼睛

新增sysenv命令

sysenv命令和sysprop类似，可以打印JVM的环境变量。

• https://alibaba.github.io/arthas/sysenv.html

新增ognl命令

ognl命令提供了单独执行ognl脚本的功能。可以很方便调用各种代码。

比如执行多行表达式，赋值给临时变量，返回一个List：

1
2
3
4
5

$ ognl '#value1=@System@getProperty("java.home"), #value2=@System@getProperty("java.runtime.name"), {#value1, #value2}'
@ArrayList[
    @String[/opt/java/8.0.181-zulu/jre],
    @String[OpenJDK Runtime Environment],
]

• https://alibaba.github.io/arthas/ognl.html

watch命令打印耗时，更方便定位性能瓶颈

之前watch命令只支持打印入参返回值等，新版本同时打印出调用耗时，可以很方便定位性能瓶颈。

1
2
3
4
5
6
7

$ watch demo.MathGame primeFactors 'params[0]'
Press Ctrl+C to abort.
Affect(class-cnt:1 , method-cnt:1) cost in 22 ms.
ts=2018-11-29 17:53:54; [cost=0.131383ms] result=@Integer[-387929024]
ts=2018-11-29 17:53:55; [cost=0.132368ms] result=@Integer[-1318275764]
ts=2018-11-29 17:53:56; [cost=0.496598ms] result=@Integer[76446257]
ts=2018-11-29 17:53:57; [cost=4.9617ms] result=@Integer[1853966253]

• https://alibaba.github.io/arthas/watch.html

改进类搜索匹配功能，更好支持lambda和内部类

之前的版本里，在搜索lambda类时，或者反编绎lambda类有可能会失败。新版本做了修复。比如

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

$ jad Test$$Lambda$1/1406718218

ClassLoader:
+-sun.misc.Launcher$AppClassLoader@5c647e05
  +-sun.misc.Launcher$ExtClassLoader@3c1491ce

Location:
/tmp/classes

/*
 * Decompiled with CFR 0_132.
 *
 * Could not load the following classes:
 *  Test
 *  Test$$Lambda$1
 */
import java.lang.invoke.LambdaForm;
import java.util.function.Consumer;

final class Test$$Lambda$1
implements Consumer {
    private Test$$Lambda$1() {
    }

    @LambdaForm.Hidden
    public void accept(Object object) {
        Test.lambda$0((Integer)((Integer)object));
    }
}

更好的tab自动补全

改进了很多命令的tab自动补全功能，有停顿时，可以多按tab尝试下。

Release Note

详细的Release Note：https://github.com/alibaba/arthas/releases/tag/arthas-all-3.0.5

随着应用越来越复杂，依赖越来越多，日志系统越来越混乱，有时会出现一些奇怪的日志，比如：

1

[] [] [] No credential found

那么怎样排查这些奇怪的日志从哪里打印出来的呢？因为搞不清楚是什么logger打印出来的，所以想定位就比较头疼。

下面介绍用Alibaba开源的应用诊断利器Arthas的redefine命令快速定位奇怪日志来源。

• Arthas: https://github.com/alibaba/arthas
• redefine命令：https://alibaba.github.io/arthas/redefine.html

修改StringBuilder

首先在java代码里，字符串拼接基本都是通过StringBuilder来实现的。比如下面的代码：

1
2
3

public static String hello(String world) {
return "hello " + world;
}

实际上生成的字节码也是用StringBuilder来拼接的：

1
2
3
4
5
6
7
8
9
10
11
12
13

public static java.lang.String hello(java.lang.String);
  descriptor: (Ljava/lang/String;)Ljava/lang/String;
  flags: ACC_PUBLIC, ACC_STATIC
  Code:
    stack=3, locals=1, args_size=1
       0: new           #22                 // class java/lang/StringBuilder
       3: dup
       4: ldc           #24                 // String hello
       6: invokespecial #26                 // Method java/lang/StringBuilder."<init>":(Ljava/lang/String;)V
       9: aload_0
      10: invokevirtual #29                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      13: invokevirtual #33                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
      16: areturn

在java的logger系统里，输出日志时通常也是StringBuilder来实现的，最终会调用StringBuilder.toString()，那么我们可以修改StringBuilder的代码来检测到日志来源。

StringBuilder.toString() 的原生实现是：

1
2
3
4
5

@Override
public String toString() {
    // Create a copy, don't share the array
    return new String(value, 0, count);
}

修改为：

1
2
3
4
5
6
7
8
9
10

@Override
public String toString() {
    // Create a copy, don't share the array
String result = new String(value, 0, count);
if(result.contains("No credential found")) {
System.err.println(result);
new Throwable().printStackTrace();
}
    return result;
}

增加的逻辑是：当String里包含No credential found时打印出当前栈，这样子就可以定位日志输出来源了。

编绎修改过的StringBuilder

其实很简单，在IDE里把StringBuilder的代码复制一份，然后贴到任意一个工程里，然后编绎即可。

也可以直接用javac来编绎：

1

javac StringBuilder.java

启动应用，使用Arthas redefine修改过的StringBuilder

启动应用后，在奇怪日志输出之前，先使用arthas attach应用，再redefine StringBuilder:

1
2

$ redefine -p /tmp/StringBuilder.class
redefine success, size: 1

当执行到输出[] [] [] No credential found的logger代码时，会打印当前栈。实际运行结果是：

1
2
3
4
5
6
7
8
9
10
11
12

[] [] [] No credential found
java.lang.Throwable
at java.lang.StringBuilder.toString(StringBuilder.java:410)
at com.taobao.middleware.logger.util.MessageUtil.getMessage(MessageUtil.java:26)
at com.taobao.middleware.logger.util.MessageUtil.getMessage(MessageUtil.java:15)
at com.taobao.middleware.logger.slf4j.Slf4jLogger.info(Slf4jLogger.java:77)
at com.taobao.spas.sdk.common.log.SpasLogger.info(SpasLogger.java:18)
at com.taobao.spas.sdk.client.identity.CredentialWatcher.loadCredential(CredentialWatcher.java:128)
at com.taobao.spas.sdk.client.identity.CredentialWatcher.access$200(CredentialWatcher.java:18)
at com.taobao.spas.sdk.client.identity.CredentialWatcher$1.run(CredentialWatcher.java:58)
at java.util.TimerThread.mainLoop(Timer.java:555)
at java.util.TimerThread.run(Timer.java:505)

可以看到是spas.sdk打印出了[] [] [] No credential found的日志。

总结

• logger最终会用StringBuilder来输出
• 修改StringBuilder来定位输出特定日志的地方
• 使用Arthas redefine命令来加载修改过的StringBuilder
• redefine命令实际上实现了任意代码线上debug的功能，可以随意本地修改代码重新编绎，然后线上redefine加载
• redefine的功能过于强大，所以请小心使用:)

Arthas实践系列

• 使用Arthas抽丝剥茧排查线上应用日志打满问题
• 深入Spring Boot：利用Arthas排查NoSuchMethodError

在应用的 service_stdout.log里一直输出下面的日志，直接把磁盘打满了：

1
2
3
4

23:07:34.441 [TAIRCLIENT-1-thread-1] DEBUG io.netty.channel.nio.NioEventLoop - Selector.select() returned prematurely 14 times in a row.
23:07:34.460 [TAIRCLIENT-1-thread-3] DEBUG io.netty.channel.nio.NioEventLoop - Selector.select() returned prematurely 3 times in a row.
23:07:34.461 [TAIRCLIENT-1-thread-4] DEBUG io.netty.channel.nio.NioEventLoop - Selector.select() returned prematurely 3 times in a row.
23:07:34.462 [TAIRCLIENT-1-thread-5] DEBUG io.netty.channel.nio.NioEventLoop - Selector.select() returned prematurely 3 times in a row.

service_stdout.log是进程标准输出的重定向，可以初步判定是tair插件把日志输出到了stdout里。

尽管有了初步的判断，但是具体logger为什么会打到stdout里，还需要进一步排查，常见的方法可能是本地debug。

下面介绍利用arthas直接在线上定位问题的过程，主要使用sc和getstatic命令。

• https://alibaba.github.io/arthas/sc.html
• https://alibaba.github.io/arthas/getstatic.html

定位logger的具体实现

日志是io.netty.channel.nio.NioEventLoop输出的，到netty的代码里查看，发现是DEBUG级别的输出：

• https://github.com/netty/netty/blob/netty-4.0.35.Final/transport/src/main/java/io/netty/channel/nio/NioEventLoop.java#L673

然后用arthas的sc命令来查看具体的io.netty.channel.nio.NioEventLoop是从哪里加载的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

class-info        io.netty.channel.nio.NioEventLoop
 code-source       file:/opt/app/plugins/tair-plugin/lib/netty-all-4.0.35.Final.jar!/
 name              io.netty.channel.nio.NioEventLoop
 isInterface       false
 isAnnotation      false
 isEnum            false
 isAnonymousClass  false
 isArray           false
 isLocalClass      false
 isMemberClass     false
 isPrimitive       false
 isSynthetic       false
 simple-name       NioEventLoop
 modifier          final,public
 annotation
 interfaces
 super-class       +-io.netty.channel.SingleThreadEventLoop
                     +-io.netty.util.concurrent.SingleThreadEventExecutor
                       +-io.netty.util.concurrent.AbstractScheduledEventExecutor
                         +-io.netty.util.concurrent.AbstractEventExecutor
                           +-java.util.concurrent.AbstractExecutorService
                             +-java.lang.Object
 class-loader      +-tair-plugin's ModuleClassLoader
 classLoaderHash   73ad2d6

可见，的确是从tair插件里加载的。

查看NioEventLoop的代码，可以发现它有一个logger的field：

1
2
3

public final class NioEventLoop extends SingleThreadEventLoop {

    private static final InternalLogger logger = InternalLoggerFactory.getInstance(NioEventLoop.class);

使用arthas的getstatic命令来查看这个logger具体实现类是什么（使用-c参数指定classloader）：

1
2
3

$ getstatic -c 73ad2d6 io.netty.channel.nio.NioEventLoop logger 'getClass().getName()'
field: logger
@String[io.netty.util.internal.logging.Slf4JLogger]

可以发现是Slf4JLogger。

再查看io.netty.util.internal.logging.Slf4JLogger的实现，发现它内部有一个logger的field：

1
2
3
4
5
6
7
8
9
10
11

package io.netty.util.internal.logging;

import org.slf4j.Logger;

/**
 * <a href="http://www.slf4j.org/">SLF4J</a> logger.
 */
class Slf4JLogger extends AbstractInternalLogger {
    private static final long serialVersionUID = 108038972685130825L;

    private final transient Logger logger;

那么使用arthas的getstatic命令来查看这个logger属性的值：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

$ getstatic -c 73ad2d6 io.netty.channel.nio.NioEventLoop logger 'logger'
field: logger
@Logger[
    serialVersionUID=@Long[5454405123156820674],
    FQCN=@String[ch.qos.logback.classic.Logger],
    name=@String[io.netty.channel.nio.NioEventLoop],
    level=null,
    effectiveLevelInt=@Integer[10000],
    parent=@Logger[Logger[io.netty.channel.nio]],
    childrenList=null,
    aai=null,
    additive=@Boolean[true],
    loggerContext=@LoggerContext[ch.qos.logback.classic.LoggerContext[default]],
]

可见，logger的最本质实现类是：ch.qos.logback.classic.Logger。

再次用getstatic命令来确定jar包的location：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

$ getstatic -c 73ad2d6 io.netty.channel.nio.NioEventLoop logger 'logger.getClass().getProtectionDomain().getCodeSource().getLocation()'
field: logger
@URL[
    BUILTIN_HANDLERS_PREFIX=@String[sun.net.www.protocol],
    serialVersionUID=@Long[-7627629688361524110],
    protocolPathProp=@String[java.protocol.handler.pkgs],
    protocol=@String[jar],
    host=@String[],
    port=@Integer[-1],
    file=@String[file:/opt/app/plugins/tair-plugin/lib/logback-classic-1.2.3.jar!/],
    query=null,
    authority=@String[],
    path=@String[file:/opt/app/plugins/tair-plugin/lib/logback-classic-1.2.3.jar!/],
    userInfo=null,
    ref=null,
    hostAddress=null,
    handler=@Handler[com.taobao.pandora.loader.jar.Handler@1a0c361e],
    hashCode=@Integer[126346621],
    tempState=null,
    factory=@TomcatURLStreamHandlerFactory[org.apache.catalina.webresources.TomcatURLStreamHandlerFactory@3edd7b7],
    handlers=@Hashtable[isEmpty=false;size=4],
    streamHandlerLock=@Object[java.lang.Object@488ccac9],
    serialPersistentFields=@ObjectStreamField[][isEmpty=false;size=7],
]

可见这个ch.qos.logback.classic.Logger的确是tair插件里加载的。

定位logger的level

上面已经定位logger的实现类是ch.qos.logback.classic.Logger，但是为什么它会输出DEBUG level的日志？

其实在上面的getstatic -c 73ad2d6 io.netty.channel.nio.NioEventLoop logger 'logger'输出里，已经打印出它的level是null了。如果对logger有所了解的话，可以知道当child logger的level为null时，它的level取决于parent logger的level。

我们再来看下ch.qos.logback.classic.Logger的代码，它有一个parent logger的属性：

1
2
3
4
5
6
7

public final class Logger implements org.slf4j.Logger, LocationAwareLogger, AppenderAttachable<ILoggingEvent>, Serializable {

    /**
     * The parent of this category. All categories have at least one ancestor
     * which is the root category.
     */
    transient private Logger parent;

所以，我们可以通过getstatic来获取到这个parent属性的内容。然后通过多个parent操作，可以发现level都是null，最终发现ROOT level是DEBUG 。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

$ getstatic -c 73ad2d6 io.netty.channel.nio.NioEventLoop logger 'logger.parent.parent.parent.parent.parent'
field: logger
@Logger[
    serialVersionUID=@Long[5454405123156820674],
    FQCN=@String[ch.qos.logback.classic.Logger],
    name=@String[ROOT],
    level=@Level[DEBUG],
    effectiveLevelInt=@Integer[10000],
    parent=null,
    childrenList=@CopyOnWriteArrayList[isEmpty=false;size=2],
    aai=@AppenderAttachableImpl[ch.qos.logback.core.spi.AppenderAttachableImpl@1ecf9bae],
    additive=@Boolean[true],
    loggerContext=@LoggerContext[ch.qos.logback.classic.LoggerContext[default]],
]

所以 io.netty.channel.nio.NioEventLoop的logger的level取的是ROOT logger的配置，即默认值DEBUG。

具体实现可以查看ch.qos.logback.classic.LoggerContext

1
2
3
4
5
6
7
8
9
10
11
12

public LoggerContext() {
    super();
    this.loggerCache = new ConcurrentHashMap<String, Logger>();

    this.loggerContextRemoteView = new LoggerContextVO(this);
    this.root = new Logger(Logger.ROOT_LOGGER_NAME, null, this);
    this.root.setLevel(Level.DEBUG);
    loggerCache.put(Logger.ROOT_LOGGER_NAME, root);
    initEvaluatorMap();
    size = 1;
    this.frameworkPackages = new ArrayList<String>();
}

为什么logback输出到了stdout里

上面我们得到结论

• tair插件里的logback默认的level是DEBUG，导致netty里的日志可以被打印出来

那么我们可以猜测：

• tair里的logback没有特殊配置，或者只配置了tair自己的package，导致ROOT logger的日志直接输出到stdout里

那么实现上tair里是使用了logger-api，它通过LoggerFactory.getLogger函数获取到了自己package的logger，然后设置level为INFO，并设置了appender。

换而言之，tair插件里的logback没有设置ROOT logger，所以它的默认level是DEBUG，并且默认的appender会输出到stdout里。

所以tair插件可以增加设置ROOT logger level为INFO来修复这个问题。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

private static com.taobao.middleware.logger.Logger logger
= com.taobao.middleware.logger.LoggerFactory.getLogger("com.taobao.tair");
public static com.taobao.middleware.logger.Logger infolog
= com.taobao.middleware.logger.LoggerFactory.getLogger("com.taobao.tair.custom-infolog");

public static int JM_LOG_RETAIN_COUNT = 3;
public static String JM_LOG_FILE_SIZE = "200MB";

static {
try {
String tmp = System.getProperty("JM.LOG.RETAIN.COUNT", "3");
JM_LOG_RETAIN_COUNT = Integer.parseInt(tmp);
} catch (NumberFormatException e) {
}
JM_LOG_FILE_SIZE = System.getProperty("JM.LOG.FILE.SIZE", "200MB");

logger.setLevel(Level.INFO);
logger.activateAppenderWithSizeRolling("tair-client", "tair-client.log", "UTF-8",
TairUtil.splitSize(JM_LOG_FILE_SIZE, 0.8 / (JM_LOG_RETAIN_COUNT + 1)), JM_LOG_RETAIN_COUNT);
logger.setAdditivity(false);
logger.activateAsync(500, 100);

logger.info("JM_LOG_RETAIN_COUNT " + JM_LOG_RETAIN_COUNT + " JM_LOG_FILE_SIZE " + JM_LOG_FILE_SIZE);

infolog.setLevel(Level.INFO);
infolog.activateAppenderWithSizeRolling("tair-client", "tair-client-info.log", "UTF-8", "10MB", 1);
infolog.setAdditivity(false);
infolog.activateAsync(500, 100);

总结

• tair插件里直接以api的方式设置了自己package下的logger
• tair插件里netty的logger的packge和tair并不一样，所以它最终取的是ROOT logger的配置
• logback默认的ROOT logger level是DEBUG，输出是stdout
• 利用arthas的sc命令定位具体的类
• 利用arthas的getstatic获取static filed的值
• 利用logger parent层联的特性，可以向上一层层获取到ROOT logger的配置

链接

• Arthas开源：https://github.com/alibaba/arthas

有时spring boot应用会遇到java.lang.NoSuchMethodError的问题，下面以具体的demo来说明怎样利用arthas来排查。

Demo: https://github.com/hengyunabc/spring-boot-inside/tree/master/demo-NoSuchMethodError

在应用的main函数里catch住异常，保证进程不退出

很多时候当应用抛出异常后，进程退出了，就比较难排查问题。可以先改下main函数，把异常catch住：

1
2
3
4
5
6
7
8
9

public static void main(String[] args) throws IOException {
try {
SpringApplication.run(DemoNoSuchMethodErrorApplication.class, args);
} catch (Throwable e) {
e.printStackTrace();
}
// block
System.in.read();
}

Demo启动之后，抛出的异常是：

1
2
3
4
5
6
7
8

java.lang.NoSuchMethodError: org.springframework.core.annotation.AnnotationAwareOrderComparator.sort(Ljava/util/List;)V
at org.springframework.boot.SpringApplication.getSpringFactoriesInstances(SpringApplication.java:394)
at org.springframework.boot.SpringApplication.getSpringFactoriesInstances(SpringApplication.java:383)
at org.springframework.boot.SpringApplication.initialize(SpringApplication.java:249)
at org.springframework.boot.SpringApplication.<init>(SpringApplication.java:225)
at org.springframework.boot.SpringApplication.run(SpringApplication.java:1118)
at org.springframework.boot.SpringApplication.run(SpringApplication.java:1107)
at com.example.demoNoSuchMethodError.DemoNoSuchMethodErrorApplication.main(DemoNoSuchMethodErrorApplication.java:13)

显然，异常的意思是AnnotationAwareOrderComparator缺少sort(Ljava/util/List;)V这个函数。

安装arthas

参考：https://alibaba.github.io/arthas/install-detail.html

使用sc命令查找类所在的jar包

应用需要抛出了异常，但是进程还没有退出，我们用arthas来attach上去。比如在mac下面：

1

./as.sh

然后选择com.example.demoNoSuchMethodError.DemoNoSuchMethodErrorApplication进程。

再执行sc命令来查找类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

$ sc -d org.springframework.core.annotation.AnnotationAwareOrderComparator
 class-info        org.springframework.core.annotation.AnnotationAwareOrderComparator
 code-source       /Users/hengyunabc/.m2/repository/org/springframework/spring/2.5.6.SEC03/spring-2.5.6.SEC03.jar
 name              org.springframework.core.annotation.AnnotationAwareOrderComparator
 isInterface       false
 isAnnotation      false
 isEnum            false
 isAnonymousClass  false
 isArray           false
 isLocalClass      false
 isMemberClass     false
 isPrimitive       false
 isSynthetic       false
 simple-name       AnnotationAwareOrderComparator
 modifier          public
 annotation
 interfaces
 super-class       +-org.springframework.core.OrderComparator
                     +-java.lang.Object
 class-loader      +-sun.misc.Launcher$AppClassLoader@5c647e05
                     +-sun.misc.Launcher$ExtClassLoader@689e3d07
 classLoaderHash   5c647e05

Affect(row-cnt:1) cost in 41 ms.

可以看到AnnotationAwareOrderComparator是从spring-2.5.6.SEC03.jar里加载的。

使用jad查看反编绎的源代码

下面使用jad命令来查看AnnotationAwareOrderComparator的源代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

$ jad org.springframework.core.annotation.AnnotationAwareOrderComparator

ClassLoader:
+-sun.misc.Launcher$AppClassLoader@5c647e05
  +-sun.misc.Launcher$ExtClassLoader@689e3d07

Location:
/Users/hengyunabc/.m2/repository/org/springframework/spring/2.5.6.SEC03/spring-2.5.6.SEC03.jar

/*
 * Decompiled with CFR 0_132.
 */
package org.springframework.core.annotation;

import java.lang.annotation.Annotation;
import org.springframework.core.OrderComparator;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;

public class AnnotationAwareOrderComparator
extends OrderComparator {
    protected int getOrder(Object obj) {
        Order order;
        if (obj instanceof Ordered) {
            return ((Ordered)obj).getOrder();
        }
        if (obj != null && (order = obj.getClass().getAnnotation(Order.class)) != null) {
            return order.value();
        }
        return Integer.MAX_VALUE;
    }
}

Affect(row-cnt:1) cost in 286 ms.

可见，AnnotationAwareOrderComparator的确没有sort(Ljava/util/List;)V函数。

排掉依赖，解决问题

从上面的排查里，可以确定

• AnnotationAwareOrderComparator来自spring-2.5.6.SEC03.jar，的确没有sort(Ljava/util/List;)V函数。

所以，可以检查maven依赖，把spring 2的jar包排掉，这样子就可以解决问题了。

总结

• 仔细看NoSuchMethodError的异常信息，了解是什么类缺少了什么函数
• 利用arthas来查找类，反编绎源码，确认问题

链接

• Arthas–Alibaba开源Java诊断利器

当用户在自己的spring boot main class上面显式使用了@EnableWebMvc，发现原来的放在 src/main/resources/static 目录下面的静态资源访问不到了。

1
2
3
4
5
6
7