Quarkus'a Giriş: Java Geliştiricileri Neden Süpersonik Java'ya Geçiyor?

Yaklaşık otuz yıldır Java, kurumsal yazılım geliştirmede baskın güç olmuştur. Zengin ekosistemi, sağlam nesne yönelimli temeli, Java Sanal Makinesi (JVM) aracılığıyla platform bağımsızlığı ve Spring Boot gibi savaşta test edilmiş çerçeveleri, onu arka uç altyapısının tartışmasız kralı yaptı.

Ancak Bulutta Yerel Mimariler, Kubernetes orkestrasyonu, Konteynerleştirme (Docker) ve Sunucusuz Bilgi İşlem (AWS Lambda, Knative) yönündeki geçiş, geleneksel Java uygulama çerçevelerindeki ciddi bir güvenlik açığını ortaya çıkardı: yüksek bellek yükü ve yavaş başlatma süreleri.

Trafikteki ani bir artışa yanıt olarak bir mikro hizmetin yatay olarak sıfırdan 100 kopyaya ölçeklenmesi gerektiğinde veya sunucusuz bir işlev isteğe bağlı olarak yürütüldüğünde, Java işleminin başlatılması için 3 ila 10 saniye beklemek kabul edilemez. Modern bulut altyapısı, anında başlatma ve hafif bellek tüketimi gerektirir; bu özellikler geleneksel olarak Go, Rust veya Node.js gibi dillere özgüdür.

Quarkus girin: GraalVM ve OpenJDK HotSpot için özel olarak tasarlanmış Kubernetes’te yerel bir Java çerçevesi. Genellikle “Süpersonik Atom Altı Java” olarak adlandırılan Quarkus, Java uygulamalarının nasıl derlendiğini, başlatıldığını ve çalıştırıldığını temel olarak yeniden tasarlıyor.

Bu ayrıntılı kılavuzda, Java geliştiricilerinin neden Quarkus’u benimsediğini, Quarkus’un saniyenin altında başlatma sürelerine ve mikro bellek ayak izlerine nasıl ulaştığını, Derleme Zamanı Optimizasyonu’nun mimari mekaniğini ve Quarkus ile Java’da üretime hazır bir reaktif mikro hizmetin nasıl oluşturulacağını keşfedeceğiz.

1. Geleneksel Java’nın Bulutta Yerel İkilemi

Quarkus’un neden var olduğunu anlamak için Spring Boot veya Jakarta EE gibi geleneksel Java çerçevelerinin başlık altında nasıl çalıştığını incelemeliyiz.

A. Ağır Çalışma Zamanı Başlatma Maliyeti

Geleneksel Java çerçeveleri büyük ölçüde çalışma zamanı dinamik yansımasına, sınıf yolu taramasına ve proxy oluşturmaya dayanır:

1. Sınıf Yolu Taraması: Başlangıç ​​sırasında JVM, @Component, @Service, @Controller veya @Entity gibi ek açıklamaları bulmak için sınıf yolundaki her JAR dosyasını tarar.
2. Ek Açıklama İşleme ve Yansıma: Çerçeve, fasulyelerin, yapılandırma özelliklerinin ve bağımlılıkların bellek içi grafiğini oluşturmak için yansımayı (Class.forName(), getDeclaredFields()) kullanır.
3. Dinamik Proxy Oluşturma: CGLIB veya ByteBuddy, Boyut Odaklı Programlamayı (AOP), veritabanı işlem yönetimini (@Transactional) ve güvenlik sınırlarını desteklemek için çalışma zamanı belleğinde dinamik bayt kodu proxy’leri oluşturur.
4. Metaspace ve RSS Enflasyonu: Tüm meta veriler, yansıtılan sınıf tanımlayıcıları ve oluşturulan proxy’ler, JVM’nin Metaspace ve Yerleşik Küme Boyutu (RSS) içindeki bellekte tutulmalıdır.

