设计模式——个人学习之工厂模式

最新推荐文章于 2022-09-29 16:53:05 发布
最新推荐文章于 2022-09-29 16:53:05 发布
阅读量136 收藏
点赞数
分类专栏： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34754162/article/details/107968912
版权

工厂模式

简介

我相信说到工厂模式，很多人都很熟悉，毕竟作为一个程序员怎么可能不了解Spring，用过Spring的人都知道，Sping IOC就是一个大型的工厂，它替你管理着项目中对象，你可以从IOC中随时的获取你想用到的对象，因此工厂模式简单的来说就是替我们生产对象的地方。

工厂模式有三种：

  • 简单工厂模式
  • 工厂方法模式
  • 抽象工厂模式

简单工厂模式

简单工厂模式的核心就是它“很简单”，因为它只需要生产一种产品，我们可以把它想象成一个产品单一的工厂。它的UML图如下：

img

产品接口：

package com.example.demo.basis.design.factory.simple;

/**
 * @author: sunzhinan
 * @create: 2020-08-12 21:40
 * @description: 手机
 */
public interface Phone {

    public void playGame();
}

具体产品类：

package com.example.demo.basis.design.factory.simple;

/**
 * @author: sunzhinan
 * @create: 2020-08-12 21:43
 * @description: 苹果手机
 */
public class Apple implements Phone{
    @Override
    public void playGame() {
        System.out.println("用苹果手机打游戏");
    }
}

package com.example.demo.basis.design.factory.simple;

/**
 * @author: sunzhinan
 * @create: 2020-08-12 21:43
 * @description: 华为手机
 */
public class HuaWei implements Phone{
    @Override
    public void playGame() {
        System.out.println("用华为手机打游戏");
    }
}

工厂类：

package com.example.demo.basis.design.factory.simple;

/**
 * @author: sunzhinan
 * @create: 2020-08-12 21:45
 * @description: 手机工厂一
 */
public class PhoneFactoryOne {

    public static Phone getInstance(String phoneName){

        if("Apple".equals(phoneName)){
            return new Apple();
        }else if ("HW".equals(phoneName)){
            return new HuaWei();
        }else{
            System.out.println("其他手机打不了游戏");
            return null;
        }
    }
}

package com.example.demo.basis.design.factory.simple;

/**
 * @author: sunzhinan
 * @create: 2020-08-12 21:51
 * @description: 手机工厂二
 */
public class PhoneFactoryTwo {

    public static Phone getAppleInstance(){
        return new Apple();
    }

    public static Phone getHWInstance(){
        return new HuaWei();
    }
}

测试类：

package com.example.demo.basis.design.factory.simple;

/**
 * @author: sunzhinan
 * @create: 2020-08-12 21:48
 * @description: 测试类
 */
public class TestFactory {
    public static void main(String[] args) {
        PhoneFactoryOne.getInstance("Apple").playGame();
        PhoneFactoryOne.getInstance("HW").playGame();

        System.out.println("--------------------");

        PhoneFactoryTwo.getAppleInstance().playGame();
        PhoneFactoryTwo.getHWInstance().playGame();
    }
}

上面我写了两个工厂类，他们都是简单工厂的形式，从简单工厂可以看出，如果我还想生产小米手机，那么我就需要修改对应的工厂类，增加一段生产小米手机的代码，这就违反了开闭原则。在我们的JDK中，也有简单工厂的影子，比如线程池里默认的线程工厂：

线程工厂接口：

public interface ThreadFactory {

    /**
     * Constructs a new {@code Thread}.  Implementations may also initialize
     * priority, name, daemon status, {@code ThreadGroup}, etc.
     *
     * @param r a runnable to be executed by new thread instance
     * @return constructed thread, or {@code null} if the request to
     *         create a thread is rejected
     */
    Thread newThread(Runnable r);
}

具体实现——Executors中默认的线程工厂：

 /**
  * The default thread factory
  */
static class DefaultThreadFactory implements ThreadFactory {
    private static final AtomicInteger poolNumber = new AtomicInteger(1);
    private final ThreadGroup group;
    private final AtomicInteger threadNumber = new AtomicInteger(1);
    private final String namePrefix;

