Download Clients and Servers in Java

Peter
Jones
Java Programming
The Language of Now & the Future
Clients and Servers
including Internet connectivity,
I/O and JDBC
John Morris and Peter Jones
Department of Electrical and Electronic Engineering,
University of Western Australia
John
Morris
Sockets
• Sockets are the “endpoints” of Internet connections
nnn
0
Internet
Ports
0
Ports
Machine
A
nnn
Machine
B
• Socket constructors require Internet addresses
• Socket( String host, int port ) throws
UnknownHostException,
IOException;
• Socket(InetAddress address, int port) throws
IOException;
... and a host of other alternatives, see the API documentation!
• Note: these constructors throw exceptions
• Use them in a try { } catch .. block
Sockets
• Note: these constructors throw exceptions
• Use them in a try { } catch .. Block
String name = new String(“ciips.ee.uwa.edu.au”);
try {
Socket t = new Socket( name, 80 );
...
}
catch( UnknownHostException e ) {
System.out.println(“Unknown host:” + name );
}
catch( IOException e ) {
...
}
• Note: UnknownHostException is a subclass of
IOException
 catch( IOException e ) alone would suffice
Aside: Datagrams, ...
• Use a DatagramSocket
• Constructor
DatagramSocket( int port ) throws
creates a datagram socket on port
IOException;
• Methods
void receive( DatagramPacket p ) throws IOException;
void send( DatagramPacket p ) throws IOException;
• DatagramPacket
• Constructor
DatagramPacket( byte[] buf, int length,
InetAddress add, int port );
creates a packet to be sent to port at add
• Methods
• byte[] getData();
• void setData( byte[] buf );
• InetAddress getAddress();
Datagrams, ...
• Use a DatagramSocket
• Constructor
DatagramSocket( int port ) throws
creates a datagram socket on port
IOException;
• Methods
Note:
void receive( DatagramPacket p ) throws IOException;
byte[]
void send( DatagramPacket p ) throws IOException
;
not
• DatagramPacket
char[]
... more later!
• Constructor
DatagramPacket( byte[] buf, int length,
InetAddress add, int port );
creates a packet to be sent to port at add
• Methods
• byte[] getData();
• void setData( byte[] buf );
• InetAddress getAddress();
Multicast sockets ...
• Messages to multiple hosts
• Use a MulticastSocket
• Constructor
MulticastSocket( int port ) throws IOException;
creates a datagram socket bound to port
Inherited from
DatagramSocket
• Methods
• void receive( DatagramPacket p ) throws IOException;
• void send( DatagramPacket p ) throws IOException;
• void joinGroup( InetAddress mcastaddr )
throws IOException;
• void leaveGroup( InetAddress mcastaddr )
throws IOException;
• Hosts can join and leave multicast groups
• Security feature:
• An applet is not allowed to use a multicast socket
Talking to a server
static final int lut_port = 3062;
String name = new String(“ciips.ee.uwa.edu.au”);
static final String query = “?”;
try {
Socket server = new Socket( name, lut_port );
DataInputStream input =
new DataInputStream( server.getInputStream() );
PrintStream output = new PrintStream( server.getOutputStream() );
do {
output.println( query );
String resp = input.readLine();
System.out.println( name + “ response: “ + resp );
} while ( !( resp.equal( quit_string ) ) );
server.close();
}
catch( UnknownHostException e ) {
System.out.println(“Unknown host:” + name );
}
catch( IOException e ) {
...
}
Talking to a server
Socket
(and almost all the rest)
throws an exception,
static final int lut_port = 3062;
String name = new String(“ciips.ee.uwa.edu.au”);
so put it all in a
static final String query = “?”;
try { } block
try {
Socket server = new Socket( name, lut_port );
DataInputStream input =
new DataInputStream( server.getInputStream() );
PrintStream output = new PrintStream( server.getOutputStream() );
do {
Once the Socket
output.println( query );
has been created,
String resp = input.readLine();
System.out.println( name + “ response: “ +create
resp input
);
and output
} while ( !( resp.equal( quit_string ) ) ); streams on it
server.close();
}
catch( UnknownHostException e ) {
System.out.println(“Unknown host:” + name );
}
DataInputStream
Just part of the stream
catch( IOException
e ) {
DataOutputStream
...
zoo - there are 55 more!
PrintStream
}
Talking to a server
static final int lut_port = 3062;
String name = new String(“ciips.ee.uwa.edu.au”);
static final String query = “?”;
Now use methods on the
try {
streams just
Socket server = new Socket( name, lut_port
); like any other
DataInputStream input =
I/O device
new DataInputStream(
server.getInputStream()
);
println
on PrintStream
PrintStream output = new PrintStream( server.getOutputStream() );
readLine on DataInputStream
do {
output.println( query );
String resp = input.readLine();
System.out.println( name + “ response: “ + resp );
} while ( !( resp.equal( quit_string ) ) );
server.close();
}
catch( UnknownHostException e ) {
System.out.println(“Unknown host:” + name );
}
catch( IOException e ) {
...
}
Talking to a server
Finally add some code to handle exceptions!
static final intChoices
lut_port
= 3062;
(Java
usually gives you plenty )
String name = new String(“ciips.ee.uwa.edu.au”);
 Separate catch blocks for different types
