Upload
ashok-hirpara
View
223
Download
0
Embed Size (px)
Citation preview
Network
Programming
in JavaJAVA.NET PACKAGE PROVIDE CLASSES FOR NETWORK PROGRAMMING
BY((ASHOK HIRPARA))
Network Programming in
Java
Java’s network support
Addressing other machines
Communicating using TCP/IP
Communicating using UDP
Broadcasting and multicasting
Network Programming in
Java
Java distinguishes between UDP, TCP server & TCP
client sockets
java.net.InetAddress class represents a single
IP address
java.net.UnkownHostException thrown if DNS
system can’t find IP address for specific host
IP Addresses and Java
Java has a class java.net.InetAddress
which abstracts network addresses
Serves three main purposes:
Encapsulates an address
Performs name lookup (converting a host name into
an IP address)
Performs reverse lookup (converting the address
into a host name)
java.net.InetAddress
Static construction using a factory method
InetAddress getByName(String hostName)
hostName can be “host.domain.com.au”, or
hostName can be “130.95.72.134”
InetAddress getLocalHost()
Some useful methods:
String getHostName()
Gives you the host name (for example “www.sun.com”)
String getHostAddress()
Gives you the address (for example “192.18.97.241”)
InetAddress getLocalHost()
InetAddress[] getAllByName(String hostName)
Using InetAddress objects
import java.net.InetAddress;
import java.net.UnknownHostExcepion;
public static void main(String[] args)
{
try {
InetAddress inet1 =
InetAddress.getByName("asp.ee.uwa.edu.au");
System.out.println(
"HostAddress=" + inet1.getHostAddress());
InetAddress inet2 =
InetAddress.getByName("130.95.72.134");
System.out.println("HostName=" + inet2.getHostName());
if (inet1.equals(inet2))
System.out.println("Addresses are equal");
}
catch (UnknownHostException uhe) {
uhe.printStackTrace();
}
}
Transmission Control Protocol
TCP is built on top of IP
Provides the illusion of a continuous flow (or
stream) of data between sender and receiver (rather like a telephone call)
Splits up streams into strings of small datagrams
which are sent in succession
Contains an error recovery mechanism to recover
datagrams which are lost
These features make application development simpler and so it is widely used
Two types of TCP Socket
java.net.ServerSocket is used by servers
so that they can accept incoming TCP/IP
connections
A server is a piece of software which advertises and
then provides some service on request
java.net.Socket is used by clients who wish
to establish a connection to a (remote) server
A client is a piece of software (usually on a different
machine) which makes use of some service
java.net.ServerSocket
Listens on well-known port for incoming
connections
Creates a dynamically allocated port for each newly established connection
Provides a Socket connected to the new port
Maintains a queue to ensure that prospective
clients are not lost
java.net.ServerSocket
Construction:
ServerSocket(int port, int backlog)
Allows up to backlog requests to queue waiting for the server to deal with them
Some useful methods:
Socket accept()
Blocks waiting for a client to attempt to establish a connection
void close()
Called by the server when it is shutting down to ensure that any resources are deallocated
java.net.Socket
Provides access to TCP/IP streams
Bi-directional communication between sender
and receiver
Can be used to connect to a remote address
and port by using the constructor:
Socket(String remoteHost, int port)
Also used to accept an incoming connection
(see ServerSocket)
java.net.Socket
Can obtain access to input and output streams
Input stream allows reception of data from the
other party
InputSteam getInputStream()
Output stream allows dispatch of data to the
other party
OutputStream getOutputStream()
How it all fits together
2037 80
2037 1583
2037 1583
Client (A) Server (B)
ServerSocket ss.s = ss.accept()
s = new Socket(“B”, 80)
Socket s
s.getInputStream()s.getOuputStream()
s.getInputStream()s.getOuputStream()
A sample TCP server
public static void main(String[] args)
{
try {
ServerSocket agreedPort =
new ServerSocket(AGREED_PORT_NUMBER, 5);
while (isStillServing()) {
Socket session = agreedPort.accept();
respond(session);
session.close();
}
agreedPort.close();
}
catch (UnknownHostException uhe) {
// Very unlikely to occur
}
catch (IOException ioe) {
// May occur if the client misbehaves?
}
}
A sample TCP client
public static void main(String[] args)
{
try {
InetAddress server = InetAddress.getByName(args[0]);
Socket connection =
new Socket(server, AGREED_PORT_NUMBER);
makeRequestToServer(connection);
getReplyFromServer(connection);
connection.close();
}
catch (UnknownHostException uhe) {
// arg[0] is not a valid server name or IP address
}
catch (IOException ioe) {
// The connection to the server failed somehow:
// the server might have crashed mid sentence?
}
}
What are datagrams?
Datagrams are discrete packets of data
Each is like a parcel that can be addressed and
sent to an recipient anywhere on the Internet
This is abstracted as the User Datagram Protocol
(UDP) in RFC768 (August 1980)
Most networks cannot guarantee reliable delivery
of datagrams
Why use datagrams?
Good for sending data that can naturally be
divided into small chunks
Poor for (lossless) stream based communications
Makes economical use of network bandwidth (up
to 3 times the efficiency of TCP/IP for small
messages)
Datagrams can be locally broadcast or multicast
(one-to-many communication)
Application using
datagrams
UDP can be used for economical point-to-point
communications over LANs
Datagrams can be used for one-to-many
communication:
Local network broadcasting;
Multicasting (MBONE)
but there is no way to create one-to-many
streams using TCP/IP
java.net.DatagramPacket
(1)
DatagramPackets normally used as short lived
envelopes for datagram messages:
Used to assemble messages before they are
dispatched onto the network,
or dismantle messages after they have been
received
Has the following attributes:
Destination/source address
Destination/source port number
Data bytes constituting the message
Length of message data bytes
java.net.DatagramPacket
(2) Construction:
DatagramPacket(byte[] data, int length)
Some useful methods:
void setAddress(InetAddress addr)
InetAddress getAddress()
void setPort(int port)
int getPort()
DatagramPackets are not immutable so, in principle you can reuse then, but . .
Experience has shown that they often misbehave when you do -- create a new one, use it once, throw it away!
java.net.DatagramSocket
(1)
Used to represent a socket associated with a
specific port on the local host
Used to send or receive datagrams
Note: there is no counterpart to
java.net.ServerSocket! Just use a
DatagramSocket with a agreed port number so
others know which address and port to send their
datagrams to
java.net.DatagramSocket
(2) Construction:
DatagramSocket(int port)
Uses a specified port (used for receiving datagrams)
DatagramSocket()
Allocate any available port number (for sending)
Some useful methods:
void send(DatagramPacket fullPacket)
Sends the full datagram out onto the network
void receive(DatagramPacket emptyPacket)
Waits until a datagram and fills in emptyPacket with the message
. . . and a few more in the Javadoc
sea.datagram.DatagramSend
er
This example sends datagrams to a specific host (anywhere on the Internet)
The steps are as follows:
Create a new DatagramPacket
Put some data which constitutes your message in the new DatagramPacket
Set a destination address and port so that the network knows where to deliver the datagram
Create a socket with a dynamically allocated port number (if you are just sending from it)
Send the packet through the socket onto the network
sea.datagram.DatagramSen
derbyte[] data = “This is the message”.getBytes();
DatagramPacket packet =
new DatagramPacket(data, data.length);
// Create an address
InetAddress destAddress =
InetAddress.getByName(“fred.domain.com”);
packet.setAddress(destAddress);
packet.setPort(9876);
DatagramSocket socket = new DatagramSocket();
socket.send(packet);
sea.datagram.DatagramRecei
ver
The steps are the reserve of sending:
Create an empty DatagramPacket (and allocate a
buffer for the incoming data)
Create a DatagramSocket on an agreed socket
number to provide access to arrivals
Use the socket to receive the datagram (the thread
will block until a new datagram arrrives)
Extract the data bytes which make up the message
sea.datagram.DatagramRecei
ver// Create an empty packet with some buffer space
byte[] data = new byte[1500];
DatagramPacket packet =
new DatagramPacket(data, data.length);
DatagramSocket socket = new DatagramSocket(9876);
// This call will block until a datagram arrives
socket.receive(packet);
// Convert the bytes back into a String and print
String message =
new String(packet.getData(), 0, packet.getLength());
System.out.println("message is " + message);
System.out.println("from " + packet.getAddress());
But it’s never quite that
simple!
Several of the constructors/methods throw
exceptions which I have omitted
Each datagrams can only hold up to a maximum of 64KB of data . .
. . but the underlying transport layer may split the
message into smaller packets (for instance
Ethernet uses about 1500 bytes)
Always remember that UDP is an unreliable
protocol: If any of the split datagrams are lost the
whole message will be lost