举例讲解Python设计模式编程中的访问者与观察者模式_Python

访问者模式
我觉得Visitor模式是在补修改已有程序结构前提下，通过添加额外的访问者完成对代码功能的拓展为什么这样用？当你的类层次较多，在某层结构中增加新的方法，要是在基类上面添加或者变更，可能破坏原来的设计，有兼容问题，所以只在需要的类上面动态添加。

python的例子
这里是个构建车的例子，每个部件都有一个accept的方法接受我上面说的所谓'访问者'，而这个访问者以参数的方式传进来，但是其实他是一个含有一些功能的类的实例，它拥有很多个visit开头的方法对应不同的部件。这样就不需要修改这些部件，而只是修改我们的访问者类的相关部分。

									# 轮子,引擎, 车身这些定义好了都不需要变动

									class Wheel:

									  def __init__(self, name):

									    self.name = name

									  def accept(self, visitor):

									    # 每个visitor是同样的，但是其中的方法是不一样的，比如这里是visitWheel，

									    # 然后传入了self，想想？他其实想做什么就能做什么

									    visitor.visitWheel(self)

									class Engine:

									  def accept(self, visitor):

									    visitor.visitEngine(self)

									class Body:

									  def accept(self, visitor):

									    visitor.visitBody(self)

									# 我们要组合成车

									class Car:

									  def __init__(self):

									    self.engine = Engine()

									    self.body  = Body()

									    self.wheels = [ Wheel("front left"), Wheel("front right"),

									            Wheel("back left") , Wheel("back right") ]

									  # 这个也不需要在动，他只是上面部件的组合，只是做了属性的委托

									  def accept(self,visitor):

									    visitor.visitCar(self)

									    self.engine.accept(visitor)

									    self.body.accept(visitor)

									    for wheel in self.wheels:

									      wheel.accept(visitor)

									# 这个才是我们的访问者，每次的修改都在这里面

									class PrintVisitor:

									  def visitWheel(self, wheel):

									    print "Visiting "+wheel.name+" wheel"

									  def visitEngine(self, engine):

									    print "Visiting engine"

									  def visitBody(self, body):

									    print "Visiting body"

									  def visitCar(self, car):

									    print "Visiting car"

									if __name__ == '__main__':

									  car = Car()

									  visitor = PrintVisitor()

									  car.accept(visitor)

观察者模式
当我们希望一个对象的状态发生变化，那么依赖与它的所有对象都能相应变化(获得通知),那么就可以用到Observer模式，其中的这些依赖对象就是观察者的对象，那个要发生变化的对象就是所谓'观察者'

python的例子

									# 这个是观察者基类

									class Subject(object):

									  def __init__(self):

									    self._observers = []

									  # 添加依赖的对象

									  def attach(self, observer):

									    if not observer in self._observers:

									      self._observers.append(observer)

									  # 取消添加

									  def detach(self, observer):

									    try:

									      self._observers.remove(observer)

									    except ValueError:

									      pass

									  # 这里只是通知上面注册的依赖对象新的变化

									  def notify(self, modifier=None):

									    for observer in self._observers:

									      # 可以设置过滤条件，对不符合过滤条件的更新

									      if modifier != observer:

									        observer.update(self)

									# 观察者类

									class Data(Subject):

									  def __init__(self, name=''):

									    super(Data, self).__init__()

									    self.name = name

									    self._data = 0

									  # python2.6新增的写法,获取属性为property，设置属性为(假设属性名字为x)@x.setter,删除为@x.deleter

									  @property

									  def data(self):

									    return self._data

									  @data.setter

									  def data(self, value):

									    self._data = value

									    self.notify()

									# 这里有2个被观察者，也就是依赖的对象，每次Data有改变，这2个view都会变动

									class HexViewer(object):

									  def update(self, subject):

									    print 'HexViewer: Subject %s has data 0x%x' % (subject.name, subject.data)

									class DecimalViewer(object):

									  def update(self, subject):

									    print 'DecimalViewer: Subject %s has data %d' % (subject.name, subject.data)

									if __name__ == '__main__':

									  data1 = Data('Data 1')

									  data2 = Data('Data 2')

									  view1 = DecimalViewer()

									  view2 = HexViewer()

									  data1.attach(view1)

									  data1.attach(view2)

									  data2.attach(view2)

									  data2.attach(view1)

									  print "Setting Data 1 = 10"

									  data1.data = 10

									  print "Setting Data 2 = 15"

									  data2.data = 15

									  print "Setting Data 1 = 3"

									  data1.data = 3

									  print "Setting Data 2 = 5"

									  data2.data = 5

									  print "Update data1's view2 Because view1 is be filtered"

									  data1.notify(modifier=view1) 

									  print "Detach HexViewer from data1 and data2."

									  data1.detach(view2)

									  data2.detach(view2)

									  print "Setting Data 1 = 10"

									  data1.data = 10

									  print "Setting Data 2 = 15"

									  data2.data = 15