Behavioral on Aurora

Interpreter Pattern in Design Pattern

Tue, 16 Jun 2020 15:51:51 +0000

解释器模式

Overview

解释器模式（Interpreter Pattern）提供了评估语言的语法或表达式的方式，它属于行为型模式。

这种模式实现了一个表达式接口，该接口解释一个特定的上下文。

这种模式被用在 SQL 解析、符号处理引擎等。

主要解决

对于一些固定文法构建一个解释句子的解释器

何时使用

如果一种特定类型的问题发生的频率足够高，那么可能就值得将该问题的各个实例表述为一个简单语言中的句子。

这样就可以构建一个解释器，该解释器通过解释这些句子来解决该问题。

应用实例

编译器
运算表达式计算

优点

可扩展性比较好，灵活
增加了新的解释表达式的方式
易于实现简单文法

实现

Expression

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


package individual.cy.learn.pattern.behavioral.interpreter;

/**
 * @author mystic
 */
public interface Expression {
 /**
 * interpret
 *
 * @param context context
 * @return true or false
 */
 boolean interpret(String context);
}

TerminalExpression

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


package individual.cy.learn.pattern.behavioral.interpreter;

/**
 * @author mystic
 */
public class TerminalExpression implements Expression {
 private final String data;

 public TerminalExpression(String data) {
 this.data = data;
 }

 @Override
 public boolean interpret(String context) {
 return context.contains(data);
 }
}

AndExpression

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


package individual.cy.learn.pattern.behavioral.interpreter;

/**
 * @author mystic
 */
public class AndExpression implements Expression {
 private final Expression exp1;
 private final Expression exp2;

 public AndExpression(Expression exp1, Expression exp2) {
 this.exp1 = exp1;
 this.exp2 = exp2;
 }

 @Override
 public boolean interpret(String context) {
 return exp1.interpret(context) && exp2.interpret(context);
 }
}

OrExpression

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


package individual.cy.learn.pattern.behavioral.interpreter;

/**
 * @author mystic
 */
public class OrExpression implements Expression {
 private final Expression exp1;
 private final Expression exp2;

 public OrExpression(Expression exp1, Expression exp2) {
 this.exp1 = exp1;
 this.exp2 = exp2;
 }

 @Override
 public boolean interpret(String context) {
 return exp1.interpret(context) || exp2.interpret(context);
 }
}

Tester

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


package individual.cy.learn.pattern.behavioral.interpreter;

/**
 * @author mystic
 */
public class InterpreterPatternTester {
 public static void main(String[] args) {
 // rule: Kushagra and Lokesh are both male.
 Expression person1 = new TerminalExpression("Kushagra");
 Expression person2 = new TerminalExpression("Lokesh");
 Expression isSingle = new OrExpression(person1, person2);

 // rule: Vikram is committed.
 Expression vikram = new TerminalExpression("Vikram");
 Expression committed = new TerminalExpression("Committed");
 Expression isCommitted = new AndExpression(vikram, committed);

 System.out.println(isSingle.interpret("Kushagra"));
 System.out.println(isSingle.interpret("Lokesh"));
 System.out.println(isSingle.interpret("Achint"));

 System.out.println(isCommitted.interpret("Committed, Vikram"));
 System.out.println(isCommitted.interpret("Single, Vikram"));
 }
}

1
2
3
4
5


true
true
false
true
false

Command Pattern in Design Pattern

Mon, 15 Jun 2020 13:57:46 +0000

命令模式

Overview

命令模式（Command Pattern）是一种数据驱动的设计模式，它属于行为型模式。

请求以命令的形式包裹在对象中，并传给调用对象。

调用对象寻找可以处理该命令的合适的对象，并把该命令传给相应的对象，该对象执行命令。

主要解决

在软件系统中，行为请求者与行为实现者通常是一种紧耦合的关系，但某些场合，比如需要对行为进行记录、撤销或重做、事务等处理时，这种无法抵御变化的紧耦合的设计就不太合适。

何时使用

在某些场合，比如要对行为进行"记录、撤销/重做、事务"等处理，这种无法抵御变化的紧耦合是不合适的。

