Question

With the generic dao interface:

public interface GenericDAO<T extends DataObject, ID extends Serializable> {
      T save (T object);
      T load (ID id);
      void remove (ID id);
      Class<T> getPersistedType();
}

You implement GenericDaoImpl with your favorite ORM, like Hibernate to handle loading and persisting generic objects. You end up with UserDao, StoreDao, TransactionDao, PetsDao, and 50 other Dao that each have different logic on how the object is to be saved, loaded, and removed. You may also have many instances of the GenericDao, each for a class type that only requires generic handling.

I am looking to implement an service that will handle these operations for any DataObject and will choose the right Dao to do it. If there is an Dao implementation for this object, use it, otherwise use the GenericDao.

One way to do it is to have a DaoFactory if/else statement to check the object type, and return the corrosponding Dao. However, this is will require you to make modification to the factory each time a new Dao is added and not very elegant.

What’s a better way to implement this? To ask it another way,
how do you find the Dao that’s associated with particular class?

Answer 1

I once wrote a GenericHibernateDAOImpl; an instance of which could be used to perform read/ write or delete operation on types of any entity. I found the following links useful:

https://community.jboss.org/wiki/GenericDataAccessObjects?_sscc=t

http://www.ibm.com/developerworks/java/library/j-genericdao/index.html

    public class GenericHibernateDAOImpl <T, ID extends Serializable> implements GenericDAO<T extends DataObject, ID extends Serializable> {
        ...

        GenericHibernateDAOImpl(Class<? extends T> persistentClass, ISessionManager manager,             IPersister persister, ILogger l) {
            Validate.noNullElements(Arrays.asList(manager, persister, l));
            this.pClass = persistentClass;
            this.sessionManager = manager;
            this.persistenceDelegate = persister;
            this.logger = l;

        }
        /**
         * {@inheritDoc}
         */
        @Override
        public final T save(final T entity) { 
            persistenceDelegate.save(entity);
            return entity;
        }

        public List<T> findFromCriterions(final Criterion... pCriterions) {
        final Criteria crit = sessionManager.getSession().createCriteria(pClass);
        for (Criterion criterion : pCriterions) {
            crit.add(criterion);
        }
        return crit.list();
    }

    }

public final class SimplePersister implements IPersister {

    private final ISessionManager sessionManager;

    public SimplePersister (final ISessionManager manager) {
        sessionManager = manager;
    }

    @Override
    public <T> void save(final T entity) {
        sessionManager.getSession().save(entity);
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public <T> void delete(final T entity) {
        sessionManager.getSession().delete(entity);
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public <T> void update(final T entity) {
        sessionManager.getSession().saveOrUpdate(entity);
    }

}