Spring Boot API Performance Testing JMeter Sinhala | හොඳම ක්‍රම

ආයුබෝවන්, හැමෝටම!

අද අපි කතා කරන්න යන්නේ ගොඩක් වැදගත්, ඒ වගේම අපේ Spring Boot Applications හදනකොට අනිවාර්යයෙන්ම අවධානය යොමු කරන්න ඕන මාතෘකාවක් ගැන – ඒ තමයි Performance Testing! අද වෙනකොට හැම Application එකක්ම fast වෙන්න ඕන, responsive වෙන්න ඕන. පරිශීලකයෙක් තත්පර කීපයකට වඩා බලාගෙන ඉන්න කැමති නැහැ. ඉතින්, අපේ API එකක් හදලා deploy කරාට පස්සේ, ඒක විවිධ අවස්ථාවලදී කොහොමද behave කරන්නේ කියලා දැනගන්න එක ගොඩක් වැදගත්. ඒකට තමයි Performance Testing උදව් වෙන්නේ. අපි අද මේ Spring Boot API වල Performance Test කරන්න JMeter කියන powerful tool එක කොහොමද පාවිච්චි කරන්නේ කියලා බලමු.

Performance Testing කියන්නේ මොකක්ද? ඇයි ඒක Spring Boot වලට වැදගත්?

සරලවම කිව්වොත්, Performance Testing කියන්නේ අපේ Software Application එකක speed, responsiveness, stability, සහ scalability වගේ දේවල් examine කරන ක්‍රියාවලියක්. අපේ Application එක එකවර Users ගොඩකට handle කරන්න පුළුවන්ද, request එකකට කොච්චර වෙලාවක් යනවද, වගේ දේවල් මේකෙන් අපිට බලාගන්න පුළුවන්.

ඇයි මේක Spring Boot Application වලට වැදගත් වෙන්නේ?

• User Experience (පරිශීලක අත්දැකීම): Slow Application එකකට කවුරුත් කැමති නැහැ. Fast Application එකකින් Users ලා සතුටු වෙනවා වගේම අපේ App එක දිගටම පාවිච්චි කරන්න පෙළඹෙනවා.
• Scalability (විශාල කර ගැනීමේ හැකියාව): අපේ API එකට අනාගතයේදී වැඩිපුර Traffic ආවොත්, ඒක handle කරන්න පුළුවන්ද? Performance Testing එකෙන් අපිට ඒක predict කරන්න පුළුවන්.
• Resource Utilization (සම්පත් භාවිතය): Application එක running වෙද්දී CPU, Memory වගේ Server Resources කොච්චර පාවිච්චි වෙනවද කියලා දැනගන්න පුළුවන්. අපිට මේවා optimize කරන්න ඒක උදව් වෙනවා.
• Early Detection of Bottlenecks (ප්‍රශ්න ඉක්මනින් හඳුනා ගැනීම): Production එකට යන්න කලින්ම Performance ප්‍රශ්න හොයාගෙන ඒවා fix කරගන්න පුළුවන්.

Performance Testing වලදී ප්‍රධාන test වර්ග කීපයක් තියෙනවා:

• Load Testing: Application එක සාමාන්‍යයෙන් handle කරන User Load එක යටතේ කොහොමද behave කරන්නේ කියලා බලනවා.
• Stress Testing: Application එකේ maximum capacity එක හොයන්න, සාමාන්‍යයෙන් දරන්න පුළුවන් load එකට වඩා වැඩි load එකක් දීලා test කරනවා.
• Scalability Testing: Users ලා වැඩිවෙනකොට Application එක කොච්චර දුරට scale කරන්න පුළුවන්ද කියලා බලනවා.

JMeter ඇයි අපිට වැදගත්?

JMeter කියන්නේ Apache Software Foundation එකෙන් maintain කරන open-source Performance Testing tool එකක්. ඒක Java වලින් හදලා තියෙන නිසා platform-independent. JMeter මේකට ගොඩක් හොඳයි මොකද:

• Open Source: පාවිච්චි කරන්න සල්ලි යන්නේ නැහැ.
• Versatile: Web (HTTP/HTTPS), SOAP/REST Web Services, FTP, Databases, Email, TCP වගේ ගොඩක් protocols test කරන්න පුළුවන්.
• User-Friendly GUI: Test Plans හදන්න, run කරන්න, results බලන්න පහසු Graphical User Interface (GUI) එකක් තියෙනවා.
• Extensible: Plugins ගොඩක් තියෙනවා, අපිට ඕන නම් අපේම plugins හදාගන්නත් පුළුවන්.

