HTTP/3 и Java

var client = HttpClient.newBuilder()
    .version(HttpClient.Version.HTTP_3)
    .connectTimeout(Duration.ofSeconds(5))
    .build();

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;
 
public class SimpleHttp3Client {
    public static void main(String[] args) throws Exception {
        // Создаем клиент с поддержкой HTTP/3
        var client = HttpClient.newBuilder()
            .version(HttpClient.Version.HTTP_3)
            .connectTimeout(Duration.ofSeconds(10))
            .build();
        
        // Формируем GET-запрос
        var request = HttpRequest.newBuilder()
            .uri(URI.create("https://www.google.com"))
            .GET()
            .build();
        
        // Отправляем синхронно и получаем ответ
        var response = client.send(request, 
            HttpResponse.BodyHandlers.ofString());
        
        System.out.println("Статус: " + response.statusCode());
        System.out.println("Версия: " + response.version());
        System.out.println("Тело ответа: " + 
            response.body().substring(0, 200));
    }
}

public class RobustHttp3Client {
    private final HttpClient http3Client;
    private final HttpClient http2Client;
    
    public RobustHttp3Client() {
        // Клиент с приоритетом HTTP/3
        this.http3Client = HttpClient.newBuilder()
            .version(HttpClient.Version.HTTP_3)
            .connectTimeout(Duration.ofSeconds(5))
            .build();
        
        // Запасной клиент для HTTP/2
        this.http2Client = HttpClient.newBuilder()
            .version(HttpClient.Version.HTTP_2)
            .connectTimeout(Duration.ofSeconds(10))
            .build();
    }
    
    public HttpResponse<String> fetch(String url) throws Exception {
        var request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .GET()
            .build();
        
        try {
            // Пытаемся через HTTP/3
            return http3Client.send(request, 
                HttpResponse.BodyHandlers.ofString());
        } catch (ConnectException e) {
            // Откатываемся на HTTP/2 при проблемах соединения
            System.err.println("HTTP/3 недоступен, используем HTTP/2");
            return http2Client.send(request, 
                HttpResponse.BodyHandlers.ofString());
        }
    }
}

private final Map<String, Boolean> http3Support = 
    new ConcurrentHashMap<>();
 
private boolean supportsHttp3(String host) {
    return http3Support.computeIfAbsent(host, h -> {
        try {
            var probe = HttpRequest.newBuilder()
                .uri(URI.create("https://" + h))
                .timeout(Duration.ofSeconds(2))
                .GET()
                .build();
            http3Client.send(probe, HttpResponse.BodyHandlers.discarding());
            return true;
        } catch (Exception e) {
            return false;
        }
    });
}

CompletableFuture<HttpResponse<String>> future = 
    client.sendAsync(request, HttpResponse.BodyHandlers.ofString());
 
future.thenAccept(response -> {
    // Обработка в отдельном потоке
    System.out.println("Получен ответ: " + response.statusCode());
}).exceptionally(error -> {
    System.err.println("Ошибка: " + error.getMessage());
    return null;
});

// Создаем executor с настроенным количеством carrier threads
var executor = Executors.newThreadPerTaskExecutor(
    Thread.ofVirtual()
        .name("http3-worker-", 0)
        .factory()
);
 
var client = HttpClient.newBuilder()
    .version(HttpClient.Version.HTTP_3)
    .executor(executor)
    .build();

try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
    // Запускаем несколько запросов параллельно
    var future1 = scope.fork(() -> 
        client.send(request1, HttpResponse.BodyHandlers.ofString()));
    var future2 = scope.fork(() -> 
        client.send(request2, HttpResponse.BodyHandlers.ofString()));
    var future3 = scope.fork(() -> 
        client.send(request3, HttpResponse.BodyHandlers.ofString()));
    
    // Ждем завершения всех или первой ошибки
    scope.join();
    scope.throwIfFailed();
    
    // Обрабатываем результаты
    var result1 = future1.resultNow();
    var result2 = future2.resultNow();
    var result3 = future3.resultNow();
} catch (Exception e) {
    // Все незавершенные запросы автоматически отменяются
    System.err.println("Ошибка при параллельных запросах: " + e);
}

