DEV Community: Edwin Zamora

🧠 Demystifying the Factory Method Pattern with a Manabita Twist

Edwin Zamora — Fri, 12 Sep 2025 23:25:21 +0000

Hello, let's dive into the fascinating world of design patterns. We'll start with one of the most useful and simple ones to get started: the Factory Method.

Throughout this post, we'll look at the theory, a practical example, and best of all, we'll "ground" it with a 100% Ecuadorian use case.

What is the Factory Method and How Does It Work?

The Factory Method is a creational design pattern that solves the problem of creating objects without specifying their concrete classes. Sound complicated? Not at all.

Imagine you have a class that needs to create objects, but it doesn't know exactly which ones it will create. It might depend on a configuration, parameters, or the environment. Instead of filling your code with if-else or switch statements to instantiate each object with new, you delegate that responsibility to a special method: the factory method.

This gives us incredible flexibility, as the main code works with a common interface and doesn't care about the specific implementation of the object it receives.

How Could I Use It? The Classic Example: A Payment System

In our project, we have a perfect example that simulates a payment system.

The Product (Payment): First, we define an interface that establishes the contract. All payment methods must have a way to "make the payment".

// src/main/java/ec/com/pattern/creational/factorymethod/payment/Payment.java
public interface Payment {
    void doPayment();
}

The Concrete Products (CardPayment, GooglePayment): Next, we create the classes that implement that interface. Each one represents a specific type of payment.

// src/main/java/ec/com/pattern/creational/factorymethod/payment/CardPayment.java
public class CardPayment implements Payment {
    public void doPayment() {
        System.out.println("Making payment with Card");
    }
}

The Factory (PaymentFactory): Here's the magic. We create a class whose sole job is to create and return the correct object based on a parameter.

// src/main/java/ec/com/pattern/creational/factorymethod/payment/PaymentFactory.java
public class PaymentFactory {
    public static Payment buildPayment(TypePayment typePayment) {
        switch (typePayment) {
            case CARD:
                return new CardPayment();
            case GOOGLE:
                return new GooglePayment();
            case PAYPAL:
                return new PaypalPayment();
            default:
                throw new IllegalArgumentException("No such payment");
        }
    }
}

🔹 Simple Explanation with a Real-World Example

Imagine you work at a bank:

The customer chooses to pay with a card, Google Pay, or PayPal.
The factory (PaymentFactory) receives that information (the TypePayment enum).
The factory creates the appropriate object:
- If it's CARD → returns a CardPayment.
- If it's GOOGLE → returns a GooglePayment.
- If it's PAYPAL → returns a PaypalPayment.
The system calls doPayment() regardless of the payment type, because all classes implement the same Payment interface.

👉 In summary:

This diagram shows a Factory pattern where a factory centralizes the creation of different payment types, using an enum to decide which concrete class to instantiate.

Adapting It "to the Local Style": A Seafood Restaurant in Manabí

Now, let's get to our own thing! Let's forget about payments and technology for a moment and think about something that defines us: food.

Imagine we're building the software for a seafood restaurant in Portoviejo. In Manabí, the same dish can have variations. For example, a "ceviche" can be made with fish, shrimp, or a mix. They are all ceviches, but they are prepared slightly differently.

This is where the Factory Method shines.

💻 Example Source Code

You can find all the code for this example in the project folder on GitHub:

See the code for the Manabita Ceviche example

File Structure (example)

src/
 ├─ Ceviche.java                # product interface
 ├─ CevicheType.java            # enum with types
 ├─ FishCeviche.java
 ├─ ShrimpCeviche.java
 ├─ MixedCeviche.java
 ├─ JipijapaCeviche.java
 └─ ManabitaRestaurantFactory.java

🧠 Desmitificando el Patrón Factory Method con un Toque Manabita

Edwin Zamora — Fri, 12 Sep 2025 23:18:57 +0000

¡Hola, vamos a sumergirnos en el fascinante mundo de los patrones de diseño. Empezaremos con uno de los más útiles y sencillos para iniciarse: el Factory Method (Método de Fábrica).

