前言

上一篇【.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）對應如下：

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

關注公眾號加入交流群

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

【其他文章推薦】

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

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

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

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

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

※聚甘新

領域驅動設計DDD（Domain Driven Design）提出了從業務設計到代碼實現一致性的要求，不再對分析模型和實現模型進行區分。也就是說從代碼的結構中我們可以直接理解業務的設計，命名得當的話，非程序人員也可以“讀”代碼。這與微服務設計中的約定優於配置不謀而合，如果你熟悉英文，那麼直接根據包名和類名就可以直接解讀出程序開發者所構建的業務的大概意圖。

領域模型包含一些明確定義的類型：

• 實體是一個對象，它有固定的身份，具有明確定義的”連續性線索”或生命周期。通常列舉的示例是一個 Person（一個實體）。大多數系統都需要唯一地跟蹤一個 Person，無論姓名、地址或其他屬性是否更改。
• l值對象沒有明確定義的身份，而僅由它們的屬性定義。它們通常不可變，所以兩個相等的值對象始終保持相等。地址可以是與 Person 關聯的值對象。
• l集合是一個相關對象集群，這些對象被看作一個整體。它擁有一個特定實體作為它的根，並定義了明確的封裝邊界。它不只是一個列表。
• l服務用於表示不是實體或值對象的自然部分的操作或活動。

領域模型在實現時可大可小，在業務的早期，在系統比較小的情況下，它有可能是一個類。當系統做大了以後，它可能是個庫。再做更大一點的時候，它可能是一個服務，給不同的應用去調用。

要將領域元素轉換為服務，可按照以下一般準則來完成此操作：

• 使用值對象的表示作為參數和返回值，將集合和實體轉換為獨立的微服務。
• 將領域服務（未附加到集合或實體的服務）與獨立的微服務相匹配。
• 每個微服務應處理一個完整的業務功能。

領域模型又可以分為失血、貧血和充血3種。

• 失血模型：基於數據庫的領域設計方式就是典型的失血模型，只關注數據的增刪改查。
• 貧血模型：就是在domain object包含了不依賴於持久化的領域邏輯，而那些依賴持久化的領域邏輯被分離到server層。
• 充血模型：充血模型跟貧血模型差不多，不同的是如何劃分業務邏輯，就是說，約大部分業務應該放到domain object裏面，而service應該是很薄的一層。

設計原則之分層架構

同一公司使用統一應用分層，以減少開發維護學習成本。應用分層這件事情看起來很簡單，但每個程序員都有自己的一套，哪怕是初學者，所以想實施起來並非那麼容易。

最早接觸分層架構的應該是我們最熟悉的MVC（Model-View-Controller）架構，將應用分成了模型、視圖和控制層，可以說引導了絕大多數開發者，而我們現在的應用中非常多的包括框架，架構設計都使用此模式。這后又演化出了MVP（Model-View-Presenter）和MVVM（Model-View-ViewModel）。這些可以說都是隨着技術的不斷髮展，為了應對不同場景所演化出來的模型。而微服務的每個架構都可以再細分成領域模型，下面看一下經典的領域模型架構。

它包括了Domain，Service Layer和Repositories。核心實體（Entity）和值對象（Value Object）應該在Domain層，定義的領域服務（Domain Service）在Service Layer，而針對實體和值對象的存儲和查詢邏輯都應該在Repositories層。值得注意的是，不要把Entity的屬性和行為分離到Domain和Service兩層中去實現，即所謂的貧血模型，事實證明這樣的實現方式會造成很大的維護問題。基於這種設計，工程的結構可以構造為：

– MicroService-Sample/src/

    domain

    gateways

    interface

    repositories

    services

當然，在微服務的架構中，每個微服務不必嚴格遵照這樣的規定，切忌死搬硬套，最重要的是理解，在不同的業務場合，架構的設計可以適當的做調整，畢竟適合的架構一定要具有靈活性。

分層的原則包括：

• 文件夾分層法

應用分層採用文件夾方式的優點是可大可小、簡單易用、統一規範，可以包括 5 個項目，也可以包括 50 個項目，以滿足所有業務應用的多種不同場景。

• 調用規約

在開發過程中，需要遵循分層架構的約束，禁止跨層次的調用。

• 下層為上層服務

以用戶為中心，以目標為導向。上層（業務邏輯層）需要什麼，下層（數據訪問層）提供什麼，而不是下層（數據訪問層）有什麼，就向上層（業務邏輯層）提供什麼。

• 實體層規約

Entity是數據表對象，不是數據訪問層對象；DTO 是網絡傳輸對象，不是表現層對象；BO 是內存計算邏輯對象，不是業務邏輯層對象，不是只能給業務邏輯層使用 。如果僅限定在本層訪問，則導致單個應用內大量沒有價值的對象轉換。以用戶為中心來設計實體類，可以減少無價值重複對象和無用轉換。

• U 型訪問

下行時表現層是 Input，業務邏輯層是 Process，數據訪問層是 Output。上行時數據訪問層是 Input，業務邏輯層是 Process,  表現層就 Output。

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

【其他文章推薦】

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

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

※回頭車貨運收費標準

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

※超省錢租車方案

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

※聚甘新