Java 21 vs Java 17: полный разбор нововведений и миграционное руководство

import static java.lang.StringTemplate.STR;

// Базовый шаблон
String name = "John";
int age = 30;
String message = STR."Name: \{name}, Age: \{age}";
// Результат: "Name: John, Age: 30"

// Выражения любой сложности
double price = 19.99;
int quantity = 3;
String receipt = STR."""
    Чек:
    Товар: Книга по Java 21
    Цена: \{price} €
    Количество: \{quantity}
    Итого: \{price * quantity} €
    """;
// Многострочные шаблоны с сохранением форматирования

// FMT шаблон для форматирования
import static java.util.FormatProcessor.FMT;
double value = 12345.6789;
String formatted = FMT."Число: %,.2f\{value}";
// Результат: "Число: 12,345.68" (локализация!)

// Безопасные шаблоны (SQL injection protection)
String userInput = getUserInput();
String query = SQL."""
    SELECT * FROM users 
    WHERE username = \{userInput}
    """;
// Автоматически экранирует значения!

4.3. Кастомные template processors

// Создание своего процессора
StringTemplate.Processor<String, RuntimeException> JSON = st -> {
    StringBuilder sb = new StringBuilder("{");
    List<Object> values = st.values();
    List<String> fragments = st.fragments();
    
    for (int i = 0; i < values.size(); i++) {
        String key = fragments.get(i).replace("\"", "").trim();
        if (!key.isEmpty()) {
            sb.append("\"").append(key).append("\": ");
            Object value = values.get(i);
            if (value instanceof String) {
                sb.append("\"").append(value).append("\"");
            } else {
                sb.append(value);
            }
            if (i < values.size() - 1) sb.append(", ");
        }
    }
    sb.append("}");
    return sb.toString();
};

// Использование
String name = "John";
int age = 30;
String json = JSON."""
    name: \{name}
    age: \{age}
    """;
// Результат: {"name": "John", "age": 30}

Scoped Values (замена ThreadLocal)

5.1. Проблемы ThreadLocal в Java 17

// Java 17: ThreadLocal имеет несколько проблем
private static final ThreadLocal<User> currentUser = new ThreadLocal<>();

// 1. Утечки памяти в пулах потоков
void processRequest() {
    currentUser.set(getUser()); // Устанавливаем пользователя
    try {
        // бизнес-логика
    } finally {
        currentUser.remove(); // ОБЯЗАТЕЛЬНО очистить!
    }
    // Если забыть remove() - утечка памяти
}

// 2. Наследование проблематично
ThreadLocal<String> parentValue = new InheritableThreadLocal<>();
parentValue.set("parent");

Thread child = new Thread(() -> {
    System.out.println(parentValue.get()); // "parent"
    // Но что если parent изменит значение после создания child?
});
child.start();

// 3. Высокий overhead для виртуальных потоков
// ThreadLocal + виртуальные потоки = катастрофа производительности

5.2. Scoped Values в Java 21

// ScopedValue - легковесная замена ThreadLocal
private static final ScopedValue<User> CURRENT_USER = ScopedValue.newInstance();

// Использование
void handleRequest(Request request) {
    User user = authenticate(request);
    
    // Значение доступно только в пределах scope
    ScopedValue.where(CURRENT_USER, user)
               .run(() -> processUserRequest());
    
    // Здесь CURRENT_USER уже не доступен - автоматическая очистка!
    // Нет утечек памяти!
}

void processUserRequest() {
    User user = CURRENT_USER.get(); // Безопасный доступ
    System.out.println("Processing for: " + user.name());
}

// Вложенные scope
private static final ScopedValue<String> LANGUAGE = ScopedValue.newInstance();
private static final ScopedValue<Locale> LOCALE = ScopedValue.newInstance();

void processInternational() {
    ScopedValue.where(LANGUAGE, "en")
               .where(LOCALE, Locale.US)
               .run(() -> {
        System.out.println(LANGUAGE.get() + " - " + LOCALE.get());
        
        // Вложенный scope с переопределением
        ScopedValue.where(LANGUAGE, "fr")
                   .run(() -> {
            System.out.println(LANGUAGE.get()); // "fr"
            System.out.println(LOCALE.get());   // Locale.US (из внешнего scope)
        });
    });
}

// Rebinding запрещен (безопасность)
ScopedValue.where(CURRENT_USER, user1)
           .run(() -> {
    // CURRENT_USER.set(user2); // ОШИБКА: IllegalStateException
    // Можно только создать новый вложенный scope
    ScopedValue.where(CURRENT_USER, user2)
               .run(() -> {
        // Новый scope с новым значением
    });
});

