Patrones de Diseño: Singleton

En este artículo quiero explicaros el patrón ‘Singleton’, cómo usarlo y en qué situaciones. Un patrón muy usado, y que os puede ayudar.

Pero… ¿Qué es un patrón?

A muchos le surgirán ésta pregunta, y su definición en Wikipedia dice que los patrones son la base para la búsqueda de soluciones a problemas comunes en el desarrollo de software y otros ámbitos referentes al diseño de interacción o interfaces.

En concreto, el patrón ‘Singleton’, nos permite limitar el número de instancias a una clase, permitiendo el acceso único de todos los sitios a un objeto único. Esto es muy importante, ya que a veces sólo necesitamos una única instancia de una clase, y así evitamos la creación innecesarias de objetos, lo que repercute en la eficiencia, y por ende, en la rapidez de de nuestro software. También es usado cuando necesitamos un acceso global y conocido públicamente. Resumiendo, ‘Singleton’ = eficiencia y rapidez.

¿Cómo conseguimos eso?

Para usar el patrón ‘Singleton’, lo primero que tenemos que hacer es declarar el constructor de clase como privado, así conseguimos evitar la creación de objetos del exterior. Continuamos creando la única instancia del objeto dentro de la clase, usando los modificadores ‘private’ y ‘static’. Finalmente creamos un método público que devuelva la instancia, y usamos de nuevo el modificador ‘static’. El modificador ‘static’ lo usamos para no tener que crear un objeto adicional para poder usar el método que devuelva el objeto único.

Aquí podemos observar un diagrama que explique el patrón:

¡Vamos a la práctica!

Aquí os dejo el código que ilustrará lo arriba explicado. Es un ejemplo fácil, pero que abstrayéndote podrás darte cuenta que puede ser aplicado a muchas clases.

Versión Java

package com.singleton.paquete;

public class Singleton {

        private Singleton(){

        }

        private static Singleton objetoUnico = new Singleton();

        public static Singleton getObjetoUnico(){

              return objetoUnico;

        }

}

package com.singleton.paquete;

public class Main {

    public static void main(String[] args) {

         Singleton objeto1 = Singleton.getObjetoUnico();
         Singleton objeto2 = Singleton.getObjetoUnico();
         Singleton objeto3 = Singleton.getObjetoUnico();
         Singleton objeto4 = Singleton.getObjetoUncio();

    }
}

Aquí creamos 4 objetos que pertenecen, en realidad, al mismo objeto: el objeto único.

Versión C# 

public class Singleton{
      public string Name {get;set}
      private Singleton()   {

      }

      private static Singleton _singleton;

      public static Singleton GetInstance()   {

             if (_singleton == null)      {

                  _singleton = new Singleton();

            }

            return _singleton;

       }

}

    class Program
    {
        static void Main(string[] args)
        {
            var singleton1 = Singleton.GetInstance();
            var singleton2 = Singleton.GetInstance();
            var singleton3 = Singleton.GetInstance();
            var singleton4 = Singleton.GetInstance();
            singleton1.Name = "Sample 1";
            singleton2.Name = "Sample 2";
            singleton3.Name = "Sample 3";
            singleton4.Name = "Sample 4";
            Console.WriteLine("Objeto 1: " + singleton1.Name);
            Console.WriteLine("Objeto 2: " + singleton2.Name);
            Console.WriteLine("Objeto 3: " + singleton3.Name);
            Console.WriteLine("Objeto 4: " + singleton4.Name);
        }
    }

¿Cual creeis que será el resultado?
Aquí termina el post de hoy sobre los patrones, en futuros posts intentaré explicar otros patrones de utilidad.