Spring Native – ahead of time compilation

Dlaczego Spring Native to przełom dla Java?

Tradycyjne aplikacje Java działają na JVM i potrzebują czasu na „rozgrzanie” – kompilację just-in-time, inicjalizację kontekstu Spring i wczytanie klas. W świecie cloud computing, gdzie płacimy za każdą sekundę działania, szybki start aplikacji to realny biznes benefit.

Co się nauczysz

Wymagania wstępne

Czym jest ahead-of-time compilation?

W tradycyjnej Javie kod jest kompilowany w dwóch etapach:
1. **Compile time:** źródła Java → bytecode JVM
2. **Runtime:** bytecode → kod maszynowy (JIT compilation)

Spring Native wykorzystuje GraalVM Native Image do stworzenia standalone pliku wykonywalnego, który:
– Nie wymaga zainstalowanej JVM
– Startuje w milisekundach
– Zużywa znacznie mniej pamięci RAM
– Ma przewidywalną wydajność od pierwszego uruchomienia

Konfiguracja Spring Native w projekcie

### Maven configuration

Aby rozpocząć pracę z Spring Native, dodaj do `pom.xml`:

    0.8.5
    11
    11



    
        org.springframework.experimental
        spring-native
        ${spring-native.version}
    



    
        
            org.springframework.experimental
            spring-aot-maven-plugin
            ${spring-native.version}
            
                
                    test-generate
                    
                        test-generate
                    
                
                
                    generate
                    
                        generate
                    
                
            
        
        
        
            org.graalvm.nativeimage
            native-image-maven-plugin
            21.3.0
            
                
                    --no-fallback
                    --allow-incomplete-classpath
                
            
        
    

### Przykładowa aplikacja Spring Boot

@SpringBootApplication
@RestController
public class NativeApplication {

    public static void main(String[] args) {
        SpringApplication.run(NativeApplication.class, args);
    }

    @GetMapping("/hello")
    public String hello(@RequestParam(defaultValue = "World") String name) {
        return "Hello " + name + "! Time: " + LocalDateTime.now();
    }

    @GetMapping("/health")
    public Map health() {
        Map health = new HashMap<>();
        health.put("status", "UP");
        health.put("timestamp", System.currentTimeMillis());
        health.put("memory", Runtime.getRuntime().totalMemory());
        return health;
    }
}

Proces kompilacji do natywnego obrazu

### Krok 1: AOT preprocessing

# Generowanie metadanych AOT
mvn spring-aot:generate

# Kompilacja z AOT optymalizacjami  
mvn package -Pnative

### Krok 2: Native image compilation

# Kompilacja natywnego obrazu (może potrwać kilka minut)
mvn -Pnative native:compile

# Alternatywnie z Docker
mvn spring-boot:build-image -Pnative

Wynik to standalone plik wykonywalny bez zależności od JVM:

# Uruchomienie natywnej aplikacji
./target/native-application

# Start time: 0.054s (vs 2.3s na JVM)
# Memory usage: 32MB (vs 150MB na JVM)

Wyzwania i ograniczenia Spring Native

### Refleksja i dynamic proxy

Spring Native wymaga statycznej analizy kodu. Dynamiczne tworzenie obiektów może być problematyczne:

// Problematyczny kod - wymaga reflection hints
Class clazz = Class.forName("com.example.DynamicService");
Object instance = clazz.getDeclaredConstructor().newInstance();

// Lepsze rozwiązanie - static configuration
@Component
public class ServiceFactory {
    
    @Bean
    public DynamicService dynamicService() {
        return new DynamicService(); // Static, wykrywalne przez AOT
    }
}

### Konfiguracja reflection hints

Gdy potrzebujesz refleksji, dodaj odpowiednie hinty:

@Configuration
@RegisterReflectionForBinding({UserDto.class, OrderDto.class})
public class NativeConfiguration {

    @Bean
    @RegisterReflectionForBinding(JsonNode.class)
    public ObjectMapper objectMapper() {
        return new ObjectMapper();
    }
}

