楼主肯定把增量覆盖率的私货藏起来了

请来第三发，谢谢

增量来一发

--- 统一回复下一楼和三楼：
@link1220 @dancingcat_
其实增量的我觉得目前粗粒度的来说，AngryTester 做的已经差不多可以了，精细到方法。
那再有详细一点的可以用 gitdiff，做更精细化的检视，精确到某一行，这个看个人就行了。
但是精确到方法，用 MD5 来做精准化判定是否变更，可能会有一些问题存在，比如：

精细到方法粒度，可能小的变化就认为了变更。
像方法头部的注释，方法内部的局部变量优化，都可能带来方法的变更。

所以可以自行来决定如何判定方法变更，实现更细粒度的判别，不至于误判，可能你加了一个@param的注释，这个方法就进到变更覆盖率统计里了。
这个场景在我们这里遇到过，有人反馈说这个代码一点没有变，为啥统计成变更了，我分析过后就是这个原因。

AngryTester的原库在这里（可能发现我经常提到这个人，因为我很大一部分灵感与这个大兄弟，站在了他的肩膀上，哈哈，很感谢他）
地址: AngryTester/jacoco

顶，说的很详细透彻

加精理由：不加精说不过去

哇哦，首精唉。谢谢大佬

大佬。学习了

楼主再多分享点干货

陈老师白闹，肚子空空哪有干货，都是坏水

陈老师多分享下你的摄影技术

也得益于今年上半年一直负责整个公司不同类型的项目的覆盖率统计技术的适配，对不同形式的项目均有一定的了解，在此记录一下，也不让千疮百孔的自己浪费掉这半年的精力，如果说可以帮到别人一星半点，那这篇文章就算是造福了。

感谢楼主分享~~~超级棒~

咨询楼主一个问题：因为线下测试的时候会出现多次发布，怎么把这多次发布的覆盖度结果进行合并？原生的 jacoco 合并或追加都是在源码未发生变化的时候才可以，期待楼主解惑！
感谢楼主分享！

就本质上来说，覆盖率报告的生成，只需要两个必须的东西，一个是 class 文件，一个是针对这些 class 产生的执行信息 (就是 exec 文件)。
当然了源码起到很重要的作用就是可以让你在报告里面来回跳转查看代码详情，如果没有源码，则没办法点进去方法。
综上来说，那也可以说成一个完善的覆盖率报告，可以有源码、class 文件、和对应的 exec 文件即可。

回到你的问题，针对你的变更，结合到这三个东西那就可以有以下合并的结论：

1. 首先，最先想到的就是多次发布产生的exec 合并，当然这是 jacoco 原本就支持的，或者说是 exec 文件本身的特性 - 支持合并
2. 第二，基于第一步，当然可以合并多次发布的报告，但也会有一些风险
3. 第三，风险 1，就是 exec 虽然可以合并，但是每次发布的时候，class 文件的变更，可能会导致同一个 class 在不同阶段中会有不同的形态，那会不会有覆盖率数据不准的问题，这个有待讨论
4. 第四，风险 2，多次发布，因为中间有停顿时间，或者覆盖率数据的收集有没有一定的时间间隔，会不会因为多次发布导致有些执行步骤的覆盖率信息没有收集到，这也在一定程度上可能会导致覆盖率数据的不准，甚至丢失
5. 第五，风险 3，多次发布，有没有可能在写入 exec 的时候，会导致数据写到一半的时候被停机，导致 exec 文件本身变得不完整，这有可能导致覆盖率数据不准，甚至有可能导致文件不完整，让 jacoco 没法读取这些信息、

综上步骤，可以简单得出，你的问题，在一定程度上可以做到，但最终能到什么地步，取决于你对这几个风险的把控，要么你可以忽略，要么你可以深度解析一下源码，看看有没有什么解决方案或者规避方案。

当然，这也是我个人现阶段对它的认知，猜出来的解决方案，也可能不对，但总归是个思路~希望可以帮到您

多谢楼主回答问题！
现在从实际验证来看（可以确定楼主的第四、第五不存在，应用仅我一个人使用）：

1. 第一次源码文件有一个方法，测试使其已覆盖，并拉取 exec。
2. 编辑源码文件，新增一个方法，测试使其覆盖，并拉取 exec。
3. 合并两次结果文件，生成报告，此时仅能看到新增的方法被覆盖

我再想想其他办法，从报告生成方面想想办法，再次感谢

楼主 最近遇到一个问题，就是我们是用 duubo 分布式服务，其中 was 服务是部署在 tomcat 里面，我可以修改 tomcat 启动参数监控，但 das 服务是部署在其他机器里面，是一个服务进程 (java -cp "./bin:../libs/*:." -Ddubbo.shutdown.hook=true "com.yjhealth.pcloud.dat
) 这样启动的服务，好像监控不到。这个要怎么处理，我是 Jenkins 大包部署的
然后就是启动参数修改 不用 jacocoagent 安装路径吗

没太明白你的问题出在哪儿，所以不能准确回答你的问题。。
但想说一点，就 jacoco 本身而言，如果你的服务启动的时候，不经过 jacocoagent 的代理程序，那么都是检测不到的。
当然了，即使你经过了 jacocoagent 的代理，也有可能是出不来的，出不来的原因就有很多了。

你可以再详细描述下问题。

嗯嗯，希望可以帮到你了。
等你研究完了可分享出来供大家食用，哈哈

@ 风雨夜阑听 楼主你好，我们遇到这个问题 “do no match with execution data. For report generation the same class files must be used as at runtime”，“Execution data for class com/xxxx does not match”。我也同步了发布的编译的 JDk，但是还是没有解决。

这个看起来就是你的构建 jdk 和你运行时的 jdk 不一致，最好是要保持一致。

在哪儿构建，就在哪儿运行，如果不能做到这样，那就干脆生成报告的时候，class 文件、源代码、和 exec 文件直接从运行时的机器上复制。

你可以看下我上面的回复，生成报告，要想准确，就得源码、class 文件、exec 最好是同一批构建的产物，当然不排除有时候分开也可以，但最好是要保证同一批~~

希望可以帮到你

你可以了解下 class 文件的构造，开头有一串东西 (好像叫魔数啥的)，是用来区分 jdk 相关的东西的，差别过大，可能就会被认为不匹配了。

