安科网

Spring-Cloud之OAuth2开放授权-11

凯哥Java

凯哥Java

2020-01-02

关注 关注

一、OAuth（开放授权）是一个开放标准，允许用户授权第三方移动应用访问他们存储在另外的服务提供者上的信息，而不需要将用户名和密码提供给第三方移动应用或分享他们数据的所有内容，OAuth2.0是OAuth协议的延续版本，但不向后兼容OAuth 1.0即完全废止了OAuth1.0。

二、认证和授权过程。

1）主要包含3中角色：

（1）服务提供方：Authorization Server

　　（2）资源拥有者：Resource Server

　　（3）客户端：Client

2）授权过程

Spring-Cloud之OAuth2开放授权-11

（1）用户打开授权页面，询问用户授权

　　（2）用户同意授权

　　（3）客户端向授权服务器进行授权申请

　　（4）授权服务器进行认证，认证通过后，返回令牌（包含用户信息）

　　（5）客户端得到令牌后，通过携带令牌访问资源服务器资源

　　（6）资源服务器向授权/认证服务确认后，方可向客户端开发资源

三、授权服务器（Authorization Server），为了更加接近生产环境，我这里采用的都是数据库或者自定义配置，请注意注释部分。

1、目录结构：

Spring-Cloud之OAuth2开放授权-11

 　　2、依赖部分

<dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <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>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>

3、启动项

package com.cetc;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

@SpringBootApplication
@EnableEurekaClient
public class AuthServerApplication {

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

4、基础配置application.yaml

server:
  port: 8694
  servlet:
    context-path: /auth
    session:
      cookie:
        name: SESSION_AUTH_SERVER #因为我这里都是本地，所以需要修改会话名称
spring:
  application:
    name: auth-server
  thymeleaf:
    encoding: UTF-8
    mode: HTML5
    cache: false
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://127.0.0.1/auth-server?useUnicode=true&amp;characterEncoding=utf-8
    username: root
    password: root
    type: com.zaxxer.hikari.HikariDataSource
  jpa:
    show-sql: true
    hibernate:
      ddl-auto: update
      naming:
        physical-strategy: org.springframework.boot.orm.jpa.hibernate.SpringPhysicalNamingStrategy
        implicit-strategy: org.springframework.boot.orm.jpa.hibernate.SpringImplicitNamingStrategy
    database: mysql
    database-platform: org.hibernate.dialect.MySQL5InnoDBDialect
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:8670/eureka/ # 实际开发中建议使用域名的方式

5、下面我们重点来看配置部分（为了节约篇幅，我这里就省略了AuthDetailsService、DataSourceConfiguration、PasswordEncoderConfiguration具体的可以参考：Spring-Boot之Security安全管理-10）

（1）security配置

package com.cetc.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.password.PasswordEncoder;

@Configuration
@EnableWebSecurity
//开启注解的使用
@EnableGlobalMethodSecurity(prePostEnabled = true, securedEnabled = true)
public class SecurityConfiguration extends WebSecurityConfigurerAdapter {

    //认证过程
    @Autowired
    private AuthDetailsService authDetailsService;

    //加密方式
    @Autowired
    private PasswordEncoder passwordEncoder;

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(authDetailsService).passwordEncoder(passwordEncoder);
    }

    //基本没有什么太大的变化
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .csrf().disable()
            .exceptionHandling()
        .and()
            .authorizeRequests()
            .antMatchers("/login.html").permitAll()
            .anyRequest().authenticated()
        .and()
            .formLogin()
            //注意我这里使用的是自定义的登录页面
            .loginPage("/login.html")
            .loginProcessingUrl("/login")
        .and()
            .logout()
            .deleteCookies("SESSION_AUTH_SERVER");
    }

    //注意加入bean主要是在authentication server的配置需要使用
    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }
}

（2）Authorization配置

package com.cetc.config;

