کوارکس کا تعارف: جاوا ڈویلپرز سپرسونک جاوا کی طرف کیوں جا رہے ہیں۔

تقریباً تین دہائیوں سے جاوا انٹرپرائز سافٹ ویئر کی ترقی میں غالب قوت رہا ہے۔ اس کا بھرپور ماحولیاتی نظام، مضبوط آبجیکٹ اورینٹڈ فاؤنڈیشن، جاوا ورچوئل مشین (JVM) کے ذریعے پلیٹ فارم کی آزادی، اور اسپرنگ بوٹ جیسے جنگی تجربہ شدہ فریم ورکس نے اسے بیک اینڈ انفراسٹرکچر کا غیر متنازعہ بادشاہ بنا دیا۔

تاہم، کلاؤڈ-نیٹیو آرکیٹیکچرز، کوبرنیٹس آرکیسٹریشن، کنٹینرائزیشن (ڈوکر)، اور سرور لیس کمپیوٹنگ (AWS Lambda، Knative) کی طرف تبدیلی نے روایتی جاوا ایپلیکیشن فریم ورکس میں ایک شدید کمزوری کو بے نقاب کیا: **ہائی میموری اسٹارٹ ٹائم ** اوور ہیڈ۔

جب ٹریفک میں اضافے کے جواب میں ایک مائیکرو سروس کو افقی طور پر صفر سے 100 نقل کرنے کی ضرورت ہوتی ہے، یا جب کوئی سرور لیس فنکشن ڈیمانڈ پر عمل کرتا ہے، تو جاوا کے بوٹ ہونے کے لیے 3 سے 10 سیکنڈ تک انتظار کرنا ناقابل قبول ہے۔ جدید کلاؤڈ انفراسٹرکچر فوری آغاز اور ہلکے وزن کی میموری کی کھپت کا مطالبہ کرتا ہے — روایتی طور پر Go، Rust، یا Node.js جیسی زبانوں کے لیے مخصوص خصوصیات۔

Quarkus درج کریں: ایک Kubernetes-آبائی جاوا فریم ورک جو خاص طور پر GraalVM اور OpenJDK HotSpot کے لیے ڈیزائن کیا گیا ہے۔ اکثر “Supersonic Subatomic Java” ڈب کیا جاتا ہے، Quarkus بنیادی طور پر دوبارہ انجینئر کرتا ہے کہ کس طرح جاوا ایپلی کیشنز کو مرتب، بوٹ، اور چلایا جاتا ہے۔

اس گہرے غوطے کی گائیڈ میں، ہم دریافت کریں گے کہ جاوا کے ڈویلپرز کوارکس کو کیوں اپنا رہے ہیں، کوارکس کس طرح سب سیکنڈ اسٹارٹ اپ ٹائمز اور مائیکرو میموری فوٹ پرنٹس حاصل کرتا ہے، بلڈ ٹائم آپٹیمائزیشن کے آرکیٹیکچرل میکانکس، اور کوارکو کے ساتھ جاوا میں پروڈکشن کے لیے تیار ری ایکٹیو مائیکرو سروس کیسے بنایا جائے۔

1. روایتی جاوا کا کلاؤڈ-آبائی مخمصہ

یہ سمجھنے کے لیے کہ کوارکس کیوں موجود ہے، ہمیں یہ جانچنا چاہیے کہ روایتی جاوا فریم ورک جیسے اسپرنگ بوٹ یا جکارتہ EE کس طرح کام کرتے ہیں۔

A. بھاری رن ٹائم ابتدائی لاگت

روایتی جاوا فریم ورک رن ٹائم متحرک عکاسی، کلاس پاتھ اسکیننگ، اور پراکسی جنریشن پر بہت زیادہ انحصار کرتے ہیں:

