Hibernate Developer Guide

hibernate.connection.driver_class = org.postgresql.Driver
hibernate.connection.url = jdbc:postgresql://localhost/mydatabase
hibernate.connection.username = myuser
hibernate.connection.password = secret
hibernate.c3p0.min_size=5
hibernate.c3p0.max_size=20
hibernate.c3p0.timeout=1800
hibernate.c3p0.max_statements=50
hibernate.dialect = org.hibernate.dialect.PostgreSQLDialect

<?xml version='1.0' encoding='utf-8'?>

<!DOCTYPE hibernate-configuration PUBLIC

"-//Hibernate/Hibernate Configuration DTD 3.0//EN"

"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">



<hibernate-configuration>

  <session-factory>

    <!-- Database connection settings -->

    <property name="connection.driver_class">org.hsqldb.jdbcDriver</property>

    <property name="connection.url">jdbc:hsqldb:hsql://localhost</property>

    <property name="connection.username">sa</property>

    <property name="connection.password"></property>



    <!-- JDBC connection pool (use the built-in) -->

    <property name="connection.pool_size">1</property>



    <!-- SQL dialect -->

    <property name="dialect">org.hibernate.dialect.HSQLDialect</property>



    <!-- Enable Hibernate's automatic session context management -->

    <property name="current_session_context_class">thread</property>



    <!-- Disable the second-level cache  -->

    <property name="cache.provider_class">org.hibernate.cache.internal.NoCacheProvider</property>



    <!-- Echo all executed SQL to stdout -->

    <property name="show_sql">true</property>



    <!-- Drop and re-create the database schema on startup -->

    <property name="hbm2ddl.auto">update</property>

    <mapping resource="org/hibernate/tutorial/domain/Event.hbm.xml"/>

  </session-factory>

</hibernate-configuration>

                Session session = sessions.openSession();

            

          java -cp hibernate_classpaths org.hibernate.tool.hbm2ddl.SchemaExport options mapping_files 
        

Configuration cfg = ....;

new SchemaExport(cfg).create(false, true);

foo.getId().equals( bar.getId() )

foo==bar

// BMT idiom

Session sess = factory.openSession();

Transaction tx = null;

try {

    tx = sess.beginTransaction();


    // do some work

    ...


        tx.commit();

}


catch (RuntimeException e) {

    if (tx != null) tx.rollback();

    throw e; // or display error message

}


finally {

    sess.close();

}

// BMT idiom with getCurrentSession()

try {

    UserTransaction tx = (UserTransaction)new InitialContext()

                            .lookup("java:comp/UserTransaction");


    tx.begin();


    // Do some work on Session bound to transaction

    factory.getCurrentSession().load(...);

    factory.getCurrentSession().persist(...);


    tx.commit();

}


catch (RuntimeException e) {

    tx.rollback();

    throw e; // or display error message

}

// CMT idiom

 Session sess = factory.getCurrentSession();

 // do some work

 ...

    session.update( someDetachedCat );
                

    session.saveOrUpdate( someDetachedCat );
                

Object detached = ...;
Object managed = entityManager.find( detached.getClass(), detached.getId() );
managed.setXyz( detached.getXyz() );
...
return managed;
                

Cat theManagedInstance = session.merge( someDetachedCat );
                

Cat theManagedInstance = entityManager.merge( someDetachedCat );
                

          ( UPDATE | DELETE ) FROM? EntityName (WHERE where_conditions)?
        

The ? suffix indications an optional parameter. The FROM and WHERE clauses are each optional.

Session session = sessionFactory.openSession();

Transaction tx = session.beginTransaction();


String hqlUpdate = "update Customer c set c.name = :newName where c.name = :oldName";

// or String hqlUpdate = "update Customer set name = :newName where name = :oldName";

int updatedEntities = s.createQuery( hqlUpdate )

        .setString( "newName", newName )

        .setString( "oldName", oldName )

        .executeUpdate();

tx.commit();

session.close();

Session session = sessionFactory.openSession();

Transaction tx = session.beginTransaction();

String hqlVersionedUpdate = "update versioned Customer set name = :newName where name = :oldName";

int updatedEntities = s.createQuery( hqlUpdate )

        .setString( "newName", newName )

        .setString( "oldName", oldName )

        .executeUpdate();

tx.commit();

session.close();

Session session = sessionFactory.openSession();

Transaction tx = session.beginTransaction();


String hqlDelete = "delete Customer c where c.name = :oldName";

// or String hqlDelete = "delete Customer where name = :oldName";

int deletedEntities = s.createQuery( hqlDelete )

        .setString( "oldName", oldName )

        .executeUpdate();

tx.commit();

session.close();

          INSERT INTO EntityName properties_list select_statement
        

Session session = sessionFactory.openSession();

Transaction tx = session.beginTransaction();


String hqlInsert = "insert into DelinquentAccount (id, name) select c.id, c.name from Customer c where ...";

int createdEntities = s.createQuery( hqlInsert )

        .executeUpdate();

tx.commit();

session.close();

@Entity

public class Flight implements Serializable {

...

    @Version

    @Column(name="OPTLOCK")

    public Integer getVersion() { ... }

}   

Here, the version property is mapped to the OPTLOCK column, and the entity manager uses it to detect conflicting updates, and prevent the loss of updates that would be overwritten by a last-commit-wins strategy.

