1. day09 Oauth2.0
2. 用户认证
- 2.1. 单点登陆
- 2.2. 第三方账号登陆
3. 认证解决方案
- 3.1. 第三方登录技术方案
- 3.2. Spring security Oauth2认证解决方案
4. 基于私钥生成jwt令牌
- 4.1. 生成私钥公钥
  - 4.1.1. 导出公钥
- 4.2. 导入认证服务并进行测试
5. Oauth2.0入门
6. 认证开发
7. 认证服务对接网关
- 7.1. 网关全局过滤器
8. 自定义登陆页面
- 8.1. 静态资源放行
- 8.2. 返回login页面
  - 8.2.1. 修改login页面
  - 8.2.2. 定义路径过滤

1. day09 Oauth2.0

2. 用户认证

09. day09 Oauth2.0 - 图1

上面流程图描述了用户要操作的各个微服务，用户查看个人信息需要访问客户微服务，下单需要访问订单微服务，秒杀抢购商品需要访问秒杀微服务。每个服务都需要认证用户的身份，身份认证成功后，需要识别用户的角色然后授权访问对应的功能。

2.1. 单点登陆

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

用户访问的项目中，至少有3个微服务需要识别用户身份，如果用户访问每个微服务都登录一次就太麻烦了，为了提高用户的体验，我们需要实现让用户在一个系统中登录，其他任意受信任的系统都可以访问，这个功能就叫单点登录。

2.2. 第三方账号登陆

随着国内及国外巨头们的平台开放战略以及移动互联网的发展，第三方登录已经不是一个陌生的产品设计概念了。所谓的第三方登录，是说基于用户在第三方平台上已有的账号和密码来快速完成己方应用的登录或者注册的功能。而这里的第三方平台，一般是已经拥有大量用户的平台，国外的比Facebook，Twitter等，国内的比如微博、微信、QQ等。

3. 认证解决方案

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

09. day09 Oauth2.0 - 图2

Java中有很多用户认证的框架都可以实现单点登录

Apache Shiro
CAS
Spring security

3.1. 第三方登录技术方案

第三方认证技术方案最主要是解决认证协议的通用标准问题，因为要实现跨系统认证，各系统之间要遵循一定的接口协议。 OAUTH协议为用户资源的授权提供了一个安全的、开放而又简易的标准。 Oauth协议目前发展到2.0版本，1.0版本过于复杂，2.0版本已得到广泛应用。

09. day09 Oauth2.0 - 图3

3.2. Spring security Oauth2认证解决方案

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

09. day09 Oauth2.0 - 图4

1、用户请求认证服务完成认证。

2、认证服务下发用户身份令牌，拥有身份令牌表示身份合法。

3、用户携带令牌请求资源服务，请求资源服务必先经过网关。

4、网关校验用户身份令牌的合法，不合法表示用户没有登录，如果合法则放行继续访问。

5、资源服务获取令牌，根据令牌完成授权。

6、资源服务完成授权则响应资源信息。

4. 基于私钥生成jwt令牌

4.1. 生成私钥公钥

JWT令牌生成采用非对称加密算法

1、生成密钥证书下边命令生成密钥证书，采用RSA 算法每个证书包含公钥和私钥

keytool -genkeypair -alias changgou -keyalg RSA -keypass changgou -keystore changgou.jks -storepass changgou

Keytool 是一个java提供的证书管理工具

-alias：密钥的别名 
-keyalg：使用的hash算法 
-keypass：密钥的访问密码 
-keystore：密钥库文件名，changgou.jks保存了生成的证书 
-storepass：密钥库的访问密码

查询证书信息：

keytool -list -keystore changgou.jks

4.1.1. 导出公钥

openssl是一个加解密工具包，这里使用openssl来导出公钥信息。

安装 openssl：http://slproweb.com/products/Win32OpenSSL.html

安装资料目录下的Win64OpenSSL-1_1_1b.exe

配置openssl的path环境变量，

09. day09 Oauth2.0 - 图5

09. day09 Oauth2.0 - 图6

cmd进入changgou.jks文件所在目录执行如下命令：

keytool -list -rfc --keystore changgou.jks | openssl x509 -inform pem -pubkey

获取公钥

09. day09 Oauth2.0 - 图7

复制并格式化

4.2. 导入认证服务并进行测试

将课件中changgou_user_auth的工程导入到项目中去

创建通过密钥生成jwt的测试类

