大家讲的简单工厂模式和工厂方法模式都是没问题的,关键到抽象工厂模式就不对了。
先从简单工厂模式和工厂方法模式复习一下,然后再看看错的是咋讲的。已经对抽象工厂模式烂熟于心的请忽略此文。
简单工厂模式:
有个一公共的产品接口,定义一些方法,各个具体的产品类都实现这个接口,然后有一个专门生产产品类实例的类被称作工厂类,专门为客户端生产产品实例,这个工厂的内部实现就是使用switch或ifelse进行逻辑判断实现的,根据客户端传递的参数不同,来决定什么时候创建什么样的具体产品,生产出不同的具体产品返回给客户端。这样,这个工厂类就集成了所有产品的创建逻辑,它变得无所不知,这也让它变成了核心。但这也成为了他的缺点,因为它将所有的逻辑集中放在一个类里,当产品接口有了新的产品实现类,工厂类需要增加代码,判断在什么时候创建该产品,就需要加入新的判断逻辑。
ShoesFactory工厂
public class ShoesFactory{ public static final String NIKE = "NIKE"; public static final String ADIDAS = "ADIDAS"; public static Shoes getShoes(String brand) { Shoes shoes = null; switch (brand) { case "NIKE": shoes = new NikeShoes(); break; case "ADIDAS": shoes = new AdidasShoes(); break; default: shoes = null; } return shoes; } }
测试类
public class SimpleFactoryTest{ public void main(String arg[]){ Shoes nikeShoes = ShoesFactory.getShoes(ShoesFactory.NIKE); nikeShoes.desc(); Shoes adidasShoes = ShoesFactory.getShoes(ShoesFactory.ADIDAS); adidasShoes.desc(); } }
缺点:每增加一个产品,都要新写一个类,然后在工厂类里增加分支,不符合java的开闭原则。
优点:对外屏蔽产品实例的创建,客户端只负责“消费”,通过这种方式实现了对职责的分割。
工厂方法模式:
有一个公共的产品接口和一个公共的产品工厂接口,任何具体工厂必须实现这个工厂接口。将具体的产品的实例创建任务交给具体的工厂类,工厂的职责单一化,每个产品实例从公共的工厂类内抽离出来,降低了耦合度。这样,当增加新的产品实例时,只需要增加相应的工厂类,符合开闭原则。
public interface ShoesFactory{ Shoes getShoes(); }
NikeShoesFactory
public class NikeShoesFactory implements ShoesFactory{ @Override public Shoes getShoes() { return new NikeShoes(); } }
AdidasShoesFactory
public class AdidasShoesFactory implements ShoesFactory{ @Override public Shoes getShoes() { return new AdidasShoes(); } }
当增加李宁鞋子时只需增加LiningShoes使其实现Shoes接口,然后增加LiningShoesFactory工厂类实现ShoesFactory接口使其负责生产LiningShoes的实例。
缺点:没增加一个具体产品都要增加相应的工厂类,增加代码量。
优点:符合开闭原则,易于扩展。
抽象工厂模式:
当有多个类型的产品时,产品类型之间横向发展,如增加裤子、上衣等产品。在工厂方法模式里,只有一个产品接口类鞋子,各种鞋子如耐克鞋、阿迪鞋实现鞋子接口,而工厂类只需要写2个就行了,耐克鞋工厂、阿迪鞋工厂类,各个工厂类职责单一只生产对应的一种具体产品。
而此时若增加了新的产品类型如裤子,他的具体产品阿迪裤子、耐克裤子,这个时候工厂类怎么实现呢?还像工厂方法类那样吗?如果业务上要求单一工厂原则(一个工厂只生产一个类型的产品),继续使用工厂方法没有问题,但如果需要提供一些列产品显然使用工厂方法模式是不行的。
此时随着多个产品类型的增加,产品之间形成一个个的产品族(耐克鞋、阿迪鞋是一个产品族,耐克裤子、阿迪裤子是一个产品族),而不同品牌之间形成产品等级。
网文实现方式
当我在网上搜索【抽象工厂模式】时,发现有不少文章给出的实现方式是如下图这样的。
抽象工厂模式结构:
代码实现
抽象工厂类
public abstract class AbstractFactory2{ public abstract Shoes getShows(String brand); public abstract Pants getPants(String brand); }
PantsFactory 裤子工厂
public class PantsFactory extends AbstractFactory2{ //裤子工厂不能生产鞋子,空实现 返回null @Override public Shoes getShows(String brand) { return null; } @Override public Pants getPants(String brand) { Pants pants = null; switch (brand) { case "NIKE": pants = new NikePants(); break; case "ADIDAS": pants = new AdidasPants(); break; default: pants = null; } return pants; } }
public class ShoesFactory extends AbstractFactory2{ @Override public Shoes getShows(String brand) { Shoes shoes = null; switch (brand) { case "NIKE": shoes = new NikeShoes(); break; case "ADIDAS": shoes = new AdidasShoes(); break; default: shoes = null; } return shoes; } //鞋子工厂不能生产鞋子,空实现 返回null @Override public Pants getPants(String brand) { return null; } }
FactoryProductor2工厂生产者,通过不同的产品名称创建具体工厂实例:(这里貌似简单工厂模式)
public class FactoryProductor2{ public static final String SHOES = "SHOES"; public static final String PANTS = "PANTS"; public static AbstractFactory2 getFactory(String productType) { if (SHOES.equalsIgnoreCase(productType)) { return new ShoesFactory(); } else if (PANTS.equalsIgnoreCase(productType)) { return new PantsFactory(); } return null; } }
测试类
public class AbstractFactoryTest2{ public static void main(String[] args) { AbstractFactory2 factory = FactoryProductor2.getFactory(FactoryProductor2.PANTS); Pants nikePants = factory.getPants("NIKE"); Pants adidasPants = factory.getPants("ADIDAS"); nikePants.desc(); adidasPants.desc(); factory = FactoryProductor2.getFactory(FactoryProductor2.SHOES); Shoes nikeShoes = factory.getShows("NIKE"); Shoes adidasShows = factory.getShows("ADIDAS"); nikeShoes.desc(); adidasShows.desc(); } }
NikePants AdidasPants NikeShoes AdidasShoes
分析正确性
大家看这样的抽象工厂,每次创建产品都要知道产品的品牌,而且工厂类的另外一个方法被废弃。
还美名其曰的说产品族难扩展,产品等级易扩展。那我们就来看看在这种方式下是怎么个难易法。
产品族难扩展: 当我们想增加上衣Coat产品时,按现在的方式扩展一下看看。首先我们需要新建接口Coat,新建实现类NikeCoat和AdidasCoat实现Coat接口。然后我们需要在抽象工厂类增加创建Coat产品的方法,同时修改现有的2个工厂完成Coat相关实现类的实例创建逻辑,其次我们需要在FactoryProductor2增加分支逻辑创建CoatFactory。
撇开FactoryProductor2类不说,总结下我们都做了什么:
- 新增产品接口Cost
- 修改抽象工厂,新增getCoat方法,修改原有工厂增加getCoat的空实现
- 新增具体工厂CoatFactory
产品等级易扩展: 当我们想增加李宁品牌时,我们需要做什么?pants包下创建LiNingPants实现pants接口,shoes包下创建LiNingShoes实现Shoes接口,然后修改factory包下的ShoesFactory工厂和PantsFactory工厂,各自增加分支判断创建李宁牌的鞋子和裤子。
总结下我们都做了什么:
-
新增具体产品 LiNingPants 和 LiNingShoes
-
修改现有具体工厂类 ShoesFactory 工厂和 PantsFactory 工厂,增加创建李宁工厂分支
这样看来产品族扩展起来确实难,而且不符合开闭原则,但产品等级扩展起来却也不容易,也不符合开闭原则。
大家发现没有,现在的抽象工厂的具体工厂内部是怎么实现的?还是使用switch或ifesle分支,不论扩展产品族还是产品等级都需要改具体工厂类,增加分支,都不符合开闭原则。这是正确的抽象工厂??
NO!!
这样实现抽象工厂模式的不仅仅是搜到的几篇博文,而且还有*鸟教程,搜索排第一:)
正确的抽象工厂
看下这个图,发现具体工厂的名字变了,分别为AdidasFactory和NikeFactory,可想而知,以品牌命名具体的工厂只创建本品牌下的所有产品。
代码实现
抽象工厂类
public abstract class AbstractFactory{ public abstract Shoes getShows(); public abstract Pants getPants(); }
这样,每一个具体的工厂类,实现具体方法时,每个方法都能生成对应的产品,方法没有空实现。而且每一个具体工厂内部没有判断分支。
NikeFactory耐克工厂
public class NikeFactory extends AbstractFactory{ @Override public Shoes getShows() { return new NikeShoes(); } @Override public Pants getPants() { return new NikePants(); } }
AdidasFactory阿迪工厂
public class AdidasFactory extends AbstractFactory{ @Override public Shoes getShows() { return new AdidasShoes(); } @Override public Pants getPants() { return new AdidasPants(); } }
而对于工厂生产者来说,通过不同的品牌名称创建对应的工厂实例,
public class FactoryProductor{ public static final String NIKE = "NIKE"; public static final String ADIDAS = "ADIDAS"; public static AbstractFactory getFactory(String brand) { if (NIKE.equalsIgnoreCase(brand)) { return new NikeFactory(); } else if (ADIDAS.equalsIgnoreCase(brand)) { return new AdidasFactory(); } return null; } }
测试类
public class AbstractFactoryTest{ public static void main(String[] args) { AbstractFactory nikeFactory = FactoryProductor.getFactory(FactoryProductor.NIKE); Pants nikePants = nikeFactory.getPants(); Shoes nikeShows = nikeFactory.getShows(); nikePants.desc(); nikeShows.desc(); AbstractFactory adidasFactory = FactoryProductor.getFactory(FactoryProductor.ADIDAS); Shoes adidasShows = adidasFactory.getShows(); Pants adidasPants = adidasFactory.getPants(); adidasPants.desc(); adidasShows.desc(); } }
NikePants NikeShoes AdidasPants AdidasShoes
分析
现在我们再来看一下,所谓的产品族难扩展,产品等级易扩展。
产品族难扩展: 当增加cost上衣产品时,首先需要新建包coat,新建接口Coat,新建实现类NikeCoat和AdidasCoat,然后在抽象工厂类新增抽象方法getCoat,ShoesFactory工厂和PantsFactory工厂分别实现该方法。
都做了什么:新建产品接口Coat,并创建实现类,抽象工厂新增抽象方法,原具体工厂类重写新增的抽象方法。
产品等级易扩展: 当增加新的品牌时,比如增加李宁牌的鞋子和裤子,怎么扩展?首先创建LiningShoes和LiningPants类分别实现Shoes和Pants接口,然后新建LiningFactory工厂类使其继承AbstractFactory抽象工厂类,重写getShoes和getPants方法。
都做了什么:新增产品实现类,新增具体工厂类。
类图
增加产品族
增加后,这个系统中有三个产品族,两个产品等级
增加产品等级
增加后,这个系统中2个产品族,3个产品等级
作者:walkinger
链接:https://juejin.im/post/5d4b8de1e51d453b1f37eac4