Explain the Load Balancer and the Rate Limiter

package com.bank.loadbalancer;

import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

public class SimpleRoundRobin {

    private final List<String> backends;
    private final AtomicInteger index = new AtomicInteger(0);

    public SimpleRoundRobin(List<String> backends) {
        this.backends = backends;
    }

    public String route() {
        return backends.get(index.getAndIncrement() % backends.size());
    }

    public static void main(String[] args) {
        var lb = new SimpleRoundRobin(
            List.of("payment-1:8080", "payment-2:8080", "payment-3:8080"));
        for (int i = 0; i < 6; i++) {
            System.out.println("Request " + (i + 1) + " -> " + lb.route());
        }
    }
}

Expected output:
Request 1 -> payment-1:8080
Request 2 -> payment-2:8080
Request 3 -> payment-3:8080
Request 4 -> payment-1:8080
Request 5 -> payment-2:8080
Request 6 -> payment-3:8080

package com.bank.ratelimit;

import java.math.BigDecimal;
import java.util.concurrent.atomic.AtomicLong;
import java.util.logging.Logger;

public class SimpleTokenBucket {

    private static final Logger LOG = Logger.getLogger(SimpleTokenBucket.class.getName());
    private final long capacity;
    private final long refillRate; // tokens per second
    private AtomicLong tokens;
    private long lastRefillTimestamp;

    public SimpleTokenBucket(long capacity, long refillRate) {
        this.capacity = capacity;
        this.refillRate = refillRate;
        this.tokens = new AtomicLong(capacity);
        this.lastRefillTimestamp = System.nanoTime();
    }

    public synchronized boolean tryConsume() {
        refill();
        if (tokens.get() > 0) {
            tokens.decrementAndGet();
            return true;
        }
        return false; // 429 Too Many Requests
    }

    private void refill() {
        long now = System.nanoTime();
        long elapsed = (now - lastRefillTimestamp) / 1_000_000_000;
        long newTokens = elapsed * refillRate;
        tokens.set(Math.min(capacity, tokens.get() + newTokens));
        lastRefillTimestamp = now;
    }

    public static void main(String[] args) {
        var bucket = new SimpleTokenBucket(5, 2); // 5 capacity, 2/sec refill
        for (int i = 0; i < 8; i++) {
            boolean allowed = bucket.tryConsume();
            LOG.info("Request " + (i + 1) + ": " + (allowed ? "ALLOWED" : "REJECTED (429)"));
        }
    }
}

Expected output:
Request 1: ALLOWED
Request 2: ALLOWED
Request 3: ALLOWED
Request 4: ALLOWED
Request 5: ALLOWED
Request 6: REJECTED (429)
Request 7: REJECTED (429)
Request 8: REJECTED (429)

package com.bank.ratelimit;

import io.github.bucket4j.Bandwidth;
import io.github.bucket4j.Bucket;
import io.github.bucket4j.BucketConfiguration;
import io.github.bucket4j.distributed.proxy.ProxyManager;
import java.time.Duration;
import java.util.function.Supplier;

public class DistributedRateLimiter {

    private final ProxyManager<String> proxyManager; // backed by Redis

    public DistributedRateLimiter(ProxyManager<String> proxyManager) {
        this.proxyManager = proxyManager;
    }

    public boolean isAllowed(String userId) {
        Supplier<BucketConfiguration> config = () -> BucketConfiguration.builder()
            .addLimit(Bandwidth.simple(100, Duration.ofMinutes(1))) // 100 req/min
            .build();

        Bucket bucket = proxyManager.builder()
            .build("rate:" + userId, config);

        return bucket.tryConsume(1);
        // All 5 gateway instances share this Redis-backed bucket.
        // Total limit: 100/min per user across the entire fleet.
    }
}

WRONG: Per-instance counters
  5 instances x 100 limit = 500 effective limit per user

CORRECT: Shared Redis counter
  5 instances sharing 1 Redis bucket = 100 effective limit per user

package com.bank.antipattern;

// WRONG: Local counter per instance. 5 instances = 5x the intended limit.
public class WrongRateLimiter {
    private int count = 0; // per-instance
    public boolean allow() { return ++count <= 100; }
}

// CORRECT: Shared counter in Redis. Limit holds across the whole fleet.
// Use Bucket4j backed by Redis via Redisson or Spring Cloud Gateway
// RedisRateLimiter with key-resolver by user ID.