Spring Boot vs Micronaut Performance SC Guide

කොහොමද යාලුවනේ? ඔයාලා හැමෝටම සුභ දවසක්! ඩිවලොප්මන්ට් ලෝකේ දවසින් දවස අලුත් දේවල් එනවා කියලා ඔයාලා දන්නවනේ. අද අපි කතා කරන්න යන්නේ මේ දවස්වල හොඳටම කතාබහට ලක්වෙන Java ෆ්‍රේම්වර්ක් දෙකක් ගැන: ඒ තමයි අපේ ගොඩක් අය ආදරේ කරන Spring Boot එකයි, අලුතින් ආපු හැබැයි වේගයෙන්ම ඉස්සරහට එන Micronaut එකයි.

අද කාලේ හැමෝම යන්නේ Microservices පැත්තට. ඒ වගේම Serverless Functions, Cloud Native apps වගේ දේවල් නිසා අපිට පුළුවන් තරම් ඉක්මනින් වැඩ පටන් ගන්න පුළුවන්, memory අඩුවෙන් පාවිච්චි කරන ෆ්‍රේම්වර්ක් ඕන වෙනවා. මේ නිසා තමයි Spring Boot වලට වඩා වේගවත්, memory අඩුවෙන් පාවිච්චි කරන විකල්ප හොයන්න පටන් ගත්තේ. Micronaut කියන්නේ ඒ වගේ අරමුණකින්ම හදපු ෆ්‍රේම්වර්ක් එකක්.

ඉතින් අද අපි බලමු මේ දෙන්නා අතරේ තියෙන වෙනස්කම් මොනවද කියලා. විශේෂයෙන්ම Startup Time (ඇප් එක පටන් ගන්න ගන්න වෙලාව) සහ Memory Consumption (පාවිච්චි කරන මතක ප්‍රමාණය) ගැන අවධානය යොමු කරමු. ඒ වගේම, පොඩි Spring Boot ඇප් එකක් Micronaut වලට Port කරගන්නේ කොහොමද කියලත් බලමු. සූදානම්ද? එහෙනම් පටන් ගමු!

මොකක්ද මේ Spring Boot කියන්නේ? (What is Spring Boot?)

Java ඩිවලොපර්ස්ලා අතරේ ගොඩක්ම ජනප්‍රිය වෙච්ච, විශ්වාසදායක ෆ්‍රේම්වර්ක් එකක් තමයි Spring Boot කියන්නේ. ඒකට ප්‍රධානම හේතුව තමයි, Spring Framework එකේ සංකීර්ණ දේවල් සරල කරලා, "Convention over Configuration" කියන සංකල්පයත් එක්ක ඉක්මනටම Production Ready ඇප්ලිකේෂන්ස් හදන්න පුළුවන් වෙන එක. Spring Data, Spring Security, Spring Cloud වගේ Spring Ecosystem එකේම කොටස් එක්ක ඉතාම හොඳින් වැඩ කරන නිසා, ඕනෑම වගේ ව්‍යාපෘතියකට (Enterprise Applications, Web Apps, APIs) Spring Boot එක ගැළපෙනවා.

Spring Boot වල වාසි:

• ඉක්මන් ඩිවලොප්මන්ට්: Boilerplate code අඩුයි. Auto-configuration නිසා ගොඩක් දේවල් තනියම සෙට් වෙනවා.
• විශාල Ecosystem එකක්: Spring Framework එකේ තියෙන හැම මොඩියුල් එකක්ම වගේ Spring Boot එක්ක පාවිච්චි කරන්න පුළුවන්. Community support එකත් වැඩියි.
• සම්පූර්ණ විසඳුමක්: Embeddable servers (Tomcat, Jetty, Undertow) වගේ දේවල් ඇතුලත් නිසා, JAR file එකක් විදියට ඇප් එක deploy කරන්න පුළුවන්.

Spring Boot වල අභියෝග:

• Startup Time එක සහ Memory Consumption: Spring Boot ඇප් එකක් පටන් ගන්න ටිකක් වෙලා යනවා. ඒ වගේම memoryත් ටිකක් වැඩියෙන් පාවිච්චි කරනවා. මොකද, මේක runtime එකේදී dependency injection වගේ ගොඩක් දේවල් කරන නිසා.
• Fat JARs: ඇප් එකේ JAR file එක ලොකු වෙන්න පුළුවන්. Serverless environment වලට නම් මේක පොඩි ගැටළුවක් වෙන්න පුළුවන්.

