2. 程式人生 > >20181122_C#中AOP初探_裝飾器模式的AOP_Remoting實現AOP_Castle實現AOP

20181122_C#中AOP初探_裝飾器模式的AOP_Remoting實現AOP_Castle實現AOP

阿新 • • 發佈：2018-11-22

一.   什麼是AOP:

a)         AOP是面向切面程式設計; 就像oop一樣, 它也是一種程式設計思想;

            i.    Oop思想→一切皆物件, 物件互動組成功能, 功能疊加組成模組, 模組疊加組成系統; 如果把一個個的類比喻成一個個磚頭, 那麼系統就是一個房子; 房子是由一塊塊磚頭構成, 所以面向物件非常適合做大型系統; 但是面向物件的在應對系統擴充套件的時候, 就顯得力不從心; 如果磚塊需要發生變化, 則就會牽扯到很多地方; 因為面向物件是靜態的, 內部就是強耦合的關係; 雖然設計模式可以解決這些問題中的某些部分, 比如可以創建出可擴充套件, 可重用的架構, 但是設計模式操作的最小單元也是類(磚頭), 無法解決類的內部的變化

           ii.   AOP→面向切面程式設計, 是對OOP的補充; 主要功能就是為了解決類的內部變化, 在不破壞類封裝的同時, 水平擴充套件類的功能; 降低模組間的耦合度; 注意AOP不是實現業務行為的: 比如一個People類, 本身具有跑步, 吃飯, 睡覺這三個方法, 但是如果你想通過AOP為其增加一個 游泳 的方法, 那麼AOP就不適用了; 因為這種屬於業務層面, 在封裝類的時候, 就應該存在的行為; AOP主要是用來做一些通用的功能, 比如 許可權校驗/日誌記錄/傳送訊息/快取處理/效能監控 等等一些通用的非業務邏輯

的功能;

          iii.    總結:

    1. 所以說AOP 只是對OOP思想的一種補充, 解決類的內部通用功能的變化
    2. 所有的業務功能還是由OOP來實現, 比如People類需要增加 游泳 方法, 還是得有OOP來完成
    3. 有了AOP之後, OOP的實現也變得簡單了, 因為OOP的程式碼, 只用關注業務邏輯; 無需再操心各種通用的功能了

二. 利用裝飾器模式實現簡答的AOP, 沒有通用性:

a)         實現程式碼:

/// <summary>
        /// 1. 這個介面定義一個註冊使用者的行為
        /// </summary>
        public interface IUserProcessor
        {
            void RegUser(User user);
        }

        /// <summary>
        /// 2. 普通的實現
        /// </summary>
        public class UserProcessor : IUserProcessor
        {
            public void RegUser(User user)
            {
                Console.WriteLine("使用者已註冊。Name:{0},PassWord:{1}", user.Name, user.Password);
            }
        }

        /// <summary>
        /// 3. 利用裝飾器模式的實現, 這個就類似於簡單的AOP功能,
        /// 裝飾器即實現了IuserProcessor的介面
        /// 但在實現的同時, 還組合進一個IuserProcessor物件; 
        /// 這就是一個標準的裝飾器模式
        /// </summary>
        public class UserProcessorDecorator : IUserProcessor
        {
            //組合一個IUserProcessor物件
            private IUserProcessor _UserProcessor { get; set; }
            public UserProcessorDecorator(IUserProcessor userprocessor)
            {
                this._UserProcessor = userprocessor;
            }
            //實現介面
            public void RegUser(User user)
            {
                BeforeProceed(user);

                this._UserProcessor.RegUser(user);

                AfterProceed(user);
            }

            /// <summary>
            /// 定義在業務邏輯執行之前要執行的動作
            /// </summary>
            /// <param name="user"></param>
            private void BeforeProceed(User user)
            {
                Console.WriteLine("方法執行前");
            }
            /// <summary>
            /// 定義在業務邏輯執行之後要執行的動作
            /// </summary>
            /// <param name="user"></param>
            private void AfterProceed(User user)
            {
                Console.WriteLine("方法執行後");
            }
        }

b) 呼叫

public static void Show()
{
    User user = new User()
    {
        Name = "孫悟空",
        Password = "123456"
    };

    //5. 裝飾器模式使用的方法
    IUserProcessor processor = new UserProcessor();
    processor.RegUser(user); //普通實現


    Console.WriteLine("***************");



    user = new User()
    {
        Name = "八戒AOP",
        Password = "567890"
    };
    processor = new UserProcessorDecorator(processor);
    processor.RegUser(user);//使用裝飾器模式實現的AOP, 看起來只為此類的此方法單獨實現的, 有很大侷限性
}