@ 风雨夜阑听 多谢回复，构建 jdk 和运行时的 jdk 我都检查了，没有问题。现在编译打包是在 jenkins 的服务器，JDK 版本也是一致的。方便加一下微信吗？18520825002

楼主你好，首先非常感谢你的分享~
想问下，如果只想要知道代码变更的影响范围，来辅助测试的测试范围，可以通过插桩来实现吗？求指点

谢阅。
影响范围这个话题是比较大的，也很难一句两句说清楚。不过按照我当前能力的理解，对测试来说，最粗粒度的可以做到检测出变更的方法或者类，出现在哪些请求的调用链上，也就是说被哪些类的哪些方法调用了，这才是测试应该关注的。如果其他的请求链路，没有出现变更方法的调用，那从一定程度上一定范围内是安全的。所以你可以按照这个思路来想想可以做点什么，至于用到的技术和一些，我有些建议，但我没有完全试验过，所以可以看看能否参考：

• 1.你可以通过解析新版本的字节码，把整个应用的调用链路给解析出来，当然了这个调用链路多数情况下会有多颗树组成，对整个应用来说，最终会是一个由多个调用树组成的森林。这个用 ASM 字节码解析，应该可以做到，但数据量可能比较大，怎么存储怎么展示，可能需要细想，在 java 层可以想办法以 hashmap 来存。
• 2. 上面的森林拿到之后，可以根据新代码的源码和基线代码的源码，来解析变更类和方法，看你怎么存储，差不多可以拿到一个变更方法的列表 (当然也会有该方法的类信息存在)。
• 3. 结合上面的调用关系森林和变更方法的列表，可以初步判断在调用森林里，哪些树中的哪些路径是包含了变更方法的，针对这些请求链路，可以看看怎么补充测试。整个调用关系的存储，之前请教过思寒，可以尝试用 neo4j 或者 kibana 来处理，或者你有其他的思路也可以尝试下

当然了，以上只是我的设想，我之前也做过尝试，只简单做到了 1 和 2，至于 3 嘛，存储和展示都需要一定的技术和资源，我并没有深入研究下去，当然可能会有一定难度，但我之前想到的也就是这个思路。我这想的都比较浅，不知道会不会对你有所帮助。

感谢楼主这么认真的回复，我也有试想过尝试用变更代码的调用关系去判断影响范围，但觉得这样是远远不够的，可能会有更多更深的影响范围，有点累觉不爱了

问题描述：项目有 4 个应用包，一个放在 181 服务器 tomcat 里面，前端代码也是这个 tomcat，其他三个应用是放在 182 服务器，启动是用 java -jar 方式启动， 项目是用 dubbo 框架。 现在有两个问题：1. 181 我修改了 tomcat 配置，加了 JavaAgent 监控，可以拿到覆盖率，但 182 上面三个应用没有 tomcat 怎么拿到覆盖率？ 我参试了在 java -jar 启动参数里面增加 JavaAgent，开启了三个监控端口，不知道是否可行？ 2. 这 4 个应用的覆盖率报告如何合并然后显示在 Jenkins 里面？

感谢提问，其实我对 jacoco 的理解也是有限的，很多原理性的东西或者更深入的东西我也不会 。
看完描述，我首先想到的是贤弟 (妹) 可能没有读完这个文章的内容，这个怪我文笔不好写的太啰嗦了，道个歉哈。
本身没有搞清楚你这四个工程是个怎样的结构，我姑且以为你这个四个工程属于父子工程（隶属一个 git url,而不是项目间交互），以此为基准，下面就聊聊你提到的几个点：

问点 1： 项目是用 dubbo 框架

答： 首先你提到 dubbo 框架让我心里一虚，因为我对 dubbo 的理解只停留在表面，所以我只能按照我理解的来说 (当然可能会错,这个需要你识别一下哈。)
dubbo 本身是基于接口进行的调用，所以你对 dubbo 的调用覆盖，势必要到 provider 端 (因为实现都在 provider 端)，一般来说，dubbo 项目会专门提供一个 client 端的 jar 包或者 GAV(通常是纯接口)，供 consumer 端调用，这至少在我理解的我们公司项目是这样。就比如你的 A B C D 四个项目，可能你对 A 项目发起的请求，它内部通过 dubbo 调用了 D(provider) 项目的接口，那么相当于你对 A 项目进行测试，那么这一部分测试一方面覆盖率你 A 项目的部分代码，另一部分也覆盖到了 D 项目的代码实现，虽然你在 A 项目中有用到一部分 D 项目的代码，但是可能它提供的都是接口，你 (应该) 是没办法统计到这些 D 项目中的具体实现。这个要计划清楚

问点 2： 但 182 上面三个应用没有 tomcat 怎么拿到覆盖率

答: jacoco 的本质工作机制，并不依赖于哪个 web 容器，它需要的是一个动态的或者静态字节码插桩，就是你这个应用或者 java 代码不管将来怎么运行，这并不重要，重要的是要给它插桩的时机 (也就是 class 的生成和运行)。这个点理清楚了，你下一个问题也就不是问题了。所以你这个问题就追溯到上面提到工作机制的 java -jar，如果你最后没有收到覆盖率数据，那我猜可能是启动命令写错了或者端口没有规划好，或者去参考下文章说的那些覆盖率报告为 0 的场景，有没有命中。

问点 3： 我参（尝？）试了在 java -jar 启动参数里面增加 JavaAgent，开启了三个监控端口，不知道是否可行

答： 肯定是可行的 ，完全支持这种机制。

问点 4： 这 4 个应用的覆盖率报告如何合并然后显示在 Jenkins 里面？

答前半句 (能否合并):

• 肯定是 OK 的，具体去看下这个文章的主题 (十二),覆盖率数据是可以合并的。

答后半句 (能否在 Jenkins 上运行):

• 我猜你想集成到 jenkins 上。这个我没法肯定回答，因为我暂时没有用过 jenkins 去统计这个覆盖率，我一直以为 jenkins 只支持单元测试的覆盖率统计 (可能显得很没文化，孤陋寡闻了哈)。 这个建议先去了解下你希望用 jenkins 能做到什么地步，如果它支持自定义覆盖率数据 (就是 exec 或者 ec 文件)，那么结合源码和 class 文件目录，那你这个目标应该是没问题的，上面覆盖率数据合并之后丢给 jenkins 去统计就行了。 如果 jenkins 只是支持像执行单元测试那样才能统计，那我暂时没有好的建议，你或许可以发帖求助下社区。