මේ අභියෝග නිසා තමයි, විශේෂයෙන්ම Microservices සහ Serverless වගේ දේවල් වලට, memory අඩුවෙන් පාවිච්චි කරන, ඉක්මනින් පටන් ගන්න පුළුවන් විකල්ප හොයන්න සිද්ධ වුණේ.

Micronaut: අලුත් කොල්ලාද? (Micronaut: The New Kid?)

Micronaut කියන්නේ JVM එක මත හදපු තවත් නවීන ෆ්‍රේම්වර්ක් එකක්. මේක නිර්මාණය කරලා තියෙන්නේ Spring Boot වල තියෙන Startup Time සහ Memory Consumption ගැටලු වලට විසඳුම් දෙන්න. Micronaut වල ප්‍රධානම වෙනස තමයි, මේක Ahead-Of-Time (AOT) compilation සහ compile-time dependency injection භාවිතා කරන එක.

ඒ කියන්නේ, ඇප් එක compile කරන වෙලාවේදීම අවශ්‍ය Dependency Injection සහ Aspect-Oriented Programming (AOP) වගේ දේවල් code එකට add කරනවා. Spring Boot වල වගේ runtime එකේදී මේ දේවල් කරන්නේ නැහැ. මේ නිසා ඇප් එක start වෙන වෙලාවේදී කරන්න තියෙන වැඩ ගොඩක් අඩු වෙනවා. ඒක නිසා Startup Time එකයි, Memory Consumption එකයි දෙකම සැලකිය යුතු විදියට අඩු වෙනවා.

Micronaut වල වාසි:

• සුපිරි වේගවත් Startup Time එකක්: මේක Micronaut වල ලොකුම වාසියක්. Serverless environment වලට මේක ඉතාම වැදගත්.
• අඩු Memory Consumption: Micronaut ඇප් එකක් run කරන්න අවශ්‍ය memory ප්‍රමාණය Spring Boot වලට වඩා ගොඩක් අඩුයි.
• Cloud Native Ready: Micronaut හදලම තියෙන්නේ Microservices, Serverless සහ Cloud Native Applications වලට ගැළපෙන්න.
• GraalVM Support: Micronaut GraalVM Native Image එක්ක ඉතාම හොඳින් වැඩ කරනවා. ඒකෙන් ඇප් එක තවත් වේගවත් කරගන්න පුළුවන්.

Micronaut වල අභියෝග:

• තරමක් කුඩා Ecosystem එකක්: Spring Boot වගේ ලොකු Ecosystem එකක් සහ community support එකක් Micronaut වලට තවම නැහැ. හැබැයි මේක වේගයෙන් වර්ධනය වෙනවා.
• ඉගෙන ගන්න ටිකක් වෙලා යයි: Spring Boot වලට පුරුදු වෙච්ච කෙනෙක්ට Micronaut වල සංකල්ප ටිකක් වෙනස් වෙන්න පුළුවන්.

කාගේද වේගය වැඩි? (Startup Time & Memory Comparison)

හරි, දැන් අපි බලමු මේ දෙන්නා අතරේ performance wise මොන වගේ වෙනස්කම්ද තියෙන්නේ කියලා. මේක අපි පොඩි practical test එකක් වගේ හිතමු. සරල REST API එකක් (Controller එකක් විතරක් තියෙන) Spring Boot සහ Micronaut වලින් හදලා ඒවා run කරලා බලමු.

Startup Time (ආරම්භක කාලය):

සාමාන්‍යයෙන්, Spring Boot ඇප් එකක Startup Time එක තත්පර 2-5ක් වගේ වෙන්න පුළුවන් (application එකේ complexity එක අනුව). හැබැයි Micronaut ඇප් එකක Startup Time එක මිලි තත්පර ගණන් වෙන්න පුළුවන්, සමහර විට තත්පරයකටත් වඩා අඩු වෙන්න පුළුවන්. මේ වෙනස ඇති වෙන්නේ ප්‍රධාන වශයෙන්ම Micronaut වල තියෙන Compile-Time Dependency Injection නිසා. Spring Boot runtime එකේදී classpath එක scan කරලා beans register කරන නිසා තමයි වැඩි වෙලාවක් යන්නේ.

උදාහරණයක් විදියට, "Hello World" REST API එකක් සඳහා:

• Spring Boot: ~2000ms - 3000ms (පළවෙනි වතාවට run කරනකොට)
• Micronaut: ~150ms - 300ms

මේක බොහොම සරල උදාහරණයක්. ඇප් එකේ dependencies වැඩි වෙනකොට මේ වෙනස තවත් හොඳට පේනවා.

