Java 25: API và Thư Viện Mới

Trong series này, chúng ta đã xem qua những thay đổi về ngôn ngữ và cải tiến JVM và performance trong Java 25. Bài này chuyển sang phần standard library của release.

Java 25 bổ sung một số API mới đáng kể — từ concurrency utilities được finalize vĩnh viễn vào platform, đến các cryptography API lấp đầy khoảng trống đã tồn tại lâu nay trong standard library.

Các addition chính gồm:

• JEP 506: Scoped Values (Final)
• JEP 510: Key Derivation Function API (Final)
• JEP 502: Stable Values (Preview)
• JEP 470: PEM Encodings of Cryptographic Objects (Preview)
• JEP 508: Vector API (Tenth Incubator)

Không phải tất cả đều sẵn sàng cho production theo cùng một cách. Chúng ta sẽ đề cập đến stability, use case thực tế, và nên đánh giá cái gì trước.

Phân Loại Nhanh

Trước khi đi sâu, đây là cách chia hữu ích nhất theo stability:

Final — dùng trong production không cần flag

• Scoped Values (java.lang.ScopedValue)
• Key Derivation Function API (javax.crypto.KDF)

Preview — yêu cầu --enable-preview khi compile và runtime

• Stable Values (java.lang.StableValue)
• PEM Encodings (java.security.PEMEncoder / PEMDecoder)

Incubator — yêu cầu --add-modules jdk.incubator.vector

• Vector API (jdk.incubator.vector)

Các final feature là actionable nhất cho hầu hết các team. Preview và incubator feature đáng theo dõi nhưng chưa phù hợp cho production chuẩn.

1. Scoped Values (Final)

JEP 506 đưa Scoped Values vào như một API được finalize vĩnh viễn trong Java 25. Đây là một trong những addition thực tế quan trọng nhất trong release này cho backend developer.

Vấn Đề

ThreadLocal được thiết kế cho thế giới của platform thread, thường theo mô hình một thread per request. Model đó hoạt động tốt nhiều năm, nhưng có ba vấn đề nghiêm trọng khi kết hợp với virtual thread:

• Mutability: Bất kỳ code nào có reference đến key đều có thể gọi set() bất cứ lúc nào, khiến state khó reasoning.
• Cleanup: Phải gọi remove() thủ công, không thì dễ bị memory leak trong thread pool.
• Chi phí khi scale: Khi virtual thread fork child task, mỗi thread kế thừa một bản copy của thread-local map — rất tốn kém khi có hàng trăm nghìn concurrent thread.

Scoped Values Giải Quyết Gì

ScopedValue được thiết kế chính xác cho use case "truyền read-only context xuống call stack". Một scoped value:

• immutable sau khi được bind,
• tự động dọn dẹp khi scope thoát ra,
• kế thừa rẻ bởi child virtual thread thông qua StructuredTaskScope.

API

// Khai báo scoped value — thường là static final
static final ScopedValue<String> REQUEST_ID = ScopedValue.newInstance();
static final ScopedValue<User> CURRENT_USER = ScopedValue.newInstance();

Bind và chạy:

ScopedValue.where(REQUEST_ID, req.getId())
           .where(CURRENT_USER, authenticate(req))
           .run(this::processRequest);

Đọc từ bất kỳ đâu trong call tree:

String reqId = REQUEST_ID.get();       // throws nếu chưa bind
User user = CURRENT_USER.orElse(null); // fallback an toàn

Pattern Server Framework

Đây là cách request-scoped context trông như thế nào với ScopedValue:

public class RequestHandler {
    private static final ScopedValue<String> REQUEST_ID = ScopedValue.newInstance();
    private static final ScopedValue<User> CURRENT_USER = ScopedValue.newInstance();
 
    public void handle(HttpRequest req) {
        ScopedValue.where(REQUEST_ID, req.getId())
                   .where(CURRENT_USER, authenticate(req))
                   .run(this::processRequest);
        // sau khi run() return, REQUEST_ID và CURRENT_USER tự động unbound
        // không cần cleanup code
    }
 
    private void processRequest() {
        String reqId = REQUEST_ID.get();
        User user = CURRENT_USER.get();
        // truyền xuống service, repository, logger — đều đọc được cùng giá trị
    }
}

