“行为变化”模式

“行为变化”模式

在组件构建过程中，组件行为的变化经常导致组件本身剧烈的变化。“行为变化”模式将组件的行为与组件本身进行解耦从而支持组件行为的变化，实现两者之间的松耦合。

典型模式

Command

Visitor

Command命令模式

将一个请求（行为）封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及可撤销的操作。

动机

在软件构建过程中，“行为请求者”和“行为实现者”通常呈现一种“紧耦合”。但在某些场合----比如需要对行为进行“记录、撤销、重置、事务”等处理，这种无法抵御变化的紧耦合是不合适的。

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

类图

Client

客户类，创建一个具体命令对象（ConcreteCommand），并且组装命令对象和接收者（Receiver）。

Command

抽象命令类，定义公共接口。

ConcreteCommand

具体命令对象，通常会持有接收者（Receiver），并调用接收者的功能来完成命令要执行的操作。

Receiver

接收者，真正执行命令的对象。任何类都可能成为一个接收者，只要它能够实现命令要求实现的相应功能

Invoker

请求者角色，要求命令对象执行请求，通常会持有命令对象，可以持有很多的命令对象。

Command命令模式设计流程

#include <iostream>
#include <vector>
#include <string>
using namespace std;

class Command
{
public:
    virtual void execute() = 0;
};

class ConcreteCommand1 : public Command
{
    string arg;
public:
    ConcreteCommand1(const string & a) : arg(a) {}
    void execute() override
    {
        cout<< "#1 process..."<<arg<<endl;
    }
};

class ConcreteCommand2 : public Command
{
    string arg;
public:
    ConcreteCommand2(const string & a) : arg(a) {}
    void execute() override
    {
        cout<< "#2 process..."<<arg<<endl;
    }
};
              
class MacroCommand : public Command
{
    vector<Command*> commands;
public:
    void addCommand(Command *c) { commands.push_back(c); }
    void execute() override
    {
        for (auto &c : commands)
        {
            c->execute();
        }
    }
};
             
int main()
{
    ConcreteCommand1 command1(receiver, "Arg ###");
    ConcreteCommand2 command2(receiver, "Arg $$$");
    
    MacroCommand macro;
    macro.addCommand(&command1);
    macro.addCommand(&command2);
    
    macro.execute();
}

要点总结

Command模式的根本目的在于将“行为请求者”和“行为实现者”解耦，在面向对象语言中，常见的实现手段是“将行为抽象为对象”。

实现Command接口的具体命令对象ConcreteCommand有时候根据需要可能会保存一些额外的状态信息。通过使用Composite模式，可以将多个命令封装为一个“复合命令”，MacroCommand.

Command模式和c++中函数对象有些类似。但二者定义行为接口的规范有些区别：Command以面向对象中的“接口-实现”来定义行为接口规范，更严格，但有性能损失；c++函数对象以函数签名来定义行为接口规范，更灵活，性能更高。

Visitor访问器模式

表示一个作用于某对象结构中的各元素的操作。使得可以在不改变（稳定）各元素的类的前提下定义（扩展）作用于这些元素的新操作（变化）。

动机

在软件构建的过程中，由于需求的变化，某些类层次结构中，常常需要增加新的的行为（方法），如果直接在基类中做这样的更改，将会给子类带来很繁重的变更负担，甚至破坏原有设计。

如何在不变更类层次结构的前提下，在运行时根据需要透明地为类层次结构上的各个类动态添加新的操作，从而避免上述问题？

类图

Visitor

声明了一个或者多个接口，个数等同于ConcreteElement的个数。

ConcreteVisitor

实现Visitor所声明的接口。

Element

声明一个让子类扩展的接口，参数为Visitor。

ConcreteElement

具体元素类，实现了Visitor的接口。

ObiectStructure

结构对象类，可以设计遍历结构中的所有元素，可设计提供一个高层次的接口让访问者对象可以访问每一个元素，亦可设计成一个复合对象或者一个聚集，如列（List）或集合（Set）。

Visitor模式设计流程

#include <iostream>
using namespace std;

class Visitor;

class Element
{
public:
    virtual void accept(Visitor& visitor) = 0; //第一次多态辨析

    virtual ~Element(){}
};

class ElementA : public Element
{
public:
    void accept(Visitor &visitor) override {
        visitor.visitElementA(*this);
    }
    

};

class ElementB : public Element
{
public:
    void accept(Visitor &visitor) override {
        visitor.visitElementB(*this); //第二次多态辨析
    }

};


class Visitor{
public:
    virtual void visitElementA(ElementA& element) = 0;
    virtual void visitElementB(ElementB& element) = 0;
    
    virtual ~Visitor(){}
};

//==================================

//扩展1
class Visitor1 : public Visitor{
public:
    void visitElementA(ElementA& element) override{
        cout << "Visitor1 is processing ElementA" << endl;
    }
        
    void visitElementB(ElementB& element) override{
        cout << "Visitor1 is processing ElementB" << endl;
    }
};
     
//扩展2
class Visitor2 : public Visitor{
public:
    void visitElementA(ElementA& element) override{
        cout << "Visitor2 is processing ElementA" << endl;
    }
    
    void visitElementB(ElementB& element) override{
        cout << "Visitor2 is processing ElementB" << endl;
    }
};
        
int main()
{
    Visitor2 visitor;
    ElementB elementB;
    elementB.accept(visitor);// double dispatch
    
    ElementA elementA;
    elementA.accept(visitor);

    
    return 0;
}

要点总结

Visitor模式通过所谓双重分发（double dispatch）来实现在不更改（不添加新的操作--编译时）Element类层次结构的前提下，在运行时透明地为类层次结构上的各个类动态添加新的操作（支持变化）。

所谓双重分发即Visitor模式中间包括了两个多态分发（注意其中的多态机制）：第一个为accept方法的多态辨析，第二个为visitElementX方法的多态辨析。

Visitor模式的最大缺点在于扩展类层次结构（增添新的Element子类），会导致Visitor类的改变。因此Visitor模式适用于“Element类层次结构稳定，而其中的操作却经常面临频繁改动”。