微服务架构如何设计API代理网关和OAuth2授权认证框架（微服务api权限控制）

( n' q1 `) F$ p

1，授权认证与微服务架构1.1，由不同团队合作引发的授权认证问题去年的时候，公司开发一款新产品，但人手不够，将B/S系统的Web开发外包，外包团队使用Vue.js框架，调用我们的WebAPI，但是这些WebAPI并不在一台服务器上，甚至可能是第三方提供的WebAPI。

! p6 u' e& r# ~) o; d, j5 _; s

同时处于系统安全的架构设计，后端WebAPI是不能直接暴露在外面的；另一方面，我们这个新产品还有一个C/S系统，C端登录的时候，要求统一到B/S端登录，可以从C端无障碍的访问任意B/S端的页面，也可以调用B/S系统的一些API，所以又增加了一个API网关代理。

整个系统的架构示意图如下：

注：上图还有一个iMSF，这是一个实时消息服务框架，这里用来做文件服务，参见《消息服务框架使用案例之--大文件上传（断点续传）功能》在Web端会读取这些上传的文件1.2，微服务--分布式“最彻底”的分1.2.1，为什么需要分布式

大部分情况下，如果你的系统不是很复杂，API和授权认证服务，文件服务都可以放到一台服务器：Web Port 服务器上，但要把它们分开部署到不同的站点，或者不同的服务器，主要是出于以下考虑：1，职责单一：每一个服务都只做一类工作，比如某某业务WebAPI，授权服务，用户身份认证服务，文件服务等；职责单一使得开发、部署和维护变得容易，比如很容易知道当前是授权服务的问题，而不是业务API问题。

* H* e- F" Q$ t1 m4 X) K5 [$ |* c" j

2，系统安全：采用内外网隔离的方案，一些功能需要直接暴露在公网，这需要付出额外的成本，比如带宽租用和安全设施；另外一些功能部署在内网，这样能够提供更大的安全保证3，易于维护：每一个服务职责都比较单一，所以每一个服务都足够小，那么开发维护就更容易，比如要更新一个功能，只需要更新一个服务而不用所有服务器都暂停；另一方面也更加容易监控服务器的负载，如果发现某一个服务器负载太大可以增加服务器来分散负载。

3 c" H3 {1 S! ~3 [8 `' p

4，第三方接入：现在系统越来越复杂，内部的系统很可能需要跟第三方的系统对接，一起协同工作；或者整个系统一部分是 .NET开发的，一部分又是Java平台开发的，两个平台部署的环境有很大差异，没法部署在一起；或者虽然同是ASP.NET MVC，但是一个是MVC３，一个是MVC５，所以需要分别独立部署。

以上就是各个服务需要分开部署的原因，而这样做的结果就是我们常说的分布式计算了，这是自然需求的结果，不是为了分而拆分1.2.2，依赖于中间层而不直接依赖于服务客户端直接访问后端服务，对后端的服务会形成比较强的依赖。

' s7 C" }4 ?9 g9 C* Q

有架构经验的朋友都知道，解决依赖的常见手段就是添加一个中间层，客户端依赖于这个中间层而不是直接依赖于服务层这样做有几个很大的好处：当服务负载过大的时候可以在中间层做负载均衡；或者后端某个服务出现问题可以切换主备服务;

或者替换后端某个服务的版本做灰度发布另一方面，当后端服务部署为多个独立的进程/服务器后，客户端直接访问这些服务，将是一个更加较复杂的问题,负载均衡，主备切换，灰度发布等运维功能更难操作，除此之外，还有下面两个比较重要的问题：。

客户端直接访问后端多个服务，将暴露过多的后端服务器地址，从而增加安全隐患；后端服务太多，需要在客户端维护这些服务访问关系，增加开发调试的复杂性；B/S页面的AJax跨域问题，WebAPI地址跟主站地址不一样，要解决跨域问题比较复杂并且也会增加安全隐患。

/ S9 O! N% e/ g

所以，为了解决客户端对后端服务层的依赖，并且解决后端服务太多以后引起的问题，我们需要在客户端和后端服务层之间添加一个中间层，这个中间层就是我们的服务代理层，也就是我们后面说的服务网关代理（WebAPI Gateway Proxy），它作为我们所有Web访问的入口站点，这就是上图所示的 Web Port。

有了网关代理，后台所有的WebAPI都可以通过这个统一的入口提供对外服务的功能，而对于后端不同服务地址的路由，由网关代理的路由功能来实现，所以这个代理功能很像Nginx这样的反向代理，只不过，这里仅仅代理WebAPI，而不是其它Web资源。

5 F4 L. s/ L$ A8 q7 W1 Q6 y

现在，网关已经成为很多分布式系统的标配，比如TX的这个架构：

. T* T# e: v) X; K) B" z

注：上图来源于网络，侵删！另外，这个读写分离代理，如果使用SOD框架，可以在AdoHelper对象直接设置读写不同的连接字符串简单达到效果1.2.3，微服务架构经过上面的设计，我们发现这个架构有几个特点：。

每个服务足够小，职责单一；每个服务运行在自己的进程或者独立的服务器中，独立发布部署和开发维护；服务对外提供访问或者服务之间进行通信，都是使用轻量级的HTTP API;每个服务有自己独立的存储，彼此之间进行数据交互都通过接口进行；

有一个API代理网关统一提供服务的对外访问这些特点是非常符合现在流行的微服务思想的，比如在《什么是微服务》这篇文章中，像下面说的这样：微服务最早由Martin Fowler与James Lewis于2014年共同提出，微服务架构风格是一种使用一套小服务来开发单个应用的方式途径，每个服务运行在自己的进程中， 并使用轻量级机制通信，通常是HTTP API，这些服务基于业务能力构建，并能够通过自动化部署机制来独立部署，这些服务使用不同的编程语言实现，以及不同数据存储技术， 并保持最低限度的集中式管理。

& E* \8 `9 w7 Z. H; i) C+ K, h. f

所以我们这个架构是基本符合微服务思想的，它的诞生背景也是要解决其它传统单体软件项目现在遇到的问题一样的，是在比较复杂的实际需求环境下自然而然的一种需求，不过好在它没有过多的“技术债务”，所以设计实施起来比较容易。

, H6 E# g. Y+ T, C

下面我们来详细看看这个架构是如何落地的2，“授权\认证\资源”独立服务的OAuth2.0架构2.1，为什么需要OAuth2.0 ?OAuth 2.0已经是一个“用户验证和授权”的工业级标准OAuth（开放授权）是一个开放标准，1.0版本于2006年创立，它允许用户让第三方应用访问该用户在某一网站上存储的私密的资源（如照片，视频，联系人列表），而无需将用户名和密码提供给第三方应用。

OAuth 2.0关注客户端开发者的简易性，同时为Web应用，桌面应用和手机，和起居室设备提供专门的认证流程2012年10月，OAuth 2.0协议正式发布为RFC 6749以上内容详见OAuth 2.0官网。

现在百度开放平台，腾讯开放平台等大部分的开放平台都是使用的OAuth 2.0协议作为支撑，国内越来越多的企业都开始支持OAuth2.0协议现在，我们的产品设计目标是要能够和第三方系统对接，那么在对接过程中的授权问题就是无法回避的问题。

, s0 g) [' j7 d/ e" ^) T

在我们原来的产品中，有用户授权验证的模块，但并没有拆分出独立的服务，用它与第三方系统对接会导致比较大的耦合性；另一方面，与第三方系统对接合作不一定每次都是以我们为主导，也有可能要用第三方的授权认证系统这就出现了选择哪一方的授权认证方案的问题。

4 R$ ?& ^7 M; Y9 ^0 V, l1 I. ~

之前我曾经经历过一个项目，因为其中的授权认证问题导致系统迟迟不能集成所以，选择一个开放标准的授权认证方案，才是最佳的解决方案，而OAuth 2.0正是这样的方案2.2，OAuth的名词解释和规范（1）Third-party application：第三方应用程序，本文中又称”客户端”（client），即上一节例子中的“Web Port”或者C/S客户端应用程序。

" i9 {8 y! N* o

（2）HTTP service：HTTP服务提供商，即上一节例子中提供软件产品的我们公司或者第三方公司（3）Resource Owner：资源所有者，本文中又称“用户”（user）（4）User Agent：用户代理，本文中就是指浏览器或者C/S客户端应用程序。

（5）Authorization server：授权服务器，即服务提供商专门用来处理认证的服务器（6）Resource server：资源服务器，即服务提供商存放用户生成的资源的服务器，即上一节例子中的内部API服务器、第三方外部API服务器和文件服务器等。

9 ]! Y/ q/ G/ y, o" A( P6 |) _

它与认证服务器，可以是同一台服务器，也可以是不同的服务器以上名词是OAuth规范内必须理解的一些名词，然后我们才能方便的讨论OAuth2.0是如何授权的有关OAuth的思路、运行流程和详细的四种授权模式，请参考阮一峰老师的《理解OAuth 2.0》。

2.3，OAuth2.0的授权模式为了表述方便，先简单说说这4种授权模式：授权码模式（authorization code）--是功能最完整、流程最严密的授权模式它的特点就是通过客户端的后台服务器，与"服务提供商"的认证服务器进行互动。

简化模式（implicit）--不通过第三方应用程序的服务器，直接在浏览器中向认证服务器申请令牌，跳过了"授权码"这个步骤，因此得名所有步骤在浏览器中完成，令牌对访问者是可见的，且客户端不需要认证密码模式（resource owner password credentials）--用户向客户端提供自己的用户名和密码。

客户端使用这些信息，向"服务商提供商"索要授权在这种模式中，用户必须把自己的密码给客户端，但是客户端不得储存密码客户端模式（client credentials）--指客户端以自己的名义，而不是以用户的名义，向"服务提供商"进行认证。

严格地说，客户端模式并不属于OAuth框架所要解决的问题在这种模式中，用户直接向客户端注册，客户端以自己的名义要求"服务提供商"提供服务，其实不存在授权问题在我们的需求中，用户不仅仅通过B/S系统的浏览器进行操作，还会通过C/S程序的客户端进行操作，B/S，C/S系统主要都是我们提供和集成的，客户购买了我们这个产品要使用它就意味着客户信任我们的产品。

授权码模式虽然是最完整的授权模式，但是授权码模式授权完成后需要浏览器的跳转，显然浏览器无法直接跳转到我们的C/S客户端，虽然从技术上可以模拟，但实现起来成本还是比较高；简化模式也有这个问题所以我们最终决定采用OAuth2.0的密码模式。

- n0 V; T0 b# X5 k# X* j- d

2.4，OAuth2.0密码模式授权流程 简单来说，密码模式的步骤如下： 用户向客户端提供用户名和密码客户端将用户名和密码发给认证服务器，向后者请求令牌认证服务器确认无误后，向客户端提供访问令牌 上面这个步骤只是说明了令牌的获取过程，也就是我们常说用户登陆成功的过程。

7 B+ c/ Q, |# G

当用户登陆成功之后，客户端得到了一个访问令牌，然后再使用这个令牌去访问资源服务器，具体说来还有如下后续过程：4，客户端携带此访问令牌，访问资源服务器；5，资源服务器去授权服务器验证客户端的访问令牌是否有效；

6，如果访问令牌有效，授权服务器给资源服务器发送用户标识信息；7，资源服务器根据用户标识信息，处理业务请求，最后发送响应结果给客户端。下面是流程图：

注意：这个流程适用于资源服务器、授权服务器相分离的情况，否则，流程中的第5，6步不是必须的，甚至第4，7步都是显而易见的事情而不必说明现在大部分有关OAuth2.0的介绍文章都没有4，5，6，7步骤的说明，可能为了表述方便，默认都是将授权服务器跟资源服务器合在一起部署的。

2.5，授权、认证与资源服务的分离什么情况下授权服务器跟资源服务器必须分开呢？如果一个系统有多个资源服务器并且这些资源服务器的框架版本不兼容，运行环境有差异，代码平台不同（比如一个是.NET，一个是Java），或者一个是内部系统，一个是外部的第三方系统，必须分开部署。

在这些情况下，授权服务器跟任意一个资源服务器部署在一起都不利于另一些资源服务器的使用，导致系统集成成本增加这个时候，授权服务器必须跟资源服务器分开部署，我们在具体实现OAuth2.0系统的时候，需要做更多的事情。

' T( ^- Y$ a, w

什么情况下授权服务器跟认证服务器必须分开呢？ 授权（authorization）和认证（authentication）有相似之处，但也是两个不同的概念：授权（authorization）：授权，批准;批准（或授权）的证书；

认证（authentication）：认证;身份验证;证明，鉴定;密押仅仅从这两个词的名词定义可能不太容易分辨，我们用实际的例子来说明他们的区别：有一个管理系统，包括成熟的人员管理，角色管理，权限管理，系统登录的时候，用户输入的用户名和密码到系统的人员信息表中查询，通过后取得该用户的角色权限。

, U: k' I9 s# }; o) M% V! ^( }$ ^

在这个场景中，用户登录系统实际上分为了3个步骤：用户在登录界面，输入用户名和密码，提交登录请求；【认证】系统校验用户输入的用户名和密码是否在人员信息表中；【授权】给当前用户授予相应的角色权限现在，该管理系统需要和第三方系统对接，根据前面的分析，这种情况下最好将授权功能独立出来，采用OAuth这种开放授权方案，而认证问题，原有管理系统坚持用户信息是敏感信息，不能随意泄露给第三方，要求在原来管理系统完成认证。

- o9 p. s; u* X% V+ r

这样一来，授权和认证，只好分别作为两个服务，独立部署实现了本文的重点就是讲述如何在授权服务器和资源服务器相分离，甚至授权和认证服务器相分离的情况下，如何设计实现OAuth2.0的问题3，PWMIS OAuth2.0 方案。

3 F. u2 @4 B8 y

PWMIS OAuth2.0 方案就是一个符合上面要求的授权与认证相分离，授权与资源服务相分离的架构设计方案，该方案已经成功支撑了我们产品的应用下面分别来说说该方案是如何设计和落地的3.1，使用Owin中间件搭建OAuth2.0认证授权服务器。

这里主要总结下本人在这个产品中搭建OAuth2.0服务器工作的经验至于为何需要OAuth2.0、为何是Owin、什么是Owin等问题，不再赘述我假定读者是使用Asp.Net,并需要搭建OAuth2.0服务器,对于涉及的Asp.Net Identity(Claims Based Authentication)、Owin、OAuth2.0等知识点已有基本了解。

, `; A8 R4 o/ P2 X' [/ T8 \. s

若不了解，请先参考以下文章：MVC5 - ASP.NET Identity登录原理 - Claims-based认证和OWIN下一代Asp.net开发规范OWIN（1）—— OWIN产生的背景以及简单介绍

OWIN OAuth 2.0 Authorization Server我们的工作，可以从研究《OWIN OAuth 2.0 Authorization Server》这个DEMO开始，不过为了更好的结合本文的主题，实现授权与认证相分离的微服务架构，推荐大家直接从我的DEMO开始：https://github.com/bluedoctor/PWMIS.OAuth2.0

PS：大家觉得好，先点个赞支持下，谢谢！克隆我这个DEMO到本地，下面开始我们OAuth2.0如何落地的正式讲解3.2，PWMIS.OAuth2.0解决方案介绍首先看到解决方案视图，先逐个做下简单说明：。

3.2.1，运行解决方案将解决方案的项目，除了PWMIS.OAuth2.Tools，全部设置为启动项目，启动之后，在 http://localhost:62424/ 站点，输入下面的地址：http://localhost:62424/Home

5 Y; R) r' ^" s9 p0 r

