【AOP框架】C++实现

本系列文档从属于：C++11应用实践系列

部分Demo和结论引用自<深入应用C++11代码优化与工程>这本书

使用C++实现一个AOP轻量级框架。

什么是AOP和OOP的区别

AOP（面向切面编程）则是针对业务处理过程中的切面进行提取，它所面对的是处理过程中的某个步骤或阶段，以获得逻辑过程中各部分之间低耦合性的隔离效果。
OOP（面向对象编程）针对业务处理过程的实体及其属性和行为进行抽象封装，以获得更加清晰高效的逻辑单元划分。

这两种设计思想在目标上有着本质的差异。

实现AOP的方式

实现AOP技术分为：静态织入和动态织入。

静态织入一般是使用专门的语法和编译工具，例如：AspectC++。
动态织入在运行期对函数拦截，将切面动态织入。

代理模式实现动态织入

经典的GoF设计模式之一：代理设计模式

class Base
{
public:
    virtual void foo() = 0;
};

class Client : public Base
{
public:
    virtual void foo() override
    {
        cout << "client foo" << endl;
    }
};

class ClientProxy : public Base
{
public:
    ClientProxy(Base* ptr) : m_ptr(ptr) {}
    virtual void foo() override
    {
        cout << "proxy" << endl;
        m_ptr->foo();
    }
private:
    Base* m_ptr;
};

//使用如下：
    Base* ptr = new Client;
    Base* proxy = new ClientProxy(ptr);
    proxy->foo();

代理模式实现动态织入局限性

不够灵活，不能自由组合多个切面。虽然可以使用装饰器，但是依旧很笨重。
耦合性很强，切面必须从基类继承，并且实现接口。

轻量级AOP框架实现

切面作为模板支持1-N个切面。
通过可变参数模板支持切面组合。
核心是要拦截目标函数,就可以在函数前后搞事情.为了降低耦合性不使用继承而使用模板方法约束每个切片所必须的函数.

Tips：模板的约束力很多时候是可以代替继承树结构的,例如：参数类型约束、函数接口约束等等。

实现函数接口检查

检查某一类型是否包含某一接口，这样就可以检查不符合接口的类型直接报错。

#define HAS_MEMBER(member) \
template<typename T, typename ...Args> \
struct has_member_##member \
{   \
private: \
template<typename U> \
static auto check(int) -> decltype(std::declval<U>().member(std::declval<Args>()...), std::true_type()); \
template<typename U> \
static std::false_type check(...); \
public: \
enum {value = std::is_same<decltype(check<T>(0)), std::true_type>::value}; \
}; \

测试代码如下：

HAS_MEMBER(foo);

template<typename...Args>
struct Test
{
    template<typename U,
        class = typename std::enable_if<has_member_foo<U, Args...>::value>::type>
        void func(Args&&...args, U&& u)
    {
        u.foo(std::forward<Args>(args)...);

        //do something
        cout << "func" << endl;
    }

    template<typename Head, typename...Tail>
        void func(Args&&...args, Head&& head, Tail&&...tail)
    {
        head.foo(std::forward<Args>(args)...);
        func(std::forward<Args>(args)..., std::forward<Tail>(tail)...);
    }
};

//切面类
struct Data
{
public:
    void foo(int i) {
        cout << "foo:" << i << endl;
    }
};

//调用优化 方便使用
template<typename...ST, typename ...Args>
void func(Args&&...args)
{
    Test<Args...> test;
    test.func(std::forward<Args>(args)..., ST()...);
}
//具体使用如下：
    func<Data, Data, Data>(200);

这里写图片描述

AOP框架C++实现

全部实现代码如下：

HAS_MEMBER(before)
HAS_MEMBER(after)

template<typename Func, typename...Args>
struct Aspect
{
    //forward or move 是一样的
    Aspect(Func&& f) : m_func(std::forward<Func>(f)) {}

    template<typename T>
    typename std::enable_if<has_member_before<T, Args...>::value
    && has_member_after<T, Args...>::value>::type
        invoke(Args&&...args, T&& aspect)
    {
        aspect.before(std::forward<Args>(args)...); //切面逻辑
        m_func(std::forward<Args>(args)...);        //核心逻辑
        aspect.after(std::forward<Args>(args)...);  //切面逻辑
    }

    template<typename T>
    typename std::enable_if<has_member_before<T, Args...>::value
        && !has_member_after<T, Args...>::value>::type
        invoke(Args&&...args, T&& aspect)
    {
        aspect.before(std::forward<Args>(args)...); //切面逻辑
        m_func(std::forward<Args>(args)...);        //核心逻辑
    }

    template<typename T>
    typename std::enable_if<!has_member_before<T, Args...>::value
        && has_member_after<T, Args...>::value>::type
        invoke(Args&&...args, T&& aspect)
    {
        m_func(std::forward<Args>(args)...);        //核心逻辑
        aspect.after(std::forward<Args>(args)...);  //切面逻辑
    }

    //适应切片组合
    template<typename Head, typename...Tail>
    void invoke(Args&&...args, Head&& headAspect, Tail&&...tailAspect)
    {
        headAspect.before(std::forward<Args>(args)...); //切面逻辑
        invoke(std::forward<Args>(args)..., std::forward<Tail>(tailAspect)...);
        headAspect.after(std::forward<Args>(args)...);  //切面逻辑
    }

private:
    Func        m_func; //最终核心逻辑
};

//辅助调用函数
template<typename...Ap, typename...Args, typename Func>
void invoke(Func&& f, Args&&...args)
{
    Aspect<Func, Args...> asp(std::forward<Func>(f));
    asp.invoke(std::forward<Args>(args)..., Ap()...);
}

struct AA
{
    void before(int i)
    {
        cout << "before AA:" << i << endl;
    }
    void after(int i)
    {
        cout << "after AA:" << i << endl;
    }
};

struct CC
{
    void before(int i)
    {
        cout << "before CC:" << i << endl;
    }
    void after(int i)
    {
        cout << "after CC:" << i << endl;
    }
};

struct BB
{
    void before()
    {
        cout << "before BB" << endl;
    }
    void after()
    {
        cout << "after BB" << endl;
    }
};

struct DD
{
    void before()
    {
        cout << "before DD" << endl;
    }
    void after()
    {
        cout << "after DD" << endl;
    }
};

void gt()
{
    cout << "gt functional" << endl;
}

void ht(int i)
{
    cout << "ht functional:" << i << endl;
}

void test()
{
    //织入普通函数
    std::function<void(int)> f = std::bind(&ht, std::placeholders::_1);
    invoke<AA, CC>(f, 1);

    cout << "------------------------" << endl;
    //织入普通函数
    invoke<BB, DD>(&gt);
    cout << "------------------------" << endl;
    invoke<CC, AA>(&ht, 1);
}

测试打印如下：
这里写图片描述