Spring Security Oauth2

Spring Security OAuth2

一. Oauth2.0

​ 是开放授权的一个标准，旨在让用户允许第三方应用去访问用户在某服务器中的特定私有资源，而可以不提供其在某服务器的账号密码给到第三方应用。通俗的话可以这样去理解，假如你们公司正在开发一个 第三方应用XXX，该应用会需要在微信中分享出来一个活动页，该活动需要让微信用户去参与，你们的应用需要收集到用户的姓名，头像，地域等信息，那么问题来了？你的应用如何才能拿到所有参与活动的微信用户的基本信息呢?

​ 根据如上的描述，我们可以将OAuth2分为四个角色：

  • Resource Owner：资源所有者 即上述中的微信用户
  • Resource Server：资源服务器 即上述中的微信服务器，提供微信用户基本信息给到第三方应用
  • Client：第三方应用客户端 即上述中你公司正在开发的第三方应用
  • Authorication Server：授权服务器 该角色可以理解为管理其余三者关系的中间层

其具体的执行流程如下图所示：

[图片上传失败...(image-cd3d38-1589169864698)]

1.1 OAuth2的四种授权方式

1.1.1 授权码(authorization-code)

​ 这种方式是最常用的流程，安全性也最高，它适用于那些有后端的 Web 应用。授权码通过前端传送，令牌则是储存在后端，而且所有与资源服务器的通信都在后端完成。这样的前后端分离，可以避免令牌泄漏。

<font color="red">第一步</font>，A 网站提供一个链接，用户点击后就会跳转到 B 网站，授权用户数据给 A 网站使用。下面就是 A 网站跳转 B 网站的一个示意链接。

https://b.com/oauth/authorize?
  response_type=code&
  client_id=CLIENT_ID&
  redirect_uri=CALLBACK_URL

​ 上面 URL 中，response_type参数表示要求返回授权码（code），client_id参数让 B 知道是谁在请求，redirect_uri参数是 B 接受或拒绝请求后的跳转网址，scope参数表示要求的授权范围（这里是只读）。

<font color="red">第二步</font>，用户跳转后，B 网站会要求用户登录，然后询问是否同意给予 A 网站授权。用户表示同意，这时 B 网站就会跳回redirect_uri参数指定的网址。跳转时，会传回一个授权码，就像下面这样。

https://a.com/callback?code=AUTHORIZATION_CODE

<font color="red">第三步</font>，A 网站拿到授权码以后，就可以在后端，向 B 网站请求令牌。

https://b.com/oauth/token?
 client_id=CLIENT_ID&
 client_secret=CLIENT_SECRET&
 grant_type=authorization_code&
 code=AUTHORIZATION_CODE&
 redirect_uri=CALLBACK_URL

​ 上面 URL 中，client_id参数和client_secret参数用来让 B 确认 A 的身份（client_secret参数是保密的，因此只能在后端发请求），grant_type参数的值是AUTHORIZATION_CODE，表示采用的授权方式是授权码，code参数是上一步拿到的授权码，redirect_uri参数是令牌颁发后的回调网址。

<font color="red">第四步</font>，B 网站收到请求以后，就会颁发令牌。具体做法是向redirect_uri指定的网址，发送一段 JSON 数据。

{    
  "access_token":"ACCESS_TOKEN",
  "token_type":"bearer",
  "expires_in":2592000,
  "refresh_token":"REFRESH_TOKEN",
  "scope":"read",
  "uid":100101,
  "info":{...}
}

上面 JSON 数据中，access_token字段就是令牌，A 网站在后端拿到了。

1.1.2 隐藏式(implicit)

​ 有些 Web 应用是纯前端应用，没有后端。这时就不能用上面的方式了，必须将令牌储存在前端。

<font color="red">第一步</font>，A 网站提供一个链接，要求用户跳转到 B 网站，授权用户数据给 A 网站使用。

https://b.com/oauth/authorize?
  response_type=token&
  client_id=CLIENT_ID&
  redirect_uri=CALLBACK_URL

