前言

上一篇【.Net Core微服務入門全紀錄（四）——Ocelot-API網關（上）】已經完成了Ocelot網關的基本搭建，實現了服務入口的統一。當然，這隻是API網關的一個最基本功能，它的進階功能還有很多很多。

服務發現

首先需要解決的就是服務發現的問題，服務發現的優點之前講過，就不說了。
上一篇中我們的服務地址都是寫在ocelot.json配置文件里，現在我們需要結合之前的Consul來實現服務發現。

• 改造代碼：

首先NuGet安裝Ocelot.Provider.Consul：

修改Startup.cs：

        public void ConfigureServices(IServiceCollection services)
        {
            //添加ocelot服務
            services.AddOcelot()
                .AddConsul();//添加consul支持
        }

修改ocelot.json配置：

{
  "Routes": [
    {
      "DownstreamPathTemplate": "/products",
      "DownstreamScheme": "http",
      "UpstreamPathTemplate": "/products",
      "UpstreamHttpMethod": [ "Get" ],
      "ServiceName": "ProductService",
      "LoadBalancerOptions": {
        "Type": "RoundRobin"
      }
    },
    {
      "DownstreamPathTemplate": "/orders",
      "DownstreamScheme": "http",
      "UpstreamPathTemplate": "/orders",
      "UpstreamHttpMethod": [ "Get" ],
      "ServiceName": "OrderService",
      "LoadBalancerOptions": {
        "Type": "RoundRobin"
      }
    }
  ],
  "GlobalConfiguration": {
    "BaseUrl": "http://localhost:9070",
    "ServiceDiscoveryProvider": {
      "Scheme": "http",
      "Host": "localhost",
      "Port": 8500,
      "Type": "Consul"
    }
  }
}

這個配置應該很好理解，就是把我們上次的DownstreamHostAndPorts節點去掉了，然後增加了ServiceDiscoveryProvider服務發現相關配置。
注意，Ocelot除了支持Consul服務發現以外，還有Eureka也可以，Eureka也是一個類似的註冊中心。

好了，代碼修改就差不多了，下面運行程序測試一下：

客戶端正常運行。

至此我們就實現了服務註冊與發現和api網關的基本功能。接下來就要提到：服務治理

服務治理

其實服務治理也沒有一個非常明確的定義。它的作用簡單來說，就是幫助我們更好的管理服務，提升服務的可用性。——緩存，限流，熔斷，鏈路追蹤 等等。。。都屬於常用的服務治理手段。
之前講的負載均衡，服務發現也可以算是服務治理。

• 緩存：

在Ocelot中啟用緩存，需要NuGet安裝一下Ocelot.Cache.CacheManager：

修改Startup.cs中的ConfigureServices()方法：

//添加ocelot服務
services.AddOcelot()
    //添加consul支持
    .AddConsul()
    //添加緩存
    .AddCacheManager(x =>
    {
        x.WithDictionaryHandle();
    });

修改ocelot.json配置文件：

{
  "Routes": [
    {
      "DownstreamPathTemplate": "/products",
      "DownstreamScheme": "http",
      "UpstreamPathTemplate": "/products",
      "UpstreamHttpMethod": [ "Get" ],
      "ServiceName": "ProductService",
      "LoadBalancerOptions": {
        "Type": "RoundRobin"
      },
      "FileCacheOptions": {
        "TtlSeconds": 5,
        "Region": "regionname"
      }
    },
    {
      "DownstreamPathTemplate": "/orders",
      "DownstreamScheme": "http",
      "UpstreamPathTemplate": "/orders",
      "UpstreamHttpMethod": [ "Get" ],
      "ServiceName": "OrderService",
      "LoadBalancerOptions": {
        "Type": "RoundRobin"
      },
      "FileCacheOptions": {
        "TtlSeconds": 5,
        "Region": "regionname"
      }
    }
  ],
  "GlobalConfiguration": {
    "BaseUrl": "http://localhost:9070",
    "ServiceDiscoveryProvider": {
      "Scheme": "http",
      "Host": "localhost",
      "Port": 8500,
      "Type": "Consul"
    }
  }
}

在Routes路由配置中增加了FileCacheOptions。TtlSeconds代表緩存的過期時間，Region代表緩衝區名稱，這個我們目前用不到。

好了，代碼修改完需要編譯重啟一下網關項目，然後打開客戶端網站測試一下：

可以看到，5秒之內的請求都是同樣的緩存數據。Ocelot也支持自定義緩存。

• 限流：

限流就是限制客戶端一定時間內的請求次數。
繼續修改配置：

{
  "Routes": [
    {
      "DownstreamPathTemplate": "/products",
      "DownstreamScheme": "http",
      "UpstreamPathTemplate": "/products",
      "UpstreamHttpMethod": [ "Get" ],
      "ServiceName": "ProductService",
      "LoadBalancerOptions": {
        "Type": "RoundRobin"
      },
      "FileCacheOptions": {
        "TtlSeconds": 5,
        "Region": "regionname"
      },
      "RateLimitOptions": {
        "ClientWhitelist": [ "SuperClient" ],
        "EnableRateLimiting": true,
        "Period": "5s",
        "PeriodTimespan": 2,
        "Limit": 1
      }
    },
    {
      "DownstreamPathTemplate": "/orders",
      "DownstreamScheme": "http",
      "UpstreamPathTemplate": "/orders",
      "UpstreamHttpMethod": [ "Get" ],
      "ServiceName": "OrderService",
      "LoadBalancerOptions": {
        "Type": "RoundRobin"
      },
      "FileCacheOptions": {
        "TtlSeconds": 5,
        "Region": "regionname"
      },
      "RateLimitOptions": {
        "ClientWhitelist": [ "SuperClient" ],
        "EnableRateLimiting": true,
        "Period": "5s",
        "PeriodTimespan": 2,
        "Limit": 2
      }
    }
  ],
  "GlobalConfiguration": {
    "BaseUrl": "http://localhost:9070",
    "ServiceDiscoveryProvider": {
      "Scheme": "http",
      "Host": "localhost",
      "Port": 8500,
      "Type": "Consul"
    },
    "RateLimitOptions": {
      "DisableRateLimitHeaders": false,
      "QuotaExceededMessage": "too many requests...",
      "HttpStatusCode": 999,
      "ClientIdHeader": "Test"
    }
  }
}

在Routes路由配置中增加了RateLimitOptions。ClientWhitelist代表客戶端白名單，在白名單中的客戶端可以不受限流的影響；EnableRateLimiting代表是否限流；Period代表限流的單位時間，例如1s，5m，1h，1d等；PeriodTimespan代表客戶端達到請求上限多少秒后可以重試；Limit代表客戶端在定義的時間內可以發出的最大請求數。
在GlobalConfiguration配置中也增加了RateLimitOptions。DisableRateLimitHeaders代表是否禁用X-Rate-Limit和Retry-After標頭（請求達到上限時response header中的限制數和多少秒后能重試）；QuotaExceededMessage：代表請求達到上限時返回給客戶端的消息；HttpStatusCode：代表請求達到上限時返回給客戶端的HTTP狀態代碼。ClientIdHeader可以允許自定義用於標識客戶端的標頭。默認情況下為“ ClientId”。
最重要的就是Period，PeriodTimespan，Limit這幾個配置。

