By Thisara Priyamal — 07 Aug 2025

MicroProfile Java Microservices | Sinhala Guide | ක්ලවුඩ් Native Java සංවර්ධනය

Java developersලාට microservices කියන architectural style එක අලුත් දෙයක් නෙවෙයි. නූතන distributed systems වලට, ඉක්මනින් scale කරන්න පුළුවන්, independent services හදන එක අද ප්‍රමිතියක් වෙලා. හැබැයි, enterprise-grade microservices develop කරනකොට, විශේෂයෙන්ම Java ecosystem එක ඇතුළේ, තවමත් අභියෝග ගොඩක් තියෙනවා. සාම්ප්‍රදායික Java EE (දැන් Jakarta EE) application servers, monolith applications වලට හොඳටම ගැළපුනත්, lightweight, fast-starting microservices වලට optimize වෙලා තිබ්බේ නැහැ. Microservices වලට අවශ්‍ය වෙන common features වන fault tolerance, metrics, health checks, externalized configuration වගේ දේවල් traditional Java EE වල built-in විදියට තිබ්බේ නැහැ. මෙන්න මේ අඩුව පුරවන්න, Java platform එක cloud-native era එකට අරගෙන එන්න හදපු සුපිරි tool එකක් තමයි Eclipse MicroProfile කියන්නේ.

මේ comprehensive tutorial එකෙන් අපි බලමු MicroProfile කියන්නේ මොකක්ද, ඇයි ඒක අද දවසෙත් Java microservices development වලට මෙතරම් වැදගත් වෙන්නේ, ඒකේ ප්‍රධාන APIs මොනවද කියලා. ඒ වගේම, සරල, ප්‍රායෝගික උදාහරණයක් එක්ක MicroProfile Config API එක පාවිච්චි කරලා කොහොමද external configuration manage කරන්නේ කියලත් අපි කතා කරමු. ඉතින්, ඔයා Java වලින් cloud-native microservices හදන්න ආසාවක් තියෙන, හෝ දැනටමත් microservices develop කරන developer කෙනෙක් නම්, මේක ඔයාගේ next step එක වෙන්න පුළුවන්. අපි පොඩ්ඩක්වත් වෙලාව නාස්ති නොකර, MicroProfile ලෝකයට කිමිදෙමු!

Eclipse MicroProfile කියන්නේ මොකක්ද?

Eclipse MicroProfile කියන්නේ Java enterprise microservices develop කරන්න හදපු open-source specification set එකක්. 2016 දී Oracle, IBM, Red Hat, Payara, Tomitribe වගේ Java community එකේ ප්‍රමුඛ සමාගම් ගණනාවක් එකතු වෙලා තමයි මේ initiative එක පටන් ගත්තේ. එයාලගේ ප්‍රධාන අරමුණ වුණේ, Java EE (දැන් Jakarta EE) ecosystem එකේ තිබුණු powerful features, microservices architectural style එකට හොඳටම ගැලපෙන විදියට, lightweight, modular, සහ cloud-native friendly කරන්න.

සාම්ප්‍රදායික Java EE application servers විශාලයි, startup වෙන්න වැඩි කාලයක් ගන්නවා, සහ memory footprint එක වැඩියි. මේවා microservices වල 'small and fast' කියන philosophy එකට ගැළපුනේ නැහැ. MicroProfile විසින් APIs ගොඩක් define කරනවා. මේවා භාවිතයෙන් developersලාට resilient, observable, සහ scalable microservices ඉක්මනින් හදන්න පුළුවන්. Simple විදියට කිව්වොත්, Java වලින් microservices හදනකොට මුහුණ දෙන පොදු අභියෝග වලට standard, lightweight විසඳුම් සපයන framework එකක් තමයි MicroProfile කියන්නේ. මේ specifications Java Community Process (JCP) එකේ කොටසක් නෙවෙයි. ඒ වෙනුවට, MicroProfile එක තමන්ගේම community-driven process එකක් හරහා evolve වෙනවා, මේ නිසා changes සහ updates ඉක්මනින් කරන්න පුළුවන්.

ඇයි අපි MicroProfile පාවිච්චි කරන්න ඕනේ?