static final String query = “?”;
 One “catch all” (IOException)
try {
{ } catch
} for each
Socket server 
= try
new Socket(
name, {lut_port
); method call
DataInputStream
input =the exception from here
 Throw
new DataInputStream( server.getInputStream() );
PrintStream output = new PrintStream( server.getOutputStream() );
do {
output.println( query );
String resp = input.readLine();
System.out.println( name + “ response: “ + resp );
} while ( !( resp.equal( quit_string ) ) );
server.close();
}
catch( UnknownHostException e ) {
System.out.println(“Unknown host:” + name );
}
catch( IOException e ) {
...
}
Talking to a server - variant 1
Exception Choices (Java usually gives you plenty )
static 
final
= 3062;
tryint{lut_port
} catch
{ } for each method call
String name = new String(“ciips.ee.uwa.edu.au”);
 Throw the exception from here
static final String query = “?”;
try {
Socket server = new Socket( name, lut_port );
}
catch( UnknownHostException e ) {
System.out.println(“Unknown host:” + name ); return error_flag;
try {
}
catch( IOException e ) {
catch
/* process other errors .... */
return error_flag;
around
}
}
{ }
each
exception
throwing call
try {
DataInputStream input =
new DataInputStream( server.getInputStream() );
PrintStream output = new PrintStream( server.getOutputStream() );
}
catch( IOException e ) {
System.out.println(“Cant form streams”); return error_flag;
}
do { /* do some real work ... */
Talking to a server - variant 2
Exception Choices (Java usually gives you plenty )
 try { } catch { } for each method call
 Throw the exception from here
This method
throws any
exceptions
up a level
public String ServerResp( String query )
throws IOException {
static final int lut_port = 3062;
String name = new String(“ciips.ee.uwa.edu.au”);
Socket server = new Socket( name, lut_port );
DataInputStream input =
new DataInputStream( server.getInputStream() );
PrintStream output = new PrintStream( server.getOutputStream() );
output.println( query );
String resp = input.readLine();
server.close();
return resp;
}
Simple Server
static final int lut_port = 3062;
static final int queue_len = 10;
try {
Socket server = new ServerSocket( lut_port, queue_len );
}
catch( IOException e ) {
System.out.println(“Can’t establish server on port “ + lut_port );
}
while( true ) { // The server never dies!
// Wait for a connection attempt
try {
Socket s = server.accept();
PrintStream ps = new PrintStream( s.getOutputStream() );
DataInputStream in = new DataInputStream( s.getInputStream() );
while( true ) {
String q = in.readLine();
if ( q.equal( “?” ) )
ps.println( “Hello” );
else if ( q.equal( “quit” ) ) break;
else
ps.println( “??” );
}
s.close();
// Close this connection
}
catch ( IOException e ) { /* Do something about it! */ }
}
Simple Server
Set up a ServerSocket
- basically just a socket
with an accept method
static final int lut_port = 3062;
static final int queue_len = 10;
try {
Socket server = new ServerSocket( lut_port, queue_len );
}
catch( IOException e ) {
System.out.println(“Can’t establish server on port “ + lut_port );
}
while( true ) { // The server never dies!
Servers usually live
// Wait for a connection attemtp
forever!!
try {
Socket s = server.accept();
The code will
PrintStream ps = new PrintStream( s.getOutputStream()
);block
here until a
DataInputStream in = new DataInputStream( s.getInputStream()
);
while( true ) {
client attempts
String q = in.readLine();
a connection
if ( q.equal( “?” ) )
ps.println( “Hello” );
else if ( q.equal( “quit” ) ) break;
else
ps.println( “??” );
}
s.close();
// Close this connection
}
catch ( IOException e ) { /* Do something about it! */ }
}
Simple Server
static final int lut_port = 3062;
static final int queue_len = 10;
try {
Socket server = new ServerSocket( lut_port, queue_len );
}
catch( IOException e ) {
System.out.println(“Can’t establish server on port “ + lut_port );
Now we just
}
while( true ) { // The 
server
dies!& output streams
createnever
the input
// Wait for a connection
attemtp
 read
and write to them
try {
 close the connection when we’re finished
Socket s = server.accept();
PrintStream ps = new PrintStream( s.getOutputStream() );
DataInputStream in = new DataInputStream( s.getInputStream() );
while( true ) {
String q = in.readLine();
if ( q.equal( “?” ) )
ps.println( “Hello” );
else if ( q.equal( “quit” ) ) break;
else
ps.println( “??” );
}
s.close();
// Close this connection
}
catch ( IOException e ) { /* Do something about it! */ }
}
Simple Server
static final int lut_port = 3062;
static final int queue_len = 10;
try {
Socket server = new ServerSocket( lut_port, queue_len );
}
But ...
catch( IOException e ) {
This server blocks whilst one user is using it!
System.out.println(“Can’t establish server on port “ + lut_port );
A second client can’t connect ‘til the first one finishes!
}
while( true ) { // The server never dies!
// Wait for a connection attemtp
try {
Socket s = server.accept();
PrintStream ps = new PrintStream( s.getOutputStream() );
DataInputStream in = new DataInputStream( s.getInputStream() );
while( true ) {
String q = in.readLine();
if ( q.equal( “?” ) )
ps.println( “Hello” );
else if ( q.equal( “quit” ) ) break;
else
ps.println( “??” );
}
Solution ...// Close this connection
s.close();
A thread for each client
}
catch ( IOException e ) { /* Do something about it! */ }
}
Multi-threaded Server
Make this parameter relevant!
static final int lut_port = 3062;
Number of queued requests
static final int queue_len = 10;
try {
Socket server = new ServerSocket( lut_port, queue_len );
}
catch( IOException e ) {
System.out.println(“Can’t establish server on port “ + lut_port );
}
As soon as we get a
while( true ) { // The server never dies!
// Wait for a connection attempt
connection,
try {
spawn a handler thread
Socket s = server.accept();
to talk to the client
// This thread will do the talking
ClientHandler ch = new ClientHandler( s );
ch.start();
}
catch ( IOException e ) { /* Do something about it! */ }
}
Start the thread
Multi-threaded Server - The Handler
This class is a Thread
class ClientHandler extends Thread {
Socket s;
Constructor public ClientHandler( Socket s ) {
just save a reference to the
this.s = s;
socket
}
public void run() {
PrintStream ps = new PrintStream( s.getOutputStream() );
DataInputStream in = new DataInputStream( s.getInputStream() );
while( true ) {
String q = in.readLine();
if ( q.equal( “?” ) )
ps.println( “Hello” );
else if ( q.equal( “quit” ) ) break;
else
ps.println( “??” );
}
s.close();
// Close this connection
}
Same operational code ..
}
Just embedded in the
thread’s run method
I/O Streams - Too much choice?
• There’s a bewildering array of choices ... “Stream Zoo”
• Considering input ..
• InputStream
 ByteArrayInputStream
 FileInputStream
 FilterInputStream
 BufferedInputStream
 DataInputStream
 DataInput
 InflaterInputStream
 GZIPInputStream
 ZipInputStream

... 3 more!
 PipedInputStream
 ... 3 more!
Matching
Output classes
also!
I/O Streams - Too much choice?
• ... and the Reader classes!
• Characters (16 bits!) rather than bytes
• Reader
 BufferedReader
 LineNumberReader
 CharArrayReader
 FilterReader
 PushbackReader
Matching
 InputStreamReader
Writer classes
 FileReader
also!
 PipedReader
 StringReader
Writing Objects to Streams
• ObjectOutputStream
• Enables writing of serialized objects
• Serializable objects implement the java.io.Serializable
interface
• private void writeObject( ObjectOutputStream out )
throws IOException;
• private void readObject( ObjectInputStream in )
throws IOException, ClassNotFoundException;
• ClassNotFoundException?
• A remote program could send you an object that you
don’t know about ..
• .. and therefore don’t know how to de-serialize!
Bytes and characters in Java
• Java has
• Primitive types
• byte
• char
• Classes
• Byte
• Character
• Class Byte has a single attribute of type byte
• It’s just a class “wrapper” for a byte
• Class Character ...
• Characters are Unicode characters
• For the full tables, see
• ftp://ftp.unicode.org/Public
• Character methods
• isDigit, isLetter, isLowerCase, ...
• Full story: Gosling, Joy & Steele, “The Java Language Specification”
Bytes and characters in Java
• Class Character ...
• Characters are Unicode characters
• Main trap ...
• “char” files created by other programs, eg C, C++
• Files created by text editors
• ... but Windows “NotePad” often creates Unicode files for you!
• Suggestion
• Use byte / Byte if the file, stream, ... may be
generated/read by any other language
URLs
• Not surprisingly, Java provides good support for URLs
• URL class
• Constructors
• URL( String spec );
• URL( String protocol, String host, int port,
String file );
• URL( String protocol, String host, String file );
• Methods
• Object getContent();
• Retrieve the whole file
• URLConnection openConnection();
• Used when URLConnection subclasses, eg
HttpURLConnection, JarURLConnection exist
• InputStream openStream();
SQL databases
• JDBC
• provides a bridge to an Open Database Connectivity
(ODBC) interface to a specific database
• Getting started
• import java.sql.*;
• Load the bridge ..
• Class.forName( “sun.jdbc.odbc.JdbcOdbcDriver” );
• Connect to a database
• Connection c = DriverManager.getConnection(
String URL,
String username, String passwd );
• Create an SQL statement
• Statement s = c.createStatement();
• Execute a statement
• s.execute( String sql_statement );
SQL databases
• JDBC
• Results from a query
• ResultSet res = s.executeQuery( String s );
• Goto the first row ...
• res.next();
• Extract data
• String name = res.getString( String col_name );
• int value = res.getInt( String col_name );
• ... and, of course, several pages more!
• Examing the table returned
• ResultSetMetaData m = res.getMetaData();
• Information about the table
• int columns = m.getColumnCount();
• String label = m.getColumnLabel( int col_no );
• Columns number from 1!
• String ctype = m.getColumnType( int col_no );
• ... and, of course, 19 more!