Multihilo

Es importante notar que, en un entorno multihilo, cada thread podría obtener una nueva instancia. Para asegurarse de que la operación sea thread safe, se deberá utilizar «syncronized».

Ejemplo de Singleton en Java

En general, hay 3 condiciones:

Se puede inicializar de dos maneras, Lazy o Eager.

• Hacer privado el constructor
• Asegurarse de que la variable con la instancia sea static
• Proveer un método public static

A continuación un ejemplo de cada una.

Singleton con Lazy Initialization

En este caso, la instancia de la clase Singleton se crea solo cuando es requerida, es decir, cuando se llama al método getInstance() por primera vez. Esto puede ser útil si la creación de la instancia es costosa en términos de recursos o tiempo.

public class SingletonLazy {

    // Instancia única de la clase, inicialmente nula
    private static SingletonLazy instancia;

    // Constructor privado para evitar instanciación desde fuera
    private SingletonLazy() {
        // Inicialización de recursos si es necesario
    }

    // Método público para obtener la instancia única de la clase
    public static SingletonLazy getInstance() {
        if (instancia == null) {
            instancia = new SingletonLazy();
        }
        return instancia;
    }

    // Método de ejemplo en la clase Singleton
    public void mostrarMensaje() {
        System.out.println("Hola desde Singleton con Lazy Initialization!");
    }
}

Uso del Singleton con Lazy Initialization:

public class Main {
    public static void main(String[] args) {
        SingletonLazy singleton = SingletonLazy.getInstance();
        singleton.mostrarMensaje();
    }
}

En este ejemplo, la instancia de SingletonLazy solo se crea cuando se llama al método getInstance() por primera vez. Si el método nunca es llamado, la instancia nunca se crea.

Singleton con Eager Initialization

En el caso de Eager Initialization, la instancia de la clase Singleton se crea en el momento en que se carga la clase. Esto asegura que la instancia esté disponible inmediatamente, pero también significa que se creará incluso si nunca se utiliza, lo que puede ser un desperdicio de recursos en algunos casos.

public class SingletonEager {

    // Instancia única de la clase, creada al cargar la clase
    private static final SingletonEager instancia = new SingletonEager();

    // Constructor privado para evitar instanciación desde fuera
    private SingletonEager() {
        // Inicialización de recursos si es necesario
    }

    // Método público para obtener la instancia única de la clase
    public static SingletonEager getInstance() {
        return instancia;
    }

    // Método de ejemplo en la clase Singleton
    public void mostrarMensaje() {
        System.out.println("Hola desde Singleton con Eager Initialization!");
    }
}

Uso del Singleton con Eager Initialization:

public class Main {
    public static void main(String[] args) {
        SingletonEager singleton = SingletonEager.getInstance();
        singleton.mostrarMensaje();
    }
}

En este ejemplo, la instancia de SingletonEager se crea en el momento en que la clase es cargada por el JVM, incluso si nunca se utiliza. Esto asegura que la instancia esté disponible inmediatamente, pero podría ser ineficiente si la instancia nunca es necesaria.

Conclusión

• Lazy Initialization: La instancia se crea solo cuando es necesario, lo que puede ahorrar recursos si la instancia no siempre se usa.
• Eager Initialization: La instancia se crea tan pronto como se carga la clase, lo que asegura que esté disponible de inmediato, pero puede ser menos eficiente si la instancia no es utilizada.

Ejemplo de Singleton en Spring Boot

En Spring Boot, el patrón Singleton es implementado por defecto en los beans de Spring, ya que los beans son Singleton por defecto. Aquí tienes un ejemplo simple:

import org.springframework.stereotype.Service;

@Service
public class SingletonService {

    // Método de ejemplo en el bean Singleton
    public void mostrarMensaje() {
        System.out.println("Hola desde Singleton en Spring Boot!");
    }
}

Uso del Singleton en Spring Boot:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication implements CommandLineRunner {

    @Autowired
    private SingletonService singletonService;

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

    @Override
    public void run(String... args) throws Exception {
        singletonService.mostrarMensaje();
    }
}

En este ejemplo:

• La clase SingletonService es un bean administrado por Spring.
• La anotación @Service indica que esta clase es un servicio de Spring, y Spring la manejará como un Singleton.
• En la clase principal DemoApplication, el SingletonService se inyecta utilizando @Autowired, asegurando que la misma instancia se utiliza en todo el ciclo de vida de la aplicación.

Conclusión

El patrón Singleton es ampliamente utilizado cuando se necesita garantizar que una clase tenga una única instancia en toda la aplicación. En Java puro, se implementa de forma explícita, mientras que en Spring Boot, los beans ya son Singleton por defecto, lo que simplifica su uso y gestión.

¿Cómo Funciona el Patrón Builder?

El patrón Builder se estructura generalmente en cuatro componentes clave:

1. Producto (Product): El objeto complejo que se va a construir.
2. Builder: Una interfaz que define los métodos necesarios para construir las partes del Producto.
3. Concrete Builder: Implementa la interfaz Builder y construye la representación concreta del Producto.Imaginemos que estamos construyendo una pizza con diferentes configuraciones, como Pizza Margarita y Pizza Pepperoni. Aquí se muestra cómo implementar el patrón Builder en Java para este caso:
4. Director: Controla el proceso de construcción, orquestando el orden en que se invocan los métodos del Builder.

Ejemplo Práctico: Construcción de una Pizza

Imaginemos que estamos construyendo una pizza con diferentes configuraciones, como Pizza Margarita y Pizza Pepperoni. Aquí se muestra cómo implementar el patrón Builder en Java para este caso:

Ventajas del uso de @Builder en Lombok:
Código más limpio y legible: No es necesario implementar manualmente el constructor, métodos setters o getters. Lombok se encarga de generar todo eso.
Inmutabilidad: Los objetos creados con el patrón Builder suelen ser inmutables, lo que aumenta la seguridad y consistencia en la gestión de datos.
Fluidez en la creación de objetos: Permite la creación de objetos de manera fluida, estableciendo solo los valores necesarios.

Explicación del Ejemplo

En este ejemplo, hemos construido una Pizza utilizando el patrón Builder.

• Producto: La clase Pizza representa el objeto complejo que queremos construir.
• Builder: La interfaz PizzaBuilder define los pasos necesarios para construir una pizza, como setMasa, setSalsa y setIngredientes.
• Concrete Builder: La clase PizzaMargaritaBuilder implementa la interfaz PizzaBuilder y construye una pizza específica, en este caso, una Pizza Margarita.
• Director: La clase PizzaDirector controla el proceso de construcción. En el método makeMargarita, se define cómo se construye una Pizza Margarita paso a paso.

El patrón Builder es un patrón de diseño creacional que permite construir objetos complejos paso a paso, proporcionando una interfaz fluida y flexible para configurar las propiedades de un objeto antes de su construcción final. Esto es particularmente útil cuando un objeto tiene muchos parámetros opcionales o configuraciones complejas, evitando la creación de múltiples constructores o un código con parámetros largos.

Implementación del patrón Builder con Lombok

Lombok es una biblioteca para Java que reduce el código repetitivo mediante anotaciones. En el caso del patrón Builder, Lombok proporciona la anotación @Builder, la cual simplifica la implementación de este patrón al generar automáticamente el código necesario.

Ejemplo de uso del patrón Builder con Lombok

import lombok.Builder;
import lombok.ToString;

@Builder
@ToString
public class Persona {
    private String nombre;
    private int edad;
    private String direccion;
}

Creación de un objeto con el patrón Builder

public class Main {
    public static void main(String[] args) {
        Persona persona = Persona.builder()
                                .nombre("Juan")
                                .edad(30)
                                .direccion("Calle Falsa 123")
                                .build();
    }
}

Explicación

• La anotación @Builder genera un builder para la clase Persona, permitiendo construir objetos con una sintaxis fluida.
• La anotación @ToString genera automáticamente el método toString(), que facilita la impresión de los valores del objeto.

Beneficios del Patrón Builder

• Flexibilidad: Puedes crear diferentes versiones de un objeto complejo usando el mismo código de construcción.
• Claridad: La separación de la construcción y la representación permite que el código sea más claro y manejable.
• Control: El Director garantiza que el objeto se construya de manera coherente y en el orden correcto

Código disponible en Github