國產龍芯的軟件生態之中.NET不會缺席，畢竟 C# 與 .NetCore/Mono 也是全球幾大主流的編程語言和運行平台之一，最近一段時間聽到太多的鼓吹政務領域不支持.NET， 大家都明白這是某些人為了自己的利益打壓使用.NET技術的公司，我今天寫這篇文章就是想通過龍芯團隊的行動告訴更多人一起來推動.NET技術在中國的發展。希望龍芯廠商、支持龍芯的國產操作系統廠商能高度重視這個問題，主動加入 .Net Core 社區，加入.NET基金會，积極貢獻代碼，儘快做好適配工作。

龍芯團隊一直在做net core的mips64移植工作，2020年6月18日完成了里程碑性的工作，在.NET Core 3.1分支上完成了MIPS64 的移植工作，目前已經在github上開源，開源地址：https://github.com/gsvm/coreclr 。具體說明可以參見 https://github.com/dotnet/runtime/issues/38069。 龍芯團隊正在做移植后的測試工作，已經完成了 9500 多項測試，ASP.NET Core示例程序 FlightFinder 已經可以在MIPS64 上正常運行，具體可以參看 https://github.com/dotnet/runtime/issues/4234。

龍芯團隊還在github上面為龍芯.NET 建立了一個倉庫 https://github.com/gsvm/loongson-dotnet，用於關於龍芯的.NET信息，工作和下載，開源協議採用和.NET Core一樣的MIT協議。 根據這個倉庫的信息，龍芯團隊將在不久的將來發布.NET Core 3.1版本，然後升級到https://github.com/dotnet/runtime ，也就是.NET 5了。目前這項工作正在緊鑼密鼓的進行，非常歡迎大家的積极參与貢獻，包括issue或者PR，如果您有任何問題或需要任何支持，請隨時提交問題或通過电子郵件:aoqi@loongson.cn 與龍芯團隊聯繫。

在文章的最後，我向你分享一個龍芯團隊成員 xiangzhai 在這個 https://github.com/xiangzhai/mono/issues/2 提到了指令集相關的編程的一些相關知識：

OpenJDK、CorelCLR、mono都太大了，比較小的虛擬機例子可以看看PSP模擬器： https://github.com/xiangzhai/ppsspp-jit-mips64/commits/mips64-port-dev

CoreCLR官方的文檔不錯：下降、寄存器分配、代碼生成 https://github.com/dotnet/runtime/blob/master/docs/design/coreclr/jit/ryujit-overview.md

CoreCLR代碼生成常用調試方法： dotnet/runtime#606

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※網頁設計公司推薦不同的風格，搶佔消費者視覺第一線

※Google地圖已可更新顯示潭子電動車充電站設置地點!!

※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益

※別再煩惱如何寫文案,掌握八大原則!

※網頁設計最專業,超強功能平台可客製化

雖然閉包主要是函數式編程的玩意兒，而C#的最主要特徵是面向對象，但是利用委託或lambda表達式，C#也可以寫出具有函數式編程風味的代碼。同樣的，使用委託或者lambda表達式，也可以在C#中使用閉包。

根據WIKI的定義，閉包又稱語法閉包或函數閉包，是在函數式編程語言中實現語法綁定的一種技術。閉包在實現上是一個結構體，它存儲了一個函數（通常是其入口地址）和一個關聯的環境（相當於一個符號查找表）。閉包也可以延遲變量的生存周期。

嗯。。看定義好像有點迷糊，讓我們看看下面的例子吧

    class Program
    {
        static Action CreateGreeting(string message)
        {
            return () => { Console.WriteLine("Hello " + message); };
        }

        static void Main()
        {
            Action action = CreateGreeting("DeathArthas");
            action();
        }
    }

這個例子非常簡單，用lambda表達式創建一個Action對象，之後再調用這個Action對象。
但是仔細觀察會發現，當Action對象被調用的時候，CreateGreeting方法已經返回了，作為它的實參的message應該已經被銷毀了，那麼為什麼我們在調用Action對象的時候，還是能夠得到正確的結果呢？
 
原來奧秘就在於，這裏形成了閉包。雖然CreateGreeting已經返回了，但是它的局部變量被返回的lambda表達式所捕獲，延遲了其生命周期。怎麼樣，這樣再回頭看閉包定義，是不是更清楚了一些？
 
