Spring, JPA, Hibernate Best Practices and Tips

Using Java Annotation with Spring AOP

2011-11-16T19:06:00.000-08:00

Here is a short refresher for your spring aop vocabulary.

"Spring AOP uses Aspect to Advice about possible actions with respect to Target object at the Join Point matching Point Cut expression". Aspects are linked to Proxy by run time weaving. Unlike AspectJ, a join point is always a method in Spring.
-----------------------
You can write spring aop advice, which will work based on your custom java annotations. Here is a simple example. Please read about spring aop limitations at the end.

Define annotation name MethodAnnotation:

 import java.lang.annotation.ElementType;  
 import java.lang.annotation.Retention;  
 import java.lang.annotation.RetentionPolicy;  
 import java.lang.annotation.Target;  
 @Retention(RetentionPolicy.RUNTIME)  
 @Target(ElementType.METHOD)  
 public @interface MethodAnnotation {  
      String comment();  
 }

Define Aspect for the annotation. In this example we are using @around advice

 import org.aspectj.lang.ProceedingJoinPoint;  
 import org.aspectj.lang.annotation.Around;  
 import org.aspectj.lang.annotation.Aspect;  
 import org.aspectj.lang.annotation.Pointcut;  
 @Component   
 @Aspect  
 public class AspectForMethodAnnotation{  
      @Around("@annotation(methodAnnotation)")  
      public Object executeAroundMethod(ProceedingJoinPoint pjp, MethodAnnotation methodAnnotation) throws Throwable {  
           // Do what you want with the actionperformed  
           String commentFromAnnotation = methodAnnotation.comment();  
           // You can use join point arguments in any way you like  
           for ( Object object : pjp.getArgs()) {  
                System.out.println(object);  
           }  
           Object ret = pjp.proceed();  
         //doing something after method execution  
         return ret;  
      }  
 }

There are few points to note here. First of all, java annotation will provide method arguments through ProceedingJoinPoint.getArgs() but not the exact variable name (unless you compile the classes with debug option). So if you have any logic based on argument name, you might want to consider passing index of that argument within annotation. To make auto proxy discover your aspect, you can declare it as @component or @configurable.

That's all. You can define auto proxy in applicationcontext.xml as below

 <?xml version="1.0" encoding="UTF-8"?>  
 <beans xmlns="http://www.springframework.org/schema/beans"  
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
     xmlns:aop="http://www.springframework.org/schema/aop"  
     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd  
               http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">  
 .....  
  <aop:aspectj-autoproxy/>  
 <bean id="methodAnnotationAspect" class="com.mdc.spring.annotationexample.AspectForMethofAnnotation" />  
 ......  
 </beans>

To inject our annotation inside a bean available within spring context, simply add annotation

 @MethodAnnotation(comment="World's best method")  
 public void bestMethod(String arg1, UrObject arg2) {  
 }

There are some caveats to this approach. If you add multiple annotations within same bean and one method calls another, then spring will not fire aop advice for subsequent calls. This is because sping aop is based on run time proxy. When a proxy invokes method on its instance, consecutive method invocation happens in actual instance, without knowledge of spring environment.

If you could have annotation class in multiple packages then place full package of annotation interface inside @annotation(...).

More info and examples of point cuts are in spring doc: http://static.springsource.org/spring/docs/3.0.x/spring-framework-reference/html/aop.html#aop-introduction-spring-defn

47 degrees has extended this concept to implement a dynamic pub-sub functionality. http://47deg.com/lab/simple-event-with-java-spring-aop-annotations/

Preprocess bean property before assigning to bean in Spring applicationcontext

2011-10-01T09:48:00.000-07:00

There could be a need to evaluate, validate or pre process a value before assigning as a property in a spring bean. One of the practical use of this technique is to decrypt password before assigning in data source. Spring 3 provides an elegant way to do this without extending any spring class. This is made possible by Expression Language supported by Spring 3 onwards.

 <bean id="datasourcePreprocessor" class="com.me.company.Preprocessor">  
  <property name="inputPassword" value="HighlyEncryptedPassword"/>  
  <property name="user" value="userName"/>   
 <!-- other properties -->  
  </bean>   
 <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">  
  <property name="driverClassName" value="oracle.jdbc.driver.OracleDriver"/>   
 <property name="url" value="jdbc:oracle:thin:@my.db.server:1521:SID"/>   
 <property name="username"value="#{ datasourcePreprocessor.user }"/>   
 <property name="password" value="#{ datasourcePreprocessor.outputPassword }"/>  
  </bean>

