六、微服务版的单点登陆系统设计及实现

另一篇文章

1.简介

1.1 背景分析

传统的登录系统中，每个站点都实现了自己的专用登录模块。各站点的登录状态相互不认可，各站点需要逐一手工登录。例如：

这样的系统，我们又称之为多点登陆系统。应用起来相对繁琐（每次访问资源服务都需要重新登陆认证和授权）。与此同时，系统代码的重复也比较高。由此单点登陆系统诞生。

1.2 单点登陆系统

单点登录，英文是 Single Sign On（缩写为 SSO）。即多个站点共用一台认证授权服务器，用户在其中任何一个站点登录后，可以免登录访问其他所有站点。而且，各站点间可以通过该登录状态直接交互。例如：

2.快速入门实践

2.1 工程结构如下

基于资源服务工程添加单点登陆认证和授权服务，工程结构定义如下：

2.2 创建认证授权工程

2.3 添加项目依赖

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

   <!--单点登录(SSO)技术方案：SpringSecurity + JWT + oauth2-->
   <dependency>
       <groupId>org.springframework.cloud</groupId>
       <artifactId>spring-cloud-starter-oauth2</artifactId>
   </dependency>

   <!--服务的发现-->
   <dependency>
       <groupId>com.alibaba.cloud</groupId>
       <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
   </dependency>

   <!--服务的配置-->
   <dependency>
       <groupId>com.alibaba.cloud</groupId>
       <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
   </dependency>

2.4 构建项目配置文件

在sca-auth工程中创建bootstrap.yml文件，例如：

server:
  port: 8071
spring:
  application:
    name: sca-auth
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848
      config:
        server-addr: localhost:8848

2.5 添加项目启动类

package com.jt;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class ResourceAuthApplication {
    public static void main(String[] args) {
        SpringApplication.run(ResourceAuthApplication.class, args);
    }
}

2.6 启动并访问项目

项目启动时，系统会默认生成一个登陆密码，例如：

打开浏览器输入http://localhost:8071呈现登陆页面,例如：

其中，默认用户名为user，密码为系统启动时，在控制台呈现的密码。执行登陆测试,登陆成功进入如下界面（因为没有定义登陆页面，所以会出现404）：

3.自定义登陆逻辑

3.1 业务描述

我们的单点登录系统最终会按照如下结构进行设计和实现,例如:

我们在实现登录时,会在UI工程中,定义登录页面(login.html),然后在页面中输入自己的登陆账号,登陆密码,将请求提交给网关,然后网关将请求转发到auth工程,登陆成功和失败要返回json数据,在这个章节我们会按这个业务逐步进行实现

3.2 定义安全配置类

修改SecurityConfig配置类,添加登录成功或失败的处理逻辑,例如:

package com.jt.config;

import org.codehaus.jackson.map.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.web.authentication.AuthenticationFailureHandler;
import org.springframework.security.web.authentication.AuthenticationSuccessHandler;

import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.Map;

/**
 * spring security 配置类,此类中要配置:
 *	 1)加密对象
 *	 2)配置认证规则
 *	
 * 当我们在执行登录操作时,底层逻辑(了解):
 * 	 1)Filter(过滤器)
 * 	 2)AuthenticationManager (认证管理器)
 * 	 3)AuthenticationProvider(认证服务处理器)
 * 	 4)UserDetailsService(负责用户信息的获取及封装)
 */
