Spring Security OAuth2登录

已于 2023-03-09 19:09:34 修改
阅读量3.9k 收藏 4
点赞数 1
分类专栏： Spring Security OAuth2 文章标签： spring java spring boot
于 2022-07-25 20:51:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/new_ord/article/details/125983125
版权

Spring Security OAuth2登录

概述

OAuth 2.0 不是身份认证协议。

什么是身份认证？身份认证是解决“你是谁？”的问题。身份认证会告诉应用当前用户是谁以及是否在使用此应用。实际中可能还会告诉你用户的名称，邮箱，手机号等。

如果对 OAuth 2.0 进行扩展，使得授权服务器和受保护资源发出的信息能够传达与用户以及他们的身份认证上下文有关的信息，我们就可以为客户端提供用于用户安全登录的所有信息。这种基于OAuth 2.0授权协议而构建的身份认证方式主要优点：

  • 用户在授权服务器上执行身份认证， 最终用户的原始凭据不会通过 OAuth 2.0 协议传送到客户端应用。
  • 允许用户在运行时执行同意决策。
  • 用户还可以将其他受保护 API 与他的身份信息的访问权限一起授权出去。通过一个调用，应用就可以知道用户是否已登录，如何称呼用户，用户的手机号，邮箱等。

本文我们将通过OAuth 2.0 授权码模式安全的传递授权服务用户信息，并登录到客户端应用。

本文您将学到：

  • 搭建基本的授权服务和客户端服务

  • 自定义授权服务器访问令牌，添加角色信息

  • 自定义授权服务器用户信息端点

  • 客户端服务使用GrantedAuthoritiesMapper做权限映射

  • 客户端服务自定义OAuth2UserService实现解析多层Json数据

OAuth2授权服务器

本节我们将使用Spring Authorization Server搭建一个授权服务器。除此之外我们还将会自定义access_token和自定义用户信息端点。

maven
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-security</artifactId>
  <version>2.6.7</version>
</dependency>

<dependency>
  <groupId>org.springframework.security</groupId>
  <artifactId>spring-security-oauth2-authorization-server</artifactId>
  <version>0.3.1</version>
</dependency>

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-web</artifactId>
  <version>2.6.7</version>
</dependency>
配置

首先通过application.yml配置服务端口8080:

server:
  port: 8080

接下来我们将创建OAuth2ServerConfig配置类，定义OAuth2 授权服务所需特定Bean。首先我们注册一个OAuth2客户端:

@Bean
public RegisteredClientRepository registeredClientRepository() {
  RegisteredClient registeredClient = RegisteredClient.withId(UUID.randomUUID().toString())
    .clientId("relive-client")
    .clientSecret("{noop}relive-client")
    .clientAuthenticationMethods(s -> {
      s.add(ClientAuthenticationMethod.CLIENT_SECRET_POST);
      s.add(ClientAuthenticationMethod.CLIENT_SECRET_BASIC);
    })
    .authorizationGrantType(AuthorizationGrantType.AUTHORIZATION_CODE)
    .authorizationGrantType(AuthorizationGrantType.REFRESH_TOKEN)
    .redirectUri("http://127.0.0.1:8070/login/oauth2/code/messaging-client-authorization-code")
    .scope(OidcScopes.PROFILE)
    .clientSettings(ClientSettings.builder()
                    .requireAuthorizationConsent(true)
                    .requireProofKey(false)
                    .build())
    .tokenSettings(TokenSettings.builder()
                   .accessTokenFormat(OAuth2TokenFormat.SELF_CONTAINED) 
                   .idTokenSignatureAlgorithm(SignatureAlgorithm.RS256)/
                   .accessTokenTimeToLive(Duration.ofSeconds(30 * 60))
                   .refreshTokenTimeToLive(Duration.ofSeconds(60 * 60))
                   .reuseRefreshTokens(true)
                   .build())
    .build();
  return new InMemoryRegisteredClientRepository(registeredClient);
}

以上将OAuth2客户端存储在内存中，如果您需要使用数据库持久化，请参考文章将JWT与Spring Security OAuth2结合使用。指定OAuth2客户端信息如下：

  • clientId: relive-client
  • clientSecret: relive-client
  • redirectUri: http://127.0.0.1:8070/login/oauth2/code/messaging-client-authorization-code
  • scope: profile