​ 上面 URL 中，response_type参数为token，表示要求直接返回令牌。

<font color="red">第二步</font>，用户跳转到 B 网站，登录后同意给予 A 网站授权。这时，B 网站就会跳回redirect_uri参数指定的跳转网址，并且把令牌作为 URL 参数，传给 A 网站。

https://a.com/callback?token=ACCESS_TOKEN

​ 这种方式把令牌直接传给前端，是很不安全的。因此，只能用于一些安全要求不高的场景，并且令牌的有效期必须非常短，通常就是会话期间（session）有效，浏览器关掉，令牌就失效了。

1.1.3 密码式(password)

​ 如果你高度信任某个应用，RFC 6749 也允许用户把用户名和密码，直接告诉该应用。该应用就使用你的密码，申请令牌，这种方式称为"密码式"（password）。

<font color="red">第一步</font>，A 网站要求用户提供 B 网站的用户名和密码。拿到以后，A 就直接向 B 请求令牌。

ttps://oauth.b.com/token?
  grant_type=password&
  username=USERNAME&
  password=PASSWORD&
  client_id=CLIENT_ID

​ 上面 URL 中，grant_type参数是授权方式，这里的password表示"密码式"，username和password是 B 的用户名和密码。

<font color="red">第二步</font>，B 网站验证身份通过后，直接给出令牌。注意，这时不需要跳转，而是把令牌放在 JSON 数据里面，作为 HTTP 回应，A 因此拿到令牌。

这种方式需要用户给出自己的用户名/密码，显然风险很大，因此只适用于其他授权方式都无法采用的情况，而且必须是用户高度信任的应用。

1.1.4 客户端凭证(client credentials)

​ 最后一种方式是凭证式（client credentials），适用于没有前端的命令行应用，即在命令行下请求令牌。

<font color="red">第一步</font>，A 应用在命令行向 B 发出请求。

https://oauth.b.com/token?
  grant_type=client_credentials&
  client_id=CLIENT_ID&
  client_secret=CLIENT_SECRET

​ 上面 URL 中，grant_type参数等于client_credentials表示采用凭证式，client_id和client_secret用来让 B 确认 A 的身份。

<font color="red">第二步</font>，B 网站验证通过以后，直接返回令牌。

这种方式给出的令牌，是针对第三方应用的，而不是针对用户的，即有可能多个用户共享同一个令牌。

二. 授权服务器的搭建

2.1 依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.security.oauth</groupId>
    <artifactId>spring-security-oauth2</artifactId>
    <version>2.3.6.RELEASE</version>
</dependency>

<dependency>
    <groupId>org.springframework.security.oauth.boot</groupId>
    <artifactId>spring-security-oauth2-autoconfigure</artifactId>
    <version>2.1.9.RELEASE</version>
</dependency>

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.1.17</version>
</dependency>

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

2.2 配置

spring:
  datasource:
    url: jdbc:mysql://mysql:3306/oauth2?useSSL=false&serverTimezone=UTC
    username: root
    password:
    driver-class-name: com.mysql.cj.jdbc.Driver
    druid:
      initial-size: 20
      max-active: 50
      min-idle: 15
      validation-query: 'select 1'
      test-on-borrow: false
      test-on-return: false
      test-while-idle: true
      # psCache, 缓存preparedStatement, 对支持游标的数据库性能有巨大的提升，oracle开启，mysql建议关闭
      pool-prepared-statements: false
      # psCache开启的时候有效
      max-open-prepared-statements: 100
      # 一个连接在被驱逐出连接池的时候，在连接池中最小的空闲时间，单位为毫秒
      min-evictable-idle-time-millis: 30000
      # 距离上次释放空闲连接的时间间隔
      time-between-eviction-runs-millis: 30000

2.3 数据库表的创建