<version

        column="version_column"

        name="propertyName"

        type="typename"

        access="field|property|ClassName"

        unsaved-value="null|negative|undefined"

        generated="never|always"

        insert="true|false"

        node="element-name|@attribute-name|element/@attribute|."

/>

@Entity

public class Flight implements Serializable {

...

    @Version

    public Date getLastUpdate() { ... }

} 

<timestamp

        column="timestamp_column"

        name="propertyName"

        access="field|property|ClassName"

        unsaved-value="null|undefined"

        source="vm|db"

        generated="never|always"

        node="element-name|@attribute-name|element/@attribute|."

/>

List blogs = sess.createQuery("from Blog blog where blog.blogger = :blogger")

        .setEntity("blogger", blogger)

        .setMaxResults(15)

        .setCacheable(true)

        .setCacheRegion("frontpages")

        .list();

@Entity 

@Cacheable

@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)

public class Forest { ... }

You can cache the content of a collection or the identifiers, if the collection contains other entities. Use the @Cache annotation on the Collection property.

@Cache can take several attributes.

ScrollableResult cats = sess.createQuery("from Cat as cat").scroll(); //a huge result set

while ( cats.next() ) {

    Cat cat = (Cat) cats.get(0);

    doSomethingWithACat(cat);

    sess.evict(cat);

}

You can evict the cached state of an instance, entire class, collection instance or entire collection role, using methods of SessionFactory.

sessionFactory.getCache().containsEntity(Cat.class, catId); // is this particular Cat currently in the cache


sessionFactory.getCache().evictEntity(Cat.class, catId); // evict a particular Cat


sessionFactory.getCache().evictEntityRegion(Cat.class);  // evict all Cats


sessionFactory.getCache().evictEntityRegions();  // evict all entity data


sessionFactory.getCache().containsCollection("Cat.kittens", catId); // is this particular collection currently in the cache


sessionFactory.getCache().evictCollection("Cat.kittens", catId); // evict a particular collection of kittens


sessionFactory.getCache().evictCollectionRegion("Cat.kittens"); // evict all kitten collections


sessionFactory.getCache().evictCollectionRegions(); // evict all collection data

public class MyIntegrator implements org.hibernate.integrator.spi.Integrator {

	public void integrate(
			Configuration configuration,
			SessionFactoryImplementor sessionFactory,
			SessionFactoryServiceRegistry serviceRegistry) {
        // As you might expect, an EventListenerRegistry is the thing with which event listeners are registered  It is a
        // service so we look it up using the service registry
        final EventListenerRegistry eventListenerRegistry = serviceRegistry.getService( EventListenerRegistry.class );

        // If you wish to have custom determination and handling of "duplicate" listeners, you would have to add an
        // implementation of the org.hibernate.event.service.spi.DuplicationStrategy contract like this
        eventListenerRegistry.addDuplicationStrategy( myDuplicationStrategy );

        // EventListenerRegistry defines 3 ways to register listeners:
        //     1) This form overrides any existing registrations with
        eventListenerRegistry.setListeners( EventType.AUTO_FLUSH, myCompleteSetOfListeners );
        //     2) This form adds the specified listener(s) to the beginning of the listener chain
        eventListenerRegistry.prependListeners( EventType.AUTO_FLUSH, myListenersToBeCalledFirst );
        //     3) This form adds the specified listener(s) to the end of the listener chain
        eventListenerRegistry.prependListeners( EventType.AUTO_FLUSH, myListenersToBeCalledLast );
	}
}

                    CustomEntityTrackingRevisionListener.java

public class CustomEntityTrackingRevisionListener
             implements EntityTrackingRevisionListener {
    @Override
    public void entityChanged(Class entityClass, String entityName,
                              Serializable entityId, RevisionType revisionType,
                              Object revisionEntity) {
        String type = entityClass.getName();
        ((CustomTrackingRevisionEntity)revisionEntity).addModifiedEntityType(type);
    }

    @Override
    public void newRevision(Object revisionEntity) {
    }
}

                    CustomTrackingRevisionEntity.java

@Entity
@RevisionEntity(CustomEntityTrackingRevisionListener.class)
public class CustomTrackingRevisionEntity {
    @Id
    @GeneratedValue
    @RevisionNumber
    private int customId;

    @RevisionTimestamp
    private long customTimestamp;

    @OneToMany(mappedBy="revision", cascade={CascadeType.PERSIST, CascadeType.REMOVE})
    private Set<ModifiedEntityTypeEntity> modifiedEntityTypes =
                                              new HashSet<ModifiedEntityTypeEntity>();
    
    public void addModifiedEntityType(String entityClassName) {
        modifiedEntityTypes.add(new ModifiedEntityTypeEntity(this, entityClassName));
    }
    
    ...
}

                    ModifiedEntityTypeEntity.java

@Entity
public class ModifiedEntityTypeEntity {
    @Id
    @GeneratedValue
    private Integer id;

    @ManyToOne
    private CustomTrackingRevisionEntity revision;
    
    private String entityClassName;
    
    ...
}

CustomTrackingRevisionEntity revEntity =
    getAuditReader().findRevision(CustomTrackingRevisionEntity.class, revisionNumber);
Set<ModifiedEntityTypeEntity> modifiedEntityTypes = revEntity.getModifiedEntityTypes()