Convenzioni di denominazione DAO Hibernate a molla?

Question

è tipico di nome DAO nel modo seguente:

UserDAO - interface 
UserDAOImpl - implements UserDAO 

Mi chiedo se il suo standard di utilizzare il suffisso 'Impl' per l'attuazione o se qualcosa di più significativo è la migliore pratica. Grazie.

Answer 1

Questo è in genere quello che uso. A volte il prefisso predefinito predefinito 10 potrebbe avere più senso se si sta creando un'interfaccia che ci si aspetta che gli altri implementino ma che si sta fornendo l'implementazione di riferimento.

La maggior parte delle volte sento che i due possono essere usati in modo intercambiabile, ma in alcune situazioni si ottiene un po 'più di chiarezza dell'altro.

Answer 2

Prima di tutto, potresti non avere davvero bisogno di una classe DAO per ciascuna delle tue classi. L'articolo Don't repeat the DAO! spiega cos'è un DAO generico. Chiedersi come denominare il codice boilerplate non è produttivo.

Ora, quando si ha un DAO generica, si potrebbe andare per:

• DAO (interfaccia)
• SessionDAO e EntityManagerDAO - per l'utilizzo sia Session o EntityManager

E, Ovviamente, usa il DAO solo tramite l'interfaccia. È possibile passare facilmente tra le implementazioni.

(io in realtà preferiscono caratteri minuscoli - Dao, anche se è un'abbreviazione, e il suffisso Impl)

Answer 3

ci sono due convenzioni che ho visto:

1. FooDao per l'interfaccia e FooDaoImpl per l'attuazione
2. IFooDao per l'interfaccia e FooDao per l'attuazione

Il primo ha le sue radici in CORBA; la seconda è una convenzione Microsoft COM/.NET. (Grazie a Pascal per la correzione.)

"Non ripetere il DAO" è una buona idea. Personalmente penso che l'articolo sia più complesso di quanto debba essere. C'è un modo per farlo senza riflessione nei cercatori che preferisco. Se usi Hibernate, la query per esempio può essere un ottimo modo per farlo semplicemente. L'interfaccia sarebbe più simile a questo:

package persistence; 

import java.io.Serializable; 
import java.util.List; 

public interface GenericDao<T, K extends Serializable> 
{ 
    T find(K id); 
    List<T> find(); 
    List<T> find(T example); 
    List<T> find(String queryName, String [] paramNames, Object [] bindValues); 

    K save(T instance); 
    void update(T instance); 
    void delete(T instance); 
} 

Answer 4

Ho anche fan del -Convenzione GenericDao e GenericDaoImpl con un certo sostegno da classi di supporto generiche, dovrebbe il salvare o eliminare richiedere azioni supplementari per alcune classi persistenti:

public interface PersistListener<T> { 
    void onPersist(T item); 
} 

Costrutti simili possono essere utilizzati anche per la cancellazione. Ciò è particolarmente utile se è necessario un qualche tipo di registro eventi per scrivere ogni attività e non si desidera utilizzare AOP per questo.

miei GenericDaoImpl sarebbe simile a questa:

public class GenericDaoImpl<T> extends HibernateTemplate { 
    public void setPersistListeners(List<PersistListener> listeners) { 
    this.persistListeners = new GenericInterfaceHandler(listeners, 
     PersistListener.class); 
    } 

    // hibernate updates the key to the object itself 
    public T save(T item) { 
    getSession().save(item); 
    List<PersistListener<T>> listeners = this.persistListeners.getAll(item); 
    for (PersistListener<T> listener : listeners) 
     listener.persist(item); 
    } 

    // ... 
} 

Che persistListener nell'esempio di cui sopra farà è quello di trovare un PersistListener con classe generica corrispondenza a quella della classe data come parametro. Si trova così, quindi la chiamata è delegata al listener appropriato. My GenericInterfaceHandler può anche essere utilizzato per restituire solo il gestore più specifico o il solo gestore per la classe data, se presente.

Se sei interessato, potrei anche pubblicare l'implementazione di GenericInterfaceHandler in quanto è un costrutto piuttosto potente in molte occasioni.