Java Networking Basics - IP, Ports, Sockets | Java ජාලකරණ මූලිකාංග

Java Networking Basics - IP, Ports, Sockets | Java ජාලකරණ මූලිකාංග

ජාලකරණය (Networking) කියන්නේ මොකද්ද? Java එක්ක ඒක කරන්නේ කොහොමද?

මචන්ලා, කොහොමද ඉතින් ඔයාලට? අද මම ඔයාලත් එක්ක කතා කරන්න යන්නේ මේ Software Engineering ක්ෂේත්‍රයේ, විශේෂයෙන්ම Java Programming වලදී, නැතුවම බැරි වැදගත් මාතෘකාවක් ගැන – ඒ තමයි Networking.

දැන් බලන්නකෝ, ඔයා ෆේස්බුක් යනවා, YouTube බලනවා, Online Game එකක් ගහනවා, නැත්නම් Bank එකක App එකක් පාවිච්චි කරනවා. මේ හැමදේකම පදනම තමයි Networking. ඔයාගේ ෆෝන් එක, ලැප්ටොප් එක, ටැබ්ලට් එක, මේ හැම එකක්ම එකිනෙකා එක්ක කතා කරන්නේ, Data හුවමාරු කරගන්නේ මේ Networking කියන සංකල්පය හරහායි. Java කියන්නේ Enterprise Applications, Web Servers, Distributed Systems වගේ දේවල් හදන්න නියම භාෂාවක් නිසා, Networking ගැන දැනගෙන ඉන්න එක Java Developer කෙනෙක්ට අනිවාර්යයි.

ඉතින්, මේ Post එකෙන් අපි Networking වල මූලිකාංග ටිකක් විස්තරාත්මකව බලමු. IP Addresses, Ports, Sockets, සහ Client-Server Communication වගේ දේවල් Java වලින් කොහොමද Implement කරන්නේ කියලා අපි කෝඩ් එක්කම කතා කරමු. බය වෙන්න එපා, සරලව තේරෙන විදියට කියල දෙන්නම්.

1. IP Addresses සහ Ports - ඇඩ්ඩ්‍රස් එකයි දොරටුවයි

ඔයාගේ ගෙදරට ඇඩ්ඩ්‍රස් එකක් තියෙනවා වගේම, Computer Network එකක තියෙන හැම Device එකකටම තියෙනවා අද්විතීය හඳුනාගැනීමේ අංකයක්. මේකට තමයි IP Address (Internet Protocol Address) කියන්නේ. මේක නැතිව Network එකක Device එකකට තවත් Device එකක් එක්ක කතා කරන්න බෑ.

IP Addresses (Internet Protocol Addresses)

සරලවම කිව්වොත්, IP Address එකක් කියන්නේ Network එකක තියෙන Device එකක් (Computer, Phone, Server) හඳුනාගන්න පාවිච්චි කරන අංකයක්. මේක සාමාන්‍යයෙන් 192.168.1.1 වගේ දශම අංක හතරක් තිත් වලින් වෙන් කරලා ලියලා තියෙනවා. මේවා IPv4 addresses. හැබැයි දැන් Device ගාණ වැඩි නිසා, IPv6 addresses (2001:0db8:85a3:0000:0000:8a2e:0370:7334 වගේ) කියන අලුත් Address System එකක් පාවිච්චි කරනවා.

IP Addresses ප්‍රධාන වශයෙන් කොටස් දෙකකට බෙදෙනවා:

  • Public IP Address: මේවා Internet එකට කෙලින්ම සම්බන්ධ වෙලා තියෙන Device වලට තියෙනවා. මේ IP Address එකෙන් තමයි ඔයාගේ ගෙදර Internet Connection එක Internet එකේදී හඳුනාගන්නේ.
  • Private IP Address: මේවා Local Network එකක් (ගෙදර Network එකක්, Office Network එකක්) ඇතුළේ Device වලට දෙන IP Addresses. මේවා Internet එකට කෙලින්ම යන්නේ නෑ. උදාහරණයක් විදියට ඔයාගේ Wi-Fi Router එකට සම්බන්ධ වෙලා තියෙන Phone එකට, Laptop එකට ලැබෙන්නේ Private IP Addresses.

