quarkus-basic-docs

---

🧩 What is Quarkus?

Quarkus is a modern, Kubernetes-native Java framework designed for:

• Cloud, container, and serverless environments
• Fast startup time
• Low memory usage

It’s often called “Supersonic Subatomic Java” ⚡ because it makes Java apps start up fast and use less RAM — perfect for modern microservices.

Quarkus supports both imperative (blocking) and reactive (non-blocking) programming styles.

---

🚀 Core Idea

Quarkus rethinks Java frameworks for the container + cloud era by:

• Doing build-time optimization (most dependency injection, classpath scanning, and reflection analysis happen at build time — not runtime).
• Working natively with GraalVM to compile your app into a native binary, which starts in milliseconds.

---

⚙️ Quarkus Key Features

Feature	Description
🏗 Build-time optimization	Framework does initialization during build, not at runtime.
🧊 Native image support (GraalVM)	Compile Java to native binary → instant startup, low memory.
🧩 MicroProfile + Jakarta EE support	Uses standards like CDI, JAX-RS, and MicroProfile Config.
🧠 Developer Joy (Dev Mode)	mvn quarkus:dev → hot reload, like Spring DevTools but faster.
☁️ Kubernetes-native	Built-in support for containerization, config maps, secrets, etc.
🔄 Reactive Core	Based on Vert.x for non-blocking I/O and event-driven systems.
🧰 Extensions-based	Modular, plug-in ecosystem (Kafka, AWS, REST, DB, etc.).

---

🌱 What is Spring Boot?

Spring Boot is a mature, general-purpose Java framework that simplifies creating production-ready applications using the Spring ecosystem. It’s built around runtime reflection, auto-configuration, and a rich ecosystem of starters.

Spring Boot focuses on:

• Simplicity
• Productivity
• Rich integrations (Spring Data, Security, Cloud, etc.)

---

⚖️ Quarkus vs Spring Boot — Key Differences

Aspect	Spring Boot	Quarkus
Startup time	Hundreds of milliseconds to a few seconds	Few milliseconds (native), ~200ms in JVM mode
Memory usage	Higher (~150–300MB typical)	Lower (~30–70MB JVM mode, <30MB native)
Boot mechanism	Runtime reflection & classpath scanning	Build-time processing and static initialization
Native image support	Supported via Spring Native (experimental in older versions, now better in Spring Boot 3)	Built-in first-class support with GraalVM
Programming model	Spring Framework (annotations like @RestController, @Autowired)	Jakarta EE + MicroProfile (@Path, @Inject, @ConfigProperty)
Reactive framework	Project Reactor (WebFlux)	Vert.x (natively reactive core)
Hot reload	Spring DevTools	Quarkus Dev Mode (mvn quarkus:dev) — faster
Configuration	application.properties / YAML + @Value	Same file names + MicroProfile Config
Cloud/K8s integration	Spring Cloud, Netflix OSS	Built-in Quarkus extensions for Kubernetes, AWS, etc.
Ecosystem maturity	Very mature and vast	Newer, smaller but rapidly growing
Best suited for	Traditional microservices, large enterprise apps	Cloud-native, serverless, and container-first microservices

---

🧠 How Quarkus achieves speed

Optimization	What it does
Ahead-of-Time (AOT) build	Moves runtime reflection and scanning to build phase.
Dependency injection at build-time	No runtime classpath scanning.
Static init for GraalVM	Prepares everything needed for native image compilation.
No heavy runtime proxies	Uses bytecode generation at build-time instead.

These optimizations make Quarkus ideal for serverless functions, microservices, or edge computing, where startup speed and memory cost matter.

---

💡 Example Comparison

Spring Boot REST Example

@RestController
@RequestMapping("/hello")
public class HelloController {

    @GetMapping
    public String hello() {
        return "Hello from Spring Boot!";
    }
}

Quarkus REST Example

import jakarta.ws.rs.GET;
import jakarta.ws.rs.Path;

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

    @GET
    public String hello() {
        return "Hello from Quarkus!";
    }
}

Both do the same thing — the difference is that Quarkus uses JAX-RS annotations instead of Spring MVC ones.

---

⚡ Real-world performance snapshot

Metric	Spring Boot (JVM)	Quarkus (Native)
Startup time	~2.5 seconds	~0.03 seconds
Memory usage	~150–300 MB	~30–40 MB
Container cold start	Slower	Very fast
Throughput	Comparable	Comparable