想了解一下项目部署完生成的 class 文件以什么方式去获取的~

楼主你好，你有研究过在 Android 9 的源码代码里使用
1.cd /external/jacoco
EMMA_INSTRUMENT_STATIC=true mma
2.EMMA_INSTRUMENT_STATIC=true make ($APK_NAME)
通过这个方式来生成 coverage.em 文件吗？

楼主请问下，如下两种方式下的覆盖率如何统计
环境背景：android studio 下 sdk 项目，涉及有多个 module，同时有涉及 android ui 相关功能
1）测试中用产出 jar 包，用 jacoco 怎么做自动化测试覆盖率统计呢
2）在这个 sdk 项目中单独 module 创建的单测项目，如何统计所有 module 的覆盖率文件，就是合并在一起的那种呢

楼主好，如何才能在不重新重新部署的情况下，初始化覆盖率？让覆盖率恢复到 0%

coverage.em 应该是在 jack-server 下生产的产物吧，Android 9 取消了 jack-server 编译，配置编译链后还是 offline 下生成插装 class。

有个问题想请教下，我将服务器上的 exec 文件远程 dump 到本地生成了一个报告，然后本地也有最新的代码和 class 文件，报告生成之后能看到覆盖率数据，但是发现到方法那一层之后就不能再点开了，页面上有个提示 “Source file "com/xx/xxx/xxx.java" was not found during generation of report.”，我想点开看具体哪些语句没有覆盖就没法看，只有一个数据，请问下楼主有遇到过类似的问题没？

请问，你解决这个问题了吗。我也遇到了。按照官网的意思是说，源文件路径可能不对，但是我的源路径是对的。

这个问题已经解决了。是因为 ant build.xml 里的源码路径 好像只能写成这样。‘./src/main/java’

你好，我也遇到了跟你一样的问题，请问你现在解决了么。。。

少年，想换工作么？哈哈。

啥情况

楼主有研究过 kotlin 的增量代码差异吗？

没有呢，暂时没涉及到 kotlin 的项目需求

老哥老哥，我有一个小问题。。。我司通过 jenkins 编译部署的 dubbo 项目，我在部署服务器上做了 Jacoco 和 ant 的两个的环境和配置。但是在修改启动服务脚本的时候发现一个难过的事情，因为通过 jenkins 编译部署，所以我所有 dubbo 服务用的都是一个启动脚本，如此一来......tcpserver 的端口只能起一个啊 TA T 我起来一个服务，其他服务全起不来了。。难过，有解吗老哥。

你这个应该问题不大吧，即使你用脚本启动，也可以给 shell 脚本传端口参数吧。
不太清楚你 jenkins 去打包部署的时候是怎么做的，如果同一个项目起多个服务，那你用 jenkins 做也是 java 命令后面跟-Dspring.profile.active 这个参数或者是直接指定 port 吧，那应该直接把 jacoco 的配置传过去应该是类似的？

就是不知道我有没有准确理解你的意图

老哥老哥，是这样的，jacoco 如果用 tcp 开放 server 端的话.... 我所有服务都是一个启动脚本，但是如果我把-jacoco 这个启动配置加到启动脚本的时候， prot 用的只有一个端口，导致了只能启动一个服务，其他服务启动的时候，会提示端口占用。。不知道我这么说说明白没有。。 就是如何做到一个 jacoco 对多服务。

报告一般生成在哪里

老哥老哥 我还有一个小问题，就是我这里是 jar 包，所以我 class 路径和源文件路径是走到那一层，或者怎么写路径，我试了 xxx.jar/META-INF/xx 提示我找不到路径。

请问你的这个情况解决了么。

hi 楼主 ：
看到你上边有说到 “你可以通过解析新版本的字节码，把整个应用的调用链路给解析出来” 我想了解下 解析字节码拿到调用链路，是可以独立于源工程进行 还是需要在源工程内部进行解析，也就是说我有一个工程 A 我需要在 A 工程中添加字节码解析代码呢 还是可以新建一个工程 然后针对 A 工程的字节码进行解析就可以？

当然可以

你这样做的目的是什么呢？
如果是单项目多工程，那一般也只有一个属于启动项目，其他属于 jar 包引入，这时候需要一个 jacoco 服务也就够了；
如果是多项目多工程，那项目之间也不需要组合统计吧？一个 jacoco 服务，对着多个系统服务，即使能启动起来不报端口占用错误，那也没什么太大意义吧。
你统计数据的时候还是要按照不同的项目或者不同的系统服务来分开，但是一个 jacoco 的话，多个系统的东西都堆到这一个服务里面，覆盖率的执行数据也是同一时间保存的，那不是纯粹增加解析的工作量么。

难道仅仅是为了给服务器节省一个 jacoco 服务的启动端口？

不知道我有没有说明白~~

(关于端口占用的问题，他只是启动的时候一个提示，你可以关注一下即使报了这个端口占用错误，系统还是不时能起来的，我印象中这个不影响应用的启动，只是显示启动这个 jacoco 的 tcp 服务失败，但实际上这个 jacoco 服务 (就是之前被另一个系统启动起来的那个) 能不能统计你这个新系统的覆盖数据，你可以尝试一下，看看拉去出来的覆盖率数据有没有你的新系统的代码，这个底层细节我没有深入去看。)

这个没明白具体什么意思，可以描述清晰一些？或者直接上图~

应该是最好独立的，只需要提供 class 文件就可以解析

部署测试服务器（加入 jacoco 的代理，按照上面的方式进行即可）2 需要知道上述部署时的版本代码，需要知道待比较的基线版本代码，并下载两个代码到某个路径下，并编译最新的代码 (至于需不需要编译，看你的需求，也可以用测试服务器上的，这样最准确。现编译的话，可能会编译机跟测试机的不同，造成生成的 class 文件不一致，这会导致覆盖率数据不准确)

楼主，这里面说的从测试服务器上获取代码和生成的 class 文件是怎么实现的呢？这个有实现的例子可以参考么？