c) 　執行結果截圖:

 

 三.  使用.net Remoting實現動態代理(AOP), 不太推薦, .net Remoting對父類的限制實在是太大了

a)         建立一個介面, 這裡和裝飾器模式沒有什麼區別

 /// <summary>
        /// 1. 使用.net Remoting 來實現動態代理, 這裡的業務還是和裝飾器與代理模式的業務一樣
        /// </summary>
        public interface IUserProcessor
        {
            void RegUser(User user);
        }

b)  實現介面, 並繼承MarshalByRefObject

 

 /// <summary>
        /// 必須繼承自MarshalByRefObject父類，否則無法生成; 
        /// 這個繼承就感覺比較噁心了;因為C#中都是單繼承的
        /// 
        /// 2. 定義一個UserProcessor來實現IUserProcessor, 必須繼承一個MarshalByRefObject; 繼承此類是.net Remoting的固定寫法類; 如果想實現動態代理就必須繼承這個類(MarshalByRefObject)
        /// </summary>
        public class UserProcessor : MarshalByRefObject, IUserProcessor
        {
            public void RegUser(User user)
            {
                Console.WriteLine("使用者已註冊。使用者名稱稱{0} Password{1}", user.Name, user.Password);
            }
        }

c)  使用Remoting進行物件生成的動態代理的固定寫法

/// <summary>
        /// MyRealProxy<T> 就是真實代理, 這個類裡面的東西, 屬於固定寫法, 是.net Remoting封裝好的
        /// </summary>
        /// <typeparam name="T"></typeparam>
        public class MyRealProxy<T> : RealProxy
        {
            private T tTarget;
            public MyRealProxy(T target): base(typeof(T))
            {
                this.tTarget = target;
            }

            /// <summary>
            /// .net Remoting的核心方法
            /// </summary>
            /// <param name="msg"></param>
            /// <returns></returns>
            public override IMessage Invoke(IMessage msg)
            {
                BeforeProceede(msg); //在執行方法之前做一些其它自定義的動作

                //這裡執行真實的方法體, 在這個方法體之前(之後)都可以加一點自己的動作
                IMethodCallMessage callMessage = (IMethodCallMessage)msg;
                object returnValue = callMessage.MethodBase.Invoke(this.tTarget, callMessage.Args);

                AfterProceede(msg);//在執行方法之後執行一些其它動作

                return new ReturnMessage(returnValue, new object[0], 0, null, callMessage);
            }
            #region 可以擴充套件的邏輯
            public void BeforeProceede(IMessage msg)
            {
                Console.WriteLine("方法執行前可以加入的邏輯");
            }
            public void AfterProceede(IMessage msg)
            {
                Console.WriteLine("方法執行後可以加入的邏輯");
            }
            #endregion
        }
/// <summary>
        /// 透明代理; 固定的寫法, 表示如何使用.net Remoting來生成物件
        /// </summary>
        public static class TransparentProxy
        {
            public static T Create<T>()
            {
                //使用反射動態建立物件
                T instance = Activator.CreateInstance<T>();
                //將物件包裝一層, 交給MyRealProxy
                MyRealProxy<T> realProxy = new MyRealProxy<T>(instance);
                //GetTransparentProxy→父類的方法
                T transparentProxy = (T)realProxy.GetTransparentProxy();
                return transparentProxy;
            }
        }

d) 呼叫方法:

 

public static void Show()
{
    User user = new User()
    {
        Name = "孫悟空",
        Password = "123456"
    };

    UserProcessor processor = new UserProcessor();
    processor.RegUser(user);
    Console.WriteLine("*********************");

    user = new User()
    {
        Name = "八戒AOP",
        Password = "567890"
    };
    //利用TransparentProxy來建立物件
    UserProcessor userProcessor = TransparentProxy.Create<UserProcessor>();
    //呼叫RegUser時, 會進入到Invoke方法中, 至於為什麼會進入到Invoke中, 是由.net Remoting的底層來實現的
    userProcessor.RegUser(user);
}

e)         執行結果:

四.   使用Castle實現動態代理

　　 對於Castle來說, 實現介面時, 方法必須是一個虛方法; 主要程式碼如下:

