devbox
在线问答5
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

如何用Java写一个整理Java方法调用关系网络的程序

作者：在线问答5 | 2024-07-11 11:50:21

赞

踩

如何用Java写一个整理Java方法调用关系网络的程序

        大家好，我是猿码叔叔，一位 Java 语言工作者，也是一位算法学习刚入门的小学生。很久没有为大家带来干货了。

        最近遇到了一个问题，大致是这样的：如果给你一个 java 方法，如何找到有哪些菜单在使用。我的第一想法是，这不很简单吗？！使用 IDEA 自带的右键 Find Usage 功能，一步一步往上溯源最终找到 Controller 中的方法，找到 requestMapping 的映射路径，然后去数据库一查便知。     

目录

一、问题真的这么简单吗？我们先分析一下这种问题的出现场景

二、有没有更快的解决方案？

三、如何提取 Java 对象中的方法以及方法中的被调用方法

        IO 流读取 .java 文件

        JDK 编译后的 .class 字节码文件

四、解读 -javap 命令反编译后的内容

五、用代码解析出类的方法与被调方法

六、让方法与被调方法的关系可视化

一、问题真的这么简单吗？我们先分析一下这种问题的出现场景

        我所在的这个项目是一个接近15年的老项目，使用的还是 SSM 框架。前后端没有做到分离开来，耦合度极高。所以刚才那个问题的目的大致就是要将部分方法拆分出来，降低耦合度，使得后期的维护更加方便，亦或是扩展起来更加容易。 

        这种项目模块或方法之间耦合度高的问题，大多出现在老项目中。而仍然使用老项目的企业中国企居多。成本与安全也是阻碍老项目得到升级的两大关键问题。随着AI的兴起，这种问题的彻底解决或许能够看到一些希望，但是否有大模型专注于解决这种问题仍然需要考虑到成本和价值问题了。

二、有没有更快的解决方案？

        除了刚才使用 IDEA 的 Find Usage 右键功能。我们或许可以调用 IDEA 的 API 也就是 Find Usage 功能，然后将项目中的所有方法串联成一个 N 叉树。对于 Controller 中的方法可以放在 Root 节点的下一层节点中。

        但，IDEA 工具真的会给你提供这个 API 吗？答案是否定的，至少我搜索了很多相关内容，也没有得到一个准确的结果。或许有相关的开源组件提供这种方法溯源菜单的功能，但也都不尽如人意。

        那我们能否自己写一个这样的程序呢？

三、如何提取 Java 对象中的方法以及方法中的被调用方法

        这个程序实现起来其实很简单。我们只需要使用 IO 流去读取 .java 文件或者反射取出 class 中的 declaredMethods 即可。前者更开放，也更有挑战性。后者除了能取到声明方法以外，方法中的被调用方法反射做不到这一点。

        IO 流读取 .java 文件

        IO 流我们使用 BufferedReader 一行一行地读取 .java 文件中的内容，然后根据方法的特征解析出方法与被调用方法即可。听起来是不是很简单，怎么写代码？

        考虑到 Java 中代码的多变性，比如换行、注释、内部类、静态代码块、字段等等，这些都是需要我们用算法来处理的。但这么搞下去，真的可以自己写一个 JDK 了。如果你肯坚持和足够动脑，也不是不可能实现。

        JDK 编译后的 .class 字节码文件

        如果你动手能力强，你会发现刚才说的一部分要处理的内容，jdk 可以帮你解决。比如注释。在项目编译后的 target 目录下，原来的 .java 文件会被编译成 .class 文件，这些文件中原有的注释内容100%都不会被保留。此时，我们可以考虑去读取 .class 文件来进一步实现我们的计划。

        当拿到 .class 文件的数据时，我傻眼了。读取到的流数据并非我们眼睛看到的数据那样，而是二进制的字节码内容，要想解析这些数据，我们得学会解读这些内容。当然现在有很多工具可以反编译字节码文件。为了不重复造轮子，我去网上找到了如下代码，可以在 java 代码中执行反编译命令，将指定目录下的 .class 文件反编译成我们能读懂的内容。

  1.     private void decodeClassFile(File clazzFile) {
  2.         String absPath = clazzFile.getAbsolutePath();
  3.         try {
  4.             String command = "javap -c " + absPath;
  5.             Process process = runtime.exec(command);
  6.             // 读取命令执行结果
  7.             BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
  8.             StringBuilder sb = new StringBuilder();
  9.             String line;
  10.             while ((line = reader.readLine()) != null) {
  11.                 sb.append(line).append("\n");
  12.             }
  13.             // 等待命令执行完成
  14.             process.waitFor();
  15.  
  16.             // 获取退出值
  17.             process.exitValue();
  18.             reader.close();
  19.  
  20.             absPath = absPath.substring(absPath.indexOf("cn"));
  21.             absPath = absPath.replace('\\', '.');
  22.             absPath = absPath.replace(".class", ".txt");
  23.             // 将反编译后的内容写入到指定的文件内
  24.             writeDecodedClazzFileDown(sb.toString(), absPath);
  25.         } catch (IOException | InterruptedException e) {
  26.             e.printStackTrace();
  27.         }
  28.     }