@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    /**初始化加密对象*/
    //此对象提供了一种不可逆的加密方式,相对于md5方式会更加安全
    @Bean
    public BCryptPasswordEncoder passwordEncoder(){
        return new BCryptPasswordEncoder();
    }
    
    /**配置认证规则*/
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        //super.configure(http);//父类中默认的一些配置
        
        //1.禁用跨域攻击(先这么写，不写会报403错误)
        http.csrf().disable();
        
        //2.放行所有资源的访问(后续可以基于选择对资源进行放行或者认证)
        http.authorizeRequests().anyRequest().permitAll();
        
        //3.定义登录成功和失败以后的处理逻辑(可选)
        //假如没有如下设置，登陆成功会显示404
        http.formLogin()//这句话会对外暴露一个登录路径/login
                .successHandler(successHandler())
                .failureHandler(failureHandler());
    }

    //处理登陆成功处理器
    //登陆成功以后返回json数据
    //private AuthenticationSuccessHandler successHandler() {...}//这样写的话，每次登录成功都会创建这个方法
    @Bean
    public AuthenticationSuccessHandler successHandler() {//这样写则不会每次登录成功之后都创建，而是在登陆成功之后，会在内存中查找
        //lambda表达式
        return (request,response,authentication)->{
            //构建map对象封装到响应的客户端的数据
            Map<String,Object> map = new HashMap<>();
            map.put("status", 200);
            map.put("message", "login ok");
            //将map对象转换为json格式字符串并写到客户端
            writeJsonToClient(response,map);
        };
    }

    //处理登陆失败处理器
    @Bean
    public AuthenticationFailureHandler failureHandler() {
        return (request,response,exception)->{
            //构建map对象封装到响应的客户端的数据
            Map<String,Object> map = new HashMap<>();
            map.put("status", 500);
            map.put("message", "login error");
            //将map对象转换为json格式字符串并写到客户端
            writeJsonToClient(response,map);
        };
    }

    private void writeJsonToClient(HttpServletResponse response,Map<String,Object> map) throws IOException {
        //将map对象，转换为json
        String json = new ObjectMapper().writeValueAsString(map);
        //设置响应数据的编码格式
        response.setCharacterEncoding("utf-8");
        //设置响应数据的类型
        response.setContentType("application/json;charset=utf-8");
        //将数据响应到客户端
        PrintWriter out = response.getWriter();
        out.println(json);
        out.flush();
    }
}

3.3 定义用户信息处理对象

在spring security应用中底层会借助UserDetailService对象获取数据库信息,并进行封装,最后返回给认证管理器,完成认证操作,例如:

package com.jt.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.authority.AuthorityUtils;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.stereotype.Service;

@Service
public class UserDetailsServiceImpl implements UserDetailsService {

    @Autowired
    private BCryptPasswordEncoder passwordEncoder;

    /**
     * 基于用户名获取数据库中的用户信息
     * @param username 这个username来自客户端
     * @return
     * @throws UsernameNotFoundException
     */
    @Override
    public UserDetails loadUserByUsername(String username)throws UsernameNotFoundException {
        //1.基于用户名查询用户信息(暂时先给假数据)
        //Userinfo info=userMapper.selectUserByUsername(username);
        String encodePassword = passwordEncoder.encode("123456");//假设这个密码来自数据库
                
        //2.查询用户权限信息(后面会访问数据库)
        //这里先给几个假数据
        List<GrantedAuthority> authorities = 
        		AuthorityUtils.createAuthorityList("sys:res:create", "sys:res:retrieve");//这里的权限信息先这么写,后面讲

        //3.封装用户相关信息(用户名,密码(必须是已经加密的密码),用户权限信息等)并返回
        return new User(username,encodePassword,authorities );
    }
}

3.4 网关中登陆路由配置

在网关配置文件中添加登录路由配置,例如

