Паттерны использования

Модификация элементов на лету

public static void transformStrings(List<String> strings) {
    ListIterator<String> iterator = strings.listIterator();
    
    while (iterator.hasNext()) {
        String original = iterator.next();
        String transformed = original.toUpperCase();
        iterator.set(transformed);
    }
}

Условная замена

public static void replaceIf(List<Integer> numbers, Predicate<Integer> condition, Integer replacement) {
    ListIterator<Integer> iterator = numbers.listIterator();
    
    while (iterator.hasNext()) {
        Integer current = iterator.next();
        if (condition.test(current)) {
            iterator.set(replacement);
        }
    }
}

Коррекция данных

public static void correctDataSequence(List<DataPoint> data) {
    if (data.isEmpty()) return;
    
    ListIterator<DataPoint> iterator = data.listIterator();
    DataPoint previous = iterator.next();
    
    while (iterator.hasNext()) {
        DataPoint current = iterator.next();
        
        // Коррекция аномальных значений
        if (isAnomaly(current, previous)) {
            DataPoint corrected = interpolate(previous, current);
            iterator.set(corrected);
        }
        
        previous = current;
    }
}

add(E e): Вставка нового элемента

Концептуальное назначение
Метод add(E e) представляет собой наиболее мощную операцию ListIterator — он позволяет вставлять новые элементы в список непосредственно перед элементом, который будет возвращен следующим вызовом next(). Это уникальная возможность, недоступная в базовом Iterator.

Семантика и поведение

Позиция вставки: Элемент вставляется перед элементом, который будет возвращен next(), или в конец списка, если next() вернет NoSuchElementException.
Влияние на итератор: После вставки последующий вызов next() вернет новый элемент, а previous() вернет только что вставленный элемент.
Состояние: Сбрасывает состояние lastReturned, поэтому последующий вызов remove() или set() выбросит исключение до следующего вызова next() или previous().

Внутренние механизмы реализации

Общий алгоритм

public void add(E e) {
    checkForComodification();
    
    try {
        int i = cursor;
        // Вставка в список
        list.add(i, e);
        
        // Корректировка состояния итератора
        cursor = i + 1;
        lastReturned = null;
        nextIndex++;
        expectedModCount = modCount;
    } catch (IndexOutOfBoundsException ex) {
        throw new ConcurrentModificationException();
    }
}

Реализация для ArrayList

public void add(E e) {
    checkForComodification();
    
    try {
        int i = cursor;
        ArrayList.this.add(i, e);
        cursor = i + 1;
        lastReturned = null;
        expectedModCount = modCount;
    } catch (IndexOutOfBoundsException ex) {
        throw new ConcurrentModificationException();
    }
}

Особенности:
Вызов ArrayList.add(index, element) со сдвигом элементов
Корректировка курсора и счетчиков
Обработка возможного расширения массива

Реализация для LinkedList

public void add(E e) {
    checkForComodification();
    lastReturned = null;
    
    if (next == null) {
        // Вставка в конец
        linkLast(e);
    } else {
        // Вставка перед next
        linkBefore(e, next);
    }
    
    nextIndex++;
    expectedModCount++;
}

Особенности:
Эффективная вставка за O(1) после нахождения позиции
Манипуляции со ссылками между узлами
Автоматическая обработка граничных условий

Особенности производительности

Временная сложность:
ArrayList: O(n) — требуется сдвиг элементов
LinkedList: O(1) — вставка в найденную позицию
Память: Создает новый объект узла (LinkedList) или может вызвать расширение массива (ArrayList).
Потокобезопасность: Не является потокобезопасным.


