【SpringCloud Alibaba】07--微服务版的单点登录系统设计及实现

一，简介

1.背景分析

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

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

2.单点登陆系统

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

二，快速入门实践

1.工程结构如下

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

2.创建认证授权工程

3.添加项目依赖

  <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <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>

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

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);
    }
}

6.启动并访问项目

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

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

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

三，自定义登陆逻辑

1.业务描述

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

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

2.定义安全配置类

package com.jt.auth.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.core.Authentication;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.web.authentication.AuthenticationFailureHandler;
import org.springframework.security.web.authentication.AuthenticationSuccessHandler;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
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.禁用跨域攻击
        http.csrf().disable();
        //http.authorizeRequests().antMatchers("/other/hello").authenticated(); //必须认证才能访问
//        http.authorizeRequests().antMatchers("/other/hello","/other/go").authenticated()  //除了这两个网址需要认证，其他都直接放行
//                .anyRequest().permitAll();
//        http.authorizeRequests().antMatchers("/other/hello","/other/go").permitAll() //除了这两个网址可以放行，其他的都需要认证
//                .anyRequest().permitAll();
        //2.放行所有资源的访问
        http.authorizeRequests().anyRequest().permitAll(); //没写这句话也是默认放行所有的请求
        //3.定义登录成功和失败以后的处理逻辑(可选)
        //假如没有如下设置登录成功会显示404
        http.formLogin() //这句话会对外暴露一个登录路径/login
                .successHandler(successHandler())
                        .failureHandler(failureHandler());
    }
    //定义认证成功的处理器
    @Bean
    public AuthenticationSuccessHandler successHandler() {
//        return new AuthenticationSuccessHandler() {
//            @Override
//            public void onAuthenticationSuccess(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Authentication authentication) throws IOException, ServletException {
//
//            }
//        }
        //lambda表达式
        return (request,response,authentication) -> {
            Map<String,Object> map = new HashMap<>();
            map.put("state",200);
            map.put("message","login ok");
            //将map对象转换为json格式字符串并写到客户端
            writeJsonToClient(response,map);
        };
    }
    //定义认证失败的处理器
    @Bean
    public AuthenticationFailureHandler failureHandler() {
        return (request,response,authentication) -> {
            Map<String,Object> map = new HashMap<>();
            map.put("state",500);
            map.put("message","login failure");
            //将map对象转换为json格式字符串并写到客户端
            writeJsonToClient(response,map);
        };
    }
    private void writeJsonToClient(HttpServletResponse response,Map<String,Object> map) throws IOException {
     	//1.将对象转换为json
        //将对象转换为json有3种方案:
        //1)Google的Gson-->toJson  (需要自己找依赖)
        //2)阿里的fastjson-->JSON (spring-cloud-starter-alibaba-sentinel)
        //3)Springboot web自带的jackson-->writeValueAsString (spring-boot-starter-web)
        //我们这里借助springboot工程中自带的jackson
        //jackson中有一个对象类型为ObjectMapper,它内部提供了将对象转换为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();
        out.closed();
    }
}

3.定义用户信息处理对象

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

package com.jt.auth.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;
/**
 * 登录时用户信息的获取和封装会在此对象进行实现,
 * 在页面上点击登录按钮时,会调用这个对象的loadUserByUsername方法,
 * 页面上输入的用户名会传给这个方法的参数
 */
@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.封装用户相关信息并返回
        return new User(username,
                encodePassword,       //必须是已经加密的密码
                AuthorityUtils.createAuthorityList("sys:res:create","sys:res:retrieve")); //权限
    }
}

4.网关中登陆路由配置

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

5.基于Postman进行访问测试

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

6.spring security详解

创建控制层用于测试，代码如下：

package com.jt.auth.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("other")
public class OtherController {
    @GetMapping("hello")
    public String sayHello() {
        return "hello";
    }
    @GetMapping("go")
    public String sayGo() {
        return "go";
    }
    @GetMapping("no")
    public String sayNo() {
        return "no";
    }
}

