For this activity you will submit two java files You will ne

For this activity, you will submit two .java files. You will need to run two classes simultaneously for this activity. Make sure you have a compiler that is capable of this.

We have seen how two programs can connect. Let’s look more into how they communicate. Once the connection has been made, both sides can establish Data Streams to send information back and forth. There are a few ways to do this. An easy way is by using DataInputStream and DataOutputStream. Using these objects, you can send information in the form of primitive data types back and forth between the Server and the Client.

Two classes are created: a Server and a Client. Both classes create a Socket and they establish a connection. From this point, both classes use the connection to establish Input and Output Streams, and then they can send data back and forth.

Once both classes can send data, your job will be to have the user (always the Client) input a whole number. This number will be sent to the Server, where the Server will calculate the result of squaring that number (raising it to the power of 2), and then it will return the result to the Client where the result will be shown to the user. Finally, everything will close and the connection will terminate.

Summary:

Create a Client class and a Server class

Have the Client connect to the Server

Establish Input and Output Streams for the Server and the Client

Have a user input a whole number on the Client’s side

Send the user’s input to the Server

Have the server calculate the result of squaring the number

Send the result back to the Client

Have the client output the result

Close everything and disconnect

Solution

Server.java

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;

/**
* A TCP server that runs on port 9090. When a client connects, it
* sends the client the current date and time, then closes the
* connection with that client. Arguably just about the simplest
* server you can write.
*/
public class Server { public static void main(String[] args) throws Exception {
System.out.println(\"The server is running.\");
int clientNumber = 0;
ServerSocket listener = new ServerSocket(9898);
try {
while (true) {
new Square(listener.accept(), clientNumber++).start();
}
} finally {
listener.close();
}
}

/**
* A private thread to handle square requests on a particular
* socket. The client terminates the dialogue by sending a single line
* containing only a period.
*/
private static class Square extends Thread {
private Socket socket;
private int clientNumber;

public Square(Socket socket, int clientNumber) {
this.socket = socket;
this.clientNumber = clientNumber;
log(\"New connection with client# \" + clientNumber + \" at \" + socket);
}

/**
* Services this thread\'s client by first sending the
* client a welcome message then repeatedly reading strings
* and sending back the square version of the string.
*/
public void run() {
try {

// Decorate the streams so we can send characters
// and not just bytes. Ensure output is flushed
// after every newline.
BufferedReader in = new BufferedReader(
new InputStreamReader(socket.getInputStream()));
PrintWriter out = new PrintWriter(socket.getOutputStream(), true);

// Send a welcome message to the client.
out.println(\"Hello, you are client #\" + clientNumber + \".\");
out.println(\"Enter a line with only a period to quit\ \");

// Get messages from the client, line by line; return them
// squared
while (true) {
String input = in.readLine();
if (input == null || input.equals(\".\")) {
break;
}
int num=Integer.valueOf(input);
out.println(num*num);
}
} catch (IOException e) {
log(\"Error handling client# \" + clientNumber + \": \" + e);
} finally {
try {
socket.close();
} catch (IOException e) {
log(\"Couldn\'t close a socket, what\'s going on?\");
}
log(\"Connection with client# \" + clientNumber + \" closed\");
}
}

/**
* Logs a simple message. In this case we just write the
* message to the server applications standard output.
*/
private void log(String message) {
System.out.println(message);
}
}}

Client.java

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;

import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;

/**
* Trivial client for the date server.
*/
public class Client {
   private BufferedReader in;
   private PrintWriter out;
   private JFrame frame = new JFrame(\"Capitalize Client\");
   private JTextField dataField = new JTextField(40);
   private JTextArea messageArea = new JTextArea(8, 60);

/**
* Constructs the client by laying out the GUI and registering a
* listener with the textfield so that pressing Enter in the
* listener sends the textfield contents to the server.
*/
public Client() {

// Layout GUI
messageArea.setEditable(false);
frame.getContentPane().add(dataField, \"North\");
frame.getContentPane().add(new JScrollPane(messageArea), \"Center\");

// Add Listeners
dataField.addActionListener(new ActionListener() {
/**
* Responds to pressing the enter key in the textfield
* by sending the contents of the text field to the
* server and displaying the response from the server
* in the text area. If the response is \".\" we exit
* the whole application, which closes all sockets,
* streams and windows.
*/
public void actionPerformed(ActionEvent e) {
out.println(dataField.getText());
String response;
try {
response = in.readLine();
if (response == null || response.equals(\"\")) {
System.exit(0);
}
} catch (IOException ex) {
response = \"Error: \" + ex;
}
messageArea.append(response + \"\ \");
dataField.selectAll();
}
});
}

   /**
   * Implements the connection logic by prompting the end user for the
   * server\'s IP address, connecting, setting up streams, and consuming the
   * welcome messages from the server. The Square protocol says that the
   * server sends three lines of text to the client immediately after
   * establishing a connection.
   */
   public void connectToServer() throws IOException {

       // Get the server address from a dialog box.
       String serverAddress = JOptionPane.showInputDialog(frame, \"Enter IP Address of the Server:\",
               \"Welcome to the Program\", JOptionPane.QUESTION_MESSAGE);

       // Make connection and initialize streams
       Socket socket = new Socket(serverAddress, 9898);
       in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
       out = new PrintWriter(socket.getOutputStream(), true);

       // Consume the initial welcoming messages from the server
       for (int i = 0; i < 3; i++) {
           messageArea.append(in.readLine() + \"\ \");
       }
   }

   /**
   * Runs the client application.
   */
   public static void main(String[] args) throws Exception {
       Client client = new Client();
       client.frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
       client.frame.pack();
       client.frame.setVisible(true);
       client.connectToServer();
   }
}