Aktualisierungen August, 2009 Kommentarverlauf ein-/ausschalten | Tastaturkürzel

  • Andreas Höhmann 13:41 am Monday, 24. August 2009 Permalink |
    Tags: code template, , extension point, , m2eclipse, , , , pom, version   

    Use Maven Artifact Version in Eclipse Code Templates 

    Based on waffel’s blog i wrote a eclipse plugin which provides the current artifact-version of a maven-project to the eclipse editor-templates. Waffel want to add the current plugin id/version to the @since field for class comments, i want to add the current version of my maven-eclipse-project. Let me explain my solution.

    It’s easy to add a new template-variable to eclipse, you can read this. Based on  org.eclipse.jface.text.templates.TemplateVariableResolver we can write a MavenVersionResolver:

     * Resolver to resolve variable <code>pomVersion</code>.
     * @author hoehmann
     * @since 1.0.0
    public class MavenVersionResolver extends TemplateVariableResolver {
      public MavenVersionResolver() {
      private String getMavenVersion(final IProject project) {
        if (project == null) {
          throw new IllegalArgumentException("Missing project"); //$NON-NLS-1$
        String result = ""; //$NON-NLS-1$
        try {
          if (project.hasNature(IMavenConstants.NATURE_ID)) {
            final MavenProjectManager projectManager = MavenPlugin.getDefault()
            final IMavenProjectFacade projectFacade = projectManager.create(
                project, new NullProgressMonitor());
            if (projectFacade != null) {
              final ArtifactKey mavenProject = projectFacade.getArtifactKey();
              if (mavenProject != null) {
                result = mavenProject.getVersion();
                // remove snapshot-indicator
                final int index = result.lastIndexOf("-SNAPSHOT"); //$NON-NLS-1$
                if (index != -1) {
                  result = result.substring(0, index);
        } catch (final CoreException ex) {
        return result;
       * {@inheritDoc}
      protected String resolve(final TemplateContext context) {
        // TODO better way to get the project?!
        return getMavenVersion(((CodeTemplateContext) context).getJavaProject()

    With the MavenProjectManager from m2eclipse we can create a IMavenProjectFacade, this facade returns the ArtifactKey and this key have the version. If the version is a snapshot-version we can cut this trailing string off and the result is the (next) version for our maven-project (for me it doesn’t make sense to add the snapshot-version into a @since comment because the release-version should be documented in the sourcecode).

    Maybe the check for the „m2eclipse“-nature is not necessary:

    if (project.hasNature(IMavenConstants.NATURE_ID)) {....}

    I tried without the nature-check and it works. The project must contain a „pom.xml“ to get a IMavenProjectFacade.

    This was the first part of the solution. The placeholder „pom_version“ will be available for all editor-templates in the „java-context“:


    Waffel described already a solution (a workaround) to use a editor-template-resolver in the code-templates. He registered a IStartup class which copies his own BundleIdResolver/BundleVersionResolver into the (internal) code-template-context-registry of the Eclipse-Java-Plugin. For waffel this was fine because he doesn’t register his resolvers as editor-template-resolvers. I want use my MavenVersionResolver in all java-templates and in the code-templates.

    And i don’t want create a new instance of the resolver, i want reuse the extension-point-configured resolver. So i have only one place to define my resolver (type = ‚pom_version‘, localized name, localized description, class etc.).

    I found a other way to register the resolver

    1. i search my MavenVersionResolver in the registered editor-templates (java-context)
    2. if i found one, i add this reference to the (internal) code-template-registry

     * Currently it's not possible to provide more variables for
     * <tt>java-code-templates</tt>, we can only add more <tt>editor-templates</tt>
     * via extension-point.
     * <p>
     * This {@link IStartup} is a workaround to register our
     * {@link MavenVersionResolver} for <tt>java-code-templates</tt> too.
     * </p>
     * @author hoehmann
     * @since 1.0.0
    public class RegisterResolvers implements IStartup {
      private static final String JAVA_PLUGIN_ID = "org.eclipse.jdt.ui"; //$NON-NLS-1$
       * Add our resolver to each registered code-template-context.
       * @param javaPlugin
       *          must not be <code>null</code>
       * @param mavenVersionResolver
       *          must not be <code>null</code>
      private void addMavenVersionResolver(final JavaPlugin javaPlugin,
          final MavenVersionResolver mavenVersionResolver) {
        final ContextTypeRegistry codeTemplateContextRegistry = javaPlugin
        final Iterator ctIter = codeTemplateContextRegistry.contextTypes();
        while (ctIter.hasNext()) {
          final TemplateContextType contextType = (TemplateContextType) ctIter
       * {@inheritDoc}
      public void earlyStartup() {
        // check if plug-in org.eclipse.jdt.ui is final already active
        final Bundle bundle = Platform.getBundle(JAVA_PLUGIN_ID);
        if (bundle != null && bundle.getState() == Bundle.ACTIVE) {
        } else {
          // register listener to final get informed, when plug-in final becomes
          // active
          final BundleContext bundleContext = Activator.getDefault().getBundle()
          bundleContext.addBundleListener(new BundleListener() {
            public void bundleChanged(final BundleEvent pEvent) {
              final Bundle eventBundle = pEvent.getBundle();
              if (!eventBundle.getSymbolicName().equals(JAVA_PLUGIN_ID)) {
                // ignore other plugins
              if (eventBundle.getState() == Bundle.ACTIVE) {
       * Try to find our {@link MavenVersionResolver} in the java-plugin
       * template-context-registry.
       * @param javaPlugin
       *          must not be <code>null</code>
       * @return
      private MavenVersionResolver getMavenVersionResolver(
          final JavaPlugin javaPlugin) {
        final ContextTypeRegistry contextRegistry = javaPlugin
        final TemplateContextType javaContextType = contextRegistry
        final Iterator<TemplateVariableResolver> resolvers = javaContextType
        MavenVersionResolver mavenVersionResolver = null;
        while (resolvers.hasNext()) {
          final TemplateVariableResolver resolver = resolvers.next();
          if (resolver instanceof MavenVersionResolver) {
            mavenVersionResolver = (MavenVersionResolver) resolver;
        return mavenVersionResolver;
       * First find the maven-version-resolver from the registered resolvers.
      private void registerResolvers() {
        final JavaPlugin javaPlugin = JavaPlugin.getDefault();
        if (javaPlugin == null) {
          throw new IllegalStateException(String.format(
              "Expected plugin '%s' is not available", JAVA_PLUGIN_ID));
        final MavenVersionResolver mavenVersionResolver = getMavenVersionResolver(javaPlugin);
        if (mavenVersionResolver != null) {
          addMavenVersionResolver(javaPlugin, mavenVersionResolver);

    Now its possible to use „pom_version“ in code-templates too:


    Now the final test  …  create a „normal“ java-project, create a new class. The javadoc will not contain a version (the project doesn’t have a maven-nature):


    If the project is a „real“ maven project the version will be available:


    If anyone need the plugin … leave a comment.

  • Andreas Höhmann 22:33 am Sunday, 16. November 2008 Permalink |
    Tags: debug, , , , sourcecode   

    Hacking maven-eclipse-plugin with eclipse-ide 

    This article show you how you can fix bugs for maven-plugins (eclipse setup for hacking the code, debugging etc.) with a concrete project: maven-eclipse-plugin. Lets start …

    At the moment one of my private todos is to fix a classpath-bug for mavens eclipse-plugin.

    First of all: this maven-plugin is great! If you have a maven-project and you want edit the source inside the eclipse-ide all you have to do is „mvn eclipse:eclipse“ in the base-dir of the project. The plugin will generate all eclipse-files for you, e.g. „.project“, „.classpath“, the „.settings“-directory etc. And there is much more … e.g. pde-development with maven. Have a look at the plugin-homepage.

    Ok. What’s the problem? I have a pom with more than one resources:


    The resources directory contains a lot of resources. For all property-files i want activate filtering, meens maven should replace placeholders in the files before the result is copied into the target-directory.

    If i now start „mvn eclipse:eclipse“ the plugin doesnt handle the different directories/includes/excludes correct. The result is a .classpath like this (i removed uninteresting entries).

     <classpathentry kind="src"

    Wrong buildpath

    The second resource (with disabled filtering and the exlude for *.properties) was not included in the classpath. If the resource-directory contains other „important“ files (e.g. spring-xmls for test or images or whatever) then the eclipse-environment is not complete.

    The problem is now clear 🙂 So lets fix the .classpath-generation-code. The plugin-code is available, maven can be started in debug-mode with „mvnDebug eclipse:eclipse“ but then my first debug-session was not sucessful. I’m searching for the correct place to fix the code but where should i place a breakpoint? Mhhh … no sources for the maven-code … first of all i need a complete debugable maven-environment. To make a long story short … i got it 😀 Here is the todo-list:

    1. Use Eclipse and checkout maven-eclipse-plugin (Its a good idea to use the trunk – http://svn.apache.org/repos/asf/maven/plugins/trunk/maven-eclipse-plugin).
    2. Now install the plugin with „mvn install“. This will install the newest version in the local repository.
    3. Then use „mvn eclipse:eclipse“ to generate all eclipse-files for the maven-eclipse-plugin.
    4. Refresh the maven-eclipse-plugin project in the eclipse-ide. Now you are ready to debug a „mvn eclipse:eclipse“ session. But hold a second! Most of the maven code will not be available in the ide, the debugging is not fun. To handle this you must checkout the maven-code.
    5. Use Eclipse and checkout the maven-sources (http://svn.apache.org/repos/asf/maven/components). There are many branches and tags available. Look into the pom.xml of the maven-eclipse-plugin to find out the right version. The plugin-api dependency is perfect for this:


      So we have to checkout the 2.0.8 branch (http://svn.apache.org/repos/asf/maven/components/tags/maven-2.0.8).

    6. Now build maven with „mvn install“ and prepare the usage in eclipse with „mvn eclipse:eclipse“.
    7. Create a working-set „maven 2.0.8“ and import all subprojects from the maven-project. With eclipse this is very ease. Use the „Existing Projects into Workspace“ import. Select the base-directory of the maven-project and import all subprojects in the workspace. Important: you must delete the „.project“ file in the maven-project-directory to run the bulk-import successfully!
    8. Now your workspace should look like this:
      Ready to hack maven-eclipse-plugin
    9. Now the last step – call „mvn eclipse:eclipse“ for the maven-eclipse-pluigin project (second time). Then you will have a eclipse-project with project-dependencies to the maven-projects (e.g. maven-plugin-api).

    The „eclipse-test“ project contains the above pom.xml with the two resources.

    To debug the eclipse-plugin i have to

    1. Start „mvnDebug eclipse:eclipse“ in the eclipse-test project
    2. Start a „Remote Java Application“ debug-session (localhost:8000) with additional sources of „maven-eclipse-plugin-trunk“ project


Neuen Beitrag erstellen
nächster Beitrag/nächster Kommentar
vorheriger Beitrag/vorheriger Kommentar
zeige/verstecke Kommentare
Zum Anfang gehen
zum Login
Zeige/Verberge Hilfe
Shift + ESC