/// <summary>
    /// 使用Castle\DynamicProxy 實現動態代理
    /// 方法必須是虛方法
    /// </summary>
    public class CastleProxyAOP
    { 
        /// <summary>
        /// 1. 業務和動態代理/裝飾器模式/.net Remoting(RealProxy)都是一樣, 定義介面物件
        /// </summary>
        public interface IUserProcessor
        {
            void RegUser(User user);
        }

        /// <summary>
        /// 2. 業務子類實現IUserProcessor介面
        /// </summary>
        public class UserProcessor : IUserProcessor
        {
            /// <summary>
            /// 必須帶上virtual 否則無效
            /// </summary>
            /// <param name="user"></param>
            public virtual void RegUser(User user)
            {
                Console.WriteLine($"使用者已註冊。Name:{user.Name},PassWord:{user.Password}");
            }
        }

        /// <summary>
        /// 3. 這裡是個重點, Intercept()方法是個重點
        /// </summary>
        public class MyInterceptor : IInterceptor
        {
            public void Intercept(IInvocation invocation)
            {
                //在方法呼叫之前執行的動作
                PreProceed(invocation);
                invocation.Proceed(); //這裡是真實的方法呼叫
                //在方法呼叫之後執行的動作
                PostProceed(invocation);
            }
            public void PreProceed(IInvocation invocation)
            {
                Console.WriteLine("方法執行前");
            }

            public void PostProceed(IInvocation invocation)
            {
                Console.WriteLine("方法執行後");
            }
        }

			public static void Show()
        {
            User user = new User()
            {
                Name = "孫悟空",
                Password = "456789"
            };

            //4. 呼叫
            ProxyGenerator generator = new ProxyGenerator();
            MyInterceptor interceptor = new MyInterceptor();

            //5. 建立物件; (這個也是動態實現的AOP); 固定寫法
			  // 基於裡式替換原則,右邊是父類, 那麼在呼叫的時候, 根本就不會去管左邊是個什麼, 直接會呼叫父類的RegUser方法, 如果要呼叫子類的RegUser方法, 則必須標註virtual
            UserProcessor userprocessor = generator.CreateClassProxy<UserProcessor>(interceptor);
            userprocessor.RegUser(user);
        } 

    }

　　

 

相關推薦

20181122_C#中AOP初探_裝飾器模式的AOP_Remoting實現AOP_Castle實現AOP

一.   什麼是AOP: a)         AOP是面向切面程式設計; 就像oop一樣, 它也是一種程式設計思想;             i

IO中的裝飾器模式

包含 java str sequence 輸入 output bytearray stringbu 緩沖區 //可以進InputStream 類 區分為目的和方法兩類//一般直接子類，都是目的不同的(A類)，// 如FileInputStream, #從文件中獲得字節

C#/.NET 使用裝飾器模式實現AOP,靜態代理

C#使用裝飾器模式實現AOP,靜態代理 記錄一下使用裝飾器模式簡單實現一下AOP（面向切向）的簡單入門Demo using System; using System.Collections.Generic; using System.Linq; using System.Text

裝飾器模式中抽象裝飾器的作用

 今天要搞清楚的問題是為什麼需要上面那個被黃色框圈住的“抽象裝飾器類”。 裝飾器模式實現了不破壞原有類的情況下動態擴充套件一個類的功能。“為什麼需要抽象裝飾器類”，搞清楚這個問題最好的辦法是手寫一個裝飾器模式，然後去掉中間的抽象裝飾器類，看看會發生什麼。下面根據最上面的UML

設計模式入門之裝飾器模式Decorator

gravity 減少 都是 一個人 額外 不同的 這也 sys 裝飾器模式 //裝飾模式定義：動態地給一個對象加入一些額外的職責。 //就添加功能來說，裝飾模式比生成子類更為靈活 //這也提現了面向對象設計中的一條基本原則，即：盡量使用對象組合。而不是對象繼承//Com

java設計模式之 裝飾器模式

rac 都在 通過 div 過濾 一個人 創建 展開 out 裝飾器模式 裝飾器模式（Decorator Pattern）允許向一個現有的對象添加新的功能，同時又不改變其結構。 這種類型的設計模式屬於結構型模式，它是作為現有的類的一個包裝。 這種模式創建了一個裝飾類，用來包

java設計模式之 裝飾器模式

食物 implement super map 結束 同時 ring 接口 包裝 適AT java設計模式之 裝飾器模式 裝飾器模式 裝飾器模式（Decorator Pattern）允許向一個現有的對象添加新的功能，同時又不改變其結構。 這種類型的設計模式