Bu çalışma zamanı yansıma döngüsü, önemli miktarda CPU döngüsü gerektirir ve yığın bellek tüketimini artırır. Geleneksel Java’daki temel bir CRUD REST hizmeti, boştayken kolaylıkla 140 MB ila 300 MB RAM tüketebilir ve başlaması 3 ila 8 saniye sürebilir.

B. Bulut Bilişimde Mali Ceza

Sunucusuz ve kapsayıcılı ortamlarda, bulut sağlayıcıları iki ölçüme göre ücretlendirme yapar: ayrılan bellek (GB) ve yürütme süresi (milisaniye).

• Soğuk Başlatma: Sunucusuz bir işlevin önyüklemesi 5 saniye sürerse, son kullanıcılar gözle görülür bir gecikme yaşar ve siz de 5 saniyelik boşta kalan başlatma hesaplaması için ödeme yaparsınız.
• Yoğunluk ve Kapsül Ölçeklenebilirliği: 16 GB RAM’e sahip bir çalışan düğümüne sahip bir Kubernetes kümesinde, belleğiniz dolmadan yalnızca ~40 geleneksel Spring Boot mikro hizmet örneğini çalıştırabilirsiniz. Her bulut sunucusu yalnızca 15 MB RAM tüketiyorsa, aynı düğüm 800’den fazla örneği barındırabilir.

2. Quarkus Mimarisi: Çalışmayı Çalışma Zamanından Yapım Zamanına Değiştirmek

Quarkus, bulutta yerel ikilemi radikal bir mimari paradigma değişimiyle çözüyor: dinamik işlemleri çalışma zamanından derleme zamanına taşıma.

Derleme Zamanında İşleme (Vaktinden Önce Optimizasyon)

Quarkus, uygulama her başlatıldığında sınıf yolu taraması, açıklama ayrıştırma ve fasulye grafiği kablolaması yürütmek yerine, tüm bu ağır işlemleri derleme aşamasında bir kez gerçekleştirir (mvn package veya ./gradlew build).

1. Uzantı Mimarisi ve Oluşturma Adımları: Quarkus, takılabilir bir uzantı çerçevesi kullanır. Uygulamanızı derlerken Quarkus uzantıları ek açıklamaları ayrıştırır, optimize edilmiş statik bayt kodu oluşturur ve bağımlılık enjeksiyon grafiklerini önceden çözer.
2. Önceden Hazırlanmış Meta Veriler: Tüm bağımlılık ekleme meta verileri önceden hesaplanır. Uygulama başladığında Quarkus, yansımayı veya sınıf yollarını taramayı çağırmadan, önceden derlenmiş sınıfları doğrudan başlatır.
3. Ölü Kodun Ortadan Kaldırılması (Ağaç Sallanması): Derleme işlemi sırasında Quarkus, uygulamanız tarafından kullanılmayan sınıfları, yöntemleri ve kitaplıkları belirler ve bunları tamamen ortadan kaldırır.

Uygulamanız JAR veya yerel ikili dosya üretildiğinde tüm çalışma zamanı yükü ortadan kaldırılmış olur. JVM, önceden kablolanmış statik bayt kodlarını yükler ve anında başlar.

3. GraalVM Yerel Görüntüsü ve OpenJDK HotSpot Karşılaştırması

Quarkus ikili yürütme modeli sağlar: standart OpenJDK HotSpot üzerinde olağanüstü hızlı çalışır, ancak GraalVM Yerel Görüntüsü olarak derlendiğinde maksimum performans potansiyeline ulaşır.

+-----------------------------------------------------------------------+
|                         Java Source Code (.java)                      |
+-----------------------------------------------------------------------+
                                    |
                                    v (Standard javac)
+-----------------------------------------------------------------------+
|                            Bytecode (.class)                          |
+-----------------------------------------------------------------------+
                       /                         \
                      /                           \
                     v                             v
   +----------------------------------+   +----------------------------------+
   |      OpenJDK HotSpot JVM         |   |     GraalVM Native Image (AOT)   |
   |  - JIT Compilation (C1/C2)       |   |  - Substrate VM                  |
   |  - Dynamic Class Loading         |   |  - No Classpath Scanning          |
   |  - Fast throughput, longer boot  |   |  - Millisecond boot, tiny RAM    |
   +----------------------------------+   +----------------------------------+

