使用工厂模式优化 if/elif/else 代码

哒呵呵

发布于 2019-04-26 13:44:30

5470

发布于 2019-04-26 13:44:30

文章被收录于专栏：鸿的学习笔记

编译自https://realpython.com/factory-method-python/ 源代码有一定的修改

导论

工厂模式不需要详细解释了，具体的可以在 Design Patterns: Elements of Reusable Object-Oriented Software 书中找到。直接进入正题吧。

简单直接的第一版代码

假设现在需要序列化一条数据，这条数据是一首歌，它包含了歌的名称、创作者和id。序列化的方式暂时有json、xml两种，因此你第一时间想到的代码可能像下面一样。

# In serializer_demo.py

import json
import xml.etree.ElementTree as et
from dataclasses import dataclass

@dataclass
class Song:
     song_id: str
     title: str
     artist: str


class SongSerializer:
    def serialize(self, song, format):
        if format == 'JSON':
            song_info = {
                'id': song.song_id,
                'title': song.title,
                'artist': song.artist
            }
            return json.dumps(song_info)
        elif format == 'XML':
            song_info = et.Element('song', attrib={'id': song.song_id})
            title = et.SubElement(song_info, 'title')
            title.text = song.title
            artist = et.SubElement(song_info, 'artist')
            artist.text = song.artist
            return et.tostring(song_info, encoding='unicode')
        else:
            raise ValueError(format)

上面的代码包含了一个Song类以及将Song序列化的类，通过运行serialize可以将Song类序列化成相应格式的字符串，例如：

>>> import serializer_demo as sd
>>> song = sd.Song('1', 'Water of Love', 'Dire Straits')
>>> serializer = sd.SongSerializer()

>>> serializer.serialize(song, 'JSON')
'{"id": "1", "title": "Water of Love", "artist": "Dire Straits"}'

>>> serializer.serialize(song, 'XML')
'<song id="1"><title>Water of Love</title><artist>Dire Straits</artist></song>'

>>> serializer.serialize(song, 'YAML')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "./serializer_demo.py", line 30, in serialize
    raise ValueError(format)
ValueError: YAML

如果像序列化其他格式，例如输入YAML时会报错，抛出异常表示不支持这种序列化。

评价

显然如果是紧急需求，或者是没有经过思考的话，上面的代码的确是一挥而就，完成任务。作为一名不断精进的工程师，肯定是不会满足于上述代码，那么上述代码存在什么问题需要去改进呢？

当一个新的序列化格式引入的时候，serialize方法需要进行修改以适应这种变化。
当Song这个对象发生改变时，也需要重新修改SongSerializer这个类以适应Song结构的变化。
当序列化格式需要发生变化或者对应的API接口发生变化时，serialize方法也必须更改，因为这些东西都是硬编码在代码里的。

开始重构

在重构代码之前，应先思考抽象出其核心逻辑，确定每一个 if/elif/else 的执行路径（或者是逻辑路径）的公共目标。基于上述目标，应该将json、xml的序列化方法抽象出相应的接口替代具体执行方法，再具体实现每一种序列化格式对应序列化方法，最后抽象 if/elif/else 的运行逻辑。

将序列化的执行方式抽象

class SongSerializer:
    def serialize(self, song, format):
        if format == 'JSON':
            return self._serialize_to_json(song)
        elif format == 'XML':
            return self._serialize_to_xml(song)
        else:
            raise ValueError(format)

    def _serialize_to_json(self, song):
        payload = {
            'id': song.song_id,
            'title': song.title,
            'artist': song.artist
        }
        return json.dumps(payload)

    def _serialize_to_xml(self, song):
        song_element = et.Element('song', attrib={'id': song.song_id})
        title = et.SubElement(song_element, 'title')
        title.text = song.title
        artist = et.SubElement(song_element, 'artist')
        artist.text = song.artist
        return et.tostring(song_element, encoding='unicode')

