How to Make Serversocket Wait Again

TCP Sockets Server/Client - 2020

---

bogotobogo.com site search:

---

TCP Sockets Server/Client

In this chapter, we are working with programs which run on different machines. Considering a programme on ane machine cannot directly reference object in a plan running on other machines, nosotros need to from a communication network with assistance from the OS. We telephone call it network channel.

When two threads want to exchange bulletin over the channel, each thread create an endpoint object that represents its end of the network aqueduct. The OS manages the hardware and software that is used to transport messages across the channel (between the endpoints). What do nosotros call those endpoint objects? They are sockets.

1. The client thread's socket specifies a local I/O port for sending letters. The client's socket should specify the address of the destination machine likewise every bit the port number that is expected to be bound to the server thread's socket.
2. The server's socket also should specify a local I/O port to receive messages. Messages tin can exist received from any client, as far as the customer automobile knows the server's address and the port number which are bound to the server's socket.
3. The customer issues a request to the server to make a connection between the two sockets. Once the server accepts the connection request, letters tin be passed in both directions across the aqueduct.

Java TCP Sockets

The java.internet class library provides classes Socket and ServerSocket for message passing for TCP/IP. Here, we'll employ a very simple client and server example to show the use of TCP socket in Coffee.

1. Class Socket

   // Client Side import java.io.*; import java.net.*;  public class ClientSocket {   public void run() { 	attempt { 		int serverPort = 4020; 		InetAddress host = InetAddress.getByName("localhost");  		Arrangement.out.println("Connecting to server on port " + serverPort);   		Socket socket = new Socket(host,serverPort);  		//Socket socket = new Socket("127.0.0.1", serverPort); 		Arrangement.out.println("But connected to " + socket.getRemoteSocketAddress());  		PrintWriter toServer =  			new PrintWriter(socket.getOutputStream(),true); 		BufferedReader fromServer =  			new BufferedReader( 					new InputStreamReader(socket.getInputStream())); 		toServer.println("Hello from " + socket.getLocalSocketAddress());  		Cord line = fromServer.readLine(); 		System.out.println("Customer received: " + line + " from Server"); 		toServer.close(); 		fromServer.shut(); 		socket.shut(); 	} 	take hold of(UnknownHostException ex) { 		ex.printStackTrace(); 	} 	catch(IOException e){ 		e.printStackTrace(); 	}   } 	   public static void main(String[] args) { 		ClientSocket client = new ClientSocket(); 		customer.run();   } }            

   The client assumes that the server is listening for connexion request on port serverPort via TCP.
   

   int serverPort = 4020; InetAddress host = InetAddress.getByName("localhost");  Socket socket = new Socket(host,serverPort);            

   The Socket constructor throws an IOException if information technology cannot make a connection.
   

   catch(IOException east){ 		e.printStackTrace(); }            

   When the client's asking is accepted, the customer creates an input stream to receive data from its socket and an output stream to transport data to the socket at the server's end of the channel. To the programmer, sending and receiving messages using sockets appears just like reading and writing data from files.

   PrintWriter toServer =  	new PrintWriter(socket.getOutputStream(),true); BufferedReader fromServer =  	new BufferedReader( 			new InputStreamReader(socket.getInputStream())); toServer.println("Hello from " + socket.getLocalSocketAddress());  String line = fromServer.readLine(); System.out.println("Client received: " + line + " from Server");            

2. Class Server Socket

   The server begins by creating a ServerSocket:

   int serverPort = 4020; ServerSocket serverSocket = new ServerSocket(serverPort);            

   Hither is the server side code:

   // Server Side import java.net.*; import java.io.*;  public class ServerSideSocket {    public void run() { 	attempt { 		int serverPort = 4020; 		ServerSocket serverSocket = new ServerSocket(serverPort); 		serverSocket.setSoTimeout(10000);  		while(true) { 			System.out.println("Waiting for client on port " + serverSocket.getLocalPort() + "...");   			Socket server = serverSocket.have(); 			Arrangement.out.println("Merely connected to " + server.getRemoteSocketAddress());   			PrintWriter toClient =  				new PrintWriter(server.getOutputStream(),true); 			BufferedReader fromClient = 				new BufferedReader( 						new InputStreamReader(server.getInputStream())); 			Cord line = fromClient.readLine(); 			System.out.println("Server received: " + line);  			toClient.println("Thanks for connecting to " + server.getLocalSocketAddress() + "\nGoodbye!");  		} 	} 	catch(UnknownHostException ex) { 		ex.printStackTrace(); 	} 	catch(IOException e){ 		e.printStackTrace(); 	}   } 	   public static void main(Cord[] args) { 		ServerSideSocket srv = new ServerSideSocket(); 		srv.run();   } }

   And then the timeout expires, a coffee.net.SocketTimeoutException is raised and the Socket is still valid.

   Later creating ServerSocket, the server calls have() method of the ServerSocket in order to listen for incoming connectedness requests from clients.

   Socket server = serverSocket.accept();            

   Method accept() wait until a client requests a connectedness; then it returns a Socket that connects the client to the server. The server so gets input and output streams from the Socket and uses them to communicate with the client.
   When the interaction ends, the customer, server, or both, shut the connectedness, and the server waits for a connection asking from another customer.
   

