SpringSecurity最新学习，spring-security-oauth2-authorization-server【spring-security-oauth2升级】

于 2024-07-03 07:53:02 发布
阅读量706 收藏 19
点赞数 22
分类专栏： # SpringSecurity 文章标签： spring 学习 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Tomwildboar/article/details/140059052
版权

视频学习地址： https://www.bilibili.com/video/BV1Wy411B7xK


这篇文章主要是简单的进行一个SpringSecurity的入门，基于它提供一个客户端的oauth2的认证，包括JWT和Opaque，也可以看成是spring-security-oauth2的升级，因为spring-security-oauth2已不再维护了。


效果展示

在这里插入图片描述
在这里插入图片描述


认证规范有很多，这里我用的是客户端认证


一、理论


假如最终目的是请求 /hello 接口，那基于oauth2的访问流程看起来就是这样的

在这里插入图片描述


JWT和Opaque

简单理解成 Jwt是公开的，直接在线就可以解析看到里面的数据（但不能修改里面的数据，所以它是安全的），Opaque一个不透明的token，在看起来就是一个字符串


二、服务端


2-1、依赖引入


<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.security</groupId>
    <artifactId>spring-security-oauth2-authorization-server</artifactId>
    <version>0.4.1</version>
</dependency>

SpringBoot的版本用的是 2.7.17


2-2、一个简单的OpaqueToken生成


配置文件添加

对应源码目录： com.xdx97.config.oauth1

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.oauth2.core.AuthorizationGrantType;
import org.springframework.security.oauth2.core.ClientAuthenticationMethod;
import org.springframework.security.oauth2.jose.jws.SignatureAlgorithm;
import org.springframework.security.oauth2.server.authorization.client.InMemoryRegisteredClientRepository;
import org.springframework.security.oauth2.server.authorization.client.RegisteredClient;
import org.springframework.security.oauth2.server.authorization.client.RegisteredClientRepository;
import org.springframework.security.oauth2.server.authorization.config.annotation.web.configurers.OAuth2AuthorizationServerConfigurer;
import org.springframework.security.oauth2.server.authorization.settings.AuthorizationServerSettings;
import org.springframework.security.oauth2.server.authorization.settings.ClientSettings;
import org.springframework.security.oauth2.server.authorization.settings.OAuth2TokenFormat;
import org.springframework.security.oauth2.server.authorization.settings.TokenSettings;
import org.springframework.security.web.SecurityFilterChain;

import java.time.Duration;
import java.util.UUID;

/**
 * oauth2服务器配置
 */
@Configuration
public class OpaqueTokenSimpleConfig {


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


        http.apply(new OAuth2AuthorizationServerConfigurer());

        http.csrf().disable()
                .authorizeHttpRequests(authorizeRequests ->
                    authorizeRequests
                    .antMatchers("/oauth2/*").permitAll()
                    .antMatchers("/introspect/*").permitAll()
                    .anyRequest().authenticated()
                )
                .formLogin();

        return http.build();
    }

    @Bean
    public RegisteredClientRepository registeredClientRepository() {


        RegisteredClient registeredClient = RegisteredClient.withId(UUID.randomUUID().toString())
                .clientId("xdx97")
                .clientSecret("{noop}xdx97")
                .clientAuthenticationMethods(authMethods -> {
                    authMethods.add(ClientAuthenticationMethod.CLIENT_SECRET_POST);
                })
                .authorizationGrantType(AuthorizationGrantType.CLIENT_CREDENTIALS)
                .clientSettings(ClientSettings.builder()
                    .requireAuthorizationConsent(true)
                    .requireProofKey(false)
                    .build())
                .tokenSettings(TokenSettings.builder()
                    .accessTokenFormat(OAuth2TokenFormat.REFERENCE)
                    .idTokenSignatureAlgorithm(SignatureAlgorithm.RS256)
                    .accessTokenTimeToLive(Duration.ofHours(1))
                    .reuseRefreshTokens(true)
                    .build())
                .build();

        return new InMemoryRegisteredClientRepository(registeredClient);
    }

    @Bean
    public AuthorizationServerSettings authorizationServerSettings() {
        return AuthorizationServerSettings.builder().build();
    }
}

