案例分析：设计模式与代码的结构特性

Posted 2020-11-24 pghustcsz

一、抽象工厂模式

在介绍抽象工厂模式，我们先简单回顾一下简单工厂模式与工厂方法模式。

1.工厂模式：针对一个系列的类,它们有很多的共同点，因此可以将他们称为一个系列的产品，也就是一个系列的类。因此使用一个工厂，用一个工厂创建函数去创建某个具体的类。

实现流程如下：

系列类—>工厂—>创建函数—>某个具体的类

2.工厂方法模式：针对一系列的类，使用一个抽象的工厂接口，之后为每个具体的类都编写一个工厂类，随后在每一个类中使用创建函数创建具体类。

实现流程如下：

系列类——>抽象工厂接口—>多个与系列对应的工厂类—>每个类的创建函数—>某一个具体的类

回顾这些我们可以看出，简单工厂模式是笼统的承包服务，不管有多少个类需要创建，全部都由一个工厂去完成；而工厂函数模式则是定制化服务，每一个工厂只能创建某一种特定的类，但是这些工厂统一遵循即抽象工厂接口的创建方法。

抽象工厂模式即是“分类之后的一对一服务”，我们有多个系列的类需要创建，让某一个工厂专门负责某一类对象的创建，另一个工厂负责另外一类的对象创建。简单来说，简单工厂模式是集中式生产；工厂方法模式是分散式生产；而抽象工厂模式则是对于同一系列的集中式生产，而对于不同系列的分散式生产（结合前两者的优点）。

 

二、抽象工厂模式的使用情景

当出现一系列的产品族，且这些类比较容易划分时，设计模式可以采用使用抽象工厂模式。原因如下：若使用简单工厂模式，那么一个工厂任务会过于繁重(要产生很多类)，且各个类间区分度不高；而若使用工厂函数模式，每个类对应一个新的工厂，此时需要创建太多类了，代码冗杂，不利于维护；最好的办法就是现根据现有类的信息对其进行分组处理，然后每组由一个工厂类去完成，这样既体现了一对一的定制服务（分组）又体现了工厂的集中生产（每一个工厂生产一类）

 

三、抽象工厂模式的python案例

现在我们有很多的类需要定义，包括不同形状类（Circle、Rectangle、Ellipse、Triangle等），以及不同颜色类（Red、Blue、Black等）。

接下将会介绍python完整实现抽象工厂模式的过程： 

 

1、定义形状类这个系列

 

import math

 

#定义一个“形状”的接口，里面定义一个面积的接口方法，只有方法的定义，并没有实现体

class IShape(object): 

    def Area(self):

        pass

#定义4个图形类，都是实现Ishape接口，并且每一个图形都有一个可以计算面积的方法，相当于重写接口方法

class Circle(IShape):

    def Area(self,radius):

        return math.pow(radius,2)*math.pi

 

class Rectangle(IShape):

    def Area(self,length,width):

        return 2*length*width

 

class Triangle(IShape):

    def Area(self,baselong,height):

        return baselong*height/2

 

class Ellipse(IShape):

    def Area(self,long_a,short_b):

        return long_a*short_b*math.pi

2、定义颜色类这个系列

 

#定义一个“颜色”的接口，里面定义一个颜色名称的接口方法，只有方法的定义，并没有实现体

class IColor(object): 

    def color(self):

        pass

 

#定义3个颜色类，都是实现IColor接口，并且每一个图形都有一个可以获取颜色名称的方法，相当于重写接口方法

class Red(IColor):

    def color(self,name):

        print(f‘我的颜色是：{name}‘)

 

class Blue(IColor):

    def color(self,name):

        print(f‘我的颜色是：{name}‘)

 

class Black(IColor):

    def color(self,name):

        print(f‘我的颜色是：{name}‘)

3、定义抽象工厂以及与每一个系列对应的工厂

 

class IFactory:  #模拟接口

    def create_shape(self):  #定义接口的方法，只提供方法的声明，不提供方法的具体实现

        pass

    def create_color(self):

        pass

 

#创建形状这一个系列的工厂

