AhmadLang / Java, How To Program, 2004

object using a three-argument constructor that takes a byte array, the offset and the length. This String is then appended to the text to display.

After displaying a packet, line 60 calls method sendPacketToClient (declared at lines 7183) to create a new packet and send it to the client. Lines 7779 create a DatagramPacket and pass four arguments to its constructor. The first argument specifies the byte array to send. The second argument specifies the number of bytes to send. The third argument specifies the client computer's Internet address, to which the packet will be sent. The fourth argument specifies the port where the client is waiting to receive packets. Line 81 sends the packet over the network. Method send of DatagramSocket throws an IOException if an error occurs while sending a packet.

[Page 1139]

Client Class

Class Client (Fig. 24.11) works similarly to class Server, except that the Client sends packets only when the user types a message in a textfield and presses the Enter key. When this occurs, the program calls method actionPerformed (lines 3257), which converts the string the user entered into a byte array (line 41). Lines 4445 create a DatagramPacket and initialize it with the byte array, the length of the string that was entered by the user, the IP address to which the packet is to be sent (InetAddress.getLocalHost() in this example) and the port number at which the Server is waiting for packets (5000 in this example). Line 47 sends the packet. Note that the client in this example must know that the server is receiving packets at port 5000otherwise, the server will not receive the packets.

Note that the DatagramSocket constructor call (line 71) in this application does not specify any arguments. This no-argument constructor allows the computer to select the next available port number for the DatagramSocket. The client does not need a specific port number, because the server receives the client's port number as part of each DatagramPacket sent by the client. Thus, the server can send packets back to the same computer and port number from which it receives a packet of information.

Client method waitForPackets (lines 81107) uses an infinite loop to wait for packets from the server. Line 91 blocks until a packet arrives. This does not prevent the user from sending a packet, because the GUI events are handled in the event-dispatch thread. It only prevents the while loop from continuing until a packet arrives at the Client. When a packet arrives, line 91 stores it in receivePacket, and lines 9499 call method displayMessage (declared at lines 110121) to display the packet's contents in the textarea.

55server = new Server-Socket( 12345, 2 ); // set up ServerSocket

56} // end try

57catch ( IOException ioException )

58{

59ioException.printStackTrace();

60System.exit( 1 );

61} // end catch

62

63outputArea = new JTextArea(); // create JTextArea for output

64add( outputArea, BorderLayout.CENTER );

65outputArea.setText( "Server awaiting connections\n" );

66

67setSize( 300, 300 ); // set size of window

68setVisible( true ); // show window

69} // end TicTacToeServer constructor

70

71// wait for two connections so game can be played

72public void execute()

73{

74// wait for each client to connect

75 for ( int i = 0; i < players.length; i++ )

76{

77try // wait for connection, create Player, start runnable

78{

81} // end try

82catch ( IOException ioException )

83{

86} // end catch

87} // end for

88

89 gameLock.lock(); // lock game to signal player X's thread 90

91try

92{

93players[ PLAYER_X ].setSuspended( false ); // resume player X

94otherPlayerConnected.signal(); // wake up player X's thread

95} // end try

96finally

97{

98gameLock.unlock(); // unlock game after signalling player X

99} // end finally

100} // end method execute

101

102// display message in outputArea

103private void displayMessage( final String messageToDisplay )

104{

105// display message from event-dispatch thread of execution

106SwingUtilities.invokeLater(

107new Runnable()

108{

113} // end inner class

114); // end call to SwingUtilities.invokeLater

115} // end method displayMessage

116

117// determine if move is valid

118public boolean validateAndMove( int location, int player )

119{

120// while not current player, must wait for turn

121while ( player != currentPlayer )

122{

123gameLock.lock(); // lock game to wait for other player to go

125try

126{

128} // end try

129catch ( InterruptedException exception )

132} // end catch

133finally

134{

136} // end finally

137} // end while

138

139// if location not occupied, make move

140if ( !isOccupied( location ) )

141{

142board[ location ] = MARKS[ currentPlayer ]; // set move on board

143currentPlayer = ( currentPlayer + 1 ) % 2; // change player

144

145// let new current player know that move occurred

146players[ currentPlayer ].otherPlayerMoved( location );

150try

151{

153} // end try

154finally

155{

159return true; // notify player that move was valid

160} // end if

161else // move was not valid

162return false; // notify player that move was invalid

163} // end method validateAndMove

164

165// determine whether location is occupied

166public boolean isOccupied( int location )