ඇයි අපි අද දවසෙත් MicroProfile පාවිච්චි කරන්න ඕනේ? මේකට ප්‍රධාන සහ ශක්තිමත් හේතු කීපයක් තියෙනවා.

Cloud-Native Ready: MicroProfile design කරලා තියෙන්නේ cloud environments වලට හොඳටම ගැලපෙන්න. සාම්ප්‍රදායික Java EE servers වලට වඩා MicroProfile runtimes (උදා: Quarkus, Open Liberty, Helidon, Payara Micro) ඉතාම වේගවත් startup times සහ අඩු memory footprint එකක් පෙන්නුම් කරනවා. මේවා containerized deployments (Docker) සහ orchestration platforms (Kubernetes, OpenShift) එක්ක seamless විදියට වැඩ කරන්න පුළුවන් විදියට හදලා තියෙනවා. මේ නිසා, ඔයාගේ microservices cloud environment එකක efficient විදියට run කරන්න පුළුවන්.
Standardization සහ Vendor Independence: MicroProfile කියන්නේ standard API set එකක්. මේකේ ප්‍රතිඵලයක් විදියට, විවිධ vendorsලා අතරේ MicroProfile implementations තියෙනවා. (උදා: Open Liberty, Quarkus, Payara Micro, Helidon, WildFly). මේ standard එක නිසා, ඔයාගේ code එක එක් server එකක වැඩ කරනවා නම්, කිසිම වෙනසක් නැතුව තවත් MicroProfile compliant server එකකත් වැඩ කරනවා. මේක vendor lock-in වීම වළක්වා ගන්න ඉතාම වැදගත්. ඔයාට ඔයාගේ project එකට වඩාත්ම ගැළපෙන MicroProfile runtime එක තෝරා ගැනීමේ නිදහස ලැබෙනවා.
Increased Productivity: MicroProfile APIs ඉතාම සරලයි සහ use කරන්න පහසුයි. බොහොමයක් APIs වලට CDI (Contexts and Dependency Injection) support එක තියෙනවා. CDI කියන්නේ dependency injection, inversion of control වගේ concepts implement කරන්න උදව් වෙන Java EE standard එකක්. CDI එක්ක MicroProfile APIs පාවිච්චි කරනකොට, boilerplate code ලියන එක අඩු වෙනවා, code එක readable වෙනවා, සහ development process එක වේගවත් වෙනවා. Developersලාට business logic එකට වැඩි අවධානයක් දෙන්න පුළුවන්.
Built-in Resilience Features: Modern microservices වලට අත්‍යවශ්‍යම feature එකක් තමයි resilience. Distributed systems වලදී failures සාමාන්‍ය දෙයක්. මේ API එකෙන් failures වලට ඔරොත්තු දෙන විදියට microservices develop කරන්න අවශ්‍ය patterns සපයනවා. @Retry (අසාර්ථක වූ operations නැවත උත්සාහ කිරීම), @Fallback (error එකක් ආවොත් විකල්ප logic එකක් ක්‍රියාත්මක කිරීම), @Bulkhead (thread pool එකක් සීමා කරලා resource starvation වළක්වා ගැනීම), @CircuitBreaker (නිරන්තරයෙන් අසාර්ථක වන services වලට request යැවීම නතර කිරීම) වගේ ප්‍රබල annotations මේකේ තියෙනවා.
Enhanced Observability: Distributed microservices system එකක් monitoring සහ troubleshooting කරන එක හරිම අමාරු වැඩක්. MicroProfile මේකටත් විසඳුම් සපයනවා. MicroProfile Metrics API එකෙන් application එකේ performance metrics (CPU usage, memory, request response times, custom business metrics) expose කරන්න පුළුවන්. මේවා Prometheous, Grafana වගේ monitoring tools එක්ක integrate කරලා microservice එකේ run-time behavior එක visualize කරන්න සහ performance issues identify කරන්න පුළුවන්.

මේ හැමදේම එකතු වුණාම, MicroProfile කියන්නේ Java වලින් modern, cloud-native microservices develop කරන අයට නියම තෝරාගැනීමක්. ඒකෙන් Java platform එකේ බලය සහ enterprise features, microservices වලට අවශ්‍ය වේගය සහ agility එක්ක සමබර කරනවා.

