Java: patrón de método de diseño de fábrica | Diseño Orientado a Objetos | Patrones de diseño

Publicado: 2013-06-28

Patrón de método de diseño de fábrica Diseño orientado a objetos

El patrón de diseño de fábrica es uno de los patrones de diseño creativo y se usa ampliamente en JDK, así como en marcos como Spring MVC y Struts. El patrón de método de fábrica es un patrón de diseño de creación orientado a objetos para implementar el concepto de fábricas y trata el problema de crear objetos (productos) sin especificar la clase exacta de objeto que se creará. La esencia de este patrón es “ Definir una interfaz para crear un objeto, pero dejar que las clases que implementan la interfaz decidan qué clase instanciar. El método Factory permite que una clase difiera la creación de instancias a las subclases “.

Patrones de diseño de Java

Primero aprendamos cómo implementar el patrón de fábrica en Java. Crearemos 5 clases para implementar este patrón.

  • Superclase (CrunchfiyCompany.java)
    • La superclase en el patrón de fábrica puede ser una interfaz, una clase abstracta o una clase java normal. Para nuestro ejemplo, tenemos superclase como clase abstracta con el método toString() anulado para fines de prueba.
  • Subclase 1 (CrunchifyEbay.java)
    • Observe que la clase está extendiendo la clase CrunchfiyCompany.
  • Subclase 2 (CrunchifyGoogle.java)
    • Observe que la clase está extendiendo la clase CrunchfiyCompany.
  • Clase de fábrica (CrunchifyFactoryPattern.java)
    • Ahora que tenemos listas las superclases y subclases, podemos escribir nuestra clase de fábrica.
    • Podemos mantener la clase Singleton de Factory o podemos mantener el método que devuelve la subclase como estático.
    • Tenga en cuenta que, según el parámetro de entrada, se crean y devuelven diferentes subclases.
  • Clase de prueba (CrunchifyFactoryPatternTest.java)
    • Programa de cliente de prueba simple que utiliza la implementación del patrón de fábrica anterior.

Otro debe leer:

  • Thread-Safe y una implementación Fast Singleton en Java
  • ¿Qué es Daemon Thread en Java? Ejemplo adjunto

CrunchfiyCompany.java
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package com . crunchify . tutorials ;
 
/**
* @author Crunchify.com
*/
 
// Super class in factory pattern can be an interface, abstract class or a
// normal java class. For our example, we have super class as abstract class
// with overridden toString() method for testing purpose.
 
public abstract class CrunchfiyCompany {
 
public abstract String getPhoneNumber ( ) ;
 
public abstract String getZipCode ( ) ;
 
@Override
public String toString ( ) {
return "Phone #= " + this . getPhoneNumber ( ) + ", Zip Code= " + this . getZipCode ( ) ;
}
}

CrunchifyEbay.java
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package com . crunchify . tutorials ;
 
/**
* @author Crunchify.com
*/
 
// Notice that the class is extending CrunchfiyCompany class.
 
public class CrunchifyEbay extends CrunchfiyCompany {
 
private String phoneNumber ;
private String zipCode ;
 
public CrunchifyEbay ( String phoneNumber , String zipCode ) {
this . phoneNumber = phoneNumber ;
this . zipCode = zipCode ;
}
 
@Override
public String getPhoneNumber ( ) {
return this . phoneNumber ;
}
 
@Override
public String getZipCode ( ) {
return this . zipCode ;
}
}

CrunchifyGoogle.java
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package com . crunchify . tutorials ;
 
/**
* @author Crunchify.com
*/
 
// Notice that the class is extending CrunchfiyCompany class.
 
public class CrunchifyGoogle extends CrunchfiyCompany {
 
private String phoneNumber ;
private String zipCode ;
 
public CrunchifyGoogle ( String phoneNumber , String zipCode ) {
this . phoneNumber = phoneNumber ;
this . zipCode = zipCode ;
}
 
@Override
public String getPhoneNumber ( ) {
return this . phoneNumber ;
}
 
@Override
public String getZipCode ( ) {
return this . zipCode ;
}
}

CrunchifyFactoryPattern.java
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package com . crunchify . tutorials ;
 
import com . crunchify . tutorials . CrunchfiyCompany ;
import com . crunchify . tutorials . CrunchifyEbay ;
import com . crunchify . tutorials . CrunchifyGoogle ;
 
/**
* @author Crunchify.com
*/
 
// Now that we have super classes and sub-classes ready, we can write our factory class.
// We can keep Factory class Singleton or we can keep the method that return the subclass a static.
// Notice that based on the input parameter, different subclass is created and returned.
 
public class CrunchifyFactoryPattern {
 
public static CrunchfiyCompany getDetails ( String type , String phoneNumber , String zipCode ) {
if ( "Ebay" . equalsIgnoreCase ( type ) )
return new CrunchifyEbay ( phoneNumber , zipCode ) ;
else if ( "Google" . equalsIgnoreCase ( type ) )
return new CrunchifyGoogle ( phoneNumber , zipCode ) ;
 
return null ;
}
 
}

CrunchifyFactoryPatternTest.java
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package com . crunchify . tutorials ;
 
import com . crunchify . tutorials . CrunchfiyCompany ;
import com . crunchify . tutorials . CrunchifyFactoryPattern ;
 
/**
* @author Crunchify.com
*/
 
// Simple Test client program that uses above factory pattern implementation.
 
public class CrunchifyFactoryPatternTest {
 
public static void main ( String [ ] args ) {
CrunchfiyCompany eBay = CrunchifyFactoryPattern . getDetails ( "Ebay" , "408.123.4567" , "98765" ) ;
CrunchfiyCompany google = CrunchifyFactoryPattern . getDetails ( "Google" , "519.123.4567" , "56789" ) ;
System . out . println ( "Factory eBay Config::" + eBay ) ;
System . out . println ( "Factory Google Config::" + google ) ;
}
}

Results
1
2
Factory eBay Config : : Phone #= 408.123.4567, Zip Code= 98765
Factory Google Config : : Phone #= 519.123.4567, Zip Code= 56789

¿Otros ejemplos usando el patrón de fábrica?

  • Los métodos java.util.Calendar, ResourceBundle y NumberFormat getInstance() utilizan el patrón Factory.
  • método valueOf() en clases contenedoras como Boolean, Integer, etc.

Beneficios del patrón de fábrica:

  • Se usa cuando tenemos una superclase con múltiples subclases y, según la entrada, necesitamos devolver una de las subclases. Este patrón elimina la responsabilidad de instanciar una clase desde el programa cliente a la clase de fábrica.
  • El patrón de fábrica proporciona un enfoque del código para la interfaz en lugar de la implementación.
  • El patrón de fábrica elimina la creación de instancias de las clases de implementación reales del código del cliente, lo que lo hace más sólido, menos acoplado y fácil de extender. Por ejemplo, podemos cambiar fácilmente la implementación de la clase de PC porque el programa cliente no lo sabe.
  • El patrón de fábrica proporciona abstracción entre la implementación y las clases de cliente a través de la herencia.

Inconvenientes:

  • La fábrica tiene que ser utilizada para una familia de objetos. Si las clases no amplían la interfaz o la clase base común, no se pueden usar en una plantilla de diseño de fábrica.

Lista de todos los tutoriales de Java Web Development, Spring MVC.