import com.zaxxer.hikari.HikariDataSource;
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.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.ClientDetailsService;
import org.springframework.security.oauth2.provider.client.JdbcClientDetailsService;
import org.springframework.security.oauth2.provider.token.TokenStore;
import org.springframework.security.oauth2.provider.token.store.JdbcTokenStore;

@Configuration
@EnableAuthorizationServer
public class AuthServerConfiguration extends AuthorizationServerConfigurerAdapter{

    @Autowired
    private AuthDetailsService authDetailsService;

    @Autowired
    private AuthenticationManager authenticationManager;

    @Autowired
    private ClientDetailsService clientDetailsService;

    @Autowired
    private TokenStore tokenStore;

    @Bean
    public ClientDetailsService clientDetailsService(HikariDataSource dataSource) {
        //使用数据库的配置方式
        return new JdbcClientDetailsService(dataSource);
    }

    @Bean
    public TokenStore tokenStore(HikariDataSource dataSource) {
        //token也使用数据的方式，后面会将JWT的使用方式
        return new JdbcTokenStore(dataSource);
    }

    @Override
    public void configure(AuthorizationServerSecurityConfigurer security) throws Exception {
        security
                //token获取方式
                .tokenKeyAccess("permitAll()")
                //检测加入权限
                .checkTokenAccess("isAuthenticated()")
                //允许表单认证
                .allowFormAuthenticationForClients();

    }

    @Override
    public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
        //这里就是具体的授权管理过程了
        clients.withClientDetails(clientDetailsService);
    }

    @Override
    public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
        endpoints
                //这里使用的认证方式为security配置方式
                .authenticationManager(authenticationManager)
                //提供get和post的认证方式
                .allowedTokenEndpointRequestMethods(HttpMethod.POST, HttpMethod.GET)
                //这里一定要配置userDetailsService，不然刷新token会出错，refresh_token
                .userDetailsService(authDetailsService)
                .tokenStore(tokenStore)
                //自定义认证页面
                .pathMapping("/oauth/confirm_access", "/oauth/confirm_access");
    }

}

其一：认证过程因为使用的是数据库，那么需要数据库的表格支持，这里也提供了为schema.sql，官网：https://github.com/spring-projects/spring-security-oauth/blob/2.0.x/spring-security-oauth2/src/test/resources/schema.sql

说明：由于官方的脚本适用于HSQL，所以我MYSQL这里脚本进行了修改，主要是主键改成255的长度，LONGVARBINARY改为BLOB

schema.sql：

-- used in tests that use HSQL
create table oauth_client_details (
  client_id VARCHAR(255) 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(255) PRIMARY KEY,
  user_name VARCHAR(256),
  client_id VARCHAR(256)
);

create table oauth_access_token (
  token_id VARCHAR(256),
  token BLOB,
  authentication_id VARCHAR(255) 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
);


-- customized oauth_client_details table
create table ClientDetails (
  appId VARCHAR(255) PRIMARY KEY,
  resourceIds VARCHAR(256),
  appSecret VARCHAR(256),
  scope VARCHAR(256),
  grantTypes VARCHAR(256),
  redirectUrl VARCHAR(256),
  authorities VARCHAR(256),
  access_token_validity INTEGER,
  refresh_token_validity INTEGER,
  additionalInformation VARCHAR(4096),
  autoApproveScopes VARCHAR(256)
);

其二：自定义认知页面编写AuthorizationController。

package com.cetc.web.authorization;

import org.springframework.security.oauth2.provider.AuthorizationRequest;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.SessionAttributes;

import javax.servlet.http.HttpServletRequest;
import java.util.Map;

@Controller
//注意一定要加@SessionAttributes("authorizationRequest")代表这是认证请求
@SessionAttributes("authorizationRequest")
public class AuthorizationController {