create table oauth_client_details (
  client_id VARCHAR(256) PRIMARY KEY,
  resource_ids VARCHAR(256),
  client_secret VARCHAR(256),
  scope VARCHAR(256),
  authorized_grant_types VARCHAR(256),
  web_server_redirect_uri VARCHAR(256),
  authorities VARCHAR(256),
  access_token_validity INTEGER,
  refresh_token_validity INTEGER,
  additional_information VARCHAR(4096),
  autoapprove VARCHAR(256)
);

create table oauth_client_token (
  token_id VARCHAR(256),
  token blob,
  authentication_id VARCHAR(256) PRIMARY KEY,
  user_name VARCHAR(256),
  client_id VARCHAR(256)
);

create table oauth_access_token (
  token_id VARCHAR(256),
  token blob,
  authentication_id VARCHAR(256) PRIMARY KEY,
  user_name VARCHAR(256),
  client_id VARCHAR(256),
  authentication blob,
  refresh_token VARCHAR(256)
);

create table oauth_refresh_token (
  token_id VARCHAR(256),
  token blob,
  authentication blob
);

create table oauth_code (
  code VARCHAR(256), authentication blob
);

create table oauth_approvals (
    userId VARCHAR(256),
    clientId VARCHAR(256),
    scope VARCHAR(256),
    status VARCHAR(10),
    expiresAt TIMESTAMP,
    lastModifiedAt TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
);

说明：数据库表是依据spring-security的官网，地址为：https://github.com/spring-projects/spring-security-oauth/blob/master/spring-security-oauth2/src/test/resources/schema.sql，但是在创建的时候将所有的字段类型LONGVARBINARY改为BLOB类型。

数据库的说明参考：http://andaily.com/spring-oauth-server/db_table_description.html

2.4 用户登录认证

@Component
public class UserSecurityService implements UserDetailsService {

    private static Logger logger = LoggerFactory.getLogger(UserSecurityService.class);

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        logger.info("用户名：" + username);

        return new User(username, "$2a$10$TWf8wOKvyAeuJiL/gj8AfeWOrW9vr6g4Q6kJ.PZ1bt53ISRXTTcga",
                Arrays.asList(new SimpleGrantedAuthority("ROLE_admin")));
    }
}

2.5 web安全配置

@Configuration
public class WebAuthorizationConfig extends WebSecurityConfigurerAdapter {

    // 密码的加解密
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.formLogin() 
                .loginPage("/login.html") 
                .loginProcessingUrl("/authentication/form")
                .and()
                .authorizeRequests() 
                .antMatchers("/login.html").permitAll()
                .anyRequest()
                .authenticated()
                .and()
                .csrf().disable();

    }
}

2.6 授权服务器配置

@Configuration
@EnableAuthorizationServer
public class AuthorizationServerConfig extends AuthorizationServerConfigurerAdapter {

    @Autowired
    private LoginAuthencation loginAuthencation;

    @Autowired
    private PasswordEncoder passwordEncoder;

    @Resource
    private DataSource dataSource;

    // 根据用户的client_id查询用户的授权信息
    @Bean
    public ClientDetailsService clientDetails() {
        return new JdbcClientDetailsService(dataSource);
    }

    //用于将token信息存放在数据库中
    @Bean
    public TokenStore tokenStore() {
        return new JdbcTokenStore(dataSource);
    }

    // authentication_code放入到数据中
    @Bean
    public AuthorizationCodeServices authorizationCodeServices() {
        return new JdbcAuthorizationCodeServices(dataSource);
    }

    @Override
    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
        // 采用数据库的方式查询用户的授权信息
        clients.withClientDetails(clientDetails());

