0
点赞
收藏
分享

微信扫一扫

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


行为模式

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

1.1策略模式

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

public interface Strategy {
public void draw(int radius, int x, int y);
}

然后定义具体的几个策略:

public class RedPen implements Strategy {
@Override
public void draw(int radius, int x, int y) {
System.out.println("用红色笔画图,radius:" + radius + ", x:" + x + ", y:" + y);
}
}
public class GreenPen implements Strategy {
@Override
public void draw(int radius, int x, int y) {
System.out.println("用绿色笔画图,radius:" + radius + ", x:" + x + ", y:" + y);
}
}
public class BluePen implements Strategy {
@Override
public 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);
}

Java设计模式学习2:行为模式_spring

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);
}
// 该方法由主题类在数据变更的时候进行调用
@Override
public 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);
}
@Override
public 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 X
Context 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 处于什么状态的。


举报

相关推荐

0 条评论