ප්‍රධාන MicroProfile APIs

MicroProfile specification එක APIs ගොඩකින් හැදිලා තියෙනවා. ඒ හැම එකක්ම microservices development වලදී මතු වෙන specific challenge එකකට විසඳුමක් දෙනවා. අපි MicroProfile 6.x (නවතම අනුවාද) වල ප්‍රධාන APIs කීපයක් ගැන විස්තරාත්මකව බලමු:

MicroProfile Config: මේ API එකෙන් application එකේ configuration data manage කරන්න පුළුවන්. Database connection strings, API keys, feature toggles වගේ විවිධ environment වලට වෙනස් වෙන values පහසුවෙන් maintain කරන්න මේක උදව් වෙනවා. Config API එකේ ප්‍රධාන වාසිය තමයි configuration values different sources (environment variables, system properties, config files, custom ConfigSources) වලින් load කරන්න පුළුවන් වීම සහ ඒවාට priority order එකක් තියෙන එක. මේකෙන් deployment වලදී configuration වෙනස් කිරීම හරිම පහසු වෙනවා.
MicroProfile Health: Microservice එකේ Health status එක report කරන්න මේ API එක use කරනවා. Microservice එක active සහ වැඩ කරන්න පුළුවන් තත්ත්වයකද තියෙන්නේ කියලා බාහිර systems (උදා: Kubernetes liveness/readiness probes) වලට දැනගන්න මේක වැදගත්. සාමාන්‍යයෙන් /health/live (liveness check) සහ /health/ready (readiness check) වගේ endpoints දෙකක් expose කරනවා. Database connection, external API availability වගේ දේවල් මේවායින් check කරන්න පුළුවන්.
MicroProfile Metrics: Application එකේ performance metrics expose කරන්න මේ API එක use කරනවා. Gauges, Counters, Meters, Timers, Histogram වගේ විවිධ metric types මේකෙන් support කරනවා. Developersලාට custom business metrics expose කරන්නත් පුළුවන්. මේ metrics Prometheous, Grafana වගේ monitoring tools එක්ක integrate කරලා microservice එකේ run-time behavior එක visualize කරන්න සහ performance issues identify කරන්න පුළුවන්.
MicroProfile Fault Tolerance: Resilient microservices develop කරන්න උපකාරී වෙනවා. Distributed systems වලදී failures සාමාන්‍ය දෙයක්. මේ API එකෙන් failures වලට ඔරොත්තු දෙන විදියට microservices develop කරන්න අවශ්‍ය patterns සපයනවා. @Retry (අසාර්ථක වූ operations නැවත උත්සාහ කිරීම), @Fallback (error එකක් ආවොත් විකල්ප logic එකක් ක්‍රියාත්මක කිරීම), @Bulkhead (thread pool එකක් සීමා කරලා resource starvation වළක්වා ගැනීම), @CircuitBreaker (නිරන්තරයෙන් අසාර්ථක වන services වලට request යැවීම නතර කිරීම) වගේ ප්‍රබල annotations මේකේ තියෙනවා.
MicroProfile JWT (JSON Web Token) Auth: Microservices අතර secure communication වලට JWTs use කරන්න support එක දෙනවා. API එකට එන requests authenticate සහ authorize කරන්න මේක වැදගත්. JWT-Auth API එක OpenID Connect සහ OAuth2 flow වලට අනුකූලව වැඩ කරනවා.
MicroProfile REST Client: Type-safe REST clients develop කරන්න පහසුකම් සලසනවා. External REST APIs consume කරන එක මේකෙන් සරල වෙනවා. Java interface එකක් defines කරලා, @Path, @GET, @POST වගේ JAX-RS annotations පාවිච්චි කරලා, MicroProfile REST Client එකෙන් ඒ interface එකට implementation එකක් automatically generate කරනවා. මේක Feign, Retrofit වගේ clients වලට සමානයි.

මේ APIs වලට අමතරව තවත් Contexts and Dependency Injection (CDI), JAX-RS, JSON-B (JSON Binding) වගේ Jakarta EE APIs ගණනාවක් MicroProfile base specification එකට ඇතුලත් වෙනවා. මේවා Java microservices වලට අත්‍යවශ්‍යම base technologies.