    @RequestMapping("/oauth/confirm_access")
    public String authorization(Map<String, ?> map, HttpServletRequest request) {
        AuthorizationRequest authorizationRequest = (AuthorizationRequest) map.get("authorizationRequest");
        request.setAttribute("clientId", authorizationRequest.getClientId());
        //这里的scope是一定要的，主要是认证需要传递的数据类型，需要scope
        request.setAttribute("scope", authorizationRequest.getScope());
        return "authorization";
    }
}

authorization.html

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>授权</title>
</head>
<body>
    <form th:action="${#servletContext.getContextPath()} + ‘/oauth/authorize‘" method="post">
        <p th:text="${clientId}"></p>
        <input type="hidden" name="user_oauth_approval" value="true">
        <input type="hidden" name="authorize" value="Authorize">
        <div th:each="item : ${scope}">
            <input type="hidden" th:name="‘scope.‘ + ${item}" value="true">
        </div>
        <button type="submit">同意授权</button>
    </form>
</body>
</html>

说明：这里的数据传输主要格式为：

Spring-Cloud之OAuth2开放授权-11

 　　注意：这里的socpe.ALL中的ALL为配置的范围。

（3）为了更好的结合jpa，我这里封装了OauthClientDetails，主要目的就是，方便操作。

package com.cetc.domain;

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "oauth_client_details")
public class OauthClientDetails {

    @Id
    private String clientId;

    private String resourceIds;

    private String clientSecret;

    private String scope;

    private String authorizedGrantTypes;

    private String webServerRedirectUri;

    private String authorities;

    private Integer accessTokenValidity;

    private Integer refreshTokenValidity;

    private String additionalInformation;

    private String autoapprove;

    public String getClientId() {
        return clientId;
    }

    public void setClientId(String clientId) {
        this.clientId = clientId;
    }

    public String getResourceIds() {
        return resourceIds;
    }

    public void setResourceIds(String resourceIds) {
        this.resourceIds = resourceIds;
    }

    public String getClientSecret() {
        return clientSecret;
    }

    public void setClientSecret(String clientSecret) {
        this.clientSecret = clientSecret;
    }

    public String getScope() {
        return scope;
    }

    public void setScope(String scope) {
        this.scope = scope;
    }

    public String getAuthorizedGrantTypes() {
        return authorizedGrantTypes;
    }

    public void setAuthorizedGrantTypes(String authorizedGrantTypes) {
        this.authorizedGrantTypes = authorizedGrantTypes;
    }

    public String getWebServerRedirectUri() {
        return webServerRedirectUri;
    }

    public void setWebServerRedirectUri(String webServerRedirectUri) {
        this.webServerRedirectUri = webServerRedirectUri;
    }

    public String getAuthorities() {
        return authorities;
    }

    public void setAuthorities(String authorities) {
        this.authorities = authorities;
    }

    public Integer getAccessTokenValidity() {
        return accessTokenValidity;
    }

    public void setAccessTokenValidity(Integer accessTokenValidity) {
        this.accessTokenValidity = accessTokenValidity;
    }

    public Integer getRefreshTokenValidity() {
        return refreshTokenValidity;
    }

    public void setRefreshTokenValidity(Integer refreshTokenValidity) {
        this.refreshTokenValidity = refreshTokenValidity;
    }

    public String getAdditionalInformation() {
        return additionalInformation;
    }

    public void setAdditionalInformation(String additionalInformation) {
        this.additionalInformation = additionalInformation;
    }

    public String getAutoapprove() {
        return autoapprove;
    }

    public void setAutoapprove(String autoapprove) {
        this.autoapprove = autoapprove;
    }
}

　　四、资源服务器Resource Server

1、目录结构：从结构上面来看，基本和Spring-Cloud之Feign声明式调用-4没有什么异同，所以我这里只讲核心点（ResourceServerConfiguration、application.yaml）。

Spring-Cloud之OAuth2开放授权-11

 　　2、先看需要的依赖

<dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <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>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>

3、ResourceServerConfiguration。资源服务器配置

