大话设计模式（Python版）--观察者模式

双向耦合的代码

#!/usr/bin/env python

class Secretary:
    def __init__(self):
        self.action = None
        self.observers = list()
    def Attach(self,observer):
        self.observers.append(observer)
    def Notify(self):
        for observer in self.observers:
            observer.Update()
    @property
    def SecretaryAction(self):
        return self.action
    @SecretaryAction.setter
    def SecretaryAction(self,value):
        self.action = value

class StockObserver:
    def __init__(self,name,sub):
        self.__name = name
        self.__sub = sub
    def Update(self):
        print(self.__sub.SecretaryAction,self.__name,"close stock, continue working")

def main():
    meimei = Secretary()
    so1 = StockObserver('lucy',meimei)
    so2 = StockObserver('lily',meimei)
    meimei.Attach(so1)
    meimei.Attach(so2)
    meimei.SecretaryAction = 'Boss is coming'
    meimei.Notify()

if __name__ == '__main__':
    main()    

解耦实践一：

#!/usr/bin/env python
from abc import abstractmethod
class Observer:
    def __init__(self,name,sub):
        self._name = name
        self._sub = sub
    @abstractmethod
    def Update(self):
        pass

class StockObserver(Observer):
    def __init__(self,name,sub):
        super(StockObserver,self).__init__(name,sub)
    def Update(self):
        print(self._sub.SecretaryAction,self._name,"close stock, continue working")

class NBAObserver(Observer):
    def __init__(self,name,sub):
        super(NBAObserver,self).__init__(name,sub)
    def Update(self):
        print(self._sub.SecretaryAction,self._name,"close NBA, continue working")

class Secretary:
    def __init__(self):
        self.__action = None
        self.__observers = list()
    def Attach(self,observer):
        self.__observers.append(observer)
    def Detach(self,observer):
        self.__observers.pop(observer)
    def Notify(self):
        for observer in self.__observers:
            observer.Update()
    @property
    def SecretaryAction(self):
        return self.action
    @SecretaryAction.setter
    def SecretaryAction(self,value):
        self.action = value

def main():
    meimei = Secretary()
    so1 = StockObserver('lucy',meimei)
    ns1 = NBAObserver('lily',meimei)
    meimei.Attach(so1)
    meimei.Attach(ns1)
    meimei.SecretaryAction = 'Boss is coming'
    meimei.Notify()

if __name__ == '__main__':
    main()

解耦实践二：

#!/usr/bin/env python
from abc import abstractmethod,ABCMeta
class Subject:
    __metaclass__ = ABCMeta
    def Attach(self,observer):
        pass
    def Detach(self,observer):
        pass
    def Notify(self):
        pass
    @property
    def SubjectState(self):
        pass
    @SubjectState.setter
    def SubjectState(self,value):
        pass

class Boss(Subject):
    def __init__(self):
        self.__action = None
        self.__observers = list()
    def Attach(self,observer):
        self.__observers.append(observer)
    def Detach(self,observer):
        self.__observers.pop(observer)    
    def Notify(self):
        for observer in self.__observers:
            observer.Update()
    def SubjectState(self):
        return self.__action    
    def SubjectState(self,value):
        self.__action = value

class Secretary(Subject):
    def __init__(self):
        self.__action = None
        self.__observers = list()
    def Attach(self,observer):
        self.__observers.append(observer)
    def Detach(self,observer):
        self.__observers.pop(observer)    
    def Notify(self):
        for observer in self.__observers:
            observer.Update()
    def SubjectState(self):
        return self.__action    
    def SubjectState(self,value):
        self.__action = value

class Observer:
    __metaclass__=ABCMeta
    def __init__(self,name,sub):
        self._name = name
        self._sub = sub
    @abstractmethod
    def Update(self):
        pass

class StockObserver(Observer):
    def __init__(self,name,sub):
        super(StockObserver,self).__init__(name,sub)
    def Update(self):
        print(self._sub.SubjectState,self._name,"close stock, continue working")

class NBAObserver(Observer):
    def __init__(self,name,sub):
        super(NBAObserver,self).__init__(name,sub)
    def Update(self):
        print(self._sub.SubjectState,self._name,"close NBA, continue working")

def main():
    bs = Boss()
    so1 = StockObserver('lucy',bs)
    ns1 = NBAObserver('lily',bs)
    bs.Attach(so1)
    bs.Attach(ns1)
    bs.SubjectState = 'Boss is coming'
    bs.Notify()

if __name__ == '__main__':
    main()

观察者模式：

#!/usr/bin/env python
from abc import abstractmethod,ABCMeta

class Subject:
    __metaclass__ = ABCMeta    
    def __init__(self):
        self.__observers = list()
    def Attach(self,observer):
        self.__observers.append(observer)
    def Detach(self,observer):
        self.__observers.pop(observer)    
    def Notify(self):
        for observer in self.__observers:
            observer.Update()
            
class ConcreteSubject(Subject):
    def __init__(self):
        super(ConcreteSubject,self).__init__()
        self.__SubjectState = None
    @property
    def SubjectState(self):
        return  self.__SubjectState
    @SubjectState.setter
    def SubjectState(self,value):
        self.__SubjectState = value
    
class Observer:
    __metaclass__=ABCMeta
    @abstractmethod
    def Update(self):
        pass
    
class ConcreteObserver(Observer):
    def __init__(self,subject, name):
        self.__subject = subject
        self.__name = name
    def Update(self):
        self.__observerState = self.__subject.SubjectState
        print('the new state of observer ',self.__name,self.__observerState)
    @property
    def Subject(self):
        return self.__subject
    @Subject.setter
    def Subject(self,value):
        self.__subject = value
        
def main():
    cs = ConcreteSubject()
    lily = ConcreteObserver(cs,'lily')
    lucy = ConcreteObserver(cs,'lucy')
    jack = ConcreteObserver(cs,'jack')
    cs.Attach(lily)
    cs.Attach(lucy)
    cs.Attach(jack)
    cs.SubjectState = 'ABC'
    cs.Notify()

if __name__ == '__main__':
    main()

观察者模式与事件委托相结合：

#!/usr/bin/env python
from abc import abstractmethod,ABCMeta

class StockObserver:
    def __init__(self,subject, name):
        self.__subject = subject
        self.__name = name
    def CloseStockMarket(self):
        print(self.__subject.SubjectState,self.__name,'close stock, continue working')

class NBAObserver:
    def __init__(self,subject, name):
        self.__subject = subject
        self.__name = name
    def CloseNBADirectSeeding(self):
        print(self.__subject.SubjectState,self.__name,'close stock, continue working')
        
class Subject:
    __metaclass__ = ABCMeta    
    def __init__(self):
        self.__observers = list()
    def Notify(self):
        pass
    @property
    def SubjectState(self):
        return  self.__SubjectState
    @SubjectState.setter
    def SubjectState(self,value):
        self.__SubjectState = value        
            
class Boss(Subject):
    def __init__(self):
        self.__observers = list()
    def Update(self,observer):
        self.__observers.append(observer)
    def Notify(self):
        for obs in self.__observers:
            obs()
    @property
    def SubjectState(self):
        return  self.__SubjectState
    @SubjectState.setter
    def SubjectState(self,value):
        self.__SubjectState = value
        

class Secretary(Subject):
    pass
        
def main():
    bs = Boss()
    lily = StockObserver(bs,'lily')
    lucy = NBAObserver(bs,'lucy')
    bs.Update(lily.CloseStockMarket)
    bs.Update(lucy.CloseNBADirectSeeding)
    bs.SubjectState = 'boss is coming' 
    bs.Notify()

if __name__ == '__main__':
    main()