JMeter එකෙන් වෙන්නේ Virtual Users ලා ගොඩක් හදලා, අපේ Application එකට එකපාරටම Request ගොඩක් යවලා, ඒ Request වල Response Time, Throughput, Error Rate වගේ දේවල් Record කරන එක.

සරල Spring Boot API එකක් හදමු

JMeter වලින් Test කරන්න කලින්, අපිට Test කරන්න පුළුවන් Spring Boot API එකක් ඕනනේ. අපි සරල CRUD (Create, Read, Update, Delete) API එකක් හදමු. මේකෙන් අපි /api/products කියන endpoint එක test කරන්න පුළුවන් වෙන විදිහට හදාගමු.

මුලින්ම, Spring Initializr එකට ගිහින් Maven Project එකක් generate කරගන්න, Dependencies විදිහට Spring Web සහ Lombok (optional, for less boilerplate code) එකතු කරගන්න. Project එක Download කරලා IDE එකක (IntelliJ IDEA, VS Code වගේ) open කරගන්න.

දැන් Product කියන model එක, ProductRepository එකයි, ProductController එකයි හදාගමු.

Product.java

package com.example.performance.model;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data // Getters, Setters, toString, equals, hashCode
@AllArgsConstructor // Constructor with all fields
@NoArgsConstructor // Default constructor
public class Product {
    private Long id;
    private String name;
    private double price;
}

ProductRepository.java (Simple In-memory storage)

package com.example.performance.repository;

import com.example.performance.model.Product;
import org.springframework.stereotype.Repository;

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.atomic.AtomicLong;

@Repository
public class ProductRepository {
    private final List<Product> products = new ArrayList<>();
    private final AtomicLong counter = new AtomicLong();

    public Product save(Product product) {
        if (product.getId() == null) {
            product.setId(counter.incrementAndGet());
        }
        products.add(product);
        return product;
    }

    public List<Product> findAll() {
        return new ArrayList<>(products);
    }

    public Optional<Product> findById(Long id) {
        return products.stream().filter(p -> p.getId().equals(id)).findFirst();
    }
}

ProductController.java

package com.example.performance.controller;

import com.example.performance.model.Product;
import com.example.performance.repository.ProductRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/api/products")
public class ProductController {

    @Autowired
    private ProductRepository productRepository;

    @GetMapping
    public ResponseEntity<List<Product>> getAllProducts() {
        return new ResponseEntity<>(productRepository.findAll(), HttpStatus.OK);
    }

    @GetMapping("/{id}")
    public ResponseEntity<Product> getProductById(@PathVariable Long id) {
        return productRepository.findById(id)
                .map(product -> new ResponseEntity<>(product, HttpStatus.OK))
                .orElse(new ResponseEntity<>(HttpStatus.NOT_FOUND));
    }

    @PostMapping
    public ResponseEntity<Product> createProduct(@RequestBody Product product) {
        Product savedProduct = productRepository.save(product);
        return new ResponseEntity<>(savedProduct, HttpStatus.CREATED);
    }

    // ... ඔබට අවශ්‍ය නම් PUT/DELETE methods එකතු කරගන්න පුළුවන්
}

මේ Application එක run කරලා බලන්න http://localhost:8080/api/products කියන URL එකට ගියාම empty array එකක් එනවද කියලා. දැන් අපි මේක JMeter වලින් Test කරමු.

JMeter Installation සහ Setup

JMeter පාවිච්චි කරන්න කලින් අපිට Java Development Kit (JDK) එක install කරලා තියෙන්න ඕන (Java 8 හෝ ඊට වැඩි version එකක්).

