（原创） C++ 轻量级AOP框架

c++11 boost技术交流群：296561497，欢迎大家来交流技术。

c++中开源的AOP框架AspectC++需要单独编译才能将切面的代码织入到核心逻辑代码中，感觉使用起来不方便，不能满足快速开发要求。我希望只要实现方法拦截即可，能织入before()和after()操作就行，不追求动态织入。思路是这样的，通过一个包装类，里面定义before()和after()方法，和->运算符重载方法，在重载操作函数中实现before()和after()操作。具体代码如下：

#include <boost/shared_ptr.hpp>

template <typename WrappedType, typename DerivedAspect>
class BaseAspect
{
protected:
  WrappedType* m_wrappedPtr; //被织入的对象

  //获取派生的切面对象
  DerivedAspect* GetDerived() 
  {
    return static_cast<DerivedAspect*>(this);
  }

  //被织入对象的删除器，用来自动触发切面中的After方法
  struct AfterWrapper
  {
    DerivedAspect* m_derived;
    AfterWrapper(DerivedAspect* derived): m_derived(derived) {};
    void operator()(WrappedType* p)
    {
      m_derived->After(p);
    }
  };
public:
  explicit BaseAspect(WrappedType* p) :  m_wrappedPtr(p) {};


  void Before(WrappedType* p) {
     // Default does nothing
  };

  void After(WrappedType* p) {
     // Default does nothing
  }

  //重载指针运算符用来织入切面（Before和After）
  boost::shared_ptr<WrappedType> operator->() 
  {
    GetDerived()->Before(m_wrappedPtr);
    return boost::shared_ptr<WrappedType>(m_wrappedPtr, AfterWrapper(GetDerived()));
  }
};

//织入切面的工厂函数, 返回包含被织入对象的切面
template <template <typename> class Aspect, typename WrappedType> 
Aspect<WrappedType> MakeAspect(WrappedType* p) 
{
  return Aspect<WrappedType>(p);
}

BaseAspect为切面的基类，提供了Before()和After()方法，供派生的切面实现；

下面看看具体的切面实现：一个实现对函数运行时间的统计，一个实现日志功能。

#include <iostream>
#include <boost/chrono/chrono.hpp>
#include <boost/chrono/system_clocks.hpp>

template<typename WrappedType>
class TimeElapsedAspect : public BaseAspect< WrappedType, TimeElapsedAspect<WrappedType> >
{
  typedef  BaseAspect<WrappedType, TimeElapsedAspect<WrappedType> > BaseAspect;
  typedef boost::chrono::time_point<boost::chrono::system_clock, boost::chrono::duration<double> > time_point;

  time_point m_tmBegin;
public:
  TimeElapsedAspect(WrappedType* p): BaseAspect(p) {}


  void Before(WrappedType* p) 
  {
    m_tmBegin = boost::chrono::system_clock::now();
  }

  void After(WrappedType* p)
  {
    time_point end = boost::chrono::system_clock::now();

    std::cout << "Time: " << (end-m_tmBegin).count() << std::endl;
  }
};

TimeElapsedAspect切面实现对函数运行时间统计。

template <typename WrappedType>
class LoggingAspect : public BaseAspect<WrappedType, LoggingAspect<WrappedType> >
{
  typedef  BaseAspect<WrappedType, LoggingAspect<WrappedType> > BaseAspect;
public:
  LoggingAspect(WrappedType* p): BaseAspect(p) {}

  void Before(WrappedType* p) 
  {
    std::cout << "entering" << std::endl;
  }

  void After(WrappedType* p) 
  {
    std::cout << "exiting" << std::endl;
  }

};

LoggingAspect实现日志记录

现在来看看测试代码

class IX
{
public:
    IX(){}
    virtual ~IX(){}

    virtual void g()=0;
private:

};

class X : public IX
{
public:
  void g() 
  {
    std::cout << "it is a test" << std::endl;
  }

};

void TestAop()
{
    boost::shared_ptr<IX> p(new X());
    MakeAspect<TimeElapsedAspect>(p.get())->g();
    MakeAspect<LoggingAspect>(p.get())->g();
}

 测试结果：

总结：

这个简单的AOP实现，可以实现对类的方法进行拦截，具体切面自由定制，不过还有个地方不太完善，还不支持切面的组合，这个可以用TypeList去实现。