在这种情况下，如何将"行为请求者"与"行为实现者"解耦？将一组行为抽象为对象，可以实现二者之间的松耦合。

应用实例

struts中的action核心控制器ActionServlet

优点

降低了系统耦合度
新的命令可以很容易添加到系统中去

实现

Command

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package individual.cy.learn.pattern.behavioral.command;

/**
 * @author mystic
 */
public interface Command {
 /**
 * execute a action
 */
 void execute();
}

Light

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


package individual.cy.learn.pattern.behavioral.command;

/**
 * @author mystic
 */
public class Light {
 public void on() {
 System.out.println("Light.on");
 }

 public void off() {
 System.out.println("Light.off");
 }
}

LightOnCommand

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


package individual.cy.learn.pattern.behavioral.command;

/**
 * @author mystic
 */
public class LightOnCommand implements Command {

 private final Light light;

 public LightOnCommand(Light light) {
 this.light = light;
 }

 @Override
 public void execute() {
 light.on();
 }
}

LightOffCommand

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


package individual.cy.learn.pattern.behavioral.command;

/**
 * @author mystic
 */
public class LightOffCommand implements Command {

 private final Light light;

 public LightOffCommand(Light light) {
 this.light = light;
 }

 @Override
 public void execute() {
 light.off();
 }
}

Stereo

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


package individual.cy.learn.pattern.behavioral.command;

/**
 * @author mystic
 */
public class Stereo {
 public void on() {
 System.out.println("Stereo.on");
 }

 public void off() {
 System.out.println("Stereo.off");
 }

 public void setCD() {
 System.out.println("Stereo.setCD");
 }

 public void setDVD() {
 System.out.println("Stereo.setDVD");
 }

 public void setRadio() {
 System.out.println("Stereo.setRadio");
 }

 public void setVolume(int volume) {
 System.out.println("Stereo.setVolume: volume = " + volume);
 }
}

StereoOnWithCdCommand

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


package individual.cy.learn.pattern.behavioral.command;

/**
 * @author mystic
 */
public class StereoOnWithCdCommand implements Command {
 private final Stereo stereo;

 public StereoOnWithCdCommand(Stereo stereo) {
 this.stereo = stereo;
 }

 @Override
 public void execute() {
 stereo.on();
 stereo.setCD();
 stereo.setVolume(11);
 }
}

StereoOffCommand

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


package individual.cy.learn.pattern.behavioral.command;

/**
 * @author mystic
 */
public class StereoOffCommand implements Command {
 private final Stereo stereo;

 public StereoOffCommand(Stereo stereo) {
 this.stereo = stereo;
 }

 @Override
 public void execute() {
 stereo.off();
 }
}

SimpleRemoteControl

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


package individual.cy.learn.pattern.behavioral.command;

/**
 * @author mystic
 */
public class SimpleRemoteControl {
 private Command slot;

 public void setCommand(Command command) {
 slot = command;
 }

 public void buttonWasPressed() {
 slot.execute();
 }
}

Tester

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


package individual.cy.learn.pattern.behavioral.command;

/**
 * @author mystic
 */
public class CommandPatternTester {
 public static void main(String[] args) {
 SimpleRemoteControl remote = new SimpleRemoteControl();
 Light light = new Light();
 Stereo stereo = new Stereo();

 // change command dynamically
 remote.setCommand(new LightOnCommand(light));
 remote.buttonWasPressed();

 remote.setCommand(new StereoOnWithCdCommand(stereo));
 remote.buttonWasPressed();

 remote.setCommand(new StereoOffCommand(stereo));
 remote.buttonWasPressed();
 }
}

1
2
3
4
5


Light.on
Stereo.on
Stereo.setCD
Stereo.setVolume: volume = 11
Stereo.off

State Pattern in Design Pattern

Fri, 12 Jun 2020 16:49:39 +0000

状态模式

Overview

在状态模式（State Pattern）中，类的行为是基于它的状态改变的。

这种类型的设计模式属于行为型模式。

在状态模式中，我们创建表示各种状态的对象和一个行为随着状态对象改变而改变的 context 对象。