167{

168if ( board[ location ].equals( MARKS[ PLAYER_X ] ) ||

169board [ location ].equals( MARKS[ PLAYER_O ] ) )

170return true; // location is occupied

171else

172return false; // location is not occupied

173} // end method isOccupied

174

175// place code in this method to determine whether game over

176public boolean isGameOver()

177{

178return false; // this is left as an exercise

179} // end method isGameOver

180

181// private inner class Player manages each Player as a runnable

182private class Player implements Runnable

183{

184private Socket connection; // connection to client

185private Scanner input; // input from client

186private Formatter output; // output to client

187private int playerNumber; // tracks which player this is

188private String mark; // mark for this player

189private boolean suspended = true; // whether thread is suspended

191// set up Player thread

192public Player( Socket socket, int number )

193{

194playerNumber = number; // store this player's number

195mark = MARKS[ playerNumber ]; // specify player's mark

196connection = socket; // store socket for client

197

198try // obtain streams from Socket

199{

202} // end try

203catch ( IOException ioException )

204{

207} // end catch

208} // end Player constructor

210// send message that other player moved

211public void otherPlayerMoved( int location )

212{

213output.format( "Opponent moved\n" );

214output.format( "%d\n", location ); // send location of move

215output.flush(); // flush output

216} // end method otherPlayerMoved

217

218// control thread's execution

219public void run()

220{

221// send client its mark (X or O), process messages from client

222try

223{

284} // end try

285finally

286{

296} // end finally

297} // end method run

299// set whether or not thread is suspended

300public void setSuspended( boolean status )

301{

302suspended = status; // set value of suspended

303} // end method setSuspended

304} // end class Player

305} // end class TicTacToeServer

Figure 24.14. Class that tests Tic-Tac-Toe server.

(This item is displayed on page 1146 in the print version)

1// Fig. 24.14: TicTacToeServerTest.java

2// Tests the TicTacToeServer.

3import javax.swing.JFrame;

4

5public class TicTacToeServerTest

6{

7public static void main( String args[] )

8{

9TicTacToeServer application = new TicTacToeServer();

10application.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );

11application.execute();

12} // end main

13} // end class TicTacToeServerTest

Figure 24.15. Client side of client/server Tic-Tac-Toe program.

(This item is displayed on pages 1147 - 1152 in the print version)

1// Fig. 24.15: TicTacToeClient.java

2// Client that let a user play Tic-Tac-Toe with another across a network.

3import java.awt.BorderLayout;

4import java.awt.Dimension;

5import java.awt.Graphics;

6import java.awt.GridLayout;

7import java.awt.event.MouseAdapter;

8import java.awt.event.MouseEvent;

9import java.net.Socket;

10import java.net.InetAddress;

11import java.io.IOException;

12import javax.swing.JFrame;

13import javax.swing.JPanel;

14import javax.swing.JScrollPane;

15import javax.swing.JTextArea;

16import javax.swing.JTextField;

17import javax.swing.SwingUtilities;

18import java.util.Formatter;

19import java.util.Scanner;

20import java.util.concurrent.Executors;

21import java.util.concurrent.ExecutorService;

23public class TicTacToeClient extends JFrame implements Runnable

24{

25private JTextField idField; // textfield to display player's mark

26private JTextArea displayArea; // JTextArea to display output

27private JPanel boardPanel; // panel for tic-tac-toe board

28private JPanel panel2; // panel to hold board

29private Square board[][]; // tic-tac-toe board

30private Square currentSquare; // current square

31private Socket connection; // connection to server

32private Scanner input; // input from server

33private Formatter output; // output to server

34private String ticTacToeHost; // host name for server

35private String myMark; // this client's mark

36private boolean myTurn; // determines which client's turn it is

37private final String X_MARK = "X"; // mark for first client

38 private final String O_MARK = "O"; // mark for second client 39

40// set up user-interface and board

41public TicTacToeClient( String host )

42{

43ticTacToeHost = host; // set name of server

44displayArea = new JTextArea( 4, 30 ); // set up JTextArea

45displayArea.setEditable( false );

46add( new JScrollPane( displayArea ), BorderLayout.SOUTH );

55{

56// loop over the columns in the board

62} // end inner for

63} // end outer for

64

65 idField = new JTextField(); // set up textfield

66idField.setEditable( false );

67add( idField, BorderLayout.NORTH );

69panel2 = new JPanel(); // set up panel to contain boardPanel

70panel2.add( boardPanel, BorderLayout.CENTER ); // add board panel

71add( panel2, BorderLayout.CENTER ); // add container panel

73setSize( 300, 225 ); // set size of window

74setVisible( true ); // show window

76startClient();

77} // end TicTacToeClient constructor