然后就可以看到下面的界面：

点击登录页面，为了方便演示，不真正验证用户名和密码，所以随意输入，提交后结果如下图：

* N+ ]* ^ j$ w' Q4 N

点击确定，进入了业务操作页面，如下图：

如果能够看到这个页面，我们的OAuth2.0演示程序就成功了。还可以运行解决方案里面的WinForm测试程序，先登录，然后运行性能测试，如下图：

v5 ]$ w) a) B- J( r

更多信息，请参考下文的【3.8集成C/S客户端访问】下面我们来看看各个程序集项目的构建过程3.3，项目 PWMIS.OAuth2.AuthorizationCenter首先添加一个MVC5项目PWMIS.OAuth2.AuthorizationCenter，然后添加如下包引用：。

Microsoft.AspNet.MvcMicrosoft.Owin.Host.SystemWebMicrosoft.Owin.Security.OAuthMicrosoft.Owin.Security

# ^/ c/ g- U m0 }

.Cookies然后在项目根目录下添加一个OWin的启动类 Startup：using Microsoft.Owin; 8 U9 W' j# D, v+ x, B using Microsoft.Owin.Security; using Microsoft.Owin.Security.OAuth; 0 ?5 N) i" A6 Z8 A3 k, Y

using Owin; using System; 2 {( o! X: e$ w& V" _2 U) _ using System.Collections.Generic; using System.Diagnostics; ! D% C/ t; p* o* Y8 p using System.Web.Http; $ |( V1 a- X7 F K 5 L7 b1 Q6 o% K* f9 H

namespacePWMIS.OAuth2.AuthorizationCenter 3 q) ?8 J5 S Z- m, m. Y) g. n+ r { 2 ]! |3 i4 @4 g5 n: u; F publicpartialclassStartup + H4 k) ~! r% u& T7 u6 X) D& D3 c4 g { publicvoidConfigureAuth

9 x2 N, U+ C2 b* W" e& n4 C P

(IAppBuilder app) { var OAuthOptions = new OAuthAuthorizationServerOptions 7 E- S1 p3 P' i( h/ a { AllowInsecureHttp =

true, : s, ]& S2 q" L0 M } AuthenticationMode = AuthenticationMode.Active, TokenEndpointPath =

new PathString("/api/token"), //获取 access_token 授权服务请求地址 AuthorizeEndpointPath = new PathString(

"/authorize"), //获取 authorization_code 授权服务请求地址 AccessTokenExpireTimeSpan = TimeSpan.FromSeconds(