主要解决

对象的行为依赖于它的状态（属性），并且可以根据它的状态改变而改变它的相关行为

何时使用

代码中包含大量与对象状态有关的条件语句

应用实例

购物订单的状态改变(未付款, 付款, 确认收货…)

优点

封装了转换规则
枚举可能的状态，在枚举状态之前需要确定状态种类
将所有与某个状态有关的行为放到一个类中，并且可以方便地增加新的状态，只需要改变对象状态即可改变对象的行为
允许状态转换逻辑与状态对象合成一体，而不是某一个巨大的条件语句块
可以让多个环境对象共享一个状态对象，从而减少系统中对象的个数

实现

Package State

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


package individual.cy.learn.pattern.behavioral.state;

/**
 * @author mystic
 */
public interface PackageState {
 /**
 * update package state
 * @param ctx context
 */
 void updateState(DeliveryContext ctx);
}

Acknowledged

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


package individual.cy.learn.pattern.behavioral.state;

/**
 * @author mystic
 */
public class Acknowledged implements PackageState {

 private static volatile Acknowledged singleton = null;

 private Acknowledged() {
 }

 public static Acknowledged instance() {
 if (singleton == null) {
 synchronized (Acknowledged.class) {
 if (singleton == null) {
 singleton = new Acknowledged();
 }
 }
 }
 return singleton;
 }


 @Override
 public void updateState(DeliveryContext ctx) {
 System.out.println("Package is acknowledged !!");
 ctx.setCurrentState(Shipped.instance());
 }
}

Shipped

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


package individual.cy.learn.pattern.behavioral.state;

/**
 * @author mystic
 */
public class Shipped implements PackageState {

 private static volatile Shipped singleton = null;

 private Shipped() {
 }

 public static Shipped instance() {
 if (singleton == null) {
 synchronized (Shipped.class) {
 if (singleton == null) {
 singleton = new Shipped();
 }
 }
 }
 return singleton;
 }

 @Override
 public void updateState(DeliveryContext ctx) {
 System.out.println("Package is shipped !!");
 ctx.setCurrentState(InTransition.instance());
 }
}

In Transition

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


package individual.cy.learn.pattern.behavioral.state;

/**
 * @author mystic
 */
public class InTransition implements PackageState {

 private static volatile InTransition singleton = null;

 private InTransition() {
 }

 public static InTransition instance() {
 if (singleton == null) {
 synchronized (InTransition.class) {
 if (singleton == null) {
 singleton = new InTransition();
 }
 }
 }
 return singleton;
 }

 @Override
 public void updateState(DeliveryContext ctx) {
 System.out.println("Package is in transition !!");
 ctx.setCurrentState(OutForDelivery.instance());
 }
}

Out of Delivery

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


package individual.cy.learn.pattern.behavioral.state;

/**
 * @author mystic
 */
public class OutForDelivery implements PackageState {

 private static volatile OutForDelivery singleton = null;

 private OutForDelivery() {
 }

 public static OutForDelivery instance() {
 if (singleton == null) {
 synchronized (OutForDelivery.class) {
 if (singleton == null) {
 singleton = new OutForDelivery();
 }
 }
 }
 return singleton;
 }

 @Override
 public void updateState(DeliveryContext ctx) {
 System.out.println("Package is out of delivery !!");
 ctx.setCurrentState(Delivered.instance());
 }
}

Delivered

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


package individual.cy.learn.pattern.behavioral.state;

/**
 * @author mystic
 */
public class Delivered implements PackageState {

 private static volatile Delivered singleton = null;

 private Delivered() {
 }

 public static Delivered instance() {
 if (singleton == null) {
 synchronized (Delivered.class) {
 if (singleton == null) {
 singleton = new Delivered();
 }
 }
 }
 return singleton;
 }

 @Override
 public void updateState(DeliveryContext ctx) {
 System.out.println("Package is delivered!!");
 }
}

DeliveryContext

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34


package individual.cy.learn.pattern.behavioral.state;

/**
 * @author mystic
 */