spring:
  cloud:
    gateway:
      routes:
        - id: router02
          uri: lb://sca-auth  #lb表示负载均衡,底层默认使用ribbon实现
          predicates: #定义请求规则(请求需要按照此规则设计)
            - Path=/auth/login/** #请求路径设计(不是我们自己定义的，而是底层自动生成)
          filters:
            - StripPrefix=1 #转发之前去掉path中第一层路径

3.5 基于Postman进行访问测试

启动sca-gateway，sca-auth服务，然后基于postman访问网关,执行登录测试，例如：

3.6 SpringSecurity 执行流程

3.7 自定义登陆页面

在sca-resource-ui工程的static目录中定义登陆页面，例如：

<!doctype html>
<html lang="en">
<head>
    <!-- Required meta tags -->
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <!-- Bootstrap CSS -->
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.0.2/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-EVSTQN3/azprG1Anm3QDgpJLIm9Nao0Yz1ztcQTwFspd3yD65VohhpuuCOmLASjC" crossorigin="anonymous">
    <title>login</title>
</head>
<body>
<div class="container"id="app">
    <h3>Please Login</h3>
    <form>
        <div class="mb-3">
            <label for="usernameId" class="form-label">Username</label>
            <input type="text" v-model="username" class="form-control" id="usernameId" aria-describedby="emailHelp">
        </div>
        <div class="mb-3">
            <label for="passwordId" class="form-label">Password</label>
            <input type="password" v-model="password" class="form-control" id="passwordId">
        </div>
        <button type="button" @click="doLogin()" class="btn btn-primary">Submit</button>
    </form>
</div>
<script src="https://cdn.jsdelivr.net/npm/bootstrap@5.0.2/dist/js/bootstrap.bundle.min.js" integrity="sha384-MrcW6ZMFYlzcLA8Nl+NtUVF0sA7MsXsP1UyJoMp4YLEuNSfAP+JcXn/tWtIaxVXM" crossorigin="anonymous"></script>
<script src="https://cdn.jsdelivr.net/npm/vue/dist/vue.js"></script>
<script src="https://unpkg.com/axios/dist/axios.min.js"></script>
<script>
    var vm=new Vue({
        el:"#app",//定义监控点，vue底层会基于此监控点在内存中构建dom树
        data:{ //此对象中定义页面上要操作的数据
            username:"",
            password:""
        },
        methods: {//此位置定义所有业务事件处理函数
            doLogin() {
                //1.定义url
                let url = "http://localhost:9000/auth/login"
                //2.定义参数

                let params = new URLSearchParams()
                params.append('username',this.username);
                params.append('password',this.password);
                //3.发送异步请求
                axios.post(url, params).then((response) => {
                    debugger
                    let result=response.data;
                    console.log(result);
                    if (result.state == 200) {
                        alert("login ok");
                    } else {
                        alert(result.message);
                    }
                })
            }
        }
    });
</script>
</body>
</html>

启动sca-resource-ui服务后，进入登陆页面，输入用户名jack,密码123456进行登陆测试。

4.颁发登陆成功令牌

4.0 单点登陆-redis解析图

4.1 构建令牌配置对象

本次我们借助JWT(Json Web Token-是一种json格式）方式将用户相关信息进行组织和加密,并作为响应令牌(Token),从服务端响应到客户端,客户端接收到这个JWT令牌之后,将其保存在客户端(例如localStorage),然后携带令牌访问资源服务器,资源服务器获取并解析令牌的合法性,基于解析结果判定是否允许用户访问资源.

Jwt令牌构成：header(签名算法、令牌类型)，payload(数据部分)，Signing(签名)

package com.jt.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
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;

/**
 * 在此配置类中配置令牌的 生成、存储方式、验签方式(令牌合法性)。
 */
@Configuration
public class TokenConfig {

    /**
     * 配置令牌的存储策率
     * 对于oauth2规范中提供了这样几种策率
     *      1.JdbcTokenStore(这里是要将token存储到关系型数据库)
     *      2.RedisTokenStore(这里是将token存储到redis数据库-key/value)
     *      3.JwtTokenStore(这里是将产生的token信息存储到客户端，并且token中可以以自包含的形式存储一些用户信息)
     *      4. 。。。
     */
    @Bean
    public TokenStore tokenStore(){
        //这里采用的是JWT方式生成和存储令牌信息
        return new JwtTokenStore(jwtAccessTokenConverter());
    }

    /**
     * 配置令牌的创建、验证方式
     * 基于此对象(JwtAccessTokenConverter)创建的令牌信息会封装到OAuth2AccessToken类型的对象中，
     * 然后再存储到TokenStore对象，外界需要时，会从tokenStore进行获取
     */
    @Bean
    public JwtAccessTokenConverter jwtAccessTokenConverter(){
        JwtAccessTokenConverter jwtAccessTokenConverter = new JwtAccessTokenConverter();
        //Jwt令牌构成：header(签名算法、令牌类型)，payload(数据部分)，Signing(签名)
        //这里的签名可以简单理解为加密，加密时会使用header中的算法以及我们自己提供的密钥
        //这里加密的目的是为了防止令牌被篡改。(这里的密钥要保管好，要存储在服务端)
        jwtAccessTokenConverter.setSigningKey(SIGNING_KEY);//设置密钥(这个就是密钥)
        return jwtAccessTokenConverter;
    }