Ports (ජාල දොරටු)

හරි, IP Address එකෙන් අපි දැනගන්නවා Data යවන්න ඕන Device එක මොකක්ද කියලා. හැබැයි ඒ Device එකේ එකම වෙලාවෙදී Application ගොඩක් Run වෙනවා වෙන්න පුළුවන් (Web Browser එක, Game එක, Email Client එක). එතකොට, අපි යවන Data එක හරියටම යන්න ඕන Application එකට යවන්නේ කොහොමද?

මෙන්න මේකට තමයි Ports පාවිච්චි කරන්නේ. Port එකක් කියන්නේ නිශ්චිත Process එකක් හෝ Service එකක් හඳුනාගන්න පාවිච්චි කරන අංකයක්. හරියට ඔයාගේ ගෙදරට ඇතුල් වෙන්න දොරවල් කිහිපයක් තියෙනවා වගේ, එකම Computer එකේ තියෙන විවිධ Application වලට Ports තියෙනවා. උදාහරණයක් විදියට:

  • Port 80: HTTP (Web Browsing) වලට.
  • Port 443: HTTPS (Secure Web Browsing) වලට.
  • Port 21: FTP (File Transfer Protocol) වලට.

Ports 0 ඉඳන් 65535 දක්වා තියෙනවා. මේවා පාවිච්චි කරන විදිය අනුව කොටස් කිහිපයකට බෙදෙනවා:

  • Well-Known Ports (0-1023): මේවා බහුලව පාවිච්චි කරන Services (HTTP, FTP, SSH) වලට වෙන් කරලා තියෙන Ports.
  • Registered Ports (1024-49151): මේවා විවිධ Application වලට Registered වෙලා තියෙන Ports.
  • Dynamic/Private Ports (49152-65535): මේවා Client Applications වලට තාවකාලිකව පාවිච්චි කරන්න පුළුවන් Ports.

2. Sockets - සම්බන්ධතාවේ හදවත

IP Address එකයි Port එකයි කියන්නේ එකිනෙකා එක්ක කතා කරන්න අවශ්‍ය වන ලිපිනයන්. හැබැයි මේ ලිපිනයන් හරහා ඇත්තටම Data යවා ගන්න, Data ලබා ගන්න අපිට ඕන වෙනවා Socket එකක්. Socket එකක් කියන්නේ Network Connection එකක Endpoint එකක්. හරියට දුරකථන සංවාදයක් පටන් ගන්න අපිට දුරකථන දෙකක් ඕන වෙනවා වගේ, Network එකක කතා කරන්නත් Sockets දෙකක් ඕන වෙනවා.

Java වලදී, Network Communication කරන්න අපි java.net Package එකේ තියෙන Classes පාවිච්චි කරනවා. Sockets ප්‍රධාන වශයෙන් වර්ග දෙකක් තියෙනවා:

  • TCP Sockets (Transmission Control Protocol): මේවා Reliable, Ordered, සහ Error-Checked Data Delivery එකක් ලබා දෙනවා. Data නැති වෙන්නේ නෑ, හරියට පිළිවෙලට යනවා. Web Browsing, Email වගේ දේවල් වලට මේවා පාවිච්චි කරනවා. (අපි මේ Post එකේදී වැඩිපුර අවධානය යොමු කරන්නේ TCP Sockets ගැනයි).
  • UDP Sockets (User Datagram Protocol): මේවා Fastest Communication වලට හොඳයි, හැබැයි Data නැති වෙන්න පුළුවන්. Video Streaming, Online Gaming වගේ දේවල් වලට මේවා පාවිච්චි කරනවා.

TCP Communication එකකදී, Server එකේ Socket එකක් Client එකක Socket එකක් එක්ක Connection එකක් හදාගන්නවා. මේ Connection එක හරහා තමයි Data හුවමාරු කරගන්නේ.

3. Client-Server Communication - කතා කරන විදිය