接下来让我们配置OAuth2授权服务其他默认配置，并对未认证的授权请求重定向到登录页面：

@Bean
@Order(Ordered.HIGHEST_PRECEDENCE)
public SecurityFilterChain authorizationServerSecurityFilterChain(HttpSecurity http) throws Exception {
  OAuth2AuthorizationServerConfiguration.applyDefaultSecurity(http);

  return http
    .exceptionHandling(exceptions -> exceptions.
                       authenticationEntryPoint(new LoginUrlAuthenticationEntryPoint("/login")))
    .build();
}

授权服务器token令牌格式使用JWT RFC 7519，所以我们需要用于令牌的签名密钥，让我们生成一个RSA密钥：

@Bean
public JWKSource<SecurityContext> jwkSource() {
  RSAKey rsaKey = Jwks.generateRsa();
  JWKSet jwkSet = new JWKSet(rsaKey);
  return (jwkSelector, securityContext) -> jwkSelector.select(jwkSet);
}

static class Jwks {

  private Jwks() {
  }

  public static RSAKey generateRsa() {
    KeyPair keyPair = KeyGeneratorUtils.generateRsaKey();
    RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
    RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
    return new RSAKey.Builder(publicKey)
      .privateKey(privateKey)
      .keyID(UUID.randomUUID().toString())
      .build();
  }
}

static class KeyGeneratorUtils {

  private KeyGeneratorUtils() {
  }

  static KeyPair generateRsaKey() {
    KeyPair keyPair;
    try {
      KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
      keyPairGenerator.initialize(2048);
      keyPair = keyPairGenerator.generateKeyPair();
    } catch (Exception ex) {
      throw new IllegalStateException(ex);
    }
    return keyPair;
  }
}

接下来我们将自定义access_token 访问令牌，并在令牌中添加角色信息：

@Configuration(proxyBeanMethods = false)
public class AccessTokenCustomizerConfig {

    @Bean
    public OAuth2TokenCustomizer<JwtEncodingContext> tokenCustomizer() {
        return (context) -> {
            if (OAuth2TokenType.ACCESS_TOKEN.equals(context.getTokenType())) {
                context.getClaims().claims(claim -> {
                    claim.put("role", context.getPrincipal().getAuthorities().stream()
                            .map(GrantedAuthority::getAuthority).collect(Collectors.toSet()));
                });
            }
        };
    }
}

可以看到Spring Security为我们提供了OAuth2TokenCustomizer用于扩展令牌信息，我们从OAuth2TokenContext获取到当前用户信息，并从中提取Authorities权限信息添加到JWT的claim。


下面我们将创建Spring Security配置类，配置授权服务基本的认证能力。

@Configuration(proxyBeanMethods = false)
public class DefaultSecurityConfig {

    @Bean
    public SecurityFilterChain defaultSecurityFilterChain(HttpSecurity http) throws Exception {
        http.authorizeRequests()
                .antMatchers("/userInfo")
                .access("hasAnyAuthority('SCOPE_profile')")
                .mvcMatchers("/userInfo")
                .access("hasAuthority('SCOPE_profile')")
                .anyRequest().authenticated()
                .and()
                .formLogin(Customizer.withDefaults())
                .oauth2ResourceServer(OAuth2ResourceServerConfigurer::jwt);
        return http.build();
    }

    @Bean
    public JwtDecoder jwtDecoder(JWKSource<SecurityContext> jwkSource) {
        return OAuth2AuthorizationServerConfiguration.jwtDecoder(jwkSource);
    }

    @Bean
    public UserDetailsService users() {
        UserDetails user = User.withDefaultPasswordEncoder()
                .username("admin")
                .password("password")
                .roles("ADMIN")
                .build();
        return new InMemoryUserDetailsManager(user);
    }
}

在上述配置类中，我们做了以下几件事。1.启用Form认证方式；2.配置登录用户名密码；3.使用oauth2ResourceServer()配置JWT验证，并声明JwtDecoder；4.保护/userInfo端点需要profile权限进行访问。


