標籤: USB CONNECTOR 

對 JsonConvert 的認識太膚淺了，終於還是遇到了問題

admin

一：背景

1. 講故事

在開始本文之前，真的好想做個問卷調查，到底有多少人和我一樣，對 JsonConvert 的認識只局限在 SerializeObject 和 DeserializeObject 這兩個方法上(┬＿┬), 這樣我也好結伴同行，不再孤單落魄，或許是這兩個方法基本上能夠解決工作中 80% 的場景，對於我來說確實是這樣，但隨着編碼的延續，終究還是會遇到那剩下的 20% ，所以呀。。。

我的場景是這樣的：前段時間寫業務代碼的時候，我有一個自定義的客戶算法類型的Model，這個Model中有這種算法類型下的客戶群以及Report統計信息，還用了 HashSet 記錄了該類型下的 CustomerID集合，為了方便講述，我把Model簡化如下：


    class CustomerAlgorithmModel
    {
        public string DisplayName { get; set; }

        public int CustomerType { get; set; }

        public ReprotModel Report { get; set; }

        public HashSet<int> CustomerIDHash { get; set; }
    }

    class ReprotModel
    {
        public int TotalCustomerCount { get; set; }

        public int TotalTradeCount { get; set; }
    }

那有意思的就來了，我個人是有記日誌的癖好，就想着以後不會出現死無對證的情況，然後就理所當然的使用 JsonConvert.SerializeObject, 這一下就出問題了，日誌送入到了 ElasticSearch ，然後通過 Kibana 查不出來，為啥呢？ 看完上面的 Model 我想你也猜到了原因，json體太大了哈，好歹 CustomerIDHash 中也有幾十萬個撒，這一下全導出成json了，這 size 還能小嗎？ 要不我寫段代碼看一看。


        static void Main(string[] args)
        {
            var algorithModel = new CustomerAlgorithmModel()
            {
                CustomerType = 1,
                DisplayName = "",
                Report = new ReprotModel()
                {
                    TotalCustomerCount = 1000,
                    TotalTradeCount = 50
                },
                CustomerIDHash = new HashSet<int>(Enumerable.Range(1, 500000))
            };

            var json = JsonConvert.SerializeObject(algorithModel);

            File.WriteAllText("1.txt", json, Encoding.UTF8);

            Console.WriteLine("寫入完成！");
        }

可以看到，僅一個json就 3.3M，這樣的記錄多來幾打后，在 kibana 上一檢索，瀏覽器就卡的要死，其實 CustomerIDHash 這個字段對我來說是可有可無的，就算存下來了也沒啥大用，所以需求就來了，如何屏蔽掉 CustomerIDHash。

二：尋求解決方案

1. 使用 JsonIgnore

有問題就網上搜啊，這一搜馬上就有人告訴你可以使用 JsonIgnoreAttribute 忽略特性，加好這個特性後繼續跑一下程序。


    [Newtonsoft.Json.JsonIgnore]
    public HashSet<int> CustomerIDHash { get; set; }

太好了，終於搞定了，但是靜下心來想一想，總感覺心裏有那麼一點不舒服，為什麼這麼說，一旦你給這個 CustomerIDHash 套上了 JsonIgnore ，這就意味着它在 JsonConvet 的世界中從此消失，也不管是誰在使用這個Model， 但這並不是我的初衷，我的初衷僅僅是為了在記錄日誌的時候踢掉 CustomerIDHash，可千萬不要影響在其他場景下的使用哈，現在這種做法就會給自己，給別人挖坑，埋下了不可預知的bug，我想你應該明白我的意思，還得繼續尋找下一個方案。

2. 使用自定義的 JsonConverter

真的，Newtonsoft 太強大了，我都想寫一個專題好好彌補彌補我的知識盲區，其實在這個場景中不就是想把 HashSet<int> 給屏蔽掉嘛，Newtonsoft 中專門提供了一個針對特定類型的自定義處理類，接下來我就寫一段：


   /// <summary>
   /// 自定義一個 針對 HashSet<int> 的轉換類
   /// </summary>
   public class HashSetConverter : Newtonsoft.Json.JsonConverter<HashSet<int>>
   {
       public override HashSet<int> ReadJson(JsonReader reader, Type objectType, HashSet<int> existingValue, bool hasExistingValue, JsonSerializer serializer)
       {
           return existingValue;
       }

       public override void WriteJson(JsonWriter writer, HashSet<int> value, JsonSerializer serializer)
       {
           writer.WriteNull();
       }
   }

就是這麼簡單，然後就可以在 SerializeObject 的時候指定下自定義的 HashSetConverter 即可，然後再將程序跑起來看一下。


 var json = JsonConvert.SerializeObject(algorithModel, Formatting.Indented, new HashSetConverter());

從圖中看，貌似也是解決了，但我突然發現自己要鑽牛角尖了，如果我的實體中又來了一個頂級優質客戶群的 TopNCustomerIDHash，但因為這個CustomerID 比較少，我希望在 Json 中能保留下來，然後就是踢掉的那個 CustomerIDHash 我要保留 CustomerIDHash.Length ，哈哈，搞事情哈，那接下來怎麼解決呢？

  • 修改 Model 實體

    class CustomerAlgorithmModel
    {
        public HashSet<int> CustomerIDHash { get; set; }

        // topN 優質客戶群
        public HashSet<int> TopNCustomerIDHash { get; set; }
    }
  • HashSetConverter 增加邏輯鑒別是否為保留字段

        public override void WriteJson(JsonWriter writer, HashSet<int> value, JsonSerializer serializer)
        {
            if (writer.Path == "TopNCustomerIDHash")
            {
                writer.WriteStartArray();

                foreach (var item in value)
                {
                    writer.WriteValue(item);
                }

                writer.WriteEndArray();
            }
            else
            {
                writer.WriteValue(value.Count);
            }
        }
  • 最後給 TopNCustomerIDHash 賦值

            var algorithModel = new CustomerAlgorithmModel()
            {
                CustomerType = 1,
                DisplayName = "",
                Report = new ReprotModel()
                {
                    TotalCustomerCount = 1000,
                    TotalTradeCount = 50
                },
                CustomerIDHash = new HashSet<int>(Enumerable.Range(1, 500000)),
                TopNCustomerIDHash = new HashSet<int>(Enumerable.Range(1, 10)),
            };

三塊都搞定后就可以把程序跑起來了，如下圖：

貌似鑽牛角尖的問題是解決了，既然鑽牛角尖肯定要各種鄙視，比如這裏的 ReportModel 我是不需要的，CustomerType 我也是不需要的，我僅僅需要看一下 DisplayName 和 TotalCustomerCount 這兩個字段就可以了， 那這個要怎麼解決呢？

3. 使用 匿名類型

確實很多時候記日誌，就是為了跟蹤 Model 中你特別關心的那幾個字段，所以摻雜了多餘的字段確實也是沒必要的，這裏可以用匿名來解決，我就來寫一段代碼：


    var json = JsonConvert.SerializeObject(new
    {
        algorithModel.DisplayName,
        algorithModel.Report.TotalCustomerCount
    }, Formatting.Indented);

三： 總結

雖然阻擊了幾個回合，但同時也發現了 Newtonsoft 中還有特別多的未挖掘功能，真的需要好好研究研究，源碼已下好，接下來準備做個系列來解剖一下，值得一提的是 .Net中已自帶了 System.Text.Json.JsonSerializer 類，目前來看功能還不算太豐富，簡單用用還是可以的，本篇就說到這裏，希望對您有幫助。

如您有更多問題與我互動，掃描下方進來吧~

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

【其他文章推薦】

※USB CONNECTOR掌控什麼技術要點? 帶您認識其相關發展及效能

※台北網頁設計公司這麼多該如何選擇?

※智慧手機時代的來臨，RWD網頁設計為架站首選

※評比南投搬家公司費用收費行情懶人包大公開

※回頭車貨運收費標準

※聚甘新

深入理解 EF Core：EF Core 寫入數據時發生了什麼？

admin

閱讀本文大概需要 14 分鐘。

原文：https://bit.ly/2C67m1C
作者：Jon P Smith
翻譯：王亮
聲明：我翻譯技術文章不是逐句翻譯的，而是根據我自己的理解來表述的。其中可能會去除一些本人實在不知道如何組織但又不影響理解的句子。

這是深入理解 EF Core 系列的第二篇文章。第一篇是關於 EF Core 如何從數據庫讀取數據的；而這一篇是關於 EF Core 如何向數據庫寫入數據的。這是四種數據庫操作 CRUD（新增、讀取、更新和刪除）中的 CUD 部分。

我假設你對 EF Core 已經有了一定的認識，但在深入學習之前，我們先來了解一下如何使用 EF Core，以確保我們已經掌握了一些基本知識。這是一個“深入研究”的課題，所以我準備大量的技術細節，希望我的描述方式你能理解。

本文是“深入理解 EF Core”系列中的第二篇。以下是本系列文章列表：

  • 深入理解 EF Core：當 EF Core 從數據庫讀取數據時發生了什麼？
  • 深入理解 EF Core：當 EF Core 寫入數據到數據庫時發生了什麼？（本文）
  • 深入理解 EF Core：使用查詢過濾器軟刪除數據（敬請期待）

概要

∮. EF Core 可以通過新的或已存在的關聯關係創建一個新的實體。為此，它必須以正確的順序來組織實體類，以便能夠建立各類之間的關聯。這使得開發人員很容易寫出具有複雜關聯關係的類。

∮. 當你調用 EF Core 的 Add 命令來添加一個新條目時，會發生很多事情：

  • EF Core 查找添加的類和其他類的所有關聯。對於每個關聯的類，它也會判斷是否需要在數據庫中創建一個新行，或者僅僅鏈接到數據庫中現有的行。
  • 它使用現有行的主鍵或偽主鍵為新添加的條目填充外鍵信息。

∮. EF Core 可以監測你從數據庫讀取的類的屬性的變化。它通過已讀入的類的隱藏副本來實現這一點。當你調用 SaveChanges 時，它會將每個讀入的屬性值與其原始值進行比較，並且會創建相應的數據更新命令。

∮. EF Core 的 Remove 方法將刪除參數提供的實體類的主鍵所指向的數據行。如果被刪除的類有外鍵關聯，那麼數據庫會自動進行相關的操作（比如級聯刪除），但你可以更改刪除的規則。

數據寫入基礎

提示：如果你已經對 EF Core 有一定的了解，那麼你可以跳過這一部分，這隻是一個簡單的 EF Core 寫入數據的例子。

在這一節的介紹中，我將描述一下本文用到的數據庫結構，然後給出一個簡單的數據庫寫入示例。下面是類/表的基本關係圖：

這些表被映射到具有類似名稱的類，例如 Book、BookAuthor、Author，這些類的屬性名稱與表的字段名稱相同。由於篇幅有限，我不打算展開來講這些類，但您可以在我的 GitHub 倉庫[1]中查看這些類。

和讀取數據一樣，EF Core 將數據寫入數據庫也是五部分：

  1. 數據庫服務器，如 SQL server, Sqlite, PostgreSQL…
  2. 映射到數據庫的一個類或多個類—我將它們稱為實體類
  3. 一個繼承 EF Core 的 DbContext 的類，該類包含 EF Core 的配置
  4. 一個創建數據庫的方法
  5. 最後，向數據庫寫入數據的命令

下面的單元測試代碼來自我的 GitHub 創庫[2]，展示了一個簡單的示例，它從現有數據庫中讀取 4 個 Book 實體及其關聯的 BookAuthor 和 Authors 實體。

[Fact]
public void TestWriteTestDataSqliteInMemoryOk()
{
    //SETUP
    var options = SqliteInMemory.CreateOptions<EfCoreContext>();
    using (var context = new EfCoreContext(options))
    {
        context.Database.EnsureCreated();

        //ATTEMPT
        var book = new Book
        {
            Title = "Test",
            Reviews = new List<Review>()
        };
        book.Reviews.Add(new Review { NumStars = 5 });
        context.Add(book);
        context.SaveChanges();

        //VERIFY
        var bookWithReview = context.Books
            .Include(x => x.Reviews).Single()
        bookWithReview.Reviews.Count.ShouldEqual(1);
    }
}

現在，如果我們將單元測試代碼對應到上面的 5 部分，結果是這樣的：

  1. 數據庫服務器——第 5 行：我選擇了一個 Sqlite 數據庫服務器，在本例中是 SqliteInMemory.CreateOptions 方法，它使用我的一個 NuGet 包 EfCore.TestSupport 創建了一個內存數據庫（內存中的數據庫對於單元測試非常有用，因為你可以為這個測試建立一個新的空數據庫）。
  2. 實體類——和上一篇結構差不多，但是多了一個與 Book 關聯的 Review 實體類。
  3. 一個繼承 DbContext 的類——第 6 行：EfCoreContext 類繼承了 DbContext 類並配置了從類到數據庫的映射關係（你可以在我的 GitHub 倉庫[3] 中查看該類）。
  4. 一個創建數據庫的方法——第 8 行：第一次執行時，這句代碼會創建一個新的數據庫，包括創建正確的表、鍵、索引等。EnsureCreated 方法用於單元測試，但對於真實的應用程序，你最好手動執行 EF Core 的 Migration 命令。
  5. 向數據庫寫入數據的命令——第 17 到 18 行：
    • 第 17 行：Add 方法告訴 EF Core 需要將一個 Book 實體及其關係(在本例中，只是一個 Review 實體)寫入數據庫。
    • 第 18 行：SaveChange 方法將在數據庫中的 Books 和 Reviews 表中創建新行。

在 //VERIFY 註釋之後的最後幾行用來檢查數據是否已經被寫入數據庫。

在本例中，你向數據庫添加了新的記錄（SQL 的 INSERT INTO 命令）。EF Core 也可以處理更新和刪除數據庫的數據，下一節介紹這個新增示例，然後介紹其他新增、更新和刪除的示例。

寫入數據時數據庫端發生了什麼

我將從創建一個新的 Book 實體類和新的 Review 實體類開始。這兩個類的關係比較簡單。使用上面單元測試的例子，主要代碼如下：

var book = new Book
{
    Title = "Test",
    Reviews = new List<Review>()
};
book.Reviews.Add(new Review { NumStars = 1 });
context.Add(book);
context.SaveChanges();

為了將這兩個實體添加到數據庫，EF Core 需要這樣做：

  1. 確定它應該以什麼順序創建這些新行——在本例中，它必須在 Books 表中創建一行，這樣它就擁有 Books 的主鍵。
  2. 將主鍵複製到與其關聯的外鍵——在本例中，它將 Books 中的主鍵 BookId 複製到 Review 的外鍵。
  3. 複製數據庫中新創建的數據，以便實體類正確表示數據庫的數據——在這種情況下，它必須複製 BookId 並更新 BookId 屬性，包括 Book 和 Review 實體類以及 Review 實體類的 ReviewId。

下面我們看看上面代碼生成的 SQL 語句：

-- 第一次訪問數據庫
SET NOCOUNT ON;
-- 向數據庫的 Books 表生成一條新數據.
-- 數據庫生成 Books 的主鍵值
INSERT INTO [Books] ([Description], [Title], ...)
VALUES (@p0, @p1, @p2, @p3, @p4, @p5, @p6);

-- 返回主鍵值，檢查並確認數據行是否已添加
SELECT [BookId] FROM [Books]
WHERE @@ROWCOUNT = 1 AND [BookId] = scope_identity();

-- 第二次訪問數據庫
SET NOCOUNT ON;
-- 向數據庫的 Review 表生成一條新數據.
-- 數據庫生成 Review 的主鍵值
INSERT INTO [Review] ([BookId], [Comment], ...)
VALUES (@p7, @p8, @p9, @p10);

-- 返回主鍵值，檢查並確認數據行是否已添加
SELECT [ReviewId] FROM [Review]
WHERE @@ROWCOUNT = 1 AND [ReviewId] = scope_identity();

重要的一點是，EF Core 是按正確的順序處理實體類的，這樣它就可以填充外鍵。這是簡單的例子，但我遇到一個客戶項目的例子是，我不得不建立一個非常複雜的數據組成的 15 個不同的實體類，一些實體類是新增，一些是更新和刪除，EF Core 通過一個 SaveChanges 將把所有工作有序地完成了庫。因此，EF Core 使開發者可以很容易地將複雜的數據寫入數據庫。