四、解读 -javap 命令反编译后的内容

        打开反编译后的文件，你会发现方法的内容区域会有数字序列号，这些序列号其实是执行顺序的一个标识。序列号右侧的 “//” 后面会跟随描述当前行的内容类别。如果是方法，// 会写着  “Method”，如果是接口方法则是“InterfaceMethod”，如果是字段定义则是“Field”。对于其他的描述，读者有兴趣也可以去研究一下。紧随这些描述后的内容就是 java 源代码中的真实内容了。

  1.    46: invokevirtual #27                 // Method cn/com/xxx/xxx/pojo/dev/Admin.getUserList:()Ljava/util/List;
  2.    97: invokeinterface #7,  3            // InterfaceMethod org/springframework/ui/Model.addAttribute:(Ljava/lang/String;Ljava/lang/Object;)Lorg/springframework/ui/Model;

        编号46，是一个普通方法；编号97是一个接口方法。46 的 Method 后面我给他分为 3 个部分。

1、方法名与方法所在的包路径。

2、() 中的内容代表参数信息。这些参数信息只包含包路径与类型，没有参数名称。

3、括号后面的内容是返回值信息。

        我们看到，参数内容与返回值区域路径首字符多了一个 “L” 字符。这个代表对象类型区别于 Java 自己的 8 大基本类型。 这 8 个类型的指令如下：

dataType.put('[', "[]");  // 代表数组
dataType.put('I', "int");
dataType.put('J', "long");
dataType.put('F', "float");
dataType.put('D', "double");
dataType.put('Z', "boolean");
dataType.put('B', "byte");
dataType.put('C', "char");
dataType.put('S', "short");

        对于其他更多的指令，读者可以去咨询 AI。比如文心一言或者GPT。

