Spring Authorization Server и Redis

@Configuration
@EnableRedisHttpSession
public class RedisSessionConfig {
    @Bean
    public LettuceConnectionFactory connectionFactory() {
        return new LettuceConnectionFactory("redis-master.internal", 6379);
    }
}

@Bean
public LettuceClientConfigurationBuilderCustomizer lettuceCustomizer() {
    return builder -> builder.readFrom(ReadFrom.REPLICA_PREFERRED);
}

@Configuration
public class RedisTokenStoreConfig {
    @Bean
    public TokenStore tokenStore(RedisConnectionFactory connectionFactory) {
        RedisTokenStore tokenStore = new RedisTokenStore(connectionFactory);
        // Кастомный префикс помогает избежать коллизий в shared Redis
        tokenStore.setPrefix("auth_srv:");
        return tokenStore;
    }
    
    @Bean
    public JwtAccessTokenConverter accessTokenConverter() {
        JwtAccessTokenConverter converter = new JwtAccessTokenConverter();
        converter.setSigningKey("my-super-secure-signing-key"); // В реальности должен быть в защищенном хранилище
        return converter;
    }
}

spring.redis.sentinel.master=mymaster
spring.redis.sentinel.nodes=redis-sentinel1:26379,redis-sentinel2:26379,redis-sentinel3:26379
spring.redis.lettuce.pool.max-active=8
spring.redis.lettuce.pool.max-idle=8
spring.redis.lettuce.pool.min-idle=2

@Bean
public LettuceClientConfigurationBuilderCustomizer lettuceConfigCustomizer() {
    return clientConfigurationBuilder -> {
        clientConfigurationBuilder.readFrom(ReadFrom.REPLICA_PREFERRED);
        clientConfigurationBuilder.clientOptions(
            ClientOptions.builder()
                .disconnectedBehavior(ClientOptions.DisconnectedBehavior.REJECT_COMMANDS)
                .build()
        );
    };
}

@Configuration
public class ResilienceConfig {
    @Bean
    public CircuitBreaker redisCircuitBreaker() {
        CircuitBreakerConfig config = CircuitBreakerConfig.custom()
            .failureRateThreshold(50)
            .waitDurationInOpenState(Duration.ofMillis(1000))
            .permittedNumberOfCallsInHalfOpenState(2)
            .slidingWindowSize(10)
            .build();
        return CircuitBreaker.of("redisCircuitBreaker", config);
    }
    
    @Bean
    public TokenStore resilientTokenStore(
            RedisConnectionFactory redisConnectionFactory,
            CircuitBreaker circuitBreaker) {
        RedisTokenStore primaryStore = new RedisTokenStore(redisConnectionFactory);
        return new ResilientTokenStore(primaryStore, circuitBreaker);
    }
}

# В redis.conf или как параметр при запуске Redis
maxmemory 2gb
maxmemory-policy volatile-ttl

@Service
public class UserSecurityMetadataService {
    private final RedisTemplate<String, Object> redisTemplate;
    private final UserRepository userRepository;
    
    // конструктор с внедрением зависимостей
    
    @KafkaListener(topics = "user-security-changes")
    public void handleSecurityChanges(SecurityChangeEvent event) {
        // Инвалидируем кэшированные метаданные безопасности
        String redisKey = "user:security:" + event.getUserId();
        redisTemplate.delete(redisKey);
        
        // При следующем запросе метаданные будут загружены заново
    }
    
    public UserSecurityMetadata getSecurityMetadata(Long userId) {
        String redisKey = "user:security:" + userId;
        
        // Пытаемся получить из Redis
        UserSecurityMetadata metadata = 
            (UserSecurityMetadata) redisTemplate.opsForValue().get(redisKey);
        
        if (metadata == null) {
            // Если нет в кэше, загружаем из базы
            User user = userRepository.findById(userId).orElseThrow();
            metadata = convertToSecurityMetadata(user);
            
            // Кэшируем с ограниченным временем жизни
            redisTemplate.opsForValue().set(redisKey, metadata, 1, TimeUnit.HOURS);
        }
        
        return metadata;
    }
}

@Configuration
public class ReactiveRedisAuthConfig {
    @Bean
    public ReactiveRedisConnectionFactory reactiveRedisConnectionFactory() {
        return new LettuceConnectionFactory(
            new RedisStandaloneConfiguration("localhost", 6379));
    }
    
