行为模式

行为模式是注意各个类之间的相互作用，讲过职责划分清楚，使得我们的代码更加清晰规范。

1.1策略模式

下面设计的场景是，需要画一个图形，可选的策略就是用红色笔来画，还是绿色笔来画，或者蓝色笔来画。
首先，先定义一个策略接口：

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);
}

1.2 观察者模式

观察者的模式无外乎两个操作，观察者订阅自己关心的主题和主题有数据变化后通知观察者们。

首先，需要定义主题，每个主题需要持有观察者列表的引用，用于在数据变更的时候通知各个观察者：

public class Subject {private List<Observer> observers = new ArrayList<Observer>();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);
}

1.3 责任链模式

责任链通常需要先建立一个单向链表，然后调用方只需要调用头部节点就可以了，后面会自动流转下去。比如流程审批就是一个很好的例子，只要终端用户提交申请，根据申请的内容信息，自动建立一条责任链，然后就可以开始流转了。

有这么一个场景，用户参加一个活动可以领取奖品，但是活动需要进行很多的规则校验然后才能放行，比如首先需要校验用户是否是新用户、今日参与人数是否有限额、全场参与人数是否有限额等等。设定的规则都通过后，才能让用户领走奖品。

首先，要定义流程上的节点的基类：

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);
}

代码其实很简单，就是先定义好一个链表，然后在通过任意一节点后，如果此节点有后继节点，那么传递下去。

1.4 模板方法模式

在含有继承结构的代码中，模板方法模式是非常常用的。

通常会有一个抽象类：

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();
}

1.5 状态模式

废话我就不说了，我们说一个简单的例子。商品库存中心有个最基本的需求是减库存和补库存，我们看看怎么用状态模式来写。

核心在于，我们的关注点不再是 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 类：

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 处于什么状态的。

原文链接：
https://mp.weixin.qq.com/s/oCBJQ4YzB_ygYbYMM86U7g

Java设计模式学习2：行为模式相关推荐

Java设计模式学习记录-解释器模式
前言这次介绍另一个行为模式,解释器模式,都说解释器模式用的少,其实只是我们在日常的开发中用的少,但是一些开源框架中还是能见到它的影子,例如:spring的spEL表达式在解析时就用到了解释器模式,以 ...
Java设计模式学习 - 模版方法模式策略模式
个人博客项目地址希望各位帮忙点个star,给我加个小星星✨ 设计模式-模板方法&策略模式简单介绍模板方法模式(Template):定义一个操作中的算法的骨架,而将一些步骤延迟到子类中. ...
Java设计模式学习之工厂模式
简单工厂模式我直接上代码代码里有很详细的注解 //简单工厂模式是由一个工厂对象决定创建出哪种产品 class Factory1 {publicstatic void main(String[] a ...
Java设计模式学习02——工厂模式
工厂模式工厂模式主要是为创建对象提供接口,将创建对象的过程隔离起来,实现了创建者与调用者的分离,提高了程序的灵活性. 核心本质: 实例化对象,用工厂方法代替new操作. 将选择实现类.创建对象统一 ...
设计模式学习之代理模式学习（一）
设计模式学习之代理模式学习(一) 关于设计模式想必学习过Java语言的人都知道吧,当时对其进行深入学习的的人应该不是很多.在我看来设计方面的知识相比于框架应用配置等知识要有意思的多,并且设计模式的对一 ...
Java设计模式之创建型模式
一.创建型模式 1.工厂模式[Factory] 定义:工厂模式是我们最常用的实例化对象模式了,是用工厂方法代替new操作的一种模式. 普通工厂:工厂是具体的,产品是抽象的.[学习难度:★★☆☆☆,使用 ...
java设计模式学习笔记之装饰模式
java设计模式学习笔记之装饰模式尊重原创,转载请注明出处,原文地址: http://blog.csdn.net/qq137722697 这是一个使用策略模式和构建模式设计的网络请求框架,去看看吧& ...
Java设计模式（装饰者模式-组合模式-外观模式-享元模式）
Java设计模式Ⅳ 1.装饰者模式 1.1 装饰者模式概述 1.2 代码理解 2.组合模式 2.1 组合模式概述 2.2 代码理解 3.外观模式 3.1 外观模式概述 3.2 代码理解 4.享元模式 ...
java设计模式4--建造者模式（Builder）
本文地址:http://www.cnblogs.com/archimedes/p/java-builder-pattern.html,转载请注明源地址. 建造者模式将一个复杂对象的构建与它的表示分离 ...
Java设计模式-观察者模式(订阅发布模式)
Java设计模式-观察者模式(订阅发布模式) 一起来看会了就当复习丫,不会来一起来看看吧. 很喜欢一句话:"八小时内谋生活,八小时外谋发展". 如果你也喜欢,让我们一起坚持吧!! ...

Java设计模式学习2：行为模式