测试请求

curl --location --request POST 'http://127.0.0.1:12345/oauth2/token?client_id=xdx97&client_secret=xdx97&grant_type=client_credentials'

在这里插入图片描述


2-3、一个简单的JwtToken生成


配置文件添加

对应源码目录： com.xdx97.config.oauth2

import com.nimbusds.jose.jwk.JWKSet;
import com.nimbusds.jose.jwk.RSAKey;
import com.nimbusds.jose.jwk.source.ImmutableJWKSet;
import com.nimbusds.jose.jwk.source.JWKSource;
import com.nimbusds.jose.proc.SecurityContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.oauth2.core.AuthorizationGrantType;
import org.springframework.security.oauth2.core.ClientAuthenticationMethod;
import org.springframework.security.oauth2.jwt.JwtDecoder;
import org.springframework.security.oauth2.server.authorization.client.InMemoryRegisteredClientRepository;
import org.springframework.security.oauth2.server.authorization.client.RegisteredClient;
import org.springframework.security.oauth2.server.authorization.client.RegisteredClientRepository;
import org.springframework.security.oauth2.server.authorization.config.annotation.web.configuration.OAuth2AuthorizationServerConfiguration;
import org.springframework.security.oauth2.server.authorization.config.annotation.web.configurers.OAuth2AuthorizationServerConfigurer;
import org.springframework.security.oauth2.server.authorization.settings.AuthorizationServerSettings;
import org.springframework.security.oauth2.server.authorization.settings.ClientSettings;
import org.springframework.security.oauth2.server.authorization.settings.TokenSettings;
import org.springframework.security.web.SecurityFilterChain;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.time.Duration;
import java.util.UUID;

@Configuration
public class JwtTokenSimpleConfig {

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

        http.apply(new OAuth2AuthorizationServerConfigurer());
        http.csrf().disable()
                .authorizeHttpRequests(authorizeRequests ->
                    authorizeRequests
                    .antMatchers("/oauth2/*").permitAll()
                    .antMatchers("/introspect/*").permitAll()
                    .antMatchers("/issuer/*").permitAll()
                    .anyRequest().authenticated()
                )
                .formLogin();

        return http.build();
    }

    @Bean
    public RegisteredClientRepository registeredClientRepository() {


        RegisteredClient registeredClient = RegisteredClient.withId(UUID.randomUUID().toString())
                .clientId("xdx97")
                .clientSecret("{noop}xdx97")
                .clientAuthenticationMethods(authMethods -> {
                    authMethods.add(ClientAuthenticationMethod.CLIENT_SECRET_POST);
                })
                .authorizationGrantType(AuthorizationGrantType.CLIENT_CREDENTIALS)
                // 必须要配置一个重定向地址
                .redirectUri("xxxxxxx")
                .clientSettings(ClientSettings.builder().requireAuthorizationConsent(true).requireProofKey(false).build())
                .tokenSettings(TokenSettings.builder().accessTokenTimeToLive(Duration.ofHours(1)).build())
                .build();

        return new InMemoryRegisteredClientRepository(registeredClient);
    }

    @Bean
    public JWKSource<SecurityContext> jwkSource() {
        KeyPair keyPair = generateRsaKey();
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
        RSAKey rsaKey = new RSAKey.Builder(publicKey)
                .privateKey(privateKey)
                .keyID(UUID.randomUUID().toString())
                .build();
        JWKSet jwkSet = new JWKSet(rsaKey);
        return new ImmutableJWKSet<>(jwkSet);
    }

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

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

    @Bean
    public AuthorizationServerSettings authorizationServerSettings() {
        return AuthorizationServerSettings.builder().build();
    }
}

测试请求

curl --location --request POST 'http://127.0.0.1:12345/oauth2/token?client_id=xdx97&client_secret=xdx97&grant_type=client_credentials'

在这里插入图片描述


因为Jwt是明文的，可以解析出来看看

在这里插入图片描述


三、资源端