60), //access_token 过期时间，默认10秒太短 Provider = new OpenAuthorizationServerProvider(), //access_token 相关授权服务

1 n l- z7 p' N% ~" s$ R AuthorizationCodeProvider = new OpenAuthorizationCodeProvider(), //authorization_code 授权服务

; t$ X5 z, \/ L9 ]# L RefreshTokenProvider = new OpenRefreshTokenProvider() //refresh_token 授权服务 }; app.UseOAuthBearerTokens(OAuthOptions);

# H* I& j. i& h

//表示 token_type 使用 bearer 方式 6 e6 p/ P( F P4 Q2 S } 7 V: `! H. R- a- m r publicvoidConfiguration(IAppBuilder app) ' ]' H# d4 f3 I6 G t { % H$ ?4 G& s h! E

// For more information on how to configure your application, visit http://go.microsoft.com/fwlink/?LinkID=316888

" `+ w8 l/ T4 n8 N2 E- d

ConfigureAuth(app); var configuration = new HttpConfiguration(); WebApiConfig.Register(configuration); 4 [. v T# a$ P0 |' z app.UseWebApi(configuration); % k% I& |" M$ X) y } $ |8 p) n9 |4 ~% m8 m } # X+ u3 f- |0 H/ R }

上面的代码中，定义了access_token 授权服务请求地址和access_token 过期时间，这里设置60秒后过期由于本篇着重讲述OAuth2.0的密码授权模式，我们直接看到类 OpenAuthorizationServerProvider的定义：。

OpenAuthorizationServerProvider token过期时间不宜太长，比如一天，这样不安全，但也不能太短，比如10秒，这样当API访问量比较大的时候会增大刷新token的负担，所以这里设置成60秒。

3.3.1，验证客户端信息在本类的第一个方法 ValidateClientAuthentication 验证客户端的信息，这里的客户端可能是C/S程序的客户端，也可能是访问授权服务器的网关代理服务器，OAuth2.0会验证需要生成访问令牌的客户端，只有合法的客户端才可以提供后续的生成令牌服务。

' B$ [/ ]" e7 Y9 a; C* \% j5 N3 O

客户端信息有2个部分，一个是clientId，一个是clientSecret，前者是客户端的唯一标识，后者是授权服务器颁发给客户端的秘钥，这个秘钥可以设定有效期或者设定授权范围为简便起见，我们的演示程序仅仅到数据库去检查下传递的这两个参数是否有对应的数据记录，使用下面一行代码:。

$ H5 A3 ^1 W. |

var identityRepository = IdentityRepositoryFactory.CreateInstance();这里会用到一个验证客户端的接口，包括验证用户名和密码的方法一起定义了：

7 {6 c& p! d& S1 S2 @

////// 身份认证持久化接口///publicinterfaceIIdentityRepository 0 B' E. `) e8 B% d# y! q# P. ] { & q6 h: M( q$ H //////

客户ID是否存在/////////Task ExistsClientId

(string clientId); ; {6 K& h& v# {( S+ y& T5 I- w ////// 校验客户标识//////客户ID///

3 }' H" l( p$ `' s' e

客户秘钥///Task ValidateClient(string clientId,

* s8 n* p9 i0 a* ~- b8 x2 v t

string clientSecret); * o; N- `0 H* [) x8 t0 g+ }, _ ////// 校验用户名密码/////////

# o8 G4 H* B% X8 g% }

///Task ValidatedUserPassword(string userName,

% `# N+ c7 E4 k/ f4 \

string password); }这样我们就可以通过反射或者简单 IOC框架将客户端验证的具体实现类注入到程序中，本例实现了一个简单的客户端和用户认证类，采用的是SOD框架访问数据库：namespace

