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

木宛城主發表於2019-03-04
Unity應用架構

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

跟蹤問題

通過觀察，你發現方法Do執行緩慢，可能有效能問題，因為這是一個線上的版本，你無法進行Debug，所以你通過日誌的形式來追蹤執行步驟：

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中，但每個方法還是要寫這一大堆和業務無關的程式碼，這壓根什麼也沒解決，這個方法的層次結構如下圖所示：

AOP面向切面程式設計的引入

什麼是AOP?

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

如果你是第一次接觸『面向切面程式設計』，可能這些概念太過複雜和籠統，我建議先翻閱相關書籍、部落格，最好對AOP有一定的瞭解。

什麼是『切面』？

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

  • 在現實生活中，一個大西瓜，一刀切下去，一分為二，這破壞了它的整體性，瓜瓤完全暴露在你面前，然後你可以隨心所欲的吃它，但不切開，你肯定吃不了它。
  • 在計算機世界，一個類（物件）包裹了若干方法，它像西瓜那樣也是一個整體，你將方法作為一個切入點，一刀切下去，方法完全暴露在你面前，你可以按照你所需的要求進行攔截，但不切開，你肯定攔截不了。當然，計算機世界裡肯定不會讓你拿一把刀來切一個物件，這是一個更加抽象的概念，下面會闡述

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

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

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();複製程式碼

小結

AOP思想是非常重要的重構手段，以不侵入的形式解耦業務邏輯和攔截方法。本質上是以橫向擴充套件的形式替換了傳統的縱向繼承方式來實現。遺憾的是，在Unity中並沒有好的AOP框架，我按照AOP的思想，簡化了實現模式，以曲線的形式實現對方法的攔截。
原始碼託管在Github上，點選此瞭解

歡迎關注我的公眾號：

相關文章