package com.changgou.oauth;
import com.alibaba.fastjson.JSON;
import org.junit.Test;
import org.springframework.core.io.ClassPathResource;
import org.springframework.security.jwt.Jwt;
import org.springframework.security.jwt.JwtHelper;
import org.springframework.security.jwt.crypto.sign.RsaSigner;
import org.springframework.security.rsa.crypto.KeyStoreKeyFactory;
import java.security.KeyPair;
import java.security.interfaces.RSAPrivateKey;
import java.util.HashMap;
import java.util.Map;
public class CreateJwtTest {
    @Test
    public void createJWT() {
        //基于私钥生成jwt
        //1.创建一个密钥工厂
        //1.1指定私钥的位置
        ClassPathResource classPathResource = new ClassPathResource("changgou.jks");
        //1.2 指定密钥库的密码
        String keyPass = "changgou";
        //参数一:指定私钥的位置  参数二:指定密钥库的密码
        KeyStoreKeyFactory keyStoreKeyFactory = new KeyStoreKeyFactory(classPathResource, keyPass.toCharArray());
        //2.基于工厂获取私钥
        String alias = "changgou";
        String password = "changgou";
        /**
         *参数一 私钥的别名
         * 参数二 密码库的密码
         */
        KeyPair keyPair = keyStoreKeyFactory.getKeyPair(alias, password.toCharArray());
        //将当前私钥转换为ras私钥
        RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyPair.getPrivate();
        //3.生成jwt
        Map<String, String> map = new HashMap<>();
        map.put("company", "heima");
        map.put("address", "beijing");
        Jwt jwt = JwtHelper.encode(JSON.toJSONString(map), new RsaSigner(rsaPrivateKey));
        String jwtEncoded = jwt.getEncoded();
        System.out.println(jwtEncoded);
    }
}

再通过公钥解析jwt内容

package com.changgou.oauth;
import org.junit.Test;
import org.springframework.security.jwt.Jwt;
import org.springframework.security.jwt.JwtHelper;
import org.springframework.security.jwt.crypto.sign.RsaVerifier;
public class ParseJwtTest {
    @Test
    public void parseJwt() {
        //基于公钥解析jwt
        //jwt
        String jwt = "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJhZGRyZXNzIjoiYmVpamluZyIsImNvbXBhbnkiOiJoZWltYSJ9.cjZNz8G0m4noNYN2VM1SH3ujAtbHElW5Vtbadb0NDI0cjM1DaAXzMA53Qbj4pmVQPl_IfSKqUEXbLxowdRa5NHR43laFsR0kzGbJiTINfSVSroSslYpDdEVwCeAF_a7I-R819YTj4p6sjuYKXbzXpeZQErczFbWWWGR2_U44xH6u1ejRNv8PikFiuzNw-muL7zUJkvqeSJzbEMnQdZMbfvZp4LtSI6B4G_PqpdNXkv19-juxAh99VgJInH_ItF0y5IBOxofA7gRebCZmU8L57gO9ohf2L00D95kis_Ji8lmA1ptLIfXqO_qLVvLBUNH-VtgjGAF0-0pyB-5jlbHP7w";
        //公钥
        String publicKey = "-----BEGIN PUBLIC KEY-----MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAvFsEiaLvij9C1Mz+oyAmt47whAaRkRu/8kePM+X8760UGU0RMwGti6Z9y3LQ0RvK6I0brXmbGB/RsN38PVnhcP8ZfxGUH26kX0RK+tlrxcrG+HkPYOH4XPAL8Q1lu1n9x3tLcIPxq8ZZtuIyKYEmoLKyMsvTviG5flTpDprT25unWgE4md1kthRWXOnfWHATVY7Y/r4obiOL1mS5bEa/iNKotQNnvIAKtjBM4RlIDWMa6dmz+lHtLtqDD2LF1qwoiSIHI75LQZ/CNYaHCfZSxtOydpNKq8eb1/PGiLNolD4La2zf0/1dlcr5mkesV570NxRmU1tFm8Zd3MZlZmyv9QIDAQAB-----END PUBLIC KEY-----";
        //解析jwt
        Jwt token = JwtHelper.decodeAndVerify(jwt, new RsaVerifier(publicKey));
        //获取jwt的原始内容
        String claims = token.getClaims();
        System.out.println(claims);
    }
}

5. Oauth2.0入门

5.1. 准备工作

\1) 搭建认证服务器之前，先在用户系统表结构中增加如下表结构：

此表名是oauth2.0固定写法不能修改

