第五章 面向方面編程___AOP入門

　　上一篇講了 AOP 和 OOP 的區別，這一次我們開始入門 AOP 。實現面向方面編程的技術，主要分為兩大類：

一是 采用動態代理技術，利用截取消息的方式，對該消息進行裝飾，以取代原有對象行為的執行；

二是 采用靜態織入的方式，引入特定的語法創建 “方面”，從而使得編譯器可以在編譯期間織入有關 “方面” 的代碼。

然而殊途同歸，實現 AOP 的技術特性卻是相同的，分別為：

crosscutting concerns （橫切性關注點）：一個關注點（concern）就是一個特定的目的，一塊我們要完成的區域，一段我們需要的邏輯行為。從技術的角度來說，一個典型的軟件系統包含一些核心的關注點和系統級的關注點。舉個例子來說，一個銀行支付系統的核心關注點是存入/支付處理，而系統級的關注點則是日志、事務完整性、權限、安全及性能問題等，許多關注點（即橫切關注點）會在很多個模塊中出現。如果使用現有的編程方法，橫切關注點會橫越多個模塊，結果是使系統變得越來越復雜，難以設計和實現。通過面向切面編程的方式能夠更好地分離系統關注點，從而提供模塊化的橫切關注點。

aspect（切面）：橫切性關注點的抽象即為切面，與類相似，只是兩者的關注點不一樣。類是對物體特征的抽象，切面是對橫切性關注點的抽象。

join point（連接點）：所謂連接點就是指那些些被攔截到的點。在Spring中這些連接點指的就是方法，因為在Spring中只支持方法類型的連接點。實際上連接點還可以是構造函數或者字段。通俗的說是程序執行中的一個精確執行點，例如類中的一個方法。它是一個抽象的概念，在實現面向切面編程時，並不需要去定義一個join point。

point cut（切入點）：切入點就是指我們要對那些方法進行攔截和定義。

advice（通知）：通知就是指我們攔截到方法之后，要做的事情。Spring中有前置通知，后置通知，異常通知，最終通知，環繞通知。

target object（目標對象）：指包含連接點的對象。也稱為被通知或被代理對象。

weave（織入）：將切面應用到目標對象，並導致代理對象創建的過程叫做織入

Introduction（引入）：運行期間，在不修改代碼的情況下，動態的為類添加方法和字段。通俗的將就是為對象引入附加的方法或屬性。

 

使用代理模式實現面向切面編程

　　下面我們使用代理模式來模擬一下，現面向切面編程。通過上面那幅圖，我們看到使用面向切面編程將核心業務和其他業務（日志記錄，性能檢測等）分離開來。這次我們模擬一下，銀行支付中記錄日志的問題。

我們有 兩個接口，ICard，ILogger ， ICard 表示 卡的接口，ILogger 表示 日志記錄接口。

卡接口：

namespace CnblogLesson_5_1.Interface
{
    /// <summary>
    /// 卡
    /// </summary>
    interface ICard
    {
        //存入
        void Deposit(double money);

        //支出
        void Pay(double money);
    }
}

日志接口：

namespace CnblogLesson_5_1.Interface
{
    //日志
    interface ILogger
    {
        /// <summary>
        /// 寫入日志
        /// </summary>
        void LogWrite(string message);
    }
}

卡的實現：

using System;
using CnblogLesson_5_1.Interface;

namespace CnblogLesson_5_1.Impl
{
    class Card : ICard
    {
        //存入
        public void Deposit(double money)
        {
            Console.WriteLine("存入：{0}" ,money);
            Logger log = new Logger();
            log.LogWrite("日志：" + DateTime.Now.ToShortTimeString() +"存入" + money.ToString());
        }

        //支出
        public void Pay(double money)
        {
            Console.WriteLine("支出：{0}", money);
            Logger log = new Logger();
            log.LogWrite("日志：" + DateTime.Now.ToShortTimeString() + "支出" + money.ToString());
        }
    }
}

日志的實現：

using System;
using CnblogLesson_5_1.Interface;

namespace CnblogLesson_5_1.Impl
{
    class Logger : ILogger
    {
        public void LogWrite(string message)
        {
            Console.WriteLine("寫入到SQL Server 數據庫中：" + message);
        }
    }
}

調用：

using System;
using CnblogLesson_5_1.Interface;
using CnblogLesson_5_1.Impl;

namespace CnblogLesson_5_1
{
    class Program
    {
        static void Main(string[] args)
        {
            ICard card = new Card();

            card.Deposit(100);
            card.Pay(100);

            Console.ReadKey();

        }
    }
}

輸出結果：

 

以上方式的缺陷：

　　我們的核心業務（存入/取錢）與記錄日志本不該彼此糾纏在一起的責任卻糾纏在一起，增加了我們系統的復雜性。

 

下面使用代理模式模擬 AOP 實現 核心業務與日志記錄的解耦：

 

ICard 和 ILogger 接口，還是那些接口，日志的實現還是日志的實現，沒有做改動。

現在，存款和取款的 實現只做自己的業務，無需進行日志記錄：

using System;
using 代理模式模擬AOP.Interface;

namespace 代理模式模擬AOP.Impl
{
    class Card : ICard
    {
        //存入
        public void Deposit(double money)
        {
            Console.WriteLine("存入：{0}" ,money);
        }

        //支出
        public void Pay(double money)
        {
            Console.WriteLine("支出：{0}", money);
        }
    }
}

現在增加代理類 ProxyCard：

using System;
using 代理模式模擬AOP.Interface;
using 代理模式模擬AOP.Impl;

namespace 代理模式模擬AOP.Proxy
{
    public class ProxyCard
    {
        private ICard target;

        public ProxyCard(ICard target)
        {
            this.target = target;
        }

        public void Invoke(string method, object[] parameters)
        {
            if (target != null)
            {
                ILogger log = new  Logger();
                double money = double.Parse(parameters[0].ToString());
                switch (method) {
                    case "Pay":
                        log.LogWrite("日志：" + DateTime.Now.ToShortTimeString() + "支出" + money.ToString());
                        break;
                    case "Deposit":
                        log.LogWrite("日志：" + DateTime.Now.ToShortTimeString() + "存入" + money.ToString());
                        break;
                }
                Type type = target.GetType();
                type.GetMethod(method).Invoke(target, parameters);
            }
        }
    }

}

調用：

using System;
using 代理模式模擬AOP.Interface;
using 代理模式模擬AOP.Impl;
using 代理模式模擬AOP.Proxy;

namespace 代理模式模擬AOP
{
    class Program
    {
        static void Main(string[] args)
        {
            ICard card = new Card();

            ProxyCard proxy = new ProxyCard(card);
            proxy.Invoke("Pay", new object[] { 100 });
            proxy.Invoke("Deposit", new object[] { 100 });

            Console.ReadKey();

        }
    }
}

執行結果：

 

通過 ProxyCard 代理對象，我們實現了對方法的攔截，在調用之前進行日志記錄的操作。實現了我們的核心業務(存入/支出)與日志記錄的分離，從而降低了系統的耦合。