Categoría: Java Development Tools (JDT)

Este ejemplo pertenece a Eclipse JDT Tutorial Series.

Normalmente, Eclipse JDT se utiliza en un entorno de plug-in. Esta es la situación normal en la que nos ocupamos de cada proyecto en el espacio de trabajo. Sin embargo, si queremos analizar una gran cantidad de archivos java, este enfoque puede no ser bueno, ya que no es fácil importar muchos proyectos al espacio de trabajo manualmente. (Podemos importar proyectos automáticamente, pero esa es otra historia).

¿Podemos usar ASTParser de Eclipse para analizar el código fuente de Java en una aplicación independiente, en lugar de un complemento? Hice la misma pregunta antes de encontrar la solución. Aquí hay un ejemplo de código completo en el que ASTParser funciona en una aplicación independiente.

 
import java.util.HashSet;
import java.util.Set;
import org.eclipse.jdt.core.dom.AST;
import org.eclipse.jdt.core.dom.ASTParser;
import org.eclipse.jdt.core.dom.ASTVisitor;
import org.eclipse.jdt.core.dom.CompilationUnit;
import org.eclipse.jdt.core.dom.SimpleName;
import org.eclipse.jdt.core.dom.VariableDeclarationFragment;
 
public class Test {
	public static void main(String args[]){
		ASTParser parser = ASTParser.newParser(AST.JLS3);
		parser.setSource("public class A { int i = 9;  n int j; n ArrayList<Integer> al = new ArrayList<Integer>();j=1000; }".toCharArray());
		//parser.setSource("/*abc*/".toCharArray());
		parser.setKind(ASTParser.K_COMPILATION_UNIT);
		//ASTNode node = parser.createAST(null);
 
 
		final CompilationUnit cu = (CompilationUnit) parser.createAST(null);
 
		cu.accept(new ASTVisitor() {
 
			Set names = new HashSet();
 
			public boolean visit(VariableDeclarationFragment node) {
				SimpleName name = node.getName();
				this.names.add(name.getIdentifier());
				System.out.println("Declaration of '"+name+"' at line"+cu.getLineNumber(name.getStartPosition()));
				return false; // do not continue to avoid usage info
			}
 
			public boolean visit(SimpleName node) {
				if (this.names.contains(node.getIdentifier())) {
				System.out.println("Usage of '" + node + "' at line " +	cu.getLineNumber(node.getStartPosition()));
				}
				return true;
			}
 
		});
	}
}

Imprimirá el siguiente mensaje:

Declaration of 'i' at line1
Declaration of 'j' at line2
Declaration of 'al' at line3

Todos los problemas, como «El tipo org.eclipse.core.runtime.IProgressMonitor no se puede resolver. Se hace referencia indirectamente a él desde los archivos .class obligatorios», etc., son causados ​​por bibliotecas faltantes.

Aquí están los archivos jar requeridos:

org.eclipse.core.contenttype.jar
org.eclipse.core.jobs.jar
org.eclipse.core.resources.jar
org.eclipse.core.runtime.jar
org.eclipse.equinox.common.jar
org.eclipse.equinox.preferences.jar
org.eclipse.jdt.core.jar
org.eclipse.osgi.jar

Lo siguiente es lo que utilicé para este programa de muestra.

Estos archivos jar estarán en el directorio de complementos, una vez que haya instalado el complemento astview. Aquí es una publicación sobre cómo agregar el complemento astview. Para mayor comodidad, también hice un archivo rar que incluye todos los archivos jar necesarios. Puedes descargarlo directamente aquí.

Esto es otro artículo que puede resultarle útil para comprender AST.

JDT es compatible con 3 pilares: modelo Java, motor de búsqueda y AST. Es una herramienta útil para manipular el código fuente de Java. Sin embargo, la práctica herramienta viene con una curva de aprendizaje empinada incluso para un desarrollador de Java experimentado y simplemente no hay suficientes ejemplos de código adecuados. Esta página resume los ejemplos de código para usar Eclipse JDT.