public class DeliveryContext {
 private PackageState currentState;
 private String packageId;

 public DeliveryContext(PackageState currentState, String packageId) {
 this.currentState = currentState != null ? currentState : Acknowledged.instance();
 this.packageId = packageId;
 }

 public void update() {
 currentState.updateState(this);
 }

 public PackageState getCurrentState() {
 return currentState;
 }

 public void setCurrentState(PackageState currentState) {
 this.currentState = currentState;
 }

 public String getPackageId() {
 return packageId;
 }

 public void setPackageId(String packageId) {
 this.packageId = packageId;
 }
}

Tester

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


package individual.cy.learn.pattern.behavioral.state;

/**
 * @author mystic
 */
public class StatePatternTester {
 public static void main(String[] args) {
 DeliveryContext ctx = new DeliveryContext(null, "Test1");
 ctx.update();
 ctx.update();
 ctx.update();
 ctx.update();
 ctx.update();
 }
}

1
2
3
4
5


Package is acknowledged !!
Package is shipped !!
Package is in transition !!
Package is out of delivery !!
Package is delivered !!

Iterator Pattern in Design Pattern

Wed, 10 Jun 2020 14:26:19 +0000

迭代器模式

Overview

迭代器模式（Iterator Pattern）是 Java 和 .Net 编程环境中非常常用的设计模式。

这种模式用于顺序访问集合对象的元素，不需要知道集合对象的底层表示。

迭代器模式属于行为型模式。

主要解决

不同的方式来遍历整个整合对象。

何时使用

遍历一个聚合对象。

应用实例

JAVA 中的 iterator

优点

它支持以不同的方式遍历一个聚合对象
迭代器简化了聚合类
在同一个聚合上可以有多个遍历
在迭代器模式中，增加新的聚合类和迭代器类都很方便，无须修改原有代码

实现

Iterator

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


package individual.cy.learn.pattern.behavioral.iterator;

/**
 * @author mystic
 */
public interface Iterator {
 /**
 * has next()
 * @return true or false
 */
 boolean hasNext();

 /**
 * next obj
 * @return next Object
 */
 Object next();
}

StringArrayIterator

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


package individual.cy.learn.pattern.behavioral.iterator;

/**
 * @author mystic
 */
public class StringArrayIterator implements Iterator{

 private final String[] args;
 private int idx;

 public StringArrayIterator(String[] args) {
 this.args = args;
 }

 @Override
 public boolean hasNext() {
 return idx < args.length;
 }

 @Override
 public Object next() {
 if(idx < args.length){
 return args[idx++];
 }
 return null;
 }
}

Container

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


package individual.cy.learn.pattern.behavioral.iterator;

/**
 * @author mystic
 */
public interface Container {
 /**
 * get iterator
 * @return Iterator
 */
 Iterator getIterator();
}

NameList

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


package individual.cy.learn.pattern.behavioral.iterator;

/**
 * @author mystic
 */
public class NameList implements Container {

 public String[] names = {"Robert", "John", "Julie", "Lora"};

 @Override
 public Iterator getIterator() {
 return new StringArrayIterator(names);
 }

}

Tester

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


package individual.cy.learn.pattern.behavioral.iterator;

/**
 * @author mystic
 */
public class IteratorPatternDemo {
 public static void main(String[] args) {
 NameList nameList = new NameList();
 for (Iterator iter = nameList.getIterator(); iter.hasNext(); ) {
 String name = (String) iter.next();
 System.out.println("name = " + name);
 }
 }
}

1
2
3
4


name = Robert
name = John
name = Julie
name = Lora

Chain of Responsibility in Design Pattern

Thu, 04 Jun 2020 08:50:47 +0000

责任链模式

Overview

顾名思义，责任链模式（Chain of Responsibility Pattern）为请求创建了一个接收者对象的链。

这种模式给予请求的类型，对请求的发送者和接收者进行解耦。

这种类型的设计模式属于行为型模式。

在这种模式中，通常每个接收者都包含对另一个接收者的引用。

如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依此类推。

主要解决