    /**
     * JWT 令牌签名时使用的密钥(可以理解为盐值加密中的盐)
     * 1.生成的令牌需要这个密钥进行签名
     * 2.获取的令牌需要使用这个密钥进行验证(校验令牌的合法性，是否被篡改过)
     */
    private static final String SIGNING_KEY="auth";
}

4.2 定义认证授权核心配置

第一步：在SecurityConfig中添加如下方法（创建认证管理器对象，后面授权服务器会用到）：

    /**
     * 定义认证管理对象，这个对象负责完成用户信息的认证，即判定用户身份信息的合法性，
     * 在基于oauth2协议认证时，需要此对象，所以这里将此对象拿出来交给spring管理
     */
    @Bean
    public AuthenticationManager authenticationManager() throws Exception {
        return super.authenticationManager();
    }

第二步：所有零件准备好了开始拼装最后的主体部分，这个主体部分就是授权服务器的核心配置

package com.jt.config;

import lombok.AllArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpMethod;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.oauth2.config.annotation.configurers.ClientDetailsServiceConfigurer;
import org.springframework.security.oauth2.config.annotation.web.configuration.AuthorizationServerConfigurerAdapter;
import org.springframework.security.oauth2.config.annotation.web.configuration.EnableAuthorizationServer;
import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerEndpointsConfigurer;
import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerSecurityConfigurer;
import org.springframework.security.oauth2.provider.token.*;
import org.springframework.security.oauth2.provider.token.store.JwtAccessTokenConverter;

import java.util.Arrays;

/**
 * 在这个对象中负责将所有的认证和授权相关配置进行整合，例如：
 * 技术方面：
 *    1.SpringSecurity(提供认证和授权的实现)
 *    2.TokenConfig(提供了令牌的 生成、存储、校验)
 *    3.Oauth2(定义了一套认证规范，例如：为谁发令牌，都发什么，。。。)
 * 业务方面：
 * 	  1.如何认证(认证逻辑的设计)
 * 	  2.认证通过之后如何颁发令牌(令牌规范)
 * 	  3.为谁颁发令牌(客户端标识)
 */
@AllArgsConstructor //生成一个全参构造函数
@EnableAuthorizationServer //启动认证和授权
@Configuration
public class Oauth2Config extends AuthorizationServerConfigurerAdapter {//Alt+Ins 重写方法

    //此对象负责完成认证管理
    //@Autowired //可以写这个注解，也可以写构造器
    private AuthenticationManager authenticationManager;
    //负责获取用户信息
    //@Autowired
    private UserDetailsService userDetailsService;
    //TokenStore负责完成令牌创建,信息读取
    //@Autowired
    private TokenStore tokenStore;
    //JWT令牌转换器(基于用户信息构建令牌,解析令牌)
    //@Autowired
    private JwtAccessTokenConverter jwtAccessTokenConverter;
    //密码加密匹配器对象
    //@Autowired
    private BCryptPasswordEncoder passwordEncoder;

//    public Oauth2Config(AuthenticationManager authenticationManager, UserDetailsServiceImpl userDetailsService, TokenStore tokenStore, JwtAccessTokenConverter jwtAccessTokenConverter, BCryptPasswordEncoder passwordEncoder) {
//        this.authenticationManager = authenticationManager;
//        this.userDetailsService = userDetailsService;
//        this.tokenStore = tokenStore;
//        this.jwtAccessTokenConverter = jwtAccessTokenConverter;
//        this.passwordEncoder = passwordEncoder;
//    }

