Patrón Factory: Ventajas y Desventajas en Desarrollo de Software

Clase 11 de 27 • Curso de Patrones de Diseño en JavaScript

Resumen

¿Por qué es relevante el patrón Factory en el desarrollo de software?

El patrón Factory es un pilar en el diseño de software, especialmente cuando se busca un sistema robusto y flexible. Permite la creación de objetos concretos pero desde una capa de abstracción común, lo que ofrece ventajas al momento de construir aplicaciones complejas. Este enfoque reduce el alto acoplamiento entre los elementos creadores y los productos, es decir, mantiene la independencia de los componentes, facilitando su reutilización y mantenimiento.

¿Cuáles son las ventajas de utilizar el patrón Factory?

Desacoplamiento: La independencia entre los elementos creadores y los productos evita que cambios en uno afecten al otro, promoviendo un sistema más estable.
Responsabilidad unificada: Implementado como parte de los principios SOLID, el patrón Factory asegura que cada método o clase realiza una tarea específica. Las fábricas crean y retornan productos sin efectos secundarios.
Facilidad de extensión: Añadir nuevos productos o fábricas no requiere modificar las existentes, solo extenderlas. Esto apoya la extensibilidad, haciendo que el diseño de software sea elegante y escalable.

¿Cuáles son las desventajas del patrón Factory?

Código genérico en exceso: Si bien es simple añadir nuevos productos, crear nuevas fábricas para cada producto puede llevar a un código innecesariamente complejor, especialmente si se manejan productos en grandes cantidades.
Exceso de abstracciones: A veces, no es necesario utilizar tantas abstracciones, pudiendo resolverse con soluciones más directas, lo cual optimiza tiempo y recursos. Sin embargo, en sistemas grandes y complejos, las abstracciones son necesarias para el manejo eficiente del código.

¿Cuándo es ideal usar el patrón Factory?

Si no se conocen de antemano todos los productos necesarios

Cuando se espera que aparezcan nuevos productos sin un número exacto inicial, el patrón Factory brinda un marco flexible donde las nuevas incorporaciones son sencillas de integrar. Esto lo hace ideal para proyectos con requisitos fluctuantes o en crecimiento constante.

Al desacoplar la creación y el uso de productos

Una de las principales funcionalidades del patrón Factory es separar la lógica de creación de la utilización de los productos. Esto permite cambios en la implementación de los productos sin afectar las partes del código que los usan, manteniendo el sistema desacoplado y manejable.

Para extender bibliotecas o frameworks

En situaciones donde se necesite agregar funcionalidad adicional a bibliotecas existentes sin modificar su estructura interna, el patrón Factory es sumamente útil. Facilita la integración de nuevas características fácilmente en frameworks preexistentes mediante la implementación de comportamientos compartidos.

Ejemplo práctico: Adaptadores HTTP en NestJS

NestJS es un framework para la creación de aplicaciones de servidor que funciona perfectamente con Express. Sin embargo, también da la opción de usar Fastify gracias a la flexibilidad del patrón Factory. Ambos, Express y Fastify, pueden ser "inyectados" en NestJS porque implementan un contrato similar, demostrando cómo el patrón Factory permite cambiar entre diferentes opciones de librerías sin complicaciones.

Tu reto: Crear un adaptador HTTP

El desafío consiste en crear tu propio adaptador HTTP para NestJS utilizando un patrón Factory. Debes implementar métodos comunes como Get, Post, Put y Delete. La idea es asegurarse de que la estructura y los métodos cumplidos abran el camino para una futura innovación que permita quizás construir el próximo web framework de moda. Esta actividad estimula la comprensión profunda de cómo los patrones pueden ser aplicados en arquitecturas modernas y flexibles.

Andres Eduardo Maneiro Antunez

student•

No estoy seguro si asi consistia el reto pero ahi va mi solucion

/** STEP 1 */
class HttpAdapter {
    constructor(type) {
        this._type = type;
    }
    get() {
        throw new Error('Methor not implemented')
    }
    post() {
        throw new Error('Methor not implemented')
    }
    put() {
        throw new Error('Methor not implemented')
    }
    delete() {
        throw new Error('Methor not implemented')
    }
    getType() {
        return this._type;
    }
}

class Express extends HttpAdapter {
    constructor() {
        super('Express');
    }
    get() {
        console.log(`get Method for ${this._type} adapter`);
    }
    post() {
        console.log(`post Method for ${this._type} adapter`);
    }
    put() {
        console.log(`put Method for ${this._type} adapter`);
    }
    delete() {
        console.log(`delete Method for ${this._type} adapter`);
    }
}
class NestJs extends HttpAdapter {
    constructor() {
        super('NestJs');
    }
    get() {
        console.log(`get Method for ${this._type} adapter`);
    }
    post() {
        console.log(`post Method for ${this._type} adapter`);
    }
    put() {
        console.log(`put Method for ${this._type} adapter`);
    }
    delete() {
        console.log(`delete Method for ${this._type} adapter`);
    }
}

class HttpAdaptrFactory {
    makeAdapter() {
        throw new Error('Method not implement')
    }
}

class ExpressFactory extends HttpAdaptrFactory {
    makeAdapter() {
        return new Express();
    }
}

class NestJsFactory extends HttpAdaptrFactory {
    makeAdapter() {
        return new NestJs();
    }
}