// Включаем JFR для виртуальных потоков
jcmd <pid> JFR.start name=vthreads settings=profile

Runtime.getRuntime().addShutdownHook(new Thread(() -> {
    executor.shutdown();
    try {
        if (!executor.awaitTermination(30, TimeUnit.SECONDS)) {
            executor.shutdownNow();
        }
    } catch (InterruptedException e) {
        executor.shutdownNow();
    }
}));

import org.xbill.DNS.*;
 
public class Http3Discovery {
    public static boolean checkHttp3Support(String hostname) {
        try {
            // Запрашиваем HTTPS-запись из DNS
            Lookup lookup = new Lookup(hostname, Type.HTTPS);
            Record[] records = lookup.run();
            
            if (records == null) {
                return false;
            }
            
            // Ищем альтернативный протокол h3
            for (Record record : records) {
                String recordData = record.rdataToString();
                if (recordData.contains("alpn=h3") || 
                    recordData.contains("alpn=\"h3\"")) {
                    return true;
                }
            }
        } catch (TextParseException e) {
            // Некорректное имя хоста
            return false;
        }
        return false;
    }
}

public class AltSvcDetector {
    private final Map<String, Http3Endpoint> altSvcCache = 
        new ConcurrentHashMap<>();
    
    public Optional<Http3Endpoint> detectHttp3(String host) {
        // Проверяем кеш
        if (altSvcCache.containsKey(host)) {
            return Optional.of(altSvcCache.get(host));
        }
        
        try {
            // Делаем пробный HTTP/2 запрос
            var client = HttpClient.newBuilder()
                .version(HttpClient.Version.HTTP_2)
                .build();
            
            var request = HttpRequest.newBuilder()
                .uri(URI.create("https://" + host))
                .timeout(Duration.ofSeconds(3))
                .GET()
                .build();
            
            var response = client.send(request, 
                HttpResponse.BodyHandlers.discarding());
            
            // Ищем Alt-Svc заголовок
            response.headers().firstValue("alt-svc")
                .ifPresent(altSvc -> parseAltSvc(host, altSvc));
            
            return Optional.ofNullable(altSvcCache.get(host));
        } catch (Exception e) {
            return Optional.empty();
        }
    }
    
    private void parseAltSvc(String host, String header) {
        // Парсим что-то вроде: h3=":443"; ma=2592000
        if (header.contains("h3=")) {
            // Извлекаем порт и время жизни записи
            altSvcCache.put(host, new Http3Endpoint(host, 443, 
                Instant.now().plusSeconds(2592000)));
        }
    }
}

public class AdaptiveFallbackClient {
    private final AtomicReference<Duration> measuredRtt = 
        new AtomicReference<>(Duration.ofSeconds(2));
    
    private HttpClient createClient() {
        // Используем измеренный RTT для таймаута
        Duration timeout = measuredRtt.get().multipliedBy(3);
        
        return HttpClient.newBuilder()
            .version(HttpClient.Version.HTTP_3)
            .connectTimeout(timeout)
            .build();
    }
    
    public HttpResponse<String> sendWithFallback(HttpRequest request) 
            throws IOException, InterruptedException {
        long startTime = System.nanoTime();
        
        try {
            var response = createClient().send(request, 
                HttpResponse.BodyHandlers.ofString());
            
            // Обновляем измеренный RTT на основе успешного соединения
            if (response.version() == HttpClient.Version.HTTP_3) {
                Duration actualRtt = Duration.ofNanos(
                    System.nanoTime() - startTime).dividedBy(2);
                measuredRtt.set(actualRtt);
            }
            
            return response;
        } catch (ConnectException e) {
            // HTTP/3 недоступен, используем HTTP/2
            var http2Client = HttpClient.newBuilder()
                .version(HttpClient.Version.HTTP_2)
                .build();
            return http2Client.send(request, 
                HttpResponse.BodyHandlers.ofString());
        }
    }
}

