Chapter 6 Networking in Java

Course Title: Java Programming.
Credit Hour: 3 hrs.

ECTS: 5 [2 Lecture , 3 Lab and 2 Tutorial Hours]
Lecture Schedule: Every _____________
Bedasa Wayessa
Java Programming CoSc3053 1

Chapter 6
Networking in Java
CS@AmboU Advanced Programming - Comp 511 2

Objectives
 Networking overview
– Types of connections
 Socket programming
– Socket, port and URI
– Implementing Socket programming
 Remote method invocation (RMI)
– Overview of RMI
– The RMI registry
– The remote Interface
– Implementing RMI

Networking overview
 Network programming is a mechanisms by which software
running on two or more computational devices can exchange
messages
 Desktop Computers, PDAs, Mobile Telephones
 Java is a network centric programming language
 Java abstracts details of network implementation behind a standard
API.
 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.

Networking overview
 Networking package is java.net
– Socket-based communications
• Applications view networking as streams of data
• Connection-based protocol
• Uses TCP (Transmission Control Protocol
– Packet-based communications
• Individual packets transmitted
• Connectionless service
• Uses UDP (User Datagram Protocol)

Protocols
Hi TCP connection
request
Hi
TCP connection
Got the reply
time? GET http://www.google.com
2:00
<file>
time
6
Internet Architecture Model
Application (HTTP, FTP) DATA
Transport (TCP,UDP) HEADER DATA
Network (IP) HEADER HEADER DATA
Link (LINK) HEADER HEADER HEADER DATA
7
Networking Basics
 Applications Layer
 Standard apps
.  HTTP
 FTP TCP/IP Stack
 Telnet The java.net
package provides Application
 User apps
support for the (http,ftp,telnet,…)
 Transport Layer two common
 TCP network Transport
 UDP protocols (TCP, UDP,..)
 Programming Interface:
 Sockets
Network
 Network Layer
(IP,..)
 IP Link
 Link Layer (device driver,..)
 Device drivers

Networking Basics
 TCP (Transport Control
.
Protocol) is a connection-oriented
TCP/IP Stack
protocol that provides a reliable
Application
flow of data between two (http,ftp,telnet,…)
computers. Transport
(TCP, UDP,..)
 Example applications:
Network
 HTTP (IP,..)
Link
 FTP (device driver,..)
 Telnet

Networking Basics
 UDP (User Datagram Protocol)
. is a protocol that sends
TCP/IP Stack
independent packets of data,
Application
called datagrams, from one (http,ftp,telnet,…)
computer to another with no Transport
(TCP, UDP,..)
guarantees(unreliable) about
Network
arrival. (IP,..)
 Example applications: Link

(device driver,..)
 Clock server
 Ping

Socket Programming
 Sockets provide the communication mechanism between two
computers using TCP.
 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.
 The client and the server can now 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.

Socket Programming
 Socket programming can be connection-oriented or connectionless.
 Socket and ServerSocket classes are used for connection-
oriented socket programming.
 The client in socket programming must know two information:
– IPaddress of Server, and Port number.

Socket class
 A socket is simply an endpoint for communications between the
machines.
 The Socket class can be used to create a socket.
 Commonly used methods of Socket class:
– public InputStream getInputStream()
– public OutputStream getOutputStream()
– public synchronized void close()

Socket class
 Four steps to create a simple client in Java
– Create a Socket object for the client
– Obtain Socket’s InputStream and Outputstream
– Process information communicated
– Close streams and Socket

ServerSocket class
 The ServerSocket class can be used to create a server socket.
 This object is used to establish communication with the clients.
 Commonly used methods of ServerSocket class:
– public Socket accept()
– public InputStream getInputStream()
– public OutputStream getOutputStream()
– public synchronized void close()

ServerSocket class
 Five steps to create a simple server in Java
– ServerSocket object
• Registers an available port and a maximum number of clients
– Each client connection handled with Server object
• Server blocks until client connects
– Sending and receiving data
• OutputStream to send and InputStream to receive data
• Methods getInputStream and getOutputstream
– Use on Socket object
– Process phase
• Server and Client communicate via streams
– Close streams and connections
Example of Socket Programming:
//MyServer.java
import java.io.*;
.import java.net.*;
public class MyServer {
public static void main(String[] args){
try{
ServerSocket ss=new ServerSocket(6666);
Socket s=ss.accept();//establishes connection
DataInputStream dis=new DataInputStream(s.getInputStream());
String str=(String)dis.readUTF();
System.out.println("message= "+str);
ss.close();
}catch(Exception e){
System.out.println(e);
}
}
}

Example of Socket Programming:
//MyClient.java
import java.io.*;
.import java.net.*;
public class MyClient {
public static void main(String[] args) {
try{
Socket s=new Socket("localhost",6666);
DataOutputStream dout=new DataOutputStream(s.getOutputStream());
dout.writeUTF("Hello Server");
dout.flush();
dout.close();
s.close();
}
}
}
URL class
 The URL class represents a URL.
 URL is an acronym for Uniform Resource Locator.
 It points to a resource on the World Wide Web.
– For example: http://www.javatpoint.com/sonoojaiswal/index.jsp
 A URL contains many information’s:
 Protocol: In this case, http is the protocol.
 Server name or IP Address:
 In this case, www.javatpoint.com is the server name.
 Port Number: It is an optional attribute.
 If we write http//ww.javatpoint.com:80/sonoojaiswal/ , 80 is the port
number.
 File Name or directory name:
 In this case, index.jsp is the file name.
URL class
 Examples of protocols include HTTP, HTTPS, FTP, and File.
 The path is also referred to as the filename, and the host is also called
the authority.
 Commonly used methods of URL class:
 public String getProtocol(): it returns the protocol of the URL.
 public String getHost(): it returns the host name of the URL.
 public String getPort(): it returns the Port Number of the URL.
 public String getFile(): it returns the file name of the URL.

URLDemo Example
//URLDemo.java
import java.io.*;
.
import java.net.*;
public class URLDemo{
try{
URL url=new
URL("http://www.javatpoint.com/sonoojaiswal/index.jsp");
System.out.print("Protocol: "+url.getProtocol());
System.out.print("Host Name: "+url.getHost());
System.out.print("Port Number: "+url.getPort());
System.out.print("File Name: "+url.getFile());
}
}
}

