Question

Using the generic dao pattern, I define the generic interface:

public interface GenericDao<T extends DataObject, ID extends Serializable> {
    T save(T t);
    void delete(ID id);
    T findById(ID id);
    Class<T> getPersistentClass();
}

I then implemented an default GenericDaoImpl implementation to perform these functions with the following constructor:

public GenericDaoImpl(Class<T> clazz) {
    this.persistentClass = clazz;
    DaoRegistry.getInstance().register(clazz, this);
}

The point of the DaoRegistry is to look up a Dao by the class associating to it. This allows me to extend GenericDaoImpl and overwrite methods for objects that requires special handling:

DaoRegistry.getInstance().getDao(someClass.getClass()).save(someClass);

While it works, there are a few things that I don’t like about it:

• DaoRegistry is an singleton
• The logic of calling save is complicated

Is there a better way to do this?

Edit
I am not looking to debate whether Singleton is an anti-pattern or not.

Answer 1

It could be better to use instance of DaoRegistry instead of static methods. It would make it more manageable for test configurations. You could implement it as

@Component("daoRegistry")
public class DaoRegistry {
  @Autowired
  private List<GenericDao> customDaos;

  private GenericDao defaultDao = new GenericDaoImpl();

  public <T> T getDao(Class<T> clazz) {
    // search customDaos for matching clazz, return default dao otherwise
  }
}

Also you could add save method to it and rename accordingly. All customised daos should be available as beans.