        /**  供学习使用
        clients.inMemory()
                // client_id
                .withClient("client")
                // client_secret
                .secret("secret")
                // 该client允许的授权类型，不同的类型，则获得token的方式不一样。
                .authorizedGrantTypes("authorization_code")
                .scopes("all")
                //回调uri，在authorization_code与implicit授权方式时，用以接收服务器的返回信息
                .redirectUris("http://localhost:9090/login");
         */
    }

    @Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
        // 存数据库
        endpoints.tokenStore(tokenStore())
                .authorizationCodeServices(authorizationCodeServices())
                .allowedTokenEndpointRequestMethods(HttpMethod.GET, HttpMethod.POST);

        // 配置tokenServices参数
        DefaultTokenServices tokenServices = new DefaultTokenServices();
        tokenServices.setTokenStore(endpoints.getTokenStore());
        tokenServices.setSupportRefreshToken(false);
        tokenServices.setClientDetailsService(endpoints.getClientDetailsService());
        tokenServices.setTokenEnhancer(endpoints.getTokenEnhancer());
        // token的过期时间为1天
        tokenServices.setAccessTokenValiditySeconds((int)TimeUnit.DAYS.toSeconds(1)); 
        endpoints.tokenServices(tokenServices);
    }

    @Override
    public void configure(AuthorizationServerSecurityConfigurer oauthServer) throws Exception {
        /**
         * 作用是使用client_id和client_secret来做登录认证，如果是在浏览器的情况下，会让用户
         * 输入用户名和密码
         */
        oauthServer.allowFormAuthenticationForClients();
        oauthServer.checkTokenAccess("isAuthenticated()");
        oauthServer.passwordEncoder(passwordEncoder);
    }
}

2.7 更改默认授权页面

@Controller
@SessionAttributes("authorizationRequest") // 必须配置
public class AuthController {

/**
 * org.springframework.security.oauth2.provider.endpoint.AuthorizationEndpoint 
    默认的授权页面
 */
    @RequestMapping("/oauth/confirm_access")
    public String getAccessConfirmation(Map<String, Object> model, HttpServletRequest request) throws Exception {
         AuthorizationRequest authorizationRequest = (AuthorizationRequest) model.get("authorizationRequest");

        System.out.println(authorizationRequest.getScope());

        return "/oauth.html";
    }
}

2.8 获取code

​ 获取授权码的地址：http://127.0.0.1:8080/oauth/authorize?client_id=other_client&response_type=code&redirect_uri=http://localhost:9090/login

​ [图片上传失败...(image-4ddc11-1589169864698)]

​ 在浏览器地址栏的重定向地址上可以看到 code值。

2.9 获取access_token

​ 根据上一步获取到的code值获取acccess_token, 请求的地址为：

http://127.0.0.1:8080/oauth/token?client_id=other_client&client_secret=1&grant_type=authorization_code&code=tuvCj9&redirect_uri=http://localhost:9090/login

​ 其中code的值为上一步请求获取到的code的数据，返回内容如下：

[图片上传失败...(image-d0a6d4-1589169864698)]

2.10 获取额外的信息

​ Oauth2在获取用户额外信息的时候，内部实现上并没有去做，所以需要我们自己去实现，实现的方式就是去重写其代码，思路是从数据库查询到的信息封装到 ClientDetails中，但是内部却没有开放出来，所以需要去找到是在何处查询数据库，根据源代码的追踪，发现查询数据库的操作是在ApprovalStoreUserApprovalHandler这个类中，所以我们需要手动的去修改其源代码，修改的内容如下：

[图片上传失败...(image-444a2f-1589169864698)]

三. 资源服务器的搭建

​ 资源服务器就是用户想要真正获取资源的服务器，我们必须要通过2.9节中获取到的access_token来获取。

3.1依赖

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.9.RELEASE</version>
</parent>
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.security.oauth</groupId>
        <artifactId>spring-security-oauth2</artifactId>
    <version>2.3.6.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>org.springframework.security.oauth.boot</groupId>
        <artifactId>spring-security-oauth2-autoconfigure</artifactId>
        <version>2.1.9.RELEASE</version>
    </dependency>
</dependencies>

3.2 配置

security:
  oauth2:
    resource:
      # access_token的验证地址
      token-info-uri: http://localhost:8080/oauth/check_token

    client:
      client-id: resources_client
      client-secret: 1

3.3 资源服务账号

​ 我们需要在授权服务器上创建client_id和client_secret，当资源服务器拿到第三方的access_token后需要到授权服务器上验证access_token的来源是否合法。