    @Bean
    public ReactiveRedisTemplate<String, Object> reactiveRedisTemplate(
            ReactiveRedisConnectionFactory factory) {
        Jackson2JsonRedisSerializer<Object> serializer = 
            new Jackson2JsonRedisSerializer<>(Object.class);
        
        RedisSerializationContext.RedisSerializationContextBuilder<String, Object> builder =
            RedisSerializationContext.newSerializationContext(new StringRedisSerializer());
        
        RedisSerializationContext<String, Object> context = 
            builder.value(serializer).build();
        
        return new ReactiveRedisTemplate<>(factory, context);
    }
}

@Configuration
@EnableWebSecurity
public class SecurityConfig {
 
    @Bean
    public SecurityFilterChain defaultSecurityFilterChain(HttpSecurity http) throws Exception {
        http
            .authorizeHttpRequests(authorize -> authorize
                .requestMatchers("/oauth2/**", "/login/**").permitAll()
                .anyRequest().authenticated()
            )
            .formLogin(withDefaults());
        return http.build();
    }
 
    @Bean
    public UserDetailsService userDetailsService() {
        // В реальном проекте тут будет интеграция с вашим хранилищем пользователей
        UserDetails user = User.withDefaultPasswordEncoder()
            .username("user")
            .password("password")
            .roles("USER")
            .build();
        return new InMemoryUserDetailsManager(user);
    }
}

@Configuration
@Import(OAuth2AuthorizationServerConfiguration.class)
public class AuthorizationServerConfig {
 
    @Bean
    public RegisteredClientRepository registeredClientRepository() {
        RegisteredClient client = RegisteredClient.withId(UUID.randomUUID().toString())
            .clientId("my-client")
            .clientSecret("{noop}secret")
            .clientAuthenticationMethod(ClientAuthenticationMethod.CLIENT_SECRET_BASIC)
            .authorizationGrantType(AuthorizationGrantType.AUTHORIZATION_CODE)
            .authorizationGrantType(AuthorizationGrantType.REFRESH_TOKEN)
            .redirectUri("http://127.0.0.1:8080/login/oauth2/code/client")
            .scope("read")
            .scope("write")
            .build();
        
        return new InMemoryRegisteredClientRepository(client);
    }
 
    @Bean
    public JWKSource<SecurityContext> jwkSource() {
        RSAKey rsaKey = generateRsa();
        JWKSet jwkSet = new JWKSet(rsaKey);
        return (jwkSelector, securityContext) -> jwkSelector.select(jwkSet);
    }
 
    @Bean
    public AuthorizationServerSettings authorizationServerSettings() {
        return AuthorizationServerSettings.builder().build();
    }
 
    private static RSAKey generateRsa() {
        KeyPair keyPair = generateRsaKey();
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
        return new RSAKey.Builder(publicKey)
            .privateKey(privateKey)
            .keyID(UUID.randomUUID().toString())
            .build();
    }
 
    private static KeyPair generateRsaKey() {
        try {
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
            keyPairGenerator.initialize(2048);
            return keyPairGenerator.generateKeyPair();
        } catch (Exception ex) {
            throw new IllegalStateException(ex);
        }
    }
}

@Configuration
@EnableRedisRepositories
public class RedisTokenStoreConfig {
 
    @Bean
    public TokenStore tokenStore(RedisConnectionFactory connectionFactory) {
        RedisTokenStore tokenStore = new RedisTokenStore(connectionFactory);
        tokenStore.setPrefix("auth_server:");  // Важно для разделения ключей в общем Redis
        return tokenStore;
    }
 
    @Bean
    public OAuth2AuthorizationService authorizationService(
            RedisConnectionFactory connectionFactory,
            RegisteredClientRepository clientRepository) {
        return new RedisOAuth2AuthorizationService(connectionFactory, clientRepository);
    }
 
    @Bean
    public OAuth2AuthorizationConsentService authorizationConsentService(
            RedisConnectionFactory connectionFactory,
            RegisteredClientRepository clientRepository) {
        return new RedisOAuth2AuthorizationConsentService(connectionFactory, clientRepository);
    }
}

@Component
public class RedisOAuth2AuthorizationService implements OAuth2AuthorizationService {
    
    private final StringRedisTemplate redisTemplate;
    private final RegisteredClientRepository clientRepository;
    private final ObjectMapper objectMapper;
    