A lo largo de este post, veremos la teoría, un ejemplo práctico y, lo mejor de todo, lo "aterrizaremos" con un caso de uso 100% ecuatoriano.

¿Qué es y cómo funciona el Factory Method?

El Factory Method es un patrón de diseño creacional que resuelve el problema de crear objetos sin especificar sus clases concretas. ¿Suena complicado? Para nada.

Imagina que tienes una clase que necesita crear objetos, pero no sabe exactamente cuáles creará. Dependerá de una configuración, de parámetros o del entorno. En lugar de llenar tu código con if-else o switch para instanciar cada objeto con new, delegas esa responsabilidad a un método especial: el método de fábrica.

Esto nos da una flexibilidad increíble, ya que el código principal trabaja con una interfaz común y no le importa la implementación específica del objeto que recibe.

¿Cómo lo podría usar? El Ejemplo Clásico: Un Sistema de Pagos

En nuestro proyecto, tenemos un ejemplo perfecto que simula un sistema de pagos.

El Producto (Payment): Primero, definimos una interfaz que establece el contrato. Todos los métodos de pago deben tener una forma de "hacer el pago".
```
// src/main/java/ec/com/pattern/creational/factorymethod/payment/Payment.java
public interface Payment {
    void doPayment();
}
```

Los Productos Concretos (CardPayment, GooglePayment): Luego, creamos las clases que implementan esa interfaz. Cada una representa un tipo de pago específico.

// src/main/java/ec/com/pattern/creational/factorymethod/payment/CardPayment.java
public class CardPayment implements Payment {
    public void doPayment() {
        System.out.println("Making payment with Card");
    }
}

La Fábrica (PaymentFactory): Aquí está la magia. Creamos una clase cuyo único trabajo es crear y devolver el objeto correcto según un parámetro.

// src/main/java/ec/com/pattern/creational/factorymethod/payment/PaymentFactory.java
public class PaymentFactory {
    public static Payment buildPayment(TypePayment typePayment) {
        switch (typePayment) {
            case CARD:
                return new CardPayment();
            case GOOGLE:
                return new GooglePayment();
            case PAYPAL:
                return new PaypalPayment();
            default:
                throw new IllegalArgumentException("No such payment");
        }
    }
}

🔹 Explicación simple con un ejemplo del mundo real

Imagina que trabajas en un banco:

El cliente elige pagar con tarjeta, Google Pay o PayPal.
La fábrica (PaymentFactory) recibe esa información (el TypePayment enum).
La fábrica crea el objeto apropiado:
- Si es CARD → devuelve un CardPayment.
- Si es GOOGLE → devuelve un GooglePayment.
- Si es PAYPAL → devuelve un PaypalPayment.
El sistema llama a doPayment() sin importar el tipo de pago, porque todas las clases implementan la misma interfaz Payment.

¿Cómo se usa la fábrica?

El código que necesita un objeto de pago (el "cliente") ya no tiene que saber cómo crear un CardPayment o un GooglePayment. Simplemente le pide a la fábrica el tipo que necesita y trabaja con la interfaz Payment.

public class Main {
    public static void main(String[] args) {
        // El cliente solo pide el tipo de pago que quiere
        Payment payment = PaymentFactory.buildPayment(TypePayment.CARD);
        payment.doPayment(); // Salida: Making payment with Card
    }
}

👉 En resumen:

Este diagrama muestra un patrón Factory donde una fábrica centraliza la creación de diferentes tipos de pago, usando un enum para decidir qué clase concreta instanciar.

Adaptándolo "a lo Criollo": Una Picantería en Manabí

Ahora, ¡vamos a lo nuestro! Olvidémonos de los pagos y la tecnología por un momento y pensemos en algo que nos identifica: la comida.

Imagina que estamos montando el software para una picantería en Portoviejo. En Manabí, un mismo plato puede tener variaciones. Por ejemplo, un "ceviche" puede ser de pescado, de camarón, o mixto. Todos son ceviches, pero se preparan de forma ligeramente distinta.