閉包就是這麼簡單，其實我們經常都在使用，只是有時候我們都不自知而已。比如大家肯定都寫過類似下面的代碼。

void AddControlClickLogger(Control control, string message)
{
	control.Click += delegate
	{
		Console.WriteLine("Control clicked: {0}", message);
	}
}

這裏的代碼其實就用了閉包，因為我們可以肯定，在control被點擊的時候，這個message早就超過了它的聲明周期。合理使用閉包，可以確保我們寫出在空間和時間上面解耦的委託。
 
不過在使用閉包的時候，要注意一個陷阱。因為閉包會延遲局部變量的生命周期，在某些情況下程序產生的結果會和預想的不一樣。讓我們看看下面的例子。

    class Program
    {
	static List<Action> CreateActions()
        {
            var result = new List<Action>();
            for(int i = 0; i < 5; i++)
            {
                result.Add(() => Console.WriteLine(i));
            }
            return result;
        }

        static void Main()
        {
            var actions = CreateActions();
            for(int i = 0;i<actions.Count;i++)
            {
                actions[i]();
            }
        }
    }

這個例子也非常簡單，創建一個Action鏈表並依次執行它們。看看結果

相信很多人看到這個結果的表情是這樣的！！難道不應該是0，1，2，3，4嗎？出了什麼問題？

刨根問底，這兒的問題還是出現在閉包的本質上面，作為“閉包延遲了變量的生命周期”這個硬幣的另外一面，是一個變量可能在不經意間被多個閉包所引用。

在這個例子裏面，局部變量i同時被5個閉包引用，這5個閉包共享i，所以最後他們打印出來的值是一樣的，都是i最後退出循環時候的值5。

要想解決這個問題也很簡單，多聲明一個局部變量，讓各個閉包引用自己的局部變量就可以了。

	//其他都保持與之前一致
        static List<Action> CreateActions()
        {
            var result = new List<Action>();
            for (int i = 0; i < 5; i++)
            {
                int temp = i; //添加局部變量
                result.Add(() => Console.WriteLine(temp));
            }
            return result;
        }

這樣各個閉包引用不同的局部變量，剛剛的問題就解決了。

除此之外，還有一個修復的方法，在創建閉包的時候，使用foreach而不是for。至少在C# 7.0 的版本上面，這個問題已經被注意到了，使用foreach的時候編譯器會自動生成代碼繞過這個閉包陷阱。

	//這樣fix也是可以的
        static List<Action> CreateActions()
        {
            var result = new List<Action>();
            foreach (var i in Enumerable.Range(0,5))
            {
                result.Add(() => Console.WriteLine(i));
            }
            return result;
        }

這就是在閉包在C#中的使用和其使用中的一個小陷阱，希望大家能通過老胡的文章了解到這個知識點並且在開發中少走彎路！

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※網頁設計公司推薦不同的風格，搶佔消費者視覺第一線

※想知道購買電動車哪裡補助最多?台中電動車補助資訊懶人包彙整

※南投搬家公司費用,距離,噸數怎麼算?達人教你簡易估價知識!

※教你寫出一流的銷售文案?

※超省錢租車方案

目錄

• 簡介
• 比特幣密碼學的基礎
  • 單向散列函數（hash算法）
  • 非對稱加密算法
  • 擴展閱讀：同態加密
• 密鑰,地址和錢包
• 比特幣中的交易
• 擴展閱讀：圖靈非完備性
• 總結

簡介

錢包在比特幣中是做什麼的呢？比特幣的交易又有什麼特點呢？怎麼才能偽造比特幣的交易呢？今天和大家一起學習一下比特幣中的錢包和交易。

比特幣密碼學的基礎

之前我們提到過比特幣使用的並不是什麼新技術，只是對於老的技術比如：P2P網絡，分佈式系統，密碼學，共識算法的重新而又巧妙的應用。

在錢包和交易生成驗證的過程中，都需要使用到密碼學的計算。這裏我們先介紹一下比特幣中會使用到的幾種密碼學技術。

更多精彩內容且看：

• 區塊鏈從入門到放棄系列教程-涵蓋密碼學,超級賬本,以太坊,Libra,比特幣等持續更新
• Spring Boot 2.X系列教程:七天從無到有掌握Spring Boot-持續更新
• Spring 5.X系列教程:滿足你對Spring5的一切想象-持續更新
• java程序員從小工到專家成神之路（2020版）-持續更新中,附詳細文章教程