Zamanından Önce (AOT) Derleme ve Alt Katman VM’si

GraalVM Native Image, Java bayt kodunu alır ve onu doğrudan işletim sistemine özgü, bağımsız yürütülebilir bir ikili dosyada (Linux’ta ELF ikili dosyası, macOS’ta Mach-O, Windows’ta EXE) derler.

• Kapalı Dünya Varsayımı: GraalVM, erişilebilir tüm kodların, sınıfların ve kaynakların derleme sırasında bilindiğini varsayar.
• Substrate VM: Yerel yürütülebilir dosya, tam bir JVM örneğini başlatmadan bellek yönetimini, iş parçacığı planlamayı ve çöp toplama işlemlerini gerçekleştiren Substrate VM adlı minyatür bir çalışma zamanı motorunu içerir.
• Sıfır Yansıma Ek Yükü: Quarkus, yansıma yapılandırmalarını ve proxy tanımlarını derleme süresi sırasında hazırladığından, GraalVM yerel görüntü derlemesi, yerel GraalVM derlemelerinin tarihsel olarak gerektirdiği manuel yapılandırma dosyaları olmadan sorunsuz bir şekilde başarılı olur.

4. Performans Karşılaştırmaları: Ampirik Kanıtlar

Performanstaki keskin zıtlığı göstermek için, standart bir REST + Database CRUD hizmetini çalıştıran üç Java çalışma zamanı yapılandırmasındaki standart sektör karşılaştırma karşılaştırmalarını inceleyelim:

1. Geleneksel Bulut Yerel Yığın (Geleneksel JVM / Spring Boot)
2. OpenJDK HotSpot’ta Quarkus
3. GraalVM Yerel Görüntüsünde Quarkus

Performans Özet Tablosu

Yerel bir görüntüye derlenen Quarkus’un 14 milisaniyede (tek bir göz açıp kapayıncaya kadar daha hızlı) önyükleme yaptığını ve yalnızca 13 MB RAM tükettiğini unutmayın. Bu, Java’yı sunucusuz ve bulut tabanlı dağıtımlar için Go ve Rust ile tamamen rekabetçi hale getirir.

5. Reaktif ve Zorunlu Çift Çekirdekli Motor

Geçmişte, Java geliştiricileri birbirini dışlayan iki programlama modeli arasında seçim yapmak zorundaydı:

1. Zorunlu (İstek başına iş parçacığı): Standart JDBC sürücülerini ve eşzamanlı REST uç noktalarını kullanan basit, okunabilir engelleme kodu.
2. Reaktif (Olay Döngüsü): Eşzamansız, engellemeyen kod (örn. RxJava, Project Reactor), yüksek aktarım kapasitesine sahiptir ancak karmaşık geri çağırma zincirleri ve zor hata ayıklama sorunlarıyla ünlüdür.

Quarkus, her iki dünyayı Eclipse Vert.x ve Netty tarafından desteklenen tek ve uyumlu bir motor altında birleştiriyor.

                      +---------------------------------+
                      |     Client HTTP Request         |
                      +---------------------------------+
                                       |
                                       v
                      +---------------------------------+
                      |       Eclipse Vert.x I/O        |
                      |          (Event Loop)           |
                      +---------------------------------+
                                   /       \
                                  /         \
                                 v           v
                 +-------------------+   +-------------------+
                 | Reactive Endpoint |   |Blocking Endpoint  |
                 | (Event Loop)      |   | (Worker Thread)   |
                 | - Mutiny (Uni/Multi)| | - Standard JDBC   |
                 | - Non-blocking    |   | - Imperative Code |
                 +-------------------+   +-------------------+

