想象一下，當程序所有的業(yè)務邏輯都完成的時候，你可能還來不及喘口氣，緊張的測試即將來臨。你的Boss告訴你，雖然程序沒問題，但某些方法為什么執(zhí)行這么慢，性能堪憂。領會了Boss的意圖之后，漫長的排查問題開始了。你會寫日志，或者是其他工具來追蹤原因。那么如何以一種優(yōu)雅的形式，并且不侵入業(yè)務代碼的形式來跟蹤呢？這正是本文的內(nèi)容。

回到頂部

跟蹤問題

通過觀察，你發(fā)現(xiàn)方法Do執(zhí)行緩慢，可能有性能問題，因為這是一個線上的版本，你無法進行Debug，所以你通過日志的形式來追蹤執(zhí)行步驟：

class Foo1{    void Do()    {        //日志記錄開始
        //性能監(jiān)控開始
        DoSomething();        //日志記錄結束
        //性能監(jiān)控結束
    }
}

看起來不錯，解決問題之后，測試又發(fā)現(xiàn)另一個方法Handle貌似也有問題，然后你一樣畫葫蘆，雖然麻煩了一點，但總歸是有解決方案：

class Foo2{    void Handle()    {        //日志記錄開始
        //性能監(jiān)控開始
        DoSomething();        //日志記錄結束
        //性能監(jiān)控結束
    }
}

上述兩段代碼，雖然看起來很丑，但畢竟是能解決問題，但是代碼的風格不怎么讓人舒服：

• 代碼沒有重用，比如日志記錄，性能監(jiān)控，它們實則是做了一樣的事情

• 日志記錄，性能監(jiān)控代碼侵入了核心的業(yè)務邏輯，造成了混亂

知道了問題之后，第二種風格的代碼出現(xiàn)了：

class Bar
{
    void Do()
    {        common.BeginLog();            common.BeginWatch();                common.BeginTransaction();
                    foo.Do();                common.Commit();            common.EndWatch();        common.EndLog();
    }
}

看似是個不錯的方案，但實際上還是沒解決本質(zhì)問題。雖然將日志，監(jiān)控放到了Common中，但每個方法還是要寫這一大堆和業(yè)務無關的代碼，這壓根什么也沒解決，這個方法的層次結構如下圖所示：

回到頂部

AOP面向切面編程的引入

什么是AOP?

• 名稱來源->『Aspect Oriented Programming』的縮寫，中文翻譯即『面向切面編程』

• 應用場景->為日志記錄，性能監(jiān)控，安全控制，事務處理，異常處理等與具體業(yè)務邏輯無關，卻又需要在全局范圍執(zhí)行的功能提供了一種良好的重用并且和業(yè)務邏輯解耦

• 核心理念->AOP的思想是圍繞著切面進行的，所謂的『切面』就是對目標對象的某種操作進行攔截，在系統(tǒng)其他部分調(diào)用目標對象的某種操作時攔截這些調(diào)用，并在進行真正的調(diào)用前、后執(zhí)行一段中間邏輯

• 實現(xiàn)方式->AOP的實現(xiàn)方式被分為『靜態(tài)織入』和『動態(tài)織入』。采用『靜態(tài)織入』方式通過擴展編譯器對代碼的中間語言IL插入代碼，從而對目標對象進行攔截。『動態(tài)織入』則在運行時創(chuàng)建動態(tài)代理對象來攔截

如果你是第一次接觸『面向切面編程』，可能這些概念太過復雜和籠統(tǒng)，我建議先翻閱相關書籍、博客，最好對AOP有一定的了解。

什么是『切面』？

『面向切面編程』總共6個字，想必最難理解的還是『切面』兩字吧。

• 在現(xiàn)實生活中，一個大西瓜，一刀切下去，一分為二，這破壞了它的整體性，瓜瓤完全暴露在你面前，然后你可以隨心所欲的吃它，但不切開，你肯定吃不了它。

• 在計算機世界，一個類（對象）包裹了若干方法，它像西瓜那樣也是一個整體，你將方法作為一個切入點，一刀切下去，方法完全暴露在你面前，你可以按照你所需的要求進行攔截，但不切開，你肯定攔截不了。當然，計算機世界里肯定不會讓你拿一把刀來切一個對象，這是一個更加抽象的概念，下面會闡述

所以『切面』是一種橫向的攔截，而非縱向繼承的機制。

使用縱向繼承的方式來攔截方法：

class Order{    public virtual void Add()    {
        Console.WriteLine("新增訂單");
    }
}class OrderExt : Order{    public override void Add()    {        //開啟事務
        BeginTransaction();        base.Add();        //提交事務
        Commit();
    }    void BeginTransaction() { }    void Commit() { }
}

缺點上面已經(jīng)提到過了，不再重復。

使用AOP橫向攔截方法，通過動態(tài)代理類來實現(xiàn)：