單向散列函數（hash算法）

在介紹單向散列函數之前，我們先了解一下什麼情況下需要使用到單向散列函數。

如果你需要從國外的網站上下載一個軟件，但是因為種種原因，國外的網絡太慢了，下載幾個G的數據幾乎是不可能的。剛好國內有鏡像網站，可以從國內下載數據。但是如何保證國內的鏡像不是被篡改過後的呢？這個時候就需要單向散列函數了。一般來說網站會提供MD5或者SHA的值作為驗證值。

單向散列函數有一個輸入和輸出。輸入稱為消息，輸出稱為散列值。

散列值的長度跟消息的長度無關，不論多少大小的長度的消息，都會計算出固定長度的散列值。

hash算法有下面幾個特點：

1. 能夠根據任意長度的消息計算出固定長度的散列值。

2. 計算速度要快。

3. 消息不同，散列值也不同。

   這就意味着，如果僅僅是一點點的變動都會引起整個散列值的巨大變化。

   因為散列值的大小是固定的，所以有可能會出現不同的消息產生相同散列值的情況。這種情況叫做碰撞。

   難以發現碰撞的性質被稱為抗碰撞性。當給定某條消息的散列值時，必須保證很難找到和該消息具有相同散列值的另一條消息。

4. 單向散列函數必須具有單向性。所謂單向性是指無法通過散列值來反推出消息的性質。

比特幣使用的散列算法是SHA256，他是安全散列算法SHA（Secure Hash Algorithm）系列算法的一種（另外還有SHA-1、SHA-224、SHA-384 和 SHA-512 等變體），SHA是美國國家安全局 （NSA） 設計，美國國家標準與技術研究院（NIST） 發布的，主要適用於数字簽名標準（DigitalSignature Standard DSS）裏面定義的数字簽名算法（Digital Signature Algorithm DSA）。

RIPEMD（RACE Integrity Primitives Evaluation Message Digest，RACE原始完整性校驗消息摘要），是Hans Dobbertin等3人在md4,md5的基礎上，於1996年提出來的。

非對稱加密算法

非對稱加密算法也叫公鑰密碼算法，通過生成的公私鑰來對明文密文進行加密解密。

非對稱加密算法需要兩個密鑰：公開密鑰（publickey）和私有密鑰（privatekey）。公開密鑰與私有密鑰是一對，如果用公開密鑰對數據進行加密，只有用對應的私有密鑰才能解密；如果用私有密鑰對數據進行加密，那麼只有用對應的公開密鑰才能解密。因為加密和解密使用的是兩個不同的密鑰，所以這種算法叫作非對稱加密算法。

擴展閱讀：同態加密

同態加密是一種加密形式，它允許人們對密文進行特定的代數運算得到仍然是加密的結果，將其解密所得到的結果與對明文進行同樣的運算結果一樣。換言之，這項技術令人們可以在加密的數據中進行諸如檢索、比較等操作，得出正確的結果，而在整個處理過程中無需對數據進行解密。其意義在於，真正從根本上解決將數據及其操作委託給第三方時的保密問題，例如對於各種雲計算的應用。

密鑰,地址和錢包

比特幣的所有權是通過数字密鑰、比特幣地址和数字簽名來確立的。数字密鑰實際上並不是存儲在網絡中，而是由用戶生成並存儲在一個文件或簡單的數據庫 中，稱為錢包。存儲在用戶錢包中的数字密鑰完全獨立於比特幣協議，可由用戶的錢包軟件生成並管理，而無需區塊鏈或網絡連接。密鑰實現了比特幣的許多有趣特性，包括去中心化信任和控制、所有權認證和基於密碼學證明的安全模型。

比特幣錢包只包含私鑰而不是比特幣。每一個用戶有一個包含多個私鑰的錢包。錢包中包含成對的私鑰和公鑰。用戶用這些私鑰來簽名交易，從而證明它們擁有交易的輸出（也就是其中的比特幣）。比特幣是以交易輸出的形式來儲存在區塊鏈中（通常記為vout或txout）。

如果錢包只包含私鑰，那麼錢包地址是什麼呢？錢包地址是從公鑰的hash值的出來的，如下圖所示：