此时我们还需要创建Controller类，用于提供给OAuth2客户端服务获取用户信息：

@RestController
public class UserInfoController {

    @PostMapping("/userInfo")
    public Map<String, Object> getUserInfo(@AuthenticationPrincipal Jwt jwt) {
        return Collections.singletonMap("data", jwt.getClaims());
    }
}

我们将用户信息使用以下JSON格式返回：

{
  "data":{
    "sub":"admin"
    ...
  }
}

OAuth2客户端服务

本节将使用Spring Security配置OAuth2客户端登录；并且我们将使用GrantedAuthoritiesMapper映射权限信息；还将通过自定义实现OAuth2UserService替换原有DefaultOAuth2UserService，用于解析多层JSON 用户信息数据。

maven
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-web</artifactId>
  <version>2.6.7</version>
</dependency>
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-security</artifactId>
  <version>2.6.7</version>
</dependency>
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-oauth2-client</artifactId>
  <version>2.6.7</version>  
</dependency>

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-thymeleaf</artifactId>
  <version>2.6.7</version>  
</dependency>
配置

首先我们指定客户端服务端口号8070,并配置OAuth2客户端相关信息：

server:
  port: 8070
  servlet:
    session:
      cookie:
        name: CLIENT-SESSION

spring:
  security:
    oauth2:
      client:
        registration:
          messaging-client-authorization-code:
            provider: client-provider
            client-id: relive-client
            client-secret: relive-client
            authorization-grant-type: authorization_code
            redirect-uri: "{baseUrl}/login/oauth2/code/{registrationId}"
            scope: profile
            client-name: messaging-client-authorization-code
        provider:
          client-provider:
            authorization-uri: http://127.0.0.1:8080/oauth2/authorize
            token-uri: http://127.0.0.1:8080/oauth2/token
            user-info-uri: http://127.0.0.1:8080/userInfo
            user-name-attribute: data.sub
            user-info-authentication-method: form

接下来配置Spring Security相关Bean，首先我们先启用Form表单认证和OAuth2登录能力：

@Bean
SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
  http.authorizeHttpRequests()
    .anyRequest()
    .authenticated()
    .and()
    .formLogin(from -> {
      from.defaultSuccessUrl("/home");
    })
    .oauth2Login(Customizer.withDefaults())
    .csrf().disable();
  return http.build();
}

这里我们指定认证成功后重定向到/home路径下。


下面我们使用GrantedAuthoritiesMapper映射用户权限：

@Bean
GrantedAuthoritiesMapper userAuthoritiesMapper() {
  //角色映射关系，授权服务器ADMIN角色对应客户端OPERATION角色
  Map<String, String> roleMapping = new HashMap<>();
  roleMapping.put("ROLE_ADMIN", "ROLE_OPERATION");
  return (authorities) -> {
    Set<GrantedAuthority> mappedAuthorities = new HashSet<>();
    authorities.forEach(authority -> {
      if (OAuth2UserAuthority.class.isInstance(authority)) {
        OAuth2UserAuthority oauth2UserAuthority = (OAuth2UserAuthority) authority;
        Map<String, Object> userAttributes = oauth2UserAuthority.getAttributes();
        List<String> role = (List) userAttributes.get("role");
        role.stream().map(roleMapping::get)
          .filter(StringUtils::hasText)
          .map(SimpleGrantedAuthority::new)
          .forEach(mappedAuthorities::add);
      }
    });
    return mappedAuthorities;
  };
}

上述将OAuth2授权服务ADMIN角色映射为客户端角色OPERATION。当然你同样可以扩展为数据库操作，那么需要你维护授权服务角色与客户端服务角色映射表，这里将不展开。

GrantedAuthoritiesMapper作为权限映射器在OAuth2登录，CAS登录，SAML和LDAP多方使用。

GrantedAuthoritiesMapper在OAuth2LoginAuthenticationProvider中源码如下：

