<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Jordi Tormo Llàcer on Medium]]></title>
        <description><![CDATA[Stories by Jordi Tormo Llàcer on Medium]]></description>
        <link>https://medium.com/@jtormoll?source=rss-1f0e3affd607------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*d69FnYgf4KorAKetPFSJxw.png</url>
            <title>Stories by Jordi Tormo Llàcer on Medium</title>
            <link>https://medium.com/@jtormoll?source=rss-1f0e3affd607------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 20:03:54 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@jtormoll/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Atravesando el hexágono de la arquitectura de software]]></title>
            <link>https://medium.com/mercadonait/atravesando-el-hex%C3%A1gono-de-la-arquitectura-de-software-3ed47e6c957d?source=rss-1f0e3affd607------2</link>
            <guid isPermaLink="false">https://medium.com/p/3ed47e6c957d</guid>
            <category><![CDATA[hexagonal-architecture]]></category>
            <category><![CDATA[clean-code]]></category>
            <category><![CDATA[ports-and-adapters]]></category>
            <category><![CDATA[microservices]]></category>
            <dc:creator><![CDATA[Jordi Tormo Llàcer]]></dc:creator>
            <pubDate>Mon, 17 Jun 2024 11:43:57 GMT</pubDate>
            <atom:updated>2024-06-17T11:43:57.734Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>Introducción</strong></p><p>Hace más de dos años que en <a href="https://medium.com/u/c0bdc0808a57">Mercadona IT</a> hemos iniciado un cambio radical en nuestra informática, basado en construir todas las nuevas aplicaciones bajo <strong>la arquitectura CNA </strong><em>(Cloud Native Application) </em>mediante <strong>el uso de microservicios</strong>, así como el inicio de la modernización de nuestros sistemas actuales.</p><p>Aquí podemos ver como ha evolucionado nuestra arquitectura a lo largo de los años:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/936/1*6yTgX6TiOE36YPKPoZoqMw.png" /><figcaption>Evolución de las arquitecturas en Mercadona</figcaption></figure><p>Para poder abordar un cambio de esa magnitud, nos estamos encontrando con innumerables retos que debemos abordar, entre ellos, la necesidad de determinar un patrón de arquitectura de software para nuestros microservicios que sea robusto y nos permita evolucionar para adaptarnos con facilidad y agilidad a futuros cambios tecnológicos. Además, que nos desacople completamente de la infraestructura y nos permita que nuestros microservicios sean portables entre distintas nubes.</p><p>En este artículo, nos vamos a centrar específicamente en el ámbito del <em>backend</em>, y dentro de él, vamos a hacer foco en los <strong>microservicios que contienen la lógica de negocio</strong>, obviando aquellos puramente técnicos.</p><p>Por ejemplo, podemos encontrar un sistema formado por tres microservicios: uno principal con la lógica empresarial acompañado por otros dos servicios técnicos, uno para ingestar desde un <em>broker</em> de mensajería y otro que implementa el patrón <em>outbox</em> para asegurar la transaccionalidad al publicar en un tópico.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/936/1*60YjIhsa20_J4UmFd4OOGQ.png" /><figcaption>Esquema de un sistema simple de microservicios de una aplicación</figcaption></figure><p>Centrándonos en el microservicio que contiene la lógica de negocio, debemos asegurarnos de blindar el código que resuelve las necesidades empresariales de aquellos que interactúan con las distintas piezas de infraestructura. Para lograrlo haremos uso de una <strong>arquitectura <em>Clean</em></strong> que nos ayudará a garantizarlo.</p><p><strong>Principios de una arquitectura <em>Clean</em></strong></p><p>La <strong>premisa</strong> fundamental de las <strong>arquitecturas <em>Clean</em></strong> consiste en <strong>separar</strong> completamente el <strong>código encargado de resolver la lógica de negocio</strong> del código que se encarga de acceder a la infraestructura. Estas arquitecturas también se encargan de estructurarlo en capas diferenciadas, con reglas estrictas sobre cómo se deben comunicar entre sí.</p><p>Entre estas reglas, se siguen las directrices contenidas en los principios SOLID, promovidos por Robert C. Martin en su publicación <em>“Design Principles and Design Patterns”.</em></p><p>Conjuntamente, estas reglas nos ayudan a desarrollar aplicaciones que no solo dan solución al negocio, sino que también <strong>perduran y escalan</strong> satisfactoriamente en un entorno tecnológico que no deja de evolucionar.</p><p>Existen distintos patrones de diseño de arquitecturas <em>Clean</em> que respetan estos principios <em>(arquitectura por capas, MVC, MVVM, hexagonal, etc.) </em>y en Mercadona hace años que empezamos a utilizar arquitectura por capas en el desarrollo de nuestras aplicaciones. Sin embargo, esta no nos garantizaba completamente la independencia de las mismas, debido al orden de las dependencias, lo cual, acababa acoplándonos en cierta manera al modelo de base de datos.</p><p><strong>La arquitectura hexagonal</strong></p><p>La arquitectura hexagonal, también conocida como arquitectura de puertos y adaptadores, fue dada a conocer por Alistair Cockburn, cuyo objetivo principal, como toda arquitectura <em>Clean</em>, es mejorar la modularidad, el mantenimiento y la flexibilidad creando componentes que tengan bajo acoplamiento.</p><p>En la actualidad, además de dar un salto a la arquitectura CNA, en Mercadona IT, hemos apostado por una <strong>arquitectura hexagonal en el diseño de nuestros microservicios</strong>, con la que conseguimos el tan deseado efecto de blindar nuestra capa de negocio. Esto es clave para <strong>crear aplicaciones robustas y fáciles de mantener en el largo plazo</strong>.</p><p>Sus conceptos principales son, en primer lugar, su <strong>separación de responsabilidades</strong>, donde encontramos, en el centro, <strong>el dominio y los casos de uso de la aplicación</strong>, que contienen la lógica de negocio pura sin depender de ninguna tecnología. A su alrededor, en la <strong>parte externa</strong> del hexágono, se sitúan las clases que implementan la comunicación con la infraestructura tecnológica, que llamamos <strong>adaptadores</strong>. Y como último concepto, encontramos los <strong>puertos</strong>, que se encargan de conectar y de abstraer el núcleo de la aplicación con la infraestructura. Además, el uso de los puertos facilita el intercambio de los adaptadores, según necesidad, y permite también el testeo aislado de los mismos.</p><p>Entre las distintas formas de estructurar la arquitectura hexagonal, en Mercadona, específicamente, hemos adoptado la <strong>aproximación Driving-Driven</strong>, como podemos ver en la siguiente figura:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/706/1*t2NGLUBlda6li3Ora1wkYw.png" /><figcaption>Esquema de la aproximación Driving-Driven de la arquitectura hexagonal</figcaption></figure><p><strong>Módulos y componentes</strong></p><p>La forma en la que hemos decidido implementar la aproximación Driving-Driven en nuestros proyectos, ha sido <strong>organizándola en distintos módulos</strong>. Hacerlo de esta forma nos ha dado la flexibilidad de poder intercambiarlos en tiempo de <em>deploy</em>.</p><p>La estructura clave la representamos como un hexágono y contiene el dominio de la aplicación en el centro y el resto de los módulos a su alrededor:</p><p>1. Núcleo de la aplicación <em>(módulo application)</em></p><p>2. Driving Side <em>(módulos conductores)</em></p><p>3. Driven Side <em>(módulos conducidos)</em></p><p>Dividimos la zona más externa, aquella que es responsable de comunicarse con las piezas de infraestructura, en dos partes, a la izquierda el lado Driving y a la derecha el lado Driven.</p><p>En los módulos Driving es donde encontraremos aquellos controladores que desencadenan lógica de negocio y se representan en el lado izquierdo del hexágono. Un ejemplo sería un controlador que recoge una petición de una llamada REST o un mensaje recibido por un evento de Kafka y lo pasa a la aplicación a través de un puerto.</p><p>En los módulos Driven vamos a encontrar los adaptadores que son desencadenados a partir de la lógica de la aplicación. Por ejemplo, un adaptador de BBDD es llamado por la aplicación para poder obtener ciertos datos previamente persistidos.</p><p>Estos módulos se encuentran organizados en 3 bloques lógicos <em>(dominio, aplicación e infraestructura)</em> y el mecanismo para desacoplarlas es mediante el uso de puertos y adaptadores. Estos pueden ser definidos de la siguiente manera:</p><ul><li>Puerto: definición de una interfaz pública, que los adaptadores deben cumplir para comunicar con la aplicación.</li><li>Adaptador: implementación concreta de un puerto para un contexto concreto.</li></ul><p>A continuación, podemos observar un ejemplo de la disposición de los módulos y organización de directorios <em>(scaffolding)</em> de nuestros proyectos:</p><pre>├── application/<br>│   ├── pom.xml<br>│   └── src/<br>│       ├── main/<br>│       │   └── java/<br>│       │       └── com/<br>│       │           └── mercadona/<br>│       │               └── academy/<br>│       │                   └── web/<br>│       │                       ├── application/<br>│       │                       │   ├── exceptions/<br>│       │                       │   ├── ports/<br>│       │                       │   │   ├── driven/<br>│       │                       │   │   └── driving/<br>│       │                       │   └── services/<br>│       │                       └── domain/<br>│       └── test/<br>├── boot/<br>├── docker/<br>├── driven/<br>│   ├── kafka-producer/<br>│   └── repository-sql/<br>│       ├── pom.xml<br>│       ├── sql/<br>│       └── src/<br>│           ├── main/<br>│           │   └── java/<br>│           │       └── com/<br>│           │           └── mercadona/<br>│           │               └── academy/<br>│           │                   └── web/<br>│           │                       └── repositories/<br>│           │                           ├── adapters/<br>│           │                           ├── config/<br>│           │                           ├── mappers/<br>│           │                           └── models/<br>│           └── test/<br>├── driving/<br>│   ├── api-rest/<br>│   │   └── src/<br>│   │       └── main/<br>│   │           └── java/<br>│   │               └── com/<br>│   │                   └── mercadona/<br>│   │                       └── academy/<br>│   │                           └── web/<br>│   │                               └── controllers/<br>│   │                                   ├── adapters/<br>│   │                                   └── mappers/<br>│   └── kafka-consumer/<br>│           └── test/</pre><p><strong>Cruzando el hexágono, ejemplo de uso de la arquitectura hexagonal en Mercadona IT</strong></p><p>Veamos un ejemplo simplificado de implementación de la arquitectura hexagonal en un microservicio de backend de una aplicación Ad-hoc de Mercadona IT que resuelve una lógica de negocio.</p><p>En este ejemplo básico, planteamos el supuesto de dar de alta un producto, a través de una petición entrante, que luego es necesario persistir; durante el proceso, nuestro caso de uso comprobará además si se trata de un alta nueva o un producto que ya existía, para notificar al usuario según sea el caso. Si es la primera vez, se producirá un mensaje en un bróker de mensajería asíncrono para el resto de los microservicios de la solución, en cambio, si el producto ya ha sido dado de alta lo notificará por correo a un usuario.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/830/1*nqwMVF2HA-t9311sYZ2yNw.png" /><figcaption>Diagrama de ejemplo de la arquitectura hexagonal y la integración con la infraestructura</figcaption></figure><p>Para dar solución al ejemplo, vamos a respetar la estructura hexagonal pasando por los distintos módulos, haciendo uso de los adaptadores y puertos necesarios, tal y como vemos en la siguiente figura:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/936/1*7farHfefyvyQiBzUZtLbZg.png" /><figcaption>Esquema de objetos y ficheros de código utilizados en la arquitectura hexagonal</figcaption></figure><p>Para empezar, partiremos del contrato API haciendo uso de la aproximación Contract-First que habrá generado los artefactos y los habrá dejado disponibles en el repositorio de artefactos conteniendo las clases de nuestra API.</p><p>En este ejemplo, el desencadenante de la ejecución será el adaptador REST, que hará uso del puerto <em>Driving</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/424/1*XyfqnjUgC6F3lQXGHsHc2w.png" /><figcaption>Esquema del adaptador REST que desencadena la ejecución y hace uso del puerto Driving</figcaption></figure><p>Importaremos el artefacto servidor, el cual será implementado por nuestro adaptador de entrada (<em>REST</em>). Además, dentro del adaptador declararemos dos variables privadas, el servicio <em>(caso de uso)</em>, y el <em>mapper</em> (<em>Mapstruct</em>).</p><p>Aquí podemos ver un fragmento de código del Adaptador <em>Driving</em> que recibe la petición.</p><pre>package com.mercadona.academy.web.controllers.adapters;<br><br>import javax.validation.Valid;<br>import lombok.extern.slf4j.Slf4j;<br>import lombok.AllArgsConstructor;<br>import org.springframework.http.ResponseEntity;<br>import org.springframework.http.HttpStatus;<br>import org.springframework.web.bind.annotation.*;<br>import com.mercadona.academy.web.controllers.mappers.ProductDTOMapper;<br>import com.mercadona.academy.web.application.ports.driving.ProductServicePort;<br>import com.mercadona.framework.cna.api.products.definition.server.ProductsApi;<br>import com.mercadona.framework.cna.api.products.model.ProductRequest;<br>import com.mercadona.framework.cna.api.products.model.ProductResourceCollectionResponse;<br>import com.mercadona.framework.cna.api.products.model.ProductResourceResponse;<br><br>@Slf4j<br>@RestController<br>@AllArgsConstructor<br>@RequestMapping<br>public class ProductControllerAdapter implements ProductsApi {<br>  private final ProductServicePort productService;<br>  private final ProductDTOMapper productDTOMapper;<br><br>  @Override<br>  public ResponseEntity&lt;ProductResourceResponse&gt; createProduct(@Valid @RequestBody ProductRequest productRequest) {<br>    var productEntity = productDTOMapper.from(productRequest);<br>    var productSaved = productService.createProduct(productEntity);<br>    var productResourceResponse = productDTOMapper.toProductResourceResponse(productSaved);<br>    return ResponseEntity.status(HttpStatus.CREATED).body(productResourceResponse);<br><br>  }<br>}</pre><p>Este adaptador hace uso del puerto <em>ProductServicePort</em> para entrar dentro de la aplicación.</p><p>Dicho puerto se encuentra definido como una interfaz en el módulo de aplicación dentro de la carpeta <em>Driving</em>, tal y como podemos ver en el siguiente fragmento:</p><pre>package com.mercadona.academy.web.application.ports.driving;<br><br>import com.mercadona.academy.web.domain.Product;<br><br>public interface ProductServicePort {<br>  Product createProduct(Product product);<br>}</pre><p>Este puerto es implementado por el caso de uso <em>ProductServiceUseCase</em>, que será el que contenga la lógica de negocio de nuestro ejemplo. Consiste en almacenar el producto en BBDD, en el caso de ser un alta nueva, notificarlo al resto de microservicios de la solución, y en caso de que el producto ya existiese previamente, alertar a un usuario concreto.</p><pre>package com.mercadona.academy.web.application.services;<br><br>import com.mercadona.academy.web.application.ports.driven.NotificationPort;<br>import com.mercadona.academy.web.application.ports.driven.ProductRepositoryPort;<br>import com.mercadona.academy.web.domain.Product;<br>import com.mercadona.academy.web.application.ports.driving.ProductServicePort;<br>import com.mercadona.academy.web.application.ports.driven.InternalProducerPort;<br>import lombok.AllArgsConstructor;<br>import lombok.extern.slf4j.Slf4j;<br>import org.springframework.stereotype.Service;<br><br>@Slf4j<br>@Service<br>@AllArgsConstructor<br>public class ProductServiceUseCase implements ProductServicePort {<br><br>  private final ProductRepositoryPort productRepository;<br>  private final InternalProducerPort internalProducerPort;<br>  private final NotificationPort notificationPort;<br><br>  @Override<br>  public Product createProduct(Product product) {<br>    // Save the product structure<br>    var productReturn = productRepository.save(product);<br>    if (productReturn.isSent()) {<br>      // publish only if product is sent<br>      internalProducerPort.produce(productReturn);<br>    } else {<br>      // notificate only if product is not sent<br>      notificationPort.produce(productReturn);<br>    }<br>    return productReturn;<br>  }<br>}</pre><p>Tal y como podemos ver aquí, el servicio de aplicación es el componente que contiene la lógica y el que desencadenará la acción y la dirigirá hacia la salida usando el puerto <em>Driven</em>.</p><p><strong>Inversión de dependencias:</strong></p><p>Llegados a este punto, además podemos observar el aporte de valor en la arquitectura hexagonal de uno de los principios SOLID, la inversión de dependencias, donde vemos que, a pesar de que el control de flujo de la aplicación es hacia el exterior del hexágono, las dependencias del código fuente son inversas, ya que son los adaptadores los que dependen del dominio y no al revés. Además, para desacoplarlo, la dependencia se implementará a través de una abstracción, haciendo uso del puerto <em>Driven</em>.</p><p>En el siguiente fragmento de código podemos ver uno de los puertos de salida, concretamente el puerto de persistencia de datos.</p><pre>package com.mercadona.academy.web.application.ports.driven;<br><br>import com.mercadona.academy.web.domain.Product;<br>import com.mercadona.framework.cna.commons.interfaces.CNACrudRepository;<br><br>public interface ProductRepositoryPort extends CNACrudRepository&lt;Product, Long&gt; {<br>}</pre><p>Por último, el puerto <em>Driven</em> es implementado por el adaptador de salida para que pueda ser usado por el servicio.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/1*RYYAvD7YWUqc4gQPFhWO3w.png" /><figcaption>Esquema del adaptador de salida que implementa el puerto Driven</figcaption></figure><p>Aquí podemos ver un pequeño fragmento del código correspondiente al adaptador <em>Driven</em>.</p><pre>package com.mercadona.academy.web.repositories.adapters;<br><br>import com.mercadona.academy.web.domain.Product;<br>import org.springframework.stereotype.Service;<br>import com.mercadona.academy.web.repositories.mappers.ProductMapper;<br>import com.mercadona.academy.web.repositories.ProductMOJpaRepository;<br>import com.mercadona.academy.web.application.ports.driven.ProductRepositoryPort;<br>import lombok.AllArgsConstructor;<br>import lombok.extern.slf4j.Slf4j;<br><br>@Slf4j<br>@Service<br>@AllArgsConstructor<br>public class ProductRepositoryAdapter implements ProductRepositoryPort {<br><br>  private final ProductMOJpaRepository repository;<br>  private final ProductMapper mapper;<br><br>  @Override<br>  public Product save(Product product) {<br>    var productModel = mapper.toModel(product);<br>    var productSaved = repository.save(productModel);<br>    return mapper.fromModel(productSaved);<br>  }<br>}</pre><p>De esta forma conseguimos cruzar el hexágono, manteniendo el desacoplamiento de los módulos mediante el uso de los puertos y adaptadores.</p><p>Como se puede ver en los fragmentos de código anteriores también hacemos uso de los <em>mappers</em> para realizar la transformación de datos entre módulos.</p><p><strong>Ejemplo de modificación:</strong></p><p>A continuación, vamos a poner a prueba nuestro microservicio y el valor que nos aporta haberlo implementado respetando la arquitectura hexagonal, lo que nos permitirá hacer un cambio de la parte de infraestructura sin tener que modificar código en el módulo de aplicación, desacoplando así la lógica empresarial.</p><p>En este supuesto, vamos a imaginar, que hemos recibido un cambio, en el que, a partir de este momento, los productos serán dados de alta en un sistema que genera eventos, y mediante EDA, a partir de ahora, nos suscribiremos a un tópico, por lo que nuestra entrada dejará de ser a través de una petición REST para pasar a ser un tópico de Kafka.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/556/1*uGqt_zTGjpUTwIUYUwLbHg.png" /><figcaption>Esquema que ejemplifica el cambio de adaptador de entrada</figcaption></figure><p>Para abordar el cambio, creamos un adaptador nuevo con la implementación específica de Kafka.</p><p>A continuación, podemos ver el código correspondiente al nuevo adaptador de entrada.</p><pre>package com.mercadona.academy.web.consumer.adapter;<br><br>import apps.fwkcna.ProductsEventPrivateKey;<br>import apps.fwkcna.ProductsEventPrivateValue;<br>import com.mercadona.academy.web.application.ports.driving.ProductServicePort;<br>import com.mercadona.academy.web.consumer.mapper.ProductEventMapper;<br>import com.mercadona.academy.web.domain.Product;<br>import com.mercadona.framework.cna.lib.kafka.consumer.MercadonaKafkaConsumerListener;<br>import lombok.extern.slf4j.Slf4j;<br>import org.apache.kafka.clients.consumer.ConsumerRecord;<br>import org.springframework.beans.factory.annotation.Value;<br>import org.springframework.stereotype.Component;<br><br>@Component<br>@Slf4j<br>public class ProductConsumerAdapter<br>  extends MercadonaKafkaConsumerListener&lt;ProductsEventPrivateKey, ProductsEventPrivateValue&gt; {<br><br>  private final ProductServicePort productService;<br>  private final ProductEventMapper mapper;<br><br>  public ProductConsumerAdapter(<br>    @Value(&quot;${kafka.consumer.topics.input-0}&quot;) final String[] topics,<br>    ProductServicePort productService,<br>    ProductEventMapper mapper) {<br><br>    super(topics);<br><br>    this.productService = productService;<br>    this.mapper = mapper;<br><br>  }<br><br>  @Override<br>  public void consume(ConsumerRecord&lt;ProductsEventPrivateKey, ProductsEventPrivateValue&gt; consumerRecord) {<br><br>    Product product = mapper.productEventToProduct(consumerRecord.value());<br>    productService.createProduct(product);<br><br>  }<br>}</pre><p>También añadimos la nueva dependencia en el pom del proyecto para incluir el módulo necesario de nuestro adaptador de Kafka.</p><pre>&lt;project xmlns=&quot;http://maven.apache.org/POM/4.0.0&quot;<br>         xmlns:xsi=&quot;http://www.w3.org/2001/XMLSchema-instance&quot;<br>         xsi:schemaLocation=&quot;http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd&quot;&gt;<br>  &lt;modelVersion&gt;4.0.0&lt;/modelVersion&gt;<br><br>  &lt;groupId&gt;com.mercadona.academy.web&lt;/groupId&gt;<br>  &lt;artifactId&gt;academy-back-web&lt;/artifactId&gt;<br>  &lt;version&gt;1.0.0&lt;/version&gt;<br>  &lt;packaging&gt;pom&lt;/packaging&gt;<br>  &lt;name&gt;academy-back-web&lt;/name&gt;<br><br>  &lt;!-- Provides dependency and plugin management for the given Spring Boot version --&gt;<br>  &lt;parent&gt;<br>    &lt;groupId&gt;com.mercadona.framework.cna&lt;/groupId&gt;<br>    &lt;artifactId&gt;parent-seed&lt;/artifactId&gt;<br>    &lt;version&gt;4.20.0&lt;/version&gt;<br>  &lt;/parent&gt;<br><br>  &lt;dependencyManagement&gt;<br>    &lt;dependencies&gt;<br>&lt;!--      &lt;dependency&gt;--&gt;<br>&lt;!--        &lt;groupId&gt;com.mercadona.academy.web&lt;/groupId&gt;--&gt;<br>&lt;!--        &lt;artifactId&gt;academy-back-web-api-rest&lt;/artifactId&gt;--&gt;<br>&lt;!--        &lt;version&gt;${project.version}&lt;/version&gt;--&gt;<br>&lt;!--      &lt;/dependency&gt;--&gt;<br>      &lt;dependency&gt;<br>        &lt;groupId&gt;com.mercadona.academy.web&lt;/groupId&gt;<br>        &lt;artifactId&gt;academy-back-web-application&lt;/artifactId&gt;<br>        &lt;version&gt;${project.version}&lt;/version&gt;<br>      &lt;/dependency&gt;<br>      &lt;dependency&gt;<br>        &lt;groupId&gt;com.mercadona.academy.web&lt;/groupId&gt;<br>        &lt;artifactId&gt;academy-back-web-repository-sql&lt;/artifactId&gt;<br>        &lt;version&gt;${project.version}&lt;/version&gt;<br>      &lt;/dependency&gt;<br>      &lt;dependency&gt;<br>        &lt;groupId&gt;com.mercadona.academy.web&lt;/groupId&gt;<br>        &lt;artifactId&gt;academy-back-web-kafka-producer&lt;/artifactId&gt;<br>        &lt;version&gt;${project.version}&lt;/version&gt;<br>      &lt;/dependency&gt;<br>      &lt;dependency&gt;<br>        &lt;groupId&gt;com.mercadona.academy.web&lt;/groupId&gt;<br>        &lt;artifactId&gt;academy-back-web-kafka-consumer&lt;/artifactId&gt;<br>        &lt;version&gt;${project.version}&lt;/version&gt;<br>      &lt;/dependency&gt;<br>    &lt;/dependencies&gt;<br>  &lt;/dependencyManagement&gt;<br><br>  &lt;modules&gt;<br>    &lt;!-- Core application--&gt;<br>    &lt;module&gt;application&lt;/module&gt;<br>    &lt;!-- Adapter implementations--&gt;<br>    &lt;module&gt;driving/api-rest&lt;/module&gt;<br>    &lt;module&gt;driven/repository-sql&lt;/module&gt;<br>    &lt;module&gt;driven/kafka-producer&lt;/module&gt;<br>    &lt;module&gt;driving/kafka-consumer&lt;/module&gt;<br>    &lt;!-- Runtime --&gt;<br>    &lt;module&gt;boot&lt;/module&gt;<br>  &lt;/modules&gt;<br><br>&lt;/project&gt;</pre><p><strong>Conclusiones</strong></p><p>Tal y como hemos visto en el ejemplo anterior, <strong>cambiando</strong> solo el <strong>adaptador</strong> e <strong>indicando las dependencias</strong> específicas en el fichero pom del proyecto, habremos logrado el cambio tecnológico, sin tocar nada del código relacionado con la lógica de negocio.</p><p>A pesar de que implica cierto nivel de complejidad, el uso de la <strong>arquitectura hexagonal </strong>proporciona grandes <strong>beneficios a nuestras aplicaciones</strong>, como, por ejemplo: desacoplamiento, escalabilidad, mantenibilidad y testabilidad.</p><p>El uso de una arquitectura hexagonal también beneficia a que los <strong>evolutivos</strong> sean más fáciles de abordar. Como hemos visto en el ejemplo, añadir o cambiar la infraestructura no ha supuesto tocar otros módulos, al igual que si el cambio tuviese lugar en la lógica de negocio, únicamente afectaría al caso de uso en cuestión y no a los adaptadores ya existentes ajenos al mismo.</p><p>La implementación de la arquitectura hexagonal, junto con otras metodologías de arquitectura como DDD, <strong>asegura la estabilidad y escalabilidad a largo plazo</strong>, lo que aporta un valor significativo en el desarrollo de software en una gran empresa. En <a href="https://medium.com/u/c0bdc0808a57">Mercadona IT</a>, debido al volumen de microservicios que desarrollamos, que asciende a cientos, necesitamos facilitar y estandarizar esta implementación. Además, y como hemos comentado al principio de este artículo, el uso de la arquitectura hexagonal, también nos facilita mucho tener nuestros microservicios preparados para ser portables entre distintas infraestructuras nube.</p><p>Por esta razón y teniendo en cuenta el valor que aporta en relación con el esfuerzo adicional que conlleva implementar el patrón de arquitectura hexagonal hemos decidido crear un <strong>scaffolding homogéneo</strong> que la implemente. Este scaffolding se ofrece a todos los desarrolladores a través de nuestro <strong>Framework Spring Boot</strong>, mediante un arquetipo de proyecto multimódulo diseñado específicamente para este propósito. Por último, cabe destacar la labor de formación interna que estamos impulsando internamente desde los <em>Solutions Architects</em>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3ed47e6c957d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/mercadonait/atravesando-el-hex%C3%A1gono-de-la-arquitectura-de-software-3ed47e6c957d">Atravesando el hexágono de la arquitectura de software</a> was originally published in <a href="https://medium.com/mercadonait">Mercadona IT</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>