TinyFrame再续篇：整合Spring AOP实现日志拦截

上一篇中主要讲解了如何使用Spring IOC实现依赖注入的。但是操作的时候，有个很明显的问题没有解决，就是日志记录问题。如果手动添加，上百个上千个操作，每个操作都要写一遍WriteLog方法，工作量的巨大是可想而知的，更别说还有用户验证这块了。所以说，解决这种问题的方法最好是进行类的横切，OK，让我们进入正题吧。

首先，在解决方案中新建一个名称为BookStore.AOP的类库项目，然后向其中添加IAdvice并继承自IMethodInterceptor接口和IDisposable接口。

然后定义三个方法：

void Initializement();

void BeforeCall(IMethodInvocation invocation);

void AfterCall(IMethodInvocation invocation);

具体代码如下：

using System;
using AopAlliance.Intercept;

namespace BookStore.AOP
{
    public interface IAdvice : IMethodInterceptor, IDisposable
    {
        void Initializement();
        void BeforeCall(IMethodInvocation invocation);
        void AfterCall(IMethodInvocation invocation);
    }
}

其中Initializement方法主要提供初始化行文；BeforeCall方法主要是在函数执行前触发；AfterCall方法主要是在函数执行后触发。

建立好这个接口之后，新建一个LogAdvice类，继承自刚刚建立的IAdvice接口，并添加如下代码：

using System;

namespace BookStore.AOP
{
    /*
     请在需要消费AOP的地方添加对BookStore.AOP的引用，否则会出现错误。
     */
    public class LogAdvice:IAdvice
    {
        public LogAdvice()
        {
            Initializement();
        }

        private log4net.ILog log;

        public void Initializement()
        {
            log4net.Config.XmlConfigurator.Configure();
            log = log4net.LogManager.GetLogger(typeof(LogAdvice));
        }

        public void BeforeCall(AopAlliance.Intercept.IMethodInvocation invocation)
        {
            log.Info(string.Format("调用函数开始:{0}", invocation.Method.Name));
        }

        public void AfterCall(AopAlliance.Intercept.IMethodInvocation invocation)
        {
            log.Info(string.Format("调用函数结束:{0}", invocation.Method.Name));
        }

        public object Invoke(AopAlliance.Intercept.IMethodInvocation invocation)
        {
            try
            {
                BeforeCall(invocation);
                object resultObj = invocation.Proceed();
                AfterCall(invocation);
                return resultObj;
            }
            catch (Exception ex)
            {
                log.Error(string.Format("调用函数错误:{0},{1},{2}", invocation.Method.Name, ex.Message, ex.StackTrace));
                return null;
            }
        }

        public void Dispose()
        {

        }
    }
}

由于这里的日志记录，我采用了Log4net来进行配置，所以不懂的同学，可以参考我之前的文章Log4Net使用方法小记来进行。

需要说明一点的是，在BeforeCall函数，AfterCall函数，Invoke函数中，我们得到的传入参数都是AopAlliance.Intercept.IMethodInvocation,通过这个参数，我们可以拦截用户当前请求的是什么函数，什么类型等等，非常方便。需要特别注意的是，在Invoke方法中，程序调用invocation.Proceed来拦截函数的执行，这也就是所谓的方法横切操作。

写到这里，我们的编码工作算是完成了，下面来开始配置AOP横切。

打开BookStore.RestService项目，双击Web.config配置文件，新添加如下的节点段落，名称分别为BookRepositoryAOP以及LogTraceAroundAdvice：

<!--Spring Config Node-->
  <spring>
    <context>
      <resource uri="config://spring/objects"/>
    </context>
    <objects xmlns="http://www.springframework.net">
      <!--without aop-->
      <object name="BookRepository" type="BookStore.Data.BookRepository, BookStore.Data" />

      <!--with aop-->
      <object name="BookRepositoryAOP" type="Spring.Aop.Framework.ProxyFactoryObject" >
        <property name="Target">
          <object type="BookStore.Data.BookRepository, BookStore.Data" />
        </property>
        <property name="InterceptorNames">
          <list>
            <value>LogTraceAroundAdvice</value>
          </list>
        </property>
      </object>
      <!--Advices-->
      <object id="LogTraceAroundAdvice" type="BookStore.AOP.LogAdvice, BookStore.AOP"></object>
    </objects>
  </spring>

其中名称为BookRepositoryAOP的节点表明当前采用AOP方式进行，横切的目标是BookStore.Data.BookRepository；横切的处理是BookStore.AOP.LogAdvice。配置好后，一定不要忘记添加对BookStore.AOP项目的引用。

这之后，打开BookService类，修改构造初始化为刚刚配置的节点：

public BookService()
           : base()
       {
           bookRepository = (IBookRepository)applicationContext["BookRepositoryAOP"];
       }

然后执行，我们就可以看到拦截的日志消息了，如果执行的时候，出现错误，还能够将错误信息捕捉，是不是感觉有了AOP，腰不酸了，腿不痛了的感觉呢？

这节就到这里了，下节主要讲解用户验证这块，也是利用横切来进行。

这里允许我白话一下：接口这东西在小项目中根本用不到，但是在大项目中，是必不可少的。IOC，AOP全靠它了。并且模块与模块之间交互，利用接口来规范，大大降低了耦合度，真好啊。