Python之工厂模式

天空飞过的鱼 發表於 2022-1-8 15:51:00

<h3>一、介绍</h3>
工厂模式（Factory Pattern）是最常用的设计模式之一，这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。
意图：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。
主要解决：主要解决接口选择的问题。
何时使用：我们明确地计划不同条件下创建不同实例时。
 
<h3>二、简单工厂</h3>
统一使用一个类作为对外接口，根据参数的不同，去选择实例化不同的类。
<div class="cnblogs_code">
<pre>"""
两个产品(两种类型的书)
"""

class TechnicalBooks(object):
"""技术书籍"""

def publish(self):
 return "Python-Book"

class LiteraryBooks(object):
"""文学书籍"""

def publish(self):
 return "Black Hole Book"

# 现在我们有两种类型的书，分别是TechnicalBooks和LiteraryBooks的书
# 按照我们平常的方法来实例化的话，此时创建对象时是会对客户端暴露真正创建的类
it_books = TechnicalBooks()
ly_books = LiteraryBooks()

# 这时我们就可以构造一个"简单工厂"把所有实例化的过程封装在里面，把真正实例的类隐藏起来
class SimpleFactory(object):
"""简单工厂"""

@staticmethod
def publish_book(name):
 if name == 'technical':
 return TechnicalBooks()
 elif name == 'literary':
 return LiteraryBooks()

it_books2 = SimpleFactory.publish_book('technical')
ly_books2 = SimpleFactory.publish_book('literary')</pre>
</div>
简单工厂的好处在于，把不同类的实例化统一到一个"工厂"，即不对外暴露真正的创建类，也提供了一个对外的统一接口。
但是简单工厂也有一个缺点，那就是违背了solid的 "开闭原则"，假如我们还需要增加一种书籍，那就必须要对简单工厂SimpleFactory进行源码的修改，
简单工厂使用场景：
<ul>
<li>已经确定有多少具体的类，不会再增加的情况下使用。</li>
</ul>
例如：某个系统，已经明确就只会有MySQL、Redis、MongoDB三个数据库的情况下，可以直接使用简单工厂模式。
 
<h3>三、工厂方法</h3>
上面的简单工厂我们已经知道了，如果新增一些类型的时候会违背软件设计中的开闭原则，但是我们希望在扩展新的类时，不要修改原有的代码。这个时候我们可以在简单工厂的基础上把SimpleFactory抽象成不同的工厂，每个工厂对应生成自己的产品，这就是工厂方法。
<div class="cnblogs_code">
<pre>"""
两个产品(两种类型的书)
"""
import abc

# 真正进行实例化的类
class TechnicalBooks(object):
"""技术书籍"""

def publish(self):
 return "Python-Book"

class LiteraryBooks(object):
"""文学书籍"""

def publish(self):
 return "Black Hole Book"

# 抽象工厂：先定义抽象类，然后每种类型的书籍都有自己对于的工厂
class AbstractFactory(metaclass=abc.ABCMeta):
"""抽象工厂"""

@abc.abstractmethod
def publish_book(self):
 pass

class TechnicalFactory(AbstractFactory):
"""技术书籍工厂"""

def publish_book(self):
 return TechnicalBooks()

class LiteraryFactory(AbstractFactory):
"""文学书籍工厂"""

def publish_book(self):
 return LiteraryBooks()

it_books2 = TechnicalFactory().publish_book()
ly_books2 = LiteraryFactory().publish_book()</pre>
</div>
这样每个工厂就只负责生产自己的产品，避免了在新增产品时需要修改工厂的代码，遵循了"开闭原则"，如果需要新增产品时，只需要增加相应的工厂即可。
比如要新增一种小说类型的书籍，只需新增一个NovelBooks类和NovelFactory类。
工厂方法的使用场景：
<ul>
<li>当系统中拥有的子类很多，并且以后可能还需要不断拓展增加不同的子类时。</li>
<li>当设计系统时，还不能明确具体有哪些类时。</li>
</ul>
在工厂方法中，使用者不需要知道具体的产品类名，只需要知道其对应的工厂即可。
 
<h3>四、抽象工厂</h3>
工厂方法解决了"开闭原则"的问题，但是我们出版书籍之前肯定还会有其他的步骤，比如印刷。 如果每一个步骤我们就要写一个对应的工厂类，那我们就会需要创建很多很多类了。 因此为了解决这个问题，我们就要需要抽象工厂类，让一个工厂可以生产同一类的多个产品或多个动作(步骤)，这就是抽象工厂。
<div class="cnblogs_code">
<pre>"""
两个产品(两种类型的书)
"""
import abc

# 印刷书籍
class PrintingTechnicalBooks(object):
"""印刷技术书籍"""

def printing(self):
 return "Print-Python-Book"

class PrintingLiteraryBooks(object):
"""印刷文学书籍"""

def printing(self):
 return "Print Black Hole Book"

# 出版书籍
class TechnicalBooks(object):
"""出版技术书籍"""

def publish(self):
 return "Python-Book"

class LiteraryBooks(object):
"""出版文学书籍"""

def publish(self):
 return "Black Hole Book"

# 抽象工厂：先定义抽象类，然后每种类型的书籍都有自己对于的工厂
class AbstractFactory(metaclass=abc.ABCMeta):
"""抽象工厂"""

@abc.abstractmethod
def print_book(self):
 pass

@abc.abstractmethod
def publish_book(self):
 pass

class TechnicalFactory(AbstractFactory):
"""技术书籍工厂"""

def print_book(self):
 return PrintingTechnicalBooks()

def publish_book(self):
 return TechnicalBooks()

class LiteraryFactory(AbstractFactory):
"""文学书籍工厂"""

def print_book(self):
 return PrintingLiteraryBooks()

def publish_book(self):
 return LiteraryBooks()

# 实例化工厂对象
it = TechnicalFactory()
ly = LiteraryFactory()

# 印刷书籍
it_print = it.print_book()
ly_print = ly.print_book()
# 出版书籍
it_publish = it.publish_book()
ly_publish = ly.publish_book()</pre>
</div>
抽象工厂模式与工厂方法模式的区别：
    抽象工厂中的一个工厂对象可以负责多个不同产品对象的创建 
 
抽象工厂的使用场景：
<ul>
<li>当多个产品(步骤)集合在一起，组成产品族时。</li>
<li>对于一个产品族，如果只想显示接口而不是实现时。</li>
</ul>
  
来源：https://www.cnblogs.com/Zzbj/p/15778464.html

頁: [1]

琼殿技术论坛's Archiver

Python之工厂模式