සරල MicroProfile උදාහරණයක් (MicroProfile Config)

දැන් අපි බලමු MicroProfile එකේ Config API එක පාවිච්චි කරලා කොහොමද සරල උදාහරණයක් හදන්නේ කියලා. මේකෙන් ඔයාට MicroProfile එකේ ease-of-use එක ගැන හොඳ අවබෝධයක් ලැබෙයි. අපි හිතමු අපේ microservice එකට greeting message එකක් load කරගන්න ඕනේ කියලා. මේ message එක environment එක අනුව වෙනස් වෙන්න පුළුවන්, ඒ නිසා අපි ඒක configuration එකක් විදියට manage කරනවා.

මුලින්ම, ඔයාගේ project එක MicroProfile-compatible runtime එකක් (Quarkus, Open Liberty, Helidon, Payara Micro වැනි) මත set up කරගන්න ඕනේ. මේ සඳහා Quickstart guides හෝ Maven archetypes පාවිච්චි කරන්න පුළුවන්. අපි මෙහිදී microprofile-config-api dependency එක direct add කරගන්නා ආකාරය දක්වමු.

පහත pom.xml එකේ MicroProfile Config API dependency එක එකතු කරන්න. (ඔබ Quarkus හෝ Open Liberty වැනි framework එකක් භාවිතා කරන්නේ නම්, බොහෝ විට මෙය ස්වයංක්‍රීයව එක්විය හැක).

<dependency>
    <groupId>org.eclipse.microprofile.config</groupId>
    <artifactId>microprofile-config-api</artifactId>
    <version>3.0</version> <!-- නවතම version එක භාවිතා කරන්න -->
    <scope>provided</scope> <!-- Runtime එක මඟින් implementation එක සැපයෙන නිසා 'provided' භාවිතා කරන්න -->
</dependency>

ඊළඟට, අපේ MicroProfile application එකේ GreetingResource.java වගේ class එකක් හදමු. මේක RESTful endpoint එකක් ලෙස JAX-RS annotations යොදා ගනිමු:

package com.example.microprofile;

import jakarta.enterprise.context.ApplicationScoped;
import jakarta.ws.rs.GET;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.Produces;
import jakarta.ws.rs.core.MediaType;
import org.eclipse.microprofile.config.inject.ConfigProperty;

@Path("/hello") // This resource will be accessible at /hello
@ApplicationScoped // Makes this a CDI managed bean, visible to MicroProfile
public class GreetingResource {

    // Inject a configuration property named 'greeting.message'
    // If the property is not found, "Hello MicroProfile Developers!" will be used as default.
    @ConfigProperty(name = "greeting.message", defaultValue = "Hello MicroProfile Developers!")
    String message;

    @GET // This method handles HTTP GET requests
    @Produces(MediaType.TEXT_PLAIN) // The method will produce plain text output
    public String hello() {
        return "Configured Message: " + message;
    }

    // You can also inject a specific Config object to access multiple properties
    // @Inject
    // Config config;
    //
    // public String getAnotherProperty() {
    //     return config.getValue("another.property", String.class);
    // }
}

දැන්, අපේ configuration property එක define කරමු. MicroProfile Config specification එකට අනුව, src/main/resources/META-INF/microprofile-config.properties කියන file එක හදලා මේ content එක දාන්න:

greeting.message=ආයුබෝවන්, MicroProfile ලෝකයට! ඔබ සාදරයෙන් පිළිගනිමු!
application.name=MyAwesomeMicroservice
database.url=jdbc:postgresql://localhost:5432/myapp

මේ microprofile-config.properties file එකේ greeting.message කියන property එකේ අගය අපි defin කළා. defaultValue එකක් තිබුණත්, file එකේ අගයක් තිබුණොත්, ඒක override වෙනවා.

Configuration Precedence (ප්‍රමුඛතාව):

MicroProfile Config API එකේ තියෙන ලොකුම වාසියක් තමයි configuration sources වලට තියෙන ප්‍රමුඛතාව.

සාමාන්‍යයෙන්, මේ විදියට තමයි අගයන් load වෙන්නේ (ඉහළින්ම තියෙන එකට වැඩිම ප්‍රමුඛතාව):

