cs 491, 591 networking in java summer 2007

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

• 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


• 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


• 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


• 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:


• 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

63 output = new ObjectOutputStream(64 connection.getOutputStream() );65 output.flush();

60 connection.getInetAddress().getHostName() );


– 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

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() );

1. Constructor

1.1 GUI components

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.2 Event handler

1.3 GUI

2. Method runServer

2.1 ServerSocket

34

35 display = new JTextArea();

36 c.add( new JScrollPane( display ),

37 BorderLayout.CENTER );

38

39 setSize( 300, 150 );

40 show();

41 }

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.

5151 server = new ServerSocket( 5000, 100 );

52

25 enter.addActionListener(

26 new ActionListener() {

27 public void actionPerformed( ActionEvent e )

28 {

2929 sendData( e.getActionCommand() );

30 }

31 }

32 );

33 c.add( enter, BorderLayout.NORTH );

The event handlers calls method sendData, using text in JTextField as argument.

Register port 5000, server will allow 100 clients to wait in queue.

2.2 accept

2.3 getHostName

2.4 Get streams

2.5 writeObject

2.6 Loop

67 connection.getInputStream() );68 display.append( "\nGot I/O streams\n" );69 70 // Step 4: Process connection.71 String message =72 "SERVER>>> Connection successful";73 output.writeObject( message );74 output.flush();75 enter.setEnabled( true );767777 do {78 try {79 message = (String) input.readObject();80 display.append( "\n" + message );81 display.setCaretPosition(82 display.getText().length() );83 }

5353 while ( true ) {54 // Step 2: Wait for a connection.55 display.setText( "Waiting for connection\n" );5656 connection = server.accept();57 58 display.append( "Connection " + counter +59 " received from: " +6060 connection.getInetAddress().getHostName() );6162 // Step 3: Get input and output streams.6363 output = new ObjectOutputStream(64 connection.getOutputStream() );65 output.flush();66 input = new ObjectInputStream(

Infinite loop to wait for connections from clients.

Wait for connection (server.accept() waits indefinitely).

Display host location.

Set up I/O streams, flush buffer (sends stream data). Send confirmation message.

Loop to get input. Set cursor to end of text.

2.6 Loop

2.7 close

3. Method sendData

3.1 writeObject

3.2 flush100 catch ( EOFException eof ) {101 System.out.println( "Client terminated connection" );102 }103 catch ( IOException io ) {104 io.printStackTrace();105 }106 }107108 private void sendData( String s )109 {110 try {111111 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 }8888 } while ( !message.equals( "CLIENT>>> TERMINATE" ) );8990 // Step 5: Close connection.91 display.append( "\nUser terminated connection" );92 enter.setEnabled( false );9393 output.close();94 input.close();95 connection.close();9697 ++counter;98 }99 }

Loop until TERMINATE string sent.

Close connection and I/O streams.

Send String object to client. Flush buffer to ensure it is sent, and update server's display.

4. main

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 );


• Client– Similar to server

– Creates same GUI

– Loops to wait for input• Sends output through event handler and sendData


– 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

50 client = new Socket(

51 InetAddress.getByName( "127.0.0.1" ), 5000 );

1. Constructor

1.1 GUI

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.*;





9

10 public class Client extends JFrame {



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.2 Event handler

1.3 GUI

2. Method runClient

2.1 Socket

3435 display = new JTextArea();36 c.add( new JScrollPane( display ),37 BorderLayout.CENTER );3839 setSize( 300, 150 );40 show();41 }4243 public void runClient() 44 {45 Socket client;4647 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 );52535455

25 enter.addActionListener(26 new ActionListener() {27 public void actionPerformed( ActionEvent e )28 {2929 sendData( e.getActionCommand() );30 }31 }32 );33 c.add( enter, BorderLayout.NORTH );

Client gets text from JTextField and calls sendData.

Create Socket to server, make connection.

2.2 I/O streams

2.3 flush

2.4 Loop

67 // Step 3: Process connection.

68 enter.setEnabled( true );

69

70 do {

71 try {

72 message = (String) input.readObject();

73 display.append( "\n" + message );



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() );

6262 output.flush();

63 input = new ObjectInputStream(

64 client.getInputStream() );

65 display.append( "\nGot I/O streams\n" );

66

Code similar to server. Create I/O objects, flush buffer, loop to wait for and process input.

2.5 close

3. Method sendData

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 }9697 private void sendData( String s )98 {99 try {

4. main

Program Output


112 {

113 Client app = new Client();

114




118 {


120 }

121 }

122 );

123

124 app.runClient();

125 }