这问题属于覆盖率范畴之外的通用功能了，用代码调用 sftp 下载、执行 scp 或者 xcopy 之类的命令，都可以。
给你个样例吧，这是从一个 linux 远程服务器上下载的，根据自己需要去调整，里面有的从远程服务器下载目录的时候 finally 里的 close 我给注释掉了，因为我认为下载目录不需要每个文件都执行重连，不是很规范，这个你自己调整吧。

当然里面还有一些本地代码，你想办法自己定义一下，或者删除掉就好了，这代码里的本地和远程，代指的是当前系统的服务器 (本地),测试服务器 (远程)。
(如果这里面涉及到下载文件的安全问题啥的，可以自己调一下)

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.administrator.platform.exception.base.BusinessValidationException;

import ch.ethz.ssh2.Connection;
import ch.ethz.ssh2.SCPClient;
import ch.ethz.ssh2.SCPInputStream;
import ch.ethz.ssh2.SCPOutputStream;
import ch.ethz.ssh2.SFTPv3Client;
import ch.ethz.ssh2.SFTPv3DirectoryEntry;
import ch.ethz.ssh2.SFTPv3FileAttributes;
import ch.ethz.ssh2.Session;
import ch.ethz.ssh2.StreamGobbler;

public class GanymedSshClient {
    private static GanymedSshClient instance;

    private Session session;
    private ServerInfo serverInfo;
    private Connection connection;

    private SCPClient scpClient;
    private SFTPv3Client sftPv3Client;

    private static final String MODE = "0644";
    private static final int MKDIR_POSIX_PERMISSION = 0755;

    private static final long LENGTH = 1024;
    private static final String REMOTE_PATH_SEPARATOR = "/";
    private static final String NO_SUCH_FILE_ERROR_MESSAGE = "No such file (SSH_FX_NO_SUCH_FILE:";

    private final List<SFTPv3DirectoryEntry> childrenList = new ArrayList<>();

    private static final Logger LOGGER = LoggerFactory
            .getLogger(GanymedSshClient.class);

    private GanymedSshClient() {

    }

    public Session getSession() {
        return session;
    }

    public void setSession(Session session) {
        this.session = session;
    }

    public ServerInfo getServerInfo() {
        return serverInfo;
    }

    public void setServerInfo(ServerInfo serverInfo) {
        this.serverInfo = serverInfo;
    }

    public GanymedSshClient(ServerInfo serverInfo) {
        this.serverInfo = serverInfo;
    }

    public GanymedSshClient(String host, int port, String username,
            String password) {
        this.serverInfo = new ServerInfo(host, port, username, password);
    }

    public GanymedSshClient(String host, String username, String password) {
        this.serverInfo = new ServerInfo(host, username, password);
    }

    public GanymedSshClient(String host) {
        this.serverInfo = new ServerInfo(host);
    }

    /**
     * 初始化session
     * 
     * @see :
     * @param :
     * @return : void
     */
    private void initConnection() {
        if (null == this.connection
                || !this.connection.isAuthenticationComplete()) {
            this.connection = new Connection(this.serverInfo.getHost());
            LOGGER.debug("开始初始化连接");
            try {
                this.connection.connect();
                boolean authed = connection.authenticateWithPassword(
                        this.serverInfo.getUsername(),
                        this.serverInfo.getPassword());

                if (!authed) {
                    throw new BusinessValidationException("初始化ssh连接失败，认证异常");
                }

                LOGGER.debug("CONNECTION 初始化完成");
            } catch (IOException e) {
                LOGGER.error("初始化连接失败，失败原因:{}", e.getMessage());
                throw new BusinessValidationException("初始化连接失败");
            }
        }
    }

    private Connection getConnection() {
        initConnection();
        return this.connection;
    }

    /**
     * 初始化session
     * 
     * @see :
     * @param :
     * @return : void
     */
    private void initSession() {
        if (null == this.session) {
            LOGGER.debug("初始化session");
            try {
                this.session = getConnection().openSession();

                if (null != this.session) {
                    LOGGER.debug("session初始化完成");
                }
            } catch (IOException e) {
                LOGGER.error("获取会话失败，失败原因:{}", e.getMessage());
            }

        }
    }

    private Session getCurrentSession() {
        initSession();

        return this.session;
    }

    private SCPClient getScpClient() {
        if (null == this.scpClient) {
            this.scpClient = new SCPClient(getConnection());
        }

        return this.scpClient;

    }

    private void close() {
        if (null != this.connection) {
            this.connection.close();
            this.connection = null;
            this.scpClient = null;
        }

        if (null != this.session) {
            this.session.close();
            this.session = null;
        }

        if (null != this.sftPv3Client) {
            this.sftPv3Client.close();
            this.sftPv3Client = null;
        }
    }

    /**
     * 上传文件
     * 
     * @see :
     * @param :
     * @return : void
     * @param localFile
     * @param remoteFileName
     * @param remoteFolder
     */
    public void uploadFile(String localFile, String remoteFolder) {
        LOGGER.debug("上传文件:{}，到:{}", localFile, remoteFolder);
        try (SCPOutputStream os = getScpOutputStream(localFile, remoteFolder);
                FileInputStream fis = new FileInputStream(localFile);) {
            byte[] b = new byte[4096];
            int i;
            while ((i = fis.read(b)) != -1) {
                os.write(b, 0, i);
            }
            os.flush();
        } catch (IOException e) {
            LOGGER.error("scp 上传文件失败：{}", e.getMessage());
            throw new BusinessValidationException("上传文件失败");
        } finally {
            close();
        }
    }

    /**
     * 获取文件输出流失败
     * 
     * @see :
     * @param :
     * @return : SCPOutputStream
     * @param localFile
     * @param remoteFolder
     * @return
     */
    private SCPOutputStream getScpOutputStream(String localFile,
            String remoteFolder) {
        try {

            File file = new File(localFile);
            return getScpClient().put(file.getName(), file.length(),
                    remoteFolder, MODE);
        } catch (IOException e) {
            LOGGER.error("获取文件输出流失败:{}", e.getMessage());
            throw new BusinessValidationException("获取文件输出流失败");
        }
    }