测试用的HelloController

@RestController
public class HelloController {

    @GetMapping("/hello")
    public String hello() {
        return "Hello World!";
    }
}

3-1、依赖引入

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-oauth2-resource-server</artifactId>
</dependency>
<dependency>
    <groupId>com.nimbusds</groupId>
    <artifactId>nimbus-jose-jwt</artifactId>
    <version>9.14</version>
</dependency>
<dependency>
    <groupId>com.nimbusds</groupId>
    <artifactId>oauth2-oidc-sdk</artifactId>
    <version>9.14</version>
</dependency>

3-2、简单OpaqueToken校验


配置文件添加

对应源码目录： com.xdx97.config.oauth1 （和上面 authService对应）

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.method.configuration.EnableMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.oauth2.server.resource.introspection.NimbusOpaqueTokenIntrospector;
import org.springframework.security.web.SecurityFilterChain;


@Configuration(proxyBeanMethods = false)
@EnableMethodSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class OpaqueResourceSimpleConfig {


    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {

        http.csrf().disable()
        .authorizeRequests(authorizeRequests ->
            authorizeRequests.anyRequest().authenticated()
        )
        .oauth2ResourceServer(oauth2ResourceServer ->
            oauth2ResourceServer.opaqueToken(opaqueToken ->
                    opaqueToken.introspector(opaqueTokenIntrospector())
            )
        );

        return http.build();
    }

    public NimbusOpaqueTokenIntrospector opaqueTokenIntrospector() {
        return new NimbusOpaqueTokenIntrospector(
                "http://localhost:12345/oauth2/introspect",
                "xdx97",
                "xdx97"
        );
    }
}

测试

  1. token 取自上一个接口
  2. token要加一个前缀
curl --location --request GET 'http://127.0.0.1:12346/hello' \
--header 'Authorization: Bearer 4KtwpET1hhzMKghkK7Z9oUwcULewPIRF5mgy7cI7GZBRKuEW12NewAJ2YwAxJfT1tpNLWRui_jELQo_S48YlWLIdVXyggt2y27DbsdbpQxpHPgr5f5dTFXFWGzKKbLJR'

在这里插入图片描述


如果一直访问401，可以看看下面 N-2


3-3、简单Jwt校验


配置文件添加

对应源码目录： com.xdx97.config.oauth1 （和上面 authService对应）

import org.springframework.boot.web.client.RestTemplateBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.method.configuration.EnableMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.oauth2.jwt.JwtDecoder;
import org.springframework.security.oauth2.jwt.JwtValidators;
import org.springframework.security.oauth2.jwt.NimbusJwtDecoder;
import org.springframework.security.web.SecurityFilterChain;
import javax.annotation.Resource;
import java.time.Duration;

@Configuration(proxyBeanMethods = false)
@EnableMethodSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class JwtSimpleConfig {


    @Resource
    private RestTemplateBuilder restTemplateBuilder;


    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {

        http.csrf().disable()
            .authorizeRequests(authorizeRequests -> authorizeRequests.anyRequest().authenticated())
            .oauth2ResourceServer()
            .jwt()
            .decoder(jwtDecoder(restTemplateBuilder));
        return http.build();
    }

    public JwtDecoder jwtDecoder(RestTemplateBuilder builder) {
        // 授权服务器 jwk 的信息
        NimbusJwtDecoder decoder = NimbusJwtDecoder.withJwkSetUri("http://127.0.0.1:12345/oauth2/jwks")
                // 设置获取 jwk 信息的超时时间
                .restOperations(
                    builder.setReadTimeout(Duration.ofSeconds(3))
                            .setConnectTimeout(Duration.ofSeconds(3))
                            .build()
                )
                .build();
        // 对jwt进行校验
        decoder.setJwtValidator(JwtValidators.createDefault());
        return decoder;
    }
}

测试，和3-2一模一样的


四、进一步体验


上面已经简单使用了SpringSecurity的oauth2客户端认证功能，但还存在一些问题，下面来一一学习


4-1、关于 scope