Optymalizacja aplikacji dla kompilacji natywnej

### 1. Minimalizacja zależności

    
    
        org.springframework.boot
        spring-boot-starter-webflux
    
    
    
    
        com.fasterxml.jackson.core
        jackson-core
    

### 2. Conditional beans dla native

@Configuration
public class ConditionalConfiguration {

    @Bean
    @ConditionalOnProperty(name = "spring.aot.enabled", havingValue = "false", matchIfMissing = true)
    public ExpensiveJvmService jvmService() {
        return new ExpensiveJvmService(); // Tylko dla JVM
    }

    @Bean  
    @ConditionalOnProperty(name = "spring.aot.enabled", havingValue = "true")
    public LightweightNativeService nativeService() {
        return new LightweightNativeService(); // Tylko dla native
    }
}

Porównanie wydajności: JVM vs Native

Deployment natywnych aplikacji

### Docker multi-stage build

# Dockerfile dla native image
FROM ghcr.io/graalvm/graalvm-ce:java11-21.3.0 AS builder

WORKDIR /app
COPY . .

# Kompilacja native image w kontenerze
RUN ./mvnw clean package -Pnative -DskipTests

# Minimal runtime image
FROM scratch
COPY --from=builder /app/target/native-application /app
EXPOSE 8080
ENTRYPOINT ["/app"]

### Kubernetes deployment

apiVersion: apps/v1
kind: Deployment
metadata:
  name: spring-native-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: spring-native
  template:
    metadata:
      labels:
        app: spring-native
    spec:
      containers:
      - name: app
        image: spring-native-app:latest
        ports:
        - containerPort: 8080
        resources:
          requests:
            memory: "64Mi"  # Znacznie mniej niż JVM
            cpu: "100m"
          limits:
            memory: "128Mi"
            cpu: "500m"
        readinessProbe:
          httpGet:
            path: /health
            port: 8080
          initialDelaySeconds: 1  # Szybki start!
          periodSeconds: 5

Kiedy używać Spring Native?

### Idealne przypadki użycia:

– **Serverless functions** – AWS Lambda, Google Cloud Functions
– **Microservices** w środowisku z częstymi restartami
– **CLI tools** napisane w Spring Boot
– **Batch processing** – zadania ETL, cron jobs
– **IoT applications** z ograniczonymi zasobami

### Kiedy zostać przy JVM:

– Aplikacje długo działające (24/7 serwisy)
– Heavy computational workloads
– Extensive use of reflection/dynamic proxies
– Częste deploymenty w dev environment (długi czas kompilacji)

Troubleshooting częstych problemów

### Problem: ClassNotFoundException w runtime

// Rozwiązanie: dodaj resource hint
@Configuration
@ImportRuntimeHints(MyRuntimeHints.class)
public class NativeConfiguration {
}

class MyRuntimeHints implements RuntimeHintsRegistrar {
    @Override
    public void registerHints(RuntimeHints hints, ClassLoader classLoader) {
        hints.resources().registerPattern("*.properties");
        hints.reflection().registerType(TypeReference.of(MyClass.class), 
            MemberCategory.INVOKE_DECLARED_CONSTRUCTORS,
            MemberCategory.INVOKE_PUBLIC_METHODS);
    }
}

### Problem: Serialization issues

// Zamiast Java serialization
// ObjectOutputStream/ObjectInputStream

// Używaj JSON serialization
@RestController
public class ApiController {
    
    private final ObjectMapper objectMapper;
    
    @PostMapping("/process")
    public ResponseEntity process(@RequestBody UserRequest request) {
        // Jackson handle reflection automatycznie z AOT hints
        UserResponse response = processUser(request);
        return ResponseEntity.ok(objectMapper.writeValueAsString(response));
    }
}

Przydatne zasoby

• Spring Native Documentation
• GraalVM Native Image Reference
• Spring Native GitHub Repository
• Spring Blog – Native Posts

Czy już testowałeś Spring Native w swoich projektach? Jakie są Twoje doświadczenia z kompilacją ahead-of-time? Podziel się w komentarzach!