Factory

Clase 17 de 26 • Curso de Patrones de Diseño y Buenas Prácticas en PHP

Resumen

El patron Factory es creacional, se utiliza para ayudar a la creación de nuevas instancias de objetos.

Jhon Alexander Romero Gonzaga

student•

Con este se evita cambiar cada año el año de los autos del año actual:

<?php 

class Automobile {

    private $vehicleMake;
    private $vehicleModel;

    public function __construct($make, $model) {
        $this->vehicleMake = $make;
        $this->vehicleModel = $model;
    }

    public function getMakeAndModel() {
        return $this->vehicleMake.' - '.$this->vehicleModel;
    }
}


class AutomobileFactory {

    private static $model;

    public static function create($make) {
        self::$model = date('Y');
        return new Automobile($make, self::$model);
    }
}

$renault = new Automobile("Renault", 2019);
$toyota = AutomobileFactory::create("Toyota");


echo $renault->getMakeAndModel().PHP_EOL;
echo $toyota->getMakeAndModel().PHP_EOL;

CASAREZ HINOSTROZA ANGEL ARIEL

student•

buen ejemplo

Damian Castellini

student•

Este sería el ejemplo a utilizar, ya que de la otra forma estaríamos chocando bastante con solid...

María Sierra

student•

Factory

Se trata de un patrón creacional, o sea, que nos ayuda a crear nuevas instancias de objetos.

El patrón factory consiste en utilizar una clase constructora abstracta con unos cuantos métodos definidos y otro(s) abstracto(s).

Cristian Andres Ladino Peña

student•

Interesante resumen 💪

Carlos Eduardo Gomez García

teacher•

El patrón factory plantea simplificar una instancia, y eso lo podemos hacer por medio de otra clase que se encargue de obtener la instancia haciendo los procesos complejos requeridos, así ante cualquier cambio solo modificamos esa clase factory y no nos preocupamos por modificar cada una de las instancias.

Luz Sthephany Granados Castro

student•

Acá un buen ejemplo de patrón de diseño Factory 😎:

https://www.youtube.com/watch?v=lLvYAzXO7Ek&ab_channel=BettaTech

Daniel Aristizabal castaño

student•

Muchas gracias, estuvo interesante el video.

Enrique Devars

teacher•

¿Esto no sería hardcodear un poco el código?

Mauro Chojrin

teacher•

¿Podrías explayarte un poco más? ¿Qué parte te parece hardcodeo?

Muñoz Ortiz Leonel

student•

Supongo que te refieres al año 2019, si es asi, eso se puede mejorar teniendo un metodo que indique el año.

GARCIA CAMARENA EZEQUIEL

student•

Nota: es un patrón creacional es decir nos ayuda a la creación de nuevos objetos. El patrón se utiliza cuando la creación del objeto es un proceso muy completo, es decir recibe muchos parámetros o realiza funciones complejas al realización de la creación del objeto, con todo estamos logrando un código un poco más abstracto, reutilizable y sobre todo que podemos cambiar las formas en que creamos los modelos y a través de factoty no nos afectan estos cambios estamos ganando mas logita y la otra cosa que podría afectar es que si cambiamos una clase con el factory no nos afecta.

Bernardo Aguayo Ortega

student•

gracias!!

Marines Millan

student•

Este es el codigo de las laminas:

class Automobile
{
    private $vehicleMake;
    private $vehicleModel;

    public function __contruct($make, $model) {
        $this->vehicleMake = $make;
        $this->vehicleModel = $model;
    }

    public function getMakeAndModel() {
        return $this->vehivle.Make.' '.$this->vehicleModel;
    }
}

class AutomobileFactory
{
    private static $model = 2019;

    public static function create($make)
    {
        return new Automobile($make, self::$model);
    }
}

$a = new Automobile('Renault', 2019);
$b = AutomobileFactory::create('Toyota');

Sergio Estrella

teacher•

¿Cuáles con las difrencias entre el patrón Factory y Abstract Factory?

Diego Forero

Team Platzi•

Abstract Factory, permite trabajar con objetos de diferentes familias de manera que no se mezclen entre sí. De esa manera se consigue la el tipo de familia que se esté utilizando sea transparente. Un ejemplo la clase Disco que puede ser usada para crear discos de tipo Bluerays o tipo DVDs si bien tienen cosas en común hay otras que no como la capacidad.

Factory Method, centraliza en una clase constructora la creación de objetos de un tipo determinado. Ocultando al invocante la necesidad de indicar un tipo u otro. Un ejemplo puede ser la clase DVD todos los discos son iguales lo que cambia es el contenido, si es informaciuón o es una pelicula pero el disco es igual.

Massimo Di Berardino

