GroupBlog

"组件协作"模式

现代软件专业分工之后第一个结果就素"框架与应用程序的划分", "组件协作"模式通过晚期绑定, 来实现框架与应用程序间的松耦合
典型模式

template Method
Strategy
Observer / Event

Template Method: 定义一个操作中的算法的骨架(稳定), 而将一些步骤延迟(变化)到子类. 它使得子类可以不改变(复用)一个算法的结构即可重用(override 重写)该算法的某些特殊步骤

下面是refactoring to patterns 的代码

class Library {
   
public:
    void step1()
    {
   
        //....
    }

    void step3()
    {
   
        //...
    }

    void step5()
    {
   
        //...
    }
};

class Applicaton {
   
public: 
    bool step2() 
    {
   
        //...
    }
    void step4()
    {
   
        //....
    }
};

int main()
{
   
    Library lib;
    Applicaton app;
    
    lib.step1();
    if (app.step2()) {
   
        lib.step3();
    }

    for (int i = 0; i < 4; i++) {
   
        app.step4();
    }
    lib.step5();
}

class Library {
   
public: 
    void run() 
    {
   
        step1();
        if (step2()) {
    //支持变化 ==> 虚函数的多态
            step3();
        }

        for (int i = 0; i < 4; i++) {
   
            step4();  //支持变化 ==> 虚函数的多态 
        }
        step5();
    }
    virtual ~Library() {
     }

protected:
    void step1() //稳定
    {
   
        //....
    }
    void step3() //稳定
    {
   
        //...
    }

    void step5() //稳定
    {
   
        //...
    }
    virtual bool step2() = 0;  //变化
    virtual void step4() = 0;  //变化
};

class Application  : public Library {
   
protected:
    virtual bool step2()
    {
   
        //...
    }
    virtual void step4()
    {
   
        //...
    }
};

int main()
{
   
    Library *lib = new Application();
    lib->run();
    delete lib;
}

在这里插入图片描述
要点总结:
1. Template Method模式是一种非常基础性的设计模式, 在面向对象系统中有着大量的应用. 它用最简洁的机制(虚函数的多态性)为很多应用程序框架提供了灵活的扩展点, 是代码复用方面的基本实现结构
2. 除了可以灵活应对子步骤的变化外, "不要调用我, 让我来调用你"的反向控制结构是Template Method的典型应用
3. 在具体实现方面, 被Template Method调用的虚方法可以具有实现, 也可以没有任何实现(抽象方法, 纯虚方法), 但一般推荐将他们设置成protected方法

Strategy

开闭原则, 复用指二进制代码的可复用性
定义一系列算法, 把它们一个一个封装起来, 并且使他们可互相替换(变化). 该模式使得算法可独立于使用它们的客户(稳定)而变化(扩展, 子类化)

enum TaxBase {
   
    CN_TAX,
    US_TAX,
    DE_TAX,
    FR_TAX
};

class SalesOrder {
   
    TaxBase tax;
public:
    double CalculateTax() 
    {
   
        if (tax == CN_TAX) {
   
            //CN***********
        } 
        else if (tax == US_TAX) {
   
            //US***********
        }
        else if (tax == DE_TAX) {
   
            //DE***********
        }
        else if (tax == FR_TAX) {
    //更改
            //...
        }
        //...
    }
};

class Context;
class TaxStrategy {
   
public:
    virtual double Calculate(const Context& context) = 0;
    virtual ~TaxStrategy() {
     }
};

class CNTax : public TaxStrategy {
   
public:
    virtual double Calculate(const Context& context) 
    {
   
        //CN************
    }
};
class USTax : public TaxStrategy {
   
public:
    virtual double Calculate(const Context& context) 
    {
   
        //US************
    }
};
class DETax : public TaxStrategy {
   
public:
    virtual double Calculate(const Context& context) 
    {
   
        //DE************
    }
};

//改变, 
class FRTax : public TaxStrategy {
   
public:
    virtual double Calculate(const Context& context) 
    {
   
        //FR************
    }
};

class SalesOrder {
   
private:
    TaxStrategy* strategy; //支持多态性, 所以用指针, 不能用对象

public:
    SalesOrder(StrategyFactory* strategyFactory) 
    {
   
        this->strategy = strategyFactory->NewStrategy();
    }
    ~SalesOrder()
    {
   
        delete this->strategy;
    }
    double CalculateTax()
    {
   
        //...
        Context context;

        double val = strategy->Calculate(context); //多态调用
    }
};

要点总结:

strategy及其子类为组件提供了一系列可重用的算法, 从而可以使得类型在运行时方便地根据需要在各个算法之间进行切换
strategy模式提供了用条件判断语句以外的另一种选择, 消除条件判断原则, 就是在解耦合. 含有许多条件判断语句的代码通常都需要strategy模式
如果strategy对象没有实例变量, 那么各个上下文可以共享同一个strategy对象, 从而节省对象开销

Observe/Event
动机:

在软件构建过程中, 我们需要为某些对象建立一种"通知依赖关系"-- 一个对象(目标对象)的状态发生改变, 所有的依赖对象(观察者对象)都将得到通知. 如果这样的依赖关系过于紧密, 将使软件不能很好地抵御变化
使用面向对象技术, 可以讲这种关系弱化, 并形成一种稳定的依赖关系. 从而实现软件体系结构的松耦合.