[关闭]
@rfish 2015-07-22T12:54:56.000000Z 字数 6033 阅读 1676

行为型模式

实验楼

策略模式(Strategy)

策略模式将各种操作（算法）进行封装，并使它们之间可以互换,动态改变对象的操作方式（算法）

对比以下两种代码，方式。

普通：

  1. # -*- coding: utf-8 -*-
  3. class Question(object):
  4.     """
  5.     问题对象，没有使用策略模式之前的作法
  6.     """
  8.     def __init__(self, admin=True):
  9.         self._admin = admin
  11.     def show(self):
  12.         """
  13.         根据是否是管理员显示不同的信息 
  14.         """
  15.         if self._admin is True:
  16.             return "show page with admin"
  17.         else:
  18.             return "show page with user"
  21. if __name__ == '__main__':
  22.     q = Question(admin=False)
  23.     print(q.show())

上面方法的缺陷是我们在增加功能的时候，需要进入到这个类里面去修改，而当功能比较多的时候，修改起来势必将特别复杂。

使用策略模式：

  1. # -*- coding: utf-8 -*-
  3. import abc
  6. class AbsShow(object):
  7.     """
  8.     抽象显示对象
  9.     """
  11.     __metaclass__ = abc.ABCMeta
  13.     @abc.abstractmethod
  14.     def show(self):
  15.         pass
  18. class AdminShow(AbsShow):
  19.     """
  20.     管理员的显示操作
  21.     """
  23.     def show(self):
  24.         return "show with admin"
  27. class UserShow(AbsShow):
  28.     """
  29.     普通用户的显示操作
  30.     """
  32.     def show(self):
  33.         return "show with user"
  35. class Question(object):
  36.     """
  37.     问题对象，使用策略模式之后的作法
  38.     """
  39.     def __init__(self, show_obj):
  40.         self.show_obj = show_obj
  42.     def show(self):
  43.         return self.show_obj.show()
  45. if __name__ == '__main__':
  46.     q = Question(show_obj=AdminShow())
  47.     print(q.show())
  48.     # 替换原来的显示对象，体现了策略模式的互换行为
  49.     q.show_obj = UserShow()
  50.     print(q.show())

如上代码，我们使操作和使用这些操作的客户端完全分开了
操作：两个继承接口的子类，AdminShow UserShow
使用操作的客户端：Question
好处：当我们在添加方法的时候，只需要增加对应的操作,而不修改客户端Question的代码。因为我们在实例化Question的时候传入的操作名称，会直接去寻找我们现有的操作。

观察者模式

观察者模式，就是当一个对象发生变化时，观察者能及时得到通知并更新。

  2. # -*- coding: utf-8 -*-
  4. import abc
  7. class Subject(object):
  8.     """
  9.     被观察对象的基类
  10.     """
  12.     def __init__(self):
  13.         self._observers = []
  15.     def attach(self, observer):
  16.         """
  17.         注册一个观察者
  18.         """
  19.         if observer not in self._observers:
  20.             self._observers.append(observer)
  22.     def detach(self, observer):
  23.         """
  24.         注销一个观察者
  25.         """
  26.         try:
  27.             self._observers.remove(observer)
  28.         except ValueError:
  29.             pass
  31.     def notify(self):
  32.         """
  33.         通知所有观察者，执行观察者的更新方法
  34.         """
  35.         for observer in self._observers:
  36.             observer.update(self)
  39. class Course(Subject):
  40.     """
  41.     课程对象，被观察的对象
  42.     """
  44.     def __init__(self):
  45.         super(Course, self).__init__()
  46.         self._message = None
  48.     @property
  49.     def message(self):
  50.         """
  51.         message 是一个属性
  52.         """
  53.         return self._message
  55.     @message.setter
  56.     def message(self, msg):
  57.         """
  58.         message 属性设置器
  59.         """
  60.         self._message = msg
  61.         self.notify()
  64. class Observer(object):
  65.     """
  66.     观察者抽象类
  67.     """
  69.     __metaclass__ = abc.ABCMeta
  71.     @abc.abstractmethod
  72.     def update(self, subject):
  73.         pass
  76. class UserObserver(Observer):
  77.     """
  78.     用户观察者
  79.     """
  81.     def update(self, subject):
  82.         print("User observer: %s" % subject.message)
  85. class OrgObserver(Observer):
  86.     """
  87.     机构观察者
  88.     """
  90.     def update(self, subject):
  91.         print("Organization observer: %s" % subject.message)
  94. if __name__ == '__main__':
  95.     # 初始化一个用户观察者
  96.     user = UserObserver()
  97.     # 初始化一个机构观察者
  98.     org = OrgObserver()
  100.     # 初始化一个课程
  101.     course = Course()
  102.     # 注册观察者
  103.     course.attach(user)
  104.     course.attach(org)
  106.     # 设置course.message，这时观察者会收到通知
  107.     course.message = "two observers"
  109.     # 注销一个观察者
  110.     course.detach(user)
  111.     course.message = "single observer"


  • 在上面的示例代码中，先是写了一个被观察者的基类，把被观察者的共同特性写入基类中。然后再在继承于基类，写了真正需要被观察的类Course。
  • 然后写了观察者的抽象类Observer提供一个update接口，在后面的UserObserver和OrgObserver中实现了这个接口。
  • 在主程序中，实例化两个观察者，user和org和一个被观察者course，并在、course中注册这两个观察者。

    注册实际上是将，两个实力对象的名称放入一个列表。当我们每写入一个massage就是执行self.notify()也就是取出列表里的所有观察者，并执行他们的update方法。