---

🏁 When to choose which

Use Case	Best Choice
Existing enterprise apps	Spring Boot
Building cloud-native microservices	Quarkus
Need blazing-fast cold start (e.g., AWS Lambda)	Quarkus (native)
Large ecosystem and integrations	Spring Boot
Lightweight containerized apps	Quarkus
Reactive + event-driven services	Quarkus (Vert.x)

---

🧩 In summary

	Spring Boot	Quarkus
🧱 Foundation	Spring Framework	MicroProfile + Vert.x
⚙️ Focus	Developer productivity	Cloud-native efficiency
⚡ Startup	Medium	Very fast
🧊 Native image	Optional / slower	Built-in
☁️ Cloud/Serverless fit	Good	Excellent
🧩 Learning curve	Easier (mature docs)	Moderate (different annotations)

---

understanding the architecture difference between Quarkus and Spring Boot really clarifies why Quarkus is faster and more cloud-efficient.

Let’s go through this step-by-step — visually, conceptually, and technically.

🧱 1. High-level Architecture Overview

Layer	Spring Boot	Quarkus
Core framework	Built on Spring Framework (IoC + Reflection + Classpath Scanning)	Built on CDI (Contexts & Dependency Injection) + Vert.x (Reactive core)
Programming model	Spring annotations (@RestController, @Service, etc.)	Jakarta EE + MicroProfile APIs (@Path, @Inject, @ConfigProperty)
Startup mechanism	Heavy runtime scanning & reflection-based injection	Build-time analysis & bytecode generation (no runtime scanning)
Runtime type	Fat JAR with embedded Tomcat/Jetty	JVM mode or Native binary via GraalVM
Execution model	Synchronous (Spring MVC) or Reactive (WebFlux)	Imperative or Reactive (Vert.x)
Configuration	Spring Environment + application.properties	MicroProfile Config + application.properties
Extension model	Starters (e.g., spring-boot-starter-web)	Extensions (e.g., quarkus-resteasy)
Container & Cloud focus	Works well	Designed for container/cloud-native runtime

---

🧠 2. Internal Architecture Flow

🧩 Spring Boot

┌────────────────────────────┐
│ Developer Code             │
│  - @RestController          │
│  - @Service, @Repository    │
└──────────────┬─────────────┘
               │
               ▼
┌────────────────────────────┐
│ Spring Context Initialization │
│  - Scans classpath for beans   │
│  - Uses reflection to wire DI  │
│  - Builds ApplicationContext   │
└──────────────┬─────────────┘
               │
               ▼
┌────────────────────────────┐
│ Embedded Server (Tomcat)   │
│  - Starts web environment  │
│  - Loads controllers       │
└──────────────┬─────────────┘
               │
               ▼
           Application Running

🧩 Key behavior:

• Bean discovery and dependency injection happen at runtime.
• Reflection and proxy creation are expensive.
• Startup time and memory overhead are higher.

---

⚡ Quarkus

┌────────────────────────────┐
│ Developer Code             │
│  - @Path, @Inject, etc.     │
└──────────────┬─────────────┘
               │
               ▼
┌────────────────────────────┐
│ Quarkus Build-time Augmentation │
│  - Scans and analyzes classes    │
│  - Generates bytecode ahead-of-time │
│  - Removes unused parts (dead code elimination) │
└──────────────┬─────────────┘
               │
               ▼
┌────────────────────────────┐
│ Build Output               │
│  - JVM JAR or               │
│  - Native Binary (GraalVM)  │
└──────────────┬─────────────┘
               │
               ▼
┌────────────────────────────┐
│ Runtime (Small, Fast)      │
│  - No classpath scanning    │
│  - Pre-wired dependencies   │
│  - Minimal reflection       │
└──────────────┬─────────────┘
               │
               ▼
           Application Running

🧩 Key behavior:

• Dependency injection, route wiring, and reflection setup happen at build-time.
• The final runtime is lightweight, with minimal boot overhead.
• Perfect for container or serverless deployments.

---

⚙️ 3. Build-Time vs Run-Time Processing

