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

Clase 12 de 30 • Curso de Go Intermedio: Programación Orientada a Objetos y Concurrencia

Resumen

¿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.

Sebastián Rodrigo Díaz

student•

Pienso que pasar de interfaces a abstact factory fue demasiado rápido, tuve que hacer un curso del patron factory para poder entender esta clase de verdad. Pienso que, aunque se agradece la rapidez en los contenidos, se hace complejo cuando los temas cambian tan abruptamente

José Martínez Santana

student•

Tienes razón

Juan Manuel Ocampo

student•

Hola Sebastián, ¿podrías compartir el link del curso de patrones?

Juan Camilo Sarmiento Reyes

student•

🐱‍💻 ¡Hola comunidad!, hice un repositorio realizando el ejercicio del patrón con unas cuantas modificaciones, espero les sirva, éxitos :D

https://github.com/juancsr/go-patterns/tree/main/abstract-factory

Cristian Rodriguez Morales

student•

Me gusto mucho, yo estoy iniciando y agradezco que te esforzaras para que yo lo pudiera ver, pude resolver un error gracias a tu codigo.

Osman Edmundo Ulloa Vásquez

student•

que buen aporte !

Cristian Córdova

student•

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

student•

Muchas gracias.

Juan Pablo Muñoz

student•

En este canal de youtube en español explican muy bien los patrones de diseño diferentes que hay, entre ellos el Abstract Factory. Recomendadisimo. Patrones de diseño - Bettatech🍕

Andres Fajardo

student•

Gracias por el dato, para mi es un tema complejo que me imagino que en un proyecto necesitará de todo un proceso para implementarlo.

David Vergara

student•

Gracias me sirvió mucho para entender

fredic yohany rojas

student•

No entendi ni madres

Cristian Francisco Meoño Canel

student•

Una pequeña analogía de como funciona este patrón de diseño

Andres felipe Rojas parra

student•

esto de abstract factory es complicar las cosas sin necesidad o es que platzi eligio el peor ejemplo que pudo?

Lorena Cardona Tovar

student•

😃 De pronto si tienen dudas con el "_", es el identificador en blanco. Lo que significa que se descarta el valor que debería asignarse o en otras palabras use '’ para ignorar dicha variable.

Algunos lugares donde lo usamos:

Una función devuelve un valor y no tiene la intención de usarlo en el futuro

Quiere iterar y necesita un valor “X” que no utilizará.

Lucas Espinosa

student•

Excelente la aplicación practica sobre temas tan importantes como patrones de diseños

fabio andres zamora osorio

student•

Mala metodologia de enseñamza en esta clase y la anterior donde se explica el patron de diseño abstract factory. el profesor debio abordar el tema de otra forma. En mi opinion el profesor debio explicar el tema asi: . 1- primero debio explicar de una forma mas clara que es un patron de diseño y para que sirve ya que aunque en las clases lo explica no lo hace de forma clara. Entiendo que el enfoque del curso no son los patrones de diseño y que la intencion era explicar ese tema de forma introductoria lo cual me parece bien pero el error es que dicha explicacion introductoria no fue clara. . 2- el profesor debio haber usado diagramas de clases uml u otro tipo de diagrama que sirvan como guia para crear el codigo de los structs e interfaces ya que con un diagrama se puede mostrar visualmente como interactuan los structs e interfaces entre si lo cual facilita entender el tema y crear el codigo. Aunque en go no hay clases sino structs pienso que un diagrama de clases uml igual serviria para explicar mejor el tema.

Santiago Ortiz Ceballos

student•

Por qué en Go no se pueden separar paquetes por carpetas? acaso es tan dificil modularizar el código? visualmente es dificil de entender cuando se tiene todo revuelto habiendo podido crear lo del email en un archivo y lo del sms en otro :c

Erick Fariñas

student•

Excelente clase, de mis favoritas de este curso, es muy completa y se explica muy bien la finalidad

Eduardo Rodriguez Cisneros

student•

Es muy gracioso que justo en el trabajo desarrollé un micro servicio de mensajería pero, viendo este patrón de diseño, veo que tengo muchas áreas de mejora.

Platzi Team

student•