重新編譯啟動看一下效果：

• 超時/熔斷

超時很好理解，就是網關請求服務時可容忍的最長響應時間。熔斷的意思就是當請求某個服務的異常次數達到一定量時，那麼網關在一定時間內就不再對這個服務發起請求了，直接熔斷。
Ocelot中啟用 超時/熔斷 需要NuGet安裝一下Ocelot.Provider.Polly：

修改Startup.cs中的ConfigureServices()方法：

//添加ocelot服務
services.AddOcelot()
    //添加consul支持
    .AddConsul()
    //添加緩存
    .AddCacheManager(x =>
    {
        x.WithDictionaryHandle();
    })
    //添加Polly
    .AddPolly();

同樣的在ocelot.json路由配置中增加QoSOptions：

"QoSOptions": {
        "ExceptionsAllowedBeforeBreaking": 3,
        "DurationOfBreak": 10000,
        "TimeoutValue": 5000
      }

ExceptionsAllowedBeforeBreaking代表發生錯誤的次數，DurationOfBreak代表熔斷時間，TimeoutValue代表超時時間。
以上的配置意思就是當服務發生3次錯誤時，那麼就熔斷10秒，期間客戶端的請求直接返回錯誤，10秒之後恢復。
這個不太好模擬，就不演示了，應該也挺好理解的。

。。。。。。

關於服務治理的學問還有很多，不繼續了。。。就到此為止吧。
想要更深入了解Ocelot的，請看官網：https://ocelot.readthedocs.io/en/latest/
或者看源碼：https://github.com/ThreeMammals/Ocelot

下一篇準備說一下：事件總線。

代碼放在：https://github.com/xiajingren/NetCoreMicroserviceDemo

未完待續…

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

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

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

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

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

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

※超省錢租車方案

※聚甘新

1.前言

回顧：認證方案之初步認識JWT

在現代Web應用程序中，即分為前端與後端兩大部分。當前前後端的趨勢日益劇增，前端設備（手機、平板、電腦、及其他設備）層出不窮。因此，為了方便滿足前端設備與後端進行通訊，就必須有一種統一的機制。所以導致API架構的流行。而RESTful API這個API設計思想理論也就成為目前互聯網應用程序比較歡迎的一套方式。

這種API架構思想的引入，因此，我們就需要考慮用一種標準的，通用的，無狀態的，與語言無關的身份認證方式來實現API接口的認證。

HTTP提供了一套標準的身份驗證框架：服務端可以用來針對客戶端的請求發送質詢(challenge)，客戶端根據質詢提供應答身份驗證憑證。

質詢與應答的工作流程如下：服務端向客戶端返回401（Unauthorized，未授權）狀態碼，並在WWW-Authenticate頭中添加如何進行驗證的信息，其中至少包含有一種質詢方式。然後客戶端可以在請求中添加Authorization頭進行驗證，其Value為身份驗證的憑證信息。

在本文中，將要介紹的是以Jwt Bearer方式進行認證。

2.Bearer認證

本文要介紹的Bearer驗證也屬於HTTP協議標準驗證，它隨着OAuth協議而開始流行，詳細定義見： RFC 6570。

     +--------+                               +---------------+
     |        |--(A)- Authorization Request ->|   Resource    |
     |        |                               |     Owner     |
     |        |<-(B)-- Authorization Grant ---|               |
     |        |                               +---------------+
     |        |
     |        |                               +---------------+
     |        |--(C)-- Authorization Grant -->| Authorization |
     | Client |                               |     Server    |
     |        |<-(D)----- Access Token -------|               |
     |        |                               +---------------+
     |        |
     |        |                               +---------------+
     |        |--(E)----- Access Token ------>|    Resource   |
     |        |                               |     Server    |
     |        |<-(F)--- Protected Resource ---|               |
     +--------+                               +---------------+

A security token with the property that any party in possession of the token (a “bearer”) can use the token in any way that any other party in possession of it can. Using a bearer token does not require a bearer to prove possession of cryptographic key material (proof-of-possession).

因此Bearer認證的核心是Token，Bearer驗證中的憑證稱為BEARER_TOKEN，或者是access_token，它的頒發和驗證完全由我們自己的應用程序來控制，而不依賴於系統和Web服務器，Bearer驗證的標準請求方式如下：

Authorization: Bearer [BEARER_TOKEN] 

那麼使用Bearer驗證有什麼好處呢？

• CORS: cookies + CORS 並不能跨不同的域名。而Bearer驗證在任何域名下都可以使用HTTP header頭部來傳輸用戶信息。
• 對移動端友好: 當你在一個原生平台(iOS, Android, WindowsPhone等)時，使用Cookie驗證並不是一個好主意，因為你得和Cookie容器打交道，而使用Bearer驗證則簡單的多。
• CSRF: 因為Bearer驗證不再依賴於cookies, 也就避免了跨站請求攻擊。
• 標準：在Cookie認證中，用戶未登錄時，返回一個302到登錄頁面，這在非瀏覽器情況下很難處理，而Bearer驗證則返回的是標準的401 challenge。

3.JWT

上面介紹的Bearer認證，其核心便是BEARER_TOKEN，那麼，如何確保Token的安全是重中之重。一種是通過HTTPS的方式，另一種是通過對Token進行加密編碼簽名，而最流行的Token編碼簽名方式便是：JSON WEB TOKEN。

Json web token (Jwt), 是為了在網絡應用環境間傳遞聲明而執行的一種基於JSON的開放標準（RFC 7519）。該token被設計為緊湊且安全的，特別適用於分佈式站點的單點登錄（SSO）場景。JWT的聲明一般被用來在身份提供者和服務提供者間傳遞被認證的用戶身份信息，以便於從資源服務器獲取資源，也可以增加一些額外的其它業務邏輯所必須的聲明信息，該token也可直接被用於認證，也可被加密。

JWT是由.分割的如下三部分組成：

Header.Payload.Signature

還記得之前說個的一篇認證方案之初步認識JWT嗎？沒有的，可以看看，對JWT的特點和基本原理介紹，可以進一步的了解。

學習了之前的文章后，我們可以發現使用JWT的好處在於通用性、緊湊性和可拓展性。

• 通用性：因為json的通用性，所以JWT是可以進行跨語言支持的，像JAVA,JavaScript,NodeJS,PHP等很多語言都可以使用。
• 緊湊性：JWT的構成非常簡單，字節佔用很小，通過 GET、POST 等放在 HTTP 的 header 中，便於傳輸。
• 可擴展性：JWT是自我包涵的，因為有了payload部分，包含了必要的一些其他業務邏輯所必要的非敏感信息，自身存儲，不需要在服務端保存會話信息, 非常易於應用的擴展。

