编译期反射实践

如果想要生成判断是否有before或者其他方法的代码，则只需要调用这个宏。

HAS_MEMBER(before) //生成判断是否有before的代码
HAS_MEMBER(after) //生成判断是否有after的代码

将类方法转为function保存

直接上代码，再逐一讲解：

以下代码是将该类的before和after方法包装成一个function，并返回一个pair。完整代码：reflect_util.hpp

template 
typename std::enable_if< //1has_member_before::value && has_member_after::value,std::pair, std::function>>::type
GetMemberFunc() {auto fun = std::make_shared>(); //2return std::make_pair( //3[self = fun](Args &&...args) {self->before(std::forward(args)...);},[self = fun](Args &&...args) {self->after(std::forward(args)...);});
}

在代码段1中，通过 enable_if 确保在该类型有before和after方法，同时也可以保证写其他版本的时候不会出现重复定义的错误。enable_if 第一个参数是需要满足的条件，第二个参数是enable_if内部的type类型，默认为void。

代码段2中，创建一个T类型的实例，并用shread_ptr管理，原因在于before方法和after方法需要共用内存，而这两个方法都要被提取为单独的function，要保证内存安全，故需要使用智能指针。其中 std::decay_t 效果等同于 std::decay::type，作用是消除T类型的const修饰和引用修饰。因为make_shared<>中的模板参数不能为引用类型。

代码段3中，利用lamda表达式将fun拷贝一份到其中命名为self，最后返回pair即可。

当前写的功能是不完整的，需要多几个模板的重载来实现只有before方法、以及只有after方法的情况。写法和上述代码一致，只不过 enable_if 中的条件稍作改变即可。前面也提到过enable_if千万不能丢，否则会报重复定义的错误，当然如果你是C++17的版本，可以直接使用 if constexpr 来实现更为简洁的代码而无需单独写三个函数。

如下：

#define ST_ASSERT                                                              \static_assert(                                                               \has_member_before::value ||                                  \has_member_after::value,                                 \"class need T::before(args...) or T::after(args...) member function!");template 
std::pair, std::function>
GetMemberFunc() {ST_ASSERT // 确保至少before after有其一auto fun = std::make_shared>();if constexpr (has_member_before::value &&has_member_after::value) { // 有before和afterreturn std::make_pair([self = fun](Args &&...args) {self->before(std::forward(args)...);},[self = fun](Args &&...args) {self->after(std::forward(args)...);});} else if constexpr (has_member_before::value &&!has_member_after::value) { // 有beforereturn std::make_pair([self = fun](Args &&...args) {self->before(std::forward(args)...);},nullptr);} else { // 只有afterreturn std::make_pair(nullptr, [self = fun](Args &&...args) {self->after(std::forward(args)...);});}
}

下面我简单解释下代码：

1. ST_ASSERT宏的作用是，通过static_assert在编译期抛出提示，T类型必须有before或after两个方法之一。
2. 通过该类型拥有的情况不同，给出不同的返回值。

很明显去除了enable_if后，我们代码清爽了许多。

AOP的实现

关于AOP，大家可以去搜一搜，这里就不过多赘述。我的简单理解就是一个事件回调，可以嵌入到业务的执行前后，把这个事件的概念换成一个切面，把业务代码看作一个横向坐标轴上的面，那么AOP就是在这个面的前后添加其他切面来实现常用的业务复用。比如用户的身份验证，可以在业务之前添加身份验证的切面，比如需要测试该业务的性能，那么可以在业务切面的前后添加开始计时和终止计时的逻辑。

Invoke调用实现AOP

根据上述对AOP的描述，我们要切入的代码主要是前和后两个逻辑，故每个要切入的类可以规定他必须定义Before或者After方法。然后通过可变参模板递归实现任意个参数的切面调用。

可以把整个切面调用过程看作一个洋葱圈层，比如添加s1类型的before和after作为切片，s2类型的before和after作为切片，s3类型的before作为切片。把业务代码逻辑作为foo函数。

则他们的调用过程如下：

s1->before => s2->before => s3->before => foo业务逻辑 => s1->after => s2->after。

如果稍微学过点数据结果，这个调用就能想到前中后序遍历上去了。