function appAdapter (adapter) {
    const httpAdapter = adapter.makeAdapter()
    httpAdapter.get();
    httpAdapter.post();
    httpAdapter.put();
    httpAdapter.delete();
    console.log(httpAdapter.getType())
}

function createAdaper(type) {
    const adapters = {
        'express': ExpressFactory,
        'nestjs': NestJsFactory
    }
    
    const Adapters = adapters[type]
    return new Adapters()
}

appAdapter(createAdaper('express'))
appAdapter(createAdaper('nestjs'))

Enrique Aguilera

student•

interface HttpAdapterFactory {
    makeAdapter(): HttpAdapter
}

interface HttpAdapter {
    get(): void
    post(): void
    put(): void
    delete(): void
}

class ExpressAdapter implements HttpAdapter {
    get(): void {
        console.log('Express método get')
    }

    post(): void {
        console.log('Express método post')
    }

    put(): void {
        console.log('Express método put')
    }

    delete(): void {
        console.log('Express método delete')
    }
}

class FastifyAdapter implements HttpAdapter {
    get(): void {
        console.log('Fastify método get')
    }

    post(): void {
        console.log('Fastify método post')
    }

    put(): void {
        console.log('Fastify método put')
    }

    delete(): void {
        console.log('Fastify método delete')
    }
}

class ExpressFactory implements HttpAdapterFactory {
    makeAdapter(): HttpAdapter {
        return new ExpressAdapter()
    }
}

class FastifyFactory implements HttpAdapterFactory {
    makeAdapter(): HttpAdapter {
        return new FastifyAdapter()
    }
}

function appFactory(factory: HttpAdapterFactory): void {
    const adapter = factory.makeAdapter()
    adapter.get()
    adapter.post()
    adapter.delete()
}

function createFactory(type: 'express' | 'fastify'): HttpAdapterFactory {
    const factories = {
        express: ExpressFactory,
        fastify: FastifyFactory
    }

    const Factory = new factories[type]
    return Factory
}

appFactory(createFactory('express'))
appFactory(createFactory('fastify'))

Daniel Basulto

teacher•

Excelente Enrique!

Alvaro Eduardo Garzón Pira

student•

¡Hola! He dejado en mi repositorio en github el código del reto en typescript y en python, les dejo el link por si quieren echar un vistazo.

Miguel Ángel Garcia Beltran

student•

Aqui mi solución :D

// STEP 1:
abstract class HttpAdapter {
    public constructor(type: string) {}

    public abstract get(): void;
    public abstract post(): void;
    public abstract put(): void;
    public abstract delete(): void;
}

// STEP 2:
class ExpressHttpAdapter extends HttpAdapter {
    constructor() {
        super("Express");
    }

    get() {
        console.log("Express get method");
    }
    post() {
        console.log("Express post method");
    }
    put() {
        console.log("Express put method");
    }
    delete() {
        console.log("Express delete method");
    }
}

// STEP 3:
interface HttpAdapterFactory {
    makeAdapter(): HttpAdapter;
}

// STEP 4:
class ExpressHttpAdapterFactory implements HttpAdapterFactory {
    makeAdapter(): HttpAdapter {
        return new ExpressHttpAdapter();
    }
}

function clientApp() {
    const expressHttpAdapter = new ExpressHttpAdapter();
    expressHttpAdapter.get();
    expressHttpAdapter.post();
    expressHttpAdapter.put();
    expressHttpAdapter.delete();
}
clientApp();

Francisco Rappazzini

student•

Les dejo mi codigo en TypeScript por si les es de ayuda:

// creo la interface para los http adapter
interface IHttpAdapter {
  get(): void;
  post(): void;
  put(): void;
  delete(): void;
  getType(): void;
}

// implemento la interface para las class de http adapters
class RestHttpAdapter implements IHttpAdapter {
  private type: string = "REST";

  get() {
    console.log("Method get in " + this.type);
  }
  post() {
    console.log("Method post in " + this.type);
  }
  put() {
    console.log("Method put in " + this.type);
  }
  delete() {
    console.log("Method delete in " + this.type);
  }
  getType(): void {
    console.log(this.type);
  }
}

class SoapHttpAdapter implements IHttpAdapter {
  private type: string = "SOAP";

  get() {
    console.log("Method get in " + this.type);
  }
  post() {
    console.log("Method post in " + this.type);
  }
  put() {
    console.log("Method put in " + this.type);
  }
  delete() {
    console.log("Method delete in " + this.type);
  }
  getType(): void {
    console.log(this.type);
  }
}

// creo la interface factory
interface IHttpAdapterFactory {
  makeAdapter(): IHttpAdapter;
}

// implemento la interface factory para las class factory
class RestHttpAdapterFactory implements IHttpAdapterFactory {
  makeAdapter(): IHttpAdapter {
    return new RestHttpAdapter();
  }
}

class SoapHttpAdapterFactory implements IHttpAdapterFactory {
  makeAdapter(): IHttpAdapter {
    return new SoapHttpAdapter();
  }
}

// funciones para instanciar factories y http adapters
const appFactory2 = (factory: IHttpAdapterFactory) => {
  const httpAdapter = factory.makeAdapter();
  httpAdapter.getType();
  httpAdapter.get();
  httpAdapter.post();
  httpAdapter.put();
  httpAdapter.delete();
};

type HttpAdapterType = "rest" | "soap";