class ShapeFactory(IFactory): #模拟类型实现某一个接口，实际上是类的继承

    def create_shape(self, name):  #重写接口中的方法

        if name ==‘Circle‘:

            return Circle()

        elif name == ‘Rectangle‘:

            return Rectangle()

        elif name == ‘Triangle‘:

            return Triangle()

        elif name == ‘Ellipse‘:

            return Ellipse()

        else:

            return None

 

#创建颜色这一个系列的工厂

class ColorFactory(IFactory): #模拟类型实现某一个接口，实际上是类的继承

    def create_color(self, name):  #重写接口中的方法

        if name ==‘Red‘:

            return Red()

        elif name ==‘Blue‘:

            return Blue()

        elif name ==‘Black‘:

            return Black()

        else:

            return None

注：这里的抽象工厂和“工厂方法模式里面的抽象工厂有点区别，因为这里有两个系列的类型需要产生，所以，抽象工厂里面需要有两个函数接口，一个产生”形状“，一个产生”颜色“，然后再在实现该接口的工厂中分别进行重写。

 

4、定义产生工厂类的类——抽象工厂模式的核心所在

 

#定义一个专门产生工厂的类

class FactoryProducer:

    def get_factory(self,name):

        if name==‘Shape‘:

            return ShapeFactory()

        elif name==‘Color‘:

            return ColorFactory()

        else:

            return None

注意：这一步是抽象工厂模式最为与众不同的，如果按照 “简单工厂模式 ”，只需要进行到第三步即可，因为然后我分别使用  ShapeFactory工厂类和ColorFactory类去分别产生每一个系列的类的实例即可，但是我们没有这么做。而是再定义一个新的“ 工厂产生类 ”去让我们决定到底是要产生哪个类的实例。

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。（这里的FactoryProducer就是超级工厂）。在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

 

5、测试运行结果：

 

if __name__==‘__main__‘:

    factory_producer=FactoryProducer()

    shape_factory=factory_producer.get_factory(‘Shape‘)

    color_factory=factory_producer.get_factory(‘Color‘)

    #--------------------------------------------------------------

 

    circle=shape_factory.create_shape(‘Circle‘)

    circle_area=circle.Area(2)

    print(f‘这是一个圆，它的面积是：{circle_area}‘)

 

    rectangle=shape_factory.create_shape(‘Rectangle‘)

    rectangle_area=rectangle.Area(2,3)

    print(f‘这是一个长方形，它的面积是：{rectangle_area}‘)

 

    triangle=shape_factory.create_shape(‘Triangle‘)

    triangle_area=triangle.Area(2,3)

    print(f‘这是一个三角形，它的面积是：{triangle_area}‘)

 

    ellipse=shape_factory.create_shape(‘Ellipse‘)

    ellipse_area=ellipse.Area(3,2)

    print(f‘这是一个椭圆，它的面积是：{ellipse_area}‘)

 

    #---------------------------------------------------------------

    red=color_factory.create_color(‘Red‘)

    red.color(‘红色‘)

 

    blue=color_factory.create_color(‘Blue‘)

    blue.color(‘蓝色‘)

 

    black=color_factory.create_color(‘Black‘)

    black.color(‘黑色‘)

运行结果如下：

 

这是一个圆，它的面积是：12.566370614359172

这是一个长方形，它的面积是：12

这是一个三角形，它的面积是：3.0

这是一个椭圆，它的面积是：18.84955592153876

我的颜色是：红色

我的颜色是：蓝色

我的颜色是：黑色

 

四、抽象工厂设计模式的总结

1、优点：

对于出现多系列的类型，创建逻辑清楚，因为是分门别类进行创建的；结合了“简单工厂模式”和“工厂方法模式”的优点

2、缺点

一系列产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码。比如，若还要在增加一系列的材质类型（包括Stone、Wood、Plastic等）。首先，需要再定义一个抽象材质接口，然后定义很多的类去实现这个接口；然后，需要在抽象工厂接口中添加一个create_material()方法，并且还需要实现一个MaterialFactory工厂类；最后，我还需要更改超级工厂FactoryProducer类，由此可见，牵一发而动全身，比较麻烦。