    /**
     * 批量上传文件
     * 
     * @see :
     * @param :
     * @return : void
     * @param localFiles
     * @param remoteFolder
     */
    public void uploadFiles(String[] localFiles, String remoteFolder) {
        for (String localFile : localFiles) {
            File thisFile = new File(localFile);

            if (thisFile.exists() && thisFile.isDirectory()) {
                File[] files = thisFile.listFiles();

                String dirName = remoteFolder + REMOTE_PATH_SEPARATOR
                        + thisFile.getName();
                mkdir(dirName);
                uploadFiles(files, dirName);

            } else if (thisFile.exists() && thisFile.isFile()) {
                uploadFile(localFile, remoteFolder);
            }
        }
    }

    /**
     * 上传本地文件到远程服务器端，即将本地的文件localFile上传到远程Linux服务器中的remoteTargetDirectory目录下
     * 
     * @param localFileList
     * @param remoteTargetDirectory
     */
    public void uploadFiles(List<String> localFileList,
            String remoteTargetDirectory) {
        uploadFiles(localFileList.toArray(new String[] {}),
                remoteTargetDirectory);
    }

    /**
     * 上传本地文件到远程服务器端，即将本地的文件localFile上传到远程Linux服务器中的remoteTargetDirectory目录下
     * 
     * @param localFileList
     * @param remoteTargetDirectory
     */
    public void uploadFiles(File[] localFileList,
            String remoteTargetDirectory) {

        String[] filePaths = new String[localFileList.length];

        for (int i = 0; i < localFileList.length; i++) {
            filePaths[i] = localFileList[i].getAbsolutePath();
        }
        uploadFiles(filePaths, remoteTargetDirectory);
    }

    /**
     * 上传文件
     * 
     * @see :
     * @param :
     * @return : void
     * @param localFolder
     * @param remoteFolder
     */
    public void uploadFolder(String localFolder, String remoteFolder) {
        File localFileFolder = new File(localFolder);
        File[] files = localFileFolder.listFiles();
        uploadFiles(files, remoteFolder);
    }

    /**
     * 下载单个文件
     * 
     * @see :
     * @param :
     * @return : void
     * @param remoteFile
     * @param destFile
     */
    public boolean downloadFile(String remoteFile, String remoteDir,
            String destFileFolder) {
        File destFile = new File(destFileFolder);
        if (!destFile.exists()) {
            destFile.mkdirs();
        }

        String localFile = remoteFile;

        /**
         * 2019年8月12日 20:38:22 modified by 孙留平
         * 
         * @see: 当远程文件中有$符号的时候，会被转义，因此远程的时候，需要换上传义字符，尤其是java的内部类被编译出来的class都是带有$符号的
         * 
         */
        if (remoteFile.contains("$")) {
            remoteFile = remoteFile.replace("$", "\\$");

        }

        try (SCPInputStream scpInputStream = getRemoteFileInputStream(
                remoteFile, remoteDir);
                FileOutputStream fos = new FileOutputStream(
                        new File(destFileFolder, localFile));) {
            String message = String.format("下载文件:%s/%s，到:%s", remoteDir,
                    remoteFile, destFileFolder);

            byte[] b = new byte[4096];
            int i;
            while ((i = scpInputStream.read(b)) != -1) {
                fos.write(b, 0, i);
            }
            fos.flush();
            LOGGER.debug("{}成功", message);
            return true;
        } catch (IOException e) {
            LOGGER.error("下载文件失败,原因:{}", e.getMessage());
            return false;
        }
        // finally {
        // close();
        // }
    }

    /**
     * 获取远程流
     * 
     * @see :
     * @param :
     * @return : SCPInputStream
     * @param remoteFile
     * @param remoteDir
     * @return
     */
    private SCPInputStream getRemoteFileInputStream(String remoteFile,
            String remoteDir) {
        SCPInputStream scpInputStream;
        try {
            scpInputStream = getScpClient()
                    .get(remoteDir + REMOTE_PATH_SEPARATOR + remoteFile);

            return scpInputStream;
        } catch (IOException e) {
            LOGGER.error("获取目录:{}下的文件:{}流失败,失败原因{}", remoteDir, remoteFile,
                    e.getMessage());
            throw new BusinessValidationException("获取输入流失败");
        }
    }

    /**
     * 下载单个文件
     * 
     * @see :
     * @param :
     * @return : void
     * @param remoteFiles
     * @param destFile
     */
    public boolean downloadFiles(String[] remoteFiles, String remoteFileFolder,
            String destFileFolder) {
        File destFile = new File(destFileFolder);
        if (destFile.isFile()) {
            destFileFolder = destFile.getParent();
        }

        for (String string : remoteFiles) {
            downloadFile(string, remoteFileFolder, destFileFolder);
        }

        return true;
    }

    /**
     * 下载目录
     * 
     * @see :
     * @param :
     * @return : void
     * @param remoteFileFolder
     * @param destFileFolder
     */
    public void downloadFolder(String remoteFileFolder, String destFileFolder) {
        // listRemoteDir(remoteFileFolder);
        List<SFTPv3DirectoryEntry> descendantsFiles = getChildren(
                remoteFileFolder);
        File destFolderFile = new File(destFileFolder);
        if (!destFolderFile.exists()) {
            destFolderFile.mkdirs();
        }
        LOGGER.debug("开始下载:从{}到:{}", remoteFileFolder, destFileFolder);
        for (SFTPv3DirectoryEntry sftPv3DirectoryEntry : descendantsFiles) {
            // 如果是文件夹，则下载文件夹
            if (sftPv3DirectoryEntry.attributes.isDirectory()) {
                downloadFolder(
                        remoteFileFolder + REMOTE_PATH_SEPARATOR
                                + sftPv3DirectoryEntry.filename,
                        destFileFolder + File.separator
                                + sftPv3DirectoryEntry.filename);
            } else if (sftPv3DirectoryEntry.attributes.isRegularFile()) {
                downloadFile(sftPv3DirectoryEntry.filename, remoteFileFolder,
                        destFileFolder);
            }
        }
    }

    /**
     * 下载目录，从远程数组，到本地文件夹，意思把数组中的远程目录都下载到同一个文件夹下，小心文件覆盖
     * 
     * @see :
     * @param :
     * @return : void
     * @param remoteFileFolder
     * @param destFileFolder
     */
    public void downloadFolders(String[] remoteFileFolder,
            String destFileFolder) {
        for (String string : remoteFileFolder) {
            downloadFolder(string, destFileFolder);
        }
    }