#Java #для_новичков #beginner #ListIterator

                                                             BiFunction<T, T, T> lookaheadProcessor,
                                                             BiFunction<T, T, T> lookbehindProcessor) {
        if (list.size() < 2) return;
        
        ListIterator<T> iterator = list.listIterator();
        
        // Обработка с lookahead
        while (iterator.hasNext()) {
            int currentIndex = iterator.nextIndex();
            T current = iterator.next();
            
            if (iterator.hasNext()) {
                // Есть следующий элемент для lookahead
                T lookahead = iterator.next();
                T processed = lookaheadProcessor.apply(current, lookahead);
                
                // Возвращаемся и заменяем текущий элемент
                iterator.previous(); // К lookahead
                iterator.previous(); // К current
                iterator.set(processed);
                iterator.next(); // К lookahead
                iterator.next(); // К следующему элементу для продолжения
            }
        }
        
        // Обработка с lookbehind
        while (iterator.hasPrevious()) {
            T current = iterator.previous();
            
            if (iterator.hasPrevious()) {
                T lookbehind = iterator.previous();
                T processed = lookbehindProcessor.apply(current, lookbehind);
                
                // Возвращаемся и заменяем
                iterator.next(); // К lookbehind
                iterator.next(); // К current
                iterator.set(processed);
                iterator.previous(); // К lookbehind для продолжения
            }
        }
    }
}

Управление состоянием и переходы

Диаграмма состояний ListIterator

Состояния:
1. Инициализация: lastReturned = null, cursor = 0
2. После next(): lastReturned = элемент, cursor = nextIndex
3. После previous(): lastReturned = элемент, cursor = previousIndex + 1
4. После remove(): lastReturned = null
5. После set(): lastReturned остается установленным
6. После add(): lastReturned = null, cursor увеличивается на 1

Допустимые переходы:
- next() → remove() ✓, set() ✓, add() ✓
- previous() → remove() ✓, set() ✓, add() ✓
- remove() → next() ✓, previous() ✓, add() ✗, set() ✗, remove() ✗
- set() → next() ✓, previous() ✓, remove() ✗, add() ✗
- add() → next() ✓, previous() ✓, remove() ✗, set() ✗

Валидация последовательности операций

public class ListIteratorValidator {
    
    public static <T> boolean validateOperationSequence(ListIterator<T> iterator, 
                                                       List<String> operations) {
        boolean canRemoveOrSet = false;
        
        for (String op : operations) {
            switch (op) {
                case "next":
                    if (!iterator.hasNext()) return false;
                    iterator.next();
                    canRemoveOrSet = true;
                    break;
                    
                case "previous":
                    if (!iterator.hasPrevious()) return false;
                    iterator.previous();
                    canRemoveOrSet = true;
                    break;
                    
                case "remove":
                    if (!canRemoveOrSet) return false;
                    iterator.remove();
                    canRemoveOrSet = false;
                    break;
                    
                case "set":
                    if (!canRemoveOrSet) return false;
                    // Необходим элемент для замены
                    iterator.set(null); // Упрощенная проверка
                    canRemoveOrSet = false;
                    break;
                    
                case "add":
                    iterator.add(null); // Всегда допустимо
                    canRemoveOrSet = false;
                    break;
                    
                default:
                    return false;
            }
        }
        
        return true;
    }
}

#Java #для_новичков #beginner #ListIterator

Оптимизированные паттерны использования

Эффективное использование для ArrayList

public class ArrayListOptimizations {
    
    // Избегайте частых add() и remove() в середине списка
    public static void efficientArrayListProcessing(List<String> list) {
        // Вместо множественных add() через ListIterator
        // Собирайте изменения и применяйте их пакетно
        
        List<String> toAdd = new ArrayList<>();
        ListIterator<String> iterator = list.listIterator();
        
        while (iterator.hasNext()) {
            String current = iterator.next();
            if (shouldDuplicate(current)) {
                toAdd.add(current + "_copy");
            }
        }
        
        // Пакетное добавление в конец
        list.addAll(toAdd);
    }
    
    // Используйте set() вместо remove() + add() для замены
    public static void replaceEfficiently(List<Integer> numbers) {
        ListIterator<Integer> iterator = numbers.listIterator();
        
        while (iterator.hasNext()) {
            Integer current = iterator.next();
            if (current % 2 == 0) {
                iterator.set(current * 2); // Эффективнее, чем remove() + add()
            }
        }
    }
}

Эффективное использование для LinkedList

public class LinkedListOptimizations {
    
    // LinkedList идеально подходит для частых вставок/удалений через ListIterator
    public static void efficientLinkedListProcessing(LinkedList<String> list) {
        ListIterator<String> iterator = list.listIterator();
        
        // Частые вставки эффективны
        while (iterator.hasNext()) {
            String current = iterator.next();
            if (requiresPrefix(current)) {
                iterator.add("prefix_" + current);
            }
        }
        
        // Частые удаления также эффективны
        iterator = list.listIterator();
        while (iterator.hasNext()) {
            if (shouldRemove(iterator.next())) {
                iterator.remove();
            }
        }
    }
    
