Spring Boot එදිරිව Quarkus: Native Compilations වල අලුත්ම කතාව - SC Guide
කොහොමද යාලුවනේ! Tech Guide Sri Lanka එකෙන් ගෙන එන තවත් අලුත්ම ලිපියකට ඔයාලා හැමෝම සාදරයෙන් පිළිගන්නවා. අද අපි කතා කරන්න යන්නේ Software Engineering ලෝකයේ, විශේෂයෙන්ම Backend Development වලට අදාල අතිශය උණුසුම් මාතෘකාවක් ගැන. Java කියන්නේ අවුරුදු ගාණක් තිස්සේ Enterprise Applications හදන්න වැඩිපුරම පාවිච්චි කරපු, විශ්වාස කරන භාෂාවක්. ඒකේ Performance, Scalability, Robustness වගේ ගුණාංග නිසා තමයි Java අදටත් Software ලෝකයේ ඉදිරියෙන්ම ඉන්නේ. හැබැයි, මෑතකාලීනව Cloud Computing, Microservices Architecture, Serverless Functions වගේ අලුත් සංකල්ප එනකොට, Java වලට පොඩි අභියෝග ටිකක් ආවා.
සාමාන්‍ය Java Application එකක් JVM (Java Virtual Machine) එක මත දුවන නිසා Startup වෙන්න ටිකක් වෙලා යනවා. ඒ වගේම Memory Consumption එකත් සාපේක්ෂව වැඩියි. Cloud එකේදී Resource Consumption එක වැඩි වෙනකොට Cost එකත් වැඩි වෙනවා. මේ ප්‍රශ්නවලට හොඳ විසඳුමක් විදියට Spring Boot වගේ Frameworks අති විශාල ජනප්‍රියත්වයක් ලබාගෙන, Java Development එක ගොඩක් පහසු කළා. Spring Boot කියන්නේ Java developers ලා අතරේ අදටත් රජ කරන, Production-ready applications ඉතා ඉක්මනින් හදන්න පුළුවන් Framework එකක්.
හැබැයි ඉතින්, Tech ලෝකේ හැමදාම අලුත් දේවල් එනවනේ. Microservices සහ Serverless වලට තවත් හොඳින් ගැලපෙන විදියට, වේගවත් Startup Time එකක් සහ අඩු Memory Usage එකක් එක්ක එන්න අලුත් Frameworks බිහි වුණා. අන්න එහෙම ආපු අලුත්, සුපිරි Framework එකක් තමයි Quarkus කියන්නේ. Red Hat සමාගමෙන් හදපු මේ Framework එකේ ටැග් ලයින් එක තමයි "Supersonic Subatomic Java". ඒකෙන් කියන්නේ එයාලගේ වේගවත් බවයි, කුඩා ප්‍රමාණයයි ගැන. මේක ඇත්තටම Java Applications වලට අලුත් ජීවයක් දීලා, Cloud Native ලෝකයට හොඳින් ගැලපෙන විදියට හදලා තියෙනවා.
ඉතින්, අද අපි කතා කරමු මේ Spring Boot කියන අපේ විශ්වාසවන්ත යාළුවයි, Quarkus කියන අලුත් Hero වයි ගැන. කවුද හොඳ? කවුද අපිට ගැලපෙන්නේ? විශේෂයෙන්ම Native Compilation පැත්තෙන් මේ දෙන්නා අතරේ තියෙන වෙනස්කම් මොනවද කියලා අපි ගැඹුරින් බලමු. මේ ලිපිය අවසානයේදී ඔයාලට ඔයාලගේ Project එකට වඩාත් සුදුසු Framework එක තෝරාගන්න හොඳ අදහසක් ගන්න පුළුවන් වෙයි කියලා මම විශ්වාස කරනවා. අපි බලමු එහෙනම් මේක කොහොමද වෙන්නේ කියලා.
Spring Boot: විශ්වාසවන්ත යාළුවා (The Trusted Friend)
මුලින්ම අපි කතා කරමු Spring Boot ගැන. Java Enterprise Development පැත්තේ වැඩ කරන කෙනෙක්ට Spring Boot ගැන අමුතුවෙන් කියන්න ඕනේ නැහැ. Rapid application development, Easy configuration, Production-ready features වගේ ගොඩක් දේවල් නිසා Spring Boot කියන්නේ Java developers ලා අතරේ අතිශය ජනප්‍රිය Framework එකක්. Spring Framework එකේ Core Concepts (Dependency Injection, Aspect-Oriented Programming) පදනම් කරගෙන හදලා තියෙන Spring Boot, "Convention over Configuration" කියන මූලධර්මය නිසා Boilerplate Code ගොඩක් අඩු කරනවා. ඒ නිසා ඉක්මනින්ම Application එකක් Deploy කරන්න පුළුවන්.
Spring Boot වල තියෙන ප්‍රධානම වාසියක් තමයි ඒකේ තියෙන විශාල Ecosystem එක. Spring Data JPA (Database interactions), Spring Security (Authentication and Authorization), Spring Web (REST APIs and Web Apps), Spring Cloud (Microservices patterns and integration) වගේ Module ගොඩක් තියෙනවා. මේ හැම Module එකක්ම Spring Boot එක්ක Seamless විදියට වැඩ කරනවා. මේක නිසා අපිට මොනවා හරි අවශ්‍යතාවයක් ආවොත්, ඒ හැමදේටම වගේ Spring Boot Ecosystem එක ඇතුළේ විසඳුමක් තියෙනවා. ඒ වගේම විශාල Community එකක් තියෙන නිසා මොනවා හරි ප්‍රශ්නයක් ආවොත් ලේසියෙන් විසඳුම් හොයාගන්න පුළුවන්. Tutorials, Stack Overflow Answers, Books වගේ ගොඩක් Learning Resources ඕන තරම් තියෙනවා. මේක තමයි Spring Boot වල ලොකුම වාසිය. ඕනෑම සංකීර්ණ Enterprise Application එකක් වුණත් Spring Boot එකෙන් හදන්න පුළුවන්.
හැබැයි ඉතින්, Cloud Native microservices වලට යනකොට, විශේෂයෙන්ම Serverless Functions, Kubernetes වගේ Platfom වලට යනකොට Spring Boot වලට පොඩි අභියෝග ටිකක් එනවා. ඒ තමයි සාමාන්‍ය JVM මත දුවන Spring Boot Application එකක Startup Time එක ටිකක් වැඩියි වගේම Memory Footprint එකත් වැඩියි. උදාහරණයක් විදියට, සරල Spring Boot REST API එකක් වුණත් Startup වෙන්න තත්පර 5-10ක් වගේ කාලයක් ගන්න පුළුවන්. ඒ වගේම Minimum Memory Usage එක 100MB - 200MB වගේ වෙන්න පුළුවන්. මේක Cloud වලට දානකොට Cost එකට බලපාන්න පුළුවන්. Serverless Functions වලදී "Cold Start" එකක් කියන ප්‍රශ්නයත් ඇති වෙනවා. මෙන්න මේ අඩුව පුරවන්න තමයි අලුත් Frameworks ආවේ. Spring Boot මේ අභියෝගවලට මුහුණ දෙන්න GraalVM native image support සහ Spring Native වගේ දේවල් එක්ක වැඩ කරනවා වුණත්, ඒක Quarkus වගේ Framework එකක Core Design එකේම තියෙන දේකට වඩා වෙනස්.
Quarkus: ක්ලවුඩ්-නේටිව් ලෝකයේ අලුත් විප්ලවය (New Revolution in Cloud-Native World)
දැන් අපි කතා කරමු Quarkus ගැන. Red Hat සමාගමෙන් හදපු මේ Framework එකේ ප්‍රධානම අරමුණ වෙන්නේ Cloud Native Development වල තියෙන අභියෝගවලට පිළිතුරු දීම. "Supersonic Subatomic Java" කියන ටැග් ලයින් එකෙන්ම ඒ අය කියන්නේ එයාලගේ වේගවත් බව සහ අඩු Memory Usage එක ගැන. Quarkus වල තියෙන ප්‍රධානම වාසියක් තමයි GraalVM එක පාවිච්චි කරලා Native Executables හදන්න පුළුවන් වීම. මේක Ahead-of-Time (AOT) Compilation කියන තාක්ෂණය පාවිච්චි කරනවා. සාමාන්‍යයෙන් Java Applications JVM එක මත Run වෙන්නේ JIT (Just-in-Time) Compilation හරහා. ඒ කියන්නේ Code එක Run වෙන වෙලාවේදී Compile වෙනවා. හැබැයි GraalVM native image එකක් කියන්නේ අපේ Java Application එක සම්පූර්ණයෙන්ම OS එකට අදාල Binary File එකක් විදියට Compile වෙන එක. මේකේ වාසි ගොඩයි:
- අධික වේගවත් Startup Time: Native Executable එකක් තත්පර ගණනකින් නෙමෙයි, Milliseconds ගාණකින් Startup වෙනවා. මේක Cold Start ප්‍රශ්නවලට නියම විසඳුමක්.
- අඩු Memory Footprint: Native Binary එකක් විදියට Compile වෙන නිසා, JVM එකට අවශ්‍ය වන Memory එක ඉතිරි වෙනවා. මේකෙන් Memory Usage එක Megabytes 10-30 වගේ ප්‍රමාණයකට අඩු කරගන්න පුළුවන්. මේක Cloud Cost එකට සෘජුවම බලපානවා.
- කුඩා Binary Size: Final Executable File එකේ Size එක ගොඩක් කුඩා වෙනවා. මේක Container Images කුඩා කරගන්න සහ වේගයෙන් Deploy කරන්න උදව් වෙනවා.
Quarkus reactive programming වලටත් හොඳට Support කරනවා. ඒ වගේම MicroProfile, Eclipse Vert.x, Hibernate ORM, RESTEasy, Apache Camel වගේ ගොඩක් Standard Libraries සහ Frameworks වලට out-of-the-box support එකක් දෙනවා. Quarkus කියන්නේ Java Ecosystem එකේ තියෙන දැනටමත් ජනප්‍රිය වෙලා තියෙන Technologies එක තැනකට ගෙනත්, Cloud Native environments වලට Optimise කරලා හදපු Framework එකක්. Development Experience එකත් ගොඩක් හොඳයි. Hot Reloading වගේ Features නිසා Development Process එක වේගවත් වෙනවා. ඔයා Code එක වෙනස් කරලා Save කරපු ගමන් Application එක Restart වෙන්නේ නැතුවම Changes Apply වෙනවා. ඒක නියම feature එකක්.
Quarkus, Java developer ලට Cloud Native ලෝකයේ ඉදිරියට යන්න හොඳ Platform එකක්. අලුත් projects වලට, විශේෂයෙන්ම Serverless Functions, FaaS (Function as a Service), Edge Computing, Containerized Microservices වගේ තැන් වලට Quarkus ගොඩක් හොඳ තේරීමක්. ඒ වගේම ඔයාලා JVM එකේ Runtime Overhead එක ගැන වැඩියෙන් හිතනවා නම්, Quarkus හොඳ විසඳුමක්.
ප්‍රධාන සටන: Spring Boot vs. Quarkus (Native Power Focus)
දැන් අපි බලමු මේ දෙන්නා අතරේ තියෙන වෙනස්කම් සහ සමානකම් මොනවද කියලා. අපේ ප්‍රධාන අවධානය යොමු කරමු Native Compilation එක පැත්තට.
- Startup Time:මේක තමයි Quarkus වල විශාලම වාසිය. සාමාන්‍යයෙන් Spring Boot Application එකක් JVM එක මත Startup වෙන්න තත්පර කීපයක් (5-15s, සංකීර්ණත්වය අනුව ඊටත් වැඩියි) යනවා. හැබැයි Quarkus Native Executable එකක් Milliseconds ගාණකින් (30-100ms) Startup වෙනවා. මේක Serverless Functions, FaaS වගේ Quick Scaling අවශ්‍ය තැන්වලදී අතිශයින්ම වැදගත්. Microservices වලදීත්, service එකක් crash වෙලා ඉක්මනින් restore වෙන්න ඕනේ නම්, මේ වේගය ගොඩක් වැදගත්.
- Memory Footprint:Spring Boot Application එකකට JVM එකත් එක්ක සාමාන්‍යයෙන් Megabytes 100-200ක් වගේ Memory අවශ්‍ය වෙනවා. විශාල Application වලදී මේක ඊටත් වැඩියි. හැබැයි Quarkus Native Executable එකකට Megabytes 10-30 වගේ අඩු Memory එකකින් වැඩ කරන්න පුළුවන්. මේකෙන් Cloud Hosting වල Cost එක ගොඩක් අඩු කරගන්න පුළුවන්. විශේෂයෙන්ම Kubernetes වගේ Container Orchestration Platforms වලදී, එකම Node එකක වැඩි Containers ප්‍රමාණයක් Deploy කරන්න පුළුවන් වෙනවා.
- Build Time:Quarkus Native Executable එකක් Build කරන්න සාමාන්‍ය JVM Jar එකක් Build කරනවට වඩා වැඩි කාලයක් ගත වෙනවා (මිනිත්තු කීපයක්, සමහරවිට ඊටත් වැඩියි, Project එකේ සංකීර්ණත්වය අනුව). ඒකට GraalVM Native Image Tool එකට අවශ්‍ය Compile කිරීම් සහ Optimization කිරීම් ටික කරන්න ඕනේ. Spring Boot Jar එකක් Build කරන්න ගොඩක් අඩු වෙලාවක් යන්නේ. හැබැයි Native Executable එක හදපු පස්සේ Deployment එක ගොඩක් වේගවත්. CI/CD pipelines වලදී මේ Build Time එක සැලකිල්ලට ගත යුතුයි.
- Developer Experience (DX):දෙකේම Hot Reloading වගේ Features තියෙන නිසා Development Experience එක හොඳයි. Spring Boot වලට විශාල Community එකක් සහ Libraries, Tutorials, Examples තියෙන නිසා අලුතින් ඉගෙන ගන්න එක ලේසියි. ඒ වගේම Spring Initializr එක වගේ Tools නිසා Project Setup එක ඉතාමත් පහසුයි. Quarkus Community එකත් සීග්‍රයෙන් වර්ධනය වෙනවා. Quarkus Dev Mode එකත් (
quarkus:dev) ඉතාමත් දක්ෂයි. ඒ වගේම එයාලගේ Code Generation සහ Compile-Time Build Process එක නිසා Developer Productivity එක වැඩි කරනවා. MicroProfile standards සහ Vert.x වගේ දේවල් එක්ක වැඩ කරන අයට Quarkus ගොඩක් හුරුපුරුදු වෙයි. - Ecosystem සහ Community:Spring Framework එකේ Ecosystem එක අති විශාලයි. අවුරුදු ගණනාවක පරිණත බවක්, අති විශාල Libraries ප්‍රමාණයක් සහ විශාල User Base එකක් තියෙනවා. Quarkus අලුත් වුණත්, Red Hat එකේ Backend එකයි, වේගවත් වර්ධනයකුයි තියෙනවා. ඒ වගේම එයාලා Standard technologies (CDI, JAX-RS, Hibernate) වලට වැඩිපුර අවධානය දෙනවා. අලුත් Libraries සහ Integrations ඉතා ඉක්මනින් Quarkus Ecosystem එකට එකතු වෙනවා.
- Configuration:Spring Boot වලට Spring Boot Starters සහ Auto-configuration හරහා Configuration Management එක ගොඩක් පහසු කරලා තියෙනවා. Quarkus වලත් Similar Concepts තියෙනවා. Quarkus වල Build-Time Configuration කියන Concept එකත් තියෙනවා, ඒකෙන් Runtime එකේදී Configuration Overhead එක අඩු කරනවා.
- Use Cases:
- Spring Boot: Large-scale monolithic applications, existing enterprise projects, traditional web applications, projects where rapid feature development, extensive third-party library support, and a vast, mature ecosystem are paramount. Debugging සහ Troubleshooting කිරීම සාපේක්ෂව පහසුයි.
- Quarkus: New microservices, serverless functions (FaaS), event-driven architectures, containerized applications, IoT edge devices, projects where extremely low memory usage, fast startup times, and high density deployments are critical. Cloud Native Environments වලට ගොඩක් සුදුසුයි.
Quarkus App එකක් හදමු: අත්දැකීමක් ගනිමු!
දැන් අපි කෙලින්ම වැඩේට බහිමු. අපි පොඩි Quarkus REST API එකක් හදලා බලමු කොහොමද මේක වැඩ කරන්නේ කියලා. මේකෙන් අපිට Quarkus වල වේගය සහ සරල බව හොඳට තේරුම් ගන්න පුළුවන්. මේකට ඔයාලට Java 11+, Maven (හෝ Gradle), සහ GraalVM (Native Image build කරන්න අවශ්‍ය නම්) install කරලා තියෙන්න ඕනේ.
පියවර 1: Project එකක් හදමු
Quarkus Project එකක් හදන්න ලේසිම ක්‍රමය තමයි Maven Archetype එකක් පාවිච්චි කරන එක. ඔයාලගේ Terminal එක (Command Prompt/PowerShell for Windows, Terminal for Linux/Mac) Open කරලා මේ Command එක Run කරන්න:
mvn io.quarkus:quarkus-maven-plugin:2.16.12.Final:create \
-DprojectGroupId=lk.scguide \
-DprojectArtifactId=quarkus-comparison-app \
-DclassName="lk.scguide.GreetingResource" \
-Dpath="/hello"
මේ Command එකෙන් වෙන්නේ quarkus-comparison-app කියන නමින් අලුත් Project ෆෝල්ඩර් එකක් හදන එක. ඒක ඇතුළේ Maven Project Structure එකක්, අවශ්‍ය Dependency ටික සහ GreetingResource.java කියන Sample Class එකක් හැදෙනවා. projectGroupId සහ projectArtifactId කියන ඒවා ඔයාගේ Project එකට අදාලව දෙන්න පුළුවන්. className එකට අපි lk.scguide.GreetingResource කියලා දුන්නේ අපේ Package එකට අදාලවයි. path එක කියන්නේ මේ Endpoint එකට Access කරන URL Path එකයි.
පියවර 2: pom.xml File එක බලමු
Project Root එකේ තියෙන pom.xml File එක Open කරලා බලන්න. ඒකේ Quarkus වලට අවශ්‍ය Core Dependency ටික Automatic generate වෙලා තියෙයි. උදාහරණයක් විදියට, quarkus-resteasy-reactive කියන dependency එක REST API හදන්න අවශ්‍යයි.
<dependency>
<groupId>io.quarkus</groupId>
<artifactId>quarkus-resteasy-reactive</artifactId>
</dependency>
ඒ වගේම, Native Build කරන්න අවශ්‍ය Maven Plugin Configuration එකත් මේකේ තියෙනවා:
<build>
<plugins>
<plugin>
<groupId>io.quarkus</groupId>
<artifactId>quarkus-maven-plugin</artifactId>
<version>${quarkus.platform.version}</version>
<extensions>true</extensions>
<executions>
<execution>
<goals>
<goal>build</goal>
<goal>generate-code</goal>
<goal>generate-code-tests</goal>
</goals>
</execution>
</executions>
</plugin>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>${compiler-plugin.version}</version>
<configuration>
<compilerArgs>
<arg>-parameters</arg>
</compilerArgs>
</configuration>
</plugin>
</plugins>
</build>
<profiles>
<profile>
<id>native</id>
<activation>
<property>
<name>native</name>
</property>
</activation>
<build>
<plugins>
<plugin>
<artifactId>maven-failsafe-plugin</artifactId>
<version>${surefire-plugin.version}</version>
<executions>
<execution>
<goals>
<goal>integration-test</goal>
<goal>verify</goal>
</goals>
<configuration>
<systemPropertyVariables>
<native.image.path>${project.build.directory}/${project.build.finalName}-runner</native.image.path>
<java.awt.headless>true</java.awt.headless>
</systemPropertyVariables>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
<properties>
<quarkus.package.type>native</quarkus.package.type>
</properties>
</profile>
</profiles>
පියවර 3: Simple REST Endpoint එකක් බලමු
Project එක හැදුනාට පස්සේ, src/main/java/lk/scguide/GreetingResource.java කියන File එක Open කරලා බලන්න. ඒකේ මේ වගේ Code එකක් තියෙයි:
package lk.scguide; // Package name එක ඔයාගේ projectGroupId එකට අනුව වෙනස් වෙන්න පුළුවන්
import jakarta.ws.rs.GET;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.Produces;
import jakarta.ws.rs.core.MediaType;
@Path("/hello")
public class GreetingResource {
@GET
@Produces(MediaType.TEXT_PLAIN)
public String hello() {
return "Hello from Quarkus REST API! SC Guide welcomes you!";
}
}
මේක JAX-RS Standard එක පාවිච්චි කරලා හදපු Simple REST Endpoint එකක්. /hello කියන Path එකට GET Request එකක් එනකොට "Hello from Quarkus REST API! SC Guide welcomes you!" කියලා Return කරනවා. මේක Spring Boot වල @RestController සහ @GetMapping වගේමයි, හැබැයි Standard Jakarta EE Annotations පාවිච්චි කරනවා.
පියවර 4: Development Mode එකේ Run කරමු
දැන් අපි අපේ Application එක Development Mode එකේ Run කරලා බලමු. Project Root එකට ගිහින් (cd quarkus-comparison-app) මේ Command එක Run කරන්න:
./mvnw quarkus:dev
Quarkus Application එක Dev Mode එකේ Startup වෙයි. Startup Time එක බලන්න, ඒක සාමාන්‍ය Spring Boot එකකට වඩා ගොඩක් වේගවත් වෙන්න ඕනේ. ඔබට Console එකේ මේ වගේ Output එකක් පෙනෙයි:
Listening for transport dt_socket at address: 5005
__ ____ __ _____ ___ __ ____ ______
--/ __ \/ / / / _ | / _ \/ //_/ / / / __/
-/ /_/ / /_/ / __ |/ , _/ ,< / /_/ /\ \
--\___\_\____/_/ |_/_/|_/_/|_|\____/___/
2023-10-27 10:00:00,123 INFO [io.quarkus] (main) Quarkus 2.16.12.Final on JVM (powered by GraalVM Native Image) started in 0.852s. Listening on: http://localhost:8080
2023-10-27 10:00:00,125 INFO [io.quarkus] (main) Profile dev activated.
2023-10-27 10:00:00,125 INFO [io.quarkus] (main) Installed features: [cdi, resteasy-reactive, smallrye-context-propagation, swagger-ui, vertx]
--
Tests paused
Press [e] to edit this page, [r] to resume testing, [o] to open the browser, [s] to stop the application, [v] to view the quarkus-comparison-app.log file, [w] to open the Swagger UI, [h] for more options.
දැන් Browser එක Open කරලා http://localhost:8080/hello කියන URL එකට යන්න. ඔයාලට "Hello from Quarkus REST API! SC Guide welcomes you!" කියලා පෙනෙයි.
Hot Reloading Test කරන්න: GreetingResource.java file එකේ "Hello from Quarkus REST API! SC Guide welcomes you!" කියන Text එක "Hello from Quarkus (Hot Reload)! SC Guide Welcomes you!" කියලා වෙනස් කරලා Save කරන්න. ඔයාට Terminal එකේ Fast Restart එකක් වෙනවා පෙනෙයි. ඒක Application එක සම්පූර්ණයෙන්ම Restart වෙන්නේ නැතුව, Changes Apply කරනවා. දැන් Browser එක Refresh කළාම අලුත් Text එක පෙනෙයි. මේක තමයි Quarkus වල තියෙන සුපිරි Dev Experience එක. Spring Boot DevTools වලට සමාන වුණත්, Quarkus එකේ මේක ගොඩක් වේගවත්.
පියවර 5: Native Executable එකක් Build කරමු
දැන් අපි බලමු Native Executable එකක් කොහොමද හදන්නේ කියලා. මේකට ඔයාලගේ System එකේ GraalVM Install කරලා Path එකට එකතු කරලා තියෙන්න ඕනේ. GraalVM Install කරන ආකාරය ගැන නිල වෙබ් අඩවියෙන් (graalvm.org) උපදෙස් ලබාගන්න පුළුවන්. ඒ වගේම, System එකේ Native Build Tools (GCC, glibc-devel වගේ) Install කරලා තියෙන්න ඕනේ.
./mvnw clean package -Dnative
මේ Command එක Run කළාම Build Process එකට ටික වෙලාවක් යයි (පරිගණකයේ Processor එක සහ Memory එක අනුව මිනිත්තු 2-10ක් වගේ). ඒකෙන් GraalVM Native Image Tool එක පාවිච්චි කරලා ඔයාලගේ Application එක සම්පූර්ණ Native Binary එකක් විදියට Compile කරනවා. Build එක ඉවර වුණාට පස්සේ, target/ ෆෝල්ඩර් එක ඇතුළේ quarkus-comparison-app-1.0.0-SNAPSHOT-runner (Windows නම් .exe) වගේ File එකක් හැදිලා තියෙයි. මේක තමයි අපේ Native Executable එක. මේ File එකේ Size එක බලන්න. සාමාන්‍ය Jar File එකකට වඩා ගොඩක් කුඩා වෙන්න පුළුවන්.
පියවර 6: Native Executable එක Run කරමු
දැන් මේ Native Executable එක Run කරන්න:
./target/quarkus-comparison-app-1.0.0-SNAPSHOT-runner
Startup Time එක බලන්න! ඒක Milliseconds ගාණක් වෙන්න ඕනේ. Spring Boot Jar එකක් Run කරනවට වඩා කීප ගුණයකින් වේගවත්. Console Output එකේදී Startup Time එක Milliseconds වලින් පෙන්නනවා. Task Manager (Windows) or top/htop (Linux/Mac) පාවිච්චි කරලා Memory Usage එකත් බලන්න. ඒකත් ගොඩක් අඩු වෙන්න ඕනේ. මේක තමයි Native Compilation එකේ Power එක!
අපේ අත්දැකීම: Spring Boot එකට වඩා Quarkus කොහොමද?
අපි මේ පොඩි Quarkus App එක හදලා, Dev Mode එකේ Run කරලා, Native Build එකක් හදලා Run කරපු වෙලාවේදී අපිට ගොඩක් දේවල් තේරුණා. අපි ඒක Spring Boot එකක් එක්ක සංසන්දනය කරමු. අපේ මේ අත්දැකීමෙන් පැහැදිලි වුණා Quarkus, Cloud Native Microservices Development වලදී කොච්චර ප්‍රයෝජනවත්ද කියලා.
- වේගය (Speed):Quarkus Dev Mode එකේ Startup Time එක පවා Spring Boot වලට වඩා වේගවත්. හැබැයි Native Build එකක් Run කරනකොට තියෙන Startup Speed එක පුදුම සහගතයි. Milliseconds ගාණකින් Application එක Ready වෙනවා. අපි දැක්කා වගේ 50-100ms වගේ කාලයකින් App එක Startup වෙනවා. මේක Serverless Environments වලට වගේම තත්පර ගාණක් ඇතුලත Scale වෙන්න ඕනේ Microservices වලට අතිශයින්ම වැදගත්. Auto-scaling වෙනකොට, අලුතින් Instances ඇවිත් request handle කරන්න පටන් ගන්න ගත වෙන වෙලාව ගොඩක් අඩු වෙනවා.
- Memory පරිභෝජනය (Memory Consumption):Native Quarkus App එකක Memory Usage එක JVM එකේ දුවන Spring Boot App එකකට වඩා සැලකිය යුතු ලෙස අඩුයි. අපේ පොඩි App එක 10-20MB වගේ Memory ප්‍රමාණයක් ගත්තේ. මේක Cloud Hosting වල Cost එක අඩු කරගන්න පුදුම විදියට උදව් වෙනවා. විශේෂයෙන්ම Kubernetes වගේ Container Orchestration Platforms වලදී, එකම Node එකක වැඩි Containers ප්‍රමාණයක් Deploy කරන්න පුළුවන් වෙනවා. මේකෙන් Infrastructure Cost එක අඩු කරගන්න පුළුවන්.
- Build Process එක (Build Process):Native Build එකට සාමාන්‍ය Jar Build එකට වඩා වැඩි කාලයක් යන එක පොඩි අඩුවක්. අපේ පොඩි Project එකට වුණත් මිනිත්තු කීපයක් ගියා. හැබැයි මේක Continuous Integration/Continuous Deployment (CI/CD) Pipeline එකකදී වුණත් Manage කරගන්න පුළුවන්. Pre-built Native Docker Images පාවිච්චි කරන එක, Multi-stage Dockerfiles පාවිච්චි කරන එක වගේ ක්‍රම වලින් මේ Build Time එකේ බලපෑම අඩු කරගන්න පුළුවන්. Deployment Artifact එක (Native Binary එක) ගොඩක් පොඩි නිසා Container Images ගොඩක් පොඩි වෙනවා. ඒක Docker Hub වගේ තැනකින් pull කරන්න ගත වෙන වෙලාව අඩු කරනවා.
- ඉගෙනීමේ වක්‍රය (Learning Curve):ඔයාලා දැනටමත් Spring Boot හරි වෙනත් Java Framework එකක් හරි පාවිච්චි කරනවා නම්, Quarkus වලට මාරු වෙන එක ලොකු අමාරු දෙයක් නෙමෙයි. Syntax සහ Annotations ටිකක් වෙනස් වුණත් (විශේෂයෙන් Jakarta EE APIs), Core Concepts බොහෝ දුරට සමානයි. JAX-RS (REST APIs), CDI (Dependency Injection), Hibernate ORM (Database access) වගේ Standard Java EE/Jakarta EE APIs පාවිච්චි කරන අයට Quarkus ගොඩක් හුරුපුරුදු වෙයි. Spring Boot වලට පුරුදු අයට මුලින් පොඩි වෙනසක් දැනුණත්, ඉක්මනින් adjust වෙන්න පුළුවන්.
- Trade-offs සහ සීමාවන් (Trade-offs and Limitations):Native Compilation වල වාසි ගොඩක් තිබුණත්, පොඩි Trade-offs ටිකකුත් තියෙනවා. සමහර Library සහ Reflection-heavy Code Native Image එකක් විදියට Build කරනකොට Issue එන්න පුළුවන්. ඒ වගේම Native Image එකක් Debug කරන එක සාමාන්‍ය JVM Application එකක් Debug කරනවට වඩා ටිකක් සංකීර්ණයි. හැබැයි Quarkus Community එක මේවාට විසඳුම් දෙනවා. Spring Boot වල තියෙන අති විශාල Libraries ප්‍රමාණය Quarkus වල නැති වුණත්, Core Technologies ගොඩක් Cover වෙනවා.
අවසාන වශයෙන්, Quarkus කියන්නේ Cloud Native World එකට නියම විසඳුමක්. සාම්ප්‍රදායික Monolithic Application එකකට Spring Boot තවමත් හොඳම තේරීම වෙන්න පුළුවන්. හැබැයි ඔයාලා අලුතින් Microservices හරි Serverless Functions හරි හදන්න යනවා නම්, විශේෂයෙන්ම Performance සහ Resource Consumption ගැන සැලකිලිමත් නම්, Quarkus ගැන දෙපාරක් හිතන්න ඕනේ නැහැ. අලුත් Projects වලට Quarkus එක්ක යන්න පසුබට වෙන්න එපා. අත්දැකීමෙන්ම ඔබට මේ වාසි තේරෙයි.
නිගමනය: තීරණය ඔයාගේ!
ඉතින් යාලුවනේ, අද අපි කතා කළේ Java Backend Development වලට අදාල Framework දෙකක් ගැන. මේ දෙකම අද Software Industry එකේ අතිශය ජනප්‍රියයි. Spring Boot කියන්නේ අවුරුදු ගාණක් තිස්සේ අපේ විශ්වාසය දිනාගත්තු, බලවත් Framework එකක්. විශාල Features ප්‍රමාණයක්, ඉතා දියුණු Ecosystem එකක් සහ දැවැන්ත Community එකක් තියෙන නිසා, සාම්ප්‍රදායික Enterprise Applications වලට, දැනට තියෙන Legacy Systems වලට සහ Rapid Feature Development අවශ්‍ය Projects වලට Spring Boot තවමත් නියම විසඳුමක්. ඒකේ Maturity එක සහ Stability එක කියන්නේ ඉතාමත් වටිනාකමක්.
Quarkus කියන්නේ අලුත්, වේගවත්, Cloud Native ලෝකයට ගැළපෙන විදියට හදපු Framework එකක්. Microservices, Serverless Functions, සහ Containerized Applications වලට තියෙන Demand එකත් එක්ක Quarkus වල වටිනාකම දිනෙන් දින වැඩි වෙනවා. විශේෂයෙන්ම Startup Time එක, Memory Footprint එක සහ Deployment Size එක අඩු කරගන්න අවශ්‍ය නම්, Quarkus කියන්නේ ගොඩක් හොඳ තේරීමක්. GraalVM Native Compilation කියන දේ Java ලෝකයේ ඉදිරි ගමනට අලුත් පිටිවහලක්.
මේ දෙකෙන්ම එකක් "හොඳයි" හෝ "නරකයි" කියලා කියන්න බැහැ. ඒක සම්පූර්ණයෙන්ම රඳා පවතින්නේ ඔයාලගේ Project එකේ අවශ්‍යතාවයන් මත, Deployment Environment එක මත, සහ ඔයාලගේ Team එකේ දැනුම මත. ඔයාලට දැනට තියෙන Legacy System එකක් Migrate කරන්න හරි, ඉක්මනින් Features ගොඩක් තියෙන Application එකක් හදන්න හරි ඕනේ නම් Spring Boot නියමයි. හැබැයි ඔයාලා අලුතින් Scalable, Resource-efficient Microservices හරි Serverless APIs හරි හදන්න යනවා නම්, විශේෂයෙන්ම Performance සහ Cloud Cost ගැන සැලකිලිමත් නම්, Quarkus ගැන අනිවාර්යෙන්ම බලන්න.
අපි මේ ලිපියේදී Quarkus App එකක් හදලා, ඒකේ Native Compilation එකේ Power එක බැලුවා. ඔයාලත් මේක Try කරලා බලන්න. ඔයාලාගේ Local Environment එකේදී වුණත් මේ Startup Speed එකේ සහ Memory Usage එකේ වෙනස පැහැදිලිවම තේරෙයි. ඔයාලට මොකද හිතෙන්නේ? Spring Boot ද? Quarkus ද? නැත්නම් මේ දෙකේම හොඳම දේවල් දෙක combine කරලා Hybrid Solution එකක්ද? ඔයාලගේ අත්දැකීම්, අදහස් පහළින් කොමෙන්ට් එකක් දාන්න අමතක කරන්න එපා. මේ වගේ තවත් අලුත් Tech ලිපි අරගෙන එනකන් හැමෝටම සුබ දවසක්! Tech Guide Sri Lanka එකත් එක්ක එකතු වෙලා ඉන්න!