    // Конструктор с внедрением зависимостей
    
    @Override
    public void save(OAuth2Authorization authorization) {
        Assert.notNull(authorization, "authorization cannot be null");
        
        String id = authorization.getId();
        String key = "oauth2_auth:" + id;
        
        try {
            String serialized = objectMapper.writeValueAsString(convertToMap(authorization));
            redisTemplate.opsForValue().set(key, serialized);
            
            // Устанавливаем TTL на основе времени жизни токена
            if (authorization.getAccessToken() != null && 
                    authorization.getAccessToken().getExpiresAt() != null) {
                Instant expiresAt = authorization.getAccessToken().getExpiresAt();
                Duration ttl = Duration.between(Instant.now(), expiresAt).plus(Duration.ofMinutes(10));
                redisTemplate.expire(key, ttl);
            }
            
            // Создаем дополнительные индексы для быстрого поиска
            if (authorization.getPrincipalName() != null) {
                redisTemplate.opsForSet().add(
                    "oauth2_auth_by_principal:" + authorization.getPrincipalName(), id);
            }
        } catch (Exception ex) {
            throw new IllegalStateException(ex);
        }
    }
    
    // Остальные методы интерфейса
    
    private Map<String, Object> convertToMap(OAuth2Authorization authorization) {
        // Преобразование объекта в Map для сериализации
        // Этот метод должен быть реализован с учетом всех полей OAuth2Authorization
    }
}

@Configuration
public class ResilienceConfig {
 
    @Bean
    public CircuitBreaker redisCircuitBreaker() {
        CircuitBreakerConfig config = CircuitBreakerConfig.custom()
            .slidingWindowType(CircuitBreakerConfig.SlidingWindowType.COUNT_BASED)
            .slidingWindowSize(10)
            .failureRateThreshold(50.0f)
            .waitDurationInOpenState(Duration.ofSeconds(10))
            .permittedNumberOfCallsInHalfOpenState(3)
            .build();
        
        return CircuitBreaker.of("redisCircuitBreaker", config);
    }
    
    @Bean
    public Retry redisRetry() {
        RetryConfig config = RetryConfig.custom()
            .maxAttempts(3)
            .waitDuration(Duration.ofMillis(100))
            .retryExceptions(RedisConnectionFailureException.class)
            .build();
        
        return Retry.of("redisRetry", config);
    }
    
    @Bean
    public OAuth2AuthorizationService resilientAuthorizationService(
            OAuth2AuthorizationService delegate,
            CircuitBreaker circuitBreaker,
            Retry retry) {
        return new ResilientOAuth2AuthorizationService(delegate, circuitBreaker, retry);
    }
}

public class ResilientOAuth2AuthorizationService implements OAuth2AuthorizationService {
    
    private final OAuth2AuthorizationService delegate;
    private final CircuitBreaker circuitBreaker;
    private final Retry retry;
    
    // Конструктор с внедрением зависимостей
    
    @Override
    public void save(OAuth2Authorization authorization) {
        Supplier<Void> decoratedSupplier = Decorators.ofSupplier(() -> {
            delegate.save(authorization);
            return null;
        })
        .withCircuitBreaker(circuitBreaker)
        .withRetry(retry)
        .decorate();
        
        try {
            decoratedSupplier.get();
        } catch (Exception e) {
            // Логирование и возможно fallback-стратегия
            throw new RuntimeException("Failed to save authorization", e);
        }
    }
    
    // Аналогичная реализация для остальных методов
}

@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
    RedisTemplate<String, Object> template = new RedisTemplate<>();
    template.setConnectionFactory(connectionFactory);
    
    Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = 
        new Jackson2JsonRedisSerializer<>(Object.class);
    
    ObjectMapper objectMapper = new ObjectMapper();
    objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
    objectMapper.registerModule(new JavaTimeModule()); // Для корректной сериализации Java 8 Date/Time API
    
    jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
    
    template.setKeySerializer(new StringRedisSerializer());
    template.setValueSerializer(jackson2JsonRedisSerializer);
    template.setHashKeySerializer(new StringRedisSerializer());
    template.setHashValueSerializer(jackson2JsonRedisSerializer);
    
    template.afterPropertiesSet();
    return template;
}

public class CompactTokenSerializer implements RedisSerializer<OAuth2AccessToken> {
 