4.開始

1. 註冊認證服務

在這裏，我們用微軟給我們提供的JwtBearer認證方式，實現認證服務註冊 。

引入nuget包：Microsoft.AspNetCore.Authentication.JwtBearer

註冊服務，將服務添加到容器中，

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddControllers();

        var Issurer = "JWTBearer.Auth";  //發行人
        var Audience = "api.auth";       //受眾人
        var secretCredentials = "q2xiARx$4x3TKqBJ";   //密鑰

        //配置認證服務
        services.AddAuthentication(x =>
        {
            x.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
            x.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
        }).AddJwtBearer(o=>{
            o.TokenValidationParameters = new TokenValidationParameters
            {
                //是否驗證發行人
                ValidateIssuer = true,
                ValidIssuer = Issurer,//發行人
                //是否驗證受眾人
                ValidateAudience = true,
                ValidAudience = Audience,//受眾人
                //是否驗證密鑰
                ValidateIssuerSigningKey = true,
                IssuerSigningKey = new SymmetricSecurityKey(Encoding.ASCII.GetBytes(secretCredentials)),
                
                ValidateLifetime = true, //驗證生命周期
                RequireExpirationTime = true, //過期時間
            };
        });
    }

注意說明：

一. TokenValidationParameters的參數默認值：
1. ValidateAudience = true,  ----- 如果設置為false,則不驗證Audience受眾人
2. ValidateIssuer = true ,   ----- 如果設置為false,則不驗證Issuer發布人，但建議不建議這樣設置
3. ValidateIssuerSigningKey = false,
4. ValidateLifetime = true,  ----- 是否驗證Token有效期，使用當前時間與Token的Claims中的NotBefore和Expires對比
5. RequireExpirationTime = true, ----- 是否要求Token的Claims中必須包含Expires
6. ClockSkew = TimeSpan.FromSeconds(300), ----- 允許服務器時間偏移量300秒，即我們配置的過期時間加上這個允許偏移的時間值，才是真正過期的時間(過期時間 +偏移值)你也可以設置為0，ClockSkew = TimeSpan.Zero

調用方法，配置Http請求管道：

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }

        app.UseRouting();
        //1.先開啟認證
        app.UseAuthentication();
        //2.再開啟授權
        app.UseAuthorization();

        app.UseEndpoints(endpoints =>
        {
            endpoints.MapControllers();
        });
    }

在JwtBearerOptions的配置中，通常IssuerSigningKey(簽名秘鑰), ValidIssuer(Token頒發機構), ValidAudience(頒發給誰) 三個參數是必須的，后兩者用於與TokenClaims中的Issuer和Audience進行對比，不一致則驗證失敗。

2.接口資源保護

創建一個需要授權保護的資源控制器，這裏我們用建立API生成項目自帶的控制器，WeatherForecastController.cs, 在控制器上使用Authorize即可

[ApiController]
[Route("[controller]")]
[Authorize]
public class WeatherForecastController : ControllerBase
{
    private static readonly string[] Summaries = new[]
    {
        "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
    };

    private readonly ILogger<WeatherForecastController> _logger;

    public WeatherForecastController(ILogger<WeatherForecastController> logger)
    {
        _logger = logger;
    }

    [HttpGet]
    public IEnumerable<WeatherForecast> Get()
    {
        var rng = new Random();
        return Enumerable.Range(1, 5).Select(index => new WeatherForecast
        {
            Date = DateTime.Now.AddDays(index),
            TemperatureC = rng.Next(-20, 55),
            Summary = Summaries[rng.Next(Summaries.Length)]
        })
        .ToArray();
    }
}

3. 生成Token

因為微軟為我們內置了JwtBearer驗證，但是沒有提供Token的發放，所以這裏我們要實現生成Token的方法

引入Nugets包：System.IdentityModel.Tokens.Jwt

這裏我們根據IdentityModel.Tokens.Jwt文檔給我們提供的幫助類，提供了方法WriteToken創建Token，根據參數SecurityToken，可以實例化，JwtSecurityToken，指定可選參數的類。

        /// <summary>
        /// Initializes a new instance of the <see cref="JwtSecurityToken"/> class specifying optional parameters.
        /// </summary>
        /// <param name="issuer">If this value is not null, a { iss, 'issuer' } claim will be added, overwriting any 'iss' claim in 'claims' if present.</param>
        /// <param name="audience">If this value is not null, a { aud, 'audience' } claim will be added, appending to any 'aud' claims in 'claims' if present.</param>
        /// <param name="claims">If this value is not null then for each <see cref="Claim"/> a { 'Claim.Type', 'Claim.Value' } is added. If duplicate claims are found then a { 'Claim.Type', List&lt;object&gt; } will be created to contain the duplicate values.</param>
        /// <param name="expires">If expires.HasValue a { exp, 'value' } claim is added, overwriting any 'exp' claim in 'claims' if present.</param>
        /// <param name="notBefore">If notbefore.HasValue a { nbf, 'value' } claim is added, overwriting any 'nbf' claim in 'claims' if present.</param>
        /// <param name="signingCredentials">The <see cref="SigningCredentials"/> that will be used to sign the <see cref="JwtSecurityToken"/>. See <see cref="JwtHeader(SigningCredentials)"/> for details pertaining to the Header Parameter(s).</param>
        /// <exception cref="ArgumentException">If 'expires' &lt;= 'notbefore'.</exception>
        public JwtSecurityToken(string issuer = null, string audience = null, IEnumerable<Claim> claims = null, DateTime? notBefore = null, DateTime? expires = null, SigningCredentials signingCredentials = null)
        {
            if (expires.HasValue && notBefore.HasValue)
            {
                if (notBefore >= expires)
                    throw LogHelper.LogExceptionMessage(new ArgumentException(LogHelper.FormatInvariant(LogMessages.IDX12401, expires.Value, notBefore.Value)));
            }

            Payload = new JwtPayload(issuer, audience, claims, notBefore, expires);
            Header = new JwtHeader(signingCredentials);
            RawSignature = string.Empty;
        }

這樣，我們可以根據參數指定內容：

1. string iss = "JWTBearer.Auth";  // 定義發行人
2. string aud = "api.auth";       //定義受眾人audience
3. IEnumerable<Claim> claims = new Claim[]
{
new Claim(JwtClaimTypes.Id,"1"),
new Claim(JwtClaimTypes.Name,"i3yuan"),
};//定義許多種的聲明Claim,信息存儲部分,Claims的實體一般包含用戶和一些元數據
4. var nbf = DateTime.UtcNow;  //notBefore  生效時間
5. var Exp = DateTime.UtcNow.AddSeconds(1000);  //expires 過期時間
6. string sign = "q2xiARx$4x3TKqBJ"; //SecurityKey 的長度必須 大於等於 16個字符
 var secret = Encoding.UTF8.GetBytes(sign);
 var key = new SymmetricSecurityKey(secret);
 var signcreds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);