URLConnection class
 The URLConnection class represents a communication link
between the URL and the application.
 This class can be used to read and write data to the specified
resource referred by the URL.
 How to get the object of URLConnection class:
 The openConnection() method of URL class returns the object of
URLConnection class.
 Syntax:
 public URLConnection openConnection() throws IOException{}

URLConnection class
 Displaying all the data of a webpage by URLConnecton class:
 The URLConnection class provides many methods, we can display all
the data of a webpage by using the getInputStream() method.
 The getInputStream() method returns all the data of the specified
URL in the stream that can be read and displayed.

URLDemo Example
//DisplayData.java
import java.io.*;
.import java.net.*;
public class DisplayData {
try{
URL url=new URL("http://www.javatpoint.com/sonoojaiswal/");
URLConnection urlcon=url.openConnection();
InputStream stream=urlcon.getInputStream();
int i;
while((i=stream.read())!=-1){
System.out.print((char)i);
}
System.out.println(e);}
}
}
}

InetAddress class
 The java.net.InetAddress class represents an IP address.
 The Inet Address class provides methods to get the IP of any host name.
 Commonly used methods of InetAddress class:
 public static InetAddress getByName(String host) throws
UnknownHostException: it returns the IP of the given host.
 public static InetAddress getLocalHost() throws
UnknownHostException: it returns the LocalHost IP and name.
 public String getHostName(): it returns the host name of the IP address.
 public String getHostAddress(): it returns the IP address in string format.

InetDemo Example
//InetDemo.java
import java.io.*;
.import java.net.*;
public class InetDemo{

try{
InetAddress ip=InetAddress.getByName("www.javatpoint.com");
System.out.println("Host Name: "+ip.getHostName());
System.out.println("IP Address: "+ip.getHostAddress());
System.out.println(e);}
}
}
}

DatagramSocket and DatagramPacket
 java provides stream sockets and datagram sockets.
 With stream sockets, a process establishes a connection to another
process.
 While the connection is in place, data flows between the processes in
streams.
 Stream sockets are said to provide a connection-oriented service.
 The protocol used for transmission is the popular TCP (Transmission
Control Protocol).
 With datagram sockets, individual packets of information are
transmitted.
 UDP (User Datagram Protocol) is a connectionless service that does
not guarantee that packets will not be lost, duplicated or arrive out of
sequence.
DatagramSocket class
 The DatagramSocket class represents a connection-less socket for
sending and receiving datagram packets.
 Datagram is basically an information but there is no guarantee of its
content, arrival or arrival time.
 The DatagramSocket and DatagramPacket classes are used for connection-
less socket programming.
 Commonly used Constructors of DatagramSocket class are:
– DatagramSocket() throws SocketException:
 it creates a datagram socket and binds it with the available Port Number