五、用代码解析出类的方法与被调方法

        解析方法与被调方法前我们需要注意几点：

  • Service 方法与 ServiceImpl 实现类的方法转换。在 Service 方法中的方法体是没有内容的，其内容会在他的实现类对应的方法体里。这时候你应该知道我要强调的是什么了。
  • 方法与被调方法的参数信息在反编译文件里的内容是不同的，比如 double 类型与 int 类型同时存在时，你看到的是 “DI”，如果前者是数组，你看到的是“[DI”。所以为了在拿到被调方法时能够准确找到下一个节点，我们必须对这些内容进行还原
  • 如上一条所说，我们解析出方法与被调方法的目的是能够准确的通过方法找到有哪些被调方法，拿到被调方法，能够准确找到被调方法中的被调方法。这是一个 N-ary 树的遍历思想，直到找不到为止。
  • 当前类的自有方法互相调用，需要拼接其包路径。这是为了统一管理。
  • 解析后的内容，在存放时应当有一个便于处理的格式。比如一级方法名前面没有空格，而二级的被调方法则应当在前面加上四个“-”字符，这样可以明确他们之间的关系。

      下面是解析代码：

  1. public class ProjectMethodCallingTreeGraph {
  2.  
  3.     private final static char[] METHOD_PREFIX = {'M', 'e', 't', 'h', 'o', 'd'};
  4.     private final static char[] INTERFACE_METHOD_PREFIX = {'I', 'n', 't', 'e', 'r', 'f'};
  5.     private final static String TARGET_ROOT_PATH = "D:\\WORK\\xxx\\pro-info\\xxx\\xxx-graph";
  6.  
  7.     private static Map<Character, String> dataType = new HashMap<>();
  8.  
  9.     static {
  10.         dataType.put('[', "[]");
  11.         dataType.put('I', "int");
  12.         dataType.put('J', "long");
  13.         dataType.put('F', "float");
  14.         dataType.put('D', "double");
  15.         dataType.put('Z', "boolean");
  16.         dataType.put('B', "byte");
  17.         dataType.put('C', "char");
  18.         dataType.put('S', "short");
  19.     }
  20.  
  21.     public static void main(String[] args) {
  22.         String path = "D:\\WORK\\xx\\pro-info\\xxx\\xxxx";
  23.         ProjectMethodCallingTreeGraph p = new ProjectMethodCallingTreeGraph();
  24.         p.readDecodedClazzFile(path);
  25.     }
  26.  
  27.  
  28.     private void readDecodedClazzFile(String path) {
  29.         File file = new File(path);
  30.         for (File f : file.listFiles()) {
  31.             String method = null;
  32.             String fName = f.getName().substring(0, f.getName().length() - 3);
  33.             boolean mapperOrService = f.getName().endsWith("Service.txt") || f.getName().endsWith("Mapper.txt");
  34.             LinkedHashSet<String> callMethods = new LinkedHashSet<>();
  35.             try (BufferedReader br = new BufferedReader(new FileReader(f))) {
  36.                 String line;
  37.                 StringBuilder sb = new StringBuilder();
  38.                 while ((line = br.readLine()) != null) {
  39.                     char[] cs = line.toCharArray();
  40.                     String res = findMethodLine(cs, callMethods, mapperOrService);
  41.                     if (res != null) {
  42.                         if (method != null && method.length() > 2) {
  43.                             sb.append("----").append(fName).append(method).append("\n");
  44.                             append(sb, callMethods, fName);
  45.                             callMethods.clear();
  46.                         }
  47.                         method = res;
  48.                     }
  49.                 }
  50.  
  51.                 writeDown(f.getName(), sb.toString());
  52.             } catch (Exception e) {
  53.                 System.out.println(e.getMessage());
  54.             }
  55.         }
  56.     }
  57.  
  58.     private void append(StringBuilder sb, LinkedHashSet<String> callMethods, String fName) {
  59.         for (String m : callMethods) {
  60.             sb.append("--------");
  61.             if (localMethod(m)) {
  62.                 sb.append(fName);
  63.             }
  64.             sb.append(m).append("\n");
  65.         }
  66.     }
  67.  
  68.     private boolean localMethod(String str) {
  69.         int n = str.length(), leftParenthesis = -1;
  70.         for (int i = 0; i < n; ++i) {
  71.             if (leftParenthesis == -1 && str.charAt(i) == '.') {
  72.                 return false;
  73.             }
  74.             if (leftParenthesis == -1 && str.charAt(i) == '(') {
  75.                 leftParenthesis = i;
  76.             }
  77.         }
  78.         return true;
  79.     }
  80.  
  81.     private void writeDown(String fname, String content) {
  82.         try (BufferedWriter bw = new BufferedWriter(new FileWriter(TARGET_ROOT_PATH + "\\" + fname))) {
  83.             bw.write(content);
  84.         } catch (Exception e) {
  85.             e.fillInStackTrace();
  86.         }
  87.     }
  88.  
  89.     private String findMethodLine(char[] cs, LinkedHashSet<String> calledMethods, boolean mapperOrService) {
  90.         int x = 0, n = cs.length;
  91.         while (x < n && cs[x] == ' ') {
  92.             ++x;
  93.         }
  94.         return x == 2 ? getSpecialCharIndex(cs, mapperOrService) : (x > 4 ? findCalledMethods(cs, x, calledMethods) : null);
  95.     }
  96.  
  97.     private String findCalledMethods(char[] cs, int x, LinkedHashSet<String> calledMethods) {
  98.         // interfaceMethod
  99.         StringBuilder sb = new StringBuilder();
  100.         int n = cs.length;
  101.         boolean canAppend = false, inParenthesis = false, simpleDataTypePrior = false;
  102.         String typeMask = "";
  103.         for (; x < n; ++x) {
  104.             if (cs[x] == '/' && cs[x - 1] == '/') {
  105.                 if (cs[x + 2] == 'M' && compare2Arrays(cs, x + 2, METHOD_PREFIX)) {
  106.                     x += 8;
  107.                     canAppend = true;
  108.                 } else if (cs[x + 2] == 'I' && compare2Arrays(cs, x + 2, INTERFACE_METHOD_PREFIX)) {
  109.                     canAppend = true;
  110.                     x += 17;
  111.                 } else {
  112.                     return null;
  113.                 }
  114.                 continue;
  115.             }
  116.             if (cs[x] == '[' || (x + 1 < n && cs[x + 1] == ')' && cs[x] == ';')) {
  117.                 continue;
  118.             }
  119.             if (canAppend && cs[x] != ':') {
  120.                 if (cs[x] == '/') {
  121.                     sb.append('.');
  122.                 } else if (cs[x] == ';') {
  123.                     sb.append(typeMask).append(", ");
  124.                     typeMask = "";
  125.                     simpleDataTypePrior = false;
  126.                 } else {
  127.                     if (inParenthesis && cs[x - 1] == '[') {
  128.                         typeMask = "[]";
  129.                     }
  130.                     if (cs[x] == 'L' && (cs[x - 1] == '(' || cs[x - 1] == '[' || cs[x - 1] == ';')) {
  131.                         continue;
  132.                     }
  133.                     if ((cs[x - 1] == '(' || cs[x - 1] == ';' || simpleDataTypePrior || cs[x - 1] == '[') && dataType.containsKey(cs[x])) {
  134.                         simpleDataTypePrior = true;
  135.                         sb.append(dataType.get(cs[x]));
  136.                         if (cs[x - 1] == '[') {
  137.                             sb.append("[]");
  138.                         }
  139.                         if ((x + 1 < n && cs[x + 1] != ')') || (x + 1 < n && cs[x + 1] == ';' && cs[x + 2] != ')')) {
  140.                             sb.append(", ");
  141.                         }
  142.                     } else {
  143.                         sb.append(cs[x]);
  144.                     }
  145.                 }
  146.                 if (cs[x] == '(') {
  147.                     inParenthesis = true;
  148.                 }
  149.             }
  150.             if (cs[x] == ')') {
  151.                 break;
  152.             }
  153.         }
  154.         if (sb.length() > 0) {
  155.             calledMethods.add(sb.toString());
  156.         }
  157.         return null;
  158.     }
  159.  
  160.     private boolean compare2Arrays(char[] a, int x, char[] b) {
  161.         return Arrays.equals(a, x, x + b.length, b, 0, b.length);
  162.     }
  163.  
  164.     private String getSpecialCharIndex(char[] cs, boolean mapperOrService) {
  165.  
  166.  
  167.         int pre = 0, cnt = 0, leftParenthesis = -1;
  168.         StringBuilder sb = new StringBuilder();
  169.         for (int i = 2; i < cs.length; ++i) {
  170.             if (leftParenthesis != -1) {
  171.                 sb.append(cs[i]);
  172.             }
  173.             if (leftParenthesis == -1 && cs[i] == ' ') {
  174.                 pre = i;
  175.                 ++cnt;
  176.             }
  177.             if (leftParenthesis == -1 && cs[i] == '(') {
  178.                 leftParenthesis = i;
  179.                 i = pre;
  180.             }
  181.             if (cs[i] == ')') {
  182.                 break;
  183.             }
  184.         }
  185.         return cnt > 1 ? sb.toString() : null;
  186.     }
  187. }

配置好 .class 文件的路径以及写入的目标路径后，执行代码，等待几秒后，就可以去看看写入的方法与被调方法信息了。

六、让方法与被调方法的关系可视化

        为了更直观的表达各方法之间的调用关系。我们可以为此创建一个 web 页面，来展现这些方法与方法之间的调用关系。由于时间有限，目前只能向读者提供方法与方法之间的调用关系，后续会丰富功能，并向大家展示。

  • web 页面
  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>方法调用关系图</title>
  6.     <style>
  7.         html {
  8.             background: orange;
  9.         }
  10.         .container {
  11.             margin: 0;
  12.             padding: 0;
  13.             text-align: center;
  14.             flex-direction: column;
  15.         }
  16.         .list-box {
  17.             margin-top: 10px;
  18.             height: 80px;
  19.             overflow-y: hidden;
  20.             border: solid 5px lightgray;
  21.             overflow-x: scroll;
  22.         }
  23.         .list-item {
  24.             list-style: none;
  25.             padding: 2px 3px;
  26.         }
  27.         ul {
  28.             display: flex;
  29.         }
  30.         li > button:hover {
  31.             background: black;
  32.             color: white;
  33.         }
  34.         button {
  35.             background: white;
  36.             color: rgba(0, 0, 0, 0.6);
  37.             padding: 4px 6px;
  38.             border: none;
  39.             cursor: pointer;
  40.             border-radius: 3px;
  41.         }
  42.         .clicked_current {
  43.             color: white;
  44.             background: black;
  45.         }
  46.     </style>
  47. </head>
  48. <body>
  49. <div class="container">
  50. </div>
  51. </body>
  52. <script type="text/javascript">
  53.  
  54.     const XMLRequest = new XMLHttpRequest();
  55.     let level = 0;
  56.  
  57.     window.onload = function () {
  58.         const url = "http://localhost/methodGraph";
  59.         request(url, 'get', false);
  60.         XMLRequest.onreadystatechange = function () {
  61.             if (XMLRequest.readyState === XMLHttpRequest.DONE && (XMLRequest.status === 200 || XMLRequest.status === 304)) {
  62.                 renderElements(JSON.parse(XMLRequest.responseText));
  63.             }
  64.         }
  65.         XMLRequest.send(null);
  66.     }
  67.  
  68.     function request(url, method, async) {
  69.         XMLRequest.open(method, url, async);
  70.         XMLRequest.setRequestHeader('Content-Type', 'application/json');
  71.     }
  72.  
  73.     let curLevel = -1;
  74.     function renderElements(arr) {
  75.         const parentDom = document.querySelector(".container");
  76.         const frag = document.createDocumentFragment();
  77.         for (const item of arr) {
  78.             const li = document.createElement("li");
  79.             li.classList.add("list-item");
  80.             const btn = document.createElement("button");
  81.             btn.onclick = function () {
  82.                 curLevel = parseInt(this.parentNode.parentNode.classList[0].substring(5));
  83.                 const docs = document.querySelectorAll(".clicked_current");
  84.                 for (const doc of docs) {
  85.                     doc.classList.remove("clicked_current");
  86.                 }
  87.                 btn.classList.add("clicked_current");
  88.                 search(item);
  89.             }
  90.             btn.title = item;
  91.             btn.textContent = getNameFromLongString(item);
  92.             li.appendChild(btn);
  93.             frag.append(li);
  94.         }
  95.         if (curLevel === level - 1) {
  96.             if (arr.length > 0) {
  97.                 const div = document.createElement("div");
  98.                 div.classList.add("list-box");
  99.                 const ul = document.createElement("ul");
  100.                 ul.classList.add(`level${level++}`)
  101.                 ul.appendChild(frag);
  102.                 div.appendChild(ul);
  103.                 parentDom.appendChild(div);
  104.             }
  105.         } else {
  106.             let rem = curLevel + 2;
  107.             if (arr.length > 0) {
  108.                 const ulExist = document.querySelector(`.level${curLevel + 1}`);
  109.                 ulExist.innerHTML = "";
  110.                 ulExist.appendChild(frag);
  111.                 rem++;
  112.             }
  113.             while (parentDom.childNodes.length > rem) {
  114.                 const last = parentDom.childNodes.length;
  115.                 parentDom.removeChild(parentDom.childNodes[last - 1]);
  116.                 level--;
  117.             }
  118.         }
  119.     }
  120.  
  121.     function getNameFromLongString(longName) {
  122.         if (level === 0) {
  123.             return longName.substring(longName.lastIndexOf('.') + 1);
  124.         }
  125.         longName = longName.substring(0, longName.indexOf('('));
  126.         return longName.substring(longName.lastIndexOf('.') + 1);
  127.     }
  128.  
  129.     function search(name) {
  130.         const url = `http://localhost/findByName?name=${name}`;
  131.         request(url, 'get', false);
  132.         XMLRequest.onreadystatechange = function () {
  133.             if (XMLRequest.readyState === XMLHttpRequest.DONE && (XMLRequest.status === 200 || XMLRequest.status === 304)) {
  134.                 renderElements(JSON.parse(XMLRequest.responseText));
  135.             }
  136.         }
  137.         XMLRequest.send(null);
  138.     }
  139. </script>
  140. </html>
  • controller
  1.     @RequestMapping("/findByName")
  2.     @ResponseBody
  3.     public List<String> findByName(@RequestParam(name = "name", defaultValue = "unknown") String name) {
  4.         return projectInformationService.findByClazzName(name);
  5.     }
  • 实现类
  1. package com.example.develper.demos.service;
  2.  
  3. import org.springframework.beans.factory.annotation.Value;
  4. import org.springframework.stereotype.Service;
  5.  
  6. import java.io.BufferedReader;
  7. import java.io.File;
  8. import java.io.FileReader;
  9. import java.util.*;
  10.  
  11. @Service
  12. public class ProjectInformationServiceImpl implements ProjectInformationService{
  13.  
  14.     Map<String, Map<String, List<String>>> name2Clazz;
  15.  
  16.     // 在 properties 中配置之前保存的那个目录里
  17.     @Value("${methodConnection.analyze.target.path}")
  18.     private String methodConnectionPath;
  19.  
  20.     private void initialized() {
  21.         if (name2Clazz != null) { return; }
  22.         if (methodConnectionPath == null) {
  23.             throw new IllegalArgumentException("请配置已经解析好的方法关系网络文档路径！");
  24.         }
  25.         name2Clazz = new HashMap<>();
  26.         File file = new File(methodConnectionPath);
  27.         if (!file.exists()) {
  28.             throw new IllegalArgumentException("请配置正确的文档路径！");
  29.         }
  30.         loadsClazzInfo(file);
  31.     }
  32.  
  33.     private void loadsClazzInfo(File file) {
  34.         File[] files = file.listFiles();
  35.         for (File f : files) {
  36.             String name = f.getName().substring(0, f.getName().length() - 4);
  37.             Map<String, List<String>> method2CalledMethods = new HashMap<>();
  38.             name2Clazz.put(name, method2CalledMethods);
  39.             try (BufferedReader br = new BufferedReader(new FileReader(f))) {
  40.                 String line;
  41.                 String methodName = null;
  42.                 while ((line = br.readLine()) != null) {
  43.                     String[] ret = countPlaceholder(line);
  44.                     if ("4".equals(ret[0])) {
  45.                         methodName = ret[1];
  46.                         method2CalledMethods.put(methodName, new ArrayList<>());
  47.                     } else if (methodName != null) {
  48.                         method2CalledMethods.get(methodName).add(ret[1]);
  49.                     }
  50.                 }
  51.             } catch (Exception e) {
  52.                 e.fillInStackTrace();
  53.             }
  54.         }
  55.     }
  56.  
  57.     private String[] countPlaceholder(String line) {
  58.         int x = 0, cnt = 0, n = line.length();
  59.         StringBuilder sb = new StringBuilder();
  60.         while (x < n) {
  61.             if (line.charAt(x) == '-') {
  62.                 ++cnt;
  63.             } else {
  64.                 sb.append(line.charAt(x));
  65.             }
  66.             ++x;
  67.         }
  68.         String[] ret = new String[2];
  69.         ret[0] = Integer.toString(cnt);
  70.         ret[1] = sb.toString();
  71.         return ret;
  72.     }
  73.  
  74.     @Override
  75.     public List<String> loadAllControllers() {
  76.         initialized();
  77.         List<String> ret = new ArrayList<>();
  78.         for (String name : name2Clazz.keySet()) {
  79.             if (name.endsWith("Controller")) {
  80.                 ret.add(name);
  81.             }
  82.         }
  83.         return ret;
  84.     }
  85.  
  86.     @Override
  87.     public List<String> findByClazzName(String name) {
  88.         // cn.com.xx.xx.common.Base58.encode(
  89.         if (name == null || name.trim().isEmpty()) {
  90.             return new ArrayList<>();
  91.         }
  92.         if (name.endsWith("Controller")) {
  93.             return new ArrayList<>(name2Clazz.getOrDefault(name, new HashMap<>()).keySet());
  94.         }
  95.         char[] cs = name.toCharArray();
  96.         StringBuilder prefix = new StringBuilder();
  97.         StringBuilder suffix = new StringBuilder();
  98.         int i = 0;
  99.         while (i < cs.length && cs[i] != '(') {
  100.             if (cs[i] == '.') {
  101.                 prefix.append(prefix.length() > 0 ? '.' : "").append(suffix);
  102.                 suffix.setLength(0);
  103.             } else {
  104.                 suffix.append(cs[i]);
  105.             }
  106.             ++i;
  107.         }
  108.         while (i < cs.length) {
  109.             suffix.append(cs[i++]);
  110.         }
  111.         char[] service = {'S', 'e', 'r', 'v', 'i', 'c', 'e'};
  112.         int x = prefix.length() - 1, k = service.length - 1;
  113.         while (k >= 0 && prefix.charAt(x) == service[k]) {
  114.             --x; --k;
  115.         }
  116.         String clazzName = prefix.toString();
  117.         if (k == -1) {
  118.             x = prefix.length();
  119.             while (prefix.charAt(x - 1) != '.') {
  120.                 --x;
  121.             }
  122.             prefix.insert(x, "impl.");
  123.             clazzName = prefix.append("Impl").toString();
  124.             name = prefix.append(".").append(suffix).toString();
  125.         }
  126.         Map<String, List<String>> clazz2Methods = name2Clazz.getOrDefault(clazzName, new HashMap<>());
  127.         return clazz2Methods.getOrDefault(name, new ArrayList<>());
  128.     }
  129. }

七、结语

        创作不易，期待读者的支持。web 页面效果不是很理想，后续会持续更新。毕竟这个功能给我平时的工作帮助挺大的。况且先前说的根据方法找菜单的功能并没有完全实现，但就目前的方向来看，一定是正确的。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/在线问答5/article/detail/810160
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号