Propagation Xuống Child Virtual Thread

Khi dùng StructuredTaskScope, scoped value tự động được kế thừa bởi các forked subtask:

private static final ScopedValue<String> TRACE_ID = ScopedValue.newInstance();
 
ScopedValue.where(TRACE_ID, "abc-123").run(() -> {
    try (var scope = StructuredTaskScope.open()) {
        scope.fork(() -> callServiceA()); // TRACE_ID.get() == "abc-123"
        scope.fork(() -> callServiceB()); // TRACE_ID.get() == "abc-123"
        scope.join();
    }
});
// TRACE_ID unbound tại đây — không cần gọi remove()

Re-Binding Trong Nested Scope

Scoped value có thể re-bind cho một nested scope. Binding bên ngoài được tự động restore khi inner scope thoát ra:

ScopedValue.where(USER, "alice").run(() -> {
    // USER.get() == "alice"
    ScopedValue.where(USER, "sudo").run(() -> doAdminAction());
    // USER.get() == "alice" trở lại — tự động restore
});

ScopedValue vs ThreadLocal

Lời Khuyên Cho Production

ScopedValue được finalize trong Java 25 và sẵn sàng cho production. Các migration target tự nhiên nhất:

• User identity và security context per-request,
• Propagation correlation ID cho distributed tracing,
• Tenant ID trong multi-tenant application,
• Thay thế logger MDC trong hệ thống dùng nhiều virtual thread.

2. Key Derivation Function API (Final)

JEP 510 bổ sung Key Derivation Function (KDF) API chuẩn vào package javax.crypto. Đây lấp đầy một khoảng trống thực sự trong Java standard library.

KDF Là Gì

Key Derivation Function nhận một source secret — shared secret từ Diffie-Hellman, passphrase, hoặc random seed — và derive ra một hoặc nhiều key cryptographically mạnh, độc lập với nhau.

Algorithm hiện đại phổ biến nhất là HKDF, hoạt động theo hai bước:

1. Extract: Nén input keying material thành một pseudorandom key đồng nhất.
2. Expand: Kéo dài key đó thành nhiều key riêng biệt theo từng mục đích, dùng context label.

HKDF là cơ chế key derivation bên trong TLS 1.3, Signal Protocol, Noise Protocol, và nhiều hệ thống hiện đại khác.

Vấn Đề Trước Java 25

Java không có KDF API chuẩn. Developer phải:

• dùng SecretKeyFactory với các workaround khó chịu,
• import BouncyCastle,
• hoặc tự viết HMAC-based derivation.

Không cách nào trong số đó thỏa mãn với team muốn giữ trong standard library.

API

Class chính là javax.crypto.KDF, được mô phỏng theo Cipher và MessageDigest:

KDF hkdf = KDF.getInstance("HKDF-SHA256");

Java 25 hỗ trợ ba variant: HKDF-SHA256, HKDF-SHA384, và HKDF-SHA512.

Full Extract-then-Expand (Pattern Phổ Biến Nhất)

KDF hkdf = KDF.getInstance("HKDF-SHA256");
 
byte[] ikm  = sharedSecret;                      // input keying material
byte[] salt = secureRandomSalt;                  // khuyến nghị: 32 bytes với SHA-256
byte[] info = "myapp|v1|encryption".getBytes();  // context label
 
AlgorithmParameterSpec spec = HKDFParameterSpec.ofExtract()
    .addIKM(ikm)
    .addSalt(salt)
    .thenExpand(info, 32); // derive 32 bytes → AES-256 key
 
SecretKey aesKey = hkdf.deriveKey("AES", spec);

Derive Nhiều Key Độc Lập

Pattern phổ biến là derive encryption key và MAC key từ cùng một shared secret:

KDF hkdf = KDF.getInstance("HKDF-SHA256");
 
// Bước 1: extract pseudorandom key
byte[] prk = hkdf.deriveData(
    HKDFParameterSpec.ofExtract()
        .addIKM(sharedSecret)
        .addSalt(salt)
        .extractOnly()
);
SecretKey prkKey = new SecretKeySpec(prk, "Generic");
 
