Trouble passing session factory when using generic dao impl pattern

[Stuart Rogers]

Greetings all,

I've got a Hibernate3/Spring3 webapp working where each domain's dao and daoimpl is explicity typed out.
I'm now trying to convert it to using the GenericDao/GenericDaoImpl pattern but am having trouble
passing the session factory into GenericDaoImpl.

GenericDao

package skincare.model.dao;

import java.util.*;

public interface GenericDao <E, PK extends java.io.Serializable>
{
    public PK save(E newInstance);

    public void update(E transientObject);

    public void saveOrUpdate(E transientObject);

    public void delete(E persistentObject);

    public E findById(PK id);

    public List<E> findAll();

    public List<E> findAllByProperty(String propertyName,Object value);
}

GenericDaoImpl

package skincare.model.dao.hibernate;

import java.io.Serializable;
import java.lang.reflect.ParameterizedType;

import java.util.*;

import org.apache.log4j.*;
import org.hibernate.*;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.stereotype.Repository;

import org.hibernate.HibernateException;
import org.hibernate.SessionFactory;
import org.hibernate.Query;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Restrictions;

import static org.hibernate.criterion.Expression.*;

import skincare.model.dao.GenericDao;

@Repository("genericDao")
public abstract class GenericDaoImpl<E, PK extends java.io.Serializable> implements GenericDao<E, PK>
{
    private static final Logger logger = Logger.getLogger(GenericDao.class);
    
    private SessionFactory sessionFactory;  //comes in from bean
    
    private Class<E> entityClass;

    //constructors
    public GenericDaoImpl() {
        this.entityClass = (Class<E>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];
    }

    //getters and setters
    public SessionFactory getSessionFactory() {
        if( sessionFactory == null)
            throw new IllegalStateException("SessionFactory has not been set on DAO before usage");
        return sessionFactory;
    }

    public void setSessionFactory(SessionFactory sessionFactory) {
        this.sessionFactory = sessionFactory;
    }

    public Class<E> getEntityClass() {
        return entityClass;
    }

    public void setEntityClass(Class<E> entityClass) {
        this.entityClass = entityClass;
    }
    
    // CRUD stuff
    public PK save(E newInstance)
    {
        return (PK) this.sessionFactory.getCurrentSession().save(newInstance);
    }

    public void update(E transientObject)
    {
        this.sessionFactory.getCurrentSession().update(transientObject);
    }

    public void saveOrUpdate(E transientObject)
    {
        this.sessionFactory.getCurrentSession().saveOrUpdate(transientObject);        
    }

    public void delete(E persistentObject)
    {
        this.sessionFactory.getCurrentSession().delete(persistentObject);
    }

    public E findById(PK id)
    {
        List<E> results = null;
        E result = null;
        
        logger.debug("entering");
    
        Criteria crit = this.sessionFactory.getCurrentSession().createCriteria(entityClass);   
        crit.add(Restrictions.eq("id", id));
        results = crit.list();
        if( !results.isEmpty()) {
            if( results.size() == 1) {
                result = results.get(0);
            }
        }
        
        logger.debug("exiting normally");
        return result;
    }

    public List<E> findAll()
    {
        List<E> results = null;
        
        logger.debug("entering");

        if( this.entityClass == null) {
            System.out.println("entityName is null");
        } else {
            System.out.println("entityName is " +  this.entityClass.getName());
        }
// good so far        
        if( this.sessionFactory == null) {
            System.out.println("sessionFactory is null");   //  OOPS
        } else {
            if( this.sessionFactory.getCurrentSession() == null) {
                System.out.println("session is null");
            } else {
                Criteria crit = this.sessionFactory.getCurrentSession().createCriteria(entityClass);
                if( crit == null) {
                    System.out.println("criteria is null");
                } else {
                    results = crit.list();
                }
            }
        }
                
        logger.debug("exiting normally with count of " + results.size() );
        return results;
    }

    public List<E> findAllByProperty(String propertyName, Object value)
    {
        // TODO Auto-generated method stub
        return null;
    }
}

SquawDao

package skincare.model.dao;

import skincare.model.CreditCardBrand;

public interface SquawDao extends GenericDao<CreditCardBrand, Long>
{
  //nothing here yet
}

SquawDaoImp

package skincare.model.dao.hibernate;

import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;

import skincare.model.CreditCardBrand;
import skincare.model.dao.GenericDao;
import skincare.model.dao.SquawDao;

@Transactional
@Repository("squawDao")
public class SquawDaoImpl extends GenericDaoImpl<CreditCardBrand, Long> implements SquawDao
{
  //nothing here yet
}

