Implementación del Patrón Factory en Go para Notificaciones

Curso de Go Intermedio: Programación Orientada a Objetos y Concurrencia

Contenido del curso

Introducción

Programación orientada a objetos

Go Modules

Testing

Concurrencia

Proyecto: servidor con worker pools

Conclusión

30
Resumen del Curso Avanzado de Go: Módulos, Tests y Concurrencia
02:34 min

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0010:10

Implementación del Patrón Factory en Go para Notificaciones

Curso de Go Intermedio: Programación Orientada a Objetos y Concurrencia

Clase 12 de 30

Clase 12 / 30

Recursos

¿Cómo implementar el patrón de diseño de notificación para email y SMS?

En el mundo del desarrollo de software, los patrones de diseño son esenciales para crear código reutilizable y escalable. Un ejemplo es el patrón de diseño de notificaciones que nos permite enviar mensajes de forma abstracta y concreta. Este enfoque es útil para ajustar diferentes métodos de envío, como SMS y Email, en una única arquitectura.

¿Cómo crear un tipo de notificación para email?

Comienza creando un tipo de notificación para email similar al SMS. Aquí, un tipo 'struct' de email notification será la base. Debes tener presente que todas las clases concretas deben seguir una interfaz común, la cual no define una forma específica en el código.

type EmailNotification struct{}

func (en EmailNotification) SendNotification() {
    fmt.Println("Sending Notification via Email")
}

¿Cuál es la función del 'iSender' en las notificaciones?

El siguiente paso clave es establecer un 'iSender' específico para el email, lo que implica crear un nuevo 'struct' llamado EmailNotificationSender. Este debe cumplir con la implementación de ciertos métodos para integrar sus funcionalidades adecuadamente.

type EmailNotificationSender struct{}

func (ens EmailNotificationSender) GetSenderMethod() string {
    return "Email"
}

func (ens EmailNotificationSender) GetSenderChannel() string {
    return "SES" // Asumiendo que usamos Amazon Simple Email Service
}

¿Cómo se implementa la interfaz INotificationFactory para gestionar errores?

La interfaz INotificationFactory se utiliza para retornar la clase concreta que se ocupará de enviar notificaciones. Implementar la gestión de errores en esta interfaz aseguró que manejemos adecuadamente los tipos incorrectos de notificaciones.

func GetNotificationFactory(notificationType string) (INotificationFactory, error) {
    if notificationType == "SMS" {
        return SMSNotification{}, nil
    } else if notificationType == "Email" {
        return EmailNotification{}, nil
    }
    return nil, fmt.Errorf("No Notification Type")
}

¿Cómo usar el patrón de diseño en el código sin conocer detalles internos?

Para culminar la implementación, necesitarás dos funciones: sendNotification y getMethod. Estas recibirán como parámetro una interfaz INotificationFactory. Esto permite que el código no necesite saber qué tipo de notificación específica se está utilizando. Lo que sigue es la función main donde el patrón de diseño se ejecuta.

func main() {
    smsFactory, _ := GetNotificationFactory("SMS")
    emailFactory, _ := GetNotificationFactory("Email")
    
    SendNotification(smsFactory)
    SendNotification(emailFactory)
}

func SendNotification(nf INotificationFactory) {
    nf.SendNotification()
}

func GetMethod(nf INotificationFactory) {
    fmt.Println(nf.GetSender().GetSenderMethod())
}

Implementar el patrón de diseño de notificaciones utilizando Go y interfaces permite la reutilización del código y facilita futuras ampliaciones de funcionalidades. Esta estructura modular es fundamental para mantener la calidad de las aplicaciones en crecimiento. Te animo a seguir explorando patrones de diseño para mejorar tu habilidad en programación.

Cristian Córdova

Hace 5 años

Buenas comunidad!

Les dejo el código de la clase con apuntes para indicar mejor lo que realiza cada parte del código. Además he añadido una función más que nos permite obtener el canal de envío de nuestros SMS/Emails :D

package main

import "fmt"

/*
**************************************************
Problema: Enviar notificaciones de Email y SMS.

Métodos/Formas de enviar la notificación:
- Email
- SMS

Canales/Tecnologías para enviar la notificación:
- Twilio (Para SMS)
- SES (Para Email)
**************************************************
*/

// Interfaz encargada enviar una notificación, según un método y un canal de envío.
type INotificationFactory interface {
	SendNotification()
	GetSender() ISender
}

// Interfaz que recoge el método y canal de envío.
type ISender interface {
	GetSenderMethod() string
	GetSenderChannel() string
}

/*
**********************************
	SMS
**********************************
*/
// STRUCT de SMS
type SMSNotification struct {
}

// Método de SMSNotification
func (SMSNotification) SendNotification() {
	fmt.Println("Sending Notification via SMS")
}

// Método de SMSNotification
func (SMSNotification) GetSender() ISender {
	return SMSNotificationSender{}
}

// STRUCT para el envío de notificaciones SMS
type SMSNotificationSender struct {
}

// Método de SMSNotificationSender
func (SMSNotificationSender) GetSenderMethod() string {
	return "SMS"
}

