学成在线-第16天-讲义- Spring Security Oauth2 JWT（学成网成考服务中心）

1用户认证需求分析1.1用户认证与授权截至目前，项目已经完成了在线学习功能，用户通过在线学习页面点播视频进行学习如何去记录学生的学习过程 呢？要想掌握学生的学习情况就需要知道用户的身份信息，记录哪个用户在什么时间学习什么课程；如果用户要购 买课程也需要知道用户的身份信息。

所以，去管理学生的学习过程最基本的要实现用户的身份认证什么是用户身份认证？用户身份认证即用户去访问系统资源时系统要求验证用户的身份信息，身份合法方可继续访问常见的用户身份认 证表现形式有：用户名密码登录，指纹打卡等方式。

什么是用户授权？用户认证通过后去访问系统的资源，系统会判断用户是否拥有访问资源的权限，只允许访问有权限的系统资源，没 有权限的资源将无法访问，这个过程叫用户授权1.2单点登录需求本项目包括多个子项目，如：学习系统，教学管理中心、系统管理中心等，为了提高用户体验性需要实现用户只认 证一次便可以在多个拥有访问权限的系统中访问，这个功能叫做单点登录。

引用百度百科：单点登录（Single Sign On），简称为 SSO，是目前比较流行的企业业务整合的解决方案之一SSO的定义是在多个应用系统中，用户只需要登录一次就可以访问所有相互信任的应用系统下图是SSO的示意图，用户登录学成网一次即可访问多个系统。

1.3第三方认证需求作为互联网项目难免需要访问外部系统的资源，同样本系统也要访问第三方系统的资源接口，一个场景如下：一个微信用户没有在学成在线注册，本系统可以通过请求微信系统来验证该用户的身份，验证通过后该用户便可在 本系统学习，它的基本流程如下：

从上图可以看出，微信不属于本系统，本系统并没有存储微信用户的账号、密码等信息，本系统如果要获取该用户 的基本信息则需要首先通过微信的认证系统（微信认证）进行认证，微信认证通过后本系统便可获取该微信用户的 基本信息，从而在本系统将该微信用户的头像、昵称等信息显示出来，该用户便不用在本系统注册却可以直接学 习。

什么是第三方认证（跨平台认证）？当需要访问第三方系统的资源时需要首先通过第三方系统的认证（例如：微信认证），由第三方系统对用户认证通 过，并授权资源的访问权限。

2用户认证技术方案2.1单点登录技术方案分布式系统要实现单点登录，通常将认证系统独立抽取出来，并且将用户身份信息存储在单独的存储介质，比如：MySQL、Redis，考虑性能要求，通常存储在Redis中，如下图

单点登录的特点是：1、认证系统为独立的系统2、各子系统通过Http或其它协议与认证系统通信，完成用户认证3、用户身份信息存储在Redis集群Java中有很多用户认证的框架都可以实现单点登录：1、Apache Shiro.。

2、CAS3、Spring security CAS2.2Oauth2认证单点登录的特点是：1、认证系统为独立的系统2、各子系统通过Http或其它协议与认证系统通信，完成用户认证3、用户身份信息存储在Redis集群。

Java中有很多用户认证的框架都可以实现单点登录： 1、Apache Shiro.2、CAS3、Spring security CAS2.2Oauth2认证2.2.1Oauth2认证流程第三方认证技术方案最主要是解决认证协议的通用标准 问题，因为要实现 跨系统认证，各系统之间要遵循一定的接口协议。

OAUTH协议为用户资源的授权提供了一个安全的、开放而又简易的标准同时，任何第三方都可以使用OAUTH认证服务，任何服务提供商都可以实现自身的OAUTH认证服务，因而OAUTH是开放的业界提供了OAUTH的多种实现如PHP、JavaScript，Java，Ruby等各种语言开发包，大大节约了程序员的时间，因而OAUTH是简易的。

互联网很多服务如Open API，很多大公司如Google，Yahoo，Microsoft等都提供了OAUTH认证服务，这些都足以说明OAUTH标准逐渐成为开放资源授权的标准Oauth协议目前发展到2.0版本，1.0版本过于复杂，2.0版本已得到广泛应用。

参考：https://baike.baidu.com/item/oAuth/7153134?fr=aladdinOauth协议：https://tools.ietf.org/html/rfc6749下边分析一个Oauth2认证的例子，黑马程序员网站使用微信认证的过程：

第三方认证技术方案最主要是解决认证协议的通用标准 问题，因为要实现 跨系统认证，各系统之间要遵循一定的接口协议OAUTH协议为用户资源的授权提供了一个安全的、开放而又简易的标准同时，任何第三方都可以使用OAUTH认证服务，任何服务提供商都可以实现自身的OAUTH认证服务，因而OAUTH是开放的。

业界提供了OAUTH的多种实现如PHP、JavaScript，Java，Ruby等各种语言开发包，大大节约了程序员的时间，因而OAUTH是简易的互联网很多服务如Open API，很多大公司如Google，Yahoo，Microsoft等都提供了OAUTH认证服务，这些都足以说明OAUTH标准逐渐成为开放资源授权的标准。

Oauth协议目前发展到2.0版本，1.0版本过于复杂，2.0版本已得到广泛应用 参考：https://baike.baidu.com/item/oAuth/7153134?fr=aladdinOauth协议：。

https://tools.ietf.org/html/rfc6749下边分析一个Oauth2认证的例子，黑马程序员网站使用微信认证的过程：：

1、客户端请求第三方授权用户进入黑马程序的登录页面，点击微信的图标以微信账号登录系统，用户是自己在微信里信息的资源拥有者。

点击“微信”出现一个二维码，此时用户扫描二维码，开始给黑马程序员授权。

2、资源拥有者同意给客户端授权资源拥有者扫描二维码表示资源拥有者同意给客户端授权，微信会对资源拥有者的身份进行验证， 验证通过后，微信会询问用户是否给授权黑马程序员访问自己的微信数据，用户点击“确认登录”表示同意授权，微信认证服务器会 颁发一个授权码，并重定向到黑马程序员的网站。

3、客户端获取到授权码，请求认证服务器申请令牌此过程用户看不到，客户端应用程序请求认证服务器，请求携带授权码4、认证服务器向客户端响应令牌认证服务器验证了客户端请求的授权码，如果合法则给客户端颁发令牌，令牌是客户端访问资源的通行证。

此交互过程用户看不到，当客户端拿到令牌后，用户在黑马程序员看到已经登录成功5、客户端请求资源服务器的资源客户端携带令牌访问资源服务器的资源黑马程序员网站携带令牌请求访问微信服务器获取用户的基本信息6、资源服务器返回受保护资源

