使用C++20实现轻量级AOP库

Posted CPP编程客

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了使用C++20实现轻量级AOP库相关的知识,希望对你有一定的参考价值。

1. OOP与AOP的两种编程思维

编程是为了解决某个具体问题,当你看整个问题的时候,容易含糊不清,寻不到方向。将问题拆解一下,弄清它是由什么组成的。随着问题拆解的越来越小,你会发现问题也变得越来越简单。那么,将问题拆解到可以解决之时的各个组成要素,就是程序的模块,当把每个模块都完成的时候,再进行组合,便可以解决整个问题。

这种思维源于物理学中的还原论,面向对象的思维就是通过对象来表示每个模块,以继承和多态来描述模块之间的关系。

模块的基本原则是要满足正交性,即相互独立,所以想对某一模块添加额外处理,不应该强行添加到模块之中,这会破坏模块的独立性。

例如,一个简单的游戏模块,

使用C++20实现轻量级AOP库

这里的两个模块Player和Enemy属于同一层级,若要在每次玩家和怪物攻击时,检测数据是否合法,并记录伤害值、血量等等信息。也就是说,添加一些公共的行为,到这些现存的模块当中。

由于这些公共的行为分散在不同的模块当中,如记录的日志模块,检测的访问控制模块。所以再要通过继承提取这些分散的公共行为,会破坏模块之间的正交性。把原本不交叉的功能强行拼凑,这时这个模块也就失去了独立性。换句话说,这对于问题的分解出现了问题,再进行组合时,可能无法还原整个问题。

那么要如何在保证模块独立性的情况下,提炼这些共同的工作呢?

实际上,分解一个问题可以从两方面着手,深度和广度。

深度层面属于向分解,处于不同深度层级下的模块,抽象层次也不同。抽象层次每高一级,公共逻辑就更具有普适性,适应范围更广。也就是说,同一深度层次之间存在公共逻辑的交叉,可以直接组合使用,如Enemy可以表示Monster和Boss。

广度层面属于横向分解,可以组合互不交叉的多个独立模块。这些独立模块可能存在于不同深度层面,也可能不在同一深度之下,因为没有公共行为,所以无法交叉,也就无法直接组合。此时,换个角度,从广度分解,便能达到组合的效果。

横向组合后的这个模块,就称为切面(Aspect),这种将广度层面的公共逻辑组合在一起的方式称为横切关注点(Cross-cutting concerns),这种编程方式就称为面向切面编程(AOP,Aspect-Oriented Programming)。

利用每个切面来将多个公共行为添加到现存模块当中,这些添加的公共行为称为Advice。

总结一下,以上介绍了解决问题的两种编程思维,面向对象和面向切面。面向对象以对象表示问题分解的模块,继承和多态表示同一深度层次下模块的关系。面向切面以切面组合分散的模块,横向关联不相交的各个模块,以公共地使用它们。

2. AOP的相关概念

这里介绍一下通用的标准术语,就是统一名称,供交流之用,上节其实已经介绍。

  • Cross-cutting concerns横切关注点,就是将非核心的公共逻辑横向组合到一起的方式。

  • Advice:就是想要向现存模块中额外添加的代码,如日志,访问控制等等。

  • PointCut:切点,指定何时应用横切关注点,在核心逻辑之前或之后,或其它时刻。

  • Aspect切面,Advice和PointCut共同组合,形成了切面。

3. mc::aspect实现的第一个版本

mcveil是一个使用Modern C++特性编写的一些工具集。因为这些新特性参考资料少,用法也少,颇显神秘,所以名字就表示通过实现各种有用的库,来展示如何运用新特性来开发些有用的工具,甚至把它用到日常开发中来,揭开这些神秘的面纱。

本篇文章的最终代码都可以在这里找到:https://github.com/gxkey/mcveil

mcveil将切面命名为aspect,这个类应该不可拷贝,且不可继承,所以基本原型如下:

1template<typename Func>
2struct aspect final : noncopyable
3{
4    aspect(Func&& func) : func_(std::forward<Func>(func))
5    {}
6
7private:
8    Func func_;
9};

noncopyable只是把禁止拷贝这部分逻辑提炼抽象,boost中有一个相同的类,modern c++实现起来也很简单,所以就直接加到了mcveil,实现如下:

1namespace mc
2{
3
4class noncopyable
5{

6protected:
7    noncopyable() = default;
8    ~noncopyable() = default;
9
10    noncopyable(const noncopyable&) = delete;
11    const noncopyable& operator=(const noncopyable&) = delete;
12};
13
14// namespace mc

aspect类只有一个模板参数Func,就是切面中的现存模块。将Func作为唯一的成员变量,在构造函数中进行初始化,以保存现存模块,供后面调用。

现在要考虑如何往现存模块加入额外逻辑?也就是说,如何在Func前后加入Advice?

首先,Advice应该可以存在无限个,所以应该使用C++11的可变参数模板。

其次,Func也可能会有0个或多个参数,所以参数也应该是可变的。

根据这两点,基本确定应该传递的参数,于是写出基本结构:

1template<typename... Advice, typename... Args>
2void invoke(Args&&... args) const
3
{
4}

现在,要做就是在Func前后依次执行Advice。本来这个逻辑实现起来是非常复杂的,至少要定义多个invoke版本,以递归的方式展开参数包。

而利用C++17的Fold Expressions,只需四行代码,就已经完成了所有工作。实现如下:

1template<typename... Advice, typename... Args>
2void invoke(Args&&... args) const
3
{
4    int dummy;
5    (Advice().before(std::forward<Args>(args)...), ...);
6    func_(std::forward<Args>(args)...);
7    (dummy = ... = (Advice().after(std::forward<Args>(args)...), 0));
8}

这几行代码相当精妙!

在C++17以前,要实现这个逻辑相较复杂,至少得多出十几行代码。

精妙之处不仅在于使用了Fold Expressions,还在于逗号表达式的使用,此举是为了逆序执行Advice的after()语句。

可以说,这里每一个看似无关的代码,其实都必不可少地发挥着作用,完成着80%的功能逻辑。

剩下的20%功能属于边角料工作,但也得费一番心思。

Advice中默认要提供before和after成员函数,就是两个切点。然而,你无法保证,因此需要一些编译期判断,同时,我们希望在两个切点都未提供的情况下,不做任何处理;若只提供了一个,那么就只调用一个。

这样处理是非常合理的,因为一个aspect中可以存在多个Advice,每个处理不同的工作,有些可能只想在核心关注点之前或之后进行相关处理,这些都应该满足。

这在C++20之前,实现起来也是相当的麻烦,需要借助宏与模板技巧,实现编译期分派,十分不灵活。

C++20之后,可以借助Concepts和C++17的if constexpr在编译期实现上述功能。

首先,定义两个Concepts,用来判断Advice中是否存在before和after成员,代码如下:

1template<typename Advice, typename... Args>
2concept HasMemberBefore = requires (Advice advice) { 
3    advice.before(std::declval<Args>()...); 
4};
5
6template<typename Advice, typename... Args>
7concept HasMemberAfter = requires (Advice advice) { 
8    advice.after(std::declval<Args>()...); 
9};

这里用的是simple requirements来检查表达式是否有效。

接着,使用if constexpr和定义的两个Concepts对Advice进行编译期检测,决定是否调用before()或after()。代码如下:

1template<typename... Advice, typename... Args>
2void invoke(Args&&... args) const
3
{
4    auto invoke_before = [&](auto&& ad) {
5        if constexpr (HasMemberBefore<decltype(ad), Args...>) 
6            ad.before(std::forward<Args>(args)...);
7    };
8
9    auto invoke_after = [&](auto&& ad) {
10        if constexpr (HasMemberAfter<decltype(ad), Args...>) 
11            ad.after(std::forward<Args>(args)...);
12    };
13
14    int dummy;
15    (invoke_before(Advice()), ...);
16    func_(std::forward<Args>(args)...);
17    (dummy = ... = (invoke_after(Advice()), 0));
18}

可以看到,这里还是利用Fold Expressions展开每个Advice,再利用Lambda函数处理每个Advice,处理逻辑使用if constexpr和定义的Concepts。

至此,基本所有逻辑已经实现完成,算起来核心逻辑不到20行代码,这都要依赖C++最新的特性,才能如此简单地实现通用的AOP功能。

最后,aspect使用起来并不太方便,所以我们使用Factory Method将它的创建封装其中:

1template<typename... Advice, typename... Args, typename Func>
2void make_aspect(Func&& func, Args&&... args)
3
{
4    mc::aspect<Func> ap(std::forward<Func>(func));
5    ap.invoke<Advice...>(std::forward<Args>(args)...);
6}

这里注意,通常的Factory Method用于创建对象并返回,而这里无需如此,因为我们就是想让aspect的使用像一个函数一样,简单易用。

现在,可以这样使用:

1#include "mcaspect.hpp"
2#include <iostream>
3
4struct Log {
5    void before(const char* str) {
6        std::cout << "Log before " << str << std::endl;
7    }
8
9    void after(const char* str) {
10        std::cout << "Log after " << str << std::endl;
11    }
12};
13
14struct Clock {
15    void before(const char* str) {
16        std::cout << "Clock before " << str << std::endl;       
17    }
18
19    void after(const char* str) {
20        std::cout << "Clock after " << str << std::endl;
21    }
22};
23
24
25struct Lambda {
26    void before() {
27        std::cout << "Lambda before " << std::endl;     
28    }
29
30    void after() {
31        std::cout << "Lambda after " << std::endl;
32    }
33
34};
35
36
37
38void foo(const char* str)
39
{
40    std::cout << str << std::endl;
41}
42
43int main()
44
{
45    mc::make_aspect<Log, Clock>(&foo, "foo function");
46    mc::make_aspect<Lambda>([](){ std::cout << "lambda function "; } );
47
48    return 0;
49}

将会如下输出:

4. 优化后的第二个版本

上述代码看似完美,实则还不完善。

上面的代码虽然可以在msvc编译,却无法在gcc编译。这是由于ap.invoke<>()的用法:

1template<typename... Advice, typename... Args, typename Func>
2void make_aspect(Func&& func, Args&&... args)
3
{
4    mc::aspect<Func> ap(std::forward<Func>(func));
5    ap.invoke<Advice...>(std::forward<Args>(args)...);
6}

注意第5行,这里对invoke展开传入了Advice,这条语句若是单独拿到main,或一个常规的自由函数中,gcc编译起来也不会出现任何问题。

而一旦把它放到模板函数中,或是类中,gcc就无法完成这个工作。

什么意思呢?

这翻译一下,其实是说,他想要个对象,而我们却给了个类型(新东西支持的不行,或者说,语法更严格,别忘了此处是成员函数

为达目的,那么便顺其意,修改invoke的接口。先来看当前的invoke的接口:

1template<typename... Advice, typename... Args>
2void invoke(Args&&... args) const
3
{
4}

这里要将Advice也作为具体的参数,那么两个可变参数,肯定无法识别。因此,必然要将一个的类型抽离,于是将Args转而作为aspect的模板参数(这招也不是第一次用了,在Factory Method那篇文章中也使用此法处理register_type引发的问题)。

于是,现在aspect类完整代码变成了这样:

1template<typename Func, typename... Args>
2struct aspect final : noncopyable
3{
4    aspect(Func&& func) : func_(std::forward<Func>(func))
5    {}
6
7    template<typename... Advice>
8    void invoke(Args&&... args, Advice&&... advice) const
9    
{
10        auto invoke_before = [&](auto&& ad) {
11            if constexpr (HasMemberBefore<decltype(ad), Args...>) 
12                ad.before(std::forward<Args>(args)...);
13        };
14
15        auto invoke_after = [&](auto&& ad) {
16            if constexpr (HasMemberAfter<decltype(ad), Args...>) 
17                ad.after(std::forward<Args>(args)...);
18        };
19
20        int dummy;
21        (invoke_before(advice), ...);
22        func_(std::forward<Args>(args)...);
23        (dummy = ... = (invoke_after(advice), 0));
24    }
25
26private:
27    Func func_;
28};

那么,也要改变make_aspect方法,更改如下:

1template<typename... Advice, typename... Args, typename Func>
2void make_aspect(Func&& func, Args&&... args)
3
{
4    mc::aspect<Func, Args...> ap(std::forward<Func>(func));
5    ap.invoke(std::forward<Args>(args)..., Advice()...);
6}

现在就将类型变为了具体的对象,传入到invoke成员函数当中,不会存在任何岐义。

以上就是当前的实现版本,我没有用最终版,就表示还可以添加功能,使其更加灵活。比如异常的处理,更多的切点等等考虑。

当然,我不太喜欢让一个东西变得太过复杂庞大,轻巧易用,简洁易懂,舍九而只取一更为重要。太多东西杂糅在一起,反而会让问题越来越复杂,影响整体的效率。

下次会讲一篇主题为「算法与泛型编程」的内容,会用到这次的工具来检测算法效率,会再有一些优化,到时见啦。

最后,大晚上码字时间有点久,难免可能存在纰漏,这篇如果还有什么问题,欢迎指正。


--相关文章--






以上是关于使用C++20实现轻量级AOP库的主要内容,如果未能解决你的问题,请参考以下文章

十条jQuery代码片段助力Web开发效率提升

十条jQuery代码片段助力Web开发效率提升

使用dynamic和MEF实现轻量级的AOP组件

Spring的几道选择题

JAVA之AOP

使用dynamic和MEF实现轻量级的AOP组件