SpringSecurity认证可以区分更细粒度，比如我们把 /hello 开头的接口定义为， hello资源，只有拥有这个资源的权限才可以访问，而不单单只是有个token


改造Controller

@RestController
@PreAuthorize("hasAuthority('SCOPE_hello')")
public class HelloController {

    @GetMapping("/hello")
    public String hello() {
        return "Hello World!";
    }
}

旧版本使用 @PreAuthorize(“#oauth2.hasScope(‘hello’)”)


服务端改造

在这里插入图片描述
在这里插入图片描述


获取token的时候也要加上scope
在这里插入图片描述


在早期的SpringSecurity Oauth2 校验scope是不需要带 SCOPE_ 前缀的，在新版中如果你想去除也可以

private JwtAuthenticationConverter jwtAuthenticationConverter() {
    JwtAuthenticationConverter converter = new JwtAuthenticationConverter();
    JwtGrantedAuthoritiesConverter authoritiesConverter = new JwtGrantedAuthoritiesConverter();
    // 去掉 SCOPE_ 的前缀
    authoritiesConverter.setAuthorityPrefix("");
    converter.setJwtGrantedAuthoritiesConverter(authoritiesConverter);
    return converter;
}

在这里插入图片描述


4-2、Opaque 认证的client_id、client_secret 处理


在上面演示的时候，有一段代码是，这是去资源端请求认证服务解析 token

public NimbusOpaqueTokenIntrospector opaqueTokenIntrospector() {
    return new NimbusOpaqueTokenIntrospector(
            "http://localhost:12345/oauth2/introspect",
            "xdx97",
            "xdx97"
    );
}

如果我们的资源要被多个不同的客户端访问，该怎么办呢？上面的 clientId 和clientSecret 写死了

目前我有一个办法就是，写一个 filter，这两个参数要么让用户传递过来，要么从数据库中取（可以在生成token的时候，把token存到Redis、 id和secret作为值）

  1. 写一个Filter（就是Java中的Filter）获取到了 id、secret后就存在ThreadLocal中
  2. 重写 OpaqueTokenIntrospector ，从上下文中获取id、secret

也可以使用Jwt，Jwt因为是明文的所以不需要id和secret


OpaqueTokenIntrospector 代码如下， Filter自己实现这个很简单

public class CustomOpaqueTokenIntrospector implements OpaqueTokenIntrospector {
    private final String introspectionUri;

    public CustomOpaqueTokenIntrospector(String introspectionUri) {
        this.introspectionUri = introspectionUri;
    }
    @Override
    public OAuth2AuthenticatedPrincipal introspect(String token) {
        // TODO 改为从 ThreadLocal 中获取
        String clientId = "";
        String clientSecret ="";

        System.out.println(clientId);
        System.out.println(clientSecret);

        clientId = clientId == null ? "xdx97" : clientId;
        clientSecret = clientSecret == null ? "xdx97" : clientSecret;

        NimbusOpaqueTokenIntrospector delegate = new NimbusOpaqueTokenIntrospector(
                introspectionUri,
                clientId,
                clientSecret
        );

        return delegate.introspect(token);
    }
}

完整目录在 resource-service： com.xdx97.config.oauth3


4-3、自定义获取token


默认获取token是在 header中，还要拼接一个前缀 Bearer， 假如想改为从 url中获取 access_token， 只需要重写BearerTokenResolver

public class CustomUriBearerTokenResolver implements BearerTokenResolver {

    private static final String BEARER_TOKEN_PARAM = "access_token"; // URI 中 Token 的参数名

    @Override
    public String resolve(HttpServletRequest request) {
        // 从 URI 参数中获取 Token
        String token = request.getParameter(BEARER_TOKEN_PARAM);
        return (token != null && !token.isEmpty()) ? token : null;
    }
}

在这里插入图片描述


4-4、自定义个性参数 （重要）


上面的流程完成了授权和鉴权，但我们拿不到有用的参数，何为有用的参数比如： 用户的 userId
不管是Opaque还是Jwt都可以在里面设置一些我们自己的参数——把参数放到 【claims】


Opaque

@Bean
public OAuth2TokenCustomizer<OAuth2TokenClaimsContext> tokenCustomizer() {
    return context -> {

        OAuth2TokenClaimsSet.Builder claims = context.getClaims();
        // 将权限信息放入jwt的claims中，这里可以注入一个 Mapper去查询数据库 （可以从 context中拿到 client_id）
        claims.claim("companyId","自定义参数");
    };
}

Jwt

@Bean
public OAuth2TokenCustomizer<JwtEncodingContext> oAuth2TokenCustomizer() {
    return context -> {
        
        JwtClaimsSet.Builder claims = context.getClaims();
        // 将权限信息放入jwt的claims中，这里可以注入一个 Mapper去查询数据库 （可以从 context中拿到 client_id）
        claims.claim("companyId", "自定义参数");
    };
}

在这里插入图片描述


这个参数也很好拿到，直接存到上下文了，资源端从上下文就可以获取到
在这里插入图片描述


4-5、自定义注册RegisteredClient


InMemoryRegisteredClientRepository 支持List集合，可以把数据库的全部的客户端都查询出来构造一个List RegisteredClient丢进去


N、其它


N-1、oauth2/token 接口404


使用 post请求


N-2、使用Opaque访问 401 问题排查


按照上述配置应该不会 401，但防止配错了需要排除问题，我自己断点调试，发现 resourceService，请求 authService的HTTP如下

import org.springframework.http.*;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.RestTemplate;

public class IntrospectionTest {


    public static  void main(String[] args) {
        String introspectionEndpoint = "http://localhost:12345/oauth2/introspect";
        String clientId = "xdx97";
        String clientSecret = "xdx97";
        String token = "7LdsIQlDLI7c2Ugw9yAAEbitc97SmZDhCobLEsQbq3HiJJ1GJgA8VpNvCgcfXhF6GmzcWaViicKjZPNOdznSufTP9OBlLXjXE806O9yT7nZyfEdnt6FvYIx9ttpOZRX1";

        RestTemplate restTemplate = new RestTemplate();
        HttpHeaders headers = new HttpHeaders();
        headers.setBasicAuth(clientId, clientSecret);
        headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);
        MultiValueMap<String, String> body = new LinkedMultiValueMap<>();
        body.add("token", token);

        HttpEntity<MultiValueMap<String, String>> request = new HttpEntity<>(body, headers);
        ResponseEntity<String> response = restTemplate.exchange(introspectionEndpoint, HttpMethod.POST, request, String.class);

        System.out.println(response.getBody());
    }
}