资源服务器校验令牌的合法性，如果合法则向用户响应资源信息内容注意：资源服务器和认证服务器可以是一个服务也可以分开的服务，如果是分开的服务资源服务器通常要请求认证 服务器来校验令牌的合法性Oauth2.0认证流程如下：。

引自Oauth2.0协议rfc6749 https://tools.ietf.org/html/rfc6749

Oauth2包括以下角色：1、客户端本身不存储资源，需要通过资源拥有者的授权去请求资源服务器的资源，比如：学成在线Android客户端、学成在线Web客户端（浏览器端）、微信客户端等2、资源拥有者通常为用户，也可以是应用程序，即该资源的拥有者。

3、授权服务器（也称认证服务器）用来对资源拥有的身份进行认证、对访问资源进行授权客户端要想访问资源需要通过认证服务器由资源拥有者授 权后方可访问4、资源服务器存储资源的服务器，比如，学成网用户管理服务器存储了学成网的用户信息，学成网学习服务器存储了学生的学习 信息，微信的资源服务存储了微信的用户信息等。

客户端最终访问资源服务器获取资源信息2.2.2Oauth2在本项目的应用Oauth2是一个标准的开放的授权协议，应用程序可以根据自己的要求去使用Oauth2，本项目使用Oauth2实现如下目标：1、学成在线访问第三方系统的资源

2、外部系统访问学成在线的资源3、学成在线前端（客户端） 访问学成在线微服务的资源4、学成在线微服务之间访问资源，例如：微服务A访问微服务B的资源，B访问A的资源2.3Spring security Oauth2认证解决方案。

本项目采用 Spring security + Oauth2完成用户认证及用户授权，Spring security 是一个强大的和高度可定制的身份验证和访问控制框架，Spring security 框架集成了Oauth2协议，下图是项目认证架构图：

1、用户请求认证服务完成认证2、认证服务下发用户身份令牌，拥有身份令牌表示身份合法3、用户携带令牌请求资源服务，请求资源服务必先经过网关4、网关校验用户身份令牌的合法，不合法表示用户没有登录，如果合法则放行继续访问。

5、资源服务获取令牌，根据令牌完成授权6、资源服务完成授权则响应资源信3Spring Security Oauth2研究3.1目标本项目认证服务基于Spring Security Oauth2进行构建，并在其基础上作了一些扩展，采用JWT令牌机制，并自定义了用户身份信息的内容。

本教程的主要目标是学习在项目中集成Spring Security Oauth2的方法和流程，通过spring Security Oauth2的研究需要达到以下目标：1、理解Oauth2的授权码认证流程及密码认证的流程。

2、理解spring Security Oauth2的工作流程3、掌握资源服务集成spring Security框架完成Oauth2认证的流程3.2搭建认证服务器息3.2.1导入基础工程导入“资料”目录下的 xc-service-ucenter-auth工程，该工程是基于Spring Security Oauth2的一个二次封装的工程，导入此工程研究Oauth2认证流程。

3.2.2创建数据库导入资料目录下的 xc_user.sql，创建用户数据库

以“oauth_”开头的表都是spring Security 自带的表。本项目中spring Security 主要使用oauth_client_details表：

client_id： 客 户 端 id resource_ids：资源id（暂时不用） client_secret：客户端密码scope：范围access_token_validity：访问token的有效期（秒） refresh_token_validity：刷新token的有效期（秒）

authorized_grant_type：授权类型，authorization_code,password,refresh_token,client_credentials3.3Oauth2授权码模式

3.3.1Oauth2授权模式Oauth2有以下授权模式：授权码模式（Authorization Code）隐式授权模式（Implicit）密码模式（Resource Owner Password Credentials）

客户端模式（Client Credentials）其中授权码模式和密码模式应用较多，本小节介绍授权码模式3.3.2授权码授权流程上边例举的黑马程序员网站使用微信认证的过程就是授权码模式，流程如下：1、客户端请求第三方授权 2、用户(资源拥有者)同意给客户端授权 3、客户端获取到授权码，请求认证服务器申请令牌 4、认证服务器向客户端响应令牌 5、客户端请求资源服务器的资源，资源服务校验令牌合法性，完成授权。

6、资源服务器返回受保护资源3.3.2申请授权码请求认证服务获取授权码：Get请求：localhost:40400/auth/oauth/authorize? client_id=XcWebApp&response_type=code&scop=app&redirect_uri=http://localhost + E3 f% |; X& O6 y, _

参数列表如下：client_id：客户端id，和授权配置类中设置的客户端id一致response_type：授权码模式固定为codescop：客户端范围，和授权配置类中设置的scop一致redirect_uri：跳转uri，当授权码申请成功后会跳转到此地址，并在后边带上code参数（授权码）。

首先跳转到登录页面：

输入账号和密码，点击LoginSpring Security接收到请求会调用UserDetailsService接口的loadUserByUsername方法查询用户正确的密码当前导入的基础工程中将正确的密码硬编码为“123”，所以这里账号随意输入，密码输入123即可认证通过。

点击“同意”。接下来返回授权码：认证服务携带授权码跳转redirect_uri

3.3.3申请令牌拿到授权码后，申请令牌Post请求：http://localhost:40400/auth/oauth/token参数如下：grant_type：授权类型，填写authorization_code，表示授权码模式。

code：授权码，就是刚刚获取的授权码，注意：授权码只使用一次就无效了，需要重新申请redirect_uri：申请授权码时的跳转url，一定和申请授权码时用的redirect_uri一致此链接需要使用 http Basic认证。

什么是http Basic认证？http协议定义的一种认证方式，将客户端id和客户端密码按照“客户端ID:客户端密码”的格式拼接，并用base64编 码，放在header中请求服务端，一个例子：Authorization：Basic WGNXZWJBcHA6WGNXZWJBcHA=

WGNXZWJBcHA6WGNXZWJBcHA= 是用户名:密码的base64编码。认证失败服务端返回 401 Unauthorized以上测试使用postman完成：http basic认证：

客户端Id和客户端密码会匹配数据库oauth_client_details表中的客户端id及客户端密码。Post请求参数：

点击发送：申请令牌成功：

access_token：访问令牌，携带此令牌访问资源token_type：有MAC Token与Bearer Token两种类型，两种的校验算法不同，RFC 6750建议Oauth2采用 Bearer Token（http://www.rfcreader.com/#rfc6750）。

refresh_token：刷新令牌，使用此令牌可以延长访问令牌的过期时间expires_in：过期时间，单位为秒scope：范围，与定义的客户端范围一致3.3.4资源服务授权3.3.4.1资源服务授权流程。