创建一个简单页面用于测试

index.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <h1>Hello Spring Security</h1>
</body>
</html>

Security默认情况

默认情况下是所有请求都需要认证，一般用于后台管理，因为你太肯定是管理员才能访问的，所以必须认证
源码：

@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.禁用跨域攻击
        http.csrf().disable();
        //3.定义登录成功和失败以后的处理逻辑(可选)
        //假如没有如下设置登录成功会显示404
        http.formLogin() //这句话会对外暴露一个登录路径/login
                .successHandler(successHandler())
                        .failureHandler(failureHandler());
    }
    //定义认证成功的处理器
    @Bean
    public AuthenticationSuccessHandler successHandler() {
        return (request,response,authentication) -> {
            Map<String,Object> map = new HashMap<>();
            map.put("state",200);
            map.put("message","login ok");
            //将map对象转换为json格式字符串并写到客户端
            writeJsonToClient(response,map);
        };
    }
    //定义认证失败的处理器
    @Bean
    public AuthenticationFailureHandler failureHandler() {
        return (request,response,authentication) -> {
            Map<String,Object> map = new HashMap<>();
            map.put("state",500);
            map.put("message","login failure");
            //将map对象转换为json格式字符串并写到客户端
            writeJsonToClient(response,map);
        };
    }
    private void writeJsonToClient(HttpServletResponse response,Map<String,Object> map) throws IOException {
        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();
    }
}

运行结果
输入网址

回车

跳转到登录页面，可见需要认证，其他请求也是一样的结果。

csrf跨域攻击

csrf详解
这里spring通过disable（）方法禁用。
如果不禁用跨域攻击，则不允许登录。报403错。

不调用父类方法，默认全部不需要认证

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    //初始化加密对象
    //此对象提供了一种不可逆的加密方式，相对于md5方式会更加安全
    @Bean
    public BCryptPasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
    /**配置认证规则*/
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        //1.禁用跨域攻击
        http.csrf().disable();
        //3.定义登录成功和失败以后的处理逻辑(可选)
        //假如没有如下设置登录成功会显示404
        http.formLogin() //这句话会对外暴露一个登录路径/login
                .successHandler(successHandler())
                        .failureHandler(failureHandler());
    }
    //定义认证成功的处理器
    @Bean
    public AuthenticationSuccessHandler successHandler() {
        //lambda表达式
        return (request,response,authentication) -> {
            Map<String,Object> map = new HashMap<>();
            map.put("state",200);
            map.put("message","login ok");
            //将map对象转换为json格式字符串并写到客户端
            writeJsonToClient(response,map);
        };
    }
    //定义认证失败的处理器
    @Bean
    public AuthenticationFailureHandler failureHandler() {
        return (request,response,authentication) -> {
            Map<String,Object> map = new HashMap<>();
            map.put("state",500);
            map.put("message","login failure");
            //将map对象转换为json格式字符串并写到客户端
            writeJsonToClient(response,map);
        };
    }
    private void writeJsonToClient(HttpServletResponse response,Map<String,Object> map) throws IOException {
        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();
    }
}

运行结果：

不需要认证，直接访问，当然加一句 http.authorizeRequests().anyRequest().permitAll();也是一样，即放行所有的请求

指定一些请求需要认证，其他不需要