1. کلاس پاتھ اسکیننگ: اسٹارٹ اپ کے دوران، JVM کلاس پاتھ میں ہر JAR فائل کو اسکین کرتا ہے تاکہ تشریحات کو دریافت کیا جا سکے جیسے @Component، @Service، @Controller، یا @Entity۔
2. تشریح کی پروسیسنگ اور عکاسی: فریم ورک ریفلیکشن (Class.forName(), getDeclaredFields()) استعمال کرتا ہے تاکہ بینز، کنفیگریشن پراپرٹیز، اور انحصار کا ان میموری گراف بنایا جاسکے۔
3. متحرک پراکسی تخلیق: CGLIB یا ByteBuddy Aspect-Oriented Programming (AOP)، ڈیٹا بیس ٹرانزیکشن مینجمنٹ (@Transactional)، اور حفاظتی حدود کو سپورٹ کرنے کے لیے رن ٹائم میموری میں ڈائنامک بائٹ کوڈ پراکسی تیار کرتا ہے۔
4. میٹا اسپیس اور آر ایس ایس انفلیشن: تمام میٹا ڈیٹا، عکاسی شدہ کلاس ڈسکرپٹرز، اور جنریٹڈ پراکسیز کو JVM کے میٹا اسپیس اور ریذیڈنٹ سیٹ سائز (RSS) کے اندر میموری میں رکھنا چاہیے۔

یہ رن ٹائم ریفلیکشن لوپ کافی CPU سائیکلوں کی ضرورت ہے اور ہیپ میموری کی کھپت کو بڑھاتا ہے۔ روایتی جاوا میں ایک بنیادی CRUD REST سروس آسانی سے 140MB سے 300MB RAM کو بیکار میں استعمال کر سکتی ہے اور شروع ہونے میں **3 سے 8 سیکنڈز کا وقت لگاتی ہے۔

B. کلاؤڈ کمپیوٹنگ میں مالی جرمانہ

سرور لیس اور کنٹینرائزڈ ماحول میں، کلاؤڈ فراہم کرنے والے دو میٹرکس کی بنیاد پر چارج کرتے ہیں: مختص میموری (GB) اور عمل درآمد کا دورانیہ (ملی سیکنڈ)۔

• کولڈ اسٹارٹس: اگر سرور لیس فنکشن کو بوٹ ہونے میں 5 سیکنڈ کا وقت لگتا ہے، تو اختتامی صارفین کو قابل توجہ تاخیر کا سامنا کرنا پڑتا ہے، اور آپ 5 سیکنڈ کے بیکار اسٹارٹ اپ کمپیوٹیشن کے لیے ادائیگی کرتے ہیں۔
• کثافت اور پوڈ اسکیل ایبلٹی: 16 جی بی ریم رکھنے والے ورکر نوڈ کے ساتھ Kubernetes کلسٹر میں، آپ میموری ختم ہونے سے پہلے صرف ~ 40 روایتی اسپرنگ بوٹ مائیکرو سروس انسٹینس چلا سکتے ہیں۔ اگر ہر ایک مثال صرف 15MB RAM استعمال کرتی ہے، تو وہی نوڈ **800 سے زیادہ مثالوں کی میزبانی کر سکتا ہے۔

2. کوارکس آرکیٹیکچر: کام کو رن ٹائم سے بلڈ ٹائم تک منتقل کرنا

Quarkus ایک ریڈیکل آرکیٹیکچرل پیراڈائم شفٹ کے ذریعے کلاؤڈ-آبائی مخمصے کو حل کرتا ہے: متحرک آپریشنز کو رن ٹائم سے بلڈ ٹائم تک منتقل کرنا۔

بلڈ ٹائم پروسیسنگ (وقت سے پہلے کی اصلاح)

کلاس پاتھ اسکیننگ، تشریح پارسنگ، اور بین گراف وائرنگ کو ہر بار ایپلیکیشن کے بوٹ کرنے کے بجائے، Quarkus یہ تمام بھاری آپریشن ایک بار تعمیر کے مرحلے (mvn package یا ./gradlew build) کے دوران انجام دیتا ہے۔

1. ایکسٹینشن آرکیٹیکچر اور تعمیراتی مراحل: کوارکس ایک پلگ ایبل ایکسٹینشن فریم ورک استعمال کرتا ہے۔ اپنی ایپلیکیشن کو مرتب کرتے وقت، Quarkus ایکسٹینشن تشریحات کو پارس کرتے ہیں، آپٹمائزڈ سٹیٹک بائیک کوڈ تیار کرتے ہیں، اور انحصار انجیکشن گرافس کو سامنے حل کرتے ہیں۔
2. پری بیکڈ میٹا ڈیٹا: تمام انحصار انجیکشن میٹا ڈیٹا کا پہلے سے حساب لگایا جاتا ہے۔ جب ایپلیکیشن شروع ہوتی ہے، Quarkus بغیر عکاسی کیے یا کلاس پاتھ کو اسکین کیے بغیر پہلے سے مرتب شدہ کلاسز کو براہ راست شروع کرتا ہے۔
3. ڈیڈ کوڈ کا خاتمہ (درخت ہلانا): تعمیر کے عمل کے دوران، کوارکس ان کلاسوں، طریقوں اور لائبریریوں کی نشاندہی کرتا ہے جو آپ کی ایپلی کیشن کے ذریعے غیر استعمال شدہ ہیں اور انہیں مکمل طور پر نکال دیتا ہے۔