බොහෝමයක් Network Applications වැඩ කරන්නේ Client-Server Model එකට අනුවයි. මෙතනදී:

  • Server: මේක තමයි Services ලබා දෙන Program එක. මේක සාමාන්‍යයෙන් Computer එකක Run වෙමින්, යම්කිසි Port එකක Listen කරමින් ඉන්නවා Client කෙනෙක්ගෙන් Connection එකක් එනකල්.
  • Client: මේක තමයි Server එකෙන් Services ඉල්ලන Program එක. මේක Server එකේ IP Address එකටයි, Port එකටයි Connect වෙලා තමන්ට අවශ්‍ය Service එක ඉල්ලනවා.

මේක තේරුම් ගන්න අපි සරල Client-Server Application එකක් හදමු. මේකෙන් වෙන්නේ Client එකෙන් Server එකට Message එකක් යවනවා, Server එක ඒ Message එක Client එකටම Echo කරලා (ආපහු යවලා) පෙන්නනවා. අපි Server එකට SimpleEchoServer කියලත්, Client එකට SimpleEchoClient කියලත් නම් කරමු.

සරල Echo Server එකක් හදමු (SimpleEchoServer.java)

මේ Server එකෙන් වෙන්නේ Port එකක් Listener කරලා, Client කෙනෙක් සම්බන්ධ වුණාම, Client එකෙන් එන Message එක ආපහු Client එකටම යවන එක. `bye` කියලා යැව්වොත් Client එක Disconnect වෙනවා.


import java.io.*;
import java.net.*;

public class SimpleEchoServer {
    public static void main(String[] args) {
        int port = 6000; // අපි 6000 කියන Port එක පාවිච්චි කරමු

        try (ServerSocket serverSocket = new ServerSocket(port)) {
            System.out.println("Server listening on port " + port);

            while (true) { // Server එක දිගටම Client Connections බලාපොරොත්තුවෙන් ඉන්නවා
                Socket clientSocket = serverSocket.accept(); // Client කෙනෙක් Connect වෙනකල් ඉන්නවා
                System.out.println("New client connected: " + clientSocket.getInetAddress().getHostAddress());

                // Client එකත් එක්ක කතා කරන්න Streams හදාගමු
                try (BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
                     PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true)) {

                    String inputLine;
                    while ((inputLine = in.readLine()) != null) { // Client එකෙන් Message එනකල් කියවනවා
                        System.out.println("Received from client: " + inputLine);
                        out.println("Server Echo: " + inputLine); // Client එකට ආපහු යවනවා
                        if (inputLine.equals("bye")) { // Client එක 'bye' කිව්වොත් Connection එක කඩනවා
                            break;
                        }
                    }
                    System.out.println("Client disconnected: " + clientSocket.getInetAddress().getHostAddress());
                } catch (IOException e) {
                    System.out.println("Error handling client: " + e.getMessage());
                } finally {
                    clientSocket.close(); // Client Socket එක වහනවා
                }
            }
        } catch (IOException e) {
            System.out.println("Server exception: " + e.getMessage());
        }
    }
}

මේ කෝඩ් එකේදී වැදගත් දේවල් කිහිපයක්:

  • ServerSocket serverSocket = new ServerSocket(port);: මේකෙන් Server එකට නිශ්චිත Port එකක Listen කරන්න කියනවා.
  • serverSocket.accept();: මේ Method එකෙන් Server එක Client කෙනෙක් Connect වෙනකල් බලාගෙන ඉන්නවා. Client කෙනෙක් Connect වුණාම අලුත් Socket Object එකක් හදනවා ඒ Client එකත් එක්ක කතා කරන්න.
  • BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));: Client එකෙන් එන Data කියවන්න මේක පාවිච්චි කරනවා.
  • PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);: Client එකට Data යවන්න මේක පාවිච්චි කරනවා. true කියන්නේ Auto-Flush කරන්න කියන එක, ඒ කියන්නේ Data යවපු ගමන් Buffer එකෙන් Clear වෙනවා.

සරල Echo Client එකක් හදමු (SimpleEchoClient.java)

මේ Client එකෙන් වෙන්නේ Server එකට Connect වෙලා, User ගෙන් Input අරගෙන Server එකට යවන එක, Server එකෙන් එන Reply එක Console එකේ Print කරන එක.


import java.io.*;
import java.net.*;
import java.util.Scanner;