package com.cetc.config;

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

@Configuration
@EnableResourceServer
public class ResourceServerConfiguration extends ResourceServerConfigurerAdapter{

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

说明：这里的认证在认证中心完成，所以这里只需要，配置拦截即可

4、application.yaml

server:
  port: 8695
spring:
  application:
    name: auth-resource
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:8670/eureka/ # 实际开发中建议使用域名的方式
security:
  oauth2:
    client:
      client-id: client
      client-secret: secret
      grant-type: authorization_code
      scope: ALL
      access-token-uri: http://127.0.0.1:8694/auth/oauth/token
      user-authorization-uri: http://127.0.0.1:8694/auth/oauth/authorize
    resource:
      id: auth-resource
      token-info-uri: http://127.0.0.1:8694/auth/oauth/check_token

说明：这里就仅仅加入了oauth2的认证配置。这里的参数主要是在授权服务器提供的授权，这里主要在数据里。我在授权的服务器的init中有加入初始化数据。

Spring-Cloud之OAuth2开放授权-11

 　　5、其他部分不再具体讲解了，如果存在不懂的地方可以参考：Spring-Cloud之Feign声明式调用-4

　　五、验证第三方客户端获取资源服务器提供的接口。（这里提供的接口为：/api/authResource/getPort）

1）启动项目：Eureka Server、Eureka Client、Auth Server、Auth Resource端口分别为8670、8673、8694、8695。

Spring-Cloud之OAuth2开放授权-11

 　　2）访问资源服务器的接口/api/authResource/getPort

Spring-Cloud之OAuth2开放授权-11

 　　说明：可以看出，直接访问时没有权限的。

3）前面测试访问时没有权限，主要是没有令牌。那我们接下来就是来获取令牌。前面也提到认证方式，这里有四种　

（1）授权码模式（authorization_code）

　　（2）简化模式（implicit）

　　（3）密码模式（password）

　　（4）客户端模式（client_credentials）

为了方便我在数据库，这几种方式都进行了配置

Spring-Cloud之OAuth2开放授权-11

 　　4）获取令牌

（1）授权码模式（authorization_code）

a、获取授权码

oauth/authorize?response_type=code&client_id=&redirect_uri=

本文：

http://127.0.0.1:8694/auth/oauth/authorize?response_type=code&client_id=client&redirect_uri=http://127.0.0.1:8695

Spring-Cloud之OAuth2开放授权-11

说明：从上面的操作来看，我们最后获得了一个授权码code=code=hkJfzA，这个授权码只能使用一次。

b、获取令牌

oauth/token?client_id=&client_secret=&grant_type=authorization_code&redirect_uri=&code=

本文：

http://127.0.0.1:8694/auth/oauth/token?client_id=client&client_secret=secret&grant_type=authorization_code&redirect_uri=http://127.0.0.1:8695&code=hkJfzA

Spring-Cloud之OAuth2开放授权-11

说明：这里我们通过授权码获取到了令牌和其他参数　

{
    "access_token": "a2a8069e-2423-4ae9-9ea0-27efdb688d0f",
    "token_type": "bearer",
    "refresh_token": "89cfeab9-5bb1-45d1-8258-68919d2f4da1",
    "expires_in": 43199,
    "scope": "ALL"
}
  • access_token：表示访问令牌，必选项。
  • token_type：表示令牌类型，该值大小写不敏感，必选项，可以是bearer类型或mac类型。
  • expires_in：表示过期时间，单位为秒。如果省略该参数，必须其他方式设置过期时间。
  • refresh_token：表示更新令牌，用来获取下一次的访问令牌，可选项。
  • scope：表示权限范围，如果与客户端申请的范围一致，此项可省略。