جب تک آپ کی ایپلیکیشن JAR یا مقامی بائنری تیار ہوتی ہے، تمام رن ٹائم اوور ہیڈ کو ختم کر دیا جاتا ہے۔ JVM صرف پری وائرڈ جامد بائیک کوڈز کو لوڈ کرتا ہے اور فوری طور پر شروع ہوتا ہے۔

3. GraalVM مقامی تصویر بمقابلہ OpenJDK HotSpot

Quarkus ایک ڈوئل ایگزیکیوشن ماڈل فراہم کرتا ہے: یہ معیاری OpenJDK HotSpot پر غیر معمولی تیزی سے چلتا ہے، لیکن GraalVM Native Image میں مرتب ہونے پر یہ اپنی زیادہ سے زیادہ کارکردگی کی صلاحیت تک پہنچ جاتا ہے۔

+-----------------------------------------------------------------------+
|                         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    |
   +----------------------------------+   +----------------------------------+

پیشگی وقت (AOT) تالیف اور سبسٹریٹ VM

GraalVM Native Image Java bytecode لیتا ہے اور اسے براہ راست OS کے مخصوص اسٹینڈ اکیکیوٹ ایبل بائنری میں مرتب کرتا ہے (Linux پر ELF بائنری، MacOS پر Mach-O، Windows پر EXE)۔

• Closed-World Assumption: GraalVM فرض کرتا ہے کہ تمام قابل رسائی کوڈ، کلاسز اور وسائل تعمیر کے وقت معلوم ہوتے ہیں۔
• سبسٹریٹ VM: مقامی ایگزیکیوٹیبل ایک چھوٹے رن ٹائم انجن کو ایمبیڈ کرتا ہے جسے سبسٹریٹ VM کہا جاتا ہے، جو مکمل JVM مثال شروع کیے بغیر میموری مینجمنٹ، تھریڈ شیڈیولنگ، اور کوڑا اٹھانے کا کام سنبھالتا ہے۔
• زیرو ریفلیکشن اوور ہیڈ: چونکہ Quarkus تعمیراتی وقت کے دوران عکاسی کنفیگریشنز اور پراکسی تعریفیں تیار کرتا ہے، اس لیے GraalVM مقامی تصویری تالیف دستی کنفیگریشن فائلوں کے بغیر آسانی سے کامیاب ہوجاتی ہے جو تاریخی طور پر مقامی GraalVM بلڈز کے لیے درکار ہیں۔

4. کارکردگی کے معیارات: تجرباتی ثبوت

کارکردگی میں بالکل تضاد کو واضح کرنے کے لیے، آئیے معیاری REST + Database CRUD سروس چلانے والی تین جاوا رن ٹائم کنفیگریشنز میں معیاری صنعت کے بینچ مارک موازنہ کا جائزہ لیں:

1. روایتی کلاؤڈ-آبائی اسٹیک (روایتی JVM / اسپرنگ بوٹ) 2۔ اوپن جے ڈی کے ہاٹ سپاٹ پر کوارکس**
2. GraalVM مقامی تصویر پر Quarkus

کارکردگی کا خلاصہ ٹیبل

دھیان دیں کہ Quarkus نے 14 ملی سیکنڈز میں ایک مقامی امیج بوٹ پر مرتب کیا—ایک پلک جھپکنے سے بھی تیز—اور محض 13 MB RAM استعمال کرتا ہے۔ یہ جاوا کو بغیر سرور اور کلاؤڈ مقامی تعیناتیوں کے لیے Go اور Rust کے ساتھ مکمل طور پر مسابقتی بناتا ہے۔

5. رد عمل اور ضروری ڈوئل کور انجن

تاریخی طور پر، جاوا ڈویلپرز کو دو باہمی خصوصی پروگرامنگ ماڈلز میں سے انتخاب کرنا پڑتا تھا:

1. لازمی (تھریڈ فی درخواست): معیاری JDBC ڈرائیورز اور ہم وقت ساز REST اینڈ پوائنٹس کا استعمال کرتے ہوئے سادہ، پڑھنے کے قابل بلاکنگ کوڈ۔
2. ری ایکٹیو (ایونٹ لوپ): غیر مسدود کوڈ (مثال کے طور پر، RxJava، پروجیکٹ ری ایکٹر) اعلی تھرو پٹ کے قابل، لیکن پیچیدہ کال بیک چینز اور مشکل ڈیبگنگ کے لیے بدنام ہے۔

Quarkus دونوں جہانوں کو Eclipse Vert.x اور Netty سے چلنے والے ایک واحد، مربوط انجن کے تحت متحد کرتا ہے۔

                      +---------------------------------+
                      |     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 |
                 +-------------------+   +-------------------+

کوارکس میں، نان بلاکنگ I/O بنیاد ہے۔ اگر آپ روایتی بلاکنگ کوڈ لکھتے ہیں، تو Quarkus خود بخود عملدرآمد کو ایک منظم ورکر تھریڈ پول میں بھیج دیتا ہے۔ اگر آپ SmallRye Mutiny (Uni<T> اور Multi<T>) جیسی رد عمل والی قسمیں استعمال کرتے ہیں، تو عملدرآمد اعلی کارکردگی والے غیر مسدود ایونٹ لوپ تھریڈ پر رہتا ہے۔

6. ڈویلپر جوی: لائیو کوڈنگ اور دیو سروسز

رن ٹائم کارکردگی کے علاوہ، Quarkus ایک انقلابی ڈویلپر کا تجربہ فراہم کرتا ہے جو تھکا دینے والے بلڈ-ٹیسٹ-ریسٹارٹ فیڈ بیک لوپ کو ختم کرنے کے لیے ڈیزائن کیا گیا ہے۔

A. زیرو-ریسٹارٹ لائیو کوڈنگ (quarkus:dev)

mvn quarkus:dev چلانے پر، Quarkus لائیو کوڈنگ موڈ شروع کرتا ہے۔ آپ جاوا فائلوں میں ترمیم کر سکتے ہیں، پراپرٹیز تبدیل کر سکتے ہیں، HTML ٹیمپلیٹس میں ترمیم کر سکتے ہیں، یا ڈیٹا بیس سکیموں کو اپ ڈیٹ کر سکتے ہیں۔

اگلی بار جب آپ اپنے براؤزر یا ٹرمینل میں HTTP درخواست کو ٹرگر کرتے ہیں، Quarkus فائل میں تبدیلیوں کا پتہ لگاتا ہے، تعمیراتی مراحل کو دوبارہ لاگو کرتا ہے، اور ایپلیکیشن کو 500 ملی سیکنڈ سے کم میں دوبارہ لوڈ کرتا ہے۔ ترقی کے دوران آپ کو اپنے ایپلیکیشن سرور کو دستی طور پر روکنے اور دوبارہ شروع کرنے کی ضرورت نہیں ہے۔

B. Quarkus Dev Services (زیرو کنفیگریشن ٹیسٹ کنٹینرز)

پوسٹگری ایس کیو ایل ڈیٹا بیس، کافکا بروکر، یا ریڈیس کیشے سے مائیکرو سروس کو جوڑنے کے لیے عام طور پر docker-compose.yml فائل لکھنے اور مقامی ڈیٹا بیس پورٹس کو ترتیب دینے کی ضرورت ہوتی ہے۔

کوارکس دیو سروسز کے ساتھ:

• اگر Quarkus ڈیٹا بیس کے انحصار کا پتہ لگاتا ہے (مثال کے طور پر، quarkus-reactive-pg-client) لیکن application.properties میں کوئی ڈیٹا بیس URL ترتیب نہیں دیا گیا ہے، تو Quarkus خودکار طور پر ایک Docker کنٹینر کو گھماتا ہے PostgreSQL کو Testcontainers کے ذریعے پس منظر میں چلاتا ہے۔
• یہ آپ کی چل رہی ایپلیکیشن میں کنکشن کی اسناد خود بخود داخل کرتا ہے۔
• جب آپ ڈیو موڈ کو روکتے ہیں، تو کنٹینر خود کو صاف کرتا ہے۔

7. ہینڈ آن واک تھرو: پروڈکشن کے لیے تیار ری ایکٹیو کوارکس سروس کی تعمیر

آئیے جاوا میں ایک صاف، اعلیٰ کارکردگی والی Quarkus مائیکرو سروس بنائیں جو Hibernate Reactive with Panache کا استعمال کرتے ہوئے PostgreSQL ڈیٹا بیس سے منسلک REST API کو بے نقاب کرے۔