    /**
     * 下载目录，从远程数组、到本地数组，一一对应
     * 
     * @see :
     * @param :
     * @return : void
     * @param remoteFileFolder
     * @param destFileFolder
     */
    public void downloadFolders(String[] remoteFileFolder,
            String[] destFileFolder) {

        if (null == remoteFileFolder || null == destFileFolder) {
            throw new BusinessValidationException("远程文件夹和本地文件夹都不能为null");
        }

        if (remoteFileFolder.length == 0 || destFileFolder.length == 0) {
            throw new BusinessValidationException("远程文件夹和本地文件夹都不能为空");
        }

        if (remoteFileFolder.length != destFileFolder.length) {
            throw new BusinessValidationException("远程文件夹数组长度，和本地文件夹数组长度，必须得一样");
        }
        for (int i = 0; i < destFileFolder.length; i++) {
            downloadFolder(remoteFileFolder[i], destFileFolder[i]);
        }
    }

    /**
     * 执行命令
     * 
     * @see :
     * @param :
     * @return : void
     * @param command
     */
    public String executeShell(String command) {
        LOGGER.debug("执行命令:{}", command);
        Session currentSession = getCurrentSession();

        try (InputStream stdStream = new StreamGobbler(
                currentSession.getStdout());
                InputStream stdErrStream = new StreamGobbler(
                        currentSession.getStderr());

                BufferedReader bReader = new BufferedReader(
                        new InputStreamReader(stdStream));

                BufferedReader bufferedErrorReader = new BufferedReader(
                        new InputStreamReader(stdErrStream))) {
            currentSession.execCommand(command);
            StringBuilder outputBuilder = new StringBuilder();
            String line = null;
            while (true) {
                line = bReader.readLine();
                if (null == line) {
                    break;
                }
                outputBuilder.append(line).append("\n");
            }

            String errorLine = null;
            while ((errorLine = bufferedErrorReader.readLine()) != null) {
                outputBuilder.append(errorLine).append("\n");
            }

            LOGGER.debug("命令执行结果:\n{}", outputBuilder);
            return outputBuilder.toString();
        } catch (IOException e1) {
            LOGGER.error("执行命令失败:{}", e1.getMessage());
            throw new BusinessValidationException("执行命令失败");
        } finally {
            close();
        }
    }

    /**
     * 删除远程文件或者目录
     * 
     * @see :
     * @param :
     * @return : void
     * @param remoteFileOrFolder
     */
    public boolean deleteRemoteFile(String remoteFile) {
        try {
            LOGGER.debug("尝试删除文件:{}", remoteFile);
            getSftpV3Client().rm(remoteFile);
            LOGGER.debug("删除文件成功:{}", remoteFile);

            return true;
        } catch (IOException e) {
            LOGGER.error("删除文件失败:{}", e.getMessage());

            if (e.getMessage().contains(NO_SUCH_FILE_ERROR_MESSAGE)) {
                LOGGER.debug("文件夹不存在，不需要删除");

                return true;
            }

            return false;
        } finally {
            close();
        }
    }

    /**
     * 删除远程文件或者目录
     * 
     * @see :
     * @param :
     * @return : void
     * @param remoteFileOrFolder
     */
    public boolean deleteRemoteFile(String[] remoteFiles) {
        try {

            LOGGER.debug("尝试删除一组文件");
            for (String remoteFile : remoteFiles) {
                getSftpV3Client().rm(remoteFile);
                LOGGER.debug("删除文件成功:{}", remoteFile);
            }
            LOGGER.debug("批量删除文件成功");
            return true;
        } catch (IOException e) {
            LOGGER.error("删除文件失败:{}", e.getMessage());
            if (e.getMessage().contains(NO_SUCH_FILE_ERROR_MESSAGE)) {
                LOGGER.debug("文件不存在，不需要删除");

                return true;
            }

            return false;
        } finally {
            close();
        }
    }

    /**
     * 删除远程目录
     * 
     * @see :
     * @param :
     * @return : void
     * @param remoteFileOrFolder
     */
    public boolean deleteRemoteFileFolder(String remoteFileFolder) {
        try {
            LOGGER.debug("尝试删除文件夹:{}", remoteFileFolder);
            getSftpV3Client().rmdir(remoteFileFolder);
            LOGGER.debug("删除文件夹成功:{}", remoteFileFolder);

            return true;
        } catch (IOException e) {
            LOGGER.error("删除文件夹失败:{}", e.getMessage());

            if (e.getMessage().contains(NO_SUCH_FILE_ERROR_MESSAGE)) {
                LOGGER.debug("文件夹不存在，不需要删除");

                return true;
            }

            if (e.getMessage().contains("Failure (SSH_FX_FAILURE:")) {
                return deleteNoneEmptyRemoteFolder(remoteFileFolder);
            }

            return false;
        } finally {
            close();
        }
    }

    /**
     * 删除非空文件夹
     * 
     * @see :
     * @param :
     * @return : boolean
     * @param remoteFolder
     * @return
     */
    private boolean deleteNoneEmptyRemoteFolder(String remoteFolder) {
        LOGGER.debug("删除非空文件夹:{}", remoteFolder);
        String command = "rm -rf " + remoteFolder;
        String deleteNoneEmptyFolder = executeShell(command);
        LOGGER.debug("删除非空文件夹结果：{}", deleteNoneEmptyFolder);
        return true;

    }

    /**
     * 在远端linux上创建文件夹
     * 
     * @param dirName
     *            文件夹名称
     * @param posixPermissions
     *            目录或者文件夹的权限
     */
    public boolean mkdir(String dirName, int posixPermissions) {
        try {
            LOGGER.debug("创建文件夹:{}", dirName);
            getSftpV3Client().mkdir(dirName, posixPermissions);
            LOGGER.debug("创建文件夹:{}成功", dirName);
            return true;
        } catch (IOException e) {
            LOGGER.error("创建文件夹失败:{}", e.getMessage());
            return false;
        }
    }

    /**
     * 在远端linux上创建文件夹
     * 
     * @param dirName
     *            文件夹名称
     */
    public boolean mkdir(String dirName) {
        return mkdir(dirName, MKDIR_POSIX_PERMISSION);
    }