 　　（2）简化模式（implicit）

/oauth/authorize?response_type=token&client_id=&redirect_uri=

本文：

http://127.0.0.1:8694/auth/oauth/authorize?response_type=token&client_id=client&redirect_uri=http://127.0.0.1:8695

Spring-Cloud之OAuth2开放授权-11

可以看出最后得出的重定向加了一下数据

#access_token=a2a8069e-2423-4ae9-9ea0-27efdb688d0f&token_type=bearer&expires_in=42537&scope=ALL

是不是和授权码模式的一样，这里不做详情解释。

（3）密码模式（password）

/oauth/token?grant_type=password&client_id=&client_secret=&username=&password=

本文：

http://127.0.0.1:8694/auth/oauth/token?grant_type=password&client_id=client&client_secret=secret&username=admin&password=admin

Spring-Cloud之OAuth2开放授权-11

返回数据和授权码模式一样

（4）客户端模式（client_credentials）

/oauth/token?grant_type=client_credentials&client_id=&client_secret=

本文：

http://127.0.0.1:8694/auth/oauth/token?grant_type=client_credentials&client_id=client&client_secret=secret

Spring-Cloud之OAuth2开放授权-11

5）携带令牌（access_token）访问资源服务器，以授权码模式得出的结果为准。

Spring-Cloud之OAuth2开放授权-11

6）刷新令牌，通过上面的解释我们知道，令牌是会过期的，所以我们需要刷新令牌refresh_token为refresh_token的值

/oauth/token?grant_type=refresh_token&client_id=&client_secret=&refresh_token=

本文：

http://127.0.0.1:8694/auth/oauth/token?grant_type=refresh_token&client_id=client&client_secret=secret&refresh_token=89cfeab9-5bb1-45d1-8258-68919d2f4da1

Spring-Cloud之OAuth2开放授权-11

刷新后老的令牌就没有用了。

　　六、客户端，这里的客户端也是通过该授权服务器进行授权然后访问的资源服务器。

1、目录结构：基础结构和Spring-Cloud之Feign声明式调用-4类似

Spring-Cloud之OAuth2开放授权-11

 　　2、依赖

<dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <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>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>

3、application.yaml配置

server:
  port: 8696
  servlet:
    session:
      cookie:
        name: SESSION_AUTH_SSO #本地避免session冲突
spring:
  application:
    name: auth-soo
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:8670/eureka/ # 实际开发中建议使用域名的方式
security:
  oauth2:
    client:
      client-id: client_sso
      client-secret: secret_sso
      grant-type: authorization_code
      scope: ALL
      access-token-uri: http://127.0.0.1:8694/auth/oauth/token
      user-authorization-uri: http://127.0.0.1:8694/auth/oauth/authorize
    resource:
      token-info-uri: http://127.0.0.1:8694/auth/oauth/check_token

为了方便我这里重新加入了一套认证数据

Spring-Cloud之OAuth2开放授权-11

4、security配置

package com.cetc.config;

import org.springframework.boot.autoconfigure.security.oauth2.client.EnableOAuth2Sso;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

@Configuration
@EnableOAuth2Sso
public class SecurityConfiguration extends WebSecurityConfigurerAdapter{

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

5、因为我们是通过feign做的代理访问，那么直接访问受保护的资源肯定不行，那么就需要加入feign的拦截配置AuthSSOConfiguration

package com.cetc.config;

import feign.RequestInterceptor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.cloud.security.oauth2.client.feign.OAuth2FeignRequestInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.oauth2.client.OAuth2ClientContext;
import org.springframework.security.oauth2.client.OAuth2RestTemplate;
import org.springframework.security.oauth2.client.token.grant.code.AuthorizationCodeResourceDetails;

@Configuration
public class AuthSSOConfiguration {

    //获取认证的配置数据
    @Bean
    @ConfigurationProperties(prefix = "security.oauth2.client")
    public AuthorizationCodeResourceDetails authorizationCodeResourceDetails() {
        return new AuthorizationCodeResourceDetails();
    }

    @Autowired
    private AuthorizationCodeResourceDetails authorizationCodeResourceDetails;