资源服务拥有要访问的受保护资源，客户端携带令牌访问资源服务，如果令牌合法则可成功访问资源服务中的资 源，如下图：

上图的业务流程如下：1、客户端请求认证服务申请令牌2、认证服务生成令牌认证服务采用非对称加密算法，使用私钥生成令牌3、客户端携带令牌访问资源服务客户端在Http header 中添加： Authorization：Bearer 令牌。

4、资源服务请求认证服务校验令牌的有效性资源服务接收到令牌，使用公钥校验令牌的合法性5、令牌有效，资源服务向客户端响应资源信息3.3.4.2资源服务授权配置基本上所有微服务都是资源服务，这里我们在课程管理服务上配置授权控制，当配置了授权控制后如要访问课程信 息则必须提供令牌。

1、配置公钥认证服务生成令牌采用非对称加密算法，认证服务采用私钥加密生成令牌，对外向资源服务提供公钥，资源服务使 用公钥 来校验令牌的合法性将公钥拷贝到 publickey.txt文件中，将此文件拷贝到资源服务工程的classpath下。

2、添加依赖

2、添加依赖4 f/ i% y% V9 T- x+ p org.springframework.cloud 1 n" ]4 m9 h+ K7 Q, p spring‐cloud‐starter‐oauth2) B" F# i9 h0 d, y ; [. c1 @4 ^% o1 |

4、在config包下创建ResourceServerConfig类：@Configuration @EnableResourceServer@EnableGlobalMethodSecurity(prePostEnabled = true, securedEnabled = true)//激活方法上的

PreAuthorize注解public class ResourceServerConfig extends ResourceServerConfigurerAdapter {//公钥private static final String PUBLIC_KEY = "publickey.txt";

//定义JwtTokenStore，使用jwt令牌@Beanpublic TokenStore tokenStore(JwtAccessTokenConverter jwtAccessTokenConverter) { return new JwtTokenStore(jwtAccessTokenConverter);

}//定义JJwtAccessTokenConverter，使用jwt令牌@Beanpublic JwtAccessTokenConverter jwtAccessTokenConverter() { JwtAccessTokenConverter converter = new JwtAccessTokenConverter(); converter.setVerifierKey(getPubKey());

return converter;}/***获取非对称加密公钥 Key*@return 公 钥 Key*/private String getPubKey() {Resource resource = new ClassPathResource(PUBLIC_KEY); try {

InputStreamReader inputStreamReader = new InputStreamReader(resource.getInputStream());BufferedReader br = new BufferedReader(inputStreamReader); return br.lines().collect(Collectors.joining("\n"));

} catch (IOException ioe) { return null;}}//Http安全配置，对每个到达系统的http请求链接进行校验@Overridepublic void configure(HttpSecurity http) throws Exception {

//所有请求必须认证通过http.authorizeRequests().anyRequest().authenticated();}}3.3.4.3资源服务授权测试这里我们测试课程图片查询get http://localhost:31200/course/coursepic/list/4028e58161bd3b380161bd3bcd2f0000

请求时没有携带令牌则报错：{ & Y6 e' x7 Z7 g0 V "error": "unauthorized", : d& g @' C3 ~/ s. b' \. A& C "error_description": "Full authentication is required to access this resource"# _0 L4 k# w! g; c F }! c5 [$ W t4 \0 ^* H

请求时携带令牌：在http header中添加 Authorization： Bearer 令牌

当输入错误的令牌也无法正常访问资源。

3.3.4.4解决swagger-ui无法访问当课程管理加了授权之后再访问swagger-ui则报错：

修改授权配置类ResourceServerConfig的configure方法： 针对swagger-ui的请求路径进行放行：//Http安全配置，对每个到达系统的http请求链接进行校验@Override# t* l: }; j1 D9 W3 F# g public void configure(HttpSecurity http) throws Exception { : z- E+ a% F1 \( F# x, y //所有请求必须认证通过http.authorizeRequests() : [, k% V+ G+ y2 j) @ //下边的路径放行; A3 o) ]! h& Q .antMatchers("/v2/api‐docs", "/swagger‐resources/configuration/ui", "/swagger‐resources","/swagger‐resources/configuration/security", "/swagger‐ui.html","/webjars/**").permitAll()1 e" F( F- {( l' @6 U5 }4 ]0 b .anyRequest().authenticated();" V) l1 ~1 Y2 s( Q! D- S }, _' J6 N% l$ m

注意：通过上边的配置虽然可以访问swagger-ui，但是无法进行单元测试，除非去掉认证的配置或在上边配置中添加所有请求均放行（"/**"）3.4Oauth2密码模式授权密码模式（Resource Owner Password Credentials）与授权码模式的区别是申请令牌不再使用授权码，而是直接通过用户名和密码即可申请令牌。

测试如下：Post请求：http://localhost:40400/auth/oauth/token参数：grant_type：密码模式授权填写password username：账号password：密码

并且此链接需要使用 http Basic认证。

上边参数使用x-www-form-urlencoded方式传输，使用postman测试如下：

注意：当令牌没有过期时同一个用户再次申请令牌则不再颁发新令牌3.5校验令牌Spring Security Oauth2提供校验令牌的端点，如下：Get: http://localhost:40400/auth/oauth/check_token?token=。

参数：token：令牌使用postman测试如下：

结果如下：{! {2 d) T" b( f$ l& o. K8 O5 m "companyId": null," x7 D) a2 K( k "userpic": null, "user_name": "mrt", "scope": [ ) u; \$ z! m; a& i "app") e0 K! }) I1 I3 f; u: R$ W8 S/ M9 c ],' c9 I& _0 v" m "name": null, 4 n2 ]6 p5 [0 w* j9 A8 G "utype": null, 7 A, ~' d5 A/ \* ?2 h/ r "id": null,1 X/ U& r! r; `! j "exp": 1531254828, % m% g8 S5 l! q( L8 a "jti": "6a00f227‐4c30‐47dc‐a959‐c0c147806462", "client_id": "XcWebApp" 6 G. @. X4 c) ?/ Z } ' u5 S' W( J+ F" u

exp：过期时间，long类型，距离1970年的秒数（new Date().getTime()可得到当前时间距离1970年的毫秒数）user_name： 用户名client_id：客户端Id，在oauth_client_details中配置scope：客户端范围，在oauth_client_details表中配置jti：与令牌对应的唯一标识。

companyId、userpic、name、utype、id：这些字段是本认证服务在Spring Security基础上扩展的用户身份信息3.5刷新令牌刷新令牌是当令牌快过期时重新生成一个令牌，它于授权码授权和密码授权生成令牌不同，刷新令牌不需要授权码 也不需要账号和密码，只需要一个刷新令牌、客户端id和客户端密码。

测 试 如 下 ： Post：http://localhost:40400/auth/oauth/token 参数：grant_type： 固定为 refresh_tokenrefresh_token：刷新令牌（注意不是access_token，而是refresh_token）

刷新令牌成功，会重新生成新的访问令牌和刷新令牌，令牌的有效期也比旧令牌长 刷新令牌通常是在令牌快过期时进行刷新3.6JWT研究3.6.1JWT介绍在介绍JWT之前先看一下传统校验令牌的方法，如下图：

问题：传统授权方法的问题是用户每次请求资源服务，资源服务都需要携带令牌访问认证服务去校验令牌的合法性，并根 据令牌获取用户的相关信息，性能低下解决：使用JWT的思路是，用户认证通过会得到一个JWT令牌，JWT令牌中已经包括了用户相关的信息，客户端只需要携带JWT访问资源服务，资源服务根据事先约定的算法自行完成令牌校验，无需每次都请求认证服务完成授权。

JWT令牌授权过程如下图：

什么是JWT？JSON Web Token（JWT）是一个开放的行业标准（RFC 7519），它定义了一种简介的、自包含的协议格式，用于在通信双方传递json对象，传递的信息经过数字签名可以被验证和信任。

JWT可以使用HMAC算法或使用RSA的公钥/私钥对来签名，防止被篡改官网：https://jwt.io/标准：https://tools.ietf.org/html/rfc7519JWT令牌的优点：1、jwt基于json，非常方便解析。

2、可以在令牌中自定义丰富的内容，易扩展3、通过非对称加密算法及数字签名技术，JWT防止篡改，安全性高4、资源服务使用JWT可不依赖认证服务即可完成授权缺点：１、JWT令牌较长，占存储空间比较大3.6.1.1令牌结构

通过学习JWT令牌结构为自定义jwt令牌打好基础JWT令牌由三部分组成，每部分中间使用点（.）分隔，比如：xxxxx.yyyyy.zzzzz Header头部包括令牌的类型（即JWT）及使用的哈希算法（如HMAC SHA256或RSA）。

一个例子如下：下边是Header部分的内容{4 w: o8 X. B9 _ "alg": "HS256", ; ] R4 k; s4 B+ Z _; |% ]* ^ "typ": "JWT"+ }, k9 A4 I: P( ?' l# c1 [ } ; d, ?, L, W; O! o7 ` 将上边的内容使用Base64Url编码，得到一个字符串就是JWT令牌的第一部分Payload第二部分是负载，内容也是一个json对象，它是存放有效信息的地方，它可以存放jwt提供的现成字段，比如：iss（签发者）,exp（过期时间戳）, sub（面向的用户）等，也可自定义字段。