    /**
     * oauth2中的认证方式的配置
     *
     * @param endpoints
     * @throws Exception
     */
    @Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
        //super.configure(endpoints);
        endpoints
        //由谁完成认证?
        .authenticationManager(authenticationManager)
        //由谁负责访问数据库?(认证是需要两部分信息：一部分来自客户端，一部分来自服务端)
        .userDetailsService(userDetailsService)
        //支持对什么进行请求认证?(默认支持post方式)
        .allowedTokenEndpointRequestMethods(HttpMethod.GET,HttpMethod.POST)
        //支持成功以后令牌如何生成和存储?(默认 令牌生成是UUID.randomUUID(),并且存储方式是存入内存)
        .tokenServices(tokenService());
    }

    /**
     * 系统底层在完成认证之后会调用TokenService对象的相关方法
     * 获取TokenStore，基于tokenStore获取token对象
     * @return
     */
    @Bean
    public AuthorizationServerTokenServices tokenService(){
        //1.构建TokenService对象(此对象提供了 创建、获取、刷新 token的方法)
        DefaultTokenServices tokenServices = new DefaultTokenServices();

        //2.设置是否支持令牌刷新(访问令牌过期了，是否支持通过令牌刷新机制，延长令牌有效期)
        tokenServices.setSupportRefreshToken(true);

        //3.设置令牌生成和存储策率
        tokenServices.setTokenStore(tokenStore);

        //4.设置令牌增强(默认令牌会比较简单，没有业务数据，就是简单的随机字符串，但是现在希望使用jwt方式)
        TokenEnhancerChain chain = new TokenEnhancerChain();
        chain.setTokenEnhancers(Arrays.asList(jwtAccessTokenConverter));
        tokenServices.setTokenEnhancer(chain);

        //5.设置访问令牌有效期
        tokenServices.setAccessTokenValiditySeconds(3600);//1小时

        //6.设置刷新令牌有效期
        tokenServices.setRefreshTokenValiditySeconds(3600*72);//3天
        return tokenServices;
    }

    /**
     * 假如：我们要做认证，我们输入了用户名和密码，然后点击提交，
     * 提交到了哪里(url-去哪里认证)，这个路径是否认需要认证？还有令牌过期了，我们要重新生成一个令牌，
     * 哪个路径可以帮我们重新生成?如下这个方法就可以提供这个配置
     *
     * 对外提供认证、令牌刷新、校验等路径(url)
     *
     * 认证成功后的安全约束配置,对指定资源的访问放行,我们登录时需要访问/oauth/token,需要对这样的url进行放行
     *
     * @param security
     * @throws Exception
     */
    @Override
    public void configure(AuthorizationServerSecurityConfigurer security) throws Exception {
        //super.configure(security);
        security
        //1.定义(公开)要认证的url(permitAll()是官方定义好的)
        // 公开oauth/token_key端点
        .tokenKeyAccess("permitAll()") //return this
        //2.定义(公开)令牌检查的url
        // 公开oauth/check_token端点
        .checkTokenAccess("permitAll()")
        //3.允许客户端直接通过表单方式提交认证
        .allowFormAuthenticationForClients();
    }

    /**
     * 认证中心是否要给所有客户端发令牌呢？假如不是，那要给哪些客户端发令牌，是否在服务端有一些规则的定义呢？
     * 例如：老赖不能坐飞机、高铁
     *
     * @param clients
     * @throws Exception
     */
    @Override
    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
        //super.configure(clients);
        clients.inMemory()
                //定义客户端的id(客户端提交用户信息进行认证时需要这个id)
                .withClient("gateway-client")
                //定义客户端密钥(客户端提交用户信息时需要携带这个密钥)
                .secret(passwordEncoder.encode("123456"))
                //定义作用范围(所有符合规则的客户端)
                .scopes("all")
                ///允许客户端基于密码方式，刷新令牌方式实现认证
                .authorizedGrantTypes("password","refresh_token");
    }
}

4.3 配置网关认证的URL