职责链上的处理者负责处理请求，客户只需要将请求发送到职责链上即可，无须关心请求的处理细节和请求的传递，所以职责链将请求的发送者和请求的处理者解耦了。

何时使用

想在访问一个类时，进行一些控制

应用实例

击鼓传花
JS 中的事件冒泡

优点

降低耦合度。它将请求的发送者和接收者解耦
简化了对象。使得对象不需要知道链的结构
增强给对象指派职责的灵活性。通过改变链内的成员或者调动它们的次序，允许动态地新增或者删除责任
增加新的请求处理类很方便。

实现

Logger

AbstractLogger

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38


package individual.cy.learn.pattern.behavioral.chain4responsibility;

/**
 * @author mystic
 */
public abstract class AbstractLogger {
 public final static int DEBUG = 1;
 public final static int INFO = 2;
 public final static int WARN = 3;
 public final static int ERROR = 4;

 protected int level;

 protected AbstractLogger nextLogger;

 public void setNextLogger(AbstractLogger nextLogger) {
 this.nextLogger = nextLogger;
 }

 public void logMessage(int level, String message) {
 // if no ability to handle, hand up it to successor
 if (this.level == level) {
 write(message);
 } else {
 if (nextLogger != null) {
 nextLogger.logMessage(level, message);
 }
 }
 }

 /**
 * write log
 *
 * @param message log info
 */
 protected abstract void write(String message);

}

DebugLogger

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


package individual.cy.learn.pattern.behavioral.chain4responsibility;

/**
 * @author mystic
 */
public class DebugLogger extends AbstractLogger {
 public DebugLogger() {
 this.level = AbstractLogger.DEBUG;
 setNextLogger(new InfoLogger());
 }

 @Override
 protected void write(String message) {
 System.out.println("DebugLogger.write: " + message);
 }
}

InfoLogger

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


package individual.cy.learn.pattern.behavioral.chain4responsibility;

/**
 * @author mystic
 */
public class InfoLogger extends AbstractLogger {
 public InfoLogger() {
 this.level = AbstractLogger.INFO;
 setNextLogger(new WarnLogger());
 }

 @Override
 protected void write(String message) {
 System.out.println("InfoLogger.write: " + message);
 }
}

WarnLogger

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


package individual.cy.learn.pattern.behavioral.chain4responsibility;

/**
 * @author mystic
 */
public class WarnLogger extends AbstractLogger {
 public WarnLogger() {
 this.level = AbstractLogger.WARN;
 setNextLogger(new ErrorLogger());
 }

 @Override
 protected void write(String message) {
 System.out.println("WarnLogger.write: " + message);
 }
}

ErrorLogger

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


package individual.cy.learn.pattern.behavioral.chain4responsibility;

/**
 * @author mystic
 */
public class ErrorLogger extends AbstractLogger {
 public ErrorLogger() {
 this.level = AbstractLogger.ERROR;
 setNextLogger(null);
 }

 @Override
 protected void write(String message) {
 System.out.println("ErrorLogger.write: " + message);
 }
}

Tester

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


package individual.cy.learn.pattern.behavioral.chain4responsibility;

/**
 * @author mystic
 */
public class Tester {
 public static void main(String[] args) {
 AbstractLogger debugLogger = new DebugLogger();
 System.out.println("**************************");
 debugLogger.logMessage(1, "Here is a debug message.");
 System.out.println("==========================");
 debugLogger.logMessage(2, "Here is a info message.");
 System.out.println("==========================");
 debugLogger.logMessage(3, "Here is a warn message.");
 System.out.println("==========================");
 debugLogger.logMessage(4, "Here is a error message.");
 System.out.println("==========================");
 }
}

1
2
3
4
5
6
7
8
9


**************************
DebugLogger.write: Here is a debug message.
==========================
InfoLogger.write: Here is a info message.
==========================
WarnLogger.write: Here is a warn message.
==========================
ErrorLogger.write: Here is a error message.
==========================

Observer Pattern in Design Pattern

Mon, 01 Jun 2020 16:12:19 +0000

观察者模式

Overview

当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。

比如，当一个对象被修改时，则会自动通知依赖它的对象。

