想象一下,當程式所有的業務邏輯都完成的時候,你可能還來不及喘口氣,緊張的測試即將來臨。你的Boss告訴你,雖然程式沒問題,但某些方法為什麼執行這麼慢,性能堪憂。領會了Boss的意圖之後,漫長的排查問題開始了。你會寫日誌,或者是其他工具來追蹤原因。那麼如何以一種優雅的形式,並且不侵入業務代碼的形式來跟 ...
想象一下,當程式所有的業務邏輯都完成的時候,你可能還來不及喘口氣,緊張的測試即將來臨。你的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上,點擊此瞭解