好了，通過以上填充參數內容，進行傳參賦值得到，完整代碼如下：

新增AuthController.cs控制器：

    [HttpGet]
    public IActionResult GetToken()
    {
        try
        {
            //定義發行人issuer
            string iss = "JWTBearer.Auth";
            //定義受眾人audience
            string aud = "api.auth";

            //定義許多種的聲明Claim,信息存儲部分,Claims的實體一般包含用戶和一些元數據
            IEnumerable<Claim> claims = new Claim[]
            {
                new Claim(JwtClaimTypes.Id,"1"),
                new Claim(JwtClaimTypes.Name,"i3yuan"),
            };
            //notBefore  生效時間
            // long nbf =new DateTimeOffset(DateTime.Now).ToUnixTimeSeconds();
            var nbf = DateTime.UtcNow;
            //expires   //過期時間
            // long Exp = new DateTimeOffset(DateTime.Now.AddSeconds(1000)).ToUnixTimeSeconds();
            var Exp = DateTime.UtcNow.AddSeconds(1000);
            //signingCredentials  簽名憑證
            string sign = "q2xiARx$4x3TKqBJ"; //SecurityKey 的長度必須 大於等於 16個字符
            var secret = Encoding.UTF8.GetBytes(sign);
            var key = new SymmetricSecurityKey(secret);
            var signcreds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
            var jwt = new JwtSecurityToken(issuer: iss, audience: aud, claims:claims,notBefore:nbf,expires:Exp, signingCredentials: signcreds);
		    var JwtHander = new JwtSecurityTokenHandler();
            var token = JwtHander.WriteToken(jwt);
            return Ok(new
            {
                access_token = token,
                token_type = "Bearer",
            });
        }
        catch (Exception ex)
        {
            throw;
        }
    }

注意：
1.SecurityKey 的長度必須 大於等於 16個字符，否則生成會報錯。（可通過在線隨機生成密鑰）

5. 運行

訪問獲取Token方法，獲取得到access_token:

再訪問，授權資源接口，可以發現，再沒有添加請求頭token值的情況下，返回了401沒有權限。

這次，在請求頭通過Authorization加上之前獲取的token值后，再次進行訪問，發現已經可以獲取訪問資源控制器，並返回對應的數據。

6.擴展說明

在HTTP標準驗證方案中，我們比較熟悉的是”Basic”和”Digest”，前者將用戶名密碼使用BASE64編碼後作為驗證憑證，後者是Basic的升級版，更加安全，因為Basic是明文傳輸密碼信息，而Digest是加密後傳輸。

一、Basic基礎認證

Basic認證是一種較為簡單的HTTP認證方式，客戶端通過明文（Base64編碼格式）傳輸用戶名和密碼到服務端進行認證，通常需要配合HTTPS來保證信息傳輸的安全。

客戶端請求需要帶Authorization請求頭，值為“Basic xxx”，xxx為“用戶名:密碼”進行Base64編碼後生成的值。 若客戶端是瀏覽器，則瀏覽器會提供一個輸入用戶名和密碼的對話框，用戶輸入用戶名和密碼后，瀏覽器會保存用戶名和密碼，用於構造Authorization值。當關閉瀏覽器后，用戶名和密碼將不再保存。

憑證為“YWxhzGRpbjpvcGVuc2VzYWl1”，是通過將“用戶名:密碼”格式的字符串經過的Base64編碼得到的。而Base64不屬於加密範疇，可以被逆向解碼，等同於明文，因此Basic傳輸認證信息是不安全的。

Basic基礎認證圖示：

缺陷匯總
1.用戶名和密碼明文（Base64）傳輸，需要配合HTTPS來保證信息傳輸的安全。
2.即使密碼被強加密，第三方仍可通過加密后的用戶名和密碼進行重放攻擊。
3.沒有提供任何針對代理和中間節點的防護措施。
4.假冒服務器很容易騙過認證，誘導用戶輸入用戶名和密碼。

二、Digest摘要認證

Digest認證是為了修復基本認證協議的嚴重缺陷而設計的，秉承“絕不通過明文在網絡發送密碼”的原則，通過“密碼摘要”進行認證，大大提高了安全性。

Digest認證步驟如下：
第一步：客戶端訪問Http資源服務器。由於需要Digest認證，服務器返回了兩個重要字段nonce（隨機數）和realm。
第二步：客戶端構造Authorization請求頭，值包含username、realm、nouce、uri和response的字段信息。其中，realm和nouce就是第一步返回的值。nouce只能被服務端使用一次。uri(digest-uri)即Request-URI的值，但考慮到經代理轉發后Request-URI的值可能被修改、因此實現會複製一份副本保存在uri內。response也可叫做Request-digest，存放經過MD5運算后的密碼字符串，形成響應碼。
第三步：服務器驗證包含Authorization值的請求，若驗證通過則可訪問資源。
Digest認證可以防止密碼泄露和請求重放，但沒辦法防假冒。所以安全級別較低。
Digest和Basic認證一樣，每次都會發送Authorization請求頭，也就相當於重新構造此值。所以兩者易用性都較差。

Digest認證圖示：

7.注意

1. 在進行JwtBearer認證時，在生成token之後，還需要與刷新token配合使用，因為當用戶執行了退出，修改密碼等操作時，需要讓該token無效，無法再次使用，所以，會給access_token設置一個較短的有效期間，(JwtBearer認證默認會驗證有效期，通過notBefore和expires來驗證)，當access_token過期后，可以在用戶無感知的情況下，使用refresh_token重新獲取access_token，但這就不屬於Bearer認證的範疇了，但是我們可以通過另一種方式通過IdentityServer的方式來實現，在後續中會對IdentityServer進行詳細講解。
2. 在生成token的時候，需要用的secret，主要是用來防止token被偽造與篡改。因為當token被劫取的時候，可以得到你的令牌中帶的一些個人不重要的信息明文，但不用擔心，只要你不在生成token里把私密的個人信息放出去的話，就算被動機不良的人得到，也做不了什麼事情。但是你可能會想，如果用戶自己隨便的生成一個 token ，帶上你的信息，那不就可以隨便訪問你的資源服務器了，因此這個時候就需要利用secret 來生成 token，來確保数字簽名的正確性。而且在認證授權資源，進行token解析的時候，通過微軟的源碼發現，已經幫我們封裝了方法，對secret進行了校驗了，確保了token的安全性，從而保證api資源的安全。

8.總結

1. JwtToken在認證時，無需Security token service安全令牌服務器的參与，都是基於Claim的，默認會驗證有效期，通過notBefore和expires來驗證，這在分佈式中提供給了極大便利。
2. JwtToken與平台、無言無關，在前端也可以直接解析出Claims。
3. 如果有不對的或不理解的地方，希望大家可以多多指正，提出問題，一起討論,不斷學習,共同進步。
4. 後面會對認證授權方案中的授權這一塊進行說明分享。
5. 本示例源碼地址
   參考JwtBearer源碼

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