我之所以提到這一點，是因為我看到過在 EF Core 代碼中，開發人員多次調用 SaveChanges 方法來從第一個新增命令中獲得主鍵，並把它設置為相關實體的外鍵。例如：

var book = new Book
{
    Title = "Test"
};
context.Add(book);
context.SaveChanges();
var review = new Review { BookId = book.BookId, NumStars = 1 }
context.Add(review);
context.SaveChanges();

雖然這代碼效果是一樣的，但它有一個缺陷——如果第二 SaveChanges 失敗，那麼就會發生部分數據更新到數據庫的情況。在某種情況下，這可能不是個問題，但對於像我客戶那種需要保證數據一致的情況，就非常糟糕了。

因此，從中得到的收穫是，您不需要將主鍵複製到外鍵中，因為你可以設置導航屬性，EF Core 將為您挑選出外鍵。因此，如果你認為需要調用兩次 SaveChanges，那麼通常意味着你沒有設置正確的導航屬性來處理這種情況。

寫數據時 DbContext 做了什麼

在上一節中，你看到了 EF Core 在數據庫端做了什麼，現在你要看看在 EF Core 中發生了什麼。大多數情況，你不需要知道，但有時候知道這些是非常重要的。例如，你只能在 SaveChanges 之前捕獲數據的狀態。而對於自增主鍵，你只有在 SaveChanges 被調用之後才能拿到主鍵的值。

與上一個示例相比，這個示例稍微複雜一些。在這個示例中，我想向你展示 EF Core 通過從數據庫中讀取的已有實體類的實例來處理另一個實體類的新實例。下面的代碼創建了一個新的 Book，但 Author 已經在數據庫中了。代碼註明了階段 1、階段 2 和階段 3，然後我用圖表描述每個階段發生的事情。

// 階段 1
var author = context.Authors.First();
var bookAuthor = new BookAuthor { Author = author };
var book = new Book
{
    Title = "Test Book",
    AuthorsLink = new List<BookAuthor> { bookAuthor }
};

// 階段 2
context.Add(book);

// 階段 3
context.SaveChanges();

接下來的三個圖向你展示了實體類及其跟蹤數據在每個階段內發生的事情。每個圖显示了其階段結束時的以下數據：

  • 流程的每個階段中每個實例的狀態。
  • Book 和 BookAuthor 類是棕色的，表示它們是類的新實例，需要添加到數據庫中，而 Author 實體類是藍色的，表示從數據庫中讀取的實例。
  • 主鍵和外鍵旁邊的括號是其當前的值。如果一個鍵是 (0)，那麼它還沒有被設值。
  • 箭頭連線連接的是從導航屬性到其相應實體類。
  • 每個階段之間的變化通過粗體文本或箭頭連線的粗線显示。

下圖显示了階段 1 完成后的情況。用於設置一個新的 Book 實體類(左)和一個新的 BookAuthor 實體類(中)，後者將 Book 連接接到一個現有的 Author 實體類(右)。

階段 1 這是調用任何 EF Core 方法之前的起點。

下一個圖显示了執行 context.Add(book) 之後的情況。更改部分以粗體显示。

你可能會驚訝於執行 Add 方法時所發生的事情。它將作為參數提供的實體的狀態設置為 Added（在本例中為 Book 實體）。然後通過導航屬性或外鍵值查看與該實體連接的所有實體。對於每個被連接的實體，它會執行以下操作（注意：我不知道它們執行的確切順序）。

  • 如果實體未被跟蹤（即其當前狀態為 Detached），則將其狀態設置為 Added——在本例中，它是 BookAuthor 實體。
  • 它用主鍵的值填充正確的外鍵的值。如果連接的主鍵還不可用，它將為跟蹤的主鍵和外鍵數據的 CurrentValue 屬性設置一個惟一的負數。你可以在上圖中看到這一點。
  • 它填充當前未設值的導航屬性——如上圖中所示。

最後一個階段，即階段 3，是調用 SaveChanges 方法時發生的情況，如圖所示。

在“寫數據時數據庫端發生了什麼”一節中，數據庫更改的任何列都被複制回實體類中，以便實體與數據庫匹配。在本例中，數據更新到數據庫時會把主鍵值更新到 Book 的 BookId 和 BookAuthor 的 BookId。
而且，此次數據庫寫入完成后，涉及的所有實體的狀態都會被更新為 Unchanged。

對於上面這樣一個很長的解釋，很多時候你不需要知道這些細節，你只管它“工作了”就行。但是，當某些東西不能正常工作或者想做一些複雜的事情時，比如記錄實體類的更改，那麼了解這個就非常有用。

更新數據到數據庫時發生了什麼

上面的示例是關於向數據庫添加新記錄的，但是沒有進行更新。在這一節中，我將展示當你更新數據庫中已有的記錄時會發生什麼。這裏使用我上一篇文章“EF Core 讀取數據時發生了什麼？”中講到的查詢例子。

這個更新很簡單，只有三行，但是它在代碼中有三個階段：讀取、更新和保存。

var books = context.Books.ToList();
books.First().PublishedOn = new DateTime(2020, 1, 1);
context.SaveChanges();

下圖展示了這三個階段：

如你所見，你使用的查詢類型很重要——普通查詢加載數據並把返回的實體保存一份“跟蹤快照”，返回的實體類被稱為“被跟蹤的”。如果實體沒有沒跟蹤，則無法更新它。

注意：上一節中的 Author 實體類也是被“跟蹤”的。在這個例子中，Author 的跟蹤狀態告訴 EF Core Author 已經在數據庫中，因此不會再次創建。

因此，如果你更改了加載的跟蹤實體類中的任何屬性，那麼當你調用 SaveChanges 時，它會將所有跟蹤的實體類與它們的跟蹤快照進行比較。對於每個類，它遍歷映射到數據庫字段的所有屬性。這個過程稱為更改跟蹤，它將檢測被跟蹤實體中的每一個更改，包括 Title、PubishedOn 等非關係屬性。

在這個簡單的示例中，只有 4 個 Book 實體，但在實際應用程序中，您可能已經加載了許多相互連接的實體類。在這一點上，比較階段可能需要一段時間。因此，你應該嘗試只加載需要更改的實體類。

注意：EF Core 有一個名為 Update 的命令，它用於更新每個屬性/列的特定情況。EF Core 會自動跟蹤更改，默認只更新已更改的屬性/列。

每次更新都將創建一個 SQL UPDATE 命令，所有這些更新都將在一個 SQL 事務中執行。使用 SQL 事務意味着所有更新都作為一個整體，如果其中任何一部分失敗，那麼事務中的任何數據庫更改都會失效。

從數據庫刪除數據時發生了什麼

CRUD 的最後一部分是 DELETE，這在某些情況很簡單，你只需要調用 context.Remove()。在另一些情況它很複雜，例如，當你刪除另一個實體類依賴的實體類時會發生什麼？

刪除映射到數據庫的實體類的方法是 Remove。舉個例子，我加載一個特定的 Book，然後刪除它。

var book = context.Books
    .Single(p => p.Title == "Quantum Networking");
context.Remove(book);
context.SaveChanges();

它的階段如下：

  1. 加載要刪除的 Book 實體類。這會獲取它的所有屬性數據，但對於刪除，您實際上只需要實體類的主鍵。
  2. 調用 Remove 方法其實是將 Book 的狀態標記為 Deleted。這些信息會有序地存儲在跟蹤快照中。
  3. 最後，SaveChanges 創建一個 SQL DELETE 命令，該命令與任何其他數據庫更改一起發送到數據庫，並且在一個 SQL 事務中。

這看起來很簡單，但這裏發生了一些重要的事情，從代碼看並不明顯。原來書名為“Quantum Networking”的書有其他一些實體類關聯到到它——在某個特定的測試用例中，書名為“Quantum Networking”的書關聯到以下實體類：

  • 兩個 Review
  • 一個 PriceOffer
  • 一個 BookAuthor

現在，Review、PriceOffer 和 BookAuthor 實體類只與這本書相關——我們使用術語叫依賴於 Book 實體類。因此，如果這本書被刪除了，那麼這些 Review、PriceOffer 和所關聯的 BookAuthor 數據行也應該被刪除。如果不刪除，那麼數據庫的關聯關係就是不正確的，SQL 數據庫將拋出異常。那麼，為什麼做這個刪除工作？

這裏所發生的都是因為設置了級聯刪除，級聯刪除規則設置了 Books 表和三個依賴表之間的數據庫關係。
下面是 EF Core 為創建 Review 表而生成的 SQL 命令的一個示例：

CREATE TABLE [Review] (
    [ReviewId] int NOT NULL IDENTITY,
    [VoterName] nvarchar(max) NULL,
    [NumStars] int NOT NULL,
    [Comment] nvarchar(max) NULL,
    [BookId] int NOT NULL,
    CONSTRAINT [PK_Review] PRIMARY KEY ([ReviewId]),
    CONSTRAINT [FK_Review_Books_BookId] FOREIGN KEY ([BookId])
         REFERENCES [Books] ([BookId]) ON DELETE CASCADE
);

CONSTRAINT 語句部分定義了約束規則，該約束表示 Review 通過 BookId 列鏈接到 Books 表中的一行。在該約束的最後，你將看到關於 DELETE 級聯的規則。它告訴數據庫，如果它鏈接的書被刪除了，那麼這個 Review 也應該被刪除。這意味着書的刪除是允許的，因為所有相關的行也被刪除了。

這是非常有用的，但有時候想要更改刪除規則怎麼辦？比如我決定不允許刪除客戶訂單中存在的書。為了做到這一點，我在 DbContext 中添加了一些 EF Core 配置來改變刪除規則，如下：

public class EfCoreContext : DbContext
{
    private readonly Guid _userId;

    public EfCoreContext(DbContextOptions<EfCoreContext> options)
        : base(options)

    public DbSet<Book> Books { get; set; }
    //… 其它 DbSet<T>

    protected override void OnModelCreating(ModelBuilder modelBuilder
    {
        //… 其它代碼

        modelBuilder.Entity<LineItem>()
            .HasOne(p => p.ChosenBook)
            .WithMany()
            .OnDelete(DeleteBehavior.Restrict);
    }
}

一旦該配置應用到數據庫，就不會生成 SQL 語句的 DELETE CASCADE。這意味着，如果你試圖刪除客戶訂單中的一本書，那麼數據庫將返回一個錯誤，EF Core 將把這個錯誤變成一個異常。

這使你對正在發生的事情有一個更深的了解，但是還有相當多的內容我沒有介紹（但我在我的書中介紹了）。這裡有一些關於刪除我還沒有提到的事情：

  • 實體類之間可以有 required 關係(依賴關係)和 optional 關係，EF Core 為每種類型使用不同的規則。
  • EF Core 可以通過設置 DeleteBehavior 來設置級聯刪除規則，當實體類存在循環關聯關係時，可以用它避免一些錯誤——一些數據庫在發現循環刪除時會拋出錯誤。
  • 你可以在調用 Remove 方法時提供一個新的只有主鍵有值的類來刪除實體類。這在處理只返回主鍵的場景非常有用。

總結

本文我介紹了 CRUD 中的新增、更新和刪除部分，前一篇文章介紹了讀取部分。

正如您所看到的，使用 EF Core 在數據庫中創建記錄很容易，但內部很複雜。你通常不需要知道 EF Core 或數據庫中發生了什麼，但了解一些細節可以讓你更好地利用 EF Core 的優勢。

更新也很簡單——只需在你讀入的實體類中更改一個或多個屬性，當你調用 SaveChanges 時，EF Core 會找到已更改的數據，並構建 SQL 命令更新數據庫。這適用於非關係屬性（如圖 Book 的 Title 屬性）和導航屬性（你可以在他們的關係）。

最後，我們看了一個刪除案例。同樣很容易使用，但很多處理也是在背後執行的。​ 另外，敬請關注我的下一篇文章，我將討論所謂的“軟刪除”。如果你設置了一個標誌，EF Core 就不會再看到這個實體類了，它仍然在數據庫中，但它是隱藏的。

希望本文對你有用，也希望你關注本系列的更多文章。

祝你編程愉快！

[1]. https://bit.ly/2MXK3ZY
[2]. https://bit.ly/2Yza7QQ
[3]. https://bit.ly/2Y0UORO

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

【其他文章推薦】

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

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

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

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

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

※聚甘新

第 10 篇 評論接口

admin

作者：HelloGitHub-追夢人物

此前我們一直在操作博客文章（Post）資源，並藉此介紹了序列化器（Serializer）、視圖集（Viewset）、路由器（Router）等 django-rest-framework 提供的便利工具，藉助這些工具，就可以非常快速地完成 RESTful API 的開發。

評論（Comment）是另一種資源，我們同樣藉助以上工具來完成對評論資源的接口開發。

首先是設計評論 API 的 URL，根據 RESTful API 的設計規範，評論資源的 URL 設計為：/comments/

對評論資源的操作有獲取某篇文章下的評論列表和創建評論兩種操作，因此相應的 HTTP 請求和動作（action）對應如下：

HTTP請求 Action URL
GET list_comments /posts/:id/comments/
POST create /comments/

文章評論列表 API 使用自定義的 action，放在 /post/ 接口的視圖集下；發表評論接口使用標準的 create action，需要定義單獨的視圖集。

然後需要一個序列化器，用於評論資源的序列化（獲取評論時），反序列化（創建評論時）。有了編寫文章序列化器的基礎，評論序列化器就是依葫蘆畫瓢的事。

comments/serializers.py

from rest_framework import serializers
from .models import Comment


class CommentSerializer(serializers.ModelSerializer):
    class Meta:
        model = Comment
        fields = [
            "name",
            "email",
            "url",
            "text",
            "created_time",
            "post",
        ]
        read_only_fields = [
            "created_time",
        ]
        extra_kwargs = {"post": {"write_only": True}}

注意這裏我們在 Meta 中增加了 read_only_fields、extra_kwargs 的聲明。

read_only_fields 用於指定只讀字段的列表，由於 created_time 是自動生成的，用於記錄評論發布時間，因此聲明為只讀的，不允許通過接口進行修改。

extra_kwargs 指定傳入每個序列化字段的額外參數，這裏給 post 序列化字段傳入了 write_only 關鍵字參數，這樣就將 post 聲明為只寫的字段，這樣 post 字段的值僅在創建評論時需要。而在返回的資源中，post 字段就不會出現。

首先來實現創建評論的接口，先為評論創建一個視圖集：

comments/views.py

from rest_framework import mixins, viewsets
from .models import Comment
from .serializers import CommentSerializer

class CommentViewSet(mixins.CreateModelMixin, viewsets.GenericViewSet):
    serializer_class = CommentSerializer

    def get_queryset(self):
        return Comment.objects.all()

視圖集非常的簡單，混入 CreateModelMixin 后，視圖集就實現了標準的 create action。其實 create action 方法的實現也非常簡單，我們來學習一下 CreateModelMixin 的源碼實現。

class CreateModelMixin:
    """
    Create a model instance.
    """
    def create(self, request, *args, **kwargs):
        serializer = self.get_serializer(data=request.data)
        serializer.is_valid(raise_exception=True)
        self.perform_create(serializer)
        headers = self.get_success_headers(serializer.data)
        return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers)

    def perform_create(self, serializer):
        serializer.save()

    def get_success_headers(self, data):
        try:
            return {'Location': str(data[api_settings.URL_FIELD_NAME])}
        except (TypeError, KeyError):
            return {}

核心邏輯在 create 方法：首先取到綁定了用戶提交數據的序列化器，用於反序列化。接着調用 is_valid 方法校驗數據合法性，如果不合法，會直接拋出異常（raise_exception=True）。否則就執行序列化的 save 邏輯將評論數據存入數據庫，最後返迴響應。

接着在 router 里註冊 CommentViewSet 視圖集：

router.register(r"comments", comments.views.CommentViewSet, basename="comment")

進入 API 交互後台，可以看到首頁列出了 comments 接口的 URL，點擊進入 /comments/ 后可以看到一個評論表單，在這裏可以提交評論數據與創建評論的接口進行交互。

接下來實現獲取評論列表的接口。通常情況下，我們都是只獲取某篇博客文章下的評論列表，因此我們的 API 設計成了 /posts/:id/comments/。這個接口具有很強的語義，非常符合 RESTful API 的設計規範。