private final Map<String, ProtocolCapabilities> capabilitiesCache = 
    new ConcurrentHashMap<>();
 
private HttpClient selectClient(String host) {
    var capabilities = capabilitiesCache.computeIfAbsent(host, 
        h -> new ProtocolCapabilities(host));
    
    // Проверяем, не устарела ли информация
    if (capabilities.isStale()) {
        capabilities.refresh();
    }
    
    // Выбираем версию протокола на основе известных возможностей
    HttpClient.Version version = capabilities.bestSupportedVersion();
    
    return HttpClient.newBuilder()
        .version(version)
        .build();
}

// Базовая конфигурация с явными таймаутами
var client = HttpClient.newBuilder()
    .version(HttpClient.Version.HTTP_3)
    .connectTimeout(Duration.ofSeconds(5))
    .followRedirects(HttpClient.Redirect.NORMAL)
    .build();
 
// Запрос с индивидуальным таймаутом
var request = HttpRequest.newBuilder()
    .uri(URI.create("https://example.com/api"))
    .timeout(Duration.ofSeconds(10)) // переопределяет общий таймаут
    .header("User-Agent", "MyApp/1.0")
    .GET()
    .build();

var sslContext = SSLContext.getInstance("TLSv1.3");
sslContext.init(null, trustManagers, new SecureRandom());
 
var client = HttpClient.newBuilder()
    .version(HttpClient.Version.HTTP_3)
    .sslContext(sslContext)
    .build();

// Прокси только для HTTP/2, HTTP/3 идет напрямую
var proxy = ProxySelector.of(
    new InetSocketAddress("proxy.corp.com", 8080));
 
var client = HttpClient.newBuilder()
    .proxy(proxy) // игнорируется для HTTP/3
    .authenticator(new Authenticator() {
        @Override
        protected PasswordAuthentication getPasswordAuthentication() {
            return new PasswordAuthentication("user", 
                "password".toCharArray());
        }
    })
    .build();

public class SmartHttp3Client {
    private final Map<String, HostStats> statistics = new ConcurrentHashMap<>();
    
    private static class HostStats {
        private final AtomicInteger attempts = new AtomicInteger(0);
        private final AtomicInteger failures = new AtomicInteger(0);
        private volatile Instant lastCheck = Instant.now();
        
        boolean shouldTryHttp3() {
            // Если больше 30% фейлов за последний час - используем HTTP/2
            if (Duration.between(lastCheck, Instant.now()).toHours() >= 1) {
                // Сбрасываем статистику раз в час для переопределения
                attempts.set(0);
                failures.set(0);
                lastCheck = Instant.now();
            }
            
            int totalAttempts = attempts.get();
            if (totalAttempts < 10) {
                return true; // недостаточно данных, пробуем
            }
            
            double failureRate = (double) failures.get() / totalAttempts;
            return failureRate < 0.3;
        }
        
        void recordAttempt(boolean success) {
            attempts.incrementAndGet();
            if (!success) {
                failures.incrementAndGet();
            }
        }
    }
}

public class AggregationService {
    private final SmartHttpClient httpClient;
    private final ExecutorService virtualThreadPool;
    
    public AggregationService() {
        // Используем виртуальные потоки для параллельных запросов
        this.virtualThreadPool = Executors.newVirtualThreadPerTaskExecutor();
        this.httpClient = new SmartHttpClient();
    }
    