1. 首先使用隨機數發生器生成一個『私鑰』。一般來說這是一個256bits的數，擁有了這串数字就可以對相應『錢包地址』中的比特幣進行操作，所以必須被安全地保存起來。

2. 『私鑰』經過SECP256K1算法處理生成了『公鑰』。SECP256K1是一種橢圓曲線算法，通過一個已知『私鑰』時可以算得『公鑰』，而『公鑰』已知時卻無法反向計算出『私鑰』。這是保障比特幣安全的算法基礎。

3. 同SHA256一樣，RIPEMD160也是一種Hash算法，由『公鑰』可以計算得到『公鑰哈希』，而反過來是行不通的。

4. 將一個字節的地址版本號連接到『公鑰哈希』頭部（對於比特幣網絡的pubkey地址，這一字節為“0”），然後對其進行兩次SHA256運算，將結果的前4字節作為『公鑰哈希』的校驗值，連接在其尾部。

5. 將上一步結果使用BASE58進行編碼(比特幣定製版本)，就得到了『錢包地址』。 比如,1A1zP1eP5QGefi2DMPTfTL5TTmv7DivfNa。

所以私鑰，公鑰和錢包地址的關係如下圖所示：

大家看到錢包地址1A1zP1eP5QGefi2DMPTfTL5TTmv7DivfNa有什麼想法呢？

肯定有人在想，這麼一大長串字母和数字實在是太不好記憶了。能不能生產一個比較好記的錢包地址呢？ 比如MyNameIsHanMeiMei….這樣開頭的地址呢？

當然可以，這叫做靚號地址，只不過需要大量的算力才行。

比特幣中的交易

簡單來說，交易就是告知全網：比特幣的持有者已授權把比特幣轉帳給其他人。而新持有者能夠再次授權，轉移給該比特幣所有權鏈中的其他人。

注意， 在比特幣的世界里既沒有賬戶，也沒有餘額，只有分散到區塊鏈里的UTXO（Unspent Transaction Outputs）。

怎麼理解這個UTXO呢？沒有賬戶也沒有餘額，那麼錢包裏面的金額是怎麼計算出來的呢？

別急，讓我們一一道來。

話說，在比特幣中，比特幣錢包間的轉賬是通過交易（Transaction）實現的。

我們看一個標準的交易流程。

那麼問題來了，世界上第一個比特幣是哪裡來的呢？

答，是挖礦來的。好了，我們的001交易表示的就是一個挖礦的過程，在這個交易中，輸入就是挖礦，輸出編號1，BTC數目是50，目的地址是A，表示這50個BTC給A了。

接下來，A想發25個BTC給B，怎麼構造這個交易呢？

同樣的，我們需要一個輸入，這個輸入就是001交易的1號輸出，我們用001.1來表示。輸出分為兩個，第一個輸出編號1，表示要付25個BTC給B。第二個輸出編號2，表示剩下的BTC要還給A。

大家可能會問了，輸入是50BTC，兩個輸出加起來才45個BTC，好像還少了5個BTC？沒錯，這個5個BTC就是給礦工的挖礦所得。

接下來，A又繼續轉賬給C，同樣的道理，把一個一個的交易連接起來。

從上面的例子我們可以看到，實際上錢是存在一個一個的交易記錄裏面的，那些未被花費的輸出，就叫做UTXO（Unspent Transaction Outputs）。

那麼怎麼保證轉賬給B的錢，不會被其他的人消費呢？這就涉及到交易的加密過程了。

我們以單個輸入和輸出為例來詳細了解一下交易的構成：

上圖中，交易的輸入就是txid，也就是之前生成的還有未花費暑輸出的交易ID。output index就是交易的輸出id。

一個非常重要的ScriptSig是輸入交易的驗證，表明這個用戶擁有這個賬戶的轉賬權限。

輸出是一個腳本，只有滿足腳本運行條件的人才能花費這個output。這也就是ScriptSig需要驗證的腳本。

我們看下腳本是怎麼做認證的吧。

比特幣的標準輸出形式有兩種。Pay To Public Key Hash (P2PKH) 和 Pay To Script Hash (P2SH)。兩者的區別在於，一個是輸出到public key的hash,一個是輸出到任意的一個腳本輸出hash。

