Chapter 4 Networking

Chapter 4
Networking
1
4.1 Introduction
Java provides:-
Stream-based communications
 a process establishes a connection to another process. While
the connection is in place, data flows between the processes
 Connection-based protocol - Uses TCP
Packet-based communications
 Individual packets transmitted
 Connectionless service - Uses UDP (User Datagram Protocol)
Client-server relationship
 Client requests some action be performed
 Server performs the action and responds to client
 Request-response model
• Common implementation: Web browsers and Web servers
2
4.2 Manipulating URLs
 The HTTP protocol uses URIs to locate data on the Internet.
 A URI that represents a document is called a URL
• URL Refer to files, directories and complex objects

 Applet method getAppletContext returns a reference to an AppletContext
object that represents the browser in which the applet is executing.
 AppletContext method showDocument receives a URL as an argument and
passes it to the AppletContext (i.e., the browser), which displays the web
resource associated with that URL.
 param tag specifies parameters in HTML document.
 Each parameter has a name and a value and the applet can read these values
and use them to customize itself.
3
4.3 Reading a File on a Web Server
Swing GUI component JEditorPane Retrieves files from a Web server at a given URI
 JEditorPane method setPage downloads the document specified by its argument and
displays it in the JEditorPane.
 If an HTML document is displayed in a JEditorPane and the user clicks a hyperlink, the
JEditorPane generates a HyperlinkEvent and notifies all registered HyperlinkListeners
of the event.
 Three event types
•HyperlinkEvent.EventType.ACTIVATED
•HyperlinkEvent.EventType.ENTERED
•HyperlinkEvent.EventType.EXITED
4
1 // Fig. 24.3: ReadServerFile.java
2 // Use a JEditorPane to display the contents of a file on a Web server.
3 import java.awt.BorderLayout;
4 import java.awt.event.ActionEvent;
5 import java.awt.event.ActionListener;
6 import java.io.IOException; Import JEditPane from package
7 import javax.swing.JEditorPane; javax.swing, import
HyperlinkEvent and
8 import javax.swing.JFrame;
HyperlinkListener from package
9 import javax.swing.JOptionPane;
javax.swing.event
10 import javax.swing.JScrollPane;
11 import javax.swing.JTextField;
12 import javax.swing.event.HyperlinkEvent;
13 import javax.swing.event.HyperlinkListener;
14
15 public class ReadServerFile extends JFrame Declare
16 { JEditorPane
17 private JTextField enterField; // JTextField to enter site name contentsArea,
18 private JEditorPane contentsArea; // to display Web site which will be used to
19 display the contents of
20 // set up GUI the file
21 public ReadServerFile()
22 {
23 super( "Simple Web Browser" );
24
5
25 // create enterField and register its listener
26 enterField = new JTextField( "Enter file URL here" );
27 enterField.addActionListener(
28 new ActionListener()
29 {
30 // get document specified by user
31 public void actionPerformed( ActionEvent event )
32 {
33 getThePage( event.getActionCommand() );
34 } // end method actionPerformed
35 } // end inner class Create JEditorPane
36 ); // end call to addActionListener using the no-argument
37 constructor
38 add( enterField, BorderLayout.NORTH );
39
Set JEditorPane
40 contentsArea = new JEditorPane(); // create editable property to false
contentsArea
41 contentsArea.setEditable( false );
42 contentsArea.addHyperlinkListener(
Register a HyperlinkListener
43 new HyperlinkListener() to handle HyperlinkEvents,
44 { which occur when the user clicks a
45 // if user clicked hyperlink, go to specified page hyperlink in thehyperlinkUpdate
Method JEditorPane
46 public void hyperlinkUpdate( HyperlinkEvent event ) is called when a
47 {
Use HyperlinkEvent
HyperlinkEvent occurs
48 if ( event.getEventType() ==
method getEventType to
49 HyperlinkEvent.EventType.ACTIVATED )
50 getThePage( event.getURL().toString() ); determine the type of the
51 } // end method hyperlinkUpdate HyperlinkEvent
52 } // end inner class Use HyperlinkEvent method
53 ); // end call to addHyperlinkListener getURL to obtain the URL
54
represented by the hyperlink
6
55 add( new JScrollPane( contentsArea ), BorderLayout.CENTER );
56 setSize( 400, 300 ); // set size of window
57 setVisible( true ); // show window
58 } // end ReadServerFile constructor
59
60 // load document
61 private void getThePage( String location )
62 {
63 try // load document and display location
64 { Invoke JEditorPane
65 contentsArea.setPage( location ); // set the page
method setPage to
66 enterField.setText( location ); // set the text
download the document
67 } // end try
68 catch ( IOException ioException )
specified by location and
69 { display it in the JEditPane
70 JOptionPane.showMessageDialog( this,
71 "Error retrieving specified URL", "Bad URL",
72 JOptionPane.ERROR_MESSAGE );
73 } // end catch
74 } // end method getThePage
75 } // end class ReadServerFile
7
1 // Fig. 24.4: ReadServerFileTest.java
2 // Create and start a ReadServerFile.
4
5 public class ReadServerFileTest
6 {
7 public static void main( String args[] )
8 {
9 ReadServerFile application = new ReadServerFile();
10 application.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
11 } // end main
12 } // end class ReadServerFileTest
8
9
4.4 Establishing a Simple Server Using Stream Sockets
Five steps to create a simple server in Java

