NetCoreApi框架搭建三、JWT授权验证）

1.首先还是粘贴大神的链接

虽然说大神的博客已经讲得很详细了，但是此处还是自己动手好点。

首先配置Startup Swagger的验证

2.新建一个项目存放tokenmodel和生成token并且存入缓存

以上是tokenmodel 具体属性可以自定义

缓存帮助类安装nuget包Microsoft.Extensions.Caching.Memory

代码：

using Microsoft.Extensions.Caching.Memory;
using System;
using System.Collections.Generic;
using System.Text;
namespace MyFirstFrame.Token.Model
{
    /// 缓存
   public class RayPIMemoryCache
    {
        public static MemoryCache _cache = new MemoryCache(new MemoryCacheOptions());
        /// 验证缓存项是否存在
        ///缓存Key
        ///
        public static bool Exists(string key)
        {
            if (key == null)
            {
                throw new ArgumentNullException(nameof(key));
            }
            object cached;
            return _cache.TryGetValue(key,out cached);
        }
        ///
        /// 获取缓存
        ///
        ///缓存Key
        ///
        public static object Get(string key)
        {
            if (key == null)
            {
                throw new ArgumentNullException(nameof(key));
            }
            return _cache.Get(key);
        }
        ///
        /// 添加缓存
        ///
        ///缓存Key
        ///缓存Value
        ///滑动过期时长（如果在过期时间内有操作，则以当前时间点延长过期时间）
        ///绝对过期时长
        ///
        public static bool AddMemoryCache(string key, object value, TimeSpan expiresSliding, TimeSpan expiressAbsoulte)
        {
            if (key == null)
            {
                throw new ArgumentNullException(nameof(key));
            }
            if (value == null)
            {
                throw new ArgumentNullException(nameof(value));
            }
            _cache.Set(key, value,new MemoryCacheEntryOptions().SetSlidingExpiration(expiresSliding).SetAbsoluteExpiration(expiressAbsoulte));
            return Exists(key);
        }
    }
}

生成token字符串

代码：

using Microsoft.Extensions.Caching.Memory;
using Microsoft.IdentityModel.Tokens;
using System;
using System.Collections.Generic;
using System.IdentityModel.Tokens.Jwt;
using System.Security.Claims;
using System.Text;

namespace MyFirstFrame.Token.Model
{
    ///
    /// 令牌类
    ///
    public class RayPIToken
    {
        public RayPIToken()
        {
        }
        /// 获取JWT字符串并存入缓存
        public static string IssueJWT(TokenModel tokenModel, TimeSpan expiresSliding, TimeSpan expiresAbsoulte)
        {
            DateTime UTC = DateTime.UtcNow;
            Claim[] claims = new Claim[]
            {
                new Claim(JwtRegisteredClaimNames.Sub,tokenModel.Sub),//Subject,
                new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),//JWT ID,JWT的唯一标识
                new Claim(JwtRegisteredClaimNames.Iat, UTC.ToString(), ClaimValueTypes.Integer64),//Issued At，JWT颁发的时间，采用标准unix时间，用于验证过期
            };
            JwtSecurityToken jwt = new JwtSecurityToken(
          issuer: "MyFirstFrame",//jwt签发者,非必须
          audience: tokenModel.Uname,//jwt的接收该方，非必须
          claims: claims,//声明集合
          expires: UTC.AddHours(12),//指定token的生命周期，unix时间戳格式,非必须
          signingCredentials: new Microsoft.IdentityModel.Tokens
              .SigningCredentials(new SymmetricSecurityKey(Encoding.ASCII.GetBytes("MyFirstFrame's Secret Key")), SecurityAlgorithms.HmacSha256));//使用私钥进行签名加密
            var encodedJwt = new JwtSecurityTokenHandler().WriteToken(jwt);//生成最后的JWT字符串
            RayPIMemoryCache.AddMemoryCache(encodedJwt, tokenModel, expiresSliding, expiresAbsoulte);//将JWT字符串和tokenModel作为key和value存入缓存
            return encodedJwt;
        }
    }
}

新建中间件：TokenAuth

代码：

using Microsoft.Extensions.Caching.Memory;
using Microsoft.AspNetCore.Http;
using MyFirstFrame.Token.Model;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Claims;
using System.Threading.Tasks;