    DefaultThreadFactory() {
        SecurityManager s = System.getSecurityManager();
        group = (s != null) ? s.getThreadGroup() :
        Thread.currentThread().getThreadGroup();
        namePrefix = "pool-" +
            poolNumber.getAndIncrement() +
            "-thread-";
    }

    public Thread newThread(Runnable r) {
        Thread t = new Thread(group, r,
                              namePrefix + threadNumber.getAndIncrement(),
                              0);
        if (t.isDaemon())
            t.setDaemon(false);
        if (t.getPriority() != Thread.NORM_PRIORITY)
            t.setPriority(Thread.NORM_PRIORITY);
        return t;
    }
}

工厂方法模式

首先我们来看工厂方法模式的UML（网络）：

工厂方法模式的结构图

通过上面的UML图我们可以看出工厂方法和简单工厂最大的区别在于它有多个工厂，在介绍简单工厂的时候，说过如果遇到需要生产新的类型手机，我们需要修改工厂类，但是通过工厂方法模式，我们只需要新建这个类型的手机工厂，所以符合开闭原则。

工厂方法（FactoryMethod）模式的定义：定义一个创建产品对象的工厂接口，将产品对象的实际创建工作推迟到具体子工厂类当中。这满足创建型模式中所要求的“创建与使用相分离”的特点。

工厂方法模式的主要角色如下：

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

工厂接口：

package com.example.demo.basis.design.factory.method;

import com.example.demo.basis.design.factory.simple.Phone;

/**
 * 工厂接口
 */
public interface PhoneFactory {
    public Phone getPhone();
}

具体工厂类：

package com.example.demo.basis.design.factory.method;

import com.example.demo.basis.design.factory.simple.Apple;
import com.example.demo.basis.design.factory.simple.Phone;

/**
 * @author: sunzhinan
 * @create: 2020-08-12 22:08
 * @description: 苹果手机工厂
 */
public class AppleFactory implements PhoneFactory{
    @Override
    public Phone getPhone() {
        return new Apple();
    }
}

package com.example.demo.basis.design.factory.method;

import com.example.demo.basis.design.factory.simple.HuaWei;
import com.example.demo.basis.design.factory.simple.Phone;

/**
 * @author: sunzhinan
 * @create: 2020-08-12 22:19
 * @description: 华为手机工厂
 */
public class HWFactory implements PhoneFactory{
    @Override
    public Phone getPhone() {
        return new HuaWei();
    }
}

package com.example.demo.basis.design.factory.method;

import com.example.demo.basis.design.factory.simple.Phone;

/**
 * @author: sunzhinan
 * @create: 2020-08-12 22:20
 * @description: 小米手机工厂
 */
public class MIPhoneFactory implements PhoneFactory{
    @Override
    public Phone getPhone() {
        return new Mi();
    }
}

测试类：

package com.example.demo.basis.design.factory.method;

import com.example.demo.basis.design.factory.simple.Phone;

/**
 * @author: sunzhinan
 * @create: 2020-08-12 22:19
 * @description: 测试类
 */
public class TestFactory {
    public static void main(String[] args) {
        Phone apple = new AppleFactory().getPhone();
        Phone huawei = new HWFactory().getPhone();
        Phone mi = new MIPhoneFactory().getPhone();

        apple.playGame();
        huawei.playGame();
        mi.playGame();
    }
}

抽象工厂模式

在介绍抽象工厂模式之前，我们思考一下工厂方法模式有个不好的地方，就是我没多一个产品，那么我就要多一个工厂，这样代码就显得很臃肿。工厂方法模式每个工厂只生产同等级的产品，但是在现实生活中我们需要更加综合的工厂，比如电子厂可以生产手机，也可以生产平板等

UML图：

抽象工厂模式的结构图

抽象工厂（AbstractFactory）模式的定义：是一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。

从UML图中可以看出抽象工厂模式的主要角色有四种：

  1. 抽象工厂（Abstract Factory）：提供了创建多个产品的方法
  2. 具体工厂（Concrete Factory）：实现抽象工厂中的抽象方法，创建具体产品。
  3. 抽象产品（Product）：定义同一等级产品的特性和功能。
  4. 具体产品（ConcreteProduct）：具体产品实现了抽象产品的功能和特性。