const createFactory2 = (type: HttpAdapterType) => {
  const factories = { rest: RestHttpAdapterFactory, soap: SoapHttpAdapterFactory };
  const Factory = factories[type];
  return new Factory();
};

appFactory2(createFactory2("rest"));
appFactory2(createFactory2("soap"));

Richar Arenas

student•

Mi solucion a la actividad

/*
    Creamos nuestra clase principal HTTPAdapter que será la encargada de 
    definir los métodos que se utilizarán en los adapters
*/

class HttpAdapter {
    type = undefined;

    constructor(type) {
        this.type = type;
    }

    getType() {
        throw new Error('Method not implemented');
    }

    get(url) {
        return `${this.type} Method GET: ${url}`;
    }

    post(url) {
        return `${this.type} Method POST: ${url}`;
    }

    put(url) {
        return `${this.type} Method PUT: ${url}`;
    }

    delete(url) {
        return `${this.type} Method DELETE: ${url}`;
    }

}

// Definimos nuestros adapters que heredarán de la clase principal
class ExpressAdapter extends HttpAdapter {
    getType() {
        return this.type;
    }
}

class NestJsAdapter extends HttpAdapter {
    getType() {
        return this.type;
    }
}

// Creamos nuestro factory que será el encargado de crear los adapters

const Adapter = {
    // Definimos los adapters disponibles
    factory : {
        Express : NestJsAdapter,
        NestJs: ExpressAdapter,
    },
    // Creamos un método para registrar los adapters
    register : function(type) {
        const NewAdapter = this.factory[type];

        if(!NewAdapter) {
            return "Adapter not found"
        }

        return new NewAdapter(type);
    }
}

const Express = Adapter.register('Express');
const NestJs = Adapter.register('NestJs');

console.log(Express.get('platzi.com')); //output: Express Method GET: platzi.com
console.log(NestJs.delete()); //output: NestJs Method DELETE: undefined

Daniel Pacheco

student•

Comparto mi Ts

abstract class HttpAdapter {

    constructor(private _type: string) {

    }
    abstract get(): void;
    abstract post(): void;
    abstract put(): void;
    abstract delete(): void;

   get type(): string {
        return this._type;
    }
}

// adapters concretos 
class AdapterExpress extends HttpAdapter {

    constructor() {
        super('Express');
    }

    get(): void {
        console.log(`get method for ${this.type} adapter`);
    }
    post(): void {
        console.log(`post method for ${this.type} adapter`);
    }
    put(): void {
        console.log(`put method for ${this.type} adapter`);
    }
    delete(): void {
        console.log(`delete method for ${this.type} adapter`);
    }
};


class AdapterNextJs extends HttpAdapter {

    constructor() {
        super('NestJs');
    }

    get(): void {
        console.log(`get method for ${this.type} adapter`);
    }
    post(): void {
        console.log(`post method for ${this.type} adapter`);
    }
    put(): void {
        console.log(`put method for ${this.type} adapter`);
    }
    delete(): void {
        console.log(`delete method for ${this.type} adapter`);
    }
};

// Interface para la abstracion de la fabrica de adapters
interface HttpAdapterFactory {
    makeAdapter(): HttpAdapter
}

// fabricas concretas para cada adapter
class ExpressAdapterFactory implements HttpAdapterFactory {
    makeAdapter(): HttpAdapter {
        return new AdapterExpress;
    };
};

class NextJsAdapterFactory implements HttpAdapterFactory {
    makeAdapter(): HttpAdapter {
        return new AdapterNextJs;
    };
};

// aplicaciones
type HttpAdapterType = 'express' | 'nextjs';

function createFactory(type: HttpAdapterType): HttpAdapterFactory  {
    const factories = {
        'express': ExpressAdapterFactory,
        'nextjs': NextJsAdapterFactory
    };
    const Factory = new factories[type];

    return Factory;
};

function createAdapter(factory: HttpAdapterFactory) {
    const adapter = factory.makeAdapter()
    adapter.get();
    adapter.post();
    adapter.put();
    adapter.delete()
}

createAdapter(createFactory('express'));
createAdapter(createFactory('nextjs'));

Daniel Basulto

teacher•

Excelente Dani, cuentame, que te pareció el uso de los conceptos de la POO como las clases abstractas, la herencia, la implementación, consideras que se disiparon dudas y ganaste conocimiento?

Omar Eduardo Sánchez

student•

Para ponerle un poquito más de desafío, hice mi reto con Swift. Aquí dejo mi solución para los curiosos:

import Foundation

protocol HttpAdapter {
  var name: String { get }

  init(name: String)

  func get()
  func post()
  func put()
  func delete()
}

protocol HttpAdapterFactory {
  associatedtype Adapter: HttpAdapter
  func makeAdapter() -> Adapter
}

struct ExpressAdapter: HttpAdapter {
  internal let name: String

  init(name: String) {
    self.name = name
  }

  func get() {
    print("Getting data")
  }

  func post() {
    print("Posting data")
  }

  func put() {
    print("Putting data")
  }

  func delete() {
    print("Deleting data")
  }
}

struct ExpressAdapterFactory: HttpAdapterFactory {
  func makeAdapter() -> ExpressAdapter {
    return ExpressAdapter(name: "express")
  }
}

