Quarkus – supersonic Java framework

Java zawsze była krytykowana za wolny start aplikacji i duże zużycie pamięci. W świecie kontenerów i microservices te problemy stają się jeszcze bardziej dotkliwe. Quarkus to odpowiedź Red Hat na te wyzwania – framework który łączy znajomy ekosystem Java z wydajnością porównywalną do Go czy Node.js.

Dlaczego Quarkus to przełom?

W erze cloud computing i Kubernetes każda sekunda startu aplikacji kosztuje. Tradycyjne aplikacje Spring Boot potrzebują 5-15 sekund na start, co w świecie autoskalowania jest wiecznością. Quarkus redukuje ten czas do 15-50 milisekund, jednocześnie zmniejszając zużycie pamięci z 200MB do około 50MB.

Czym jest Quarkus?

Quarkus to framework Java zaprojektowany od podstaw z myślą o kontenerach, microservices i cloud-native deployment. Jego kluczową cechą jest możliwość kompilacji aplikacji do natywnego kodu maszynowego przy użyciu GraalVM.

### Kluczowe cechy Quarkus:

– **Supersonic startup:** Aplikacje startują w milisekundach
– **Subatomic memory footprint:** Drastycznie mniejsze zużycie RAM
– **Developer Joy:** Hot reload i szybkie iteracje podczas developmentu
– **Standards-based:** Używa znanych standardów jak JAX-RS, CDI, JPA

Jak działa magia Quarkus?

Tradycyjne frameworki Java wykonują większość konfiguracji i refleksji w runtime. Quarkus przenosi te operacje do czasu kompilacji (build-time), pozostawiając w runtime tylko niezbędny kod.

### Build-time vs Runtime

Pierwsza aplikacja Quarkus

Stwórzmy prostą aplikację REST API w Quarkus. Proces jest podobny do Spring Boot, ale rezultat znacznie bardziej wydajny.

### Generowanie projektu

mvn io.quarkus:quarkus-maven-plugin:0.21.1:create \
    -DprojectGroupId=com.example \
    -DprojectArtifactId=my-quarkus-app \
    -DclassName="com.example.GreetingResource" \
    -Dpath="/hello"

### Struktura projektu

Po wygenerowaniu otrzymamy standardową strukturę Maven:

my-quarkus-app/
├── pom.xml
├── src/
│   ├── main/
│   │   ├── java/
│   │   │   └── com/example/GreetingResource.java
│   │   └── resources/
│   │       └── application.properties
│   └── test/
│       └── java/
│           └── com/example/GreetingResourceTest.java
└── target/

### Pierwszy endpoint

package com.example;

import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

@Path("/hello")
public class GreetingResource {

    @GET
    @Produces(MediaType.TEXT_PLAIN)
    public String hello() {
        return "Hello Quarkus from Red Hat!";
    }
}

### Uruchomienie w trybie dev

./mvnw compile quarkus:dev

Aplikacja uruchomi się w trybie deweloperskim z hot reload. Każda zmiana w kodzie zostanie automatycznie przeładowana bez restartu aplikacji.

Dependency Injection w Quarkus

Quarkus używa standardu CDI (Contexts and Dependency Injection) zamiast własnego systemu DI jak Spring.

package com.example;

import javax.enterprise.context.ApplicationScoped;

@ApplicationScoped
public class GreetingService {
    
    public String greeting(String name) {
        return "Hello " + name + " from Quarkus service!";
    }
}

package com.example;

import javax.inject.Inject;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;

@Path("/hello")
public class GreetingResource {

    @Inject
    GreetingService greetingService;

    @GET
    @Path("/{name}")
    @Produces(MediaType.TEXT_PLAIN)
    public String greeting(@PathParam("name") String name) {
        return greetingService.greeting(name);
    }
}

Kompilacja do natywnego obrazu

Prawdziwa moc Quarkus ujawnia się podczas kompilacji do native image. Wymaga to zainstalowanego GraalVM.

### Instalacja GraalVM

# macOS
brew install graalvm/tap/graalvm-ce-19

# Linux - pobierz z GitHub releases
export GRAALVM_HOME=/path/to/graalvm
export PATH=$GRAALVM_HOME/bin:$PATH

### Kompilacja native image

./mvnw package -Pnative

### Uruchomienie native image

./target/my-quarkus-app-1.0-SNAPSHOT-runner

# Start w <20ms!
2019-01-10 15:30:42,123 INFO  [io.quarkus] Quarkus 0.21.1 on JVM started in 0.015s.

Quarkus vs Spring Boot - kiedy wybrać co?

### Wybierz Quarkus gdy:
- Budujesz microservices z częstym skalowaniem
- Pracujesz w środowisku kontenerowym (Docker/Kubernetes)
- Startup time i zużycie pamięci są krytyczne
- Możesz zaakceptować dłuższy czas kompilacji
- Zespół zna standardy Java EE/Jakarta EE

### Zostań przy Spring Boot gdy:
- Masz duży, stabilny monolith
- Zespół ma wieloletnie doświadczenie ze Springiem
- Używasz wielu Spring-specific features
- Potrzebujesz maksymalnej elastyczności runtime
- Startup time nie jest problemem

Ograniczenia Quarkus native image

### Co może nie działać:
- **Dynamic classloading:** Code generation w runtime
- **Reflection:** Wymaga explicit configuration
- **Resources:** Muszą być zdefiniowane w build time
- **Niektóre libraries:** Hibernate Search, niektóre JDBC drivers

Rozszerzenia Quarkus

Quarkus posiada system extensions podobny do Spring Boot starters:

# Lista dostępnych extensions
./mvnw quarkus:list-extensions

# Dodanie extension
./mvnw quarkus:add-extension -Dextensions="hibernate-orm,jdbc-postgresql"

### Popularne extensions (stan na styczeń 2019):
- **quarkus-hibernate-orm:** JPA/Hibernate support
- **quarkus-jdbc-postgresql:** PostgreSQL driver
- **quarkus-smallrye-health:** Health checks
- **quarkus-smallrye-metrics:** Metrics collection
- **quarkus-smallrye-openapi:** OpenAPI/Swagger support

Przydatne zasoby:

• Oficjalna dokumentacja Quarkus
• Quarkus na GitHub
• GraalVM documentation
• Red Hat Developer - Quarkus guides

Quarkus reprezentuje przyszłość Java w świecie cloud-native. Choć nadal jest w fazie rozwoju, już teraz pokazuje imponujące rezultaty wydajnościowe. Czy to oznacza koniec Spring Boot? Raczej nie, ale na pewno rozpoczyna nową erę konkurencji, która przynosi korzyści wszystkim Java developerom.

Czy planujesz wypróbować Quarkus w swoim następnym projekcie? Jakie są Twoje największe obawy związane z migracją z tradycyjnych frameworków?