此部分不建议存放敏感信息，因为此部分可以解码还原原始内容最后将第二部分负载使用Base64Url编码，得到一个字符串就是JWT令牌的第二部分一个例子：{ . r( c3 X9 ?# D* ~& c: G; D0 H "sub": "1234567890",1 h5 I+ D; y# t7 G "name": "456", "admin": true; d; I( ^/ L* o% x; n! k* t- } }/ D. {4 c* H' a/ G) V! B 。

Signature第三部分是签名，此部分用于防止jwt内容被篡改这个部分使用base64url将前两部分进行编码，编码后使用点（.）连接组成字符串，最后使用header中声明签名算法进行签名一个例子：HMACSHA256( $ Z5 M/ h8 F, z# L p base64UrlEncode(header) + "." + base64UrlEncode(payload), secret)2 X7 o4 |' E+ w" O

base64UrlEncode(header)：jwt令牌的第一部分base64UrlEncode(payload)：jwt令牌的第二部分secret：签名所使用的密钥3.6.3JWT入门Spring Security 提供对JWT的支持，本节我们使用Spring Security 提供的JwtHelper来创建JWT令牌，校验JWT令牌等操作。

3.6.3.1生成私钥和公钥JWT令牌生成采用非对称加密算法1、生成密钥证书下边命令生成密钥证书，采用RSA 算法每个证书包含公钥和私钥keytool -genkeypair -alias xckey -keyalg RSA -keypass xuecheng -keystore xc.keystore -storepass xuechengkeystore

Keytool 是一个java提供的证书管理工具-alias：密钥的别名-keyalg：使用的hash算法-keypass：密钥的访问密码-keystore：密钥库文件名，xc.keystore保存了生成的证书

-storepass：密钥库的访问密码查询证书信息：keytool -list -keystore xc.keystore删除别名keytool -delete -alias xckey -keystore xc.keystore

2、导出公钥openssl是一个加解密工具包，这里使用openssl来导出公钥信息安装 openssl：http://slproweb.com/products/Win32OpenSSL.html安装资料目录下的Win64OpenSSL-1_1_0g.exe。

配置openssl的path环境变量，本教程配置在D:\OpenSSL-Win64\bin cmd进入xc.keystore文件所在目录执行如下命令：keytool ‐list ‐rfc ‐‐keystore xc.keystore | openssl x509 ‐inform pem ‐pubkey 8 ], N% r0 o, j6 V, F2 D

输入密钥库密码：

下边这一段就是公钥内容：-----BEGIN PUBLIC KEY-----MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAijyxMdq4S6L1Af1rtB8SjCZHNgsQG8JTfGy55eYvzG0B

/E4AudR2prSRBvF7NYPL47scRCNPgLnvbQczBHbBug6uOr78qnWsYxHlW6Aa5dI5NsmOD4DLtSw8eX0hFyK5F j6ScYOSFBz9cd1nNTvx2+oIv0lJDcpQdQhsfgsEr1ntvWterZt/8r7xNN83gHYuZ6TM5MYvjQNBc5qC7Krs9wM7U oQuL+s0X6RlOib7/mcLn/lFLsLDdYQAZkSDx/6+t+1oHdMarChIPYT1sx9Dwj2j2mvFNDTKKKKAq0cv14Vrhz67Vj mz2yMJePDqUi0JYS2r0iIo7n8vN7s83v5uOQIDAQAB-----END PUBLIC KEY-----

将上边的公钥拷贝到文本文件中，合并为一行3.6.3.2生成jwt令牌在认证工程创建测试类，测试jwt令牌的生成与验证//生成一个jwt令牌@Test/ w5 @) ]6 |8 m public void testCreateJwt(){% F* }( r4 H+ n$ g" g //证书文件 4 M9 o: u$ o* @1 L ? String key_location = "xc.keystore"; " O7 X! d$ }# \ g# ~0 Y //密钥库密码/ e E/ Z7 Z/ Q$ k8 ^% U String keystore_password = "xuechengkeystore";- Y4 Q5 l% p9 X: U4 U7 U //访问证书路径 : V. u# D' |5 z* I. x ClassPathResource resource = new ClassPathResource(key_location); 8 |' S2 Q I; d% _3 ~/ } //密钥工厂 / G5 e' K! B* p# A6 m KeyStoreKeyFactory keyStoreKeyFactory = new KeyStoreKeyFactory(resource, keystore_password.toCharArray());/ \0 {! D7 J8 X7 v3 h+ B //密钥的密码，此密码和别名要匹配 " J* n; J9 S8 X$ S% T: X9 s3 p+ K String keypassword = "xuecheng"; 2 x( i9 `+ L4 ]9 G) w$ g //密钥别名& H3 \0 w1 l! P/ v8 P String alias = "xckey"; , c8 [! v0 A) q; K7 R3 y# C //密钥对（密钥和公钥）) y9 n4 O4 }0 |4 l8 o4 J9 o/ l. ?7 A KeyPair keyPair = keyStoreKeyFactory.getKeyPair(alias,keypassword.toCharArray()); ! J4 ?- Y; u6 @$ E( Y' h; ^7 @9 n' Q //私钥 0 Q- r# e! q3 e! ~9 g RSAPrivateKey aPrivate = (RSAPrivateKey) keyPair.getPrivate();4 Q$ i+ Y* o+ A+ c- f //定义payload信息& p. t4 @2 [ a9 m- `+ s Map tokenMap = new HashMap<>(); tokenMap.put("id", "123"); 6 A% E9 k1 J4 | a* \2 i" E# y tokenMap.put("name", "mrt");) Y: ~. B# e2 \9 W4 e4 W+ ~8 b8 ^ tokenMap.put("roles", "r01,r02");4 ]9 {! E& X2 w$ d( E tokenMap.put("ext", "1"); : B1 R* U) e5 n* F [( |$ P! G: E //生成jwt令牌 - y5 c2 {1 |6 L; K2 ?, i Jwt jwt = JwtHelper.encode(JSON.toJSONString(tokenMap), new RsaSigner(aPrivate));) e* C. ?) \% b R2 y //取出jwt令牌 $ M2 J2 }9 _3 \3 [5 b: t* j) N# p String token = jwt.getEncoded(); & M, S( [( H! j/ S' P System.out.println("token="+token); ) f! p. m0 e! W }8 ?1 B g% \9 Y 。

3.6.3.3验证jwt令牌//资源服务使用公钥验证jwt的合法性，并对jwt解码@Testpublic void testVerify(){//jwt令牌String token="eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHQiOiIxIiwicm9sZXMiOiJyMDEscjAyIiwibmFtZSI6Im1ydCIsI mlkIjoiMTIzIn0.KK7_67N5d1Dthd1PgDHMsbi0UlmjGRcm_XJUUwseJ2eZyJJWoPP2IcEZgAU3tUaaKEHUf9wSRwaDgwhrw fyIcSHbs8oy3zOQEL8j5AOjzBBs7vnRmB7DbSaQD7eJiQVJOXO1QpdmEFgjhc_IBCVTJCVWgZw60IEW1_Lg5tqaLvCiIl26K 48pJB5f‐le2zgYMzqR1L2LyTFkq39rG57VOqqSCi3dapsZQd4ctq95SJCXgGdrUDWtD52rp5o6_0uq‐ mrbRdRxkrQfsa1j8C5IW2‐T4eUmiN3f9wF9JxUK1 XC1OQkOn‐ZTBCdqwWIygDFbU7sf6KzfHJTm5vfjp6NIA";

//公钥String publickey = "‐‐‐‐‐BEGIN PUBLIC KEY‐‐‐‐‐ MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAijyxMdq4S6L1Af1rtB8SjCZHNgsQG8JTfGy55eYvzG0B/E4AudR2 prSRBvF7NYPL47scRCNPgLnvbQczBHbBug6uOr78qnWsYxHlW6Aa5dI5NsmOD4DLtSw8eX0hFyK5Fj6ScYOSFBz9cd1nNTvx 2+oIv0lJDcpQdQhsfgsEr1ntvWterZt/8r7xNN83gHYuZ6TM5MYvjQNBc5qC7Krs9wM7UoQuL+s0X6RlOib7/mcLn/lFLsLD dYQAZkSDx/6+t+1oHdMarChIPYT1sx9Dwj2j2mvFNDTKKKKAq0cv14Vrhz67Vjmz2yMJePDqUi0JYS2r0iIo7n8vN7s83v5u OQIDAQAB‐‐‐‐‐END PUBLIC KEY‐‐‐‐‐";

//校验jwtJwt jwt = JwtHelper.decodeAndVerify(token, new RsaVerifier(publickey));//获取jwt原始内容String claims = jwt.getClaims();

//jwt令牌String encoded = jwt.getEncoded(); System.out.println(encoded);}4认证接口开发4.1需求分析用户登录的流程图如下：

执行流程：1、用户登录，请求认证服务2、认证服务认证通过，生成jwt令牌，将jwt令牌及相关信息写入Redis，并且将身份令牌写入cookie3、用户访问资源页面，带着cookie到网关4、网关从cookie获取token，并查询Redis校验token,如果token不存在则拒绝访问，否则放行

5、用户退出，请求认证服务，清除redis中的token，并且删除cookie中的token使用redis存储用户的身份令牌有以下作用：1、实现用户退出注销功能，服务端清除令牌后，即使客户端请求携带token也是无效的。

2、由于jwt令牌过长，不宜存储在cookie中，所以将jwt令牌存储在redis，由客户端请求服务端获取并在客户端存 储4.2Redis配置4.2.1安装Redis1、安装Redis服务下载Windows版本的redis：。

https://github.com/MicrosoftArchive/redis/tags 下载Redis-x64-3.2.100版本，解压Redis-x64-3.2.100.zip进入cmd命令行，进入Redis-x64-3.2.100目录。

运行：redis‐server redis.windows.conf& G$ O8 d/ _2 e 出现 下图说明 redis启动成功：

注册为服务：redis‐server ‐‐service‐install redis.windows‐service.conf ‐‐loglevel verbose + n1 [( s* M a, P 刷新服务，会看到多了一个redis服务。

常用的redis服务命令如下： 进入redis安装目录：卸载服务：redis-server.exe --service-uninstall开启服务：redis-server.exe --service-start

停止服务：redis-server.exe --service-stop2、redis-desktop-manager下载windows版本的redis客户端：https://redisdesktop.com/download 下载

redis-desktop-manager-0.9.2.806.exe安装后启动redis客户端： 配置redis链接：

连接成功：

4.2.2redis连接配置在认证服务的application.yml文件中添加如下配置：spring:! ? c5 p( T- ]1 v application: " ]8 q7 k V( k* H- p: S name: xc‐service‐ucenter‐auth redis: 3 L# |( y0 a1 p) [; ? host: ${REDIS_HOST:127.0.0.1} port: ${REDIS_PORT:6379}) \" h1 ^1 ~! l; Q0 v' u. l' Z timeout: 5000 #连接超时 毫秒 + f, j0 E% `4 b" o jedis:2 e' V2 R' z0 r0 |/ c( p pool: 4 F: h+ N0 L# a! n% s+ P maxActive: 3 4 G: v' \! T; y4 k$ d5 q- B maxIdle: 3 r+ [4 }6 r& L5 J minIdle: 1 ( }. }0 z# L; X- V0 ]( q$ ] maxWait: ‐1 #连接池最大等行时间 ‐1没有限制/ a( w" C# a% w- n; N7 C! ^% I: c

4.2.3测试@SpringBootTest @RunWith(SpringRunner.class) public class RedisTest { ; Y, W2 a5 U3 L) U$ J @Autowired0 O' H. @, b* ~8 H9 d7 Z private StringRedisTemplate stringRedisTemplate; @Test 7 j7 u5 V; q: F public void testRedis(){( F1 m& x u! a* ]" L; v1 Q3 ] //定义key ' C+ E9 |/ k6 [* M4 `5 p5 r2 s/ }8 { String key = "user_token:9734b68f‐cf5e‐456f‐9bd6‐df578c711390";( O8 y% |9 ?( N1 J8 u //定义Map5 ^2 A# E3 n- N+ ], @ Map mapValue = new HashMap<>(); mapValue.put("id","101"); mapValue.put("username","itcast");) k9 r% O$ I S4 L String value = JSON.toJSONString(mapValue); & l# @3 I& H, z& N9 ] // 向 redis 中 存 储 字 符 串 stringRedisTemplate.boundValueOps(key).set(value,60, TimeUnit.SECONDS);4 k; w, G( g' S5 I //读取过期时间，已过期返回‐2. B" t$ m( \- O* J/ ?6 l/ S Long expire = stringRedisTemplate.getExpire(key); ; u6 n, O& a7 Q" C# f$ ?, U //根据key获取value7 N9 ~# K2 u+ T' s3 f String s = stringRedisTemplate.opsForValue().get(key); System.out.println(s);' o- k: ?! J6 n- e } # P+ f! ~* x" ~( e ｝ ( L& c$ p6 \! y; I: k

4.3认证服务4.3.1需求分析认证服务需要实现的功能如下：1、登录接口前端post提交账号、密码等，用户身份校验通过，生成令牌，并将令牌存储到redis将令牌写入cookie2、退出接口校验当前用户的身份为合法并且为已登录状态。

将令牌从redis删除删除cookie中的令牌。业务流程如下：

4.3.2Api接口@Api(value = "用户认证",description = "用户认证接口") public interface AuthControllerApi { + B0 `" A* f9 [5 L @ApiOperation("登录") ! E/ ` `' q9 X0 @# b! Z public LoginResult login(LoginRequest loginRequest);/ b/ `2 c- P* W! p# S- c" } @ApiOperation("退出") 2 k; I' c) W: ^ public ResponseResult logout();% k* i. Q( j+ J8 D1 X4 o }1 `% l* A% |8 {1 B {* N

4.3.3配置参数在application.yml中配置参数auth: : |6 o8 @# J( Z7 M, c/ _ tokenValiditySeconds: 1200 #token存储到redis的过期时间clientId: XcWebApp% \; n" y& u* |, Y( @5 q clientSecret: XcWebApp cookieDomain: localhost cookieMaxAge: ‐16 f3 O3 N, S% L- I! O

4.3.4申请令牌测试为了不破坏Spring Security的代码，我们在Service方法中通过RestTemplate请求Spring Security所暴露的申请令牌接口来申请令牌，下边是测试代码：

@SpringBootTest @RunWith(SpringRunner.class) public class TestClient {* [% `! O% s1 @- _# ]! O' U @Autowired: V: q, r$ n! k4 y& M" E( K8 {% Q1 D LoadBalancerClient loadBalancerClient; L" O H0 c: M) o @Autowired, F7 H5 m3 C2 X& s5 ? RestTemplate restTemplate;/ m9 k+ V/ y% ` @Test; \9 U3 P5 n: Q l public void testClient(){ - u( T- M' D# N _! ^4 c" q //采用客户端负载均衡，从eureka获取认证服务的ip 和端口+ I* F6 `) k' E( L7 B- L* b ServiceInstance serviceInstance = loadBalancerClient.choose(XcServiceList.XC_SERVICE_UCENTER_AUTH); / L( X* y, p) }" F) x# Z URI uri = serviceInstance.getUri(); 4 j; x- l; C6 r, Q! a) [7 Q String authUrl = uri+"/auth/oauth/token";9 [5 T, B, H% y. h3 ^( Z- v @SpringBootTest @RunWith(SpringRunner.class) public class TestClient {; `3 D7 D) A; G" r9 D @Autowired & {" b+ U* W3 o0 }5 b) H LoadBalancerClient loadBalancerClient; , Z) m; [9 I& J- E1 Q @Autowired/ M+ k9 y6 @1 v2 C3 p" c RestTemplate restTemplate;9 D- u5 |4 L7 b0 i7 i6 \ @Test" Y: d6 `2 y& ^* c public void testClient(){ 7 M/ J' I3 X! w' y7 e //采用客户端负载均衡，从eureka获取认证服务的ip 和端口 - M$ T: s8 |/ C: z ServiceInstance serviceInstance = loadBalancerClient.choose(XcServiceList.XC_SERVICE_UCENTER_AUTH); 2 [ o& G1 F4 n' l/ s Q URI uri = serviceInstance.getUri();5 s" m+ [" H3 F String authUrl = uri+"/auth/oauth/token"; ! K8 j$ s8 j( k8 }8 j! X

4.3.4Dao暂时使用静态数据，待用户登录调通再连接数据库校验用户信息4.3.5Service调用认证服务申请令牌，并将令牌存储到 redis1、AuthToken创建 AuthToken模型类，存储申请的令牌，包括身份令牌、刷新令牌、jwt令牌身份令牌：用于校验用户是否认证。

刷新令牌：jwt令牌快过期时执行刷新令牌jwt令牌：用于授权@Data @ToString " y3 |7 _( Y( u. Z! i @NoArgsConstructor public class AuthToken { " x9 x: y! G) E+ n5 r String access_token;//身份token* u: V; x2 a/ V2 D String refresh_token;//刷新token String jwt_token;//jwt令牌3 @+ X, n* g) v" L" Y0 l* J" Q R4 U } % [# t9 U B4 T* C/ q" T

申请令牌的service方法如下：@Service" h$ x+ s8 w5 G public class AuthService { & @7 `* ~: i3 ^6 u private static final Logger LOGGER = LoggerFactory.getLogger(AuthService.class); @Value("${auth.tokenValiditySeconds}")" ?# o; p3 T4 Y9 Q( [ p: T8 H int tokenValiditySeconds; - h( U6 s8 F& e8 ?- ` @Autowired ; d. E0 x/ m0 w& Y+ Y$ R, b RestTemplate restTemplate; @Autowired - t9 U( F. `! e1 n2 J. C) ^8 ~! x LoadBalancerClient loadBalancerClient; @Autowired 2 G2 e7 ^5 N% s" C: T* T StringRedisTemplate stringRedisTemplate; 8 m4 k. R4 L) W //认证方法, K8 Q2 h0 u$ t3 l+ ~* o+ r- w9 B public AuthToken login(String username,String password,String clientId,String clientSecret){! J3 \ M5 @: d- f: v2 N, F7 U //申请令牌, q" C! s3 x, j7 Q9 H AuthToken authToken = applyToken(username,password,clientId, clientSecret); if(authToken == null){ 2 s) I/ O3 q8 m. W ExceptionCast.cast(AuthCode.AUTH_LOGIN_APPLYTOKEN_FAIL); 2 ^! }, _( G) `( x" D }- H7 s$ g7 I V //将 token存储到redis% |7 l4 c* F( _. x4 z8 Y; `, r1 E String access_token = authToken.getAccess_token(); String content = JSON.toJSONString(authToken);6 s/ E( H! b# R ^# Z boolean saveTokenResult = saveToken(access_token, content, tokenValiditySeconds); + H8 x+ w8 x1 J3 p if(!saveTokenResult){! @$ Q6 B! w* A6 L& N ExceptionCast.cast(AuthCode.AUTH_LOGIN_TOKEN_SAVEFAIL);# w+ n6 Z. C' Y ] H* f' z& R } 8 j1 x0 r' M" p0 a- K2 J& ? return authToken; 7 C- p m H/ n }1 Z- i2 s( K4 f3 y6 a6 ^ //存储令牌到redis* @* _" F n+ `3 ?- H; |* V private boolean saveToken(String access_token,String content,long ttl){ 7 M" q- i% f d! R //令牌名称0 t6 F/ \7 S2 O* ] String name = "user_token:" + access_token; & }+ n8 Z1 ]. ]0 T+ `2 ^ //保存到令牌到redis ; X( J1 T& z! v1 ? stringRedisTemplate.boundValueOps(name).set(content,ttl, TimeUnit.SECONDS); ! q7 e: h( \8 G //获取过期时间, c7 }! X4 C! T% t Long expire = stringRedisTemplate.getExpire(name); return expire>0;# o# t4 G( \7 Z" c0 R } + k5 c% M. n7 e5 T" P //认证方法 ' T( R' N7 B2 N4 K private AuthToken applyToken(String username,String password,String clientId,String clientSecret){9 M0 ^% R1 \/ l( `& Y //选中认证服务的地址0 |$ c) |. z: m9 V ServiceInstance serviceInstance = loadBalancerClient.choose(XcServiceList.XC_SERVICE_UCENTER_AUTH); ]! R7 l& a! H4 Y' @9 t if (serviceInstance == null) { LOGGER.error("choose an auth instance fail");; i! Z+ z* j$ u: I3 V% k ExceptionCast.cast(AuthCode.AUTH_LOGIN_AUTHSERVER_NOTFOUND); ! Q" t$ Y5 B. N+ V; [7 d: {, q }( i9 N [! }! \- I8 L //获取令牌的url 6 y! r" v c# M* W8 K6 D6 o3 H String path = serviceInstance.getUri().toString()+"/auth/oauth/token"; ) W1 i8 P1 Z3 S( _0 U //定义body 4 E, R; \: `8 c U; @! F) H) a9 d MultiValueMap formData = new LinkedMultiValueMap<>();: \ i3 _- N2 _% M //授权方式 1 O' `4 n5 j4 O' }( `% }' h2 n formData.add("grant_type", "password");$ s6 U: V* w( G* ^ //账号formData.add("username",username); " \6 H6 W1 t9 \* [8 \/ D //密码 ~( w( Y( X) j# T2 ]' { formData.add("password", password); ) L2 A$ |$ j& B9 D3 Q2 {: V //定义头9 W/ x4 G! a0 b( }& w1 W+ ? p& H MultiValueMap header = new LinkedMultiValueMap<>(); header.add("Authorization", httpbasic(clientId,clientSecret)); ( s/ L8 D* l" g& F1 N //指定 restTemplate当遇到400或401响应时候也不要抛出异常，也要正常返回值 # ]9 Z( W- y( j- w: f/ X4 k restTemplate.setErrorHandler(new DefaultResponseErrorHandler(){/ m9 j+ P& Z9 T! q. Z" Z @Override1 s4 [" G& o0 q3 e2 P public void handleError(ClientHttpResponse response) throws IOException { ( }4 ^$ x0 d- ]2 @! s. N //当响应的值为400或401时候也要正常响应，不要抛出异常if(response.getRawStatusCode()!=400 && response.getRawStatusCode()!=401){ / c, ]/ F: z8 @0 C super.handleError(response); 3 g$ D$ i1 a% O( k8 a v7 Q. t }6 w. J: D0 u4 ~- n) m } 9 Q( f7 w* _7 P7 q }); 1 }2 t% T, H+ L! k. R Map map = null; try {) E4 @, C, i8 A5 y" m //http请求spring security的申请令牌接口 4 o ^9 h6 ^) A9 c9 b+ { ResponseEntity mapResponseEntity = restTemplate.exchange(path, HttpMethod.POST, }0 i9 k0 I7 S* c2 e new HttpEntity(formData, header), Map.class); map = mapResponseEntity.getBody();! O6 Q5 [4 m" Q/ N M5 |' @, h } catch (RestClientException e) { e.printStackTrace();# e8 M* H8 K+ ]% s; J/ c% f LOGGER.error("request oauth_token_password error: {}",e.getMessage()); e.printStackTrace(); ExceptionCast.cast(AuthCode.AUTH_LOGIN_APPLYTOKEN_FAIL); / c5 |7 d3 [5 B) K } + A4 t0 B8 F; U$ g2 m4 L" [ if(map == null ||* T9 g: P0 _) I6 o T map.get("access_token") == null || map.get("refresh_token") == null || ) P% O. U: z, ?4 r3 B map.get("jti") == null){//jti是jwt令牌的唯一标识作为用户身份令牌 : ?, r9 y& n, I0 g& k4 ? ExceptionCast.cast(AuthCode.AUTH_LOGIN_APPLYTOKEN_FAIL);2 P+ m; f; |7 F" O* a }$ _8 \# \) w% C# ~& y AuthToken authToken = new AuthToken(); . \ U& l( g+ Q: W //访问令牌(jwt) 5 U2 `! T: D4 X+ y3 h String jwt_token = (String) map.get("access_token");1 b5 n* V! l0 X) k- E9 |4 a3 v //刷新令牌(jwt), S1 _2 Y2 P! `9 r. i/ ~ n String refresh_token = (String) map.get("refresh_token"); % E! r! Y# Q3 ^ I' O* D3 Y( B //jti，作为用户的身份标识 # r1 v8 G# ]! _5 t* C+ B String access_token = (String) map.get("jti"); authToken.setJwt_token(jwt_token); authToken.setAccess_token(access_token); authToken.setRefresh_token(refresh_token); return authToken; , W2 n+ P' r* ^( w& z }1 |" v% S. j% m q2 G5 c5 Q //获取httpbasic认证串 * [" k D) W9 a& Y. @( K5 Z } private String httpbasic(String clientId,String clientSecret){ ( m$ v7 |- @" g/ w% g( ~4 j //将客户端id和客户端密码拼接，按“客户端id:客户端密码” String string = clientId+":"+clientSecret;2 f, F0 O6 N5 D# k0 _- N //进行base64编码 ) R; Q* i+ t) L8 U: A byte[] encode = Base64.encode(string.getBytes()); return "Basic "+new String(encode);" v+ J) Q/ G# h9 O* N } 4 j+ f& c0 S9 i$ P2 P* e/ A }( ?6 e1 W' `0 a 5 h& Q0 c& Y4 a* e9 [* {+ ~( F

4.3.6ControllerAuthController代码如下：@RestController# G% M6 X- R5 r# Q" z public class AuthController implements AuthControllerApi { @Value("${auth.clientId}") $ D( f0 z4 s U( d- P4 M/ Y String clientId; @Value("${auth.clientSecret}") & v% j, Y4 Y+ o! j: q) C/ s8 a String clientSecret; $ U7 ?3 x% f$ K: Z! o @Value("${auth.cookieDomain}") String cookieDomain; @Value("${auth.cookieMaxAge}") int cookieMaxAge;5 H& X! [2 b- S% ~4 Z8 P$ P @Value("${auth.tokenValiditySeconds}") int tokenValiditySeconds;, m/ [! k! q2 k+ U4 l" z: S @Autowired7 O& _6 @" s8 T* u+ n* G AuthService authService;8 N1 L' D9 t. f& h* B" o' Y; W @Override @PostMapping("/userlogin")4 L' E3 ^" K4 u' B public LoginResult login(LoginRequest loginRequest) {. b/ ?/ ?# T# ^8 Y- T+ _ //校验账号是否输入 / r- V# s. } s5 r( l& b$ t) ? if(loginRequest == null || StringUtils.isEmpty(loginRequest.getUsername())){ ExceptionCast.cast(AuthCode.AUTH_USERNAME_NONE);) e- T* t/ Z* N7 C } - t1 {0 a; E. g5 Q+ }) e% k& R //校验密码是否输入if(StringUtils.isEmpty(loginRequest.getPassword())){ ! f$ k) n' r6 \& d ExceptionCast.cast(AuthCode.AUTH_PASSWORD_NONE);( I9 d& R5 L% Z' }/ |4 C } 5 s0 q V; x) |8 q- F AuthToken authToken = authService.login(loginRequest.getUsername(), loginRequest.getPassword(), clientId, clientSecret); 9 |$ }. f& x; O, ^; i //将令牌写入cookie: |1 | N/ W3 | //访问token # f. H( f; c$ b0 K String access_token = authToken.getAccess_token(); 9 Q: ^" c! {. q* N) s" X& D //将访问令牌存储到cookie saveCookie(access_token); 1 ?7 E; S. K9 i, _0 T* `% x return new LoginResult(CommonCode.SUCCESS,access_token); ; W4 D9 E2 T# L2 w }5 O& k! K ?" G* h5 s$ k //将令牌保存到cookie: l8 K2 r4 a3 |% e4 g private void saveCookie(String token){ ?: m4 Y6 Y! o& f" P. F7 @! L* e HttpServletResponse response = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getResponse(); J' z7 _8 M }" R //添加cookie 认证令牌，最后一个参数设置为false，表示允许浏览器获取 $ H1 D0 b; \: V3 r8 i: J CookieUtil.addCookie(response, cookieDomain, "/", "uid", token, cookieMaxAge, false);4 g# e5 G% E: v' g+ ^3 L } % d% Y. x3 T# o3 i- x; o, B @Override @PostMapping("/userlogout") public ResponseResult logout() { ; a, Q& Y, |; d4 M# x8 y. k return null; # c# N" A% ?1 G( ?- ?) z- e } 3 _' [! X2 J3 z# i( \$ { } ' q5 v1 ~0 |6 O1 X

4.3.7登录url放行认证服务默认都要校验用户的身份信息，这里需要将登录url放行在WebSecurityConfig类中重写 configure(WebSecurity web)方法，如下：@Override1 U6 [4 E* U9 o) ]! F- I: C public void configure(WebSecurity web) throws Exception { web.ignoring().antMatchers("/userlogin"); 5 W/ g7 P. J* B3 J }# j* u0 N! U1 h) A! t 。

4.3.8测试认证接口使用postman测试：Post请求：http://localhost:40400/auth/userlogin

4.3.9测试写入Cookiecookie最终会写到xuecheng.com域名下，可通过nginx代理进行认证，测试cookie是否写成功1、配置nginx代理在ucenter.xuecheng.com下配置代理路径。

#认证 & B; q1 X. j# R: U% G$ c location ^~ /openapi/auth/ { 8 a8 \' O# M' g/ m proxy_pass http://auth_server_pool/auth/; ' M: l$ y. F+ C( ^& j2 f6 G }9 ?5 p+ r4 D0 Y 添加：#认证服务3 D8 `& k N& [- s upstream auth_server_pool{ 5 ~# G8 J0 }! F$ M, k server 127.0.0.1:40400 weight=10; ( j( g+ `# S6 ` }$ l1 T3 T$ J8 ?5 K5 U

2、请求：http://ucenter.xuecheng.com/openapi/auth/userlogin观察cookie写入结果