@Override
public Authentication authenticate(Authentication authentication) throws AuthenticationException {
    OAuth2LoginAuthenticationToken loginAuthenticationToken = (OAuth2LoginAuthenticationToken) authentication;
    //...省略部分源码
  
    /* map authorities */
    Collection<? extends GrantedAuthority> mappedAuthorities = this.authoritiesMapper
      .mapAuthorities(oauth2User.getAuthorities());
    /* map authorities */
  
    OAuth2LoginAuthenticationToken authenticationResult = new OAuth2LoginAuthenticationToken(
      loginAuthenticationToken.getClientRegistration(), loginAuthenticationToken.getAuthorizationExchange(),
      oauth2User, mappedAuthorities, accessToken, authorizationCodeAuthenticationToken.getRefreshToken());
    authenticationResult.setDetails(loginAuthenticationToken.getDetails());
    return authenticationResult;
}

所以当我们自定义实现GrantedAuthoritiesMapper后，OAuth2 登录成功后将映射后的权限信息存储在认证信息Authentication的子类OAuth2LoginAuthenticationToken中，在后续流程中需要时获取。


接下来将实现OAuth2UserService自定义DefaultJsonOAuth2UserService类。当然Spring Security提供了DefaultOAuth2UserService，那么为什么不使用它呢？原因很简单，首先让我们回顾授权服务器返回用户信息格式：

{
  "data":{
    "sub":"admin"
    ...
  }
}

不错，用户信息嵌套data字段中，而DefaultOAuth2UserService处理用户信息响应时并没有处理这个格式，以下是DefaultOAuth2UserService源码：

public OAuth2User loadUser(OAuth2UserRequest userRequest) throws OAuth2AuthenticationException {
        Assert.notNull(userRequest, "userRequest cannot be null");
        if (!StringUtils.hasText(userRequest.getClientRegistration().getProviderDetails().getUserInfoEndpoint().getUri())) {
            OAuth2Error oauth2Error = new OAuth2Error("missing_user_info_uri", "Missing required UserInfo Uri in UserInfoEndpoint for Client Registration: " + userRequest.getClientRegistration().getRegistrationId(), (String)null);
            throw new OAuth2AuthenticationException(oauth2Error, oauth2Error.toString());
        } else {
            String userNameAttributeName = userRequest.getClientRegistration().getProviderDetails().getUserInfoEndpoint().getUserNameAttributeName();
            if (!StringUtils.hasText(userNameAttributeName)) {
                OAuth2Error oauth2Error = new OAuth2Error("missing_user_name_attribute", "Missing required \"user name\" attribute name in UserInfoEndpoint for Client Registration: " + userRequest.getClientRegistration().getRegistrationId(), (String)null);
                throw new OAuth2AuthenticationException(oauth2Error, oauth2Error.toString());
            } else {
                RequestEntity<?> request = (RequestEntity)this.requestEntityConverter.convert(userRequest);
               /* 获取用户信息 */  
              ResponseEntity<Map<String, Object>> response = this.getResponse(userRequest, request);
                //在这里直接获取响应体信息，默认此userAttributes包含相关用户信息，并没有解析多层JSON
                Map<String, Object> userAttributes = (Map)response.getBody();
               /* 获取用户信息 */  
                Set<GrantedAuthority> authorities = new LinkedHashSet();
                authorities.add(new OAuth2UserAuthority(userAttributes));
                OAuth2AccessToken token = userRequest.getAccessToken();
                Iterator var8 = token.getScopes().iterator();

                while(var8.hasNext()) {
                    String authority = (String)var8.next();
                    authorities.add(new SimpleGrantedAuthority("SCOPE_" + authority));
                }

                return new DefaultOAuth2User(authorities, userAttributes, userNameAttributeName);
            }
        }
    }

而最后创建DefaultOAuth2User时，你可能会收到以下错误信息

Missing attribute 'sub' in attributes

通过上面源码，Spring Security 所希望返回的用户信息格式：

{
  "sub":"admin",
  ...
}

但是实际中，我们开发时通常会统一返回响应格式。例如：

{
  "code":200,
  "message":"success",
  "data":{
    "sub":"admin",
    ...
  }
}

下面我们是我们通过以userNameAttributeName以 . 为分割符，提取用户信息实现，以下只展示部分代码，其余代码和DefaultOAuth2UserServicey源码相同。

首先我们新建工具类JsonHelper用于解析Json

@Slf4j
public class JsonHelper {
    private static final JsonHelper.MapTypeReference MAP_TYPE = new JsonHelper.MapTypeReference();

