Unity應用架構設計(12)——AOP思想的實踐

時間 2019-11-17

原文原文鏈接

想象一下，當程序全部的業務邏輯都完成的時候，你可能還來不及喘口氣，緊張的測試即未來臨。你的Boss告訴你，雖然程序沒問題，但某些方法爲何執行這麼慢，性能堪憂。領會了Boss的意圖以後，漫長的排查問題開始了。你會寫日誌，或者是其餘工具來追蹤緣由。那麼如何以一種優雅的形式，而且不侵入業務代碼的形式來跟蹤呢？這正是本文的內容。git

跟蹤問題

經過觀察，你發現方法Do執行緩慢，可能有性能問題，由於這是一個線上的版本，你沒法進行Debug，因此你經過日誌的形式來追蹤執行步驟：github

class Foo1
{
    void Do() {
        //日誌記錄開始
        //性能監控開始
        DoSomething();
        //日誌記錄結束
        //性能監控結束
    }
}複製代碼

看起來不錯，解決問題以後，測試又發現另外一個方法Handle貌似也有問題，而後你同樣畫葫蘆，雖然麻煩了一點，但總歸是有解決方案：編程

class Foo2
{
    void Handle() {
        //日誌記錄開始
        //性能監控開始
        DoSomething();
        //日誌記錄結束
        //性能監控結束
    }
}複製代碼

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

代碼沒有重用，好比日誌記錄，性能監控，它們實則是作了同樣的事情
日誌記錄，性能監控代碼侵入了核心的業務邏輯，形成了混亂

知道了問題以後，第二種風格的代碼出現了：框架

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

看似是個不錯的方案，但實際上仍是沒解決本質問題。雖然將日誌，監控放到了Common中，但每一個方法仍是要寫這一大堆和業務無關的代碼，這壓根什麼也沒解決，這個方法的層次結構以下圖所示：ide

AOP面向切面編程的引入

什麼是AOP?工具

名稱來源->『Aspect Oriented Programming』的縮寫，中文翻譯即『面向切面編程』
應用場景->爲日誌記錄，性能監控，安全控制，事務處理，異常處理等與具體業務邏輯無關，卻又須要在全局範圍執行的功能提供了一種良好的重用而且和業務邏輯解耦
核心理念->AOP的思想是圍繞着切面進行的，所謂的『切面』就是對目標對象的某種操做進行攔截，在系統其餘部分調用目標對象的某種操做時攔截這些調用，並在進行真正的調用前、後執行一段中間邏輯
實現方式->AOP的實現方式被分爲『靜態織入』和『動態織入』。採用『靜態織入』方式經過擴展編譯器對代碼的中間語言IL插入代碼，從而對目標對象進行攔截。『動態織入』則在運行時建立動態代理對象來攔截

若是你是第一次接觸『面向切面編程』，可能這些概念太過複雜和籠統，我建議先翻閱相關書籍、博客，最好對AOP有必定的瞭解。性能

什麼是『切面』？測試

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

在現實生活中，一個大西瓜，一刀切下去，一分爲二，這破壞了它的總體性，瓜瓤徹底暴露在你面前，而後你能夠爲所欲爲的吃它，但不切開，你確定吃不了它。
在計算機世界，一個類（對象）包裹了若干方法，它像西瓜那樣也是一個總體，你將方法做爲一個切入點，一刀切下去，方法徹底暴露在你面前，你能夠按照你所需的要求進行攔截，但不切開，你確定攔截不了。固然，計算機世界裏確定不會讓你拿一把刀來切一個對象，這是一個更加抽象的概念，下面會闡述

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

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

class Order
{
    public virtual void Add() {
        Console.WriteLine("新增訂單");
    }
}

class OrderExt : Order
{
    public override void Add() {
        //開啓事務
        BeginTransaction();
        base.Add();
        //提交事務
        Commit();
    }
    void BeginTransaction() { }
    void Commit() { }
}複製代碼

缺點上面已經提到過了，再也不重複。

使用AOP橫向攔截方法，經過動態代理類來實現：

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）在運行時動態建立的，因此叫動態代理對象。客戶端不知道真正調用的對象實際上是OrderProxy。整個過程以下所示：

1.) Target:目標類，須要被代理的類
2.) Join Point:鏈接點，指那些可能被攔截到的方法。
3.) Point Cut:切入點，已經被加強的鏈接點
4.) 切面類：提供了事務管理，日誌記錄，性能監控等公共操做的類
5.) Advice：通知點，用來加強代碼
6.) Weaving：織入，將Advice應用到目標對象Target，是建立新的代理對象Proxy的過程。
7.) Proxy：代理類
8.) Aspect：切面，是切入點PointCut和通知Advice的結合，2點肯定一條線，多條線組合成面

在Unity中使用AOP思想

很遺憾，在Unity中沒有好的AOP框架，雖然.NET有不少AOP框架，但考慮到Unity的跨平臺，不少技術並不兼容。因此我以另外一種形式間接的實現了AOP。

理解了AOP以後，實際上我只關注兩點：

既然沒有框架來動態建立代理對象，那我只能本身建立
代理對象是用來攔截方法的，你須要告訴代理對象怎麼來攔截方法，因此經過委託的形式來指定策略

定義一個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();
}複製代碼

實現接口，就能夠自定義攔截方法，一個日誌的策略以下所示：

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方法進行攔截，即執行先後進行日誌的打印，你能夠這樣來使用：

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