工厂模式

　　工厂模式是通过调用一个简单的函数就可以创建不同的对象，下面就简单讲讲工厂方法和抽象工厂模式

 

工厂方法

　　工厂方法模式是指定义一个可以根据参数值的不同，而返回不同对象的函数

　　案例：我们知道session是保存在服务端的，可以保存在缓存里，数据库...  在不同地方就有不同的保存方式，所以要实例不同session对象

class SessionFactory:
 
    @staticmethod
    def get_session_obj(handler):
        obj = None
 
        if config.SESSION_TYPE == "cache":
            obj = CacheSession(handler)
        elif config.SESSION_TYPE == "memcached":
            obj = MemcachedSession(handler)
        elif config.SESSION_TYPE == "redis":
            obj = RedisSession(handler)
        return obj

 　　在上面个例子中修改起来也很方便，只要在配置文件里修改即可

 

抽象工厂

　　一系列的工厂方法组合在一起实现一个抽象工厂

class JSONParser:
    def parse(self, raw_data):
        return json.loads(raw_data)


class XMLParser:
    def parse(self, raw_data):
        return xml2dict(raw_data)


def new_parser(type, **kwargs):
    if type == 'json':
        return JSONParser()
    elif type == 'xml':
        return XMLParser()


parser = new_parser('json')
with open('hello.json') as fp:
    data = parser.parse(fp.read())
print(data)



class DBSaver:
    def save(self, obj, **kwargs):
        model = Model(**obj)
        model.save()


class FileSaver:
    def __init__(self, save_dir):
        self.save_dir = save_dir

    def save(self, obj, name):
        path = os.path.join(self.save_dir, name)
        with open(path, 'wb') as fp:
            data = json.dumps(obj)
            fp.write(data)


def new_saver(type, **kwargs):
    if type == 'db':
        return DBSaver()
    elif type == 'file':
        save_dir = kwargs['save_dir']
        return FileSaver(save_dir)


class FileHandler:
    def __init__(self, parse_type, save_type, **kwargs):
        self.parser = new_parser(parse_type, **kwargs)
        self.saver = new_saver(save_type, **kwargs)

    def do(self, data, filename):
        obj = self.parser.parse(data)
        self.saver.save(obj, filename)

handler = FileHandler('json', 'file', save_dir='save')
with open('hello.json') as fp:
    data = fp.read()
handler.do(data, 'data.json')

 　　由于抽象工厂是一系列的工厂方法组合在一起，所以在编程过程时，先工厂方法再抽象工厂