spring:
  cloud:
    gateway:
      routes:
        - id: router02
          uri: lb://sca-auth  #lb表示负载均衡,底层默认使用ribbon实现
          predicates: #定义请求规则(请求需要按照此规则设计)
            #- Path=/auth/login/**  #请求路径设计,没要令牌之前,以前是这样配置
        	- Path=/auth/oauth/**   #微服务架构下,需要令牌,现在要这样配置
          filters:
            - StripPrefix=1 #转发之前去掉path中第一层路径

4.4 Postman访问测试

第一步：启动服务
依次启动sca-auth服务，sca-resource-gateway服务。

第二步：检测sca-auth服务控制台的Endpoints信息，例如:

第三步：打开postman进行登陆访问测试 http://localhost:9000/auth/oauth/token?username=jack&password=123456&client_id=gateway-client&grant_type=password&client_secret=123456

登陆成功会在控制台显示令牌信息，例如：

{
    "access_token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE2MzI3MzE1NzcsInVzZXJfbmFtZSI6ImphY2siLCJhdXRob3JpdGllcyI6WyJzeXM6cmVzOmNyZWF0ZSIsInN5czpyZXM6cmV0cmlldmUiXSwianRpIjoiZjQwM2EwZjQtYzM2ZS00OTU1LThkYjItYWZhNDUwYTE2MjBiIiwiY2xpZW50X2lkIjoiZ2F0ZXdheS1jbGllbnQiLCJzY29wZSI6WyJhbGwiXX0.QHK1tFZl07f27LArnByveR-4YO39cGjKOv2MneRTYOQ",
    "token_type": "bearer",
    "refresh_token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VyX25hbWUiOiJqYWNrIiwic2NvcGUiOlsiYWxsIl0sImF0aSI6ImY0MDNhMGY0LWMzNmUtNDk1NS04ZGIyLWFmYTQ1MGExNjIwYiIsImV4cCI6MTYzMjk4NzE3NywiYXV0aG9yaXRpZXMiOlsic3lzOnJlczpjcmVhdGUiLCJzeXM6cmVzOnJldHJpZXZlIl0sImp0aSI6ImM4NDY0OGI3LTRiNTUtNDIwZS05ZTZjLWJiY2M2NjhhMzE0NyIsImNsaWVudF9pZCI6ImdhdGV3YXktY2xpZW50In0.MKIDiHhMowDkB3-Z4uRK7qlpOkf6mdfN9WcF3FjIUzw",
    "expires_in": 3599,
    "scope": "all",
    "jti": "f403a0f4-c36e-4955-8db2-afa450a1620b"
}

检查令牌：

Postman测试刷新令牌：

4.5 登陆页面登陆方法设计

登陆成功以后，将token存储到localStorage中,修改登录页面的doLogin方法,例如

 methods: {//此位置定义所有业务事件处理函数
    doLogin() {
        //1.定义url
        let url = "http://localhost:9000/auth/oauth/token"
        //2.定义参数
        let params = new URLSearchParams()
        params.append('username',this.username);
        params.append('password',this.password);
        params.append('client_id',"gateway-client");
        params.append('client_secret',"123456");
        params.append('grant_type',"password");
        //3.发送异步请求
        axios.post(url, params)
            .then((response) => {
                alert("login ok")
                console.log("response",response);
                debugger
                let result = response.data;
                console.log(result);
                //将返回的访问令牌存储到浏览器本地对象中
                localStorage.setItem("accessToken",result.access_token);
                location.href = "/fileupload.html";
        })
        .catch((error)=>{
            console.log(error);
        })
    }
}

访问url http://localhost:8080/login.html，并输入密码

登录之后则会跳转到下面页面

5.资源服务器配置

5.1 添加依赖

打开资源服务的pom.xml文件，添加oauth2依赖。

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

5.2 令牌处理器配置

package com.jt.auth.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
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;

/**
 * 创建JWT令牌配置类,基于这个类实现令牌对象的创建和解析.
 * JWT令牌的构成有三部分构成:
 * 		1)HEADER (头部信息:令牌类型,签名算法)
 * 		2)PAYLOAD (数据信息-用户信息,权限信息,令牌失效时间,...)
 * 		3)SIGNATURE (签名信息-对header和payload部分进行加密签名)
 */
@Configuration
public class TokenConfig {
    //定义令牌签发口令(暗号),这个口令自己定义即可
    //在对header和PAYLOAD部分进行签名时,需要的一个口令
    private String SIGNING_KEY= "auth";
    //初始化令牌生成策略(默认生成策略 UUID)
    //这里我们采用JWT方式生成令牌
    @Bean
    public TokenStore tokenStore(){
        return new JwtTokenStore(jwtAccessTokenConverter());
    }
    
    //构建JWT令牌转换器对象,基于此对象创建令牌,解析令牌
    @Bean
    public JwtAccessTokenConverter jwtAccessTokenConverter(){
        JwtAccessTokenConverter converter=new JwtAccessTokenConverter();
        converter.setSigningKey(SIGNING_KEY);
        return converter;
    }
}

5.3 资源服务令牌解析配置