Quarkus’ta engellenmeyen G/Ç temeldir. Geleneksel engelleme kodu yazarsanız Quarkus, yürütmeyi otomatik olarak yönetilen bir çalışan iş parçacığı havuzuna gönderir. SmallRye Mutiny (Uni<T> ve Multi<T>) gibi reaktif türleri kullanırsanız yürütme, yüksek performanslı, engellemeyen olay döngüsü iş parçacığında kalır.

6. Geliştirici Joy: Canlı Kodlama ve Geliştirme Hizmetleri

Quarkus, çalışma zamanı performansının ötesinde sıkıcı derleme-test-yeniden başlatma geri bildirim döngüsünü ortadan kaldırmak için tasarlanmış devrim niteliğinde bir geliştirici deneyimi sunar.

A. Canlı Kodlamayı Sıfırla Yeniden Başlatma (quarkus:dev)

mvn quarkus:dev çalıştırıldığında Quarkus canlı kodlama modunu başlatır. Java dosyalarını düzenleyebilir, özellikleri değiştirebilir, HTML şablonlarını değiştirebilir veya veritabanı şemalarını güncelleyebilirsiniz.

Tarayıcınızda veya terminalinizde bir sonraki HTTP isteğini tetiklediğinizde, Quarkus dosya değişikliklerini algılar, derleme adımlarını yeniden uygular ve uygulamayı 500 milisaniyeden kısa sürede çalışırken yeniden yükler. Geliştirme sırasında uygulama sunucunuzu hiçbir zaman manuel olarak durdurup yeniden başlatmanıza gerek kalmaz.

B. Quarkus Geliştirme Hizmetleri (Sıfır Yapılandırma Test Kapsayıcıları)

Bir mikro hizmeti PostgreSQL veritabanına, Kafka aracısına veya Redis önbelleğine bağlamak genellikle bir docker-compose.yml dosyası yazmayı ve yerel veritabanı bağlantı noktalarını yapılandırmayı gerektirir.

Quarkus Geliştirme Hizmetleri ile:

• Quarkus bir veritabanı bağımlılığı tespit ederse (ör. quarkus-reactive-pg-client) ancak application.properties‘de hiçbir veritabanı URL’si yapılandırılmamışsa, Quarkus otomatik olarak arka planda Testcontainers aracılığıyla PostgreSQL çalıştıran bir Docker konteynerini başlatır.
• Bağlantı kimlik bilgilerini çalışan uygulamanıza otomatik olarak enjekte eder.
• Geliştirme modunu durdurduğunuzda konteyner kendini temiz bir şekilde temizler.

7. Uygulamalı Çözüm Yolu: Üretime Hazır Reaktif Quarkus Hizmeti Oluşturma

Java’da, Hibernate Reactive with Panache kullanarak PostgreSQL veritabanına bağlı bir REST API’yi açığa çıkaran temiz, yüksek performanslı bir Quarkus mikro hizmeti oluşturalım.

