全网推广网站,网站开发与维护视频教程,wordpress亿级数据,优秀建筑案例分析目录
策略模式
观察者模式
责任链模式
模板方法模式
状态模式 行为型模式关注的是各个类之间的相互作用#xff0c;将职责划分清楚#xff0c;使得我们的代码更加地清晰。
策略模式
策略模式太常用了
下面设计的场景是#xff0c;我们需要画一个图形#xff0c;可选…目录
策略模式
观察者模式
责任链模式
模板方法模式
状态模式 行为型模式关注的是各个类之间的相互作用将职责划分清楚使得我们的代码更加地清晰。
策略模式
策略模式太常用了
下面设计的场景是我们需要画一个图形可选的策略就是用红色笔来画还是绿色笔来画或者蓝色笔来画。
首先先定义一个策略接口
public interface Strategy { public void draw(int radius, int x, int y); }
然后我们定义具体的几个策略
public class RedPen implements Strategy {Overridepublic void draw(int radius, int x, int y) {System.out.println(用红色笔画图radius: radius , x: x , y: y);}
}
public class GreenPen implements Strategy {Overridepublic void draw(int radius, int x, int y) {System.out.println(用绿色笔画图radius: radius , x: x , y: y);}
}
public class BluePen implements Strategy {Overridepublic void draw(int radius, int x, int y) {System.out.println(用蓝色笔画图radius: radius , x: x , y: y);}
}
使用策略的类
public class Context {private Strategy strategy;public Context(Strategy strategy){this.strategy strategy;}public int executeDraw(int radius, int x, int y){return strategy.draw(radius, x, y);}
}
客户端演示
public static void main(String[] args) {Context context new Context(new BluePen()); // 使用绿色笔来画context.executeDraw(10, 0, 0);
}
放到一张图上让大家看得清晰些 这个时候大家有没有联想到结构型模式中的桥梁模式它们其实非常相似我把桥梁模式的图拿过来大家对比下 要我说的话它们非常相似桥梁模式在左侧加了一层抽象而已。桥梁模式的耦合更低结构更复杂一些。
观察者模式
观察者模式对于我们来说真是再简单不过了。无外乎两个操作观察者订阅自己关心的主题和主题有数据变化后通知观察者们。
首先需要定义主题每个主题需要持有观察者列表的引用用于在数据变更的时候通知各个观察者
public class Subject {private ListObserver observers new ArrayListObserver();private int state;public int getState() {return state;}public void setState(int state) {this.state state;// 数据已变更通知观察者们notifyAllObservers();}// 注册观察者public void attach(Observer observer) {observers.add(observer);}// 通知观察者们public void notifyAllObservers() {for (Observer observer : observers) {observer.update();}}
}
定义观察者接口
public abstract class Observer { protected Subject subject; public abstract void update(); }
其实如果只有一个观察者类的话接口都不用定义了不过通常场景下既然用到了观察者模式我们就是希望一个事件出来了会有多个不同的类需要处理相应的信息。比如订单修改成功事件我们希望发短信的类得到通知、发邮件的类得到通知、处理物流信息的类得到通知等。
我们来定义具体的几个观察者类
public class BinaryObserver extends Observer {// 在构造方法中进行订阅主题public BinaryObserver(Subject subject) {this.subject subject;// 通常在构造方法中将 this 发布出去的操作一定要小心this.subject.attach(this);}// 该方法由主题类在数据变更的时候进行调用Overridepublic void update() {String result Integer.toBinaryString(subject.getState());System.out.println(订阅的数据发生变化新的数据处理为二进制值为 result);}
}public class HexaObserver extends Observer {public HexaObserver(Subject subject) {this.subject subject;this.subject.attach(this);}Overridepublic void update() {String result Integer.toHexString(subject.getState()).toUpperCase();System.out.println(订阅的数据发生变化新的数据处理为十六进制值为 result);}
}
客户端使用也非常简单
public static void main(String[] args) {// 先定义一个主题Subject subject1 new Subject();// 定义观察者new BinaryObserver(subject1);new HexaObserver(subject1);// 模拟数据变更这个时候观察者们的 update 方法将会被调用subject.setState(11);
}
output
订阅的数据发生变化新的数据处理为二进制值为1011 订阅的数据发生变化新的数据处理为十六进制值为B
当然JDK 也提供了相似的支持具体的大家可以参考 java.util.Observable 和 java.util.Observer 这两个类。
实际生产过程中观察者模式往往用消息中间件来实现如果要实现单机观察者模式笔者建议读者使用 Guava 中的 EventBus它有同步实现也有异步实现本文主要介绍设计模式就不展开说了。
还有即使是上面的这个代码也会有很多变种大家只要记住核心的部分那就是一定有一个地方存放了所有的观察者然后在事件发生的时候遍历观察者调用它们的回调函数。
责任链模式
责任链通常需要先建立一个单向链表然后调用方只需要调用头部节点就可以了后面会自动流转下去。比如流程审批就是一个很好的例子只要终端用户提交申请根据申请的内容信息自动建立一条责任链然后就可以开始流转了。
有这么一个场景用户参加一个活动可以领取奖品但是活动需要进行很多的规则校验然后才能放行比如首先需要校验用户是否是新用户、今日参与人数是否有限额、全场参与人数是否有限额等等。设定的规则都通过后才能让用户领走奖品。
如果产品给你这个需求的话我想大部分人一开始肯定想的就是用一个 List 来存放所有的规则然后 foreach 执行一下每个规则就好了。不过读者也先别急看看责任链模式和我们说的这个有什么不一样
首先我们要定义流程上节点的基类
public abstract class RuleHandler {// 后继节点protected RuleHandler successor;public abstract void apply(Context context);public void setSuccessor(RuleHandler successor) {this.successor successor;}public RuleHandler getSuccessor() {return successor;}
}
接下来我们需要定义具体的每个节点了。
校验用户是否是新用户
public class NewUserRuleHandler extends RuleHandler {public void apply(Context context) {if (context.isNewUser()) {// 如果有后继节点的话传递下去if (this.getSuccessor() ! null) {this.getSuccessor().apply(context);}} else {throw new RuntimeException(该活动仅限新用户参与);}}
}
验用户所在地区是否可以参与
public class LocationRuleHandler extends RuleHandler {public void apply(Context context) {boolean allowed activityService.isSupportedLocation(context.getLocation);if (allowed) {if (this.getSuccessor() ! null) {this.getSuccessor().apply(context);}} else {throw new RuntimeException(非常抱歉您所在的地区无法参与本次活动);}}
}
校验奖品是否已领完
public class LimitRuleHandler extends RuleHandler {public void apply(Context context) {int remainedTimes activityService.queryRemainedTimes(context); // 查询剩余奖品if (remainedTimes 0) {if (this.getSuccessor() ! null) {this.getSuccessor().apply(userInfo);}} else {throw new RuntimeException(您来得太晚了奖品被领完了);}}
}
客户端
public static void main(String[] args) {RuleHandler newUserHandler new NewUserRuleHandler();RuleHandler locationHandler new LocationRuleHandler();RuleHandler limitHandler new LimitRuleHandler();// 假设本次活动仅校验地区和奖品数量不校验新老用户locationHandler.setSuccessor(limitHandler);locationHandler.apply(context);
}
代码其实很简单就是先定义好一个链表然后在通过任意一节点后如果此节点有后继节点那么传递下去。
至于它和我们前面说的用一个 List 存放需要执行的规则的做法有什么异同留给读者自己琢磨吧。
模板方法模式
在含有继承结构的代码中模板方法模式是非常常用的。
通常会有一个抽象类
public abstract class AbstractTemplate {// 这就是模板方法public void templateMethod() {init();apply(); // 这个是重点end(); // 可以作为钩子方法}protected void init() {System.out.println(init 抽象层已经实现子类也可以选择覆写);}// 留给子类实现protected abstract void apply();protected void end() {}
}
模板方法中调用了 3 个方法其中 apply() 是抽象方法子类必须实现它其实模板方法中有几个抽象方法完全是自由的我们也可以将三个方法都设置为抽象方法让子类来实现。也就是说模板方法只负责定义第一步应该要做什么第二步应该做什么第三步应该做什么至于怎么做由子类来实现。
我们写一个实现类
public class ConcreteTemplate extends AbstractTemplate {public void apply() {System.out.println(子类实现抽象方法 apply);}public void end() {System.out.println(我们可以把 method3 当做钩子方法来使用需要的时候覆写就可以了);}
}
客户端调用演示
public static void main(String[] args) {AbstractTemplate t new ConcreteTemplate();// 调用模板方法t.templateMethod();
}
代码其实很简单基本上看到就懂了关键是要学会用到自己的代码中。
状态模式
废话我就不说了我们说一个简单的例子。商品库存中心有个最基本的需求是减库存和补库存我们看看怎么用状态模式来写。
核心在于我们的关注点不再是 Context 是该进行哪种操作而是关注在这个 Context 会有哪些操作。
定义状态接口
public interface State { public void doAction(Context context); }
定义减库存的状态
public class DeductState implements State {public void doAction(Context context) {System.out.println(商品卖出准备减库存);context.setState(this);//... 执行减库存的具体操作}public String toString() {return Deduct State;}
}
定义补库存状态
public class RevertState implements State {public void doAction(Context context) {System.out.println(给此商品补库存);context.setState(this);//... 执行加库存的具体操作}public String toString() {return Revert State;}
}
前面用到了 context.setState(this)我们来看看怎么定义 Context 类内部包含状态类State
public class Context {private State state;private String name;public Context(String name) {this.name name;}public void setState(State state) {this.state state;}public void getState() {return this.state;}
}
我们来看下客户端调用大家就一清二楚了
public static void main(String[] args) {// 我们需要操作的是 iPhone XContext context new Context(iPhone X);// 看看怎么进行补库存操作State revertState new RevertState();revertState.doAction(context);// 同样的减库存操作也非常简单State deductState new DeductState();deductState.doAction(context);// 如果需要我们可以获取当前的状态// context.getState().toString();
}
读者可能会发现在上面这个例子中如果我们不关心当前 context 处于什么状态那么 Context 就可以不用维护 state 属性了那样代码会简单很多。
不过商品库存这个例子毕竟只是个例我们还有很多实例是需要知道当前 context 处于什么状态的。 行为型模式总结
行为型模式部分介绍了策略模式、观察者模式、责任链模式、模板方法模式和状态模式其实经典的行为型模式还包括备忘录模式、命令模式等但是它们的使用场景比较有限而且本文篇幅也挺大了我就不进行介绍了。 知识来源
图文详解 23 种设计模式