@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.禁用跨域攻击
        http.csrf().disable();
        //http.authorizeRequests().antMatchers("/other/hello").authenticated(); //必须认证才能访问
        http.authorizeRequests().antMatchers("/other/hello","/other/go").authenticated()  //除了这两个网址需要认证，其他都直接放行
                .anyRequest().permitAll();
        //3.定义登录成功和失败以后的处理逻辑(可选)
        //假如没有如下设置登录成功会显示404
        http.formLogin() //这句话会对外暴露一个登录路径/login
                .successHandler(successHandler())
                        .failureHandler(failureHandler());
    }
    //定义认证成功的处理器
    @Bean
    public AuthenticationSuccessHandler successHandler() {
        //lambda表达式
        return (request,response,authentication) -> {
            Map<String,Object> map = new HashMap<>();
            map.put("state",200);
            map.put("message","login ok");
            //将map对象转换为json格式字符串并写到客户端
            writeJsonToClient(response,map);
        };
    }
    //定义认证失败的处理器
    @Bean
    public AuthenticationFailureHandler failureHandler() {
        return (request,response,authentication) -> {
            Map<String,Object> map = new HashMap<>();
            map.put("state",500);
            map.put("message","login failure");
            //将map对象转换为json格式字符串并写到客户端
            writeJsonToClient(response,map);
        };
    }
    private void writeJsonToClient(HttpServletResponse response,Map<String,Object> map) throws IOException {
        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();
    }
}

运行结果：
运行hello请求

回车

需要验证
运行go请求

回车

需要认证
运行no请求

不需要认证

指定一些请求放行，其他需要认证

@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.禁用跨域攻击
        http.csrf().disable();
        http.authorizeRequests().antMatchers("/other/hello","/other/go").permitAll() //除了这两个网址可以放行，其他的都需要认证
                .anyRequest().authenticated();
        //3.定义登录成功和失败以后的处理逻辑(可选)
        //假如没有如下设置登录成功会显示404
        http.formLogin() //这句话会对外暴露一个登录路径/login
                .successHandler(successHandler())
                        .failureHandler(failureHandler());
    }
    //定义认证成功的处理器
    @Bean
    public AuthenticationSuccessHandler successHandler() {
        //lambda表达式
        return (request,response,authentication) -> {
            Map<String,Object> map = new HashMap<>();
            map.put("state",200);
            map.put("message","login ok");
            //将map对象转换为json格式字符串并写到客户端
            writeJsonToClient(response,map);
        };
    }
    //定义认证失败的处理器
    @Bean
    public AuthenticationFailureHandler failureHandler() {
        return (request,response,authentication) -> {
            Map<String,Object> map = new HashMap<>();
            map.put("state",500);
            map.put("message","login failure");
            //将map对象转换为json格式字符串并写到客户端
            writeJsonToClient(response,map);
        };
    }
    private void writeJsonToClient(HttpServletResponse response,Map<String,Object> map) throws IOException {
        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();
    }
}

测试hello请求

直接放行
测试go请求

直接放行
测试其他请求，这里测试no请求


不放行，需要认证

当没有设置formLogin()

@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.禁用跨域攻击
        http.csrf().disable();
    }
}

登录成功后：

因为你没有设置，无论登录成功还是失败，都没有设置返回的是什么值，或者跳转什么页面，故是404

设置formLogin()

不设置返回信息，但是有页面

@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.禁用跨域攻击
        http.csrf().disable();
        
        //3.定义登录成功和失败以后的处理逻辑(可选)
        //假如没有如下设置登录成功会显示404
        http.formLogin(); //这句话会对外暴露一个登录路径/login
    }
}

登陆后返回页面


并且多次测试，发现你没特别设置的话，登录成功后默认返回到index.html页面，别的名称不行，必须index.

设置返回信息

@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.禁用跨域攻击
        http.csrf().disable();
        //3.定义登录成功和失败以后的处理逻辑(可选)
        //假如没有如下设置登录成功会显示404
        http.formLogin() //这句话会对外暴露一个登录路径/login
                .successHandler(successHandler())
                        .failureHandler(failureHandler());
    }
    //定义认证成功的处理器
    @Bean
    public AuthenticationSuccessHandler successHandler() {
        //lambda表达式
        return (request,response,authentication) -> {
            Map<String,Object> map = new HashMap<>();
            map.put("state",200);
            map.put("message","login ok");
            //将map对象转换为json格式字符串并写到客户端
            writeJsonToClient(response,map);
        };
    }
    //定义认证失败的处理器
    @Bean
    public AuthenticationFailureHandler failureHandler() {
        return (request,response,authentication) -> {
            Map<String,Object> map = new HashMap<>();
            map.put("state",500);
            map.put("message","login failure");
            //将map对象转换为json格式字符串并写到客户端
            writeJsonToClient(response,map);
        };
    }
    private void writeJsonToClient(HttpServletResponse response,Map<String,Object> map) throws IOException {
        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();
    }
}

