GraalVM – native compilation Javy

Czy wyobrażasz sobie aplikację Java startującą w 20 milisekund? Czy chciałbyś, żeby Twoja aplikacja Spring Boot zajmowała tylko 30MB RAM-u zamiast 300MB? To już nie science fiction – to GraalVM native compilation.

Dlaczego GraalVM to przełom w świecie Javy?

Tradycyjne aplikacje Java mają fundamentalny problem: wolny start i wysokie zużycie pamięci. JVM musi załadować tysiące klas, zainicjalizować JIT compiler i przygotować środowisko runtime. W świecie cloud computing, gdzie płacisz za każdą sekundę działania i każdy MB pamięci, to ogromny koszt.

GraalVM rozwiązuje ten problem, kompilując kod Java do natywnych binarek jeszcze przed uruchomieniem. To oznacza, że nie potrzebujesz JVM-a w runtime – aplikacja działa jak native’owy program C czy Go.

Czym jest GraalVM?

GraalVM to uniwersalna maszyna wirtualna opracowana przez Oracle, która wspiera nie tylko Javę, ale także Scala, Kotlin, JavaScript, Python, Ruby i wiele innych języków. Jednak jej najciekawszą funkcjonalnością jest native-image – narzędzie do kompilacji kodu Java do natywnych binarek.

Jak działa tradycyjna JVM vs GraalVM native?

Tradycyjna JVM:

1. Uruchamiasz java -jar app.jar
2. JVM loaduje klasy podczas runtime
3. JIT compiler optymalizuje kod w locie
4. Aplikacja osiąga pełną wydajność po „rozgrzaniu”

GraalVM native:

1. Kompilacja: native-image analizuje cały kod
2. Generuje natywną binarkę z całym runtime
3. Uruchamiasz bezpośrednio ./my-app
4. Aplikacja osiąga pełną wydajność od pierwszej milisekundy

Instalacja i konfiguracja GraalVM

Rozpocznijmy od instalacji GraalVM. W 2019 roku najlepiej pobrać GraalVM Community Edition z oficjalnej strony Oracle.

# Pobierz GraalVM CE 19.1.1 dla Java 8
wget https://github.com/oracle/graal/releases/download/vm-19.1.1/graalvm-ce-linux-amd64-19.1.1.tar.gz

# Rozpakuj i ustaw JAVA_HOME
tar -xzf graalvm-ce-linux-amd64-19.1.1.tar.gz
export JAVA_HOME=/path/to/graalvm-ce-19.1.1
export PATH=$JAVA_HOME/bin:$PATH

# Zainstaluj native-image
gu install native-image

# Sprawdź wersję
java -version
native-image --version

Pierwszy projekt – Hello World native

Zacznijmy od prostego przykładu, żeby zrozumieć proces kompilacji.

// HelloWorld.java
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello from GraalVM native!");
        System.out.println("Start time: " + System.currentTimeMillis());
    }
}

# Kompilacja standardowa
javac HelloWorld.java

# Kompilacja do native binary
native-image HelloWorld

# Uruchomienie
./helloworld

Pierwsza kompilacja może potrwać kilka minut, ponieważ native-image analizuje cały kod i jego dependencies. Rezultat? Binarka wielkości około 8MB, która startuje w milisekundach.

Spring Boot z GraalVM – praktyczny przykład

Prawdziwy test to aplikacja Spring Boot. W 2019 roku Spring Boot nie ma jeszcze pełnego wsparcia dla GraalVM (to przyjdzie w Spring Native w 2021), ale można to zrobić ręcznie.

Konfiguracja Maven

    4.0.0
    
    com.example
    graal-demo
    1.0.0
    jar
    
    
        8
        8
        2.1.5.RELEASE
    
    
    
        
            org.springframework.boot
            spring-boot-starter-web
            ${spring-boot.version}
        
    
    
    
        
            
                org.springframework.boot
                spring-boot-maven-plugin
                ${spring-boot.version}
            
        
    

Prosta REST aplikacja

@RestController
@SpringBootApplication
public class GraalDemoApplication {
    
    @GetMapping("/hello")
    public String hello(@RequestParam(defaultValue = "World") String name) {
        return "Hello " + name + " from GraalVM native!";
    }
    
    @GetMapping("/info")
    public Map info() {
        Map info = new HashMap<>();
        info.put("timestamp", System.currentTimeMillis());
        info.put("freeMemory", Runtime.getRuntime().freeMemory());
        info.put("totalMemory", Runtime.getRuntime().totalMemory());
        return info;
    }
    
