behavior型design模式tutorial

behavior型design模式关注object之间通信 and 职责分配, 定义了object之间交互方式, 使得system更加flexible and 可maintenance. 本tutorial将详细介绍观察者, 策略, 模板method, commandsetc.common behavior型design模式.

behavior型design模式overview

behavior型design模式主要目 is 定义object之间交互方式, from 而improvingsystem flexible性 and 可maintenance性. throughusingbehavior型模式, 我们可以:

定义object之间通信方式
分配object之间职责
reducingobject之间耦合
improvingsystem 可scale性

1. observer pattern (Observer)

concepts

observer pattern定义object间一种一 for many 依赖relationships, 当一个object status发生变化时, 所 has 依赖于它 object都得 to notification并被自动update.

implementation

                    // 主题interface
interface Subject {
    void registerObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers();
}

// 观察者interface
interface Observer {
    void update(String message);
}

// 具体主题
class ConcreteSubject implements Subject {
    private List observers = new ArrayList<>();
    private String state;
    
    public void setState(String state) {
        this.state = state;
        notifyObservers();
    }
    
    public String getState() {
        return state;
    }
    
    @Override
    public void registerObserver(Observer observer) {
        observers.add(observer);
    }
    
    @Override
    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }
    
    @Override
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(state);
        }
    }
}

// 具体观察者A
class ConcreteObserverA implements Observer {
    private String name;
    
    public ConcreteObserverA(String name) {
        this.name = name;
    }
    
    @Override
    public void update(String message) {
        System.out.println(name + " received: " + message);
    }
}

// 具体观察者B
class ConcreteObserverB implements Observer {
    private String name;
    
    public ConcreteObserverB(String name) {
        this.name = name;
    }
    
    @Override
    public void update(String message) {
        System.out.println(name + " received: " + message);
    }
}

// 客户端code
class Client {
    public static void main(String[] args) {
        ConcreteSubject subject = new ConcreteSubject();
        
        Observer observerA = new ConcreteObserverA("Observer A");
        Observer observerB = new ConcreteObserverB("Observer B");
        
        subject.registerObserver(observerA);
        subject.registerObserver(observerB);
        
        subject.setState("New state 1");
        subject.setState("New state 2");
        
        subject.removeObserver(observerA);
        subject.setState("New state 3");
    }
}

                

application场景

当一个object status变化需要notificationotherobject时
当一个object需要将自己变化notification给 many 个object时
当object之间耦合度需要降 low 时

2. strategy pattern (Strategy)

concepts

strategy pattern定义一系列 algorithms, 把它们一个个encapsulation起来, 并且使它们可相互replace.

implementation

                    // 策略interface
interface Strategy {
    int doOperation(int num1, int num2);
}

// 具体策略A
class OperationAdd implements Strategy {
    @Override
    public int doOperation(int num1, int num2) {
        return num1 + num2;
    }
}

// 具体策略B
class OperationSubtract implements Strategy {
    @Override
    public int doOperation(int num1, int num2) {
        return num1 - num2;
    }
}

// 具体策略C
class OperationMultiply implements Strategy {
    @Override
    public int doOperation(int num1, int num2) {
        return num1 * num2;
    }
}

//  on  under 文
class Context {
    private Strategy strategy;
    
    public Context(Strategy strategy) {
        this.strategy = strategy;
    }
    
    public void setStrategy(Strategy strategy) {
        this.strategy = strategy;
    }
    
    public int executeStrategy(int num1, int num2) {
        return strategy.doOperation(num1, num2);
    }
}

// 客户端code
class Client {
    public static void main(String[] args) {
        Context context = new Context(new OperationAdd());
        System.out.println("10 + 5 = " + context.executeStrategy(10, 5));
        
        context.setStrategy(new OperationSubtract());
        System.out.println("10 - 5 = " + context.executeStrategy(10, 5));
        
        context.setStrategy(new OperationMultiply());
        System.out.println("10 * 5 = " + context.executeStrategy(10, 5));
    }
}

                

application场景

当一个class has many 种behavior, 并且这些behavior in run时可以相互replace时
当一个algorithms has many 种变体, 并且客户端需要able to选择其in一种变体时
当你需要避免using big 量条件语句来选择不同 behavior时

3. 模板method模式 (Template Method)

concepts

模板method模式定义一个operationin algorithms 骨架, 而将一些步骤latency to 子classin. 模板method使得子class可以不改变一个algorithms structure即可重定义该algorithms 某些specific步骤.

implementation

                    // abstractionclass
abstract class AbstractClass {
    // 模板method
    public final void templateMethod() {
        primitiveOperation1();
        primitiveOperation2();
        concreteOperation();
        hook();
    }
    