func run<F: HttpAdapterFactory>(factory: F) {
  let adapter = factory.makeAdapter()
  print("Testing adapter methods for: \(adapter.name)")
  print("============================================")
  print("Testing GET...")
  adapter.get()
  print("Testing POST...")
  adapter.post()
  print("Testing PUT...")
  adapter.put()
  print("Testing DELETE...")
  adapter.delete()
  print("============================================")
}

run(factory: ExpressAdapterFactory())

Marco Rojas

student•

Mi aporte del ejercicio en python:

from __future__ import annotations
from abc import ABC, abstractmethod

class HttpAdapter(ABC):

    def __init__(self, name: str):
        self.adapter_name = name

    @abstractmethod
    def get(self) -> None:
        pass

    @abstractmethod
    def post(self) -> None:
        pass

    @abstractmethod
    def put(self) -> None:
        pass

    @abstractmethod
    def delete(self) -> None:
        pass


class HttpAdapterFactory(ABC):

    @staticmethod
    @abstractmethod
    def make_adapter() -> HttpAdapter:
        pass


class MyAdapter1(HttpAdapter):

    def __init__(self, name: str):
        super().__init__(name)

    def get(self) -> None:
        print('get method in MyAdapter1')

    def post(self) -> None:
        print('post method in MyAdapter1')

    def put(self) -> None:
        print('put method in MyAdapter1')

    def delete(self) -> None:
        print('delete method in MyAdapter1')


class MyAdapter2(HttpAdapter):

    def __init__(self, name: str):
        super().__init__(name)

    def get(self) -> None:
        print('get method in MyAdapter2')

    def post(self) -> None:
        print('post method in MyAdapter2')

    def put(self) -> None:
        print('put method in MyAdapter2')

    def delete(self) -> None:
        print('delete method in MyAdapter2')

      
class FabricAdapter1(HttpAdapterFactory):

    @staticmethod
    def make_adapter() -> HttpAdapter:
        return MyAdapter1('MyAdapterX')


class FabricAdapter2(HttpAdapterFactory):

    @staticmethod
    def make_adapter() -> HttpAdapter:
        return MyAdapter2('MyAdapterY')


if __name__ == "__main__":
    adapter_creator1 = FabricAdapter1()
    http_adapter = adapter_creator1.make_adapter()
    http_adapter.get()
    http_adapter.post()
    http_adapter.put()
    http_adapter.delete()
    print()
    adapter_creator2 = FabricAdapter2()
    http_adapter = adapter_creator2.make_adapter()
    http_adapter.get()
    http_adapter.post()
    http_adapter.put()
    http_adapter.delete()

Jorge Romero

student•

Ahí humildemente, si tengo algo malo, diganme xd

/**
 * Como implementar factory?
 * 1. Declara una clase/interface de producto base, que será devuelta por la clase de la fábrica y sus subclases.
 * 2. Implementa subclases de productos concretos que hereden/implementen la clase/interface de producto base.
 * 3. Declara una clase/interface de fábrica que devuelva objetos que coincidan con el producto base, no con los productos concretos.
 * 4. Implementa subclases de fábricas concretas que hereden/implementen la clase/interface de fábrica base. Estas clases devolverán productos
 * concretos en su método de fábrica.
 */

/** Paso 1 */
class HttpAdapter {

    constructor(type){
        this.type = type;
    }

    get() {
        throw new Error('Method not implemented!');
    }

    post() {
        throw new Error('Method not implemented!');
    }

    put() {
        throw new Error('Method not implemented!');
    }

    delete() {
        throw new Error('Method not implemented!');
    }
}

/** Paso 2 */
class ExpressHttpAdapter extends HttpAdapter {

    constructor() {
        super('express');
    }

    get() {
        console.log('Get desde Express');
    }

    post() {
        console.log('Post desde Express');
    }

    put() {
        console.log('Put desde Express');
    }

    delete() {
        console.log('Delete desde Express');
    }
}

class FastifyHttpAdapter extends HttpAdapter {
    constructor() {
        super('fastify');
    }

    get() {
        console.log('Get desde Fastify');
    }

    post() {
        console.log('Post desde Fastify');
    }

    put() {
        console.log('Put desde Fastify');
    }

    delete() {
        console.log('Delete desde Fastify');
    }
}

/** Paso 3 */
class HttpAdapterFactory {
    makeAdapter() {
        throw new Error('Method not implemented!');
    }
}

/** Paso 4 */
class ExpressHttpAdapterFactory extends HttpAdapterFactory {
    makeAdapter() {
        return new ExpressHttpAdapter('express');
    }
}

class FastifyHttpAdapterFactory extends HttpAdapterFactory {
    makeAdapter() {
        return new FastifyHttpAdapter('fastify');
    }
}

/* Client App */

function clienteApp(factory) {
    const adapter = factory.makeAdapter();
    adapter.get();
    console.log(adapter.type);
}

clienteApp(new ExpressHttpAdapterFactory());
clienteApp(new FastifyHttpAdapterFactory());

Cesar Edwin Puma Palomino

student•

Hola! Aquí dejo mi solución, espero les agrade.

abstract class HttpAdapter {
    constructor(protected readonly name: string) { }

    get(): void {
        console.log(`${this.name}:: get()`)
    }
    post(): void {
        console.log(`${this.name}:: post()`)
    }
    put(): void {
        console.log(`${this.name}:: put()`)
    }
    delete(): void {
        console.log(`${this.name}:: delete()`)
    }

}