    public UserSummary aggregateUserData(String userId) throws Exception {
        // Три параллельных запроса через structured concurrency
        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            
            // Запрос профиля пользователя
            var profileFuture = scope.fork(() -> 
                fetchProfile(userId));
            
            // Запрос истории транзакций
            var transactionsFuture = scope.fork(() -> 
                fetchTransactions(userId));
            
            // Запрос аналитики активности
            var analyticsFuture = scope.fork(() -> 
                fetchAnalytics(userId));
            
            // Ждем завершения всех или первой ошибки
            scope.join();
            scope.throwIfFailed();
            
            // Собираем результаты
            return new UserSummary(
                profileFuture.resultNow(),
                transactionsFuture.resultNow(),
                analyticsFuture.resultNow()
            );
        }
    }
    
    private UserProfile fetchProfile(String userId) throws Exception {
        var request = HttpRequest.newBuilder()
            .uri(URI.create("https://users.api.internal/profile/" + userId))
            .timeout(Duration.ofSeconds(5))
            .GET()
            .build();
        
        var response = httpClient.sendSmart(request);
        
        if (response.statusCode() != 200) {
            throw new ServiceException("Profile service unavailable");
        }
        
        return parseJson(response.body(), UserProfile.class);
    }
    
    private List<Transaction> fetchTransactions(String userId) throws Exception {
        var request = HttpRequest.newBuilder()
            .uri(URI.create("https://payments.api.internal/transactions/" + userId))
            .timeout(Duration.ofSeconds(3))
            .GET()
            .build();
        
        var response = httpClient.sendSmart(request);
        
        if (response.statusCode() != 200) {
            // Транзакции некритичны, возвращаем пустой список
            return Collections.emptyList();
        }
        
        return parseJsonList(response.body(), Transaction.class);
    }
    
    private AnalyticsData fetchAnalytics(String userId) throws Exception {
        var request = HttpRequest.newBuilder()
            .uri(URI.create("https://analytics.api.internal/activity/" + userId))
            .timeout(Duration.ofSeconds(4))
            .GET()
            .build();
        
        var response = httpClient.sendSmart(request);
        
        if (response.statusCode() != 200) {
            // Аналитика тоже необязательна
            return AnalyticsData.empty();
        }
        
        return parseJson(response.body(), AnalyticsData.class);
    }
}

public class SmartHttpClient {
    private final HttpClient http3Client;
    private final HttpClient http2Client;
    private final Map<String, ProtocolCapability> hostCapabilities;
    
    public SmartHttpClient() {
        this.http3Client = HttpClient.newBuilder()
            .version(HttpClient.Version.HTTP_3)
            .connectTimeout(Duration.ofSeconds(2))
            .executor(Executors.newVirtualThreadPerTaskExecutor())
            .build();
            
        this.http2Client = HttpClient.newBuilder()
            .version(HttpClient.Version.HTTP_2)
            .connectTimeout(Duration.ofSeconds(5))
            .build();
            
        this.hostCapabilities = new ConcurrentHashMap<>();
    }
    
    public HttpResponse<String> sendSmart(HttpRequest request) 
            throws IOException, InterruptedException {
        
        String host = request.uri().getHost();
        var capability = hostCapabilities.computeIfAbsent(host, 
            h -> new ProtocolCapability());
        
        // Проверяем, стоит ли пробовать HTTP/3
        if (capability.shouldTryHttp3()) {
            try {
                var response = http3Client.send(request, 
                    HttpResponse.BodyHandlers.ofString());
                
                // Успех - обновляем статистику
                capability.recordSuccess(true);
                return response;
                
            } catch (ConnectException | HttpTimeoutException e) {
                // HTTP/3 не работает - запоминаем и пробуем HTTP/2
                capability.recordSuccess(false);
            }
        }
        
        // Откатываемся на HTTP/2
        return http2Client.send(request, 
            HttpResponse.BodyHandlers.ofString());
    }
    
    private static class ProtocolCapability {
        private final AtomicInteger successCount = new AtomicInteger(0);
        private final AtomicInteger failureCount = new AtomicInteger(0);
        private volatile Instant lastReset = Instant.now();
        
        boolean shouldTryHttp3() {
            // Сбрасываем статистику каждый час для переопределения
            if (Duration.between(lastReset, Instant.now()).toHours() >= 1) {
                successCount.set(0);
                failureCount.set(0);
                lastReset = Instant.now();
                return true;
            }
            
            int total = successCount.get() + failureCount.get();
            if (total < 5) {
                return true; // Мало данных, пробуем
            }
            
            // Если больше 40% фейлов - не пытаемся
            double failRate = (double) failureCount.get() / total;
            return failRate < 0.4;
        }
        