package com.jt.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
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.config.annotation.web.configurers.ResourceServerSecurityConfigurer;
import org.springframework.security.oauth2.provider.token.TokenStore;

/**
 * 思考?对于一个系统而言,它资源的访问权限你是如何进行分类设计的
 *      1)不需要登录就可以访问(例如12306查票)
 *      2)登录以后才能访问(例如12306的购票)
 *      3)登录以后没有权限也不能访问(例如会员等级不够不让执行一些相关操作)
 */
@Configuration
@EnableResourceServer 开启资源服务配置
//启动方法上的权限控制，需要授权才可以访问的方法上添加@PreAuthorize等相关注解
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class ResourceServerConfig extends ResourceServerConfigurerAdapter {

//    @Autowired
//    private TokenStore tokenStore;
//
//    /**token服务配置*/
//    @Override
//    public void configure(ResourceServerSecurityConfigurer resources) throws Exception {
//        //super.configure(resources);
//        //通过tokenStore获取token解析器对象，基于此对象对token信息进行解析
//        resources.tokenStore(tokenStore);
//    }

    /**路由安全认证配置*/
    @Override
    public void configure(HttpSecurity http) throws Exception {
        //super.configure(http);

        //1.关闭跨域攻击
        http.csrf().disable();

        //2.放行相关请求
        http.authorizeRequests()
                .antMatchers("/resource/upload/**")
                .authenticated()
                .anyRequest().permitAll();
    }
}

5.4 ResourceController 方法配置

在controller的上传方法上添加 @PreAuthorize(“hasAuthority(‘sys:res:create’)”)注解，用于告诉底层框架方法此方法需要具备的权限，例如

5.5 启动服务访问测试

第一步:启动服务（sca-auth,sca-resource-gateway,sca-resource)
第二步:执行登陆获取access_token令牌
第三步:携带令牌访问资源(url中的前缀"sca"是在资源服务器中自己指定的,你的网关怎么配置的,你就怎么写)

设置请求头(header)，要携带令牌并指定请求的内容类型，例如

设置请求体(body)，设置form-data，key要求为file类型，参数名与你服务端controller文件上传方法的参数名相同，值为你选择的文件，例如

上传成功会显示你访问文件需要的路径，假如没有权限会提示你没有访问权限。例如：

没有权限测试：

5.6 文件上传JS方法设计

// 将file上传到服务器的方法
function upload(file){
    //定义一个表单(axios中提供的表单对象)
    let form=new FormData();
    //将文件添加到表单中
    form.append("uploadFile",file);
    //异步提交(现在是提交到网关)
    //let url="http://localhost:8881/resource/upload/"
    let url="http://localhost:9000/sca/resource/upload/";
    axios.post(url,form,{headers:{"Authorization":"Bearer "+localStorage.getItem("accessToken")}})
        .then(function (response){
            alert("upload ok")
            console.log(response.data);
        })
        .catch(function (e){//失败时执行catch代码块
            //debugger
            if(e.response.status==401){
                alert("请先登录");
                location.href="login-sso.html";
            }else if(e.response.status==403){
                alert("你没有权限");
            }else if(e.response.status==429){
                alert("上传太频繁");
            }
            console.log("error",e);
        })
}

6.技术摘要应用实践说明

6.1 背景分析

企业中数据是最重要的资源,对于这些数据而言,有些可以直接匿名访问,有些只能登录以后才能访问,还有一些你登录成功以后,权限不够也不能访问.总之这些规则都是保护系统资源不被破坏的一种手段.几乎每个系统中都需要这样的措施对数据(资源)进行保护.我们通常会通过软件技术对这样业务进行具体的设计和实现.早期没有统一的标准,每个系统都有自己独立的设计实现,但是对于这个业务又是一个共性,后续市场上就基于共性做了具体的落地实现,例如Spring Security,Apache shiro，JWT，Oauth2等技术诞生了.

6.2 Spring Security 技术

Spring Security 是一个企业级安全框架,由spring官方推出,它对软件系统中的认证,授权,加密等功能进行封装,并在springboot技术推出以后,配置方面做了很大的简化.现在市场上分布式架构中的安全控制,正在逐步的转向Spring Security。Spring Security 在企业中实现认证和授权业务时,底层构建了大量的过滤器，如图所示：

