360 likes | 435 Views
CS 491, 591 Networking in Java Summer 2007. Establishing a Simple Server (Using Stream Sockets). Creating a Java server Create ServerSocket object ServerSocket s = new ServerSocket( port, queueLength ); Register port number and set max number of waiting clients
E N D
Establishing a Simple Server (Using Stream Sockets) • Creating a Java server • Create ServerSocket object ServerSocket s = new ServerSocket( port, queueLength ); • Register port number and set max number of waiting clients • Binds server to port, waits for clients • Server listens indefinitely (blocks) for clients Socket connection = s.accept() • Connections managed by Socket objects • Returns Socket when connection established
Establishing a Simple Client (Using Stream Sockets) • Creating a Java server • Get I/O objects for communication • OutputStream - sends info to client • InputStream - gets info from client • Server's input stream is client's output stream, and vice versa • Use Socket object to get references to streams • connection.getInputStream() • connection.getOutputStream() • Methods write and read • Send individual bytes
Establishing a Simple Client (Using Stream Sockets) • Creating a Java server • Chaining stream types (sending objects and data, not bytes) ObjectInputStream input = new ObjectInputStream( connection.getInputStream() ) • Processing phase • Server/client communicate using InputStream and OutputStream • Termination • Transmission complete • Method close (of Socket) connection.close() • Networking appears as sequential file I/O • Sockets simplify networking
Establishing a Simple Client (Using Stream Sockets) • Creating a Java client • Create Socket to connect to server Socket connection = new Socket( serverAddress, port ) • If successful, returns Socket • Else throws subclass of IOException • Get stream objects • connection.getInputStream() • connection.getOutputStream() • Use chaining if transmitting objects and data, not pure bytes • ObjectInputStream, ObjectOutputStream
Establishing a Simple Client (Using Stream Sockets) • Creating a Java client • Processing phase • Communicate using stream objects • Termination • Transmission complete • connection.close() (close Socket) • Client must determine when server done • read returns -1 when eof found • ObjectInputStream generates EOFException
Client/Server Interaction with Stream Socket Connections • Upcoming program • Simple client/server chat application • Use stream sockets • Client connects, transmit String objects • do-while loop to get input • Event handler calls sendData method to send output • When either sends TERMINATE, connection terminates • Server waits for next client • GUI:
60 connection.getInetAddress().getHostName() ); 63 output = new ObjectOutputStream( 64 connection.getOutputStream() ); 65 output.flush(); Client/Server Interaction with Stream Socket Connections • Server • Once connection (Socket) established • getInetAddress() - returns InetAddress object • getHostName() - returns client's host name • Create ObjectOutputStream • flush() • Sends stream header to client • Required by client's ObjectInputStream
108 private void sendData( String s ) 109 { 111 output.writeObject( "SERVER>>> " + s ); 112 output.flush(); 113 display.append( "\nSERVER>>>" + s ); 81 display.setCaretPosition( 82 display.getText().length() ); Client/Server Interaction with Stream Socket Connections • Send/receive data • Method sendData called by event handler • Buffer flushed after every transmission • Sets cursor position to end of text • Allows JTextArea to scroll with text • Server processes single connection at a time • More likely to have separate threads for each connection
1 // Fig. 21.3: Server.java 2 // Set up a Server that will receive a connection 3 // from a client, send a string to the client, 4 // and close the connection. 5 import java.io.*; 6 import java.net.*; 7 import java.awt.*; 8 import java.awt.event.*; 9 import javax.swing.*; 10 11 public class Server extends JFrame { 12 private JTextField enter; 13 private JTextArea display; 14 ObjectOutputStream output; 15 ObjectInputStream input; 16 17 public Server() 18 { 19 super( "Server" ); 20 21 Container c = getContentPane(); 22 23 enter = new JTextField(); 24 enter.setEnabled( false ); 1. Constructor 1.1 GUI components
34 35 display = new JTextArea(); 36 c.add( new JScrollPane( display ), The event handlers calls method sendData, using text in JTextField as argument. 37 BorderLayout.CENTER ); 38 39 setSize( 300, 150 ); 40 show(); 41 } Register port 5000, server will allow 100 clients to wait in queue. 42 43 public void runServer() 44 { 45 ServerSocket server; 46 Socket connection; 47 int counter = 1; 48 49 try { 50 // Step 1: Create a ServerSocket. 51 server = new ServerSocket( 5000, 100 ); 52 25 enter.addActionListener( 26 new ActionListener() { 27 public void actionPerformed( ActionEvent e ) 28 { 29 sendData( e.getActionCommand() ); 30 } 31 } 32 ); 33 c.add( enter, BorderLayout.NORTH ); 1.2 Event handler 1.3 GUI 2. Method runServer 2.1 ServerSocket
67 connection.getInputStream() ); Infinite loop to wait for connections from clients. 68 display.append( "\nGot I/O streams\n" ); 69 Wait for connection (server.accept() waits indefinitely). 70 // Step 4: Process connection. 71 String message = Display host location. 72 "SERVER>>> Connection successful"; Set up I/O streams, flush buffer (sends stream data). Send confirmation message. 73 output.writeObject( message ); 74 output.flush(); Loop to get input. Set cursor to end of text. 75 enter.setEnabled( true ); 76 77 do { 78 try { 79 message = (String) input.readObject(); 80 display.append( "\n" + message ); 81 display.setCaretPosition( 82 display.getText().length() ); 83 } 53 while ( true ) { 54 // Step 2: Wait for a connection. 55 display.setText( "Waiting for connection\n" ); 56 connection = server.accept(); 57 58 display.append( "Connection " + counter + 59 " received from: " + 60 connection.getInetAddress().getHostName() ); 61 62 // Step 3: Get input and output streams. 63 output = new ObjectOutputStream( 64 connection.getOutputStream() ); 65 output.flush(); 66 input = new ObjectInputStream( 2.2 accept 2.3 getHostName 2.4 Get streams 2.5 writeObject 2.6 Loop
100 catch ( EOFException eof ) { Loop until TERMINATE string sent. 101 System.out.println( "Client terminated connection" ); 102 } 103 catch ( IOException io ) { Close connection and I/O streams. 104 io.printStackTrace(); 105 } 106 } 107 Send String object to client. Flush buffer to ensure it is sent, and update server's display. 108 private void sendData( String s ) 109 { 110 try { 111 output.writeObject( "SERVER>>> " + s ); 112 output.flush(); 113 display.append( "\nSERVER>>>" + s ); 114 } 84 catch ( ClassNotFoundException cnfex ) { 85 display.append( 86 "\nUnknown object type received" ); 87 } 88 } while ( !message.equals( "CLIENT>>> TERMINATE" ) ); 89 90 // Step 5: Close connection. 91 display.append( "\nUser terminated connection" ); 92 enter.setEnabled( false ); 93 output.close(); 94 input.close(); 95 connection.close(); 96 97 ++counter; 98 } 99 } 2.6 Loop 2.7 close 3. Method sendData 3.1 writeObject 3.2 flush
133 134 app.runServer(); 135 } 136 } 115 catch ( IOException cnfex ) { 116 display.append( 117 "\nError writing object" ); 118 } 119 } 120 121 public static void main( String args[] ) 122 { 123 Server app = new Server(); 124 125 app.addWindowListener( 126 new WindowAdapter() { 127 public void windowClosing( WindowEvent e ) 128 { 129 System.exit( 0 ); 130 } 131 } 132 ); 4. main
Client/Server Interaction with Stream Socket Connections • Client • Similar to server • Creates same GUI • Loops to wait for input • Sends output through event handler and sendData
50 client = new Socket( 51 InetAddress.getByName( "127.0.0.1" ), 5000 ); Client/Server Interaction with Stream Socket Connections • Create Socket with two arguments • Internet address of server and port number • static method getByName (Class InetAddress) • Returns InetAddress object • Takes String • Could have taken "localhost" or called static method getLocalHost • Create I/O objects as before • Output of server is input of client
1 // Fig. 21.4: Client.java 2 // Set up a Client that will read information sent 3 // from a Server and display the information. 4 import java.io.*; 5 import java.net.*; 6 import java.awt.*; 7 import java.awt.event.*; 8 import javax.swing.*; 9 10 public class Client extends JFrame { 11 private JTextField enter; 12 private JTextArea display; 13 ObjectOutputStream output; 14 ObjectInputStream input; 15 String message = ""; 16 17 public Client() 18 { 19 super( "Client" ); 20 21 Container c = getContentPane(); 22 23 enter = new JTextField(); 24 enter.setEnabled( false ); 1. Constructor 1.1 GUI
34 35 display = new JTextArea(); 36 c.add( new JScrollPane( display ), Client gets text from JTextField and calls sendData. 37 BorderLayout.CENTER ); 38 39 setSize( 300, 150 ); 40 show(); Create Socket to server, make connection. 41 } 42 43 public void runClient() 44 { 45 Socket client; 46 47 try { 48 // Step 1: Create a Socket to make connection. 49 display.setText( "Attempting connection\n" ); 50 client = new Socket( 51 InetAddress.getByName( "127.0.0.1" ), 5000 ); 52 53 54 55 25 enter.addActionListener( 26 new ActionListener() { 27 public void actionPerformed( ActionEvent e ) 28 { 29 sendData( e.getActionCommand() ); 30 } 31 } 32 ); 33 c.add( enter, BorderLayout.NORTH ); 1.2 Event handler 1.3 GUI 2. Method runClient 2.1 Socket
67 // Step 3: Process connection. 68 enter.setEnabled( true ); 69 70 do { 71 try { Code similar to server. Create I/O objects, flush buffer, loop to wait for and process input. 72 message = (String) input.readObject(); 73 display.append( "\n" + message ); 74 display.setCaretPosition( 75 display.getText().length() ); 76 } 77 catch ( ClassNotFoundException cnfex ) { 78 display.append( 79 "\nUnknown object type received" ); 80 } 81 } while ( !message.equals( "SERVER>>> TERMINATE" ) ); 82 56 display.append( "Connected to: " + 57 client.getInetAddress().getHostName() ); 58 59 // Step 2: Get the input and output streams. 60 output = new ObjectOutputStream( 61 client.getOutputStream() ); 62 output.flush(); 63 input = new ObjectInputStream( 64 client.getInputStream() ); 65 display.append( "\nGot I/O streams\n" ); 66 2.2 I/O streams 2.3 flush 2.4 Loop
100 message = s; 101 output.writeObject( "CLIENT>>> " + s ); 102 output.flush(); 103 display.append( "\nCLIENT>>>" + s ); 104 } 105 catch ( IOException cnfex ) { 106 display.append( 107 "\nError writing object" ); 108 } 109 } 110 83 // Step 4: Close connection. 84 display.append( "Closing connection.\n" ); 85 input.close(); 86 output.close(); 87 client.close(); 88 } 89 catch ( EOFException eof ) { 90 System.out.println( "Server terminated connection" ); 91 } 92 catch ( IOException e ) { 93 e.printStackTrace(); 94 } 95 } 96 97 private void sendData( String s ) 98 { 99 try { 2.5 close 3. Method sendData
111 public static void main( String args[] ) 112 { 113 Client app = new Client(); 114 115 app.addWindowListener( 116 new WindowAdapter() { 117 public void windowClosing( WindowEvent e ) 118 { 119 System.exit( 0 ); 120 } 121 } 122 ); 123 124 app.runClient(); 125 } 126 } 127 4. main Program Output
Program Output
Connectionless Client/Server Interaction with Datagrams • Connection-oriented interaction • Like phone call • Have connection to other end • Connection maintained for duration of call, even if not talking • Connectionless interaction • Like sending postal mail • Use datagrams, packets of data • If large packet, break into smaller pieces • Send separately • May arrive out of order or not arrive at all • Duplicates may arrive
40 byte data[] = new byte[ 100 ]; 41 receivePacket = 42 new DatagramPacket( data, data.length ); 45 socket.receive( receivePacket ); 27 socket = new DatagramSocket( 5000 ); Connectionless Client/Server Interaction with Datagrams • DatagramSocket( port ) • Binds server to port • DatagramPacket( byteArray, byteArray.length ) • Create DatagramPacket to store received packet • byteArray stores data • Method receive( packetToStore ) • Blocks until packet arrives, stores in packetToStore
48 display.append( "\nPacket received:" + 49 "\nFrom host: " + receivePacket.getAddress() + 50 "\nHost port: " + receivePacket.getPort() + 51 "\nLength: " + receivePacket.getLength() + 52 "\nContaining:\n\t" + 53 new String( receivePacket.getData(), 0, 54 receivePacket.getLength() ) ); Connectionless Client/Server Interaction with Datagrams • getAddress - returns InetAddress • getPort, getLength - return integers • getData - returns byte array • Used in String constructor to create string
58 sendPacket = 59 new DatagramPacket( receivePacket.getData(), 60 receivePacket.getLength(), 61 receivePacket.getAddress(), 62 receivePacket.getPort() ); 63 socket.send( sendPacket ); Connectionless Client/Server Interaction with Datagrams • Echo packet back to client • DatagramPacket( byteArray, length, InetAddress, port ) • Method send( packetToSend )
1 // Fig. 21.5: Server.java 2 // Set up a Server that will receive packets from a 3 // client and send packets to a client. 4 import java.io.*; 5 import java.net.*; 6 import java.awt.*; 7 import java.awt.event.*; 8 import javax.swing.*; 9 Create new DatagramSocket, binds server to port. 10 public class Server extends JFrame { 11 private JTextArea display; 12 13 private DatagramPacket sendPacket, receivePacket; 14 private DatagramSocket socket; 15 16 public Server() 17 { 18 super( "Server" ); 19 20 display = new JTextArea(); 21 getContentPane().add( new JScrollPane( display), 22 BorderLayout.CENTER ); 23 setSize( 400, 300 ); 24 show(); 25 26 try { 27 socket = new DatagramSocket( 5000 ); 28 } 1. Declarations 1.1 DatagramSocket
34 35 public void waitForPackets() Loop to wait for packets. 36 { Create new DatagramPacket to receive info. 37 while ( true ) { 38 try { 39 // set up packet 40 byte data[] = new byte[ 100 ]; Gather and display packet data. Convert byte array to a String. 41 receivePacket = 42 new DatagramPacket( data, data.length ); 43 Create packet back to client. 44 // wait for packet 45 socket.receive( receivePacket ); 46 47 // process packet 48 display.append( "\nPacket received:" + 49 "\nFrom host: " + receivePacket.getAddress() + 50 "\nHost port: " + receivePacket.getPort() + 51 "\nLength: " + receivePacket.getLength() + 52 "\nContaining:\n\t" + 53 new String( receivePacket.getData(), 0, 54 receivePacket.getLength() ) ); 55 56 // echo information from packet back to client 57 display.append( "\n\nEcho data to client..."); 58 sendPacket = 59 new DatagramPacket( receivePacket.getData(), 29 catch( SocketException se ) { 30 se.printStackTrace(); 31 System.exit( 1 ); 32 } 33 } 2. Method waitForPackets 2.1 receivePacket 2.2 receive 2.3 Process packet 2.4 Echo packet
67 } 68 catch( IOException io ) { Send packet back to client. 69 display.append( io.toString() + "\n" ); 70 io.printStackTrace(); 71 } 72 } 73 } 74 75 public static void main( String args[] ) 76 { 77 Server app = new Server(); 78 79 app.addWindowListener( 80 new WindowAdapter() { 81 public void windowClosing( WindowEvent e ) 82 { 83 System.exit( 0 ); 84 } 85 } 86 ); 87 88 app.waitForPackets(); 89 } 90 } 60 receivePacket.getLength(), 61 receivePacket.getAddress(), 62 receivePacket.getPort() ); 63 socket.send( sendPacket ); 64 display.append( "Packet sent\n" ); 65 display.setCaretPosition( 66 display.getText().length() ); 2.5 send 3. main
31 socket = new DatagramSocket(); Connectionless Client/Server Interaction with Datagrams • Client • Similar to server • Has JTextField • Sends packets with event handler for JTextField • Convert String to byteArray • String.getBytes() • Have loop to receive echoed packets from server • Constructor needs no arguments • Uses next available port • Server gets client's port number as part of DatagramPacket
1 // Fig. 21.6: Client.java 2 // Set up a Client that will send packets to a 3 // server and receive packets from a server. 4 import java.io.*; 5 import java.net.*; 6 import java.awt.*; 7 import java.awt.event.*; 8 import javax.swing.*; 9 10 public class Client extends JFrame implements ActionListener { 11 private JTextField enter; 12 private JTextArea display; 13 14 private DatagramPacket sendPacket, receivePacket; 15 private DatagramSocket socket; 16 17 public Client() 18 { 19 super( "Client" ); 20 21 enter = new JTextField( "Type message here" ); 22 enter.addActionListener( this ); 23 getContentPane().add( enter, BorderLayout.NORTH ); 24 display = new JTextArea(); 25 getContentPane().add( new JScrollPane( display ), 26 BorderLayout.CENTER ); 27 setSize( 400, 300 ); 28 show(); 29 1. Constructor 1.1 GUI 1.2 Register event handler
34 se.printStackTrace(); No argument constructor. 35 System.exit( 1 ); 36 } 37 } Similar to server, loop to receive echoed packets. 38 39 public void waitForPackets() 40 { 41 while ( true ) { 42 try { 43 // set up packet 44 byte data[] = new byte[ 100 ]; 45 receivePacket = 46 new DatagramPacket( data, data.length ); 47 48 // wait for packet 49 socket.receive( receivePacket ); 50 51 // process packet 52 display.append( "\nPacket received:" + 53 "\nFrom host: " + receivePacket.getAddress() + 54 "\nHost port: " + receivePacket.getPort() + 55 "\nLength: " + receivePacket.getLength() + 56 "\nContaining:\n\t" + 57 new String( receivePacket.getData(), 0, 58 receivePacket.getLength() ) ); 30 try { 31 socket = new DatagramSocket(); 32 } 33 catch( SocketException se ) { 1.3 DatagramSocket 2. waitForPackets 2.1 DatagramPacket 2.2 receive 2.3 Process packet
67 } 68 69 public void actionPerformed( ActionEvent e ) 70 { 71 try { Convert String to a byte array, use to initialize DatagramPacket. 72 display.append( "\nSending packet containing: " + 73 e.getActionCommand() + "\n" ); 74 75 String s = e.getActionCommand(); 76 byte data[] = s.getBytes(); 77 78 sendPacket = new DatagramPacket( data, data.length, 79 InetAddress.getLocalHost(), 5000 ); 80 socket.send( sendPacket ); 81 display.append( "Packet sent\n" ); 82 display.setCaretPosition( 83 display.getText().length() ); 84 85 } 86 catch ( IOException exception ) { 87 display.append( exception.toString() + "\n" ); 88 exception.printStackTrace(); 89 } 90 } 59 display.setCaretPosition( 60 display.getText().length() ); 61 } 62 catch( IOException exception ) { 63 display.append( exception.toString() + "\n" ); 64 exception.printStackTrace(); 65 } 66 } 3. actionPerformed 3.1 Create packet 3.2 send
100 System.exit( 0 ); 101 } 102 } 103 ); 104 105 app.waitForPackets(); 106 } 107 } 91 92 public static void main( String args[] ) 93 { 94 Client app = new Client(); 95 96 app.addWindowListener( 97 new WindowAdapter() { 98 public void windowClosing( WindowEvent e ) 99 { Program Output