System properties (Java command line -Dkey=value)
Environment variables (KEY=value)
META-INF/microprofile-config.properties files (classpath එකේ තියෙන හැම එකක්ම)
Custom ConfigSource implementations (ඔබට අවශ්‍ය නම් හදාගන්න පුළුවන්)

ඒ කියන්නේ, ඔයා microprofile-config.properties file එකේ greeting.message එකක් දාලා තිබුණත්, application එක run කරනකොට command line එකෙන් -Dgreeting.message="Hello from Command Line!" කියලා දුන්නොත්, command line value එක තමයි load වෙන්නේ. ඒ වගේම, environment variable එකක් විදියට GREETING_MESSAGE="Hello from Env Var!" කියලා දුන්නොත්, ඒක තමයි highest precedence එක වෙන්නේ (environment variables uppercase කරලා, dots . underscores _ බවට පත් කරනවා).

Application එක Run කිරීම:

දැන් ඔයාගේ MicroProfile server එක (උදා: Open Liberty, Quarkus, Payara Micro) run කරලා /hello endpoint එකට request එකක් යැව්වොත් (curl http://localhost:8080/hello හෝ web browser එකක් හරහා), ඔයාට "Configured Message: ආයුබෝවන්, MicroProfile ලෝකයට! ඔබ සාදරයෙන් පිළිගනිමු!" කියලා output එක ලැබෙයි.

මේ උදාහරණයෙන් පේනවා ඇති, MicroProfile Config API එක කොච්චර සරලද කියලා. @ConfigProperty annotation එක විතරක් පාවිච්චි කරලා, application එකට අවශ්‍ය configuration values inject කරගන්න පුළුවන්. මේකෙන් code එක clean වෙනවා වගේම, deployment වලදී configuration වෙනස් කිරීමත් පහසු වෙනවා, code changes නැතුවම. මේක modern cloud-native applications වලට අත්‍යවශ්‍යම feature එකක්.

නිගමනය (Conclusion)

ඉතින්, අපි මේ comprehensive tutorial එකෙන් Eclipse MicroProfile කියන්නේ මොකක්ද, ඇයි ඒක Java microservices develop කරන්න වැදගත් වෙන්නේ, ඒකේ ප්‍රධාන APIs මොනවද, සහ සරල, ප්‍රායෝගික උදාහරණයක් එක්ක කොහොමද MicroProfile Config API එක පාවිච්චි කරන්නේ කියලා විස්තරාත්මකව බැලුවා. MicroProfile කියන්නේ Java developersලාට cloud-native applications develop කරන්න නියම platform එකක්. ඒකෙන් standardisation, resilience, scalability, සහ observability වගේ දේවල් built-in විදියටම දෙන නිසා, ඔයාට business logic එකට වැඩි අවධානයක් දෙන්න පුළුවන්. මේක Java ecosystem එක microservices යුගයට සාර්ථකව පිවිසීමට ලොකු දායකත්වයක් සපයනවා.

මේක ඔයාගේ Java microservices journey එකේ ආරම්භය වෙන්න පුළුවන්. MicroProfile APIs තව ගොඩක් තියෙනවා explore කරන්න. Health, Metrics, Fault Tolerance, REST Client වගේ APIs ගැන තවදුරටත් ඉගෙන ගන්න එකෙන් ඔයාගේ microservices වලට විශාල වටිනාකමක් එකතු වෙයි. අදම මේක ඔයාගේ project එකක try කරලා බලන්න. විශේෂයෙන්ම Quarkus, Open Liberty, Helidon වගේ MicroProfile-compliant runtimes භාවිතයෙන් development process එක කෙතරම් පහසුද කියලා අත්විඳින්න.

ඔයාගේ අත්දැකීම් කොහොමද? MicroProfile පාවිච්චි කරලා ඔයා මොනවද develop කළේ? පහළින් comment එකක් දාලා අපිට කියන්න. MicroProfile ගැන තව මොනවාද දැනගන්න ඕනේ කියලත් අනිවාර්යෙන්ම සඳහන් කරන්න! අපි හැමෝටම එකතු වෙලා Java ecosystem එකේ අලුත් දේවල් ඉගෙන ගනිමු!