由於接口位於 /posts/ 空間下，因此我們在 PostViewSet 添加自定義 action 來實現，先來看代碼：

blog/views.py

class PostViewSet(
    mixins.ListModelMixin, mixins.RetrieveModelMixin, viewsets.GenericViewSet
):
    # ...
    
    @action(
            methods=["GET"],
            detail=True,
            url_path="comments",
            url_name="comment",
            pagination_class=LimitOffsetPagination,
            serializer_class=CommentSerializer,
    )
    def list_comments(self, request, *args, **kwargs):
        # 根據 URL 傳入的參數值（文章 id）獲取到博客文章記錄
        post = self.get_object()
        # 獲取文章下關聯的全部評論
        queryset = post.comment_set.all().order_by("-created_time")
        # 對評論列表進行分頁，根據 URL 傳入的參數獲取指定頁的評論
        page = self.paginate_queryset(queryset)
        # 序列化評論
        serializer = self.get_serializer(page, many=True)
        # 返回分頁后的評論列表
        return self.get_paginated_response(serializer.data)

action 裝飾器我們在上一篇教程中進行了詳細說明，這裏我們再一次接觸到 action 裝飾器更為深入的用法，可以看到我們除了設置 methods、detail、url_path 這些參數外，還通過設置 pagination_class、serializer_class 來覆蓋原本在 PostViewSet 中設置的這些類屬性的值（例如對於分頁，PostViewSet 默認為我們之前設置的 PageNumberPagination，而這裏我們替換為 LimitOffsetPagination）。

list_comments 方法邏輯非常清晰，註釋中給出了詳細的說明。另外還可以看到我們調用了一些輔助方法，例如 paginate_queryset 對查詢集進行分頁；get_paginated_response 返回分頁后的 HTTP 響應，這些方法其實都是 GenericViewSet 提供的通用輔助方法，源碼也並不複雜，如果不用這些方法，我們自己也可以輕鬆實現，但既然 django-rest-framework 已經為我們寫好了，直接復用就行，具體的實現請大家通過閱讀源碼進行學習。

現在進入 API 交互後台，進入某篇文章的詳細接口，例如訪問 /api/posts/5/，Extra Actions 下拉框中可以看到 List comments 的選項：

點擊 List comments 即可進入這篇文章下的評論列表接口，獲取這篇文章的評論列表資源了：

關注公眾號加入交流群

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

【其他文章推薦】

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

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

※想知道最厲害的網頁設計公司“嚨底家”!

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

※產品缺大量曝光嗎?你需要的是一流包裝設計!

※聚甘新

