工厂模式

前言：通文以简单工厂 -> 工厂方法 -> 抽象工厂的思路进行演进编写。

所有工厂设计模式解决的问题：创建对象需要非常复杂的过程或者大量重复的代码

所有工厂设计模式解决的问题：创建对象需要非常复杂的过程或者大量重复的代码

所有工厂设计模式解决的问题：创建对象需要非常复杂的过程或者大量重复的代码

重要的事情说三遍！

简单工厂

首先，简单工厂并不是一种设计模式，只是一种我们平时常用的编程习惯。

定义

由一个工厂对象决定创建出哪一种产品类的实例。

类型

创建型，但是不属于GOF 23种设计模式。

适用场景

• 工厂类负责创建的对象比较少
• 客户端（应用层）只知道传入工厂类的参数，对于如何创建对象（逻辑）不关心

优点

只需要传入一个正确的参数，就可以获取你所需要的对象，而无须知道其创建细节

所以简单工厂的工厂类需要必要的判断逻辑,可以决定在什么时候创建哪一个产品的实例。由此推出简单工厂的适用场景第一点：工厂类负责创建的对象类型比较少，不然判断逻辑将会很冗长。

缺点

• 工厂类的职责相对过重，增加新的产品需要修改工厂类的判断逻辑，违背开闭原则。

Coding

比如我们常用的慕课网，它的视频分类有Java课程和Python课程等等，以此为背景我们创建相关类。

public abstract class Video {
    public abstract void produce();
}

public class JavaVideo extends Video {
    @Override
    public void produce() {
        System.out.println("生产Java视频");
    }
}

public class PythonVideo extends Video {
    @Override
    public void produce() {
        System.out.println("生产Python视频");
    }
}

下面在创建一个应用层的类，也就是调用我们类的一个Client：

public class Test {
    public static void main(String[] args) {
        Video video = new JavaVideo();
        video.produce();
    }
}
// console 生产Java视频

现在我们声明了一个父类的引用Video，它的具体实现是JavaVideo。在我们现在的这个应用层（Test类）中，它是非常依赖JavaVideo类的，如果我们现在想生成PythonVideo，就必须要就引入PythonVideo类。

放上一个我们现在的类引用图：

那我们想一想：能不能让应用层不依赖对应的类，把整个生产过程放到一个类里面，使我们应用层不依赖具体的实现类？

这就是简单工厂的由来。

接下来开始创建我们的简单工厂类：

public class VideoFactory {
    // 如果没有覆写的需求,直接声明成静态方法也可.
    public Video getVideo(String name){
        if ("java".equalsIgnoreCase(name))
            return new JavaVideo();
        else if ("python".equalsIgnoreCase(name))
            return new PythonVideo();
        else 
            return null;
    }
}

修改应用层代码：

public class Test {
    public static void main(String[] args) {
        VideoFactory videoFactory = new VideoFactory();
        Video video = videoFactory.getVideo("java");
        if (null == video){
            return;
        }
        video.produce();
    }
}

看看现在的类图：

现在不管你有多少种video，我应用层只需要引入VideoFactory。

---

对于简单工厂的介绍就是这些，人如其名还是比较简单的。

到这里看完简单工厂类的代码，我们可以很自然而然地理解开篇讲的简单工厂的缺点。很明显是不符合开闭原则的，现在如果新增一个前端视频，我们就需要去VideoFactory里面多增加一个判断逻辑。

开闭原则：对扩展开放、对修改关闭。
讲工厂方法之前，我们的简单工厂代码还可以用反射优化一下：