You can implement the decrypt method in setInputPassword or getOutputPassword() method of com.me.company.Preprocessor.
Anotherside tip of this facility is that you can refer to any system property by simply putting something like value="#{ systemProperties['user.name'] }". 'systemProperties' is predefined in spring 3.

To read more about this technique read <a href="http://static.springsource.org/spring/docs/3.0.5.RELEASE/reference/expressions.html">http://static.springsource.org/spring/docs/3.0.5.RELEASE/reference/expressions.html</a>

How to avoid duplicate entities from hibernate outer join

2011-09-26T18:41:00.000-07:00

Ever wondered why we get duplicate entities as a result of outer join from Hibernate. We would expect this as hibernate query results should be smart enough to remove duplicates based on primary key (id) field. It does not happen by default. If you run into this issue, you can use DistinctRootEntityResultTransformer. To reduce your result set into distinct entities:

 String hql = "from p from Parent p left outer join p.children where c.name=:name";  
 Query q = session.createQuery(hql);  
 q.setString("name", "John");   
 List<parent> parents = (Parent)DistinctRootEntityResultTransformer.transformList(q.list());

If you are using @OneToMany(fetch=FetchType.EAGER) then "Set" should be used to avoid duplicate entities.

How to auto scan jpa entities? (using spring configuration)

2011-01-26T20:55:00.000-08:00

If you configure spring with annotation-config and datasource, spring provides easy way to auto scan entity classes within a package. You can find details of this configuration at http://weblogs.java.net/blog/2007/11/27/annotation-based-configuration-spring. You might think it should be pretty simple to let spring scan all JPA persistence entitites even when you define EntityManagerFactory instead of DataSource. Well, spring by default scans @Entity classes from same path as persistence.xml. There is no easy way to specify a package name and let spring scan within that package instead of giving relative or absolutely path. Here I tell you steps to achieve the same. It really helps to specify the package scan like you can do with datasource configuration. Step1: Define a custom bean say myMagicScanner like this
Step 2: While defining EntityManagerFactory use above bean as PersistenceUnitPostProcessor
Define a custom bean say myMagicScanner like this Step 3:
Finally here is the java class for scanner utility used in MyMagicScannerBean. Notice that I am implementing org.springframework.orm.jpa.persistenceunit.PersistenceUnitPostProcessor package com.springjpa.util;

