Qual è il punto di una facciata in Java EE?

Question

Non capisco davvero il punto di una facciata.

public abstract class AbstractFacade<T> { 

    private Class<T> entityClass; 

    public AbstractFacade(Class<T> entityClass) { 
     this.entityClass = entityClass; 
    } 

    protected abstract EntityManager getEntityManager(); 

    public void create(T entity) { 
     getEntityManager().persist(entity); 
    } 

    public void edit(T entity) { 
     getEntityManager().merge(entity); 
    } 

    public void remove(T entity) { 
     getEntityManager().remove(getEntityManager().merge(entity)); 
    } 

    public T find(Object id) { 
     return getEntityManager().find(entityClass, id); 
    } 

    public List<T> findAll() { 
     CriteriaQuery cq = getEntityManager().getCriteriaBuilder().createQuery(); 
     cq.select(cq.from(entityClass)); 
     return getEntityManager().createQuery(cq).getResultList(); 
    } 

    public List<T> findRange(int[] range) { 
     CriteriaQuery cq = getEntityManager().getCriteriaBuilder().createQuery(); 
     cq.select(cq.from(entityClass)); 
     Query q = getEntityManager().createQuery(cq); 
     q.setMaxResults(range[1] - range[0]); 
     q.setFirstResult(range[0]); 
     return q.getResultList(); 
    } 

    public int count() { 
     CriteriaQuery cq = getEntityManager().getCriteriaBuilder().createQuery(); 
     Root<T> rt = cq.from(entityClass); 
     cq.select(getEntityManager().getCriteriaBuilder().count(rt)); 
     Query q = getEntityManager().createQuery(cq); 
     return ((Long) q.getSingleResult()).intValue(); 
    } 
} 

Se ho questo codice e quindi ho un EJB come questo.

@Stateless 
public class WrapSpecFacade extends AbstractFacade<WrapSpec> { 
    @PersistenceContext 
    private EntityManager em; 

    @Override 
    protected EntityManager getEntityManager() { 
     return em; 
    } 

    public WrapSpecFacade() { 
     super(WrapSpec.class); 
    } 

} 

Qual è il punto di questo? Perché chiamare questa una facciata? Per me è solo una classe astratta che raggruppa funzionalità simili. Grazie.

Answer 1

La facciata è un motivo di progettazione. Un pattern, un pattern software, è un insieme di regole per organizzare il codice e fornire una certa struttura. Alcuni obiettivi possono essere raggiunti utilizzando un modello. Durante la progettazione dell'applicazione viene utilizzato un motivo di progettazione.

Il modello di facciata consente ai programmatori di creare un'interfaccia semplice per gli oggetti per utilizzare altri oggetti. Considerare di lavorare con un gruppo molto complesso di classi, tutte implementando le proprie interfacce. Bene, vuoi fornire un'interfaccia per esporre solo alcune funzionalità dei molti che hai. In questo modo si ottengono la semplicità del codice, la flessibilità, l'integrazione e l'accoppiamento lento.

Facciata, nel tuo esempio, viene utilizzata per gestire l'accoppiamento tra molti attori. È un problema di design. Quando ci sono molti componenti che interagiscono tra loro, più sono legati, più sarà difficile mantenerli (intendo la manutenzione del codice). La facciata consente di raggiungere un accoppiamento lento, che è un obiettivo che un programmatore dovrebbe sempre cercare di raggiungere.

Si consideri il seguente:

public class MyClass1 implements Interface1 { 
    public void call1() {} 
    public call call2() {} 
} 

public class MyClass2 implements Interface2 { 
    public void call3() {} 
    public void call4() {} 
} 

public class MyClass { 
    private MyClass1 a; 
    private MyClass2 b; 
    //calling methods call1 call2 call3 and call4 in other methods of this class 
    ... 
    ... 
} 

Se è stato necessario modificare la logica di business si trova in una classe utilizzata da chiamata1 o chiamata2 ... per non cambiare l'interfaccia, non avrebbe bisogno di cambiare tutte queste classi, ma solo la classe all'interno del metodo utilizzato da uno dei metodi di interfaccia delle prime due classi.

Facciata consente di migliorare questo meccanismo.

Mi dispiace ma mi rendo conto che non sembra così meraviglioso. Gli schemi di progettazione sono molto utilizzati nell'industria del software e possono essere molto utili quando si lavora su progetti di grandi dimensioni. Si potrebbe sottolineare che il proprio progetto non è così grande e questo può essere vero, ma Java EE ha lo scopo di aiutare la programmazione di applicazioni aziendali e di livello enterprise. Ecco perché a volte il pattern di facciata viene usato di default (anche alcuni IDE lo usano).

Answer 2

In genere questo modello viene utilizzato per nascondere l'implementazione delle classi sottostanti per le quali presenta un'interfaccia o per semplificare l'implementazione sottostante di qualcosa che può essere complesso.

Una facciata può presentare una semplice interfaccia con il mondo esterno, ma sotto la cappa fare cose come creare istanze di altre classi, gestire transazioni, gestire file o connessioni TCP/IP - tutte cose da cui si può essere protetti l'interfaccia semplificata.

Answer 3

Nel tuo particolare contesto, questa non è proprio una facciata. Quello che hai in quel codice è fondamentalmente un DAO (Data Access Object).

Un DAO può essere visto come una facciata per le operazioni DB, ma questo non è il suo scopo principale. Intende principalmente nascondere gli interni del DB.Nel tuo esempio, se stai cambiando il sistema di archiviazione sottostante in file XML o in qualche archivio di valori-chiave come HBase, puoi ancora usare i metodi definiti in quella "Facciata" e non è richiesta alcuna modifica nel codice cliente.

A (tradizionale) La facciata si occupa di progetti complessi che devono essere nascosti ai clienti. Invece di esporre una complessa API e flussi complessi (ottenere questo da questo servizio, passarlo a questo convertitore, ottenere il risultato e convalidarlo con questo e quindi inviarlo a questo altro servizio), basta incapsulare tutto ciò in una facciata e semplicemente esporre un metodo semplice ai clienti. In questo modo, insieme al fatto che la tua API è molto più facile da usare, sei anche libero di cambiare l'implementazione (complessa) sottostante senza infrangere il codice dei tuoi clienti.