    //这里使用他配置好的OAuth2ClientContext，这里有坑自己体会
    @Autowired
    @Qualifier("oauth2ClientContext")
    private OAuth2ClientContext oAuth2ClientContext;

    //配置请求拦截
    @Bean
    public RequestInterceptor requestInterceptor() {
        return new OAuth2FeignRequestInterceptor(oAuth2ClientContext, authorizationCodeResourceDetails);
    }

    //oauth2认证配置
    @Bean
    public OAuth2RestTemplate oAuth2RestTemplate() {
        return new OAuth2RestTemplate(authorizationCodeResourceDetails);
    }
}

6、提供接口/api/authSSO/getPort测试，启动auth-sso端口8696

Spring-Cloud之OAuth2开放授权-11

 　　测试：

Spring-Cloud之OAuth2开放授权-11

是不是感觉很简单，那我们来看一下实际的请求过程

Spring-Cloud之OAuth2开放授权-11

所以这个认证过程是通过上面那张图来实现的，这是spring提供了很多配置而已。通过程序去实现了这个过程。

八、总结：上面的过程我就不再说了，这里总结一下过程。简单一点，就是在分布式开发过程中，我们提供统一的认证/授权平台，把需要保护的资源加入认证中，当然也可以通过SSO（@EnableOAuth2Sso）的方式直接登录访问。资源服务器的目的在于可以提供第三方的访问需求比如现在的QQ授权、微信授权等。SSO的目的在于单点登录，做到登录一次，可以访问所有资源的目的。

九、本文源码地址：https://github.com/lilin409546297/spring-cloud/tree/master/oauth2

十、授权码模式详情编写可以参考：https://www.cnblogs.com/ll409546297/p/10396837.html

spring-cloud oauth

凯哥Java

凯哥Java

0 关注 0 粉丝 0 动态

关注 关注

相关推荐

java.lang.IllegalArgumentException: no server available 报错: 没有可用的服务器

报错信息:

melonjj 2020-08-18

Spring Cloud 对应 Spring Boot 版本

不注意，会让你走很长很长的套路。。。。

melonjj 2020-04-16

Nacos服务注册与发现

下载解压之后到nacos->bin->startup.cmd,直接双击运行即可。

ChainDestiny 2020-02-23

Turbine——Hystrix集群监控

Hystrix Turbine将每个服务Hystrix Dashboard数据进行了整合。Hystrix Turbine的使用非常简单，只需要引入相应的依赖和加上注解和配置就可以了。了解springcloud架构可以加求求：三五三六二四七二五九

马勒格彼得 2020-02-14

Spring-cloud之Eureka服务搭建、集群

eureka是Netfix的子模块之一也是核心模块，eureka有2个组件，一个eurekaServer，这个服务主要是用来定位服务以实现中间层服务器的负载平衡和故障转移。另外一个是是eurekaClient，是用来与server进行交互的，使服务之间的交

小鱿鱼 2020-02-10

Spring-Cloud组件eureka

eureka是Netflix的子模块之一，也是一个核心的模块，eureka里有2个组件，一个是EurekaServer 这个是用于定位服务以实现中间层服务器的负载平衡和故障转移，另一个便是EurekaClient 它是用于与Server交互的，可以使得交互

MicroBoy 2020-01-25

Spring-cloud微服务实战【三】：eureka注册中心（中）

回忆一下,在上一篇文章中,我们创建了两个springboot项目,并且在consumer项目中通过restTemplate进行HTTP通信,成功访问到了producer提供的接口,思考一下这样的实现方式有什么问题?什么是eureka注册中心?我们通过一张图

横云断岭 2020-01-19

spring-cloud 图片

whbing 2019-12-29

Spring-Cloud学习之Eureka集群搭建

上一篇文章讲解了如何搭建单个节点的eureka，这篇讲解如何搭建eureka集群，这里的集群还是本地不同的端口执行三个eureka，因为条件不要允许，没有三台电脑，所以大家将就一下吧，eureka集群的目的就是防止一个点故障导致，整个服务瘫痪的问题，成为单

方志朋 2019-12-21

Spring-Cloud之Eureka注册中心环境搭建（单节点）

服务启动时会生成服务的基本信息对象InstanceInfo，然后在启动时会register到服务治理中心。注册完成后会从服务治理中心拉取所有的服务信息，缓存在本地。如果服务治理中心在90s内没有收到一个服务的续约，就会认为服务已经挂了，会把服务注册信息删掉

Julywhj 2019-12-15

Zuul2.X网关实现服务熔断降级

<spring-boot.version>2.1.9.RELEASE</spring-boot.version>. <spring-cloud.version>Greenwich.SR4</spring-cloud

Julywhj 2019-12-12

nacos服务注册与发现及服务配置实现

Nacos 提供了一组简单易用的特性集，可快速实现动态服务发现、服务配置、服务元数据及流量管理。更敏捷和容易地构建、交付和管理微服务平台。

neweastsun 2019-12-03

spring-cloud-kubernetes官方demo运行实战

官方提供了简单的demo用于快速了解spring-cloud-kubernetes，但是成功运行此demo需要做一些设置和修改，这也是此文的意义所在，接下来我们一起实战这个demo；上面提到的linux、minikube、java、maven，请确保已全部

技术积累LZ 2019-11-03

Spring-Cloud的相关资料

Spring Cloud 学习笔记（一）——入门、特征、配置

qingjiuquan 2017-11-13

Hystrix【入门】

--加上上面的公共依赖--> <dependencies>

方志朋 2019-10-21

spring-cloud分布式接口调用提示LinedHashMap的类型转换错误解决方法

但是在正常java代码调用过程中，得到的类型是LinedHashMap，强制转换类型是就提示类型转换失败，抛异常了。然后把Object类型转换为<T>的泛型，在接口和后台api的实现方法上同样指定一个返回的数据类型，再一调用，居然通过了，输出的

JudeJoo 2019-09-29

【spring cloud hoxton】Ribbon 真的能被 spring-cloud-loadbalancer 替代吗

早上刷圈看到 Spring Cloud Hoxton.M2 Released 的消息，随手发布到了我的知识星球，过了会有个朋友过来如下问题。抽取半天时间学习spring-cloud-loadbalancer 的源码，整理出此文总结。Spring Cloud

0xZzzz 2019-09-08

springboot配置文件抽离 git管理统 配置中心详解

springboot配置文件抽离，便于服务器读取对应配置文件，避免项目频繁更改配置文件，影响项目的调试与发布

xlklmy 2019-09-02

springcloud的feign访问方式1.4.1和2.0.1兼容问题，接入服务《二》

<artifactId>spring-cloud-starter-feign</artifactId>. <!-- 引入接入包 -->. <artifactId>spring-cloud-starter-op

爱莲说 2018-10-19

SpringCloud笔记

spring cloud面向开发人员，对分布式系统从编程模型上提供了强大的支持。可以说是分布式系统解决方案的全家桶，极大地降低了开发与构建分布式系统的门槛。Eureka服务注册发现统一配置中心Spring Cloud Stream异步调用Zuul服务网关H

cooldatabase 2019-07-01
凯哥Java

凯哥Java

W3CSchool教程
HTML 教程
CSS 教程
Bootstrap 教程
Javascript 教程
jQuery 教程
后端教程
C 教程
Java 教程
PHP 教程
Python 教程
Go 教程
移动开发
Android 教程
Swift 教程
Kotlin 教程
jQuery Mobile 教程
ionic 教程
关于我们
新闻动态
联系方式
招聘英才
安科实验室
帮助与反馈

安科网(Ancii)，中国第一极客网

Copyright © 2013 - 2019 Ancii.com

京ICP备18063983号 京公网安备11010802014868号