AOP概念

　　Aspect Oriented Programming，面向切面程式設計，可以通過預編譯方式和執行期動態代理，實現在不修改原始碼的情況下給程式動態統一新增功能的一種技術。

前提

• 瞭解Spring.NET IOC
• 熟悉代理模式
  

　　下面我們結合一個具體的例子來了解AOP。

基本情景

User類

    /// <summary>
    /// 使用者實體，具有姓名和年齡兩個屬性
    /// </summary>
    public class User
    {
        public string Name { get
 
; set; }
        public int Age { get; set; }
    }

IUserService

    public interface IUserService
    {
        //獲得使用者資訊
        void GetUserInfo(User enUser);
    }

UserService

    public class UserService:IUserService
    {
        /// <summary>
        /// 獲得使用者的資訊
        /// </summary>
 

        /// <param name="enUser">使用者實體</param>
        public void GetUserInfo(User enUser)
        {
            //輸出使用者的姓名和年齡
            Console.WriteLine("姓名："+enUser .Name+"年齡："+enUser .Age  );
        }
    }

客戶端（控制檯應用程式）Program

• “ new()”出具體的實現——這裡我們不採用此方式

    class Program
    {
 

        static void Main(string[] args)
        {
            //例項化一個實體
            User enUser = new User()
            {
                Name = "Danny",
                Age = 15
            };           
            IUserService userService = new UserService();
            userService.GetUserInfo(enUser);

        }
    }

• 通過Spring IOC獲得具體實現（相當於工廠）

//引入Spring.Core.dll
using Spring.Context;
using Spring.Context.Support;

namespace WithoutAOP
{
    class Program
    {
        static void Main(string[] args)
        {
            //例項化一個實體
            User enUser = new User()
            {
                Name = "Danny",
                Age = 15
            };          

            //獲得Spring.IOC容器的上下文
            IApplicationContext context = ContextRegistry.GetContext();
            //根據配置檔案中的配置獲得業務實現類
            IUserService userService = (IUserService)context.GetObject("userService");
            //呼叫業務實現類的方法
            userService.GetUserInfo(enUser);
        }
    }
}

配置檔案

    <!--Spring配置-->
    <configSections>
        <sectionGroup name="spring">
            <section name="context" type="Spring.Context.Support.ContextHandler, Spring.Core"/>
            <section name="objects" type="Spring.Context.Support.DefaultSectionHandler, Spring.Core"/>
        </sectionGroup>
    </configSections>
    <spring>
        <context>
            <resource uri="config://spring/objects"/>
        </context>
        <objects xmlns="http://www.springframework.net">
            <object id="userService" type="AOPExample.UserService,AOPExample"/>
        </objects>
    </spring>

　　現在我們要為已有的業務邏輯增加日誌功能。接下來看看AOP如何來實現。
　　在瞭解之前，我們先來了解AOP中的一些術語。

AOP術語

• 目標物件(Target)，即我們要代理的物件（UserService），也就是我們要為此物件增加日誌功能。
• 關注點(Concern)：如日誌功能。日誌功能是系統級別的，不可能只在一個物件中增加日誌功能。
• 通知(Advice):在Advice中寫日誌功能的具體實現。通知類實現不同的介面，如：Before，After……這些決定了日誌功能如何新增（切入）到業務邏輯中，是在業務邏輯執行前新增，還是執行後新增。

AOP實現思路

• 寫具體的通知類Advice（實現日誌功能）

• 在配置檔案中進行配置

  • 配置生成代理類的方式

  • 配置目標物件（可以直接配置具體的目標物件，也可以通過名稱或正則表示式，程式執行後會在容器中尋找到符合條件的物件作為目標物件）

  • 配置通知類

ProxyFactoryObject 顯式建立AOP代理

Advice通知類

//引入System.Aop.dll;
using Spring.Aop;       //AOP
using System.Reflection;//反射
namespace AOPExample
{
    /// <summary>
    /// Advice通知類：實現日誌功能
    /// </summary>
    public class LogBeforeAdvice:IMethodBeforeAdvice
    {
        /// <summary>
        /// 實現介面IMethodBeforeAdvice中的Before方法，在目標方法執行前執行Before（）
        /// </summary>
        /// <param name="method">攔截的方法</param>
        /// <param name="args">方法的引數</param>
        /// <param name="target">攔截的物件</param>
        public void Before(MethodInfo method, object[] args, object target)
        {
            Console.WriteLine("攔截的方法名—>" + method.Name);
            Console.WriteLine("目標物件—>" + target);
            Console.WriteLine("引數—>");

            //如果引數不為空，遍歷所有引數並輸出
            if (args != null)
            {
                foreach (object arg in args)
                {
                    Console.WriteLine("\t: " + arg);
                }
            }  
        }
    }
}

配置檔案

<?xml version="1.0"?>
<configuration>
    <!--Spring.Context.Support.ContextRegistry 的型別初始值設定項引發異常。-->
    <!--註釋掉此配置節，否則會報上述異常-->
    <!--<startup> 
        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5.1" />
    </startup>-->  
    <!--Spring配置-->
    <configSections>
        <sectionGroup name="spring">
            <section name="context" type="Spring.Context.Support.ContextHandler, Spring.Core"/>
            <section name="objects" type="Spring.Context.Support.DefaultSectionHandler, Spring.Core"/>
        </sectionGroup>
    </configSections>

    <spring>
        <context>
            <resource uri="config://spring/objects"/>
        </context>
        <objects xmlns="http://www.springframework.net">
            <!--配置通知類LogBeforeAdvice-->
            <object id="beforeAdvice" type="AOPExample.LogBeforeAdvice,AOPExample"/>         
            <!--通過ProxyFactoryObject 顯式建立AOP代理-->
            <object id="userServiceProxy" type="Spring.Aop.Framework.ProxyFactoryObject">
                <!--指定代理的真實物件-->
                <property name="Target">
                    <object type="AOPExample.UserService,AOPExample"/>
                </property>
                <!--指定具體通知類-->
                <property name="InterceptorNames">
                    <list>
                        <!--指定具體通知類，和前面配置的id一致-->
                        <value>beforeAdvice</value>
                    </list>
                </property>
            </object>
        </objects>
    </spring>
</configuration>

客戶端

    class Program
    {
        static void Main(string[] args)
        {
            //例項化使用者
            User enUser = new User()
            {
                Name ="Jenny",
                Age=15
            };

            //獲得Spring容器上下文
            IApplicationContext context = ContextRegistry.GetContext();
            //從配置檔案獲得由ProxyFactoryObject生成的代理類
            //需要修改客戶端，原來是直接呼叫真實物件，現在是呼叫代理
            IUserService userServiceProxy = (IUserService)context["userServiceProxy"];
            userServiceProxy.GetUserInfo(enUser);

        }
    }

執行結果

總結

• 優點：通過ProxyFactoryObject 建立代理類，省去自己手動建立代理類；
• 缺點1：如果有多個目標物件，每個都需要在配置檔案中配置；
• 缺點2：客戶端呼叫時，由原來呼叫目標物件，變成呼叫代理物件，需要修改客戶端程式碼。