Spring Boot වේගවත් කරමු | Performance Tuning Tips SC Guide

ආයුබෝවන්! Spring Boot ඇප් එක ස්ලෝද?

මචන්ලා, ඔයාලා Spring Boot use කරලා application එකක් develop කරලා deploy කරාට පස්සේ, client ලාගෙන් එන ප්‍රධානම complaint එකක් තමයි “ඇප් එක මාර ස්ලෝ බං! මේක ටිකක් වේගවත් කරන්න බැරිද?” කියන එක. සමහරවිට servers වල memory usage එක වැඩි වෙලා, CPU usage එක වැඩි වෙලා server bills වැඩි වෙන එකත් ලොකු ප්‍රශ්නයක් වෙන්න පුළුවන්. මේ හැම ප්‍රශ්නයකටම උත්තරේ තියෙන්නේ “Performance Tuning” කියන concept එක ඇතුළේ. අද අපි කතා කරමු Spring Boot application එකක Performance කොහොමද improve කරගන්නේ කියලා.

Performance Tuning කියන්නේ application එකක් හොඳට වැඩ කරන එක විතරක් නෙවෙයි. ඒකෙන් application එකේ user experience එක improve වෙනවා වගේම, infrastructure costs අඩු කරගන්නත් පුළුවන් වෙනවා. අද වෙළඳපොලේ තියෙන තරඟකාරීත්වයත් එක්ක, අපේ application එක ඉක්මන් නැත්නම්, users ලා ඉක්මනින්ම වෙන තැනකට යනවා. ඉතින්, මේක මාරම වැදගත් දෙයක්.

වෙලාව නාස්ති නොකර කෙලින්ම වැඩේට බහිමු!

1. මූලිකම දේවල් - "Performance" කියන්නේ මොකක්ද?

“Performance” කියන්නේ මොකක්ද කියලා අපි මුලින්ම තේරුම් ගමු. ගොඩක් අය හිතන්නේ Performance කියන්නේ “ඇප් එක වේගවත්” වෙන එක විතරයි කියලා. ඒත් ඒක එච්චර සරල දෙයක් නෙවෙයි. මේකෙදි ප්‍රධානම දේවල් කිහිපයක් තියෙනවා:

• Latency (ප්‍රමාදය): Request එකක් server එකට ගිහින්, response එකක් එන්න ගතවන කාලය. මේක අඩු වෙන්න අඩු වෙන්න ඇප් එක user ට දැනෙන්නේ වේගවත්ව.
• Throughput (නිමැවුම් ධාරිතාව): යම්කිසි වෙලාවක් ඇතුළත server එකකට handle කරන්න පුළුවන් requests ප්‍රමාණය. වැඩි Throughput එකක් කියන්නේ එකම වෙලාවේ requests ගොඩක් handle කරන්න පුළුවන් කියන එක.
• Resource Utilization (සම්පත් භාවිතය): application එක CPU, Memory, Disk I/O, Network වගේ server resources කොච්චර කාර්යක්ෂමව use කරනවද කියන එක. අනවශ්‍ය විදියට resources use කරනවා නම්, server bills වැඩි වෙනවා වගේම, system එක slow වෙන්නත් පුළුවන්.

ඉතින්, Performance Tuning කියන්නේ මේ දේවල් තුනම improve කරන එක.

2. ඇප් එක නාස්ති කරන තැන් හොයාගමු - Profiling Tools

Performance Tuning කරන්න කලින්, ප්‍රශ්නේ තියෙන්නේ කොහෙද කියලා දැනගන්න එක ගොඩක් වැදගත්. අපි මේකට use කරනවා Profiling Tools.

2.1. Spring Boot Actuator

Spring Boot application එකක performance metrics බලන්න තියෙන basic ම tool එක තමයි Spring Boot Actuator. මේකෙන් application health, metrics, environment details වගේ දේවල් බලන්න පුළුවන්.

ඔයාගේ pom.xml එකට මේ dependency එක add කරගන්න:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

ඊට පස්සේ application.properties එකේ මේක දාන්න:

management.endpoints.web.exposure.include=*

