COLLEGE OF COMPUTING AND

INFORMATICS

DEPARTMENT OF SOFTWARE
ENGINEERING

ADVANCED PROGRAMMING IN JAVA [SENG-2033]

BY SAMSON R.
Chapter four
networking
 Contents

 Introduction.
 Socket Programming
 Establishing server using stream socket.
 Establishing client using stream socket.
 Client/server interaction with stream sockets
 Introduction
 The term network programming refers to writing programs
that execute across multiple devices (computers), in which

the devices are all connected to each other using a network.

 Java Networking is a concept of connecting two or more
computing devices together by using java programming so
that we can share resources.

 The java.net package of the Java APIs contains a

collection of classes and interfaces that allow the user to
write network programming.
 Socket Programming
 Sockets provide the communication mechanism between two
computers using TCP and UDP.
 A socket is simply an endpoint for communications between
the machines.
 Java Socket programming is used for communication
between the applications running on different JRE.
 Java Socket programming can be connection-oriented or
connection-less
 Two Communication Models

TCP Socket UDP Socket

 Connection-Oriented  No Connection
 Reliable  No Guarantees(not Reliable)

 No handshake
 Starts With
handshake
 TCP CONNECTION
 A client program creates a socket on its end of the communication
and attempts to connect that socket to a server.
 When the connection is made, the server creates a socket object on its
end of the communication.
 Then client and server can communicate by writing to and reading
from the socket.
 The java.net.Socket class represents a socket, and the
java.net.ServerSocket class provides a mechanism for the server
program to listen for clients and establish connections with them.
 Cont..
The following steps occur when establishing a TCP connection
between two computers using sockets:
 The server instantiates a ServerSocket object, denoting which port
number communication is to occur on.
 The server invokes the accept() method of the ServerSocket class.
This method waits until a client connects to the server on the given
port.
 After the server is waiting, a client instantiates a Socket object,
specifying the server name and port number to connect to.
 Cont..
 The constructor of the Socket class attempts to connect the
client to the specified server and port number.
 If communication is established, the client now has a
Socket object capable of communicating with the server.
 On the server side, the accept() method returns a reference
to a new socket on the server that is connected to the
client's socket.
 Cont..
 After the connections are established, communication can occur
using I/O streams.
 Each socket has both an OutputStream and an InputStream.
 The client's OutputStream is connected to the server's
InputStream, and the client's InputStream is connected to the
server's OutputStream.
 TCP is a two way communication protocol, so data can be sent
across both streams at the same time.
 Cont..
There are following useful classes providing complete set of methods to
implement sockets.
ServerSocket Class
 The java.net.ServerSocket class is used by server applications to obtain
a port and listen for client requests.
Socket Class
 The java.net.Socket class represents the socket that both the client and
server use to communicate with each other.
 The client obtains a Socket object by instantiating one, whereas the server
obtains a Socket object from the return value of the accept() method.
 ServerSocket Class Constructors
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 bound by another
application.

public ServerSocket(int port, int backlog) throws IOException Similar to the previous
constructor, the backlog parameter specifies how many incoming clients to store in a wait
queue.

public ServerSocket(int port, int backlog, InetAddress address) throws IOException

Similar to the previous constructor, the InetAddress parameter specifies the local IP address
to bind 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

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
 ServerSocket Class Methods

public int getLocalPort() Returns the port that the server socket is listening on. This
method is useful if you passed in 0 as the port number in a constructor and let the server
find a port for you.

public Socket accept() throws IOException Waits for an incoming client. This method
blocks until either a client 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

public void setSoTimeout(int timeout) Sets the time-out value for how long the server
socket waits for a client during the accept().

public void bind(SocketAddress host, int backlog) Binds the socket to the specified
server and port in the SocketAddress object. Use this method if you instantiated the
ServerSocket using the no-argument constructor.
 Socket Class Constructors

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 connection is successful and the client is
connected to the server.

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.

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.

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 by an InetAddress object instead of a String

public Socket() Creates an unconnected socket. Use the connect() method to connect this
socket to a server.
 Socket Class Methods
public void connect(SocketAddress host, int timeout) throws IOException This method
connects the socket to the specified host. This method is needed only when you instantiated
the Socket using the no-argument constructor.

public InetAddress getInetAddress() This method returns the address of the other
computer that this socket is connected to.
public int getPort() Returns the port the socket is bound to on the remote machine.
public int getLocalPort() Returns the port the socket is bound to on the local machine.

public SocketAddress getRemoteSocketAddress() Returns the address of the remote

socket.

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.
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
public void close() throws IOException Closes the socket, which makes this Socket
 Establishing a Server Using Stream Sockets
Five steps to create a simple server in Java
Step 1: Create ServerSocket object
 ServerSocket server = new ServerSocket( portNumber, queueLength );

 Register an available port

 Specify a maximum number of clients

 Binding the server to the port

○ Only one client can be bound to a specific port

Step 2: Server listens for client connection

 Server blocks until client connects

 Socket connection = server.accept();

 Cont..
Step 3: Sending and receiving data
 OutputStream to send and InputStream to receive data

○ Method getOutputStream returns Socket’s OutputStream

○ Methods getInputstream returns Socket’s InputStream

Step 4: Process phase

 Server and Client communicate via streams

Step 5: Close streams and connections

 Method close

 Port numbers can be between 0 and 65,535.

 Most operating systems reserve port numbers below 1024 for system
services.
 Cont..
import java.io.DataInputStream; serverSoc s=new serverSoc(3000);
import java.io.DataOutputStream; System.out.println("Waiting for client on port 3000 ");
import java.io.IOException; try (Socket server = s.ss.accept()) {
import java.net.*; System.out.println("Server is connected to client 1");
public class serverSoc { DataInputStream in = new
ServerSocket ss; DataInputStream(server.getInputStream());

System.out.println(in.readUTF());
public serverSoc(int port) throws IOException { DataOutputStream out = new
this.ss = new ServerSocket(port); DataOutputStream(server.getOutputStream());
} out.writeUTF("Thank you for connecting to \n Goodbye!");
}
}
class testServer{ catch(IOException exx)
public static void main (String [] args) throws {}
IOException }

{ }
 Establishing a Client Using Stream Sockets
Four steps to create a simple client in Java

Step 1: Create a Socket to connect to server

Socket connection = new Socket ( serverAddress, port );

Step 2: Obtain Socket’s InputStream and Outputstream

Step 3: Process information communicated

Step 4: Close streams and connection

 Cont..
package ajp;

try (
import java.io.DataInputStream; Socket client = newSocket(InetAddress.getLocalHost(),3000)) {
import java.io.DataOutputStream;
System.out.println("Client 1 is connected to Server");
import java.io.IOException;
OutputStream outToServer = client.getOutputStream();
import java.io.InputStream;
DataOutputStream out = new
import java.io.OutputStream;
DataOutputStream(outToServer);
import java.net.InetAddress;
import java.net.Socket; out.writeUTF("Hello Server");

public class clients { InputStream inFromServer = client.getInputStream();

DataInputStream in = new DataInputStream(inFromServer);

public static void main(String [] args) System.out.println("Server says " + in.readUTF());

{ }

try }catch(IOException e)

{ {
System.out.println("Connecting on port " + 3000); } }}