public class SimpleEchoClient {
    public static void main(String[] args) {
        String hostname = "localhost"; // Server එකේ IP Address එක හෝ Hostname එක. අපේ Server එක මේ Computer එකේම Run වෙන නිසා "localhost" දානවා.
        int port = 6000; // Server එක Listen කරන Port එක.

        try (Socket socket = new Socket(hostname, port); // Server එකට Connect වෙනවා
             PrintWriter out = new PrintWriter(socket.getOutputStream(), true); // Server එකට Data යවන්න
             BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream())); // Server එකෙන් එන Data කියවන්න
             Scanner scanner = new Scanner(System.in)) { // User Input ගන්න

            System.out.println("Connected to the echo server. Type 'bye' to exit.");

            String userInput;
            while (true) {
                System.out.print("You: ");
                userInput = scanner.nextLine(); // User ගෙන් Input ගන්නවා
                out.println(userInput); // Server එකට යවනවා

                String serverResponse = in.readLine(); // Server එකෙන් එන Reply එක කියවනවා
                System.out.println("Server: " + serverResponse);

                if (userInput.equals("bye")) { // User 'bye' කිව්වොත් Disconnect වෙනවා
                    break;
                }
            }
            System.out.println("Disconnected from server.");

        } catch (UnknownHostException e) {
            System.out.println("Server not found: " + e.getMessage());
        } catch (IOException e) {
            System.out.println("I/O error: " + e.getMessage());
        }
    }
}

මේ කෝඩ් එකේදී වැදගත් දේවල්:

  • Socket socket = new Socket(hostname, port);: මේකෙන් Server එකේ IP Address එකයි, Port එකයි දීලා Connect වෙනවා.
  • ඉතිරි කොටස Server Code එකේදී වගේම InputStream/OutputStream පාවිච්චි කරලා Data කියවන, යවන එක.

මේක Run කරන්නේ කොහොමද?

  1. මුලින්ම SimpleEchoServer.java compile කරලා run කරන්න. (Terminal එකක: javac SimpleEchoServer.java, ඊටපස්සේ java SimpleEchoServer). මේක Server listening on port 6000 කියලා පෙන්වාවි.
  2. ඊටපස්සේ තවත් Terminal එකක් open කරලා SimpleEchoClient.java compile කරලා run කරන්න. (javac SimpleEchoClient.java, ඊටපස්සේ java SimpleEchoClient).
  3. Client Terminal එකේ ඔයාට ඕන Message එකක් Type කරලා Enter කරන්න. ඒ Message එක Server Terminal එකේ Print වෙලා, ආපහු Server Echo: Message එක Client Terminal එකේ පෙන්වයි.
  4. 'bye' කියලා Type කරලා Enter කලාම Client එක Disconnect වෙනවා.

අවසන් වශයෙන්

ඉතින් මචන්ලා, අද අපි කතා කලේ Java වල Networking වල මූලිකාංග ගැන. IP Addresses, Ports, Sockets වගේ දේවල් මොනවද, ඒවට මොනවද කරන්නේ කියලා ඔයාලට දැන් හොඳ අවබෝධයක් ඇති කියලා හිතනවා. ඒ වගේම, සරල Client-Server Application එකක් Java වලින් කොහොමද හදන්නේ කියලා අපි Code එක්කම බැලුවා.

මේක Networking වල මුලිකම පියවරක් විතරයි. මේකෙන් එහාට ගොඩක් දේවල් තියෙනවා ඉගෙන ගන්න. Threads පාවිච්චි කරලා එකවර Clientලා ගොඩකට Handle කරන විදිය, Serialization, Deserialization, HTTP Client Libraries (Apache HttpClient, OkHttp) වගේ දේවල් ගැනත් ඔයාලට ඉදිරියේදී ඉගෙන ගන්න පුළුවන්.

මේ Post එකෙන් ඔයාලට අලුත් දෙයක් ඉගෙන ගන්න ලැබුණා නම්, අදහස්, යෝජනා, ප්‍රශ්න තියෙනවා නම්, කමෙන්ට් සෙක්ෂන් එකේ කියන් යමු! මේ කෝඩ් ටික ඔයාලගේම Computer එකේ Run කරලා බලන්න. එතකොට තව හොඳට තේරෙයි. තවත් අලුත් Post එකකින් හමුවෙමු, හැමෝටම ජය වේවා!