    // Использование previous() для навигации назад
    public static void findAndProcessFromEnd(LinkedList<String> list, String target) {
        ListIterator<String> iterator = list.listIterator(list.size());
        
        while (iterator.hasPrevious()) {
            String current = iterator.previous();
            if (current.equals(target)) {
                // Нашли - обрабатываем и можем идти в обе стороны
                processFound(current);
                
                // Можем продолжить в любом направлении
                if (iterator.hasPrevious()) {
                    processPrevious(iterator.previous());
                }
                if (iterator.hasNext()) {
                    processNext(iterator.next());
                }
                break;
            }
        }
    }
}

#Java #для_новичков #beginner #ListIterator

Best Practices

1. Выбор начальной позиции

// Начинайте с нужной позиции, а не всегда с начала
ListIterator<T> iterator = list.listIterator(startPosition);

// Для обработки с конца
ListIterator<T> reverseIterator = list.listIterator(list.size());

2. Минимизация переходов между next() и previous()

// Неэффективно:
while (iterator.hasNext()) {
    T current = iterator.next();
    if (condition(current)) {
        iterator.previous(); // Дорогой переход
        iterator.add(newElement);
        iterator.next(); // Еще один переход
        iterator.next(); // Пропускаем добавленный элемент
    }
}

// Более эффективно:
while (iterator.hasNext()) {
    T current = iterator.next();
    if (condition(current)) {
        iterator.add(newElement);
        // current остался тем же, newElement теперь перед ним
    }
}

3. Использование nextIndex()/previousIndex() для логики, зависящей от позиции

ListIterator<T> iterator = list.listIterator();
while (iterator.hasNext()) {
    int currentIndex = iterator.nextIndex();
    T element = iterator.next();
    
    if (currentIndex % 2 == 0) {
        // Обработка четных позиций
        processEven(element, currentIndex);
    }
}

4. Безопасность в многопоточных сценариях

// Всегда синхронизируйте доступ к ListIterator
synchronized(list) {
    ListIterator<T> iterator = list.listIterator();
    while (iterator.hasNext()) {
        // Обработка
    }
}

// Или используйте потокобезопасные альтернативы
List<T> syncList = Collections.synchronizedList(new ArrayList<>());
// Но даже synchronizedList требует внешней синхронизации для итерации

#Java #для_новичков #beginner #ListIterator

Predicates в Spring Cloud Gateway: Механика и расширяемость условий маршрутизации

Механизм работы предикатов: от конфигурации к исполнению

Предикаты в Spring Cloud Gateway — это условия, определяющие, должен ли конкретный маршрут быть применён к входящему запросу. На архитектурном уровне предикаты реализуют паттерн Factory Method через абстракцию RoutePredicateFactory. Каждый предикат компилируется в объект Predicate<ServerWebExchange>, который затем оценивается в процессе сопоставления маршрута.


Процесс инициализации предиката

Когда приложение Spring Cloud Gateway стартует, происходит следующая последовательность:
Парсинг конфигурации: Конфигурационный файл (YAML или properties) читается, и определения предикатов преобразуются в объекты PredicateDefinition.
Поиск фабрик: Для каждого PredicateDefinition Spring ищет соответствующий bean типа RoutePredicateFactory. Имя фабрики определяется по свойству name в определении предиката.
Создание конфигурационного объекта: Фабрика создаёт конфигурационный объект (обычно static inner class), который заполняется значениями из аргументов предиката.
Генерация предиката: Вызывается метод apply() фабрики, который возвращает функциональный интерфейс Predicate<ServerWebExchange>.


Порядок оценки предикатов

Предикаты внутри маршрута оцениваются в порядке их объявления, но с важной оптимизацией: оценка происходит лениво и останавливается при первом false.

Механизм оценки реализован через цепочку вызовов and():

// Внутренняя реализация оценки предикатов маршрута
public boolean test(ServerWebExchange exchange) {
    for (Predicate<ServerWebExchange> predicate : predicates) {
        if (!predicate.test(exchange)) {
            return false; // Прерывание при первом false
        }
    }
    return true;
}