Hither are the communications between server and client.

Methods of Socket Class

The java.net.Socket course represents the socket that both the client and server use to communicate with each other. The customer obtains a Socket object by instantiating one, whereas the server obtains a Socket object from the return value of the accept() method.

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

1. public Socket(String host, int port) throws UnknownHostException, IOException.
   This method attempts to connect to the specified server at the specified port. If this constructor does not throw an exception, the connectedness is successful and the client is continued to the server.
2. public Socket(InetAddress host, int port) throws IOException.
   This method is identical to the previous constructor, except that the host is denoted by an InetAddress object.
3. public Socket(InetAddress host, int port, InetAddress localAddress, int localPort) throws IOException.
   This method is identical to the previous constructor, except that the host is denoted past an InetAddress object instead of a String.
4. public Socket(String host, int port, InetAddress localAddress, int localPort) throws IOException.
   Connects to the specified host and port, creating a socket on the local host at the specified address and port.
5. public Socket()
   Creates an unconnected socket. Use the connect() method to connect this socket to a server.

When the Socket constructor returns, it does non simply instantiate a Socket object but it actually attempts to connect to the specified server and port.

These methods tin can be invoked past both the client and server since both the customer and server have a Socket object.

1. public void connect(SocketAddress host, int timeout) throws IOException
   This method connects the socket to the specified host. This method is needed just when y'all instantiated the Socket using the no-statement constructor.
2. public int getPort()
   Returns the port the socket is spring to on the remote machine.
3. public InetAddress getInetAddress()
   This method returns the address of the other estimator that this socket is connected to.
4. public int getLocalPort()
   Returns the port the socket is bound to on the local automobile.
5. public SocketAddress getRemoteSocketAddress()
   Returns the address of the remote socket.
6. public InputStream getInputStream() throws IOException
   Returns the input stream of the socket. The input stream is connected to the output stream of the remote socket.
7. public OutputStream getOutputStream() throws IOException
   Returns the output stream of the socket. The output stream is connected to the input stream of the remote socket.
8. public void close() throws IOException
   Closes the socket, which makes this Socket object no longer capable of connecting once again to whatsoever server.

Methods of ServerSocket Form

The coffee.net.ServerSocket class is used by server applications to obtain a port and listen for client requests.

The ServerSocket class has four constructors:

1. public ServerSocket(int port) throws IOException.
   Attempts to create a server socket bound to the specified port. An exception occurs if the port is already leap by another application.
2. public ServerSocket(int port, int backlog) throws IOException.
   Similar to the previous constructor, the backlog parameter specifies how many incoming clients to shop in a wait queue.
3. public ServerSocket(int port, int excess, InetAddress address) throws IOException.
   Similar to the previous constructor, the InetAddress parameter specifies the local IP accost to demark to. The InetAddress is used for servers that may have multiple IP addresses, allowing the server to specify which of its IP addresses to accept client requests on.
4. public ServerSocket() throws IOException.
   Creates an unbound server socket. When using this constructor, use the bind() method when you are ready to bind the server socket.

If the ServerSocket constructor does not throw an exception, it means that your awarding has successfully bound to the specified port and is set up for client requests.

Hither are some of the common methods of the ServerSocket class:

1. public int getLocalPort()
   Returns the port that the server socket is listening on. This method is useful if you lot passed in 0 as the port number in a constructor and allow the server observe a port for you.
2. public Socket accept() throws IOException
   Waits for an incoming client. This method blocks until either a customer connects to the server on the specified port or the socket times out, assuming that the time-out value has been set using the setSoTimeout() method. Otherwise, this method blocks indefinitely.
3. public void setSoTimeout(int timeout)
   Sets the time-out value for how long the server socket waits for a client during the accept().
4. public void bind(SocketAddress host, int backlog)
   Binds the socket to the specified server and port in the SocketAddress object. Utilise this method if you instantiated the ServerSocket using the no-statement constructor.