class ExpressHttpAdapter extends HttpAdapter {
    get() {
        console.log(`${this.name}:: expressGET()`)
    }

}
class PureHttpAdapter extends HttpAdapter {
    post() {
        console.log(`${this.name}:: fastifyPOST()`)
    }
}
class FastifyHttpAdapter extends HttpAdapter {
    constructor(name: string, private readonly alias: string) {
        super(name)
    }
    delete() {
        console.log(`${this.name}-(${this.alias}):: fastifyDELETE()`)
    }
}

// .........

interface HttpAdapterFactory {
    makeAdapter(): HttpAdapter
}

class ExpressHttpAdapterFactory implements HttpAdapterFactory {
    makeAdapter(): HttpAdapter {
        return new ExpressHttpAdapter('ExpressAdapter');
    }
}
class PureHttpAdapterFactory implements HttpAdapterFactory {
    makeAdapter(): HttpAdapter {
        return new PureHttpAdapter('PureAdapter');
    }
}
class FastifyHttpAdapterFactory implements HttpAdapterFactory {
    makeAdapter(): HttpAdapter {
        return new FastifyHttpAdapter('FastifyAdapter', 'fasti');
    }
}
// ---------------------



function clientApp(factory: HttpAdapterFactory) {
    const httpAdapter = factory.makeAdapter();
    httpAdapter.get();
    httpAdapter.post();
    httpAdapter.delete();
}

// clientApp(new ExpressHttpAdapterFactory())
// clientApp(new PureHttpAdapterFactory())
// clientApp(new FastifyHttpAdapterFactory())


type TypeHttpAdapterfactory = 'express' | 'pure' | 'fastify';
const httpAdapterFactories: Record<TypeHttpAdapterfactory, new () => HttpAdapterFactory> = {
    'express': ExpressHttpAdapterFactory,
    'pure': PureHttpAdapterFactory,
    'fastify': FastifyHttpAdapterFactory
}
function createHttpAdapter(type: TypeHttpAdapterfactory) {
    const FactoryClass = httpAdapterFactories[type];
    return new FactoryClass();
}       

clientApp(createHttpAdapter("express"))
clientApp(createHttpAdapter("fastify"))
clientApp(createHttpAdapter("pure"))

David Higuera

student••

class HttpAdapter {

    constructor(name) {
        this.name = name
    }

    get() {
        throw new Error('Method not implemented')
    }

    post() {
        throw new Error('Method not implemented')
    }

    put() {
        throw new Error('Method not implemented')
    }

    delete() {
        throw new Error('Method not implemented')
    }
}

class HttpAdapterFactory {
    makeAdapter() {
        return HttpAdapter
    }
}

class ExpressHttpAdapter extends HttpAdapter {
    constructor() {
        super('Express');
    }

    get() {
        console.log(this.name, '[GET]')
    }
}

class FastifyHttpAdapter extends HttpAdapter {
    constructor(name) {
        super('Fastify');
    }

    get() {
        console.log(this.name, '[GET]')
    }
}


class ExpressFactory extends HttpAdapterFactory {
    constructor() {
        super()
    }

    makeAdapter() {
        return new ExpressHttpAdapter()
    }
}

class FastifyFactory extends HttpAdapterFactory {
    constructor() {
        super()
    }

    makeAdapter() {
        return new FastifyHttpAdapter()
    }
}

function appFactory(factory) {
    const adapter = factory.makeAdapter()
    adapter.get()
}

function createFactory(type) {
    const factories = {
        express: ExpressFactory,
        fastify: FastifyFactory
    }

    const factory = factories[type]
    return new factory()
}

appFactory(createFactory('fastify')) // Fastify [GET]
appFactory(createFactory('express')) // Express [GET]

Jennifer Yanez Jiménez

student•

// Clase Base
class HttpAdapter {
    get(){
        throw new Error("Method not implemented")         
    }
    post(){
        throw new Error("Method not implemented") 
    }
    put(){
        throw new Error("Method not implemented") 
    }
    delete(){
        throw new Error("Method not implemented") 
    }
}

// Subclases
class HttpAdapterExpress extends HttpAdapter {
    get(){
        console.log("Metodo get de Express ejecutado")
    }
    post(){
        console.log("Metodo post de Express ejecutado")
    }
    put(){
        console.log("Metodo put de Express ejecutado")
    }
    delete(){
        console.log("Metodo delete de Express ejecutado")
    }
}

class HttpAdapterFastify extends HttpAdapter {
    get(){
        console.log("Metodo get de Fastify ejecutado")
    }
    post(){
        console.log("Metodo post de Fastify ejecutado")
    }
    put(){
        console.log("Metodo put de Fastify ejecutado")
    }
    delete(){
        console.log("Metodo delete de Fastify ejecutado")
    }
}

// Clase Factory Base
class HttpAdapterFactory {
    makeAdapter(){
        return new HttpAdapter()
    }
}

// Subclases de Factory
class HttpAdapterExpressFactory extends HttpAdapterFactory {
    makeAdapter(){
        return new HttpAdapterExpress()
    }
}

class HttpAdapterFastifyFactory extends HttpAdapterFactory {
    makeAdapter(){
        return new HttpAdapterFastify()
    }
}

// Cliente
function appFactory(factory){
	const method = factory.makeAdapter();
	method.get()
}