PWMIS.OAuth2.AuthorizationCenter.Repository $ g9 L) @4 n8 t$ ? b# e8 b0 L { ) z/ [* k4 h( `# Z9 A publicclass SimpleIdentityRepository : IIdentityRepository . ?/ [- D9 S) b {

1 O; f$ @0 w0 m

privatestatic System.Collections.Concurrent.ConcurrentDictionary dictClient = new System.Collections.Concurrent.ConcurrentDictionary<

) b% ?1 P3 L2 U) g9 Z& i/ N! z8 X: H

string, string>(); publicasync Task ExistsClientId(string clientId) { ; R- `8 U) t* q8 }# W

returnawait Task.Run(() => " z" ? M5 d3 [4 b, f { AuthClientInfoEntity entity = new AuthClientInfoEntity(); & @, c1 B l9 E entity.ClientId = clientId; 9 |5 S7 l* Z: ?8 ~) P% N2 E OQL q = OQL.From(

entity) .Select(entity.ClientId) & A9 q( B0 s+ W+ F7 o8 O .Where(entity.ClientId) % u5 o; k- j5 s .END; AuthDbContext context =

new AuthDbContext(); AuthClientInfoEntity dbEntity = context.QueryObject(

q); return dbEntity != null; }); , a' n& E# A2 U8 t- U } 1 `0 H0 P1 |9 P. k: I% g, c, s , F# [# o D7 X" f& L publicasyncTask

ValidateClient(string clientId, string clientSecret) { stringdict_clientSecret; 6 y1 p; j; w- J

3 z& m: w, |0 K/ ^6 N

if (dictClient.TryGetValue(clientId, out dict_clientSecret) && dict_clientSecret== clientSecret) * s& o* F. t% D {

( H+ }# L5 |+ B! c: ?5 L3 u! T

returntrue; } & G4 I. O9 B$ B, z else ; R$ X( ]( d, w/ _; T' D( m Y { $ v% P% S' b) w5 T. J ~2 @; v returnawaitTask.Run(() => { AuthClientInfoEntity entity =

new AuthClientInfoEntity(); ( v, Z1 b: x6 a+ i8 M entity.ClientId = clientId; 5 r2 G# C# G. ^% T. V' @ a entity.ClientSecret = clientSecret; OQL q = OQL.From(

5 S1 T- U0 ]$ r" V' ~ G: i

entity) : Y& `/ j b0 G# c .Select(entity.ClientId) ! e' l/ e/ _& E7 Q8 P# U .Where(entity.ClientId, entity.ClientSecret

) .END; AuthDbContext context = new AuthDbContext(); AuthClientInfoEntity dbEntity = context.QueryObject(

9 D, I. Z# H' g& S4 n0 T

q); ) e: Y7 q* y2 ~4 K" H if (dbEntity != null) { * n2 E" T( k* k% m) e9 D- z dictClient.TryAdd(

clientId, clientSecret); returntrue; }

% f; C3 `* v; Y0 r

elsereturnfalse; }); & J1 _& R' G* E8 k* {) w } & Z/ V8 _1 u# _6 R & s& Q0 j6 A6 P } # k% j- W2 t& C2 c( b |" s' v3 j- n publicasyncTask

/ D, z2 _& U. o6 T _% L( Z! }

> ValidatedUserPassword(string userName, string password) + v8 g* W1 e* h; u4 N7 v) {% I9 O' z { $ A6 E0 }4 N7 N; |0 g returnawaitTask.Run

>(() => 5 u* F3 U5 ?! z1 R! O' x, t4 f1 b { UserInfoEntity user = new UserInfoEntity(); ' x* l: p5 M+ k$ r$ Z: e" s' h1 S user.UserName = userName; user.Password = password; OQL q = OQL.From(

2 `5 O8 [" g. G& T+ C

user) ( T. h; y0 D' e$ ~& Z: M1 r b .Select() .Where(user.UserName, user.Password) # l0 F+ q# u) f& h$ U1 c5 n n$ R& K .END; 0 Q% b' G) T! |0 N0 {. W AuthDbContext context =

* w. Q) S- n. |

new AuthDbContext(); 2 k/ V2 O9 w# y( n, N4 S6 } AuthClientInfoEntity dbEntity = context.QueryObject(

q); : T7 X( r6 {" H$ c, E# j0 s. e return dbEntity != null; }); 6 A. K }9 N- k2 q( r, }% k } 3 R; c# k0 M6 |% u7 g } ' ?9 m, H+ J; s" E! B3 W. g }AuthDbContext 类非常简单，它会自动生成验证客户端所需要的表：

namespacePWMIS.OAuth2.AuthorizationCenter.Repository { ! }( h, D& B- a, a6 a3 K/ Z publicclassAuthDbContextbContext { ) e5 B' V3 t: o' ?3 J" Q9 Q0 Q. \

4 ]' a9 Z# P! F& {2 [

publicAuthDbContext() : base("OAuth2") { # v0 J6 v( J; d. Z1 A } / G5 T# D9 z; Y8 \

protectedoverrideboolCheckAllTableExists() + N. ~/ K& y% o% z+ G { base.CheckTableExists(); + b2 B" d5 y0 R0 d0 I5 L/ l

base.CheckTableExists(); returntrue; ) U% A% I2 X$ Y& j1 D. L- y. d } 8 F5 E$ G( ]' g5 d8 V* \: B } }3.3.2，认证用户，生成访问令牌生成访问令牌需要重写OWIN OAuthAuthorizationServerProvider类的 GrantResourceOwnerCredentials方法（方法的详细内容看前面【OpenAuthorizationServerProvider的定义】），方法里面使用到了IdentityService 对象，它有一个UserLogin 方法，用来实现或者调用用户认证服务：

. V. g+ E" A5 I. L5 X

IdentityServiceUserLogin方法提供了2种方式来认证用户身份，一种是直接访问用户数据库，一种是调用第三方的用户认证接口，这也是当前演示程序默认配置的方式当用户认证比较复杂的时候，推荐使用这种方式，比如认证的时候需要检查验证码。

需要在授权服务器的应用程序配置文件中配置使用何种用户身份验证方式以及验证地址：

="webpages:Enabled"value="false"/>

value="true"/>

/>

( N: {9 U( ?! `, e7 z- H

>如果认证用户名和密码通过，在GrantResourceOwnerCredentials方法最后，调用OWin的用户标识方式表示授权验证通过：3.4，项目 PWMIS.OAuth2.Tools项目 PWMIS.OAuth2.Tools 封装了OAuth2.0调用相关的一些API函数，前面我们介绍了基于OWIN实现的OAuth2.0服务端，下面我们来看看如何调用它生成一个访问令牌。

. E$ U/ Q7 ]1 j% h+ I4 l5 L( R" n' B

3.4.1，OAuthClient类--获取和刷新令牌看到 OAuthClient.cs 文件的 OAuthClient类的GetToken 方法////// 获取访问令牌///

9 a4 e) n5 @9 Z% _% V& O

///授权模式///刷新的令牌///

) Y( |0 f; m# b: P" N& a% p

用户名///用户密码///授权码///

' V/ ~/ a& J: R/ Z

可选业务参数///publicasync Task GetToken(string grantType, string

refreshToken = null, string userName = null, string password = null, string authorizationCode = null

1 |/ D! ]: \9 c

