NETWORK
PROGRAMMING IN
JAVA
INTRODUCTION
A network represents interconnection of computers that is capable of
sharing files and information between multiple systems
The computer which recieves service is called client and the
computer which provides service is called server
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.
The java.net package contains a set of classes and interfaces that
support communication between processes (executing applications)
that are running on the same or different hosts.
2
Network basics
Protocol:
A protocol represents a set of rules and standards that define a
certain type of network communication
There are many different protocols defining different aspects of
network communication
HTTP- Used to transfer HTML documents on the Web
FTP-Allows you to transfer binary files over the Internet
Both protocols have their own set of rules and standards on how
data is transferred
3
Network basics
IP Address:
It is a unique identification number allotted to every computer on a
network or Internet
It contains 4 integer numbers in the range of 0 to 255 and are
separated by dots
Eg: 87.248.114.14
Domain Name System:
Since it is not easy to remember IP addresses, they are often
mapped to meaningful names called domain names
Special servers called Domain Name Servers (DNS) are available
on the Internet that translate host names into IP addresses 4
Network basics
When we are typing a site address, the DNS translate this domain name
into corresponding numeric IP address and then sends the request
using the IP address.
Port:
Each computer on the Internet can provide a variety of services and the
type of service must be known before information can be transferred.
This is accomplished by using ports
Every computer with an IP address has several thousand logical ports
Each port is identified by a number from 1 to 65,535 and each port
can be allocated to a particular service.
5
Network basics
Ports 0 - 1023 are reserved for use by well-known services
Port No Protocol Description
21 FTP File Transfer Protocol
23 TELNET Remote Login
25 SMTP Simple Mail Transfer
Protocol
Data transmitted over the Internet is accompanied by addressing
information that identifies the computer(IP address) and the port for
which it is destined
The receiver checks each packet it sees for the port and sends the
data to any programs that are listening to the specified port. 6
Network basics
SOCKETS:
Sockets provide the communication mechanism between two
computers that enable you to transfer data through a particular port
Network programming usually involves a server and one or more clients. The
client sends requests for information/services own by the Server
Once the connection is established between Client and Server, they
can start sending / receiving information.
Socket acts as an interface through which sever and client can
send / receive information
It is identified by using the port number and IP address
7
Socket Communication
A server (program) runs on a specific computer and has a socket that
is bound to a specific port.
The server waits and listens to the socket for a client to make a
connection request.
Connection request
port
server
Client
8
Socket Communication
The server accepts the connection request from client.
Upon acceptance, the server gets a new socket bounds to a different
port
new socket is dedicated for serving the client that had sent request
The original socket can continue to listen for further connection
requests
port
server
port
Client
Connection
port
9
The Java Networking Package
The java.net package provides classes useful for developing
networking applications
It provides support for the two common network protocols:
TCP:
allows for reliable communication between two applications
TCP is known as a connection-oriented protocol, which means
that a connection is established and maintained between source
and destination
Guarantees that data sent from one end of the connection
actually gets to the other end and in the same order it was sent.
Otherwise, an error is reported
10
The Java Networking Package
UDP:
connection-less protocol that allows for packets of data(data
grams) to be transmitted between applications.
the destination port and IP addresses are written down in a
datagram and the datagram is sent to the destination
UDP does not guarantee that packets will be received in the
order they were sent
11
The Java Networking Package
Some of the important classes available in java.net Package are:
InetAddress
ServerSocket
Socket
DatagramPacket
DatagramSocket
URL
12
InetAddress Class
When you are establishing a connection across the Internet,
addresses are fundamental.
The InetAddress class is used to encapsulate both the numerical IP
address and the domain name for that address.
Only the name needs to be supplied to get the respective address
The InetAddress class has no visible constructors
There are 3 different methods available which return an instance of
the InetAddress Class.
13
InetAddress Class
staticInetAddress getLocalHost( ) throws UnknownHostException
returns the InetAddress object that represents the local host.
staticInetAddress getByName(String hostName) throws
UnknownHostException
returns an InetAddress for a host name passed to it.
staticInetAddress[ ] getAllByName(String hostName) throws
UnknownHostException
returns an array of InetAddresses that represent all of the addresses
that a particular name resolves to.
14
InetAddress Class: Example
import java.net.*;
class InetAddressTest
{
public static void main(String args[])
throws UnknownHostException
{
InetAddress Address = InetAddress.getLocalHost();
System.out.println(Address);
Address = InetAddress.getByName("www.yahoo.com");
System.out.println(Address);
InetAddress SW[] =
InetAddress.getAllByName("www.google.com");
for (int i=0; i<SW.length; i++)
System.out.println(SW[i]);
}
15
}
InetAddress Class: Example
OUTPUT
COMPAQ-PC/192.168.2.2
www.yahoo.com/106.10.170.118
www.google.com/74.125.235.50
www.google.com/74.125.235.51
www.google.com/74.125.235.52
www.google.com/74.125.235.48
www.google.com/74.125.235.49
16
InetAddress Class: Methods
String getHostAddress(): Returns a string that represents the host
address associated with the InetAddress object.
String getHostName() : Returns a string that represents the host name
associated with the InetAddress object.
17
Transmission Control Protocol
With a TCP network connection, the client computer is similar to
the person placing the telephone call, and the server computer is
similar to the person waiting for a call
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
When a TCP connection is established, the client and server have a
reliable, two-way communication stream that allows data to be
transmitted in either direction.
18
Transmission Control Protocol
Using TCP provides a Stream-based communication for data transmission
and it can detect lost transmissions and resubmit them
The two computers can communicate until the connection is closed or lost
The java.net.ServerSocket and java.net.Socket classes are the two
classes needed to create a TCP/IP connection between two computers
19
Socket-based Programs
Server ServerSocket(1234)
client
Output/write stream
Input/read stream
Socket(“128.250.25.158”, 1234)
20
Socket Class
If TCP is similar to placing a telephone call, a socket is the
telephone
The java.net.Socket class is Java's fundamental class for performing
client-side TCP operations.
The Socket class contains constructor that is used to create stream
socket that connects to specific port number associated with exactly
one host
A socket is bound to a port number so that the TCP layer can identify
the application that data destined to be sent
The actual reading and writing of data over the socket is accomplished
via the familiar stream classes.
21
Socket Class
CONSTRCUTORS
Socket(String hostName, int port)-Creates a socket that connects
to the given port number on the specified host
Socket(InetAddress ipAddress, int port)-Creates a socket that
connects to the given port number at the specified IP address
When the Socket constructor returns, it does not simply instantiate a
Socket object. Within the constructor, it actually attempts to connect to
the specified server and port.
22
Socket Class
METHODS
InetAddress getInetAddress()- tells which remote host the Socket is
connected to or, if the connection is now closed, which host the
Socket was connected to when it was connected.
int getPort() tells you which port the Socket is (or was or will be)
connected to on the remote host.
InputStream getInputStream()-returns an input stream that can read
data from the socket into a program.
You can chain this InputStream to a filter stream or reader that offers
more functionality—DataInputStream or InputStreamReader before
reading input
23
Socket Class
It's also extremely helpful to buffer the input by chaining it to a
BufferedInputStream or a BufferedReader for performance
reasons.
OutputStream getOutputStream() returns a raw OutputStream for
writing data from your application to the other end of the socket
chain this stream to a more convenient class like DataOutputStream
or OutputStreamWriter before using it.
public void close() -Closes the socket, which makes this Socket
object no longer capable of connecting again to any server.
24
Implementing a client
Java programs normally use client sockets in the following fashion:
1. The program creates a new socket with a Socket() constructor
2. The socket attempts to connect to the remote host.
3. Once the connection is established, the local and remote hosts
get input and output streams from the socket and use those
streams to send data to each other.
4. When the transmission of data is complete, one or both sides
close the connection.
25
Implementing a client: Example
Socket clientSocket = new Socket("localhost", 6789);
OutputStreamWriter outToServer = new
OutputStreamWriter(clientSocket.getOutputStream());
BufferedReader inFromServer = new BufferedReader(new
InputStreamReader(clientSocket.getInputStream()));
outToServer.writeBytes(“Hi from client”+’\n’);
String str = inFromServer.readLine();
System.out.println(“Message from server:”+ str);
clientSocket.close();
26
ServerSocket
The java.net.ServerSocket class is used by server applications to
obtain a port and listen for client requests
A serversocket waits for requests from client to come in over the
network.
When a client Socket on a remote host attempts to connect to that
port, the server wakes up, negotiates the connection between the
client and the server, and opens a regular Socket between the two
hosts.
Once the server socket has set up the connection, the server uses a
regular Socket object to send data to the client
27
ServerSocket
CONSTRCUTORS:
public ServerSocket (int port) -creates a server socket on the port
specified by the argument.
public ServerSocket(int port, int queueLength)-creates a
ServerSocket on the specified port with the specified queue length.
queueLength specifies how many incoming clients to store in a wait
queue
public ServerSocket(int port, int qLength, InetAddress address)
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 28
ServerSocket
METHODS
public int getLocalPort(). Returns the port that the server socket is
listening on.
public Socket accept() - returns a Socket object representing the
connection between the remote client and the local server. It stops the
flow of execution and waits until a client connects
We use the streams returned by this Socket's getInputStream() and
getOutputStream() methods to communicate with the client
29
Implementing Server
1. A new ServerSocket is created on a particular port using a
ServerSocket() constructor.
2. The server invokes the accept() method of the ServerSocket class.
accept() blocks until a client attempts to make a connection, at which
point accept() returns a Socket object connecting the client and the
server.
3.Depending on the requirement, either getInputStream()
method, getOutputStream() method, or both are called to get input
and output streams that communicate with the client.
4.The server and the client interact according to an agreed-upon
protocol until it is time to close the connection.
30
Implementing Server:Example
5. The server, the client, or both close the connection.
6. The server returns to step 2 and waits for the next connection.
EXAMPLE:
ServerSocket server = new ServerSocket(5776);
Socket connection = server.accept( );
BufferedReader inFromClient = new BufferedReader(new
InputStreamReader(connectionSocket.getInputStream()));
String str= inFromClient.readLine();
System.out.println(“Message from client:”+str);
DataOutputStream outToclient
= new DataOutputStream(connection.getOutputStream( ));
outToclient.writeBytes("You've connected to this server. Bye..“+’\n’);
connection.close( );
31
Client-Server Interaction via TCP
32
Client-Server Interaction via TCP:
Example
Client Machine Code
import java.io.*;
import java.net.*;
public class SimpleClient {
public static void main(String args[]) throws Exception {
String sentence;
String sent1;
BufferedReader inFromUser = new BufferedReader(new
InputStreamReader(System.in));
Socket clientSocket = new Socket("localhost", 6789);
DataOutputStream outToServer = new
DataOutputStream(clientSocket.getOutputStream());
33
Client-Server Interaction via TCP:
Example
Client Machine Code
BufferedReader inFromServer = new BufferedReader(new
InputStreamReader(clientSocket.getInputStream()));
sentence = inFromUser.readLine();
outToServer.writeBytes(sentence+'\n');
System.out.println("Message from Server:");
sent1= inFromServer.readLine();
System.out.println(sent1);
clientSocket.close();
}
}
34
Client-Server Interaction via TCP:
Example
Server Machine Code:
import java.io.*;
import java.net.*;
public class SimpleServer {
public static void main(String args[]) throws Exception {
String clientSentence;
ServerSocket welcomeSocket = new ServerSocket(6789);
while(true) {
Socket connectionSocket = welcomeSocket.accept();
BufferedReader inFromClient = new BufferedReader(new
InputStreamReader(connectionSocket.getInputStream()));
35
Client-Server Interaction via TCP:
Example
Server Machine Code:
DataOutputStream outToClient = new
DataOutputStream(connectionSocket.getOutputStream());
System.out.println("Message from Client:");
clientSentence = inFromClient.readLine();
System.out.println(clientSentence);
outToClient.writeBytes("Thanks for
greetings"+'\n');
}
}
}
36
Client-Server Interaction via TCP:
Example
37
Client-Server Interaction via TCP:
Example
38
Client-Server Interaction via TCP:
Example
39
User Datagram Protocol
User Datagram Protocol (UDP) provides a protocol for sending
packets of data called datagrams between applications.
UDP can be compared to mailing someone a letter(datagram), where a
client sends a datagram to a server without actually connecting to the
server
UDP does not guarantee that packets will be received in the order they
were sent or that they will even be delivered at all
The java.net.DatagramPacket and java.net.DatagramSocket classes
are used to send and receive datagram packets using UDP
This is suitable for applications in which speed is the significant factor
40
User Datagram Protocol
Datagram packets are used to implement a connectionless
packet delivery service supported by the UDP protocol
Each packet needs to have destination address and each packet
might be routed differently, and might arrive in any order.
The format of datagram packet is:
Msg | length | Host | serverPort
The sender of a message uses a datagram socket to send a packet,
and a recipient uses a datagram socket to receive a message.
When a message is sent, the recipient does not need to be available.
Similarly, when a message is received, the sender does not need to be
still available.
41
DatagramPacket
The DatagramPacket class represents a datagram packet,
and it is used by both the sender and receiver of a packet.
CONSTRCUTORS:
There are two types of constructors for DatagramPacket:
The first constructor is used to receive data from the net; the second is
for data that you will send to the net.
public DatagramPacket(byte[] buffer, int length)-Creates a datagram
packet for receiving a packet of the specified size. The buffer will
contain the incoming packet
The array of bytes passed in to these constructors is used to contain
the data of the incoming packet, and typically are empty arrays.
42
DatagramPacket
public DatagramPacket(byte[] buffer, int length, InetAddress
address, int port)-Creates a datagram packet for sending a
packet of the specified size. The buffer contains the data of the
packet, and the address and port denote the recipient.
METHODS:
The DatagramPacket class contains get and set methods for the various
attributes of the datagram packet
byte[] getData();
void setData(byte[] buf);
void setPort(int port);
int getPort();
InetAddress getAddress();
void setAddress(InetAddress a);
43
DatagramSocket
The java.net.DatagramSocket class is used by both the sender and the
recipient of a datagram packet to send and receive a packet,
respectively
CONSTRUCTORS
public DatagramSocket(int port)-Creates a datagram socket on the
localhost computer at the specified port.
public DatagramSocket(int port, InetAddress address)-Creates a
datagram socket using the specified port and host address
44
DatagramSocket
METHODS
public void send(DatagramPacket packet)-Sends the specified
datagram packet. The DatagramPacket object contains the destination
information of the packet
public void receive(DatagramPacket packet)-This method receives a
single UDP datagram from the network and stores it in the pre-existing
DatagramPacket object
Like the accept( ) method in the ServerSocket class, this method
blocks the calling thread until a datagram arrives
45
DatagramSocket
METHODS
public void send(DatagramPacket packet)-Sends the specified
datagram packet. The DatagramPacket object contains the destination
information of the packet
public void receive(DatagramPacket packet)-This method receives a
single UDP datagram from the network and stores it in the pre-existing
DatagramPacket object
Like the accept( ) method in the ServerSocket class, this method
blocks the calling thread until a datagram arrives
46
Receiving a Datagram Packet
To receive a datagram packet, the following steps are performed:
1. Create an array of bytes large enough to hold the data of the incoming
packet.
2. A DatagramPacket object is instantiated using the array of bytes.
3. A DatagramSocket is instantiated, and it is specified which port (and
specific localhost address, if necessary) on the localhost the socket
will bind to.
4. The receive() method of the DatagramSocket class is invoked, passing
in the DatagramPacket object. This blocks the execution of further
code until a datagram packet is received or a time out occurs.
47
Sending a Datagram Packet
To receive a datagram packet, the following steps are performed:
1. Create an array of bytes large enough to hold the data of the packet to
be sent, and fill the array with the data.
2. Create a new DatagramPacket object that contains the array of bytes,
as well as the server name and port number of the recipient.
3. A DatagramSocket is instantiated, and it is specified which port (and
specific localhost address, if necessary) on the localhost the socket
will bind to.
4. The send() method of the DatagramSocket class is invoked, passing in
the DatagramPacket object.
48
Receiving a Datagram Packet
import java.net.*;
import java.io.*;
public class PacketReceiver
{ public static void main(String [] args) throws Exception
{
byte [] buffer = new byte[1024];
DatagramPacket packet =
new DatagramPacket(buffer, buffer.length);
DatagramSocket socket = new DatagramSocket(5002);
System.out.println(“Waiting for a packet...”);
socket.receive(packet);
System.out.println(“Just received packet from “+
packet.getSocketAddress());
buffer = packet.getData();
System.out.println(new String(buffer));
}
} 49
Sending a Datagram Packet
import java.net.*;
import java.io.*;
public class PacketSender
{
public static void main(String [] args)
{
try
{
String data =
“You have just received a packet of data sent using UDP”;
byte [] buffer = data.getBytes();
DatagramPacket packet = new DatagramPacket(buffer,buffer.length,
InetAddress.getLocalHost(), 5002);
50
Sending a Datagram Packet
DatagramSocket socket = new DatagramSocket(5003);
System.out.println(“Sending a packet...”);
socket.send(packet);
}catch(IOException e)
{
e.printStackTrace();
}
}
}.
51
OUTPUT
52
OUTPUT
53
mport java.io.*;
import java.net.*;
class UDPClient {
public static void main(String args[])throws Exception
{
BufferedReader inFromUser =new BufferedReader(new
InputStreamReader(System.in));
DatagramSocket clientSocket = new DatagramSocket();
InetAddress IPAddress=InetAddress.getByName("localhost");
byte[] sendData = new byte[1024];
byte[] receiveData = new byte[1024];
String sentence = inFromUser.readLine();
sendData = sentence.getBytes();
DatagramPacket sendPacket = new DatagramPacket(sendData,
sendData.length, IPAddress, 9876);
54
clientSocket.send(sendPacket);
Client
import java.io.*;
import java.net.*;
class UDPClient {
public static void main(String args[])throws Exception
{
BufferedReader inFromUser =new BufferedReader(new
InputStreamReader(System.in));
DatagramSocket clientSocket = new DatagramSocket();
InetAddress IPAddress=InetAddress.getByName("localhost");
byte[] sendData = new byte[1024];
byte[] receiveData = new byte[1024];
String sentence = inFromUser.readLine();
sendData = sentence.getBytes();
DatagramPacket sendPacket = new DatagramPacket(sendData,
sendData.length, IPAddress, 9876);
55
clientSocket.send(sendPacket);
Client
DatagramPacket receivePacket =new DatagramPacket(receiveData,
receiveData.length);
clientSocket.receive(receivePacket);
String modifiedSentence =new String(receivePacket.getData());
System.out.println("FROM SERVER:" + modifiedSentence);
clientSocket.close();
}
}
56
Server
import java.io.*;
import java.net.*;
class UDPServer
{
public static void main(String args[]) throws Exception
{
DatagramSocket serverSocket = new DatagramSocket(9876);
byte[] receiveData= new byte[1024];
byte[] sendData= new byte[1024];
while(true)
{
DatagramPacket receivePacket =new DatagramPacket(receiveData,
receiveData.length);
serverSocket.receive(receivePacket);
String sentence = new String(receivePacket.getData());
57
InetAddress IPAddress = receivePacket.getAddress();
Server
int port = receivePacket.getPort();
String capitalizedSentence = sentence.toUpperCase();
sendData = capitalizedSentence.getBytes();
DatagramPacket sendPacket =new DatagramPacket(sendData,
sendData.length, IPAddress, port);
serverSocket.send(sendPacket);
}
}
}
58
OUTPUT
59
Client/server socket interaction: UDP
60
URL -Uniform Resource Locator
URL is a reference (an address) to a resource on the Internet
A URL can be broken down into parts, as follows:
protocol://host:port/path?query#ref
Eg:http://www.javapassion.com:80/javaintro/index.html#Networking_A
Part Meaning Required
scheme or protocol Internet protocol to be followed. e.g. http, https, ftp, Yes
mailto, etc. This defines the syntax of the URL.
domain or hostname This is the destination location for the URL. It can be Yes
a hostname or ip address.
port The port to be used to connect to the location. No
path or pathname This is typically a file or location on the web server. No
query_string or This is the data to be passed to software running on No
search the server.
fragment_id or ref This specifies a part or a position within the overall No
61
resource or document
URL -Uniform Resource Locator
The java.net.URL class represents a URL. The URL class has
several constructors for creating URLs
CONSTRUCTOR
public URL(String protocol, String host, int port, String file)
Creates a URL by putting together the given parts
public URL(String url)- Creates a URL from the given String.
The URL class contains many methods for accessing the various parts of
the URL being represented:
public String getPath().
public String getQuery()
public String getProtocol()
public String getHost()
public String getFile()
public String getRef() 62
URL class:Example
import java.net.*;
import java.io.*;
public class URLDemo
{
public static void main(String [] args)
{
try
{
URL url = new URL(args[0]);
System.out.println("URL is:" + url.toString());
System.out.println("protocol is:"+ url.getProtocol());
System.out.println("file name is:" + url.getFile());
System.out.println("host is:" + url.getHost());
System.out.println("path is:" + url.getPath());
63
URL class:Example
import java.net.*;
import java.io.*;
public class URLDemo
{
public static void main(String [] args)
{
try
{
URL url = new URL(args[0]);
System.out.println("URL is:" + url.toString());
System.out.println("protocol is:"+ url.getProtocol());
System.out.println("file name is:" + url.getFile());
System.out.println("host is:" + url.getHost());
System.out.println("path is:" + url.getPath());
64
URL class:Example
System.out.println("port is:" + url.getPort());
System.out.println("query is:" + url.getQuery());
System.out.println("ref is:" + url.getRef());
}
catch(IOException e)
{
e.printStackTrace();
}
}
}
65
URL class:Example
OUTPUT
Java http://www.example.com:80/example.php?y=2#results
URL is:http://www.example.com:80/example.php?y=2#results
protocol is:http
file name is:/example.php?y=2
host is:www.example.com
path is:/example.php
port is:80
query is:y=2
ref is:results
66