    // abstractionmethod
    protected abstract void primitiveOperation1();
    protected abstract void primitiveOperation2();
    
    // 具体method
    private void concreteOperation() {
        System.out.println("AbstractClass: concreteOperation");
    }
    
    // hookmethod
    protected void hook() {
        // 默认implementation for 空
    }
}

// 具体classA
class ConcreteClassA extends AbstractClass {
    @Override
    protected void primitiveOperation1() {
        System.out.println("ConcreteClassA: primitiveOperation1");
    }
    
    @Override
    protected void primitiveOperation2() {
        System.out.println("ConcreteClassA: primitiveOperation2");
    }
}

// 具体classB
class ConcreteClassB extends AbstractClass {
    @Override
    protected void primitiveOperation1() {
        System.out.println("ConcreteClassB: primitiveOperation1");
    }
    
    @Override
    protected void primitiveOperation2() {
        System.out.println("ConcreteClassB: primitiveOperation2");
    }
    
    @Override
    protected void hook() {
        System.out.println("ConcreteClassB: hook");
    }
}

// 客户端code
class Client {
    public static void main(String[] args) {
        AbstractClass classA = new ConcreteClassA();
        classA.templateMethod();
        
        System.out.println();
        
        AbstractClass classB = new ConcreteClassB();
        classB.templateMethod();
    }
}

                

application场景

当你希望定义一个algorithms 骨架, 而将一些步骤 implementationlatency to 子class时
当你希望 in 子classin重定义algorithms 某些specific步骤, 而不改变algorithms structure时
当你希望 in 父classin定义algorithms 公共部分, 而将变体部分留给子classimplementation时

4. Command Pattern

concepts

commands模式将一个requestencapsulation for 一个object, from 而使你可用不同 request for 客户forparameter化; for request排队 or 记录requestlog, 以及support可revert operation.

implementation

                    // commandsinterface
interface Command {
    void execute();
    void undo();
}

// 接收者
class Receiver {
    public void action() {
        System.out.println("Receiver: action");
    }
    
    public void undoAction() {
        System.out.println("Receiver: undoAction");
    }
}

// 具体commands
class ConcreteCommand implements Command {
    private Receiver receiver;
    
    public ConcreteCommand(Receiver receiver) {
        this.receiver = receiver;
    }
    
    @Override
    public void execute() {
        receiver.action();
    }
    
    @Override
    public void undo() {
        receiver.undoAction();
    }
}

// 调用者
class Invoker {
    private Command command;
    
    public void setCommand(Command command) {
        this.command = command;
    }
    
    public void executeCommand() {
        command.execute();
    }
    
    public void undoCommand() {
        command.undo();
    }
}

// 客户端code
class Client {
    public static void main(String[] args) {
        Receiver receiver = new Receiver();
        Command command = new ConcreteCommand(receiver);
        Invoker invoker = new Invoker();
        
        invoker.setCommand(command);
        invoker.executeCommand();
        invoker.undoCommand();
    }
}

                

application场景

当你需要将request 发送者 and 接收者解耦时
当你需要support可revert operation时
当你需要supportlog记录 and transaction时
当你需要将 many 个operation组合成一个复合operation时

behavior型模式选择guide

in 选择behavior型模式时, 可以考虑以 under 因素:

such as果需要object间一 for many 通信, usingobserver pattern
such as果需要 in run时选择不同 algorithms, usingstrategy pattern
such as果需要定义algorithms 骨架并允许子class重定义某些步骤, using模板method模式
such as果需要将requestencapsulation for object, usingcommands模式

实践case: behavior型模式 application

case: messagenotificationsystem

fake设你需要design一个messagenotificationsystem, 需要考虑以 under requirements:

system需要support many 种notification方式 (email, SMS, pushnotificationetc.)
当 has new message时, 需要notification所 has subscribe user
notification 发送流程 has 固定步骤, 但具体implementation可能不同
需要support发送commands revert and 重做

in 这个systemin, 你可以application以 under behavior型模式:

observer pattern: 用于messagerelease and subscribemechanism
strategy pattern: 用于不同 notification方式
模板method模式: 用于notification发送流程
commands模式: 用于encapsulationnotification发送 request

互动练习

练习1: observer patternapplication

请design一个天气预报system, 当天气dataupdate时, 所 has subscribe 显示设备 (such as手机, 电脑, 电视) 都能接收 to update并显示最 new 天气information.

练习2: strategy patternapplication

请design一个sortsystem, support many 种sortalgorithms (such as冒泡sort, fast 速sort, 插入sort) , 并且客户端可以 in run时选择using哪种sortalgorithms.

练习3: commands模式application

请design一个文本编辑器 revert/重做functions, usingcommands模式encapsulation文本编辑operation (such as插入, delete, replace) .