上述代码中把 if/elif/else 对应的逻辑路径下的序列化方法抽象出了 _serialize_to_json 和 _serialize_to_xml 方法。这一版的代码相对于之前更易读和容易理解了，但是之前提到的问题依然没有得到解决，需要进一步重构。

基本工厂模式

上一版代码只是把具体的序列化方法进行了重构，这一版代码把 if/elif/else 抽象成 _get_serializer 方法，从而将选择执行相应的逻辑路径的方法也抽离出来。

class SongSerializer:
    def serialize(self, song, format):
        serializer = self._get_serializer(format)
        return serializer(song)

    def _get_serializer(self, format):
        if format == 'JSON':
            return self._serialize_to_json
        elif format == 'XML':
            return self._serialize_to_xml
        else:
            raise ValueError(format)

    def _serialize_to_json(self, song):
        payload = {
            'id': song.song_id,
            'title': song.title,
            'artist': song.artist
        }
        return json.dumps(payload)

    def _serialize_to_xml(self, song):
        song_element = et.Element('song', attrib={'id': song.song_id})
        title = et.SubElement(song_element, 'title')
        title.text = song.title
        artist = et.SubElement(song_element, 'artist')
        artist.text = song.artist
        return et.tostring(song_element, encoding='unicode')

现在 serialize 方法内部所有逻辑都被抽象成相应的接口， if/elif/else 逻辑被放在了 _get_serializer 的内部方法里，也就是工厂模式里的creator（选择要使用哪个序列化方法）。具体的序列化方法 _serialize_to_json 和 _serialize_to_xml 就是product（具体执行序列化的逻辑）。SongSerializer则是所谓的client。

更为灵活的增减product

为了使得_serialize_to_xml和_serialize_to_json可以更灵活的添加和实现，而不需要修改原始的SongSerializer类变成彻底的client，可以将相应的工厂方法外提成同一个文件下的外部函数。

class SongSerializer: 
    def serialize(self, song, format):
        serializer = get_serializer(format)
        return serializer(song)


def get_serializer(format):
    if format == 'JSON':
        return _serialize_to_json
    elif format == 'XML':
        return _serialize_to_xml
    else:
        raise ValueError(format)


def _serialize_to_json(song):
    payload = {
        'id': song.song_id,
        'title': song.title,
        'artist': song.artist
    }
    return json.dumps(payload)


def _serialize_to_xml(song):
    song_element = et.Element('song', attrib={'id': song.song_id})
    title = et.SubElement(song_element, 'title')
    title.text = song.title
    artist = et.SubElement(song_element, 'artist')
    artist.text = song.artist
    return et.tostring(song_element, encoding='unicode')

这一版代码基本上完成了简单的工厂模式重构，SongSerializer.serialize作为一个client决定着接口的具体执行，根据相应的标识符调用creator组件get_serializer中实现序列化。creator根据client传入的参数返回相应的对象，选择对应的product(_serialize_to_json 和 _serialize_to_xml)完成相应的序列化。

小结

经过相当大的重构，这一版的代码依然还不够尽善尽美，因为还没考虑到如下的情形：

if/elif/else 逻辑依然没有完全替代，如果需要添加新的逻辑就需要修改get_serializer方法。
可以根据外部数据的不同的创建对应的对象。
可以对同一特征灵活地拥有不同的执行方式，例如上述的Song对象可以拥有json和xml的序列化方式，而没有yaml地序列化方式。
将相同的特征抽象成统一的接口。

工厂模式的最终抽象

首先将_serialize_to_xml和_serialize_to_json从方法变成对应的抽象接口Serializer，以方便扩展序列化支持的数据。

# In serializers.py
from abc import ABCMeta, abstractmethod
import json
import xml.etree.ElementTree as et

class Serializer(metaclass=ABCMeta):
    @abstractmethod
    def start_object(self, object_name, object_id):
        pass

    @abstractmethod
    def add_property(self, name, value):
        pass

    @abstractmethod
    def to_str(self):
        pass