namespace MyFirstFrame.AuthHelper
{
    ///
    /// Token验证授权中间件
    ///
    public class TokenAuth
    {
        ///
        /// http委托
        ///
        private readonly RequestDelegate _next;
        ///
        /// 构造函数
        ///
        ///
        public TokenAuth(RequestDelegate next)
        {
            _next = next;
        }
        ///
        /// 验证授权
        ///
        ///
        ///
        public Task Invoke(HttpContext httpContext)
        {
            //获取请求头部
            var headers = httpContext.Request.Headers;
            //检测是否包含'Authorization'请求头，如果不包含返回context进行下一个中间件，用于访问不需要认证的API
            if (!headers.ContainsKey("Authorization"))
            {
                return _next(httpContext);
            }
            var tokenStr = headers["Authorization"];
            try
            {
                string jwtStr = tokenStr.ToString().Substring("Bearer ".Length).Trim();
                //验证缓存中是否存在该jwt字符串
                if (!RayPIMemoryCache.Exists(jwtStr))
                {
                    return httpContext.Response.WriteAsync("非法请求");
                }
                TokenModel tm = ((TokenModel)RayPIMemoryCache.Get(jwtStr));
                //提取tokenModel中的Sub属性进行authorize认证
                List lc = new List();
                Claim c = new Claim(tm.Sub + "Type", tm.Sub);
                lc.Add(c);
                ClaimsIdentity identity = new ClaimsIdentity(lc);
                ClaimsPrincipal principal = new ClaimsPrincipal(identity);
                httpContext.User = principal;
                return _next(httpContext);
            }
            catch (Exception)
            {
                return httpContext.Response.WriteAsync("token验证异常");
            }
        }

    }
}

在Startup配置注意这里需要放在app.UseMvc();上面

注册缓存和验证：

3.验证使用

为了验证使用我直接写了一个生成token字符串的接口

点击验证，这样你的接口就可以访问成功了。

2019.9.11更新

感觉出现瓶颈了，搭完简单的框架之后就不知道要干嘛了，感觉一下没有目标了，所以就抽空把JWT来深入一下。

前面讲的JWT是存入缓存的，所以用不用JWT生成字符串其实都无所谓，下面讲一下JWT的身份验证。

这生成JWT字符串的类里面加了两个方法，一个是生成字符串，一个是解析字符串的

代码：

 ///
        /// 获取JWT字符串
        ///
        ///
        ///
        ///
        ///
        public static string IssueJWTNew(TokenModel model)
        {
            DateTime UTC = DateTime.UtcNow;
            Claim[] claims = new Claim[] {
                new Claim(JwtRegisteredClaimNames.Sub,model.UserID.ToString()),//Subject,
                new Claim(JwtRegisteredClaimNames.Jti,Guid.NewGuid().ToString()),
                new Claim(JwtRegisteredClaimNames.Iat,UTC.ToString(),ClaimValueTypes.Integer64),
                new Claim(ClaimTypes.Role,model.SystemRoleId),
                new Claim("Role",model.SystemRoleId.ToString()),
                new Claim("Name",model.Name.ToString())
            };
            //秘钥
            var jwtConfig = new JwtAuthConfigModel();
            var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(jwtConfig.JWTSecretKey));
            var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
            //过期时间
            double exp = 0;
            switch (model.TokenType)
            {
                case "Web":
                    exp = jwtConfig.WebExp;
                    break;
                case "App":
                    exp = jwtConfig.AppExp;
                    break;
                case "MiniProgram":
                    exp = jwtConfig.MiniProgramExp;
                    break;
                case "Other":
                    exp = jwtConfig.OtherExp;
                    break;
            }
            JwtSecurityToken jwt = new JwtSecurityToken(
                issuer: "XQP.NetCore",
                audience: model.Name,
                claims: claims,
                expires: UTC.AddHours(exp),
                signingCredentials: creds
                );
            var jwtHandler = new JwtSecurityTokenHandler();
            var encodedJwt = jwtHandler.WriteToken(jwt);
            return encodedJwt;
        }

        ///
        /// 解析
        ///
        ///
        ///
        public static TokenModel SerializeJWT(string jwtStr)
        {
            var jwtHandler = new JwtSecurityTokenHandler();
            JwtSecurityToken jwtToken = jwtHandler.ReadJwtToken(jwtStr);
            object role = new object(); ;
            object name = new object();
            try
            {
                jwtToken.Payload.TryGetValue("Role", out role);
                jwtToken.Payload.TryGetValue("Name", out name);
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
                throw;
            }
            var tm = new TokenModel
            {
                UserID = int.Parse(jwtToken.Subject),
                SystemRoleId =role.ToString(),
                Name = name.ToString(),
            };
            return tm;
        }

同时在登录哪里登录成功之后调用生成字符串的方法，并返回。

 
 实体也根据自己的情况修改了一下，这里其实主要用的角色这个字段

 
 还加了一个配置类，主要配置密钥和过期时间的

 
 最后就是中间件的修改了，这里给解析出来的身份进行了授权。

 
 然后就是Startup配置修改了，这里用的是画红线的那个，大神说可以用多个身份的，我试了没成功，如果有哪位知道原因也可以告诉我一下

 
 然后和之前一下使用就可以了，登录的时候拿到JWT字符串，然后访问接口的时候进行认证（直接用Swagger上的锁就可以）