Analyseur Java pour Netbeans?

Question

Existe-t-il un plugin ou un analyseur pour NetBeans qui peut créer une structure arborescente à partir de mon code source Java (ou me laisser facilement extraire des choses comme des noms de classes, des attributs et des méthodes)? Edit: J'ai besoin des noms à des fins de programmation, pas seulement pour les obtenir. J'ai besoin qu'ils soient retournés à mon programme lors de l'exécution.

Si je le code source (pour un jeu):

class Main { 
    Terrain terrain; 
    TradingSystem currentSystem; 
    City city; 

    public static void main(String[] args) { 

    } 
} 

class Terrain { 

} 

class City { 
    House tavern; 
} 

class TradingSystem { 
    Bank cityBank; 
    Trader npc1; 
} 

alors je besoin d'un analyseur que peut créer quelque chose comme ça

----------Main------------------- 
    |   |     | 
Terrain  City   --TradingSystem--- 
       |   |    | 
      House   Bank   Trader 

de mon code source. J'ai besoin d'un chemin de Main aux branches, comme ce Main-> TradingSystem-> Bank, ou ce Main-> City-> House.

Je dois être en mesure d'extraire les

• noms de classe
• noms de méthode
• noms d'attributs

J'ai besoin pour un plugin Netbeans je crée. Cela existe-t-il, gratuit à utiliser/télécharger?

Éditer: S'il existe quelque chose pour extraire les noms de classes, les noms d'attributs et les noms de méthodes d'un et d'un fichier source qui est une bonne deuxième option. Je peux écrire la logique supplémentaire à partir de là.

Answer 1

J'ai créé 3 classes simples:

public class A { 
    B b; 
} 

public class B { 
    C c; 

    public C getC() { 
     return c; 
    } 
} 

public class C { 

} 

Et un autre peu complexe:

public class SO { 

    A a; 
    B b; 
    C c; 

    public static void fooMethod1() { 
    } 

    public String fooMethod2() { 
     return ""; 
    } 

    private double fooMethod3() { 
     return 0.0; 
    } 
} 

j'ai pu extraire les informations ci-dessus par ce code récursif:

public void getData(Map<String, Set<String>> fields, Map<String, Set<String>> methods, Class clazz) 
    {   
     if(clazz.isPrimitive()) 
     { 
      return; 
     } 
     for(Method method : clazz.getDeclaredMethods()) 
     { 
      if(!methods.containsKey(clazz.getName())) 
      { 
       Set<String> methodNames = new HashSet<>(); 
       methodNames.add(method.getName()); 
       methods.put(clazz.getName(), methodNames); 
      } 
      else 
      { 
       methods.get(clazz.getName()).add(method.getName()); 
      } 
     } 

     for(Field field : clazz.getDeclaredFields()) 
     { 
      if(!fields.containsKey(clazz.getName())) 
      { 
       Set<String> fieldNames = new HashSet<>(); 
       fieldNames.add(field.getName()); 
       fields.put(clazz.getName(), fieldNames); 
      } 
      else 
      { 
       fields.get(clazz.getName()).add(field.getName()); 
      } 

      getData(fields, methods, field.getType()); 
     } 
    } 

I called the code above like so: 
SO so = new SO(); 
     Map<String, Set<String>> methods = new HashMap<>(); 
     Map<String, Set<String>> fields = new HashMap<>(); 
     so.getData(fields, methods, SO.class); 

Et imprimé les résultats comme suit:

for(String str : fields.keySet()) 
     { 
      System.out.println(str); 
      for(String fieldName : fields.get(str)) 
      { 
       System.out.print(fieldName + " "); 
      } 
      System.out.println(); 
     } 

     System.out.println("-------------------------------"); 
     for(String str : methods.keySet()) 
     { 
      System.out.println(str); 
      for(String methodName : methods.get(str)) 
      { 
       System.out.print(methodName + " "); 
      } 
      System.out.println(); 
     } 

Le résultat était donné comme ceci:

so.B 
c 
so.SO 
b c a 
so.A 
b 
------------------------------- 
so.B 
getC 
so.SO 
fooMethod3 getData fooMethod1 fooMethod2 main 

qui devrait être ce que vous recherchez.