public class VideoFactory {
    public Video getVideo(Class clazz){
        try {
            return (Video)clazz.newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return null;
    }
}


public class Test {
    public static void main(String[] args) {
        VideoFactory videoFactory = new VideoFactory();
        Video video = videoFactory.getVideo(JavaVideo.class);
        if (null == video){
            return;
        }
        video.produce();
    }
}

使用到简单工厂的一些源码
jdk -> java.util.Calendar -> createCalendar方法

工厂方法

定义

定义一个创建对象的接口，但让实现这个接口的类来决定实例化哪个类，工厂方法让类的实例化推迟到子类中进行。

类型

创建型

适用场景

• 创建对象需要非常复杂的过程或者大量重复的代码
• 客户端（应用层）不依赖于产品类实例如何被创建、实现等细节
• 一个类通过其子类来指定创建哪个对象

简单工厂模式很简单，如果它能满足我们的需要，我觉得就不要折腾了。之所以需要引入工厂模式，是因为我们往往需要使用两个或两个以上的工厂。

优点

• 用户只需要关心所需产品对应的工厂，无须关心创建细节
• 加入新产品符合开闭原则，提高可扩展性

缺点

• 类的个数容易过多，增加复杂度
• 增加了系统的抽象性和理解难度

Coding

// 具体实例化哪个类让子类去实现
public abstract class VideoFactory {
    public abstract Video getVideo(String level);
}

public class JavaVideoFactory extends VideoFactory {
    @Override
    public Video getVideo(String level) {
		if("1080P".equals(level))
			return new JavaVideo1080p();
		else if("580P".equals(level))
        	return new JavaVideo580p();
		else
			return null;
    }
}

public class PythonVideoFactory extends VideoFactory {
     @Override
    public Video getVideo(String level) {
		if("1080P".equals(level))
			return new PythonVideo1080p();
		else if("580P".equals(level))
        	return new PythonVideo580p();
		else
			return null;
    }
}

核心在于，我们需要在第一步选好我们需要的工厂

VideoFactory factory = new JavaVideoFactory();

看完代码再理解一下适用场景里说的：是因为我们往往需要使用两个或两个以上的工厂
此时如果要新增一个前端课程，我们仅需要新增一个FeVideo和一个FeVideoFactory，而不用对现有代码进行修改，单从这个方面来看他是符合开不原则的。

任何设计模式都是有优缺点的，我们要根据实际的业务情况选择合适的方案。

使用到工厂方法的一些源码
jdk -> java.util.Collection -> iterator方法

抽象工厂

定义

抽象工厂提供一个创建一系列相关或相互依赖对象的接口。（产品族和产品等级的概念，下文会讲）

类型

创建型

适用场景

• 客户端（应用层）不依赖于产品类实例如何被创建，实现等细节
• 强调一系列相关的产品对象（属于同一产品族）一起使用创建对象需要大量重复的代码
• 提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于具体实现

优点

• 具体产品在应用层代码隔离，无须关心创建细节
• 将一个系列的产品族统一到一起创建

缺点

• 规定了所有可能被创建的产品集合，产品族中扩展新的产品困难，需要修改抽象工厂的接口
• 增加了系统的抽象性和理解难度

产品等级结构与产品族

我们将同一水平方向的同颜色方块、圆、椭圆认为一个产品族；同一垂直方向的不同颜色的同形状认为同一产品等级。

比如说美的电器：美的生产洗衣机，我们把圆形理解成洗衣机，美的还生产空调，椭圆理解成空调，它们都是美的品牌，也就是属于美的产品族。接下来竖着看，椭圆形都理解为空调，第一排是美的空调，第二排理解成海尔空调，它们属于同一产品等级结构。

上面我们学过了工厂方法模式，工厂方法针对的就是产品等级结构。而抽象工厂模式，针对的则是产品族。

Coding

比如现在我们接到这样一个需求，基于上面的coding，我们规定所有video必须有配套的笔记。如果是用工厂方法模式，我们则需要新建java笔记类，python笔记类，java笔记工厂类，python笔记工厂类等等。这样很容易造成一个类爆炸的现象。

现在我们把java视频和java笔记理解为同一产品族，借用抽象工厂模式来实现：

public interface CourseFactory {
    Video getVideo();
    Article getArticle();
}

public abstract class Video {
    public abstract void product();
}

public abstract class Article {
    public abstract void produce();
}

public class JavaVideo extends Video {
    @Override
    public void product() {
        System.out.println("生产java视频");
    }
}

public class JavaArticle extends Article {
    @Override
    public void produce() {
        System.out.println("生产java笔记");
    }
}
// 没有具体声明java视频的工厂或者笔记的工厂，而是声明了一个java课程的工厂。
// 这样每一个工厂只能制造出同一产品族的实例，提高了可靠性。
public class JavaCourseFactory implements CourseFactory {

    @Override
    public Video getVideo() {
        return new JavaVideo();
    }

    @Override
    public Article getArticle() {
        return new JavaArticle();
    }
}

此时我们可以结合抽象工厂的优缺点看以下，如果要新增一个产品族，那抽象工厂是符合开闭原则的；如果要新增一个产品等级，我们就需要对所有工厂实现类进行改动，此时就是违背开闭原则的。

使用抽象工厂的源码
java.sql.Connection 它的产品族可以理解有mysql、oracle、sqlserver

最后希望小伙伴们能融会贯通，在特定场合使用适合的工厂模式。

学习笔记。内容总结于Geely老师的《Java设计模式精讲 》,并参考此博客JavaDoop
我的个人博客：他和她的猫