观察者模式属于行为型模式。

主要解决

一个对象状态改变给其他对象通知的问题，而且要考虑到易用和低耦合，保证高度的协作。

何时使用

一个对象（目标对象）的状态发生改变，所有的依赖对象（观察者对象）都将得到通知，进行广播通知。

应用实例

拍卖的时候，拍卖师观察最高标价，然后通知给其他竞价者竞价

优点

观察者和被观察者是抽象耦合的
建立一套触发机制

实现一

Observer

Observer Interface

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


package individual.cy.learn.pattern.behavioral.observer.sln2;

/**
 * @author mystic
 */
public interface Observer {
 /**
 * update
 * @param event event
 */
 void update(String event);
}

People Daily

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package individual.cy.learn.pattern.behavioral.observer.sln2;

/**
 * @author mystic
 */
public class PeopleDaily implements Observer {
 @Override
 public void update(String event) {
 System.out.println("Breaking news in People Daily! event = " + event);
 }
}

New York Times

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package individual.cy.learn.pattern.behavioral.observer.sln2;

/**
 * @author mystic
 */
public class NewYorkTimes implements Observer {
 @Override
 public void update(String event) {
 System.out.println("Breaking news in New York Times! event = " + event);
 }
}

Subject

Subject Interface

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


package individual.cy.learn.pattern.behavioral.observer.sln2;

/**
 * @author mystic
 */
public interface Subject {
 /**
 * register
 *
 * @param observer observer
 */
 void registerObserver(Observer observer);

 /**
 * unregister
 *
 * @param observer observer
 */
 void unregisterObserver(Observer observer);

 /**
 * notify all observers
 * @param event event
 */
 void notifyObservers(String event);
}

Feed

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


package individual.cy.learn.pattern.behavioral.observer.sln2;

import java.util.ArrayList;
import java.util.List;

/**
 * @author mystic
 */
public class Feed implements Subject {
 private final List<Observer> observers = new ArrayList<>();

 @Override
 public void registerObserver(Observer observer) {
 observers.add(observer);
 }

 @Override
 public void unregisterObserver(Observer observer) {
 observers.remove(observer);
 }

 @Override
 public void notifyObservers(String event) {
 observers.forEach(o -> o.update(event));
 }
}

Tester

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


package individual.cy.learn.pattern.behavioral.observer.sln2;

/**
 * @author mystic
 */
public class Tester {
 public static void main(String[] args) {
 Feed globalEvent = new Feed();

 Observer newYorkTimes = new NewYorkTimes();
 Observer peopleDaily = new PeopleDaily();

 globalEvent.registerObserver(newYorkTimes);
 globalEvent.registerObserver(peopleDaily);

 globalEvent.notifyObservers("Violent Parade in USA");

 System.out.println("Unregister New York Times!");
 globalEvent.unregisterObserver(newYorkTimes);
 globalEvent.notifyObservers("Violent Parade in Canada");
 }
}

1
2
3
4


Breaking news in New York Times! event = Violent Parade in USA
Breaking news in People Daily! event = Violent Parade in USA
Unregister New York Times!
Breaking news in People Daily! event = Violent Parade in Canada

实现二

Observer

Abstract Observer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


package individual.cy.learn.pattern.behavioral.observer;

/**
 * @author mystic
 */
public abstract class AbstractObserver {
 protected Subject subject;

 /**
 * update
 */
 public abstract void update();
}

Binary Observer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


package individual.cy.learn.pattern.behavioral.observer;

/**
 * @author mystic
 */
public class BinaryObserver extends AbstractObserver {
 public BinaryObserver(Subject subject) {
 this.subject = subject;
 this.subject.attach(this);
 }

 @Override
 public void update() {
 System.out.println("BinaryObserver.update: " + Integer.toBinaryString(subject.getState()));
 }
}

Octal Observer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


package individual.cy.learn.pattern.behavioral.observer;

/**
 * @author mystic
 */
public class OctalObserver extends AbstractObserver {

 public OctalObserver(Subject subject) {
 this.subject = subject;
 this.subject.attach(this);
 }