import java.io.IOException;import java.util.HashSet;import java.util.Set;import javax.persistence.Embeddable;import javax.persistence.Entity;import javax.persistence.MappedSuperclass;import org.hibernate.MappingException;import org.springframework.beans.BeansException;import org.springframework.context.ApplicationContext;import org.springframework.context.ApplicationContextAware;import org.springframework.core.io.Resource;import org.springframework.core.io.support.PathMatchingResourcePatternResolver;import org.springframework.core.io.support.ResourcePatternResolver;import org.springframework.core.type.classreading.CachingMetadataReaderFactory;import org.springframework.core.type.classreading.MetadataReader;import org.springframework.core.type.classreading.MetadataReaderFactory;import org.springframework.core.type.filter.AnnotationTypeFilter;import org.springframework.core.type.filter.TypeFilter;import org.springframework.orm.jpa.persistenceunit.MutablePersistenceUnitInfo;import org.springframework.orm.jpa.persistenceunit.PersistenceUnitPostProcessor;import org.springframework.util.ClassUtils;public class MyMagicScanner implements ApplicationContextAware,  PersistenceUnitPostProcessor { private static final String RESOURCE_PATTERN = "**/*.class"; private ApplicationContext applicationContext; private String[] packagesToScan; private ResourcePatternResolver resourcePatternResolver = new PathMatchingResourcePatternResolver(); private TypeFilter[] entityTypeFilters = new TypeFilter[] {   new AnnotationTypeFilter(Entity.class, false),   new AnnotationTypeFilter(Embeddable.class, false),   new AnnotationTypeFilter(MappedSuperclass.class, false) }; @Override public void setApplicationContext(ApplicationContext applicationContext)   throws BeansException {  this.applicationContext = applicationContext; } @Override public void postProcessPersistenceUnitInfo(MutablePersistenceUnitInfo pui) {  String[] entities = scanPackages();  for (String entity : entities) {   pui.addManagedClassName(entity);  } } /**  *   * Set whether to use Spring-based scanning for entity classes in the  * classpath instead of listing annotated classes explicitly.  *   * <p>  *   * Default is none. Specify packages to search for autodetection of your  * entity classes in the classpath. This is analogous to  *   * Spring's component-scan feature  * (org.springframework.context.annotation.ClassPathBeanDefinitionScanner}).  */ public void setPackagesToScan(String[] packagesToScan) {  this.packagesToScan = packagesToScan; } /**  *   * Perform Spring-based scanning for entity classes.  *   * @see #setPackagesToScan  */ protected String[] scanPackages() {  Set<String> entities = new HashSet<String>();  if (this.packagesToScan != null) {   try {    for (String pkg : this.packagesToScan) {     String pattern = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX       + ClassUtils.convertClassNameToResourcePath(pkg)       + RESOURCE_PATTERN;     Resource[] resources = this.resourcePatternResolver       .getResources(pattern);     MetadataReaderFactory readerFactory = new CachingMetadataReaderFactory(       this.resourcePatternResolver);     for (Resource resource : resources) {      if (resource.isReadable()) {       MetadataReader reader = readerFactory         .getMetadataReader(resource);       String className = reader.getClassMetadata()         .getClassName();       if (matchesFilter(reader, readerFactory)) {        entities.add(className);       }      }     }    }   } catch (IOException ex) {    throw new MappingException(      "Failed to scan classpath for unlisted classes", ex);   }  }  return entities.toArray(new String[entities.size()]); } /**  *   * Check whether any of the configured entity type filters matches the  * current class descriptor contained in the metadata  *   * reader.  */ private boolean matchesFilter(MetadataReader reader,   MetadataReaderFactory readerFactory) throws IOException {  if (this.entityTypeFilters != null) {   for (TypeFilter filter : this.entityTypeFilters) {    if (filter.match(reader, readerFactory)) {     return true;    }   }  }  return false; }}

Hibernate property default for hbm2ddl

2008-02-11T14:37:00.000-08:00

While using hbm2ddl for schema creation and update, if you want it to set a default value for the new column, use "default" property in hbm.

Example:
<property name="initialSize" type="int">
<column name="INITIAL_SIZE" not-null="false" unique="false" sql-type="INTEGER" default="3"/>
</property>

Although hibernate documentation also mention to have insert="false" attribute, but it seems to be working even otherwise. The resultant effect would be same as using default in alter/create table SQL statements for schema creation/update.

Bypassing lazy initialization in HQL

2008-02-11T11:46:00.000-08:00

When you have lazy initialization turned on (default) in hibernate, you have to invoke seperate getter/find quary to retrieve child collections.
Sometimes you want to bypass lazy initialization for instance during schema migration.

You can use Hibernate HQL semantics of "fetch" to retrieve child collection in one query.

Example:
from MyEntity as me inner join fetch me.childEntityCollection

The above query gets MyEntity with child childEntities already populated instead of proxy holders.

Performance tuning and unit testing hibernate application.

2007-10-25T18:04:00.001-07:00

For complete list of hibernate best practices visit this blog home: http://hibernatebp.blogspot.com/

There is a decent tutorial on testing hibernate mappings using Junit at http://today.java.net/pub/a/today/2005/10/11/testing-hibernate-mapping.html?page=1
Unitils is a java open source which uses standard unite testing framework such as JUnit, DBUnit and EasyMock. Unitils contains a very simple but powerful mapping test. This test checks whether the mapping of all Hibernate mapped objects is consistent with the database. To activate it, just add following test to your test suite:

@SpringApplicationContext({"classpath:services-config.xml", "classpath:test-ds-config.xml"})
public class HibernateMappingTest extends UnitilsJUnit3 {
public void testMappingToDatabase() {
HibernateUnitils.assertMappingWithDatabaseConsistent(); }}

