精华内容
下载资源
问答
  • 工厂方法模式
    万次阅读
    2022-02-18 14:40:23


    前言

    在现实生活中社会分工越来越细,越来越专业化。各种产品有专门的工厂生产,彻底告别了自给自足的小农经济时代,这大大缩短了产品的生产周期,提高了生产效率。同样,在软件开发中能否做到软件对象的生产和使用相分离呢?能否在满足“开闭原则”的前提下,客户随意增删或改变对软件相关对象的使用呢?这就是本节要讨论的问题。

    在简单工厂模式中,我们提到了简单工厂模式违背了开闭原则,而“工厂方法模式”是对简单工厂模式的进一步抽象化,其好处是可以使系统在不修改原来代码的情况下引进新的产品,即满足开闭原则。


    一、定义

    工厂方法模式(FACTORY METHOD)是一种常用的类创建型设计模式,此模式的核心精神是封装类中变化的部分,提取其中个性化善变的部分为独立类,通过依赖注入以达到解耦、复用和方便后期维护拓展的目的。
    它的核心结构有四个角色:

    • 抽象工厂(Abstract Factory):提供了创建产品的接口,调用者通过它访问具体工厂的工厂方法 newProduct() 来创建产品。
    • 具体工厂(ConcreteFactory):主要是实现抽象工厂中的抽象方法,完成具体产品的创建。
    • 抽象产品(Product):定义了产品的规范,描述了产品的主要特性和功能。
    • 具体产品(ConcreteProduct):实现了抽象产品角色所定义的接口,由具体工厂来创建,它同具体工厂之间一一对应。

    二、使用场景

    工厂方法经常用在以下两种情况中:

    第一种情况是对于某个产品,调用者清楚地知道应该使用哪个具体工厂服务,实例化该具体工厂,生产出具体的产品来。Java Collection中的iterator() 方法即属于这种情况。

    第二种情况,只是需要一种产品,而不想知道也不需要知道究竟是哪个工厂为生产的,即最终选用哪个具体工厂的决定权在生产者一方,它们根据当前系统的情况来实例化一个具体的工厂返回给使用者,而这个决策过程这对于使用者来说是透明的。


    三、代码样例

    1.需求

    延续简单工厂模式的计算器控制台程序,要求输入两个数和运算符号,得到结果。

    2.类图

    在这里插入图片描述

    3.工厂相关类

    /**
     * 工厂接口
     * 
     */
    public interface IFactory {
        public Operation createOperation();
    }
    
    class AddFactory implements IFactory {
    
        @Override
        public Operation createOperation() {
    	return new OperationAdd();
        }
    
    }
    
    class SubFactory implements IFactory {
    
        @Override
        public Operation createOperation() {
    	return new OperationSub();
        }
    
    }
    
    class MulFactory implements IFactory {
    
        @Override
        public Operation createOperation() {
    	return new OperationMul();
        }
    
    }
    
    class DivFactory implements IFactory {
    
        @Override
        public Operation createOperation() {
    	return new OperationDiv();
        }
    
    }
    

    4.产品相关类

    /**
     * 操作类抽象类
     * 
     */
    public abstract class Operation {
        public double numberA;
        public double numberB;
    
        public abstract double result();
    }
    
    /**
     * 加法类
     * 
     */
    public class OperationAdd extends Operation {
    
        @Override
        public double result() {
    	return numberA + numberB;
        }
    
    }
    
    /**
     * 除法类
     * 
     */
    public class OperationDiv extends Operation {
    
        @Override
        public double result() {
    	if (numberB == 0) {
    	    throw new RuntimeException("divided by 0");
    	}
    	return numberA / numberB;
        }
    
    }
    
    /**
     * 乘法类
     * 
     */
    public class OperationMul extends Operation {
    
        @Override
        public double result() {
    	return numberA * numberB;
        }
    
    }
    
    /**
     * 减法类
     * 
     */
    public class OperationSub extends Operation {
    
        @Override
        public double result() {
    	return numberA - numberB;
        }
    
    }
    

    5.客户端

    /**
     * 工厂方法客户端
     * 
     */
    public class FactoryClient {
        public static void main(String[] args) {
    	IFactory operFactory = new DivFactory();
    	Operation operation = operFactory.createOperation();
    
    	operation.numberA = 3.4;
    	operation.numberB = 4.5;
    
    	System.out.println(operation.result());
    
        }
    }
    

    四、优缺点

    优点

    • 用户只需要知道具体工厂的名称就可得到所要的产品,无须知道产品的具体创建过程。
    • 灵活性增强,对于新产品的创建,只需多写一个相应的工厂类。
    • 典型的解耦框架。高层模块只需要知道产品的抽象类,无须关心其他实现类,满足迪米特法则、依赖倒置原则和里氏替换原则。

    缺点:

    • 在添加新产品时,要编写新的具体产品类,并要提供与之对应的具体工厂类。系统软件个数也成对增加,从而增加了系统的复杂度,带来更多开销
    • 由于系统的可扩展性,在客户端中要引入抽象层进行定义,从而增加了系统的抽象性和理解难度
    • 抽象产品只能生产一类产品

    结尾

    • 感谢大家的耐心阅读,如有建议请私信或评论留言。
    • 如有收获,劳烦支持,关注、点赞、评论、收藏均可,博主会经常更新,与大家共同进步
    更多相关内容
  • 工厂方法模式

    万次阅读 多人点赞 2019-05-31 20:40:44
    本章将通过如何克服简单工厂模式的不足来引出工厂方法模式,并通过实例来学习工厂方法模式,理解工厂方法模式的结构及特点,学会如何在实际软件项目开发合理地使用工厂方法模式。 本章知识点 工厂方法模式的定义 ...

    工厂方法模式

    本章导学

    工厂方法模式是简单工厂模式的延伸,它继承了简单工厂模式的优点,同时还弥补了简单工厂模式的缺陷,更好地符合开闭原则的要求,在增加新的具体产品对象时不需要对已有的系统做任何修改。
    本章将通过如何克服简单工厂模式的不足来引出工厂方法模式,并通过实例来学习工厂方法模式,理解工厂方法模式的结构及特点,学会如何在实际软件项目开发合理地使用工厂方法模式。

    本章知识点

    1. 工厂方法模式的定义
    2. 工厂方法模式的结构
    3. 工厂方法模式的实现
    4. 工厂方法模式的应用
    5. 工厂方法模式的优/缺点
    6. 工厂方法模式的适用环境
    7. 配量文件与反射
    8. 工厂方法的重载
    9. 工厂方法的隐藏

    工厂方法模式概述

    考虑这样一个系统,使用简单工厂模式设计的按钮工厂类可以返回一个具体类型的 按钮实例,例如圆形按钮矩形按钮、菱形按钮等。
    在这里插入图片描述
    在这个系统中如果需要增加一种新类型的按钮,例如椭圆形按钮,那么除了增加一个新的具体产品类之外还需要修改工厂类的代码,这就使得整个设计在一定程度上违反了开闭原则。
    现在对该系统进行修改,不再提供一个按钮工厂类来统一负责所有产品的创建,而是将具体按钮的创建过程交给专门的工厂子类去完成。先定义一个抽象的按钮工厂类,再定义具体的工厂类来生产圆形按钮、矩形按钮、菱形按钮等,它们实现了在抽象按钮工厂类中声明的方法。这种抽象化的结果是使得这种结构可以在不修改具体工厂类的情况下引进新的产品,如果出现新的按钮类型,只需要为这种新类型的按钮定义一个具体的工厂类就可以创建该新按钮的实例,这种改进的设计方案即为工厂方法模式。工厂方法模式通过引入抽象的工厂类,使得它具有超越简单工厂模式的优越性,让系统更加符合开闭原则。
    在这里插入图片描述
    在工厂方法模式中不再提供一个统一的工厂类来创建所有的产品对象,而是针对不同的产品提供不同的工厂,系统提供一个与产品等级结构对应的工厂等级结构。
    工厂方法模式的定义如下:
    工厂方法模式:定义一个用于创建对象的接口,但是让子类决定将哪一个类实例化。工厂方法模式让一个类的实例化延迟到其子类。

    工厂方法模式简称为工厂模式( Factory Pattern),又可称作虚拟构造器模式('Virtual
    Constructor Pattern)或多态工厂模式( Polymorphic Factory Pattern)。工厂方法模式是种类创建型模式。在工厂方法模式中,工厂父类负责定义创建产品对象的公共接口,而工厂子类负责生成具体的产品对象,这样做的目的是将产品类的实例操作延迟到工厂子类中完成,即通过工厂子类来确定究竟应该实例化哪一个具体产品类

    工厂方法模式结构与实现

    工厂方法模式结构

    工厂方法模式提供一个抽象工厂接口来声明抽象工厂方法,而由其子类来具体实现
    工厂方法,创建具体的产品对象。
    在这里插入图片描述
    工厂方法模式包含以下4个角色。
    (1) Product(抽象产品):它是定义产品的接口,是工厂方法模式所创建对象的超类型,也就是产品对象的公共父类
    (2) ConcreteProduct(具体产品):它实现了抽象产品接口,某种类型的具体产品由专门的具体工厂创建,具体工厂和具体产品之间一一对应
    (3) Factory(抽象工厂):在抽象工厂类中声明了工厂方法( Factory Method),用于返回一个产品。抽象工厂是工厂方法模式的核心,所有创建对象的工厂类都必须实现该接口。
    (4) ConcreteFactory(具体工厂):它是抽象工厂类的子类,实现了在抽象工厂中声明的工厂方法,并可由客户端调用,返回一个具体产品类的实例

    工厂方法模式实现

    与简单工厂模式相比,工厂方法模式最重要的特点是引入了抽象工厂角色,抽象工厂可以是接口,也可以是抽象类或者具体类。其典型代码如下:

    public interface Factory {
    	public Product factoryMethod();
    }
    

    在抽象工厂中声明了工厂方法但并未实现工厂方法,具体产品对象的创建由其子类负责,客户端针对抽象工厂编程,可在运行时再指定具体工厂类,具体工厂类实现了工厂方法,不同的具体工厂可以创建不同的具体产品。其典型代码如下:

    public class ConcreteFactory implements Factory {
    	public Product factoryMethod() {
    		return new ConcreteProduct();
    	}
    }
    

    在实际使用时,具体工厂类在实现工厂方法时除了创建具体产品对象之外,还可以负责产品对象的初始化工作以及一些资源和环境配置工作,例如连接数据库、创建文件等。在客户端代码中,开发人员只需关心工厂类即可,不同的具体工厂可以创建不同的产品。典型的客户端代码片段如下:

    Factory factory;
    //可通过配置文件与反射机制实现
    factory = new ConcreteFactory();
    Product product;
    product= factory.factoryMethod();
    

    可以通过配置文件来存储具体工厂类 ConcreteFactory的类名,再通过反射机制创建具体工厂对象,在更换新的具体工厂时无须修改源代码,系统扩展更为方便

    工厂方法模式应用实例

    下面通过一个应用实例来进一步学习和理解工厂方法模式。

    1. 实例说明

    某系统运行日志记录器( Logger)可以通过多种途径保存系统的运行日志,例如通过文件记录或数据库记录,用户可以通过修改配置文件灵活地更换日志记录方式。在设计各类日志记录器时,开发人员发现需要对日志记录器进行一些初始化工作,初始化参数的设置过程较为复杂,而且某些参数的设置有严格的先后次序,否则可能会发生记录失败。 为了更好地封装记录器的初始化过程并保证多种记录器切换的灵活性,现使用工厂方法模式设计该系统(注:在Java中常用的日志记录工具有SLF4J、Log4、GCLog Viewer、Logstash等)。
    2.实力类图
    通过分析,本实例结构图如下
    在这里插入图片描述
    在图4-4中, Logger接口充当抽象产品,其子类 FileLogger和 DatabaseLogger充当具体产品, LoggerFactory接口充当抽象工厂,其子类 FileLoggerFactory和DatabaseLoggerFactory充当具体工厂。

    3.实例代码
    (1)Logger:日志记录器接口,充当抽象产品角色。

    //desagmpatterns.factorymethod Logger. Java
    package designpatterns. factorymethod;
    
    public interface Logger {
    	public void writeLog();
    }
    

    (2) DatabaseLogger:数据库日志记录器,充当具体产品角色

    //designpatterns.factorymethod. DatabaseLogger.java
    package designpatterns.factorymethod
    
    public class DatabaseLogger implements Logger {
    	public void writeLog() {
    		System.out.println("数据库日志记录");
    	}
    

    (3) Filelogger:文件日志记录器,充当具体产品角色。

    public class FileLogger implements Logger {
    	public void writeLog() {
    		System.out.printin("文件日志记录");
    	}
    }
    

    (4) LoggerFactory:日志记录器工厂接口,充当抽象工厂角色

    public interface LoggerFactory {
    	public Logger createLogger(); // 抽象工厂方法
    }
    

    (5) DatabaseFactory:数据库日志记录器工厂类,充当具体工厂色

    public class DatabaseLoggerFactory implements LoggerFactory {
    	public Logger createLogger(){
    		//连接数据库,代码省略
    		//创建数据库日志记录器对象
    		Logger logger= new DatabaseLogger();
    		//初始化数据库日志记录器,代码省略
    		return logger;
    	}
    }
    

    (6) FileLoggerFactory:文件日志记录器工厂类,充当具体工厂角色

    public class FileLoggerFactory implements LoggerFactory{
    	public Logger createlogger() {
    		// 创建文件日志记录器对象
    		Logger logger= new FileLogger();
    		//创建文件,代码省略
    		
    		return logger;
    	}
    } 
    

    (7) Client:客户端测试类

    public class Client {
    	public static vold main(string []args){
    		LoggerFactory factory;
    		Logger logger;
    		factory = new FileloggerFactory();//可引入配置文件和反射机制实现
    		logger = factory.createlogger();
    		logger.writeLog();
    	}
    }
    

    结果及分析
    编译并运行程序,输出结果如下

    文件日志记录
    

    如果需要更换日志记录器,只需要修改客户端代码中的具体工厂类的类名即可,例如将FileLoggerFactory改为 DatabaseLoggerFactory,此时输出结果如下:

    数据库日志记录
    

    如果需要增加并使用新的日志记录器,只需要对应增加一个新的具体工厂类,然后在客户端代码中修改具体工厂类的类名,原有类库的源代码无须做任何修改。通过引入配置文件并使用反射机制可以实现在不修改客户端代码的基础上更换具体工厂类,在下面将详细说明其实现过程,让系统更加符合开闭原则,具备更好的灵活性和可扩展性。

    反射机制与配置文件

    在上一节的日志记录器实例中,在更换日志记录器时需要修改客户端代码,对于客户端而言并不符合开闭原则,本节将介绍如何在不修改任何客户端代码的基础上更换或增加新的日志记录方式。
    在实际应用开发中可以对具体工厂类的实例化过程进行改进,在客户端代码中不直接使用new关键字来创建工厂对象,而是通过Java反射机制结合配置文件(例如XML文件)来生成具体工厂对象。在整个实现过程中需要用到两个技术,即Java反射机制与配置文件。
    1.Java反射机制
    Java反射( Java Reflection)是指在程序运行时获取已知名称的类或已有对象的相关信息的一种机制,包括类的方法、属性、父类等信息,还包括实例的创建和实例类型的判断等。在反射中使用最多的类是 Class, Class类的实例表示正在运行的Java应用程序中的类和接口,其 forName(String className)方法可以返回与带有给定字符串名的类或接口相关联的Class对象,再通过 Class对象的 newInstance()方法创建此对象所表示的类的一个新实例,即通过一个类名字符串得到类的实例。例如创建一个字符串类型的对象,其代码如下:

    //通过类名生成实例对象并将其返回
    Class c = Class.forName("java.lang.String");
    Object obj = c .newInstance();
    return obj;
    

    此外,在JDK中还提供了java.lang.reflect包,封装了其他与反射相关的类,在本书中只用到上述简单的反射代码,在此不予扩展。
    2.配置文件
    软件系统的配置文件通常为XML文件,可以使用DOM( Document Object Model)、SAX( Simple API for XMl.)、StAx( Streaming API for XML.)等技术来处理XML文件。在软件开发中可以把类名存储到XML配置文件中,再读取配置文件获取类名字符串,然后通过Java反射机制来创建对象。例如将上一小节的具体日志记录器工厂类类名FileLoggerFactory存储在如下XML格式的配置文件 c

    <!-- config.xml -->
    <?xml version ="1.0"?>
    <config>
    <className>designpatterns.factorymethod.FileLoggerFactory</className>
    </config>
    

    在该文件中, designpatterns.factorymethod为具体工厂类所在的包名, FileLoggerFactory 为具体工厂类的类名。
    为了读取该配置文件,并通过存储在其中的类名字符串反射生成对象,可以创建一个工具类XMLUtil,其详细代码如下

    package design.simplefactory;
    
    import java.io.IOException;
    
    import javax.xml.parsers.DocumentBuilder;
    import javax.xml.parsers.DocumentBuilderFactory;
    import javax.xml.parsers.ParserConfigurationException;
    
    import org.w3c.dom.Document;
    import org.w3c.dom.Node;
    import org.w3c.dom.NodeList;
    import org.xml.sax.SAXException;
    
    public class XMLUtil {
    	public static Object getBean() {
    		DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
    		DocumentBuilder builder = null;
    		try {
    			builder = factory.newDocumentBuilder();
    			
    			Document document = builder.parse("src/design/config.xml");
    			
    			// 获取包含类名的文本节点
    			NodeList list = document.getElementsByTagName("className");
    			Node classNode = list.item(0).getFirstChild();
    			String cName = classNode.getNodeValue().trim();
    			Class c = Class.forName(cName);
    			Object obj = c.newInstance();
    			return obj;
    		} catch (ParserConfigurationException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} catch (SAXException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		
    		return null;
    	}
    
    }
    
    

    注:在后续的设计模式学习过程中将多次重用该类。
    有了 XMLUtiI类之后,可以对日志记录器的客户端代码进行修改,不再直接使用new关键字来创建具体的工厂类,而是将具体工厂类的类名存储在XML文件中,再通过XMLUtil类的静态工厂方法 getBean()进行对象的实例化,将代码修改如下:

    public class Client {
    	public static vold main(string []args){
    		LoggerFactory factory;
    		Logger logger;
    		// getBean()的返回值类型为Object,需要进行强制类型转换
    		factory = (LoggerFactory) XMLUtil.getBean();
    		logger = factory.createlogger();
    		logger.writeLog();
    	}
    }
    

    在引入 XMLUti类和XM配置文件之后,如果需要增加一种新类型的日志记录方式只需要执行以下4个步:
    (1)新的日志记录器需要继承抽象日志记录器 Logger
    (2)对应增加一个新的具体日志记录器工厂,继承抽象日志记录器工厂LoggerFacto
    ry,并实现其中的工厂方法 createLogger(),设置好初始化参数和环境变量,返回具体日志记录器对象。
    (3)修改配置文件 config.xml,用新增的具体日志记录器工厂类的类名字符替换原有工厂类的类名字符串
    (4)编译新增的具体日志记录器类和具体日志记录器工厂类,运行客户端测试类即可使用新的日志记录方式,而原有类库代码无须做任何修改,完全符合开闭原则

    通过上述重构可以使系统更加灵活,由于很多设计模式都关注系统的可扩展性和灵活性,因此都定义了抽象层,在抽象层中声明业务方法,而将具体业务方法的实现放在实现层中。为了更好地体现这些设计模式的特点,本书在很多设计模式中都使用XML配置文件和Java反射机制来创建对象。

    工厂方法的重载

    在某些情况下,可以通过多种方式来初始化同一个产品类。例如上面所提到的日志记录器类,可以为各种日志记录器提供默认实现;还可以为数据库日志记录器提供数据库连接字符串,为文件日志记录器提供文件路径;也可以将相关参数封装在一个 Object类型的对象中,通过 Object对象将配置参数传入工厂类。此时可以提供一组重载的工厂方法,以不同的方式对产品对象进行创建。当然,对于同一个具体工厂而言,无论使用哪个工厂方法,所创建的产品类型均要相同。重载的工厂方法结构图如图所示。
    在这里插入图片描述

    引入重载方法后,抽象工厂类LoggerFactory的代码修改如下:

    public interface LoggerFactory{
    	public Logger createLogger();
    	public Logger createLogger(String args);
    	public Logger createLogger(Object obj);
    }
    
    

    具体工厂类 DatabaseLoggerFactory的代码修改如下

    public class DatabaseLoggerFactory implements LoggerFactory{
    	public Logger createLogger(){
    			//使用默认方式连接数据库,代码省略
    			Logger logger = new DatabaseLogger();
    			//初始化数据库日志记录器,代码省略
    			return logger;
    	}
    	public Logger createLogger(String args){
    		//使用参数args作为连接字符串来连接数据库,代码省略
    		Logger logger = new DatabaseLogger();
    		//初始化数据库日志记录器,代码省略
    		return logger;
    	}
    	public Logger createLogger(Object obj){
    		//使用封装在参数objb中的连接字符串来连接数据库,代码省略
    		Logger logger = new DatabaseLogger();
    		//使用封装在参数obj中的数据来初始化数据库志记录器,代码省略
    		return logger;
    	}
    	
    }
    	//其他具体工厂类代码省略
    
    

    在抽象工厂中声明了多个重载的厂方法,在具体工厂中实现了这些工了方法,这些方法可以包含不同的业务逻辑,以满足产品对象的多样化创建需求。

    工厂方法的隐藏

    有时候,为了进一步简化客户端的使用,还可以对客户端隐藏工厂方法,此时在工厂类中直接调用产品类的业务方法,客户端无须调用工厂方法创建产品对象,直接使用工厂对象即可调用所创建的产品对象中的业务方法。
    如果对客户端隐藏工厂方法,那么如图4-4所示的日志记录器结构图可修改为如图所示的结构图

    在这里插入图片描述
    在图4-6中,抽象工厂类 LoggerFactory的代码修改如下:

    //将接口改为抽象类
    public abstract class LoggerFactory{
    	//在工厂类中直接调用日志记录器类的业务方法 
    	public void writeLog(){
    		Logger logger = this.createLogger();
    		logger.writeLog();
    	}
    	public abstract logger createLogger();
    }
    

    客户端代码修改如下:

    public class Client{
    	public static void main(String [] args) {
    		LoggerFactory factory;
    		factory = (LoggerFactory) XMLUtil.getBean();
    		//直接使用工厂对象来调用产品对象的业务方法
    		factory.writeLog();
    	}
    }
    

    通过把业务方法的调用移至工厂类中,可以直接使用工厂对象来调用产品对象的业务方法,客户端无须使用工厂方法来创建产品对象。在某些情况下可以使用这种设计方案。

    工厂方法模式优/缺点与适用环境

    工厂方法模式是简单工厂模式的延伸,它继承了简单厂模式的优点,同时还弥补了简单工厂模式的不足。工厂方法模式是使用频率最高的设计模式之一,是很多开源框架和API类库的核心模式。
    工厂方法模式优点
    (1)在工厂方法模式中,工厂方法用来创建客户所需要的产品,同时还向客户隐藏了哪种具体产品类将被实例化这一细节,用户只需要关心所需产品对应的工厂,无须关心创建细节,甚至无需知道具体产品类的类名。
    (2)基于工厂角色和产品角色的多态性设计是工厂方法模式的关键。它能够让工厂自主确定创建何种产品对象,而如何创建这个对象的细节完全封装在具体工厂内部。工厂方法模式之所以又被称为多态工厂模式,正是因为所有的具体工厂类都具有同一抽象父类。
    (3)使用工厂方法模式的另一个优点是在系统中加入新产品时无须修改抽象工厂和抽象产品提供的接口,无须修改客户端,也无须修改其他的具体工厂和具体产品,只需要添加一个具体工厂和具体产品即可,这样系统的可扩展性也就变得非常好,完全符合开闭原则。
    工厂方法模式缺点
    工厂方法模式的缺点主要如下:
    (1)在添加新产品时需要编写新的具体产品类,而且还要提供与之对应的具体工厂类,系统中类的个数将成对增加,在一定程度上增加了系统的复杂度,有更多的类需要编译和运行,会给系统带来一些额外的开销。
    (2)由于考虑到系统的可扩展性,需要引入抽象层,在客户端代码中均使用抽象层进行定义,增加了系统的抽象性和理解难度。
    工厂方法模式适用环境
    在以下情况下可以考虑使用工厂方法模式:
    (1)客户端不知道它所需要的对象的类。在工厂方法模式中,客户端不需要知道具体产品类的类名,只需要知道所对应的工厂即可,具体产品对象由具体工厂类创建,可将具体工厂类的类名存储在配置文件或数据库中。
    (2)抽象工厂类通过其子类来指定创建哪个对象。在工厂方法模式中,对于抽象工厂类只需要提供一个创建产品的接口,而由其子类来确定具体要创建的对象,利用面向对象的多态性和里氏代换原则,在程序运行时子类对象将覆盖父类对象,从而使得系统更容易扩展。

    本章小结

    1. 在工厂方法模式中定义一个用于创建对象的接口,但是让子类决定将哪一个类实化。工厂方法模式让一个类的实例化延迟到其子类,它是一种类创建型模式。
    2. 工厂方法模式包含抽象产品、具体产品、抽象工厂和具体工厂4个角色。其中,抽产品是定义产品的接口;具体产品实现了抽象产品接口,某种类型的具体产品由专门的具体工厂创建;抽象工厂声明了工厂方法,用于返回一个产品;具体工厂是抽象工厂类的子类,实现了在抽象工厂中声明的工厂方法,返回一个具体产品类的实例。
    3. 工厂方法模式的优点主要是提供了专门的工厂方法用来创建客户所需要的产品,同时还向客户隐藏了哪种具体产品类将被实例化这一细节;它能够让工厂自主确定创建何种产品对象,而如何创建这个对象的细节完全封装在具体工厂内部;在系统中加入新产品时完全符合开闭原则。其缺点主要是系统中类的个数将成对增加,在一定程度上增加了系统的复杂度,会给系统带来一些额外的开销;增加了系统的抽象性和理解难度。
    4. 工厂方法模式适用于以下环境:客户端不知道它所需要的对象的类;抽象工厂类通过其子类来指定创建哪个对象。
    5. 通过引入配置文件和反射机制将具体工厂类的类名存储在配置文件中,然后使用反射来生成工厂对象,使得系统可以在不修改任何已有代码的基础上能够增加新的产品类,完全符合开闭原则。
    6. 在抽象工厂中可以声明多个重载的工厂方法,在具体工厂中实现了这些工厂方法,这些方法可以包含不同的业务逻辑,以满足产品对象的多样化创建需求
    7. 在工厂类中可以直接调用产品类的业务方法,客户端无须调用工厂方法创建产品对象,直接使用工厂对象即可调用所创建的产品对象中的业务方法,实现对工厂方法的隐藏。
    展开全文
  • 工厂方法模式(Factory Method) 抽象工厂模式 (Abstract Factory) 但是在实际过程中还有一种工厂模式经常被使用,那就是 简单工厂模式(Simple Factory)。有一种常见的分类的方法:根据产品是由具体产品还是...
  • 类图说明二、工厂方法模式1.描述2.特点3.适用场景4.类图说明5.简单工厂模式与工厂方法模式区别:三、抽象工厂模式1.描述2.特点3.优缺点4.类图说明结尾 前言 简单工厂模式、工厂方法模式、抽象工厂模式比较相像,很...


    前言

    简单工厂模式、工厂方法模式、抽象工厂模式比较相像,很多同学傻傻分不清楚,本文进行详细对比说明,建议对三个模式有一定基础再进行阅读,如不了解可查看往期文章。

    一、简单工厂模式

    1.描述

    简单工厂模式是属于创建型模式,又叫做静态工厂方法(Static Factory Method)模式,但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式,可以理解为是不同工厂模式的一个特殊实现。

    2.特点

    • 它是一个具体的类,非接口 抽象类。有一个重要的create()方法,利用if或者switch创建产品并返回。

    • create()方法通常是静态的,所以也称之为静态工厂。

    3.优缺点

    缺点:

    • 扩展性差(我想增加一种面条,除了新增一个面条产品类,还需要修改工厂类方法)

    • 不同的产品需要不同额外参数的时候 不支持。

    4.类图说明

    Factory(工厂):核心部分,负责实现创建所有产品的内部逻辑,工厂类可以被外界直接调用,创建所需对象

    Product(抽象类产品):工厂类所创建的所有对象的父类,封装了产品对象的公共方法,所有的具体产品为其子类对象

    ConcreteProduct(具体产品):简单工厂模式的创建目标,所有被创建的对象都是某个具体类的实例。它要实现抽象产品中声明的抽象方法(有关抽象类)

    在这里插入图片描述


    二、工厂方法模式

    1.描述

    提供一个用于创建对象的接口(工厂接口),让其实现类(工厂实现类)决定实例化哪一个类(产品类),并且由该实现类创建对应类的实例。

    2.特点

    • 可以一定程度上解耦,消费者和产品实现类隔离开,只依赖产品接口(抽象产品),产品实现类如何改动与消费者完全无关。

    • 可以一定程度增加扩展性,若增加一个产品实现,只需要实现产品接口,修改工厂创建产品的方法,消费者可以无感知(若消费者不关心具体产品是什么的情况)。

    • 可以一定程度增加代码的封装性、可读性。清楚的代码结构,对于消费者来说很少的代码量,就可以完成很多工作。

    另外,抽象工厂才是实际意义的工厂模式,工厂方法只是抽象工厂的一个比较常见的情况。

    3.适用场景

    消费者不关心它所要创建对象的类(产品类)的时候。

    消费者知道它所要创建对象的类(产品类),但不关心如何创建的时候。

    例如:hibernate里通过sessionFactory创建session、通过代理方式生成ws客户端时,通过工厂构建报文中格式化数据的对象。

    4.类图说明

    提供一个产品类的接口。产品类均要实现这个接口(也可以是abstract类,即抽象产品)。

    提供一个工厂类的接口。工厂类均要实现这个接口(即抽象工厂)。

    由工厂实现类创建产品类的实例。工厂实现类应有一个方法,用来实例化产品类
    在这里插入图片描述

    5.简单工厂模式与工厂方法模式区别:

    • 简单工厂模式:本着高内聚低耦合的原则,将系统的逻辑部分和功能分开。

    • 工厂方法模式:和“简单工厂模式”不同的地方,是加入了“开放-封闭原则”(软件实体类、模块或者函数等等,应该可以扩展,但是不可以修改)规则,将简单工厂的内部判断逻辑,移动到了客户端代码来进行,在扩展新功能的时候,简单工厂模式要修改工厂类,工厂方法模式是只需要修改客户端。


    三、抽象工厂模式

    1.描述

    抽象工厂模式(Abstract Factory Pattern),是围绕一个超级工厂创建其他工厂。

    该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。

    在抽象工厂模式中,接口是负责创建一个相关对象的工厂,不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

    2.特点

    • 意图:提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。

    • 主要解决:主要解决接口选择的问题。

    • 何时使用:系统的产品有多于一个的产品族,而系统只消费其中某一族的产品。

    • 如何解决:在一个产品族里面,定义多个产品。

    • 关键代码:在一个工厂里聚合多个同类产品。

    3.优缺点

    优点:
    当一个产品族中的多个对象,被设计成一起工作时,它能保证客户端始终只使用同一个产品族中的对象。
    缺点:
    产品族扩展非常困难,要增加一个系列的某一产品,既要在抽象的 Creator 里加代码,又要在具体的里面加代码。

    4.类图说明

    我们将创建 Shape 和 Color 接口,实现这些接口的实体类。

    下一步是创建抽象工厂类 AbstractFactory。

    接着定义工厂类 ShapeFactory 和 ColorFactory,这两个工厂类都是扩展了AbstractFactory。

    然后创建一个工厂创造器/生成器类 FactoryProducer。

    AbstractFactoryPatternDemo 类使用FactoryProducer 来获取 AbstractFactory 对象。

    它将向 AbstractFactory 传递形状信息 Shape(CIRCLE / RECTANGLE / SQUARE),以便获取它所需对象的类型。

    同时它还向 AbstractFactory 传递颜色信息 Color(RED / GREEN / BLUE),以便获取它所需对象的类型。
    在这里插入图片描述


    结尾

    • 感谢大家的耐心阅读,如有建议请私信或评论留言。
    • 如有收获,劳烦支持,关注、点赞、评论、收藏均可,博主会经常更新,与大家共同进步
    展开全文
  • 关于简单工厂模式,工厂方法模式,抽象工厂模式的一次总结 模式 定义 简单工厂模式 定义一个工厂类,它可以根据参数的不同返回不同类的实例,被创建的实例通常都具有共同的父类。 工厂方法模式 定义一个...

    LOG:更新日志

    • 2019-3-29 第一次完成此文章V1.0.0版本
    • 2019-4-10 更新标题,增加了“java版”字样,文章版本更新至V1.0.1

    一、简单工厂模式,工厂方法模式,抽象工厂模式定义

    模式定义
    简单工厂模式定义一个工厂类,它可以根据参数的不同返回不同类的实例,被创建的实例通常都具有共同的父类
    工厂方法模式定义一个用于创建对象的接口,但是让子类决定将哪一个类实例化。工厂方法模式让一个类的实例化延迟到其子类
    抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类

    PS:简单工厂模式不是GOF 23种设计模式之一!它只是日常编程中一种常用的方法或者说是这是一种习惯。

    PS:文中部分看不懂的名词文末都有解释。

    二、三种工厂模式的优缺点以及适用场景

    简单工厂模式优缺点以及适用场景

    • 优点

      1. 实现了对象创建和使用的分离(即业务逻辑和界面逻辑分离)。
      2. 客户端无需知道所创建的具体产品类的类名,只需知道具体产品类所对应的参数即可。
      3. 通过引入配置文件,可以在不修改任何客户端代码的情况下更换和增加新的具体产品类,在一定程度上提高了系统的灵活性。
    • 缺点

      1. 工厂类集中了所有产品的逻辑,职责过重,一旦不能工作,整个系统都要受到影响。
      2. 增加系统中类的个数,增加了系统的复杂度和理解难度。
      3. 系统扩展困难,一旦添加新产品不得不修改工厂逻辑。
      4. 由于使用了静态工厂方法,造成工厂角色无法形成基于继承的等级结构,工厂类不能得到很好地扩展。
    • 适用环境

      1. 工厂类负责创建的对象比较少,由于创建的对象较少,不会造成工厂方法中的业务逻辑太过复杂。
      2. 客户端只知道传入工厂类的参数,对于如何创建对象并不关心。

    工厂方法模式优缺点以及适用场景

    • 优点

      1. 符合开放-关闭原则(简称开-闭原则)
      2. 将创建对象的逻辑与任务交给了工厂类
    • 缺点

      1. 每次新增产品,产品类都需要创建对应工厂类,增加了系统的开销
    • 适用场景

      1. 创建某些类的对象的逻辑比较复杂, 并且有很多分支条件,而且还可能增加新的条件。
      2. 一个类不知道它所需要的对象的类 。
      3. 一个类通过其子类来指定创建哪个对象。
      4. 需要封装创建类的对象的逻辑, 使得这些逻辑局部化。

    抽象工厂模式优缺点以及适用场景

    • 优点

      1. 隔离了具体类的生成, 使得客户端并不需要知道什么被创建。

      2. 当一个产品族中的多个对象被设计成一起工作时,它能够保证客户端始终只使用同一个产品族中的对象。

      3. 增加新的产品族很方便,无须修改已有系统,符合开闭原则

        PS:抽象工厂模式有符合开闭原则的情况,也有不符合开闭原则的情况!!!
        PS:抽象工厂模式有符合开闭原则的情况,也有不符合开闭原则的情况!!!
        PS:抽象工厂模式有符合开闭原则的情况,也有不符合开闭原则的情况!!!

    • 缺点

      1. 增加新的产品等级结构麻烦,需要对原有系统进行较大的修改,甚至需要修改抽象层代码,这显然会带来较大的不便,违背了开闭原则
    • 适用场景

      1. 一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节。
      2. 系统中有多于一个的产品族,但每次只使用其中某一产品族。
      3. 属于同一个产品族的产品将在一起使用, 这一约束必须在系统的设计中体现出来。
      4. 产品等级结构稳定, 设计完成之后,不会向系统中增加新的产品等级结构或者删除已有的产品等级结构。

    三、名词解释

    1. 开放-关闭原则(开闭原则): 用抽象构建架构,用实现扩展细节。
      PS:讲人话就是不修改源代码。

    2. 产品等级结构: 产品等级结构即产品的继承结构

    3. 产品族: 产品族是指由同一个工厂生产的,位于不同产品等级结构中的一组产品

    下面用一张图描述到底什么是产品族,什么是产品等级结构。这种图叫做相图
    横着的表示不同种类的产品,竖着的表示同一种类产品的不同类型。
    例子:
    一行表示一部手机的组成:CPU(处理器)、RAM(运行内存)、ROM(机身存储)
    一列比如可以表示如下
    CPU有:骁龙855、骁龙845、骁龙835
    RAM有:4G、8G、16G
    ROM有:64G、128G、256G
    在这里插入图片描述
    简单工厂模式,工厂方法模式以及抽象工厂模式的相图(博主自己理解画的)
    在这里插入图片描述

    四、简单工厂模式、工厂方法模式与抽象工厂模式之间的区别

    • 简单工厂模式与工厂方法模式区别:
    1. 简单工厂模式不符合开闭原则,工厂方法模式符合开闭原则。
    2. 两个模式中心不同。简单工厂模式的中心是一个实体工厂类,工厂方法模式的中心是抽象工厂类或接口。
    3. 简单工厂模式中,工厂类包含创建对象的逻辑判断(如:if…else或switch…case);工厂方法 模式中,不必包含创建对象的逻辑判断。
    • 工厂方法模式与抽象工厂模式区别:
    1. 工厂方法模式中一个实体工厂类只能创建一种实体产品类;抽象工厂模式中一个实体工厂类可以创建多种实体产品类。

      PS:讲人话就是,工厂方法模式:一个工厂一种产品抽象工厂模式:一个工厂多种产品

    2. 工厂方法模式只有一个抽象产品类,抽象工厂模式有多个抽象产品类。

    五、抽象工厂模式的两种情况:①符合开闭原则;②不符合开闭原则

    又称抽象工厂模式“开闭原则”的倾斜性

    • ①符合开闭原则情况

      增加产品族对于增加新的产品族抽象工厂模式很好地支持开闭原则,只需要增加具体产品并对应增加一个新的具体工厂,对已有代码无须做任何修改。

    • ②不符合开闭原则情况

      增加新的产品等级结构对于增加新的产品等级结构 ,需要修改所有的工厂角色,包括抽象工厂类,在所有的工厂类中都需要增加生产新产品的方法,违背了开闭原则。

    六、三种模式例子java实现代码

    java实现简单工厂模式

    java实现工厂模式与抽象工厂模式

    七、个人简单总结

    综上所述:

    简单工厂模式:只有一个实体工厂类;一个实体工厂类生产所有的产品类,工厂根据传入的参数判断具体生产哪个产品给客户。

    工厂方法模式:只有一个抽象产品类;一个实体工厂类生产一种产品类,客户需要知道生产该产品的工厂类名称。

    抽象工厂模式:有多个抽象产品类;一个实体工厂类可以生产多种产品类,客户可以从一个工厂获得所有想要的产品。

    持续更新中…

    未经允许请勿转载,有问题请在评论区评论或者私信!

    展开全文
  • 工厂模式 所谓工厂,就是将零件组装成产品的地方。 建一个对象常常需要复杂的过程,所以不适合包含在一个复合...例如,在《设计模式》一书中,像工厂方法模式、抽象工厂模式、生成器模式,甚至是单例模式都应用了工厂
  • 1、简单工厂模式中包含判断什么对象的逻辑,而工厂方法模式则需要调用者判断要实例化什么具体类型的工厂进而创建出想要的对象。当增加新类时,简单工厂模式需要修改工厂类,而工厂方法模式不需要,因此工厂方法模式...
  • 抽象工厂模式的区别及优缺点及使用场景简单工厂普通简单工厂多方法简单工厂静态方法简单工厂工厂方法模式抽象工厂模式 工厂模式是java设计模式中比较简单的一个设计模式,但很多地方都用到了工厂模式,(如解析xml...
  • Java设计模式(二):工厂方法模式

    千次阅读 2020-10-07 21:59:23
    模式动机 在上文中,我们了解到简单...工厂方法模式(Factory Method Pattern)又称为工厂模式,也叫虚拟构造器(Virtual Constructor)模式或者多态工厂(Polymorphic Factory)模式,它属于类创建型模式。在工厂方法模式
  • 设计模式之工厂方法模式–更加符合开闭原则的工厂模式 工厂方法模式是简单工厂模式的升级版本,更加符合开闭原则。 定义一个创建对象的接口,让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。 ...
  • 设计模式之工厂方法模式

    千次阅读 2021-11-22 20:53:25
    工厂方法模式,定义抽象工厂类来负责定义创建对象的公共接口,而具体工厂类则负责生成具体的对象。 类型 创建型。 角色: 抽象产品:它是定义产品的接口,产品对象的公共父类 具体产品:它实现了抽象产品接口,具体...
  • 工厂方法模式的详解(终极)

    千次阅读 2021-03-02 19:18:56
    2、工厂方法模式的实现细节,满足了开闭原则,用创建类和创建类工厂的方式实现开闭。 该代码新增了工厂接口;用工厂类实现。 package com.behavior_model.gongchang.factorymethod; /** * * @author pshdhx ...
  • 工厂方法模式 工厂模式的本质 实例化对象不使用new,用工厂方法代替 将选择实现类,创建对象统一管理和控制。从而将调用者跟我们的实现解耦 - oop七大原则 开闭原则:一个软件的实体应当对扩展开放,对修改关闭 ...
  • 工厂方法模式(Factory Method)

    千次阅读 2021-01-19 12:12:01
    一、工厂方法模式定义 工厂方法模式又称为工厂模式,也叫虚拟构造器模式或者多态工厂模式,它属于类创建型模式。在工厂方法模式中,工厂父类负责定义创建产品对象的公共接口,而工厂子类则负责生成具体的产品对象,...
  • 工厂方法模式 工厂方法模式(Factory Method Pattern):定义一个用于创建对象的接口,让子类决定将哪一个类实例化。工厂方法模式让一个类的实例化延迟到其子类。 工厂方法模式又简称为工厂模式(Factory Pattern),...
  • 工厂方法模式使用Factory模式替代使用new创建对象;抽象工厂模式使用迭代模式创建对象 定义变量不同。简单工厂模式使用参数或者配置文件等事先定义好的变量,然后利用分支判断初始化具体产品类并返回;工厂方法模式...
  • 工厂方法模式的核心是抽象工厂类Factory,各种具体工厂类继承抽象工厂类并实现在抽象工厂类中定义的工厂方法,从而让客户只关心抽象产品和抽象工厂,不用管具体返回的是哪一种具体产品,也不用关心它是如何被具体工厂...
  • 工厂方法模式+策略模式。

    千次阅读 2018-10-09 15:29:35
    问题提出了,那我们就应该想办法来修改这个缺陷,正好工厂方法模式可以帮我们产生指定的对象,但是问题又来了,工厂方法模式要指定一个类,他才能产生对象,怎么办?引入一个配置文件进行映射,避免系统僵化情况的...
  • 工厂方法模式实现四则计算器

    千次阅读 2020-11-17 18:32:26
    工厂方法模式,又称工厂模式、多态工厂模式和虚拟构造器模式,通过定义工厂父类负责定义创建对象的公共接口,而子类则负责生成具体的对象。 1.2 主要作用 将类的实例化(具体产品的创建)延迟到工厂类的子类(具体...
  • 工厂方法模式介绍 工厂方法模式(Factory Pattern),是创建型设计模式之一。工厂方法模式是一种结构简单的模式,其在我们平时开发中应用很广泛,也许你并不知道,但是你已经使用了无数次该模式了,如Android中...
  • 工厂方法使一个类的实例化延伸到其子类。二、优点 1.拥有良好的封装性。调用者需要一个具体产品,只需要向工厂获取,而不用知道创建对象的艰辛过程,降低模块间的耦合。 2.易于扩展。增加产品时,只需要适当修改...
  • 创建型模式——工厂方法模式

    千次阅读 2020-07-10 08:22:13
    创建型模式——工厂方法模式 (一)概述 工厂方法模式定义一个用于创建对象的接口,让子类决定实例化哪一个类。Factory Method是一个类的实例化延迟到其子类。 在工厂方法模式中,核心的工厂类不再负责所有的产品的...
  • 设计模式——4、工厂方法模式

    千次阅读 2021-02-02 16:38:31
    在《简单工厂模式》一节我们介绍了简单工厂模式,提到了简单工厂模式违背了开闭原则,而“工厂方法模式”是对简单工厂模式的进一步抽象化,其好处是可以使系统在不修改原来代码的情况下引进新的产品,即满足开闭原则...
  • C++ 工厂方法模式

    万次阅读 2017-04-24 19:29:39
    工厂方法模式(Factory Method Pattern)是一种常用的对象创建型设计模式,此模式的核心思想是封装类中不变的部分,提取其中个性化善变的部分为独立类,通过依赖注入以达到解耦、复用以及方便后期维护拓展的目的。...
  • 简单工厂模式 看一个具体的需求 看一个披萨的项目:要便于披萨种类的扩展,要便于维护 (1)披萨的种类很多(比如GreekPizz、CheesePizz等) (2)披萨的制作有prepare,bake, cut, box (3)完成披萨店订购功能。 ...
  • 创建型设计模式——工厂方法模式

    千次阅读 2022-02-10 18:05:36
    1.什么是工厂方法模式工厂方法模式设计方案: 将披萨项目的实例化功能抽象成抽象方法,在不同的口味点餐子类中具体实现。 工厂方法模式: 定义了一个创建对象的抽象方法,由子类决定要实例化的类。工厂方法模式...
  • 工厂方法模式VS简单工厂模式

    千次阅读 2016-06-10 23:14:46
    转发请注明出处:http://blog.csdn.net/qq_28055429/article/details/51628921One----简单工厂模式:一,基本知识:(1)定义:简单工厂模式是属于创建型模式,又叫做静态工厂方法(Static Factory Method)模式,但不...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 339,111
精华内容 135,644
关键字:

工厂方法模式