Step 1: Create ServerSocket object
 ServerSocket server = new ServerSocket(portNumber, queueLength );
 Register an available port
 Specify a maximum number of clients
 Handshake point
 Binding the server to the port
• Only one client can be bound to a specific port
Step 2: Server listens for client connection

 Server blocks until client connects
 Socket connection = server.accept();
10
4.4 Establishing a Simple Server Using Stream Sockets (Cont.)
Step 3: Sending and receiving data

 Output Stream to send and InputStream to receive data
 Method getOutputStream returns Socket’s OutputStream
 Methods getInputstream returns Socket’s InputStream
Step 4: Process phase

 Server and Client communicate via streams
Step 5: Close streams and connections

 Method close
 Port numbers can be between 0 and 65,535. Most operating systems

reserve port numbers below 1024 for system services.
11
4.5 Establishing a Simple Client Using Stream Sockets
 Four steps to create a simple client in Java
 Step 1: Create a Socket to connect to server
 Socket connection = new Socket (serverAddress, port );
 Step 2: Obtain Socket’s InputStream and Outputstream
 Step 3: Process information communicated
 Step 4: Close streams and connection
12

4.6 Client/Server Interaction with Stream Socket
Connections
 Client/server chat application

 Uses stream sockets
 Server waits for a client connection attempt
 Client connects to the server
 Send and receive messages
 Client or server terminates the connection
 Server waits for the next client to connect