Aquí es donde el Factory Method brilla.

💻 Código Fuente del Ejemplo

Puedes encontrar todo el código de este ejemplo en la carpeta del proyecto en GitHub:

Ver el código del ejemplo del Ceviche Manabita

Estructura de archivos (ejemplo)

src/
 ├─ Ceviche.java                # interfaz producto
 ├─ CevicheType.java            # enum con tipos
 ├─ FishCeviche.java
 ├─ ShrimpCeviche.java
 ├─ MixedCeviche.java
 ├─ JipijapaCeviche.java
 └─ ManabitaRestaurantFactory.java

🧠 Microservice with Hexagonal Architecture using AI (Copilot + Gemini + Spring Boot)

Edwin Zamora — Sat, 12 Jul 2025 19:41:39 +0000

🚀 Introduction

This article explores how to build a back-end microservice using only free AI tools through custom instructions.
The goal is to demonstrate how convenient and powerful it can be to use AI to generate professionally structured projects, without manually writing every line of code.

👁️ What do I want to prove?

How far can we go building a professional microservice with AI as our co-pilot?
In this case, we used Gemini and Copilot for the development and implementation of the software.

This experiment shows that AI, when properly guided, can assist technical development without replacing the programmer. It works as a "technical assistant" that responds to our custom instructions, helping to apply best practices and maintain design quality.

📖 Core Reference: Hexagonal Architecture Explained

For a foundational understanding of hexagonal architecture, this project is based on the excellent article by Arho Huttunen:
🔗 Hexagonal Architecture with Spring Boot – arhohuttunen.com

🧡 What's included in this POC?

🧹 Hexagonal architecture: decoupled inputs/outputs, clean domain.
☕ Spring Boot 3 with professional dependencies.
🐳 Containers with Docker Compose and MySql.
🔁 DTO ↔ Entity mapping with MapStruct.
🧪 Unit tests with JUnit and Mockito.
📘 Documentation with Swagger/OpenAPI.
🤖 Generated using AI: GitHub Copilot and Gemini.

🔗 View the repository: github.com/edzamo/coffee-shop-hexagonal-con-IA

🧠 How to generate structured code with AI

Using AI to code isn't just about asking for code.
It's about teaching it the context of your project, guiding it with clear prompts, and reviewing each response critically.

During this development, I discovered that AI can:

Understand complex patterns like hexagonal architecture.
Generate coherent and well-named classes.
Suggest effective unit tests.
Validate project designs and structures.

💡 Tip: if you define your own prompts and folder structures (like in .heHexaBarista), you can turn AI into a real technical co-pilot.

✨ The deep benefit of using AI in software development

Tools like Copilot and Gemini not only speed up work, but also help maintain code consistency and quality.

They become constant technical assistants that:

🧠 Reduce repetitive effort.
⚙️ Respect your style and conventions.
🚀 Let you focus on business logic and architecture decisions.

The key is to use custom instructions and provide technical context. This way, AI stops being generic and becomes a highly productive tool.

🛑 AI doesn't replace the developer, it empowers them.

🛠️ How to practice with AI while coding

Personal recommendations to take advantage of AI in real projects:

💡 Start with simple projects and apply real patterns (like MVC or hexagonal architecture).
🤭 Provide context: class names, folder structure, conventions.
✍️ Use clear and step-by-step prompts, as if explaining to a junior.
🧪 Review everything the AI generates. Learn from its mistakes and successes.
📁 Define a clear structure (adapters, ports, domain) so AI can understand it easily.

🧾 Conclusion

This project not only demonstrates a functional architecture, but also how to integrate AI into a professional development workflow.
When properly guided, AI allows you to develop faster without sacrificing design or quality.

If you want to try it yourself:

Explore the .heHexaBarista folder.
Install GitHub Copilot or Gemini.
Build with AI as your technical ally. 🚀

🧠 Microservicio con arquitectura hexagonal usando IA (Copilot + Gemini + Spring Boot)

Edwin Zamora — Sat, 12 Jul 2025 19:03:29 +0000

