Értékosztályok: típusbiztonság és sebesség egyaránt

Ha már dolgoztál domain-driven Java architektúrával, biztosan találkoztál ezzel a problémával. Szeretnéd, hogy a fordító már a fordítás pillanatában kiszűrje az érvénytelen állapotokat. Legyen PositiveInt típusod, ami sosem lehet negatív. Vagy DomainName, ami csak érvényes domain nevet fogad el.

Csak aztán jön a teljesítményprobléma. Millió esemény, minden egyes PositiveInt sorozatszámmal – és a típusbiztonság hirtelen 16 bájt overheaddé és felesleges memóriafoglalássá válik. Évekig tartotta magát a gyakorlat: a határon finomítsd a típusokat, de a kritikus úton már nyers int-tel vagy long-gal dolgozz.

Project Valhalla ezt a kompromisszumot szünteti meg.

A régi probléma: a wrapper overhead

Vegyük a PositiveInt példát. Egy egyszerű wrapper osztály, ami egyetlen int-et csomagol, HotSpot alatt 12 bájt objektumfejlécet plusz 4 bájt adatot igényel. Az array azonban nem az értékeket tárolja,而是 azoknak a heap-objektumoknak a hivatkozásait. Minden hozzáférés pointer-dereferenciát jelent, ami potenciális cache-miss-t okoz.

A számok keményen mutatnak: a wrapper négyszer annyi memóriát vesz el, mint az eredő int. És amikor random access patternek jönne elő, minden egyes lépés újabb pointer-követést igényel, ami vertikálja a cache-tartalmakat.

Ez a probléma tett egy merei architektúrát. A domain primitives jól működtek az API-kban,验证input és az invariants-t, de a hot loopokban – amikor stream-eket vagy algoritmusokat futtattatsz – vissza kellett kasztolni nyers primitívekre és elhagyni a típusbiztonságot.

Értékosztályok: a megoldás

Project Valhalla Java 27 Early Access-ben már elérhető, és a value keyword-t bevezetésével újfajta osztályokat támogat. Ez a típus nem rendelkezik identity-vel, és a JVM szabadon dönthet, hogy flatten-eli őket a memória minden szintjén: inline array-ban, embedded field-ben, vagy akár CPU-register-ben.

A kód szinte azonos:

public value class PositiveInt {
    private final int value;

    public PositiveInt(int value) {
        if (value <= 0) {
            throw new IllegalArgumentException("must be positive: " + value);
        }
        this.value = value;
    }

    public int value() { 
        return value; 
    }
}

A konstruktor továbbhin fut, és a statischek még mindig megmaradnak: minden PositiveInt helyén biztosan tudod, hogy a érték pozitív. T

A JVM azonban szabad van zu flatten-eli az 4-bájt int-et direkt in array slot-ba, vagy az object field-be, vagy a register-ba. Nincs objektumheader, indirection vagy cache-miss.

Nagyobb értékosztályok

A value class-ok több primitívre is elérhető sind. Például egy Coordinate tartalmazhat Latitude és Longitude double-eket.

public value class Coordinate {
    private final Latitude latitude;
    private final Longitude longitude;

    public Coordinate(Latitude latitude, Longitude longitude) {
        this.latitude = latitude;
        this.longitude = longitude;
    }
}

Traditional értékosztályokban három szintű indirection van – egy a Coordinate-hoz, és két további a Latitude és Longitudra. Value class-ban viszont a double-ek közvetlenül beágyazódnak, 16 bájt kontinuus data-t tartalmaznak, zero pointer és cache-miss nélkül.

NameOcean és domain nevek

At NameOcean, domain registration és DNS-rendezés során sok időt töltünk validation-nal – valid domain names, pricing és availability. Nyomtatott határvonalában validerálunk, és aztán nyers string-ekkel vagy number-ekkel belsőleg dolgozzunk. With value classes azonban lehet DomainName és Tld értékosztályokat létrehozni, és milliós domain lookup-ot processzálni a DNS pipeline-on keresztül – type-safe és performance-wise mindway.

public value class DomainName {
    private final String value;

    public DomainName(String value) {
        if (!isValidDomain(value)) {
            throw new IllegalArgumentException("Invalid domain: " + value);
        }
        this.value = value;
    }
}

public value case Tld {
    private final String value;

    public Tld(String value) {
        if (!isValidTld(value)) {
            throw new IllegalArgumentException("Invalid TLD: " + value);
        }
        this.value = value;
    }

Type Safety és Compile-Time Correctness

Beyond performance, value classes visszaállítják a Java fejlesztés fontos részét: compile-time correctness. Hogy T extends RefinedInt<T> F-bounded generikusok segítségével a compiler megelőzi, hogy Probability és Price értékosztályokat összehasonlítsunk. F-bounded generics és Value classes együtt nem the praktisch olyan praktisch, olyan korábban nem volt.

Architektúra változása

A cloud applications-ban, például NameOcean's Vibe Hosting-ban, value classes olyan shift-t képviseli, hogy performance optimization új módon gondolkodhat.

• Boundary validation és hot-path performance nem több konfliktus
• Type safety egész codebook-ra skálálódik
• Domain-driven design most praktikus és efficient lehet

You can now encode business rules into your type system and let the JVM handle the performance implications. No more choosing between correctness and speed.

A jövő

Project Valhalla még preview-ban van (Java 27 EA), but the trajectory is clear. Once value classes stabilize in Java LTS releases, they'll likely become foundational to how serious Java architectures are built.

If you're designing systems today, start thinking about where refined types could live in your code without performance penalty. Where do you validate once at the boundary and then work with unsafe primitives? Those are your candidates for value classes tomorrow.

The friction between type safety and performance is lifting. It's a good time to rethink your domain primitives.

Want to build high-performance systems on modern infrastructure? NameOcean's Vibe Hosting leverages AI-powered optimization for cloud applications. Check out how value classes fit into modern cloud-native architecture.