Download EE2E1 Lecture 9

EE2E1. JAVA Programming
Lecture 9
Network Programming
Contents








Introduction to networks
TCP/IP Sockets
A simple client program
A simple server program
A server with multiple clients
Example – a simple email program
URL connections
Advanced networking technologies in Java
Introduction to Networks

Network programming is surprisingly easy in Java

Most of the classes relevant to network
programming are in the java.net package

Sending data out onto a network involves attaching
a stream to a network connection (socket) and using
the stream I/O functions we looked at in a previous
lecture

The main issues to consider are client/server
architectures and attaching multiple clients to a
server

First we will look an introduction to networking
and the TCP/IP protocol
Internet Protocol (IP)

Data is transmitted between computers in packets
 Each packet is marked with a destination
address
Server
Client
14
30
80
Internet
130.65.83.25
30
data
Network packet
Server Ports

Each 4 byte address is the IP address



Normally we refer to computers with domain
names

www.bham.ac.uk

java.sun.com
The translation from domain name to IP
address is carried out using DNS (Domain
Name Service)
IP has no provision for re-transmission in case
of failure to deliver packets

This is the job of the Transmission Control
Protocol (TCP)

Most internet programs (eg the WWW, email
etc) are based on TCP/IP
TCP/IP Sockets

A TCP/IP socket enables a java program
running on a client machine to open a
connection with a web server

There is a socket on both the client and
server sides

Client server communication is carried
out through input and output streams
Client output
stream
Client
socket
Client input
stream
Server input
stream
Server
socket
Server output
stream
A simple client program

Java has a Socket object which is an abstraction
for a TCP/IP network endpoint to a client
computer
int HTTP_PORT=80;
Socket s= new Socket(“java.sun.com”,HTTP_PORT);
InputStream instream=s.getInputStream();
OutputStream outstream=s.getOutputStream();

Connects to a server specified by the hostname
“java.sun.com” and creates I/O streams

We can also directly specify the IP address
instead of a string
 Java has a InetAddress class to specify IP
addresses
 The (static) method getByName()
converts from a hostname to an
InetAddress
int HTTP_PORT=80;
InetAddress address=InetAddress(“java.sun.com”);
Socket s= new Socket(address,HTTP_PORT);

Note that Java also provides a mechanism
for the user datagram protocol (UDP) which
is a simpler transport protocol that TCP


The Datagram socket is the abstraction to
a UDP socket
The difference between TCP and UDP is
like the difference between a telephone
conversation (albeit sent in packets) and
sending a letter

As it stands, attempting to read from a
socket will block until data becomes
available

