Java - prüfen, ob Java-Datei gut geschrieben ist

Question

Meine Java-Anwendung muss eine Menge Java-Quellcodes analysieren, ich verwende diesen Parser https://github.com/javaparser/javaparser.

Dies ist die Funktion, in der ich eine andere Funktion aufrufen, die eine einzelne Datei analysiert:

private static void createSimplifiedAST(String userFolder, String userProjectFolder, ArrayList userProjectFiles){ 
    File projectDir = new File(usersFolderPath + userFolder + "/" + userProjectFolder); 

    // explore all java files inside a directory (user's project folder) 
    new DirExplorer((level, path, file) -> path.endsWith(".java"), (level, path, file) -> { 
     System.out.println(path); 
     System.out.println(Strings.repeat("=", path.length())); 

     // create root of simplified AST of user's single file 
     TreeNode<String> projectSingleFile = new ArrayMultiTreeNode<String>("projectFileTreeRoot"); 

     // create simplified AST of user's single file 
     declarationNumber = 0; 
     forNumber = 0; 
     forEachNumber = 0; 
     whileNumber = 0; 
     try { 
      iterateASTNodes(file, projectSingleFile); 
     } catch (ParseException ex) { 
      Logger.getLogger(JavaSourceCodeParser.class.getName()).log(Level.SEVERE, null, ex); 
     } catch (IOException ex) { 
      Logger.getLogger(JavaSourceCodeParser.class.getName()).log(Level.SEVERE, null, ex); 
     } 

     // prints single file tree 
     System.out.println(projectSingleFile); 

     // save simplified ASTs to txts 
     saveASTToTxt(userFolder, userProjectFolder, file, projectSingleFile); 

     // add simplified AST of single file to user's project files array list 
     userProjectFiles.add(projectSingleFile); 

    }).explore(projectDir); 
} 

Und dies ist die Funktion eine einzelne Datei zu analysieren:

private static void iterateASTNodes(File file, TreeNode<String> treeNode) throws ParseException, IOException{ 
    try { 
     new NodeIterator(new NodeIterator.NodeHandler() { 
      @Override 
      public boolean handle(Node node) { 
       if (node instanceof VariableDeclarator) { 
        treeNode.add(new ArrayMultiTreeNode<>("declaration" + declarationNumber)); 
        declarationNumber++; 
        return false; 
       } else if (node instanceof ForStmt) { 
        treeNode.add(new ArrayMultiTreeNode<>("for" + forNumber)); 
        forNumber++; 
        iterateASTNodesWrapper(node, treeNode.find("for" + (forNumber - 1))); 
        return false; 
       } else if (node instanceof ForeachStmt) { 
        treeNode.add(new ArrayMultiTreeNode<>("foreach" + forEachNumber)); 
        forEachNumber++; 
        iterateASTNodesWrapper(node, treeNode.find("foreach" + (forEachNumber - 1))); 
        return false; 
       } else if (node instanceof WhileStmt) { 
        treeNode.add(new ArrayMultiTreeNode<>("while" + whileNumber)); 
        whileNumber++; 
        iterateASTNodesWrapper(node, treeNode.find("while" + (whileNumber - 1))); 
        return false; 
       } else { 
        return true; 
       } 
      } 
     }).explore(JavaParser.parse(file)); 
    } catch (ParseException | IOException ex) { 
     System.err.println(" ERROR: lexical error!"); 
    } 
} 

Dies ist die NodeIterator Klasse :

public class NodeIterator { 
    public interface NodeHandler { 
     boolean handle(Node node); 
    } 

    private NodeHandler nodeHandler; 

    public NodeIterator(NodeHandler nodeHandler) { 
     this.nodeHandler = nodeHandler; 
    } 

    public void explore(Node node) { 
     if (nodeHandler.handle(node)) { 
      for (Node child : node.getChildrenNodes()) { 
       explore(child); 
      } 
     } 
    } 
} 

Und die DirExplorer Klasse:

public class DirExplorer { 
    public interface FileHandler { 
     void handle(int level, String path, File file); 
    } 

    public interface Filter { 
     boolean interested(int level, String path, File file); 
    } 