on the localhost machine.
– DatagramSocket(int port) throws SocketEeption:
 it creates a datagram socket and binds it with the given Port Number.
– DatagramSocket(int port, InetAddress address) throws SocketEeption:
 it creates a datagram socket and binds it with the specified port number and host address.
DatagramPacket class
 The DatagramPacket is message that can be sent or received.
 If you send multiple packet, it may arrive in any order.
 Moreover, packet delivery is not guaranteed.
 Commonly used Constructors of DatagramPacket class are:
 DatagramPacket(byte[] barr, int length):
 it creates a datagram packet. This constructor is used to receive the
packets.
 DatagramPacket(byte[] barr, int length, InetAddress address, int port):
 it creates a datagram packet. This constructor is used to send the
packets.

DatagramSocket
Example of Sending DatagramPacket by DatagramSocket
//DSender.java
import java.net.*;
public class DSender{

public static void main(String[] args) throws Exception {
DatagramSocket ds = new DatagramSocket();

String str = "Welcome java";
InetAddress ip = InetAddress.getByName("127.0.0.1");
DatagramPacket dp = new DatagramPacket(str.getBytes(),
str.length(), ip, 3000);
ds.send(dp);
ds.close();
}
}

DatagramSocket
Example of Receiving DatagramPacket by DatagramSocket
//DReceiver.java
import java.net.*;
public class DReceiver{
public static void main(String[] args) throws Exception {
DatagramSocket ds = new DatagramSocket(3000);

byte[] buf = new byte[1024];
DatagramPacket dp = new DatagramPacket(buf, 1024);

ds.receive(dp);
String str = new String(dp.getData(), 0, dp.getLength());

System.out.println(str);
ds.close();
}
}

Remote Method Invocation (RMI)
 RMI allows Java objects running on separate computers or in separate
processes to communicate with one another via remote method calls.
 RMI is based on a similar, earlier technology for procedural programming
called remote procedure calls (RPCs) developed in the 1980s.
 RPC allows a procedural program (i.e., a program written in C or another
procedural programming language) to call a function residing on another
computer as conveniently as if that function were part of the same program
running on the same computer.
 A goal of RPC was to allow programmers to concentrate on the required
tasks of an application by calling functions, while making the mechanism that
allows the application’s parts to communicate over a network transparent to
the programmer.

 RPC performs all the networking and marshaling of data (i.e., packaging of
function arguments and return values for transmission over a network).
 A disadvantage of RPC is that it supports a limited set of simple data types.
 Therefore, RPC is not suitable for passing and returning Java objects.
 RMI is Java’s implementation of RPC for Java-object-to-Java-object distributed
communication.
 Once a Java object registers as being remotely accessible (i.e., it is a remote
object), a client can obtain a remote reference to that object, which allows
the client to use that object remotely.
 The method call syntax is identical to the syntax for calling methods of other
objects in the same program.

 Distributed Systems:
 A distributed system is a collection of independent computers that
appears to its users as a single coherent system - computer (Tanenbaum
& Van Steen).
 This definition has two aspects:
1. Hardware: autonomous machines
2. Software: a single system view for the users
Distributed system can also be defined as a system designed to support the
development of applications and services which can exploit a physical
architecture consisting of multiple, autonomous processing elements that do
not share primary memory but cooperate by sending asynchronous messages
over a communication network (Blair & Stefani).
Client/Server Model vs Distributed Object Model
 Client/Server Model
 The client/server model is a form of distributed computing in which one
program (the client) communicates with another program (the server) for the
purpose of exchanging information.
 In this model,
 both the client and server usually speak the same language -- a protocol that
both the client and server understand
 so they are able to communicate.
 While the client/server model can be implemented in various ways, it is
typically done using low-level sockets.
 Using sockets to develop client/server systems means that we must
design a protocol, which is a set of commands agreed upon by the client
and server through which they will be able to communicate.

Client/Server Model vs Distributed Object Model
 Distributed Object Model
 A distributed object-based system is a collection of objects that isolates
the requesters of services (clients) from the providers of services
(servers) by a well defined encapsulating interface.
 In other words, clients are isolated from the implementation of services
as data representations and executable code.
 This is one of the main differences that distinguish the distributed object-
based model from the pure client/server model.
 In the distributed object-based model, a client sends a message to an
object, which in turns interprets the message to decide what service to
perform.
 The Java (RMI) is example of this model.

RMI
 The most fundamental means of inter-object communication in Java is method
invocation.
 Mechanisms like the Java event model are built on simple method invocations
between objects in the same virtual machine.
 Java's Remote Method Invocation (RMI) is a mechanism that lets us get a