        void recordSuccess(boolean success) {
            if (success) {
                successCount.incrementAndGet();
            } else {
                failureCount.incrementAndGet();
            }
        }
    }
}

public class Http3ConnectionPool {
    private final HttpClient sharedClient;
    private final Semaphore connectionLimiter;
    private final Map<String, ConnectionMetrics> metricsPerHost;
    
    public Http3ConnectionPool(int maxConcurrentConnections) {
        // Единственный клиент для всего приложения
        this.sharedClient = HttpClient.newBuilder()
            .version(HttpClient.Version.HTTP_3)
            .connectTimeout(Duration.ofSeconds(3))
            .executor(Executors.newVirtualThreadPerTaskExecutor())
            .build();
        
        // Ограничиваем общее количество одновременных операций
        this.connectionLimiter = new Semaphore(maxConcurrentConnections);
        this.metricsPerHost = new ConcurrentHashMap<>();
    }
    
    public <T> T executeRequest(HttpRequest request, 
            HttpResponse.BodyHandler<T> handler) throws Exception {
        
        String host = request.uri().getHost();
        var metrics = metricsPerHost.computeIfAbsent(host, 
            h -> new ConnectionMetrics());
        
        // Берем permit перед выполнением
        connectionLimiter.acquire();
        long startTime = System.nanoTime();
        
        try {
            metrics.incrementActive();
            var response = sharedClient.send(request, handler);
            
            long duration = System.nanoTime() - startTime;
            metrics.recordLatency(duration);
            
            return response.body();
            
        } finally {
            metrics.decrementActive();
            connectionLimiter.release();
        }
    }
    
    private static class ConnectionMetrics {
        private final AtomicInteger activeRequests = new AtomicInteger(0);
        private final LongAdder totalLatency = new LongAdder();
        private final LongAdder requestCount = new LongAdder();
        
        void incrementActive() {
            activeRequests.incrementAndGet();
        }
        
        void decrementActive() {
            activeRequests.decrementAndGet();
        }
        
        void recordLatency(long nanos) {
            totalLatency.add(nanos);
            requestCount.increment();
        }
        
        double getAverageLatencyMs() {
            long count = requestCount.sum();
            if (count == 0) return 0;
            return totalLatency.sum() / (double) count / 1_000_000;
        }
        
        int getActiveCount() {
            return activeRequests.get();
        }
    }
}

public interface ConnectionPoolMXBean {
    int getTotalActiveRequests();
    Map<String, Double> getAverageLatenciesByHost();
    Map<String, Integer> getActiveRequestsByHost();
}
 
@ManagedResource
public class ConnectionPoolMonitor implements ConnectionPoolMXBean {
    private final Http3ConnectionPool pool;
    
    @ManagedAttribute
    public int getTotalActiveRequests() {
        return pool.getAllMetrics().values().stream()
            .mapToInt(ConnectionMetrics::getActiveCount)
            .sum();
    }
    
    @ManagedAttribute
    public Map<String, Double> getAverageLatenciesByHost() {
        return pool.getAllMetrics().entrySet().stream()
            .collect(Collectors.toMap(
                Map.Entry::getKey,
                e -> e.getValue().getAverageLatencyMs()
            ));
    }
}

public class TenantAwareConnectionPool {
    private final HttpClient sharedClient;
    private final Map<String, Semaphore> tenantLimits;
    private final int maxConnectionsPerTenant;
    
    public TenantAwareConnectionPool(int maxPerTenant) {
        this.sharedClient = HttpClient.newBuilder()
            .version(HttpClient.Version.HTTP_3)
            .executor(Executors.newVirtualThreadPerTaskExecutor())
            .build();
        
        this.tenantLimits = new ConcurrentHashMap<>();
        this.maxConnectionsPerTenant = maxPerTenant;
    }
    