代码实现如下（C++11需要使用eable_if来实现，代码量很多，所以这里就直接用C++17的 if constexpr 来实现了）：

 /*以下是截取的一个类的两个方法*/// 递归的尽头template  void Invoke(Args &&...args, T &&aspect) {ST_ASSERTif constexpr (has_member_Before::value &&has_member_After::value) {aspect.Before(std::forward(args)...); // 核心逻辑之前的切面逻辑m_func(std::forward(args)...);        // 核心逻辑aspect.After(std::forward(args)...); // 核心逻辑之后的切面逻辑} else if constexpr (has_member_Before::value &&!has_member_After::value) {aspect.Before(std::forward(args)...); // 核心逻辑之前的切面逻辑m_func(std::forward(args)...);        // 核心逻辑} else {m_func(std::forward(args)...);       // 核心逻辑aspect.After(std::forward(args)...); // 核心逻辑之后的切面逻辑}}// 变参模板递归template void Invoke(Args &&...args, T &&headAspect, Tail &&...tailAspect) {ST_ASSERTif constexpr (has_member_Before::value &&has_member_After::value) {headAspect.Before(std::forward(args)...);Invoke(std::forward(args)..., std::forward(tailAspect)...);headAspect.After(std::forward(args)...);} else if constexpr (has_member_Before::value &&!has_member_After::value) {headAspect.Before(std::forward(args)...);Invoke(std::forward(args)..., std::forward(tailAspect)...);} else {Invoke(std::forward(args)..., std::forward(tailAspect)...);headAspect.After(std::forward(args)...); // 核心逻辑之后的切面逻辑}}

上述完整代码：aspect.hpp

上述代码是根据C++变参模板实现的通用性操作，可以同时添加多个切片 ，他们都是Aspect类的两个方法，具体实现逻辑就是：通过之前得到的编译期常量( has_member_Before::value )判断 T 是否具有Before或者After方法，分三种情况：

1. 同时又Before和After：利用中序进行递归。

2. 只有Before：利用前序进行递归。

3. 只有After：利用后序进行递归。

为了简化调用过程，继续封装如下：

最后记得定义一个终止模板递归的最终形态。

template  using identity_t = T;// AOP的辅助函数，简化调用
template 
void Invoke(Func &&f, Args &&...args) {Aspect asp(std::forward(f));asp.Invoke(std::forward(args)..., identity_t()...);
}

最终如果像最开始讲的要拓展s1、s2、s3的方法上去，那么简单的使用如下代码即可：

Invoke(&foo,args); //s1,s2,s3为拓展逻辑，foo为业务逻辑

统一转function存储并实现AOP调用顺序

统一转function存储

将任意类的before和after方法集体装箱为function的关键代码逻辑如下，完整代码请看：

  void Get() {} //空的func，用于结束模板的递归实例化template  void Get(T &&head, Tail &&...tails) {ST_ASSERTauto &&p = details::GetMemberFunc();m_output.push_back(p);Get(tails...);}

由于所有的获取before和after的逻辑在前面获取类的方法已经讲到，所以单个类型直接调用 GetMemberFunc 函数即可得出结果，并放入vector中，最后通过模板实例化的递归将所有的类型都装箱。

具体的使用方式也很简单，如下代码：

#include"reflect_util.hpp"
using func_t = reflect::MemberFunc::func_t;
using func_pair_t = reflect::MemberFunc::func_pair_t;struct LoginAspect {void before(int i) { cout << "Login start " << i << endl; }void after(int i) { cout << "after start " << i << endl; }
};
int main(){vector out;// 获取before和after方法，并通过function进行包装reflect::MemberFunc(out).Get(TimeElapsedAspect{}, LoggingAspect{},LoginAspect{});//将三个类型的before和after方法分离成function后以pair的形式存储在out中for(auto&& p : out){if(p.first){//如果before存在则调用p.first(0);}if(p.second){//如果after存在则调用p.second(1);}}
}

AOP的调用顺序实现

// 根据AOP的顺序存入out数组
void AspectOrder(vector &out, vector &v,const func_t &func, int index) {if (v.size() <= index) {out.push_back(func);return;}if (v[index].first) {out.push_back(v[index].first);}AspectOrder(out, v, func, index + 1);if (v[index].second) {out.push_back(v[index].second);}
}

完整测试代码：test_aspect.cc

参考链接：
C++模板进阶指南：SFINAE
SFINAE
C++11实现一个轻量级的AOP框架