දැන් ඔයාට /actuator/metrics, /actuator/health වගේ endpoints වලින් data බලාගන්න පුළුවන්. මේකෙන් ඔයාගේ application එකේ HTTP requests, JVM memory usage වගේ දේවල් බලාගන්න පුළුවන්.

2.2. JVisualVM / Java Mission Control (JMC)

මේවා JVM (Java Virtual Machine) එකට attach වෙලා application එකේ CPU usage, Memory consumption, Thread activity, Garbage Collection වගේ දේවල් real-time බලන්න පුළුවන් free tools. මේවා Java Development Kit (JDK) එකත් එක්කම එනවා.

• JVisualVM: මේකෙන් memory leaks, thread deadlocks වගේ දේවල් හොයාගන්න ලේසියි. CPU samples අරගෙන application එකේ slow වෙන්නේ මොන methods ද කියලා identify කරන්නත් පුළුවන්.
• Java Mission Control (JMC): මේක JVisualVM ට වඩා advanced. Flight Recorder වගේ features තියෙනවා. මේකෙන් production environment එකක දී පවා application එකේ හැසිරීම බලන්න පුළුවන්, performance impact එකක් නැතුවම.

මේ tools වලින් ලැබෙන data analysis කරලා, performance bottleneck එක තියෙන්නේ කොහෙද කියලා හරියටම අඳුරගන්න පුළුවන්.

2.3. Distributed Tracing (e.g., Zipkin, Jaeger)

Microservices architecture එකකදී request එකක් services කිහිපයක් හරහා යනවා. මේ වගේ වෙලාවක request එකක් slow වෙන්නේ මොන service එකේදීද කියලා හොයාගන්න Distributed Tracing tools උදව් වෙනවා. Spring Cloud Sleuth use කරලා Zipkin වගේ tools එක්ක integrate කරන්න පුළුවන්.

3. ඇප් එක හදාගමු - Optimization Strategies

bottleneck එක හොයාගත්තට පස්සේ, දැන් වෙලාව application එක optimize කරන්න. මේකෙදි අපිට කරන්න පුළුවන් දේවල් ගොඩක් තියෙනවා:

3.1. JVM Tuning

Java application එකක performance වලට JVM එකේ configuration එක ලොකු බලපෑමක් කරනවා.

• G1GC (Garbage-First Garbage Collector): Java 9 ඉඳන් default GC එක. Latency අඩු කරගෙන, throughput එක වැඩි කරන්න හොඳයි. විශාල memory heaps තියෙන applications වලට වඩාත් සුදුසුයි.
• ParallelGC: Throughput එකට වැඩි අවධානයක් දෙනවා. Multi-threaded applications වලට හොඳයි.
• Shenandoah/ZGC: මේවා low-latency GC, නමුත් production use කරන්න කලින් හොඳට test කරන්න ඕනේ.

Garbage Collector (GC) Selection:JVM එකේ Garbage Collector එක (GC) application performance එකට ගොඩක් බලපානවා. JVM එකේ memory use කරලා ඉවර වුණාට පස්සේ අනවශ්‍ය objects memory එකෙන් අයින් කරන්නේ GC එකෙන්. මේකට විවිධ GC algorithms තියෙනවා:ඔයාගේ application එකේ requirement එකට අනුව GC එකක් තෝරාගන්න පුළුවන්. සාමාන්‍යයෙන් G1GC හොඳ choice එකක්.

java -XX:+UseG1GC -jar your-app.jar

Heap Size Configuration:JVM එකට allocate කරන Memory ප්‍රමාණය (Heap Size) එක හරියට define කරන එක වැදගත්. ගොඩක් වෙලාවට default values මදි වෙන්න පුළුවන්. ඒත් අනවශ්‍ය විදියට වැඩි කරන එකත් හොඳ නෑ. ගොඩක් වැඩි කලොත් Garbage Collection (GC) වලට වැඩි වෙලාවක් යනවා.

java -Xms512m -Xmx2048m -jar your-app.jar