class JsonSerializer(Serializer):
    def __init__(self):
        self._current_object = None

    def start_object(self, object_name, object_id):
        self._current_object = {
            'id': object_id
        }

    def add_property(self, name, value):
        self._current_object[name] = value

    def to_str(self):
        return json.dumps(self._current_object)


class XmlSerializer(Serializer):
    def __init__(self):
        self._element = None

    def start_object(self, object_name, object_id):
        self._element = et.Element(object_name, attrib={'id': object_id})

    def add_property(self, name, value):
        prop = et.SubElement(self._element, name)
        prop.text = value

    def to_str(self):
        return et.tostring(self._element, encoding='unicode')

Serializer接口将上述的json和xml序列化方法抽象成了三个方法：

start_object(object_name, object_id)
add_property(name, value)
to_str()

XmlSerializer和JsonSerializer都是Serializer接口的具体实现。

于是具体的Serializer的执行，也就是client，就可以抽象成下述模式：

# In serializers.py

class ObjectSerializer:
    def serialize(self, serializable, format):
        serializer = factory.get_serializer(format)
        serializable.serialize(serializer)
        return serializer.to_str()

这里的ObjectSerializer的实现便通用许多，只需要serializable和format参数。format用于确定Serializer的具体执行方法，serializable可以按照自己本身确定的的serialize方式实现serialize方法。

于是将Song类就重构成serializable的具体实现：

# In songs.py

class Song:
    def __init__(self, song_id, title, artist):
        self.song_id = song_id
        self.title = title
        self.artist = artist

    def serialize(self, serializer):
        serializer.start_object('song', self.song_id)
        serializer.add_property('title', self.title)
        serializer.add_property('artist', self.artist)

Song类实现了Serializable的具体接口serialize，在这个接口里Song类使用serializer对象写入自己的信息而无需关心具体序列格式，使得Song类灵活的转换成不同的序列化格式。

到目前为止，这一版代码的client(ObjectSerializer)和product(serializer)有了。作为creator的factory该如何实现。

factory方法的实现

最简单的factory方法可以依旧使用 if/else/elif 的逻辑处理数据。

# In serializers.py

class SerializerFactory:
    def get_serializer(self, format):
        if format == 'JSON':
            return JsonSerializer()
        elif format == 'XML':
            return XmlSerializer()
        else:
            raise ValueError(format)


factory = SerializerFactory()

经过前面的讨论，if/else/elif 使得上述代码依旧不够灵活，例如要添加yaml的序列化格式就需要修改SerializerFactory类的源码。因此可以提供类似于注册的模式，也就是register_format方法，将各个格式注册进SerializerFactory类，从而灵活的添加对应的序列化方式。

# In serializers.py

class SerializerFactory:

    def __init__(self):
        self._creators = {}

    def register_format(self, format, creator):
        self._creators[format] = creator

    def get_serializer(self, format):
        creator = self._creators.get(format)
        if not creator:
            raise ValueError(format)
        return creator()


factory = SerializerFactory()
factory.register_format('JSON', JsonSerializer)
factory.register_format('XML', XmlSerializer)

yaml格式的序列化可以单独写成一个文件。

# In yaml_serializer.py

import yaml
import serializers

class YamlSerializer(serializers.JsonSerializer):
    def to_str(self):
        return yaml.dump(self._current_object)


serializers.factory.register_format('YAML', YamlSerializer)

现在执行结果依旧和之前的代码一样：

>>> import serializers
>>> import songs
>>> import yaml_serializer
>>> song = songs.Song('1', 'Water of Love', 'Dire Straits')
>>> serializer = serializers.ObjectSerializer()

>>> print(serializer.serialize(song, 'JSON'))
{"id": "1", "title": "Water of Love", "artist": "Dire Straits"}

>>> print(serializer.serialize(song, 'XML'))
<song id="1"><title>Water of Love</title><artist>Dire Straits</artist></song>

>>> print(serializer.serialize(song, 'YAML'))
{artist: Dire Straits, id: '1', title: Water of Love}