登录：

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进行登陆测试。

8.Security 认证流程分析

目前的登陆操作，也就是用户的认证操作，其实现主要基于Spring Security框架，其认证简易流程如下：

四，颁发登录成功令牌

1.流程分析

我们在访问一些网络资源的时候，需要认证自己的身份才能进一步访问，所以这里就需要在浏览器中时刻保持我们登陆成功的信息和用户信息，那么问题来了，这样的数据我们存放在哪呢？
1）可以存放在auth认证服务器内存中，可后期会使用负载均衡，认证服务器可能会有好多个，而你访问另一个资源时认证的可能是另一个认证服务器，该服务器中并没有你认证的消息，那么你就可能要再次登录认证。
2）存放在关系型数据库（Mysql…）中，每次需要认证直接调用认证信息即可，一般用于用户比较少的情况下。
3）存在在非关系数据库（Redis…）中，因其缓冲区的原因，可以支持大量用户的使用。
4）存放在UI客户端中，这就需要使用到jwt的规则，因为在客户端中，所以信息不能存放私密的信息，比如密码等。

2.构建令牌配置对象

令牌生成策略：

我们查看TokenStore令牌几个实现类：
JdbcTokenStore：关系性数据库
RedisTokenStore: 非关系型数据库
JwtTokenStore: 放在客户端的jwt格式
InMemoryTokenStore:oauth2默认的方式，将其存放在内存中，单机大多使用这种，即上述1）

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

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;

/**
 * 在此配置类中配置令牌的生成，存储策略，验签方式(令牌的合法性)
 */
@Configuration
public class TokenConfig {
    /**
     * JWT 令牌签名时使用的密钥(可以理解为盐值加密中的盐)
     * 1) 生成的令牌需要这个密钥进行签名
     * 2) 获取的令牌需要使用这个密钥进行验签(校验令牌合法性，是否被篡改过)
     */
    //定义签名key,在执行令牌签名需要这个key，可以自己指定
    private String SIGNING_KEY = "auth";

    /**
     * 配置令牌的存储策略，对于oauth2规范中提供了这样的几种策略
     * 1)JdbcTokenStore(这里是要将token存储到关系型数据库)
     * 2)RedisTokenStore(这里要将token存储到redis数据库-key/value)
     * 3)JwtTokenStore(这里是将产生的token信息存储到客户端，并且token中可以以自包含的形式存储一些用户信息)
     * ...
     * @return
     */
    @Bean
    public TokenStore tokenStore() {
        //这里采用JWT的方式存储令牌
        return new JwtTokenStore(jwtAccessTokenConverter());
    }
    
    //定义Jwt转换器，负责生成jwt令牌，解析令牌内容
    /**
     * 配置令牌的创建及验签方式
     * 基于此对象创建的令牌信息会封装OAuth2AccessToken类型的对象中
     * 然后存储到TokenStore对象，外界需要时，会从tokenStore进行获取
     * @return
     */
    @Bean
    public JwtAccessTokenConverter jwtAccessTokenConverter() {
        JwtAccessTokenConverter converter = new JwtAccessTokenConverter();
        //JWT令牌构成: header(签名算法，令牌类型),payload(数据部分),Signing(签名)
        //这里的签名可以简单理解为加密，加密时会使用header中算法以及我们自己提供的密钥
        //这里加密的目的是为了防止令牌被篡改(这里的密钥要保管好，要存储在服务端)
        //设置加密/解密口令
        converter.setSigningKey(SIGNING_KEY);//设置密钥
        return converter;
    }
}