Memory Consumption (මතක පරිභෝජනය):

Memory Usage එකත් Micronaut වල ලොකු වාසියක්. Spring Boot ඇප් එකකට සාමාන්‍යයෙන් 100MB-200MB+ වගේ memory ප්‍රමාණයක් අවශ්‍ය වෙන්න පුළුවන් (idle state එකේදී). Micronaut ඇප් එකකට නම් 20MB-50MB වගේ ප්‍රමාණයකින් වැඩේ කරගන්න පුළුවන්. Microservices deployment වලදී, එක server එකක services ගොඩක් run කරනකොට මේ memory saving එක ඉතාම වැදගත් වෙනවා.

මේ වෙනස්කම් වෙන්නේ, Micronaut අවශ්‍ය දේවල් විතරක් load කරන, Reflection based code generation භාවිතා නොකරන නිසා. Spring Boot වල Reflection භාවිතා වෙනවා, ඒ නිසා runtime එකේදී ගොඩක් දේවල් කරන්න සිද්ධ වෙනවා, ඒකට වැඩි memory එකක් අවශ්‍ය වෙනවා.

මේ ප්‍රස්ථාරයකින් පෙන්නුවොත් මේ වෙනස හොඳටම පැහැදිලි වෙයි:

| Feature            | Spring Boot          | Micronaut           |
|--------------------|----------------------|---------------------|
| Startup Time       | Slower (seconds)     | Faster (ms)         |
| Memory Usage (idle)| Higher (100MB-200MB+)| Lower (20MB-50MB)   |
| DI                 | Runtime Reflection   | Compile-Time AOT    |
| Ecosystem          | Mature, Large        | Growing             |
| Best For           | Enterprise, Monoliths| Microservices, Serverless |

මේ දත්ත වලින් පේනවා, Micronaut, performance පැත්තෙන් Spring Boot වලට වඩා පැහැදිලි වාසියක් අරගෙන තියෙනවා කියලා. විශේෂයෙන්ම resource-constrained environments වලට (Containerized deployments, Serverless platforms) Micronaut ඉතාම හොඳ තේරීමක්.

Spring Boot App එකක් Micronaut වලට Port කරමු (Porting a Spring Boot App to Micronaut)

දැන් අපි බලමු, පොඩි Spring Boot REST API එකක් Micronaut වලට Port කරන්නේ කොහොමද කියලා. මේකෙන් ඔයාලට මේ ෆ්‍රේම්වර්ක් දෙක අතරේ තියෙන code-level වෙනස්කම් හොඳට තේරෙයි.

මුලින්ම අපි Spring Boot වලින් පොඩි "Hello World" API එකක් හදමු.

Spring Boot Code Example:

// src/main/java/com/example/demo/HelloController.java
package com.example.demo;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

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

// src/main/java/com/example/demo/DemoApplication.java
package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

මේක සාමාන්‍ය Spring Boot REST API එකක්. දැන් මේකම Micronaut වලට Port කරගමු. Micronaut වලට RestController වෙනුවට Controller සහ GetMapping වෙනුවට Get වගේ annotations පාවිච්චි වෙනවා. ඒ වගේම SpringApplication.run() වෙනුවට Micronaut.run() පාවිච්චි වෙනවා.

Micronaut Code Example (Ported from Spring Boot):

// src/main/java/com/example/HelloController.java
package com.example;

import io.micronaut.http.annotation.Controller;
import io.micronaut.http.annotation.Get;
import io.micronaut.http.HttpStatus;

@Controller("/hello") // Base path for all methods in this controller
public class HelloController {

    @Get // Maps to GET /hello
    public String index() {
        return "Hello from Micronaut!";
    }
}

// src/main/java/com/example/Application.java
package com.example;

import io.micronaut.runtime.Micronaut;

public class Application {

    public static void main(String[] args) {
        Micronaut.run(Application.class, args);
    }
}

පේනවනේ, code එකේ ලොකු වෙනසක් නැහැ. package name එක, imports, සහ annotations ටිකක් වෙනස් වෙනවා විතරයි. නමුත් මේ පොඩි වෙනස්කම් වලින් backend එකේ ලොකු performance වෙනස්කම් ඇති වෙනවා. Project setup එකත් වෙනස්. Micronaut Project එකක් Create කරන්න Micronaut CLI එක පාවිච්චි කරන්න පුළුවන්:

mn create-app my-micronaut-app --features=graalvm