// Testing

appFactory(new HttpAdapterExpressFactory())
appFactory(new HttpAdapterFastifyFactory())

Jennifer Yanez Jiménez

student•

// Clase Baseclass HttpAdapter { get(){ throw new Error("Method not implemented") } post(){ throw new Error("Method not implemented") } put(){ throw new Error("Method not implemented") } delete(){ throw new Error("Method not implemented") }} // Subclasesclass HttpAdapterExpress extends HttpAdapter { get(){ console.log("Metodo get de Express ejecutado") } post(){ console.log("Metodo post de Express ejecutado") } put(){ console.log("Metodo put de Express ejecutado") } delete(){ console.log("Metodo delete de Express ejecutado") }} class HttpAdapterFastify extends HttpAdapter { get(){ console.log("Metodo get de Fastify ejecutado") } post(){ console.log("Metodo post de Fastify ejecutado") } put(){ console.log("Metodo put de Fastify ejecutado") } delete(){ console.log("Metodo delete de Fastify ejecutado") }} // Clase Factory Baseclass HttpAdapterFactory { makeAdapter(){ return new HttpAdapter() }} // Subclases de Factoryclass HttpAdapterExpressFactory extends HttpAdapterFactory { makeAdapter(){ return new HttpAdapterExpress() }} class HttpAdapterFastifyFactory extends HttpAdapterFactory { makeAdapter(){ return new HttpAdapterFastify() }} // Clientefunction appFactory(factory){ const method = factory.makeAdapter(); method.get()} // Testing appFactory(new HttpAdapterExpressFactory())appFactory(new HttpAdapterFastifyFactory())

William Andres Tovar Riobo

student•

/** Step 1 */
interface HttpAdapter {
    get(): void;
    post(): void;
    put(): void;
    delete(): void;
}

interface HttpAdapterFactory {
    createAdapter(): HttpAdapter;
}


/** Step 2 */
class ExpressAdapter implements HttpAdapter {
    constructor(string: string) {
        console.log('ExpressAdapter constructor');
    }

    get() {
        console.log('ExpressAdapter get');
    }

    post() {
        console.log('ExpressAdapter post');
    }

    put() {
        console.log('ExpressAdapter put');
    }

    delete() {
        console.log('ExpressAdapter delete');
    }
}

class FastifyAdapter implements HttpAdapter {
    constructor(string: string) {
        console.log('FastifyAdapter constructor');
    }

    get() {
        console.log('FastifyAdapter get');
    }

    post() {
        console.log('FastifyAdapter post');
    }

    put() {
        console.log('FastifyAdapter put');
    }

    delete() {
        console.log('FastifyAdapter delete');
    }
}

/** Step 3 */
class ExpressAdapterFactory implements HttpAdapterFactory {
    createAdapter(): HttpAdapter {
        return new ExpressAdapter('ExpressAdapter');
    }
}

class FastifyAdapterFactory implements HttpAdapterFactory {
    createAdapter(): HttpAdapter {
        return new FastifyAdapter('FastifyAdapter');
    }
}

/** Step 4 */
function clientApp(factory: HttpAdapterFactory) {
    const adapter = factory.createAdapter();

    adapter.get();
    adapter.post();
    adapter.put();
    adapter.delete();

}

type AdapterType = 'express' | 'fastify';

function clientCreateAdapter(type: AdapterType): HttpAdapterFactory {
    let factory: HttpAdapterFactory;
    switch (type) {
        case 'express':
            factory = new ExpressAdapterFactory();
            break;
        case 'fastify':
            factory = new FastifyAdapterFactory();
            break;
        default:
            throw new Error('Invalid type');
    }
    return factory;
}


clientApp(clientCreateAdapter('express'));
clientApp(clientCreateAdapter('fastify'));

Jhon Maicol Paucar Chiguano

student•

Aquí esta mi aporte. Según lo entendido en cada una de las clases previamente vistas.

// 1. Creacion del contrato o interfaz para los productos, en JS clase abstracta pura.

class HttpAdapter {
  get() {
    throw new Error('Method not implemented.')
  }
  post() {
    throw new Error('Method not implemented.')
  }
  put() {
    throw new Error('Method not implemented.')
  }
  delete() {
    throw new Error('Method not implemented.')
  }
}

// 2. Cracion de las sub clases que implementan la interfaz o el contrato.

class ExpressAdapter extends HttpAdapter {
  get() {
    console.log('Quiere hacer una peticion GET a express')
  }
  post() {
    console.log('Quiere hacer una peticion POST a express')
  }
  put() {
    console.log('Quiere hacer una peticion PUT a express')
  }
  delete() {
    console.log('Quiere hacer una peticion DELETE a express')
  }
}

class FastifyAdapter extends HttpAdapter {
  get() {
    console.log('Quiere hacer una peticion GET a fastify')
  }
  post() {
    console.log('Quiere hacer una peticion POST a fastify')
  }
  put() {
    console.log('Quiere hacer una peticion PUT a fastify')
  }
  delete() {
    console.log('Quiere hacer una peticion DELETE a fastify')
  }
}

// 3. Creacion del contrato o interfaz para la factory que generara los productos.
class FactoryHttpAdapter {
  createHttpAdapter() {
    throw new Error('Method not implemented.')
  }
}

