Novità in Java: che cos'è JPA e DAO?

Question

Sono nuovo di Java e sto provando a creare un progetto Web con servlet. Vorrei interrogare il mio database ma penso di non capire tutto su JPA e DAO.

ho insegnato a fare le cose in questo modo:

• Crea classe com.package.entity.User (generato dal mio database)
• Creare interfaccia com.package.dao.UserDao
• Creare classe com.package.dao.jpa.JpaUserDao attuazione UserDao
• Crea EJB com.package.service.UserService con metodi come public List<User> findAll()

Ho sentito che non è necessario creare un'interfaccia DAO con JPA, ma sono completamente perso e non capisco cosa dovrei fare o cosa sia un EJB. Voglio semplicemente trovare tutti gli utenti nel mio database e mostrare i loro nomi seguendo le buone pratiche di Java.

È già tutto OK per i miei servlet e JSP.

Cosa raccomanderesti?

Answer 1

DAO sta per "Data Access Object". Estrae il concetto di "ottenere qualcosa da un archivio dati". Gli oggetti DAO possono essere implementati con chiamate JDBC, chiamate JPA o altro. Forse chiama qualche webservice remoto. Avere un DAO su JPA sembra ridondante e aggiunge un livello, ma penso che ne valga la pena.

Ad esempio, è possibile utilizzare un caso di "visualizzazione di utenti con gli occhi verdi".

con JPA dritto:

List<User> users = entityManager.createQuery("select u from User u where u.EyeColor = 'green'""); 

con una DAO dovreste:

List<User> users = dao.UsersWithEyeColor("green"); 

La DAO qui ha un paio di vantaggi:

1. E 'più facile da leggere .
2. Non espone la struttura del database al resto dell'applicazione
3. Sarebbe molto più semplice per il test dell'unità. La classe che sta ottenendo gli utenti con gli occhi verdi ha solo bisogno di creare un dao "Mock". Questo è più facile che prendere in giro JPA.

Questi sono solo alcuni argomenti per l'utilizzo di un DAO. Per un'applicazione molto semplice e di piccole dimensioni potrebbe essere troppo sovraccarico. Ma per tutto ciò che diventerà più grande e dovrà essere mantenuto per molti anni, penso che ne valga la pena.

Answer 2

DAO (Data Access Object) è fondamentalmente un modello per la programmazione, per utilizzare questo, è necessario creare una classe che creerà un oggetto che fornisce un'interfaccia astratta a un tipo di unità di persistenza (db, file system. Xml, ecc.) Perché è utile? Perché fornisce alcune operazioni di dati specifici senza esporre i dettagli del database.

Un esempio fondamentale di DAO:

import java.util.List; 


public abstract class DAOFactory { 

    public static final int MYSQL_JDBC = 1; 
    public static final int MYSQL_JPA = 2; 
    public static final int MYSQL_HIBERNATE = 3; 

    public abstract List<UserDTO> listAllUsers(); 

    public static DAOFactory getDAOFactory(int whichFactory) { 
     switch (whichFactory) { 
     case MYSQL_JDBC : return new MySqlJDBCDaoFactory(); 
     case MYSQL_JPA: return new MySqlJpaDaoFactory(); 
     case MYSQL_HIBERNATE: return new MySqlHibernateDaoFactory(); 
     default: return null; 
     } 
    } 

} 

Poi si deve creare una fabbrica specifici per ogni tipo di persistenza si riuscirà nella propria applicazione, e che fabbrica specifici devono implementare i metodi che si utilizzano per la persistenza, per esempio listAllUsers();

Ad esempio, per MySQL JPA:

public class MySqlJpaDaoFactory extends DAOFactory { 

    @Override 
    public List<UserDTO> listAllUsers() { 
     // Here I implement specific functionality to retrieve data using JPA Framework 
     //EntityManagerFactory emf = ... 
     //EntityManager em = ... 
     //List<UserDTO> list = em.get...(); 
     //return list; 
     return null; 
    } 

} 

Per MySQL JDBC quello che dovete fare altro processo:

public class MySqlJDBCDaoFactory extends DAOFactory { 

    @Override 
    public List<UserDTO> listAllUsers() { 
     //Connection = DriverManager ... 
     //PreparedStatement ps = connection.prepareStatement("select * from ..."); 
     //ResultSet = ps.executeQuery() 
     // and so on... 
     return null; 
    } 

} 

Poi si richiama la tua fabbrica in questo modo:

DAOFactory myfactory = DAOFactory.getDAOFactory(DAOFactory.MYSQL_JDBC); 
List<UserDTO> list = myfactory.listAllUsers(); 

E se riesci a vedere, non importa se cambi la struttura del tuo database o la modalità di persistenza, non devi re-inventare il ruota, cambia semplicemente un parametro e otterrai l'implementazione per la persistenza che desideri, basata semplicemente su un parametro.

Spero che possa aiutarti a capire lo schema, non uso EJB e, se stai utilizzando DAO, non penso sia ancora necessario implementare EJB.

migliori saluti