添加消息时，程序的执行顺序：

Created with Raphaël 2.1.2Startcourse.message="..."self.notify()取出注册列表中的所有实例名称，执行update方法End

好处：
该模式的好处，观察者和被观察者在程序逻辑上分开，当需要观察某个类时，只需要，将这个观察者实例化后注册到（添加到）被观察者的观察者列表中，即可。将会提供灵活方便的代码运用。

命令模式（Command）

命令模式就是对命令的封装。所谓封装命令，就是将一系列操作封装到命令类中，并且命令类只需要对外公开一个执行方法execute，调用此命令的对象只需要执行命令的execute方法就可以完成所有的操作。

  1. # -*- coding: utf-8 -*-
  3. import abc
  6. class VmReceiver(object):
  7.     """
  8.     命令接收者，真正执行命令的地方
  9.     """
  11.     def start(self):
  12.         print("Virtual machine start")
  14.     def stop(self):
  15.         print("Virtual machine stop")
  18. class Command(object):
  19.     """
  20.     命令抽象类
  21.     """
  22.     __metaclass__ = abc.ABCMeta
  24.     @abc.abstractmethod
  25.     def execute(self):
  26.         """
  27.         命令对象对外只提供 execute 方法
  28.         """
  29.         pass
  32. class StartVmCommand(Command):
  33.     """
  34.     开启虚拟机的命令
  35.     """
  37.     def __init__(self, recevier):
  38.         """
  39.         使用一个命令接收者初始化
  40.         """
  41.         self.recevier = recevier
  43.     def execute(self):
  44.         """
  45.         真正执行命令的时候命令接收者
  46.         """
  47.         self.recevier.start()
  50. class StopVmCommand(Command):
  51.     """
  52.     停止虚拟机的命令
  53.     """
  55.     def __init__(self, recevier):
  56.         """
  57.         使用一个命令接收者初始化
  58.         """
  59.         self.recevier = recevier
  61.     def execute(self):
  62.         """
  63.         真正执行命令的时候命令接收者
  64.         """
  65.         self.recevier.stop()
  68. class ClientInvoker(object):
  69.     """
  70.     命令调用者
  71.     """
  73.     def __init__(self, command):
  74.         self.command = command
  76.     def do(self):
  77.         self.command.execute()
  80. if __name__ == '__main__':
  81.     recevier = VmReceiver()
  82.     start_command = StartVmCommand(recevier)
  83.     # 命令调用者同时也是客户端，通过命令实例也执行真正的操作
  84.     client = ClientInvoker(start_command)
  85.     client.do()
  87.     # 能改变命令接收者，执行不同的操作
  88.     stop_command = StopVmCommand(recevier)
  89.     client.command = stop_command
  90.     client.do()
  • 声明一个命令执行者的类VmReceiver，里面包含所有的命令.
  • 再实例两个命令类，用来传递命令（传入执行者类）
  • 再实例化命令调用者ClientInvoker时传入相应的操作(such as StopVmCommand)名称。
    然后会找到该名称的类StopVmCommand，执行该类，该类就会去执行者VmReceiver中找对应的方法start执行。