මෙහි -Xms කියන්නේ initial heap size එක. -Xmx කියන්නේ maximum heap size එක. මේක ඔයාගේ application එකේ memory footprint එකට අනුව adjust කරන්න.

3.2. Database Optimization

ගොඩක් Spring Boot applications වල bottleneck එක තියෙන්නේ database layer එකේ. මේවා optimize කරගන්න ක්‍රම කිහිපයක්:

• Efficient Queries:
  • Indexes: Database tables වලට හරියට indexes add කරන්න. මේකෙන් query performance එක පුදුම විදියට වැඩි වෙනවා.
  • Avoid N+1 Queries: Spring Data JPA use කරනකොට මේක පොදු ප්‍රශ්නයක්. One-to-many/many-to-many relationships load කරනකොට N+1 queries ඇති වෙන්න පුළුවන්. මේක මගහරින්න @EntityGraph, JOIN FETCH, හෝ @BatchSize වගේ දේවල් use කරන්න.
  • Use Pagination: Data ගොඩක් load කරනකොට එකපාරටම load නොකර pagination use කරන්න. Spring Data JPA Pageable interface එක use කරන්න පුළුවන්.

Caching:නිතරම access කරන data cache කරන්න. Spring Framework එකේ built-in cache abstraction එකක් තියෙනවා. Redis, Ehcache වගේ cache providers එක්ක integrate කරන්න පුළුවන්. මේකෙන් database hits අඩු කරලා performance එක වැඩි කරගන්න පුළුවන්.

// Enable caching in your main application class
@EnableCaching
@SpringBootApplication
public class MyApplication { ... }

// Cache method results
@Service
public class ProductService {
    @Cacheable("products")
    public List<Product> getAllProducts() {
        // Fetch from database
    }
}

Connection Pooling:Database connection pool එකක් use කරන එක අනිවාර්යයි. Spring Boot default විදියට HikariCP use කරනවා, ඒක හොඳම choice එකක්. ඒත් pool size එක වගේ settings හරියට configure කරන්න ඕනේ. Connections මදි වුනොත් bottlenecks ඇති වෙන්න පුළුවන්.

spring.datasource.hikari.maximum-pool-size=20
spring.datasource.hikari.minimum-idle=5
spring.datasource.hikari.connection-timeout=30000

3.3. Code Optimization

අපි ලියන code එකේ quality එකත් performance එකට කෙලින්ම බලපානවා.

• Efficient Algorithms & Data Structures:කරන වැඩේට හරියන algorithm එකයි data structure එකයි use කරන එක වැදගත්. උදාහරණයක් විදියට, නිතර search කරනවා නම් ArrayList එකකට වඩා HashSet එකක් හෝ HashMap එකක් use කරන එක හොඳයි.
• Stream API vs. Traditional Loops:Java Stream API එකෙන් code එක readable වෙනවා වගේම, සමහර වෙලාවට parallel streams use කරලා performance එකත් වැඩි කරගන්න පුළුවන්. ඒත් හැමවෙලේම Streams වේගවත් නෑ. සරල operations වලට traditional loops වේගවත් වෙන්න පුළුවන්. Benchmark කරලා බලන්න.
• Lazy Initialization:අවශ්‍ය නම් විතරක් object එකක් initialize කරන්න @Lazy annotation එක use කරන්න පුළුවන්. මේකෙන් application startup time එක අඩු කරගන්න පුළුවන්.

Logger Levels:Production environment එකේදී DEBUG හෝ TRACE level logs active කරලා තියන්න එපා. මේවා file I/O operations ගොඩක් ඇති කරන නිසා performance එකට බලපානවා.

logging.level.root=INFO

Asynchronous Processing:Long-running operations (e.g., sending emails, generating reports) main request thread එකේ කරන්නෙ නැතුව වෙන thread එකකට assign කරන්න. Spring Framework එකේ @Async annotation එක use කරලා මේක පහසුවෙන් කරන්න පුළුවන්.

@EnableAsync
@SpringBootApplication
public class MyApplication { ... }

@Service
public class EmailService {
    @Async
    public CompletableFuture<String> sendEmail(String to, String subject, String body) {
        // Simulate long-running email sending process
        return CompletableFuture.completedFuture("Email Sent!");
    }
}