09.設計模式_裝飾者模式

9.png 組件 復雜 2-2 就會 蘋果手機 apple pat 轉載 轉載自 http://www.cnblogs.com/zhili/p/DecoratorPattern.html 一、引言 在軟件開發中，我們經常想要對一類對象添加不同的功能，例如要給手機添加貼膜

Python不歸路_裝飾器（一）

意思 地址 函數返回值 right 輸出結果 運用 logs pan ext 裝飾器 　　裝飾器 什麽是裝飾器？給現有函數添加新功能的函數，不更改現有函數源代碼，現有函數調用方式。裝飾器是由高階函數和嵌套函數組成。 　　概括上面這句話的意思:1、裝飾器 - - - >

java之裝飾器模式

args pattern lte auto eight pro 簡單的 add con Decorator Pattern(裝飾器模式)，定義：Attach additional responsibilities to an object dynamically. Deco

裝飾器模式

-- 添加 div implement 它的 pos 能力 數組 filter 簡介 裝飾模式可以在不改變一個對象本身功能的基礎上給對象增加額外的新行為。例如一張照片，我們可以不改變照片本身，給它增加一個相框， 使得它具有防潮的功能；給他增加一個燈管，使它有可以發光的功能

適配器模式/代理模式/裝飾器模式/工廠模式

取數 取數據 cat remote struct catch span 擁有 rto 適配器模式 要對原有的類的功能進行擴展,但又不希望改變原有類的功能,來適應新的需求,這時候可以從原有類繼承,實現一個適配器,這不會改變原有類的功能,又可以添加新的功能. 1.類適配器 c

設計模式—裝飾器模式

component 動態擴展 @override 額外 添加 膨脹 裝飾模式 dci 不想 裝飾器模式（Decorator Pattern）允許向一個現有的對象添加新的功能，同時又不改變其結構。這種類型的設計模式屬於結構型模式，它是作為現有的類的一個包裝。 這種模式創建了一

javascript裝飾器模式

目前 edm ould list model 開發 cti on() 概念 裝飾器模式 什麽是裝飾器 原名decorator 被翻譯為裝飾器 可以理解為裝飾 修飾 包裝等意 現實中的作用 一間房子通過裝飾可以變得更華麗，功能更多 類似一部手機可以單獨使用 但是很多人都願

python中的無參裝飾器和有參裝飾器

tools mysql認證 ati 轉載 lan 單獨 get 原則 url 　　　　　　　　　　　　　　　　　　python中的無參裝飾器和有參裝飾器 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　作者：尹正傑 版權聲明：原創作品，謝絕轉載

設計模式- 結構型模式，裝飾器模式（5）

bject 語法 函數 IT 裝飾 gof body 能夠 color 無論何時我們想對一個對象添加額外的功能，都有下面這些不同的可選方法。? 如果合理，可以直接將功能添加到對象所屬的類（例如，添加一個新的方法）? 使用組合? 使用繼承與繼承相比，通常應該優先選擇組合，因為

flask中權限訪問裝飾器

根據 req map ted split rst ret gpo clas 根據session裏面保存的管理員id查詢出對於的角色，根據角色查詢出權限，根據權限查詢出能夠訪問的路徑 # 權限控制裝飾器def admin_auth(f): @wraps(f) d

Java設計模式（9）----------裝飾器模式

tor 畫框 imp 橋接 好的 找到 strac 想是 bstr 1、介紹 裝飾器模式是一種結構型的設計模式。使用該模式的目的是為了較為靈活的對類進行擴展，而且不影響原來類的結構。有同學說可以通過繼承的方式進行實現啊，沒錯，繼承的確可以實現，但是繼承的成本相對比較高，

設計模式 —— 裝飾器模式（Decorator Pattern）

trac 價格 div desc number one 添加 imp esc 裝飾器模式（Decorator Pattern） 概念 裝飾器模式 允許向一個現有的對象添加新的功能，同時又不改變其結構。裝飾者可以在所委托被裝飾者的行為之前或之後加上自己的行為，以達到特定

Java進階篇設計模式之五-----外觀模式和裝飾器模式

和我 logs 適配器模式 del xtra implement () 實例化 網絡遊戲 前言 在上一篇中我們學習了結構型模式的適配器模式和橋接模式。本篇則來學習下結構型模式的外觀模式和裝飾器模式。 外觀模式 簡介 外觀模式隱藏系統的復雜性，並向客戶端提供了一個客戶端可以