3.定义认证授权核心配置

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

 @Bean
  public AuthenticationManager authenticationManagerBean()
            throws Exception {
      return super.authenticationManager();
  }

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

package com.jt.auth.config;

import com.jt.auth.service.UserDetailsServiceImpl;
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.crypto.password.PasswordEncoder;
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.AuthorizationServerTokenServices;
import org.springframework.security.oauth2.provider.token.DefaultTokenServices;
import org.springframework.security.oauth2.provider.token.TokenEnhancerChain;
import org.springframework.security.oauth2.provider.token.TokenStore;
import org.springframework.security.oauth2.provider.token.store.JwtAccessTokenConverter;

import java.util.Arrays;

/**
 * 在这个对象中负责将所有的认证和授权配置进行整合，例如
 * 业务方面：
 * 1) 如何认证(认证逻辑的设计)
 * 2) 认证通过如何颁发令牌
 * 3) 为谁颁发令牌(客户端标识)
 * 技术方面：
 * 1)SpringSecurity(提供认证和授权的实现)
 * 2)TokenConfig(提供了令牌的生成，存储，校验)
 * 3)Oauth2(定义了一套认证规范，例如为谁发令牌，都发什么，...)
 *
 */
@AllArgsConstructor //生成全参构造函数
@Configuration
@EnableAuthorizationServer //开启认证和授权服务
public class Oauth2Config extends AuthorizationServerConfigurerAdapter {
    //此对象负责完成认证管理
    //@Autowired
    private AuthenticationManager authenticationManager;
    //TokenStore负责完成令牌创建，信息读取
    //@Autowired
    private TokenStore tokenStore;
    //JWT令牌转换器(基于用户信息构建令牌，解析令牌)
    //@Autowired
    private JwtAccessTokenConverter jwtAccessTokenConverter;
    //密码加密匹配器对象
    //@Autowired
    private BCryptPasswordEncoder passwordEncoder;
    //负责获取用户信息
    //@Autowired
    private UserDetailsServiceImpl userDetailsService;
    //设置认证端点的配置(/oauth/token)，客户端通过这个路径获取JWT令牌
    /**
     * oauth2认证方式配置
     * @param endpoints
     * @throws Exception
     */
    @Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception{
        //super.configure(endpoints);
        //由谁完成认证?
        //谁负责访问数据库？(认证时需要两部分信息:一部分来自客户端，一部分来自数据库)
        //支持对什么请求进行认证(默认支持post方式)
        //认证成功以后令牌如何生成和存储?(默认令牌生成UUID.randomUUID(),存储方式为内存)
        endpoints
                //配置认证管理器
                .authenticationManager(authenticationManager)
                //验证用户的方法获得用户详情
                .userDetailsService(userDetailsService)
                //要求提交认证使用post请求方式，提高安全性
                .allowedTokenEndpointRequestMethods(HttpMethod.POST,HttpMethod.GET)
                //要配置令牌的生成，由于令牌生成比较复杂，下面有方法实现
                .tokenServices(tokenService()); //这个不配置，默认令牌为UUID.randomUUID().toString
    }
    //系统底层完成认证以后会调用TokenService对象的相关方法
    //获取TokenStore，基于tokenStore获取token对象
    @Bean
    public AuthorizationServerTokenServices tokenService() {
        //1.构建TokenService对象(此对象提供了创建，获取，刷新token的方法)
        DefaultTokenServices tokenServices = new DefaultTokenServices();
        //2.设置令牌生成和存储策略
        tokenServices.setTokenStore(tokenStore);
        //3.设置是否支持令牌刷新(访问令牌过期了，是否支持通过令牌刷新机制，延长令牌有效期)
        tokenServices.setSupportRefreshToken(true);
        //4.设置令牌的增强策略(默认令牌会比较简单，没有业务数据，就是简单的随机字符串(UUID)，但现在希望是jwt方式)
        TokenEnhancerChain tokenEnhancer = new TokenEnhancerChain();
        tokenEnhancer.setTokenEnhancers(Arrays.asList(jwtAccessTokenConverter));//可以有多个令牌
        tokenServices.setTokenEnhancer(tokenEnhancer);
        //5.设置令牌有效期
        tokenServices.setAccessTokenValiditySeconds(3600); //1小时
        //6.设置刷新令牌有效期
        tokenServices.setRefreshTokenValiditySeconds(3600*72); //3天
        return tokenServices;
    }