Детальный разбор встроенных предикатов

Path Predicate: эффективное сопоставление путей

Предикат Path — наиболее часто используемый. Внутри он использует PathPatternParser из Spring WebFlux, который компилирует строковые шаблоны в оптимизированные структуры данных.

Механика работы:

// Пример внутренней реализации
public class PathRoutePredicateFactory extends 
        AbstractRoutePredicateFactory<PathRoutePredicateFactory.Config> {
    
    @Override
    public Predicate<ServerWebExchange> apply(Config config) {
        final PathPattern pattern = pathPatternParser.parse(config.getPattern());
        
        return exchange -> {
            PathContainer path = exchange.getRequest().getPath();
            PathPattern.PathMatchInfo info = pattern.matchAndExtract(path);
            
            if (info != null) {
                // Сохранение извлечённых переменных в атрибуты
                exchange.getAttributes().put(
                    PathPatternRoutePredicateHandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE,
                    info.getUriVariables()
                );
                return true;
            }
            return false;
        };
    }
}

Использование переменных пути:

predicates:
  - Path=/api/users/{id}/orders/{orderId}
Извлечённые переменные id и orderId доступны в фильтрах через шаблоны ${id} и ${orderId}.

Host Predicate: виртуальные хосты и шаблоны

Предикат Host позволяет маршрутизировать на основе заголовка Host или имени сервера.

Расширенные шаблоны:

predicates:
  - Host=**.example.com,{subdomain}.api.example.com

Шаблон {subdomain}.api.example.com извлекает поддомен как переменную.

Внутренне это преобразуется в регулярное выражение:

// Пример генерации паттерна
String pattern = "^(?<subdomain>[^.]+)\\.api\\.example\\.com$";

Query Predicate: параметры запроса

Предикат Query проверяет наличие и значение параметров URL.

Конфигурация с регулярными выражениями:

predicates:
  - Query=version,v[0-9]+\.[0-9]+  # Проверка формата версии
  - Query=token                     # Просто наличие параметра

Внутренняя реализация использует ServerWebExchange.getRequest().getQueryParams() для доступа к параметрам. Важно отметить, что параметры кэшируются после первого чтения для эффективности.


#Java #middle #Spring_Cloud_Gateway

RemoteAddr Predicate: контроль доступа по IP

Этот предикат проверяет IP-адрес клиента через CIDR-нотацию.

Механика работы:

public Predicate<ServerWebExchange> apply(Config config) {
    List<IpSubnetFilterRule> sources = config.getSources().stream()
        .map(IpSubnetFilterRule::new)
        .collect(Collectors.toList());
    
    return exchange -> {
        InetSocketAddress remoteAddress = exchange.getRequest()
            .getRemoteAddress();
        
        if (remoteAddress != null) {
            for (IpSubnetFilterRule source : sources) {
                if (source.matches(remoteAddress)) {
                    return true;
                }
            }
        }
        return false;
    };
}

Важные нюансы:
При использовании за прокси (nginx, load balancer) необходимо корректно настраивать X-Forwarded-For
IP-адрес извлекается из ServerHttpRequest.getRemoteAddress(), который может быть обёрткой для реального соединения


Weight Predicate: взвешенная маршрутизация

Предикат Weight используется для канареечных развёртываний и A/B тестирования. Он работает в паре: один маршрут определяет группу, а другие маршруты распределяют вес внутри группы.

Конфигурация:

