[Java] IDEA插件之快速删除Java代码中的注释

• 实现状态机。该方式较为通用，适用于多种语言（取决于状态机支持的注释符号）。
  
• 正则匹配。该方式容易误判，尤其是容易误删字符串。
  
• 利用第三方库。该方式局限性较强，比如不同语言可能有不同的第三方库。
  

• JavaParser解析源码并得到AST。
  
• 识别出注释类型的节点并将其删掉。
  
• 将AST中剩余的节点按一定规则打印出来。
  

• LineComment 单行注释。
  
• BlockComent 块注释。
  
• JavadocComment Java文档注释。
  

import java.util.ArrayList;
import java.util.stream.Collectors;
/**
 * @author xiaoxi666
 * @date 2021-02-15 17:13
 * 我是 Javadoc 注释
 */
public class Input {
  /**
   * 我是 Javadoc 注释
   *
   * @param param1
   * @param param2
   */
  public static void someMethod(String param1, // 我是单行注释
         String param2
// 我是单行注释 String param3,
/* 我是块注释 String param4,
         String param5,
         String param6 */
  /* 我是块注释 String param4 */)
 {
  // 我是单行注释
  int a = 1;
  /* 我是块注释，注意我和Javadoc注释的区别，我只有一个星号 */
  int b = 2;
  /*
   * 我是块注释
   */
  int c = 3;
  String s1 = "// 我是字符串中的内容，不是注释";
  String s2 = "/* 我是字符串中的内容，不是注释 */";
  String s3 = "/** 我是字符串中的内容，不是注释 */";
  }
}

<dependencies>
  <dependency>
   <groupId>com.github.javaparser</groupId>
   <artifactId>javaparser-symbol-solver-core</artifactId>
   <version>3.18.0</version>
  </dependency>
</dependencies>

package core;import com.github.javaparser.JavaParser;
import com.github.javaparser.ParseResult;
import com.github.javaparser.ParserConfiguration;
import com.github.javaparser.ast.CompilationUnit;
import com.github.javaparser.ast.Node;
import com.github.javaparser.ast.comments.BlockComment;
import com.github.javaparser.ast.comments.Comment;
import com.github.javaparser.ast.comments.LineComment;
import com.github.javaparser.printer.lexicalpreservation.LexicalPreservingPrinter;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
/**
 * @author xiaoxi666
 * @date 2021-02-15 20:09
 * 几个注释的概念：
 * LineComment
 * BlockComment
 * JavadocComment
 */
public final class CommentsRemover {
  private CommentsRemover() {}
  public static String doAction(String content) {
  JavaParser javaParser = createJavaParser();
  ParseResult<CompilationUnit> result = javaParser.parse(content);
  Optional<CompilationUnit> optionalCompilationUnit = result.getResult();
  if (!optionalCompilationUnit.isPresent()) {
    return "";
  }
  CompilationUnit compilationUnit = optionalCompilationUnit.get();
  removeComments(compilationUnit);
  return LexicalPreservingPrinter.print(compilationUnit);
  }
  private static void removeComments(CompilationUnit compilationUnit) {
  List<Comment> comments = compilationUnit.getAllContainedComments();
  List<Comment> unwantedComments = comments
    .stream()
    .filter(CommentsRemover::isValidCommentType)
    .collect(Collectors.toList());
  unwantedComments.forEach(Node::remove);
  }
  /**
   * 创建源码解析器。我们设置LexicalPreservationEnabled为true，保留源码中的所有语法。
   *
   * @return JavaParser
   */
  private static JavaParser createJavaParser() {
  ParserConfiguration parserConfiguration = new ParserConfiguration();
  parserConfiguration.setLexicalPreservationEnabled(true);
  return new JavaParser(parserConfiguration);
  }
  /**
   * 我们只识别单行注释和块注释
   *
   * @param comment
   * @return true if meet the correct type
   */
  private static boolean isValidCommentType(Comment comment) {
  return comment instanceof LineComment || comment instanceof BlockComment;
  }
}

• 删除源码注释。首先读取当前文件内容也即源码，然后交给前面已经介绍过的CommentsRemover.doAction处理，就拿到了删除注释后的源码。
  
• 格式化代码。删除注释后，可能会引入多余的空格，因此我们自动格式化，这样用户就不用再手动格式化一次了。
  

/**
 * 移除代码中的注释
 *
 * @param editor
 * @return true if remove comments successfully
 */
private boolean removeComments(Editor editor) {
  String src = editor.getDocument().getText();
  if (Strings.isNullOrEmpty(src)) {
  return false;
  }
  String dst = CommentsRemover.doAction(checkEndLineAndModifyIfNeed(src));
  if (Strings.isNullOrEmpty(dst)) {
  return false;
  }
  editor.getDocument().setText(dst);
  return true;
}
/**
 * 由于我们保留了源码格式，移除注释之后会引入不必要的空格，因此需要再格式化一下
 *
 * @param editor
 * @param project
 */
private void reformat(Editor editor, Project project) {
  PsiDocumentManager.getInstance(project).commitAllDocuments();
  PsiFile file = PsiDocumentManager.getInstance(project).getPsiFile(editor.getDocument());
  if (file == null) {
  return;
  }
  LastRunReformatCodeOptionsProvider provider = new LastRunReformatCodeOptionsProvider(PropertiesComponent.getInstance());
  ReformatCodeRunOptions currentRunOptions = provider.getLastRunOptions(file);
  TextRangeType processingScope = TextRangeType.WHOLE_FILE;
  currentRunOptions.setProcessingScope(processingScope);
  (new FileInEditorProcessor(file, editor, currentRunOptions)).processCode();
}

• 对于500行左右的文件，响应时间约200ms，几乎瞬间完成。
  
• 对于1000行左右的文件，响应时间约为1s。
  
• 对于3000行左右的文件，响应时间约需2s。
  
• 对于5000行左右的文件，响应时间约需3s。