14
1 // Fig. 24.5: Server.java
2 // Set up a Server that will receive a connection from a client, send
3 // a string to the client, and close the connection.
4 import java.io.EOFException;
5 import java.io.IOException;
6 import java.io.ObjectInputStream;
7 import java.io.ObjectOutputStream;
8 import java.net.ServerSocket; Import ServerSocket and
9 import java.net.Socket; Socket from package
10 import java.awt.BorderLayout; java.net r
e
erv on
12 import java.awt.event.ActionListener; s cti
13 import javax.swing.JFrame; k e nne
t
14 import javax.swing.JScrollPane; oc t co
15 erS lien
v or c
import javax.swing.JTextArea;
16 import javax.swing.JTextField; r
e ts f
S
17 import javax.swing.SwingUtilities;
l are wai
c h
De hic
18
19 public class Server extends JFrame w wh i ch
20 {
ct ion
e
21 private JTextField enterField; // inputs message from user
conn client
22 private JTextArea displayArea; // display information to user
oc ket s to the
23 private ObjectOutputStream output; // output stream to client
c l a r e S o n n e ct
24 private De
ObjectInputStream input; // input stream from client
c
25 private ServerSocket server; // server socket
26 private Socket connection; // connection to client
27 private int counter = 1; // counter of number of connections
28
15
29 // set up GUI
30 public Server()
31 {
32 super( "Server" );
33
34 enterField = new JTextField(); // create enterField
35 enterField.setEditable( false );
38 {
39 // send message to client
41 {
42 sendData( event.getActionCommand() );
43 enterField.setText( "" );
45 } // end anonymous inner class
46 ); // end call to addActionListener
47
49
50 displayArea = new JTextArea(); // create displayArea
51 add( new JScrollPane( displayArea ), BorderLayout.CENTER );
52
55 } // end Server constructor
56
16
57 // set up and run server
58 public void runServer()
59 {
60 try // set up server to receive connections; process connections
61 {
62 server = new ServerSocket( 12345, 100 ); // create ServerSocket
63
64 while ( true ) Create ServerSocket at port
65 { 12345 with queue of length 100
66 try
67 { Wait for a client
68 waitForConnection(); // wait for a connection
Afterconnection
the connection is
69 getStreams(); // get input & output streams
Send the initialobtain
established, connection
70 processConnection(); // process connection
71 } // end try
message to
references to the
the client
streamsand
72 catch ( EOFException eofException ) process
for all messages
the connection
73 { received from the client
74 displayMessage( "\nServer terminated connection" );
75 } // end catch
17
76 finally
77 {
78 closeConnection(); // close connection
79 counter++;
80 } // end finally
81 } // end while
82 } // end try
84 {
85 ioException.printStackTrace();
86 } // end catch
87 } // end method runServer Output thehost name of the computer that
88 made
Usethe connection usingmethod
ServerSocket Socket accept
89 // wait method
for connection to arrive, then display connection info
getInetAddress and
90 private
to wait for a connection from a client
void waitForConnection() throws IOException
InetAddress method getHostName
91 {
92 displayMessage( "Waiting for connection\n" );
93 connection = server.accept(); // allow server to accept connection
94 displayMessage( "Connection " + counter + " received from: " +
95 connection.getInetAddress().getHostName() );
96 } // end method waitForConnection
97
Obtain Socket’s OutputStream and use
98 // get streams to send and receive data
99
Method flush empties
private void getStreams() throws IOException
output buffer
it to initialize ObjectOutputStream
100 { and sends header information
101 // set up output stream for objects
102 output = new ObjectOutputStream( connection.getOutputStream() );
103 output.flush(); // flush output buffer to send header information
104
18
105 // set up input stream for objects
106 input = new ObjectInputStream( connection.getInputStream() );
107
108 displayMessage( "\nGot I/O streams\n" );
109 } // end method getStreams Obtain Socket’s InputStream and use it
110 to initialize ObjectInputStream
111 // process connection with client
112 private void processConnection() throws IOException
113 {
114 String message = "Connection successful";
115 sendData( message ); // send connection successful message
116
117 // enable enterField so server user can send messages
118 setTextFieldEditable( true );
119 Use ObjectInputStream method
120 do // process messages sent from client readObject to read a String from client
121 {
122 try // read message and display it
123 {
124 message = ( String ) input.readObject(); // read new message
125 displayMessage( "\n" + message ); // display message
126 } // end try
127 catch ( ClassNotFoundException classNotFoundException )
128 {
129 displayMessage( "\nUnknown object type received" );
130 } // end catch
131
19
132 } while ( !message.equals( "CLIENT>>> TERMINATE" ) );
133 } // end method processConnection
134
135 // close streams and socket
Method closeConnection
136 private void closeConnection()
137 {
closes streams and sockets
138 displayMessage( "\nTerminating connection\n" );
139 setTextFieldEditable( false ); // disable enterField
140
141 try
142 {
143 output.close(); // close output stream
144 input.close(); // close input stream
Invoke Socket method
145 connection.close(); // close socket
146 } // end try
close to close the socket
148 {
150 } // end catch
151 } // end method closeConnection
153 // send message to client Use ObjectOutputStream method
154 private void sendData( String message ) writeObject to send a String to client
155 {
156 try // send object to client
157 {
158 output.writeObject( "SERVER>>> " + message );
159 output.flush(); // flush output to client
160 displayMessage( "\nSERVER>>> " + message );
161 } // end try
20
163 {
164 displayArea.append( "\nError writing object" );
165 } // end catch
166 } // end method sendData
167
168 // manipulates displayArea in the event-dispatch thread
169 private void displayMessage( final String messageToDisplay )
170 {
171 SwingUtilities.invokeLater(
172 new Runnable()
173 {
174 public void run() // updates displayArea
175 {
176 displayArea.append( messageToDisplay ); // append message
177 } // end method run
179 ); // end call to SwingUtilities.invokeLater
180 } // end method displayMessage
181
21
182 // manipulates enterField in the event-dispatch thread
183 private void setTextFieldEditable( final boolean editable )
184 {
186 new Runnable()
187 {
188 public void run() // sets enterField's editability
189 {
190 enterField.setEditable( editable );
192 } // end inner class
194 } // end method setTextFieldEditable
195 } // end class Server
22
1 // Fig. 24.6: ServerTest.java
2 // Test the Server application.
4
5 public class ServerTest
6 {
8 {
9 Server application = new Server(); // create server
11 application.runServer(); // run server application
12 } // end main
13 } // end class ServerTest
23
Software Engineering Observation
When using an ObjectOutputStream and ObjectInputStream to send and
receive data over a network connection, always create the ObjectOutputStream
first and flush the stream so that the client’s ObjectInputStream can prepare to
receive the data.
This is required only for networking applications that communicate using
ObjectOutputStream and ObjectInputStream.
24
1 // Fig. 24.7: Client.java
2 // Client that reads and displays information sent from a Server.
3 import java.io.EOFException;
5 import java.io.ObjectInputStream;
6 import java.io.ObjectOutputStream;
7 import java.net.InetAddress;
8 import java.net.Socket;
14 import javax.swing.JTextArea;
17
18 public class Client extends JFrame
19 {
20 private JTextField enterField; // enters information from user
21 private JTextArea displayArea; // display information to user
22 private ObjectOutputStream output; // output stream to server
23 private ObjectInputStream input; // input stream from server
24 private String message = ""; // message from server
25 private String chatServer; // host server for this application
26 private Socket client; // socket to communicate with server
27
25
28 // initialize chatServer and set up GUI
29 public Client( String host )
30 {
31 super( "Client" );
32
33 chatServer = host; // set server to which this client connects
34
35 enterField = new JTextField(); // create enterField
36 enterField.setEditable( false );
39 {
40 // send message to server
42 {
43 sendData( event.getActionCommand() );
44 enterField.setText( "" );
48
50
53
56 } // end Client constructor
57
26
58 // connect to server and process messages from server
59 public void runClient()
60 {
61 try // connect to server, get streams, process connection
62 {
63 connectToServer(); // create a Socket to make connection
64 getStreams(); // get the input and output streams
65 processConnection(); // process connection
66 } // end try
67 catch ( EOFException eofException )
68 {
69 displayMessage( "\nClient terminated connection" );
70 } // end catch
72 {
74 } // end catch
75 finally
76 {
77 closeConnection(); // close connection
78 } // end finally
79 } // end method runClient
80
81 // connect to server
82 private void connectToServer() throws IOException
83 {
84 displayMessage( "Attempting connection\n" );
85
27
86 // create Socket to make connection to server
87 client = new Socket( InetAddress.getByName( chatServer ), 12345 );
88 CreateUse
a Socket that
InetAddress static method
89 // display connection information
will connect with port to obtain an
getByName
90 displayMessage( "Connected to: " +
91 client.getInetAddress().getHostName() );
12345 on the server object containing the
InetAdress
92 } // end method connectToServer IP address specified Display
as a command-
a message
93 line argument
Obtain Socket’s to the application
indicating
OutputStream the name
and use of the
94 // get streams to send and receive data
Method flush it empties buffer server computer to which
outputObjectOutputStream
to initialize
95 private void getStreams() throws IOException
and sends header information the client has connected
96 {
97 // set up output stream for objects
98 output = new ObjectOutputStream( client.getOutputStream() );
99 output.flush(); // flush output buffer to send header information
100
101 // set up input stream for objects
102 input = new ObjectInputStream( client.getInputStream() );
103
104 displayMessage( "\nGot I/O streams\n" );
105 } // end method getStreams
106
107 // process connection with server
108 private void processConnection() throws IOException
109 {
110 // enable enterField so client user can send messages
111 setTextFieldEditable( true );
112
28
113 do // process messages sent from server
114 {
115 try // read message and display it
116 {
117 message = ( String ) input.readObject(); // read new message
118 displayMessage( "\n" + message ); // display message
119 } // end try Read a String
120 catch ( ClassNotFoundException classNotFoundException )
object from server
121 {
122 displayMessage( "\nUnknown object type received" );
123 } // end catch
124
125 } while ( !message.equals( "SERVER>>> TERMINATE" ) );
126 } // end method processConnection
127
128 // close streams and socket
129 private void closeConnection()
130 {
131 displayMessage( "\nClosing connection" );
132 setTextFieldEditable( false ); // disable enterField
133
134 try
135 {
136 output.close(); // close output stream
137 input.close(); // close input stream 1
Invoke Socket method
138 client.close(); // close socket
139 } // end try
close to close the socket
29
141 {
143 } // end catch
144 } // end method closeConnection
145
146 // send message to server Use ObjectOutputStream method
147 private void sendData( String message ) writeObject to send a String to server
148 {
149 try // send object to server
150 {
151 output.writeObject( "CLIENT>>> " + message );
152 output.flush(); // flush data to output
153 displayMessage( "\nCLIENT>>> " + message );
154 } // end try
156 {
157 displayArea.append( "\nError writing object" );
158 } // end catch
159 } // end method sendData
160
30
163 {
165 new Runnable()
166 {
168 {
169 displayArea.append( messageToDisplay );
174
175 // manipulates enterField in the event-dispatch thread
176 private void setTextFieldEditable( final boolean editable )
177 {
179 new Runnable()
180 {
181 public void run() // sets enterField's editability
182 {
183 enterField.setEditable( editable );
187 } // end method setTextFieldEditable
188 } // end class Client
31
1 // Fig. 24.8: ClientTest.java
2 // Test the Client class.
4
5 public class ClientTest
6 {
8 {
9 Client application; // declare client application
10
11 // if no command line args
12 if ( args.length == 0 )
13 application = new Client( "127.0.0.1" ); // connect to localhost
14 else
15 application = new Client( args[ 0 ] ); // use args to connect
16
18 application.runClient(); // run client application
19 } // end main
20 } // end class ClientTest
32
33
4.7 Connectionless Client/Server Interaction with Datagrams
 Connectionless transmission with datagrams

 No connection maintained with other computer
 Break message into separate pieces and send as packets
 Message arrive in order, out of order or not at all
 Receiver puts messages in order and reads them
34
1 // Fig. 24.9: Server.java
2 // Server that receives and sends packets from/to a client.
4 import java.net.DatagramPacket;
5 import java.net.DatagramSocket;
6 import java.net.SocketException;
12
13 public class Server extends JFrame
14 {
15 private JTextArea displayArea; // displays packets received Use a
16 private DatagramSocket socket; // socket to connect to client DatagramSocket
17 as our server
18 // set up GUI and DatagramSocket
19 public Server()
20 {
21 super( "Server" );
22
27
35
28 try // create DatagramSocket for sending and receiving packets
29 {
30 socket = new DatagramSocket( 5000 );
Use the DatagramSocket
31 } // end try constructor that takes an integer
32 catch ( SocketException socketException ) port number argument to bind the
33 { server to a port where it can receive
34 socketException.printStackTrace(); packets from clients
35 System.exit( 1 );
36 } // end catch
37 } // end Server constructor
38
39 // wait for packets to arrive, display data and echo packet to client
40 public void waitForPackets()
41 {
42 while ( true )
43 {
44 try // receive packet, display contents, return copy to client
45 {
46 byte data[] = new byte[ 100 ]; // set up packet
Create a DatagramPacket in
47 DatagramPacket receivePacket =
48 new DatagramPacket( data, data.length );
which a received packet of
49 information can be stored
50 socket.receive( receivePacket ); // wait to receive packet
51
Use DatagramSocket
method receive to wait for a
packet to arrive at the server
36
52 // display information from received packet
53 displayMessage( "\nPacket received:" +
54
Use DatagramPacket
"\nFrom host: " + receivePacket.getAddress() + Use
methodDatagramPacket
getAddress to obtain
55 "\nHost port: " + receivePacket.getPort() +
Use DatagramPacket
method getPort to the
obtain the
56 "\nLength: " + receivePacket.getLength() + the host name of computer
method
portfrom
number through
getLength to obtain
which thesent
57 "\nContaining:\n\t" + new String( receivePacket.getData(), which the packet was
58 0, receivePacket.getLength() ) ); thehost
number of bytes
computer sentofthe
data sent
packet
59
60 sendPacketToClient( receivePacket ); // send packet to client
61 } // end try
Use DatagramPacket method getData to
63 { obtain an byte array containing the data
64 displayMessage( ioException.toString() + "\n" );
66 } // end catch
67 } // end while
68 } // end method waitForPackets
69
70 // echo packet to client
71 private void sendPacketToClient( DatagramPacket receivePacket )
72 throws IOException Create a DatagramPacket, which specifies the
73 { data to send, the number of bytes to send, the
74 displayMessage( "\n\nEcho data to client..." );
client computer’s Internet address and the port
75
76 // create packet to send
where the client is waiting to receive packets
77 DatagramPacket sendPacket = new DatagramPacket(
78 receivePacket.getData(), receivePacket.getLength(),
79 receivePacket.getAddress(), receivePacket.getPort() );
80
37
81 socket.send( sendPacket ); // send packet to client
82 displayMessage( "Packet sent\n" );
83 } // end method sendPacketToClient
84 Use method send of DatagramSocket
85 // manipulates displayArea in the to send the packet over the network
event-dispatch thread
87 {
89 new Runnable()
90 {
92 {
93 displayArea.append( messageToDisplay ); // display message
98 } // end class Server
38
1 // Fig. 24.10: ServerTest.java
2 // Tests the Server class.
4
5 public class ServerTest
6 {
8 {
9 Server application = new Server(); // create server
11 application.waitForPackets(); // run server application
12 } // end main
13 } // end class ServerTest
Server window after packet

of data is received from client
39
1 // Fig. 24.11: Client.java
2 // Client that sends and receives packets to/from a server.
4 import java.net.DatagramPacket;
5 import java.net.DatagramSocket;
6 import java.net.InetAddress;
7 import java.net.SocketException;
16
17 public class Client extends JFrame
18 {
19 private JTextField enterField; // for entering messages
20 private JTextArea displayArea; // for displaying messages
21 private DatagramSocket socket; // socket to connect to server
22
23 // set up GUI and DatagramSocket
24 public Client()
25 {
26 super( "Client" );
27
40
28 enterField = new JTextField( "Type message here" );
31 {
33 {
34 try // create and send packet
35 {
36 // get message from textfield
37 String message = event.getActionCommand();
38
Create a DatagramPacket andthe
displayArea.append( "\nSending packet containing: " Convert
+
initialize
String it with the
39 message + "\n" ); byte array, the length of the string that was
to a byte entered by the
array
40 user, the IP address to which the packet is to be sent and
41 byte data[] = message.getBytes();the//
port number
convert to at which the server is waiting
bytes
42
43 // create sendPacket
44 DatagramPacket sendPacket = new DatagramPacket( data, Use DatagramPacket
45 data.length, InetAddress.getLocalHost(), 5000 );
method send to send the packet
46
47 socket.send( sendPacket ); // send packet
48 displayArea.append( "Packet sent\n" );
49 displayArea.setCaretPosition(
50 displayArea.getText().length() );
51 } // end try
41
53 {
54 displayMessage( ioException.toString() + "\n" );
56 } // end catch
57 } // end actionPerformed
60
62
63 displayArea = new JTextArea();
65
66 setSize( 400, 300 ); // set window size
68
69 try // create DatagramSocket for sending and receiving packets
Create a
70 {
71 socket = new DatagramSocket();
DatagramSocket
72 } // end try for sending and
73 catch ( SocketException socketException ) receiving packets
74 {
75 socketException.printStackTrace();
76 System.exit( 1 );
77 } // end catch
78 } // end Client constructor
79
42
80 // wait for packets to arrive from Server, display packet contents
81 public void waitForPackets()
82 {
83 while ( true )
84 {
85 try // receive packet and display contents
86 { Create a
87 byte data[] = new byte[ 100 ]; // set up packet
DatagramPacket
88 DatagramPacket receivePacket = new DatagramPacket(
89 data, data.length );
to store received
90 information
91 socket.receive( receivePacket ); // wait for packet
92
93 // display packet contents
94 displayMessage( "\nPacket received:" +
95
Use DatagramPacket
"\nFrom host: " + receivePacket.getAddress() + Use DatagramPacket
method getAddress to obtain
96 "\nHost port: " + receivePacket.getPort() +
Use DatagramPacket
method getPort to the
obtain the
97 "\nLength: " + receivePacket.getLength() + the host name of computer
98
method
port number
getLength to obtain
through which the
"\nContaining:\n\t" + new String( receivePacket.getData(),from which the packet was sent
99 0, receivePacket.getLength() ) ); thehost
number of bytes
computer sentofthe
data sent
packet
100 } // end try
101 catch ( IOException exception )
102 {
103
Use DatagramPacket method getData to
displayMessage( exception.toString() + "\n" );
104 exception.printStackTrace(); obtain an byte array containing the data
105 } // end catch
106 } // end while
107 } // end method waitForPackets
108
43
111 {
113 new Runnable()
114 {
116 {
117 displayArea.append( messageToDisplay );
122 } // end class Client
44
1 // Fig. 24.12: ClientTest.java
2 // Tests the Client class.
4
5 public class ClientTest
6 {
8 {
9 Client application = new Client(); // create client
11 application.waitForPackets(); // run client application
12 } // end main
13 } // end class ClientTest
Client window after sending

packet to Server and receiving
packet back from Server
45

Chapter 4 Networking

Uploaded by

Document Information

Original Title

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 4 Networking

Uploaded by

Copyright:

Available Formats

Chapter 4

• URL Refer to files, directories and complex objects

Five steps to create a simple server in Java

Step 2: Server listens for client connection

Step 3: Sending and receiving data

 Method getOutputStream returns Socket’s OutputStream

 Methods getInputstream returns Socket’s InputStream

Step 4: Process phase

Step 5: Close streams and connections

 Port numbers can be between 0 and 65,535. Most operating systems

 Step 2: Obtain Socket’s InputStream and Outputstream

 Step 3: Process information communicated

 Step 4: Close streams and connection

 Client/server chat application

When using an ObjectOutputStream and ObjectInputStream to send and

receive data over a network connection, always create the ObjectOutputStream

receive the data.

This is required only for networking applications that communicate using

ObjectOutputStream and ObjectInputStream.

 Connectionless transmission with datagrams

Server window after packet

Client window after sending

You might also like