 @Override
 public void update() {
 System.out.println("OctalObserver.update: " + Integer.toOctalString(subject.getState()));
 }
}

Hex Observer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


package individual.cy.learn.pattern.behavioral.observer;

/**
 * @author mystic
 */
public class HexObserver extends AbstractObserver {
 public HexObserver(Subject subject) {
 this.subject = subject;
 this.subject.attach(this);
 }

 @Override
 public void update() {
 System.out.println("HexObserver.update: " + Integer.toHexString(subject.getState()).toUpperCase());
 }
}

Subject

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


package individual.cy.learn.pattern.behavioral.observer;

import java.util.ArrayList;
import java.util.List;

/**
 * @author mystic
 */
public class Subject {
 private final List<AbstractObserver> observerList = new ArrayList<>();

 private int state;

 public int getState() {
 return state;
 }

 public void setState(int state) {
 this.state = state;
 notifyAllObservers();
 }

 public void attach(AbstractObserver observer) {
 observerList.add(observer);
 }

 public void notifyAllObservers() {
 observerList.forEach(AbstractObserver::update);
 }
}

Tester

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


package individual.cy.learn.pattern.behavioral.observer;

/**
 * @author mystic
 */
public class ObserverPatternTester {
 public static void main(String[] args) {
 Subject subject = new Subject();
 new HexObserver(subject);
 new OctalObserver(subject);
 new BinaryObserver(subject);

 System.out.println("First state change: 15");
 subject.setState(15);
 System.out.println("========================");
 System.out.println("Second state change: 10");
 subject.setState(10);
 }
}

1
2
3
4
5
6
7
8
9


First state change: 15
HexObserver.update: F
OctalObserver.update: 17
BinaryObserver.update: 1111
========================
Second state change: 10
HexObserver.update: A
OctalObserver.update: 12
BinaryObserver.update: 1010

Strategy Pattern in Design Pattern

Sun, 31 May 2020 20:27:11 +0000

策略模式

Overview

在策略模式（Strategy Pattern）中，一个类的行为或其算法可以在运行时更改。

这种类型的设计模式属于行为型模式。

在策略模式中，我们创建表示各种策略的对象和一个行为随着策略对象改变而改变的 context 对象。

策略对象改变 context 对象的执行算法。

主要解决

在有多种算法相似的情况下，使用 if…else 所带来的复杂和难以维护。

何时使用

一个系统有许多许多类，而区分它们的只是他们直接的行为。

应用实例

诸葛亮的锦囊妙计，每一个锦囊就是一个策略
旅行的出游方式，选择骑自行车、坐汽车，每一种旅行方式都是一个策略
JAVA AWT 中的 LayoutManager

优点

算法可以自由切换
避免使用多重条件判断
扩展性良好

注意事项

如果一个系统的策略多于四个，就需要考虑使用混合模式，解决策略类膨胀的问题。

实现

Behavior

Jump Interface

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package individual.cy.learn.pattern.behavioral.strategy;

/**
 * @author mystic
 */
public interface JumpBehavior{
 /**
 * jump
 */
 void jump();
}

Short Jump

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package individual.cy.learn.pattern.behavioral.strategy;

/**
 * @author mystic
 */
public class ShortJump implements JumpBehavior {
 @Override
 public void jump() {
 System.out.println("ShortJump.jump");
 }
}

Long Jump

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package individual.cy.learn.pattern.behavioral.strategy;

/**
 * @author mystic
 */
public class LongJump implements JumpBehavior {
 @Override
 public void jump() {
 System.out.println("LongJump.jump");
 }
}

Kick Interface

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package individual.cy.learn.pattern.behavioral.strategy;

/**
 * @author mystic
 */
public interface KickBehavior{
 /**
 * kick
 */
 void kick();
}

Lightning Kick

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package individual.cy.learn.pattern.behavioral.strategy;

/**
 * @author mystic
 */
public class LightningKick implements KickBehavior {
 @Override
 public void kick() {
 System.out.println("LightningKick.kick");
 }
}

Tornado Kick

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


package individual.cy.learn.pattern.behavioral.strategy;