126}

127

ProgramOutput

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


– 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

27 socket = new DatagramSocket( 5000 );

40 byte data[] = new byte[ 100 ];

41 receivePacket =

42 new DatagramPacket( data, data.length );

45 socket.receive( receivePacket );


– getAddress - returns InetAddress– getPort, getLength - return integers– getData - returns byte array

• Used in String constructor to create string

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() ) );


– Echo packet back to client• DatagramPacket( byteArray, length, InetAddress, port )

• Method send( packetToSend )

58 sendPacket =

59 new DatagramPacket( receivePacket.getData(),60 receivePacket.getLength(),

62 receivePacket.getPort() );

63 socket.send( sendPacket );

61 receivePacket.getAddress(),

1. Declarations

1.1 DatagramSocket

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.*;





9

10 public class Server extends JFrame {


12

13 private DatagramPacket sendPacket, receivePacket;

14 private DatagramSocket socket;

15

16 public Server()

17 {

18 super( "Server" );

19


21 getContentPane().add( new JScrollPane( display),


23 setSize( 400, 300 );

24 show();

25

26 try {

27 socket = new DatagramSocket( 5000 );

28 }

Create new DatagramSocket, binds server to port.

2. Method waitForPackets

2.1 receivePacket

2.2 receive

2.3 Process packet

2.4 Echo packet

3435 public void waitForPackets()36 {3737 while ( true ) {38 try {39 // set up packet40 byte data[] = new byte[ 100 ];41 receivePacket =4242 new DatagramPacket( data, data.length );4344 // wait for packet45 socket.receive( receivePacket );46 47 // process packet48 display.append( "\nPacket received:" +49 "\nFrom host: " + receivePacket.getAddress() +50 "\nHost port: " + receivePacket.getPort() +51 "\nLength: " + receivePacket.getLength() +52 "\nContaining:\n\t" +5353 new String( receivePacket.getData(), 0,54 receivePacket.getLength() ) );5556 // echo information from packet back to client57 display.append( "\n\nEcho data to client...");

29 catch( SocketException se ) {30 se.printStackTrace();31 System.exit( 1 );32 }33 }

5858 sendPacket =59 new DatagramPacket( receivePacket.getData(),

Create new DatagramPacket to receive info.

Gather and display packet data. Convert byte array to a String.

Create packet back to client.

Loop to wait for packets.

2.5 send

3. main67 }68 catch( IOException io ) {69 display.append( io.toString() + "\n" );70 io.printStackTrace();71 }72 }73 }7475 public static void main( String args[] )76 {77 Server app = new Server();7879 app.addWindowListener(80 new WindowAdapter() {81 public void windowClosing( WindowEvent e )82 {83 System.exit( 0 );84 }85 }86 );8788 app.waitForPackets();89 }90 }

60 receivePacket.getLength(),

61 receivePacket.getAddress(),

62 receivePacket.getPort() );

6363 socket.send( sendPacket );

64 display.append( "Packet sent\n" );



Send packet back to client.

Program Output


• 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

31 socket = new DatagramSocket();

1. Constructor

1.1 GUI

1.2 Register event handler

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.*;





9

10 public class Client extends JFrame implements ActionListener {



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 );


25 getContentPane().add( new JScrollPane( display ),


27 setSize( 400, 300 );

28 show();

29

1.3 DatagramSocket

2. waitForPackets

2.1 DatagramPacket

2.2 receive

2.3 Process packet

34 se.printStackTrace();


36 }

37 }

38

39 public void waitForPackets()

40 {

4141 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 {

3131 socket = new DatagramSocket();

32 }

33 catch( SocketException se ) {

No argument constructor.

Similar to server, loop to receive echoed packets.

3. actionPerformed

3.1 Create packet

3.2 send

67 }6869 public void actionPerformed( ActionEvent e )70 {71 try {72 display.append( "\nSending packet containing: " +73 e.getActionCommand() + "\n" );7475 String s = e.getActionCommand();7676 byte data[] = s.getBytes();7778 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() );8485 }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 }

Convert String to a byte array, use to initialize DatagramPacket.

Program Output


101 }

102 }

103 );

104

105 app.waitForPackets();

106 }

107}

91


93 {

94 Client app = new Client();

95




99 {

cs 491, 591 networking in java summer 2007

Documents