වෙබ් එකේ හැංගිලා තියෙන Data අදින හැටි: Java වල URL & URLConnection! (SC Guide)

ආයුබෝවන් හැමෝටම! කොහොමද කට්ටියට? අද අපි කතා කරන්න යන්නේ Java වල Program කරන අපිට නැතුවම බැරි Subject එකක් ගැන. ඒ තමයි Web එකෙන් Data Fetch කරන එක. අපි දන්නවා Web එක කියන්නේ අති විශාල Data Collection එකක් නේ. මේ Data අපේ Program එකට ගන්න පුළුවන් නම් කොච්චර ෂෝක් ද? අපි App එකක් කරනකොට, Website එකකින් Latest News ටිකක් ගන්න, Currency Exchange Rates වගේ ඒවා Update කරගන්න, නැත්නම් Weather Updates ගන්න ඕනෙ වෙනවා නේද? අන්න ඒ වගේ වෙලාවට අපිට උදව්වට එනවා Java වල තියෙන සුපිරි Classes දෙකක්: URL සහ URLConnection.

අද අපි මේ දෙකෙන් වැඩ කරන හැටි මුල ඉඳන්ම, ලේසියෙන් තේරෙන විදිහට කතා කරමු. මොකද අලුතෙන් Program කරන අයට මේ Subject එක ටිකක් අමාරු වෙන්න පුළුවන්. ඒත් මම පොරොන්දු වෙනවා මේ Article එක ඉවර වෙනකොට ඔයාලට මේ ගැන හොඳ Idea එකක් එයි කියලා.

1. URL එකෙන් වැඩ පටන් ගමු! (URL: The Address of the Web)

මුලින්ම අපි බලමු URL එක කියන්නේ මොකක්ද කියලා. URL කියන්නේ Uniform Resource Locator එකට. සරලවම කිව්වොත්, Web එකේ තියෙන ඕනෑම Resource එකක් (Web Page එකක්, Image එකක්, Video එකක්, නැත්නම් Data File එකක්) හොයාගන්න තියෙන Address එක තමයි URL එක. හරියට අපේ ගෙදර Address එක වගේ. Java වලදී, java.net.URL Class එක පාවිච්චි කරලා අපිට මේ URL එක Represent කරන්න පුළුවන්.

URL එකක් හදන හැටි

URL Object එකක් හදන එක හරිම ලේසියි. ඒකට ඔයාලට ඕන කරන Web Address එක String එකක් විදිහට Constructor එකට දෙන්න විතරයි තියෙන්නේ. හැබැයි මේකෙන් MalformedURLException එකක් එන්න පුළුවන්, මොකද ඔයාලා දෙන URL එක වැරදි විදිහට Format වෙලා තියෙන්න පුළුවන්. ඒ නිසා try-catch Block එකක් ඇතුලේ කරන එක හොඳයි.

import java.net.MalformedURLException;
import java.net.URL;

public class URLDemo {
    public static void main(String[] args) {
        try {
            // Facebook එකේ URL එකක් හදමු
            URL facebookURL = new URL("https://www.facebook.com/developer");
            System.out.println("Protocol: " + facebookURL.getProtocol());
            System.out.println("Host: " + facebookURL.getHost());
            System.out.println("Port: " + facebookURL.getPort()); // Port එකක් නැත්නම් -1 එනවා
            System.out.println("Path: " + facebookURL.getPath());
            System.out.println("Query: " + facebookURL.getQuery()); // Query එකක් නැත්නම් null එනවා
            System.out.println("File: " + facebookURL.getFile());

            System.out.println("\nGoogle එකේ තව URL එකක් බලමු:");
            URL googleSearchURL = new URL("https://www.google.com/search?q=java+urlconnection+tutorial");
            System.out.println("Protocol: " + googleSearchURL.getProtocol());
            System.out.println("Host: " + googleSearchURL.getHost());
            System.out.println("Path: " + googleSearchURL.getPath());
            System.out.println("Query: " + googleSearchURL.getQuery());

        } catch (MalformedURLException e) {
            System.err.println("URL එක වැරදියි: " + e.getMessage());
        }
    }
}

මේ Code එක Run කරාම ඔයාලට පේනවා URL Object එකෙන් අපිට ඒ URL එකේ විවිධ කොටස් (Protocol, Host, Port, Path, Query, File) වෙන වෙනම ගන්න පුළුවන් කියලා. මේවා අපිට විවිධ Task වලට වැදගත් වෙනවා.