抽象产品：

package com.example.demo.basis.design.factory.abfactory;

/**
 * 手机产品抽象接口
 */
public interface Phone {
    public void playGame();
}

package com.example.demo.basis.design.factory.abfactory;

/**
 * 平板抽线接口
 */
public interface IPad {
    public void view();
}

具体产品：

package com.example.demo.basis.design.factory.abfactory;

/**
 * @author: sunzhinan
 * @create: 2020-08-12 21:43
 * @description: 苹果手机
 */
public class Apple implements Phone {
    @Override
    public void playGame() {
        System.out.println("用苹果手机打游戏");
    }
}

package com.example.demo.basis.design.factory.abfactory;

/**
 * @author: sunzhinan
 * @create: 2020-08-12 21:43
 * @description: 华为手机
 */
public class HuaWei implements Phone {
    @Override
    public void playGame() {
        System.out.println("用华为手机打游戏");
    }
}

package com.example.demo.basis.design.factory.abfactory;

/**
 * @author: sunzhinan
 * @create: 2020-08-12 22:50
 * @description: 苹果平板电脑
 */
public class AirPad implements IPad{
    @Override
    public void view() {
        System.out.println("用苹果电脑看电视");
    }
}

package com.example.demo.basis.design.factory.abfactory;

/**
 * @author: sunzhinan
 * @create: 2020-08-12 22:51
 * @description: 华为平板
 */
public class HuaWeiIpad implements IPad{
    @Override
    public void view() {
        System.out.println("用华为平板看视频");
    }
}

抽象工厂：

package com.example.demo.basis.design.factory.abfactory;

/**
 * @author: sunzhinan
 * @create: 2020-08-12 22:55
 * @description: 抽象工厂类
 */
public abstract class MyFactory {

    public abstract Phone getPhone();

    public abstract IPad getIPad();
}

具体工厂：

package com.example.demo.basis.design.factory.abfactory;

/**
 * @author: sunzhinan
 * @create: 2020-08-12 22:54
 * @description: 苹果工厂
 */
public class AppleFactory extends MyFactory{
    @Override
    public Phone getPhone() {
        return new Apple();
    }

    @Override
    public IPad getIPad() {
        return new AirPad();
    }
}

package com.example.demo.basis.design.factory.abfactory;

/**
 * @author: sunzhinan
 * @create: 2020-08-12 22:58
 * @description: 华为工厂
 */
public class HuaWeiFactory extends MyFactory{
    @Override
    public Phone getPhone() {
        return new HuaWei();
    }

    @Override
    public IPad getIPad() {
        return new HuaWeiIpad();
    }
}

测试类：

package com.example.demo.basis.design.factory.abfactory;

/**
 * @author: sunzhinan
 * @create: 2020-08-12 23:01
 * @description: 测试类
 */
public class Test {
    public static void main(String[] args) {
        AppleFactory appleFactory = new AppleFactory();
        HuaWeiFactory huaWeiFactory = new HuaWeiFactory();
        appleFactory.getPhone().playGame();
        appleFactory.getIPad().view();

        System.out.println("------------------");

        huaWeiFactory.getIPad().view();
        huaWeiFactory.getPhone().playGame();

    }
}

其实从上面的代码可以看出，工厂方法模式和抽象工厂模式相比：工厂方法生产的产品单一，而抽象工厂可以生产同一类型的不同产品，这个思想更加抽象，功能更加丰富，两者没有优劣之分，根据具体需求来选择。

参考：《GoF设计模式》

