Advance Java-Network Programming
Download as PPTX, PDF6 likes1,327 views
The document discusses network programming in Java using the java.net package. It covers using TCP and UDP for network communication. TCP provides reliable, ordered streams between hosts using sockets, while UDP provides simpler datagram transmission that is unreliable but can be broadcast. The InetAddress class represents IP addresses, and sockets are used for both TCP clients/servers and UDP communication.
![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)](https://image.slidesharecdn.com/networkprogramminginjava-150209052017-conversion-gate01/85/Advance-Java-Network-Programming-5-320.jpg)
![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();
}
}](https://image.slidesharecdn.com/networkprogramminginjava-150209052017-conversion-gate01/85/Advance-Java-Network-Programming-6-320.jpg)
![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?
}
}](https://image.slidesharecdn.com/networkprogramminginjava-150209052017-conversion-gate01/85/Advance-Java-Network-Programming-14-320.jpg)
![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?
}
}](https://image.slidesharecdn.com/networkprogramminginjava-150209052017-conversion-gate01/85/Advance-Java-Network-Programming-15-320.jpg)
![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!](https://image.slidesharecdn.com/networkprogramminginjava-150209052017-conversion-gate01/85/Advance-Java-Network-Programming-20-320.jpg)
![sea.datagram.DatagramSen
der
byte[] 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);](https://image.slidesharecdn.com/networkprogramminginjava-150209052017-conversion-gate01/85/Advance-Java-Network-Programming-24-320.jpg)
![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());](https://image.slidesharecdn.com/networkprogramminginjava-150209052017-conversion-gate01/85/Advance-Java-Network-Programming-26-320.jpg)
Advance Java-Network Programming
- 1. Network Programming in Java JAVA.NET PACKAGE PROVIDE CLASSES FOR NETWORK PROGRAMMING BY((ASHOK HIRPARA))
- 2. Network Programming in Java Java’s network support Addressing other machines Communicating using TCP/IP Communicating using UDP Broadcasting and multicasting
- 3. 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
- 4. 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)
- 5. 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)
- 6. 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(); } }
- 7. 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
- 8. 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
- 9. 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
- 10. 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
- 11. 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)
- 12. 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()
- 13. 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()
- 14. 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? } }
- 15. 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? } }
- 16. 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
- 17. 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)
- 18. 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
- 19. 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
- 20. 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!
- 21. 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
- 22. 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
- 23. 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
- 24. sea.datagram.DatagramSen der byte[] 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);
- 25. 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
- 26. 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());
- 27. 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