,string scope=null) { & d" z; o7 W, x3 w* Z) ^2 s var clientId = System.Configuration.ConfigurationManager.AppSettings[

"ClientID"]; var clientSecret = System.Configuration.ConfigurationManager.AppSettings["ClientSecret"

]; 0 s/ X) k; _% K4 k {8 `* t: \ this.ExceptionMessage = ""; ; {" Z5 v! B; h- @9 F) L& h var parameters = new Dictionary

$ D6 P$ x. H p" {

>(); x4 l. q8 ]9 V- d1 W: ?* o parameters.Add("grant_type", grantType); if (!string.IsNullOrEmpty(userName) && !

string.IsNullOrEmpty(password)) / }7 V# B* N/ Y3 W6 M# q { " O6 r) N4 M) z9 ? parameters.Add("username", userName); parameters.Add(

& |4 v6 X) O# k- ^- J! r; Z

"password", password); * r# G8 P" @3 ^* Z W parameters.Add("scope", scope); } 9 q! i5 W9 y, R4 d2 e; f

7 W" E+ }) l) G2 }- F4 K; j

if (!string.IsNullOrEmpty(authorizationCode)) 3 F& h0 g: b; F+ v8 X9 s) ? { ' B" a8 f0 K: C2 l& O5 \, Y1 X C var redirect_uri = System.Configuration.ConfigurationManager.AppSettings[

$ |" i; V& W* @0 A: w

"RedirectUri"]; parameters.Add("code", authorizationCode); 7 [# ~- t$ A' [% q9 L parameters.Add(

"redirect_uri", redirect_uri); //和获取 authorization_code 的 redirect_uri 必须一致，不然会报错 } 6 y8 V2 C6 C' I3 [" b2 L8 j

/ h4 L2 K6 W, j. h

if (!string.IsNullOrEmpty(refreshToken)) { parameters.Add("refresh_token"

; K, n" Y0 a$ ^

, refreshToken); ) J6 U! ^# m. J } httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue(

"Basic", ! W. _+ [* i8 K Convert.ToBase64String(Encoding.ASCII.GetBytes(clientId + ":" + clientSecret)));

* V" b1 L% B) \: N# @

string errCode = "00"; try { / Z5 d! a# Q) _* L //PostAsync 在ASP.NET下面，必须加).ConfigureAwait(false)；否则容易导致死锁

//详细内容，请参考 http://blog.csdn.net/ma_jiang/article/details/53887967var cancelTokenSource = new CancellationTokenSource(

0 w- F3 s* i2 N6 q* O; [7 I

50000); var response = await httpClient.PostAsync("/api/token", new FormUrlEncodedContent(parameters), cancelTokenSource.Token).ConfigureAwait(

, `0 b1 p0 L3 u

false); var responseValue = await response.Content.ReadAsStringAsync();