    /**
     * 假如我们要做认证，我们输入了用户名和密码，然后提交，
     * 提交到哪里(url-去哪认证)，这个路径是否需要认证？还有令牌过期了，
     * 我们要重新生成一个令牌，哪个路径帮我们重新生成？
     * 对外提供认证路径，令牌刷新，校验等路径
     * 如下这个方法就可以提供这个配置
     * @param security
     * @throws Exception
     */

    @Override
    public void configure(AuthorizationServerSecurityConfigurer security) throws Exception {
        //super.config(security)
        security
        //1.定义(公开)要认证的url(permitAll()是官方定义好的)
        //公开oauth/token_key端口
        .tokenKeyAccess("permitAll()")
        //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
                .withClient("gateway-client")
                //定义客户端密钥(客户端提交用户信息时需要携带这个密钥)
                .secret(passwordEncoder.encode("123456"))
                //定义作用范围(所有符合规则的客户端)
                .scopes("all") //all只是个名字而已和写abc效果相同
                //允许客户端基于密码方式，刷新令牌方式实现认证
                .authorizedGrantTypes("password","refresh_token");
    }
}

这里没有使用@Autowired注入，而是使用了lombok中的@AllArgsConstructor，构造全参构造器，效果是一样的。

4.配置网关认证的URL

5.Postman访问测试

第一步：启动服务
依次启动sca-auth服务，sca-resource-gateway服务。
第二步：检测sca-auth服务控制台的Endpoints信息，例如:

第三步：打开postman进行登陆访问测试

第四步：测试令牌，将access_token中数据复制，

第四步，校验刷新令牌，刷新令牌主要是为了当令牌过期后，再次获取之前令牌。

6.登陆页面登陆方法设计

修改之前登录页面

登录，登录成功后跳转上传文件页面，并且能够查到令牌

五，资源服务器配置

1.业务描述

用户在访问受限资源时，一般要先检测用户是否已经认证（登录），假如没有认证要先认证，认证通过还要检测是否有权限，没有权限则给出提示，有权限则直接访问。例如：

这里，我们做文件的上传也会采用这样的逻辑进行实现。

2.添加项目依赖

打开资源服务(sca-resource)的pom.xml文件，添加oauth2依赖，基于此依赖实现授权业务。

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

3.令牌处理器配置

用户登陆成功以后可以携带token访问服务端资源服务器，资源服务器中需要有解析token的对象，例如：

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;

@Configuration
public class TokenConfig {
    //定义令牌签发口令(暗号),这个口令自己定义即可
    private String SIGNING_KEY = "auth";
    //初始化令牌策略
    //这里我们采用JWT方式生成令牌
    @Bean
    public TokenStore tokenStore() {
        return new JwtTokenStore(jwtAccessTokenConverter());
    }
    //构建JWT令牌转换器对象，基于此对象创建令牌，解析令牌token
    @Bean
    public JwtAccessTokenConverter jwtAccessTokenConverter() {
        JwtAccessTokenConverter converter = new JwtAccessTokenConverter();
        converter.setSigningKey(SIGNING_KEY);
        return converter;
    }
}

4.启动和配置认证和授权规则

定义配置类，在类中定义资源访问规则例如：

package com.jt.resource.config;

