面向切面编程--AOP

转自:https://www.cnblogs.com/qicosmos/archive/2013/04/07/3003480.html

（原创） 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();
}