Регистрация и использование
Spring Boot автоматически обнаружит компонент через аннотацию @Component.
Для использования в YAML:
Или в краткой форме, если реализован shortcutFieldOrder():
Предикат с динамической конфигурацией
Для предикатов, требующих внешней конфигурации или состояния:
Асинхронные предикаты
Для предикатов, требующих асинхронных операций (обращение к БД, внешним API):
Асинхронные предикаты возвращают AsyncPredicate<ServerWebExchange>, который оценивается в реактивном контексте и не блокирует event loop threads.
#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
👍2
Производительность и оптимизации
Кэширование вычислений предикатов
Для дорогих предикатов важно кэшировать результаты:
Порядок предикатов для оптимизации
Располагайте предикаты в порядке возрастания вычислительной сложности:
Мониторинг и метрики
Интеграция с Micrometer для мониторинга эффективности предикатов:
#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
👍3
Что выведет код?
#Tasks
public class Task151225 {
public static void main(String[] args) {
Boolean b1 = true;
Boolean b2 = new Boolean(true);
boolean b3 = true;
Boolean b4 = Boolean.valueOf(true);
System.out.println(b1 == b2);
System.out.println(b1 == b3);
System.out.println(b2 == b4);
System.out.println(b3 == b4);
}
}#Tasks
👍2
Варианты ответа:
Anonymous Quiz
21%
false false true true
29%
false true true true
14%
true true false true
36%
false true false true
🔥1
Вопрос с собеседований
Что такое optimistic locking?🤓
Ответ:
Оптимистичная блокировка предполагает, что конфликты редки.
Данные читаются без блокировки, но при записи проверяется версия. Если она изменилась — операция повторяется.
Подходит для систем с высоким параллелизмом, снижает блокировки.
#собеседование
Что такое optimistic locking?
Ответ:
Данные читаются без блокировки, но при записи проверяется версия. Если она изменилась — операция повторяется.
Подходит для систем с высоким параллелизмом, снижает блокировки.
#собеседование
Please open Telegram to view this post
VIEW IN TELEGRAM
👍2
История IT-технологий сегодня — 16 декабря
ℹ️ Кто родился в этот день
Артур Самуэль (англ. Arthur Samuel, 5 декабря 1901 — 29 июля 1990) — американский учёный, один из первых исследователей машинного обучения; создал самообучающуюся программу для игры в шашки ещё в 1950-х в IBM.
🌐 Знаковые события
1947 — Уильям Шокли, Джон Бардин и Уолтер Браттейн в лабораториях Bell Labs впервые создали действующий биполярный транзистор.
1968 — опубликованы материалы и видеозаписи демонстрации Дугласа Энгельбарта, где гипертекст был зафиксирован как рабочая концепция.
#Biography #Birth_Date #Events #16Декабря
Артур Самуэль (англ. Arthur Samuel, 5 декабря 1901 — 29 июля 1990) — американский учёный, один из первых исследователей машинного обучения; создал самообучающуюся программу для игры в шашки ещё в 1950-х в IBM.
1947 — Уильям Шокли, Джон Бардин и Уолтер Браттейн в лабораториях Bell Labs впервые создали действующий биполярный транзистор.
1968 — опубликованы материалы и видеозаписи демонстрации Дугласа Энгельбарта, где гипертекст был зафиксирован как рабочая концепция.
#Biography #Birth_Date #Events #16Декабря
Please open Telegram to view this post
VIEW IN TELEGRAM
👍2
Глава 6. Итераторы
Циклы for-each, индексированный for и семантика fail-fast/fail-safe коллекций
Концептуальные основы for-each
Цикл for-each (также известный как enhanced for loop) был введен в Java 5 как синтаксический сахар над стандартными итераторами. Он предоставляет более чистый и читаемый способ обхода коллекций и массивов, скрывая сложности управления итератором от разработчика.
Синтаксис и семантика
Механизм преобразования
Для массивов
Компилятор преобразует цикл for-each для массивов в стандартный индексированный цикл:
Для коллекций, реализующих Iterable
Для объектов, реализующих интерфейс Iterable<T>, компилятор генерирует код с использованием итератора:
Требования к использованию
Интерфейс Iterable
Для использования в цикле for-each класс должен реализовывать интерфейс Iterable<T>:
Исключения и ограничения
Поддерживаемые типы:
Массивы любых типов
Все классы, реализующие Iterable<T>
Коллекции из Java Collections Framework
Ограничения:
Нельзя получить доступ к индексу текущего элемента
Нельзя модифицировать коллекцию во время итерации (за исключением Iterator.remove())
Поддерживается только последовательный обход вперед
Внутренние механизмы работы
Генерация байт-кода
Компилятор Java генерирует специфичный байт-код для циклов for-each.
Для коллекций:
Особенности:
Автоматическое создание и управление итератором
Обработка исключений NoSuchElementException
Автоматическое закрытие ресурсов для AutoCloseable объектов
Оптимизации времени выполнения
JVM применяет несколько оптимизаций для циклов for-each:
Inlining: Частые вызовы методов итератора могут быть inline-ированы.
Loop unrolling: Для малых массивов цикл может быть развернут.
Escape analysis: Временные объекты могут размещаться на стеке.
Преимущества и недостатки
Преимущества
Читаемость: Более чистый и выразительный синтаксис
Безопасность: Автоматическое управление итератором, исключение ошибок индексации
Универсальность: Работает с массивами и любыми Iterable коллекциями
Меньше boilerplate кода: Не требуется явное создание итератора
Недостатки
Ограниченный контроль: Нет доступа к индексу, нельзя модифицировать коллекцию
Односторонний обход: Только последовательное движение вперед
Производительность: Незначительный overhead по сравнению с индексированным циклом для массивов
#Java #для_новичков #beginner #for_each #fail_fast #fail_safe
Циклы 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
👍2
Паттерны использования
Стандартный обход коллекций
Работа с вложенными коллекциями
Обход массивов
Индексированный цикл for: полный контроль над итерацией
Концептуальные основы
Индексированный цикл for предоставляет полный контроль над процессом итерации, включая управление индексом, направлением обхода и возможностью пропуска элементов.
Синтаксис и структура
Механизм выполнения
Фазы выполнения
Инициализация: Выполняется один раз перед началом цикла
Проверка условия: Выполняется перед каждой итерацией
Выполнение тела: Если условие истинно
Инкремент: Выполняется после каждой итерации
Возврат к шагу 2
Байт-код представление
Варианты использования
Стандартный последовательный обход
Обратный обход
Обход с шагом
Множественные переменные цикла
Производительность и оптимизации
Для ArrayList:
Производительность:
For-each: Создание итератора + вызовы hasNext()/next()
Индексированный for: Прямой доступ по индексу + boundary checking
Для LinkedList:
Производительность:
For-each: O(n) общее время
Индексированный for: O(n²) из-за последовательного поиска элементов
Особые техники и паттерны
Пакетная обработка
Обход с модификацией
Параллельная обработка индексов
#Java #для_новичков #beginner #for_each #fail_fast #fail_safe
Стандартный обход коллекций
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
// Явное использование итератора
Iterator<String> iterator = names.iterator();
while (iterator.hasNext()) {
String name = iterator.next();
System.out.println(name);
}
// Эквивалентный for-each
for (String name : names) {
System.out.println(name);
}Работа с вложенными коллекциями
List<List<Integer>> matrix = Arrays.asList(
Arrays.asList(1, 2, 3),
Arrays.asList(4, 5, 6),
Arrays.asList(7, 8, 9)
);
// Вложенные for-each
for (List<Integer> row : matrix) {
for (Integer value : row) {
System.out.print(value + " ");
}
System.out.println();
}
Обход массивов
int[] numbers = {1, 2, 3, 4, 5};
// Традиционный for
for (int i = 0; i < numbers.length; i++) {
System.out.println(numbers[i]);
}
// For-each
for (int number : numbers) {
System.out.println(number);
}Индексированный цикл for: полный контроль над итерацией
Концептуальные основы
Индексированный цикл for предоставляет полный контроль над процессом итерации, включая управление индексом, направлением обхода и возможностью пропуска элементов.
Синтаксис и структура
for (инициализация; условие; инкремент) {
// Тело цикла
}Механизм выполнения
Фазы выполнения
Инициализация: Выполняется один раз перед началом цикла
Проверка условия: Выполняется перед каждой итерацией
Выполнение тела: Если условие истинно
Инкремент: Выполняется после каждой итерации
Возврат к шагу 2
Байт-код представление
// Псевдокод байт-кода
ICONST_0
ISTORE index
GOTO condition
loop:
// Тело цикла
ILOAD index
ICONST_1
IADD
ISTORE index
condition:
ILOAD index
array_length
IF_ICMPLT loop
Варианты использования
Стандартный последовательный обход
List<String> list = new ArrayList<>();
// ... инициализация
for (int i = 0; i < list.size(); i++) {
String element = list.get(i);
process(element);
}
Обратный обход
for (int i = list.size() - 1; i >= 0; i--) {
String element = list.get(i);
process(element);
}Обход с шагом
for (int i = 0; i < list.size(); i += 2) {
String element = list.get(i);
process(element);
}Множественные переменные цикла
for (int i = 0, j = 10; i < 10 && j > 0; i++, j--) {
System.out.println("i=" + i + ", j=" + j);
}Производительность и оптимизации
Для ArrayList:
// For-each (опосредованно через итератор)
for (String item : arrayList) {
process(item);
}
// Индексированный for
for (int i = 0; i < arrayList.size(); i++) {
String item = arrayList.get(i);
process(item);
}
Производительность:
For-each: Создание итератора + вызовы hasNext()/next()
Индексированный for: Прямой доступ по индексу + boundary checking
Для LinkedList:
// For-each (эффективно)
for (String item : linkedList) {
process(item);
}
// Индексированный for (неэффективно!)
for (int i = 0; i < linkedList.size(); i++) {
String item = linkedList.get(i); // O(n) для каждого вызова!
process(item);
}
Производительность:
For-each: O(n) общее время
Индексированный for: O(n²) из-за последовательного поиска элементов
Особые техники и паттерны
Пакетная обработка
int batchSize = 50;
for (int i = 0; i < data.size(); i += batchSize) {
int end = Math.min(i + batchSize, data.size());
List<Item> batch = data.subList(i, end);
processBatch(batch);
}
Обход с модификацией
// Удаление элементов во время обхода (только для ArrayList)
for (int i = 0; i < list.size(); i++) {
if (shouldRemove(list.get(i))) {
list.remove(i);
i--; // Корректировка индекса после удаления
}
}
Параллельная обработка индексов
// Обработка двух коллекций одновременно
for (int i = 0; i < Math.min(list1.size(), list2.size()); i++) {
processPair(list1.get(i), list2.get(i));
}
#Java #для_новичков #beginner #for_each #fail_fast #fail_safe
👍2
Рекомендации по выбору
Когда использовать for-each:
Простой последовательный обход без необходимости модификации
Работа с LinkedList или другими не-RandomAccess коллекциями
Улучшение читаемости кода
Обход массивов когда индекс не нужен
Работа с вложенными структурами
Когда использовать индексированный for:
Необходимость доступа к индексу
Обратный или нестандартный обход
Модификация коллекции во время итерации
Пакетная обработка с определенным шагом
Работа с ArrayList или массивами
Гибридные подходы
Использование счетчика с for-each
Обход с ListIterator
Fail-fast коллекции: философия быстрого отказа
Концепция fail-fast
Fail-fast (быстрый отказ) — это подход к обработке ошибок, при котором система немедленно сообщает о проблеме, как только она обнаружена. В контексте коллекций Java это означает, что итераторы обнаруживают структурные модификации коллекции во время итерации и немедленно выбрасывают исключение.
Механизм реализации
Ключевым элементом fail-fast поведения является поле modCount:
Назначение: Отслеживание количества структурных модификаций коллекции.
Инкрементация: Увеличивается при каждой операции, изменяющей размер или структуру коллекции.
Использование: Сравнивается с сохраненной копией в итераторе.
Реализация в итераторах
Коллекции с fail-fast семантикой
ArrayList и все его производные
LinkedList
HashSet
HashMap (итераторы entrySet, keySet, values)
TreeMap и TreeSet
Пример поведения
Детальный анализ исключения ConcurrentModificationException
Условия возникновения
Структурная модификация: Изменение размера коллекции (add, remove)
Одновременная итерация: Активный итератор или for-each цикл
Разные объекты: Модификация не через текущий итератор
Что считается структурной модификацией
Вызывают исключение:
add(), addAll()
remove(), removeAll(), retainAll(), clear()
set() на определенных позициях в некоторых реализациях
Не вызывают исключение:
set() для замены элемента без изменения размера
Операции через Iterator.remove()
Операции через ListIterator.add(), set(), remove()
Механизм обнаружения изменений
#Java #для_новичков #beginner #for_each #fail_fast #fail_safe
Когда использовать for-each:
Простой последовательный обход без необходимости модификации
Работа с LinkedList или другими не-RandomAccess коллекциями
Улучшение читаемости кода
Обход массивов когда индекс не нужен
Работа с вложенными структурами
// Идеальный сценарий для for-each
for (Customer customer : customers) {
sendNotification(customer);
}
Когда использовать индексированный for:
Необходимость доступа к индексу
Обратный или нестандартный обход
Модификация коллекции во время итерации
Пакетная обработка с определенным шагом
Работа с ArrayList или массивами
// Идеальный сценарий для индексированного for
for (int i = 0; i < array.length; i++) {
if (array[i] == null) {
array[i] = defaultValue;
}
}
Гибридные подходы
Использование счетчика с for-each
int index = 0;
for (String item : collection) {
processWithIndex(item, index);
index++;
}
Обход с ListIterator
ListIterator<String> iterator = list.listIterator();
while (iterator.hasNext()) {
String item = iterator.next();
int index = iterator.previousIndex();
processWithIndex(item, index);
}
Fail-fast коллекции: философия быстрого отказа
Концепция fail-fast
Fail-fast (быстрый отказ) — это подход к обработке ошибок, при котором система немедленно сообщает о проблеме, как только она обнаружена. В контексте коллекций Java это означает, что итераторы обнаруживают структурные модификации коллекции во время итерации и немедленно выбрасывают исключение.
Механизм реализации
Ключевым элементом fail-fast поведения является поле modCount:
// Пример из AbstractList
protected transient int modCount = 0;
Назначение: Отслеживание количества структурных модификаций коллекции.
Инкрементация: Увеличивается при каждой операции, изменяющей размер или структуру коллекции.
Использование: Сравнивается с сохраненной копией в итераторе.
Реализация в итераторах
private class Itr implements Iterator<E> {
int expectedModCount = modCount;
int cursor = 0;
public E next() {
checkForComodification(); // Проверка изменений
// ... остальная логика
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
public void remove() {
checkForComodification();
// ... удаление элемента
expectedModCount = modCount; // Синхронизация после успешного удаления
}
}Коллекции с fail-fast семантикой
ArrayList и все его производные
LinkedList
HashSet
HashMap (итераторы entrySet, keySet, values)
TreeMap и TreeSet
Пример поведения
List<String> list = new ArrayList<>(Arrays.asList("A", "B", "C"));
// Попытка модификации во время итерации
for (String item : list) {
if (item.equals("B")) {
list.remove(item); // ConcurrentModificationException!
}
}Детальный анализ исключения ConcurrentModificationException
Условия возникновения
Структурная модификация: Изменение размера коллекции (add, remove)
Одновременная итерация: Активный итератор или for-each цикл
Разные объекты: Модификация не через текущий итератор
Что считается структурной модификацией
Вызывают исключение:
add(), addAll()
remove(), removeAll(), retainAll(), clear()
set() на определенных позициях в некоторых реализациях
Не вызывают исключение:
set() для замены элемента без изменения размера
Операции через Iterator.remove()
Операции через ListIterator.add(), set(), remove()
Механизм обнаружения изменений
// Упрощенная проверка в ArrayList.Itr
final void checkForComodification() {
if (modCount != expectedModCount) {
// Разные стратегии в разных коллекциях
if (modCount == expectedModCount + 1 && lastRet < 0) {
// Возможно, это наш собственный remove()
expectedModCount = modCount;
} else {
throw new ConcurrentModificationException();
}
}
}
#Java #для_новичков #beginner #for_each #fail_fast #fail_safe
👍2
Стратегии работы с fail-fast коллекциями
Безопасные паттерны
Сбор элементов для удаления:
Использование индексированного цикла:
Опасные паттерны (антипаттерны)
Модификация через коллекцию во время итерации:
Параллельные модификации из разных потоков:
Преимущества и недостатки fail-fast подхода
Преимущества
Раннее обнаружение ошибок: Проблемы выявляются сразу же
Предсказуемость: Гарантированная consistency во время итерации
Простота отладки: Точное указание на проблему
Защита от тонких багов: Предотвращение незаметной порчи данных
Недостатки
Ограничения на модификации: Нельзя изменять коллекцию во время итерации
Производительность: Дополнительные проверки на каждой операции
Сложность в многопоточных сценариях: Требует внешней синхронизации
Fail-safe коллекции: философия безопасного продолжения
Fail-safe (безопасный отказ) — это подход, при котором система продолжает работу даже при возникновении ошибок или изменений состояния. В контексте коллекций это означает, что итераторы работают с моментальным снимком (snapshot) данных или используют специальные механизмы для обеспечения consistency во время итерации.
Механизмы реализации
Copy-on-write (копирование при записи)
Наиболее распространенный механизм fail-safe:
Слабая согласованность (weakly consistent)
Альтернативный подход, используемый в concurrent коллекциях:
Итератор видит элементы, существовавшие на момент его создания
Может видеть некоторые, но не все последующие изменения
Не выбрасывает ConcurrentModificationException
Коллекции с fail-safe семантикой
CopyOnWriteArrayList
Принцип работы: При каждой модификации создается новая копия внутреннего массива.
ConcurrentHashMap
Принцип работы: Сегментированная блокировка и слабо-консистентные итераторы.
ConcurrentLinkedQueue
Принцип работы: Lock-free алгоритмы и weak consistency.
#Java #для_новичков #beginner #for_each #fail_fast #fail_safe
Безопасные паттерны
Использование Iterator.remove():
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
String item = iterator.next();
if (shouldRemove(item)) {
iterator.remove(); // Безопасно!
}
}
Сбор элементов для удаления:
List<String> toRemove = new ArrayList<>();
for (String item : list) {
if (shouldRemove(item)) {
toRemove.add(item);
}
}
list.removeAll(toRemove); // Безопасно вне цикла
Использование индексированного цикла:
for (int i = 0; i < list.size(); i++) {
if (shouldRemove(list.get(i))) {
list.remove(i);
i--; // Корректировка индекса
}
}Опасные паттерны (антипаттерны)
Модификация через коллекцию во время итерации:
for (String item : list) {
list.add("new"); // ConcurrentModificationException!
}Параллельные модификации из разных потоков:
// Поток 1
for (String item : list) {
// Итерация
}
// Поток 2
list.add("new"); // ConcurrentModificationException в потоке 1
Преимущества и недостатки fail-fast подхода
Преимущества
Раннее обнаружение ошибок: Проблемы выявляются сразу же
Предсказуемость: Гарантированная consistency во время итерации
Простота отладки: Точное указание на проблему
Защита от тонких багов: Предотвращение незаметной порчи данных
Недостатки
Ограничения на модификации: Нельзя изменять коллекцию во время итерации
Производительность: Дополнительные проверки на каждой операции
Сложность в многопоточных сценариях: Требует внешней синхронизации
Fail-safe коллекции: философия безопасного продолжения
Fail-safe (безопасный отказ) — это подход, при котором система продолжает работу даже при возникновении ошибок или изменений состояния. В контексте коллекций это означает, что итераторы работают с моментальным снимком (snapshot) данных или используют специальные механизмы для обеспечения consistency во время итерации.
Механизмы реализации
Copy-on-write (копирование при записи)
Наиболее распространенный механизм fail-safe:
public class CopyOnWriteArrayList<E> {
private transient volatile Object[] array;
public Iterator<E> iterator() {
return new COWIterator<E>(getArray(), 0);
}
static final class COWIterator<E> implements ListIterator<E> {
private final Object[] snapshot;
private int cursor;
COWIterator(Object[] elements, int initialCursor) {
snapshot = elements; // Снимок на момент создания
cursor = initialCursor;
}
public E next() {
if (!hasNext())
throw new NoSuchElementException();
return (E) snapshot[cursor++];
}
}
}Слабая согласованность (weakly consistent)
Альтернативный подход, используемый в concurrent коллекциях:
Итератор видит элементы, существовавшие на момент его создания
Может видеть некоторые, но не все последующие изменения
Не выбрасывает ConcurrentModificationException
Коллекции с fail-safe семантикой
CopyOnWriteArrayList
Принцип работы: При каждой модификации создается новая копия внутреннего массива.
CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
// Безопасная модификация во время итерации
for (String item : list) { // Итератор использует snapshot
if (condition(item)) {
list.add("new"); // Не влияет на текущую итерацию
}
}
ConcurrentHashMap
Принцип работы: Сегментированная блокировка и слабо-консистентные итераторы.
ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
// Итерация по entrySet
for (Map.Entry<String, Integer> entry : map.entrySet()) {
map.put("newKey", 42); // Безопасно, но может не отобразиться в текущем итераторе
}
ConcurrentLinkedQueue
Принцип работы: Lock-free алгоритмы и weak consistency.
ConcurrentLinkedQueue<String> queue = new ConcurrentLinkedQueue<>();
for (String item : queue) {
queue.offer("new"); // Безопасно
}
#Java #для_новичков #beginner #for_each #fail_fast #fail_safe
👍2
Детальный анализ поведения fail-safe коллекций
CopyOnWriteArrayList: детали реализации
Структура данных:
Алгоритм добавления элемента:
Характеристики:
Чтение: O(1), без блокировок
Запись: O(n), требует полного копирования
Память: Дополнительная копия во время модификации
Итераторы: Всегда работают с snapshot
ConcurrentHashMap: сегментированная архитектура
Структура (Java 7 и ранее):
Итерация:
Характеристики:
Чтение: O(1) в среднем, без блокировок
Запись: O(1) в среднем, блокировка только сегмента
Итераторы: Weakly consistent, могут не видеть все изменения
Преимущества и недостатки fail-safe подхода
Преимущества
Безопасность в многопоточных сценариях: Нет необходимости во внешней синхронизации
Отсутствие ConcurrentModificationException: Итерация никогда не прерывается
Высокая производительность чтения: Особенно в read-heavy workload'ах
Простота использования: Меньше требований к синхронизации
Недостатки
Расход памяти: Copy-on-write требует дополнительной памяти
Задержка видимости изменений: Итераторы могут не видеть свежие данные
Производительность записи: Copy-on-write имеет высокую стоимость
Сложность семантики: Weak consistency может быть неинтуитивной
Паттерны использования fail-safe коллекций
Сценарии для CopyOnWriteArrayList
Конфигурационные данные:
Кэширование часто читаемых данных:
Сценарии для ConcurrentHashMap
Кэш с конкурентным доступом:
#Java #для_новичков #beginner #for_each #fail_fast #fail_safe
CopyOnWriteArrayList: детали реализации
Структура данных:
public class CopyOnWriteArrayList<E> {
// volatile для обеспечения memory visibility
private transient volatile Object[] array;
final Object[] getArray() {
return array;
}
final void setArray(Object[] a) {
array = a;
}
}Алгоритм добавления элемента:
public boolean add(E e) {
synchronized(lock) {
Object[] elements = getArray();
int len = elements.length;
// Создание новой копии
Object[] newElements = Arrays.copyOf(elements, len + 1);
newElements[len] = e;
// Атомарная замена ссылки
setArray(newElements);
return true;
}
}Характеристики:
Чтение: O(1), без блокировок
Запись: O(n), требует полного копирования
Память: Дополнительная копия во время модификации
Итераторы: Всегда работают с snapshot
ConcurrentHashMap: сегментированная архитектура
Структура (Java 7 и ранее):
public class ConcurrentHashMap<K, V> {
final Segment<K,V>[] segments; // Массив сегментов
static final class Segment<K,V> extends ReentrantLock {
transient volatile HashEntry<K,V>[] table;
}
}Итерация:
public Iterator<Map.Entry<K,V>> iterator() {
return new EntryIterator();
}
// Weakly consistent итератор
final class EntryIterator extends HashIterator
implements Iterator<Entry<K,V>> {
public Map.Entry<K,V> next() {
HashEntry<K,V> e = super.nextEntry();
return new WriteThroughEntry(e.key, e.value);
}
}Характеристики:
Чтение: O(1) в среднем, без блокировок
Запись: O(1) в среднем, блокировка только сегмента
Итераторы: Weakly consistent, могут не видеть все изменения
Преимущества и недостатки fail-safe подхода
Преимущества
Безопасность в многопоточных сценариях: Нет необходимости во внешней синхронизации
Отсутствие ConcurrentModificationException: Итерация никогда не прерывается
Высокая производительность чтения: Особенно в read-heavy workload'ах
Простота использования: Меньше требований к синхронизации
Недостатки
Расход памяти: Copy-on-write требует дополнительной памяти
Задержка видимости изменений: Итераторы могут не видеть свежие данные
Производительность записи: Copy-on-write имеет высокую стоимость
Сложность семантики: Weak consistency может быть неинтуитивной
Паттерны использования fail-safe коллекций
Сценарии для CopyOnWriteArrayList
Конфигурационные данные:
public class ConfigurationManager {
private final CopyOnWriteArrayList<Listener> listeners =
new CopyOnWriteArrayList<>();
public void addListener(Listener listener) {
listeners.add(listener); // Безопасно, даже во время уведомлений
}
public void notifyListeners() {
for (Listener listener : listeners) { // Snapshot итератор
listener.onChange();
}
}
}Кэширование часто читаемых данных:
public class DataCache {
private volatile CopyOnWriteArrayList<Data> cache =
new CopyOnWriteArrayList<>();
public void refreshCache() {
List<Data> newData = loadData();
cache = new CopyOnWriteArrayList<>(newData); // Атомарная замена
}
public List<Data> getData() {
return cache; // Безопасное чтение
}
}Сценарии для ConcurrentHashMap
Кэш с конкурентным доступом:
public class ConcurrentCache<K, V> {
private final ConcurrentHashMap<K, V> cache = new ConcurrentHashMap<>();
public V get(K key) {
return cache.get(key); // Без блокировок
}
public V computeIfAbsent(K key, Function<K, V> loader) {
return cache.computeIfAbsent(key, loader); // Атомарно
}
public void processAll() {
for (Map.Entry<K, V> entry : cache.entrySet()) {
// Безопасная итерация даже при concurrent модификациях
processEntry(entry);
}
}
}#Java #для_новичков #beginner #for_each #fail_fast #fail_safe
👍2
Критерии выбора fail-fast и fail-safe
Выбор fail-fast коллекций когда:
Single-threaded окружение или контролируемая многопоточность
Важна немедленная видимость изменений
Ограниченные ресурсы памяти
Частые операции записи
Нужна предсказуемость поведения
Выбор fail-safe коллекций когда:
Высокая конкурентность чтения и записи
Read-heavy workloads
Не критична задержка видимости изменений
Достаточно памяти для copy-on-write
Нужна thread-safe семантика без внешней синхронизации
Гибридные подходы
Комбинация fail-fast и внешней синхронизации
Использование ReadWriteLock
Практические рекомендации и best practices
Общие рекомендации по выбору циклов
Предпочитайте for-each для простого последовательного обхода
Используйте индексированный for когда нужен индекс или нестандартный обход
Избегайте индексированного for для LinkedList
Рассмотрите Stream API для сложных операций фильтрации и трансформации
Рекомендации по работе с fail-fast коллекциями
Не модифицируйте коллекцию во время итерации через методы коллекции
Используйте Iterator.remove() для безопасного удаления
Собирайте изменения отдельно для пакетного применения
Синхронизируйте доступ в многопоточных сценариях
Рекомендации по работе с fail-safe коллекциями
Понимайте семантику weak consistency для concurrent коллекций
Учитывайте стоимость copy-on-write для больших коллекций
Используйте для read-heavy workloads
Избегайте частых модификаций больших CopyOnWriteArrayList
#Java #для_новичков #beginner #for_each #fail_fast #fail_safe
Выбор fail-fast коллекций когда:
Single-threaded окружение или контролируемая многопоточность
Важна немедленная видимость изменений
Ограниченные ресурсы памяти
Частые операции записи
Нужна предсказуемость поведения
// Оптимально для single-threaded сценариев
List<String> singleThreadedList = new ArrayList<>();
Выбор fail-safe коллекций когда:
Высокая конкурентность чтения и записи
Read-heavy workloads
Не критична задержка видимости изменений
Достаточно памяти для copy-on-write
Нужна thread-safe семантика без внешней синхронизации
// Оптимально для многопоточных read-heavy сценариев
List<String> concurrentList = new CopyOnWriteArrayList<>();
Гибридные подходы
Комбинация fail-fast и внешней синхронизации
public class SynchronizedListWrapper {
private final List<String> list = new ArrayList<>();
public synchronized void safeIteration() {
// Внутри synchronized блока fail-fast безопасен
for (String item : list) {
process(item);
}
}
public synchronized void modify() {
list.add("new");
}
}Использование ReadWriteLock
public class ReadWriteProtectedList {
private final List<String> list = new ArrayList<>();
private final ReadWriteLock lock = new ReentrantReadWriteLock();
public void iterateSafely() {
lock.readLock().lock();
try {
for (String item : list) {
process(item); // Безопасное чтение
}
} finally {
lock.readLock().unlock();
}
}
public void modifySafely() {
lock.writeLock().lock();
try {
list.add("new"); // Безопасная модификация
} finally {
lock.writeLock().unlock();
}
}
}Практические рекомендации и best practices
Общие рекомендации по выбору циклов
Предпочитайте for-each для простого последовательного обхода
Используйте индексированный for когда нужен индекс или нестандартный обход
Избегайте индексированного for для LinkedList
Рассмотрите Stream API для сложных операций фильтрации и трансформации
// For-each для простого обхода
for (Item item : items) {
process(item);
}
// Индексированный for когда нужен индекс
for (int i = 0; i < items.size(); i++) {
processWithIndex(items.get(i), i);
}
// Stream API для сложных операций
items.stream()
.filter(this::shouldProcess)
.map(this::transform)
.forEach(this::process);
Рекомендации по работе с fail-fast коллекциями
Не модифицируйте коллекцию во время итерации через методы коллекции
Используйте Iterator.remove() для безопасного удаления
Собирайте изменения отдельно для пакетного применения
Синхронизируйте доступ в многопоточных сценариях
// Безопасный паттерн
List<String> toRemove = new ArrayList<>();
for (String item : list) {
if (shouldRemove(item)) {
toRemove.add(item);
}
}
list.removeAll(toRemove);
Рекомендации по работе с fail-safe коллекциями
Понимайте семантику weak consistency для concurrent коллекций
Учитывайте стоимость copy-on-write для больших коллекций
Используйте для read-heavy workloads
Избегайте частых модификаций больших CopyOnWriteArrayList
// Оптимальное использование CopyOnWriteArrayList
CopyOnWriteArrayList<Data> dataCache = new CopyOnWriteArrayList<>();
// Редкое обновление всего кэша
public void refreshCache() {
List<Data> freshData = loadFreshData();
dataCache = new CopyOnWriteArrayList<>(freshData);
}
// Частое чтение
public List<Data> getCachedData() {
return dataCache;
}
#Java #для_новичков #beginner #for_each #fail_fast #fail_safe
👍2
Что выведет код?
#Tasks
import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;
public class Task161225 {
public static void main(String[] args) {
List<Integer> failFast = new ArrayList<>(Arrays.asList(1, 2, 3));
List<Integer> failSafe = new CopyOnWriteArrayList<>(Arrays.asList(1, 2, 3));
try {
for (int num : failFast) {
System.out.print(num + " ");
if (num == 2) failFast.add(4);
}
} catch (Exception e) {
System.out.print("FFex ");
}
try {
for (int num : failSafe) {
System.out.print(num + " ");
if (num == 2) failSafe.add(4);
}
} catch (Exception e) {
System.out.print("FSex ");
}
System.out.print(failFast.size() + " ");
System.out.print(failSafe.size());
}
}
#Tasks
👍1
Варианты ответа:
Anonymous Quiz
22%
1 2 FFex 1 2 3 FSex 3 4
11%
1 2 FFex 1 2 3 3 6
44%
1 2 FFex 1 2 3 3 4
22%
1 2 FFex 1 2 3 4 4
😱1
Spring Cloud Gateway: граница микросервисов.
Если рискнете посмотреть сегодняшнее видео, то скорее всего приобретете неплохую компетенцию по Spring Cloud Gateway.
Что я там показал и о чем рассказал:
🔵 Зачем вообще нам Gateway и что это такое.
🔵 Как происходит роутинг и как это настроить в mvc и webflux версиях.
🔵 Что такое предикаты, фильтры, и что они могут.
🔵 Как всегда немного подебажил))
Репозиторий на GitHub очень ждет Ваших звезд. Хотя-бы зацените как я для Вас постарался.☺️
Ссылка на Youtube
Ссылка на Рутьюб
Смотрите, ставьте лайки, подписывайтесь на каналы!✌️
Если рискнете посмотреть сегодняшнее видео, то скорее всего приобретете неплохую компетенцию по Spring Cloud Gateway.
Что я там показал и о чем рассказал:
Репозиторий на GitHub очень ждет Ваших звезд. Хотя-бы зацените как я для Вас постарался.
Ссылка на Youtube
Ссылка на Рутьюб
Смотрите, ставьте лайки, подписывайтесь на каналы!
Please open Telegram to view this post
VIEW IN TELEGRAM
2🔥6🆒1 1
Вопрос с собеседований
Что такое pessimistic locking?🤓
Ответ:
Пессимистичная блокировка предполагает высокую вероятность конфликта.
Данные блокируются сразу при чтении. Это гарантирует безопасность, но снижает производительность.
Часто используется в базах данных для защиты от одновременных обновлений.
#собеседование
Что такое pessimistic locking?
Ответ:
Данные блокируются сразу при чтении. Это гарантирует безопасность, но снижает производительность.
Часто используется в базах данных для защиты от одновременных обновлений.
#собеседование
Please open Telegram to view this post
VIEW IN TELEGRAM
👍3
История IT-технологий сегодня — 17 декабря
ℹ️ Кто родился в этот день
Джозеф Генри (англ. Joseph Henry; 17 декабря 1797 — 13 мая 1878) — американский физик, первый секретарь Смитсоновского института. Создавая магниты, Генри открыл новое явление в электромагнетизме — самоиндукцию.
🌐 Знаковые события
1903 — первый полёт самолёта Wright Flyer братьев Райт.
#Biography #Birth_Date #Events #17Декабря
Джозеф Генри (англ. Joseph Henry; 17 декабря 1797 — 13 мая 1878) — американский физик, первый секретарь Смитсоновского института. Создавая магниты, Генри открыл новое явление в электромагнетизме — самоиндукцию.
1903 — первый полёт самолёта Wright Flyer братьев Райт.
#Biography #Birth_Date #Events #17Декабря
Please open Telegram to view this post
VIEW IN TELEGRAM
👍2🔥1
Gateway Filters: Глубокая архитектура и реактивная реализация
Реактивная природа фильтров в Spring Cloud Gateway
В Spring Cloud Gateway каждый фильтр реализует интерфейс GatewayFilter, который определяет единственный метод:
Ключевой аспект — возвращаемый тип Mono<Void>. Это реактивный тип, представляющий отложенное вычисление, которое может завершиться успешно, с ошибкой или никогда не завершиться. Фильтры не блокируют поток выполнения (thread) — вместо этого они описывают pipeline обработки, который выполняется асинхронно.
Пример неблокирующего фильтра:
Цепочка фильтров как реактивный pipeline
GatewayFilterChain представляет собой последовательность фильтров, организованную как связанный список. Когда вызывается chain.filter(exchange), выполнение передаётся следующему фильтру в цепочке. Последний фильтр в цепочке вызывает фактическую маршрутизацию запроса к целевому сервису через NettyRoutingFilter.
Внутренняя реализация DefaultGatewayFilterChain:
Важное наблюдение: цепочка фильтров не выполняется немедленно. Она описывается как последовательность операторов реактивного программирования, которые будут выполнены позже, когда на них подпишутся.
Порядок выполнения фильтров
Фильтры выполняются в строго определённом порядке:
GlobalFilter с наименьшим значением getOrder() (отрицательные значения имеют наивысший приоритет)
Остальные GlobalFilter в порядке возрастания значения getOrder()
Фильтры маршрута в порядке их объявления в конфигурации
Пример конфликта порядка:
#Java #middle #Spring_Cloud_Gateway #Filters
Реактивная природа фильтров в Spring Cloud Gateway
В Spring Cloud Gateway каждый фильтр реализует интерфейс GatewayFilter, который определяет единственный метод:
Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain);
Ключевой аспект — возвращаемый тип Mono<Void>. Это реактивный тип, представляющий отложенное вычисление, которое может завершиться успешно, с ошибкой или никогда не завершиться. Фильтры не блокируют поток выполнения (thread) — вместо этого они описывают pipeline обработки, который выполняется асинхронно.
Пример неблокирующего фильтра:
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
// Этот код выполняется синхронно при построении цепочки
long startTime = System.currentTimeMillis();
// Возвращаем Mono, который описывает асинхронную операцию
return chain.filter(exchange)
.then(Mono.fromRunnable(() -> {
// Этот код выполняется асинхронно ПОСЛЕ завершения цепочки
long duration = System.currentTimeMillis() - startTime;
log.info("Request processed in {} ms", duration);
}));
}Цепочка фильтров как реактивный pipeline
GatewayFilterChain представляет собой последовательность фильтров, организованную как связанный список. Когда вызывается chain.filter(exchange), выполнение передаётся следующему фильтру в цепочке. Последний фильтр в цепочке вызывает фактическую маршрутизацию запроса к целевому сервису через NettyRoutingFilter.
Внутренняя реализация DefaultGatewayFilterChain:
public class DefaultGatewayFilterChain implements GatewayFilterChain {
private final List<GatewayFilter> filters;
private final int index;
private final Publisher<Void> currentPublisher;
@Override
public Mono<Void> filter(ServerWebExchange exchange) {
return Mono.defer(() -> {
if (this.index < filters.size()) {
GatewayFilter filter = filters.get(this.index);
DefaultGatewayFilterChain chain = new DefaultGatewayFilterChain(
this, this.index + 1);
return filter.filter(exchange, chain);
} else {
return Mono.empty(); // Конец цепочки
}
});
}
}Важное наблюдение: цепочка фильтров не выполняется немедленно. Она описывается как последовательность операторов реактивного программирования, которые будут выполнены позже, когда на них подпишутся.
Порядок выполнения фильтров
Фильтры выполняются в строго определённом порядке:
GlobalFilter с наименьшим значением getOrder() (отрицательные значения имеют наивысший приоритет)
Остальные GlobalFilter в порядке возрастания значения getOrder()
Фильтры маршрута в порядке их объявления в конфигурации
Пример конфликта порядка:
@Component
@Order(-1) // Выполняется ПЕРВЫМ
public class FirstGlobalFilter implements GlobalFilter {
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
log.info("First global filter");
return chain.filter(exchange);
}
}
@Component
@Order(0) // Выполняется ВТОРЫМ
public class SecondGlobalFilter implements GlobalFilter {
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
log.info("Second global filter");
return chain.filter(exchange);
}
}
#Java #middle #Spring_Cloud_Gateway #Filters
👍2
Детальный разбор встроенных фильтров
AddRequestHeader / AddResponseHeader
Эти фильтры добавляют заголовки к запросу или ответу.
Важно понимать их реактивную природу:
Особенность: Заголовки добавляются в момент модификации запроса, который происходит синхронно при построении цепочки. Однако сама отправка модифицированного запроса к целевому сервису происходит асинхронно.
RemoveRequestHeader
Удаляет заголовки из запроса.
Важная деталь — фильтр работает с копией заголовков:
RewritePath / SetPath
Эти фильтры модифицируют путь запроса. RewritePath использует регулярные выражения для замены, а SetPath устанавливает фиксированный путь.
Внутренняя механика RewritePath:
#Java #middle #Spring_Cloud_Gateway #Filters
AddRequestHeader / AddResponseHeader
Эти фильтры добавляют заголовки к запросу или ответу.
Важно понимать их реактивную природу:
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
ServerHttpRequest request = exchange.getRequest();
// Модификация запроса (PRE-фильтр)
ServerHttpRequest mutatedRequest = request.mutate()
.header(headerName, headerValue)
.build();
// Создание нового обмена с модифицированным запросом
return chain.filter(exchange.mutate().request(mutatedRequest).build());
}Особенность: Заголовки добавляются в момент модификации запроса, который происходит синхронно при построении цепочки. Однако сама отправка модифицированного запроса к целевому сервису происходит асинхронно.
RemoveRequestHeader
Удаляет заголовки из запроса.
Важная деталь — фильтр работает с копией заголовков:
ServerHttpRequest mutated = exchange.getRequest().mutate()
.headers(headers -> {
headers.remove(headerName);
// или headers.removeIf(key -> key.startsWith("X-Secret-"));
})
.build();
RewritePath / SetPath
Эти фильтры модифицируют путь запроса. RewritePath использует регулярные выражения для замены, а SetPath устанавливает фиксированный путь.
Внутренняя механика RewritePath:
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
String path = exchange.getRequest().getURI().getRawPath();
// Применение регулярного выражения
String newPath = path.replaceAll(regexp, replacement);
// Сохранение переменных из регулярного выражения
Map<String, String> variables = extractVariables(path, regexp);
exchange.getAttributes().put(URI_TEMPLATE_VARIABLES_ATTRIBUTE, variables);
// Построение нового URI
URI newUri = UriComponentsBuilder.fromUri(exchange.getRequest().getURI())
.replacePath(newPath)
.build(true)
.toUri();
ServerHttpRequest mutated = exchange.getRequest().mutate()
.uri(newUri)
.build();
return chain.filter(exchange.mutate().request(mutated).build());
}#Java #middle #Spring_Cloud_Gateway #Filters
👍2
RequestRateLimiter
Один из самых сложных фильтров, реализующий ограничение частоты запросов. Работает с Redis для распределённого лимитирования.
Архитектура:
Алгоритм token bucket в Redis:
#Java #middle #Spring_Cloud_Gateway #Filters
Один из самых сложных фильтров, реализующий ограничение частоты запросов. Работает с Redis для распределённого лимитирования.
Архитектура:
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
// 1. Определение ключа для лимитирования
return keyResolver.resolve(exchange)
.switchIfEmpty(Mono.error(new IllegalStateException("Key not found")))
.flatMap(key -> {
// 2. Проверка лимита через Redis
return rateLimiter.isAllowed(key, config.getReplenishRate(),
config.getBurstCapacity(), config.getRequestedTokens())
.flatMap(response -> {
// 3. Добавление заголовков с информацией о лимите
exchange.getResponse().getHeaders()
.add("X-RateLimit-Remaining",
String.valueOf(response.getTokensLeft()));
exchange.getResponse().getHeaders()
.add("X-RateLimit-Replenish-Rate",
String.valueOf(config.getReplenishRate()));
if (response.isAllowed()) {
return chain.filter(exchange);
} else {
// 4. Отклонение запроса при превышении лимита
exchange.getResponse().setStatusCode(
HttpStatus.TOO_MANY_REQUESTS);
return exchange.getResponse().setComplete();
}
});
})
.onErrorResume(Exception.class, e -> {
// Обработка ошибок Redis
log.warn("Rate limiter error", e);
return chain.filter(exchange); // Разрешить запрос при ошибке
});
}Алгоритм token bucket в Redis:
-- Lua-скрипт, выполняемый атомарно в Redis
local tokens_key = KEYS[1] -- ключ для хранения токенов
local timestamp_key = KEYS[2] -- ключ для метки времени
local rate = tonumber(ARGV[1]) -- replenishRate
local capacity = tonumber(ARGV[2]) -- burstCapacity
local now = tonumber(ARGV[3]) -- текущее время
local requested = tonumber(ARGV[4]) -- requestedTokens
local fill_time = capacity / rate
local ttl = math.floor(fill_time * 2)
local last_tokens = tonumber(redis.call("get", tokens_key))
if last_tokens == nil then
last_tokens = capacity
end
local last_refreshed = tonumber(redis.call("get", timestamp_key))
if last_refreshed == nil then
last_refreshed = 0
end
local delta = math.max(0, now - last_refreshed)
local filled_tokens = math.min(capacity, last_tokens + (delta * rate))
local allowed = filled_tokens >= requested
local new_tokens = filled_tokens
if allowed then
new_tokens = filled_tokens - requested
end
redis.call("setex", tokens_key, ttl, new_tokens)
redis.call("setex", timestamp_key, ttl, now)
return { allowed, new_tokens }
#Java #middle #Spring_Cloud_Gateway #Filters
👍2