Hoy vamos a echar un vistazo al patrón de método de fábrica que se usa con mucha frecuencia.Después de leer los principios, daremos los códigos fuente de implementación de .NET y JAVA.
definición:
Patrón de método de fábrica: defina una interfaz para crear objetos, pero deje que las subclases decidan qué clase instanciar . El patrón del método de fábrica permite que una clase difiera la creación de instancias a sus subclases .
Patrón de método de fábrica: defina una interfaz para crear un objeto, pero deje que las subclases decidan qué clase instanciar . Factory Method permite que una clase difiera la creación de instancias a las subclases .
Conocido como el Patrón de Fábrica (Factory Pattern)
También conocido como patrón de constructor virtual o patrón de fábrica polimórfica
La clase principal de fábrica es responsable de definir la interfaz pública para crear objetos de productos , mientras que la subclase de fábrica es responsable de generar objetos de productos específicos.
El propósito es retrasar la instanciación de la clase de producto a la subclase de fábrica , es decir, determinar qué clase de producto específica debe instanciarse a través de la subclase de fábrica.
analizar:
• Ya no proporcione una clase de fábrica para que sea responsable de la creación de todas las subclases de manera unificada, sino que transfiera el proceso de creación de subclases específicas a subclases de fábrica especiales para completar
• Si aparece un nuevo tipo de subclase, solo necesita definir una clase de fábrica específica para este nuevo tipo de subclase para crear una instancia de la nueva subclase
Diagrama de clase:
El patrón del método de fábrica contiene los siguientes 4 roles:
Producto (producto abstracto)
ConcreteProduct (producto específico)
Fábrica (fábrica abstracta)
ConcreteFactory (fábrica de hormigón)
aplicabilidad:
1. Cuando una clase no conoce la clase del objeto que debe crear. 2. Cuando una clase quiere que sus subclases especifiquen los objetos que crea. 3. Al * delegar la responsabilidad de la creación de objetos a una de las múltiples * clases auxiliares, y * al querer localizar la información, qué subclase auxiliar es el proxy.
ventaja:
El método de fábrica se utiliza para crear los productos que los clientes necesitan, al tiempo que oculta a los clientes los detalles de qué clase de producto específico se instanciará.
La fábrica puede determinar de forma independiente qué objeto de producto crear , y los detalles de cómo crear este objeto están completamente encapsulados dentro de la fábrica específica.
Al agregar nuevos productos al sistema, cumple completamente con el principio de apertura y cierre.
defecto:
El número de clases en el sistema aumentará en pares , lo que aumenta la complejidad del sistema hasta cierto punto y traerá una sobrecarga adicional al sistema.
Mayor abstracción y dificultad de comprensión del sistema.
Caso 1: (código .NET)
La lista de códigos incluye:
Código fuente de Program.cs
using System;
using System.Configuration;
using System.Reflection;
namespace FactoryMethodSample
{
class Program
{
static void Main(string[] args)
{
LoggerFactory factory;
Logger logger;
//读取配置文件
string factoryString = ConfigurationManager.AppSettings["factory"];
//反射生成对象
factory = (LoggerFactory)Assembly.Load("FactoryMethodSample").CreateInstance(factoryString);
logger = factory.CreateLogger();
logger.WriteLog();
Console.Read();
}
}
}
Registrador.cs
namespace FactoryMethodSample
{
interface Logger
{
void WriteLog();
}
}FileLogger.cs
using System;
namespace FactoryMethodSample
{
class FileLogger : Logger
{
public void WriteLog()
{
Console.WriteLine("文件日志记录。");
}
}
}DatabaseLogger.cs
using System;
namespace FactoryMethodSample
{
class DatabaseLogger : Logger
{
public void WriteLog()
{
Console.WriteLine("数据库日志记录。");
}
}
}
LoggerFactory.cs
namespace FactoryMethodSample
{
interface LoggerFactory
{
Logger CreateLogger();
}
}
FileLoggerFactory.cs
namespace FactoryMethodSample
{
class FileLoggerFactory : LoggerFactory
{
public Logger CreateLogger()
{
//创建文件日志记录器对象
Logger logger = new FileLogger();
//创建文件，代码省略
return logger;
}
}
}
Base de datosLoggerFactory.cs
namespace FactoryMethodSample
{
class DatabaseLoggerFactory : LoggerFactory
{
public Logger CreateLogger()
{
//连接数据库，代码省略
//创建数据库日志记录器对象
Logger logger = new DatabaseLogger();
//初始化数据库日志记录器，代码省略
return logger;
}
}
}
Aplicación.config
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<appSettings>
<add key="factory" value="FactoryMethodSample.FileLoggerFactory"/>
</appSettings>
</configuration>Caso 2: (código JAVA)
Producto
public interface Work {
void doWork();
}
ConcretoProducto
public class StudentWork implements Work {
public void doWork() {
System.out.println("学生*作业!");
}
}
public class TeacherWork implements Work {
public void doWork() {
System.out.println("老师审批作业!");
}
}
Creador
public interface IWorkFactory {
Work getWork();
}
ConcretoCreador
public class StudentWorkFactory implements IWorkFactory {
public Work getWork() {
return new StudentWork();
}
}
public class TeacherWorkFactory implements IWorkFactory {
public Work getWork() {
return new TeacherWork();
}
}
Prueba
public class Test {
public static void main(String[] args) {
IWorkFactory studentWorkFactory = new StudentWorkFactory();
studentWorkFactory.getWork().doWork();
IWorkFactory teacherWorkFactory = new TeacherWorkFactory();
teacherWorkFactory.getWork().doWork();
}
}
El programa se ejecuta y devuelve el resultado:
¡Los estudiantes hacen su tarea! ¡ El maestro aprueba la tarea!