// Bước 2: expand thành hai key độc lập với context label khác nhau
SecretKey encKey = hkdf.deriveKey("AES",
    HKDFParameterSpec.expandOnly(prkKey, "encryption-key".getBytes(), 32));
 
SecretKey macKey = hkdf.deriveKey("HmacSHA256",
    HKDFParameterSpec.expandOnly(prkKey, "authentication-key".getBytes(), 32));

Hai key này cryptographically độc lập — biết một key không cho bạn biết gì về key kia.

Khi Nào Dùng deriveData vs deriveKey

// Dùng deriveKey khi cần SecretKey object (để dùng với Cipher, Mac, v.v.)
SecretKey aesKey = hkdf.deriveKey("AES", spec);
 
// Dùng deriveData khi cần raw bytes (cho mục đích không phải key)
byte[] rawBytes = hkdf.deriveData(spec);

Relevant Với Backend Developer Ở Đâu

• Derive session key từ Diffie-Hellman shared secret.
• Key wrapping: derive key-encryption key từ master secret.
• Implement protocol theo pattern TLS 1.3 hoặc Noise Protocol.
• Secure token generation nơi cần các key độc lập theo từng mục đích.

Lưu Ý Về PBKDF2

PBKDF2 không được truy cập qua class KDF mới. Nó vẫn nằm trong SecretKeyFactory để đảm bảo backward compatibility. KDF API hướng về phía trước với các algorithm hiện đại như HKDF.

3. Stable Values (Preview)

JEP 502 giới thiệu StableValue, một lazy initialization primitive mới trong package java.lang. Đây là preview trong Java 25, nghĩa là yêu cầu --enable-preview và có thể thay đổi trước khi finalize.

Vấn Đề

Java có vài option cho deferred initialization, và không cái nào thực sự lý tưởng:

• static final field: khởi tạo sớm (eager) lúc class load.
• Double-checked locking với volatile: dễ lỗi và ngăn JIT constant-folding.
• "Holder class" pattern: chỉ dùng được cho static field.

StableValue nhằm mục tiêu cho phép lazy, thread-safe, at-most-once initialization mà JVM có thể xử lý tương tự final field sau khi được set.

Khái Niệm Cốt Lõi

Một StableValue<T> là container có thể được set đúng một lần. Sau khi được set, JVM có thể constant-fold các lần đọc giống như với final field.

Entry point phổ biến nhất là supplier factory, bao bọc lazy initialization gọn gàng:

public class Component {
    // computed một lần lúc access đầu tiên, sau đó constant-foldable
    private final Supplier<Logger> logger =
        StableValue.supplier(() -> Logger.getLogger(Component.class));
 
    public void process() {
        logger.get().info("Process started");
    }
}

Dùng StableValue Trực Tiếp

Với các trường hợp cần kiểm soát nhiều hơn:

public class Component {
    private final StableValue<Config> config = StableValue.of();
 
    private Config getConfig() {
        return config.orElseSet(() -> Config.load());
        // orElseSet thread-safe: supplier chạy nhiều nhất một lần
    }
}

Các method chính trên StableValue<T>:

T orElseSet(Supplier<? extends T> supplier) // compute và set nếu chưa set (at-most-once)
boolean trySet(T contents)                  // set nếu chưa set; trả false nếu đã set
void setOrThrow(T contents)                 // set; throws nếu đã set
T orElseThrow()                             // lấy; throws nếu chưa set
T orElse(T other)                           // lấy hoặc default
boolean isSet()                             // kiểm tra đã set chưa

Memoized Function

StableValue cũng cung cấp higher-level factory method cho các pattern memoization phổ biến:

// Memoized IntFunction: cache kết quả cho input trong [0, size)
IntFunction<Integer> powers =
    StableValue.intFunction(10, n -> 1 << n);
 
int four = powers.apply(2); // computed một lần, sau đó được cache
int eight = powers.apply(3);
 
// Lazy list: các phần tử được computed lúc access đầu tiên
List<String> labels =
    StableValue.list(5, i -> "item-" + i);
 
// Lazy map: giá trị computed lúc access đầu tiên cho set key định trước
Map<String, Config> configs =
    StableValue.map(Set.of("dev", "staging", "prod"), env -> Config.load(env));