Its possible to set a timeout (in ms) after
which a socket read will throw an
exception
int HTTP_PORT=80;
Socket s= new Socket(“java.sun.com”,HTTP_PORT);
s.setSoTimeOut(5000);
// 5 seconds
InputStream instream=s.getInputStream();
try{ // read socket}
catch(InterruptedIOException e) { // process exception}

The above code assumes we have already
created a Socket object from which to call
setSoTimeOut()

But the Socket constructor can itself
block if it can’t make a connection

This is possible if the server is
unavailable

Needs a multi-threaded solution
class SocketOpener implements Runnable
{
public void SocketOpener(String aHost, int aPort,
int aTimeOut) {}
public Socket openSocket()
{
Thread t=new Thread(this);
t.start();
// Calls the run method
try
{
t.join(timeOut);
// Returns when thread dies or timeout expires
}
catch (interruptedException e) {}
return socket;
}
public void run()
{
// Opens a socket
try{socket=new Socket(host,port);}
catch (IOException e) {}
}
private int timeOut;
private String host;
private int port;
private Socket socket;
};

We can now implement a simple client program
which opens a socket to communicate with a web
server
 The hostname is supplied from the command
line
 A GET command is sent to the web server
 This is a HTTP command to return the
requested item
 For example “GET / HTTP/1.0” means get
the root page (/) from the host
 The server will then return the requested
information which is just HTML text
public class WebGet
{
public static void main(String[] args)
{
// Read command line args
String host;
String resource;
if (args.length==2)
{
host=args[0];
resource=args[1];
System.out.println("Getting " + resource + " from " + host);
}
else
{
System.out.println("Getting / from java.sun.com");
host="java.sun.com";
resource="/";
}
try
{
// Open socket
final int HTTP_PORT=80;
SocketOpener so=new SocketOpener(host, HTTP_PORT, 10000);
Socket s=so.openSocket();
// Get streams
if (s!=null)
{
InputStream instream=s.getInputStream();
OutputStream outstream=s.getOutputStream();
// Turn streams in scanners and writers
Scanner in=new Scanner(instream);
PrintWriter out=new PrintWriter(outstream);
// Send command
String command="GET " + resource + " HTTP/1.0\n\n";
out.print(command);
out.flush();
// Read response from the server
while (in.hasNextLine())
{
String input=in.nextLine();
System.out.println(input);
}
// Close socket
s.close();
}
else
System.out.println("Error - couldn't open socket");
}
catch(IOException e) {}
}
}
A simple server program
A server is a program which waits for a
client to connect to it at a specified port
 Normally a server would specify some
application level protocol (such as HTTP)
enabling clients to interact with the server
 To start with, we will look at a simple server
which simply echo’s the text sent to it by the
client
 We will use telnet as the client to test out
our server


A ServerSocket object is created to establish a
server connection

The accept() method then waits for a client to
connect

accept() waits indefinitely and returns a Socket
object that represents the connection to the
client
int portNumber=8250;
ServerSocket s=new ServerSocket(portNumber);
Socket clientSoc=s.accept();
public class EchoServer
{
public static void main(String[] args)
{
try
{
ServerSocket s=new ServerSocket(8250);
Socket clientSoc=s.accept();
BufferedReader in=new BufferedReader(new
InputStreamReader(clientSoc.getInputStream()));
PrintWriter out=new
PrintWriter(clientSoc.getOutputStream(),true);
out.println("Hello client! Enter BYE to exit");
boolean done=false;
while (!done)
{
String line=in.readLine();
if (line==null) done=true;
else
{
out.println("Echo: " + line);
if (line.trim().equals("BYE"))
done=true;
}
}
clientSoc.close();
}
catch(Exception e){}
}
}

We can run the telnet client on the local
host (IP 127.0.0.1) at port 8250
 Use telnet command
open 127.0.0.1 8250
A server with multiple clients

In the real world a server will want to link to many
clients
 Examples include servers providing
information (such as weather or travel info) or
online ticket booking
 Clearly we don’t want a single client program
to ‘hog’ a server and prevent other clients from
accessing it
 By implementing a multi-threaded server, we
can allow multiple connections
 We simply need to create a new thread to
handle each newly accepted client
connection
int portNumber=8250;
ServerSocket s=new ServerSocket(portNumber);
while(true)
// accept multiple clients
{
Socket clientSoc=s.accept();
Thread t=new ThreadedEchoHandler(clientSoc);
t.start();
// Handle the client communication
}

We can implement 2 classes,
MultiThreadedEchoServer and
ThreadedEchoHandler to handle multiple
client connections
 MultiThreadedEchoServer creates
ThreadedEchoHandler objects for each
client
 ThreadedEchoHandler extends Thread
and its run() method handles client I/O
 Its implementation is the same as the
main method of the EchoServer class
MultiThreadedEchoServer
object
ThreadedEchoHandler
object
Telnet
ThreadedEchoHandler
object
Telnet
ThreadedEchoHandler
object
Telnet
public class MultiThreadedEchoServer
{
public static void main(String[] args)
{
int clientID=1;
try
{
ServerSocket s=new ServerSocket(8250);
for (;;)
{
Socket clientSoc=s.accept();
System.out.println("New client connection” + clientID);
new ThreadedEchoHandler(clientSoc,clientID).start();
clientID++;
}
}
catch(Exception e){}
}
}
An email program
As a simple example of socket
programming we can implement a program
that sends email to a remote site
 This is taken from Core Java, vol 2,
chapter 3
 Email servers use port number 25 which is
the SMTP port
 Simple mail transport protocol


A client socket to the mail server can be
opened on port 25
Socket s=new Socket(“engmail.bham.ac.uk”,25);

SMPT uses the following protocol
HELO sending host
MAIL FROM:sender email address
RCPT TO: recipient email address
DATA
mail message
…
.
QUIT
The email program uses a simple GUI to
input the required information
 The send button on the GUI calls the
sendMail() method which outputs the
correct protocol to the mail server

Socket s=new Socket(“engmail.bham.ac.uk”,25);
out=new PrintWriter(s.getOutputStream());
String hostname=InetAddress.getLocalHost().getHostName();
out.println(“HELO “ + hostname);
out.println(“MAIL FROM: “ + from.getText());
etc
URL connections



We have seen that to send or retrieve information
to a web server, we use the HTTP protocol
through a client socket attached to port 80
We can do this by using normal socket-based
programming and sending the correct HTTP
commands
However, Java has specific support for the HTTP
protocol through its URLConnection class
 Its very easy to retrieve a file from a web server
by simply providing the file’s url as a string
URL u=new URL(“http://www.bham.ac.uk”);
URLConnection c=u.openConnection();
InputStream in=c.getInputStream();


This sets up an input stream from a url connection
 Can turn this into a Scanner object for text
processing
The URLConnection class also has additional
functionality related to the HTTP protocol
 Querying the server for header information
 Setting request properties
The following simple example program
opens a web page and displays the HTML
 It also checks the server response code
 404 if the page is not found
 200 if the connection succeeded
 Uses a Scanner object to output the lines of
HTML

public class URLGet
{
public static void main(String[] args) throws IOException
{
String urlName;
if (args.length > 0)
urlName = args[0];
else
urlName = "http://java.sun.com";
URL url = new URL(urlName);
URLConnection c = url.openConnection();
// Check response code
HttpURLConnection
httpConnection = (HttpURLConnection) c;
int code =httpConnection.getResponseCode();
String message=httpConnection.getResponseMessage();
System.out.println(code + " " + message);
if (code!=HttpURLConnection.HTTP_OK)
return;
// Read server response
InputStream instream=connection.getInputStream();
Scanner in=new Scanner(instream);
while (in.hasNextLine())
{
String input=in.nextLine();
System.out.println(input);
}
}
}
Advanced networking technologies
in Java

In this section we will look briefly at more
advanced technologies for networking in
Java without looking in detail at code
 Sending data to a web server
 CGI and servlet technology
 Inter-object communication
 Remote method invocation (RMI)
 CORBA
CGI and servlet technology

We often need to send data back to a web server
 Typically we fill out an online form displayed
on a web browser and click a ‘submit’ button
 Older web technology uses a CGI script to
process the information
 CGI stands for Common Gateway Interface
 Typically it is a program running on the
server and written in a scripting language
like Perl
 The CGI script processes the data submitted
and sends back a response to the client –
usually a HTML page
Script produces
reply page
Reply
page
Client displays
web form
submit
CGI script
Form data
http server
Server starts
CGI script
Server
Client web
Server returns browser
reply
CGI is well established and still widely used
technology
 Its major disadvantage is that each request
forks a new process which can make it slow
 Makes sharing resources tricky
 Also there are some security flaws with CGI
– it can be fooled into running commands
on the server since it uses an interpreted
scripted language


Servlets are Java classes which extend the
HttpServlet class. They run inside a Servlet
Container which calls methods of the servlet
 The servlet container must be part of a
compliant web server which contains the Java
runtime environment
 They run in the Java virtual machine inside the
web server and so are portable and secure
 Unlike CGI each separate request creates a new
thread which is able to share resources with
existing running threads
Inter-object communication

Object orientation is all about objects
‘communicating’ with each other by calling
each others’ methods
 What if the objects are distributed across
a network?
 What if the objects are implemented in
different languages? (eg Java and C++)

There are two mechanisms for inter object
communication across a network
 Language independent mechanism is called
CORBA
 Common object request broker
 A separate language neutral broker object
handles all messages between the objects
 Generally rather slow and complex because
of its generality and ability to handle legacy
code
 If both objects are implemented in Java a much
simpler mechanism is Remote Method
Invocation (RMI)

In RMI, a client object calls a method of a
server object on a different machine
 Client/server terminology only applies to
the single method call
Method call with parameters
Client
object
Server
object
Returned data (objects)


All this seems easy but the actual behind the
scenes issues are complex
 Actual inter-object communictation is done
through separate stub objects which package
remote method calls and parameters
 The server registers its objects with a naming
service
 The clients finds the remote objects using a url :
“rmi://servername.com/”
 There are complex security issues involved also
as calling a remote method locally can
introduce viruses
However, much of this is transparent to the
programmer and RMI is relatively straighforward
And finally…..
Network programming is a doddle in Java
 Sockets look like ordinary I/O streams from
an application programming viewpoint
 The main issues are writing multi-threaded
code for multiple client applications
 In the last lab exercise, you will have the
opportunity to write a multi-threading
server for a network-based game!

A very early ……..
Merry Christmas!!