Refactorizando un Singleton usando Static

Uno de los patrones de diseño del software que tenemos disponible es el Singleton. Según las buenas prácticas es un patrón del que tenemos que huir, porque viola varios principios del desarrollo. Para más información me remito a los principios STUPID vs SOLID.

Según podemos encontrar por Internet, hay un gran debate entre usarlo o no. Sólo se ve que sea la buena opción cuando necesitamos usar un sistema de cacheado de la información de forma global, registros de información global o sistemas en los que manejamos procesos debiendo controlar su cantidad.

Una forma de salvar la situación es el uso de Static en favor de tener información global, mejorando así también el rendimiento, aunque la idea de Singleton es subyacente a la forma de uso de Static. Otra forma de salvar la situación, es controlar la creación del objeto externamente, no internamente en la clase, delegando esta responsabilidad.

Este es un post de la serie de apuntes de repaso sobre principios y patrones de diseño software.

Al grano, algo de código fuente

Para trabajar esta refactorización podríamos partir de la clase del post anterior sobre una utilidad de crawleo:

<?php

class TestingUtils
{
    private static $instance;
    private $base_url;

    private function __construct($base_url)
    {
        $this->base_url = $base_url;
    }

    public static function get_instance($base_url)
    {
        if (!isset(self::$instance)) {
            self::$instance = new self($base_url);
        }

        return self::$instance;
    }

    public function change_base_url($base_url)
    {
        $this->base_url = $base_url;
    }

    public function do_get($path_call)
    {
        /* Some code */
    }

    public function do_post($path_call, $data)
    {
        /* Some code */
    }

    public function do_put($path_call, $data)
    {
        /* Some code */
    }

    public function do_patch($path_call, $data)
    {
        /* Some code */
    }

    public function do_delete($path_call)
    {
        /* Some code */
    }
}

Convertir en clase con métodos y propiedades estáticos

La idea es simple, es dejar de instanciar el objeto, de forma que ya no se instancia, aunque internamente contendrá igualmente información única debido a las variables estáticas que pueda contener. Quedaría algo así:

<?php

class TestingUtils
{
    private static $base_url = 'https://localhost/api';

    public static function set_base_url($base_url)
    {
        self::$base_url = $base_url;
    }

    public static function do_get($path_call)
    {
        /* Some code */
    }

    public static function do_post($path_call, $data)
    {
        /* Some code */
    }

    public static function do_put($path_call, $data)
    {
        /* Some code */
    }

    public static function do_patch($path_call, $data)
    {
        /* Some code */
    }

    public static function do_delete($path_call)
    {
        /* Some code */
    }
}

Usando la clase con métodos estáticos

El resultado viene a ser el mismo, sólo que ahora incluso sería más simple usando el codekata anterior:

<?php

include 'TestingUtils.php';

TestingUtils::set_base_url('https://localhost:8000/api');

for ($i = 1; $i <= 100; ++$i) {
    var_dump(TestingUtils::do_post('/locations', [
        'latitude' => rand(0,100) / 100,
        'longitude' => rand(0,100) / 100,
        'comment' => 'Localización para GIS de pruebas',
    ]));
    //var_dump($tools->do_delete('/locations/'.$i));
}

//var_dump($tools->do_post('/', []));
//var_dump($tools->do_put('/', []));
//var_dump($tools->do_patch('/', []));
//var_dump($tools->do_delete('/'));

var_dump(TestingUtils::do_get('/locations'));

Conclusiones

El resultado es el mismo, sólo tenemos un valor de $base_url en toda la aplicación. Además, no tenemos que instanciar el objeto para hacer uso de sus funciones. Y el código cumple más con los principios del desarrollo SOLID.