Stage	Spring Boot	Quarkus
Bean scanning	Runtime	Build-time
Reflection setup	Runtime	Build-time / bytecode generated
Proxy creation	Runtime (via CGLIB)	Build-time
Dependency injection	Runtime	Build-time
Configuration loading	Runtime	Runtime (MicroProfile Config)
Native image prep	Optional (via Spring Native)	Built-in, optimized for GraalVM

👉 Result: Quarkus removes most of the startup “thinking time” by doing it during the build phase.

---

🧊 4. Runtime Differences (JVM vs Native)

Mode	Spring Boot	Quarkus
JVM Mode	Yes	Yes
Native Binary (GraalVM)	Experimental (Spring Native / Spring Boot 3+)	Built-in, first-class support
Memory footprint	150–300MB	30–70MB (JVM), ~20–40MB (native)
Startup time	1–3 seconds	0.03–0.3 seconds (native)

---

☁️ 5. Cloud & Container Architecture

Feature	Spring Boot	Quarkus
Kubernetes readiness	via Spring Cloud Kubernetes	Built-in (quarkus-kubernetes)
Config maps / Secrets	via Spring Cloud	Native via MicroProfile Config
Health checks	spring-boot-actuator	quarkus-smallrye-health
Metrics	spring-boot-actuator	smallrye-metrics
Distributed tracing	spring-cloud-sleuth	smallrye-opentracing
Reactive engine	Project Reactor	Vert.x (natively non-blocking)

---

🧩 6. Internal Components Overview

Component	Spring Boot	Quarkus
DI Engine	Spring IoC Container	CDI (Arc - Quarkus implementation)
HTTP Layer	Spring MVC / WebFlux	RESTEasy / Vert.x
Reactive Core	Project Reactor	Vert.x
Config System	Spring Environment	MicroProfile Config
ORM	Spring Data JPA	Hibernate ORM with Panache
Security	Spring Security	Quarkus Security / OIDC
Scheduler	Spring Scheduler	Quarkus Scheduler
Testing	@SpringBootTest	@QuarkusTest

---

⚡ 7. Architectural Summary

	Spring Boot	Quarkus
Design Era	Java EE monolith → microservices	Cloud-native / serverless
Runtime model	Reflection-heavy, dynamic	Static, optimized
Injection mechanism	Reflection & proxy	Build-time code generation
Target runtime	JVM only	JVM + GraalVM Native
Performance	High startup + memory	Low startup + memory
Ideal for	Enterprise microservices, legacy modernization	Cloud-native, containerized, serverless workloads

---

🧭 Example Deployment Comparison

Spring Boot

Developer -> Build JAR -> Run JAR -> Starts in 2–5 sec -> Runs JVM process (150MB+)

Quarkus (Native)

Developer -> Build Native Binary -> Run Executable -> Starts in 0.03 sec -> Uses ~30MB

---

🧩 8. Analogy (Simplified)

Analogy	Meaning
🧱 Spring Boot	Like a smart robot that learns every time it starts
⚡ Quarkus	Like a robot that learns once at build time and runs instantly next time

---

🔚 Summary

	Spring Boot	Quarkus
Core	Spring Framework	CDI + Vert.x
Lifecycle	Runtime introspection	Build-time processing
Performance	Moderate	Very fast
Native compilation	Optional	Built-in
Ideal for	General purpose microservices	Cloud-native, container, and serverless apps

---

side-by-side list** showing the equivalent annotations and concepts in Spring and Quarkus (Jakarta / MicroProfile).

---

🧩 1. Basic Bean Definitions

Concept	Spring Boot	Quarkus / Jakarta EE	Notes
Declare a bean / service	@Component, @Service, @Repository	@ApplicationScoped, @Singleton	Quarkus uses CDI (Contexts and Dependency Injection)
Dependency injection	@Autowired	@Inject	@Inject is the Jakarta standard
Configuration class	@Configuration	None (use CDI beans or producer methods)	Quarkus avoids heavy config classes
Define a bean manually	@Bean	@Produces	CDI equivalent of Spring’s @Bean factory method

---

⚙️ 2. Configuration and Properties

Concept	Spring Boot	Quarkus / MicroProfile Config	Notes
Inject a config property	@Value("${my.prop}")	@ConfigProperty(name = "my.prop")	Both read from application properties
Configuration file	application.properties / application.yml	application.properties / application.yml	Same file name; Quarkus supports profiles (%dev.key=value)
Profile-based config	@Profile("dev")	%dev.key=value (in properties file)	Quarkus handles profiles at config level
Externalized config system	Spring Environment API	MicroProfile Config API	Quarkus implements MicroProfile Config