為了保證輸出只能由特定的人來花費，一般的情況下是直接輸出到對方的public key hash。由於只有對方擁有的私鑰能夠生成這個public key hash，也就是說只有對方才能夠對這個輸出進行驗證。

但每次都需要知道對方的public key hash還是比較麻煩的，更簡單的做法就是，發送者直接輸出到一個特定的hash值就行了，只要對方能夠生成這個hash就可以。

下面的例子是一個P2PKH的腳本形式。

P2PKH的輸出是一個腳本，裏面一個重要的值就是PK hash。

怎麼驗證呢？

驗證方提供兩個值，一個是sig，一個是PubKey。因為比特幣的虛擬機是棧結構的，我們先把這兩個值入棧。

然後調用OP_DUP對最上層的PubKey進行拷貝，然後調用OP_HASH160算法來計算Pk Hash，然後將發送方保存的Pk Hash入棧。接下來調用OP_EQUALVERIFY對兩個PK Hash進行對比。

如果對比成功，最後一步就是驗證Sig和PubKey是否匹配。

如果都成功，說明接收方的確是這個PK Hash的擁有者。那麼對方就可以盡情使用了。

擴展閱讀：圖靈非完備性

和馮·諾伊曼同為現代計算機奠基人的阿蘭·圖靈（AlanTurin）在1950年提出了判定計算機能否像人那般實際“思考”的標準，也就是著名的“圖靈檢驗”。

他設想一台超級計算機和一個人躲藏在幕後回答提問者的問題，而提問者則試圖分辨哪個是人哪個是計算機。

圖靈爭辯說，假如計算機偽裝得如此巧妙，以致沒有人可以在實際上把它和一個真人分辨開來的話，那麼我們就可以聲稱，這台計算機和人一樣具備了思考能力，或者說，意識（他的原詞是“智慧”）。

在可計算性理論里，如果一系列操作數據的規則（如指令集、編程語言、細胞自動機）按照一定的順序可以計算出結果，被稱為圖靈完備（turing complete）。

比特幣腳本語言不是圖靈完備的，具有一定的局限性，它沒有循環語句和複雜的條件控制語句。

總結

本文介紹了比特幣的錢包和交易的概念，希望大家能夠喜歡。

本文作者：flydean程序那些事

本文鏈接：http://www.flydean.com/bitcoin-transactions/

本文來源：flydean的博客

歡迎關注我的公眾號:程序那些事，更多精彩等着您！

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※網頁設計公司推薦不同的風格，搶佔消費者視覺第一線

※想知道購買電動車哪裡補助最多?台中電動車補助資訊懶人包彙整

※南投搬家公司費用,距離,噸數怎麼算?達人教你簡易估價知識!

※教你寫出一流的銷售文案?

※超省錢租車方案

1、Aop 全程是Aspect Oriented Programming 即面向切面編程，通過預編譯方式和運行期動態代理實現程序功能的同一維護的一種技術。Aop是oop的延續，是軟件開發中的 一個熱點，也是Spring框架中一個重要的內容。是函數式編程的一個衍生範例，利用Aop可以對業務邏輯各個部分進行分割，從而使得業務邏輯各部分之間的耦合度降低，提高程序的可重用行，提高了開發效率。簡單的說就是把我們程序中的重複代碼抽取出來，在需要執行的時候，使用動態代理的技術，在不修改源碼的基礎上已有的方法進行增強，（使用動態代理的方式實現）

相關術語

JoinPoint：鏈接點 那些被攔截到的點，在spring中，這些點指的是方法，因為spring只支持方法類型的連接點

Pointcut：切入點   是指我們要對哪些JoinPont進行攔截的定義

Advice：通知/增強  攔截到Joinpoint之後所要做的事情就是通知

通知類型：前置通知、後置通知、異常通知、最終通知、環繞通知

Introduction：引介   是一種特殊的通知，在不修改類代碼的前提下，Introduction可以在運行期為類動態的添加一些方法或field

Target：目標對象，代理的目標對象

Weaving 織入   是指把增強應用到目標對象來創建新的代理對象的過程，spring採用動態代理織入，而AspectJ採用編譯期織入和類裝載期織入

Proxy：代理，一類類被Aop織入增強后，就產生一個結果代理類

Aspect：切面   是切入點和通知（引介）的結合

在 spring 中，框架會根據目標類是否實現了接口來決定採用哪種動態代理的方式。

