Flux.just("user1", "user2", "user3")
    .flatMap(this::fetchUserDetailsAsync)
    .filter(user -> user.isActive())
    .subscribe(user -> System.out.println("Active user: " + user.getName()));

Generate a Spring Boot service that integrates with Redis to handle [caching / rate limiting / distributed locks / task queues] for [описание бизнес-логики].  
Include configuration, connection pooling, and example use cases.  
Ensure reliability with TTL management, error handling, and fallback mechanisms.  
Use Spring Data Redis or Lettuce/Jedis client. Explain the trade-offs of chosen technologies and patterns (e.g., Cache Aside, Write-Through).

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
  <groupId>io.jsonwebtoken</groupId>
  <artifactId>jjwt</artifactId>
  <version>0.11.5</version>
</dependency>

public class JwtTokenUtil {
    private static final String SECRET_KEY = "secretKey";

    public static String generateToken(String username) {
        return Jwts.builder()
                .setSubject(username)
                .setIssuedAt(new Date())
                .setExpiration(new Date(System.currentTimeMillis() + 1000 * 60 * 60))
                .signWith(SignatureAlgorithm.HS256, SECRET_KEY)
                .compact();
    }

    public static String getUsernameFromToken(String token) {
        return Jwts.parser().setSigningKey(SECRET_KEY).parseClaimsJws(token).getBody().getSubject();
    }

    public static boolean isTokenExpired(String token) {
        return getExpirationDateFromToken(token).before(new Date());
    }

    private static Date getExpirationDateFromToken(String token) {
        return Jwts.parser().setSigningKey(SECRET_KEY).parseClaimsJws(token).getBody().getExpiration();
    }

    public static boolean validateToken(String token, String username) {
        return (username.equals(getUsernameFromToken(token)) && !isTokenExpired(token));
    }
}

public class JwtAuthenticationFilter extends OncePerRequestFilter {
    private static final String HEADER_STRING = "Authorization";
    private static final String TOKEN_PREFIX = "Bearer ";

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        String header = request.getHeader(HEADER_STRING);
        
        if (header != null && header.startsWith(TOKEN_PREFIX)) {
            String token = header.substring(TOKEN_PREFIX.length());

            try {
                if (JwtTokenUtil.validateToken(token, JwtTokenUtil.getUsernameFromToken(token))) {
                    UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(
                            JwtTokenUtil.getUsernameFromToken(token), null, new ArrayList<>());
                    SecurityContextHolder.getContext().setAuthentication(authentication);
                }
            } catch (ExpiredJwtException e) {
                response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
            }
        }

        filterChain.doFilter(request, response);
    }
}

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable()
            .authorizeRequests()
            .antMatchers("/login").permitAll()
            .anyRequest().authenticated()
            .and()
            .addFilter(new JwtAuthenticationFilter());
    }
}

@RestController
public class AuthController {

    @PostMapping("/login")
    public String login(@RequestBody AuthRequest authRequest) {
        if ("admin".equals(authRequest.getUsername()) && "admin123".equals(authRequest.getPassword())) {
            return JwtTokenUtil.generateToken(authRequest.getUsername());
        }
        return "Invalid credentials";
    }
}

@Scheduled(fixedRate = 10_000)
public void cleanUp() {
    List<Job> jobs = jobRepository.findAllByStatus(PENDING);
    jobs.forEach(job -> {
        job.setStatus(PROCESSING);
        jobRepository.save(job);
    });
}

@Transactional
@Scheduled(fixedRate = 10_000)
public void cleanUp() {
    List<Job> jobs = jobRepository.findAllByStatusForUpdate(PENDING);
    ...
}

Generate a Spring Boot REST API for managing [сущность или бизнес-логика, например: product catalog, user profiles, task assignments].
Include CRUD endpoints, validation (Hibernate Validator), exception handling, DTO mapping (MapStruct or ModelMapper), and OpenAPI documentation.
Ensure security with JWT-based authentication and role-based access control (Spring Security).
Use layered architecture (Controller → Service → Repository) and follow clean code principles. Add unit tests for controller and service layers.

class ConfigService {
    public Config getCurrentConfig();      // read-only, вызывается часто
    public void reload();                 // обновить конфиг, редко
}