    public <T> T executeForTenant(String tenantId, HttpRequest request,
            HttpResponse.BodyHandler<T> handler) throws Exception {
        
        // Получаем или создаем семафор для тенанта
        var tenantSemaphore = tenantLimits.computeIfAbsent(tenantId,
            id -> new Semaphore(maxConnectionsPerTenant, true));
        
        // Пытаемся захватить permit с таймаутом
        boolean acquired = tenantSemaphore.tryAcquire(
            500, TimeUnit.MILLISECONDS);
        
        if (!acquired) {
            throw new TenantQuotaExceededException(
                "Tenant " + tenantId + " exceeded connection limit");
        }
        
        try {
            return sharedClient.send(request, handler).body();
        } finally {
            tenantSemaphore.release();
        }
    }
}

public class ResilientHttp3Client {
    private final HttpClient client;
    private final CircuitBreaker circuitBreaker;
    
    public <T> T executeWithRetry(HttpRequest request,
            HttpResponse.BodyHandler<T> handler, int maxRetries) {
        
        Exception lastError = null;
        
        for (int attempt = 0; attempt <= maxRetries; attempt++) {
            // Проверяем состояние circuit breaker
            if (!circuitBreaker.allowRequest()) {
                throw new CircuitOpenException(
                    "Circuit breaker is open, rejecting request");
            }
            
            try {
                long startTime = System.currentTimeMillis();
                var response = client.send(request, handler);
                
                long duration = System.currentTimeMillis() - startTime;
                circuitBreaker.recordSuccess(duration);
                
                return response.body();
                
            } catch (HttpTimeoutException e) {
                // Таймаут - возможно сеть перегружена, стоит повторить
                lastError = e;
                circuitBreaker.recordFailure();
                
                if (attempt < maxRetries) {
                    // Exponential backoff
                    Thread.sleep((long) Math.pow(2, attempt) * 100);
                }
                
            } catch (ConnectException e) {
                // HTTP/3 недоступен - откатываемся немедленно без retry
                throw new Http3UnavailableException(
                    "Failed to establish QUIC connection", e);
                
            } catch (IOException e) {
                // Общая сетевая проблема
                lastError = e;
                circuitBreaker.recordFailure();
                
                // Для идемпотентных запросов пробуем еще
                if (isIdempotent(request) && attempt < maxRetries) {
                    Thread.sleep(200);
                } else {
                    throw e;
                }
            }
        }
        
        throw new MaxRetriesExceededException(
            "Failed after " + maxRetries + " attempts", lastError);
    }
    
    private boolean isIdempotent(HttpRequest request) {
        String method = request.method();
        return "GET".equals(method) || "HEAD".equals(method) || 
               "PUT".equals(method) || "DELETE".equals(method);
    }
}

public class BackwardCompatibleHttpClient {
    private final HttpClient legacyClient;
    private final HttpClient modernClient;
    private final Set<String> http3Whitelist;
    
    public BackwardCompatibleHttpClient() {
        // Старый клиент остается как есть
        this.legacyClient = HttpClient.newBuilder()
            .version(HttpClient.Version.HTTP_2)
            .build();
        
        // Новый клиент для проверенных хостов
        this.modernClient = HttpClient.newBuilder()
            .version(HttpClient.Version.HTTP_3)
            .connectTimeout(Duration.ofSeconds(2))
            .build();
        
        // Белый список хостов с подтвержденной поддержкой HTTP/3
        this.http3Whitelist = ConcurrentHashMap.newKeySet();
        loadWhitelistFromConfig();
    }
    
    public HttpResponse<String> send(HttpRequest request) 
            throws IOException, InterruptedException {
        
        String host = request.uri().getHost();
        
        // Проверенные хосты идут через HTTP/3
        if (http3Whitelist.contains(host)) {
            try {
                return modernClient.send(request, 
                    HttpResponse.BodyHandlers.ofString());
            } catch (ConnectException e) {
                // Убираем из белого списка при проблемах
                http3Whitelist.remove(host);
            }
        }
        
        // Остальное через проверенный путь
        return legacyClient.send(request, 
            HttpResponse.BodyHandlers.ofString());
    }
}