// 4. Creacion de la factory que generara los productos implementando la interfaz o el contrato.
class FactoryHttpAdapterExpress extends FactoryHttpAdapter {
  createHttpAdapter() {
    return new ExpressAdapter()
  }
}

class FactoryHttpAdapterFastify extends FactoryHttpAdapter {
  createHttpAdapter() {
    return new FastifyAdapter()
  }
}

function appHttpAdapter(factory) {
  if (!factory) {
    console.log('--- No factory provided ---')
    return
  }
  const httpAdapter = factory.createHttpAdapter()
  return httpAdapter.get()
}

function createHttpAdapter(type) {
  const listOfFactories = {
    express: FactoryHttpAdapterExpress,
    fastify: FactoryHttpAdapterFastify
  }

  const HttpAdapter = listOfFactories[type]

  if (!HttpAdapter) {
    console.log(`Type ${type} not found`)
    return
  }

  return new HttpAdapter()
}

appHttpAdapter(createHttpAdapter('express'))
```// 1. Creacion del contrato o interfaz para los productos, en JS clase abstracta pura.
class HttpAdapter {  get() {    throw new Error('Method not implemented.')  }  post() {    throw new Error('Method not implemented.')  }  put() {    throw new Error('Method not implemented.')  }  delete() {    throw new Error('Method not implemented.')  }}
// 2. Cracion de las sub clases que implementan la interfaz o el contrato.
class ExpressAdapter extends HttpAdapter {  get() {    console.log('Quiere hacer una peticion GET a express')  }  post() {    console.log('Quiere hacer una peticion POST a express')  }  put() {    console.log('Quiere hacer una peticion PUT a express')  }  delete() {    console.log('Quiere hacer una peticion DELETE a express')  }}
class FastifyAdapter extends HttpAdapter {  get() {    console.log('Quiere hacer una peticion GET a fastify')  }  post() {    console.log('Quiere hacer una peticion POST a fastify')  }  put() {    console.log('Quiere hacer una peticion PUT a fastify')  }  delete() {    console.log('Quiere hacer una peticion DELETE a fastify')  }}
// 3. Creacion del contrato o interfaz para la factory que generara los productos.class FactoryHttpAdapter {  createHttpAdapter() {    throw new Error('Method not implemented.')  }}
// 4. Creacion de la factory que generara los productos implementando la interfaz o el contrato.class FactoryHttpAdapterExpress extends FactoryHttpAdapter {  createHttpAdapter() {    return new ExpressAdapter()  }}
class FactoryHttpAdapterFastify extends FactoryHttpAdapter {  createHttpAdapter() {    return new FastifyAdapter()  }}
function appHttpAdapter(factory) {  if (!factory) {    console.log('--- No factory provided ---')    return  }  const httpAdapter = factory.createHttpAdapter()  return httpAdapter.get()}
function createHttpAdapter(type) {  const listOfFactories = {    express: FactoryHttpAdapterExpress,    fastify: FactoryHttpAdapterFastify  }
  const HttpAdapter = listOfFactories\[type]
  if (!HttpAdapter) {    console.log(`Type ${type} not found`)    return  }
  return new HttpAdapter()}
appHttpAdapter(createHttpAdapter('express'))

Jose Luis Bedoya

student•

mi solución :class httpAdapter { name; constructor(adatorName) { this.name = adatorName; } get() { throw new Error("Methor not implemented"); } post() { throw new Error("Methor not implemented"); } put() { throw new Error("Methor not implemented"); } delete() { throw new Error("Methor not implemented"); }} //paso 2class axiosAdapter extends httpAdapter { constructor(adatorName) { super(adatorName); } get() { console.log("axios get"); } post() { console.log("axios post"); } put() { console.log("axios put"); } delete() { console.log("axios delete"); } showName() { console.log(this.name); }} class httpAdapterFactory { createAdapter() { throw new Error("Method not implemented"); }} class concreteAdapterFactory extends httpAdapterFactory { createAdapter(type) { return new axiosAdapter(type); }} function clientApp() { const axiosAdater = new concreteAdapterFactory().createAdapter("joselin"); axiosAdater.get(); axiosAdater.post(); axiosAdater.put(); axiosAdater.delete(); axiosAdater.showName();}clientApp();

class httpAdapter {
  name;
  constructor(adatorName) {
    this.name = adatorName;
  }

  get() {
    throw new Error("Methor not implemented");
  }

  post() {
    throw new Error("Methor not implemented");
  }
  put() {
    throw new Error("Methor not implemented");
  }

  delete() {
    throw new Error("Methor not implemented");
  }
}

//paso 2
class axiosAdapter extends httpAdapter {
  constructor(adatorName) {
    super(adatorName);
  }
  get() {
    console.log("axios get");
  }
  post() {
    console.log("axios post");
  }
  put() {
    console.log("axios put");
  }
  delete() {
    console.log("axios delete");
  }

  showName() {
    console.log(this.name);
  }
}

class httpAdapterFactory {
  createAdapter() {
    throw new Error("Method not implemented");
  }
}

class concreteAdapterFactory extends httpAdapterFactory {
  createAdapter(type) {
    return new axiosAdapter(type);
  }
}

function clientApp() {
  const axiosAdater = new concreteAdapterFactory().createAdapter("joselin");
  axiosAdater.get();
  axiosAdater.post();
  axiosAdater.put();
  axiosAdater.delete();
  axiosAdater.showName();
}
clientApp();

Luis Felipe Medina Álvarez

student•

No sé bien si debía hacerse así, pero sí pude crear la clase específica y hacer referencia a los métodos de la clase base:```js class HttpAdapter { Get() { throw new Error('This method is not implemented'); } Post() { throw new Error('This method is not implemented'); } Put() { throw new Error('This method is not implemented'); } Delete() { throw new Error('This method is not implemented'); } }