/**
 * @author mystic
 */
public class TornadoKick implements KickBehavior {
 @Override
 public void kick() {
 System.out.println("TornadoKick.kick");
 }
}

Fighter

Fighter Interface

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45


package individual.cy.learn.pattern.behavioral.strategy;

/**
 * @author mystic
 */
public abstract class BaseFighter {
 protected KickBehavior kickBehavior;
 protected JumpBehavior jumpBehavior;

 public BaseFighter(KickBehavior kickBehavior, JumpBehavior jumpBehavior) {
 this.kickBehavior = kickBehavior;
 this.jumpBehavior = jumpBehavior;
 }

 /**
 * display
 */
 public abstract void display();

 public void punch() {
 System.out.println("BaseFighter.punch");
 }

 public void roll() {
 System.out.println("BaseFighter.roll");
 }

 public void kick() {
 // delegate to KickBehavior
 kickBehavior.kick();
 }

 public void jump() {
 // delegate to JumpBehavior
 jumpBehavior.jump();
 }

 public void setKickBehavior(KickBehavior kickBehavior) {
 this.kickBehavior = kickBehavior;
 }

 public void setJumpBehavior(JumpBehavior jumpBehavior) {
 this.jumpBehavior = jumpBehavior;
 }
}

YeWen Fighter

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


package individual.cy.learn.pattern.behavioral.strategy;

/**
 * @author mystic
 */
public class YeWenFighter extends BaseFighter {
 public YeWenFighter(KickBehavior kickBehavior, JumpBehavior jumpBehavior) {
 super(kickBehavior, jumpBehavior);
 }

 @Override
 public void display() {
 System.out.println("YeWenFighter.display");
 }
}

Ken Fighter

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


package individual.cy.learn.pattern.behavioral.strategy;

/**
 * @author mystic
 */
public class KenFighter extends BaseFighter {
 public KenFighter(KickBehavior kickBehavior, JumpBehavior jumpBehavior) {
 super(kickBehavior, jumpBehavior);
 }

 @Override
 public void display() {
 System.out.println("KenFighter.display");
 }
}

Tester

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


package individual.cy.learn.pattern.behavioral.strategy;

/**
 * @author mystic
 */
public class StrategyPatternTester {
 public static void main(String[] args) {
 // make some behaviors first
 JumpBehavior shortJump = new ShortJump();
 JumpBehavior longJump = new LongJump();
 KickBehavior tornadoKick = new TornadoKick();

 // Make a fighter with desired behaviors
 BaseFighter ken = new KenFighter(tornadoKick, shortJump);
 ken.display();

 // Test behaviors
 ken.punch();
 ken.roll();
 ken.jump();
 ken.kick();

 // change behavior dynamically
 ken.setJumpBehavior(longJump);
 ken.jump();

 ken.setKickBehavior(tornadoKick);
 ken.kick();
 }
}

Behavioral on Aurora

Interpreter Pattern in Design Pattern

解释器模式

Overview

主要解决

何时使用

应用实例

优点

实现

Expression

TerminalExpression

AndExpression

OrExpression

Tester

相关文章

Command Pattern in Design Pattern

命令模式

Overview

主要解决

何时使用

应用实例

优点

实现

Command

Light

LightOnCommand

LightOffCommand

Stereo

StereoOnWithCdCommand

StereoOffCommand

SimpleRemoteControl

Tester

相关文章

State Pattern in Design Pattern

状态模式

Overview

主要解决

何时使用

应用实例

优点

实现

Package State

Acknowledged

Shipped

In Transition

Out of Delivery

Delivered

DeliveryContext

Tester

相关文章

Iterator Pattern in Design Pattern

迭代器模式

Overview

主要解决

何时使用

应用实例

优点

实现

Iterator

StringArrayIterator

Container

NameList

Tester

相关文章

Chain of Responsibility in Design Pattern

责任链模式

Overview

主要解决

何时使用

应用实例

优点

实现

Logger

AbstractLogger

DebugLogger

InfoLogger

WarnLogger

ErrorLogger

Tester

相关文章