3.4 资源服务器安全配置

@Configuration
@EnableResourceServer
public class ResourceServerConfig extends ResourceServerConfigurerAdapter {

    @Override
    public void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests() //
                .antMatchers("/user").access("#oauth2.hasAnyScope('all','read')");
    }
}

3.5 获取资源

通过调用如下接口去获取资源服务器的资源：

http://localhost:8081/user?access_token=92de29ea-df7d-4d35-b585-c740322f9028

四. JWT(Json Web Token)

4.1 传统跨域登录流程

  1. 用户向服务器发送用户名和密码。
  2. 验证服务器后，相关数据（如用户角色，登录时间等）将保存在当前会话中。
  3. 服务器向用户返回session_id，session信息都会写入到用户的Cookie。
  4. 用户的每个后续请求都将通过在Cookie中取出session_id传给服务器。
  5. 服务器收到session_id并对比之前保存的数据，确认用户的身份。

[图片上传失败...(image-a616f0-1589169864698)]

​ 这种模式最大的问题是，没有分布式架构，无法支持横向扩展。如果使用一个服务器，该模式完全没有问题。但是，如果它是服务器群集或面向服务的跨域体系结构的话，则需要一个统一的session数据库库来保存会话数据实现共享，这样负载均衡下的每个服务器才可以正确的验证用户身份。

​ 但是在实际中常见的单点登陆的需求：站点A和站点B提供统一公司的相关服务。现在要求用户只需要登录其中一个网站，然后它就会自动登录到另一个网站。怎么做？

​ 一种解决方案是听过持久化session数据，写入数据库或文件持久层等。收到请求后，验证服务从持久层请求数据。该解决方案的优点在于架构清晰，而缺点是架构修改比较费劲，整个服务的验证逻辑层都需要重写，工作量相对较大。而且由于依赖于持久层的数据库或者问题系统，会有单点风险，如果持久层失败，整个认证体系都会挂掉。

4.2 Jwt

​ 针对如上的问题，另外一种解决方案就是JWT(Json Web Token)，其原则是在服务器验证之后，将生产的一个Json对象返回给用户，格式如下：

{
    "access_token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE1NzEyNDE2NTksInVzZXJfbmFtZSI6ImFhIiwiYXV0aG9yaXRpZXMiOlsiUk9MRV9hZG1pbiJdLCJqdGkiOiJlZTczOTI4OC0zNDMwLTQxMjUtODBhOC1lMDU0Njg5OWQ2ODIiLCJjbGllbnRfaWQiOiJteV9jbGllbnQiLCJzY29wZSI6WyJhbGwiXX0.Ji4xYQJuJRrZeCTTMOb1e2GiOESAyiI9NzbWffKzcJ0",
    "token_type": "bearer",
    "expires_in": 43198,
    "scope": "all",
    "jti": "ee739288-3430-4125-80a8-e0546899d682"
}
4.2.1 Jwt数据结构

​ 如上代码返回的access_token为一个字符串，之间用 . 分隔为为三段，其中第一段为 header(头)，第二段为 payload (负载)，第三段为signature(签名)，如下图所示：

[图片上传失败...(image-588c21-1589169864698)]

​ 我们可以在 <https://jwt.io/> 在线解析这个JWT token, 如下图所示

[图片上传失败...(image-f2bd36-1589169864698)]

header

字段名 描述
alg 算法
typ 令牌类型

payload

字段名 描述
exp 超时时间
jti JWT ID

signature

​ 签名，为了验证发送过来的access_token是否有效，通过如下算法得到：

[图片上传失败...(image-280921-1589169864698)]

4.2.2 用法与问题

​ 客户端接收服务器返回的JWT，将其存储在Cookie或localStorage中。此后，客户端将在与服务器交互中都会带JWT。如果将它存储在Cookie中，就可以自动发送，因此一般是将它放入HTTP请求的Header Authorization字段中。当跨域时，也可以将JWT被放置于POST请求的数据主体中。