基於XMl的AOP步驟

1、創建Maven項目引入spring坐標

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.mingqi</groupId>
    <artifactId>SpringIOC</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.7</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

2、創建業務層接口：

package com.mingqi.services;
public interface IAccountService {
    /**
     * 模擬登陸賬戶
     */
    void saveAccount();

    /**
     * 模擬更新賬戶
     * @param id
     */
    void updateAccount(int id);

    /**
     * 模擬刪除賬戶
     * @return
     */
    int deleteAccount();

}

3.創建業務層實現類

package com.mingqi.services.impl;
import com.mingqi.services.IAccountService;
public class AccountServicesImpl implements IAccountService {
    public void saveAccount() {
        System.out.println("執行了保存");
    }

    public void updateAccount(int id) {
        System.out.println("執行了更新"+id);
    }

    public int deleteAccount() {
        System.out.println("執行了刪除");
        return 0;
    }
}

4、創建工具類

package com.mingqi.utils;
import org.aspectj.lang.ProceedingJoinPoint;
/**
 * 用戶記錄日誌的工具類，裏面提供公共的代碼
 */
public class Logger {
    /**
     * 用於打印日誌：計劃讓其在切入點方法執行前執行（切入點方法就是業務層方法）
     */
    public  void beforePrintLog(){
        System.out.println("Logger類中的pringLog方法開始記錄日誌了。。。");
    }
    public  void afterReturningPrintLog()
    {
        System.out.println("後置通知Logger類中的beforePrintLog方法開始記錄日誌了。。。");
    }
    /**
     * 異常通知
     */
    public void afterThrowingPrintLog()
    {
        System.out.println("異常通知Logger類中的afterThrowingPrintLog方法開始記錄日誌了。。。");

    }
    /**
     * 最終通知
     */
    public void afterPrintLog()
    {
        System.out.println("最終通知Logger類中的afterPrintLog方法開始記錄日誌了。。。");
    }

    /**
     * 環繞通知
     * 問題  當我們配置了環繞通知以後，切入點方法沒有執行，而通知方法執行了
     * 分析： 通過對比動態代理中的環繞通知代碼，發現動態代理中的環繞通知有明確的切入點方法調用，而我們的代碼中沒有
     * 解決： Spring 框架為我們提供了一個接口：ProceedingJoinPoint。該接口有一個方法proceed（），此方法就相當於明確調用切入點的方法
     *        該接口可以作為環繞通知的參數方法，在程序執行時，spring框架會為我們提供該接口的實現類供我們使用
     * spring中的環繞通知
     *      他是spring框架為我們提供的一種可以在代碼中手動控制增強方法何時會執行的方式
     * @param pjp
     * @return
     */
    public Object aroundPringLog(ProceedingJoinPoint pjp){
        Object rtValue = null;
        try{
            Object[] args = pjp.getArgs();//得到方法執行所需的參數

            System.out.println("Logger類中的aroundPringLog方法開始記錄日誌了。。。前置");

            rtValue = pjp.proceed(args);//明確調用業務層方法（切入點方法）

            System.out.println("Logger類中的aroundPringLog方法開始記錄日誌了。。。後置");

            return rtValue;
        }catch (Throwable t){
            System.out.println("Logger類中的aroundPringLog方法開始記錄日誌了。。。異常");
            throw new RuntimeException(t);
        }finally {
            System.out.println("Logger類中的aroundPringLog方法開始記錄日誌了。。。最終");
        }
    }
}