1. JMeter Download කරන්න: Apache JMeter Website එකට (https://jmeter.apache.org/download_jmeter.cgi) ගිහින් latest binary zip file එක download කරගන්න.
2. Extract කරන්න: Download කරපු zip file එක extract කරලා කැමති තැනක (e.g., C:\apache-jmeter-x.x හෝ ~/apache-jmeter-x.x) තියාගන්න.
3. JMeter Run කරන්න:
   • Windows නම්: [JMeter_HOME]\bin\jmeter.bat file එක double click කරලා run කරන්න.
   • Linux/macOS නම්: Terminal එක open කරලා [JMeter_HOME]/bin/jmeter.sh command එක run කරන්න.

JMeter GUI එක open වුණාට පස්සේ, අපි Test Plan එකක් හදන්න ලෑස්ති.

JMeter Test Plan එකක් හදමු

Test Plan එකක් කියන්නේ JMeter වලදී අපි run කරන්න බලාපොරොත්තු වෙන tests වල blueprint එක. ඒකේ අපිට Test Scenarios, Configurations, Listeners වගේ දේවල් define කරන්න පුළුවන්.

1. Thread Group එකක් එකතු කරන්න

Test Plan මත Right Click කරලා Add > Threads (Users) > Thread Group තෝරන්න.

• Number of Threads (users): එකවර අපේ Application එකට Request කරන Virtual Users ගණන. (e.g., 100)
• Ramp-up period (seconds): මේ Users ලා ටික මේ කාලය ඇතුළතදී activate වෙනවා. (e.g., 10 - Users 100 ක් තත්පර 10 ඇතුළත system එකට එනවා)
• Loop Count: එක් User කෙනෙක් Request කීපාරක් යවනවද කියලා. (e.g., 5 - හැම User කෙනෙක්ම Request 5ක් යවනවා. Infinite දාන්නත් පුළුවන්)

අපි මුලින්ම Users 100 ක්, Ramp-up තත්පර 10 ක්, Loop Count 1 ක් විදිහට දාගමු.

2. HTTP Request Sampler එකතු කරන්න

Thread Group මත Right Click කරලා Add > Sampler > HTTP Request තෝරන්න.

අපි මුලින්ම GET /api/products endpoint එක test කරමු.

• Name: Get All Products
• Protocol: HTTP
• Server Name or IP: localhost
• Port Number: 8080
• HTTP Request: Method: GET
• Path: /api/products

දැන් අපි POST /api/products එකත් test කරමු. ඒකට තව HTTP Request එකක් එකතු කරන්න.

• Name: Create New Product
• Protocol: HTTP
• Server Name or IP: localhost
• Port Number: 8080
• HTTP Request: Method: POST
• Path: /api/products

Remember: POST Request එකකට body එකක් ඕනනේ. ඒක දාන්න HTTP Request Sampler එකේ Body Data tab එකට ගිහින් පහත JSON එක add කරන්න:

{
  "name": "Test Product ${__threadNum}",
  "price": 99.99
}

මෙහිදී ${__threadNum} කියන්නේ JMeter function එකක්. මේකෙන් හැම Thread එකකටම unique product name එකක් හදනවා. ඒ වගේම Header එකක් විදිහට Content-Type: application/json එකතු කරන්න ඕන. ඒකට HTTP Request Sampler එක මත Right Click කරලා Add > Config Element > HTTP Header Manager එකතු කරලා, Add button එක click කරලා Content-Type කියන Name එකට application/json කියලා Value එක දෙන්න.

3. Listeners එකතු කරන්න

Listeners වලින් වෙන්නේ Test Results analyze කරන්න උදව් වෙන එක. Thread Group මත Right Click කරලා Add > Listener වලින් පහත ඒවා එකතු කරගන්න:

• View Results Tree: හැම Request එකකම Details (Request, Response, Headers) බලන්න පුළුවන්. Debug කරන්න ගොඩක් හොඳයි.
• Aggregate Report: Test එකේ overall summary එක බලන්න පුළුවන් (Average, Throughput, Error % වගේ). මේක තමයි Performance Metrics වලට වැදගත්ම Report එක.

Test Plan එක Run කරමු!

JMeter GUI එකේ Start button එක (Green Play button) click කරන්න. නැත්නම් Run > Start කියන එක දෙන්න. Test එක run වෙනකොට Listeners වල Results පෙන්නන්න පටන් ගනීවි.

Note: Test එක run කරන්න කලින් අපේ Spring Boot Application එක running තියෙන්න ඕන.

මෙන්න අපේ Test Plan එකේ Structure එක:

Test Plan
  ├── Thread Group
  │     ├── HTTP Request: Get All Products (GET /api/products)
  │     ├── HTTP Request: Create New Product (POST /api/products)
  │     └── HTTP Header Manager (For Content-Type: application/json)
  ├── View Results Tree
  └── Aggregate Report

Test Results කියවමු

Aggregate Report එකෙන් අපිට වැදගත්ම metrics බලාගන්න පුළුවන්:

• Samples: Total Requests ගණන.
• Average: සාමාන්‍ය Response Time එක (මිලි තත්පර වලින්). මේක අඩු වෙන්න අඩු වෙන්න හොඳයි.
• Median: Request වලින් 50% ක් මේ වෙලාවට වඩා අඩු කාලයකින් complete වෙලා තියෙනවා.
• 90% Line (90th Percentile): Request වලින් 90% ක් මේ වෙලාවට වඩා අඩු කාලයකින් complete වෙලා තියෙනවා. මේක ඉතා වැදගත් metric එකක්, මොකද මේකෙන් අපේ application එකේ worst-case scenario එකක් පෙන්නනවා.
• Min/Max: අඩුම සහ වැඩිම Response Time එක.
• Error %: Fail වුණු Requests වල ප්‍රතිශතය. මේක 0% වෙන්න ඕන.
• Throughput: තත්පරයකට handle කරපු Requests ගණන (Requests/sec). මේක වැඩි වෙන්න වැඩි වෙන්න හොඳයි.
• Received/Sent: Data කොච්චර received වුණාද/sent වුණාද කියලා.

සාමාන්‍යයෙන් Average, 90% Line, Error %, Throughput කියන ඒවා තමයි අපි ගොඩක්ම බලන්නේ. අපේ Application එක හොඳ Performance එකක් දෙනවා නම්, Average සහ 90% Line values අඩු වෙන්න ඕන, Throughput වැඩි වෙන්න ඕන, Error % එක 0% වෙන්න ඕන.

View Results Tree එකෙන් අපිට හැම Request එකකම Response Data, Request Data, Headers වගේ දේවල් බලලා, මොකක් හරි error එකක් ආවොත් debug කරගන්න පුළුවන්.

තව ටිකක් දියුණු වෙමු (Getting More Advanced)

JMeter වලට තව ගොඩක් advanced features තියෙනවා:

• Assertions: Response එකේ content එක, status code එක, length එක වගේ දේවල් validate කරන්න පුළුවන්. (e.g., Response Assertions)
• Timers: Users ලා Requests අතරතුරදී wait කරන වෙලාවක් simulate කරන්න පුළුවන්. (e.g., Constant Timer, Gaussian Random Timer)
• CSV Data Set Config: Test data CSV file එකකින් read කරලා Request වලට dynamic data දෙන්න පුළුවන්. මේකෙන් අපිට ගොඩක් real-world scenarios simulate කරන්න පුළුවන්.
• Controllers: Test logic එක control කරන්න (e.g., Loop Controller, If Controller, Random Controller).
• Distributed Testing: එක JMeter machine එකකින් දරන්න බැරි load එකක් නම්, machines ගොඩක් පාවිච්චි කරලා test කරන්න පුළුවන්.

Gatling ගැන කෙටි හැඳින්වීමක්

JMeter වගේම, Gatling කියන්නෙත් Performance Testing වලට පාවිච්චි කරන තවත් powerful tool එකක්. Gatling හැදිලා තියෙන්නේ Scala Programming Language එකෙන්. JMeter GUI එකක් එක්ක එනකොට, Gatling කියන්නේ code-centric tool එකක්. Test Scenarios හදන්නේ Scala Code වලින්. මේකෙන් code review, version control වගේ දේවල් පහසු වෙනවා. ඒ වගේම JMeter වලට වඩා අඩු Resource එකකින් වැඩි Load එකක් generate කරන්න පුළුවන් කියලා කියනවා.

ඔබට Java, Scala වගේ languages වල හොඳ අත්දැකීමක් තියෙනවා නම්, Gatling ඉතා හොඳ choice එකක් වෙන්න පුළුවන්. නමුත් JMeter කියන්නේ Performance Testing වලට අලුත් කෙනෙක්ට පටන් ගන්න ඉතා පහසු සහ powerful tool එකක්.

අවසන් වශයෙන්

අද අපි JMeter පාවිච්චි කරලා Spring Boot API එකක Performance Test කරන්නේ කොහොමද කියලා කතා කළා. Performance Testing කියන්නේ අපේ Software Quality එක ensure කරන්න අත්‍යාවශ්‍ය දෙයක්. මේකෙන් අපිට අපේ Application එකේ Weak Points හොයාගෙන ඒවා optimize කරන්න පුළුවන්.

මතක තියාගන්න, Performance Testing කියන්නේ එක පාරක් කරලා අතහරින දෙයක් නෙවෙයි. Application එකේ changes කරන හැම වෙලාවකම වගේ මේක rerun කරලා Performance එක maintain වෙනවද කියලා බලන්න ඕන. ඒ වගේම Load එක ටිකෙන් ටික වැඩි කරලා Test කරන්න, ඒකෙන් තමයි Application එකේ Real Capacity එක හොයාගන්න පුළුවන්.

ඉතින්, මේ Guide එකෙන් ඔයාලට JMeter ගැන හොඳ අවබෝධයක් ලැබුණා කියලා හිතනවා. ඔයාලගේම Spring Boot Project එකකට මේක apply කරලා බලන්න. මොකක් හරි ප්‍රශ්නයක් ආවොත්, පහළින් comment එකක් දාන්න! ඔයාලගේ අත්දැකීම් අපිත් එක්ක බෙදාගන්නත් අමතක කරන්න එපා!

Happy Testing!