This article assume that you are familiar with Eclipse plug-in development. See Eclipse Plugin Development for an introduction. For user interface related activities, e.g. creating a view extension point please see Eclipse RCP tutorial.

The following will create a command which will read the project of the workspace, get all package and Java source files for these projects and read all methods for them by using the JDT Java Model API.

Create a plug-in project called de.vogella.jdt.infos. Choose the "Hello World, command" as a template.

Add the following dependencies to your plug-in:

Change the handler to the following.

package de.vogella.jdt.infos.handlers;

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.IJavaProject;
import org.eclipse.jdt.core.IMethod;
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.jface.text.Document;

public class SampleHandler extends AbstractHandler {

  public Object execute(ExecutionEvent event) throws ExecutionException {
    // 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) {
      try {
        printProjectInfo(project);
      } catch (CoreException e) {
        e.printStackTrace();
      }
    }
    return null;
  }

  private void printProjectInfo(IProject project) throws CoreException,
      JavaModelException {
    System.out.println("Working in project " + project.getName());
    // Check if we have a Java project
    if (project.isNatureEnabled("org.eclipse.jdt.core.javanature")) {
      IJavaProject javaProject = JavaCore.create(project);
      printPackageInfos(javaProject);
    }
  }

  private void printPackageInfos(IJavaProject javaProject)
      throws JavaModelException {
    IPackageFragment[] packages = javaProject.getPackageFragments();
    for (IPackageFragment mypackage : packages) {
      // Package fragments include all packages in the
      // classpath
      // We will only look at the package from the source
      // folder
      // K_BINARY would include also included JARS, e.g.
      // rt.jar
      if (mypackage.getKind() == IPackageFragmentRoot.K_SOURCE) {
        System.out.println("Package " + mypackage.getElementName());
        printICompilationUnitInfo(mypackage);

      }

    }
  }

  private void printICompilationUnitInfo(IPackageFragment mypackage)
      throws JavaModelException {
    for (ICompilationUnit unit : mypackage.getCompilationUnits()) {
      printCompilationUnitDetails(unit);

    }
  }

  private void printIMethods(ICompilationUnit unit) throws JavaModelException {
    IType[] allTypes = unit.getAllTypes();
    for (IType type : allTypes) {
      printIMethodDetails(type);
    }
  }

  private void printCompilationUnitDetails(ICompilationUnit unit)
      throws JavaModelException {
    System.out.println("Source file " + unit.getElementName());
    Document doc = new Document(unit.getSource());
    System.out.println("Has number of lines: " + doc.getNumberOfLines());
    printIMethods(unit);
  }

  private void printIMethodDetails(IType type) throws JavaModelException {
    IMethod[] methods = type.getMethods();
    for (IMethod method : methods) {

      System.out.println("Method name " + method.getElementName());
      System.out.println("Signature " + method.getSignature());
      System.out.println("Return Type " + method.getReturnType());

    }
  }
} 

Start your plug-in. Create a few projects in your new workspace. Create a few packages for them and a few Java files. Press the menu entry which points to your sample command.

You should see the projects, package and source files listed in the Console view of the calling workbench.

The following will create an AST for each source file in your workspace and print out the name and the return type of each method using the AST.

Create a new plug-in project "de.vogella.jdt.astsimple" using the "Hello world" template.

Maintain the following plug-in dependencies.

Manifest-Version: 1.0
Bundle-ManifestVersion: 2
Bundle-Name: Astsimple Plug-in
Bundle-SymbolicName: de.vogella.jdt.astsimple;singleton:=true
Bundle-Version: 1.0.0
Bundle-RequiredExecutionEnvironment: JavaSE-1.6
Require-Bundle: org.eclipse.core.runtime;bundle-version="3.4.0",
 org.eclipse.ui;bundle-version="3.4.2",
 org.eclipse.jdt.core;bundle-version="3.4.4",
 org.eclipse.core.resources;bundle-version="3.4.2",
 org.eclipse.jdt.ui;bundle-version="3.4.2" 

To get information about the AST you can use the Visitor Pattern. This allows you to add a visitor to the AST for a specific elements. In this visitor can you capture information about the object and return it after processing the AST. Create for this the following class.

package de.vogella.jdt.astsimple.handler;

import java.util.ArrayList;
import java.util.List;

import org.eclipse.jdt.core.dom.ASTVisitor;
import org.eclipse.jdt.core.dom.MethodDeclaration;

public class MethodVisitor extends ASTVisitor {
  List<MethodDeclaration> methods = new ArrayList<MethodDeclaration>();

  @Override
  public boolean visit(MethodDeclaration node) {
    methods.add(node);
    return super.visit(node);
  }

  public List<MethodDeclaration> getMethods() {
    return methods;
  }
} 

Add a new command "de.vogella.jdt.astsimple.GetInfo" and put it into the menu.

Create the following handler for this command.

package de.vogella.jdt.astsimple.handler;

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.JavaModelException;
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 {

  private static final String JDT_NATURE = "org.eclipse.jdt.core.javanature";

  @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(JDT_NATURE)) {
          analyseMethods(project);
        }
      } catch (CoreException e) {
        e.printStackTrace();
      }
    }
    return null;
  }

  private void analyseMethods(IProject project) throws JavaModelException {
    IPackageFragment[] packages = JavaCore.create(project)
        .getPackageFragments();
    // parse(JavaCore.create(project));
    for (IPackageFragment mypackage : packages) {
      if (mypackage.getKind() == IPackageFragmentRoot.K_SOURCE) {
        createAST(mypackage);
      }

    }
  }

  private void createAST(IPackageFragment mypackage)
      throws JavaModelException {
    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());
      }

    }
  }

  
/**
   * 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
  }
} 

Add the command to your menu. Run your new plugin, create a new Java project and select the command. It should print out the information about your methods in the IDE from which you started your new plugin

Please help me to support this article:

Before posting questions, please see the vogella FAQ. If you have questions or find an error in this article please use the www.vogella.com Google Group. I have created a short list how to create good questions which might also help you.