4、創建bean配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
       <!-- 配置spring的IOC，把service對象配置進來-->
       <bean id="accountSevice" class="com.mingqi.services.impl.AccountServicesImpl"></bean>
       <!-- spring 中基於xml的Aop配置步驟
         1、把通知Bean也交給spring來管理
         2、使用aop：config標籤表名開始aop的配置
         3、使用aop:aspect標籤表明配置切面
             id屬性：是給切面提供一個唯一標識
             ref屬性：是指定通知類的id
         4、在aop:aspect標籤的內部使用對應的標籤來配置通知的類型
             我們現在的示例是讓printlog方法在切入點方法執行之前執行，所以是前置通知
             aop:before:標識前置通知
                method屬性： 用於指定Logger類中的方法哪個是前置通知
                pointcut屬性： 用於指定切入點表達式，該表達式的含義指的是對業務層中的哪些方法增強
                切入點表達式的寫法：
                   關鍵字：execution（表達式）
                   表達式：  訪問修飾符 返回值 包名.包名.包名....類名.方法名(參數列表)
                   標準的寫法： public void com.mingqi.service.impl.AccountServiceImpl.saveAccount()
                   訪問修飾符可以省略：void com.mingqi.service.impl.AccountServiceImpl.saveAccount()
                   返回值可以使用通配符，標識任意返回值：* com.mingqi.service.impl.AccountServiceImpl.saveAccount()
                   包名可以使用通配符，表示任意包，但是有幾級包就需要寫幾個*  *.*.*.*.*.AccountServiceImpl.saveAccount()
                   包名可以使用..代表當前包及其子包：* *.AccountServiceImpl.saveAccount()
                   類名和方法名都可以使用*來實現統配 * *..*.*();
                   參數列表： 可以直接寫數據類型:
                                 基本類型直接寫名稱：int
                                 引用類型寫包名.類名的方式： java.lang.String
                                可以使用通配符來標識任意類型，單必須有參數
                                可以使用..標識有無參數均可，有參數可以是任意類型

                      全通配寫法：
                    * *..*.*(..)
                   實際開發中 切入點表達式的通常寫法：
                          切到業務層實現類的所有方法，* com.mingqi.service.impl.*.*(..);
         -->
       <!-- 配置Logger類-->
       <bean id="logger" class="com.mingqi.utils.Logger"></bean>
       <!--使用aop：config標籤表名開始aop的配置-->
       <aop:config>
              <aop:pointcut id="pt1" expression="execution(* com.mingqi.services.impl.*.*(..))"></aop:pointcut>
              <!--使用aop:aspect標籤表明配置切面-->
              <aop:aspect id="LogAdvice" ref="logger">
                     <!-- 配置前置通知：在切入點方法執行之前執行
                     <aop:before method="beforePrintLog" pointcut-ref="pt1"></aop:before>-->

                     <!-- 配置後置通知：在切入點方法正常執行之後值。它和異常通知永遠只能執行一個
                          <aop:after-returning method="afterReturningPrintLog" pointcut-ref="pt1"></aop:after-returning>-->
                     <!-- 配置異常通知：在切入點方法執行產生異常之後執行。它和後置通知永遠只能執行一個
                         <aop:after-throwing method="afterThrowingPrintLog" pointcut-ref="pt1"></aop:after-throwing>-->
                     <!-- 配置最終通知：無論切入點方法是否正常執行它都會在其後面執行
                        <aop:after method="afterPrintLog" pointcut-ref="pt1"></aop:after>-->
                     <!-- 配置環繞通知 詳細的註釋請看Logger類中-->
                        <aop:around method="aroundPringLog" pointcut-ref="pt1"></aop:around>
                    </aop:aspect>
             </aop:config>
       </beans>

6、創建測試類

package com.mingqi.test;
import com.mingqi.services.IAccountService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class SpringIoc {
    @Test
    public void TestAccount()
    {
        ApplicationContext ac= new ClassPathXmlApplicationContext("beam.xml");
        IAccountService accountService=(IAccountService) ac.getBean("accountSevice");
        accountService.saveAccount();
        accountService.updateAccount(22);
        accountService.deleteAccount();
    }
}

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※網頁設計一頭霧水該從何著手呢? 台北網頁設計公司幫您輕鬆架站!

※網頁設計公司推薦不同的風格，搶佔消費者視覺第一線

※Google地圖已可更新顯示潭子電動車充電站設置地點!!

※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益

※別再煩惱如何寫文案,掌握八大原則!

※網頁設計最專業,超強功能平台可客製化

前言

最近在做項目過程中使用到了如題并行方法，當時還是有點猶豫不決，因為平常使用不多， 於是藉助周末時間稍微深入了下，發現我用錯了，故此做一詳細記錄，希望對也不是很了解的童鞋在看到此文後不要再犯和我同樣的錯誤。

并行遍歷異步表象

這裏我們就不再講解該語法的作用以及和正常遍歷處理的區別，網上文章比比皆是，我們直接進入主題，本文所演示程序在控制台中進行。可能大部分童鞋都是如下大概這樣用的

