Java – Generating sources by running a project’s java class in Maven

code generationjavamaven-2

I'm converting a largish Ant build to Maven. As part of the Ant build, we have several steps which created Java classes by invoking one of the project's classes, simplified as:

javac SomeGenerator.java
java  SomeGenerator  generated # generate classes in generated/
javac generated/*.java

I've split each generator in its own Maven module, but I have the problem of not being able to run the generator since it's not yet compiled in the generate-sources phase.

I've tried something similar to

        <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>exec-maven-plugin</artifactId>
            <version>1.1.1</version>
            <executions>
                <execution>
                    <id>generate-model</id>
                    <goals>
                        <goal>java</goal>
                    </goals>
                    <phase>generate-sources</phase>

                    <configuration>
                        <mainClass>DTOGenerator</mainClass>
                        <arguments>
                            <argument>${model.generated.dir}</argument>
                        </arguments>
                    </configuration>
                </execution>
            </executions>
        </plugin>

Which sadly does not work, for the reasons outlined above. Splitting the code generators into two projects each, one for compiling the generator and another for generating the DTOs seems overkill.

What alternatives are there?

Using Maven 2.2.1.

Best Answer

You can execute the maven-compile-plugin in the generate-sources phase. Just add another execution before the existing execution and configure it so that it just picks up the sources for the generator.

Or split the project in two: build the generator with a separate POM and include the generator library as a dependency to the POM that's generating the sources.

Personally I would split the project. Keeps the build files cleaner and easier to maintain.

Related Solutions

Java inner class and static nested class

From the Java Tutorial:

Nested classes are divided into two categories: static and non-static. Nested classes that are declared static are simply called static nested classes. Non-static nested classes are called inner classes.

Static nested classes are accessed using the enclosing class name:

OuterClass.StaticNestedClass

For example, to create an object for the static nested class, use this syntax:

OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();

Objects that are instances of an inner class exist within an instance of the outer class. Consider the following classes:

class OuterClass {
    ...
    class InnerClass {
        ...
    }
}

An instance of InnerClass can exist only within an instance of OuterClass and has direct access to the methods and fields of its enclosing instance.

To instantiate an inner class, you must first instantiate the outer class. Then, create the inner object within the outer object with this syntax:

OuterClass outerObject = new OuterClass()
OuterClass.InnerClass innerObject = outerObject.new InnerClass();

see: Java Tutorial - Nested Classes

For completeness note that there is also such a thing as an inner class without an enclosing instance:

class A {
  int t() { return 1; }
  static A a =  new A() { int t() { return 2; } };
}

Here, new A() { ... } is an inner class defined in a static context and does not have an enclosing instance.

Maven – Command to run only one specific test plugin defined in Maven

Specify the fully-qualified goal in the form of:

mvn groupID:artifactID:version:goal

For example:

mvn sample.plugin:maven-hello-plugin:1.0-SNAPSHOT:sayhi

EDIT: I'm modifying my answer to cover the update of the initial question and a comment from the OP.

I won't cover all the details but, it the particular case of the antrun plugin, you could just run:

mvn antrun:run

But now that you've updated the question, I understand that things are a bit more complicated than what I thought initially and I don't think that this will actually work. I mean, invoking mvn antrun:run won't fail but it won't pick up the configuration of the execution bound to the test phase.

The only (ugly) solution I can think of would be to add another maven-antrun-plugin configuration in a specific profile, something like this:

  <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-antrun-plugin</artifactId>
    <version>1.3</version>
    <dependencies>
      <dependency>
        <groupId>com.googlecode.jslint4java</groupId>
        <artifactId>jslint4java-ant</artifactId>
        <version>1.3.3</version>
      </dependency>
    </dependencies>
    <configuration>
      <tasks>
        <ant antfile="${basedir}/jslint.xml">
          <property name="root" location="${basedir}" />
          <target name="jslint" />
        </ant>
      </tasks>
    </configuration>
  </plugin>

And to use this profile when calling antrun:run:

mvn antrun:run -Pmyprofile-for-antrun

Best Answer

Related Solutions

Java inner class and static nested class

Maven – Command to run only one specific test plugin defined in Maven

Related Topic