Autor: Juan Pablo Fuentes

Arquitectura Hexagonal (Puertos y Adaptadores)

La arquitectura hexagonal, también conocida como arquitectura de puertos y adaptadores, es un estilo de diseño de software propuesto por Alistair Cockburn. Su objetivo es aislar el núcleo de la aplicación (la lógica de negocio) del mundo exterior (interfaces de usuario, bases de datos, APIs externas, etc.), creando un diseño más modular, escalable y fácil de probar.

Conceptos clave

1. Core de la aplicación (Dominios):
   • Es el núcleo que contiene la lógica de negocio, los casos de uso y las reglas de la aplicación.
   • Es completamente independiente de cualquier tecnología o infraestructura externa.
2. Puertos:
   • Interfaces que definen cómo interactuar con el núcleo de la aplicación.
   • Hay dos tipos:
     • Puertos de entrada: Permiten interactuar con la aplicación desde el exterior (e.g., controladores de una API o eventos).
     • Puertos de salida: Permiten que la aplicación interactúe con servicios externos (e.g., base de datos, APIs de terceros).
3. Adaptadores:
   • Implementaciones concretas de los puertos. Son responsables de conectar el núcleo con el mundo exterior.
     • Adaptadores de entrada: Transforman las solicitudes externas (API, CLI, UI) en comandos comprensibles para el núcleo.
     • Adaptadores de salida: Implementan las interacciones con servicios externos (e.g., repositorios de datos, APIs externas).
4. Separación de preocupaciones:
   • Los adaptadores y la infraestructura están separados del núcleo. Esto permite cambiar tecnologías o interfaces externas sin afectar la lógica de negocio.

Beneficios de la arquitectura hexagonal

1. Independencia tecnológica:
   • Puedes cambiar tecnologías (base de datos, frameworks) sin modificar el núcleo.
2. Facilidad de pruebas:
   • El núcleo puede ser probado de forma aislada con simulaciones o stubs.
3. Escalabilidad:
   • Es fácil añadir nuevos adaptadores o integrar nuevos sistemas externos.
4. Mantenimiento:
   • Reduce la complejidad al desacoplar la lógica de negocio de las dependencias externas.

Ejemplo práctico

Imaginemos un sistema para gestionar órdenes de compra. Implementaremos:

• Backend (C#): Con un núcleo que maneja órdenes y un adaptador para la base de datos.
• Frontend (React): Como adaptador de entrada para interactuar con el usuario.

Backend con C# (Puertos y Adaptadores)

Estructura del proyecto

/Core
    - IOrderService.cs (Puerto de entrada)
    - IOrderRepository.cs (Puerto de salida)
    - OrderService.cs (Implementación del servicio)
    - Models/
        - Order.cs
/Infrastructure
    - DatabaseOrderRepository.cs (Adaptador de salida)
/API
    - OrderController.cs (Adaptador de entrada)

Código

1. Core: Definición de puertos
2. Puerto de entrada (IOrderService):

   public interface IOrderService
   {
       void CreateOrder(Order order);
       Order GetOrderById(Guid orderId);
   }
   

3. Puerto de salida (IOrderRepository):

   public interface IOrderRepository
   {
       void Add(Order order);
       Order FindById(Guid orderId);
   }
   

4. Core: Lógica de negocio
5. Modelo de Orden:

   public class Order
   {
       public Guid Id { get; set; }
       public string ProductName { get; set; }
       public int Quantity { get; set; }
       public decimal Price { get; set; }
   }
   

6. Implementación del servicio:

   public class OrderService : IOrderService
   {
       private readonly IOrderRepository _orderRepository;
   
       public OrderService(IOrderRepository orderRepository)
       {
           _orderRepository = orderRepository;
       }
   
       public void CreateOrder(Order order)
       {
           // Validaciones de negocio
           if (order.Quantity <= 0)
               throw new ArgumentException("La cantidad debe ser mayor a cero.");
   
           _orderRepository.Add(order);
       }
   
       public Order GetOrderById(Guid orderId)
       {
           return _orderRepository.FindById(orderId);
       }
   }
   

7. Infraestructura: Adaptador de salida
8. Adaptador para la base de datos:

   public class DatabaseOrderRepository : IOrderRepository
   {
       private readonly List<Order> _orders = new List<Order>();
   
       public void Add(Order order)
       {
           _orders.Add(order);
       }
   
       public Order FindById(Guid orderId)
       {
           return _orders.FirstOrDefault(o => o.Id == orderId);
       }
   }
   

9. API: Adaptador de entrada
10. Controlador:

    [ApiController]
    [Route("api/orders")]
    public class OrderController : ControllerBase
    {
        private readonly IOrderService _orderService;
    
        public OrderController(IOrderService orderService)
        {
            _orderService = orderService;
        }
    
        [HttpPost]
        public IActionResult CreateOrder([FromBody] Order order)
        {
            _orderService.CreateOrder(order);
            return Ok("Orden creada con éxito.");
        }
    
        [HttpGet("{id}")]
        public IActionResult GetOrderById(Guid id)
        {
            var order = _orderService.GetOrderById(id);
            return order != null ? Ok(order) : NotFound();
        }
    }
    

Frontend con React (Adaptador de entrada)

Estructura del proyecto

/components
    - OrderForm.jsx
    - OrderList.jsx
/services
    - api.js

Código

1. Servicio para interactuar con el backend (api.js):

   const BASE_URL = "http://localhost:5000/api/orders";
   
   export const createOrder = async (order) => {
       const response = await fetch(`${BASE_URL}`, {
           method: "POST",
           headers: { "Content-Type": "application/json" },
           body: JSON.stringify(order),
       });
       return response.json();
   };
   
   export const getOrderById = async (id) => {
       const response = await fetch(`${BASE_URL}/${id}`);
       return response.json();
   };
   

2. Formulario para crear órdenes (OrderForm.jsx):

   import React, { useState } from "react";
   import { createOrder } from "../services/api";
   
   const OrderForm = () => {
       const [productName, setProductName] = useState("");
       const [quantity, setQuantity] = useState(1);
       const [price, setPrice] = useState(0);
   
       const handleSubmit = async (e) => {
           e.preventDefault();
           const order = { productName, quantity, price };
           await createOrder(order);
           alert("Orden creada con éxito.");
       };
   
       return (
           <form onSubmit={handleSubmit}>
               <input
                   type="text"
                   placeholder="Nombre del producto"
                   value={productName}
                   onChange={(e) => setProductName(e.target.value)}
               />
               <input
                   type="number"
                   placeholder="Cantidad"
                   value={quantity}
                   onChange={(e) => setQuantity(e.target.value)}
               />
               <input
                   type="number"
                   placeholder="Precio"
                   value={price}
                   onChange={(e) => setPrice(e.target.value)}
               />
               <button type="submit">Crear Orden</button>
           </form>
       );
   };
   
   export default OrderForm;
   

Ventajas en este ejemplo

1. Backend:
   • La lógica de negocio está aislada (OrderService) y puede probarse fácilmente con mocks.
   • Cambiar la base de datos o usar un servicio externo solo requiere modificar DatabaseOrderRepository.
2. Frontend:
   • El adaptador para interactuar con el backend (api.js) desacopla los detalles de implementación del resto del código.

Para saber más:

https://salesystems.es/arquitectura-hexagonal/

https://www.hackio.com/blog/que-es-arquitectura-hexagonal-en-programacion

https://medium.com/@edusalguero/arquitectura-hexagonal-59834bb44b7f