---

🌐 3. REST Endpoints

Concept	Spring Boot	Quarkus / Jakarta REST (JAX-RS)	Notes
REST controller	@RestController	@Path (on class)	JAX-RS standard used in Quarkus
Request mapping	@RequestMapping, @GetMapping, etc.	@GET, @POST, @PUT, @DELETE	Different naming but same function
Path parameter	@PathVariable	@PathParam	Similar
Query parameter	@RequestParam	@QueryParam	Same purpose
Request body	@RequestBody	@Consumes(MediaType.APPLICATION_JSON) + method param
Response body	@ResponseBody	@Produces(MediaType.APPLICATION_JSON)
HTTP status control	ResponseEntity	Response (Jakarta REST)

---

🧭 4. Dependency Injection Scopes

Scope	Spring	Quarkus / CDI
Singleton	@Singleton (by default)	@Singleton
Application-wide	@Component or @Service	@ApplicationScoped
Per request	@RequestScope	@RequestScoped
Per session	@SessionScope	@SessionScoped
Prototype	@Scope("prototype")	No direct equivalent (create new manually)

---

🧰 5. Lifecycle Hooks

Concept	Spring Boot	Quarkus / CDI	Notes
Post construct	@PostConstruct	@PostConstruct	Same Jakarta annotation
Pre destroy	@PreDestroy	@PreDestroy	Same
Application startup hook	CommandLineRunner, ApplicationRunner	@Startup bean with @PostConstruct or StartupEvent observer	Example: void onStart(@Observes StartupEvent ev)
Application shutdown hook	DisposableBean	@Observes ShutdownEvent

---

🧩 6. Scheduling

Concept	Spring Boot	Quarkus
Enable scheduling	@EnableScheduling	Auto-enabled via quarkus-scheduler extension
Scheduled method	@Scheduled(fixedRate = 5000)	@Scheduled(every = "5s")
Cron expression	@Scheduled(cron = "0 * * * * *")	@Scheduled(cron = "0 * * * * ?")

---

📬 7. REST Client

Concept	Spring	Quarkus / MicroProfile
REST client	RestTemplate, WebClient, FeignClient	@RegisterRestClient, MicroProfile Rest Client
Base URL	@FeignClient(name="...", url="...")	@RegisterRestClient(configKey = "...")
Inject client	@Autowired	@Inject @RestClient

---

🧾 8. Transactions & Persistence (JPA)

Concept	Spring	Quarkus
Entity manager injection	@PersistenceContext	@Inject EntityManager
Transaction management	@Transactional (Spring)	@Transactional (Jakarta)
Repository	JpaRepository	Panache repositories (PanacheEntity, PanacheRepository)
Enable JPA	spring-boot-starter-data-jpa	quarkus-hibernate-orm-panache

---

💬 9. Event System

Concept	Spring	Quarkus / CDI
Publish event	ApplicationEventPublisher.publishEvent()	@Inject Event<MyEvent> then event.fire()
Listen to event	@EventListener	void onEvent(@Observes MyEvent event)

---

🔒 10. Security

Concept	Spring Security	Quarkus Security / OIDC
Enable security	@EnableWebSecurity	Add quarkus-oidc or quarkus-security extension
Role-based access	@PreAuthorize("hasRole('ADMIN')")	@RolesAllowed("admin")
Auth principal injection	@AuthenticationPrincipal	@Inject JsonWebToken jwt

---

🚀 11. Testing

Concept	Spring Boot	Quarkus
Test runner	@SpringBootTest	@QuarkusTest
Mock bean	@MockBean	@InjectMock
Inject dependencies	@Autowired	@Inject

---

✅ Summary Table (Quick View)

Category	Spring Annotation	Quarkus Equivalent
@Component / @Service	@ApplicationScoped
@Autowired	@Inject
@Value	@ConfigProperty
@Configuration + @Bean	@Produces
@RestController	@Path
@GetMapping	@GET
@RequestParam	@QueryParam
@Scheduled	@Scheduled(every="5s")
@Transactional	@Transactional
@EventListener	@Observes
@EnableScheduling	none (auto-enabled)
@PreAuthorize	@RolesAllowed
@SpringBootTest	@QuarkusTest

---