    @Override
    public byte[] serialize(OAuth2AccessToken token) throws SerializationException {
        if (token == null) {
            return null;
        }
        
        // Компактное представление, только самые необходимые поля
        Map<String, Object> map = new HashMap<>();
        map.put("v", token.getTokenValue());
        map.put("t", token.getTokenType().getValue());
        map.put("e", token.getExpiresAt() != null ? 
            token.getExpiresAt().getEpochSecond() : null);
        map.put("s", new ArrayList<>(token.getScopes()));
        
        try {
            return new ObjectMapper()
                .writerWithDefaultPrettyPrinter()
                .writeValueAsBytes(map);
        } catch (Exception ex) {
            throw new SerializationException("Error serializing token", ex);
        }
    }
 
    @Override
    public OAuth2AccessToken deserialize(byte[] bytes) throws SerializationException {
        // Реализация десериализации
    }
}

@Component
public class RedisTokenStoreHealthIndicator implements HealthIndicator {
    
    private final RedisConnectionFactory connectionFactory;
    
    public RedisTokenStoreHealthIndicator(RedisConnectionFactory connectionFactory) {
        this.connectionFactory = connectionFactory;
    }
    
    @Override
    public Health health() {
        RedisConnection connection = null;
        try {
            connection = connectionFactory.getConnection();
            if (connection.ping() == null) {
                return Health.down().withDetail("error", "No response from Redis").build();
            }
            
            // Дополнительные проверки работоспособности
            long keysCount = connection.keyCommands().dbSize();
            
            return Health.up()
                .withDetail("totalKeys", keysCount)
                .build();
        } catch (Exception e) {
            return Health.down(e).build();
        } finally {
            if (connection != null) {
                connection.close();
            }
        }
    }
}

# Мониторинг всех команд в реальном времени
redis-cli MONITOR
 
# Анализ самых "тяжелых" ключей
redis-cli --bigkeys
 
# Отслеживание задержек
redis-cli --latency

@Component
public class RedisTokenMetrics {
    private final MeterRegistry registry;
    private final StringRedisTemplate redisTemplate;
    
    public RedisTokenMetrics(MeterRegistry registry, StringRedisTemplate redisTemplate) {
        this.registry = registry;
        this.redisTemplate = redisTemplate;
        
        // Регистрируем gauge для подсчета токенов
        Gauge.builder("auth.tokens.active", this, RedisTokenMetrics::countActiveTokens)
            .description("Number of active tokens in Redis")
            .register(registry);
    }
    
    private long countActiveTokens() {
        try {
            // Считаем ключи по паттерну
            return redisTemplate.execute((RedisCallback<Long>) connection -> {
                ScanOptions options = ScanOptions.scanOptions()
                    .match("auth_server:access:*").count(1000).build();
                Cursor<byte[]> cursor = connection.scan(options);
                
                long count = 0;
                while(cursor.hasNext()) {
                    cursor.next();
                    count++;
                }
                return count;
            });
        } catch (Exception e) {
            return -1L; // Индикация ошибки в метрике
        }
    }
}

@Component
public class EncryptingRedisTokenStore implements TokenStore {
    private final RedisTokenStore delegate;
    private final StringEncryptor encryptor;
    
    // конструктор с инъекцией зависимостей
    
    @Override
    public void storeAccessToken(OAuth2AccessToken token, OAuth2Authentication authentication) {
        // Шифруем чувствительные данные
        OAuth2AccessToken encryptedToken = encryptToken(token);
        delegate.storeAccessToken(encryptedToken, authentication);
    }
    
    @Override
    public OAuth2AccessToken readAccessToken(String tokenValue) {
        OAuth2AccessToken encryptedToken = delegate.readAccessToken(tokenValue);
        if (encryptedToken == null) {
            return null;
        }
        return decryptToken(encryptedToken);
    }
    
    // другие методы интерфейса
    
    private OAuth2AccessToken encryptToken(OAuth2AccessToken token) {
        // Логика шифрования
    }
    
    private OAuth2AccessToken decryptToken(OAuth2AccessToken token) {
        // Логика дешифрования
    }
}

# Отключаем опасные команды
rename-command FLUSHALL ""
rename-command FLUSHDB ""
rename-command CONFIG ""
rename-command KEYS ""
 
# Обязательная аутентификация
requirepass SuperComplexPassword
 