When the ServerSocket invokes accept(), the method does non render until a client connects. Subsequently a client does connect, the ServerSocket creates a new Socket on an unspecified port and returns a reference to this new Socket. A TCP connection at present exists betwixt the client and server, and advice can brainstorm.

Methods of InetAddress Class

This class represents an Internet Protocol (IP) address. Here are following useful methods which y'all would demand while doing socket programming:

1. String getHostName()
   Gets the host proper noun for this IP address.
2. static InetAddress InetAddress getLocalHost()
   Returns the local host.
3. String toString()
   Converts this IP address to a String.
4. static InetAddress getByAddress(byte[] addr)
   Returns an InetAddress object given the raw IP accost .
5. static InetAddress getByAddress(String host, byte[] addr)
   Create an InetAddress based on the provided host name and IP address.
6. static InetAddress getByName(String host)
   Determines the IP address of a host, given the host'due south proper noun.
7. Cord getHostAddress()
   Returns the IP address string in textual presentation.

TCP Sockets Server/Customer - Serialize Message Objects Passing Example

The following example demonstrates message passing betwixt a client and server plan using TCP sockets. The Message objects are serialized and passed through the connection aqueduct.

The customer sends a Message containing the integer n, the server replies with a message containing n*n. The customer gets due north from the statement.

The client program, Client.java is:

import java.io.*; import java.net.*;  public class Client {   public static void main(String[] args) { 		int serverPort = 4020; 		Socket socket = zero; 		ObjectOutputStream toServer = zero; 		ObjectInputStream fromServer = naught; 		attempt { 			if(args.length != i) { 				System.out.println("Need 1 argument"); 				System.exit(1); 			} 			int number = Integer.parseInt(args[0]); 			InetAddress serverHost = InetAddress.getByName("localhost");  			System.out.println("Connecting to server on port " + serverPort);  			socket = new Socket(serverHost,serverPort);  			Organisation.out.println("Only connected to " + socket.getRemoteSocketAddress());  			toServer = new ObjectOutputStream( 					new BufferedOutputStream(socket.getOutputStream())); 			Message msgToSend = new Message(number); 			toServer.writeObject(msgToSend); 			toServer.flush(); 			 			// This will block until the respective ObjectOutputStream  			// in the server has written an object and flushed the header 			fromServer = new ObjectInputStream( 					new BufferedInputStream(socket.getInputStream())); 			Bulletin msgFromReply = (Message)fromServer.readObject(); 			System.out.println(number + " * " + number + " = " + msgFromReply.number); 		} 		catch(IOException e) { 			e.printStackTrace(); 			System.exit(1); 		} 		grab(ClassNotFoundException e) { 			e.printStackTrace(); 			System.exit(1); 		} 		finally { 			if(socket != zilch) { 				try { 					socket.close(); 				} 				catch(IOException e) { 					east.printStackTrace(); 				} 			} 		} 	} }        

Server program, Server.java:

import java.io.*; import coffee.net.*;  public class Server {    public static void main(String[] args) { 		int serverPort = 4020; 		ServerSocket serverSocket = cipher; 		ObjectOutputStream toClient = zip; 		ObjectInputStream fromClient = null; 		try { 			serverSocket = new ServerSocket(serverPort); 			while(true) { 				Socket socket = serverSocket.accept(); 				Organization.out.println("Just connected to " +  					socket.getRemoteSocketAddress()); 				toClient = new ObjectOutputStream( 					new BufferedOutputStream(socket.getOutputStream())); 				fromClient = new ObjectInputStream( 					new BufferedInputStream(socket.getInputStream())); 				Message msgRequest = (Message) fromClient.readObject(); 				int number = msgRequest.number; 				toClient.writeObject(new Bulletin(number*number)); 				toClient.flush(); 			} 		} 		grab(IOException e) { 			eastward.printStackTrace(); 			System.go out(ane); 		} 		take hold of(ClassNotFoundException e) { 			e.printStackTrace(); 			Organization.get out(1); 		}    } }        

Bulletin program, Message.java:

import java.io.*;  public final class Message implements Serializable { 	public int number; 	Message(int number) { 		this.number = number; 	} }        

If we run, we get:

Using Command Line Arguments in Eclipse

In the above case, the Client.java requires an statement, we need to configure its run. So, correct mouse click on the lawmaking from the Package Workspace.

And then, nosotros get the menus for the run.

Select Arguments tab and then run.

pierceparawascrack.blogspot.com

Source: https://www.bogotobogo.com/Java/tutorials/tcp_socket_server_client.php

Share this post