设计模式-行为型模式
1.责任链
2.观察者
3.模板
4.策略
责任链
首先想到了netty的pipeline处理channelhandler
概述
使多个对象有机会处理请求，解耦：使得避免发送者和接受者之间的耦合关系，将这些对象连城一条链，并沿着这条链传递请求，直到有一个对象处理它为止
给多个对象一个请求的机会，解耦发送者和接受者
适用性
可处理一个请求的对象被动态的指定
有多个对象处理一个请求，那个对象处理该请求运行时自动确定
参与者
handler：定义一个处理请求的接口
concreteHandler ： 处理它所负责的请求，能处理就处理不能就下一个
client：向链路上的concretehandler提交请求
handler
public interface RequestHandle {
void handleRequest(Request request);
}
ConcreteHandler
public class HRRequestHandle implements RequestHandle {
public void handleRequest(Request request) {
if (request instanceof DimissionRequest) {
System.out.println("要离职, 人事审批!");
}
System.out.println("请求完毕");
}
}
public class PMRequestHandle implements RequestHandle {
RequestHandle rh;
public PMRequestHandle(RequestHandle rh) {
this.rh = rh;
}
public void handleRequest(Request request) {
if (request instanceof AddMoneyRequest) {
System.out.println("要加薪, 项目经理审批!");
} else {
rh.handleRequest(request);
}
}
}
public class TLRequestHandle implements RequestHandle {
RequestHandle rh;
public TLRequestHandle(RequestHandle rh) {
this.rh = rh;
}
public void handleRequest(Request request) {
if (request instanceof LeaveRequest) {
System.out.println("要请假, 项目组长审批!");
} else {
rh.handleRequest(request);
}
}
}
Client
public class Test {
public static void main(String[] args) {
// 构造责任链 tl 持有 pm 持有 hr
RequestHandle hr = new HRRequestHandle();
RequestHandle pm = new PMRequestHandle(hr);
RequestHandle tl = new TLRequestHandle(pm);
// 顺序请求。。。。。。。。。。。责任链
//team leader处理离职请求
Request request = new DimissionRequest();
tl.handleRequest(request);
System.out.println("===========");
//team leader处理加薪请求
request = new AddMoneyRequest();
tl.handleRequest(request);
System.out.println("========");
//项目经理上理辞职请求
request = new DimissionRequest();
pm.handleRequest(request);
}
}
result
要离职, 人事审批!
请求完毕
===========
要加薪, 项目经理审批!
========
要离职, 人事审批!
请求完毕
观察者模式
概述：
定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于他的对象都得到通知并被自动更新
参与者
1.subject抽象主题：抽象目标类，提供了一个用于保存观察者对象的聚集类；包含增加，删除观察者的方法以及通知所有观察者的方法
2.Concerete subject具体主题，实现抽象目标中的通知方法，方具体主题内部状态发生改变时，通知所有注册过的观察者对象
3.Observer抽象观察者：是一个抽象类，包含了一个更新自己的抽象方法，当接到具体主题的更改自身的状态
4.Concrete Observer 具体观察者:实现抽象观察者中的抽象方法，
代码示例
subject
public abstract class Subject {
protected static List<Observer> ll = new ArrayList<>();
public void add(Observer observer){
ll.add(observer);
}
public void remove(Observer observer){
ll.remove(observer);
}
public abstract void notifyObserver();
}
ConcreteSubject
public class ConcreteSuibject extends Subject {
@Override
public void notifyObserver() {
for (Object obs : Subject.ll) {
((Observer) obs).getNotify();
}
}
}
Observer
public interface Observer {
void getNotify();
}
ConcreteObserver
package com.company.observer;
public class ConcreteObserver implements Observer{
@Override
public void getNotify() {
System.out.println("和嘿嘿，，，，，，，");
}
}
main
package com.company.observer;
public class main {
public static void main(String[] args) {
ConcreteSuibject concreteSuibject = new ConcreteSuibject();
Observer observer1 = new ConcreteObserver();
Observer observer2 = new ConcreteObserver();
concreteSuibject.add(observer1);
concreteSuibject.add(observer2);
concreteSuibject.notifyObserver();
}
}
这个concreteObserver可以有多个实现，比如observer1 = new ConcreteObserver1 ； observer2 = new ConcreteOnserver2；然后observer1和2可以根据不同的实现类实现不同的功能
策略模式
概述
定义一系列算法，将他们一个个封装起来，并且使他们可以相互替换，本模式可以使得算法可以独立于使用它的客户而变化
使用场景
1.算法可以自由切换
2.多个类只有算法或者行为上稍有不同的场景
3.比如一件产品，今天8折，明天满减准则，可以使用策略模式
组成
1.strategy：定义多有支持的算法的公共接口，
2.ConcreteStrategy：以strategy接口实现某具体算法
3.context用一个ConcreteStrategy对象来配置，通过传入不同的策略使用这个接口来调用某ConcreteStrategy定义的算法
代码示例
context
public class Context {
Strategy strategy;
public Context(Strategy strategy) {
this.strategy = strategy;
}
//上下文接口
public void contextInterface() {
strategy.algorithmInterface();
}
}
stategy
public abstract class Strategy {
//算法方法
public abstract void algorithmInterface();
}
ConcreteStrategy
public class ConcreteStrategyA extends Strategy {
@Override
public void algorithmInterface() {
System.out.println("算法A实现");
}
}
Client
public class Client {
public static void main(String[] args) {
Context context;
context = new Context(new ConcreteStrategyA());
context.contextInterface();
context = new Context(new ConcreteStrategyB());
context.contextInterface();
context = new Context(new ConcreteStrategyC());
context.contextInterface();
}
}