【其他文章推薦】

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

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

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

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

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

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

※聚甘新

閱讀本文大概需要 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

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

【其他文章推薦】

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

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

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

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

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

※聚甘新

作者：HelloGitHub-追夢人物

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

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

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

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

文章評論列表 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 即可進入這篇文章下的評論列表接口，獲取這篇文章的評論列表資源了：

關注公眾號加入交流群

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

【其他文章推薦】

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

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

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

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

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

※聚甘新

本文始發於個人公眾號：TechFlow，原創不易，求個關注

import numpy as np
import pandas as pd
from sklearn.datasets import load_breast_cancer

breast = load_breast_cancer()
X, y = breast.data, breast.target
# reshape，將一維向量轉成二維
y = y.reshape((-1, 1))

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=23)

def loss_error(y_pred, y, weight):
    return weight.T.dot((y_pred != y_train))

def stump_classify(X, idx, threshold, comparator):
    if comparator == 'lt':
        return X[:, idx] <= threshold
    else:
        return X[:, idx] > threshold
    
def get_thresholds(X, i):
    min_val, max_val = X[:, i].min(), X[:, i].max()
    return np.linspace(min_val, max_val, 10)

def build_stump(X, y, weight):
    m, n = X.shape
    ret_stump, ret_pred = None, []
    best_error = float('inf')

    # 枚舉特徵
    for i in range(n):
        # 枚舉閾值
        for j in get_thresholds(X, i):
            # 枚舉正例兩種情況
            for c in ['lt', 'gt']:
                # 預測並且求誤差
                pred = stump_classify(X, i, j, c).reshape((-1, 1))
                err = loss_error(pred, y, weight)
                # 記錄下最好的樹樁
                if err < best_error:
                    best_error, ret_pred = err, pred.copy()
                    ret_stump = {'idx': i, 'threshold': j, 'comparator': c} 
    return ret_stump, best_error, ret_pred

def adaboost_train(X, y, num_stump):
    stumps = []
    m = X.shape[0]
    # 樣本權重初始化，一開始全部相等
    weight = np.ones((y_train.shape[0], 1)) / y_train.shape[0]
    # 生成num_stump個樹樁
    for i in range(num_stump):
        best_stump, err, pred = build_stump(X, y, weight)
        # 計算alpha
        alpha = 0.5 * np.log((1.0 - err) / max(err, 1e-10))
        best_stump['alpha'] = alpha
        stumps.append(best_stump)

        # 更新每一條樣本的權重
        for j in range(m):
            weight[j] = weight[j] * (np.exp(-alpha) if pred[j] == y[j] else np.exp(alpha))
        weight = weight / weight.sum()
        # 如果當前的準確率已經非常高，則退出
        if err < 1e-8:
            break
    return stumps

def adaboost_classify(X, stumps):
    m = X.shape[0]
    pred = np.ones((m, 1))
    alphs = 0.0
    for i, stump in enumerate(stumps):
        y_pred = stump_classify(X, stump['idx'], stump['threshold'], stump['comparator'])
        # 根據alpha加權求和
        pred = y_pred * stump['alpha']
        alphs += stump['alpha']
    pred /= alphs
    # 根據0.5劃分0和1類別
    return np.sign(pred).reshape((-1, 1))

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理【其他文章推薦】

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

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

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

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

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

※超省錢租車方案

※聚甘新

從linux源碼看epoll

前言

在linux的高性能網絡編程中，繞不開的就是epoll。和select、poll等系統調用相比,epoll在需要監視大量文件描述符並且其中只有少數活躍的時候，表現出無可比擬的優勢。epoll能讓內核記住所關注的描述符，並在對應的描述符事件就緒的時候,在epoll的就緒鏈表中添加這些就緒元素，並喚醒對應的epoll等待進程。
本文就是筆者在探究epoll源碼過程中，對kernel將就緒描述符添加到epoll並喚醒對應進程的一次源碼分析(基於linux-2.6.32內核版本)。由於篇幅所限，筆者聚焦於tcp協議下socket可讀事件的源碼分析。

簡單的epoll例子

下面的例子，是從筆者本人用c語言寫的dbproxy中的一段代碼。由於細節過多，所以做了一些刪減。

int init_reactor(int listen_fd,int worker_count){
	......
	// 創建多個epoll fd，以充分利用多核
	for(i=0;i<worker_count;i++){
		reactor->worker_fd = epoll_create(EPOLL_MAX_EVENTS);
	}
	/* epoll add listen_fd and accept */
	// 將accept后的事件加入到對應的epoll fd中
	int client_fd = accept(listen_fd,(struct sockaddr *)&client_addr,&client_len)));
	// 將連接描述符註冊到對應的worker裏面
	epoll_ctl(reactor->client_fd,EPOLL_CTL_ADD,epifd,&event);
}
// reactor的worker線程
static void* rw_thread_func(void* arg){
	......

	for(;;){
		  // epoll_wait等待事件觸發
        int retval = epoll_wait(epfd,events,EPOLL_MAX_EVENTS,500);
        if(retval > 0){
        	for(j=0; j < retval; j++){
        		// 處理讀事件
        	   if(event & EPOLLIN){
                 handle_ready_read_connection(conn);
                 continue;
             }
             /* 處理其它事件 */
        	}
        }
	}
	......
}

上述代碼事實上就是實現了一個reactor模式中的accept與read/write處理線程，如下圖所示:

epoll_create

Unix的萬物皆文件的思想在epoll裏面也有體現，epoll_create調用返回一個文件描述符，此描述符掛載在anon_inode_fs(匿名inode文件系統)的根目錄下面。讓我們看下具體的epoll_create系統調用源碼:

SYSCALL_DEFINE1(epoll_create, int, size)
{
	if (size <= 0)
		return -EINVAL;

	return sys_epoll_create1(0);
}

由上述源碼可見，epoll_create的參數是基本沒有意義的，kernel簡單的判斷是否為0，然後就直接就調用了sys_epoll_create1。由於linux的系統調用是通過(SYSCALL_DEFINE1,SYSCALL_DEFINE2……SYSCALL_DEFINE6)定義的，那麼sys_epoll_create1對應的源碼即是SYSCALL_DEFINE(epoll_create1)。
(注:受限於寄存器數量的限制，(80×86下的)kernel限制系統調用最多有6個參數。據ulk3所述，這是由於32位80×86寄存器的限制)
接下來，我們就看下epoll_create1的源碼:

SYSCALL_DEFINE1(epoll_create1, int, flags)
{
	// kzalloc(sizeof(*ep), GFP_KERNEL),用的是內核空間
	error = ep_alloc(&ep);
	// 獲取尚未被使用的文件描述符，即描述符數組的槽位
	fd = get_unused_fd_flags(O_RDWR | (flags & O_CLOEXEC));
	// 在匿名inode文件系統中分配一個inode,並得到其file結構體
	// 且file->f_op = &eventpoll_fops
	// 且file->private_data = ep;
	file = anon_inode_getfile("[eventpoll]", &eventpoll_fops, ep,
				 O_RDWR | (flags & O_CLOEXEC));
	// 將file填入到對應的文件描述符數組的槽裏面
	fd_install(fd,file);			 
	ep->file = file;
	return fd;
}