    private FileHandler fileHandler; 
    private Filter filter; 

    public DirExplorer(Filter filter, FileHandler fileHandler) { 
     this.filter = filter; 
     this.fileHandler = fileHandler; 
    } 

    public void explore(File root) { 
     explore(0, "", root); 
    } 

    private void explore(int level, String path, File file) { 
     try { 
      if (file.isDirectory()) { 
       for (File child : file.listFiles()) { 
        explore(level + 1, path + "/" + child.getName(), child); 
       } 
      } else { 
       if (filter.interested(level, path, file)) { 
        fileHandler.handle(level, path, file); 
       } 
      } 
     } catch (Exception e) { 
      System.out.println(" ERROR: something went wrong!\n"); 
     } 
    } 
} 

Wenn ich das Programm laufen, an einem gewissen Punkt, stoppt er, während diese Datei Parsen:

public class Test { 
    /**<caret> 
    public void foo() { 
    } 
} 

ich verstanden habe, dass es wegen eines lexikalischen Fehler stoppt, dies:

Exception in thread "main" com.github.javaparser.TokenMgrError: Lexical error at line 6, column 2. Encountered: <EOF> after : "" 
at com.github.javaparser.ASTParserTokenManager.getNextToken(ASTParserTokenManager.java:2480) 
at com.github.javaparser.ASTParser.jj_ntk(ASTParser.java:9154) 
at com.github.javaparser.ASTParser.ClassOrInterfaceBody(ASTParser.java:829) 
at com.github.javaparser.ASTParser.ClassOrInterfaceDeclaration(ASTParser.java:470) 
at com.github.javaparser.ASTParser.TypeDeclaration(ASTParser.java:398) 
at com.github.javaparser.ASTParser.CompilationUnit(ASTParser.java:203) 
at com.github.javaparser.JavaParser.parse(JavaParser.java:111) 
at com.github.javaparser.JavaParser.parse(JavaParser.java:158) 
at com.github.javaparser.JavaParser.parse(JavaParser.java:177) 
at javasourcecodeparser.JavaSourceCodeParser.iterateASTNodes(JavaSourceCodeParser.java:89) 
at javasourcecodeparser.JavaSourceCodeParser.lambda$createSimplifiedAST$1(JavaSourceCodeParser.java:178) 
at javasourcecodeparser.DirExplorer.explore(DirExplorer.java:35) 
at javasourcecodeparser.DirExplorer.explore(DirExplorer.java:31) 
at javasourcecodeparser.DirExplorer.explore(DirExplorer.java:31) 
at javasourcecodeparser.DirExplorer.explore(DirExplorer.java:31) 
at javasourcecodeparser.DirExplorer.explore(DirExplorer.java:31) 
at javasourcecodeparser.DirExplorer.explore(DirExplorer.java:31) 
at javasourcecodeparser.DirExplorer.explore(DirExplorer.java:31) 
at javasourcecodeparser.DirExplorer.explore(DirExplorer.java:31) 
at javasourcecodeparser.DirExplorer.explore(DirExplorer.java:24) 
at javasourcecodeparser.JavaSourceCodeParser.createSimplifiedAST(JavaSourceCodeParser.java:194) 
at javasourcecodeparser.JavaSourceCodeParser.main(JavaSourceCodeParser.java:225) 

Jetzt stoppt dieser Fehler das gesamte Programm und ich bin nicht in der Lage, die anderen "guten" Codes zu analysieren.

Was ich will ist, dass das Programm die Datei mit lexikalischen Fehlern überspringen und die anderen Dateien weiter analysieren muss.

Irgendwelche Ideen? Vielleicht versuchen Sie, jede Datei zu kompilieren und nur zu analysieren, wenn die Kompilierung erfolgreich ist?

Answer 1

Sie haben uns nicht die Stacktrace gezeigt, aber ich erwarte, dass die Ausnahme in diesem Methodenaufruf ausgelöst wird:

JavaParser.parse(file) 

Wenn ja, ist die Lösung einfach Ihren Code restrukturieren, so dass Sie geworfen fangen Ausnahmen durch diesen Anruf, und fahren Sie dann mit der nächsten Datei fort.