    private static ObjectMapper mapper;

    private JsonHelper() {
    }

    static {
        mapper = new ObjectMapper();
        mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    }

    public static JsonNode getFirstNode(final JsonNode node, final String path) {
        JsonNode resultNode = null;
        if (path != null) {
            resultNode = getElement(node, path);
        }
        return resultNode;
    }

    public static JsonNode getElement(final JsonNode json, final String name) {
        if (json != null && name != null) {
            JsonNode node = json;
            for (String nodeName : name.split("\\.")) {
                if (node != null) {
                    if (nodeName.matches("\\d+")) {
                        node = node.get(Integer.parseInt(nodeName));
                    } else {
                        node = node.get(nodeName);
                    }
                }
            }
            if (node != null) {
                return node;
            }
        }
        return null;
    }


    public static Map<String, Object> parseMap(String json) {
        try {
            return mapper.readValue(json, MAP_TYPE);
        } catch (JsonProcessingException e) {
            log.error("Cannot convert json to map");
        }
        return null;
    }

    private static class MapTypeReference extends TypeReference<Map<String, Object>> {
        private MapTypeReference() {
        }
    }
}

新建DefaultJsonOAuth2UserService实现OAuth2UserService，添加多层JSON提取用户信息逻辑：

public class DefaultJsonOAuth2UserService implements OAuth2UserService<OAuth2UserRequest, OAuth2User> {
  
    //...
  
    @Override
    public OAuth2User loadUser(OAuth2UserRequest userRequest) throws OAuth2AuthenticationException {
        //...省略部分代码
        RequestEntity<?> request = this.requestEntityConverter.convert(userRequest);
        ResponseEntity<JsonNode> response = getResponse(userRequest, request);
        JsonNode responseBody = response.getBody();

        //多层JSON提取用户信息属性
        Map<String, Object> userAttributes = new HashMap<>();
        if (userNameAttributeName.contains(".")) {
          String firstNodePath = userNameAttributeName.substring(0, userNameAttributeName.lastIndexOf("."));
          userAttributes = this.extractUserAttribute(responseBody, firstNodePath);
          userNameAttributeName = userNameAttributeName.substring(firstNodePath.length() + 1);
        } else {
          userAttributes = JsonHelper.parseMap(responseBody.toString());
        }

        //...省略部分代码
    }
}

如您需要参考详细代码，请查阅文末源码链接获取。


最后我们创建Controller类，使用thymeleaf引擎构建首页信息，不同权限信息看到首页列表结果不同：

@Controller
public class HomeController {

    private static Map<String, List<String>> articles = new HashMap<>();

    static {
        articles.put("ROLE_OPERATION", Arrays.asList("Java"));
        articles.put("ROLE_SYSTEM", Arrays.asList("Java", "Python", "C++"));
    }

    @GetMapping("/home")
    public String home(Authentication authentication, Model model) {
        String authority = authentication.getAuthorities().iterator().next().getAuthority();
        model.addAttribute("articles", articles.get(authority));
        return "home";
    }
}

测试

我们启动服务后，访问http://127.0.0.1:8070/login， 登录成功后，您将会看到：

在这里插入图片描述

之后我们退出登录，使用OAuth2 方式登录，您将会看到不同信息：

在这里插入图片描述

结论

我们使用OAuth2.0 授权协议上构建身份认证证明是可行的。但是我们不能忽略在这之间的陷阱。

  1. 令牌本身并不传递有关身份认证事件的信息。令牌可能是直接颁发给客户端的，使用的是无须用户交互的 OAuth 2.0 客户端凭据模式。

  2. 客户端都无法从访问令牌中得到关于用户及其登录状态的信息。OAuth 2.0 访问令牌的目标受众是资源服务器。（在本文中我们使用JWT访问令牌，通过自定义访问令牌信息使客户端服务获取用户权限等信息，但是OAuth2.0 协议中并没有定义访问令牌格式，我们仅是使用了JWT的特性来做到这一点。）

  3. 客户端可以出示访问令牌给资源服务获取用户信息，所以很容易就认为只要拥有一个有效的访问令牌，就能证明用户已登录，这一思路仅在某些情况下是正确的，即用户在授权服务器上完成身份认证，刚生成访问令牌的时候。（因为访问令牌有效期可能远长与身份认证会话有效期）

  4. 基于OAuth2.0的用户信息API的最大问题是，不同身份提供者实现用户信息API必然不同。用户的唯一标识可能是“user_id"，也可能是“sub”。