    public static void main(String[] args) {
        SpringApplication.run(GraalDemoApplication.class, args);
    }
}

Kompilacja z reflection configuration

Największym wyzwaniem w GraalVM native compilation jest reflection. Spring Boot intensywnie używa reflection do tworzenia beans, proxy i auto-configuration.

# Generuj reflection configuration podczas uruchamiania
java -agentlib:native-image-agent=config-output-dir=src/main/resources/META-INF/native-image \
     -jar target/graal-demo-1.0.0.jar

# Następnie kompiluj do native
mvn clean package
native-image -jar target/graal-demo-1.0.0.jar graal-demo-native

Reflection configuration files

Agent GraalVM generuje kilka plików konfiguracyjnych w META-INF/native-image:

• reflect-config.json – klasy używające reflection
• resource-config.json – zasoby ładowane w runtime
• proxy-config.json – proxy classes
• jni-config.json – JNI calls

Przykład reflect-config.json:

[
  {
    "name": "com.example.GraalDemoApplication",
    "allDeclaredConstructors": true,
    "allPublicConstructors": true,
    "allDeclaredMethods": true,
    "allPublicMethods": true
  },
  {
    "name": "org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration",
    "allDeclaredConstructors": true,
    "allDeclaredMethods": true
  }
]

Porównanie wydajności

Czas na testy wydajności! Sprawdźmy różnice między JVM a native binary.

Dockerfile dla native aplikacji

# Multi-stage build
FROM oracle/graalvm-ce:19.1.1 AS builder

# Zainstaluj native-image
RUN gu install native-image

# Skopiuj kod źródłowy
COPY . /app
WORKDIR /app

# Zbuduj JAR
RUN ./mvnw clean package -DskipTests

# Kompiluj do native
RUN native-image -jar target/graal-demo-1.0.0.jar graal-demo-native

# Finalna imagen
FROM ubuntu:18.04
RUN apt-get update && apt-get install -y curl && rm -rf /var/lib/apt/lists/*

COPY --from=builder /app/graal-demo-native /app/graal-demo-native

EXPOSE 8080
ENTRYPOINT ["/app/graal-demo-native"]

Typowe problemy i rozwiązania

Problem: ClassNotFoundException w runtime

GraalVM nie może znaleźć klasy ładowanej dynamicznie.

// Problematyczny kod
Class clazz = Class.forName("com.example.DynamicClass");

// Rozwiązanie: dodaj do reflect-config.json
{
  "name": "com.example.DynamicClass",
  "allDeclaredConstructors": true,
  "allDeclaredMethods": true
}

Problem: Resources not found

Aplikacja nie może znaleźć plików konfiguracyjnych.

// resource-config.json
{
  "resources": [
    {"pattern": "application.properties"},
    {"pattern": "application-*.properties"},
    {"pattern": "static/.*"},
    {"pattern": "templates/.*"}
  ]
}

Problem: Bardzo długa kompilacja

Native compilation może trwać kilka minut nawet dla małych aplikacji.

# Optymalizuj kompilację
native-image \
  --no-server \
  --no-fallback \
  -H:+ReportExceptionStackTraces \
  -H:+ReportUnsupportedElementsAtRuntime \
  -jar myapp.jar myapp-native

Kiedy używać GraalVM native?

GraalVM native compilation nie jest srebrną kulą. Oto kiedy ma sens:

Ograniczenia w 2019 roku

Warto znać aktualne ograniczenia GraalVM native compilation:

• Brak pełnego wsparcia dla Spring Boot – wymaga manual configuration
• Hibernate wymaga dużo konfiguracji – entity classes muszą być pre-configured
• Niektóre biblioteki nie działają – sprawdzaj compatibility matrix
• Debugging jest trudniejszy – native binary to nie JVM
• Profiling ograniczony – standardowe JVM profilers nie działają

Przyszłość GraalVM

Oracle intensywnie rozwija GraalVM. W planach na najbliższe lata:

• Lepsza integracja z Spring Boot
• Wsparcie dla większej liczby bibliotek
• Szybsza kompilacja
• Lepsze debugging i profiling

Przydatne zasoby

• GraalVM Official Documentation
• SubstrateVM (native-image) na GitHub
• Reflection w GraalVM – przewodnik
• GraalVM Medium Blog
• GraalVM: Fast, Polyglot, Native (Devoxx)

Masz doświadczenie z GraalVM? Które use cases sprawdziły się w Twoich projektach, a które okazały się problematyczne? Podziel się swoimi spostrzeżeniami w komentarzach!