Sign in Subscribe
By Thisara Priyamal —

Java වලින් REST API Call කරන හැටි | HttpClient & Jersey Client SC Guide

Java වලින් REST API Call කරන හැටි | HttpClient & Jersey Client SC Guide

ආයුබෝවන් Java යාලුවනේ! RESTful Web Services ගැන SC Guide එකක්!

ඉතින් කොහොමද යාලුවනේ? අද අපි කතා කරන්න යන්නේ ගොඩක් වැදගත්, වගේම දවසින් දවස ජනප්‍රිය වෙන, ඕනෑම Software Engineer කෙනෙක් අනිවාර්යයෙන්ම දැනගෙන ඉන්න ඕන මාතෘකාවක් ගැන. ඒ තමයි Java භාවිතයෙන් RESTful Web Services (ඒ කියන්නේ APIs) consume කරන හැටි. ලෝකයේ තියෙන ගොඩක් Applications එකිනෙකා අතර දත්ත හුවමාරු කරගන්නේ මේ APIs හරහා තමයි. ඒ නිසා, Java Developer කෙනෙක් විදිහට, APIs එක්ක වැඩ කරන එක ඔයාලගේ දෛනික වැඩ වල අනිවාර්ය අංගයක් වෙනවා.

මොකද මේ REST APIs කියන්නේ? සරලව කිව්වොත්, මේවා කියන්නේ විවිධ Software Applications වලට එකිනෙකා අතර සන්නිවේදනය කරන්න උදව් කරන නීති මාලාවක්. හරියට ඔයාලා WhatsApp එකෙන් යාලුවෙක්ට Message එකක් යවනවා වගේ, Software Applications වලටත් එකිනෙකාට 'කතා' කරන්න මේ APIs ඕන වෙනවා. Java කියන්නේ මේ APIs එක්ක වැඩ කරන්න පුළුවන් ඉතාමත් බලවත්, ස්ථාවර භාෂාවක්. ඒ නිසා, අද අපි බලමු Java වලදී මේ APIs වලට requests යවලා, responses ලබාගන්නේ කොහොමද කියලා.

අපි මේ SC Guide එකේදී ප්‍රධාන ක්‍රම දෙකක් ගැන කතා කරනවා:

  1. java.net.http.HttpClient: මේක Java 11 එක්ක ආපු, APIs consume කරන්න තියෙන අලුත්ම සහ modern ම ක්‍රමය. ගොඩක් simple වගේම powerful.
  2. Jersey Client: මේක JAX-RS (Java API for RESTful Web Services) වල implementation එකක්. ලොකු Enterprise Applications වල ගොඩක් වෙලාවට මේ Client එක පාවිච්චි කරනවා.

ඉතින්, ලංකාවේ Tech Industry එක දියුණු වෙන මේ කාලේ, මේ දැනුම ඔයාලගේ Software Development Skill Set එකට ලොකු වටිනාකමක් එකතු කරයි. අපි එහෙනම් වැඩේට බහිමු!

RESTful Web Services කෙටියෙන්

REST (Representational State Transfer) කියන්නේ Architectural Style එකක්. ඒක Software Systems වල communication සඳහා guidelines සපයනවා. RESTful APIs කියන්නේ HTTP Protocol එක මත පදනම් වෙලා ක්‍රියාත්මක වෙන Web Services. මේවා lightweight, scalable, සහ maintain කරන්න ලේසියි.

RESTful APIs වල ප්‍රධානම ලක්ෂණ කිහිපයක්:

  • Resources: API එකක් expose කරන්නේ resources. උදාහරණයක් විදිහට, Users, Products, Orders වගේ දේවල් resources වෙන්න පුළුවන්. මේ resources වලට අදාළ URLs (Uniform Resource Locators) තියෙනවා.
  • HTTP Methods: HTTP වල Standard Methods (verbs) resources මත operations කරන්න යොදා ගන්නවා:
    • GET: Resource එකකින් data retrieve කරන්න. (කියවන්න)
    • POST: අලුත් Resource එකක් create කරන්න. (ලියන්න)
    • PUT: දැනට පවතින Resource එකක් update කරන්න. (වෙනස් කරන්න)
    • DELETE: Resource එකක් remove කරන්න. (මකන්න)
  • Statelessness: Server එක Client requests අතර Client ගේ තත්ත්වය (state) මතක තියාගන්නේ නැහැ. හැම request එකකම ඒකට අවශ්‍ය හැම information එකක්ම අඩංගු වෙන්න ඕන.
  • Representation: Resources Client එකට යවන්නේ විවිධ formats වලින්. වැඩිපුරම JSON (JavaScript Object Notation) සහ XML (Extensible Markup Language) පාවිච්චි කරනවා. අද කාලේ ගොඩක් වෙලාවට JSON තමයි පාවිච්චි කරන්නේ.

