How to write a DAO correctly?

We have been using the following hierarchy of objects in our applications for a long time to implement work with the DBMS:

1) hierarchy for entities - each entity describes one table, they have a common ancestor in order to easily identify all objects)+ add some general functionality (at least redefine the toString() method). If you do not need additional functionality, you can use the interface:

abstract class ABaseDaoEntity {
}

class EntityA extends ABaseDaoEntity {
    private String id;

    // getters,setters    
}

class EntityB extends ABaseDaoEntity {
    private String name;
    private String userId;

    // getters,setters
}

2) any recollection classes (in this case, only your own type of error):

class DaoException extends Exception {
}

3) DAO hierarchy: interface with common methods (optionally added to the interface of a specific DAO):

interface IDao<T extends ABaseDaoEntity> {

    // get by id
    void get(T entity) throws DaoException;
    T create(T entity) throws DaoException;
    void update(T entity) throws DaoException;
    void delete(T entity) throws DaoException;
}

4) the DAO hierarchy: a common abstract class: needed in order to add common functionality to all daos (in your case, only a link to the object session factory), in addition, there must also be implementations of IDao methods if this code is universal for any entity. When using frameworks, this is often the case at least for methods: create, update, delete

abstract class ABaseDao<T extends ABaseDaoEntity> implements IDao<T> {
    private SessionFactory factory;

    public ABaseDao(SessionFactory factory) {
        setFactory(factory);
    }

    protected SessionFactory getFactory() {
        return factory;
    }
    protected void setFactory(SessionFactory factory) {
        this.factory = factory;
    }

    // here we may add implementation for common IDao methods
    // (if possible of course, - just in case implementation is the same for all types of entities)
}

5) the DAO hierarchy: the interfaces of the dao objects, in fact, here you need to declare only the find methods, since you can add the rest by simply adding inheritance from the IDao interface (obviously, only if necessary):

// dao with inheritance from IDao
interface IEntityADao extends IDao<EntityA> {

    List<EntityA> findAll() throws DaoException;
}

// dao without inheritance from IDao
interface IEntityBDao {

    // find entity by name and user id
    EntityB get(String name, String userId) throws DaoException;

    List<EntityB> findAll() throws DaoException;
}

6) The DAO hierarchy: examples of DAO implementations:

// concrete dao for EntityA
class EntityADao extends ABaseDao<EntityA> implements IEntityADao {

    public EntityADao(SessionFactory factory) {
        super(factory);
    }

    // implementations of the ABase DAO methods (required only)

    // implementations of the EntityA DAO methods

}

// concrete dao for EntityB
class EntityBDao extends ABaseDao<EntityB> implements IEntityBDao {

    public EntityBDao(SessionFactory factory) {
        super(factory);
    }

    // implementations of the EntityB DAO methods

}

P. s missed an important detail:

7) DAO factory: needed in order to access a specific DAO object:

interface IDaoFactory {
  IEntityADao getEntityADao();
  IEntityBDao getEntityBDao();
}
class DaoFactory implements IDaoFactory {
  // implementations of all methods
}

P. s. if the DAO stateless objects (by functionality) - you can create them every time the getter is called, but if statefull, you can create them when creating a DAOFactory object and then return references to the objects (you can use lazy loading)

8) IDaoFactoryBean, DaoFactoryBean-interface (optional) and implementation of the bean, which is actually responsible for creating and providing access to DAOFactory. this should be the component's EJB, singleton

interface IDaoFactoryBean {
    IDaoFactory getDaoFactory();
}

P. s. if the creation of the session factory process complex or there is a need to change it often, then it is better to put the creation of this object in a separate singleton ejb. in this case, the DaoFactoryBean bin can be made stateless if DaoFactory is also stateless (meaning not ejb stateless a by functionality)