මේකෙන් Gradle හෝ Maven project එකක් හදාගන්න පුළුවන්. Spring Boot වලට වඩා Micronaut වල Build tool එකේ Dependency configuration ටිකක් වෙනස් වෙන්න පුළුවන්, හැබැයි පොදු සංකල්ප සමානයි.

මේ විදියට පොඩි ඇප් එකක් Port කරන එක එච්චර අමාරු නැහැ. හැබැයි Dependency Injection Patterns, Configuration, Data Access වගේ තව දේවල් Spring Boot වලට වඩා Micronaut වල වෙනස් විදියට කරන්න පුළුවන්. නමුත් මූලික සංකල්ප තේරුම් ගත්තොත් ඉක්මනින්ම පුරුදු වෙන්න පුළුවන්.

ඉතින්, මොකක්ද තෝරගන්නේ? (So, What to Choose?)

දැන් ඔයාලා හිතනවා ඇති, "මේ දෙකෙන් මොකක්ද මට හොඳ?" කියලා. ඒකට උත්තරේ තියෙන්නේ ඔයාලගේ project එකේ අවශ්‍යතා මත. එක ෆ්‍රේම්වර්ක් එකක් හැමවෙලේම හැමදේටම හොඳ නැහැ.

Spring Boot තෝරගන්න ඕන වෙලාවට:

• ඔයාලා Enterprise-level විශාල application එකක් හදනවා නම්.
• විශාල developer community support එකක් සහ mature ecosystem එකක් අවශ්‍ය නම්.
• Development speed එක සහ existing Spring knowledge එක ප්‍රයෝජනයට ගන්න ඕන නම්.
• Startup time එක සහ memory consumption එක එතරම් critical නැති නම් (උදා: batch processing applications, traditional web apps).
• Monolithic architecture එකක් හදනවා නම්.

Micronaut තෝරගන්න ඕන වෙලාවට:

• Microservices architectures හදනවා නම්.
• Serverless functions (AWS Lambda, Azure Functions) වගේ දේවල් වලට deploy කරනවා නම්.
• ඉතාම අඩු Startup time එකක් සහ memory consumption එකක් අවශ්‍ය නම්.
• Cloud Native applications හදනවා නම්.
• JVM එකේදී Native Executables (GraalVM) හදන්න අවශ්‍ය නම්.
• JVM ecosystem එකේ performance critical services හදනවා නම්.

සරලව කියනවා නම්, ඔයාලා වේගය සහ efficiency එක ගැන වැඩිපුර හිතනවා නම්, Micronaut එක හොඳ තේරීමක්. Spring Boot එක තෝරගන්න පුළුවන් project එකේ stability, ecosystem එක සහ development speed එක ප්‍රමුඛ නම්.

අවසන් වශයෙන්...

ඉතින් යාලුවනේ, අද අපි Spring Boot සහ Micronaut කියන මේ ෆ්‍රේම්වර්ක් දෙක හොඳින්ම බැලුවා. මේ දෙකම Java ඩිවලොපර්ස්ලාට ඉතාම වටිනා මෙවලම්. Micronaut අලුත් වුණාට, Microservices සහ Cloud Native ලෝකයේ තියෙන අභියෝග වලට ඉතාම හොඳ විසඳුම් සපයනවා. Spring Boot තවමත් Java ලෝකයේ රජු වගේ ඉන්නවා, ඒකේ තියෙන maturity එකයි, විශාල ecosystem එකයි නිසා.

මගේ උපදෙස තමයි, දෙකම ඉගෙන ගන්න එක. ඔයාලගේ project එකේ අවශ්‍යතා අනුව, ඒ වෙලාවට වඩාත්ම ගැළපෙන එක තෝරගන්න එක තමයි නුවණට හුරු. Micronaut වල මේ performance advantages ගැන දැනගත්තට පස්සේ, ඔයාලටත් හිතුණාද පොඩි Micronaut ඇප් එකක් හදලා බලන්න? නැත්නම් දැනටමත් පාවිච්චි කරන Spring Boot ඇප් එකක් Micronaut වලට Port කරන්න හිතුණාද?

ඔයාලා මේ ගැන හිතන්නේ කොහොමද කියලා කමෙන්ට් සෙක්ෂන් එකේ කියන්න. Micronaut පාවිච්චි කරලා තියෙනවා නම් ඔයාලගේ අත්දැකීම් බෙදා ගන්න. ප්‍රශ්න තියෙනවා නම් අහන්න. අපි ඊළඟ ලිපියකින් නැවත හමුවෙමු! හැමෝටම සුභ දවසක්!