好处：
代码更加灵活，增加代码复用。

模板方法模式(Template Method)

先定义一个类模板，在这个类中，我们定义了各种操作的顺序（轮毂或者说是骨架），但是并不实现这些操作，这些操作由子类来操作。

  1. # -*- coding: utf-8 -*-
  3. import abc
  6. class Fishing(object):
  7.     """
  8.     钓鱼模板基类
  9.     """
  10.     __metaclass__ = abc.ABCMeta
  12.     def finishing(self):
  13.         """
  14.         钓鱼方法中，确定了要执行哪些操作才能钓鱼
  15.         """
  16.         self.prepare_bait()
  17.         self.go_to_riverbank()
  18.         self.find_location()
  19.         print("start fishing")
  21.     @abc.abstractmethod
  22.     def prepare_bait(self):
  23.         pass
  25.     @abc.abstractmethod
  26.     def go_to_riverbank(self):
  27.         pass
  29.     @abc.abstractmethod
  30.     def find_location(self):
  31.         pass
  34. class JohnFishing(Fishing):
  35.     """
  36.     John 也想去钓鱼，它必须实现钓鱼三步骤
  37.     """
  39.     def prepare_bait(self):
  40.         """
  41.         从淘宝购买鱼饵
  42.         """
  43.         print("John: buy bait from Taobao")
  45.     def go_to_riverbank(self):
  46.         """
  47.         开车去钓鱼
  48.         """
  49.         print("John: to river by driving")
  51.     def find_location(self):
  52.         """
  53.         在岛上选择钓点
  54.         """
  55.         print("John: select location on the island")
  58. class SimonFishing(Fishing):
  59.     """
  60.     Simon 也想去钓鱼，它也必须实现钓鱼三步骤
  61.     """
  63.     def prepare_bait(self):
  64.         """
  65.         从京东购买鱼饵
  66.         """
  67.         print("John: buy bait from JD")
  69.     def go_to_riverbank(self):
  70.         """
  71.         骑自行车去钓鱼
  72.         """
  73.         print("John: to river by biking")
  75.     def find_location(self):
  76.         """
  77.         在河边选择钓点
  78.         """
  79.         print("John: select location on the riverbank")
  82. if __name__ == '__main__':
  83.     # John 去钓鱼
  84.     f = JohnFishing()
  85.     f.finishing()
  87.     # Simon 去钓鱼
  88.     f = SimonFishing()
  89.     f.finishing()

将应该执行的步骤用抽象方法放在父类中，并写一个不是抽象方法的方法按顺序执行前面的步骤。(如果是抽象方法在写子类的时候就会复写掉了)。也就是我调用这个方法，即可按顺序执行完所有步骤。

作业

问题1：
请描述策略模式命令模式的不同之处

答：
我觉得，策略模式和命令模式，在前面都是一样的，在策略模式中，把选择操作，和实际操作分开了。而在命令模式，也将选择操作和实际操作分开了。但是有个中间者，它将命令的执行传递给了真正执行的那个类中。

下面是策略模式：

  1.                     +-----------+
  2.               +---> |AdminShow（）|
  3.               |     +-----------+
  4. +----------+  |                  
  5. |Question（）++                  
  6. +----------+  |                  
  7.               |     +-----------+
  8.               +---> |UserShow（） |
  9.                     +-----------+
  10.   选择                   执行

下面是命令模式：

  1.                         +----------------+                      
  2.                     +-> |StartVmCommand()+---+                  
  3.                     |   +----------------+   |                  
  4. +---------------+   |                        |    +------------+
  5. |ClientInvoker（）+-+                        +--> |VmReceiver（）|
  6. +---------------+   |                        |    +------------+
  7.                     |   +----------------+   |                  
  8.                     +-> |StopVmCommand() +---+                  
  9.                         +----------------+                      
  11.    选择                      传递                      执行

问题2：
在学习命令模式的时候有没有想到任务队列呢？我们将需要执行的命令对象放入队列中，工作线程从队列中获取命令对象，并调用命令的execute方法以完成任务。这不就是命令模式吗？那么问题来了，请使用 Python 线程和队列实现命令模式，在这个例子中，你需要创建命令接收者，命令抽象类，命令具体类，一个用于将命令对象放入队列的线程类和一个从队列中获取命令对象并执行的线程类。提示：使用 Python threading 和 Queue 模块。

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注