¿Cuál es el punto de una fachada en Java EE?

Question

Realmente no entiendo el punto de una fachada.

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();
    }
}

Si tengo este código y luego tengo un EJB como este.

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

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

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

}

¿Cual es el punto de esto? ¿Por qué llamar a esto una fachada? Para mí es solo una clase abstracta que agrupa una funcionalidad similar. Gracias.

Answer 1

La fachada es un patrón de diseño. Un patrón, un patrón de software, es un conjunto de reglas para organizar el código y proporcionarle una determinada estructura. Se pueden alcanzar algunos objetivos utilizando un patrón. Se utiliza un patrón de diseño al diseñar la aplicación.

El patrón de fachada permite a los programadores crear una interfaz simple para que los objetos usen otros objetos. Considere trabajar con un grupo de clases muy complejo, todos implementando sus propias interfaces. Bueno, desea proporcionar una interfaz para exponer solo alguna funcionalidad de los muchos que tiene. Al hacerlo, logra la simplicidad del código, la flexibilidad, la integración y el acoplamiento suelto.

La fachada, en su ejemplo, se usa para gestionar el acoplamiento entre muchos actores. Es un problema de diseño. Cuando tiene muchos componentes que interactúan juntos, cuanto más estén atados, más difíciles será para mantenerlos (quiero decir, mantenimiento del código). Fachade le permite alcanzar el acoplamiento suelto, que es un objetivo que un programador siempre debe tratar de alcanzar.

Considera lo siguiente:

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
   ...
   ...
}

Si tuviera que cambiar la lógica comercial ubicada en una clase utilizada por Call1 o Call2 ... al no cambiar la interfaz, no necesitaría cambiar todas estas clases, sino solo la clase dentro del método utilizado por uno de los métodos de interfaz de Las dos primeras clases.

La fachada le permite mejorar este mecanismo.

Lo siento, pero me doy cuenta de que no se ve tan maravilloso. Los patrones de diseño se usan fuertemente en la industria del software y pueden ser muy útiles cuando se trabajan en grandes proyectos. Puede señalar que su proyecto no es tan grande y eso puede ser cierto, pero Java EE tiene como objetivo ayudar a la programación de aplicaciones de nivel empresarial y empresarial. Es por eso que a veces el patrón de fachada se usa de forma predeterminada (algunos IDE también lo usan).

Answer 2

Por lo general, este patrón se utiliza para ocultar la implementación de las clases subyacentes para las que presenta una interfaz o para simplificar la implementación subyacente de algo que puede ser complejo.

Una fachada puede presentar una interfaz simple para el mundo exterior, pero debajo del capó hace cosas como crear instancias de otras clases, administrar transacciones, manejar archivos o conexiones TCP/IP, todas las cosas de las que puede protegerse por la interfaz simplificada.

Answer 3

En su contexto particular, esto no es realmente una fachada. Lo que tiene en ese código es básicamente un DAO (objeto de acceso a datos).

Un DAO puede verse como una fachada para las operaciones de DB, pero este no es su objetivo principal. Principalmente tiene la intención de ocultar las partes internas de DB. En su ejemplo, si está cambiando el sistema de almacenamiento subyacente a archivos XML o a algún almacén de valores clave como HBase, aún puede usar los métodos definidos en esa "fachada" y no se requiere ningún cambio en el código del cliente.

Una fachada (tradicional) trata con diseños complejos que deben estar ocultos a los clientes. En lugar de exponer una API compleja y flujos complejos (obtenga esto de este servicio, pasárselo a este convertidor, obtenga el resultado y validelo con esto y luego envíelo a este otro servicio), simplemente encapsula todo eso en una fachada y simplemente Exponga un método simple a los clientes. De esta manera, junto con el hecho de que su API es mucho más fácil de usar, también es libre de cambiar la implementación subyacente (compleja) sin romper el código de sus clientes.