Když jsem se dostal do fáze většího poznávání J2EE, došlo mi, že vrstvení logiky je nedílnou součástí úspěchu při návrhu.
Jistě by nebylo moudré nechat „dolování dat“ rozházené po aplikační logice tak, jak ho zrovna potřebuji. Zde nastupuje DAO (Data Access Object), což je návrhový vzor sloužící ke komunikaci mezi persistentní vrstvou a zbytkem světa.

Asi nejvíce mě zaujala možnost, kde DAO vrstvu definuji pomocí generiky a abstraktní třídy. Více než tisíc slov je lepší přímá ukázka kódu.

První věcí je interface, který obsahuje všechny důležité metody, které je třeba pro DAO jednotlivých entit třeba vystavit:
public interface GenericDAO<t, ID extends Serializable> {
       public T find(ID id);
       public List<t> findAll();
       public T create(T entity);
       public T save(T entity);
       public void remove(T entity);
 }
Jednotlivé metody jsou vcelku jasné. Jedná se o základní operace jako: získej data, vytvoř, ulož, smaž. Co se týče generických typů, jedná se o entitu, které přísluší dané DAO a o typ primárního klíče. Typem primárního klíče může být jak základní datový typ jako String, Integer, tak i složený primární klíč, např: ZakazkaPK (obsahuje číslo zakázky a datum vystavení).Nyní mohu přejít k vlastní implementaci lokálního interface:
@Local
public interface ZamestnanecDAOLocal extends GenericDAO<za­mestnanec, String> {
 }
Samotná EJB beana může vypadat následovně:
@Stateless
public class ZamestnanecDAOBean implements ZamestnanecDAOLocal {
       @Persistence­Context(unitNa­me = „myDB“)
       private EntityManager em;
       //… implementace metod
 }

Velkou nevýhodou je ovšem fakt, že pokaždé musím implementovat metody, které jsou potřeba ke splnění požadavku z GenericDAO.

Zde nastupuje abstraktní třída, která za nás vyřeší onu potřebnou implementaci.
public abstract class AbstractDAO<t, ID extends Serializable> implements GenericDAO<t, ID> {
       private Class<t> entityBeanType;
       private EntityManager em;
       public AbstractDAO() {
              // vytvari, ziskava typ entity pro dane DAO
              this.entityBe­anType = (Class<t>) ((Parameterized­Type)
                            getClass().get­GenericSuperclas­s())
                            .getActualType­Arguments()[0];
       }

       public Class<t> getEntityBean­Type() {
              return entityBeanType;
       }

       @Persistence­Context(unitNa­me = „default“)
       public void setEntityMana­ger(EntityMana­ger em) {
              this.em = em;
       }

       protected EntityManager getEntityMana­ger() {
              if (em == null) {
                     throw new IllegalStateEx­ception(„…“);
              }
        return em;
       }

       public T find(ID id) {
              T entity;
              entity = getEntityMana­ger().find(ge­tEntityBeanTy­pe(), id);
              return entity;
       }

       // … implementace zbylych metod
 }
Nyní stačí danou abstraktní třídu nechat dědit samotnou implementací EJB beany:
@Stateless
public class ZamestnanecDAOBean extends AbstractDAO<za­mestnanec, String> implements ZamestnanecDAOLocal {
 }

Takto definovaná beana je schopna podědit abstraktní třídu a například anotovaný setter pro entitymanager převzít na svá bedra. Podle specifikace je totiž možné EJB beany nechat dědit mezi sebou, s vyjímkou, že dependency injections a další služby jsou poté managovány potomkem, v našem případě „ZamestnanecDA­OBean“.

Aby samotné DAO nebylo tak chudé, přidal jsem si několik dalších možností. Některé jsou již specifikovány na danou implementace ORM frameworku. Osobně jsem díky tomu přešel na Hibernate Session a Criteria API. Tady jsou některé další metody:

    /
     * <p>Vraci vsechny zaznamy z dane tabulky, ktera prislusi entite.
     * Navic umoznuje definovat razeni podle <i>Hibernate Criteria API: Order</i></p>
     * <p>Zpusob pouziti: {@code findAll(Order­.asc(„jmeno“), Order.desc(„prij­meni“))}</p>
     
      @param orderBy definice razeni zaznamu
     * @return vsechny zaznamy, pokud zadne neexistuji, vraci null
     /
    public List<t> findAll(Order… orderBy);

    /
      <p>Vraci vsechny zaznamy z dane tabulky, ktera prislusi entite.
     * Navic umoznuje definovat omezeny vyber dat, pouzivane napr. pro strankovani.</p>
     * <p>Zpusob pouziti: {@code findAll(0, 20); } Prvni radek je roven 0</p>
     
      @param first prvni radek, od ktereho se vybiraji zaznamy
     * @param offset maximalni pocet vybiranych zaznamu
     * @return vsechny zaznamy dle definovanych omezenich
     /
    public List<t> findAll(int first, int offset);

    /
      <p>Vraci vsechny zaznamy z dane tabulky, ktera prislusi entite.
     * Navic umoznuje definovat omezeny vyber dat, pouzivane napr. pro strankovani
     * a definovat razeni podle <i>Hibernate Criteria API: Order</i></p>
     * <p>Zpusob pouziti: {@code findAll(0, 20, Order.asc(„jme­no“)); } Prvni radek je roven 0</p>
     
      @param first prvni radek, od ktereho se vybiraji zaznamy
     * @param offset maximalni pocet vybiranych zaznamu
     * @param orderBy definice razeni zaznamu
     
      @return vsechny zaznamy dle definovanych omezenich
     /
    public List<t> findAll(int first, int offset, Order… orderBy);

    /
      <p>Dohledava zaznamy na zaklade Hibernate Example.</p>
     * <p>Spousti: {@code findByExample(e­xampleInstance, false, false, false, excludeProper­ty)}</p>
     * <p> Zpusob pouziti: <a href=„http://­www.hibernate­.org/hib_docs/re­ference/en/html/q­uerycriteria.html“>15­.6. Example queries</a>
     
      @param exampleInstance s naplnenymi vlastnostmi pro vyber
     * @param excludeProperty pradavajici vlastnosti pro vyber pres example
     * @return dohledane zaznamy
     /
    public List<t> findByExample(T exampleInstance, String… excludeProper­ty);

    /**
      <p>Ziskava pocet vsech radku z tabulky prislusici dane entite</p>
     
      @return pocet vsech radku
     */
    public int countAll();