reference to an object on a remote host and use it as if it were in our own virtual
machine.
 It lets us invoke methods on remote objects, passing real Java objects as arguments
and getting real Java objects as returned values.
 RMI is a powerful tool that leverages Java object serialization, allowing you to
transparently work with objects on remote machines as if they were local.
 With RMI it is easy to write distributed applications in which clients and servers
work with each other's data as full-fledged Java objects, rather than streams or
packets of data.
RMI
 The Genesis of an RMI Application:
 Developing a distributed application using RMI involves the following
steps:
1. Define a remote interface
2. Implement the remote interface
3. Develop the server
4. Develop a client
5. Generate Stubs and Skeletons, start the RMI registry, server,
and client

RMI
 Remote and Non-Remote Objects:
 Before an object can be used with RMI, it must be serializable.
 But that's not sufficient.
 Remote objects in RMI are real distributed objects.
 As the name suggests, a remote object can be an object on a
different machine; it can also be an object on the local host.
 The term remote means that the object is used through a special
kind of object reference that can be passed over the network.
 Like normal Java objects, remote objects are passed by reference.

RMI
 Remote and Non-Remote Objects:
 In RMI, the actual method invocations will happen on the remote
host, where the object resides.
 Non-Remote objects are simpler.
 The catch is that when you pass a nonremote object over the
network it is simply copied.
 So, they are passed by copy (as opposed to by reference).

RMI
 Stubs and Skeletons
 Stubs and skeletons are used in the implementation of remote objects.
 When you invoke a method on a remote object (which could be on a
different host), you are actually calling some local code that serves as a
proxy for that object. This is the stub.
 The skeleton is another proxy that lives with the real object on its
original host.
 It receives remote method invocations from the stub and passes them to
the object.
 Stubs and skeletons for your remote objects are created by running the
rmic (RMI compiler) utility.
 After compiling your Java source files normally, you run rmic on the
remote object classesAdvanced
CS@AmboU as a second pass.
Programming - Comp 511 41

RMI
 Remote Interfaces:
 Remote objects are objects that implement a special remote interface
that specifies which of the object's methods can be invoked remotely.
 The remote interface must extend the java.rmi.Remote interface.
 Your remote object will implement its remote interface; as will the stub
object that is automatically generated for it.
 In the rest of your code, you should then refer to the remote object as
an instance of the remote interface - not as an instance of its actual class.
 Because both the real object and stub implement the remote interface,
they are equivalent as far as we are concerned (for method invocation).
 All methods in the remote interface must declare that they can throw
the exception java.rmi.RemoteException.

RMI
 Remote Interfaces:
 This exception (actually, one of many subclasses to RemoteException)
is thrown when any kind of networking error happens:
 For example, the server could crash, the network could fail, or you
could be requesting an object that for some reason isn't available.
 Here's a simple example of the remote interface that defines the
behavior of RemoteObject.
 There are two methods that are used to calculate the sum and product.
import java.rmi.*;
public interface MyRemoteObject extends Remote{
public double sum(double num1, double num2) throws
RemoteException;
public double product(double num1, double num2) throws
RemoteException;
}
RMI
 The UnicastRemoteObject class:
 The actual implementation of a remote object (not the interface we
discussed previously) will usually extend
java.rmi.server.UnicastRemoteObject.
 This is the RMI equivalent to the familiar Object class.
 When a subclass of UnicastRemoteObject is constructed, the RMI
runtime system automatically "exports" it to start listening for network
connections from remote interfaces (stubs) for the object.
 Here's a remote object class that implements the RemoteObject
interface.

RMI
 The UnicastRemoteObject class:
import java.rmi.*;
public class MyRemoteObjectImpl implements MyRemoteObject

extends UnicastRemoteObject{
public double sum(double num1, double num2) throws

RemoteException{
//implementation of method here

}
public double product(double num1, double num2) throws

RemoteException{
//implementation of method here

}
}

RMI
 The RMI Registry:
 The registry is the RMI phone book.
 You use the registry to look up a reference to a registered remote object on
another host.
 The registry is implemented by a class called Naming and an application called
rmiregistry.
 This application must be running on the local host before you start a Java
program that uses the registry.
 You can then create instances of remote objects and bind them to particular
names in the registry.
 (Remote objects that bind themselves to the registry sometimes provide a
main( ) method for this purpose.)
 A registry name can be anything you choose; it takes the form of a slash-
separated path.
RMI
 The RMI Registry:
 When a client object wants to find your object, it constructs a special
URL with the rmi: protocol, the hostname, and the object name.
 On the client, the RMI Naming class then talks to the registry and