Recursive Memoization

Vì memoized function biết toàn bộ input range từ trước, nó hỗ trợ đệ quy an toàn:

final class Fibonacci {
    private static final int MAX = 46;
    private static final IntFunction<Integer> FIB =
        StableValue.intFunction(MAX, Fibonacci::fib);
 
    public static int fib(int n) {
        return n < 2 ? n : FIB.apply(n - 1) + FIB.apply(n - 2);
    }
}

Tại Sao Vẫn Còn Là Preview

StableValue đụng đến vùng JVM optimization tinh tế. JEP team muốn thêm feedback về:

• API surface chính xác trước khi finalize,
• các edge case trong JIT constant-folding guarantee,
• và cách nó compose với value class từ Project Valhalla.

Vậy nên dù ý tưởng rất hấp dẫn, hãy xem đây là thứ để evaluate và experiment hơn là pattern production mặc định.

Góc Độ JVM Optimization

Lý do StableValue quan trọng hơn chỉ "lazy initialization" là cách JVM xử lý. Khi một StableValue được lưu trong static final field và được set, JIT có thể xử lý các lần đọc sau như đọc final field — enable cùng constant-folding optimization mà final có, mà không yêu cầu giá trị phải được set lúc construction. Đó là điểm khác biệt chính so với volatile.

4. PEM Encodings of Cryptographic Objects (Preview)

JEP 470 bổ sung PEM API chuẩn vào java.security. Đây là preview feature trong Java 25, yêu cầu --enable-preview.

PEM Là Gì

PEM (Privacy-Enhanced Mail) là format text encoding mà bạn thấy ở khắp nơi trong security:

-----BEGIN CERTIFICATE-----
MIIBkTCB+wIJ...
-----END CERTIFICATE-----

PEM file xuất hiện trong TLS certificate chain, private key file, CSR, và SSH key. Dù ubiquitous như vậy, Java không có API chuẩn để đọc hoặc ghi chúng. Workaround phổ biến là dùng BouncyCastle hoặc viết code tự strip Base64 thủ công.

API

Hai class mới, đều immutable và thread-safe:

PEMEncoder — convert Java cryptographic object thành PEM text:

PEMEncoder encoder = PEMEncoder.of();
 
// Encode private key
String privateKeyPem = encoder.encodeToString(keyPair.getPrivate());
 
// Encode public key
String publicKeyPem = encoder.encodeToString(keyPair.getPublic());
 
// Encode certificate
String certPem = encoder.encodeToString(x509Cert);
 
// Encrypt private key với password
PEMEncoder encryptingEncoder = PEMEncoder.of().withEncryption("passphrase".toCharArray());
String encryptedPem = encryptingEncoder.encodeToString(keyPair.getPrivate());

PEMDecoder — convert PEM text trở lại Java object:

PEMDecoder decoder = PEMDecoder.of();
 
// Typed decode — biết trước type cần lấy
PublicKey pub = decoder.decode(pemText, PublicKey.class);
PrivateKey priv = decoder.decode(privPemText, PrivateKey.class);
X509Certificate cert = decoder.decode(certPemText, X509Certificate.class);
 
// Decrypt encrypted private key
PEMDecoder decryptingDecoder = PEMDecoder.of().withDecryption("passphrase".toCharArray());
PrivateKey key = decryptingDecoder.decode(encryptedPem, PrivateKey.class);

Auto-Detection Với Pattern Matching

Khi không biết trước type:

DEREncodable obj = PEMDecoder.of().decode(unknownPem);
 
switch (obj) {
    case X509Certificate cert ->
        System.out.println("Subject: " + cert.getSubjectX500Principal());
    case PrivateKey key ->
        System.out.println("Algorithm: " + key.getAlgorithm());
    case PublicKey key ->
        System.out.println("Public key type: " + key.getAlgorithm());
    case PEMRecord record ->
        System.out.println("Unknown PEM type: " + record.type());
}

Các Type Được Hỗ Trợ

Tại Sao Điều Này Quan Trọng