student•

¡Hola Sergio! Te comparto este post donde se explica con mas detalle la diferencia. El resumen, Factory Method es un patrón aplicable a métodos los cuales puedes sobre escribir y cambiar su funcionalidad, en cambio Abstract Factory es un patrón de objetos o clases el cual implementa Factory Method

Juan Sebastián Joya Rodríguez

student•

Acrode con lo que entendí, implementas una clase que te ayuda a hacer mas facil la creacion de instancias de otras clases.

César Cubillos

student•

Pregunta ¿el colocar el año ahí no sería harcoding o en qué casos algo se llama harcoding?

Luis Alberto Guerra Luis

student•

tambien tengo la misma duda

Christian David Sánchez

student•

tienes razon. Es un dato cambiante y se estaría "harcodeando"

Muñoz Ortiz Leonel

student•

El metodo create de un factory siempre debe ser public static?

ORLANDO GOMEZ DIVANTOQUE

student•

Al ser static simplifica su uso, ya que de otra forma habría que crear una instancia para luego si llamar el método.

Jonathan Sebastian Sanchez Sanabria

student•

Factory

Tambien llamado: Método fabrica o Constructor virtual

Qué es?

Factory method es un patrón de diseño creacional que resuelve el problema de crear objetos de producto sin especificar sus clases concretas, define un método que debe utilizarse para crear objetos, en lugar de una llamada directa al constructor (operador new). Las subclases pueden sobrescribir este método para cambiar las clases de los objetos que se crearán.

Para que sirve?

Cuando la creación de un objeto es algo muy complejo.

El patrón Factory Method separa el código de construcción de producto del código que hace uso del producto. Por ello, es más fácil extender el código de construcción de producto de forma independiente al resto del código.

Como se logra en código?

Cree la interfaz del producto, esta declara las operaciones que todos los productos deben implementar, esta interfaz deberá declarar métodos que tengan sentido en todos los productos.

interface Product {
    operation(): string;
}

El patrón factory consiste en utilizar una clase constructora abstracta con unos cuantos métodos definidos y otros abstractos.

La responsabilidad de esta clase no es crear productos, por lo general contiene alguna lógica de negocio, las subclases pueden cambiar indirectamente esa lógica.

Añada un patrón Factory Method vacío dentro de la clase creadora.

El tipo de retorno del método deberá coincidir con la interfaz común de los productos.

abstract class Creator {
    
    public abstract factoryMethod(): Product;

    public someOperation(): string {
        // Llame al método de fábrica para crear un objeto Producto.
        const product = this.factoryMethod();
        // Ahora, usa el producto.
        return `Creator: The same creator's code has just worked with ${product.operation()}`;
    }
}

Haga que todos los productos sigan la misma interfaz esto proporciona varias implementaciones de la interfaz del producto

class ConcreteProduct1 implements Product {
    public operation(): string {
        return '{Result of the ConcreteProduct1}';
    }
}

class ConcreteProduct2 implements Product {
    public operation(): string {
        return '{Result of the ConcreteProduct2}';
    }
}

Las subclases anulan el método de fábrica para cambiar el tipo de producto resultante

El método usa el tipo de producto abstracto, aunque el tipo de producto en realidad se devuelve en este método. De esta manera, el Creador puede permanecer independiente de las clases de productos concretas.

class ConcreteCreator1 extends Creator {

    public factoryMethod(): Product {
        return new ConcreteProduct1();
    }
}

class ConcreteCreator2 extends Creator {
    public factoryMethod(): Product {
        return new ConcreteProduct2();
    }
}

El código del cliente funciona con una instancia de un creador concreto, aunque a través de su interfaz base. Siempre que el cliente siga trabajando con el creador a través de la interfaz base, puede pasarla a la subclase de cualquier creador.

function clientCode(creator: Creator) {
    // ...
    console.log('Client: I\'m not aware of the creator\'s class, but it still works.');
    console.log(creator.someOperation());
    // ...
}

La aplicación elige el tipo de creador según la configuración o variables de entorno.

console.log('App: Launched with the ConcreteCreator1.');
clientCode(new ConcreteCreator1());
console.log('');

console.log('App: Launched with the ConcreteCreator2.');
clientCode(new ConcreteCreator2());

La salida de este código seria:

[LOG]: "App: Launched with the ConcreteCreator1." 
[LOG]: "Client: I'm not aware of the creator's class, but it still works." 
[LOG]: "Creator: The same creator's code has just worked with {Result of the ConcreteProduct1}" 
[LOG]: "" 
[LOG]: "App: Launched with the ConcreteCreator2." 
[LOG]: "Client: I'm not aware of the creator's class, but it still works." 
[LOG]: "Creator: The same creator's code has just worked with {Result of the ConcreteProduct2}"