    /**
     * 在远程Linux服务器端移动文件或者文件夹到新的位置
     * 
     * @param oldPath
     * @param newPath
     */
    public boolean moveFileOrDir(String oldPath, String newPath) {
        try {
            LOGGER.debug("把文件或者文件夹从:{},移动到:{}", oldPath, newPath);
            getSftpV3Client().mv(oldPath, newPath);
            LOGGER.debug("把文件或者文件夹从:{},移动到:{}成功", oldPath, newPath);
            return true;
        } catch (Exception e) {
            LOGGER.error("移动文件失败:从何{}到:{}", oldPath, newPath);
            return false;
        }
    }

    /**
     * 获取sftpclient
     * 
     * @see :
     * @param :
     * @return : SFTPv3Client
     * @return
     */
    private SFTPv3Client getSftpV3Client() {
        try {
            if (null == this.sftPv3Client) {
                LOGGER.debug("初始化SFTPv3Client");
                this.sftPv3Client = new SFTPv3Client(getConnection());
                LOGGER.debug("初始化SFTPv3Client完成");
            }
            return this.sftPv3Client;
        } catch (IOException e) {
            LOGGER.error("获取SFTPv3Client失败，失败原因:{}", e.getMessage());
            throw new BusinessValidationException("获取SFTPv3Client失败");
        }
    }

    /**
     * 列举远程目录文件
     * 
     * @see :
     * @param :
     * @return : List<File>
     * @param remoteDir
     * @return
     */
    private void listRemoteDir(String remoteDir) {
        List<SFTPv3DirectoryEntry> children = null;
        try {
            children = getSftpV3Client().ls(remoteDir);
            if (children.isEmpty()) {
                return;
            }

            Iterator iterator = children.iterator();
            while (iterator.hasNext()) {
                SFTPv3DirectoryEntry thisChild = (SFTPv3DirectoryEntry) iterator
                        .next();

                SFTPv3FileAttributes attributes = thisChild.attributes;
                if (!".".equals(thisChild.filename)
                        && !"..".equals(thisChild.filename)) {
                    String childFolder = remoteDir + "/" + thisChild.filename;
                    if (attributes.isDirectory()) {
                        listRemoteDir(childFolder);
                    }
                    this.childrenList.add(thisChild);
                }
            }
        } catch (IOException e) {
            LOGGER.error("获取子孙文件或者文件夹失败:{}", e.getMessage());
            throw new BusinessValidationException("获取文件夹下的内容失败");
        }
    }

    /**
     * 列举远程目录文件
     * 
     * @see :
     * @param :
     * @return : List<File>
     * @param remoteDir
     * @return
     */
    private List<SFTPv3DirectoryEntry> getChildren(String remoteDir) {
        List<SFTPv3DirectoryEntry> children = null;
        List<SFTPv3DirectoryEntry> finalChildren = new ArrayList<>();
        try {
            children = getSftpV3Client().ls(remoteDir);
            Iterator iterator = children.iterator();
            while (iterator.hasNext()) {
                SFTPv3DirectoryEntry thisChild = (SFTPv3DirectoryEntry) iterator
                        .next();
                if (!".".equals(thisChild.filename)
                        && !"..".equals(thisChild.filename)) {
                    finalChildren.add(thisChild);
                }
            }
            return finalChildren;
        } catch (IOException e) {
            LOGGER.error("获取子孙文件或者文件夹失败:{}", e.getMessage());
            throw new BusinessValidationException("获取文件夹下的内容失败");
        }
        // finally {
        // close();
        // }
    }

    /**
     * 单例模式
     * 懒汉式
     * 线程安全
     * 
     * @return
     */
    public static GanymedSshClient getInstance() {
        if (null == instance) {
            synchronized (GanymedSshClient.class) {
                if (null == instance) {
                    instance = new GanymedSshClient();
                }
            }
        }
        return instance;
    }

    /**
     * 获取实例
     * 
     * @see :
     * @param :
     * @return : GanymedSshClient
     * @param ip
     * @param port
     * @param name
     * @param password
     * @return
     */
    public static GanymedSshClient getInstance(String ip, int port, String name,
            String password) {
        if (null == instance) {
            synchronized (GanymedSshClient.class) {
                if (null == instance) {
                    instance = new GanymedSshClient(ip, port, name, password);
                }
            }
        }
        return instance;
    }

    /**
     * 获取实例
     * 
     * @see :
     * @param :
     * @return : GanymedSshClient
     * @param ip
     * @param port
     * @param name
     * @param password
     * @return
     */
    public static GanymedSshClient getInstance(String ip, String name,
            String password) {
        if (null == instance) {
            synchronized (GanymedSshClient.class) {
                if (null == instance) {
                    instance = new GanymedSshClient(ip, name, password);
                }
            }
        }
        return instance;
    }

    /**
     * 获取实例
     * 
     * @see :
     * @param :
     * @return : GanymedSshClient
     * @param ip
     * @param port
     * @param name
     * @param password
     * @return
     */
    public static GanymedSshClient getInstance(String ip) {
        if (null == instance) {
            synchronized (GanymedSshClient.class) {
                if (null == instance) {
                    instance = new GanymedSshClient(ip);
                }
            }
        }
        return instance;
    }

    /**
     * 获取实例
     * 
     * @see :
     * @param :
     * @return : GanymedSshClient
     * @param ip
     * @param port
     * @param name
     * @param password
     * @return
     */
    public static GanymedSshClient getInstance(ServerInfo serverInfo) {
        if (null == instance) {
            synchronized (GanymedSshClient.class) {
                if (null == instance) {
                    instance = new GanymedSshClient(serverInfo);
                }
            }
        }
        return instance;
    }

    /**
     * 判断服务器是否可认证
     * 
     * @see :
     * @param :
     * @return : boolean
     * @return
     */
    public boolean serverCanBeAuthed() {
        try {
            initConnection();
            return true;
        } catch (Exception e) {
            LOGGER.error("认证授权失败，原因:{}", e.getMessage());
            return false;
        }
    }

