Python设计模式-享元模式

Python设计模式-享元模式

基于Python3.5.2，代码如下

#coding:utf-8

class Coffee:
    name = ""
    price = 0
    def __init__(self,name):
        self.name = name
        self.price = len(name)
    def show(self):
        print("Coffee Name:%s Price:%s"%(self.name,self.price))
class Customer:
    name = ""
    coffee_factory = ""
    def __init__(self,name,coffee_factory):
        self.name = name
        self.coffee_factory = coffee_factory
    def order(self,coffee_name):
        print("%s order a cup of coffee:%s" % (self.name, coffee_name))
        return self.coffee_factory.getCoffee(coffee_name)

class CoffeeFactory():
    coffee_dict = {}
    def getCoffee(self,name):
        if self.coffee_dict.get(name,False) == False:
            self.coffee_dict[name] = Coffee(name)
        return self.coffee_dict[name]
    def getCoffeeCount(self):
        return len(self.coffee_dict)

if __name__ == "__main__":
    coffee_factory = CoffeeFactory()
    customer1 = Customer("Client 1",coffee_factory).order("coffee1")
    customer2 = Customer("Client 2", coffee_factory).order("coffee1")
    customer3 = Customer("Client 3", coffee_factory).order("coffee2")
    customer4 = Customer("Client 4", coffee_factory).order("coffee3")
    print("CoffeeFactory中coffee的实例对象数",coffee_factory.getCoffeeCount())

享元模式分析与解读

享元模式

运用共享技术有效支持大量细粒度对象。在享元对象内部并且不会随环境改变而改变的共享部分，可以称为是享元对象的内部对象，而随环境改变而改变的、不可以共享的状态就是外部状态了。享元模式可以避免大量非常相似类的开销。在程序设计中，有时需要生成大量细粒度的类实例来表示数据。如果能发现这些实例除了几个参数外基本相同的，有时就能够大幅度减少需要实例化的类的数量，如果能把这些参数移到类实例的外面，在方法调用时将他们传递进来，就可以通过共享大幅度减少单个实例的数目。

享元模式的适用场景

1、系统中存在大量的相似对象时，可以选择享元模式；
2、需要缓冲池的场景中，如进程池、线程池等技术。

解读

代码中，模拟了不同用户来下订单购买咖啡的场景，咖啡店中可供选择的咖啡类型有限，由于顾客每个都不同，在生成订单买咖啡时，需要生成咖啡实例，如果同一个种类咖啡被不同顾客订购时，会生成多个实例，此时就应用享元模式对该场景应用进行改造。
1、在Coffee类中，包含了Coffee的名称和价格；
2、用CoffeeFactory类来管理Coffee类，类通过getCoffee()来确保同一个种类的Coffee只生成一次。
3、在Customer类中，初始化时将CoffeeFactory对象传入，当Customer调用order()方法时，通过CoffeeFactory对象的getCoffee()方法来获得Coffee对象，从而达到对象共享的目的。

程序运行结果如下:
Client 1 order a cup of coffee:coffee1
Client 2 order a cup of coffee:coffee1
Client 3 order a cup of coffee:coffee2
Client 4 order a cup of coffee:coffee3
CoffeeFactory中coffee的实例对象数 3

通过运行结果，显示工厂类中只生成了三个coffee对象，不同的顾客实现了对coffee对象的共享。

享元模式的优缺点

优点:

1、减少重复对象，节约系统资源。

缺点:

1、虽然节约了系统资源，但同时也提高了系统的复杂性，尤其当遇到外部状态与内部状态混在一起时，需要先将其分离，再使用享元模式。
2、享元模式需要注意线程安全问题。

备注

class Flyweight():
    def operation(self):
        raise NotImplementedError

class ConcreteFlyweight(Flyweight):
    def operation(self):
        print("实现operation")

class FlyweightFactory():
    flyweights = {}
    def __init__(self):
        self.flyweights["A"] = ConcreteFlyweight()
        self.flyweights["B"] = ConcreteFlyweight()
        self.flyweights["C"] = ConcreteFlyweight()
    def getFlyweight(self,key):
        return self.flyweights[key]

if __name__ == "__main__":
    f = FlyweightFactory()
    fa = f.getFlyweight("A")
    fa.operation()

    fb = f.getFlyweight("B")
    fb.operation()

该实现方式，对不同的语言具有通用性。