79// start the client thread

80public void startClient()

81{

82try // connect to server, get streams and start outputThread

83{

84// make connection to server

85connection = new Socket(

88// get streams for input and output

89input = new Scanner( connection.getInputStream() );

90output = new Formatter( connection.getOutputStream() );

91} // end try

92catch ( IOException ioException )

93{

94ioException.printStackTrace();

95} // end catch

96

97// create and start worker thread for this client

98ExecutorService worker = Executors.newFixedThreadPool( 1 );

99worker.execute( this ); // execute client

100} // end method startClient

101

102// control thread that allows continuous update of displayArea

103public void run()

104{

105myMark = input.nextLine(); // get player's mark (X or O)

107SwingUtilities.invokeLater(

108new Runnable()

109{

115} // end anonymous inner class

116); // end call to SwingUtilities.invokeLater

118myTurn = ( myMark.equals( X_MARK ) ); // determine if client's turn

120// receive messages sent to client and output them

121while ( true )

122{

123if ( input.hasNextLine() )

125} // end while

126} // end method run

128// process messages received by client

129private void processMessage( String message )

130{

131// valid move occurred

132if ( message.equals( "Valid move." ) )

133{

134displayMessage( "Valid move, please wait.\n" );

135setMark( currentSquare, myMark ); // set mark in square

136} // end if

137else if ( message.equals( "Invalid move, try again" ) )

138{

139displayMessage( message + "\n" ); // display invalid move

140myTurn = true; // still this client's turn

141} // end else if

142else if ( message.equals( "Opponent moved" ) )

143{

144int location = input.nextInt(); // get move location

145input.nextLine(); // skip newline after int location

146int row = location / 3; // calculate row

147int column = location % 3; // calculate column

151displayMessage( "Opponent moved. Your turn.\n" );

152myTurn = true; // now this client's turn

153} // end else if

154else

155displayMessage( message + "\n" ); // display the message

156} // end method processMessage

157

158// manipulate outputArea in event-dispatch thread

159private void displayMessage( final String messageToDisplay )

160{

161SwingUtilities.invokeLater(

162new Runnable()

163{

168} // end inner class

169); // end call to SwingUtilities.invokeLater

170} // end method displayMessage

171

172// utility method to set mark on board in event-dispatch thread

173private void setMark( final Square squareToMark, final String mark )

174{

175SwingUtilities.invokeLater(

176new Runnable()

177{

182} // end anonymous inner class

183); // end call to SwingUtilities.invokeLater

184} // end method setMark

185

186// send message to server indicating clicked square

187public void sendClickedSquare( int location )

188{

189// if it is my turn

190if ( myTurn )

191{

192output.format( "%d\n", location ); // send location to server

193output.flush();

194myTurn = false; // not my turn anymore

195} // end if

196} // end method sendClickedSquare

197

198// set current Square

199public void setCurrentSquare( Square square )

200{

201currentSquare = square; // set current square to argument

202} // end method setCurrentSquare

203

204// private inner class for the squares on the board

205private class Square extends JPanel

206{

207private String mark; // mark to be drawn in this square

208private int location; // location of square

209

210public Square( String squareMark, int squareLocation )

211{

212mark = squareMark; // set mark for this square

213location = squareLocation; // set location of this square

226); // end call to addMouseListener

227} // end Square constructor

228

229// return preferred size of Square

230public Dimension getPreferredSize()

231{

232return new Dimension( 30, 30 ); // return preferred size

233} // end method getPreferredSize

234

235// return minimum size of Square

236public Dimension getMinimumSize()

237{

238return getPreferredSize(); // return preferred size

239} // end method getMinimumSize

240

241// set mark for Square

242public void setMark( String newMark )

243{

244mark = newMark; // set mark of square

245repaint(); // repaint square

246} // end method setMark

247

248// return Square location

249public int getSquareLocation()

250{

251return location; // return location of square

252} // end method getSquareLocation

253

254// draw Square

255public void paintComponent( Graphics g )

256{

257super .paintComponent( g );

258

259g.drawRect( 0, 0, 29, 29 ); // draw square

260g.drawString( mark, 11, 20 ); // draw mark

261} // end method paintComponent

262} // end inner-class Square