    /**
     * 判断服务器是否可连通
     * 
     * @see :
     * @param :
     * @return : boolean
     * @return
     */
    public boolean serverIpCanBeConnected() {
        try {
            return InetAddress.getByName(this.serverInfo.getHost())
                    .isReachable(3000);
        } catch (UnknownHostException e) {
            LOGGER.error("测试连接服务器失败,失败原因:{}", e.getMessage());
            return false;
        } catch (IOException e) {
            LOGGER.error("连接服务器IO异常,失败原因:{}", e.getMessage());
            return false;
        }

    }

    public static void main(String[] args) {
        GanymedSshClient ganymedSshClient = new GanymedSshClient(
                "192.168.110.31", "admin", "admin");
        String destFolder = "E:\\test3\\tq-datamanagement";
        ganymedSshClient.downloadFolder(
                "/home/admin/codecoverge/tq-datamanagement", destFolder);
    }
}

感谢！确实同事也建议使用 scp 的方式，但我觉得用 docker 自动化部署的应用，在文件路径的查找与拷贝会不会在实现自动化存在问题而导致不稳定，所以想问下楼主有没有其他方法，没想到楼主把代码都贴出来了。非常感谢，我先按照这个思路试试看。

谢谢楼主指导 我想拿到一个调用链路，但是还没方向，能在指导一下吗 谢谢了

想怎么指导呢~~~

就是没有思路拿到字节码文件怎么解析 TT

楼主请教一下，公司测试环境有 jar 包，不会有源文件放到服务器上的，java -jar 方式启动这种方式，怎么能得到测试报告呢

覆盖率平台刚搭建起来，目前两个比较棘手的问题，不知楼主有无遇到过

覆盖率平台刚搭建起来，目前两个比较棘手的问题，不知楼主有无遇到过
1.差异覆盖率。还没走到 jacoco 源码，暂时无解；目前用了 github 上的 diff-cover ，但是报告不行
2.服务 docker 化后，脚本注入、服务重启、dump 以及 exec 文件如何 copy 出来，一堆问题

你好像没有理清集成测试覆盖率的流程。
测试环境启动的时候，注入 jacoco，只是提供了一个 jacoco 的功能，同时在测试服务器上开启 tcp 服务存放当前应用的执行覆盖数据。
当然，这个 tcp 服务成功开启之后，是允许远程调用的，就是你可以在其他的服务器上甚至在你本机发起 tcp 连接，去获取它存放的覆盖数据。这一点 jacoco 提供的有专门的的 api。

你可以把这个过程理解为，测试环境集成 jacoco 功能且开启了一个 tcp 服务之后，你后续的覆盖率统计，已经基本和这个测试环境没什么关系了。

剩余的过程，就是你自己生成报告的方法了，总之生成报告只需要三个东西，上面有提到，至于你的源码存放在哪里并不重要，你只要保证你的测试环境启动的 jar 包的编译源码跟你生成报告时候用的源码是一致的就可以了。

不知道我有没有描述清楚。

搜一下 ASM，了解一下他的一些机制，再看看有没有头绪

看你说的一堆问题，那就一个一个解决么，问题这种东西，解决一个少一个，干掉一个轻松一下。
回答你的第一个问题：总结为代码比对的问题。
差异化的覆盖，大致可以在两个阶段做处理，我提一些我的思路，看能不能对你有一点帮助。

• 在 jacoco 自己的生成报告之前。

你去过滤 class 的信息，选择性生成报告，这样你可以只要那些过滤出来的变更代码的数据，原来的数据可以丢掉。当然需要你对 jacoco 自己的机制要清楚。

• 在 jacoco 自己生成的报告之后。

你去针对它的报告，结合自己的代码比对结果对报告做定制。当然，这个时候你可能需要对它的百分比单独处理， 小心数据不准确。

回答你的第二个问题：关于容器的问题，我不是很精通。
但我猜测是否可以把你对应的那个 tcp 服务的端口也映射出去给宿主，dump 的时候请求直接发给主机。
至于怎么拿出来，那应该有不少方式把。

兄弟，咋我的还是不行啊？只改一下路径就可以吗？

明白一些，源码和 class 文件服务器没有的话可以在本地生成，保证与 jar 包的编译源码一致就行，现在不清楚执行的 exec 文件在服务器哪里可以找到

换一下 jackson 的版本试试

楼主很赞

我用命令启动成功了 但是报告在哪里

你好像没有弄清楚它的工作原理吧，你这个命令只是起一个 java 服务的，与以前不一样的是，你起这个 java 服务的时候，注入了 jacoco 的代理，让你有对这个 java 服务统计代码执行状况的能力，后续的测试过程和生成报告是独立的哦

好的，祝你好运

楼主，麻烦请教下；我们最近在做单测覆盖率的收集，之前用的 jenkins jacoco 插件做的；现在 jenkins 不让用了；介绍一下前提，我们的工程是一个父子工程，分为 service(逻辑层)，web，thrift；web 和 thrift 通过 jar 包方式引用 service。开发会在 web 和 thrift 中增加单测，然后我们的 pom 使用了 maven 的 jacoco 插件，有 pre-agent 和 report2 个 goal。我发现执行 mvn clean test 后，会在 web 和 thrfit 每个模块中增加一个 jacoco.exec，然后生成一个 html 报告。想问下楼主，这种情况下，service 里的代码能收集到嘛？ 我们想做基于工程维度 (多模块) 的覆盖率报告生成，我看网上都是使用 aggregate 的 goal

可以指定 sourcefile 的位置

请问下楼主，改造的 jacoco 代码怎么调试啊？我用 java -javaagent:xxx -jar xxx.jar 方式运行的。想用 remote 远程调试，能监听到虚拟机，但是没在断点上停下来。ps：我之前用 javaassist 也写过一个 agent，是可以用这种方式调试的。

去翻了 jacoco+asm；楼主，上面讲到的调用链，没弄清楚调用链怎么生成出来，可能理解不够，或者方向不对；方便指点下关键代码或思路么？
我大致考虑是不是可以直接用 jacoco，在 jacoco 插桩位置标记序号，最终按需要列出代码，从代码中刷选出方法。。。

此外，如果想区分不同人员的执行记录，楼主有什么思路么？个人工作台拦截请求，并给请求加上唯一标签？但我没有思路怎么在 Java 服务中传递；

合并和调用链问题我最近在解决，可以留个联系方式一起讨论下

大家的源码 diff 都是怎么做的，谁能详细介绍下嘛？