java.net.http.HttpClient භාවිතයෙන් REST API කැඳවීම

Java 11 එක්ක හඳුන්වා දුන් HttpClient API එක HTTP requests කරන්න තියෙන modern, flexible, සහ powerful tool එකක්. මේක asynchronous programming වලටත් හොඳට support කරනවා. අපි බලමු මේකෙන් API calls කරන්නේ කොහොමද කියලා.

GET Request එකක් යවන හැටි

අපි මේකට test කරන්න jsonplaceholder.typicode.com කියන API එක පාවිච්චි කරමු. මේකෙන් dummy data ලබාගන්න පුළුවන්.

පහත code එකෙන් https://jsonplaceholder.typicode.com/todos/1 කියන URL එකට GET request එකක් යවලා, ඒකෙන් එන response එක console එකේ print කරන හැටි බලමු.

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class HttpClientGetExample {
    public static void main(String[] args) {
        // HttpClient instance එකක් හදාගන්නවා
        HttpClient client = HttpClient.newHttpClient();

        // HttpRequest එකක් build කරනවා
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://jsonplaceholder.typicode.com/todos/1"))
                .GET() // GET request එකක් විදිහට define කරනවා
                .build();

        try {
            // request එක send කරලා response එක ගන්නවා
            // HttpResponse.BodyHandlers.ofString() කියන්නේ response body එක String එකක් විදිහට ගන්න කියලා.
            HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());

            // Response status code එක print කරනවා
            System.out.println("Status Code: " + response.statusCode());

            // Response body එක print කරනවා
            System.out.println("Response Body: " + response.body());

        } catch (Exception e) {
            // error එකක් ආවොත් print කරනවා
            System.err.println("Error sending GET request: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

මේ code එක run කරාම ඔයාලට Status Code 200 (ඒ කියන්නේ Success!) සහ පහත JSON response එක ලැබෙයි:

{
  "userId": 1,
  "id": 1,
  "title": "delectus aut autem",
  "completed": false
}

POST Request එකක් යවන හැටි

POST request එකකදී අපි Server එකට data යවනවා. අපි බලමු අලුත් 'todo' එකක් create කරන්න POST request එකක් යවන හැටි.

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class HttpClientPostExample {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();

        // Server එකට යවන්න ඕන JSON data එක
        String jsonBody = "{\"title\": \"foo\", \"body\": \"bar\", \"userId\": 1}";

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://jsonplaceholder.typicode.com/posts"))
                .header("Content-Type", "application/json") // Content-Type header එක define කරනවා
                .POST(HttpRequest.BodyPublishers.ofString(jsonBody)) // POST request එක define කරලා data එක attach කරනවා
                .build();

        try {
            HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());

            System.out.println("Status Code: " + response.statusCode());
            System.out.println("Response Body: " + response.body());

        } catch (Exception e) {
            System.err.println("Error sending POST request: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

මෙහිදී අපි HttpRequest.BodyPublishers.ofString(jsonBody) භාවිතා කරලා JSON string එක request body එකට attach කරනවා. header("Content-Type", "application/json") කියන්නේ server එකට කියනවා අපි යවන්නේ JSON data කියලා. මේ code එක run කරාම, jsonplaceholder එකෙන් dummy id එකක් එක්ක response එකක් එයි:

{
  "id": 101,
  "title": "foo",
  "body": "bar",
  "userId": 1
}

Jersey Client භාවිතයෙන් REST API කැඳවීම

Jersey Client කියන්නේ JAX-RS (Java API for RESTful Web Services) වල reference implementation එක. මේක enterprise-level applications වලට ගොඩක් ප්‍රයෝජනවත් වෙන feature ගොඩක් එක්ක එන powerful client එකක්. Jersey Client එක භාවිතා කරන්න කලින්, ඔයාලා Maven හෝ Gradle වලට අවශ්‍ය dependencies add කරගන්න ඕන.

Maven Dependencies (pom.xml)

<dependencies>
    <!-- Jersey Client -->
    <dependency>
        <groupId>org.glassfish.jersey.core</groupId>
        <artifactId>jersey-client</artifactId>
        <version>3.1.3</version> <!-- නවතම stable version එකක් භාවිතා කරන්න -->
    </dependency>
    <!-- JSON processing සඳහා (උදා: Jackson) -->
    <dependency>
        <groupId>org.glassfish.jersey.media</groupId>
        <artifactId>jersey-media-json-jackson</artifactId>
        <version>3.1.3</version> <!-- Jersey client version එකට අදාළව -->
    </dependency>
</dependencies>

Note: Version numbers අලුත් වෙන්න පුළුවන්. Maven Central Repository එක බලලා අලුත්ම stable version එක යොදාගන්න.

GET Request එකක් යවන හැටි (Jersey Client)

import jakarta.ws.rs.client.Client;
import jakarta.ws.rs.client.ClientBuilder;
import jakarta.ws.rs.client.WebTarget;
import jakarta.ws.rs.core.MediaType;
import jakarta.ws.rs.core.Response;

public class JerseyClientGetExample {
    public static void main(String[] args) {
        // Client instance එකක් හදනවා
        Client client = ClientBuilder.newClient();

        // WebTarget එකක් define කරනවා. මේක URL එක represent කරනවා.
        WebTarget webTarget = client.target("https://jsonplaceholder.typicode.com/todos/1");

        try {
            // GET request එකක් යවලා String response එකක් ගන්නවා
            Response response = webTarget.request(MediaType.APPLICATION_JSON).get();

            // Status code එක check කරනවා
            if (response.getStatus() == 200) {
                String responseBody = response.readEntity(String.class);
                System.out.println("Status Code: " + response.getStatus());
                System.out.println("Response Body: " + responseBody);
            } else {
                System.out.println("Error Status Code: " + response.getStatus());
                System.out.println("Error Message: " + response.readEntity(String.class));
            }
        } finally {
            // Client එක close කරන එක වැදගත්
            client.close();
        }
    }
}

මෙහිදී ClientBuilder.newClient() වලින් Client instance එකක් හදනවා. ඊට පස්සේ client.target(URL) වලින් WebTarget එකක් හදාගෙන ඒකෙන් request එක යවනවා. MediaType.APPLICATION_JSON වලින් කියන්නේ අපිට JSON response එකක් ඕන කියලා. response.readEntity(String.class) වලින් response body එක කියවනවා.

POST Request එකක් යවන හැටි (Jersey Client)

POST request එකක් යවන්නත් Jersey Client එක ඉතාමත් පහසුයි. අපි JSON object එකක් POJO (Plain Old Java Object) එකක් විදිහට හදාගෙන ඒක send කරන හැටි බලමු. ඒකට Jackson dependency එක උදව් වෙනවා.

import jakarta.ws.rs.client.Client;
import jakarta.ws.rs.client.ClientBuilder;
import jakarta.ws.rs.client.Entity;
import jakarta.ws.rs.client.WebTarget;
import jakarta.ws.rs.core.MediaType;
import jakarta.ws.rs.core.Response;

// මේක request body එක සඳහා POJO එකක්
class PostData {
    public String title;
    public String body;
    public int userId;

    // Constructors, getters, setters (නැතත් කමක් නෑ Jackson auto map කරයි)
    public PostData(String title, String body, int userId) {
        this.title = title;
        this.body = body;
        this.userId = userId;
    }
    public PostData() {}
}

public class JerseyClientPostExample {
    public static void main(String[] args) {
        Client client = ClientBuilder.newClient();
        // Jackson JSON Provider එක register කරනවා
        client.register(org.glassfish.jersey.jackson.JacksonFeature.class);

        WebTarget webTarget = client.target("https://jsonplaceholder.typicode.com/posts");

        // POST කරන්න ඕන data එක POJO object එකක් විදිහට හදාගන්නවා
        PostData newPost = new PostData("SC Guide Post", "This is a post from Java Jersey Client!", 10);

        try {
            // POST request එක යවනවා. Entity.json(Object) වලින් object එක JSON විදිහට send කරනවා.
            Response response = webTarget.request(MediaType.APPLICATION_JSON)
                    .post(Entity.json(newPost));

            if (response.getStatus() == 201) { // 201 Created කියන්නේ successful creation
                String responseBody = response.readEntity(String.class);
                System.out.println("Status Code: " + response.getStatus());
                System.out.println("Response Body: " + responseBody);
            } else {
                System.out.println("Error Status Code: " + response.getStatus());
                System.out.println("Error Message: " + response.readEntity(String.class));
            }
        } finally {
            client.close();
        }
    }
}

මේ code එකේ PostData කියන POJO එක හදාගෙන, ඒක Entity.json(newPost) විදිහට POST කරනවා. JacksonFeature එක register කරපු නිසා, Jersey එකට පුළුවන් මේ Java Object එක JSON එකට convert කරන්න (marshalling) සහ JSON response එකක් ආවොත් ඒක Java Object එකකට convert කරන්න (unmarshalling).

වැදගත් කරුණු සහ හොඳ පුරුදු (Best Practices)

API consumption කියන්නේ හරිම straightforward වැඩක් වගේ පෙනුනත්, ලොකු applications වලදී මේක robust සහ maintainable විදිහට කරන්න ගොඩක් දේවල් බලන්න ඕන. මෙන්න ඒ ගැන පොඩි tips කිහිපයක්:

  • Error Handling: හැමවිටම HTTP status codes (2xx for success, 4xx for client errors, 5xx for server errors) පරීක්ෂා කරන්න. try-catch blocks භාවිතා කරලා network errors හෝ වෙනත් exceptions handle කරන්න.
  • Timeouts: API calls වලට timeouts set කරන්න. නැත්නම්, server එක respond නොකරන අවස්ථා වලදී application එක hang වෙන්න පුළුවන්. HttpClient වලට connectTimeout() සහ requestTimeout() වගේ methods තියෙනවා. Jersey වලටත් ClientBuilder එක හරහා timeout properties configure කරන්න පුළුවන්.
  • Asynchronous vs. Synchronous: ඉහත උදාහරණ දෙකම synchronous (blocking) calls. ඒ කියන්නේ response එක එනකම් thread එක block වෙනවා. HttpClient එක sendAsync() කියන method එක හරහා asynchronous calls වලට support කරනවා. මේකෙන් application එකේ responsiveness වැඩි දියුණු කරන්න පුළුවන්.
  • JSON Parsing: API response එක JSON එකක් නම්, ඒක Java Objects වලට map කරන්න Jackson හෝ Gson වගේ libraries පාවිච්චි කරන්න. ඒක raw String parsing වලට වඩා ගොඩක් පහසුයි.
  • Logging: API requests සහ responses log කරන්න. මේක debugging වලට වගේම troubleshooting වලටත් ගොඩක් වැදගත්.
  • Authentication: APIs ගොඩක් වෙලාවට authentication (API Keys, OAuth, JWT tokens) ඉල්ලනවා. Requests වලට අවශ්‍ය headers එකතු කරන්නේ කොහොමද කියලා ඔයාලා දැනගෙන ඉන්න ඕන.

අවසන් වශයෙන් (Conclusion)

අද අපි Java වල RESTful Web Services consume කරන ප්‍රධාන ක්‍රම දෙකක් ගැන ඉගෙන ගත්තා: java.net.http.HttpClient සහ Jersey Client. HttpClient එක Java 11+ ව්‍යාපෘති වලට ගොඩක් හොඳයි, සරලයි, වගේම modern. Jersey Client එක JAX-RS ecosystem එකේ වැඩ කරන අයට සහ enterprise-level applications වලට වඩාත් සුදුසුයි.

මතක තියාගන්න, API consumption කියන්නේ අද දවසේ Software Development වල හරිම මූලික කුසලතාවයක්. මේ උදාහරණ ටික practice කරලා, ඔයාලාටම තව APIs එක්ක experiment කරන්න. Real-world applications වලදී මේ concept ඔයාලට ගොඩක් ප්‍රයෝජනවත් වෙයි.

ඉතින්, මේ SC Guide එක ඔයාලට ප්‍රයෝජනවත් වෙන්න ඇති කියලා හිතනවා. ඔයාලා වැඩිපුරම පාවිච්චි කරන method එක මොකක්ද? නැත්නම් API calls කරනකොට ඔයාලට හම්බවෙච්ච අත්දැකීම් මොනවද? පහතින් Comment කරන්න! ඔයාලගේ අදහස් දැනගන්න අපි ආසයි.

තවත් අලුත් SC Guide එකකින් හමුවෙමු! සුභ දවසක්!

Previous

Python Threads Sinhala | Concurrency Basics SC Guide | Python සමග Threads

 Next

Python Multiprocessing: CPU-Bound Tasks සඳහා සමාන්තරකරණය SC Guide