applicationContext.xml

  <!-- Hibernate session factory -->
  <bean id="sessionFactoryA"
    class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
    <property name="dataSource"             ref="dataSourceA" />
    <property name="hibernateProperties">
      <props>
        <prop key="hibernate.dialect">$dbServerAlocal{hibernate.dialect}</prop>
        <prop key="cache.provider_class">$dbServerAlocal{hibernate.cache.provider_class}</prop>
        <prop key="hibernate.connection.characterEncoding">$dbServerAlocal{hibernate.connection.characterEncoding}</prop>
        <prop key="hibernate.connection.releaseMode">$dbServerAlocal{hibernate.connection.release_mode}</prop>
        <prop key="hibernate.show_sql">$dbServerAlocal{hibernate.show_sql}</prop>
        <prop key="hibernate.format_sql">$dbServerAlocal{hibernate.format_sql}</prop>
        <prop key="hibernate.hbm2ddl.auto">$dbServerAlocal{hibernate.hbm2ddl.auto}</prop>
        <prop key="hibernate.transaction.factory_class">com.atomikos.icatch.jta.hibernate3.AtomikosJTATransactionFactory</prop>
        <prop key="hibernate.transaction.manager_lookup_class">com.atomikos.icatch.jta.hibernate3.TransactionManagerLookup</prop>
        <prop key="hibernate.current_session_context_class">jta</prop>
        <prop key="hibernate.transaction.auto_close_session">true</prop>
      </props>
    </property>
    <property name="annotatedClasses">
      <set>
        <value>skincare.model.CreditCardBrand</value>
      </set>
    </property>
  </bean>

  <bean=id="genericDao"                   class="skincare.model.dao.hibernate.GenericDaoImpl"   abstract="true" >
    <property name="sessionFactory"    ref="sessionFactory" />
  </bean>

  <bean id="squawDao"                   class="skincare.model.dao.hibernate.SquawDaoImpl" />
   
  <bean id="squawService"               class="skincare.service.SquawServiceImpl">
    <property name="squawDao"           ref="squawDao" />
  </bean>
 
</beans> 

executing the following does print the correct domain name in GenericDaoImpl.findAll but also finds
sessionFactory to be null on the line commented with an "OOPS"

LiveTestCase

package skincare.service;

import java.io.*;
import java.util.*;
import java.lang.reflect.*;
import java.math.BigDecimal;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.text.DecimalFormat;
import java.net.*;
import java.security.MessageDigest;
import java.util.concurrent.CancellationException;
import java.util.concurrent.ExecutionException;

import javax.persistence.*;
import javax.naming.*;
import javax.sql.*;

import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;

import javax.swing.*;
import javax.swing.event.*;

import javax.transaction.UserTransaction;
import javax.transaction.HeuristicMixedException;
import javax.transaction.HeuristicRollbackException;
import javax.transaction.NotSupportedException;
import javax.transaction.RollbackException;
import javax.transaction.SystemException;

import org.apache.log4j.Logger;
import org.apache.log4j.Level;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;
import org.springframework.orm.hibernate3.SessionFactoryUtils;
import org.springframework.orm.hibernate3.SessionHolder;
import org.springframework.transaction.support.TransactionSynchronizationManager;

import org.hibernate.*;
import org.hibernate.Query;
import org.hibernate.context.ManagedSessionContext;
import org.hibernate.type.*;
import org.hibernate.type.Type;
import org.hibernate.transform.Transformers;

import static org.junit.Assert.*;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import org.junit.runners.Suite.SuiteClasses;

import skincare.model.CreditCardBrand;
import skincare.service.SquawService;

public class SquawServiceLiveTest
{
    ApplicationContext ctx;

    UserTransaction ut;

    SessionFactory sfA,   sfB;
    Session      sessA, sessB;    
    
    CreditCardBrand        creditCardBrand;
    SquawService squawService;  //comes in from bean
    
    java.util.List<CreditCardBrand> outrec_list;
    
    public void ReadTest()
    {
        this.outrec_list = squawService.findAll();
        ListIterator<CreditCardBrand> li = this.outrec_list.listIterator();
        while( li.hasNext()) {
            System.out.println( li.next().toString());
        }
    }

    public static void main(String[] args)
    {
        SquawServiceLiveTest theApp = new SquawServiceLiveTest();

        theApp.ctx = new ClassPathXmlApplicationContext("beans.skincare.xml");

        theApp.ut  = (javax.transaction.UserTransaction) theApp.ctx.getBean("atomikosUsrTx");

        theApp.sfA = (SessionFactory)          theApp.ctx.getBean("sessionFactoryA", SessionFactory.class);        
        theApp.squawService =   (SquawService) theApp.ctx.getBean("squawService");
        
        theApp.ReadTest();
    }

}

It's SOOOOOOOO close to working - what am I missing?

Thanks in advance,

Still-learning Stuar

[Stuart Rogers]

The missing piece was the abstract=true parameter in the bean for genericDao ... so now you can have a bean for the abstract class and inject the sessionFactory param as usual.

CASE CLOSED!


Still-learning Stuart