F3 l# b) R* x9 B& r+ P, X+ S

if (response.StatusCode != HttpStatusCode.OK) { try ; w e" j2 d1 W6 m5 _7 [4 T {

var error = await response.Content.ReadAsAsync(); 5 Q2 O& W* W) u: d" K6 k+ |# T if (error.ExceptionMessage ==

! P- q% S B a; p

null) { string errMsg = ""; , ?2 Y( S4 P% x$ [" c6 u+ }( G

& m& h+ C7 X( W( V e

foreach (var item in error) 1 p* G; Q' I4 x& Y2 Z { errMsg += item.Key +

4 i) K% Z$ x' x2 g: k* ]) y4 [) q

":\"" + (item.Value == null ? "" : item.Value.ToString()) + "\","; } 1 K9 @* i6 f8 w0 r+ s

* d: p3 `2 t" H+ j+ V& ]

this.ExceptionMessage = "HttpError:{" + errMsg.TrimEnd(,)+"}"; % Q: `/ O: p# w/ A2 M! E }

else { / Q7 |( K, t1 y' R- e, N" f: ~ this.ExceptionMessage = error.ExceptionMessage; } 7 ?$ d0 Z0 f" j errCode =

. [. r+ m4 t) L$ @4 l

"1000"; 9 t4 i$ p# L( T } E; [3 X1 @1 J! C catch (AggregateException agex) { 7 I4 h& }; Y) m7 h2 H! \" w

! x' H: }( ?6 J- G; l* ]* V( k

string errMsg = ""; 6 K5 _) [2 z& l5 ]. ~+ M6 L! j: ] foreach (var ex in agex.InnerExceptions) 2 E8 V" r; {5 g+ g" u; v { " i" N$ W- N* i P! T errMsg += ex.Message; " D& b9 n+ J3 C) o8 i } " K' u3 d5 h- w errCode =

, M+ B6 A. _; B2 Y7 ?( W/ o; n

"1001"; . A% z. p' M8 R5 ^( `6 E* { this.ExceptionMessage = errMsg; }

catch (Exception ex) . N, E0 ?$ g7 B1 u, _6 K% Q { this.ExceptionMessage = response.Content.ReadAsStringAsync().Result; errCode =

"1002"; % O7 H9 n9 }5 h! o2 d4 F WriteErrorLog(errCode, ex.Message); " m! V0 R1 a1 I; Z$ D; I( R } 1 ?% x7 J( H( O W& x' P( m9 j; D WriteErrorLog(errCode,

"StatusCode:" + response.StatusCode + "\r\n" + this.ExceptionMessage); this.ExceptionMessage =

! E0 h" Q: ~8 Z; d

"{ErrorCode:" + errCode + ",ErrorObject:{" + this.ExceptionMessage + "}}"; ; W* C, A5 A: W return

# l. v5 Z( Y% g% _

null; } returnawait response.Content.ReadAsAsync(); * j) }: g; n- X3 I } ( f0 W% a1 x' T7 J; N4 B4 |2 z1 J

catch (AggregateException agex) { 4 U' B) Q- z& U6 f; W string errMsg = ""; foreach

1 [* l( ~+ o3 x! M

(var ex in agex.InnerExceptions) 9 c& M( N. T# O2 U& A5 L% R { errMsg += ex.Message+","; 4 W7 Z' z" d& ^ u- [ } 6 p* ?' f5 }! i3 C$ a errCode =

"1003"; this.ExceptionMessage = errMsg; WriteErrorLog(errCode, errMsg); 1 r" f& N6 N: R! _1 Q5 K

6 g5 l" p4 p! l0 A% o( m/ _+ o, ~3 Z

this.ExceptionMessage = "{ErrorCode:" + errCode + ",ErrorMessage:" + this.ExceptionMessage + "}";

returnnull; } # }: j d* h4 P Q7 P# m6 @% ~+ l& h catch (Exception ex) { 6 b! z# `3 h( b; n1 y/ Y& B this.ExceptionMessage = ex.Message; 1 ?( D0 q# v: D4 f Q errCode =

( h: ~% O9 w; e1 |

"1004"; WriteErrorLog(errCode, this.ExceptionMessage); this.ExceptionMessage =

) H+ V6 Y8 {, `

"{ErrorCode:" + errCode + ",ErrorMessage:" + this.ExceptionMessage + "}"; 5 y/ Q+ K4 z2 q# h. C! N+ ] returnnull; / e% \3 M: _" p6 Z, \4 D } }

方法首先要获取客户端的clientId 和clientSecret 信息，这个信息需要指定到本次请求的Authorization 头信息里面；然后在请求正文里面，指定授权类型，这里应该是"password"，再在正文里面添加用户名和密码参数。

接着，调用HttpClient对象，访问授权服务器的 /api/token ，该地址正是前面介绍的授权服务器项目里面指定的最后，对请求返回的响应结果做复杂的异常处理，得到正确的返回值或者异常结果在本例中，获取的令牌有效期只有1分钟，超过时间就需要刷新令牌：。

5 Z8 r% o. n7 {* I/ L& s$ O* i

////// 使用指定的令牌，直接刷新访问令牌/////////public

2 W$ p q3 F3 n4 Q* f: r5 g

TokenResponse RefreshToken(TokenResponse token) { # G4 H; c9 ?4 G' N5 H4 N3 S this.CurrentToken = token;

. u) N* a$ L2 j& m

return GetToken("refresh_token", token.RefreshToken).Result; }3.4.2，TokenManager类--令牌的管理由于令牌过期后需要刷新令牌获取新的访问令牌，否则应用使用过期的令牌访问就会出错，因此我们应该在令牌超期之前就检查令牌是否马上到期，在到期之前的前一秒我们就立即刷新令牌，用新的令牌来访问资源服务器；但是刷新令牌可能导致之前一个线程使用的令牌失效，造成访问未授权的问题，毕竟授权服务跟资源服务器分离之后，这个可能性是比较高的，因此我们需要对令牌的使用进行管理，降低发生问题的风险。

首先看到 PWMIS.OAuth2.Tools.TokenManager 文件的 CreateToken 生成令牌的方法：////// 使用密码模式，给当前用户创建一个访问令牌///

///用户登录密码///验证码///

' a2 _0 L/ K7 a) ]" f$ o

publicasync Task CreateToken(string password,string validationCode=null) { ' g3 n; E) }3 G0 F. m( X; B+ e OAuthClient oc =

7 _; i1 I6 D. D C- w1 ~

new OAuthClient(); oc.SessionID = this.SessionID; var tokenRsp= await oc.GetTokenOfPasswardGrantType(

this.UserName, password, validationCode); " z1 G' p" `& q; i0 {6 j+ v$ o8 J if (tokenRsp != null) { UserTokenInfo uti =

new UserTokenInfo(this.UserName, tokenRsp); dictUserToken[this.UserName] = uti; + h( k( n% H5 M- _8 M) v' u6 L }

else { this.TokenExctionMessage = oc.ExceptionMessage; # \" q. R" D5 s2 F: t# Y8 V/ d$ Q }

/ g; n: Q- E# X5 q% {

return tokenRsp; 1 o: G1 U% K( N( u }生成的令牌存储在一个字段中，通过登录用户名来获取对应的令牌然后看TakeToken 方法，它首先尝试获取一个当前用户的令牌，如果令牌快过期，就尝试刷新令牌：。

/// /// 取一个访问令牌/// /// 如果没有或者获取令牌失败，返回空public TokenResponse TakeToken() {

& I, f! ^0 R2 C3 V: u+ x

if (dictUserToken.ContainsKey(this.UserName)) ( e7 _0 n7 m/ Y ? { UserTokenInfo uti = dictUserToken[

8 g6 c7 y) C: D6 [: @7 p

this.UserName]; this.OldToken = uti.Token; , G) Z6 @8 x% f0 ? //如果令牌超期，刷新令牌if (DateTime.Now.Subtract(uti.FirstUseTime).TotalSeconds >= uti.Token.expires_in || NeedRefresh) { lock (uti.SyncObject) 8 E# f$ z& @( f" E% p$ d { + u5 @- {4 F3 s8 T' _

//防止线程重入，再次判断if (DateTime.Now.Subtract(uti.FirstUseTime).TotalSeconds >= uti.Token.expires_in || NeedRefresh) { 0 N0 G# V5 U8 b) d1 {

2 O+ U% d5 i( l0 H" A% D$ O, [& m6 T8 n

//等待之前的用户使用完令牌再刷新while (uti.UseCount > 0) { 5 J! g2 M/ y# P

if (DateTime.Now.Subtract(uti.LastUseTime).TotalSeconds > 5) ; i2 U4 C/ i( d" V1 W& U9 @& s {

; @8 | k0 p5 t, ^( W& b

//如果发出请求超过5秒使用计数还大于0，可以认为资源服务器响应缓慢，最终请求此资源可能会拒绝访问this.TokenExctionMessage = "Resouce Server maybe Request TimeOut."

- [3 K' H" S) v {" X- k5 Q0 V- R

; ) X5 N5 k% R7 u1 D `" B OAuthClient.WriteErrorLog("00", "**警告** "+DateTime.Now.ToString()+

7 m S9 @8 V4 d; d3 i* p

"：用户"+this.UserName+" 最近一次使用当前令牌（" +uti.Token.AccessToken +"）已经超时（10秒）,使用次数："

+uti.UseCount+"，线程ID:"+System.Threading.Thread.CurrentThread.ManagedThreadId+"\r\n**下面将刷新令牌，但可能导致之前还未处理完的资源服务器访问被拒绝访问。

"); break; } System.Threading.Thread.Sleep(

* u ?" N9 |) |0 q; c7 V" f

100); 8 b+ h. M" i- h n. D& l; e! X- M } 3 D: j% \* q1 Z4 h2 N! z0 v8 L //刷新令牌try 2 o* r. p8 d/ L% w& w/ c { OAuthClient oc = new OAuthClient();

+ @0 c* }. F. X# W% O6 U- O% `

var newToken = oc.RefreshToken(uti.Token); $ M) C- X% x! a( a if (newToken == null)

throw new Exception("Refresh Token Error:" + oc.ExceptionMessage); $ t- f9 l2 u; |/ U, m1 | r else

) t3 N) f( F) i, H h

if( string.IsNullOrEmpty( newToken.AccessToken)) / V( x, N/ T4 o7 c4 A/ o throw new Exception(

"Refresh Token Error:Empty AccessToken. Other Message:" + oc.ExceptionMessage); + i v- y: x! z" A 6 T( d W2 u0 q$ B0 s- }6 V1 e uti.ResetToken(newToken);

this.TokenExctionMessage = oc.ExceptionMessage; } 8 W: Y+ D* Z; g" G- g

. M: Z+ S+ W2 P6 J, l* P9 v

catch (Exception ex) { this.TokenExctionMessage = ex.Message; ! @ _7 `" H( b# m# A" r

$ T- t" A" Z. J) k1 G/ x

returnnull; 8 U' [7 e/ r& u% {, Z! _! U } NeedRefresh = false; & d7 }6 P* `; T7 `# ]% | } }

, p; g* \" G Q2 c! z

//end lock 7 ]. ]8 Z/ H! U& u8 Y W } 3 |2 x: Y/ z6 o d' D + K5 H r5 y/ W( Z this.CurrentUserTokenInfo = uti; 0 n$ K; Z( K$ e% a uti.BeginUse();

: _! d2 ~/ \9 `3 _! r! |

//this.CurrentTokenLock.Set();return uti.Token; } " z) u8 b0 D" z) v2 \: ^( K% b else { ) X/ I/ Q+ U6 f1 ]# O: ]

* e* d/ |; M3 a# ^. M$ l9 n

//throw new Exception(this.UserName+" 还没有访问令牌");this.TokenExctionMessage = "UserNoToken"; & Y; G( {0 W: `) S5 w 。

returnnull; . x, c5 z5 I# E3 C! H4 ^: ~ } }有了令牌管理功能，客户端生成和获取一个访问令牌就方便了，下面看看客户端如何来使用它3.5，项目 Demo.OAuth2.Port项目 Demo.OAuth2.Port 在本解决方案里面有3个作用：

- C6 c2 P! B: U8 F

提供静态资源的访问，比如调用WebAPI的Vue.js 功能代码；提供后端API路由功能，作为前端所有API访问的网关代理；存储用户的登录票据，关联用户的访问令牌这里我们着重讲解第3点功能，网关代理功能另外详细介绍。

/ r1 R3 c, L' q# g& e- B6 n* \

在方案中，用户的访问令牌缓存在Port站点的进程中，每当用户登录成功后，就生成一个用户访问令牌跟当前用户票据关联看到项目的控制器 LogonController 的用户登录Action： [。

2 C' l& s; q& a0 h! }

HttpPost] ) T. [; m" ]: y- L [AsyncTimeout(60000)] publicasync Task Index(LogonModel model

6 c9 z( }' p3 t! C0 K& g

) { LogonResultModel result = new LogonResultModel(); . i5 h: V! P) {3 X# J# ]( h //首先，调用授权服务器，以密码模式获取访问令牌

//授权服务器会携带用户名和密码到认证服务器去验证用户身份//验证服务器验证通过，授权服务器生成访问令牌给当前站点程序//当前站点标记此用户登录成功，并将访问令牌存储在当前站点的用户会话中//当前用户下次访问别的站点的WebAPI的时候，携带此访问令牌。

4 D$ Y+ m! R' e( w. Q4 l

& U! K7 c: b% ?: Z1 n TokenManager tm = new TokenManager(model.UserName, Session.SessionID); # k9 S) y. h5 O; I$ ~

var tokenResponse = await tm.CreateToken(model.Password,model.ValidationCode); 0 s4 m3 Z5 j3 j: Z5 o* D5 [ if (tokenResponse !=

7 w' e4 F0 J# X6 w" A* {5 m- `

null && !string.IsNullOrEmpty(tokenResponse.AccessToken)) ) @$ u- G7 q# w! @& y. E$ C+ W, ? { result.UserId =

0 u8 T+ ]7 `9 H) K+ I$ d$ q

123; result.UserName = model.UserName; + i" e& M3 ]9 @" Z0 ]# q! L result.LogonMessage = "OK";

/* OWin的方式 ( b# X' p7 x" p F6 p ClaimsIdentity identity = new ClaimsIdentity("Basic"); ' Z3 r* ?+ X$ x- o identity.AddClaim(new Claim(ClaimTypes.Name, model.UserName)); - O$ @4 s6 |6 B( | ClaimsPrincipal principal = new ClaimsPrincipal(identity); $ L: W4 A+ W4 p# f4 n HttpContext.User = principal; */

" Q* `. N( i4 M0 f6 i1 X

6 n( b; u* d! @2 }$ X8 {7 A FormsAuthentication.SetAuthCookie(model.UserName, false); % U2 m" H0 n* Z! c7 _( I- w, n* h } 3 N# J# R* F% ~

else { 9 Y% @0 ~5 l0 ]- k) c3 Q+ O/ o' h result.LogonMessage = tm.TokenExctionMessage; }

% E( I/ |4 |: ?+ X( X

return Json(result); $ @+ s1 l* y8 P6 O0 z& _ }Port站点作为授权服务器的客户端，需要配置客户端信息，看到Web.config文件的配置：

value="3.0.0.0" />

/>

="PWMIS.OAuth2.Port"/>

value="http://localhost:60186"/> + A) Z* `6 ~, Z6 `- l5 n* A0 n

7 C1 A: |8 S6 w% K6 ~

学习到了，之前一直没注意过这个点，受教了