// Método de SMSNotificationSender
func (SMSNotificationSender) GetSenderChannel() string {
	return "Twilio"
}

/*
**********************************
	EMAIL
**********************************
*/
// STRUCT de Email
type EmailNotification struct {
}

// Método de EmailNotification
func (EmailNotification) SendNotification() {
	fmt.Println("Sending Notification via Email")
}

// Método de EmailNotification
func (EmailNotification) GetSender() ISender {
	return EmailNotificationSender{}
}

// STRUCT para el envío de notificaciones Email
type EmailNotificationSender struct {
}

// Método de EmailNotificationSender
func (EmailNotificationSender) GetSenderMethod() string {
	return "Email"
}

// Método de EmailNotificationSender
func (EmailNotificationSender) GetSenderChannel() string {
	return "SES"
}

/*
**********************************
	Funcionalidad
**********************************
*/
// Función que evalua el tipo de notificación que debe enviar
func getNotificationFactory(notificationType string) (INotificationFactory, error) {
	if notificationType == "SMS" {
		return &SMSNotification{}, nil
	}

	if notificationType == "Email" {
		return &EmailNotification{}, nil
	}

	return nil, fmt.Errorf("No Notification Type")
}

// Función que envía la notificación
func sendNotification(f INotificationFactory) {
	f.SendNotification()
}

// Función que escoge la forma/método por la que se enviará la notificación
func getMethod(f INotificationFactory) {
	fmt.Println(f.GetSender().GetSenderMethod())
}

// Función que escoge el canal/tecnología por la que se enviará la notificación
func getChannel(f INotificationFactory) {
	fmt.Println(f.GetSender().GetSenderChannel())
}

func main() {
	smsFactory, _ := getNotificationFactory("SMS")
	emailFactory, _ := getNotificationFactory("Email")

	getMethod(smsFactory)        // Recoge el método de Envío
	getChannel(smsFactory)       // Recoge el canal de Envío
	sendNotification(smsFactory) // Envía la notificación

	getMethod(emailFactory)        // Recoge el método de Envío
	getChannel(emailFactory)       // Recoge el canal de Envío
	sendNotification(emailFactory) // Envía la notificación
}

Braulio Valdés

Hace 4 años

Muchas gracias.

Comentarios (26)26 comentarios

Sebastián Rodrigo Díaz

José Martínez Santana

Juan Manuel Ocampo

Juan Camilo Sarmiento Reyes

Cristian Rodriguez Morales

Osman Edmundo Ulloa Vásquez

Juan Pablo Muñoz

Andres Fajardo

David Vergara

Hace 3 años

fredic yohany rojas

Cristian Francisco Meoño Canel

Andres felipe Rojas parra

Lorena Cardona Tovar

Lucas Espinosa

fabio andres zamora osorio

Cristian Aguirre

Hace 4 meses

Santiago Ortiz Ceballos

Erick Fariñas

Eduardo Rodriguez Cisneros

Platzi Team

Carlos Nassif Trejo Garcia

Oscar Giraldo Castillo

Hace 9 meses

Cristian Henao

Hace 2 años

Francisco Alejandro Gutierrez Flores

Juan Camilo Colorado Cardona

Introducción

Programación Orientada a Objetos y Concurrencia en Go

Concurrencia y Testing en Go: Go Routinas y Worker Pools

Fundamentos de Programación en Go: Structs, Apuntadores y Manejo de Errores

Go Routines, Canales y Apuntadores en Golang

Programación orientada a objetos

Programación Orientada a Objetos en Go: Análisis y Comparativa

Equivalente de Clases en Go: Uso de Structs y Propiedades

Métodos en Structs: Implementación de Receiver Functions en Go

Implementación de Constructores en Go: Ejemplos y Mejores Prácticas

Herencia y Composición en Programación Orientada a Objetos

Interfaces y Polimorfismo en TypeScript y Go

Patrón Abstract Factory: Interfaces y Polimorfismo en Go

Implementación del Patrón Factory en Go para Notificaciones

Funciones Anónimas en Go: Uso y Consideraciones Prácticas

Funciones Variádicas y Retornos con Nombre en Go

Go Modules

Manejo de Dependencias y Módulos en Go

Creación y Publicación de Módulos en GitHub con Go

Testing

Tests unitarios y code coverage en Go

Cobertura de Código y Testing en Go: Mejorando la Calidad del Software

Profiling de Código en Go para Optimización de Rendimiento

Testing Unitario en Go: Uso de Mock Services

Testeo Unitario de Funciones con MOOC en Go

Concurrencia

Canales con y sin buffer en Go: diferencias y uso práctico

Sincronización de Rutinas en Go con Wait Group

"Uso de Canales con Buffer como Semáforos en Go"

Manejo de Canales de Lectura y Escritura en Go

Concurrencia en Go: Creación de Worker Pools y Fibonacci

Multiplexación de Canales en Go con Select y Case

Proyecto: servidor con worker pools

Creación de un Web Server con Worker Pool en Go

Creación de un Servidor Web Concurrente con Go

Conclusión

Resumen del Curso Avanzado de Go: Módulos, Tests y Concurrencia

Implementación del Patrón Factory en Go para Notificaciones