Pros

Evitar acoplamiento entre el creador y los productos concretos.
Principio de responsabilidad Unica: Se puede mover todo el código de creación de productos a un solo lugar, logrando que el código sea mas fácil de mantener.
Principio abierto cerrado: Se pueden agregar o quitar productos sin afectar el código cliente.

Contra

Puede hacer que el código se complique ya que se deben incorporar nuevas clases para implementar el patron. Lo ideal seria introducir el patrón en una jerarquia existente de clases creadoras.

Usuario anónimo

user•

En javascript sería algo así...

class Automovil {
    constructor(make, year) {
        this.make = make
        this.year = year
    }
    getAutomovil() {
        return console.log(`This Automovil is make ${this.make} and year ${this.year}`);
    }
}

class AutomovilFactory {
    constructor(make) {
        this.make = make
    }
    create() {
        const year = 2019;
        return console.log(new Automovil(this.make, year));
    }
}

const automovil = new Automovil('Renault', 2018);
automovil.getAutomovil();
const autoRefactory = new AutomovilFactory('Toyota');
autoRefactory.create();

Daniel Hurtado

student•

Se podría usar este mismo patrón sin la necesidad de una nueva clase? Es decir agregar la función create dentro de la misma clase Automobile, O no sería recomendable?

Renzo Martín Staiti

student•

No tiene mucho sentido el ejemplo, el 2019, lo vas a tener que cambiar en algun momento, vas a necesitar ese parametro. Ahora si me decis que ese año, depende de otra cosa, y te evitas tener que pasarlo cada vez que llamas a la clase, tiene todo el sentido. De ser asi, lo hubiese digavado mas al ejemplo. No harcodeando

Juan Pablo Campuzano Monsalve

student•

Según lo investigado y anotado de otras fuentes, estás son mis notas:

El patrón de diseño Factory, también conocido como Factory Method, es un patrón creacional que se utiliza para delegar la lógica de creación de objetos a clases específicas, permitiendo de esta forma flexibilizar y centralizar la creación de objetos en una aplicación. El objetivo principal de este patrón es separar la construcción de objetos de su representación, haciendo que el código sea más modular y fácil de mantener. El patrón Factory se implementa típicamente de la siguiente manera: 1. **Interfaz de producto**: Define la interfaz de los objetos que el método fábrica creará.2. **Implementaciones concretas del producto**: Estas son clases que implementan la interfaz de producto y definen objetos específicos que serán creados por la fábrica.3. **Creador (o Factory)**: Esta es una clase que declara el método fábrica, el cual retorna objetos de tipo producto. Este método puede ser diseñado como abstracto, obligando a las subclases a definir cómo se crean los objetos, o puede retornar un tipo de producto predeterminado.4. **Creadores concretos**: Son subclases del creador que implementan el método fábrica para crear y retornar productos específicos. El uso del patrón Factory tiene varias ventajas: - **Flexibilidad**: Los clientes trabajan con interfaces para instancias de objetos, lo que permite cambiar las clases concretas de productos sin cambiar el código que usa los productos.- **Desacoplamiento**: Los clientes no necesitan saber cómo se crean y ensamblan los objetos; solo necesitan saber cómo interactuar con ellos a través de sus interfaces.- **Consolidación del código de creación**: Toda la lógica relacionada con la creación de los objetos se mantiene en un lugar, lo que facilita las actualizaciones y el mantenimiento. El patrón Factory es especialmente útil cuando hay un conjunto complejo de criterios para crear diferentes objetos, lo que puede incluir la elección de la clase de objeto a crear en tiempo de ejecución en base a ciertos parámetros. También es útil cuando el proceso de creación debe estar aislado del código principal para facilitar la futura expansión o mantenimiento sin modificar el código que utiliza los objetos.

JHEYSON EDUARDO AVENDAÑO HERNÁNDEZ

student•

como asi que el patron factory no es una cancion de la factoria?

Manuel Ducos

student•

<?php class Book { private $info; private $edition; public function __construct($info, $edition) { $this->info = $info; $this->edition = $edition; } } class BookFactory { private static $edition = '2022'; public static function create($info) { return new Book($info, self::$edition); } } $book2 = BookFactory::create('book info');

Sergio Null

student•

un poco malo el ejemplo...ni siquiera está formateada ni resaltada la sintaxis y encima usa nombres poco semanticos en algunos casos de este y otros videos ($a, $vel, etc...)

Oscar Jaramillo

student•

Factory Method es un patrón de diseño creacional que proporciona una interfaz para crear objetos en una superclase, mientras permite a las subclases alterar el tipo de objetos que se crearán.