The jar file for the annotation processor can be found in the JBoss Maven repository using Example 2.1, “Maven dependency”.
Example 2.1. Maven dependency
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-jpamodelgen</artifactId>
<version>1.0.0</version>
</dependency>
Alternatively, a full distribution package can be downloaded from SourceForge.
In most cases the annotation processor will automatically run
provided the processor jar is added to the classpath and a JDK 6 is used.
This happens due to Java's
Service Provider contract and the fact the the Hibernate Static
Metamodel Generator jar files contains the file
javax.annotation.processing.Processor in the
META-INF/services directory. The fully qualified name
of the processor itself is:
org.hibernate.jpamodelgen.JPAMetaModelEntityProcessor.
Note
The use of a Java 6 compiler is a prerequisite.
As mentioned before, the annotation processor will run automatically each time the Java compiler is called, provided the jar file is on the classpath. Sometimes, however, it is useful to control the annotation processing in more detail, for example if you exclusively want to run the processor without compiling any other source files. Example 2.2, “Javac Task configuration” shows how Ant's Javac Task can be configured to just run annotation processing.
Example 2.2. Javac Task configuration
<javac srcdir="${src.dir}"
destdir="${target.dir}"
failonerror="false"
fork="true"
classpath="${classpath}">
<compilerarg value="-proc:only"/>
</javac>
The option -proc:only instructs the compiler to just run the annotation processing. You can also completely disable processing by specifying -proc:none.
Tip
Run 'javac -help' to see which other
annotation processor relevant options can be specified.
There are several ways of running the annotation processor as part of a Maven build. Again, it will automatically run if you are using a JDK 6 compiler and the annotation processor jar is on the classpath. In case you have more than one annotation processors on your classpath you can explicitly pass the processor option to the compiler plugin:
Example 2.3. Maven compiler plugin configuration - direct execution
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.6</source>
<target>1.6</target>
<compilerArguments>
<processor>org.hibernate.jpamodelgen.JPAMetaModelEntityProcessor</processor>
</compilerArguments>
</configuration>
</plugin>
The maven-compiler-plugin approach has the disadvantage that the maven compiler plugin does currently not allow to specify multiple compiler arguments (MCOMPILER-62) and that messages from the Messenger API are suppressed (MCOMPILER-66). A better approach is to disable annotation processing for the compiler plugin as seen in Example 2.4, “Maven compiler plugin configuration - indirect execution”.
Example 2.4. Maven compiler plugin configuration - indirect execution
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.6</source>
<target>1.6</target>
<compilerArgument>-proc:none</compilerArgument>
</configuration>
</plugin>
Once disabled, the maven-processor-plugin for annotation processing can be used. The configuration can be seen in Example 2.5, “Configuration with maven-processor-plugin”.
Example 2.5. Configuration with maven-processor-plugin
<plugin>
<groupId>org.bsc.maven</groupId>
<artifactId>maven-processor-plugin</artifactId>
<version>2.0.5</version>
<executions>
<execution>
<id>process</id>
<goals>
<goal>process</goal>
</goals>
<phase>generate-sources</phase>
<configuration>
<processors>
<processor>org.hibernate.jpamodelgen.JPAMetaModelEntityProcessor</processor>
</processors>
</configuration>
</execution>
</executions>
<dependencies>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-jpamodelgen</artifactId>
<version>1.3.0.Final</version>
</dependency>
</dependencies>
</plugin>
Of course you also want to have annotation processing available in your favorite IDE. The following paragraphs and screenshots show you how to enable the Hibernate Static Metamodel Generator within your IDE.
Intellij Idea contains from version 9.x onwards a specific configuration section for annotation processing under the project settings window. The screenshots show you how to configure the Hibernate Static Metamodel Generator.
In the annotation processor configuration, enable annotation
processing and select obtain from project classpath. Add the
annotation processor name
org.hibernate.jpamodelgen.JPAMetaModelEntityProcessor
(and optionally the annotation processor options). Select the
module(s) containing your entities. If you have configured Maven as
recommended, it is best to select the same output directory for the
generated classes. At the time of writing, it is
target/generated-sources/apt. That way, the
generated classes will be available in IntelliJ Idea.
In Eclipse, from the Galileo release onwards, exists an additional configuration section under Java Compiler. There you can configure all kinds of aspects of annotation processing. Just check the "Enable annotation processing" option, configure the directory for the generated sources and finally add the Hibernate Static Metamodel Generator and JPA 2 jar files to the factory path.
The Hibernate Static Metamodel Generator accepts a series of
custom options which can be passed to the processor in the format
-A[property]=[value]. The supported properties
are:
Table 2.1. Annotation processor options (passed via -A[property]=[value])
| Option name | Option value and usage |
| debug | If set to true additional trace
information will be outputted by the processor |
| persistenceXml | Per default the processor looks in
/META-INF for persistence.xml. Specifying
this option a persitence.xml file from a
different location can be specified (has to be on the
classpath) |
| ormXml | Allows to specify additional entity mapping files. The
specified value for this option is a comma separated string of
mapping file names. Even when this option is specified
/META-INF/orm.xml is implicit. |
| lazyXmlParsing | Possible values are true or
false. If set to true
the annotation processor tries to determine whether any of the
xml files has changed between invocations and if unchanged
skips the xml parsing. This feature is experimental and
contains the risk of wron results in some cases of mixed mode
configurations. To determine wether a file has been modified a
temporary file
Hibernate-Static-Metamodel-Generator.tmp
is used. This file gets created in the
java.io.tmpdir directory. |
| fullyAnnotationConfigured | If set to true the processor will
ignore orm.xml and
persistence.xml. |
| addGeneratedAnnotation | If set to true the processor will
add the @Generated to the generated
Java source file. Adding this annotation using JDK 5will cause
a compilation error. In this case set the flag to
false. The default for this option is
true |
| addGenerationDate | If set to true the generation date
of the metamodel class will be inserted in the date parameter
of the @Generated annotation. The
default is false. This parameter is
ignored if addGeneratedAnnotation is set
to false. |
| addSuppressWarningsAnnotation | If set to true the processor will
add @SuppressWarnings("all") to the
generated Java source file. Per default this annotation is not
generated. See also METAGEN-50. |