# Ограничение максимальной памяти
maxmemory 2gb
maxmemory-policy allkeys-lru
 
# Ограничение клиентов
maxclients 10000

# С помощью redis-cli
redis-cli --hotkeys
 
# Через Redis Latency Monitor
redis-cli> CONFIG SET latency-monitor-threshold 100
redis-cli> LATENCY LATEST

@Component
public class CachingTokenService implements OAuth2TokenService {
    private final OAuth2TokenService delegate;
    private final LoadingCache<String, OAuth2AccessToken> tokenCache;
    
    public CachingTokenService(OAuth2TokenService delegate) {
        this.delegate = delegate;
        this.tokenCache = Caffeine.newBuilder()
            .maximumSize(10_000)
            .expireAfterWrite(10, TimeUnit.SECONDS)
            .build(delegate::readAccessToken);
    }
    
    @Override
    public OAuth2AccessToken readAccessToken(String tokenValue) {
        return tokenCache.get(tokenValue);
    }
    
    // другие методы интерфейса с пробросом к делегату
}

# В redis.conf
save 900 1       # снэпшот каждые 15 минут при изменении минимум 1 ключа
save 300 10      # снэпшот каждые 5 минут при изменении минимум 10 ключей
save 60 10000    # снэпшот каждую минуту при изменении минимум 10000 ключей
 
appendonly yes
appendfsync everysec   # запись в AOF каждую секунду (компромисс между производительностью и надежностью)

#!/bin/bash
TIMESTAMP=$(date +%Y%m%d%H%M%S)
BACKUP_DIR="/mnt/backups/redis"
REDIS_DATA_DIR="/var/lib/redis"
 
# Создаем BGSAVE для генерации свежего RDB
redis-cli BGSAVE
 
# Ждем завершения BGSAVE
while [ $(redis-cli info persistence | grep rdb_bgsave_in_progress | cut -d ":" -f2 | tr -d "\r\n") -eq 1 ]; do
  sleep 1
done
 
# Копируем RDB и AOF в бэкап с временной меткой
cp "${REDIS_DATA_DIR}/dump.rdb" "${BACKUP_DIR}/dump-${TIMESTAMP}.rdb"
cp "${REDIS_DATA_DIR}/appendonly.aof" "${BACKUP_DIR}/appendonly-${TIMESTAMP}.aof"
 
# Удаляем старые бэкапы (оставляем последние 7 дней)
find ${BACKUP_DIR} -name "dump-*.rdb" -mtime +7 -delete
find ${BACKUP_DIR} -name "appendonly-*.aof" -mtime +7 -delete

@SpringBootTest
public class TokenFormatCompatibilityTest {
    @Autowired
    private RedisConnectionFactory redisConnectionFactory;
    
    @Test
    public void testBackwardCompatibility() throws Exception {
        // Создаем токен в "старом" формате
        OAuth2AccessToken oldFormatToken = createOldFormatToken();
        String tokenKey = "test:compatibility:" + UUID.randomUUID().toString();
        
        // Сохраняем его в Redis через низкоуровневое API
        RedisConnection conn = redisConnectionFactory.getConnection();
        conn.set(
            tokenKey.getBytes(), 
            serializeInOldFormat(oldFormatToken)
        );
        
        // Пытаемся прочитать токен через новый код
        TokenStore tokenStore = new RedisTokenStore(redisConnectionFactory);
        OAuth2AccessToken readToken = tokenStore.readAccessToken(tokenKey);
        
        // Проверяем, что токен успешно прочитан и содержит правильные данные
        assertThat(readToken).isNotNull();
        assertThat(readToken.getValue()).isEqualTo(oldFormatToken.getValue());
        
        // Очистка
        conn.del(tokenKey.getBytes());
    }
    
    // Вспомогательные методы
}

@Component
public class CacheInvalidationListener {
    private final CacheManager cacheManager;
    
    @Autowired
    public CacheInvalidationListener(CacheManager cacheManager, RedisConnectionFactory connectionFactory) {
        this.cacheManager = cacheManager;
        
        // Подписываемся на канал уведомлений об отзыве токенов
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        container.setConnectionFactory(connectionFactory);
        container.addMessageListener(
            (message, pattern) -> invalidateTokenCache(new String(message.getBody())),
            new ChannelTopic("token:revocation")
        );
        container.start();
    }
    