Creo que Platzi no lee los comentarios :(

Platzi Team

student•

Esta clase en mi concepto se pudo haber presentado de una mejor forma para un mayor entendimiento, colocan todo en el main y se vuelve una locura seguir el codigo.

Carlos Nassif Trejo Garcia

student•

Utilice switch en el getNotificationFactory, y cambie algunas cosas :P

package main

import "fmt"

// Abstract Factory

type INotificationFactory interface {
	SendNotification()
	GetSender() ISender
}

type ISender interface {
	GetSenderMethod() string
	GetSenderChannel() string
}

// SMS Sender
type SMSNotification struct {
}

func (SMSNotification) SendNotification() {
	println("Sending SMS Notification")
}

func (SMSNotification) GetSender() ISender {
	return SMSNotificationSender{}
}

type SMSNotificationSender struct {
}

func (SMSNotificationSender) GetSenderMethod() string {
	return "SMS"
}

func (SMSNotificationSender) GetSenderChannel() string {
	return "Twilio"
}

// Email Sender
type EmailNotification struct {
}

func (EmailNotification) SendNotification() {
	println("Sending Email Notification")
}

func (EmailNotification) GetSender() ISender {
	return EmailNotificationSender{}
}

type EmailNotificationSender struct {
}

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

func (EmailNotificationSender) GetSenderChannel() string {
	return "SES"
}

func getNotificationFactory(notificationType string) (INotificationFactory, error) {
	switch notificationType {
	case "SMS":
		return &SMSNotification{}, nil
	case "Email":
		return &EmailNotification{}, nil
	default:
		return nil, fmt.Errorf("notification type invalid")
	}
}

func sendNotification(f INotificationFactory) {
	f.SendNotification()
	sender := f.GetSender()
	fmt.Printf("Sender: %s, Channel: %s\n", sender.GetSenderMethod(), sender.GetSenderChannel())
}

func getMethod(f INotificationFactory) {
	fmt.Println(f.GetSender().GetSenderMethod())
}

func getChannel(f INotificationFactory) {
	fmt.Println(f.GetSender().GetSenderChannel())
}

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

	sendNotification(smsFactory)
	sendNotification(emailFactory)

	getMethod(smsFactory)
	getMethod(emailFactory)

	getChannel(smsFactory)
	getChannel(emailFactory)
}

Cristian Henao

student•

Gran clase, quizás si uno no tiene el concepto claro de abstract factory puede ser confuso, puedes echarle una mirada en esta página [gurú pattern design](https://refactoring.guru/es/design-patterns/factory-method) 

Francisco Alejandro Gutierrez Flores

student•

Les comparto una propuesta para crear métodos donde la interface se asigna como receptor del método en lugar de pasar como argumento

package main

import (
	"fmt"
	"math"
	"reflect"
)

// Definición de la interfaz figura
type figura interface {
	CalcularArea() float64
	GetProps() string
}

// Definición de la estructura Figura que embebe la interfaz figura
type Figura struct {
	figura
}

// Método para imprimir la informacion incluyendo el área de una figura definido para la estructura Figura
func (f *Figura) ImprimirInfo() {
	// Se imprime el tipo de la figura, sus propiedades y el área calculada
	fmt.Printf("%s, %s, Área: %.1f \n", reflect.TypeOf(f.figura).Elem().Name(), f.GetProps(), f.CalcularArea())
}

// Definición de la estructura Circulo
type Circulo struct {
	// Radio del círculo
	Radius float64
}

// Método para calcular el área de un círculo
func (c *Circulo) CalcularArea() float64 {
	return math.Pi * c.Radius * c.Radius
}

func (c *Circulo) GetProps() string {
	return fmt.Sprintf("Radio: %v", c.Radius)
}

// Definición de la estructura Cuadrado
type Cuadrado struct {
	// Lado del cuadrado
	Side float64
}

// Método para calcular el área de un cuadrado
func (s *Cuadrado) CalcularArea() float64 {
	return s.Side * s.Side
}

func (s *Cuadrado) GetProps() string {
	return fmt.Sprintf("Lado: %v", s.Side)
}

// Definición de la estructura Triangulo
type Triangulo struct {
	// Base del triángulo
	Base float64
	// Altura del triángulo
	Height float64
}

// Método para calcular el área de un triángulo
func (t *Triangulo) CalcularArea() float64 {
	return 0.5 * t.Base * t.Height
}

func (t *Triangulo) GetProps() string {
	return fmt.Sprintf("Base: %v, Altura: %v", t.Base, t.Height)
}

func main() {
	// Creación de instancias de las diferentes figuras en un slice de *Figura
	figuras := []*Figura{
		{&Circulo{Radius: 5}},
		{&Cuadrado{Side: 14}},
		{&Circulo{Radius: 20}},
		{&Cuadrado{Side: 4}},
		{&Triangulo{Base: 3, Height: 6}},
		{&Triangulo{Base: 5, Height: 3}}}

	// Iteración sobre las figuras
	for _, figura := range figuras {
		// Llamada al método ImprimirArea de la estructura Figura que embebe la interfaz figura
		figura.ImprimirInfo()
	}
}

Juan Camilo Colorado Cardona

student•

Este ejmplo de aca les puede ayudar mucho a entender: https://refactoring.guru/es/design-patterns/abstract-factory/go/example

Julian Torres

student•

Considero que hay mejores maneras de implementar el Abstract Factory

Wolsey Osmin Rubio Gil

student•

Se podría manejar asi:

func sendNotifications(factories ...INotificationFactory) {
	for _, factory := range factories {
		factory.SendNotification()
	}
}```