Java Networking

The word network programming submits to writing plans that carry out across manifold devices (computers), in which the tools are entirely attached to each other with a network.

The java.net wrap-up of the J2SE APIs surrounds a set of classes and lines that supply the low-level communication elements, authorizing you to write plans that center on solving the difficulty at hand.

The java.net enclose offers hold for the two ordinary network protocols −

• TCP − TCP stands for Transmission Control Protocol, which authorizes for consistent communiqué between two requests. TCP is classically exercised over the Internet Protocol, which is submitted to as TCP/IP.
• UDP − UDP stands for User Datagram Protocol, a connection-less protocol that authorizes for packets of statistics to be broadcasted amid applications.

Get the thoughtfulness on the subsequent two subjects −

• Socket Programming − this is the main extensively used notion in Networking and it has been clarified in extremely detail.
• URL Processing − this would be wrapped unconnectedly. Learn in relation to URL Processing in Java language.

Socket Programming

Sockets give the communiqué device amid two computers by TCP. A client plan makes a socket on its closing stages of the communiqué and attempts to join that socket to a server.

When the link is complete, the server generates a socket entity on its end of the statement. The customer and the server can begin to communicate by writing to and reading from the socket.

The java.net.Socket class symbolizes an opening, and the java.net.ServerSocket class supplies an instrument for the server curriculum to snoop for clients and institute associations with them.

The subsequent steps happen when establishing a TCP connection between two computers with sockets −

• The server instantiates a ServerSocket entity, denoting which docks number statement is to happen on.
• The server appealing to the accept() technique of the ServerSocket class. This technique waits to wait for a client to attach to the server on the known port.
• subsequent to the server is coming up, a client instantiates a Socket object, specifies the server name and the docks number to attach to.
• The constructor of the Socket class makes effort to connect the client using the specified server and the docks numbers. If the announcement is found, the client currently has a Socket object competent of communicating with the server.
• On the server elevation, the accept() process returns a position to a new socket on the server that is attached to the client's socket.

After the associations are instituted, communication can happen with I/O streams. Each hole has both an OutputStream and an InputStream. The client's OutputStream is united to the server's InputStream, and the client's InputStream is fixed to the server's OutputStream.

TCP is a two-way message protocol; hence, data can be sent crosswise across both streams at an identical time. Subsequent are the helpful classes if an absolute set of methods to realize sockets.

ServerSocket Class Methods

The java.net.ServerSocket class is employed by server applications to get a port and take note of client demands.

The ServerSocket class has four constructors −

If the ServerSocket constructor does not fling an exception, it signifies that your application has productively bound to the specified harbor and is complete for client requests

Following are some of the common methods of the ServerSocket class −

While the ServerSocket appeal to accept(), the process does not revisit until a client attaches. After a customer does join, the ServerSocket produces a new Socket on an indeterminate port and revisits a position to this original Socket. A TCP link now lives between the customer and the server, and communication can begin.

Socket Class Methods

The java.net.Socket class symbolizes the hole that together the client and the server employed to converse with each other. The client gets a Socket object by instantiating one, while the server gets a Socket object from the revisit value of the accept() method.

The Socket class has five constructors that a client uses to connect to a server −

When the opening constructor revisits, it does not just instantiate a Socket object but it really attempts to attach to the specified server and port.

Some processes of attention in the Socket class are listed here. Notice that together the client and the server have a Socket thing, so these techniques can be appealed to both the client and the server.

InetAddress Class Methods

This class represents an Internet Protocol (IP) address. Here are the following useful methods which you would need while doing socket programming −

Socket Client Example

The following GreetingClient is a client program that connects to a server by using a socket and sends a greeting and then waits for a response.

Example

// File Name GreetingClient.java
import java.net.*;
import java.io.*;

public class GreetingClient {

   public static void main(String [] args) {
      String serverName = args[0];
      int port = Integer.parseInt(args[1]);
      try {
         System.out.println("Connecting to " + serverName + " on port " + port);
         Socket client = new Socket(serverName, port);
         
         System.out.println("Just connected to " + client.getRemoteSocketAddress());
         OutputStream outToServer = client.getOutputStream();
         DataOutputStream out = new DataOutputStream(outToServer);
         
         out.writeUTF("Hello from " + client.getLocalSocketAddress());
         InputStream inFromServer = client.getInputStream();
         DataInputStream in = new DataInputStream(inFromServer);
         
         System.out.println("Server says " + in.readUTF());
         client.close();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

Socket Server Example

The following GreetingServer program is an example of a server application that uses the Socket class to listen for clients on a port number specified by a command-line argument −

Example

// File Name GreetingServer.java
import java.net.*;
import java.io.*;

public class GreetingServer extends Thread {
   private ServerSocket serverSocket;
   
   public GreetingServer(int port) throws IOException {
      serverSocket = new ServerSocket(port);
      serverSocket.setSoTimeout(10000);
   }

   public void run() {
      while(true) {
         try {
            System.out.println("Waiting for client on port " + 
               serverSocket.getLocalPort() + "...");
            Socket server = serverSocket.accept();
            
            System.out.println("Just connected to " + server.getRemoteSocketAddress());
            DataInputStream in = new DataInputStream(server.getInputStream());
            
            System.out.println(in.readUTF());
            DataOutputStream out = new DataOutputStream(server.getOutputStream());
            out.writeUTF("Thank you for connecting to " + server.getLocalSocketAddress()
               + "\nGoodbye!");
            server.close();
            
         } catch (SocketTimeoutException s) {
            System.out.println("Socket timed out!");
            break;
         } catch (IOException e) {
            e.printStackTrace();
            break;
         }
      }
   }
   
   public static void main(String [] args) {
      int port = Integer.parseInt(args[0]);
      try {
         Thread t = new GreetingServer(port);
         t.start();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

Compile the client and the server and then start the server as follows:

$ java GreetingServer 6066
Waiting for client on port 6066...

Check the client program as follows:

Output

$ java GreetingClient localhost 6066
Connecting to localhost on port 6066
Just connected to localhost/127.0.0.1:6066
Server says Thank you for connecting to /127.0.0.1:6066
Goodbye!

Here at Intellinuts, we have created a complete Java tutorial for Beginners to get started in Java.