مرحلہ 1: پروجیکٹ کا انحصار (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>

مرحلہ 2: رد عمل والی ہستی کی وضاحت کریں (UserEntity.java)

Quarkus نے Panache کے ساتھ ڈیٹا تک رسائی کو آسان بنایا، جو کہ Hibernate کے اوپر ایک ایکٹو-ریکارڈ پیٹرن کا نفاذ ہے۔

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: Reactive REST Resource (UserResource.java) کو لاگو کریں

RESTEasy Reactive اور SmallRye Mutiny کا استعمال کرتے ہوئے، ہمارے HTTP اینڈ پوائنٹس مکمل طور پر غیر مسدود تھریڈز پر کام کرتے ہیں:

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());
    }
}

مرحلہ 4: ایپلیکیشن کنفیگریشن (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

نوٹ کریں کہ ہم نے ڈیٹا بیس یو آر ایل، صارف نام، یا پاس ورڈز کو کنفیگر نہیں کیا! جب آپ ./mvnw quarkus:dev چلاتے ہیں، Quarkus خود بخود PostgreSQL کا پتہ لگاتا ہے، ایک Docker کنٹینر لانچ کرتا ہے، ڈیٹا بیس اسکیما ٹیبلز سیٹ کرتا ہے، اور http://localhost:8080/swagger-ui پر Swagger UI کھولتا ہے۔

مرحلہ 5: مقامی ایگزیکیوٹیبلز کی تعمیر اور ان پر عمل درآمد

فوری لائیو کوڈنگ ڈیو موڈ میں چلانے کے لیے:

./mvnw quarkus:dev

ڈوکر کنٹینر کے اندر GraalVM کا استعمال کرتے ہوئے مقامی لینکس بائنری بنانے کے لئے (کسی مقامی GraalVM انسٹالیشن کی ضرورت نہیں ہے):

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

نتیجے میں بائنری کو براہ راست اپنے OS پر لانچ کرنے کے لیے:

./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 سیکنڈ کا آغاز!

8. اسٹریٹجک فیچر کا موازنہ: کوارکس بمقابلہ اسپرنگ بوٹ

9. نتیجہ: کیا یہ کوارکس کی طرف جانے کا وقت ہے؟

Quarkus محض ایک اور ویب فریم ورک نہیں ہے۔ یہ کلاؤڈ-آبائی دور کے لیے جاوا کے ارتقاء کی نمائندگی کرتا ہے۔ GraalVM مقامی تالیف کے ساتھ بلڈ ٹائم آپٹیمائزیشن کو ملا کر، Quarkus اس لیگیسی سٹیریوٹائپ کو باطل کر دیتا ہے کہ جاوا بہت سست ہے یا جدید مائیکرو سروسز اور سرور لیس فنکشنز کے لیے بہت زیادہ میموری ہے۔

آپ کو کوارکس کا انتخاب کب کرنا چاہیے؟

• سرور لیس اور ایونٹ سے چلنے والی ایپلی کیشنز: اگر آپ AWS Lambda، GCP Cloud Run، یا Knative میں مائیکرو سروسز تعینات کر رہے ہیں تو Quarkus کی مقامی بائنریز کولڈ اسٹارٹ کے مسائل کو مکمل طور پر ختم کر دیتی ہیں۔
• High-density Kubernetes Clusters: اگر آپ کے بنیادی ڈھانچے کے بل پر کلسٹر RAM کی کھپت کا غلبہ ہے، Quarkus میں خدمات کی منتقلی میموری کی لاگت کو 75% تک کم کرسکتی ہے۔
• ری ایکٹیو مائیکرو سروسز: اگر آپ ہائی تھرو پٹ سسٹم بناتے ہیں جس میں نان بلاکنگ اسٹریمنگ (کافکا، جی آر پی سی، ویب ساکٹس) کی ضرورت ہوتی ہے، تو کوارکس باکس سے باہر اعلی درجے کی کارکردگی پیش کرتا ہے۔

جاوا اب سست سٹارٹ اپس یا پھولے ہوئے رن ٹائمز کے ذریعے لنگر انداز نہیں ہوتا ہے۔ Quarkus کے ساتھ، Java کے ڈویلپرز Supersonic Speed ​​اور Subatomic Footprint کے ساتھ کلاؤڈ مقامی ایپلی کیشنز بنا سکتے ہیں۔