Suppose that the column PERSON.FIRSTNAME is missing in the test database. This will make the test fail with a message indicating that this column should be added:
AssertionFailedError: Found mismatches between Java objects and database tables. Applying following DDL statements to the database should resolve the problem: alter table PERSON add column firstName varchar(255);

For more details about unitils refer to http://unitils.sourceforge.net/spring_article.html

ORMUnit from the author of "POJOs in Action" also comes very handy for testing hibernate based applications.It could be now downloaded from http://code.google.com/p/ormunit/

Guidelines to choose between session management strategy:
A basic Hibernate client/server application may be designed with server-side units of work that span a single client request.When a request from the application user requires data access, a new unit of work is started. The unit of work endswhen processing is complete and the response for the user is ready. This is session-per-request strategy.
In a scenario like web applications, you don’t usually maintain a database transaction across a user interaction. Users take a long time to think about modifications. You can handle this scenario either by extending the persistence context or using detached objects. Hibernate objects are automayically detached when session is closed. You have to just call update to reattach it with session. This strategy is called session-per-request-with-detached objects.
You can also extend a persistence context to span the whole transaction unit. That is session per application transaction which spans across multiple requests. Also known as sesseion per conversation.
session-per-request-with-detached-objects is more of a BMP in context of EJBs. You have to pragrammatically take care of detached objects. Whereas session-per-conversation is loosely similar to CMP where hibernate will take care of it per unit of work.
At the end of a unit of work, all the modifications you made, have to be synchronized with database through SQL DML statements. This process is called flushing of the persistence context. If a single property of an object is changed twice in the same persistence context, Hibernate needs to execute only one SQL UPDATE.Hibernate flushes occur at the following times:
When a Transaction on the Hibernate API is committed Before a query is executed
When the application calls session.flush() explicitly

You can control this behavior by explicitly setting the Hibernate FlushMode via call to session.setFlushMode(). The default flush mode is FlushMode.AUTO and enables the behavior described previously. If you chose FlushMode.COMMIT, the persistence context isn’t flushed before query execution. It is flushed only when you call Transaction.commit() or Session.flush() manually. Repeated flushing of the persistence context is often a source for performance issues, because all dirty objects in the persistence context have to be detected atflush-time. A common cause is a particular unit-of-work pattern that repeats aquery and update sequence many times. Every update leads to a flush and a dirty check of all persistent objects, before each query. A Flush-Mode.COMMIT may be appropriate in this situation. The performance of the flush setting also depends on the size of the persistence context i.e the number of persistent objects it manages.
Hibernate supports query cache which stores the primary keys of the objects found by a query. When it executes a query hibernate looks into query cache for the results before accessing the database. A query cache is useful for read only data because hibernate flushes all cached queries that involves a modified table.

In order to decide whether to leave the default lazy loading or go for eager loading, you should analyze relationships that are traversed in each request. If the application always traverses a relationship, it should be early loaded. By default hibernate lazily loads objects and collection and uses seperate SQL SELECT statement for each object or collection. In eager loading all the objects would be fetched in single SELECT.
Sometime different requests require different objects to be eagerly loaded. A fetch join identifies relationship to eagerly load. HQL with fetch join ignores lazy loading settings specified in mapping.
Example:

from Order orderleft outer join fetch order.catalogleft outer join fetch order.lineitems as lineitemsleft outer join fetch lineitem.product where order.id = ?

There are several limitations to fetch join such as duplicate data and ability to fetch only single collection. Also it is too verbose.

In hibernate Session is your 1st level cache. Hibernate has a pluggable 2nd level caching architecture and there are several caching frameworks such as EHCache that supports process level cache. In hibernate caching is configured on per class or per collection basis. If you specify read-only, objects that are never modified by application are cached. If you specify read/write, objects that are modiefied by application are cached.
<class name="Catalog" table="catalog"><cache usage="read-write"/> -------------------</cache>
Objects configured for cache should be lazy loaded.

If you use the identifier as part of your equals() and hashCode() implementation, add the entity to a Set before you save it.

I personally do not like java annotations but if you want to use it for out of box validation, here is a decent tutorial:http://www-128.ibm.com/developerworks/java/library/j-hibval.html