Parallel.ForEach(Enumerable.Range(0, 10), index =>
{
    Console.WriteLine(index);
});

我們採取并行方式遍歷10個元素，然後結果也隨機打印出10個元素，一點毛病也沒有。然而我是用的異步方式，如下：

Parallel.ForEach(Enumerable.Range(0, 10), async index =>
{
    await AsyncTask(index);
});

static async Task<int> AsyncTask(int i)
{
    await Task.Delay(100);
    
    var calculate = i * 2;
    
    Console.WriteLine(calculate);

    return calculate;
}

我們只是將并行操作更改為了異步形式，然後對每個元素進行對應處理，打印無序結果，一切也是如我們所期望，接下來我再來看一個例子，經過并行異步處理后猜猜最終字典中元素個數可能或一定為多少呢？

var dicts = new ConcurrentDictionary<string, int>();

Parallel.ForEach(Enumerable.Range(0, 10), async index =>
{
    var result = await AsyncTask(index);

    dicts.TryAdd(index.ToString(), result);
});

Console.WriteLine($"element count in dictionary {dicts.Count}");

如果對該并行方法沒有深入了解的話，大概率都會猜錯，我們看到字典中元素為0，主要原因是用了異步后引起的，為何會這樣呢？我們首先從表象上來分析，當我們在控制台上對并行方法用了異步后，你會發現編譯器會告警（主函數入口已用異步標識），如下：

接下來我們再來看看調用該并行異步方法的最終調用構造，如下：

public static ParallelLoopResult ForEach<TSource>(IEnumerable<TSource> source, Action<TSource> body);

第二個參數為內置委託Action，所以我們也可以看出並不能用於異步，因為要是異步至少也是Func<Task>，比如如下方法參數形式

static async Task AsyncDemo(Func<int,Task> func)
{
    await func(1);
}

并行遍歷異步本質

通過如上表象的分析我們得出并行遍歷方法應該是並不支持異步（通過最終結果分析得知，表述為不能用於異步更恰當），但是在實際項目開發中我們若沒有注意到該方法的構造很容易就會誤以為支持異步，如我一樣寫完也沒報錯，也就草草了事。那麼接下來我們反編譯看下最終實際情況會是怎樣的呢。

進入主函數，我們已將主函數進行異步標識，所以將主函數放在狀態機中執行（狀態機類，<Main>d_0），這點我們毫無保留的贊同，接下來實例化字典，並通過并行遍歷異步處理元素集合併將其結果嘗試放入到字典中

由上我們可以看到主函數是在狀態機中運行且構造為AsyncTaskMethodBuilder，當我們通過并行遍歷異步處理時每次都會實例化一個狀態機類即如上<<Main>b__0>d，但我們發現此狀態機的構造是AsyncVoidMethodBuilder，利用此狀態機類來異步處理每一個元素，如下

最終調用AsyncTask異步方法，這裏我就不再截圖，同樣也是生成一個此異步方法的狀態機類。稍加分析想必我們已經知曉結果，AsyncTaskMethodBuilder指的就是（async task），而AsyncVoidMethodBuilder指的是（async void），所以對并行遍歷異步操作是將其隱式轉換為async void，而不是async task，這也和我們從其構造為Action得出的結論一致，我們知道（async void）僅限於基於事件的處理程序（常見於客戶端應用程序），其他情況避免用async void，也就是說將返回值放在Task或Task<T>中。當并行執行任務時，由於返回值為void，不會等待操作完成，這也就不難解釋為何字典中元素個數為0。

總結

當時並沒有過多的去了解，只是想當然的認為用了異步也沒出現編譯報錯，但是又由於沒怎麼用過，我還是抱着懷疑的態度，於是再深究了下，發現用法是大錯特錯。通過構造僅接受為Action委託，這也就意味着根本無法等待異步操作完成，之所以能接受異步索引其本質是隱式轉換為（async void），從另外一個角度看，異步主要用於IO密集型，而并行處理用於CPU密集型計算，基於此上種種一定不能用於異步，否則結果你懂的。

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※網頁設計公司推薦不同的風格，搶佔消費者視覺第一線

※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益

※自行創業缺乏曝光? 網頁設計幫您第一時間規劃公司的形象門面

※南投搬家公司費用需注意的眉眉角角，別等搬了再說!

※教你寫出一流的銷售文案?