群友反馈：
群里有小伙伴反馈，在Swagger使用的时候报错，无法看到列表，这里我说下如何调试和主要问题：
1、如果遇到问题，这样的：
![]()
请在浏览器 =》 F12 ==》 console 控制台 ==》点击错误信息地址
![]()
或者直接链接http://localhost:xxxxx/swagger/v1/swagger.json，就能看到错误了
2、主要问题就是同一个controller中的同一个请求特性（注意[HttpGet]和[HttpGet("{id}")]是两个） ，不能同名
![]()
主要修改下路由，然后配合修改名字就行
[Route("api/[controller]/[action]")]
4、或者直接在方法上增加路由
[HttpPost]
[Route("newPost")]
public void Post([FromBody]string value)
{
}
WHY
书接上文，在前边的两篇文章中，我们简单提到了接口文档神器Swagger，《从零开始搭建自己的前后端分离【 .NET Core2.0 Api + Vue 2.0 + AOP + 分布式】框架之三 || Swagger的使用 3.1》、《从零开始搭建自己的前后端分离【 .NET Core2.0 Api + Vue 2.0 + AOP + 分布式】框架之四 || Swagger的使用 3.2》，两个文章中，也对常见的几个问题做了简单的讨论，最后还剩下一个小问题，
如何给接口实现权限验证？
其实关于这一块，我思考了下，因为毕竟我的项目中是使用的vue + api 搭建一个前台展示，大部分页面都没有涉及到权限验证，本来要忽略这一章节，可是犹豫再三，还是给大家简单分析了下，个人还是希望陪大家一直搭建一个较为强大的，只要是涉及到后端那一定就需要 登陆=》验证了，本文主要是参考网友https://www.cnblogs.com/RayWang/p/9255093.html的思路，我自己稍加改动，大家都可以看看。
根据维基百科定义，JWT（读作 [/dʒɒt/]），即JSON Web Tokens，是一种基于JSON的、用于在网络上声明某种主张的令牌（token）。JWT通常由三部分组成: 头信息（header）, 消息体（payload）和签名（signature）。它是一种用于双方之间传递安全信息的表述性声明规范。JWT作为一个开放的标准（RFC 7519），定义了一种简洁的、自包含的方法，从而使通信双方实现以JSON对象的形式安全的传递信息。
以上是JWT的官方解释，可以看出JWT并不是一种只能权限验证的工具，而是一种标准化的数据传输规范。所以，只要是在系统之间需要传输简短但却需要一定安全等级的数据时，都可以使用JWT规范来传输。规范是不因平台而受限制的，这也是JWT做为授权验证可以跨平台的原因。
如果理解还是有困难的话，我们可以拿JWT和JSON类比：
JSON是一种轻量级的数据交换格式，是一种数据层次结构规范。它并不是只用来给接口传递数据的工具，只要有层级结构的数据都可以使用JSON来存储和表示。当然，JSON也是跨平台的，不管是Win还是Linux，.NET还是Java，都可以使用它作为数据传输形式。
1）客户端向授权服务系统发起请求，申请获取“令牌”。
2）授权服务根据用户身份，生成一张专属“令牌”，并将该“令牌”以JWT规范返回给客户端
3）客户端将获取到的“令牌”放到http请求的headers中后，向主服务系统发起请求。主服务系统收到请求后会从headers中获取“令牌”，并从“令牌”中解析出该用户的身份权限，然后做出相应的处理（同意或拒绝返回资源）
一、通过Jwt获取Token，并通过缓存记录，配合中间件实现验证
在之前的搭建中，swagger已经基本成型，其实其功能之多，不是我这三篇所能写完的，想要添加权限，先从服务开始
在ConfigureServices中，增加以下代码
![]()
![]()
#region Token绑定到ConfigureServices
//添加header验证信息
var security = new Dictionary> { { "Blog.Core", new string[] { } }, };
c.AddSecurityRequirement(security);
//方案名称“Blog.Core”可自定义，上下一致即可
c.AddSecurityDefinition("Blog.Core", new ApiKeyScheme
{
Description = "JWT授权(数据将在请求头中进行传输) 直接在下框中输入{token}\"",
Name = "Authorization",//jwt默认的参数名称
In = "header",//jwt默认存放Authorization信息的位置(请求头中)
Type = "apiKey"
});
#endregion
View Code
最终的是这样的
![]()
![]()
/// <summary>
/// ConfigureServices 方法
/// </summary>
/// <param name="services"></param>
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc();
#region Swagger
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new Info
{
Version = "v0.1.0",
Title = "Blog.Core API",
Description = "框架说明文档",
TermsOfService = "None",
Contact = new Swashbuckle.AspNetCore.Swagger.Contact { Name = "Blog.Core", Email = "Blog.Core@xxx.com", Url = "https://www.jianshu.com/u/94102b59cc2a" }
});
//就是这里
#region 读取xml信息
var basePath = PlatformServices.Default.Application.ApplicationBasePath;
var xmlPath = Path.Combine(basePath, "Blog.Core.xml");//这个就是刚刚配置的xml文件名
var xmlModelPath = Path.Combine(basePath, "Blog.Core.Model.xml");//这个就是Model层的xml文件名
c.IncludeXmlComments(xmlPath, true);//默认的第二个参数是false，这个是controller的注释，记得修改
c.IncludeXmlComments(xmlModelPath);
#endregion
#region Token绑定到ConfigureServices
//添加header验证信息
//c.OperationFilter<SwaggerHeader>();
var security = new Dictionary<string, IEnumerable<string>> { { "Blog.Core", new string[] { } }, };
c.AddSecurityRequirement(security);
//方案名称“Blog.Core”可自定义，上下一致即可
c.AddSecurityDefinition("Blog.Core", new ApiKeyScheme
{
Description = "JWT授权(数据将在请求头中进行传输) 直接在下框中输入{token}\"",
Name = "Authorization",//jwt默认的参数名称
In = "header",//jwt默认存放Authorization信息的位置(请求头中)
Type = "apiKey"
});
#endregion
});
#endregion
#region Token服务注册
services.AddSingleton<IMemoryCache>(factory =>
{
var cache = new MemoryCache(new MemoryCacheOptions());
return cache;
});
services.AddAuthorization(options =>
{
options.AddPolicy("Admin", policy => policy.RequireClaim("AdminType").Build());//注册权限管理，可以自定义多个
});
#endregion
}
View Code
然后执行代码，就可以看到效果
![]()
图 1
![]()
图 2
它的作用就是，每次请求时，从Header报文中，获取密钥token，这里根据token可以进一步判断相应的权限等。
接下来，就是在项目中添加五个文件，如下图
![]()
，图 3
具体来说：
1：BlogCoreMemoryCache
这里是简单的一个缓存的使用，在以后的Redis中，也可以配合使用，这里是先借鉴大神的，以后我会扩展，然后并结合Redis，具体看Git上的代码，这里不做详细说明
![]()
![]()
public class RayPIMemoryCache
{
public static MemoryCache _cache = new MemoryCache(new MemoryCacheOptions());
/// <summary>
/// 验证缓存项是否存在
/// </summary>
/// <param name="key">缓存Key</param>
/// <returns></returns>
public static bool Exists(string key)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
object cached;
return _cache.TryGetValue(key, out cached);
}
/// <summary>
/// 获取缓存
/// </summary>
/// <param name="key">缓存Key</param>
/// <returns></returns>
public static object Get(string key)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
return _cache.Get(key);
}
/// <summary>
/// 添加缓存
/// </summary>
/// <param name="key">缓存Key</param>
/// <param name="value">缓存Value</param>
/// <param name="expiresSliding">滑动过期时长（如果在过期时间内有操作，则以当前时间点延长过期时间）</param>
/// <param name="expiressAbsoulte">绝对过期时长</param>
/// <returns></returns>
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);
}
}
View Code
2：BlogCoreToken，主要方法，获取JWT字符串并存入缓存中
![]()
![]()
public class BlogCoreToken
{
public BlogCoreToken()
{
}
/// <summary>
/// 获取JWT字符串并存入缓存
/// </summary>
/// <param name="tm"></param>
/// <param name="expireSliding"></param>
/// <param name="expireAbsoulte"></param>
/// <returns></returns>
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: "Blog.Core",//jwt签发者,非必须，自定义
audience: tokenModel.Uname,//jwt的接收该方，非必须
claims: claims,//声明集合
expires: UTC.AddHours(12),//指定token的生命周期，unix时间戳格式,非必须
signingCredentials: new Microsoft.IdentityModel.Tokens
.SigningCredentials(new SymmetricSecurityKey(Encoding.ASCII.GetBytes("Blog.Core's Secret Key")), SecurityAlgorithms.HmacSha256));
var encodedJwt = new JwtSecurityTokenHandler().WriteToken(jwt);
RayPIMemoryCache.AddMemoryCache(encodedJwt, tokenModel, expiresSliding, expiresAbsoulte);//将JWT字符串，令牌实体，存入缓存
return encodedJwt;
}
}
View Code
3：TokenAuth，这是一个中间件，每次网络请求的时候，都走这里，作为报文获取判断，并防篡改
![]()
![]()
public class TokenAuth
{
/// <summary>
///
/// </summary>
private readonly RequestDelegate _next;
/// <summary>
///
/// </summary>
/// <param name="next"></param>
public TokenAuth(RequestDelegate next)
{
_next = next;
}
/// <summary>
///
/// </summary>
/// <param name="httpContext"></param>
/// <returns></returns>
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().Trim();
//如何存在Authorization，但是和缓存的不一样，那就是被篡改了
if (!RayPIMemoryCache.Exists(jwtStr))
{
return httpContext.Response.WriteAsync("非法请求");
}
TokenModel tm = ((TokenModel)RayPIMemoryCache.Get(jwtStr));
//提取tokenModel中的Sub属性进行authorize认证
List<Claim> lc = new List<Claim>();
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验证异常");
}
}
}
View Code
4：上边的方法中都会用到一个TokenModel，自己简单写一个，也可以是你登陆的时候的用户实体类，或者其他，
![]()
![]()
///
/// 令牌类
///
public class TokenModel
{
publicTokenModel()
{
this.Uid = 0;
}
///
/// 用户Id
///
public long Uid { get; set; }
///
/// 用户名
///
public string Uname { get; set; }
///
/// 手机
///
public string Phone { get; set; }
///
/// 头像
///
public string Icon { get; set; }
///
/// 昵称
///
public stringUNickname { get; set; }
///
/// 签名
///
public string Sub { get; set; }
View Code
5：将四个文件都添加好后，最后两步
1、然后再Startup的Configure中，将TokenAuth注册中间件
![]()
图 6
2、在需要加权限的页面中，增加特性
这个时候，你运行项目，发现之前写的都报错了，
![]()
图 7
别慌！是因为每次操作请求，都会经过TokenAuth 中的Invoke方法，方法中对Header信息进行过滤，因为现在Header中，并没有相应的配置信息，看到这里，你就想到了，这个特别像我们常见的[HttpGet]等特性，没错！在.Net Core 中，到处都可以看到AOP编程，真的特别强大。
这个时候我们就用到了最开始的那个权限按钮
![]()
，图 8
没错就是这里，但是我们方法写好了，那Token如何获取呢，别急，我们新建一个LoginController，来模拟一次登陆操作，简单传递几个参数，将用户角色和缓存时间传递，然后生成Token，并生成到缓存中，为之后做准备。
![]()
![]()
[HttpGet]
[Route("Token")]
public JsonResult GetJWTStr(long id=1, string sub="Admin", int expiresSliding = 30, int expiresAbsoulute = 30)
{
TokenModel tokenModel = new TokenModel();
tokenModel.Uid = id;
tokenModel.Sub = sub;
DateTime d1 = DateTime.Now;
DateTime d2 = d1.AddMinutes(expiresSliding);
DateTime d3 = d1.AddDays(expiresAbsoulute);
TimeSpan sliding = d2 - d1;
TimeSpan absoulute = d3 - d1;
string jwtStr = BlogCoreToken.IssueJWT(tokenModel, sliding, absoulute);
return Json(jwtStr);
}
View Code
这个时候我们就得到了我们的Token
![]()
图 9
然后粘贴到我们的上图权限窗口中，还记得么
![]()
图 10
接下来，你再调用窗口，就发现都可以辣！
二、通过认证授权的形式，实现验证，去掉缓存（此部分代码周一Git更新）
1、还是和上一种方法类似，做了封装，在项目文件夹AuthHelper下，新建一个OverWrite文件夹，然后新建JwtHelper类
这个类，主要是是生成Token，和解析Token
namespace Blog.Core.AuthHelper
{
public class JwtHelper
{
public static string secretKey { get; set; } = "sdfsdfsrty45634kkhllghtdgdfss345t678fs";
/// <summary>
/// 颁发JWT字符串
/// </summary>
/// <param name="tokenModel"></param>
/// <returns></returns>
public static string IssueJWT(TokenModelJWT tokenModel)
{
var dateTime = DateTime.UtcNow;
var claims = new Claim[]
{
new Claim(JwtRegisteredClaimNames.Jti,tokenModel.Uid.ToString()),//Id
new Claim("Role", tokenModel.Role),//角色
new Claim(JwtRegisteredClaimNames.Iat,dateTime.ToString(),ClaimValueTypes.Integer64)
};
//秘钥
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(JwtHelper.secretKey));
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
var jwt = new JwtSecurityToken(
issuer: "Blog.Core",
claims: claims, //声明集合
expires: dateTime.AddHours(2),
signingCredentials: creds);
var jwtHandler = new JwtSecurityTokenHandler();
var encodedJwt = jwtHandler.WriteToken(jwt);
return encodedJwt;
}
/// <summary>
/// 解析
/// </summary>
/// <param name="jwtStr"></param>
/// <returns></returns>
public static TokenModelJWT SerializeJWT(string jwtStr)
{
var jwtHandler = new JwtSecurityTokenHandler();
JwtSecurityToken jwtToken = jwtHandler.ReadJwtToken(jwtStr);
object role = new object(); ;
try
{
jwtToken.Payload.TryGetValue("Role", out role);
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
var tm = new TokenModelJWT
{
Uid = long.Parse(jwtToken.Id),
Role = role.ToString(),
};
return tm;
}
}
/// <summary>
/// 令牌
/// </summary>
public class TokenModelJWT
{
/// <summary>
/// Id
/// </summary>
public long Uid { get; set; }
/// <summary>
/// 角色
/// </summary>
public string Role { get; set; }
}
}
2、还是在OverWrite文件夹中，新建中间件JwtTokenAuth.cs，主要作用和之前一样
public class JwtTokenAuth
{
/// <summary>
///
/// </summary>
private readonly RequestDelegate _next;
/// <summary>
///
/// </summary>
/// <param name="next"></param>
public JwtTokenAuth(RequestDelegate next)
{
_next = next;
}
/// <summary>
///
/// </summary>
/// <param name="httpContext"></param>
/// <returns></returns>
public Task Invoke(HttpContext httpContext)
{
//检测是否包含'Authorization'请求头
if (!httpContext.Request.Headers.ContainsKey("Authorization"))
{
return _next(httpContext);
}
var tokenHeader = httpContext.Request.Headers["Authorization"].ToString();
TokenModelJWT tm = JwtHelper.SerializeJWT(tokenHeader);
//授权
var claimList = new List<Claim>();
var claim = new Claim(ClaimTypes.Role, tm.Role);
claimList.Add(claim);
var identity = new ClaimsIdentity(claimList);
var principal = new ClaimsPrincipal(identity);
httpContext.User = principal;
return _next(httpContext);
}
}
3、在项目启动类的配置服务ConfigureService中，新增认证部分
#region 认证
services.AddAuthentication(x =>
{
x.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
x.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(o =>
{
o.TokenValidationParameters = new TokenValidationParameters
{
ValidIssuer = "Blog.Core",
ValidAudience = "wr",
IssuerSigningKey = new SymmetricSecurityKey(Encoding.ASCII.GetBytes(JwtHelper.secretKey)),
RequireSignedTokens = true,
// 将下面两个参数设置为false，可以不验证Issuer和Audience，但是不建议这样做。
ValidateAudience = false,
ValidateIssuer = true,
ValidateIssuerSigningKey = true,
// 是否要求Token的Claims中必须包含 Expires
RequireExpirationTime = true,
// 是否验证Token有效期，使用当前时间与Token的Claims中的NotBefore和Expires对比
ValidateLifetime = true
};
});
#endregion
登陆，就是验证用户登陆以后，通过个人信息（用户名+密码），调取数据库数据，根据权限，生成一个令牌
认证，就是根据登陆的时候，生成的令牌，检查其是否合法，这个主要是证明没有被篡改
授权，就是根据令牌反向去解析出的用户身份，回应当前http请求的许可，表示可以使用当前接口，或者拒绝访问
![]()
4、修改services.AddAuthorization方法，通过增加角色的方式来配置
services.AddAuthorization(options =>
{
options.AddPolicy("Client", policy => policy.RequireRole("Client").Build());
options.AddPolicy("Admin", policy => policy.RequireRole("Admin").Build());
options.AddPolicy("AdminOrClient", policy => policy.RequireRole("Admin,Client").Build());
});
5、记得修改configure中的中间件
app.UseMiddleware<JwtTokenAuth>();
如果没有权限会是这样的
![]()
WHAT
这一篇呢，写的比较潦草，主要是讲如何使用，具体的细节知识，还是大家摸索，还是那句话，这里只是抛砖引玉的作用哟，通过阅读本文，你会了解到，什么是JWT，如何添加配置.net core 中间件，如何使用Token验证，在以后的项目里你就可以在登陆的时候，调用Token，返回客户端，然后判断是否有相应的接口权限。
NEXT
好啦！项目准备阶段就这么结束了，以后咱们就可以直接用swagger来调试了，而不是没错都用F5运行等，接下来我们就要正式开始搭建项目了，主要采用的是泛型仓储模式 Repository+Service，也是一种常见的模式。
CODE
https://github.com/anjoy8/Blog.Core.git
