Java network programming

Java network programming

Network programming is the writing of programs that run on multiple devices (computers) that are connected over the network.

java.net the J2SE API in the package contains classes and interfaces that provide low-level communication details. You can use these classes and interfaces directly to focus on solving problems without paying attention to communication details.

java.net support for two common network protocols is available in the package:

• TCP: TCP is an abbreviation for the transport control protocol, which guarantees reliable communication between the two applications. Typically used in Internet protocols, it is called TCP/IP.
• UDP: UDP is an abbreviation for the user data report protocol, a protocol without a connection. Provides packets of data to be sent between applications.

This tutorial focuses on the following two topics.

• Socket programming: This is the most widely used network concept, and it has been explained in great detail
• URL Processing: This section will be discussed in a separate section, click here to learn more about URL processing in the Java language.

Socket programming

The socket uses TCP to provide a communication mechanism between the two computers. The client program creates a socket and attempts to connect to the server's socket.

When the connection is established, the server creates a Socket object. Clients and servers can now communicate by writing and reading Socket objects.

The java.net.Socket class represents a socket, and the java.net.ServerSocket class provides a mechanism for server programs to listen to and connect clients.

The following steps occur when a TCP connection is made using a socket between two computers:

• The server instantiates a ServerSocket object, which represents communication through the ports on the server.
• The server calls the accept() method of the ServerSocket class, which waits until the client connects to a given port on the server.
• While the server is waiting, a client instantiates a Socket object, specifying the server name and port number to request a connection.
• The constructor of the Socket class tries to connect the client to the specified server and port number. If communication is established, creating a Socket object on the client side can communicate with the server.
• On the server side, the accept() method returns a new socket reference on the server that connects to the client's socket.

TCP is a two - way communication protocol, so data can be sent at the same time through two streams. H ere's a complete set of useful ways to implement sockets that some classes provide.

The method of the ServerSocket class

The server application gets a port by using the java.net.ServerSocket class and listens for client requests.

The ServerSocket class has four construction methods:

Create an unbound server socket. I f the ServerSocket construction method does not throw an exception, it means that your application has successfully bound to the specified port and is listening for client requests.

Here are some common ways to use the ServerSocket class:

The method of the Socket class

The java.net.Socket class represents the sockets that both clients and servers use to communicate with each other. T he client gets a Socket object by instantiation, while the server gets a Socket object through the return value of the accept() method.

The Socket class has five construction methods.

When the Socket construction method returns, and there is no simple instantiation of a Socket object, it actually attempts to connect to the specified server and port.

Here are some methods of interest, noting that both the client and the server have a Socket object, so both the client and the server can call them.

The method of the InetAddress class

This class represents an Internet Protocol (IP) address. Here's a list of some of the more useful methods for Socket programming:

Socket client instance

The following GreenClient is a client program that connects to the server via socket and sends a request, waiting for a response.

// 文件名 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 service-side instance

The following GreenServer program is a server-side application that uses Socket to listen to a specified port.

// 文件名 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 java code above and execute the following command to start the service, using port number 6066:

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

$ 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!