• Modelo Java
  • Modelo Java: concepto y diseño
  • Modelo Java: crear, acceder y cargar proyectos
  • Atravesar el archivo .jar mediante Eclipse JDT
  • Contar el número total de métodos en un proyecto Java
• Motor de búsqueda de Java
  • Un ejemplo muy simple
  • Referencias de métodos de búsqueda
• ASTParser: analizar proyectos, archivos y métodos
  • Utilice ASTView para explorar AST de una clase Java
  • Analizar un proyecto Java en el espacio de trabajo
  • Analizar archivos .java individuales
  • Analizar un método Java
  • Analizar declaraciones de Java
  • Un ejemplo independiente completo de ASTParser
  • ¿Cómo resolver enlaces al usar Eclipse JDT ASTParser?
• Más ejemplos y posibles problemas
  • Obtenga comentarios internos utilizando Eclipse JDT ASTParser
  • ¿Cómo formatear el código fuente usando CodeFormatter?
  • Insertar líneas en blanco en el código fuente
  • Agregar un comentario al código fuente
  • Agregar una declaración al código fuente
  • Cargue dinámicamente una gran cantidad de proyectos de código abierto en el espacio de trabajo
  • Encuentra todas las personas que llaman a un método: obtén todos los métodos que llaman a un método en particular
  • Contar el número de declaraciones en un método Java utilizando Eclipse JDT ASTParser
  • java.lang.IllegalStateException: el espacio de trabajo está cerrado.

Si tiene algún problema, deje su comentario para que podamos comunicarme con usted lo antes posible.

Este tutorial pertenece a Eclipse JDT Tutorial Series.

ASTParser puede usar su método setKind () para configurar la fuente para que sea analizada como una unidad de compilación, expresión única, una secuencia de declaraciones o una secuencia de declaraciones del cuerpo de la clase.

parser.setKind(ASTParser.K_COMPILATION_UNIT);

Cualquiera de esos cuatro no puede manejar un solo método independiente. Esto no es agradable. Siguiendo la lógica de una unidad de compilación, se puede analizar una clase. Entonces podemos agregar un nombre de clase falso como un shell a cada método, luego el método envuelto en una clase falsa se puede analizar correctamente usando ASTParser.

El código se ve así:

String sourceStart = "public class A {";
//add a fake class A as a shell, to meet the requirement of ASTParser
String sourceMiddle = "";
for(String s : tempMiddle){	
	s = s.trim();
	if(s.trim().length()>0 && !s.startsWith("---") && !s.startsWith("/") && !s.startsWith("*") )
	sourceMiddle += s.trim() + "n";
}
String sourceEnd = "}";
 
String source = sourceStart + sourceMiddle + sourceEnd;
 
parser.setSource(source.toCharArray());
parser.setKind(ASTParser.K_COMPILATION_UNIT);
final CompilationUnit cu = (CompilationUnit) parser.createAST(null);
 