CREATE TABLE `oauth_client_details` (
  `client_id` varchar(48) NOT NULL COMMENT '客户端ID，主要用于标识对应的应用',
  `resource_ids` varchar(256) DEFAULT NULL,
  `client_secret` varchar(256) DEFAULT NULL COMMENT '客户端秘钥，BCryptPasswordEncoder加密',
  `scope` varchar(256) DEFAULT NULL COMMENT '对应的范围',
  `authorized_grant_types` varchar(256) DEFAULT NULL COMMENT '认证模式',
  `web_server_redirect_uri` varchar(256) DEFAULT NULL COMMENT '认证后重定向地址',
  `authorities` varchar(256) DEFAULT NULL,
  `access_token_validity` int(11) DEFAULT NULL COMMENT '令牌有效期',
  `refresh_token_validity` int(11) DEFAULT NULL COMMENT '令牌刷新周期',
  `additional_information` varchar(4096) DEFAULT NULL,
  `autoapprove` varchar(256) DEFAULT NULL,
  PRIMARY KEY (`client_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

导入1条初始化数据,其中加密字符明文为changgou：

INSERT INTO `oauth_client_details` VALUES ('changgou', null, '$2a$10$Yvkp3xzDcri6MAsPIqnzzeGBHez1QZR3A079XDdmNU4R725KrkXi2', 'app', 'authorization_code,password,refresh_token,client_credentials', 'http://localhost', null, '43200', '43200', null, null);

5.2. Oauth2授权模式介绍

Oauth2有以下授权模式：

授权码模式（Authorization Code）
隐式授权模式（Implicit）
密码模式（Resource Owner Password Credentials）
客户端模式（Client Credentials）

其中授权码模式和密码模式应用较多

5.3. 授权码模式

上边例举的黑马程序员网站使用QQ认证的过程就是授权码模式，流程如下：

1、客户端请求第三方授权

2、用户同意给客户端授权

3、客户端获取到授权码，请求认证服务器申请令牌

4、认证服务器向客户端响应令牌

5、客户端请求资源服务器的资源，资源服务校验令牌合法性，完成授权

6、资源服务器返回受保护资源

5.3.1. 申请授权码

通过get请求获取 必须要与数据库信息一致

http://localhost:9200/oauth/authorize?client_id=changgou&response_type=code&scop=app&redirect_uri=http://localhost

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

09. day09 Oauth2.0 - 图8

输入账号和密码，点击Login。 Spring Security接收到请求会调用UserDetailsService接口的loadUserByUsername方法查询用户正确的密码。当前导入的基础工程中客户端ID为changgou，秘钥也为changgou即可认证通过。

09. day09 Oauth2.0 - 图9

点击Authorize,接下来返回授权码：认证服务携带授权码跳转redirect_uri,code=k45iLY就是返回的授权码, 每一个授权码只能使用一次

09. day09 Oauth2.0 - 图10

5.3.2. 申请令牌

拿到授权码后，申请令牌。

Post请求：
http://localhost:9200/oauth/token

grant_type：授权类型，填写authorization_code，表示授权码模式 
code：授权码，就是刚刚获取的授权码，注意：授权码只使用一次就无效了，需要重新申请。 
redirect_uri：申请授权码时的跳转url，一定和申请授权码时用的redirect_uri一致。

09. day09 Oauth2.0 - 图11

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

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

Authorization：Basic WGNXZWJBcHA6WGNXZWJBcHA=WGNXZWJBcHA6WGNXZWJBcHA= 是用户名:密码的base64编码。认证失败服务端返回 401 Unauthorized。

在postman中操作

09. day09 Oauth2.0 - 图12

返回结果

09. day09 Oauth2.0 - 图13

access_token：访问令牌，携带此令牌访问资源 
token_type：有MAC Token与Bearer Token两种类型，两种的校验算法不同，RFC 6750建议Oauth2采用 Bearer Token（http://www.rfcreader.com/#rfc6750）。 
refresh_token：刷新令牌，使用此令牌可以延长访问令牌的过期时间。 
expires_in：过期时间，单位为秒。 
scope：范围，与定义的客户端范围一致。    
jti：当前token的唯一标识

5.3.3. 令牌校验

Spring Security Oauth2提供校验令牌的端点，如下：

Get: http://localhost:9200/oauth/check_token?token= [access_token]

09. day09 Oauth2.0 - 图14

令牌不通过会返回400 并返回异常

令牌过期会返回400 token has expired

5.3.4. 刷新令牌

刷新令牌是当令牌快过期时重新生成一个令牌，它于授权码授权和密码授权生成令牌不同，刷新令牌不需要授权码也不需要账号和密码，只需要一个刷新令牌、客户端id和客户端密码。

测试如下： Post：http://localhost:9200/oauth/token

参数：

grant_type：固定为 refresh_token

refresh_token：刷新令牌（注意不是access_token，而是refresh_token）

09. day09 Oauth2.0 - 图15

5.4. 密码模式

密码模式（Resource Owner Password Credentials）与授权码模式的区别是申请令牌不再使用授权码，而是直接通过用户名和密码即可申请令牌。

5.3.2. 申请令牌

Post请求：
http://localhost:9200/oauth/token
携带参数： 
grant_type：密码模式授权填写password 
username：账号 
password：密码

09. day09 Oauth2.0 - 图16

目前后端密码是写死未itheima 后期会动态查询验证

5.5. 资源服务授权

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

09. day09 Oauth2.0 - 图17

1、客户端请求认证服务申请令牌
2、认证服务生成令牌认证服务采用非对称加密算法，使用私钥生成令牌。
3、客户端携带令牌访问资源服务客户端在Http header 中添加： Authorization：Bearer令牌。
4、资源服务请求认证服务校验令牌的有效性资源服务接收到令牌，使用公钥校验令牌的合法性。
5、令牌有效，资源服务向客户端响应资源信息

5.5.1. 用户服务对接Oauth2

基本上所有微服务都是资源服务，这里我们在课程管理服务上配置授权控制，当配置了授权控制后如要访问课程信息则必须提供令牌。

1、配置公钥，将 changggou_user_auth 项目中public.key复制到changgou_service_user中

09. day09 Oauth2.0 - 图18

2、添加依赖

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-oauth2</artifactId>
</dependency>

3、配置每个系统的Http请求路径安全控制策略以及读取公钥信息识别令牌，如下：

package com.changgou.user.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.oauth2.config.annotation.web.configuration.EnableResourceServer;
import org.springframework.security.oauth2.config.annotation.web.configuration.ResourceServerConfigurerAdapter;
import org.springframework.security.oauth2.provider.token.TokenStore;
import org.springframework.security.oauth2.provider.token.store.JwtAccessTokenConverter;
import org.springframework.security.oauth2.provider.token.store.JwtTokenStore;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.stream.Collectors;
@Configuration
@EnableResourceServer
@EnableGlobalMethodSecurity(prePostEnabled = true, securedEnabled = true)//激活方法上的PreAuthorize注解
public class ResourceServerConfig extends ResourceServerConfigurerAdapter {
    //公钥
    private static final String PUBLIC_KEY = "public.key";
    /***
     * 定义JwtTokenStore
     * @param jwtAccessTokenConverter
     * @return
     */
    @Bean
    public TokenStore tokenStore(JwtAccessTokenConverter jwtAccessTokenConverter) {
        return new JwtTokenStore(jwtAccessTokenConverter);
    }
    /***
     * 定义JJwtAccessTokenConverter
     * @return
     */
    @Bean
    public 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请求链接进行校验
     * @param http
     * @throws Exception
     */
    @Override
    public void configure(HttpSecurity http) throws Exception {
        //所有请求必须认证通过
        http.authorizeRequests()
                //下边的路径放行
                .antMatchers(
                        "/user/add"). //配置地址放行
                permitAll()
                .anyRequest().
                authenticated();    //其他地址需要认证授权
    }
}

5.5.2. 资源服务授权测试

启动user启动类

不携带令牌访问http://localhost:9005/user

由于该地址受访问限制，需要授权，所以出现如下错误：

{
    "error": "unauthorized",
    "error_description": "Full authentication is required to access this resource"
}

携带令牌访问http://localhost:9005/user

在http header中添加 Authorization： Bearer 令牌

09. day09 Oauth2.0 - 图19

6. 认证开发

09. day09 Oauth2.0 - 图20

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

使用redis存储用户的身份令牌有以下作用：

1、实现用户退出注销功能，服务端清除令牌后，即使客户端请求携带token也是无效的。 
2、由于jwt令牌过长，不宜存储在cookie中，所以将jwt令牌存储在redis，由客户端请求服务端获取并在客户端存储。

6.1. 认证需求

认证服务需要实现的功能如下：

1、登录接口

前端post提交账号、密码等，用户身份校验通过，生成令牌，并将令牌存储到redis。将令牌写入cookie。

2、退出接口校验当前用户的身份为合法并且为已登录状态。将令牌从redis删除。删除cookie中的令牌。

09. day09 Oauth2.0 - 图21

6.2. 授权参数配置

修改changgou_user_auth中application.yml配置文件，修改对应的授权配置

auth:
  ttl: 1200  #token存储到redis的过期时间
  clientId: changgou    #客户端ID
  clientSecret: changgou    #客户端秘钥
  cookieDomain: localhost   #Cookie保存对应的域名
  cookieMaxAge: -1          #Cookie过期时间，-1表示浏览器关闭则销毁

6.3. 申请令牌测试

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

package com.changgou.oauth;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.http.client.ClientHttpResponse;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.util.Base64Utils;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.DefaultResponseErrorHandler;
import org.springframework.web.client.RestTemplate;
import java.io.IOException;
import java.net.URI;
import java.nio.charset.StandardCharsets;
import java.util.Map;
@SpringBootTest
@RunWith(SpringRunner.class)
public class ApplyTokenTest {
    @Autowired
    private RestTemplate restTemplate;
    @Autowired
    private LoadBalancerClient loadBalancerClient;
    @Test
    public void applyToken() {
        //构建请求地址
        ServiceInstance serviceInstance = loadBalancerClient.choose("user-auth");
        URI uri = serviceInstance.getUri(); //http://localhost:9200
        //拼接
        String url = uri + "/oauth/token";
        //封装请求参数 body和headers
        MultiValueMap<String, String> body = new LinkedMultiValueMap<>();
        body.add("grant_type", "password");
        body.add("username", "itheima");
        body.add("password", "itheima");
        MultiValueMap<String, String> headers = new LinkedMultiValueMap<>();
        headers.add("Authorization", this.getHttpBasic("changgou", "changgou"));
        HttpEntity<MultiValueMap<String, String>> requestEntity = new HttpEntity<>(body, headers);
        //当后端出现了401或者400 后端不对这两个异常进行处理 而是直接返回给前端
        restTemplate.setErrorHandler(new DefaultResponseErrorHandler() {
            @Override
            public void handleError(ClientHttpResponse response) throws IOException {
                //如果不是400或401 状态码 放行
                if (response.getStatusCode().value() != 400 && response.getStatusCode().value() != 401) {
                    super.handleError(response);
                }
            }
        });
        //发送请求
        ResponseEntity<Map> responseEntity = restTemplate.exchange(url, HttpMethod.POST, requestEntity, Map.class);
        Map entityBody = responseEntity.getBody();
        System.out.println(entityBod3y);
    }
    private String getHttpBasic(String clientId, String clientSecret) {
        String value = clientId + ":" + clientSecret;
        byte[] encode = Base64Utils.encode(value.getBytes(StandardCharsets.UTF_8));
        return "Basic " + new String(encode);
    }
}

在启动类添加bean注解 RestTemplate

@Bean
public RestTemplate restTemplate(){
    return new RestTemplate();
}

运行测试方法

6.4. 业务层

service

package com.changgou.oauth.service;
import com.changgou.oauth.util.AuthToken;
public interface AuthService {
    AuthToken login(String username,String password,String clientId,String clientSecret);
}

impl

package com.changgou.oauth.service.impl;
import com.changgou.oauth.service.AuthService;
import com.changgou.oauth.util.AuthToken;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.http.client.ClientHttpResponse;
import org.springframework.stereotype.Service;
import org.springframework.util.Base64Utils;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.DefaultResponseErrorHandler;
import org.springframework.web.client.RestTemplate;
import java.io.IOException;
import java.net.URI;
import java.util.Map;
import java.util.concurrent.TimeUnit;
@Service
public class AuthServiceImpl implements AuthService {
    @Autowired
    private RestTemplate restTemplate;
    @Autowired
    private LoadBalancerClient loadBalancerClient;
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    @Value("${auth.ttl}")
    private long ttl;
    @Override
    public AuthToken login(String username, String password, String clientId, String clientSecret) {
        //1.申请令牌
        ServiceInstance serviceInstance = loadBalancerClient.choose("user-auth");
        URI uri = serviceInstance.getUri();
        String url = uri + "/oauth/token";
        MultiValueMap<String, String> body = new LinkedMultiValueMap<>();
        body.add("grant_type", "password");
        body.add("username", username);
        body.add("password", password);
        MultiValueMap<String, String> headers = new LinkedMultiValueMap<>();
        headers.add("Authorization", this.getHttpBasic(clientId, clientSecret));
        HttpEntity<MultiValueMap<String, String>> requestEntity = new HttpEntity<>(body, headers);
        restTemplate.setErrorHandler(new DefaultResponseErrorHandler() {
            @Override
            public void handleError(ClientHttpResponse response) throws IOException {
                if (response.getStatusCode().value() != 400 && response.getStatusCode().value() != 401) {
                    super.handleError(response);
                }
            }
        });
        ResponseEntity<Map> exchange = restTemplate.exchange(url, HttpMethod.POST, requestEntity, Map.class);
        Map map = exchange.getBody();
        if (map == null || map.get("access_token") == null || map.get("refresh_token") == null|| map.get("jti") == null){
            //申请令牌失败
            throw new RuntimeException("申请令牌失败");
        }
        //2.封装结果数据
        AuthToken authToken =new AuthToken();
        authToken.setAccessToken((String) map.get("access_token"));
        authToken.setRefreshToken((String) map.get("refresh_token"));
        authToken.setJti((String) map.get("jti"));
        //3.将jti作为redis中的key 将jwt作为redis中的value进行存储
        stringRedisTemplate.boundValueOps(authToken.getJti()).set(authToken.getAccessToken(),ttl, TimeUnit.SECONDS);
        return authToken;
    }
    private String getHttpBasic(String clientId, String clientSecret) {
        String value = clientId + ":" + clientSecret;
        byte[] encode = Base64Utils.encode(value.getBytes());
        return "Basic " + new String(encode);
    }
}

6.5. 控制层

package com.changgou.oauth.controller;
import com.changgou.entity.Result;
import com.changgou.entity.StatusCode;
import com.changgou.oauth.service.AuthService;
import com.changgou.oauth.util.AuthToken;
import com.changgou.oauth.util.CookieUtil;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import javax.servlet.http.HttpServletResponse;
@Controller
@RequestMapping("/oauth")
public class AuthController {
    @Autowired
    private AuthService authService;
    @Value("${auth.clientId}")
    private String clientId;
    @Value("${auth.clientSecret}")
    private String clientSecret;
    @Value("${auth.cookieDomain}")
    private String cookieDomain;
    @Value("${auth.cookieMaxAge}")
    private int cookieMaxAge;
    @RequestMapping("/login")
    @ResponseBody
    public Result login(String username, String password, HttpServletResponse response) {
        //校验参数
        if (StringUtils.isEmpty(username)) {
            throw new RuntimeException("请输入用户名");
        }
        if (StringUtils.isEmpty(password)) {
            throw new RuntimeException("请输入密码");
        }
        //申请令牌
        AuthToken authToken = authService.login(username, password, clientId, clientSecret);
        //将jti的值存入cookie中
        this.saveJtiToCookie(authToken.getJti(), response);
        //返回结果
        return new Result(true, StatusCode.OK, "登陆成功", authToken.getJti());
    }
    //将令牌的jti存入到cookie中
    private void saveJtiToCookie(String jti, HttpServletResponse response) {
        CookieUtil.addCookie(response, cookieDomain, "/", "uid", jti, cookieMaxAge, false);
    }
}

6.6. 登录请求放行

09. day09 Oauth2.0 - 图22

6.7. 测试接口

09. day09 Oauth2.0 - 图23

6.8. 动态获取用户信息

当前在认证服务中，用户密码是写死在用户认证类中。所以用户登录时，无论帐号输入什么，只要密码是itheima都可以访问。因此需要动态获取用户帐号与密码.

在changgou_service_user下的controller层 UserController类

添加以用户名查询用户信息

@GetMapping("/load/{username}")
public User findUserInfo(@PathVariable("username") String username) {
    User user = userService.findById(username);
    return user;
}

在changgou_service_user_api 下创建feign包创建userFeign类注册到feign

com.changgou.user.feign.UserFeign

package com.changgou.user.feign;
import com.changgou.user.pojo.User;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
@FeignClient(name = "user")
public interface UserFeign {
    @GetMapping("/user/load/{username}")
    public User findUserInfo(@PathVariable("username") String username);
}

回到changgou-user-oauth项目 pom文件引入 changgou_service_user_api

      <dependency>
            <groupId>com.changgou</groupId>
            <artifactId>changgou_service_user_api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

修改在changgou-user-oauth的启动类开启feign客户端扫描注解

@EnableFeignClients(basePackages = {"com.changgou.user.feign"})

在changgou-user-oauth的UserDetailsServiceImpl 注入 userFeign 并动态查询用户信息验证用户账号和密码

@Autowired
private UserFeign userFeign;

//String pwd = new BCryptPasswordEncoder().encode("itheima");
com.changgou.user.pojo.User userInfo = userFeign.findUserInfo(username);
String pwd = userInfo.getPassword();

在changgou_service_user项目下的config ResourceServerConfig配置类

添加登陆时用户查询请求

/***
 * Http安全配置，对每个到达系统的http请求链接进行校验
 * @param http
 * @throws Exception
 */
@Override
public void configure(HttpSecurity http) throws Exception {
    //所有请求必须认证通过
    http.authorizeRequests()
            //下边的路径放行
            .antMatchers(
                    "/user/add","/user/load/**"). //配置地址放行
            permitAll()
            .anyRequest().
            authenticated();    //其他地址需要认证授权
}

7. 认证服务对接网关

进入changgou_gateway_system项目pom文件将所有依赖全部注释掉

然后在changgou_gateway项目pom文件引入以下依赖

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-gateway</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <!--redis-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis-reactive</artifactId>
            <version>2.1.3.RELEASE</version>
        </dependency>

新建changgou_gateway_web项目模块

创建启动类

package com.changgou.web.gateway;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
@SpringBootApplication
@EnableEurekaClient
public class WebGatewayApplication {
    public static void main(String[] args) {
        SpringApplication.run(WebGatewayApplication.class, args);
    }
}

application

spring:
  application:
    name: gateway-web
  cloud:
    gateway:
      globalcors:
        cors-configurations:
          '[/**]': # 匹配所有请求
            allowedOrigins: "*" #跨域处理 允许所有的域
            allowedMethods: # 支持的方法
              - GET
              - POST
              - PUT
              - DELETE
      routes:
        - id: changgou_goods_route
          uri: lb://goods
          predicates:
            - Path=/api/album/**,/api/brand/**,/api/cache/**,/api/categoryBrand/**,/api/category/**,/api/para/**,/api/pref/**,/api/sku/**,/api/spec/**,/api/spu/**,/api/stockBack/**,/api/template/**
          filters:
            #- PrefixPath=/brand
            - StripPrefix=1
          #用户微服务
        - id: changgou_user_route
          uri: lb://user
          predicates:
            - Path=/api/user/**,/api/address/**,/api/areas/**,/api/cities/**,/api/provinces/**
          filters:
            - StripPrefix=1
          #认证微服务
        - id: changgou_oauth_user
          uri: lb://user-auth
          predicates:
            - Path=/api/oauth/**
          filters:
            - StripPrefix=1
  redis:
    host: 192.168.130.128
server:
  port: 8001
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:6868/eureka
  instance:
    prefer-ip-address: true
management:
  endpoint:
    gateway:
      enabled: true
    web:
      exposure:
        include: true

7.1. 网关全局过滤器

09. day09 Oauth2.0 - 图24

新建过滤器类AuthorizeFilter,对请求进行过滤

业务逻辑：

判断当前请求是否为登录请求，是的话，则放行
判断cookie中是否存在信息, 没有的话，拒绝访问
判断redis中令牌是否存在，没有的话，拒绝访问

package com.changgou.web.gateway.filter;
import com.changgou.web.gateway.service.AuthService;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.http.HttpStatus;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;
@Component
public class AuthFilter implements GlobalFilter, Ordered {
    @Autowired
    private AuthService authService;
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        ServerHttpRequest request = exchange.getRequest();
        ServerHttpResponse response = exchange.getResponse();
        //1.判断请求路径是否为登陆请求 如果是 则直接放行
        String path = request.getURI().getPath();
        if ("/api/oauth/login".equals(path)) {
            //直接放行
            return chain.filter(exchange);
        }
        //2.不是登陆请求 从cookie中获取jti的值 如果值不存在 拒绝本次访问
        String jti = authService.getJtiFromCookie(request);
        if (StringUtils.isEmpty(jti)) {
            //为空 拒绝访问
            response.setStatusCode(HttpStatus.UNAUTHORIZED);
            return response.setComplete();
        }
        //3.如果cookie中有jti的值 从redis中获取jwt的值 如果值不存在 拒绝本次访问
        String jwt = authService.getJwtFromRedis(jti);
        if (StringUtils.isEmpty(jwt)) {
            //过期或不存在 拒绝访问
            response.setStatusCode(HttpStatus.UNAUTHORIZED);
            return response.setComplete();
        }
        //对当前的请求对象进行增强 让它携带令牌的信息
        request.mutate().header("Authorization", "Bearer " + jwt);
        return chain.filter(exchange);
    }
    @Override
    public int getOrder() {
        return 0;
    }
}

新建业务逻辑类AuthService

package com.changgou.web.gateway.service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.http.HttpCookie;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.stereotype.Service;
@Service
public class AuthService {
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    //从cookie中获取jti的值
    public String getJtiFromCookie(ServerHttpRequest request) {
        HttpCookie httpCookie = request.getCookies().getFirst("uid");
        if (httpCookie != null) {
            String jti = httpCookie.getValue();
            return jti;
        }
        return null;
    }
    public String getJwtFromRedis(String jti) {
        //从redis中获取jwt
        String jwt = stringRedisTemplate.boundValueOps(jti).get();
        return jwt;
    }
}

8. 自定义登陆页面

在changgou-user-oauth导入thymeleaf依赖

<!--thymeleaf-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>

将前端页面放到项目中

09. day09 Oauth2.0 - 图25

将static文件夹复制一份拷贝到changgou_gateway_web的resource下

8.1. 静态资源放行

修改 WebSecurityConfig 类下configure方法放行指定资源和请求

  /***
     * 忽略安全拦截的URL
     * @param web
     * @throws Exception
     */
    @Override
    public void configure(WebSecurity web) throws Exception {
        web.ignoring().antMatchers(
                "/oauth/login",
                "/oauth/logout","/oauth/toLogin","/login.html","/css/**","/data/**","/fonts/**","/img/**","/js/**");
    }

第二个configure

@Override
public void configure(HttpSecurity http) throws Exception {
    http.csrf().disable()
            .httpBasic()        //启用Http基本身份验证
            .and()
            .formLogin()       //启用表单身份验证
            .and()
            .authorizeRequests()    //限制基于Request请求访问
            .anyRequest()
            .authenticated();       //其他请求都需要经过验证
    //开启表单登陆
    http.formLogin().loginPage("/oauth/toLogin") //设置访问登陆页面的路径
            .loginProcessingUrl("/oauth/login");  //设置执行登陆操作的路径
}

8.2. 返回login页面

com.changgou.oauth.controller.AuthController 添加toLogin方法返回login页面

@RequestMapping("/toLogin")
public String toLogin(){
    return "login";
}

8.2.1. 修改login页面

09. day09 Oauth2.0 - 图26

<script th:inline="javascript">
    var app = new Vue({
        el:"#app",
        data:{
            username:"",
            password:"",
            msg:""
        },
        methods:{
            login:function(){
                app.msg="正在登录";
                axios.post("/api/oauth/login?username="+app.username+"&password="+app.password).then(function (response) {
                    if (response.data.flag){
                        app.msg="登录成功";
                    }else{
                        app.msg="登录失败";
                    }
                })
            }
        }
    })
</script>

8.2.2. 定义路径过滤

在 changgou_gateway_web 项目下的filter 创建URLFilter

package com.changgou.web.gateway.filter;
public class URLFilter {
    //所有需要传递令牌的地址
//    public static String filterPath = "/api/oauth/toLogin,/api/wseckillorder,/api/seckill,/api/wxpay,/api/wxpay/**,/api/worder/**,/api/user/**,/api/address/**,/api/cart/**,/api/categoryReport/**,/api/orderConfig/**,/api/order/**,/api/orderItem/**,/api/orderLog/**,/api/preferential/**,/api/returnCause/**,/api/returnOrder/**,/api/returnOrderItem/**";
    public static String filterPath = "/api/wseckillorder,/api/seckill,/api/wxpay,/api/wxpay/**,/api/worder/**,/api/user/**,/api/address/**,/api/wcart/**,/api/cart/**,/api/categoryReport/**,/api/orderConfig/**,/api/order/**,/api/orderItem/**,/api/orderLog/**,/api/preferential/**,/api/returnCause/**,/api/returnOrder/**,/api/returnOrderItem/**";
    public static boolean hasAuthorize(String url) {
        String[] split = filterPath.replace("**", "").split(",");
        for (String value : split) {
            if (url.startsWith(value)) {
                return true; //代表当前的访问地址是需要传递令牌的
            }
        }
        return false;//当前请求地址是不需要令牌的
    }
}

修改AuthFilter filter方法中的判断请求路径

//1.判断请求路径是否为登陆请求 如果是 则直接放行
String path = request.getURI().getPath();
if ("/api/oauth/login".equals(path) || !URLFilter.hasAuthorize(path)) {
    //直接放行
    return chain.filter(exchange);
}