@Component
public class UserContext {
    private static final ThreadLocal<String> currentUserId = new ThreadLocal<>();

    public static void set(String userId) { currentUserId.set(userId); }
    public static String get() { return currentUserId.get(); }
    public static void clear() { currentUserId.remove(); }
}

@Service
@RequiredArgsConstructor
public class OrderService {
    private final AuditLogger auditLogger;

    public CompletableFuture<Order> createOrder(String userId, OrderDto dto) {
        UserContext.set(userId);

        return CompletableFuture.supplyAsync(() -> {
            Order order = buildOrder(dto);
            auditLogger.log("Order created by: " + UserContext.get());
            return order;
        });
    }
}

propertiesspring.threads.virtual.enabled=true

@Service
@RequiredArgsConstructor
public class WithdrawalService {

    private final AccountRepository accountRepository;
    private final WithdrawalRepository withdrawalRepository;

    public void requestWithdrawal(Long userId, BigDecimal amount) {
        Account account = accountRepository.findByUserId(userId)
            .orElseThrow();

        if (account.getBalance().compareTo(amount) < 0) {
            throw new InsufficientFundsException();
        }

        boolean hasPending = withdrawalRepository
            .existsByUserIdAndStatus(userId, Status.PENDING);

        if (hasPending) {
            throw new WithdrawalAlreadyPendingException();
        }

        account.setBalance(account.getBalance().subtract(amount));
        accountRepository.save(account);

        withdrawalRepository.save(
            new Withdrawal(userId, amount, Status.PENDING)
        );
    }
}

@Service
@RequiredArgsConstructor
public class UserProfileService {

    private final UserRepository userRepository;
    private final RedisTemplate<String, UserProfile> redisTemplate;

    private static final Duration TTL = Duration.ofMinutes(5);

    public UserProfile getProfile(Long userId) {
        String key = "profile:" + userId;

        UserProfile cached = redisTemplate.opsForValue().get(key);
        if (cached != null) {
            return cached;
        }

        UserProfile profile = userRepository.findById(userId)
            .map(UserProfile::from)
            .orElseThrow(UserNotFoundException::new);

        redisTemplate.opsForValue().set(key, profile, TTL);
        return profile;
    }
}