硬核!史上最全的工厂模式文章,从零到一全面讲解!
文章首发于「陈树义」公众号及个人博客 shuyi.tech,欢迎访问更多有趣有价值的文章。
文章首发于「陈树义」公众号及个人博客 shuyi.tech,欢迎访问更多有趣有价值的文章。
工厂模式是编程中用得最多的设计模式。本文由一个简单的生活例子触发,从工厂方法模式到简单工厂模式,再到多工厂模式,最后到抽象工厂模式。环环相扣,深入浅出,让读者看着大呼过瘾!
小黑眼瞅着年近35岁,于是想着搞搞副业预防中年危机。有一天走在路上,看到路边一家炸鸡店在卖薯条。善于思考的小黑想着:我是否能将这个过程用面向对象的语言表达出来?于是小黑在脑海中开始构思。
// 薯条接口
public interface Chips {
void peel();
void cut();
void fried();
}
// 普通薯条
public class CommonChips implements Chips {
@Override
public void peel() {
System.out.println("土豆去皮");
}
@Override
public void cut() {
System.out.println("土豆切条");
}
@Override
public void fried() {
System.out.println("炸薯条");
}
}
那当客人点了薯条之后,炸鸡店应该怎么做一份薯条呢?小黑很快地在脑海中写下了下面的代码。
public class Client {
public static void main(String[] args) {
// 店员开始炸薯条啦~
Chips chips = new CommonChips();
chips.peel();
chips.cut();
chips.fried();
}
}
不出意外,最终结果应该是下面这样。小黑说道。
土豆去皮
土豆切条
炸薯条
过了几天,小黑看到肯德基推出了波纹薯条,于是炸鸡店也跟进推出新品。于是炸鸡店的店员也不得不跟着改进下切薯条的方法。小黑想:这种情况,我们的类结构应该怎么调整呢?想了一会之后,小黑说:我们只需要在 Chips 薯条类增加一个新的切波纹薯条方法,之后让店员用新的方法去切薯条即可,其它的步骤都不用变。
// 薯条
public class CommonChips implements Chips {
@Override
public void peel() {
System.out.println("土豆去皮");
}
// 增加一个切波纹薯条的方法
@Override
public void cutBoWen() {
System.out.println("土豆切成波纹");
}
@Override
public void fried() {
System.out.println("炸薯条");
}
}
店员制作薯条的时候的步骤需要变换一下:
public class Client {
public static void main(String[] args) {
// 店员开始炸波纹薯条啦~
Chips chips = new CommonChips();
chips.peel();
chips.cutBoWen();
chips.fried();
}
}
如无意外,结果应该是:
土豆去皮
土豆切成波纹
炸薯条
看起来这样的操作完全没问题,问题可以完美解决。不过小黑总觉得哪里不对劲,但又一时没想到原因。直到他听到店员吐苦水说:我就卖薯条的,你还要让我学怎么做薯条,多麻烦啊。还不如直接把薯条做好,我直接炸薯条就行。这样我就不用关心薯条怎么做的了。 下次做旋风薯条、麻辣薯条等等的时候,我也不用关心薯条怎么做,直接炸薯条就可以了。
工厂方法模式
听到这里小黑焕然大悟!作为售卖的店员来说,他不需要关注原材料怎么生产的,只需要知道怎么做好卖给顾客就可以了。这不就和我们编程中的工厂方法模式类似么?
工厂方法模式指的是使用者与创建者分离,使用者不需要知道对象是怎么创建出来的,而创建的过程封装在工厂里。 这就像这家炸鸡店一样,店员(使用者)不需要关心薯条怎么做出来的,薯条怎么做出来交给中央厨房(工厂)去做就可以了。
于是小黑调整了一下炸薯条的实现,使用工厂方法来实现。具体实现上,增加了一个工厂类来制作薯条。
文章首发于「陈树义」公众号及个人博客 shuyi.tech,欢迎访问更多有趣有价值的文章。
// 工厂抽象类
public abstract class AbstractFoodFactory {
public abstract Chips make(String type);
}
// 具体工厂类
public class ChipFactory extends AbstractFoodFactory{
@Override
public Chips make(String type) {
if (type.equals("common")) {
Chips chips = new CommonChips();
chips.peel();
chips.cut();
return chips;
} else if (type.equals("bowen")) {
Chips chips = new CommonChips();
chips.peel();
chips.cutBoWen();
return chips;
}
return null;
}
}
此时店员怎么卖薯条呢?直接去工厂拿到薯条,之后炸薯条就可以了!
public class Client {
public static void main(String[] args) {
// 直接告诉工厂要什么薯条
FoodFactory foodFactory = new FoodFactory();
Chips chips = foodFactory.make("bowen");
// 拿到薯条后直接炸薯条
chips.fried();
}
}
想到这里,小黑不由得感叹:编程其实就是现实世界的投射。工厂方法模式,本质上就是将对象的实例化与使用分离开来,这使得使用方不需要去关心对象的实例化。要解决的问题是:希望能够创建一个对象,但创建过程比较复杂,希望对外隐藏这些细节。 在这个例子中,就是店员不需要去关心薯条怎么做出来的,只需要直接炸薯条就可以了。这样就可以炸更多薯条,挣更多钱了!
简单工厂模式
但小黑还是觉得工厂方法模式太复杂了。你看 AbstractFoodFactory 类其实只有一个实现类,那这种情况下没必要还弄一个抽象类,还弄个实现类,这样多累啊。直接弄一个提供静态方法的工厂类不就好了。于是小黑调整了一下代码。
// 创建简单工厂类
public class SimpleFoodFactory {
// 提供静态方法
public static Chips make(String type) {
if (type.equals("common")) {
Chips chips = new CommonChips();
chips.peel();
chips.cut();
return chips;
} else if (type.equals("bowen")) {
Chips chips = new CommonChips();
chips.peel();
chips.cutBoWen();
return chips;
}
return null;
}
}
// 店员炸鸡更快了!
public class Client {
public static void main(String[] args) {
// 不用创建食物工厂了,直接拿薯条!
Chips chips = SimpleFoodFactory.make("bowen");
chips.fried();
}
}
可以看到整个类结构精简了,不需要抽象工厂类。而在使用的时候,店员也可以直接拿到薯条,不需要去创建食物工厂了!
其实这就是我们常说的简单工厂模式!在只有一个工厂实现的时候,我们可以简化成提供静态方法的简单工厂类,从而简化使用。
多工厂模式
除了简单工厂类,我们还有多工厂模式,小黑说道。
多工厂模式就是每种类型的产品单独作为一个工厂,例如:普通薯条单独作为一个工厂,波纹薯条单独作为一个工厂。为什么要这么做呢?这是因为在单种对象初始化比较复杂的时候,所有产品类的初始化都放到一个类中,会使得代码结构不清晰,这时候就用多工厂模式。 例如我们的波纹薯条非常复杂,可能需要 100 道工序,那和普通薯条放在同一个工厂制作就不太合适,于是我们单独建了一个制作波纹薯条的工厂。
于是小黑继续对之前的代码做改造。Chips 类和 Food 接口还是没有变动,有变化的仅仅是工厂类。
// 新的抽象工厂类
public abstract class AbstractFoodFactory {
// 不需要告诉我要什么类型的薯条了,一个工厂只做一种薯条
public abstract Chips make();
}
// 普通薯条工厂
public class CommonChipFactory extends AbstractFoodFactory{
@Override
public Chips make() {
Chips chips = new CommonChips();
chips.peel();
chips.cut();
return chips;
}
}
// 波纹薯条工厂
public class BowenChipFactory extends AbstractFoodFactory{
@Override
public Chips make() {
Chips chips = new CommonChips();
chips.peel();
chips.cutBoWen();
return chips;
}
}
现在店员炸薯条变成了这样:
// 店员炸鸡更快了!
public class Client {
public static void main(String[] args) {
// 去普通薯条工厂直接拿薯条
CommonChipFactory commonChipFactory = new CommonChipFactory();
Chips chips = commonChipFactory.make();
chips.fried();
// 去波纹薯条工厂拿波纹薯条
BowenChipFactory bowenChipFactory = new BowenChipFactory();
chips = bowenChipFactory.make();
chips.fried();
}
}
抽象工厂模式
看到多工厂模式,大家是不是已经累趴了,但其实还有抽象工厂模式!
抽象工厂模式,其实就是工厂模式更高级的抽象。从名字可以知道,抽象二字是用来形容工厂的,那说明在抽象工厂模式中,工厂也被抽象出来了。 例如对于肯德基和麦当劳来说,他们的薯条都是由供应商提供的,那么对于供应商来说,他们如何去表示这个过程呢?
首先,我们先创建一个工厂类,可以做普通薯条和波纹薯条。
public interface ChipFactory {
// 薯条族,即普通薯条,还是波纹薯条
void makeChip();
void makeBowenChip();
}
文章首发于「陈树义」公众号及个人博客 shuyi.tech,欢迎访问更多有趣有价值的文章。
那么肯德基肯定有其对应的薯条工厂,麦当劳也有其薯条工厂。
// 肯德基薯条工厂
public class KfcChipFactory implements ChipFactory{
@Override
public void makeChip() {
System.out.println("生产肯德基普通薯条");
}
@Override
public void makeBowenChip() {
System.out.println("生产肯德基波纹薯条");
}
}
// 麦当劳薯条工厂
public class MacDonaldChipFactory implements ChipFactory{
@Override
public void makeChip() {
System.out.println("生产麦当劳普通薯条");
}
@Override
public void makeBowenChip() {
System.out.println("生产麦当劳波纹薯条");
}
}
最后我们用一个场景类来表示生产过程。
public class Client {
public static void main(String[] args) {
ChipFactory kfcChipFactory = new KfcChipFactory();
kfcChipFactory.makeChip();
kfcChipFactory.makeBowenChip();
ChipFactory macChipFactory = new MacDonaldChipFactory();
macChipFactory.makeChip();
macChipFactory.makeBowenChip();
}
}
可以看到,抽象工厂比起工厂方法,最大的区别在于:抽象工厂是两层的抽象结构,而工厂方法则只有一层抽象。这就使得抽象工厂能够表示更多的内容,而工厂方法表达的内容更少。 在这个例子中,工厂方法模式表示的是薯条类型,而表示不了肯德基、麦当劳的品牌类型。而抽象工厂不仅可以表示薯条类型,也可以表示品牌类型。
但其实抽象工厂也有一些坏处,例如当我们要增加一种新的薯条类型时,我们需要修改 ChipFactory 工厂类,又要修改每个实现类。这就违背了我们的开闭原则,使得代码非常不稳定。但抽象工厂也有好处,即当我们有一个新的品牌时,扩展非常方便。例如当我们有德克士这个品牌时,我们可以直接增加一个 DicosChipFactory 类,实现 ChipFactory 接口就可以了。
这要求我们要用变化的角度去分析需求,看看哪些是变化更大的,将变化的东西使用类结构来承载。例如在生产薯条的例子中,生产新薯条的场景相对较少、新品牌可能变动,那么我们就应该将薯条类型作为产品族,这样变化就不大。
总的来说,抽象工厂一般用在多个维度,即有产品族的情况下。产品族作为用第一层的抽象类来承载,但如果产品族变化很大则不适合使用抽象工厂。
总结
想到这里,小黑感觉知识间好像都关联起来了。
- 工厂方法是用来分类使用与创建的,创建对象使用工厂方法实现,创建的过程封装在工厂类的方法中,我们不需要关心对象是怎么生产的。
- 如果工厂方法只创建一种类型的对象,那么可以将工厂类简化成带静态方法的工厂类,去掉工厂抽象类,减少类结构冗余。
- 如果工厂方法要创建很多种类型的对象,而每种对象的创建过程都很复杂,那么就用多工种模式,即每种产品都对应一个工厂类,这就形成了多工厂模式。
- 如果产品有多个产品族(两个维度的变量),那么可以进一步抽象成抽象工厂模式。
总的来说,就是以工厂方法为基点,往前缩变成了简单工厂,往后扩展变成了多工厂,往上一层就变成了抽象工厂。
注:在设计模式中,其实只有工厂方法模式和抽象工厂模式两种。简单工厂模式、多工厂模式、普通工厂方法,都属于工厂方法。
文章首发于「陈树义」公众号及个人博客 shuyi.tech,欢迎访问更多有趣有价值的文章。
![扫描关注微信公众号](https://images.cnblogs.com/cnblogs_com/chanshuyi/1943043/o_220725133529_%E5%BE%AE%E4%BF%A1%E6%90%9C%E4%B8%80%E6%90%9C-%E6%A0%91%E5%93%A5%E8%81%8A%E7%BC%96%E7%A8%8B.png)