Choose the right inheritence mapping strategy which suits your needs. Debate with domain architect and comeup with right OO design. Sometimes a good OO design might not be necessarily good for performance. You can refer to: http://www-128.ibm.com/developerworks/java/library/j-hibernate/

Some standard practices.

2007-10-23T19:35:00.000-07:00

For complete list of hibernate best practices visit this blog home: http://hibernatebp.blogspot.com/

You know it but just a reminder that HQL queries refer to object properties not database column's.
Realize mapping with respect to the database table model you are expecting. Whether you are using middlegen to start your hibernate project from existing schema or starting from scratch, you should visualize the outcome in terms of traditional db model and SQLs.It takes the surprise factor out and makes the design more predictable specially when you want to choose between association/composition or inheritance/composition.
Properties or attributes of POJO class need not be public. Hibernate's fundamental persistence architecture is based on reflection. Hibernate only enforces for having accessor getters and setters methods. This is more of a good OO design practice to keep class attributes private.
Place hbm.xml file in same package as your source. It will be useful while packaging as jar for web applications.
Creating session factory is a slow operation. You can take help from spring to maintain single session factory throughout your application per database. Session Factory is thread safe anyway. Please note that session object is not thread safe and it should be retrieved from session factory as and when required. Hibernate defines two states for any mapped object: transient and persistent. Transient object is like disassociated object and mapped is associated with a particular session.
Implement object versioning if required to resolve conflict. Most of the time you work with offline set of objects and persist them when required. It is advised to implement some sort of high level object versioning mechanism. Hibernate does not lock objects in memory. Your application can expect the behavior as defined by the isolation level of your database transactions. Hibernate provides automatic versioning and most of the cases it is sufficient. Many business processes require a whole series of interactions with the user interleaved with database accesses. Hibernate can automatically detect if a concurrent modification occured during user think time. It checks at the end of the conversation. Hibernate checks instance versions during flush, throwing an exception if conflicting updates occured. If you set optimistic-lock="dirty" when mapping , Hibernate will only compare dirty fields during flush.
Use Named queries and paremeters: Named queries and paremeters makes program more readable. Named parameters are identified by ":". Query interface has type safe methods like setString, setTime to set values.

Example of mapping document with named query:

<hibernate-mapping">.........................

<![CDATA[ from com.mydeveloperconnection.hibernateBP.Test as test where test.bpno ">= :bpnum ]]"></query">.................</hibernate-mapping">

2007-09-25T19:18:00.000-07:00

For complete list of hibernate best practices visit this blog home: http://hibernatebp.blogspot.com/

Avoid loading all objects to find count: This is a classic case, where we want total count of entity in database. Avoid loading all objects and iterating through them to find count. Here is a simple way:

return (Integer) getHibernateTemplate().execute( new HibernateCallback()

{

public Object doInHibernate( Session session ) throws HibernateException,SQLException {

Query query = session.createQuery("select count(id) from My_Entity");

return ( (Long) query.iterate().next() ).intValue();

}

} );

Who should use hibernate?

2007-06-21T07:59:00.000-07:00

For complete list of hibernate best practices visit this blog home: http://hibernatebp.blogspot.com/

Who should use hibernate?
Hibernate implements Java Persistence and supports all the standardized mappings,
queries, and APIs. Before we start with hibernate best practices, lets see who needs hibernate.
Hibernate is suitable for:

Application supporting various database and want to focus of their business logic instead of basic persistence mechanism.
Application which already have to data store and want to remove clutter of SQLs all over the code to better organized and maintained piece of software.
Applications which require seamless integration with caching APIs.
Applications driven by model such as UML. Declarative mappings in the form of XML is one of the reason for hibernate's popularity. There are several MDA tools such AndroMDA, middlegen which facilitates generating hibernate mapping file automatically and java code from it.
Many more..

However hibernate is not meant for die hard fans of complex SQLs and for application where large portion of business logic reside in their mile long stored procedures. Hibernate is also not yet designed for large scale data warehousing or data mart applications which uses underlying database server's additional capabilities for performance and scalability. A dashboard application working on top of data warehouse can use hibernate efficiently.