［C++之AOP］实战Aspect C++之观察者模式

Aspect C++支持“虚切面”，类似C++中的虚函数。方面可以继承，“派生方面”可以重写“基方面”的“虚切面”，类似C++中的类继承。

有了这个特性，就可以实现一些模式了，这里列出AOP中经典的观察者(Observer)模式［注］。

［注］这个说法不太妥当，观察者模式是经典的设计模式，这里的意思是说AOP经典的观察者模式实现。

它的代码如下：

aspect ObserverPattern {
    // 管理subjects和observers的数据结构
    // TODO 
public:
    // 角色接口
    struct ISubject {};
    struct IObserver {
        virtual void update(ISubject *) = 0;
    };
    // 在派生方面中被重写
    pointcut virtual observers () = 0;
    pointcut virtual subjects () = 0;
    // subjectChange()匹配所有非const方法，但限定了subjects类
    pointcut virtual subjectChange () =
        execution(" % ::%() " && !" % ::%() const")
        && within(subjects ());
    // 为每个subject/observer类增加基类，并插入通知代码
    advice observers () : baseclass(IObserver );
    advice subjects () : baseclass(ISubject );
    advice subjectChange () : after() {
        ISubject * subject = tjp->that ();
        updateObservers (subject );
    }
    // 具体操作
    void updateObservers (ISubject * sub ) {  }
    void addObserver (ISubject * sub , IObserver * ob ) {  }
    void remObserver (ISubject * sub , IObserver * ob ) {  }
};

其中“...” 部分是需要完成的C++实现代码，可以简单实现一个：

#ifndef __OBSERVER_PATTERN_AH__
#define __OBSERVER_PATTERN_AH__

#include <map>
#include <set>
using namespace std;

aspect ObserverPattern {
    // 管理subjects和observers的数据结构
    struct ISubject;
    struct IObserver;
    map < ISubject*, set<IObserver*> > listeners;
public:
    // 角色接口
    struct ISubject {};
    struct IObserver {
        virtual void update(ISubject *) = 0;
    };
    // 在派生方面中被重写
    pointcut virtual observers () = 0;
    pointcut virtual subjects () = 0;
    // subjectChange()匹配所有非const方法
    pointcut virtual subjectChange () =
        execution(" % ::%() " && !" % ::%() const")
        && within(subjects ());
    // 为每个subject/observer类增加基类，并插入通知代码
    advice observers () : baseclass(IObserver );
    advice subjects () : baseclass(ISubject );
    advice subjectChange () : after() {
        ISubject * subject = tjp->that ();
        updateObservers (subject );
    }
    // 具体操作
    void updateObservers (ISubject * sub ) {
        const set<IObserver*>& observers = listeners[sub];
        set<IObserver*>::const_iterator iter = observers.begin();
        for (; iter != observers.end(); iter ++)
        {
            (*iter)->update(sub);
        }
    }
    void addObserver (ISubject * sub , IObserver * ob ) { listeners[sub].insert(ob); }
    void removeObserver (ISubject * sub , IObserver * ob ) { listeners[sub].erase(ob); }
};

#endif // __OBSERVER_PATTERN_AH__

保存为ObserverPattern.ah供下面使用。

下面编写一个应用实例：

1、car.h

#ifndef __CAR_H__
#define __CAR_H__

#include <string>
using namespace std;

class Car
{
    string name;
    int x;
    int y;
    enum Direction{South, East, North, West};
    Direction direction;

    Car (const Car&);
    Car& operator = (const Car&);
public:
    Car (const string& name);
    void turnLeft ();
    void turnRight ();
    void forward (size_t step);

    const string& getName() const;
    int getX () const;
    int getY () const;
    Direction getDirection () const;
};



#endif // __CAR_H__

2、car.cc

#include "car.h"
#include <cassert>

Car::Car (const string& name_)
: name(name_), x(0), y(0), direction(South)
{
}

void Car::turnLeft ()
{
    if (direction == West)
        direction = South;
    else
        direction = (Direction)(int(direction) + 1);
}