勿白头空悲切
关注
专栏目录
Java设计模式——工厂设计模式
12-22
工厂模式： – 实现了创建者和调用者的分离。 – 详细分类： 简单工厂模式 工厂方法模式 抽象工厂模式 面向对象设计的基本原则： OCP（开闭原则，Open-Closed Principle）：一个软件的实体应当对扩展开放，对修改...
BeanFactory简单介绍
LinDongTian
10-13 1万+
一、BeanFactory 　　BeanFactory，以Factory结尾，表示它是一个工厂类(接口)，它负责生产和管理bean的一个工厂。在Spring中，BeanFactory是IOC容器的核心接口，它的职责包括：实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。 BeanFactory只是个接口，并不是IOC容器的具体实现，但是Spring容器给出了很多种实现，...
Spring之BeanFactory详解
weixin_44399827的博客
07-25 1万+
Spring的本质是一个bean工厂(beanFactory)或者说bean容器，它按照我们的要求，生产我们需要的各种各样的bean，提供给我们使用。只是在生产bean的过程中，需要解决bean之间的依赖问题，才引入了依赖注入(DI)这种技术。也就是说依赖注入是beanFactory生产bean时为了解决bean之间的依赖的一种技术而已。 beanFactory会在bean的生命周期的各个阶段中对bean进行各种管理，并且spring将这些阶段通过各种接口暴露给我们，让我们可以对bean进行各种处理，我们
spring框架进阶
m0_55849631的博客
09-29 209
1.BeabFactory和·ApplicationContext接口的区别（考察对spring核心接口类的架构是否了解）BeanFactory是spring框架最底层接口，定义如何创建获得Bean，主要是面向spring本身的。ApplicationContext继承BeanFactory接口，对功能进行扩展spring中实际实现classPathxmlApplicationContext这个类进行具体实现bean的创建和管理BeanFactory主要是面向spring框架存在的，不支持web和Aop功能
java设计模式工厂模式_Java中的工厂设计模式
从零开始的教程世界
07-20 231
java设计模式工厂模式Welcome to the Factory Design Pattern in Java tutorial. Factory Pattern is one of the Creational Design pattern and it’s widely used in JDK as well as frameworks like Spring and Struts. 欢迎...
BeanFactory 和ApplicationContext区别
qq_36074064的博客
07-26 5949
第一， BeanFactory BeanFactory实际上是实例化，配置和管理众多bean的容器。 这些bean通常会彼此合作，因而它们之间会产生依赖。 BeanFactory使用的配置数据可以反映这些依赖关系中 （一些依赖可能不像配置数据一样可见，而是在运行期作为bean之间程序交互的函数）。 一个BeanFactory可以用接口org.springframework.beans.fa
Java设计模式——工厂设计模式详解
08-28
Java设计模式——工厂设计模式详解 在软件设计中，工厂设计模式是一种常用的设计模式，主要用于实例化有共同接口的类。Java设计模式——工厂设计模式是Java中的一种常用的设计模式，主要用于实例化有共同接口的类。...
设计模式(四)——工厂模式
01-21
工厂模式 意义 工厂模式 实现了创建者和调用者的分离。将实例化对象的代码提取出来，放到一个类中统一管理和维护，达到和主项目的依赖关系的解耦。从而提高项目的扩展和维护性。 核心本质 实例化对象，用工厂方法...
工厂模式学习学习 ——记录
07-26
工厂模式 优点：面向接口编程，有非常良好的扩展性，符合开闭原则，将创建的工作转移到工厂类中。 工厂模式每一种单一的工厂类只能完成单一的任务，代码简答。 缺点：当类过多时势必引起类文件臃肿，增加代码开销。
基础知识——–常用设计模式之工厂模式
12-22
一、关于工厂模式 工厂模式是我们最常用的实例化对象模式了，是用工厂方法代替new操作的一种模式。著名的Jive论坛 ,就大量使用了工厂模式，工厂模式在Java程序系统可以说是随处可见。因为工厂模式就相当于创建实例...
【设计模式学习】工厂方法模式
John的博客
04-05 1246
cpp学习设计模式：工厂方法模式在学习工厂方法模式之前，先回忆前面学的简单工厂模式；简单工厂模式就是将对象的创建和逻辑的判断都交给了一个工厂类去做，这样做的优点是客户端不需要知道具体产品类的类名和具体产品的生产过程，达到分离的目的；但是简单工厂模式的缺点也是不容忽略的，那就是工厂类的责任太过重大，而且如果产品类比较多的话，判断逻辑也会比较复杂，使系统的逻辑变得难理解；上面是对简单工厂模式的回忆；那么
Spring基础复习：BeanFactory的使用
APlus
10-11 1万+
一、引言 说到BeanFactory，就必然要提起IoC，IoC全名Inversion of Control，翻译为控制反转或者依赖注入，它是一种程序设计思想。 我们引入以下场景来讲讲IoC： 在传统的Web开发中，经常使用一个用户类（User）的实例代表一个注册的用户： public class User { private String username; private String p...
Spring5源码浅析(五)—DefaultListableBeanFactory之总览
jacob_earl的专栏
01-07 779
        通过前四篇《Spring5源码浅析(一)--BeanFactory》、《Spring5源码浅析(二)-- ListableBeanFactory与HierarchicalBeanFactory》、《Spring5源码浅析(三)-- ConfigurableBeanFactory》、《Spring5源码浅析(四)--ConfigurableListableBeanFactory》的分...
BeanFactory和ApplicationContext的区别
yjc0403的博客
12-19 2842
BeanFactory和ApplicationContext的区别   描述   BeanFactory： 是Spring里面最低层的接口，提供了最简单的容器的功能，只提供了实例化对象和拿对象的功能；   ApplicationContext： 应用上下文，继承BeanFactory接口，它是Spring的一各更高级的容器，提供了更多的有用的功能； 1) 国际化（Messag...
Spring源码解析：BeanFactory深入理解
FromNowOnUntilTheEnd
12-12 4万+
（现在一般都用ApplicantContext代替BeanFactory） 说到Spring框架，人们往往大谈特谈一些似乎高逼格的东西，比如依赖注入，控制反转，面向切面等等。但是却忘记了最基本的一点，Spring的本质是一个bean工厂(beanFactory)或者说bean容器，它按照我们的要求，生产我们需要的各种各样的bean，提供给我们使用。只是在生产bean的过程中，需要解决bean之间...
BeaFactory　和 FactoryBean
五石之瓠 以为大樽 浮于江湖 悠笑人生
07-17 529
用于访问Spring bean容器的 root interface。他定义了bean容器最基本的公共方法; 而他的子接口，如 ListableBeanFactory 和 ConfigurableBeanFactory。 可用于特定目的。 如果对象实现了这个方法，　他会维护一些bean的定义，而每一个bean 通过一个字符串name作为唯一标识符。 根据bean 的定义: 如果定义的是 Proto...
Spring IOC容器的实现原理
weixin_30537391的博客
01-21 99
1 概述 1.1 依赖反转模式 　　在Java中，一个复杂的功能一般都需要由两个或者两个以上的类通过彼此合作来实现业务逻辑的，这使得每个对象都需要与其合作的对象的引用。如果这个获取依赖对象的过程需要自己去实现，那么这将导致代码的高度偶尔并且难以测试。 　　依赖反转就是对象依赖关系的管理被反转了（获取依赖对象的方式进行了反转），以前是自己主动获取依赖对象，现在是通过框架或者IOC容器将依赖对象...
BeanFactory和FactoryBean的区别
热门推荐
屌丝程序员的奋斗之路
11-16 5万+
1.BeanFactory              BeanFactory是IOC最基本的容器，负责生产和管理bean，它为其他具体的IOC容器提供了最基本的规范，例如DefaultListableBeanFactory, XmlBeanFactory,ApplicationContext 等具体的容器都是实现了BeanFactory，再在其基础之上附加了其他的功能。  BeanFacto
一分钟掌握FactoryBean的实现
Marvin
09-09 2815
 一些代理和FactoryBean有关知识的补充,对理解有关这类的题目有帮助的1：每一个代理都有0个或多个方法，它有哪些方法要看它继承的是哪些接口，当应用程序来调用代理的某些方法时，代理把这些方法交给InvocationHandler的invoke()方法去处理，而返回调用实际方法结果的对象。（实际上这就是使用代理要达到的目的）***Invoke()方法***public Obje
深度解析：Java设计模式——工厂方法模式
"java设计模式之工厂方法模式" 工厂方法模式是设计模式中的一种，属于创建型模式，它的主要目的是为了封装对象的创建过程，提供一个创建对象的接口，但允许子类决定实例化哪一个类。在Java设计模式中，工厂方法模式...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值