import org.codehaus.jackson.map.ObjectMapper;
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;
import org.springframework.security.web.access.AccessDeniedHandler;

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

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

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

    /**
     * 路由安全认证配置
     * @param http
     * @throws Exception
     */
    @Override
    public void configure(HttpSecurity http) throws Exception {
        //1.关闭跨域攻击
        http.csrf().disable();
        //2.放行相关请求
        http.exceptionHandling()
                .accessDeniedHandler(accessDeniedHandler());
        http.authorizeRequests().antMatchers("/sca/resource/upload/file/**","/sca/resource/upload/res/**").authenticated()
                .anyRequest().permitAll();
        //http.authorizeRequests().anyRequest().permitAll();
    }
    //没有权限时执行此处理器方法
    public AccessDeniedHandler accessDeniedHandler() {
        return (request,response,e) -> {
            Map<String,Object> map = new HashMap<>();
            map.put("state", HttpServletResponse.SC_FORBIDDEN); //SC_FORBIDDEN的值是403
            map.put("message","没有权限访问，请联系管理员");
            //1.设置响应数据的编码
            response.setCharacterEncoding("utf-8");
            //2告诉浏览器响应数据的内容类型以及编码
            response.setContentType("application/json;charset=utf-8");
            //3获取输出流对象
            PrintWriter out = response.getWriter();
            //4.输出数据
            String result = new ObjectMapper().writeValueAsString(map);
            out.println(result);
            out.flush();
            out.close();
        };
    }
}

5.ResourceController 方法配置

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

	@PreAuthorize("hasAuthority('sys:res:create')") //用户权限 AOP设计
    @RequiredLog("upload file") //此注解描述的方法是切入点方法
    @PostMapping("/upload/file") //文件上传的请求方式必须是post
    public String uploadFile(MultipartFile uploadFile) throws IOException {
    ...
    }

6.启动服务访问测试

第一步:启动服务（sca-auth,sca-resource-gateway,sca-resource)
第二步:执行登陆获取access_token令牌
第三步:携带令牌访问资源(url中的前缀"sca"是在资源服务器中自己指定的,你的网关怎么配置的,你就怎么写)
设置请求头(header)，要携带令牌并指定请求的内容类型，例如：
首先登录认证获取令牌

在图片上传的网址的请求头中添加令牌认证

在Body中需上传的文件，注意这里类型要调成File类型

模拟文件上传，显示结果

7.文件上传JS方法设计

修改文件上传页面js

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

当没有登录就想上传文件，提示我们登录

并跳到登录页面

登录认证成功后即可上传文件

8.令牌校验测试

当我们把资源服务配置中的token服务注销掉，同上述步骤，查看结果

运行ok

当我们把令牌配置失效

查看结果

认证失败，为什么？因为你没有token配置了，所以令牌没有解析，故认证失败。
综上所述：令牌需要解析，而创建解析令牌需token配置类，那为什么还要在资源服务配置中写token服务呢？因为我们目前只有一个服务，所以可以不用写token服务，当我们多起来，就需要分别配置了

9.权限认证分析

我们是否有这样的经历，当我们访问淘宝的商品页面的时候，不需要登录，而当我们下单的时候，是不是就需要登录认证？
而商品的上架下架也肯定不能够被普通用户操作，而是有商家才有这样的权限，所以不同的用户也会有不同的权限。

我们在认证用户后将用户相关信息封装起来，其中就包括权限

为了方便测试，我们随便写了几个控制层，分别需要不同的权限
查询业务，这里不需要特殊权限

删除业务，这里需要特殊的权限

之前的上传文件业务，这里也需要特殊权限，为了方便测试，修改了其路径
设置需要认证的网址

因为查询业务不需要认证，直接获取

删除业务需要认证，不认证会报401，即未认证异常

删除业务不仅需要认证，还需要我们的特殊权限，这里没有，所以返回我们设置的403信息

而我们有上传业务的权限，所以认证过后，可以成功实现上传

六，技术摘要应用实践说明

1.背景分析

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

2.Spring Security 技术

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

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

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 三个部分拼成一个字符串，每个部分之间用"点"（.）分隔，就可以返回给用户。

4.Oauth2规范

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

七，总结

1.重难点分析

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

2.FAQ 分析

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