2. URLConnection එකට සම්බන්ධ වෙමු! (URLConnection: The Bridge to the Resource)

හරි, දැන් අපි URL එක මොකක්ද කියලා දන්නවා. ඒත් URL එකෙන් විතරක් අපිට Web එකෙන් Data අදින්න බැහැ. ඒක හරියට Address එක දන්නවා වගේ, ඒත් ඒ ගෙදරට ගිහින් දොර ඇරලා ඇතුලට යන වැඩේ කරන්න බැහැ වගේ. අන්න ඒ වැඩේට තමයි අපිට URLConnection එක ඕනේ වෙන්නේ.

java.net.URLConnection Class එක පාවිච්චි කරන්නේ URL එකකින් Represent කරන Resource එකට Connection එකක් Establish කරලා, ඒ Resource එකෙන් Data කියවන්න (read) නැත්නම් Data ලියන්න (write) පුළුවන් කරන්නයි. මේක Web Service එකකට Request එකක් යවන්න, Image එකක් Download කරන්න, නැත්නම් Web Page එකක Content එක කියවන්න වගේ දේවල් වලට පාවිච්චි කරන්න පුළුවන්.

URLConnection එකක් හදන හැටි සහ Data කියවන හැටි

URLConnection එකක් හදන්න ඕන නම්, මුලින්ම URL Object එකක් හදලා, ඒකේ openConnection() Method එක Call කරන්න ඕනේ. මේ Method එකෙන් URLConnection Object එකක් Return කරනවා. ඊට පස්සේ අපිට ඒ Connection එකෙන් InputStream එකක් අරන් Data කියවන්න පුළුවන්.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.URLConnection;