其中:
图中绿色部分为认证过滤器,黄色部分为授权过滤器。Spring Security就是通过这些过滤器然后调用相关对象一起完成认证和授权操作.

6.3 Jwt 数据规范

JWT(JSON WEB Token)是一个标准，采用数据自包含方式进行json格式数据设计，实现各方安全的信息传输，其官方网址为：https://jwt.io/。官方JWT规范定义，它构成有三部分，分别为Header(头部)，Payload(负载)，Signature(签名),其格式如下：

xxxxx.yyyyy.zzzzz

Header部分

Header 部分是一个 JSON 对象，描述 JWT 的元数据，通常是下面的样子。

{
  "alg": "HS256",
  "typ": "JWT"
}

上面代码中，alg属性表示签名的算法（algorithm），默认是 HMAC SHA256（简写HS256）；typ属性表示这个令牌（token）的类型（type），JWT 令牌统一写为JWT。最后，将这个 JSON 对象使用 Base64URL 算法（详见后文）转成字符串。

Payload部分

Payload 部分也是一个 JSON 对象，用来存放实际需要传递的数据。JWT规范中规定了7个官方字段，供选用（了解）。

• iss (issuer)：签发人
• exp (expiration time)：过期时间
• sub (subject)：主题
• aud (audience)：受众
• nbf (Not Before)：生效时间
• iat (Issued At)：签发时间
• jti (JWT ID)：编号

除了官方字段，你还可以在这个部分定义私有字段，下面就是一个例子。

{
  "sub": "1234567890",
  "name": "John Doe",
  "admin": true
}

注意，JWT 默认是不加密的，任何人都可以读到，所以不要把秘密信息放在这个部分。

这个 JSON 对象也要使用 Base64URL 算法转成字符串。

Signature部分

Signature 部分是对前两部分的签名，其目的是防止数据被篡改。

首先，需要指定一个密钥（secret）。这个密钥只有服务器才知道，不能泄露给用户。然后，使用 Header 里面指定的签名算法（默认是 HMAC SHA256），按照下面的公式产生签名。

HMACSHA256(
  base64UrlEncode(header) + "." +
  base64UrlEncode(payload),
  secret)

算出签名以后，把 Header、Payload、Signature 三个部分拼成一个字符串，每个部分之间用"点"（.）分隔，就可以返回给用户。

6.4 Oauth2规范

oauth2定义了一种认证授权协议，一种规范，此规范中定义了四种类型的角色：
1)资源有者(User)
2)认证授权服务器(jt-auth)
3)资源服务器(jt-resource)
4)客户端应用(jt-ui)
同时，在这种协议中规定了认证授权时的几种模式：
1)密码模式 (基于用户名和密码进行认证)
2)授权码模式(就是我们说的三方认证：QQ，微信，微博，。。。。)
3)…

7.总结（Summary）

7.1 重难点分析

• 单点登陆系统的设计架构（微服务架构）
• 服务的设计及划分(资源服务器，认证服务器，网关服务器，客户端服务）
• 认证及资源访问的流程(资源访问时要先认证再访问)
• 认证和授权时的一些关键技术(Spring Security,Jwt,Oauth2)

7.2 FAQ 分析

• 为什么要单点登陆（分布式系统，再访问不同服务资源时，不要总是要登陆，进而改善用户体验）
• 单点登陆解决方案？(市场常用两种: spring security+jwt+oauth2,spring
  securit+redis+oauth2)
• Spring Security 是什么？（spring框架中的一个安全默认，实现了认证和授权操作）
• JWT是什么？（一种令牌格式，一种令牌规范，通过对JSON数据采用一定的编码，加密进行令牌设计）
• OAuth2是什么？（一种认证和授权规范，定义了单点登陆中服务的划分方式，认证的相关类型）
• …

7.3 Bug 分析

• 401 : 访问资源时没有认证。
• 403 : 访问资源时没有权限。
• 404：访问的资源找不到（一定要检查你访问资源的url）
• 405: 请求方式不匹配（客户端请求方式是GET，服务端处理请求是Post就是这个问题）
• 500: 不看后台无法解决？（error,warn）
• …