class Order{    public virtual void Add()    {
        Console.WriteLine("新增訂單");
    }
}class TransactionUtility{    public void BeginTransaction() { }    public void Commit() { }
}class OrderProxy{    public Order o;    public TransactionUtility u;    public void Add()    {
        u.BeginTransaction();
        o.Add();
        u.Commit();
    }
}

當然這個OrderProxy一般是通過框架（比如Spring）在運行時動態(tài)創(chuàng)建的，所以叫動態(tài)代理對象。客戶端不知道真正調(diào)用的對象其實是OrderProxy。整個過程如下所示：

1.) Target:目標類，需要被代理的類
2.) Join Point:連接點，指那些可能被攔截到的方法。
3.) Point Cut:切入點，已經(jīng)被增強的連接點
4.) 切面類：提供了事務管理，日志記錄，性能監(jiān)控等公共操作的類
5.) Advice：通知點，用來增強代碼
6.) Weaving：織入，將Advice應用到目標對象Target，是創(chuàng)建新的代理對象Proxy的過程。
7.) Proxy：代理類
8.) Aspect：切面，是切入點PointCut和通知Advice的結合，2點確定一條線，多條線組合成面

回到頂部

在Unity中使用AOP思想

很遺憾，在Unity中沒有好的AOP框架，雖然.NET有很多AOP框架，但考慮到Unity的跨平臺，很多技術并不兼容。所以我以另一種形式間接的實現(xiàn)了AOP。

理解了AOP之后，實際上我只關注兩點：

• 既然沒有框架來動態(tài)創(chuàng)建代理對象，那我只能自己創(chuàng)建

• 代理對象是用來攔截方法的，你需要告訴代理對象怎么來攔截方法，所以通過委托的形式來指定策略

定義一個Proxy類，指定需要被代理的類的方法，以及攔截策略：

public class Proxy{    public static Proxy Instance = new Proxy();    private IInvocationHandler _invocationHandler;    private object _target;    private string _method;    private object[] _args;    private Proxy()    {
    }    public Proxy SetInvocationHandler(IInvocationHandler invocationHandler)    {
        _invocationHandler = invocationHandler;        return this;
    }    public Proxy SetTarget(object target)    {
        _target = target;        return this;
    }    public Proxy SetMethod(string method)    {
        _method = method;        return this;
    }    public Proxy SetArgs(object[] args)    {
        _args = args;        return this;
    }    public object Invoke()    {        var methodInfo = _target.GetType().GetMethod(_method);        return _invocationHandler.Invoke(_target, methodInfo, _args);
    }
}

攔截策略是個公共接口，提供策略：

public interface IInvocationHandler{    void PreProcess();    object Invoke(object proxy, MethodInfo method, object[] args);    void PostProcess();
}

實現(xiàn)接口，就可以自定義攔截方法，一個日志的策略如下所示：

public class LogInvocationHandler:IInvocationHandler{    public void PreProcess()    {
        LogFactory.Instance.Resolve<ConsoleLogStrategy>().Log("Pre Process");
    }    public object Invoke(object target, MethodInfo method, object[] args)    {
        PreProcess();        var result= method.Invoke(target, args);
        PostProcess();        return result;
    }    public void PostProcess()    {
        LogFactory.Instance.Resolve<ConsoleLogStrategy>().Log("Post Process");
    }
}

假設你需要對repository對象的Test方法進行攔截，即執(zhí)行前后進行日志的打印，你可以這樣來使用：

 Proxy.Instance.SetTarget(repository)    .SetMethod("Test")    .SetArgs(new object[] {})    .SetInvocationHandler(new LogInvocationHandler())    .Invoke();

回到頂部

小結

AOP思想是非常重要的重構手段，以不侵入的形式解耦業(yè)務邏輯和攔截方法。本質(zhì)上是以橫向擴展的形式替換了傳統(tǒng)的縱向繼承方式來實現(xiàn)。遺憾的是，在Unity中并沒有好的AOP框架，我按照AOP的思想，簡化了實現(xiàn)模式，以曲線的形式實現(xiàn)對方法的攔截。
源代碼托管在Github上，點擊此了解

本博客為木宛城主原創(chuàng)，基于Creative Commons Attribution 2.5 China Mainland License發(fā)布，歡迎轉載，演繹或用于商業(yè)目的，但是必須保留本文的署名木宛城主（包含鏈接）。如您有任何疑問或者授權方面的協(xié)商，請給我留言。

http://www.cnblogs.com/OceanEyes/p/aop_in_action.html

延伸閱讀

• 珊珊老師——北京IT機構十年一線教學經(jīng)驗 2024-08-28
• 告別“老頑固” 2023-04-18
• 時光飛逝 2024-03-26
• 會當凌絕頂，一覽眾山小 2023-04-18
• 自豪 2023-04-18
• 綻放 2023-04-18
• 畢業(yè)有感 2023-04-18
• 投入六個月的經(jīng)歷，收獲了整個人生 2023-04-18
• 非常響亮的名字 2023-04-18
• 不可磨滅的力量 2023-04-18

珊珊老師——北京IT機構十年一線教學經(jīng)驗