Adım 1: Proje Bağımlılıkları (pom.xml)

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.ghaznix.quarkus</groupId>
    <artifactId>user-service</artifactId>
    <version>1.0.0-SNAPSHOT</version>

    <properties>
        <compiler-plugin.version>3.13.0</compiler-plugin.version>
        <maven.compiler.release>21</maven.compiler.release>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <quarkus.platform.artifact-id>quarkus-bom</quarkus.platform.artifact-id>
        <quarkus.platform.group-id>io.quarkus.platform</quarkus.platform.group-id>
        <quarkus.platform.version>3.15.1</quarkus.platform.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>${quarkus.platform.group-id}</groupId>
                <artifactId>${quarkus.platform.artifact-id}</artifactId>
                <version>${quarkus.platform.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <dependencies>
        <!-- RESTEasy Reactive for high-performance HTTP endpoints -->
        <dependency>
            <groupId>io.quarkus</groupId>
            <artifactId>quarkus-resteasy-reactive-jackson</artifactId>
        </dependency>

        <!-- Hibernate Reactive with Panache for active-record data access -->
        <dependency>
            <groupId>io.quarkus</groupId>
            <artifactId>quarkus-hibernate-reactive-panache</artifactId>
        </dependency>

        <!-- Reactive PostgreSQL Driver -->
        <dependency>
            <groupId>io.quarkus</groupId>
            <artifactId>quarkus-reactive-pg-client</artifactId>
        </dependency>

        <!-- Quarkus SmallRye OpenAPI / Swagger UI -->
        <dependency>
            <groupId>io.quarkus</groupId>
            <artifactId>quarkus-smallrye-openapi</artifactId>
        </dependency>

        <!-- Testing -->
        <dependency>
            <groupId>io.quarkus</groupId>
            <artifactId>quarkus-junit5</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>io.rest-assured</groupId>
            <artifactId>rest-assured</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>${quarkus.platform.group-id}</groupId>
                <artifactId>quarkus-maven-plugin</artifactId>
                <version>${quarkus.platform.version}</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>build</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

Adım 2: Reaktif Varlığı Tanımlayın (UserEntity.java)

Quarkus, Hibernate’in üzerinde yer alan bir Aktif Kayıt modeli uygulaması olan Panache ile veri erişimini basitleştirdi.

package com.ghaznix.quarkus.entity;

import io.quarkus.hibernate.reactive.panache.PanacheEntity;
import io.smallrye.mutiny.Uni;

import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.Table;
import jakarta.validation.constraints.Email;
import jakarta.validation.constraints.NotBlank;
import java.time.Instant;

@Entity
@Table(name = "users")
public class UserEntity extends PanacheEntity {

    @NotBlank(message = "Username cannot be blank")
    @Column(unique = true, nullable = false)
    public String username;

    @Email(message = "Email must be valid")
    @Column(unique = true, nullable = false)
    public String email;

    @Column(nullable = false)
    public String role;

    @Column(name = "created_at", nullable = false, updatable = false)
    public Instant createdAt = Instant.now();

    /**
     * Helper method to find a user reactively by email.
     */
    public static Uni<UserEntity> findByEmail(String email) {
        return find("email", email).firstResult();
    }
}

3. Adım: Reaktif REST Kaynağını Uygulama (UserResource.java)

RESTEasy Reactive ve SmallRye Mutiny kullanarak, HTTP uç noktalarımız engellemeyen iş parçacıkları üzerinde tamamen eşzamansız olarak çalışır:

package com.ghaznix.quarkus.resource;

import com.ghaznix.quarkus.entity.UserEntity;
import io.quarkus.hibernate.reactive.panache.Panache;
import io.smallrye.mutiny.Uni;

import jakarta.enterprise.context.ApplicationScoped;
import jakarta.validation.Valid;
import jakarta.ws.rs.*;
import jakarta.ws.rs.core.MediaType;
import jakarta.ws.rs.core.Response;
import java.net.URI;
import java.util.List;

@Path("/api/v1/users")
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
@ApplicationScoped
public class UserResource {

    @GET
    public Uni<List<UserEntity>> getAllUsers() {
        return UserEntity.listAll();
    }

    @GET
    @Path("/{id}")
    public Uni<Response> getUserById(@PathParam("id") Long id) {
        return UserEntity.<UserEntity>findById(id)
                .onItem().ifNotNull().transform(user -> Response.ok(user).build())
                .onItem().ifNull().continueWith(() -> Response.status(Response.Status.NOT_FOUND).build());
    }

    @POST
    public Uni<Response> createUser(@Valid UserEntity user) {
        return Panache.withTransaction(user::persist)
                .replaceWith(() -> Response.created(URI.create("/api/v1/users/" + user.id))
                        .entity(user)
                        .build());
    }

    @DELETE
    @Path("/{id}")
    public Uni<Response> deleteUser(@PathParam("id") Long id) {
        return Panache.withTransaction(() -> UserEntity.deleteById(id))
                .map(deleted -> deleted 
                        ? Response.noContent().build() 
                        : Response.status(Response.Status.NOT_FOUND).build());
    }
}

Adım 4: Uygulama Yapılandırması (application.properties)

# Quarkus Application Configuration
quarkus.application.name=user-service
quarkus.http.port=8080

# Database Schema Management (Automatically managed by Dev Services in dev mode)
quarkus.hibernate-orm.database.generation=drop-and-create
quarkus.hibernate-orm.log.sql=true

# SmallRye OpenAPI & Swagger UI Configuration
quarkus.smallrye-openapi.path=/swagger-ui
quarkus.swagger-ui.always-include=true

Veritabanı URL’lerini, kullanıcı adlarını veya şifrelerini yapılandırmadığımızı unutmayın! ./mvnw quarkus:dev komutunu çalıştırdığınızda Quarkus, PostgreSQL’i otomatik olarak algılar, bir Docker konteyneri başlatır, veritabanı şeması tablolarını ayarlar ve http://localhost:8080/swagger-ui adresinde Swagger UI’yi açar.

Adım 5: Yerel Yürütülebilir Dosyaları Oluşturma ve Yürütme

Anında Canlı Kodlama Geliştirme Modunda çalıştırmak için:

./mvnw quarkus:dev

Docker kapsayıcısı içinde GraalVM kullanarak yerel bir Linux ikili programı oluşturmak için (yerel GraalVM kurulumu gerekmez):

./mvnw package -Dnative -Dquarkus.native.container-build=true

Ortaya çıkan ikili dosyayı doğrudan işletim sisteminizde başlatmak için:

./target/user-service-1.0.0-SNAPSHOT-runner

__  ____  __  _____   ___  __ ____  ______ 
 --/ __ \/ / / / _ | / _ \/ //_/ / / / __/ 
 -/ /_/ / /_/ / __ |/ , _/ ,< / /_/ /\ \   
--\___\_\____/_/ |_/_/|_/_/|_|\____/___/   
2026-08-26 01:37:15,102 INFO  [io.quarkus] (main) user-service 1.0.0-SNAPSHOT native (powered by Quarkus 3.15.1) started in 0.016s. Listening on: http://0.0.0.0:8080
2026-08-26 01:37:15,103 INFO  [io.quarkus] (main) Profile prod activated. 
2026-08-26 01:37:15,103 INFO  [io.quarkus] (main) Installed features: [cdi, hibernate-reactive, panache, reactive-pg-client, resteasy-reactive, resteasy-reactive-jackson, smallrye-openapi]

0,016 saniyelik başlatma!

8. Stratejik Özellik Karşılaştırması: Quarkus ve Spring Boot

9. Sonuç: Quarkus’a Geçiş Zamanı Geldi mi?

Quarkus yalnızca başka bir web çerçevesi değildir; bulutta yerel çağ için Java’nın evrimini temsil eder. Quarkus, derleme zamanı optimizasyonunu GraalVM yerel derlemesiyle birleştirerek, Java’nın modern mikro hizmetler ve sunucusuz işlevler için çok yavaş veya bellek açısından çok yoğun olduğu yönündeki eski stereotipi geçersiz kılıyor.

Quarkus’u Ne Zaman Seçmelisiniz?

• Sunucusuz ve Olay Odaklı Uygulamalar: Mikro hizmetleri AWS Lambda, GCP Cloud Run veya Knative’e dağıtıyorsanız Quarkus yerel ikili dosyaları, soğuk başlatma sorunlarını tamamen ortadan kaldırır.
• Yüksek Yoğunluklu Kubernetes Kümeleri: Altyapı faturanızda küme RAM tüketimi ağırlıklıysa, hizmetleri Quarkus’a taşımak bellek maliyetlerini %75’e kadar azaltabilir.
• Reaktif Mikro Hizmetler: Engellenmeyen akış gerektiren yüksek verimli sistemler (Kafka, gRPC, WebSockets) oluşturursanız Quarkus, kutudan çıktığı anda en üst düzey performansı sunar.

Java artık yavaş başlangıçlar veya şişirilmiş çalışma süreleri nedeniyle bağlı kalmıyor. Quarkus ile Java geliştiricileri Süpersonik Hız ve Atom Altı Ayak İzi ile bulutta yerel uygulamalar oluşturabilir.