🚀 Introducción

Este artículo explora cómo construir un microservicio back-end utilizando únicamente herramientas de IA gratuitas, a través de instrucciones personalizadas.

El objetivo es demostrar lo cómodo y poderoso que puede ser el uso de IA para generar proyectos estructurados profesionalmente, sin necesidad de escribir cada línea de código manualmente.

📖 Referencia principal: Arquitectura Hexagonal explicada

Para entender el enfoque base de este proyecto, revisa este excelente artículo:

🔗 arhohuttunen.com/hexagonal-architecture-spring-boot

👁️‍🗨️ ¿Qué quiero probar?

¿Hasta dónde podemos llegar construyendo un microservicio profesional con IA como copiloto?

En este caso, usamos Gemini y Copilot para el desarrollo e implementación del software.

Este experimento demuestra que la IA, bien guiada, puede acompañar el desarrollo técnico sin reemplazar al programador. Funciona como un “asistente técnico” que responde a nuestras instrucciones personalizadas, ayudando a aplicar buenas prácticas y mantener la calidad del diseño.

🧱 ¿Qué contiene este POC?

🧩 Arquitectura hexagonal: entradas/salidas desacopladas, dominio limpio.
☕ Spring Boot 3 con dependencias profesionales.
🐳 Contenedores con Docker Compose y MySql.
🔁 Mapeo DTO ↔ Entidades con MapStruct.
🧪 Pruebas unitarias con JUnit y Mockito.
📘 Documentación con Swagger/OpenAPI.
🤖 Generado usando IA: GitHub Copilot y Gemini.

🔗 Ver el repositorio: github.com/edzamo/coffee-shop-hexagonal-con-IA

🧠 Cómo generar código estructurado con IA

Usar IA para codificar no se trata simplemente de pedirle código.

Es enseñarle el contexto de tu proyecto, guiarla con prompts claros, y revisar cada respuesta con sentido crítico.

Durante este desarrollo, descubrí que la IA puede:

Entender patrones complejos como la arquitectura hexagonal.
Generar clases coherentes y bien nombradas.
Sugerir pruebas unitarias efectivas.
Validar diseños y estructuras del proyecto.

💡 Tip: si defines tus propios prompts y estructuras de carpetas (como en .heHexaBarista), puedes convertir a la IA en una copiloto técnica real.

✨ El profundo beneficio de usar la IA al desarrollar software

Herramientas como Copilot y Gemini no solo aceleran el trabajo, sino que también ayudan a mantener la coherencia y calidad en el código.

Se convierten en asistentes técnicos constantes que:

🧠 Disminuyen el esfuerzo repetitivo.
⚙️ Respetan tu estilo y convenciones.
🚀 Te permiten concentrarte en la lógica de negocio y decisiones de arquitectura.

La clave está en usar instrucciones personalizadas y brindar contexto técnico. Así, la IA deja de ser genérica y se convierte en una herramienta altamente productiva.

🛑 La IA no reemplaza al desarrollador, lo potencia.

🛠️ Cómo practicar con IA al codificar

Recomendaciones personales para aprovechar IA en proyectos reales:

💡 Empieza con proyectos simples y aplica patrones reales (como MVC o arquitectura hexagonal).
🧭 Dale contexto: nombres de clases, estructura de carpetas, convenciones.
✍️ Usa prompts claros y paso a paso, como si explicaras a un junior.
🧪 Revisa todo lo que genere la IA. Aprende de sus errores y aciertos.
📁 Define una estructura clara (adaptadores, puertos, dominio) para que la IA la entienda fácilmente.

🧾 Conclusión

Este proyecto no solo demuestra una arquitectura funcional, sino también cómo integrar IA en un flujo de trabajo profesional.

Cuando se le guía bien, la IA permite desarrollar más rápido sin sacrificar diseño ni calidad.

Si quieres probarlo tú mismo:

Explora la carpeta .heHexaBarista.
Instala GitHub Copilot o Gemini.
Crea con IA como tu aliada técnica. 🚀