returns the remote object reference.
 Following there are four source codes. Check it out!

RMI
//Code 1: The Remote Interface
import java.rmi.*;
public interface Addition extends Remote{
public int add(int a, int b) throws RemoteException;

}
//Code 2: The implementation of Remote Interface
import java.rmi.*;
import java.rmi.server.*;
public class AdditionImpl extends UnicastRemoteObject implements

Addition{
public AdditionImpl() throws RemoteException{}
public int add(int x, int y){

return x+y;
}
}
RMI
 .
//Code 3: Server program
import java.rmi.*;
import java.io.*;
public class Server{
public static void main(String args[]) throws IOException{
AdditionImpl server = new AdditionImpl();
Naming.rebind("rmi://localhost/Addition",server);
System.out.println("Remote object has been successfully executed");

}
}

RMI
.
//Code 4: Client Program
import java.rmi.*;
public class Client{
public static void main(String args[]){
try{
Addition addition =
(Addition)Naming.lookup("rmi://localhost/Addition");
System.out.println("The sum is: " + addition.add(90,80));
}catch(ConnectException e){
System.out.println("Unable to connect to server");
}
catch(Exception ex){
ex.printStackTrace();
}
}
}

End of Chapter 6
Next: Java - Database connectivity
https://docs.oracle.com/en/java/
49

Chapter 6 Networking in Java

Uploaded by

Copyright:

Available Formats

You might also like

Chapter 6 Networking in Java

Uploaded by

Document Information

Original Description:

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Chapter 6 Networking in Java

Uploaded by

Copyright:

Available Formats

Course Title: Java Programming.

Credit Hour: 3 hrs.

Java Programming CoSc3053 1

CS@AmboU Advanced Programming - Comp 511 2

CS@AmboU Advanced Programming - Comp 511 3

CS@AmboU Advanced Programming - Comp 511 4

CS@AmboU Advanced Programming - Comp 511 5

Application (HTTP, FTP) DATA

Transport (TCP,UDP) HEADER DATA

Network (IP) HEADER HEADER DATA

Link (LINK) HEADER HEADER HEADER DATA

CS@AmboU Advanced Programming - Comp 511 8

CS@AmboU Advanced Programming - Comp 511 9

 Example applications: Link

CS@AmboU Advanced Programming - Comp 511 10

CS@AmboU Advanced Programming - Comp 511 11

CS@AmboU Advanced Programming - Comp 511 12

CS@AmboU Advanced Programming - Comp 511 13

CS@AmboU Advanced Programming - Comp 511 14

CS@AmboU Advanced Programming - Comp 511 15

CS@AmboU Advanced Programming - Comp 511 17

CS@AmboU Advanced Programming - Comp 511 20

CS@AmboU Advanced Programming - Comp 511 21

CS@AmboU Advanced Programming - Comp 511 22

CS@AmboU Advanced Programming - Comp 511 23

CS@AmboU Advanced Programming - Comp 511 24

CS@AmboU Advanced Programming - Comp 511 25

public static void main(String[] args){

CS@AmboU Advanced Programming - Comp 511 26

CS@AmboU Advanced Programming - Comp 511 29

public class DSender{

DatagramSocket ds = new DatagramSocket();

CS@AmboU Advanced Programming - Comp 511 30

DatagramSocket ds = new DatagramSocket(3000);

DatagramPacket dp = new DatagramPacket(buf, 1024);

String str = new String(dp.getData(), 0, dp.getLength());

CS@AmboU Advanced Programming - Comp 511 31

CS@AmboU Advanced Programming - Comp 511 32

CS@AmboU Advanced Programming - Comp 511 33

CS@AmboU Advanced Programming - Comp 511 35

CS@AmboU Advanced Programming - Comp 511 36

CS@AmboU Advanced Programming - Comp 511 38

CS@AmboU Advanced Programming - Comp 511 39

CS@AmboU Advanced Programming - Comp 511 40

CS@AmboU Advanced Programming - Comp 511 42

CS@AmboU Advanced Programming - Comp 511 43

CS@AmboU Advanced Programming - Comp 511 45

public class MyRemoteObjectImpl implements MyRemoteObject

public double sum(double num1, double num2) throws

//implementation of method here

public double product(double num1, double num2) throws

//implementation of method here

CS@AmboU Advanced Programming - Comp 511 46

 Following there are four source codes. Check it out!

CS@AmboU Advanced Programming - Comp 511 48

public int add(int a, int b) throws RemoteException;

//Code 2: The implementation of Remote Interface

public class AdditionImpl extends UnicastRemoteObject implements