cu.accept(new ASTVisitor() {
        //by add more visit method like the following below, then all king of statement can be visited.
	public boolean visit(ForStatement node) {
 
	System.out.println("ForStatement -- content:" + node.toString());
 
	ArrayList<Integer> al = new ArrayList<Integer>();
	al.add(node.getStartPosition());
	al.add(node.getLength());
 
	statements.add(al);
	return false;
}
 
      	/*
	IfStatement
	ForStatement
	WhileStatement
	DoStatement
	TryStatement
	SwitchStatement
	SynchronizedStatement
	*/
}

Puede haber una mejor manera de hacer esto, pero seguramente esto funciona y es mucho mejor que escribir un analizador desde cero.

Salud.

Aquí hay una publicación sobre el uso de JDT ASTParser para analizar una clase que reside en un archivo .java.

Esta publicación pertenece a la serie de tutoriales Eclipse JDT.

Este mensaje de error inicia toda la serie de tutoriales de JDT ASTParser.

En resumen, esto se debe simplemente a la adición de archivos jar dependientes al proyecto Java normal.

Para usar JDT, debe tener el programa ejecutándose como un complemento (o al menos, una aplicación habilitada para OSGi) en lugar de usarlo como un jar.

Se pueden encontrar tutoriales paso a paso mediante el botón de búsqueda en la barra lateral derecha:

1. ¿Cómo crear un proyecto de complemento?
2. ¿Cómo funciona JDT?
3. Un ejemplo completo para analizar un proyecto java.

En este artículo, usaremos Eclipse JDT para crear, acceder y cargar proyectos. Supongo que sabe cómo crear un proyecto de complemento de Eclipse simple que agrega un elemento de menú en el que puede hacer clic y activar algunas acciones. Si no lo sabe, puede consultar este artículo. La razón por la que necesitamos un proyecto de complemento es que el modelo Java solo funciona dentro de un complemento, una aplicación independiente no es compatible con el modelo Java.

Este artículo solo se centra en el modelo JDT Java. Se explorarán los siguientes tres temas:

• Crea proyectos en el espacio de trabajo
• Acceder a proyectos en el espacio de trabajo
• Importe dinámicamente proyectos existentes al espacio de trabajo

Esos son esencialmente importantes cuando desea procesar una gran cantidad de proyectos Java.

1. Crea proyectos

Podemos usar Java Model para crear un nuevo proyecto en el espacio de trabajo.

Lo siguiente aquí requiere las siguientes dependencias:

import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IProjectDescription;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IPackageFragment;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.launching.JavaRuntime;

Agregue código para ejecutar el método. El código ignora las declaraciones try / catch, Eclipse le pedirá que agregue código de manejo de excepciones.

// create a project with name "TESTJDT"
IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
IProject project = root.getProject("TESTJDT");
project.create(null);
project.open(null);
 
//set the Java nature
IProjectDescription description = project.getDescription();
description.setNatureIds(new String[] { JavaCore.NATURE_ID });
 
//create the project
project.setDescription(description, null);
IJavaProject javaProject = JavaCore.create(project);
 
//set the build path
IClasspathEntry[] buildPath = {
		JavaCore.newSourceEntry(project.getFullPath().append("src")),
				JavaRuntime.getDefaultJREContainerEntry() };
 
javaProject.setRawClasspath(buildPath, project.getFullPath().append(
				"bin"), null);
 
//create folder by using resources package
IFolder folder = project.getFolder("src");
folder.create(true, true, null);
 
//Add folder to Java element
IPackageFragmentRoot srcFolder = javaProject
				.getPackageFragmentRoot(folder);
 
//create package fragment
IPackageFragment fragment = srcFolder.createPackageFragment(
		"com.programcreek", true, null);
 
//init code string and create compilation unit
String str = "package com.programcreek;" + "n"
	+ "public class Test  {" + "n" + " private String name;"
	+ "n" + "}";
 
		ICompilationUnit cu = fragment.createCompilationUnit("Test.java", str,
				false, null);
 
//create a field
IType type = cu.getType("Test");
 
type.createField("private String age;", null, true, null);

Cuando active la acción, se creará el siguiente proyecto.

2. Acceder a proyectos

Si ya hay proyectos en nuestro espacio de trabajo, podemos usar Java Model para recorrer cada uno de ellos.

	public void run(IAction action) {
		// Get the root of the workspace
		IWorkspace workspace = ResourcesPlugin.getWorkspace();
		IWorkspaceRoot root = workspace.getRoot();
		// Get all projects in the workspace
		IProject[] projects = root.getProjects();
		// Loop over all projects
		for (IProject project : projects) {
			System.out.println(project.getName());
		}
 
	}

Si importamos algunos proyectos o creamos algunos, y hacemos clic en el elemento del menú que creamos, los nombres de los proyectos se mostrarán de la siguiente manera.

3. Cargar / importar dinámicamente proyectos existentes en el espacio de trabajo

En el paso anterior, necesitamos importar manualmente los proyectos existentes al espacio de trabajo. Si el número es mayor, esto no sería aplicable.

Eclipse JDT proporciona funciones para hacer esto de forma dinámica. Ahora veamos cómo importar una gran cantidad de proyectos existentes al espacio de trabajo. No copia archivos al directorio raíz del espacio de trabajo, solo apunta a los proyectos en el directorio externo. En el ejemplo, utilizo la unidad flash para guardar mis proyectos de código abierto. De esta manera, puede analizar miles de proyectos y obtener la información útil que necesita sin copiar nada.

IWorkspaceRoot root= ResourcesPlugin.getWorkspace().getRoot();
 
final IWorkspace workspace = ResourcesPlugin.getWorkspace();
 
System.out.println("root" + root.getLocation().toOSString());
 
Runnable runnable = new Runnable() {
	public void run() {
		try {
			IPath projectDotProjectFile = new Path("/media/flashx/TestProjectImport" + "/.project");
			IProjectDescription projectDescription = workspace.loadProjectDescription(projectDotProjectFile);
			IProject project = workspace.getRoot().getProject(projectDescription.getName());
			JavaCapabilityConfigurationPage.createProject(project, projectDescription.getLocationURI(),	null);
			//project.create(null);
		} catch (CoreException e) {
			e.printStackTrace();
		}
	}
};
 
// and now get the workbench to do the work
final IWorkbench workbench = PlatformUI.getWorkbench();
workbench.getDisplay().syncExec(runnable);
 
 
IProject[] projects = root.getProjects();
 
for(IProject project: projects){
	System.out.println(project.getName());
}

¿Qué pasa si el proyecto que queremos cargar no contiene un archivo .project? Este es el caso complicado, necesitamos crear dinámicamente todos esos proyectos usando su código fuente.

Notas

Cuando practique los ejemplos anteriores, es posible que obtenga un mensaje de error como «El tipo org.eclipse.core.runtime.IAdaptable no se puede resolver. Se hace referencia indirectamente a partir de archivos .class obligatorios». La solución es agregar org.eclipse.core.runtime mediante el Editor de menús de complementos. Simplemente agregar a la ruta de construcción no funcionará.

Si cree que este artículo es útil y desea leer más, puede ir a Eclipse JDT Tutorial Series que escribí.

Este tutorial pertenece a Eclipse JDT Tutorial Series.

Dado un método, es posible que deseemos un recuento del número de declaraciones en el método (por ejemplo: para medir la complejidad del método). Podemos usar eclipse JDT ASTParser para hacer este trabajo.

Una forma aproximada de contar el número de declaraciones en un método es contar el número de líneas que terminan con punto y coma junto con líneas que contienen las palabras «si / para / mientras /».

En esta publicación, explicaré una técnica para contar el número de declaraciones de una manera más precisa utilizando el paradigma de visitante de eclipse jdt. Esta publicación anterior trata sobre cómo trabaja el visitante.

Este ejemplo demuestra el uso de la visita y la visita final para capturar lo que sucede entre la visita y la visita final.

Básicamente, inicializamos un campo, el recuento de declaraciones a 0 en la visita de una declaración de método, incrementamos este campo en cada visita de declaraciones como la declaración If, la declaración de retorno, etc. Finalmente, cuando se llama a la visita final de la declaración del método, tenemos un recuento de las declaraciones en el método.

public boolean visit(MethodDeclaration md) {
	// initialize the field to 0
	m_nStatementCount = 0;
	return true;
}
 
public void endVisit(MethodDeclaration md) {
	System.out.println("Statement count for method" + md.getName().getFullyQualifiedName() + 
	+ m_nStatementCount);
 
}
 
 
// the visitors below increment the statement count field
public boolean visit (ReturnStatement node) {
	m_nStatementCount++;
	return true;
}
 
public boolean visit (ExpressionStatement node) {
	m_nStatementCount++;
	return true;
}
 
public boolean visit (IfStatement node) {
	m_nStatementCount++;
	return true;
}
 
//and so on for other subclasses of Statement.*

* Tienes que escribir el código anterior para cada una de las subclases de Statement
descrito en help.eclipse.org.

Nota: no existe un método de visita que tome un objeto Statement como parámetro; de lo contrario, podríamos haber tenido uno de esos métodos de visita en el que se incrementa el recuento.

Para obtener una vista completa de cómo funciona todo el método, vaya a una publicación anterior aquí.

Este tutorial pertenece a Eclipse JDT Tutorial Series.

Exploraré cómo podemos calcular el ventilador, es decir, encontrar todos los métodos que llaman a un método en particular (todos los llamadores de un método).

En Eclipse, uno puede hacer clic derecho en un método y elegir «abrir jerarquía de llamadas» y eclipse muestra todos los métodos que llaman al método seleccionado y todos los métodos que son llamados desde el método seleccionado (llamadores y destinatarios del método seleccionado).

Podemos encontrar personas que llaman y destinatarios mediante programación y les explicaré cómo lo he hecho.

Hay un par de formas diferentes que conozco:

1. Use las clases internas de eclipse JDT: estas son las mismas clases que usa eclipse para mostrar los llamadores y los destinatarios de un método
2. Utilice el visitante ast de eclipse

En esta publicación, discutiré cómo podemos usar las clases internas de eclipse JDT para encontrar llamadores y destinatarios de un método.

En primer lugar, importe las siguientes clases (como puede ver, ¡están en un paquete «interno»!)

import org.eclipse.jdt.internal.corext.callhierarchy.CallHierarchy;
import org.eclipse.jdt.internal.corext.callhierarchy.MethodWrapper;

Escriba un métodogetCallersOf que tome el método seleccionado como entrada [IMethod]. Este será su método de tipo API, debe llamar a este método desde su programa para cualquier método cuyas llamadas desee encontrar.

La parte crucial del código es obtener primero el objeto CallHierarchy predeterminado, usar este objeto CallHierarchy para obtener las raíces de llamada del IMethod de entrada y, para cada objeto contenedor de método que se devuelve, invocar el método getCalls. getCalls a su vez devuelve una matriz de objetos MethodWrapper y estos son los llamadores reales. De cada objeto MethodWrapper, podemos obtener un IMethod correspondiente.

 
public HashSet<IMethod> getCallersOf(IMethod m) {
 
 CallHierarchy callHierarchy = CallHierarchy.getDefault();
 
 IMember[] members = {m};
 
 MethodWrapper[] methodWrappers = callHierarchy.getCallerRoots(members);
  HashSet<IMethod> callers = new HashSet<IMethod>();
  for (MethodWrapper mw : methodWrappers) {
    MethodWrapper[] mw2 = mw.getCalls(new NullProgressMonitor());
    HashSet<IMethod> temp = getIMethods(mw2);
    callers.addAll(temp);    
   }
 
return callers;
}
 
 HashSet<IMethod> getIMethods(MethodWrapper[] methodWrappers) {
  HashSet<IMethod> c = new HashSet<IMethod>(); 
  for (MethodWrapper m : methodWrappers) {
   IMethod im = getIMethodFromMethodWrapper(m);
   if (im != null) {
    c.add(im);
   }
  }
  return c;
 }
 
 IMethod getIMethodFromMethodWrapper(MethodWrapper m) {
  try {
   IMember im = m.getMember();
   if (im.getElementType() == IJavaElement.METHOD) {
    return (IMethod)m.getMember();
   }
  } catch (Exception e) {
   e.printStackTrace();
  }
  return null;
 }

Este ejemplo pertenece a Eclipse JDT Tutorial Series.

He hablado sobre cómo analizar un método Java, cómo analizar una secuencia de declaraciones. Ahora veamos cómo analizar un proyecto Java.

Este ejemplo utiliza Eclipse JDT ASTParser y Java Model. Dado que el modelo Java debe usarse dentro de un complemento, el siguiente código debe ejecutarse dentro de un proyecto de complemento. Puede leer el tutorial sobre cómo crear un complemento.

El siguiente es el código para manejar una acción y analiza un proyecto.

import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IPackageFragment;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.dom.AST;
import org.eclipse.jdt.core.dom.ASTParser;
import org.eclipse.jdt.core.dom.CompilationUnit;
import org.eclipse.jdt.core.dom.MethodDeclaration;
 
public class GetInfo extends AbstractHandler {
 
        @Override
        public Object execute(ExecutionEvent event) throws ExecutionException {
                IWorkspace workspace = ResourcesPlugin.getWorkspace();
                IWorkspaceRoot root = workspace.getRoot();
                // Get all projects in the workspace
                IProject[] projects = root.getProjects();
                // Loop over all projects
                for (IProject project : projects) {
                        try {
                                if (project.isNatureEnabled("org.eclipse.jdt.core.javanature")) {
 
                                        IPackageFragment[] packages = JavaCore.create(project)
                                                        .getPackageFragments();
                                        // parse(JavaCore.create(project));
                                        for (IPackageFragment mypackage : packages) {
                                                if (mypackage.getKind() == IPackageFragmentRoot.K_SOURCE) {
                                                        for (ICompilationUnit unit : mypackage
                                                                        .getCompilationUnits()) {
                                                                // Now create the AST for the ICompilationUnits
                                                                CompilationUnit parse = parse(unit);
                                                                //MethodVisitor visitor = new MethodVisitor();
                                                               // parse.accept(visitor);
 
                                                                /*for (MethodDeclaration method : visitor.getMethods()) {
                                                                        System.out.print("Method name: "
                                                                                        + method.getName()
                                                                                        + " Return type: "
                                                                                        + method.getReturnType2());
                                                                }  */
 
                                                        }
                                                }
 
                                        }
                                }
                        } catch (CoreException e) {
                                e.printStackTrace();
                        }
                }
                return null;
        }
 
        /**
         * Reads a ICompilationUnit and creates the AST DOM for manipulating the
         * Java source file
         *
         * @param unit
         * @return
         */
 
        private static CompilationUnit parse(ICompilationUnit unit) {
                ASTParser parser = ASTParser.newParser(AST.JLS3);
                parser.setKind(ASTParser.K_COMPILATION_UNIT);
                parser.setSource(unit);
                parser.setResolveBindings(true);
                return (CompilationUnit) parser.createAST(null); // parse
        }
}

* Puede buscar usando el código de Google y obtener un montón de ejemplos de código como el anterior. En realidad, el código anterior es un ejemplo de estilo de programación basado en búsquedas. Debe probarse completamente antes de pasar a producción.

Este ejemplo pertenece a Eclipse JDT Tutorial Series.

En primer lugar, Eclipse JDT ASTParser PUEDE funcionar en una aplicación Java estándar. Esto brinda la conveniencia de un simple análisis de una gran cantidad de archivos de clase Java. Suponga que desea analizar 100 archivos .java que se encuentran en un directorio. No podrá importar al espacio de trabajo de eclipse como un proyecto. Afortunadamente, todavía podemos analizar esos archivos usando ASTParser.

En resumen, hay 3 pasos para hacer esto:
1. leer nombres de archivos de un directorio
2. obtener cadenas de código de cada archivo
3. use JDT ASTParser para analizar

A continuación se muestran los archivos jar necesarios para ejecutar el programa. Esta es una condición previa, el problema ocurrirá si no se configura correctamente. Aquí está el enlace de descarga: lib.zip.

Aquí hay un código completo de ASTParser en una aplicación Java estándar independiente.

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.HashSet;
import java.util.Set;
 
import org.eclipse.jdt.core.dom.AST;
import org.eclipse.jdt.core.dom.ASTParser;
import org.eclipse.jdt.core.dom.ASTVisitor;
import org.eclipse.jdt.core.dom.CompilationUnit;
import org.eclipse.jdt.core.dom.SimpleName;
import org.eclipse.jdt.core.dom.VariableDeclarationFragment;
 
public class Main {
 
	//use ASTParse to parse string
	public static void parse(String str) {
		ASTParser parser = ASTParser.newParser(AST.JLS3);
		parser.setSource(str.toCharArray());
		parser.setKind(ASTParser.K_COMPILATION_UNIT);
 
		final CompilationUnit cu = (CompilationUnit) parser.createAST(null);
 
		cu.accept(new ASTVisitor() {
 
			Set names = new HashSet();
 
			public boolean visit(VariableDeclarationFragment node) {
				SimpleName name = node.getName();
				this.names.add(name.getIdentifier());
				System.out.println("Declaration of '" + name + "' at line"
						+ cu.getLineNumber(name.getStartPosition()));
				return false; // do not continue 
			}
 
			public boolean visit(SimpleName node) {
				if (this.names.contains(node.getIdentifier())) {
					System.out.println("Usage of '" + node + "' at line "
							+ cu.getLineNumber(node.getStartPosition()));
				}
				return true;
			}
		});
 
	}
 
	//read file content into a string
	public static String readFileToString(String filePath) throws IOException {
		StringBuilder fileData = new StringBuilder(1000);
		BufferedReader reader = new BufferedReader(new FileReader(filePath));
 
		char[] buf = new char[10];
		int numRead = 0;
		while ((numRead = reader.read(buf)) != -1) {
			System.out.println(numRead);
			String readData = String.valueOf(buf, 0, numRead);
			fileData.append(readData);
			buf = new char[1024];
		}
 
		reader.close();
 
		return  fileData.toString();	
	}
 
	//loop directory to get file list
	public static void ParseFilesInDir() throws IOException{
		File dirs = new File(".");
		String dirPath = dirs.getCanonicalPath() + File.separator+"src"+File.separator;
 
		File root = new File(dirPath);
		//System.out.println(rootDir.listFiles());
		File[] files = root.listFiles ( );
		String filePath = null;
 
		 for (File f : files ) {
			 filePath = f.getAbsolutePath();
			 if(f.isFile()){
				 parse(readFileToString(filePath));
			 }
		 }
	}
 
	public static void main(String[] args) throws IOException {
		ParseFilesInDir();
	}
}

Esta es una forma de analizar un archivo de clase Java, otra forma es hacerlo en un complemento.

Este artículo pertenece a la serie de tutoriales Eclipse JDT.

¿Qué es el modelo Java?

El modelo Java es el conjunto de clases que modelan los objetos asociados con la creación, edición y construcción de un programa Java.

Está definido en el paquete org.eclipse.jdt.core. En consecuencia, las clases que no son de API se definen en el paquete org.eclipse.jdt.internal.core. Verá su relación en la siguiente sección.

En el diagrama siguiente, se muestra un proyecto simple en la vista Explorar paquete. Cada elemento se asigna a algún IJavaElement. Todas esas clases extienden directamente o no directamente la clase IJavaElement, y hay muchas otras clases distintas a las que se muestran en el diagrama. Si desea ver más, puede ir a la referencia 2 para ver toda la jerarquía.

El diseño de la manija / información

Tomemos IJavaElement, por ejemplo, ya que es el protocolo común para todos los elementos proporcionados por el modelo Java. Otros elementos de Java tienen el mismo diseño (por ejemplo, IType, IMethod, etc.). Los elementos del modelo Java se exponen a los clientes como identificadores del elemento subyacente real.

En realidad, el patrón de diseño aquí es una mezcla de Proxy y Bridge. Esos patrones no son exactamente los mismos que se definen. Puede seguir los enlaces para ver qué es una implementación canónica del patrón Proxy y Bridge.

La ventaja de este diseño:
1. El identificador (IJavaElement) es una clave para un elemento. Definen comportamientos de cada elemento, pero no guardan ninguna información de estado.
2. Un objeto de información almacena el estado del elemento. Solo hay un implementador (JavaElement) para un identificador, por lo que es un Bridge simplificado.

* Los recursos centrales de Eclipse tienen un diseño similar.

Referencias:

1. Especificación JDT APT

2. Jerarquía para el paquete org.eclipse.jdt.core