Chapter 1. Setting up an annotations project
Prev |  | Next

## Chapter 1. Setting up an annotations project

## 1.1. Requirements

- Download and unpack the Hibernate Annotations distribution from the Hibernate website.

- This preview release requires Hibernate 3.2.0.CR2 and above. Do not use this release of Hibernate Annotations with an older version of Hibernate 3.x!

- This release is known to work on Hibernate core 3.2.0.CR2

- Make sure you have JDK 5.0 installed. You can of course continue using XDoclet and get some of the benefits of annotation-based metadata with older JDK versions. Note that this document only describes JDK 5.0 annotations and you have to refer to the XDoclet documentation for more information.

## 1.2. Configuration

First, set up your classpath (after you have created a new project in your favorite IDE):

- Copy all Hibernate3 core and required 3rd party library files (see lib/README.txt in Hibernate).

- Copy `hibernate-annotations.jar` and `lib/ejb3-persistence.jar` from the Hibernate Annotations distribution to your classpath as well.

- To use the Chapter 5, Hibernate Lucene Integration, add the lucene jar file.

We also recommend a small wrapper class to startup Hibernate in a static initializer block, known as `HibernateUtil`. You might have seen this class in various forms in other areas of the Hibernate documentation. For Annotation support you have to enhance this helper class as follows:

    package hello;

    import org.hibernate.*;
    import org.hibernate.cfg.*;
    import test.*;
    import test.animals.Dog;

    public class HibernateUtil {

    private static final SessionFactory sessionFactory;

        static {
            try {

                sessionFactory = new AnnotationConfiguration().buildSessionFactory();
            } catch (Throwable ex) {
                // Log exception!
                throw new ExceptionInInitializerError(ex);
            }
        }

        public static Session getSession()
                throws HibernateException {
            return sessionFactory.openSession();
        }
    }

Interesting here is the use of `AnnotationConfiguration`. The packages and annotated classes are declared in your regular XML configuration file (usually `hibernate.cfg.xml`). Here is the equivalent of the above declaration:

    <!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

            <hibernate-configuration>
              <session-factory>
                <mapping package="test.animals"/>
                <mapping class="test.Flight"/>
                <mapping class="test.Sky"/>
                <mapping class="test.Person"/>
                <mapping class="test.animals.Dog"/>
                <mapping resource="test/animals/orm.xml"/>
              </session-factory>
            </hibernate-configuration>

Note that you can mix the hbm.xml use and the new annotation one. The resource element can be either an hbm file or an EJB3 XML deployment descriptor. The distinction is transparent for your configuration process.

Alternatively, you can define the annotated classes and packages using the programmatic API

                sessionFactory = new AnnotationConfiguration()
                        .addPackage("test.animals") //the fully qualified package name
                        .addAnnotatedClass(Flight.class)
                        .addAnnotatedClass(Sky.class)
                        .addAnnotatedClass(Person.class)
                        .addAnnotatedClass(Dog.class)
                        .addResource("test/animals/orm.xml")
                        .buildSessionFactory();

You can also use the Hibernate Entity Manager which has it's own configuration mechanism. Please refer to this project documentation for more details.

There is no other difference in the way you use Hibernate APIs with annotations, except for this startup routine change or in the configuration file. You can use your favorite configuration method for other properties ( `hibernate.properties`, `hibernate.cfg.xml`, programmatic APIs, etc). You can even mix annotated persistent classes and classic `hbm.cfg.xml` declarations with the same `SessionFactory`. You can however not declare a class several times (whether annotated or through hbm.xml). You cannot mix configuration strategies (hbm vs annotations) in a mapped entity hierarchy either.

To ease the migration process from hbm files to annotations, the configuration mechanism detects the mapping duplication between annotations and hbm files. HBM files are then prioritized over annotated metadata on a class to class basis. You can change the priority using `hibernate.mapping.precedence` property. The default is `hbm, class`, changing it to `class, hbm` will prioritize the annotated classes over hbm files when a conflict occurs.

Prev | Up | Next
Preface | Home | Chapter 2. Entity Beans