    private void invalidateTokenCache(String tokenId) {
        Cache tokenCache = cacheManager.getCache("tokens");
        if (tokenCache != null) {
            tokenCache.evict(tokenId);
        }
    }
}

redis-oauth2-demo/
├── auth-server/           # Сервер авторизации
│   ├── src/
│   └── Dockerfile
├── resource-server/       # Ресурс-сервер (защищенный API)
│   ├── src/
│   └── Dockerfile
├── frontend/              # Angular SPA
│   ├── src/
│   └── Dockerfile
├── docker-compose.yml     # Композиция всех сервисов
├── prometheus/            # Конфигурация мониторинга
└── load-tests/            # JMeter скрипты для нагрузочного тестирования

@SpringBootApplication
public class AuthServerApplication {
 
  public static void main(String[] args) {
      SpringApplication.run(AuthServerApplication.class, args);
  }
  
  @Bean
  public PasswordEncoder passwordEncoder() {
      return new BCryptPasswordEncoder();
  }
  
  @Bean
  public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
      RedisTemplate<String, Object> template = new RedisTemplate<>();
      template.setConnectionFactory(connectionFactory);
      
      // Оптимизированные сериализаторы для Redis
      Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<>(Object.class);
      ObjectMapper mapper = new ObjectMapper();
      mapper.registerModule(new JavaTimeModule());
      mapper.activateDefaultTyping(
          mapper.getPolymorphicTypeValidator(), 
          ObjectMapper.DefaultTyping.NON_FINAL,
          JsonTypeInfo.As.PROPERTY
      );
      serializer.setObjectMapper(mapper);
      
      template.setKeySerializer(new StringRedisSerializer());
      template.setValueSerializer(serializer);
      template.setHashKeySerializer(new StringRedisSerializer());
      template.setHashValueSerializer(serializer);
      
      return template;
  }
}

@Configuration
public class AuthorizationServerConfig {
 
  @Bean
  public RegisteredClientRepository registeredClientRepository() {
      RegisteredClient client = RegisteredClient.withId(UUID.randomUUID().toString())
          .clientId("demo-client")
          .clientSecret("{bcrypt}$2a$10$jdJGhzsiIqYFpjJiYWMl/eKDOd8vdyQis2aynmFN0dgJ53XvpzzwC") // secret
          .clientAuthenticationMethod(ClientAuthenticationMethod.CLIENT_SECRET_BASIC)
          .authorizationGrantType(AuthorizationGrantType.AUTHORIZATION_CODE)
          .authorizationGrantType(AuthorizationGrantType.REFRESH_TOKEN)
          .redirectUri("http://localhost:4200/callback")
          .scope("user.read")
          .scope("user.write")
          .tokenSettings(TokenSettings.builder()
              .accessTokenTimeToLive(Duration.ofHours(1))
              .refreshTokenTimeToLive(Duration.ofDays(30))
              .reuseRefreshTokens(false)
              .build())
          .clientSettings(ClientSettings.builder()
              .requireAuthorizationConsent(true)
              .build())
          .build();
 
      return new InMemoryRegisteredClientRepository(client);
  }
 
  @Bean
  public ProviderSettings providerSettings() {
      return ProviderSettings.builder()
          .issuer("http://auth-server:9000")
          .build();
  }
 
  @Bean
  public JWKSource<SecurityContext> jwkSource() {
      RSAKey rsaKey = generateRsa();
      JWKSet jwkSet = new JWKSet(rsaKey);
      return (jwkSelector, securityContext) -> jwkSelector.select(jwkSet);
  }
  
  // Утилитные методы для генерации ключей
}

@SpringBootTest
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
public class RedisTokenPersistenceTests {
 
    @Autowired
    private OAuth2AuthorizationService authorizationService;
    
    @Autowired
    private RegisteredClientRepository clientRepository;
    
    @Test
    public void whenTokenSaved_thenCanBeRetrieved() {
        // Arrange
        RegisteredClient client = clientRepository.findByClientId("demo-client");
        OAuth2Authorization authorization = createAuthorization(client);
        
        // Act
        authorizationService.save(authorization);
        OAuth2Authorization retrieved = 
            authorizationService.findById(authorization.getId());
        
        // Assert
        assertThat(retrieved).isNotNull();
        assertThat(retrieved.getAccessToken().getToken()).isEqualTo(
            authorization.getAccessToken().getToken());
    }
    
    // Вспомогательные методы...
}