spring:
  cloud:
    gateway:
      routes:
      - id: weight_high
        uri: https://weighthigh.example.org
        predicates:
        - Path=/api/**
        - Weight=group1, 80
        metadata:
          response-timeout: 3000
      
      - id: weight_low
        uri: https://weightlow.example.org
        predicates:
        - Path=/api/**
        - Weight=group1, 20
        metadata:
          response-timeout: 5000

Внутренняя механика:
При инициализации создаётся общий AtomicInteger для группы
Для каждого запроса вычисляется хэш (обычно на основе пути и/или заголовков)
Хэш мапируется на диапазон весов для выбора маршрута
Выбор детерминирован для одинаковых хэшей, что обеспечивает согласованную маршрутизацию


Method Predicate: фильтрация по HTTP-методам

Простейший, но эффективный предикат для ограничения доступа:

predicates:
  - Method=GET,POST,OPTIONS
Внутренне преобразуется в проверку exchange.getRequest().getMethod().

Сложные комбинации через AND/OR

Spring Cloud Gateway поддерживает логические комбинации предикатов через DSL и конфигурацию.


Комбинации через YAML

В YAML предикаты по умолчанию объединяются через логическое И (AND):

predicates:
  - Path=/api/**
  - Method=GET
  - Header=X-API-Key,.*
  - Query=version,v2

Все четыре условия должны быть истинны для применения маршрута.


Логическое ИЛИ через кастомный предикат

Для реализации ИЛИ необходимо создать составной предикат:

@Component
public class OrRoutePredicateFactory extends 
        AbstractRoutePredicateFactory<OrRoutePredicateFactory.Config> {
    
    public OrRoutePredicateFactory() {
        super(Config.class);
    }
    
    @Override
    public Predicate<ServerWebExchange> apply(Config config) {
        return exchange -> {
            for (PredicateDefinition def : config.getPredicates()) {
                RoutePredicateFactory factory = findFactory(def);
                if (factory != null && factory.apply(convert(def)).test(exchange)) {
                    return true;
                }
            }
            return false;
        };
    }
    
    public static class Config {
        private List<PredicateDefinition> predicates = new ArrayList<>();
        // геттеры и сеттеры
    }
}

Использование в YAML:

predicates:
  - name: Or
    args:
      predicates:
        - name: Path
          args:
            pattern: /api/v1/**
        - name: Path
          args:
            pattern: /legacy/api/**

Негация (NOT) через After с отрицанием

Прямой поддержки NOT нет, но можно использовать временные предикаты с отрицанием:

public Predicate<ServerWebExchange> apply(Config config) {
    return exchange -> {
        // Инвертирование любого предиката
        return !delegatePredicate.test(exchange);
    };
}

#Java #middle #Spring_Cloud_Gateway

Создание кастомного предиката

Реализация RoutePredicateFactory

Создание кастомного предиката требует реализации интерфейса RoutePredicateFactory:

@Component
public class JwtClaimRoutePredicateFactory extends 
        AbstractRoutePredicateFactory<JwtClaimRoutePredicateFactory.Config> {
    
    private final JwtDecoder jwtDecoder;
    
    public JwtClaimRoutePredicateFactory(JwtDecoder jwtDecoder) {
        super(Config.class);
        this.jwtDecoder = jwtDecoder;
    }
    
    @Override
    public Predicate<ServerWebExchange> apply(Config config) {
        return exchange -> {
            // Извлечение JWT из заголовка
            String authHeader = exchange.getRequest()
                .getHeaders()
                .getFirst(HttpHeaders.AUTHORIZATION);
            
            if (authHeader == null || !authHeader.startsWith("Bearer ")) {
                return false;
            }
            
            String token = authHeader.substring(7);
            
            try {
                // Декодирование и проверка claims
                Jwt jwt = jwtDecoder.decode(token);
                
                // Проверка конкретного claim
                String claimValue = jwt.getClaimAsString(config.getClaimName());
                
                if (claimValue == null) {
                    return false;
                }
                
                // Сопоставление с ожидаемым значением
                if (config.getPattern() != null) {
                    return claimValue.matches(config.getPattern());
                }
                
                return config.getExpectedValues()
                    .stream()
                    .anyMatch(expected -> expected.equals(claimValue));
                
            } catch (JwtException e) {
                return false;
            }
        };
    }
    
    // Конфигурационный класс
    public static class Config {
        private String claimName;
        private String pattern;
        private List<String> expectedValues = new ArrayList<>();
        
        // Геттеры и сеттеры
        public String getClaimName() {
            return claimName;
        }
        
        public void setClaimName(String claimName) {
            this.claimName = claimName;
        }
        
        public String getPattern() {
            return pattern;
        }
        
        public void setPattern(String pattern) {
            this.pattern = pattern;
        }
        
        public List<String> getExpectedValues() {
            return expectedValues;
        }
        
        public void setExpectedValues(List<String> expectedValues) {
            this.expectedValues = expectedValues;
        }
    }
    
    // Короткая форма конфигурации
    @Override
    public List<String> shortcutFieldOrder() {
        return Arrays.asList("claimName", "pattern");
    }
}

#Java #middle #Spring_Cloud_Gateway

Регистрация и использование

Spring Boot автоматически обнаружит компонент через аннотацию @Component.

Для использования в YAML:

predicates:
  - name: JwtClaim
    args:
      claimName: roles
      expectedValues: admin,superuser

Или в краткой форме, если реализован shortcutFieldOrder():

predicates:
  - JwtClaim=roles,admin|superuser

Предикат с динамической конфигурацией

Для предикатов, требующих внешней конфигурации или состояния:

@Component
public class RateLimitPredicateFactory extends 
        AbstractRoutePredicateFactory<RateLimitPredicateFactory.Config> 
        implements ApplicationListener<EnvironmentChangeEvent> {
    
    private final RateLimiter rateLimiter;
    private final Map<String, Config> configCache = new ConcurrentHashMap<>();
    
    public RateLimitPredicateFactory(RateLimiter rateLimiter) {
        super(Config.class);
        this.rateLimiter = rateLimiter;
    }
    
    @Override
    public Predicate<ServerWebExchange> apply(Config config) {
        // Кэширование конфигурации для производительности
        String cacheKey = config.getClientId() + ":" + config.getLimit();
        configCache.put(cacheKey, config);
        
        return exchange -> {
            Config cachedConfig = configCache.get(cacheKey);
            
            // Извлечение идентификатора клиента из запроса
            String clientId = extractClientId(exchange);
            
            if (clientId == null || !clientId.equals(cachedConfig.getClientId())) {
                return false;
            }
            
            // Проверка лимита
            return rateLimiter.tryAcquire(clientId, cachedConfig.getLimit());
        };
    }
    
    @Override
    public void onApplicationEvent(EnvironmentChangeEvent event) {
        // Очистка кэша при изменении конфигурации
        configCache.clear();
    }
    
    private String extractClientId(ServerWebExchange exchange) {
        // Логика извлечения clientId из запроса
        return exchange.getRequest().getHeaders()
            .getFirst("X-Client-Id");
    }
    
    public static class Config {
        private String clientId;
        private int limit;
        
        // Геттеры и сеттеры
    }
}

Асинхронные предикаты

Для предикатов, требующих асинхронных операций (обращение к БД, внешним API):

@Component
public class ExternalServicePredicateFactory extends 
        AbstractRoutePredicateFactory<ExternalServicePredicateFactory.Config> {
    
    private final WebClient webClient;
    
    @Override
    public AsyncPredicate<ServerWebExchange> applyAsync(Config config) {
        return exchange -> {
            // Асинхронная проверка через внешний сервис
            return webClient.post()
                .uri(config.getValidationUrl())
                .bodyValue(buildValidationRequest(exchange))
                .retrieve()
                .bodyToMono(ValidationResponse.class)
                .map(response -> response.isValid())
                .onErrorReturn(false); // При ошибке считаем предикат false
        };
    }
    
    public static class Config {
        private String validationUrl;
        private int timeoutMs = 1000;
        
        // Геттеры и сеттеры
    }
}

Асинхронные предикаты возвращают AsyncPredicate<ServerWebExchange>, который оценивается в реактивном контексте и не блокирует event loop threads.


#Java #middle #Spring_Cloud_Gateway

Производительность и оптимизации

Кэширование вычислений предикатов

Для дорогих предикатов важно кэшировать результаты:

public Predicate<ServerWebExchange> apply(Config config) {
    LoadingCache<ServerWebExchange, Boolean> cache = Caffeine.newBuilder()
        .maximumSize(1000)
        .expireAfterWrite(1, TimeUnit.MINUTES)
        .build(exchange -> computeExpensivePredicate(exchange, config));
    
    return exchange -> {
        try {
            return cache.get(exchange);
        } catch (Exception e) {
            return false;
        }
    };
}

Порядок предикатов для оптимизации

Располагайте предикаты в порядке возрастания вычислительной сложности:

predicates:
  - Method=GET              # Быстрая проверка
  - Path=/api/**            # Умеренная сложность
  - Query=token,.*          # Простая проверка параметра
  - JwtClaim=roles,admin   # Дорогая проверка JWT

Это позволяет отсеивать неподходящие запросы до выполнения дорогих операций.

Мониторинг и метрики

Интеграция с Micrometer для мониторинга эффективности предикатов:

public Predicate<ServerWebExchange> apply(Config config) {
    Counter matchCounter = meterRegistry.counter(
        "gateway.predicate.matches",
        "predicate", config.getName()
    );
    
    Counter totalCounter = meterRegistry.counter(
        "gateway.predicate.checks",
        "predicate", config.getName()
    );
    
    Timer timer = meterRegistry.timer(
        "gateway.predicate.duration",
        "predicate", config.getName()
    );
    
    return exchange -> {
        totalCounter.increment();
        
        return timer.record(() -> {
            boolean matches = internalTest(exchange, config);
            if (matches) {
                matchCounter.increment();
            }
            return matches;
        });
    };
}

#Java #middle #Spring_Cloud_Gateway

Глава 6. Итераторы

Циклы for-each, индексированный for и семантика fail-fast/fail-safe коллекций

Концептуальные основы for-each

Цикл for-each (также известный как enhanced for loop) был введен в Java 5 как синтаксический сахар над стандартными итераторами. Он предоставляет более чистый и читаемый способ обхода коллекций и массивов, скрывая сложности управления итератором от разработчика.

Синтаксис и семантика

for (Type element : collection) {
    // Обработка element
}

Механизм преобразования

Для массивов

Компилятор преобразует цикл for-each для массивов в стандартный индексированный цикл:

// Исходный код
for (String item : array) {
    process(item);
}

// Преобразуется в
for (int i = 0; i < array.length; i++) {
    String item = array[i];
    process(item);
}

Для коллекций, реализующих Iterable

Для объектов, реализующих интерфейс Iterable<T>, компилятор генерирует код с использованием итератора:

// Исходный код
for (String item : collection) {
    process(item);
}

// Преобразуется в
for (Iterator<String> iterator = collection.iterator(); iterator.hasNext(); ) {
    String item = iterator.next();
    process(item);
}

Требования к использованию

Интерфейс Iterable

Для использования в цикле for-each класс должен реализовывать интерфейс Iterable<T>:

public interface Iterable<T> {
    Iterator<T> iterator();
}

Этот интерфейс требует реализации единственного метода iterator(), возвращающего объект Iterator.

Исключения и ограничения

Поддерживаемые типы:
Массивы любых типов
Все классы, реализующие Iterable<T>
Коллекции из Java Collections Framework

Ограничения:
Нельзя получить доступ к индексу текущего элемента
Нельзя модифицировать коллекцию во время итерации (за исключением Iterator.remove())
Поддерживается только последовательный обход вперед

Внутренние механизмы работы

Генерация байт-кода
Компилятор Java генерирует специфичный байт-код для циклов for-each.

Для коллекций:

// Псевдокод байт-кода
INVOKEINTERFACE java/lang/Iterable.iterator()Ljava/util/Iterator;
ASTORE iterator
GOTO condition
loop:
 ALOAD iterator
 INVOKEINTERFACE java/util/Iterator.next()Ljava/lang/Object;
 // Обработка элемента
condition:
 ALOAD iterator
 INVOKEINTERFACE java/util/Iterator.hasNext()Z
 IFNE loop

Особенности:
Автоматическое создание и управление итератором
Обработка исключений NoSuchElementException
Автоматическое закрытие ресурсов для AutoCloseable объектов

Оптимизации времени выполнения

JVM применяет несколько оптимизаций для циклов for-each:
Inlining: Частые вызовы методов итератора могут быть inline-ированы.
Loop unrolling: Для малых массивов цикл может быть развернут.
Escape analysis: Временные объекты могут размещаться на стеке.

Преимущества и недостатки

Преимущества
Читаемость: Более чистый и выразительный синтаксис
Безопасность: Автоматическое управление итератором, исключение ошибок индексации
Универсальность: Работает с массивами и любыми Iterable коллекциями
Меньше boilerplate кода: Не требуется явное создание итератора

Недостатки
Ограниченный контроль: Нет доступа к индексу, нельзя модифицировать коллекцию
Односторонний обход: Только последовательное движение вперед
Производительность: Незначительный overhead по сравнению с индексированным циклом для массивов


#Java #для_новичков #beginner #for_each #fail_fast #fail_safe