所以我们需要统一的OAuth2.0为基础的标准身份认证协议。OpenID Connect 是一个开放标准，它定义了一种使用 OAuth 2.0 执行用户身份认证的互通方式。这将在后续文章中介绍它。

与往常一样，本文中使用的源代码可在 GitHub 上获得。

ReLive27
关注
专栏目录
SpringSecurity OAuth2实现账户登录
aa731679676的博客
04-20 1412
项目说明 使用Spring Security搭建一个用户登录平台，请求后返回token完成认证授权 针对于password模式 技术栈 Springboot Springsecurity Mybatis Mybatis-Plus POM <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId&gt
Spring Security OAuth2 统一登录
算法之道
04-28 1134
Spring Security OAuth2 是一个在 Spring Security 框架基础上构建的 OAuth2 授权服务器和资源服务器的扩展库。它提供了一套功能强大的工具和组件，用于实现 OAuth2 协议中的授权流程、令牌管理和访问控制。
使用自定义的加密和密钥进行登录，jwt和spring security 干货全代码
最新发布
trench的博客
07-23 115
使用了自定义的加密方式去验证。
15 Spring Security OAuth2登录（三方登录）
Markix的博客
10-28 2851
OAuth2可以用来实现 OAuth2登录（三方登录）。在OAuth2登录的场景中，用户信息则是"资源"！ Spring Security 实现了 OAuth2登录功能。实现原理是：Client获取用户授权，得到令牌，通过令牌，获取用户信息（资源）。再在本地构建用户登录认证信息，维持用户会话状态，以此达到登录的目的。
大白话唠唠 Oauth2 与授权认证的那些事儿！
石杉的架构笔记
11-26 1395
我的新课《C2C 电商系统微服务架构120天实战训练营》在公众号儒猿技术窝上线了，感兴趣的同学，可以长按扫描下方二维码了解课程详情：课程大纲请参见文末出处：https://kefeng....
Spring Cloud云架构 - SSO单点登录之OAuth2.0登录认证(1)
weixin_33688840的博客
12-18 701
之前写了很多关于spring cloud的文章，今天我们对OAuth2.0的整合方式做一下笔记，首先我从网上找了一些关于OAuth2.0的一些基础知识点，帮助大家回顾一下知识点： 一、oauth中的角色 client：调用资源服务器API的应用 Oauth 2.0 Provider：包括Authorization Server和Resource Server （1）Authorization Se...
spring-oauth2-login
02-23
spring-oauth2-login
Spring Security OAuth2 实现登录互踢的示例代码
08-19
Spring Security OAuth2 实现登录互踢的示例代码 Spring Security OAuth2 是一个基于 OAuth2 协议的身份验证框架，提供了丰富的身份验证机制和授权机制。本文主要介绍了 Spring Security OAuth2 实现登录互踢的示例...
Spring Security OAuth2集成短信验证码登录以及第三方登录
08-27
在实现集成登录认证组件时，我们需要了解OAuth2.0认证体系、SpringBoot、SpringSecurity以及Spring Cloud等相关知识。同时，我们还需要了解如何定义拦截器、如何在拦截的通知进行预处理、如何在UserDetailService....
Spring Security Oauth2.0 实现短信验证码登录示例
08-28
Spring Security Oauth2.0 实现短信验证码登录示例 本篇文章主要介绍了 Spring Security Oauth2.0 实现短信验证码登录示例，具有一定的参考价值。下面是该示例的详细知识点解释： 一、Spring Security Oauth2.0 ...
springsecurity+oauth2+jwt实现单点登录demo
06-06
该资源是springsecurity+oauth2+jwt实现的单点登录demo，模式为授权码模式，实现自定义登录页面和自定义授权页面。应用数据存在内存中或者存在数据库中（附带数据库表结构），token存储分为数据库或者Redis。demo...
Spring Security OAuth2 Provider 之 第三方登录简单演示
05-01
NULL 博文链接：https://rensanning.iteye.com/blog/2386309
Spring Security OAuth过期的解决方法
09-07
Spring Security 5.x引入了对OAuth2和OpenID Connect 1.0的支持，这意味着你可以直接在框架内实现OAuth2的功能，包括资源服务器、客户端和身份验证服务器。这有助于减少混乱并提供更一致的体验。 4. **移除过时的...
基于SpringSecurityOAuth2实现单点登录, 简单示例用于学习SpringSecurityOAuth2. 解决了遇到的所有SpringSecurityOAuth2的坑
神尐破
09-11 1760
OAuth（开放授权）是一个开放标准，允许用户授权第三方应用访问他们存储在另外的服务提供者上的信息，而不需要将用户名和密码提供给第三方移动应用或分享他们数据的所有内容。这是一个标准， spring也推荐也默认采用这种登录授权的模式， 所以跟着spring来，方向不会错。OAuth 的核心就是向第三方应用颁发令牌，资源服务器可以向客户端颁发令牌。客户端通过令牌，去请求数据。OAuth 2.0 规定了四种获得令牌的流程：authorization code（授权码模式）implicit（简化模式）
Spring Security OAuth2 单点登录
weixin_42073629的博客
04-05 3944
1. 概述 在前面的文章中，我们学习了 Spring Security OAuth 的简单使用。 《Spring Security OAuth2 入门》 《Spring Security OAuth2 存储器》 今天我们来搞波“大”的，通过 Spring Security OAuth 实现一个单点登录的功能。 可能会有女粉丝不太了解单点登录是什么？单点登录，英文是Single Sign On，简称为SSO，指的是当有多个系统需要登录时，用户只需要登录一个统一的登录系统，而无需在多个系统重复登录。..
SpringSecurity+OAUTH2集成多种登录方式
无望丶
04-11 3422
Authorization Code（授权码模式）：授权码模式， 通过授权码获取token进行资源访问。Implicit（简化模式）：用于移动应用程序或 Web 应用程序，这种模式比授权码模式少了code环节，回调url直接附带token。Resource Owner Password Credentials（密码模式）：资源所有者和客户端之间具有高度信任时（例如，客户端是设备的操作系统的一部分，或者是一个高度特权应用程序， 比如APP， 自研终端等），因为client可能存储用户密码。
Spring Security OAuth2单点登录
22333
05-07 4170
springSecurity入门以及点单登录实现
登录模块 用户认证 SpringSecurity +Oauth2+Jwt
m0_46690280的博客
10-14 7175
SpringSecurity Oauth2 jwtSpringSecurity Oauth2 jwt1 用户认证分析1.1 单点登录1.2 第三方账号登录2 认证解决方案2.1 单点登录技术方案2.2 第三方登录技术方案2.2.1 Oauth2认证流程2.2.2 Oauth2在项目的应用2.3 Spring security Oauth2认证解决方案3 Jwt令牌回顾3.1 令牌结构3.2 生成私钥公钥3.3 基于私钥生成jwt令牌3.3.1导入认证服务3.3.2 认证服务中创建测试类3.4 基于公
插件学习笔记：Oauth2.0+SpringSecurity实现单点登录
Mactavish_Cui的博客
02-25 2700
概念 单点登录(Single Sign On, SSO)，指的是登录一次即可访问信任的多个服务，这在微服务的架构中是十分重要的，也是业务整合的解决方案之一。在之前的学习里学了基于SpringSecurity+Oauth2.0实现的SSO，也有基于CAS实现的SSO，在本篇文章中将SSO的Oauth2.0+SpringSecurity实现单独剥离出来，给出详细的搭建步骤。在CAS实现单点登录的章节中会有二者的对比。 系统架构 下图给出了基于SpringSecurity于Oatuth2.0的单点登录解决方案，该
Spring Security OAuth2授权流程详解
"spring-security-oauth2 是一个基于Spring Security的实现OAuth2协议的开源库，用于构建安全的、授权的服务端和客户端应用。这个库详细介绍了OAuth2的四种授权方式：AuthorizationCode，Implicit，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值