Arquitectura en Capas

Arquitectura de Software - Arquitectura en Capas

La arquitectura de un sistema se puede ver como un conjunto de estructuras que le dan razón al sistema. Estas estructuras comprenden elementos de software, las relaciones entre ellos y sus propiedades.

La arquitectura en capas es una técnica para organizar el código de un sistema en capas, en donde cada capa usa los servicios de la que está por debajo suyo.

Lo podemos ver como una torta, en donde cada capa descansa sobre la anterior.

 

Capas Comunes

La forma comúnmente usada de la arquitectura en capas es con 3 capas.

• Presentation o Capa de Presentación: Esta es la planta baja del edificio, la fachada. Es lo que los usuarios ven y con lo que interactúan. Aquí se maneja la interfaz de usuario, la presentación de datos, y las interacciones del usuario. Es como el salón donde se reciben a los invitados y se les muestras dónde está todo.
• Domain o Capa de Lógica de Negocio: Subiendo al primer piso, tenemos la lógica de negocio. Aquí es donde están las reglas y procesos específicos del negocio, lo que le da sentido al sistema, lo fundamental. Es como la cocina, se decide qué se va a cocinar y cómo se va a servir
• Data Source o Capa de Acceso a Datos: En el sótano, tenemos la capa de acceso a datos. Es la capa que interactúa con bases de datos o cualquier otro almacenamiento de datos. Es como el almacén en donde se guarda toda la comida y las bebidas antes de ser preparadas y servidas.
• Service o Capa de Servicios: A veces hay un piso adicional, la capa de servicios, que actúa como un intermediario entre la presentación y la lógica de negocio. Es como tener un equipo de camareros que llevan la comida de la cocina al salón.

Ventajas

• Separación de Responsabilidades: Cada capa tiene una responsabilidad clara, lo que facilita la gestión y el mantenimiento.
• Flexibilidad y Escalabilidad: Se puede modificar o escalar una capa sin afectar a las otras.
• Facilidad de Pruebas: Las capas independientes permiten realizar pruebas más enfocadas y efectivas.

Desventajas

• Rendimiento: A veces, el paso de datos entre capas puede afectar el rendimiento.
• Complejidad: Para sistemas pequeños, este modelo puede ser excesivamente complejo.

Ejemplo: Sistema de Gestión de Pedidos en Restaurante

Debemos desarrollar un sistema para gestionar pedidos en un restaurante.

El sistema debe permitir que los clientes realicen pedidos de comidas y que estos pedidos sean procesados por el personal de cocina.

Solución

Planteamos una solución simple en 3 capas, en esta estructura:

• presentacion/: Clases relacionadas con la interacción del usuario,  InterfazUsuario.
• dominio/: Clases que representan la lógica de negocio, Pedido y Chef.
• datos/: Maneja el acceso y manipulación de los datos, representado por la clase Almacen.
• main/: Contiene la clase Restaurante, que sirve como el punto de entrada principal del programa. La capa Main no la vimos antes, pero se puede ver como un punto de inicio y coordinación del programa, configuración, son las llamadas clases sucias, que conocen todas los paquetes.

En código Java:

• Presentación

InterfazUsuario.java – Maneja la interacción con el usuario.

              
    public class InterfazUsuario {
        private Chef chef;
    
        public InterfazUsuario(Chef chef) {
            this.chef = chef;
        }
    
        public void realizarPedido(String item) {
            Pedido pedido = new Pedido(item);
            System.out.println(pedido.describirPedido());
            String resultado = chef.prepararComida(pedido);
            System.out.println(resultado);
        }
    }
              
              

• Dominio

Pedido.java – Representa el pedido del cliente.

              
    public class Pedido {
        private String item;
    
        public Pedido(String item) {
            this.item = item;
        }
    
        public String getItem() {
            return item;
        }
    
        public String describirPedido() {
            return "Pedido recibido para: " + item;
        }
    }
              
              

Chef.java – Encargado de la lógica de negocio, como preparar la comida.

              
    public class Chef {
        private Almacen almacen;
    
        public Chef(Almacen almacen) {
            this.almacen = almacen;
        }
    
        public String prepararComida(Pedido pedido) {
            String ingredientes = almacen.obtenerIngredientes(pedido.getItem());
            return "Comida preparada con " + ingredientes + " para " + pedido.getItem();
        }
    }
              
              

• Datos

Almacen.java – Maneja el acceso a datos, por ejemplo para obtener ingredientes.

              
    public class Almacen {
        public String obtenerIngredientes(String item) {
            // Simulación de la obtención de ingredientes
            return "tomate, queso, masa";
        }
    }
    
              

• Main

Restaurante.java – Clase principal que inicia y coordina el sistema.

              
    public class Restaurante {
        public static void main(String[] args) {
            Almacen almacen = new Almacen();
            Chef chef = new Chef(almacen);
            InterfazUsuario interfaz = new InterfazUsuario(chef);
            interfaz.realizarPedido("pizza");
        }
    }
              
              

Cada clase está asignada a una de las cuatro capas definidas: Presentación, Dominio, Datos y Main.

Conclusiones

En resumen, la arquitectura de software de capas es como un edificio bien organizado o una fiesta bien planificada, donde cada elemento tiene su lugar y propósito, trabajando juntos para crear una experiencia armoniosa y funcional.

 

 

Recursos utilizados: 

Imagen de topntp26 en Freepik