void Car::turnRight ()
{
    if (direction == South)
        direction = West;
    else
        direction = (Direction)(int(direction) - 1);
}

void Car::forward (size_t step)
{
    switch (direction)
    {
    case South:
        y += step; break;
    case East:
        x += step; break;
    case North:
        y -= step; break;
    case West:
        x -= step; break;
    default:
        assert (!"Invalid direction");
    }
}

const string& Car::getName() const
{
    return name;
}

int Car::getX() const
{
    return x;
}

int Car::getY() const
{
    return y;
}

Car::Direction Car::getDirection() const
{
    return direction;
}

3、dummy.h(这个用来测试Aspect C++的匹配模式会不会混乱)

#ifndef __DUMMY_H__
#define __DUMMY_H__

class Dummy
{
public:
    void test_non_const (){}
    void test_const () const {}
};

#endif // __DUMMY_H__

4、main.cc

#include "car.h"
#include "dummy.h"

int main()
{
    Car car("No.1");
    car.turnLeft();
    car.forward(3);
    car.turnLeft();
    car.forward(9);
    car.turnRight();
    car.forward(12);

    Car car1("No.2");
    car1.forward(7);
    car1.turnLeft();
    car1.forward(3);

    car.forward(5);

    Dummy dummy;
    dummy.test_non_const();
    dummy.test_const();
    
    return 0;
}

这个程序编译运行，没有任何输出。有时候为了监视对象的状态，可以在执行一个操作后加上一些打印状态的代码，当然这样比较繁琐；也可以在各个操作函数中加入这些代码，但修改已经写好的代码总是不太舒服。

下面先实现一个Car状态打印类：

5、car_logging.h

#ifndef __CAR_LOGGING__
#define __CAR_LOGGING__

#include "car.h"
#include <iostream>
using namespace std;

class CarLogging
{
public:
    void printCarInfo (const Car& car)
    {
        static const char* direction_str[] = {"South", "East", "North", "West"};
        cout << "Car name: " << car.getName()
            << ", direction: " << direction_str[int(car.getDirection())] 
            << ", x: " << car.getX() 
            << ", y: " << car.getY() 
            << endl;
    }
};

extern CarLogging g_carLogging;

#endif // __CAR_LOGGING__

6、car_logging.cc

#include "car_logging.h"

CarLogging g_carLogging;

7、CarLoggingObserver.ah

#ifndef __CAR_LOGGING_OBSERVER_AH__
#define __CAR_LOGGING_OBSERVER_AH__

#include "ObserverPattern.ah"
#include "car.h"
#include "car_logging.h"

aspect CarLoggingObserver : public ObserverPattern {
    // 定义方面(ointcuts)
    pointcut subjects() = "Car";
    pointcut observers() = "CarLogging";
public:
    advice observers() :
    void update( ObserverPattern::ISubject* sub ) {
        printCarInfo (*(Car*)sub);
    }

    advice construction (classes(subjects())) : after()
    {
        addObserver(tjp->that(), &g_carLogging);
    }

    advice destruction (classes(subjects())) : before()
    {
        removeObserver(tjp->that(), &g_carLogging);
    }
};

#endif // __CAR_LOGGING_OBSERVER_AH__

这个方面重写了subjects以及observers切面，并定义了observers在update被调用时执行的操作，另外还在Car的构造函数和析构函数中添加了注册和注销代码。

运行ac++生成代码，编译并运行，结果如下：

这里演示的例子依旧选择了不影响原始程序的做法，网上很多资料都把这个模式和实现代码结合起来，由于Aspect C++编译速度还是很慢，所以选择“外挂”的方式，这样不需要这些方面时，直接编译C++代码即可。

关于Aspect C++以及AOP，还有许多话题，不过不打算再继续了，AOP是个广泛的议题，局限在某一实现上只会使我们眼界变窄。

AOP被称为设计模式最佳实践者，它当之无愧。网上还有很多AOP实践设计模式的资料。