Trước đây, load một RSA private key do OpenSSL tạo ra cần hai đến ba library hoặc năm mươi dòng code parse Base64 thủ công. API mới rút gọn xuống còn một method call, dùng thuần standard library. Với developer xây dựng hệ thống TLS-aware, xử lý certificate tùy chỉnh, hoặc key management tooling, đây là cải thiện chất lượng cuộc sống đáng kể.

5. Vector API (Tenth Incubator)

JEP 508 là lần incubator thứ mười của Vector API. Được truy cập qua module jdk.incubator.vector, yêu cầu --add-modules jdk.incubator.vector.

Vector API cung cấp cách diễn đạt SIMD (Single Instruction, Multiple Data) computations được compile thành hardware vector instruction như AVX2 và AVX-512 trên x64, hoặc NEON và SVE trên ARM.

Tại Sao Vẫn Còn Là Incubator

Vector API bị giữ lại khỏi preview vì cần Project Valhalla. Vector type cần là value type — stack-allocated, không có object identity, không null — để đạt performance tối đa. Cho đến khi value class support của Valhalla sẵn sàng, API design cuối cùng chưa thể được lock down.

Thay Đổi Trong Lần Incubation Thứ Mười

Ba addition đáng chú ý trong Java 25:

1. VectorShuffle hỗ trợ MemorySegment: Có thể load/store shuffle pattern trực tiếp từ/vào off-heap memory, tích hợp chặt hơn với BLAS-style routine.
2. Implementation dùng FFM API: Internal implementation giờ link đến native math library qua Foreign Function & Memory API thay vì custom C++ JVM code.
3. Float16 auto-vectorization: Các phép tính cộng, trừ, nhân, chia, và fused multiply-add trên Float16 giờ được auto-vectorize trên CPU x64 hỗ trợ — hữu ích cho ML inference.

Cách Hoạt Động

Abstraction cốt lõi là VectorSpecies, kết hợp element type với vector width:

import jdk.incubator.vector.*;
 
// SPECIES_PREFERRED chọn vector rộng nhất JVM có thể dùng hiệu quả
static final VectorSpecies<Float> SPECIES = FloatVector.SPECIES_PREFERRED;

Trên CPU với AVX-512, SPECIES_PREFERRED có thể xử lý 16 float mỗi instruction. Với AVX2 là 8. Trên CPU không có vector support, fallback về scalar.

SIMD Array Multiplication

static float[] vectorMultiply(float[] a, float[] b) {
    float[] result = new float[a.length];
    int i = 0;
    int upperBound = SPECIES.loopBound(a.length);
 
    // vectorized loop — xử lý SPECIES.length() phần tử mỗi iteration
    for (; i < upperBound; i += SPECIES.length()) {
        FloatVector va = FloatVector.fromArray(SPECIES, a, i);
        FloatVector vb = FloatVector.fromArray(SPECIES, b, i);
        va.mul(vb).intoArray(result, i);
    }
 
    // scalar tail
    for (; i < a.length; i++) {
        result[i] = a[i] * b[i];
    }
    return result;
}

Dot Product Với Fused Multiply-Add

static float dotProduct(float[] a, float[] b) {
    FloatVector sum = FloatVector.zero(SPECIES);
    int i = 0;
    int upperBound = SPECIES.loopBound(a.length);
 
    for (; i < upperBound; i += SPECIES.length()) {
        FloatVector va = FloatVector.fromArray(SPECIES, a, i);
        FloatVector vb = FloatVector.fromArray(SPECIES, b, i);
        sum = va.fma(vb, sum); // fused multiply-add: sum += va * vb
    }
 
    float result = sum.reduceLanes(VectorOperators.ADD);
    for (; i < a.length; i++) result += a[i] * b[i];
    return result;
}

Masked Operation

Mask cho phép áp dụng operation có điều kiện theo từng lane:

// ReLU: clamp giá trị âm về 0
static float[] relu(float[] input) {
    float[] output = new float[input.length];
    FloatVector zero = FloatVector.zero(SPECIES);
    int i = 0;
    for (; i < SPECIES.loopBound(input.length); i += SPECIES.length()) {
        FloatVector v = FloatVector.fromArray(SPECIES, input, i);
        v.max(zero).intoArray(output, i);
    }
    for (; i < input.length; i++) output[i] = Math.max(input[i], 0);
    return output;
}