// Derived class implementing HTTP Adapter methods class HttpAdapterMST extends HttpAdapter { Get() { console.log('Este es el método Get'); } Post() { console.log('Este es el método Post'); } Put() { console.log('Este es el método Put'); } Delete() { console.log('Este es el método Delete'); } }

// Base class for the Factory class HttpAdapterFactory { MakeAdapter() { throw new Error('This method is not implemented'); } }

// Factory class for creating MST Adapter instances class MSTAdapterFactory extends HttpAdapterFactory { MakeAdapter() { return new HttpAdapterMST(); } }

// Function that uses the factory to create and test the adapter function appFactory(factory) { const adaptador = factory.MakeAdapter(); adaptador.Get(); adaptador.Post(); adaptador.Put(); adaptador.Delete(); }

// Correctly pass the factory instance appFactory(new MSTAdapterFactory());

Kyb3r Cipher

student•

Mi implementacion del challenge de Facotory:

class HttpAdapter {
    constructor(type) {
        this.name = type;
    }

    get() {
        throw error("Method not implement.");
    }

    post() {
        throw error("Method not implement.");
    }

    put() {
        throw error("Mehotd not implement.");
    }

    delete() {
        throw error("Method not implement.");
    }
}

class HttpAdapterFactory {
    makeAdapter() {
        throw error("Method not implement.");
    }
}

class Express extends HttpAdapter {
    constructor() {
        super("Express")
    }

    get() {
        console.log(`get Method for ${this.name}`);
    }

    post() {
        console.log(`post Method for ${this.name}`);
    }

    put() {
        console.log(`put Method for ${this.name}`);
    }

    delete() {
        console.log(`delete Method for ${this.name}`);
    }
}

class ExpressFactory extends HttpAdapterFactory {
    makeAdapter() {
        return new Express();
    }
}

class Fastify extends HttpAdapter {
    constructor() {
        super("Express")
    }

    get() {
        console.log(`get Method for ${this.name}`);
    }

    post() {
        console.log(`post Method for ${this.name}`);
    }

    put() {
        console.log(`put Method for ${this.name}`);
    }

    delete() {
        console.log(`delete Method for ${this.name}`);
    }
}

class FastifyFactory extends HttpAdapter {
    makeAdapter() {
        return new Fastify();
    }
}

function appFactory(factory) {
    const car = factory.makeCar();
    car.showCost();
}

appFactory(new ExpressFactory());
appFactory(new FastifyFactory());

Sergio Oviedo

student•

// Interfaces
interface HttpAdapterInterface {
  get(): void;
  post(): void;
  put(): void;
  delete(): void;
}

interface HttpAdapterFactoryInterface {
  makeAdapter(type: AdapterServicesType): HttpAdapterInterface;
}

// types
type AdapterServicesType = "Express" | "Fastify";

// express adapter
class ExpressAdapter implements HttpAdapterInterface {
  public get(): void {
    console.log("Método get Express");
  }

  public post(): void {
    console.log("Método post Express");
  }

  public put(): void {
    console.log("Método put Express");
  }

  public delete(): void {
    console.log("Método delete Express");
  }
}

// fastify adapter
class FastifyAdapter implements HttpAdapterInterface {
  public get(): void {
    console.log("Método get Fastify");
  }

  public post(): void {
    console.log("Método post Fastify");
  }

  public put(): void {
    console.log("Método put Fastify");
  }

  public delete(): void {
    console.log("Método delete Fastify");
  }
}

// Http Adapter (factory)
class HttpAdapterFactory implements HttpAdapterFactoryInterface {
  makeAdapter(type: AdapterServicesType): HttpAdapterInterface {
    switch (type) {
      case "Express":
        return new ExpressAdapter();
      case "Fastify":
        return new FastifyAdapter();
      default:
        throw new Error(`Adapter type "${type}" no es válido...`);
    }
  }
}

// example
const factory = new HttpAdapterFactory();

// test Express
const express_service: ExpressAdapter = factory.makeAdapter("Express");
express_service.get();
express_service.post();

// test Fastify
const fastify_services: FastifyAdapter = factory.makeAdapter("Fastify");
fastify_services.put();
fastify_services.delete();

Patrón Factory: Ventajas y Desventajas en Desarrollo de Software

Introduccion

Patrones de Diseño Creacionales en Software

Patrones Creacionales: Singleton, Factory, Abstract Factory, Builder, Prototype

Singleton

Patrón Singleton: Implementación y Uso en Programación Orientada a Objetos

Diagrama de Clases del Patrón Singleton en JavaScript

Diferencias entre JavaScript y TypeScript en patrones de diseño

Ventajas y desventajas del patrón Singleton en diseño de software

Factory

Patrones de Diseño: Introducción al Patrón Factory

Patrón Factory: Implementación y Detalles Esenciales

Implementación del Patrón Factory Method en JavaScript

Comparación del Patrón Factory en JavaScript y TypeScript