最後epoll_create生成的文件描述符如下圖所示:

struct eventpoll

所有的epoll系統調用都是圍繞eventpoll結構體做操作,現簡要描述下其中的成員:

/*
 * 此結構體存儲在file->private_data中
 */
struct eventpoll {
	// 自旋鎖，在kernel內部用自旋鎖加鎖，就可以同時多線(進)程對此結構體進行操作
	// 主要是保護ready_list
	spinlock_t lock;
	// 這個互斥鎖是為了保證在eventloop使用對應的文件描述符的時候，文件描述符不會被移除掉
	struct mutex mtx;
	// epoll_wait使用的等待隊列，和進程喚醒有關
	wait_queue_head_t wq;
	// file->poll使用的等待隊列，和進程喚醒有關
	wait_queue_head_t poll_wait;
	// 就緒的描述符隊列
	struct list_head rdllist;
	// 通過紅黑樹來組織當前epoll關注的文件描述符
	struct rb_root rbr;
	// 在向用戶空間傳輸就緒事件的時候，將同時發生事件的文件描述符鏈入到這個鏈表裡面
	struct epitem *ovflist;
	// 對應的user
	struct user_struct *user;
	// 對應的文件描述符
	struct file *file;
	// 下面兩個是用於環路檢測的優化
	int visited;
	struct list_head visited_list_link;
};

本文講述的是kernel是如何將就緒事件傳遞給epoll並喚醒對應進程上，因此在這裏主要聚焦於(wait_queue_head_t wq)等成員。

epoll_ctl(add)

我們看下epoll_ctl(EPOLL_CTL_ADD)是如何將對應的文件描述符插入到eventpoll中的。
藉助於spin_lock(自旋鎖)和mutex(互斥鎖),epoll_ctl調用可以在多個KSE(內核調度實體,即進程/線程)中併發執行。

SYSCALL_DEFINE4(epoll_ctl, int, epfd, int, op, int, fd,
		struct epoll_event __user *, event)
{
	/* 校驗epfd是否是epoll的描述符 */
	// 此處的互斥鎖是為了防止併發調用epoll_ctl,即保護內部數據結構
	// 不會被併發的添加修改刪除破壞
	mutex_lock_nested(&ep->mtx, 0);
	switch (op) {
		case EPOLL_CTL_ADD:
			...
			// 插入到紅黑樹中
			error = ep_insert(ep, &epds, tfile, fd);
			...
			break;
		......
	}
	mutex_unlock(&ep->mtx);	
}		

上述過程如下圖所示：

ep_insert

在ep_insert中初始化了epitem，然後初始化了本文關注的焦點,即事件就緒時候的回調函數，代碼如下所示:

static int ep_insert(struct eventpoll *ep, struct epoll_event *event,
		     struct file *tfile, int fd)
{
	/* 初始化epitem */
	// &epq.pt->qproc = ep_ptable_queue_proc
	init_poll_funcptr(&epq.pt, ep_ptable_queue_proc);
	// 在這裏將回調函數注入
	revents = tfile->f_op->poll(tfile, &epq.pt);
	// 如果當前有事件已經就緒，那麼一開始就會被加入到ready list
	// 例如可寫事件
	// 另外，在tcp內部ack之後調用tcp_check_space,最終調用sock_def_write_space來喚醒對應的epoll_wait下的進程
	if ((revents & event->events) && !ep_is_linked(&epi->rdllink)) {
		list_add_tail(&epi->rdllink, &ep->rdllist);
		// wake_up ep對應在epoll_wait下的進程
		if (waitqueue_active(&ep->wq)){
			wake_up_locked(&ep->wq);
		}
		......
	}	
	// 將epitem插入紅黑樹
	ep_rbtree_insert(ep, epi);
	......
}

tfile->f_op->poll的實現

向kernel更底層註冊回調函數的是tfile->f_op->poll(tfile, &epq.pt)這一句，我們來看一下對於對應的socket文件描述符，其fd=>file->f_op->poll的初始化過程：

    // 將accept后的事件加入到對應的epoll fd中
    int client_fd = accept(listen_fd,(struct sockaddr *)&client_addr,&client_len)));
    // 將連接描述符註冊到對應的worker裏面
    epoll_ctl(reactor->client_fd,EPOLL_CTL_ADD,epifd,&event);

回顧一下上述user space代碼，fd即client_fd是由tcp的listen_fd通過accept調用而來，那麼我們看下accept調用鏈的關鍵路徑:

accept
      |->accept4
            |->sock_attach_fd(newsock, newfile, flags & O_NONBLOCK);
                  |->init_file(file,...,&socket_file_ops);
                        |->file->f_op = fop;
                              /* file->f_op = &socket_file_ops */
            |->fd_install(newfd, newfile); // 安裝fd

那麼，由accept獲得的client_fd的結構如下圖所示:

(注:由於是tcp socket,所以這邊sock->ops=inet_stream_ops,這個初始化的過程在我的另一篇博客<<從linux源碼看socket的阻塞和非阻塞>>中，博客地址如下:
https://my.oschina.net/alchemystar/blog/1791017)
既然知道了tfile->f_op->poll的實現，我們就可以看下此poll是如何將安裝回調函數的。

回調函數的安裝

kernel的調用路徑如下:

sock_poll /*tfile->f_op->poll(tfile, &epq.pt)*/;
	|->sock->ops->poll
		|->tcp_poll
			/* 這邊重要的是拿到了sk_sleep用於KSE(進程/線程)的喚醒 */
			|->sock_poll_wait(file, sk->sk_sleep, wait);
				|->poll_wait
					|->p->qproc(filp, wait_address, p);
					/* p為&epq.pt,而且&epq.pt->qproc= ep_ptable_queue_proc*/
						|-> ep_ptable_queue_proc(filp,wait_address,p);

繞了一大圈之後，我們的回調函數的安裝其實就是調用了eventpoll.c中的ep_ptable_queue_proc,而且向其中傳遞了sk->sk_sleep作為其waitqueue的head,其源碼如下所示:

static void ep_ptable_queue_proc(struct file *file, wait_queue_head_t *whead,
				 poll_table *pt)
{
	// 取出當前client_fd對應的epitem
	struct epitem *epi = ep_item_from_epqueue(pt);
	// &pwq->wait->func=ep_poll_callback，用於回調喚醒
	// 注意，這邊不是init_waitqueue_entry,即沒有將當前KSE(current,當前進程/線程)寫入到
	// wait_queue當中，因為不一定是從當前安裝的KSE喚醒，而應該是喚醒epoll\_wait的KSE
	init_waitqueue_func_entry(&pwq->wait, ep_poll_callback);
	// 這邊的whead是sk->sk_sleep,將當前的waitqueue鏈入到socket對應的sleep列表
	add_wait_queue(whead, &pwq->wait);	
}	

這樣client_fd的結構進一步完善，如下圖所示:

ep_poll_callback函數是喚醒對應epoll_wait的地方，我們將在後面一起講述。

epoll_wait

epoll_wait主要是調用了ep_poll:

SYSCALL_DEFINE4(epoll_wait, int, epfd, struct epoll_event __user *, events,
		int, maxevents, int, timeout)
{
	/* 檢查epfd是否是epoll\_create創建的fd */
	// 調用ep_poll
	error = ep_poll(ep, events, maxevents, timeout);
	...
}

緊接着，我們看下ep_poll函數:

static int ep_poll(struct eventpoll *ep, struct epoll_event __user *events,
		   int maxevents, long timeout)
{
	......
retry:
	// 獲取spinlock
	spin_lock_irqsave(&ep->lock, flags);
	// 將當前task_struct寫入到waitqueue中以便喚醒
	// wq_entry->func = default_wake_function;
	init_waitqueue_entry(&wait, current);
	// WQ_FLAG_EXCLUSIVE，排他性喚醒，配合SO_REUSEPORT從而解決accept驚群問題
	wait.flags |= WQ_FLAG_EXCLUSIVE;
	// 鏈入到ep的waitqueue中
	__add_wait_queue(&ep->wq, &wait);
	for (;;) {
		// 設置當前進程狀態為可打斷
		set_current_state(TASK_INTERRUPTIBLE);
		// 檢查當前線程是否有信號要處理，有則返回-EINTR
		if (signal_pending(current)) {
			res = -EINTR;
			break;
		}
		spin_unlock_irqrestore(&ep->lock, flags);
		// schedule調度，讓出CPU
		jtimeout = schedule_timeout(jtimeout);
		spin_lock_irqsave(&ep->lock, flags);
	}
	// 到這裏，表明超時或者有事件觸發等動作導致進程重新調度
	__remove_wait_queue(&ep->wq, &wait);
	// 設置進程狀態為running
	set_current_state(TASK_RUNNING);
	......
	// 檢查是否有可用事件
	eavail = !list_empty(&ep->rdllist) || ep->ovflist != EP_UNACTIVE_PTR;
	......
	// 向用戶空間拷貝就緒事件
	ep_send_events(ep, events, maxevents)
}		   

上述邏輯如下圖所示:

ep_send_events

ep_send_events函數主要就是調用了ep_scan_ready_list,顧名思義ep_scan_ready_list就是掃描就緒列表:

static int ep_scan_ready_list(struct eventpoll *ep,
			      int (*sproc)(struct eventpoll *,
					   struct list_head *, void *),
			      void *priv,
			      int depth)
{
	...
	// 將epfd的rdllist鏈入到txlist
	list_splice_init(&ep->rdllist, &txlist);
	...
	/* sproc = ep_send_events_proc */
	error = (*sproc)(ep, &txlist, priv);
	...
	// 處理ovflist,即在上面sproc過程中又到來的事件
	...
}

其主要調用了ep_send_events_proc:

static int ep_send_events_proc(struct eventpoll *ep, struct list_head *head,
			       void *priv)
{
	for (eventcnt = 0, uevent = esed->events;
	     !list_empty(head) && eventcnt < esed->maxevents;) {
	   // 遍歷ready list 
		epi = list_first_entry(head, struct epitem, rdllink);
		list_del_init(&epi->rdllink);
		// readylist只是表明當前epi有事件，具體的事件信息還是得調用對應file的poll
		// 這邊的poll即是tcp_poll,根據tcp本身的信息設置掩碼(mask)等信息 & 上興趣事件掩碼，則可以得知當前事件是否是epoll_wait感興趣的事件
		revents = epi->ffd.file->f_op->poll(epi->ffd.file, NULL) &
			epi->event.events;
		if(revents){
			/* 將event放入到用戶空間 */
			/* 處理ONESHOT邏輯 */
			// 如果不是邊緣觸發，則將當前的epi重新加回到可用列表中，這樣就可以下一次繼續觸發poll,如果下一次poll的revents不為0，那麼用戶空間依舊能感知 */
			else if (!(epi->event.events & EPOLLET)){
				list_add_tail(&epi->rdllink, &ep->rdllist);
			}
			/* 如果是邊緣觸發，那麼就不加回可用列表，因此只能等到下一個可用事件觸發的時候才會將對應的epi放到可用列表裡面*/
			eventcnt++
		}
		/* 如poll出來的revents事件epoll_wait不感興趣(或者本來就沒有事件)，那麼也不會加回到可用列表 */
		......
	}
	return eventcnt;
}			    

上述代碼邏輯如下所示:

事件到來添加到epoll就緒隊列(rdllist)的過程

經過上述章節的詳述之後，我們終於可以闡述，tcp在數據到來時是怎麼加入到epoll的就緒隊列的了。

可讀事件到來

首先我們看下tcp數據包從網卡驅動到kernel內部tcp協議處理調用鏈:

step1:

網絡分組到來的內核路徑，網卡發起中斷後調用netif_rx將事件掛入CPU的等待隊列，並喚起軟中斷(soft_irq)，再通過linux的軟中斷機制調用net_rx_action，如下圖所示:

注:上圖來自PLKA(<<深入Linux內核架構>>)

step2:

緊接着跟蹤next_rx_action

next_rx_action
	|-process_backlog
		......
			|->packet_type->func 在這裏我們考慮ip_rcv
					|->ipprot->handler 在這裏ipprot重載為tcp_protocol
						(handler 即為tcp_v4_rcv)					

我們再看下對應的tcp_v4_rcv

tcp_v4_rcv
      |->tcp_v4_do_rcv
            |->tcp_rcv_state_process
                  |->tcp_data_queue
                        |-> sk->sk_data_ready(sock_def_readable)
                              |->wake_up_interruptible_sync_poll(sk->sleep,...)
                                    |->__wake_up
                                          |->__wake_up_common
                                                |->curr->func
                                                /* 這裏已經被ep_insert添加為ep_poll_callback,而且設定了排它標識WQ_FLAG_EXCLUSIVE*/
                                                      |->ep_poll_callback

這樣，我們就看下最終喚醒epoll_wait的ep_poll_callback函數:

static int ep_poll_callback(wait_queue_t *wait, unsigned mode, int sync, void *key)
{
	// 獲取wait對應的epitem	
	struct epitem *epi = ep_item_from_wait(wait);
	// epitem對應的eventpoll結構體
	struct eventpoll *ep = epi->ep;
	// 獲取自旋鎖，保護ready_list等結構
	spin_lock_irqsave(&ep->lock, flags);
	// 如果當前epi沒有被鏈入ep的ready list,則鏈入
	// 這樣，就把當前的可用事件加入到epoll的可用列表了
	if (!ep_is_linked(&epi->rdllink))
		list_add_tail(&epi->rdllink, &ep->rdllist);
	// 如果有epoll_wait在等待的話，則喚醒這個epoll_wait進程
	// 對應的&ep->wq是在epoll_wait調用的時候通過init_waitqueue_entry(&wait, current)而生成的
	// 其中的current即是對應調用epoll_wait的進程信息task_struct
	if (waitqueue_active(&ep->wq))
		wake_up_locked(&ep->wq);
}

上述過程如下圖所示:

最後wake_up_locked調用__wake_up_common,然後調用了在init_waitqueue_entry註冊的default_wake_function,調用路徑為:

wake_up_locked
	|->__wake_up_common
		|->default_wake_function
			|->try_wake_up (wake up a thread)
				|->activate_task
					|->enqueue_task    running

將epoll_wait進程推入可運行隊列，等待內核重新調度進程,然後epoll_wait對應的這個進程重新運行后，就從schedule恢復，繼續下面的ep_send_events(向用戶空間拷貝事件並返回)。
wake_up過程如下圖所示:

可寫事件到來

可寫事件的運行過程和可讀事件大同小異:
首先，在epoll_ctl_add的時候預先會調用一次對應文件描述符的poll，如果返回事件里有可寫掩碼的時候直接調用wake_up_locked以喚醒對應的epoll_wait進程。
然後，在tcp在底層驅動有數據到來的時候可能攜帶了ack從而可以釋放部分已經被對端接收的數據，於是觸發可寫事件，這一部分的調用鏈為:

tcp_input.c
tcp_v4_rcv
	|-tcp_v4_do_rcv
		|-tcp_rcv_state_process
			|-tcp_data_snd_check
				|->tcp_check_space
					|->tcp_new_space
						|->sk->sk_write_space
						/* tcp下即是sk_stream_write_space*/

最後在此函數裏面sk_stream_write_space喚醒對應的epoll_wait進程

void sk_stream_write_space(struct sock *sk)
{
	// 即有1/3可寫空間的時候才觸發可寫事件
	if (sk_stream_wspace(sk) >= sk_stream_min_wspace(sk) && sock) {
		clear_bit(SOCK_NOSPACE, &sock->flags);

		if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
			wake_up_interruptible_poll(sk->sk_sleep, POLLOUT |
						POLLWRNORM | POLLWRBAND)
		......
	}
}

關閉描述符(close fd)

值得注意的是，我們在close對應的文件描述符的時候，會自動調用eventpoll_release將對應的file從其關聯的epoll_fd中刪除，kernel關鍵路徑如下:

close fd
      |->filp_close
            |->fput
                  |->__fput
                        |->eventpoll_release
                              |->ep_remove

所以我們在關閉對應的文件描述符后，並不需要通過epoll_ctl_del來刪掉對應epoll中相應的描述符。

總結

epoll作為linux下非常優秀的事件觸發機製得到了廣泛的運用。其源碼還是比較複雜的，本文只是闡述了epoll讀寫事件的觸發機制，探究linux kernel源碼的過程非常快樂^_。

公眾號

關注筆者公眾號，獲取更多乾貨文章:

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

【其他文章推薦】

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

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

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

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

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

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

※聚甘新

每次滾動到元素時，都显示加載動畫，如何添加？

元素添加初始參數

以上圖中的動畫為例，添加倆個左右容器，將內容放置在容器內部。

添加初始數據，默認透明度0、左右分別移動100px。

 1   //左側容器
 2   .item-leftContainer {
 3     opacity: 0;
 4     transform: translateX(-100px);
 5   }
 6   //右側容器
 7   .item-rightContainer {
 8     opacity: 0;
 9     transform: translateX(100px);
10   }

添加動畫數據

在less中添加動畫數據。這裏只設置了to，也可以省略第1步中的初始參數設置而在動畫里設置from。

執行后，透明度由0到1，倆個容器向中間移動100px回到原處。

 1   //動畫
 2   @keyframes showLeft {
 3     to {
 4       opacity: 1;
 5       transform: translateX(0px);
 6     }
 7   }
 8   @keyframes showRight {
 9     to {
10       opacity: 1;
11       transform: translateX(0px);
12     }
13   }
14   @keyframes hideLeft {
15     to {
16       opacity: 0;
17       transform: translateX(-100px);
18     }
19   }
20   @keyframes hideRight {
21     to {
22       opacity: 0;
23       transform: translateX(100px);
24     }
25   }

觸發動畫

頁面加載/刷新觸發 – 在componentDidMount中執行

頁面滾動時觸發 – 在componentDidMount、componentWillUnmount添加監聽/註銷頁面滾動的事件

校驗當前滾動高度與元素的位置差異：

window.pageYOffset（滾動距離） + windowHeight（窗口高度） > leftElement.offsetTop （元素的相對位置）+ parentOffsetTop（父元素的相對位置） + 200

1. 真正的滾動視覺位置 – window.pageYOffset（滾動距離） + windowHeight（窗口高度）
2. 元素距離頂部的高度 – 這裏使用了leftElement.offsetTop + parentOffsetTop，原因是父容器使用了absolute絕對定位。如果是正常布局的話，使用元素當前的位置leftElement.offsetTop即可
3. 額外添加200高度，是為了優化視覺體驗。當超出200高度時才觸發動畫

當頁面滾動到下方，觸發显示動畫；當頁面重新滾動到上方，觸發隱藏動畫。

 1     componentDidMount() {
 2         this.checkScrollHeightAndLoadAnimation();
 3         window.addEventListener('scroll', this.bindHandleScroll);
 4     }
 5     componentWillUnmount() {
 6         window.removeEventListener('scroll', this.bindHandleScroll);
 7     }
 8     bindHandleScroll = (event) => {
 9         this.checkScrollHeightAndLoadAnimation();
10     }
11     checkScrollHeightAndLoadAnimation() {
12         const windowHeight = window.innerHeight;
13         let parentEelement = document.getElementById("softwareUsingWays-container") as HTMLElement;
14         const parentOffsetTop = parentEelement.offsetTop;
15         let leftElement = (parentEelement.getElementsByClassName("item-leftContainer") as HTMLCollectionOf<HTMLElement>)[0];
16         if (window.pageYOffset + windowHeight > leftElement.offsetTop + parentOffsetTop + 200) {
17             leftElement.style.animation = "showLeft .6s forwards" //添加動畫  
18         } else {
19             leftElement.style.animation = "hideLeft 0s forwards" //隱藏動畫 
20         }
21         let rightElement = (parentEelement.getElementsByClassName(".item-rightContainer") as HTMLCollectionOf<HTMLElement>)[0];
22         if (window.pageYOffset + windowHeight > rightElement.offsetTop + parentOffsetTop + 200) {
23             rightElement.style.animation = "showRight .6s forwards" //添加動畫  
24         } else {
25             rightElement.style.animation = "hideRight 0s forwards" //隱藏動畫 
26         }
27     }

關鍵字：React 滾動、加載/出現動畫

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

【其他文章推薦】

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

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

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

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

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

※聚甘新