代理模式
1代理模式
代理模式定义如下:为某对象提供一个代理,以控制对此对象的访问和控制。代理模式在使用过程中,应尽量对抽象主题类进行代理,而尽量不要对加过修饰和方法的子类代理。如上例中,如果有一个xServer继承了Server,并新加了方法xMethod,xServer的代理应以Server为主题进行设计,而尽量不要以xServer为主题,以xServer为主题的代理可以从ServerProxy继承并添加对应的方法。
class serverProxy:
pass
class infoServerProxy(serverProxy):
server=""
def __init__(self,server):
self.server=server
def recv(self,info):
return self.server.recv(info)
def show(self):
self.server.show()
class whiteInfoServerProxy(infoServerProxy):
white_list=[]
def recv(self,info):
try:
assert type(info)==dict
except:
return "info structure is not correct"
addr=info.get("addr",0)
if not addr in self.white_list:
return "Your address is not in the white list."
else:
content=info.get("content","")
return self.server.recv(content)
def addWhite(self,addr):
self.white_list.append(addr)
def rmvWhite(self,addr):
self.white_list.remove(addr)
def clearWhite(self):
self.white_list=[]
2代理模式的优点和使用场景
优点:
1、职责清晰:非常符合单一职责原则,主题对象实现真实业务逻辑,而非本职责的事务,交由代理完成;
2、扩展性强:面对主题对象可能会有的改变,代理模式在不改变对外接口的情况下,可以实现最大程度的扩展;
3、保证主题对象的处理逻辑:代理可以通过检查参数的方式,保证主题对象的处理逻辑输入在理想范围内。
应用场景:
1、针对某特定对象进行功能和增强性扩展。如IP防火墙、远程访问代理等技术的应用;
2、对主题对象进行保护。如大流量代理,安全代理等;
3、减轻主题对象负载。如权限代理等。
3代理模式的缺点
可能会降低整体业务的处理效率和速度。
策略模式
1策略模式
class customer:
customer_name=""
snd_way=""
info=""
phone=""
email=""
def setPhone(self,phone):
self.phone=phone
def setEmail(self,mail):
self.email=mail
def getPhone(self):
return self.phone
def getEmail(self):
return self.email
def setInfo(self,info):
self.info=info
def setName(self,name):
self.customer_name=name
def setBrdWay(self,snd_way):
self.snd_way=snd_way
def sndMsg(self):
self.snd_way.send(self.info)
class msgSender:
dst_code=""
def setCode(self,code):
self.dst_code=code
def send(self,info):
pass
class emailSender(msgSender):
def send(self,info):
print "EMAIL_ADDRESS:%s EMAIL:%s"%(self.dst_code,info)
class textSender(msgSender):
def send(self,info):
print "TEXT_CODE:%s EMAIL:%s"%(self.dst_code,info)
策略模式定义如下:定义一组算法,将每个算法都封装起来,并使他们之间可互换。以上述例子为例,customer类扮演的角色(Context)直接依赖抽象策略的接口,在具体策略实现类中即可定义个性化的策略方式,且可以方便替换。
2策略模式的优点和应用场景
优点:
1、各个策略可以自由切换:这也是依赖抽象类设计接口的好处之一;
2、减少代码冗余;
3、扩展性优秀,移植方便,使用灵活。
应用场景:
1、算法策略比较经常地需要被替换时,可以使用策略模式。如现在超市前台,会常遇到刷卡、某宝支付、某信支付等方式,就可以参考策略模式。
3策略模式的缺点
1、项目比较庞大时,策略可能比较多,不便于维护;
2、策略的使用方必须知道有哪些策略,才能决定使用哪一个策略,这与迪米特法则是相违背的。
责任链模式
1责任链模式
class manager():
successor = None
name = ''
def __init__(self, name):
self.name = name
def setSuccessor(self, successor):
self.successor = successor
def handleRequest(self, request):
pass
class lineManager(manager):
def handleRequest(self, request):
if request.requestType == 'DaysOff' and request.number <= 3:
print '%s:%s Num:%d Accepted OVER' % (self.name, request.requestContent, request.number)
else:
print '%s:%s Num:%d Accepted CONTINUE' % (self.name, request.requestContent, request.number)
if self.successor != None:
self.successor.handleRequest(request)
class departmentManager(manager):
def handleRequest(self, request):
if request.requestType == 'DaysOff' and request.number <= 7:
print '%s:%s Num:%d Accepted OVER' % (self.name, request.requestContent, request.number)
else:
print '%s:%s Num:%d Accepted CONTINUE' % (self.name, request.requestContent, request.number)
if self.successor != None:
self.successor.handleRequest(request)
class generalManager(manager):
def handleRequest(self, request):
if request.requestType == 'DaysOff':
print '%s:%s Num:%d Accepted OVER' % (self.name, request.requestContent, request.number)
class request():
requestType = ''
requestContent = ''
number = 0
责任链模式的定义如下:使多个对象都有机会处理请求,从而避免了请求的发送者和接收者之间的耦合关系。将这些对象连成一条链,并沿着这条链传递该请求,直到有对象处理它为止。
2责任链模式的优点和应用场景
优点:
1、将请求者与处理者分离,请求者并不知道请求是被哪个处理者所处理,易于扩展。
应用场景:
1、若一个请求可能由一个对请求有链式优先级的处理群所处理时,可以考虑责任链模式。除本例外,银行的客户请求处理系统也可以用责任链模式实现(VIP客户和普通用户处理方式当然会有不同)。
3责任链模式的缺点
1、如果责任链比较长,会有比较大的性能问题;
2、如果责任链比较长,若业务出现问题,比较难定位是哪个处理者的问题。
命令模式
1命令模式
命令模式的定义为:将一个请求封装成一个对象,从而可以使用不同的请求将客户端参数化,对请求排队或者记录请求日志,可以提供命令的撤销和恢复功能。命令模式中通常涉及三类对象的抽象:Receiver,Command,Invoker
只有一个Invoker的命令模式也可以抽象成一个类似的“星形网络”,但与之前介绍的中介者模式不同,单纯的命令模式更像是一个辐射状的结构,由Invoker直接对Receiver传递命令,而一般不反向传递,中介者模式“星形网络”的中心,是个协调者,抽象结节间的信息流全部或者部分是双向的。
另外,命令模式的定义中提到了“撤销和恢复功能”,也给了各位开发人员一个命令模式使用过程中的建议:各个Receiver中可以设计一个回滚接口,支持命令的“撤销”。
2命令模式的优点和应用场景
优点:
1、低耦合:调用者和接收者之间没有什么直接关系,二者通过命令中的execute接口联系;
2、扩展性好:新命令很容易加入,也很容易拼出“组合命令”。
应用场景:
1、触发-反馈机制的系统,都可以使用命令模式思想。如基于管道结构的命令系统(如SHELL),可以直接套用命令模式;此外,GUI系统中的操作反馈(如点击、键入等),也可以使用命令模式思想。
3命令模式的缺点
1、如果业务场景中命令比较多,那么对应命令类和命令对象的数量也会增加,这样系统会膨胀得很大。
中介者模式
1中介者模式
中介者模式的定义为:用一个中介对象封装一系列的对象交互。中介者使各对象不需要显式地互相作用,从而使其耦合松散,并可以独立地改变它们之间的交互。
class abstractMediator():
purchase=""
sales=""
warehouse=""
def setPurchase(self,purchase):
self.purchase=purchase
def setWarehouse(self,warehouse):
self.warehouse=warehouse
def setSales(self,sales):
self.sales=sales
def execute(self,content,num):
pass
class stockMediator(abstractMediator):
def execute(self,content,num):
print "MEDIATOR:Get Info--%s"%content
if content=="buy":
self.warehouse.inc(num)
self.sales.getNotice("Bought %s"%num)
elif content=="increase":
self.sales.getNotice("Inc %s"%num)
self.purchase.getNotice("Inc %s"%num)
elif content=="decrease":
self.sales.getNotice("Dec %s"%num)
self.purchase.getNotice("Dec %s"%num)
elif content=="warning":
self.sales.getNotice("Stock is low.%s Left."%num)
self.purchase.getNotice("Stock is low. Please Buy More!!! %s Left"%num)
elif content=="sell":
self.warehouse.dec(num)
self.purchase.getNotice("Sold %s"%num)
else:
pass
2中介者模式的优点和应用场景
优点:
1、减少类与类的依赖,降低了类和类之间的耦合;
2、容易扩展规模。
应用场景:
1、设计类图时,出现了网状结构时,可以考虑将类图设计成星型结构,这样就可以使用中介者模式了。如机场调度系统(多个跑道、飞机、指挥塔之间的调度)、路由系统;著名的MVC框架中,其中的C(Controller)就是M(Model)和V(View)的中介者。
3中介者模式的缺点
1、中介者本身的复杂性可能会很大,例如,同事类的方法如果很多的话,本例中的execute逻辑会很复杂。
模版模式
1模版模式
模板模式定义如下:定义一个操作中的算法的框架,而将一些步骤延迟到子类中,使得子类可以不改变一个算法的结构即可重新定义该算法的某些特定的步骤。子类实现的具体方法叫作基本方法,实现对基本方法高度的框架方法,叫作模板方法。
2模板模式的优点和应用
优点:
1、可变的部分可以充分扩展,不变的步骤可以充分封装;
2、提取公共代码,减少冗余代码,便于维护;
3、具体过程可以定制,总体流程方便掌控。
使用场景:
1、某超类的子类中有公有的方法,并且逻辑基本相同,可以使用模板模式。必要时可以使用钩子方法约束其行为。具体如本节例子;
2、比较复杂的算法,可以把核心算法提取出来,周边功能在子类中实现。例如,机器学习中的监督学习算法有很多,如决策树、KNN、SVM等,但机器学习的流程大致相同,都包含输入样本、拟合(fit)、预测等过程,这样就可以把这些过程提取出来,构造模板方法,并通过钩子方法控制流程。
3模板模式的缺点
1、模板模式在抽象类中定义了子类的方法,即子类对父类产生了影响,部分影响了代码的可读性。
迭代器模式
1迭代器与生成器
在python中,迭代器并不用举太多的例子,因为python中的迭代器应用实在太多了(不管是python还是其它很多的编程语言中,实际上迭代器都已经纳入到了常用的库或者包中)。而且在当前,也几乎没有人专门去开发一个迭代器,而是直接去使用list、string、set、dict等python可迭代对象,或者直接使用__iter__和next函数来实现迭代器。
2迭代器模式
迭代器模式的定义如下:它提供一种方法,访问一个容器对象中各个元素,而又不需要暴露对象的内部细节。
访问者模式
1访问者模式
访问者模式的定义如下:封装一些作用于某种数据结构中的各元素的操作,它可以在不改变数据结构的前提下定义于作用于这些元素的新操作。
2访问者模式的优点和应用
优点:
1、将不同的职责非常明确地分离开来,符合单一职责原则;
2、职责的分开也直接导致扩展非常优良,灵活性非常高,加减元素和访问者都非常容易。
应用场景:
1、要遍历不同的对象,根据对象进行不同的操作的场景;或者一个对象被多个不同对象顺次处理的情况,可以考虑使用访问者模式。除本例外,报表生成器也可以使用访问者模式实现,报表的数据源由多个不同的对象提供,每个对象都是Visitor,报表这个Element顺次Accept各访问者完善并生成对象。
3访问者的缺点
1、访问者得知了元素细节,与最小隔离原则相悖;
2、元素变更依旧可能引起Visitor的修改。
观察者模式
1观察者模式
"""观察者"""
class Observer:
def update(self):
pass
class AlarmSensor(Observer):
def update(self,action):
print "Alarm Got: %s" % action
self.runAlarm()
def runAlarm(self):
print "Alarm Ring..."
class WaterSprinker(Observer):
def update(self,action):
print "Sprinker Got: %s" % action
self.runSprinker()
def runSprinker(self):
print "Spray Water..."
class EmergencyDialer(Observer):
def update(self,action):
print "Dialer Got: %s"%action
self.runDialer()
def runDialer(self):
print "Dial 119..."
"""被观察者"""
class Observed:
observers=[]
action=""
def addObserver(self,observer):
self.observers.append(observer)
def notifyAll(self):
for obs in self.observers:
obs.update(self.action)
class smokeSensor(Observed):
def setAction(self,action):
self.action=action
def isFire(self):
return True
观察者模式也叫发布-订阅模式,其定义如下:定义对象间一种一对多的依赖关系,使得当该对象状态改变时,所有依赖于它的对象都会得到通知,并被自动更新。
观察者模式的通知方式可以通过直接调用等同步方式实现(如函数调用,HTTP接口调用等),也可以通过消息队列异步调用(同步调用指被观察者发布消息后,必须等所有观察者响应结束后才可以进行接下来的操作;异步调用指被观察者发布消息后,即可进行接下来的操作。)。事实上,许多开源的消息队列就直接支持发布-订阅模式,如Zero MQ等。
2观察者模式的优点和应用
优点:
1、观察者与被观察者之间是抽象耦合的;
2、可以将许多符合单一职责原则的模块进行触发,也可以很方便地实现广播。
应用场景:
1、消息交换场景。如上述说到的消息队列等;
2、多级触发场景。比如支持中断模式的场景中,一个中断即会引发一连串反应,就可以使用观察者模式。
3观察者模式的缺点
1、观察者模式可能会带来整体系统效率的浪费;
2、如果被观察者之间有依赖关系,其逻辑关系的梳理需要费些心思。
解释器模式
1解释器模式
class PlayContext():
play_text = None
class Expression():
def interpret(self, context):
if len(context.play_text) == 0:
return
else:
play_segs=context.play_text.split(" ")
for play_seg in play_segs:
pos=0
for ele in play_seg:
if ele.isalpha():
pos+=1
continue
break
play_chord = play_seg[0:pos]
play_value = play_seg[pos:]
self.execute(play_chord,play_value)
def execute(self,play_key,play_value):
pass
class NormGuitar(Expression):
def execute(self, key, value):
print "Normal Guitar Playing--Chord:%s Play Tune:%s"%(key,value)
解释器模式定义如下:给定一种语言,定义它的文法表示,并定义一个解释器,该解释器使用该表示来解释语言中的句子。典型的解释器模式中会有终结符和非终结符之说,语法也根据两种终结符,决定语句最终含义。上例中,非终结符就是空格,终结符就是整个句尾。
2解释器模式的优点和应用
优点:
1、在语法分析的场景中,具有比较好的扩展性。规则修改和制订比较灵活。
应用场景:
1、若一个问题重复发生,可以考虑使用解释器模式。这点在数据处理和日志处理过程中使用较多,当数据的需求方需要将数据纳为己用时,必须将数据“翻译”成本系统的数据规格;同样的道理,日志分析平台也需要根据不同的日志格式翻译成统一的“语言”。
2、特定语法解释器。如各种解释型语言的解释器,再比如自然语言中基于语法的文本分析等。
3解释器模式的缺点
1、解释规则多样化会导致解释器的爆炸;
2、解释器目标比较单一,行为模式比较固定,因而重要的模块中尽量不要使用解释器模式。
备忘录模式
1备忘录模式
class GameCharacter():
vitality = 0
attack = 0
defense = 0
def displayState(self):
print 'Current Values:'
print 'Life:%d' % self.vitality
print 'Attack:%d' % self.attack
print 'Defence:%d' % self.defense
def initState(self,vitality,attack,defense):
self.vitality = vitality
self.attack = attack
self.defense = defense
def saveState(self):
return Memento(self.vitality, self.attack, self.defense)
def recoverState(self, memento):
self.vitality = memento.vitality
self.attack = memento.attack
self.defense = memento.defense
class FightCharactor(GameCharacter):
def fight(self):
self.vitality -= random.randint(1,10)
class Memento:
vitality = 0
attack = 0
defense = 0
def __init__(self, vitality, attack, defense):
self.vitality = vitality
self.attack = attack
self.defense = defense
备忘录模式定义如下:在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态。这样以后就可以将该对象恢复到原来保存的状态。在备忘录模式中,如果要保存的状态多,可以创造一个备忘录管理者角色来管理备忘录。
2备忘录模式的应用场景
1、需要保存和恢复数据的相关状态场景。如保存游戏状态的场景;撤销场景,如Ctrl-Z操作;事务回滚的应用。一般情况下事务回滚有两种方式:一是把从恢复点开始的操作都反向执行一遍;二是直接恢复到恢复点的各种状态。两种方式各有优缺点,要结合业务场景,决定使用哪种模式;
2、副本监控场景。备忘录可以当作一个临时的副本监控,实现非实时和准实时的监控。
状态模式
1状态模式
模拟电梯控制器
"""抽象状态类"""
class LiftState:
def open(self):
pass
def close(self):
pass
def run(self):
pass
def stop(self):
pass
"""具体状态类"""
class OpenState(LiftState):
def open(self):
print "OPEN:The door is opened..."
return self
def close(self):
print "OPEN:The door start to close..."
print "OPEN:The door is closed"
return StopState()
def run(self):
print "OPEN:Run Forbidden."
return self
def stop(self):
print "OPEN:Stop Forbidden."
return self
class RunState(LiftState):
def open(self):
print "RUN:Open Forbidden."
return self
def close(self):
print "RUN:Close Forbidden."
return self
def run(self):
print "RUN:The lift is running..."
return self
def stop(self):
print "RUN:The lift start to stop..."
print "RUN:The lift stopped..."
return StopState()
class StopState(LiftState):
def open(self):
print "STOP:The door is opening..."
print "STOP:The door is opened..."
return OpenState()
def close(self):
print "STOP:Close Forbidden"
return self
def run(self):
print "STOP:The lift start to run..."
return RunState()
def stop(self):
print "STOP:The lift is stopped."
return self
"""上下文类"""
class Context:
lift_state=""
def getState(self):
return self.lift_state
def setState(self,lift_state):
self.lift_state=lift_state
def open(self):
self.setState(self.lift_state.open())
def close(self):
self.setState(self.lift_state.close())
def run(self):
self.setState(self.lift_state.run())
def stop(self):
self.setState(self.lift_state.stop())
状态模式的定义如下:当一个对象内在状态改变时允许其改变行为,这个对象看起来像改变了其类。
2状态模式的优点和应用
优点:
1、状态模式的优点是结构清晰,相比于if…else…简约了不少;
2、封装性好,外部调用不必知道内部实现细节。
应用场景:
1、行为状态改变的场景。这点在各种控制器中非常常见,同时,逻辑结构为状态转移图的场景中都非常适用。
3状态模式的缺点
1、在状态比较多时,子类也会非常多,不便于管理。