​ 但是JWT也面临着诸多的问题，如下所示：

  1. JWT默认不加密，但可以加密。生成原始令牌后，可以使用改令牌再次对其进行加密。
  2. 当JWT未加密方法是，一些私密数据无法通过JWT传输。
  3. JWT不仅可用于认证，还可用于信息交换。善用JWT有助于减少服务器请求数据库的次数。
  4. JWT的最大缺点是服务器不保存会话状态，所以在使用期间不可能取消令牌或更改令牌的权限。也就是说，一旦JWT签发，在有效期内将会一直有效。
  5. JWT本身包含认证信息，因此一旦信息泄露，任何人都可以获得令牌的所有权限。为了减少盗用，JWT的有效期不宜设置太长。对于某些重要操作，用户在使用时应该每次都进行进行身份验证。
  6. 为了减少盗用和窃取，JWT不建议使用HTTP协议来传输代码，而是使用加密的HTTPS协议进行传输。

4.3 jwt授权服务器搭建

依赖：

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.9.RELEASE</version>
</parent>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.security.oauth</groupId>
        <artifactId>spring-security-oauth2</artifactId>
        <version>2.3.6.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>org.springframework.security.oauth.boot</groupId>
        <artifactId>spring-security-oauth2-autoconfigure</artifactId>
        <version>2.1.9.RELEASE</version>
    </dependency>
</dependencies>

jwt授权服务器

@Configuration
@EnableAuthorizationServer
public class OauthAuthenticationServer extends AuthorizationServerConfigurerAdapter {

    @Autowired
    private PasswordEncoder passwordEncoder;

    @Bean
    public TokenStore tokenStore() {
        return new JwtTokenStore(jwtAccessTokenConverter());
    }

    @Bean
    public JwtAccessTokenConverter jwtAccessTokenConverter() {
        JwtAccessTokenConverter jwtAccessTokenConverter = new JwtAccessTokenConverter();
        jwtAccessTokenConverter.setSigningKey("123"); //设置签名
        return jwtAccessTokenConverter;
    }

    // 基于内存的授权码
    @Override
    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
        clients.inMemory()  //
                .withClient("my_client") //
                .secret("$2a$10$TWf8wOKvyAeuJiL/gj8AfeWOrW9vr6g4Q6kJ.PZ1bt53ISRXTTcga")  //
                .scopes("all") //
                .authorizedGrantTypes("authorization_code")
                .redirectUris("http://localhost:9090/login");
    }

    @Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
        endpoints.accessTokenConverter(jwtAccessTokenConverter())
                 .allowedTokenEndpointRequestMethods(HttpMethod.GET, HttpMethod.POST);
    }

    @Override
    public void configure(AuthorizationServerSecurityConfigurer security) throws Exception {
        security.allowFormAuthenticationForClients()
                .passwordEncoder(passwordEncoder);
    }
}

4.4 jwt资源服务器

@Configuration
@EnableResourceServer
public class ReourceServerConfig extends ResourceServerConfigurerAdapter {

    @Bean
    public TokenStore jwtTokenStore() {
        return new JwtTokenStore(jwtAccessTokenConverter());
    }

    @Bean
    public DefaultTokenServices defaultTokenServices() {
        DefaultTokenServices defaultTokenServices = new DefaultTokenServices();
        defaultTokenServices.setTokenStore(jwtTokenStore());
        return defaultTokenServices;
    }

    @Bean
    public JwtAccessTokenConverter jwtAccessTokenConverter() {
        JwtAccessTokenConverter jwtAccessTokenConverter = new JwtAccessTokenConverter();
        jwtAccessTokenConverter.setSigningKey("123");
        return jwtAccessTokenConverter;
    }

    @Override
    public void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()  //
                .anyRequest() //
                .authenticated() //
                .and() //
                .csrf().disable();
    }

    @Override
    public void configure(ResourceServerSecurityConfigurer resources) throws Exception {
        resources.tokenServices(defaultTokenServices());
    }
}