循序漸進VUE+Element 前端應用開發(12）— 整合ABP框架的前端登錄處理,循序漸進VUE+Element 前端應用開發(5）— 表格列表頁面的查詢，列表展示和字段轉義處理,循序漸進VUE+Element 前端應用開發(9）— 界面語言國際化的處理,循序漸進VUE+Element 前端應用開發(11）— 圖標的維護和使用

admin

VUE+Element 前端是一個純粹的前端處理，前面介紹了很多都是Vue+Element開發的基礎，從本章隨筆開始，就需要進入深水區了，需要結合ABP框架使用（如果不知道，請自行補習一下我的隨筆：ABP框架使用），ABP框架作為後端，是一個非常不錯的技術方向，但是前端再使用Asp.NET 進行開發的話，雖然會快捷一點，不過可能顯得有點累贅了，因此BS的前端選項採用Vue+Element來做管理（後續可能會視情況加入Vue+AntDesign），CS前端我已經完成了使用Winform+ABP的模式了。本篇隨筆主要介紹Vue+Element+ABP的整合方式，先從登錄開始介紹。

 1、ABP開發框架的回顧

ABP是ASP.NET Boilerplate的簡稱，ABP是一個開源且文檔友好的應用程序框架。ABP不僅僅是一個框架，它還提供了一個最徍實踐的基於領域驅動設計(DDD)的體繫結構模型。

啟動Host的項目，我們可以看到Swagger的管理界面如下所示。

我們登錄獲得用戶訪問令牌token后，測試字典類型或者字典數據的接口，才能返迴響應的數據。

我根據ABP後端項目之間的關係，整理了一個架構的圖形。

應用服務層是整個ABP框架的靈魂所在，對內協同倉儲對象實現數據的處理，對外配合Web.Core、Web.Host項目提供Web API的服務，而Web.Core、Web.Host項目幾乎不需要進行修改，因此應用服務層就是一個非常關鍵的部分，需要考慮對用戶登錄的驗證、接口權限的認證、以及對審計日誌的記錄處理，以及異常的跟蹤和傳遞，基本上應用服務層就是一個大內總管的角色，重要性不言而喻。

對於通過Winform方式展示界面，以Web API方式和後端的ABP的Web API服務進行數據交互，是我們之前已經完成的項目，項目界面如下所示。

主體框架界面採用的是基於菜單的動態生成，以及多文檔的界面布局，具有非常好的美觀性和易用性。

左側的功能樹列表和頂部的菜單模塊，可以根據角色擁有的權限進行動態構建，不同的角色具有不同的菜單功能點，如下是測試用戶登錄后具有的界面。

 

2、Vue+Element整合ABP框架的前端登錄處理

之前我們開發完成的Vue+Element的前端項目，默認已經具有登錄系統的功能，不過登錄是採用mock方式進行驗證並處理的，本篇隨筆介紹是基於實際的ABP項目進行用戶身份的登錄處理，這個也是開發其他接口展示數據的開始步驟，必須通過真實的用戶身份登錄後台，獲得對應的token令牌，才能進行下一步接口的開發工作。

例如對應登錄界面上，界面效果如下所示。

在用戶登錄界面中，我們處理用戶登錄邏輯代碼如下所示。

    // 處理登錄事件
    handleLogin() {
      this.$refs.loginForm.validate(valid => {
        if (valid) {
          this.loading = true
          this.$store
            .dispatch('user/login', this.loginForm)
            .then(() => {
              this.$router.push({ path: this.redirect || '/' })
              this.loading = false
            })
            .catch(() => {
              this.loading = false
            })
        } else {
          console.log('error submit!!')
          return false
        }
      })
    }

這裏主要就是調用Store模塊裏面的用戶Action處理操作。

例如對於用戶store模塊裏面的登錄Action函數如下所示。

const actions = {
  // user login
  login({ commit }, userInfo) {
    const { username, password } = userInfo
    return new Promise((resolve, reject) => {
      login({ username: username.trim(), password: password }).then(response => {
        const { result } = response // 獲取返回對象的 result
 var token = result.accessToken var userId = result.userId // 記錄令牌和用戶Id
        commit('SET_TOKEN', token)
        commit('SET_USERID', userId)

        // 存儲cookie
        setToken(token)
        setUserId(userId)
        resolve()
      }).catch(error => {
        reject(error)
      })
    })
  },

而其中 login({ username: username.trim(), password: password }) 操作，是通過API封裝處理的調用，使用前在Store模塊中先引入API模塊，如下所示。

import { login, logout, getInfo } from '@/api/user'

 而其中 API模塊代碼如下所示。

export function login(data) {
  return request({
    url: '/abp/TokenAuth/Authenticate',
    method: 'post',
    data: {
      UsernameOrEmailAddress: data.username,
      password: data.password
    }
  })
}

這裏我們用了一個/abp的前綴，用來給WebProxy的處理，實現地址的轉義，從而可以實現跨站的處理，讓前端調用外部地址就和調用本地地址一樣，無縫對接。

我們來看看vue.config.js裏面對於這個代理的轉義操作代碼。

 而 http://localhost:21021/api 地址指向的項目，是我們本地使用ABP開發的一個後端Web API項目，我們可以通過地址 http://localhost:21021/swagger/index.html 進行接口的查看。

 我們打開獲取授權令牌的Authenticate接口，查看它的接口定義內容

 

通過標註的1,2，我們可以看到這個接口的輸入參數和輸出JSON信息，從而為我們封裝Web API的調用提供很好的參考。

ABP框架統一返回的結果是result，這個result裏面才是返回對應的接口內容，如上面的輸出JSON信息裏面的定義。

所以在登陸返回結果后，我們要返回它的result對象，然後在進行數據的處理。

const { result } = response // 獲取返回對象的 result

然後通過result來訪問其他屬性即可。

var token = result.accessToken // 用戶令牌
var userId = result.userId // 用戶id

用戶登錄成功后，並獲取到對應的數據，我們就可以把必要的數據，如token和userid存儲在State和Cookie裏面了。

// 修改State對象，記錄令牌和用戶Id
commit('SET_TOKEN', token)
commit('SET_USERID', userId)

// 存儲cookie
setToken(token)
setUserId(userId)

有了這些信息，我們就可以進一步獲取用戶的相關信息，如用戶名稱、介紹，包含角色列表和權限列表等內容了。

例如對應用戶信息獲取接口的ABP後端地址是 http://localhost:21021//api/services/app/User/Get 

 那麼我們前端就需要在API模塊裏面構建它的訪問地址（/abp/services/app/User/Get）和接口處理了。

export function getInfo(id) {
  return request({
    url: '/abp/services/app/User/Get',
    method: 'get',
    params: {
      id
    }
  })
}

如上所示，在Store模塊里引入API模塊，如下所示。

import { login, logout, getInfo } from '@/api/user'

然後在Store模塊中封裝一個Action用來處理用戶信息的獲取的。

  // 獲取用戶信息
  getInfo({ commit, state }) {
    return new Promise((resolve, reject) => {
      getInfo(state.userid).then(response => {
        const { result } = response
        console.log(result) // 輸出測試

        if (!result) {
          reject('Verification failed, please Login again.')
        }

        const { roles, roleNames, name, fullName } = result

        // 角色非空提醒處理
        if (!roles || roles.length <= 0) {
          reject('getInfo: roles must be a non-null array!')
        }

        commit('SET_ROLES', { roles, roleNames })
        commit('SET_NAME', name)
        // commit('SET_AVATAR', avatar) //可以動態設置頭像
        commit('SET_INTRODUCTION', fullName)
        resolve(result)
      }).catch(error => {
        reject(error)
      })
    })
  },

Vue + Element前端項目的視圖、Store模塊、API模塊、Web API之間關係如下所示。

 

 登錄后我們獲取用戶身份信息，在控制台中記錄返回對象信息，可以供參考，如下所示

  

有了token信息，我們就可以繼續其他接口的數據請求或者提交了，從而可以實現更多的管理功能了。

後續隨筆將基於ABP接口對接的基礎上進行更多界面功能的開發和整合。 

 

列出一下前面幾篇隨筆的連接，供參考：

循序漸進VUE+Element 前端應用開發(1）— 開發環境的準備工作

循序漸進VUE+Element 前端應用開發(2）— Vuex中的API、Store和View的使用

循序漸進VUE+Element 前端應用開發(3）— 動態菜單和路由的關聯處理

循序漸進VUE+Element 前端應用開發(4）— 獲取後端數據及產品信息頁面的處理

循序漸進VUE+Element 前端應用開發(5）— 表格列表頁面的查詢，列表展示和字段轉義處理

循序漸進VUE+Element 前端應用開發(6）— 常規Element 界面組件的使用

循序漸進VUE+Element 前端應用開發(7）— 介紹一些常規的JS處理函數

循序漸進VUE+Element 前端應用開發(8）— 樹列表組件的使用

循序漸進VUE+Element 前端應用開發(9）— 界面語言國際化的處理

循序漸進VUE+Element 前端應用開發(11）— 圖標的維護和使用

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

【其他文章推薦】

※帶您來了解什麼是 USB CONNECTOR  ?

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

※如何讓商品強力曝光呢? 網頁設計公司幫您建置最吸引人的網站，提高曝光率!

※綠能、環保無空污,成為電動車最新代名詞，目前市場使用率逐漸普及化

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

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

※聚甘新

ConcurrentHashMap源碼解析-Java7

admin

目錄

一.ConcurrentHashMap的模型圖

二.源碼分析-類定義

　　2.1 極簡ConcurrentHashMap定義

　　2.2 Segment內部類

　　2.3 HashEntry內部類

　　2.4 ConcurrentHashMap的重要常量

三.常用接口源碼分析

　　3.1 ConcurrentHashMap構造方法

　　3.2 map.put操作

　　3.3 創建新segment

　　3.4 segment.put操作

　　3.5 segment.rehash擴容

　　3.6 map.get操作

　　3.7 map.remove操作

　　3.8 map.size操作

 

　　原文地址：https://www.cnblogs.com/-beyond/p/13157083.html

一.ConcurrentHashMap的模型圖

　　之前看了Java8中的HashMap，然後想接着看Java8的ConcurrentHashMap，但是打開Java8的ConcurrentHashMap，瞬間就慫了，將近7k行代碼，而反觀一下Java7的Concurrent，也就在1500多行，那就先選擇少的看吧。畢竟Java7的ConcurrentHashMap更加簡單。下面所有的介紹都是針對Java7而言！！！！！

　　下面是ConcurrentHashMap的結構圖，ConcurrentHashMap有一個segments數組，每個segment中又有一個table數組，該數組的每個元素時HashEntry類型。

　　 

　　可以簡單的理解為ConcurrentHashMap是多個HashMap組成，每一個HashMap是一個segment，就如傳說中一樣，ConcurrentHashMap使用分段鎖的方式，這個“段”就是segment。

　　ConcurrentHashMap之所以能夠保證併發安全，是因為支持對不同segment的併發修改操作，比如兩個線程同時修改ConcurrentHashMap，一個線程修改第一個segment的數據，另一個線程修改第二個segment的數據，兩個線程可以併發修改，不會出現併發問題；但是多個線程同一個segment進行併發修改，則需要先獲取該segment的鎖后再修改，修改完后釋放鎖，然後其他要修改的線程再進行修改。

　　那麼，ConcurrentHashMap可以支持多少併發量呢？這個也就是問，ConcurrentHashMap最多能支持多少線程併發修改，其實也就是segment的數量，只要修改segment的這些線程不是修改同一個segment，那麼這些線程就可以并行執行，這也就是ConcurrentHashMap的併發量（segment的數量）。

　　注意，ConcurrentHashMap創建完成后，也就是segment的數量、併發級別已經確定，則segment的數量和併發級別都不能再改變了，即使發生擴容，也是segment中的table進行擴容，segment的數量保持不變。

 

二.源碼分析-類定義

2.1 極簡ConcurrentHashMap定義

　　下面是省略了大部分代碼的ConcurrentHashMap定義：

package java.util.concurrent;

import java.util.AbstractMap;
import java.util.concurrent.locks.ReentrantLock;

public class ConcurrentHashMap<K, V> extends AbstractMap<K, V> implements ConcurrentMap<K, V>, Serializable {

    final Segment<K, V>[] segments;

    /**
     * segment分段的定義
     */
    static final class Segment<K, V> extends ReentrantLock implements Serializable {

        transient volatile HashEntry<K, V>[] table;
    }

    /**
     * 存放的元素節點
     */
    static final class HashEntry<K, V> {

    }
}

 

2.2 Segment內部類

　　ConcurrentHashMap內部有一個segments屬性，是Segment類型的數組，Segment類和HashMap很相似（Java7的HashMap)，維持一個數組，每個數組是一個HashEntry，當發生hash衝突后，則使用拉鏈法（頭插法）來解決衝突。

　　而Segment數組的定義如下，省略了方法：

static final class Segment<K, V> extends ReentrantLock implements Serializable {
    static final int MAX_SCAN_RETRIES = Runtime.getRuntime().availableProcessors() > 1 ? 64 : 1;
    private static final long serialVersionUID = 2249069246763182397L;
    
    // segment的負載因子（segments數組中的所有segment負載因子都相同）
    final float loadFactor;
    
    // segment中保存元素的數組
    transient volatile HashEntry<K, V>[] table;
   
    // 該segment中的元素個數
    transient int count;
    
    // modify count，該segment被修改的次數
    transient int modCount;
    
    // segment的擴容閾值
    transient int threshold;
}

　　注意每個Segment都有負載因子、以及擴容閾值，但是後面可以看到，其實segments數組中的每一個segment，負載因子和擴容閾值都相同，因為創建的時候，都是使用0號segment的負載因子和擴容閾值。

 

2.3 HashEntry內部類

　　Segment類中有一個table數組，table數組的每個元素都是HashEntry類型，和HashMap的Entry類似，源碼如下：（省略了方法）

/**
 * map中每個元素的類型
 */
static final class HashEntry<K, V> {
    final int hash;
    final K key;
    volatile V value;
    volatile HashEntry<K, V> next;
}

 

2.4 ConcurrentHashMap的一些常量

　　ConcurrentHashMap中有很多常量，

// 默認初始容量
static final int DEFAULT_INITIAL_CAPACITY = 16;

// 默認的負載因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;

// 默認的併發級別(同時支持多少線程併發修改)
// 因為JDK7中ConcurrentHashMap中是用分段鎖實現併發，不同分段的數據可以進行併發操作，同一個段的數據不能同時修改
static final int DEFAULT_CONCURRENCY_LEVEL = 16;

// 最大容量
static final int MAXIMUM_CAPACITY = 1 << 30;

// 每一個分段的數組容量初始值
static final int MIN_SEGMENT_TABLE_CAPACITY = 2;

// 最多能有多少個segment
static final int MAX_SEGMENTS = 1 << 16; // slightly conservative

// 嘗試對整個map進行操作（比如說統計map的元素數量），可能需要鎖定全部segment；
// 這個常量表示鎖定所有segment前，嘗試的次數
static final int RETRIES_BEFORE_LOCK = 2;

　　

三.常用接口源碼分析

3.1 ConcurrentHashMap構造方法

　　ConcurrentHashMap有多個構造方法，但是內部其實都是調用同一個進行創建：

public ConcurrentHashMap() {
    this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL);
}

public ConcurrentHashMap(int initialCapacity) {
    this(initialCapacity, DEFAULT_LOAD_FACTOR, DEFAULT_CONCURRENCY_LEVEL);
}

public ConcurrentHashMap(int initialCapacity, float loadFactor) {
    this(initialCapacity, loadFactor, DEFAULT_CONCURRENCY_LEVEL);
}

/**
 * 統一調用的構造方法
 *
 * @param initialCapacity  初始容量
 * @param loadFactor       負載因子
 * @param concurrencyLevel 併發級別
 */
@SuppressWarnings("unchecked")
public ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel) {
    // 校驗參數合法性
    if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0) {
        throw new IllegalArgumentException();
    }

    // 對併發級別進行調整，不允許超過segment的數量（超過segment其實是沒有意義的）
    if (concurrencyLevel > MAX_SEGMENTS) {
        concurrencyLevel = MAX_SEGMENTS;
    }

    // 根據concurrencyLevel確定sshift和ssize的值
    int ssize = 1; // ssize是表示segment的數量，ssize是不小於concurrencyLevel的數，並且是2的n次方
    int sshift = 0;// sshift是ssize轉換為2進制后的位數，比如ssize為16（1000），則sshift為4
    while (ssize < concurrencyLevel) {
        ++sshift;
        ssize <<= 1;
    }
    // 比如concurrencyLevel默認為16，走完循環，sshift為4，ssize為16
    // 如果concurrentLevel為8，則sshift為3，ssize為8

    // segment的shift偏移量
    this.segmentShift = 32 - sshift;
    // segment掩碼
    this.segmentMask = ssize - 1;

    // 對傳入的初始容量進行調整（不允許大於最大容量）
    if (initialCapacity > MAXIMUM_CAPACITY) {
        initialCapacity = MAXIMUM_CAPACITY;
    }

    // 假設傳入的容量為128，併發級別為16，則initialCapacity為128，ssize為16
    int c = initialCapacity / ssize;
    // c可以理解為根據傳入的初始容量，計算出每個segment中的數組容量
    if (c * ssize < initialCapacity) {
        ++c;
    }

    // cap表示的是每個segment中的數組容量
    int cap = MIN_SEGMENT_TABLE_CAPACITY;
    // 如果默認的每個segment中的數組長度小於上面計算出來的每個segment的數組長度，則將容量翻倍
    while (cap < c) {
        cap <<= 1;
    }

    // 創建一個segment，作為segments數組的第一個segment
    Segment<K, V> s0 = new Segment<K, V>(loadFactor, (int) (cap * loadFactor), new HashEntry[cap]);

    // 創建segments數組
    Segment<K, V>[] ss = (Segment<K, V>[]) new Segment[ssize];

    // 將s0賦值給segments數組的第一個元素（偏移量為0）
    UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0]

    // 複製segment數組
    this.segments = ss;
}

/**
 * 傳入map，將map中的元素加入到ConcurrentHashMap中
 * 注意使用默認的負載因子（0.75）和默認的併發級別（16）
 * 初始容量取map容量和默認容量的較大值
 */
public ConcurrentHashMap(Map<? extends K, ? extends V> m) {
    this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1, DEFAULT_INITIAL_CAPACITY),
            DEFAULT_LOAD_FACTOR,
            DEFAULT_CONCURRENCY_LEVEL);
    putAll(m);
}

　　

3.2 map.put操作

　　map.put，map就是指ConcurrentHashMap，其實就是確定HashEntry應該放入哪個segment中的哪個位置，所以可分為3步：

　　1.首先需要確定放入哪個segment；

　　2.確定segment后，再確定HashEntry應該放入segment的哪個位置；

　　3.進行覆蓋覆蓋或者插入。

/**
 * put操作，注意key或者value為null時，會拋出NPE
 */
@SuppressWarnings("unchecked")
public V put(K key, V value) {
    Segment<K, V> s;
    if (value == null) {
        throw new NullPointerException();
    }

    // 計算key的hash
    int hash = hash(key);

    // hash值右移shift位后 與 mask掩碼進行取與，確定數據應該放到哪個segments數組的哪一個segment中
    int j = (hash >>> segmentShift) & segmentMask;

    // 判斷計算出的segment數組位置上的segment是否為null，如果為null，則進行創建segment
    if ((s = (Segment<K, V>) UNSAFE.getObject(segments, (j << SSHIFT) + SBASE)) == null) {
        s = ensureSegment(j);
    }

    // 創建segment后，將數據put到segment中，調用的segment.put()
    return s.put(key, hash, value, false);
}

　　

3.3 創建新segment

　　上面put的時候，如果發現segment為null，則會進行調用ensureSegment進行創建segment，代碼如下：

/**
 * 擴容（創建）segment
 *
 * @param k 需要擴容或者需要創建的segment位置
 * @return 返回擴容后的segment
 */
@SuppressWarnings("unchecked")
private Segment<K, V> ensureSegment(int k) {
    final Segment<K, V>[] ss = this.segments;
    long u = (k << SSHIFT) + SBASE; // 傳入的index，對應的偏移量
    Segment<K, V> seg;

    // 判斷是否需要擴容或者創建segment，如果獲取到segment不為null，則返回segment
    if ((seg = (Segment<K, V>) UNSAFE.getObjectVolatile(ss, u)) == null) {
        Segment<K, V> proto = ss[0]; // “原型設計模式”，使用segments數組的0號位置segment
        int cap = proto.table.length;// 0號segment的table長度
        float lf = proto.loadFactor; // 0號segment的負載因子
        int threshold = (int) (cap * lf); // 0號segment的擴容閾值

        // 創建一個HashEntry的數組，數組容量和0號segment相同
        HashEntry<K, V>[] tab = (HashEntry<K, V>[]) new HashEntry[cap];

        // 再次檢測，指定的segment是不是為null，如果為null才進行下一步操作
        if ((seg = (Segment<K, V>) UNSAFE.getObjectVolatile(ss, u)) == null) { // recheck
            // 創建segment
            Segment<K, V> s = new Segment<K, V>(lf, threshold, tab);

            // 使用CAS將新創建的segment填入指定的位置
            while ((seg = (Segment<K, V>) UNSAFE.getObjectVolatile(ss, u)) == null) {
                if (UNSAFE.compareAndSwapObject(ss, u, null, seg = s)) {
                    break;
                }
            }
        }
    }

    // 返回新增的segment
    return seg;
}

　　上面需要注意的是：

　　1.創建segment中的table數組時，是使用0號segment的table屬性（長度、負載因子、閾值）；

　　2.創建segment前會進行再check，check發現segment的確為null時，再進行創建segment；

　　3.利用CAS來將創建的segment填入segments數組中；

 

3.4 segment.put操作

　　當確定HashEntry應該放到哪個segment后，就開始調用segment的put方法，如下：

/**
 * 在確定應該存放到那個segment后，就segment.put()將k-v存入segment中
 *
 * @param key          put的key
 * @param hash         hash(key)的值
 * @param value        put的value
 * @param onlyIfAbsent true:key對應的Entry不進行覆蓋，false:key對應的entry存在與否，都進行put覆蓋
 * @return
 */
final V put(K key, int hash, V value, boolean onlyIfAbsent) {
    // 先獲取鎖（ReentrantLock，內部使用非公平鎖）
    HashEntry<K, V> node = tryLock() ? null : scanAndLockForPut(key, hash, value);
    V oldValue;
    try {
        HashEntry<K, V>[] tab = table;

        // 根據hash值計算出在segment的table中的位置
        int index = (tab.length - 1) & hash;

        // 定位到segment的table的index位置（第一個節點）
        HashEntry<K, V> first = entryAt(tab, index);

        // 從第一個節點開始遍歷
        for (HashEntry<K, V> e = first; ; ) {
            // 節點不為空，則判斷是否key是否相同（相同HashEntry）
            if (e != null) {
                K k;
                // 比較是否key是否相等（判斷put的key是否已經存在）
                if ((k = e.key) == key || (e.hash == hash && key.equals(k))) {
                    // 如果key已經存在，則進行覆蓋，如果onlyIsAbsent為false（不關心key對應的Entry是否存在）
                    oldValue = e.value;
                    if (!onlyIfAbsent) {
                        // 覆蓋舊值，修改計數加1
                        e.value = value;
                        ++modCount;
                    }
                    break;
                }
                e = e.next;
            } else {
                // 頭插法，將put的k-v創建新HashEntry，放到first的前面
                if (node != null) {
                    node.setNext(first);
                } else {
                    node = new HashEntry<K, V>(hash, key, value, first);
                }

                // segment中table元素數量加1
                int c = count + 1;

                // 加1后的size大於擴容閾值，且數組的長度小於最大容量，則進行rehash
                if (c > threshold && tab.length < MAXIMUM_CAPACITY) {
                    // 擴容，並進行rehash
                    rehash(node);
                } else {
                    // 將節點放入數組中的指定位置
                    setEntryAt(tab, index, node);
                }

                // 修改次數加一，修改segment的table元素個數
                ++modCount;
                count = c;

                // 舊值為null
                oldValue = null;
                break;
            }
        }
    } finally {
        // 釋放鎖
        unlock();
    }
    return oldValue;
}

　　梳理一下，大致在做下面幾件事：

　　1.先獲取鎖（ReetrantLock，內部使用非公平鎖NonFairSync）；

　　2.獲取到鎖后根據hash計算出在table的位置；

　　3.遍歷table的HashEntry的鏈表，如果有相同key的，則進行覆蓋，如果沒有，在進行頭插法；

　　4.插入鏈表后，確定是否需要擴容，需要則執行rehash；

　　5.修改計數（count、modCount），並且釋放鎖。

 

3.5 segment.rehash擴容

　　segment擴容時，會將該segment的容量擴容為之前的2倍，並且將各位置的鏈表節點元素進行rehash。

/**
 * 將segment的table容量擴容一倍（newCap=oldCap*2），注意只會擴容該node所在的segment
 *
 * @param node segment[i]->鏈表的頭結點
 */
@SuppressWarnings("unchecked")
private void rehash(HashEntry<K, V> node) {
    HashEntry<K, V>[] oldTable = table;
    int oldCapacity = oldTable.length;

    // 新容量為舊容量的2倍
    int newCapacity = oldCapacity << 1;

    // 設置新的擴容閾值
    threshold = (int) (newCapacity * loadFactor);

    // 申請新數組，數組長度為新容量值
    HashEntry<K, V>[] newTable = (HashEntry<K, V>[]) new HashEntry[newCapacity];

    // 循環遍歷segment的數組（舊數組）
    int sizeMask = newCapacity - 1; // 新的掩碼
    for (int i = 0; i < oldCapacity; i++) {
        // 獲取第i個位置的HashEntry節點，如果該節點為null，則該位置為空，不作處理
        HashEntry<K, V> e = oldTable[i];
        if (e != null) {
            HashEntry<K, V> next = e.next;

            // 計算新位置
            int idx = e.hash & sizeMask;

            // next為null，表示該位置只有一個節點，直接將節點複製到新位置
            if (next == null) {   //  Single node on list
                newTable[idx] = e;
            } else { // Reuse consecutive sequence at same slot
                HashEntry<K, V> lastRun = e;
                int lastIdx = idx;
                for (HashEntry<K, V> last = next; last != null; last = last.next) {
                    int k = last.hash & sizeMask;
                    if (k != lastIdx) {
                        lastIdx = k;
                        lastRun = last;
                    }
                }
                newTable[lastIdx] = lastRun;
                // 從頭結點開始，開始將節點拷貝到新數組中
                for (HashEntry<K, V> p = e; p != lastRun; p = p.next) {
                    V v = p.value;
                    int h = p.hash;
                    int k = h & sizeMask;
                    HashEntry<K, V> n = newTable[k];
                    newTable[k] = new HashEntry<K, V>(h, p.key, v, n);
                }
            }
        }
    }

    // 將頭結點添加到segment的table中
    int nodeIndex = node.hash & sizeMask; // add the new node
    node.setNext(newTable[nodeIndex]);
    newTable[nodeIndex] = node;
    table = newTable;
}

　　為啥擴容的時候沒有加鎖呀？

　　其實已經加鎖了，只不過不是在rehash中加鎖！！！因為rehash是在map.put中調用，put的時候已經加鎖了，所以rehash中不用加鎖。

　　

3.6 map.get操作

　　get操作，先定位到segment，然後定位到segment的具體位置，進行獲取

/**
 * 從ConcurrentHashMap中獲取key對應的value，不需要加鎖
 */
public V get(Object key) {
    Segment<K, V> s;
    HashEntry<K, V>[] tab;

    // 計算key的hash
    int h = hash(key);

    // 計算key處於哪一個segment中（index）
    long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;

    // 獲取數組中該位置的segment，如果該segment的table不為空，那麼就繼續在segment中查找，否則返回null，因為未找到
    if ((s = (Segment<K, V>) UNSAFE.getObjectVolatile(segments, u)) != null && (tab = s.table) != null) {

        // tab指向segment的table數組，通過hash計算定位到table數組的位置（然後開始遍歷鏈表）
        HashEntry<K, V> e;
        for (e = (HashEntry<K, V>) UNSAFE.getObjectVolatile(tab, ((long) (((tab.length - 1) & h)) << TSHIFT) + TBASE);
             e != null; e = e.next) {
            K k;
            // 判斷key和hash是否匹配，匹配則證明找到要查找的數據，將數據返回
            if ((k = e.key) == key || (e.hash == h && key.equals(k)))
                return e.value;
        }
    }
    
    return null;
}

　　

3.7 map.remove操作

　　 刪除節點，和get的流程差不多，先定位到segment，然後確定segment的哪個位置（哪條鏈表），遍歷鏈表，找到後進行刪除。

/**
 * 刪除map中key對應的元素
 */
public V remove(Object key) {
    // 計算key的hash
    int hash = hash(key);

    // 根據hash確定segment
    Segment<K, V> s = segmentForHash(hash);

    // 調用segment.remove進行刪除
    return s == null ? null : s.remove(key, hash, null);
}

/**
 * 刪除segment中key對應的hashEntry
 * 如果傳入的value不為空，則會在value匹配的時候進行刪除，否則不操作
 */
final V segmeng.remove(Object key, int hash, Object value) {
    // 獲取鎖失敗，則不斷自旋嘗試獲取鎖
    if (!tryLock()) {
        scanAndLock(key, hash);
    }

    V oldValue = null;
    try {
        HashEntry<K, V>[] tab = table;
        // 定位到segment中table的哪個位置
        int index = (tab.length - 1) & hash;
        HashEntry<K, V> e = entryAt(tab, index);
        HashEntry<K, V> pred = null;

        // 遍歷鏈表
        while (e != null) {
            K k;
            HashEntry<K, V> next = e.next;
            // 如果key和hash都匹配
            if ((k = e.key) == key || (e.hash == hash && key.equals(k))) {
                V v = e.value;
                // 如果沒有傳入value，則直接刪除該節點
                // 如果傳入了value，比如調用的map.remove(key,value)，則要value匹配才會刪除，否則不操作
                if (value == null || value == v || value.equals(v)) {
                    if (pred == null) { // 頭結點就是要找刪除的元素，next為null，則將null賦值數組的該位置
                        setEntryAt(tab, index, next);
                    } else { // 
                        pred.setNext(next);
                    }

                    // 修改次數加一，map數量減一
                    ++modCount;
                    --count;
                    oldValue = v;
                }
                break;
            }

            // 不匹配時，pred保存當前一次檢測的節點，e指向下一個節點
            pred = e;
            e = next;
        }
    } finally {
        unlock();// 釋放鎖
    }
    return oldValue;
}

　　

3.8 map.size操作

　　ConcurrentHashMap的size()，需要統計每一個segment中的元素數量（也就是count值），因為不同的segment允許併發修改，統計過程中可能會出現修改操作，導致統計不準確，所以要想準確統計整個map的元素數量，可以這樣做：通過加鎖的方式來解決（將所有的segment都加鎖），這樣就能保證元素不會變化了，這是我們的想法。

　　而ConcurrentHashMap是這樣解決的，先嘗試不加鎖進行統計兩次，這兩次統計，不止會統計每個segment的元素數量，還會統計每個segment的modCount(修改次數），進行匯總；如果兩次統計的modCount總量相同，也就說明兩次統計期間沒有修改操作，證明統計的元素總量正確；如果兩次modCount總量不相同，表示有修改操作，則進行重試，如果重試后，發現還是不準確（modCount不匹配），那麼就嘗試為所有的segment加鎖，再進行統計。

　　源碼如下：

/**
 * 獲取ConcurrentHashMap中的元素個數，如果元素個數超過Integer.MAX_VALUE，則返回Integer.MAX_VALUE
 */
public int size() {
    final Segment<K, V>[] segments = this.segments;
    int size;           // 返回元素數量（統計結果->元素的總量）
    boolean overflow;   // 標誌是否溢出（是否超過Integer.MAX_VALUE）
    long sum;           // 所有segment的modCount總量次數（整個map的修改次數）
    long last = 0L;     // previous sum，上一輪統計的modCount總量
    int retries = -1;   // 記錄重試的次數

    try {
        // 此處for循環主要用於控制重試
        for (; ; ) {
            // 重試的次數如果達到RETRIES_BEFORE_LOCK，則強制獲取所有segment的鎖
            if (retries++ == RETRIES_BEFORE_LOCK) {
                for (int j = 0; j < segments.length; ++j) {
                    ensureSegment(j).lock();
                    // 強制獲取segment的table第i個位置，並加鎖
                }
            }

            sum = 0L;
            size = 0;
            overflow = false;
            // 開始對segments中的每一個segment中進行統計
            for (int j = 0; j < segments.length; ++j) {
                // 獲取第j個segment
                Segment<K, V> seg = segmentAt(segments, j);
                // 如果segment不為空，則進行統計
                if (seg != null) {
                    sum += seg.modCount;
                    int c = seg.count;
                    // size累加
                    if (c < 0 || (size += c) < 0)
                        overflow = true;
                }
            }

            // 如果本次統計的modCount總量和上次一樣，則表示在這兩次統計之間沒有進行過修改，則不再重試
            if (sum == last) {
                break;
            }
            // 記錄本次統計的modCount總量
            last = sum;
        }
    } finally {
        // 判斷是否加了鎖（如果retries大於RETRIES_BEFORE_LOCK），則證明加了鎖，於是進行釋放鎖
        if (retries > RETRIES_BEFORE_LOCK) {
            for (int j = 0; j < segments.length; ++j)
                segmentAt(segments, j).unlock();
        }
    }
    return overflow ? Integer.MAX_VALUE : size;
}

　　

 

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

【其他文章推薦】

※為什麼 USB CONNECTOR 是電子產業重要的元件?

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

※台北網頁設計公司全省服務真心推薦

※想知道最厲害的網頁設計公司“嚨底家”!

※推薦評價好的iphone維修中心

※聚甘新

Redis系列（五）：數據結構List雙向鏈表源碼解析和API實現

admin

1.介紹

Redis中List是通過ListNode構造的雙向鏈表。

特點：

1.雙端：獲取某個結點的前驅和後繼結點都是O(1)

2.無環：表頭的prev指針和表尾的next指針都指向NULL，對鏈表的訪問都是以NULL為終點

3.帶表頭指針和表尾指針：獲取表頭和表尾的複雜度都是O(1)

4.帶鏈表長度計數器：len屬性記錄，獲取鏈表長度O(1)

5.多態：鏈表結點使用void*指針來保存結點的值，並且可以通過鏈表結構的三個函數為結點值設置類型特定函數，所以鏈表可以保存各種不同類型的值

雙向鏈表詳解：https://www.cnblogs.com/vic-tory/p/13140779.html

中文網：http://redis.cn/commands.html#list

2.源碼解析

// listNode 雙端鏈表節點
typedef struct listNode {

    // 前置節點
    struct listNode *prev;

    // 後置節點
    struct listNode *next;

    // 節點的值
    void *value;

} listNode;

 

// list 雙端鏈表
typedef struct list { // 在c語言中,用結構體的方式來模擬對象是一種常見的手法

    // 表頭節點
    listNode *head;

    // 表尾節點
    listNode *tail;

    // 節點值複製函數
    void *(*dup)(void *ptr);

    // 節點值釋放函數
    void(*free)(void *ptr);

    // 節點值對比函數
    int(*match)(void *ptr, void *key);

    // 鏈表所包含的節點數量
    unsigned long len;

} list;

 

/* 作為宏實現的函數 */
//獲取長度
#define listLength(l) ((l)->len)
//獲取頭節點
#define listFirst(l) ((l)->head)
//獲取尾結點
#define listLast(l) ((l)->tail)
//獲取前一個結點
#define listPrevNode(n) ((n)->prev)
//獲取后一個結點
#define listNextNode(n) ((n)->next)
//獲取結點的值 是一個void類型指針
#define listNodeValue(n) ((n)->value)

/* 下面3個函數主要用來設置list結構中3個函數指針，參數m為method的意思 */
#define listSetDupMethod(l,m) ((l)->dup = (m))
#define listSetFreeMethod(l,m) ((l)->free = (m))
#define listSetMatchMethod(l,m) ((l)->match = (m))

/* 下面3個函數主要用來獲取list結構的單個函數指針 */
#define listGetDupMethod(l) ((l)->dup)
#define listGetFree(l) ((l)->free)
#define listGetMatchMethod(l) ((l)->match)

3.API實現

listCreate函數：創建一個不包含任何結點的新鏈表

/*
 * listCreate 創建一個新的鏈表
 *
 * 創建成功返回鏈表，失敗返回 NULL 。
 *
 * T = O(1)
 */
list *listCreate(void)
{
    struct list *list;

    // 分配內存
    if ((list = zmalloc(sizeof(*list))) == NULL)
        return NULL;//內存分配失敗則返回NULL

    // 初始化屬性
    list->head = list->tail = NULL;//空鏈表
    list->len = 0;
    list->dup = NULL;
    list->free = NULL;
    list->match = NULL;

    return list;
}

listAddNodeHead函數：將一個包含給定值的新結點添加到給定鏈表的表頭

/*
 * listAddNodeHead 將一個包含有給定值指針 value 的新節點添加到鏈表的表頭
 *
 * 如果為新節點分配內存出錯，那麼不執行任何動作，僅返回 NULL
 *
 * 如果執行成功，返回傳入的鏈表指針
 *
 * T = O(1)
 */
list *listAddNodeHead(list *list, void *value)
{
    listNode *node;

    // 為節點分配內存
    if ((node = zmalloc(sizeof(*node))) == NULL)
        return NULL;

    // 保存值指針
    node->value = value;

    // 添加節點到空鏈表
    if (list->len == 0) {
        list->head = list->tail = node;
        //該結點的前驅和後繼都為NULL
        node->prev = node->next = NULL;
    }
    else { // 添加節點到非空鏈表
        node->prev = NULL;
        node->next = list->head;
        list->head->prev = node;
        list->head = node;
    }

    // 更新鏈表節點數
    list->len++;

    return list;
}

listAddNodeTail函數：將一個包含給定值的新結點插入到給定鏈表的表尾

/*
 * listAddNodeTail 將一個包含有給定值指針 value 的新節點添加到鏈表的表尾
 *
 * 如果為新節點分配內存出錯，那麼不執行任何動作，僅返回 NULL
 *
 * 如果執行成功，返回傳入的鏈表指針
 *
 * T = O(1)
 */
list *listAddNodeTail(list *list, void *value)
{
    listNode *node;

    // 為新節點分配內存
    if ((node = zmalloc(sizeof(*node))) == NULL)
        return NULL;

    // 保存值指針
    node->value = value;

    // 目標鏈表為空
    if (list->len == 0) {
        list->head = list->tail = node;
        node->prev = node->next = NULL;
    }//目標鏈非空
    else {
        node->prev = list->tail;
        node->next = NULL;
        list->tail->next = node;
        list->tail = node;
    }

    // 更新鏈表節點數
    list->len++;

    return list;
}

listInsertNode函數：將一個給定值的新結點插入到給定結點之前或者之後

/*
 * listInsertNode 創建一個包含值 value 的新節點，並將它插入到 old_node 的之前或之後
 *
 * 如果 after 為 0 ，將新節點插入到 old_node 之前。
 * 如果 after 為 1 ，將新節點插入到 old_node 之後。
 *
 * T = O(1)
 */
list *listInsertNode(list *list, listNode *old_node, void *value, int after) {
    listNode *node;

    // 創建新節點
    if ((node = zmalloc(sizeof(*node))) == NULL)
        return NULL;

    // 保存值
    node->value = value;

    // 將新節點添加到給定節點之後
    if (after) {
        node->prev = old_node;
        node->next = old_node->next;
        // 給定節點是原表尾節點
        if (list->tail == old_node) {
            list->tail = node;
        }
    }
    // 將新節點添加到給定節點之前
    else {
        node->next = old_node;
        node->prev = old_node->prev;
        // 給定節點是原表頭節點
        if (list->head == old_node) {
            list->head = node;
        }
    }

    // 更新新節點的前置指針
    if (node->prev != NULL) {
        node->prev->next = node;
    }
    // 更新新節點的後置指針
    if (node->next != NULL) {
        node->next->prev = node;
    }

    // 更新鏈表節點數
    list->len++;

    return list;
}

listDelNode函數：從指定的list中刪除給定的結點

/*
 * listDelNode 從鏈表 list 中刪除給定節點 node
 *
 * 對節點私有值(private value of the node)的釋放工作由調用者進行。該函數一定會成功.
 *
 * T = O(1)
 */
void listDelNode(list *list, listNode *node)
{
    // 調整前置節點的指針
    if (node->prev)
        node->prev->next = node->next;
    else
        list->head = node->next;

    // 調整後置節點的指針
    if (node->next)
        node->next->prev = node->prev;
    else
        list->tail = node->prev;

    // 釋放值
    if (list->free) list->free(node->value);

    // 釋放節點
    zfree(node);

    // 鏈表數減一
    list->len--;
}

listRelease函數：釋放給定鏈表以及鏈表中所有結點

 

/*
 * listRelease 釋放整個鏈表，以及鏈表中所有節點, 這個函數不可能會失敗.
 *
 * T = O(N)
 */
void listRelease(list *list)
{
    unsigned long len;
    listNode *current, *next;

    // 指向頭指針
    current = list->head;
    // 遍歷整個鏈表
    len = list->len;
    while (len--) {
        next = current->next;

        // 如果有設置值釋放函數，那麼調用它
        if (list->free) list->free(current->value);

        // 釋放節點結構
        zfree(current);

        current = next;
    }

    // 釋放鏈表結構
    zfree(list);
}

 

該函數不僅釋放了表結點的內存還釋放了表結構的內存

 listGetIterator函數：為給定鏈表創建一個迭代器

在講這個函數之前，我們應該先看看鏈表迭代器的結構：

// listIter 雙端鏈表迭代器
typedef struct listIter {

    // 當前迭代到的節點
    listNode *next;

    // 迭代的方向
    int direction;

} listIter;

迭起器只有兩個重要的屬性：當前迭代到的結點，迭代的方向

下面再看看鏈表的迭代器創建函數

/*
 * listGetIterator 為給定鏈表創建一個迭代器，
 * 之後每次對這個迭代器調用 listNext 都返回被迭代到的鏈表節點,調用該函數不會失敗
 *
 * direction 參數決定了迭代器的迭代方向：
 *  AL_START_HEAD ：從表頭向表尾迭代
 *  AL_START_TAIL ：從表尾想表頭迭代
 *
 * T = O(1)
 */
listIter *listGetIterator(list *list, int direction)
{
    // 為迭代器分配內存
    listIter *iter;
    if ((iter = zmalloc(sizeof(*iter))) == NULL) return NULL;

    // 根據迭代方向，設置迭代器的起始節點
    if (direction == AL_START_HEAD)
        iter->next = list->head;
    else
        iter->next = list->tail;

    // 記錄迭代方向
    iter->direction = direction;

    return iter;
}

listReleaseIterator函數：釋放指定的迭代器

/*
 * listReleaseIterator 釋放迭代器
 *
 * T = O(1)
 */
void listReleaseIterator(listIter *iter) {
    zfree(iter);
}

listRewind函數和listRewindTail函數：迭代器重新指向表頭或者表尾的函數

 

/*
 * 將迭代器的方向設置為 AL_START_HEAD,
 * 並將迭代指針重新指向表頭節點。
 *
 * T = O(1)
 */
void listRewind(list *list, listIter *li) {
    li->next = list->head;
    li->direction = AL_START_HEAD;
}

/*
 * 將迭代器的方向設置為 AL_START_TAIL,
 * 並將迭代指針重新指向表尾節點。
 *
 * T = O(1)
 */
void listRewindTail(list *list, listIter *li) {
    li->next = list->tail;
    li->direction = AL_START_TAIL;
}

listNext函數：返回當前迭代器指向的結點

 

/*
 * 返回迭代器當前所指向的節點。
 *
 * 刪除當前節點是允許的,但不能修改鏈表裡的其他節點。
 *
 * 函數要麼返回一個節點,要麼返回 NULL,常見的用法是：
 *
 * iter = listGetIterator(list,<direction>);
 * while ((node = listNext(iter)) != NULL) {
 *     doSomethingWith(listNodeValue(node));
 * }
 *
 * T = O(1)
 */
listNode *listNext(listIter *iter)
{
    listNode *current = iter->next;

    if (current != NULL) {
        // 根據方向選擇下一個節點
        if (iter->direction == AL_START_HEAD)
            // 保存下一個節點，防止當前節點被刪除而造成指針丟失
            iter->next = current->next;
        else
            // 保存下一個節點，防止當前節點被刪除而造成指針丟失
            iter->next = current->prev;
    }

    return current;
}

 

 

 

該函數保持了當前結點的下一個結點，避免了當前結點被刪除而迭代器無法繼續迭代的尷尬情況

 listDup函數：複製整個鏈表，返回副本

 

/*
 * 複製整個鏈表。
 *
 * 複製成功返回輸入鏈表的副本，
 * 如果因為內存不足而造成複製失敗，返回 NULL 。
 *
 * 如果鏈表有設置值複製函數 dup ，那麼對值的複製將使用複製函數進行，
 * 否則，新節點將和舊節點共享同一個指針。
 *
 * 無論複製是成功還是失敗，輸入節點都不會修改。
 *
 * T = O(N)
 */
list *listDup(list *orig)
{
    list *copy;//鏈表副本
    listIter *iter;//鏈表迭代器
    listNode *node;//鏈表結點

    // 創建新的空鏈表
    if ((copy = listCreate()) == NULL)
        return NULL;//創建空的鏈表失敗則返回NULL

    // 設置副本鏈表的節點值處理函數
    copy->dup = orig->dup;
    copy->free = orig->free;
    copy->match = orig->match;

    //獲取輸入鏈表的迭代器
    iter = listGetIterator(orig, AL_START_HEAD);
    
    //遍歷整個輸入鏈表進行複製
    while ((node = listNext(iter)) != NULL) {
        
        //副本結點值
        void *value;

        // 存在複製函數
        if (copy->dup) {
            
            //調用複製函數複製
            value = copy->dup(node->value);
         
            //複製結果為空，說明複製失敗
            if (value == NULL) {
                
                //複製失敗則釋放副本鏈表和迭代器，避免內存泄漏
                listRelease(copy);
                listReleaseIterator(iter);
            
                return NULL;
            }
        }
        //不存在複製函數 則直接指針指向
        else
            value = node->value;

        // 將節點添加到副本鏈表 
        if (listAddNodeTail(copy, value) == NULL) {
                
            //如果不能成功添加，則釋放副本鏈表和迭代器，避免內存泄漏
            listRelease(copy);
            listReleaseIterator(iter);
        
            return NULL;
        }
    }

    // 釋放迭代器
    listReleaseIterator(iter);

    // 返回副本
    return copy;
}

 

如果複製失敗則要注意釋放副本鏈表和迭代器，避免內存泄漏

 listSearchKey函數：查找list中值和key匹配的結點

  

/*
 * 查找鏈表 list 中值和 key 匹配的節點。
 *
 * 對比操作由鏈表的 match 函數負責進行，
 * 如果沒有設置 match 函數，
 * 那麼直接通過對比值的指針來決定是否匹配。
 *
 * 如果匹配成功，那麼第一個匹配的節點會被返回。
 * 如果沒有匹配任何節點，那麼返回 NULL 。
 *
 * T = O(N)
 */
listNode *listSearchKey(list *list, void *key)
{
    listIter *iter;//鏈表迭代器
    listNode *node;//鏈表結點

    //獲得鏈表迭代器
    iter = listGetIterator(list, AL_START_HEAD);

    //遍歷整個鏈表查詢
    while ((node = listNext(iter)) != NULL) {

        //存在比較函數
        if (list->match) {

            //利用比較函數進行比較
            if (list->match(node->value, key)) {

                //返回目標結點之前釋放迭代器空間，避免內存泄漏
                listReleaseIterator(iter);

                return node;
            }
        }
        //不存在比較函數
        else {
            //直接比較
            if (key == node->value) {

                //返回目標結點之前釋放迭代器空間，避免內存泄漏
                listReleaseIterator(iter);
                // 找到
                return node;
            }
        }
    }

    //返回目標結點之前釋放迭代器空間，避免內存泄漏
    listReleaseIterator(iter);

    // 未找到
    return NULL;
}

listIndex函數：返回鏈表在給定索引上的值

 

/*
 * 返回鏈表在給定索引上的值。
 *
 * 索引以 0 為起始，也可以是負數， -1 表示鏈表最後一個節點，諸如此類。
 *
 * 如果索引超出範圍(out of range),返回 NULL 。
 *
 * T = O(N)
 */
listNode *listIndex(list *list, long index) {
    
    listNode *n;//鏈表結點

    
    /* n不用設置成NULL的原因：
    如果索引超出範圍，
    那肯定是找到表頭或者表尾沒有找到，
    表頭的前驅和表尾的後繼都是NULL，
    所以這裏n不用設置為NULL，直接設置也可以*/
    
    // 如果索引為負數，從表尾開始查找
    if (index < 0) {
        
        //變成正數，方便索引
        index = (-index) - 1;
    
        //從尾部開始找
        n = list->tail;
        
        //尋找 因為從尾部開始找，所以是前驅
        while (index-- && n) n = n->prev;
        
    }
    
    // 如果索引為正數，從表頭開始查找
    else {
        
        //從頭部開始找
        n = list->head;
    
        //尋找 因為從頭部開始找，所以是後繼
        while (index-- && n) n = n->next;
    }

    return n;
}

listRotate函數：取出鏈表的表尾結點放到表頭，成為新的表頭結點

/*
 * 取出鏈表的表尾節點，並將它移動到表頭，成為新的表頭節點。
 *
 * T = O(1)
 */
void listRotate(list *list) {
    
    //表尾結點
    listNode *tail = list->tail;

    //如果鏈表中只有一個元素，那麼表頭就是表尾，可以直接返回
    if (listLength(list) <= 1) return;

    // 重新設置表尾節點
    list->tail = tail->prev;
    list->tail->next = NULL;

    // 插入到表頭
    list->head->prev = tail;
    tail->prev = NULL;
    tail->next = list->head;
    list->head = tail;
}

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

【其他文章推薦】

※USB CONNECTOR掌控什麼技術要點? 帶您認識其相關發展及效能

※台北網頁設計公司這麼多該如何選擇?

※智慧手機時代的來臨，RWD網頁設計為架站首選

※評比南投搬家公司費用收費行情懶人包大公開

※回頭車貨運收費標準

※聚甘新

003.OpenShift網絡

admin

一 OpenShift網絡實現

1.1 軟件定義網絡(SDN)


默認情況下，Docker網絡使用僅使用主機虛機網橋bridge，主機內的所有容器都連接至該網橋。連接到此橋的所有容器都可以彼此通信，但不能與不同主機上的容器通信。通常，這種通信使用端口映射來處理，其中容器端口綁定到主機上的端口，所有通信都通過物理主機上的端口路由。

當有大量主機和容器時，使用此模式，需要手動管理所有端口綁定非常不現實。

為了支持跨集群的容器之間的通信，OpenShift容器平台使用了軟件定義的網絡(SDN)方法。軟件定義的網絡是一種網絡模型，它通過幾個網絡層的抽象來管理網絡服務。SDN將處理流量的軟件(稱為控制平面)和路由流量的底層機制(稱為數據平面)解耦。SDN支持控制平面和數據平面之間的通信。

在OpenShift Container Platform 3.9中（之後簡稱OCP），管理員可以為pod網絡配置三個SDN插件:

  1. ovs-subnet：默認插件，子網提供了一個flat pod網絡，其中每個pod可以與其他pod和service通信。

  2. ovs-multitenant：該為pod和服務提供了額外的隔離層。當使用此插件時，每個project接收一個惟一的虛擬網絡ID (VNID)，該ID標識來自屬於該project的pod的流量。通過使用VNID，來自不同project的pod不能與其他project的pod和service通信。

  3. ovs-networkpolicy：此插件允許管理員使用NetworkPolicy對象定義自己的隔離策略。


cluster network由OpenShift SDN建立和維護，它使用Open vSwitch創建overlay網絡，master節點不能通過集群網絡訪問容器，除非master同時也為node節點。

注意：VNID為0的project可以與所有其他pod通信，在OpenShift容器平台中，默認項目的VNID為0。

1.2 Kubernetes SDN Pod




在默認的OpenShift容器平台安裝中，每個pod都有一個惟一的IP地址。pod中的所有容器都對外表現在相同的主機上。給每個pod提供自己的IP地址意味着，在端口分配、網絡、DNS、負載平衡、應用程序配置和遷移方面，pod被視為物理主機或虛擬機的獨立節點（僅從網絡層面看待）。

Kubernetes提供了service的概念，在任何OpenShift應用程序中，service都是必不可少的資源。service充當一個或多個pod前的負載平衡器。該service提供一個固定的IP地址，並且允許與pod通信，而不必跟蹤單獨的pod IP地址。



大多數實際應用程序都不是作為單個pod運行的。它們需要水平伸縮，這樣應用程序就可以在許多pod上運行，以滿足不斷增長的用戶需求。在OpenShift集群中，pod不斷地在集群中的節點之間創建和銷毀。每次創建pod時，它們都會獲得一個不同的IP地址。一個service提供一個單獨的、惟一的IP地址供其他pod使用，而不依賴於pod運行的節點，因此一個pod不必一定需要發現另一個pod的IP地址。客戶端通過service的請求在不同pod之間實現負載均衡。

1.3 Kubernetes SDN Service


service背後運行的一組pod由OpenShift容器平台自動管理。每個service都被分配了一個唯一的IP地址供客戶端連接。這個IP地址也來自OpenShift SDN，它與pod的內部網絡不同，也只在集群中可見。每個與selector匹配的pod都作為endpoint添加到service資源中。當創建和銷毀pods時，service後面的endpoint將自動更新。

service yaml語法：

  1 - apiVersion: v1
  2   kind: Service			#聲明資源類型
  3   metadata:
  4     labels:
  5       app: hello-openshift
  6       name: hello-openshift	#服務的唯一名稱
  7   spec:
  8     ports:，
  9     - name: 8080-tcp
 10       port: 8080		#服務對外公開的端口客戶機連接到服務端口
 11       protocol: TCP
 12       targetPort: 8080		#targetPort屬性必須匹配pod容器定義中的containerPort，服務將數據包轉發到pod中定義的目標端口。
 13     selector:			#該服務使用selector屬性查找要轉發數據包的pod。目標pod的元數據中需要有匹配的標籤。如果服務發現多個具有匹配標籤的pod，它將在它們之間實現負載
 14       app: hello-openshift
 15       deploymentconfig: hello-openshift


1.4 service對外暴露


默認情況下，pod和service IP地址不能從OpenShift集群外部訪問。對於需要從OpenShift集群外部訪問服務的應用程序，可以通過以下三種方式。

HostPort/HostNetwork：在這種方法中，client可以通過主機上的網絡端口直接訪問集群中的應用程序pod。應用程序pod中的端口被綁定到運行該pod的主機上的端口。這種方法在集群中運行大量pod時，存在端口衝突的風險。

NodePort：這是一種較老的基於Kubernetes的方法，通過綁定到node主機上的可用端口，將service公開給外部客戶端，然後node主機代理到service IP地址的連接。使用oc edit svc命令編輯服務屬性，指定NodePort的類型，併為NodePort屬性提供端口值。OpenShift然後通過node主機的公共IP地址和nodePort中設置的端口值代理到服務的連接。這種方法支持非http通信。

OpenShift routes：OpenShift中的推薦方式。它使用唯一的URL公開服務。使用oc expose命令公開用於外部訪問的服務，或者從OpenShift web控制台公開服務。在這種方法中，目前只支持HTTP、HTTPS、TLS whit SNI和WebSockets。

附圖：显示了NodePort服務如何允許外部訪問Kubernetes服務。



service nodeport yaml語法：

  1 apiVersion: v1
  2 kind: Service
  3 metadata:
  4 ...
  5 spec:
  6   ports:
  7   - name: 3306-tcp
  8     port: 3306
  9     protocol: TCP
 10     targetPort: 3306	#pod目標端口，即需要和pod定義的端口匹配
 11     nodePort: 30306	#OpenShift集群中主機上的端口，暴露給外部客戶端
 12   selector:
 13     app: mysqldb
 14     deploymentconfig: mysqldb
 15     sessionAffinity: None
 16   type: NodePort	#服務的類型，如NodePort
 17 ...



OpenShift將服務綁定到服務定義的nodePort屬性中定義的值，併為集群中所有node（包括master）上的流量打開該端口。外部客戶端可以連接到node端口上的任何節點的公共IP地址來訪問服務。請求會在服務後面的各個pod之間實現輪詢的負載平衡。

OpenShift route主要限於HTTP和HTTPS流量，但是節點端口可以處理非HTTP流量，當設置好公開的端口后，客戶機可以使用TCP或UDP的協議連接到該端口。

提示：缺省情況下，NodePort屬性的端口號限制在30000-32767之間，可通過在OpenShift主配置文件中配置範圍。

node port在集群中的所有node上都是打開的，包括master節點。如果沒有提供node端口值，OpenShift將自動在配置範圍內分配一個隨機端口。

1.5 pod訪問外部網絡


pod可以使用其主機的地址與外部網絡通信。只要主機能夠解析pod需要到達的服務器，pod就可以使用網絡地址轉換(network address translation, NAT)機制與目標服務器通信。

二 OpenShift SDN練習

2.1 前置準備


[student@workstation ~]$ lab install-prepare setup

[student@workstation ~]$ cd /home/student/do280-ansible

[student@workstation do280-ansible]$ ./install.sh

提示：以上準備為部署一個正確的OpenShift平台。

2.2 本練習準備


[student@workstation ~]$ lab openshift-network setup #準備本實驗環境

2.3 創建應用


[student@workstation ~]$ oc login -u developer -p redhat https://master.lab.example.com

[student@workstation ~]$ oc new-project network-test #創建project

[student@workstation ~]$ oc new-app –name=hello -i php:7.0 http://registry.lab.example.com/scaling

[student@workstation ~]$ oc get pods

NAME READY STATUS RESTARTS AGE

hello-1-build 1/1 Running 0 8s

2.4 擴展應用


[student@workstation ~]$ oc scale –replicas=2 dc hello

[student@workstation ~]$ oc get pods -o wide

NAME READY STATUS RESTARTS AGE IP NODE

hello-1-kszfh 1/1 Running 0 11m 10.128.0.21 node1.lab.example.com

hello-1-q7wk2 1/1 Running 0 11m 10.129.0.37 node2.lab.example.com

2.5 測試訪問


[student@workstation ~]$ curl http://10.128.0.21:8080

curl: (7) Failed connect to 10.128.0.21:8080; Network is unreachable

[root@node1 ~]# curl http://10.128.0.21:8080

  1 <html>
  2  <head>
  3   <title>PHP Test</title>
  4  </head>
  5  <body>
  6  <br/> Server IP: 10.128.0.21
  7  </body>
  8 </html>
  9 [root@node1 ~]# curl http://10.129.0.37:8080
 10 <html>
 11  <head>
 12   <title>PHP Test</title>
 13  </head>
 14  <body>
 15  <br/> Server IP: 10.129.0.37
 16  </body>
 17 </html>



提示：默認情況下，pod的ip屬於內部，集群內部節點可以使用pod ip訪問，集群外部（如workstation）無法訪問。

[student@workstation ~]$ oc get svc hello

NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE

hello ClusterIP 172.30.253.212 <none> 8080/TCP 14m

[student@workstation ~]$ curl http://172.30.253.212:8080

curl: (7) Failed connect to 172.30.253.212:8080; Network is unreachable

[root@node1 ~]# curl http://172.30.253.212:8080 #驗證負載均衡

  1 <html>
  2  <head>
  3   <title>PHP Test</title>
  4  </head>
  5  <body>
  6  <br/> Server IP: 10.128.0.21
  7  </body>
  8 </html>
  9 [root@node1 ~]# curl http://172.30.253.212:8080		#驗證負載均衡
 10 <html>
 11  <head>
 12   <title>PHP Test</title>
 13  </head>
 14  <body>
 15  <br/> Server IP: 10.129.0.37
 16  </body>
 17 </html>



提示：默認情況下，cluster的ip屬於內部，集群內部節點可以使用cluster ip訪問，集群外部（如workstation）無法訪問。

2.6 檢查服務


[student@workstation ~]$ oc describe svc hello

Name: hello

Namespace: network-test

Labels: app=hello

Annotations: openshift.io/generated-by=OpenShiftNewApp

Selector: app=hello,deploymentconfig=hello

Type: ClusterIP

IP: 172.30.253.212

Port: 8080-tcp 8080/TCP

TargetPort: 8080/TCP

Endpoints: 10.128.0.21:8080,10.129.0.37:8080

Session Affinity: None

Events: <none>

解釋：

endpoint：显示請求路由到的pod IP地址列表。當pod有更新后，endpoint將自動更新。

Selector：OpenShift使用為pods定義的選擇器和標籤來使用給定的集群IP，以便實現應用的負載均衡。如上所示為OpenShift將此服務的請求路由到所有標記為app=hello和deploymentconfig=hello的pod。

2.7 檢查pod


[student@workstation ~]$ oc describe pod hello-1-kszfh

2.8 設置外部訪問


使用NodePort方式設置外部訪問。

[student@workstation ~]$ oc edit svc hello

  1 apiVersion: v1
  2 kind: Service
  3 metadata:
  4   annotations:
  5     openshift.io/generated-by: OpenShiftNewApp
  6   creationTimestamp: 2019-07-19T15:50:09Z
  7   labels:
  8     app: hello
  9   name: hello
 10   namespace: network-test
 11   resourceVersion: "24496"
 12   selfLink: /api/v1/namespaces/network-test/services/hello
 13   uid: e348e2a3-aa3c-11e9-b230-52540000fa0a
 14 spec:
 15   clusterIP: 172.30.253.212
 16   ports:
 17   - name: 8080-tcp
 18     port: 8080
 19     protocol: TCP
 20     targetPort: 8080
 21     nodePort: 30800
 22   selector:
 23     app: hello
 24     deploymentconfig: hello
 25   sessionAffinity: None
 26   type: NodePort
 27 status:



[student@workstation ~]$ oc describe svc hello

Name: hello

Namespace: network-test

Labels: app=hello

Annotations: openshift.io/generated-by=OpenShiftNewApp

Selector: app=hello,deploymentconfig=hello

Type: NodePort #驗證是否為NodePort

IP: 172.30.253.212

Port: 8080-tcp 8080/TCP

TargetPort: 8080/TCP

NodePort: 8080-tcp 30800/TCP

Endpoints: 10.128.0.21:8080,10.129.0.37:8080

Session Affinity: None

External Traffic Policy: Cluster

Events: <none>

2.9 驗證外部訪問


[student@workstation ~]$ curl http://node1.lab.example.com:30800

  1 <html>
  2  <head>
  3   <title>PHP Test</title>
  4  </head>
  5  <body>
  6  <br/> Server IP: 10.128.0.21
  7  </body>
  8 </html>



[student@workstation ~]$ curl http://node2.lab.example.com:30800

  1 <html>
  2  <head>
  3   <title>PHP Test</title>
  4  </head>
  5  <body>
  6  <br/> Server IP: 10.129.0.37
  7  </body>
  8 </html>


2.10 使用pod shell


[student@workstation ~]$ oc rsh hello-1-kszfh #使用pod的shell

sh-4.2$ curl http://services.lab.example.com

三 OpenShift router

3.1 OpenShift route概述


OpenShift service允許在OpenShift中的pod之間進行網絡訪問；

OpenShift routes允許從OpenShift外部對pods進行網絡訪問。



路由概念上是通過連接公網IP和DNS主機名訪問內網service IP。在實踐中，為了提高性能和減少延遲，OpenShift route通過OpenShift創建的網絡直接連接到pod，使用該服務只查找endpoint，service只是協助查詢Pod地址。

OpenShift 路由功能由router service提供，該服務在OpenShift實例中作為一個pod運行，可以像任何其他常規pod一樣伸縮和複製。router service基於開源軟件HAProxy實現。

OpenShift route配置的公共DNS主機名需要指向運行router的節點的公共IP地址。route pod與常規應用程序pod不同，它綁定到節點的公共IP地址，而不是內部pod網絡。這通常使用DNS通配符配置。

  1 - apiVersion: v1
  2   kind: Route				#聲明為route類型
  3   metadata:
  4     creationTimestamp: null
  5     labels:
  6       app: quoteapp
  7     name: quoteapp				#路由器名字
  8   spec:
  9     host: quoteapp.apps.lab.example.com	#與route關聯的FQDN，必須預先配置，以解析到OpenShift route pod運行的節點的IP地址
 10     port:
 11       targetPort: 8080-tcp
 12   to:					#一個對象，該對象聲明此route指向的資源類型(在本例中是OpenShift service)，以及該資源的名稱(quoteapp)
 13     kind: Service
 14     name: quoteapp



提示：不同資源類型可以使用相同的名稱，如一個名為quoteapp的route可以指向一個名為quoteapp的service。

service通過selector與pod的label進行匹配，router通過name與service的name匹配。

3.2 創建route


創建route最簡單和推薦的方法是使用oc expose命令，將service資源名稱作為輸入參數。–name選項可用於控制route資源的名稱，–hostname選項可用於為route提供自定義主機名。

示例：

[user@demo ~]$ oc expose service quote \

–name quote –hostname=quoteapp.apps.lab.example.com

從模板或不帶–hostname參數的oc expose命令創建的路由，命名方式為：

<route-name>-<project-name>.<default-domain>

解釋

route-name：route的名稱，或原始資源的名稱；

project-name：包含資源的項目的名稱；

default-domain：該值是在OpenShift master上配置的，它對應於作為安裝OpenShift先決條件列出的通配符DNS域。

例如，在OpenShift集群中名為test的project中創建一條名為quote的路由，其中子域為apps.example.com，則FQDN為quote-test.apps.example.com

注意：承載通配符域的DNS服務器不知道任何route的主機名，它只將任何名稱解析為已配置的ip。只有OpenShift route知道route主機名，將每個主機都當作HTTP虛擬主機。無效的通配符域主機名，即不與任何route對應的主機名，將被OpenShift路由器阻塞。

通過向oc create提供JSON或YAML資源定義文件，也可以像其他OpenShift資源一樣創建route資源。

oc new-app命令在從容器映像、Dockerfiles或應用程序源代碼構建pod時不創建route資源。

oc new-app命令不知道pod是否打算從OpenShift實例外部訪問。當oc new-app命令從模板創建一組pod時，沒有什麼可以阻止模板將路由資源包含到應用程序中。

3.3 查找默認subdomain


默認路由子域是在OpenShift配置文件master-config.yaml中的routingConfig字段中定義，使用關鍵字subdomain。

routingConfig:

subdomain: apps.example.com

默認情況下，OpenShift HAProxy route綁定到主機端口80 (HTTP)和443 (HTTPS)。route必須放置在這些端口不使用的節點上。或者，可以通過設置ROUTER_SERVICE_HTTP_PORT和ROUTER_SERVICE_HTTPS_PORT環境變量來配置路由器監聽其他端口.

路由器支持以下協議：

  • HTTP


  • HTTPS with SNI

  • WebSockets

  • TLS with SNI

3.4 routing類型和選項


路由可以是安全的，也可以是非安全的。安全route提供了使用幾種類型的TLS方式來向客戶端提供證書的能力。不安全路由是最容易配置的，因為它們不需要密鑰或證書，但是安全路由會加密進出pod的流量。

在創建安全路由之前，需要生成TLS證書。

示例：如下步驟創建名為test.example.com的路由創建一個簡單的自簽名證書。

  • 使用openssl命令創建私鑰：


[user@demo ~]$ openssl genrsa -out example.key 2048

  • 使用生成的私鑰創建證書籤名請求(CSR)：


[user@demo ~]$ openssl req -new -key example.key -out example.csr -subj “/C=US/ST=CA/L=Los Angeles/O=Example/OU=IT/CN=test.example.com”

  • 使用密鑰和CSR生成證書


[user@demo ~]$ openssl x509 -req -days 366 -in example.csr -signkey example.key -out example.crt

  • 當證書準備好時，創建一個edge-terminated的路由


[user@demo ~]$ oc create route edge –service=test \

–hostname=test.example.com \

–key=example.key –cert=example.crt

3.5 通配符子域


wildcard policy允許用戶定義domain中所有主機的route。route可以使用wildcardPolicy字段將wildcard policy指定為其配置的一部分。OpenShift路由器支持通配符路由，通過設置路由器部署配置中的ROUTER_ALLOW_WILDCARD_ROUTES環境變量為true，從而可將wildcardPolicy屬性設置為子域的任何route都由路由器提供服務。路由器根據route的通配符策略暴露相關的service。

示例：如下下示例表示對於三個不同的路由，a.lab.example.com、b.lab.example.com和c.lab.example.com，它們應該路由到一個名為test的OpenShift服務，可以使用通配符策略配置路由。

  • 將路由器作為集群管理用戶處理通配符路由


[user@demo ~]$ oc scale dc/router –replicas=0

[user@demo ~]$ oc set env dc/router ROUTER_ALLOW_WILDCARD_ROUTES=true

[user@demo ~]$ oc scale dc/router –replicas=1

  • 使用通配符策略創建新路由


[user@demo ~]$ oc expose svc test –wildcard-policy=Subdomain \

–hostname=’www.lab.example.com’

3.6 管理route


在master節點上，在default中查找router

[root@master]# oc project default

[root@master]# oc get pods

在master節點上，檢查路由器環境變量，以找到運行在pod中的HAProxy進程的連接參數

[root@master]# oc env pod router-1-32toa –list | tail -n 6

提示：當創建路由器時，STATS_PASSWORD變量中的密碼是隨機生成的。STATS_USERNAME和STATS_PORT變量有固定的默認值，但是它們都可以在路由器創建時更改。

在router運行的節點上，配置firewall-cmd以打開STATS_PORT變量指定的端口。

[root@node ~]# firewall-cmd –permanent –zone=public –add-port=1936

[root@node ~]# firewall-cmd –reload

打開web瀏覽器並訪問HAProxy statistics URL 為 http://nodeIP:STATS_PORT/。

在User Name字段中輸入STATS_USERNAME的值，在Password字段中輸入STATS_PASSWORD的值，然後單擊OK。則會显示的HAProxy metrics頁面。

四 創建Route練習

4.1 前置準備


準備完整的OpenShift集群，參考《003.OpenShift網絡》2.1。

4.2 本練習準備


[student@workstation ~]$ lab secure-route setup #準備本實驗環境

4.3 創建應用


[student@workstation ~]$ oc login -u developer -p redhat https://master.lab.example.com

[student@workstation ~]$ oc new-project secure-route #創建project

[student@workstation ~]$ oc new-app –docker-image=registry.lab.example.com/openshift/hello-openshift –name=hello

[student@workstation ~]$ oc get pods -o wide

NAME READY STATUS RESTARTS AGE IP NODE

hello-1-wwgkr 1/1 Running 0 20s 10.129.0.38 node2.lab.example.com

4.4 創建TLS證書


[student@workstation ~]$ cd /home/student/DO280/labs/secure-route/ #使用環境中的腳本快速創建TLS自簽名證書

[student@workstation secure-route]$ ./create-cert.sh

4.5 創建route


[student@workstation secure-route]$ ll

-rw-r–r–. 1 student student 550 Aug 7 2018 commands.txt

-rwxr-xr-x. 1 student student 506 Jul 19 2018 create-cert.sh

-rw-rw-r–. 1 student student 1224 Jul 20 10:43 hello.apps.lab.example.com.crt

-rw-rw-r–. 1 student student 1017 Jul 20 10:43 hello.apps.lab.example.com.csr

-rw-rw-r–. 1 student student 1679 Jul 20 10:43 hello.apps.lab.example.com.key

[student@workstation secure-route]$ oc create route edge \

> –service=hello –hostname=hello.apps.lab.example.com \

> –key=hello.apps.lab.example.com.key \

> –cert=hello.apps.lab.example.com.crt

4.6 確認驗證


[student@workstation secure-route]$ oc get route

NAME HOST/PORT PATH SERVICES PORT TERMINATION WILDCARD

hello hello.apps.lab.example.com hello 8080-tcp edge None

[student@workstation secure-route]$ oc get route hello -o yaml #以yaml格式查看route

4.7 測試訪問


[student@workstation ~]$ curl http://hello.apps.lab.example.com #以http形式訪問會無法轉發至後端任何pod

  1 ……
  2       <h1>Application is not available</h1>
  3       <p>The application is currently not serving requests at this endpoint. It may not have been started or is still starting.</p>
  4 ……



[student@workstation ~]$ curl -k -vvv https://hello.apps.lab.example.com #以https形式訪問

  1 ……
  2 Hello OpenShift!
  3 * Connection #0 to host hello.apps.lab.example.com left intact
  4 ……


4.8 非安全形式訪問


由於加密的通信在路由器上終止，並且請求使用不安全的HTTP轉發到pods，所以可以使用pod IP地址通過普通HTTP訪問應用程序。為此，請使用oc get pods -o命令中指定的IP地址。

[student@workstation secure-route]$ oc get pod -o wide

NAME READY STATUS RESTARTS AGE IP NODE

hello-1-wwgkr 1/1 Running 0 21m 10.129.0.38 node2.lab.example.com

[root@node1 ~]# curl -vvv http://10.129.0.38:8080


五 OpenShift網絡綜合實驗

5.1 前置準備


準備完整的OpenShift集群，參考《003.OpenShift網絡》2.1。

5.2 本練習準備


[student@workstation ~]$ lab network-review setup

5.3 驗證所需資源


[student@workstation ~]$ oc login -u developer -p redhat \

https://master.lab.example.com

[student@workstation ~]$ oc get pod -o wide

NAME READY STATUS RESTARTS AGE IP NODE

hello-openshift-1-6ls8z 1/1 Running 0 2m 10.128.0.23 node1.lab.example.com

[student@workstation ~]$ oc get svc

NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE

hello-openshift ClusterIP 172.30.124.237 <none> 8080/TCP,8888/TCP 2m

[student@workstation ~]$ oc get route

NAME HOST/PORT PATH SERVICES PORT TERMINATION WILDCARD

hello-openshift hello.apps.lab.example.com hello-opensift 8080-tcp None

5.4 測試訪問


[student@workstation ~]$ curl http://hello.apps.lab.example.com #測試http訪問

  1 ……
  2       <h1>Application is not available</h1>
  3       <p>The application is currently not serving requests at this endpoint. It may not have been started or is still starting.</p>
  4 ……

[root@node1 ~]# curl http://10.128.0.23:8080 #測試使用pod ip訪問

Hello OpenShift!

[root@node1 ~]# curl http://172.30.124.237:8080 #測試使用cluster ip訪問

curl: (7) Failed connect to 172.30.124.237:8080; Connection refused

5.5 TS cluster故障


[student@workstation ~]$ oc describe svc hello-openshift -n network-review



提示：由上可知，沒有endpoint，endpoint是使用selector對pod的label進行匹配。

[student@workstation ~]$ oc describe pod hello-openshift-1-6ls8z #查看pod詳情



故障點：由上可知，Selector的label不一致，則沒有標記為hello_openshift的pod能進行匹配。

[student@workstation ~]$ oc edit svc hello-openshift

  1 ……
  2   selector:
  3     app: hello-openshift
  4     deploymentconfig: hello-openshift
  5   sessionAffinity: None
  6 ……


5.6 測試訪問


[root@node1 ~]# curl http://10.128.0.23:8080 #測試使用pod ip訪問

Hello OpenShift!

[root@node1 ~]# curl http://172.30.124.237:8080 #再次測試

Hello OpenShift!

[student@workstation ~]$ curl http://hello.apps.lab.example.com #測試http訪問

  1 ……
  2       <h1>Application is not available</h1>
  3       <p>The application is currently not serving requests at this endpoint. It may not have been started or is still starting.</p>
  4 ……


5.7 TS route故障


[student@workstation ~]$ oc describe route hello-openshift



故障點：由上可知，此路由沒有endpoint。即對route的URL請求沒有後端endpoint進行響應。路由器查詢service的endpoint，並註冊有效的endpoint來實現負載平衡。同時發現service名稱中有一個拼寫錯誤，它應該是hello-openshift。

[student@workstation ~]$ oc edit route hello-openshift

  1 ……
  2 spec:
  3   host: hello.apps.lab.example.com
  4   port:
  5     targetPort: 8080-tcp
  6   to:
  7     kind: Service
  8     name: hello-openshift
  9     weight: 100
 10   wildcardPolicy: None
 11 ……



[root@node1 ~]# curl http://hello.apps.lab.example.com #再次測試

Hello OpenShift!

5.8 確認驗證


[student@workstation ~]$ lab network-review grade #使用腳本判斷 本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※帶您來了解什麼是 USB CONNECTOR  ?

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

※如何讓商品強力曝光呢? 網頁設計公司幫您建置最吸引人的網站，提高曝光率!

※綠能、環保無空污,成為電動車最新代名詞，目前市場使用率逐漸普及化

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

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

※聚甘新

年僅 28 歲就宣布從字節跳動退休？

admin

這两天，互聯網熱議最大的一個話題除了阿里 P8 程序員找生活助理的事，另外一個就是 28 歲的郭宇宣布從字節跳動退休，稱選擇經營溫泉旅行，選擇成為一名職業作家。

我看到這個話題的時候，情不自禁地“嘖嘖”了兩聲，真特么酸了，28 歲就退休了，我已經 31 歲了，還在辛苦打拚的路上，除了要忙工作，還要高產似母豬地更文，然而，即便我這麼努力，還是沒能成為一名“職業作家”，退休更是遙遙無期。

郭大佬非常牛逼的一點在於，高考之後就開始敲代碼，上了大學之後依然敲代碼，大三就在支付寶干過，然後創業的一家公司被字節跳動收購，再然後嘛，就財務自由退休了——28 歲，重新定義了退休的年紀。

字節跳動這家公司發展的真的是巨快，明星產品今日頭條和抖音，真的是國民級應用。反正我父母都是這兩款產品的忠實用戶，我妹妹雖然不玩今日頭條，但抖音玩得那叫一個熱火朝天。

我自己是不玩抖音也不看今日頭條的，因為覺得這種短視頻，或者說亂七八糟的新聞熱點有點浪費生命的感覺，所以一直很抵觸。

當然了，我如果說我一次也沒玩過，有點聖人的感覺，我做不到。但每次無聊到刷上倆小時的抖音，我就會噁心到把這款軟件卸載掉。尤其是聽到那些無厘頭的狂笑，我感覺到娛樂在致死。

這不是抖音的問題，是我的問題，是人性的問題，抖音就抓住了人性的弱點，讓你沉浸其中，忘乎所以。

抨擊歸抨擊，但我不能忽視的事實是，字節跳動是真的牛逼，郭大佬是真的有錢了。

每個人都有自己人生，郭大佬有實力又有運氣，他過的是一種極致的人生。

我是 2014 年回的洛陽，一回來就跟着一個老闆做創業項目，依稀還記得當初他給我許下的承諾：三年後讓你在洛陽買房買車，五年後帶你走上人生巔峰。

2015 年，我買了房，靠的是我和老婆辛苦攢下的一些積蓄，還有父母義無反顧的支持。老闆也借給了我兩三萬，一年後我就還他了，所以在買房這個承諾上，他有幫助，但遠非承諾中的那樣。

2016 年，我買了車，分期付款的那種，和老闆沒有一點關係。

至於五年後走上人生巔峰，更是瞎扯淡。我現在還是一名普通的程序員，生活的幸福指數也完全靠的是自己的付出。

這些年裡，老闆無數次胯下海口，聽得我耳朵都膩了。至於我為什麼還沒有離職，並不是我沉浸在溫柔故鄉，而是洛陽的軟件環境整體就這麼個樣，去哪都是打工，還不如自己踏踏實實做一些事情，比如說寫作。

對比我倆，就會發現一些很有意思的點，我來給同學們剖析一下。

1）學歷重不重要

很重要，郭大佬讀過深圳高級中學，深圳最好的高中之一，大學是暨南大學，211。

我呢，高中雖然是保送的，但那時候的學校已經走了下坡路，很動蕩，師資和校領導換了好幾波；然後我上的是一所大專。

所以我大學那會很自卑，即便專業是計算機網絡，也沒多少心思學習。而郭大佬就完全不一樣了，沉下一門心思學編程，為此還掛科了好幾門。因為他是非科班出身，專業是政治與行政管理。

假如，請允許我假如一下，給低學歷的同學們一點點信心。

假如我上大學那會一門心思撲倒編程上，大三也不至於出去參加培訓，真的，大把大把的時光我都浪費了。除了談戀愛是正事，我就只會打遊戲了。

假如拿現在的心態去過大學兩年的時光，我堅信，我一定能進阿里，因為拼過和沒拼過的人生差別巨大。

我就認識這樣一個初中小妹妹，平常老喊我二叔，搞得我都逆來順受了。她的成績非常優異，全年級第二名，為什麼不是第一名，因為語文成績拖了後腿。這不是關鍵，關鍵是小妹妹現在就開始學編程了，還去給初一的同學授過課。

後生可畏。

所以，我的結論就是，能通過學習改變命運，就下勁學，錯過這個年紀就真的沒機會了。如果真的上了大專，上了一般的本科，也不是沒有機會，別整天喊自己迷茫，誰的青春沒有迷茫過，關鍵是要發掘自己的興趣點，如果要從事程序員這個行業，就好好學編程。

2）要不要創業

十個創業九個坑，我只能這麼說，能進大廠進大廠，進不去進中廠，進不去中廠進小廠。如果非要創業，也得你自身實力夠硬，假如創業失敗，你還有出路，或者實在是沒有其他更好的選擇了，再選擇創業。

職場新人最好不要被忽悠去創業，太慘了。

你看，人家郭大佬在支付寶鍍了一層金，然後所在公司稀里糊塗被字節跳動收購了，這是運氣，沒得說。

大部分人的命運可能像我一樣，在日企待過三年半，有了一些資歷，然後作為技術大拿參与到創業公司，一開始老闆牛逼吹上天，最後，啥也沒撈着。

青春荒廢了，人際關係荒廢了，程序員的黃金年齡段也荒廢了。

3）要不要提前退休

有不少同學問過我這樣的話題，“二哥，我馬上到了結婚的年紀，雖然在一線城市掙得還可以，但遠沒到能買得起房子的水準，可能這輩子都不可能了，我想現在回二線城市或者三線城市，你看可行嗎？”

這種想法，其實就和郭大佬退休的想法是一致的，只不過郭財務自由了。

對於普通人來說，我的建議是這樣的，請認認真真做好筆記。

第一，不要盲目回二三線。

拿洛陽來說吧，一般程序員的極限工資就是一萬塊，撐死的那種。五險一金，包括獎金，能沒有公司就考慮沒有。

捫心自問一下，自己能否承受得起這份清心寡慾。另外，二三線城市也是會加班的，關鍵是不一定有加班工資。

第二，搞一份副業吧，同學們。

在一線城市，你可能沒有精力和時間搞副業，另外，主業的成長潛力並不比副業差，搞的意義不是特別大。但如果要回二三線，副業必須得搞，哪怕掙個零花錢，心裏不慌。

幸福指數高不高，離不開錢那，雖然很俗。粗茶淡飯沒問題，二三線城市的生活成本相對較低是真的，但你的掙錢能力也得匹配上吧，匹配不上的話，活得就會很累的。

我羡慕郭大佬，有些同學可能羡慕我，覺得我的幸福指數也很高。那我要告訴你的真相就是，我既要忙工作，還要讀書寫作，也是很拼的。

人生就是這樣，為別人的成功送上祝福的同時，不要忘記腳踏實地地活着。

如果覺得文章對你有點幫助，請微信搜索「 沉默王二 」第一時間閱讀。

本文已收錄 GitHub，傳送門~ ，裏面更有大廠面試完整考點，歡迎 Star。

我是沉默王二，一枚有顏值卻靠才華苟且的程序員。關注即可提升學習效率，別忘了三連啊，點贊、收藏、留言，我不挑，嘻嘻。

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

【其他文章推薦】

※為什麼 USB CONNECTOR 是電子產業重要的元件?

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

※台北網頁設計公司全省服務真心推薦

※想知道最厲害的網頁設計公司“嚨底家”!

※推薦評價好的iphone維修中心

※聚甘新

Jmeter系列（21）- 詳解 HTTP Request

admin

如果你想從頭學習Jmeter，可以看看這個系列的文章哦

https://www.cnblogs.com/poloyy/category/1746599.html

 

HTTP Request 介紹

用來發送 HTTP、HTTPS 協議請求

 

HTTP Request 界面

字段名 作用
名稱 不多介紹啦，建議自定義一個識別度高的名稱
註釋 對於測試沒有任何影響，僅記錄作用
協議

http或https，大小寫不敏感

默認：http
服務器名稱或IP
  • 服務器 host 或者 ip，不包括協議
  • 比如：www.baidu.com、192.168.196.128
端口號 目標服務器的端口號，默認：80
方法 發送 http 請求的方法
路徑
  • 目標請求的 URL 路徑
  • 不包括協議、host、ip、端口
內容編碼 請求的編碼方式，默認：iso8859
自動重定向
  • 發出的請求的響應碼是3**，會自動跳轉到新目標頁面
  • 只記錄最終頁面的返回結果
跟隨重定向
  • 和自動重定向唯一不同的是：
  • 會記錄重定向過程中的的所有請求的響應結果
使用 KeepAlive
  • jmeter 和目標服務器之間使用 Keep-Alive 方式進行 HTTP 通信
  • 真正做性能測試強烈建議不勾選
對POST使用multipart/form-data post 請求需要上傳文件時勾選
與瀏覽器兼容的頭
  • 當勾選 multipart/form-data 時，勾選此項
  • http請求頭中的 Content-Type 和Content-Transfer-Encoding 被忽略
  • 而只發送 Content-Disposition 部分

 

Parameters 講解

字段 描述
Name 參數名
Value 參數值
URL Encode?
  • 是否要 URL 編碼？
  • 重點：如果參數值包含了中文、特殊字符（非数字字母以外），最好勾上，當然全都勾上最穩妥
Content-Type
  • 參數值的資源類型
  • 默認：text/plain
Include Equals?
  • 當你的參數值為空的時候，可以選擇不包含=，默認勾選
  • 如果參數值不為空，則不可以取消勾選

 

什麼是 URL 編碼

  • URL 編碼解碼，又叫百分號編碼，是統一資源定位（URL）的編碼方式
  • URL 地址（常說網址）規定了数字，字母可以直接使用，另外一批作為特殊用戶字符也可以直接用（ / , : @  等），剩下的其它所有字符必須通過 %xx 編碼處理
  • 編碼方法很簡單，在該字符ascii碼的的16進制字符前面加%，如空格字符，ascii碼是32，對應16進制是20，那麼 urlencode 編碼結果是 %20 

 

URL 編碼的栗子

直接在網上搜在線 URL 編解碼

 

include equals 的栗子

參數值為空，且勾選 Include equals

 

參數值為空，但不勾選  Include equals

 

其實說的就是等於號而已，一般也不會傳空值，即使傳了也會帶上=

 

Body Data 講解

  • 沒啥好說的，傳 json 字符串就行了，注意下格式，後面再講具體栗子
  • 不過倒有個重點：如果 Parameters 有參數列表的話，是無法切換到 Body Data 的哦

 

Files Upload 講解

字段 描述
File Path 文件的本地路徑
Parameter Name 參數名
MIME Type 資源媒體類型

 

常見資源媒體類型

類型 文件後綴 格式
超文本標記語言文本 .html text/html
普通文本 .txt text/plain
XML 文件 .xml text/xml
PNG 圖片 .png image/png
GIF .gif image/gif
JPEG 圖片 .jpeg、jpg  image/jpeg

 

類型 文件後綴 格式
表單中進行文件上傳   multipart/form-data
表單默認提交數據的格式   application/x-www-form-urlencoded
XML 數據格式   application/xml
JSON 數據格式   application/json
PDF 文件 .pdf application/pdf
RTF 文本 .rtf application/rtf
GZIP 文件  .gz application/x-gzip
TAR 文件 .tar application/x-tar
AVI 文件 .avi  video/x-msvideo
MPEG 文件 .mpg、.mpeg video/mpeg

 

不同的content-type在jmeter中如何輸入參數

前提

因為是需要真實接口進行測試的，這裏提供兩種方案

  • 自己用 Flask 框架開發了本地的接口進行測試， 如果有需要的同學進群領取哦：870155189
  • 或者進入 http://open.yesapi.cn/?r=user/registration&from=wx_837493986，直接註冊個賬號，弄個免費會員，有在線免費的接口提供測試哦

 

application/x-www-form-urlencoded 的栗子

備註：也是表單提交最常見的栗子

 

Parameters 方式傳參

 

總結

  • 最終表單的參數列表會拼接到 URL 中，所以如果包含了中文、特殊字符就要勾選編碼？哦
  • 這裏不可以通過 Body Data 傳遞參數哦，會無法識別到參數，已實踐過（即使加了 HTTP請求頭也不行），乖乖用 Parameters 的方式傳參

 

content-type:application/json 的栗子

Body Data 方式傳參

 

添加 HTTP請求頭

 

請求體

 

請求頭

 

結論

重點就是添加 HTTP請求頭，指明 Content-type 是 json 格式

 

content-type:multipart/form-data

重點：用於 post 請求，需要文件上傳的場景；記住不是 get 請求

 

請求參數列表

如果選了 get 方法的話，文件參數是不會生效哦

 

文件參數

 

請求體

 

重點

  • 如果添加了 HTTP請求頭，請務必不要添加 content-type : multipart/form-data 
  • 如果加了的話：那麼所有的請求參數都會被當成文件以二進制形式傳輸，我們 parameters 里的文本格式參數就不會被識別，接口會提示參數為空

 

HTTP Request Advance

說實話我還沒用過這部分的內容，不過還是得了解下每個配置項是什麼意思哦

 

Client implemention 和 Timeouts

字段 描述
implementation 發送http請求的方式，可選項為 java、HttpClient4（默認）
Connect 連接超時時間，單位毫秒
Respones 響應等待超時時間，單位毫秒

 

Embedded Resources from HTML Files

  • 從HTML文件獲取所有內含的資源
  • jmeter 在發出的  HTTP請求獲得響應的 HTML文件內容后，對 HTML進行解析並獲取HTML中包含的所有資源（圖片、flash等）
字段 描述
Retrieve All Embedded Resources 發送http請求的方式，可選項為 java、HttpClient4（默認）
Parallel downloadds. Number

是否使用自設資源處。啟用后可以設置資源池大小，默認為6
URLs must match URL 匹配過濾，填寫此項則只會下載與此內容項匹配的 url 的資源

 

Source address

只用於 HTTP協議且 implemention = HttpClient4 時

字段 描述
IP/Hostname IP /主機名以使用特定的IP地址或（本地）主機名
Device 選擇設備以選擇該接口的第一個可用地址，該設備可以是IPv4或IPv6
Device IPv4 選擇IPv4設備來選擇名稱設備的IPv4地址（如eth0, lo, em0）
Device IPv6 選擇IPv6設備來選擇名稱設備的IPv6地址（如eth0, lo, em0）

 

Proxy Server

代理服務器

字段 描述
Server Name or IP 代理服務器的名稱或者IP地址
Port Number 代理服務器的端口號
Username 代理服務器的用戶名
Password 代理服務器的密碼

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

【其他文章推薦】

※USB CONNECTOR掌控什麼技術要點? 帶您認識其相關發展及效能

※台北網頁設計公司這麼多該如何選擇?

※智慧手機時代的來臨，RWD網頁設計為架站首選

※評比南投搬家公司費用收費行情懶人包大公開

※回頭車貨運收費標準

※聚甘新

汎德和台達電合作，為北市增添電動車充電站

admin

電源管理及散熱解決方案廠商台達電10日宣布，BMW台灣總代理汎德選定台達的電動車充電解決方案，並捐贈給台北市政府，將在今年3月底前，為台北市20處公用停車場設置40台具有網路通訊功能、IP55防塵防水與時尚精巧的外型設計的台達智能電動車交流充電機，為越來越多的BMW i系列以及搭配J1772 Type1規格的電動車提供更便捷的充電服務，同時也強化了台達在台灣的充電站普及率。

台達副總裁暨電源系統事業群總經理鄭安強調，台達十分樂意與夥伴攜手實現智能綠生活，很榮幸可以滿足BMW台灣總代理汎德對充電站的嚴謹要求，包括其高度可靠度以及智能化。事實上，台達電動車充電解決方案已獲得許多國家的肯定，並且在歐洲、台灣以及大中華區累積不少成功案例。

台達電指出，台達智能電動車交流充電機擁有網路通訊功能、內建RFID讀卡機與7kW電源容量，能協助系統管理廠商為電動車車主提供更便利的服務。另外，這款通過台灣CNS標準認證的交流充電機具有IP55防塵防水與防破壞(IK8)機體設計，除了相當堅固外，時尚精巧的外型設計更能節省空間，而台達充電站管理系統(Site Management System, SMS)能進行遠端支援及能源管理的功能，提升充電基地營運效率。

台達電並表示，台達電動車充電解決方案逐步於全球協助夥伴建立住宅及商業應用的高效、快速與方便的電動車充電設備。例如，台達的120kW直流超快速電動車充電機於挪威及瑞典的高速公路能夠同時提供四台電動車快充的服務。台達其它直流與交流技術也於香港國際機場、上海的商業大樓與台灣的日月潭旅客租車服務支援電動交通。

（本文內容由授權使用。）

本站聲明:網站內容來源於EnergyTrend https://www.energytrend.com.tw/ev/,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※帶您來了解什麼是 USB CONNECTOR  ?

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

※如何讓商品強力曝光呢? 網頁設計公司幫您建置最吸引人的網站，提高曝光率!

※綠能、環保無空污,成為電動車最新代名詞，目前市場使用率逐漸普及化

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

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