你还在看错误的抽象工厂模式实现案例?

跟風遠走 提交于 2020-01-26 04:50:28

昨天在搜抽象工厂模式时,发现有好几篇博文讲的实现方式和我所认知的有出入,而且还看到某某教程讲的也是错误的还在搜索引擎排第一。

大家讲的简单工厂模式和工厂方法模式都是没问题的,关键到抽象工厂模式就不对了。

先从简单工厂模式和工厂方法模式复习一下,然后再看看错的是咋讲的。已经对抽象工厂模式烂熟于心的请忽略此文。

简单工厂模式:

有个一公共的产品接口,定义一些方法,各个具体的产品类都实现这个接口,然后有一个专门生产产品类实例的类被称作工厂类,专门为客户端生产产品实例,这个工厂的内部实现就是使用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的开闭原则。

优点:对外屏蔽产品实例的创建,客户端只负责“消费”,通过这种方式实现了对职责的分割。

工厂方法模式:

有一个公共的产品接口和一个公共的产品工厂接口,任何具体工厂必须实现这个工厂接口。将具体的产品的实例创建任务交给具体的工厂类,工厂的职责单一化,每个产品实例从公共的工厂类内抽离出来,降低了耦合度。这样,当增加新的产品实例时,只需要增加相应的工厂类,符合开闭原则。

 
ShoesFactory
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个就行了,耐克鞋工厂、阿迪鞋工厂类,各个工厂类职责单一只生产对应的一种具体产品。

而此时若增加了新的产品类型如裤子,他的具体产品阿迪裤子、耐克裤子,这个时候工厂类怎么实现呢?还像工厂方法类那样吗?如果业务上要求单一工厂原则(一个工厂只生产一个类型的产品),继续使用工厂方法没有问题,但如果需要提供一些列产品显然使用工厂方法模式是不行的。

此时随着多个产品类型的增加,产品之间形成一个个的产品族(耐克鞋、阿迪鞋是一个产品族,耐克裤子、阿迪裤子是一个产品族),而不同品牌之间形成产品等级。

网文实现方式

当我在网上搜索【抽象工厂模式】时,发现有不少文章给出的实现方式是如下图这样的。

抽象工厂模式结构:

 

factory 包里放的是抽象工厂类和它的具体工厂类 PantsFactory 裤子工厂,ShoesFactory 鞋子工厂,而抽象工厂类里有两个方法 getPants 和 getShoes,所以对于这两个工厂来说,继承抽象工厂后都会有一个空的方法实现返回null,因为具体的工厂只生产某一产品,即裤子厂只生产裤子,归于鞋子是空实现。

 

代码实现

抽象工厂类

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;
    }
}

 

ShoesFactory 鞋子工厂
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


易学教程内所有资源均来自网络或用户发布的内容,如有违反法律规定的内容欢迎反馈
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!