Другие важные нововведения

6.1. Record Patterns в for циклах

// Java 21: Деструктуризация в циклах
record Employee(String name, int age, Department dept) {}
record Department(String name, String location) {}

List<Employee> employees = getEmployees();

// Деструктуризация records
for (Employee(var name, var age, Department(var deptName, var location)) : employees) {
    System.out.printf("%s works in %s (%s)%n", name, deptName, location);
}

// С guard выражениями
for (Employee(var name, var age, var dept) : employees 
     if age > 30 && dept.name().equals("IT")) {
    System.out.println("Senior IT: " + name);
}

6.2. Unnamed Patterns and Variables

// Игнорирование ненужных компонентов
Object obj = getComplexObject();

// Старый способ
if (obj instanceof Point p) {
    System.out.println("Point: " + p.x()); // y не нужен
}

// Java 21: Unnamed pattern
if (obj instanceof Point(int x, _)) { // Игнорируем y
    System.out.println("X coordinate: " + x);
}

// Unnamed variables
try {
    int result = calculate();
} catch (Exception _) { // Игнорируем исключение
    System.out.println("Calculation failed");
}

// В циклах
for (int i = 0, _ = initSomething(); i < 10; i++) {
    // _ используется для инициализации, но не в теле цикла
}

// В lambda параметрах
map.forEach((key, _) -> System.out.println("Key: " + key));

6.3. Deprecation Warning for VM

// Java 21 добавляет предупреждения для устаревших VM флагов
// При запуске с устаревшими флагами:
// java -XX:+UseConcMarkSweepGC MyApp
// Warning: Option UseConcMarkSweepGC was deprecated in version 9.0
// and will likely be removed in a future release.

// Новые диагностические опции
-XX:+EnableDynamicAgentLoading
-XX:DumpLoadedClassList=classes.txt

6.4. Криптографические улучшения

// Поддержка алгоритма Dilithium (пост-квантовая криптография)
KeyPairGenerator kpg = KeyPairGenerator.getInstance("Dilithium");
KeyPair kp = kpg.generateKeyPair();

// Улучшенная поддержка EdDSA
Signature sig = Signature.getInstance("Ed25519");
sig.initSign(privateKey);
sig.update(message);
byte[] signature = sig.sign();

Миграция с Java 17 на Java 21: практическое руководство

7.1. Подготовка к миграции

# 1. Проверка совместимости
javac --release 21 -Xlint:all src/**/*.java

# 2. Анализ зависимостей
./mvnw dependency:tree
# Проверить, что все зависимости совместимы с Java 21

# 3. Обновление инструментов
# Обновить Maven до 3.9+, Gradle до 8.3+
# Обновить IDE (IntelliJ 2023.2+, Eclipse 4.28+)

# 4. Настройка CI/CD
# Обновить образы Docker:
FROM eclipse-temurin:21-jdk

7.2. Поэтапная миграция

<!-- pom.xml для поэтапной миграции -->
<properties>
    <maven.compiler.release>21</maven.compiler.release>
    <!-- Можно начать с 17, затем перейти на 21 -->
</properties>

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.11.0</version>
            <configuration>
                <release>21</release>
                <compilerArgs>
                    <!-- Включить preview фичи если нужно -->
                    <arg>--enable-preview</arg>
                </compilerArgs>
                <source>21</source>
                <target>21</target>
            </configuration>
        </plugin>
    </plugins>
</build>

7.3. Обратная совместимость

// Java 21 поддерживает class file version 65.0 (Java 21)
// Но может читать более старые версии

// Потенциальные проблемы:
// 1. Удаленные API (уже удаленные в Java 17 обычно)
// 2. Изменения в Security Manager (deprecated в 17, удален в 21)
// 3. Finalization (deprecated в 18, удален в 21)

// Решение проблем с Finalization:
public class ResourceCleanup {
    // Вместо finalize():
    
    // Способ 1: Cleaner (Java 9+)
    private static final Cleaner cleaner = Cleaner.create();
    private final Cleaner.Cleanable cleanable;
    
    public ResourceCleanup() {
        this.cleanable = cleaner.register(this, this::cleanup);
    }
    
    private void cleanup() {
        // Освобождение ресурсов
    }
    
    // Способ 2: Try-with-resources
    public void process() {
        try (var resource = acquireResource()) {
            // использование
        } // автоматическое закрытие
    }
}

Заключение

Java 21 представляет собой значительный шаг вперед по сравнению с Java 17, принося не просто инкрементальные улучшения, а фундаментальные изменения в парадигме разработки.