通过 active 来判断是否校验通过

{
    "active": true,
    "sub": "xdx97",
    "aud": [
        "xdx97"
    ],
    "nbf": 1719137941,
    "iss": "http://127.0.0.1:12345",
    "exp": 1719141541,
    "iat": 1719137941,
    "jti": "f75bb022-fa4b-453b-9d3f-8576465a1cb0",
    "client_id": "xdx97",
    "token_type": "Bearer"
}

N-3、Opaque服务器重启和Jwt服务器重启会不会丢失


不透明token，如果重启服务端会丢失，Jwt则不会


N-4、建议


如果不熟悉的小伙伴，建议不要修改代码的内容，直接复制运行，运行成功后再去修改


N-5、源码


关注公众号：小道仙97
回复关键字：SpringSecurityDemo

小道仙97
关注
  • 22
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
oauth2 spring-authorization-server自定义资源拥有者凭据许可模式
tof
04-19 1743
1.版本 spring-authorization-server 0.2.3 spring-boot 2.6.6 2.概述 spring-authorization-server中实现的oauth2标准中已经不支持自定义资源拥有者模式，但是项目从之前spring-seucirty-oauth2内置的升级到最新的授权服务器或者需要资源拥有者模式，就不要扩展 3.分析 官方源码的测试代码中给的示例初始化spring security的安全配置基本如下 protected void config
Spring Security OAuth2 入门
m0_62714732的博客
10-28 9267
1. 概述 2. 引入 Spring Security OAuth2 依赖 3. 配置资源服务器 4. 配置授权服务器 4.1 授权码模式 Spring Security Setting 4.2 密码模式 4.3 简化模式 4.4 客户端模式 4.5 如何选择？ 4.6 为什么有 Client 编号和密码 5. 刷新令牌 5.1 获取刷新令牌 5.2 “刷新”访问令牌 5.3 为什么需要有刷新令牌 6. 删除令牌 6.1 删除访问令牌 6.2 删除刷新令牌 6.3 RFC
spring-security-oauth2-authorization-server实现用户名密码登录
笑对人生
08-09 1358
spring-security-oauth2-authorization-server实现用户名密码登录
spring-security-oauth2-authorization-server（二）Token生成分析之JWT Token和Opaque Token
weixin_42229668的博客
09-17 3771
因为SpringBoot3.x是目前最新的版本，整合spring-security-oauth2-authorization-server的资料很少，所以产生了这篇文章，主要为想尝试SpringBoot高版本，想整合最新的spring-security-oauth2-authorization-server的初学者，旨在为大家提供一个简单上手的参考，如果哪里写得不对或可以优化的还请大家踊跃评论指正。前面一篇文章。
Spring Boot 3.3新特性发布,spring-security-oauth2-authorization-server使用1.3.0
最新发布
weimeilayer的博客
06-03 1085
Prometheus Client 1.0.0是一个备受期待的流行 Java 指标库版本，它包含一些突破性的变化，包括但不限于对本机直方图的内置支持、与 OpenTelemetry 跟踪的无缝集成以及对 OpenTelemetry Exporter 的支持。spring-boot-actuator 模块现在包含 SBOM 端点。Spring Boot 进入了全新的 3.x 时代了，3.1.x 和 3.0.x 也相继停止维护了，商业支持的版本也只有 2.7+ 了，2.6.x 以下的版本彻底退出历史舞台。
SpringSecurityOauth2（四种模式）
qq_45597391的博客
06-19 1万+
Oauth2.0是目前流行的授权机制，用于授权第三方应用，获取数据。
Spring Security Oauth2
m0_74907678的博客
03-07 363
Oauth2
OAuth2.0
Jesse_cool的博客
10-26 262
前言 看到spring security OAuth 不太理解，所以查了很多资料 例子： 有一个"云冲印"的网站，可以将用户储存在Google的照片，冲印出来。用户为了使用该服务，必须让"云冲印"读取自己储存在Google上的照片。 一般来说，总不可能让云冲印拿到自己的密码吧，由此，OAuth诞生了（密码模式的话也是要提供账号密码 的） OAuth运行流程 客户端的授权模式 客户...
spring-security-oauth2
12-11
spring3 oauth2 实现机制介绍，包括服务端和客户端
spring-security-oauth2-authorization-server.zip
08-25
本项目“spring-security-oauth2-authorization-server”将带你深入理解如何利用Spring Security OAuth2构建一个授权服务器，以保护你的API并提供安全的访问控制。 OAuth2是一种开放标准，用于授权第三方应用访问...
spring-security-oauth2详细配置demo
09-30
Spring Security OAuth2 是一个强大的框架，用于为Java应用提供安全认证和授权服务。这个详细配置的Demo旨在帮助开发者理解并实现OAuth2在Spring Security中的应用。在这个Demo中，我们将探讨OAuth2的核心概念、...
springboot-security-oauth2:SpringBoot集成Spring Security、OAuth2实现authorization code授权码模式
05-10
springboot-security-oauth2 此SpringBoot项目集成Spring Security、OAuth2实现资源访问授权认证。 支持client credentials、password、authorization code认证模式。 项目默认最为复杂的authorization code授权码认证模式，已经实现自定义登录页、授权页、错误页，以及第三方用户登录。 1.支持/oauth/authorize,/oauth/token,/oauth/refresh_token,/oauth/error； 2.用户认证的accessToken使用RedisTokenStore保存在Redis中（但是代码也已经支持JDBC持久化存储Token，目前处于注释状态）。 注：如果需要使用JDBCTokenStore可以使用一下SQL语句创建响应的数据表： USE `iot_boss
springBoot-springSecurity-OAuth2
01-16
SpringBoot、SpringSecurity和OAuth2是Java开发领域中非常重要的技术组件，它们分别在Web应用的快速开发、安全控制和授权认证方面发挥着关键作用。本文将深入探讨这些技术的结合使用，以及如何在实际项目中实现它们...
spring-Security-oauth2.zip
05-26
Spring Security OAuth2 是一个强大的框架，用于在Spring应用程序中实现安全性和身份验证。OAuth2 是一个授权框架，允许第三方应用获取有限的访问权限到受保护的资源，而无需分享用户名和密码。本压缩包文件“spring...
Spring Security——OAuth2.0
热门推荐
代码星辰的博客
10-06 1万+
Spring Security——OAuth2.0
Spring Security 系列(2) —— Spring Security OAuth2
qq_38219153的博客
06-16 455
OAuth（开放授权）是一个开放标准，允许用户让第三方应用访问该用户在某一网站上存储的私密的资源（如照片，视频，联系人列表），而无需将用户名和密码提供给第三方应用。在认证和授权的过程中涉及的三方包括： 1、服务提供方，用户使用服务提供方来存储受保护的资源，如照片，视频，联系人列表。 2、用户，存放在服务提供方的受保护的资源的拥有者。 3、客户端，要访问服务提供方资源的第三方应用，通常是网站，如提供照片打印服务的网站。在认证过程之前，客户端要向服务提供者申请客户端标识。例如微信的第三方登陆，以京东的微信登陆为
spring-security-oauth2（授权模式入门简单使用）
IABQL的博客
08-13 2730
当前应用需要实现第三方登入，那么第三方是如何进行授权认证的？这就是oauth2协议。模拟实现微信端是如何进行授权认证登入。举例：豆瓣就是客户应用，授权服务器、资源服务器就是微信端持有。豆瓣需要向微信的授权服务器获取授权，获取到授权后再向资源服务器获取用户信息。那么我们就需要1.需要配置一个授权服务器（发放授权码）2.配置一个资源服务器（获取用户信息接口需要令牌才能访问）3.配置一个接口（获取返回用户信息）4.还要实现模拟用户的登入（因为授权服务器需要向用户发起是否允许授权的请求）......
SpringSecurity整合OAuth2.0
玩转Java
12-10 9815
springsecurity整合aoth2.0
Spring Security之EnableGlobalMethodSecurity注解详解
Smiling Ron的博客
02-12 3998
@EnableGlobalMethodSecurity 详解 @EnableGlobalMethodSecurity(securedEnabled=true) 开启@Secured 注解过滤权限 例如：@Secured({“ROLE_EMP”})、@Secured({“ROLE_EMP”, “ROLE_ROOT”})、@Secured({“ROLE_ROOT”}) @EnableGlobalMet...
spring-security-oauth2-authorization-server jar包下载
08-15
要下载spring-security-oauth2-authorization-server jar包，可以按照以下步骤进行操作： 1. 打开Maven Central Repository的官方网站（https://mvnrepository.com/），这是一个广泛使用的jar包库。 2. 在搜索框中输入"spring-security-oauth2-authorization-server"，然后点击搜索按钮。 3. 在搜索结果中找到对应的jar包，确认版本号和适配的Spring版本。 4. 点击jar包的名称，进入详情页面。 5. 在页面上找到提供下载的链接，通常是一个按钮或者一个Maven/Gradle的依赖配置。 6. 如果点击了一个按钮，则直接下载jar包。如果是Maven/Gradle的依赖配置，则复制配置内容，然后在项目的构建配置文件（比如pom.xml）中添加该依赖。 7. 根据自己的需要选择适合的下载方式，可以选择下载jar包或者添加Maven/Gradle依赖。 8. 下载完成后，将jar包添加到项目的类路径中，以便项目能够正常使用。 需要注意的是，下载的jar包要根据项目使用的Spring版本和其他相关依赖进行匹配，否则可能会出现兼容性问题。如果在下载过程中遇到问题，可以查阅相关的文档或向Spring社区寻求帮助。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值