public class URLConnectionReader {
    public static void main(String[] args) {
        try {
            // කියවන්න ඕන URL එක දෙමු
            URL google = new URL("https://www.google.com");

            // Connection එක Open කරමු
            URLConnection connection = google.openConnection();

            // Connection එකෙන් Data කියවන්න InputStream එකක් ගමු
            // InputStreamReader එකෙන් bytes character stream එකක් බවට convert කරනවා
            // BufferedReader එකෙන් characters effectively කියවන්න පුළුවන්
            BufferedReader in = new BufferedReader(
                                    new InputStreamReader(connection.getInputStream()));

            String inputLine;
            StringBuilder content = new StringBuilder();
            
            // Line by line කියවමු
            while ((inputLine = in.readLine()) != null) {
                content.append(inputLine).append("\n");
            }
            in.close(); // InputStream එක වහන්න අමතක කරන්න එපා!

            // කියවපු Content එක Print කරමු
            System.out.println("Google.com එකෙන් කියවපු Content එක:\n");
            System.out.println(content.toString().substring(0, Math.min(content.length(), 500))); // මුල් අකුරු 500 විතරක් print කරමු
            System.out.println("...ඉතුරු කොටස...");

        } catch (IOException e) {
            System.err.println("Web එකෙන් Data කියවීමේ ගැටලුවක්: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

මේ Code එකෙන් google.com එකට Connect වෙලා, ඒකේ HTML Source Code එක කියවලා Console එකේ Print කරනවා. අප්පච්චි, මේකෙන් අපිට ඕනම Website එකක Source Code එක බලන්න පුළුවන් නේද? එතකොට Web Scraping වගේ දේවල් වලට මේක හොඳටම පාවිච්චි කරන්න පුළුවන්.

3. පොඩි Advanced Tips ටිකක්! (Some Advanced Tips for URLConnection)

URL සහ URLConnection කියන්නේ Java වල Web Data Handling වලට තියෙන Basic Tools. හැබැයි මේවා පාවිච්චි කරනකොට අපිට තව පොඩි Tips ටිකක් දැනගෙන හිටියොත් වැඩේ ලේසි වෙනවා.

HTTP Specific Operations: HttpURLConnection

අපි බොහෝ වෙලාවට වැඩ කරන්නේ HTTP (Hypertext Transfer Protocol) නැත්නම් HTTPS (Secure HTTP) Protocol එකත් එක්ක නේ. URLConnection කියන්නේ General Class එකක්. හැබැයි HTTP Request වලට විතරක් විශේෂිත Operations කරන්න පුළුවන් Subclass එකක් තියෙනවා: ඒ තමයි java.net.HttpURLConnection.

මේකෙන් අපිට HTTP Response Codes (200 OK, 404 Not Found, 500 Internal Server Error වගේ), Request Methods (GET, POST, PUT, DELETE), Headers වගේ දේවල් Manage කරන්න පුළුවන්. අපිට URLConnection Object එකක් HttpURLConnection එකකට Cast කරගන්න පුළුවන්, හැබැයි URL එක HTTP/HTTPS Protocol එකකින් තියෙන්න ඕනේ.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;

public class HttpURLConnectionDemo {
    public static void main(String[] args) {
        try {
            URL url = new URL("https://jsonplaceholder.typicode.com/todos/1"); // Free API එකක්
            HttpURLConnection httpConnection = (HttpURLConnection) url.openConnection();

            // Request Method එක GET විදිහට Set කරමු
            httpConnection.setRequestMethod("GET");
            
            // Connection Timeout එක Set කරමු (milliseconds)
            httpConnection.setConnectTimeout(5000); // 5 seconds
            httpConnection.setReadTimeout(5000); // 5 seconds

            int responseCode = httpConnection.getResponseCode();
            System.out.println("Response Code: " + responseCode);
            System.out.println("Response Message: " + httpConnection.getResponseMessage());

            if (responseCode == HttpURLConnection.HTTP_OK) { // HTTP 200 OK
                BufferedReader in = new BufferedReader(
                        new InputStreamReader(httpConnection.getInputStream()));
                String inputLine;
                StringBuilder content = new StringBuilder();
                while ((inputLine = in.readLine()) != null) {
                    content.append(inputLine);
                }
                in.close();
                System.out.println("API Response:\n" + content.toString());
            } else {
                System.out.println("Request Failed!");
            }
            httpConnection.disconnect(); // Connection එක Disconnect කරන්න අමතක කරන්න එපා

        } catch (IOException e) {
            System.err.println("Error connecting or reading: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

මේ Code එකෙන් අපි jsonplaceholder.typicode.com කියන Free API එකකට GET Request එකක් යවලා, ඒකෙන් එන Response එක කියවනවා. මෙතනදී අපි setConnectTimeout() සහ setReadTimeout() පාවිච්චි කරලා Connection එකට සහ Data කියවන්න පුළුවන් උපරිම කාලයත් දීලා තියෙනවා. මොකද Network එක slow වුනොත් අපේ Program එකට එන Error වලක්වා ගන්න මේක වැදගත්.

වැදගත් Notes:

• Error Handling: හැමවෙලේම try-catch Blocks පාවිච්චි කරන්න අමතක කරන්න එපා. Network Operations වලදී IOException වගේ Errors එන්න පුළුවන්.
• Resource Closing: InputStream, OutputStream වගේ Streams පාවිච්චි කරලා ඉවර වුනාම, close() Method එකෙන් ඒවා වහන්න අමතක කරන්න එපා. නැත්නම් Resource Leaks වෙන්න පුළුවන්. Java 7 වල ඉඳන් තියෙන try-with-resources Statement එක මේකට ගොඩක් උදව් වෙනවා.
• Advanced Use Cases: සරල Request වලට URLConnection හොඳයි. ඒත් Complex Request (Custom Headers, Form Data POST කිරීම, File Uploads) වගේ ඒවාට Apache HttpClient වගේ Third-Party Libraries පාවිච්චි කරන එක ලේසියි. Java 11 වල ඉඳන් java.net.http.HttpClient කියන නව API එකත් තියෙනවා, ඒක තව ගොඩක් Modern සහ Effective. ඒ ගැන අපි වෙන දවසක කතා කරමු!

අවසන් වචන

ඔන්න ඉතින් අද අපි Java වල URL සහ URLConnection කියන Super Classes දෙක ගැන ගොඩක් දේවල් ඉගෙන ගත්තා. Web එකෙන් Data Fetch කරන එකට මේවා කොච්චර වැදගත්ද කියලා දැන් ඔයාලට පැහැදිලි ඇති නේද? Basic Web Interaction වලට මේ Classes දෙක හොඳටම ප්‍රමාණවත්. මේ Article එක කියවලා ඔයාලත් මේ Code ටික Try කරලා බලන්න. තමන්ගේම Projects වලට මේ Knowledge එක Apply කරගන්න. එතකොට තමයි හොඳටම Practice වෙන්නේ.

මේ ගැන ඔයාලට මොනවා හරි ප්‍රශ්න තියෙනවා නම්, නැත්නම් මේ වගේ තව මොනවා ගැනද දැනගන්න ඕන කියලා Comment Section එකේ කියන්න. ඔයාලගේ අදහස් දැනගන්න අපි කැමතියි. එහෙනම් තවත් Article එකකින් හමුවෙමු! Happy Coding!