五. 单点登录

​ 单点登录(Singal Sign On)是很多企业经常使用的一种登录方式，那么何为单点登录呢？为了解决什么样的问题呢？举个例子，在淘宝公司内部，有天猫、淘宝、阿里云、聚划算等众多的产品线，这些产品线是不同的服务器来支撑运行，但是作为用户的我们却可以使用同一套账户名和密码进行登录他几乎所有的产品，登录服务器只有一个，根据登录服务器返回的特定的信息，可以去访问它所有的产品线。着就是所谓的单点登录。

​ 在具体的实现的时候，我们使用JWT的方式来实现单点登录。他的处理流程如下：

5.1 认证服务器

依赖

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.security.oauth</groupId>
        <artifactId>spring-security-oauth2</artifactId>
        <version>2.3.6.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.security.oauth.boot</groupId>
        <artifactId>spring-security-oauth2-autoconfigure</artifactId>
        <version>2.1.9.RELEASE</version>
    </dependency>
</dependencies>

授权服务

@Configuration
@EnableAuthorizationServer
public class SsoAuthorizationConfigServer extends AuthorizationServerConfigurerAdapter {
    @Bean
    public JwtAccessTokenConverter jwtAccessTokenConverter() {
        JwtAccessTokenConverter jwtAccessTokenConverter = new JwtAccessTokenConverter();
        jwtAccessTokenConverter.setSigningKey("abcxyz");
        return jwtAccessTokenConverter;
    }

    @Override
    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
        clients.inMemory()  //
                .withClient("client-a") //
                .secret("$2a$10$TWf8wOKvyAeuJiL/gj8AfeWOrW9vr6g4Q6kJ.PZ1bt53ISRXTTcga")  //
                .authorizedGrantTypes("authorization_code", "refresh_token")
                .scopes("all")
                .redirectUris("http://localhost:8081/clientA/login")
                .autoApprove(true)
                .and()
                .withClient("client-b") //
                .secret("$2a$10$TWf8wOKvyAeuJiL/gj8AfeWOrW9vr6g4Q6kJ.PZ1bt53ISRXTTcga")  //
                .authorizedGrantTypes("authorization_code")
                .scopes("all")
                .redirectUris("http://localhost:8082/clientB/login")
                .autoApprove(true);
    }

    @Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
        endpoints//.tokenStore(jwtTokenStore())
                 .accessTokenConverter(jwtAccessTokenConverter());
    }
}

5.2 子系统

依赖

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.security.oauth</groupId>
        <artifactId>spring-security-oauth2</artifactId>
        <version>2.3.6.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-security</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.security.oauth.boot</groupId>
        <artifactId>spring-security-oauth2-autoconfigure</artifactId>
        <version>2.1.9.RELEASE</version>
    </dependency>
</dependencies>

配置

server:
  port: 8081
  servlet:
    context-path: /clientA


security:
  oauth2:
    client:
      client-id: client-a
      client-secret: 1
      access-token-uri: http://localhost:7070/auth/oauth/token
      user-authorization-uri: http://localhost:7070/auth/oauth/authorize

    resource:
      jwt:
        key-value: abcxyz

启动类配置

@SpringBootApplication
@EnableOAuth2Sso
public class SsoClientApplicationA {
    public static void main( String[] args ) {
        SpringApplication.run(SsoClientApplicationA.class, args);
    }
}
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 212,222评论 6赞 493
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 90,455评论 3赞 385
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 157,720评论 0赞 348
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 56,568评论 1赞 284
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 65,696评论 6赞 386
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 49,879评论 1赞 290
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 39,028评论 3赞 409
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 37,773评论 0赞 268
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 44,220评论 1赞 303
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 36,550评论 2赞 327
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,697评论 1赞 341
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 34,360评论 4赞 332
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 40,002评论 3赞 315
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,782评论 0赞 21
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,010评论 1赞 266
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 46,433评论 2赞 360
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 43,587评论 2赞 350