3.4. Spring Boot Specific Optimizations

• Serialization/Deserialization:REST APIs වලදී JSON serialization/deserialization වලට Jackson library එක use කරනවා. Custom serializers/deserializers ලියනකොට performance ගැන හිතන්න. Unnecessary annotations (e.g., @JsonInclude(JsonInclude.Include.NON_NULL)) remove කරන එකත් පොඩි speedup එකක් දෙන්න පුළුවන්.
• Spring WebFlux (Reactive Programming):High-concurrency applications වලට Spring WebFlux use කරන එක හොඳ solution එකක්. මේක traditional Servlet-based model එකට වඩා වෙනස්. Non-blocking I/O use කරන නිසා request threads ගොඩක් අඩු වෙනවා. ඒත් මේකට application architecture එකම වෙනස් කරන්න වෙන නිසා, හැම application එකකටම මේක apply කරන්න බෑ.

Exclude Unnecessary Auto-configurations:Spring Boot එකෙන් ගොඩක් දේවල් auto-configure කරනවා. ඒත් ඔයාගේ application එකට අවශ්‍ය නැති modules තියෙනවා නම්, ඒවා exclude කරන්න පුළුවන්. මේකෙන් startup time එක සහ memory footprint එක අඩු වෙනවා.

@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})
public class MyApplication { ... }

4. නිතරම බලමු - Monitoring and Continuous Improvement

Performance Tuning කියන්නේ එකපාරක් කරලා ඉවර කරන දෙයක් නෙවෙයි. ඒක continuous process එකක්. අලුත් features add කරනකොට, user base එක වැඩි වෙනකොට performance bottlenecks අලුතෙන් ඇති වෙන්න පුළුවන්. ඒ නිසා නිතරම monitor කරන එක වැදගත්.

• Monitoring Tools: Prometheus, Grafana, ELK Stack (Elasticsearch, Logstash, Kibana) වගේ tools use කරලා application metrics, logs වගේ දේවල් monitor කරන්න. Alerts configure කරලා performance issue එකක් ආව ගමන් දැනගන්න ක්‍රමයක් හදාගන්න.
• Automated Performance Testing: JMeter, Gatling, Locust වගේ tools use කරලා automated load tests සහ stress tests ලියන්න. CI/CD pipeline එකට මේවා integrate කරලා code change එකක් deploy කරන්න කලින් performance impact එකක් තියෙනවද කියලා බලන්න.
• Regular Profiling: Production environment එකේදී periodic profiling කරන්න. මේකෙන් long-term performance trends සහ memory leaks වගේ දේවල් අඳුරගන්න පුළුවන්.

අවසන් වශයෙන්

ඉතින් මචන්ලා, Spring Boot application එකක performance optimize කරන්න පුළුවන් විවිධ ක්‍රම ගැන අපි කතා කළා. මේවා එක රැයින් කරන්න පුළුවන් දේවල් නෙවෙයි. මේකට කාලය, උත්සාහය සහ tools ගැන හොඳ අවබෝධයක් අවශ්‍යයි. නමුත් මේ දේවල් හරියට කළොත්, ඔයාගේ application එක සුපිරි වේගයෙන් දුවන්න පටන් ගනියි වගේම, users ලත් සතුටු වෙයි. Servers වලට යන වියදමත් අඩු කරගන්න පුළුවන්.

හැම වෙලාවෙම මතක තියාගන්න, optimization කරන්න කලින් bottleneck එක identify කරන එක තමයි වැදගත්ම දේ. Blindly optimize කරන එකෙන් වෙන්නේ කාලය නාස්ති වෙන එක විතරයි.

මේ article එක ඔයාලට වැදගත් වෙන්න ඇති කියලා හිතනවා. ඔයාලත් මේ දේවල් try කරලා ඔයාලගේ අත්දැකීම් comment section එකේ share කරන්න. එහෙනම්, ඊළඟ පෝස්ට් එකකින් හම්බවෙමු!

ජය වේවා!