Ai Nên Quan Tâm

Vector API phù hợp nhất với:

• numerical computing và scientific workload,
• ML inference (matrix multiply, embedding lookup),
• audio và video signal processing,
• image filter,
• full-text search scoring function.

Với CRUD backend application thông thường, Vector API chưa relevant. Nhưng với Java performance-focused trong data hoặc ML context, đáng học dù vẫn còn là incubator.

Các Thay Đổi Thư Viện Khác Đáng Chú Ý

Algorithm Mới Trong MessageDigest

Java 25 bổ sung hai MessageDigest algorithm mới:

• SHAKE128-256 — variant 256-bit fixed-length của SHAKE128 (NIST FIPS 202)
• SHAKE256-512 — variant 512-bit fixed-length của SHAKE256 (NIST FIPS 202)

Đây là extended output function (XOF) từ SHA-3 family, được dùng trong một số cryptographic protocol hiện đại.

TLS 1.2 Hardening

SHA-1 giờ bị tắt mặc định trong TLS 1.2 handshake signature. Điều này đưa TLS configuration mặc định của Java gần hơn với security recommendation hiện tại. Hầu hết deployment hiện đại sẽ không thấy gì khác, nhưng application kết nối đến hệ thống legacy vẫn dùng SHA-1 trong TLS handshake có thể cần re-enable thủ công.

TLS Keying Material Exporter

ExtendedSSLSession có thêm hai method mới:

SecretKey exportKeyingMaterialKey(String label, byte[] context, int length);
byte[] exportKeyingMaterialData(String label, byte[] context, int length);

Đây implement RFC 5705 (Keying Material Exporter cho TLS), cần thiết cho một số protocol implementation muốn derive shared secret gắn với một TLS session cụ thể.

Class IO Helper

Như một phần của JEP 512 (Compact Source Files), một class java.lang.IO mới có sẵn:

IO.println("Hello, World!");
IO.print("không có newline");
String line = IO.readln("Nhập tên của bạn: ");

Trong compact source file, IO được import tự động. Trong class file thông thường, truy cập qua java.lang.IO. Đây là convenience nhỏ, chủ yếu liên quan đến ví dụ và script.

Nên Đánh Giá API Nào Trước?

Nếu muốn đánh giá nhanh các library addition trong Java 25:

1. Scoped Values nếu team đang adopt virtual thread và muốn thay thế ThreadLocal cho request-scoped context.
2. Key Derivation Function API nếu làm việc với bất kỳ hệ thống security-sensitive nào cần HKDF — stable và dùng được ngay.
3. PEM Encodings nếu xử lý certificate, key, hoặc TLS configuration và muốn bỏ BouncyCastle cho use case đó. Lưu ý vẫn còn là preview.
4. Stable Values nếu quan tâm đến lazy initialization performance, đặc biệt là startup time. Theo dõi, nhưng chờ finalize trước khi đưa vào team standard.
5. Vector API chỉ nếu đang làm numerical hoặc ML-adjacent work và thoải mái với incubator feature.

Kết

Câu chuyện API mới trong Java 25 theo pattern rõ ràng: lấp đầy các khoảng trống lâu nay trong standard library trong khi tiếp tục phát triển concurrency và security primitive.

Scoped Values và Key Derivation Function API là các addition headline vì cả hai đều được finalize và ngay lập tức applicable. Chúng giải quyết các vấn đề thực tế mà Java developer đã phải workaround bằng external library hoặc các pattern awkward.

Stable Values và PEM Encodings là các ý tưởng compelling cần thêm một iteration nữa trước khi sẵn sàng cho production chuẩn. Cả hai đáng học từ bây giờ.

Vector API tiếp tục mature đều đặn, đợi Project Valhalla unblock design cuối cùng của nó.

Nhìn chung, các Java 25 standard library addition tiếp tục hành trình chậm mà chắc của platform hướng đến việc đầy đủ hơn ngay trong hộp.

Ở bài tiếp theo trong series này, chúng ta sẽ xem qua các deprecation và removal trong Java 25 — những feature và API đang được phase out, và bạn nên làm gì nếu code của mình phụ thuộc vào chúng.