Scribd
Upload
0 views

Tutorial Week04 Socket Programming (1)

This document outlines two exercises for a tutorial on socket programming and HTTP server implementation in Java. The first exercise involves enhancing a chat application with logging functionalities using java.util.logging.Logger, while the second exercise focuses on building a basic HTTP client-server application that handles GET requests. Detailed steps for setting up the server, client, and logging are provided, along with instructions for testing the applications.

Uploaded by

ayash.20221941
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
0 views

Tutorial Week04 Socket Programming (1)

This document outlines two exercises for a tutorial on socket programming and HTTP server implementation in Java. The first exercise involves enhancing a chat application with logging functionalities using java.util.logging.Logger, while the second exercise focuses on building a basic HTTP client-server application that handles GET requests. Detailed steps for setting up the server, client, and logging are provided, along with instructions for testing the applications.

Uploaded by

ayash.20221941
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 12

5COSC022W.

2 Client-Server Architectures

Tutorial Week 04: Socket Programming

EXERCISE 1: LOGGING

In this tutorial, you will enhance tutorial Week 03 exercise 2 chat application by adding
logging functionalities. Logging is an essential aspect of software development as it
helps in tracking the application's behavior, debugging issues, and maintaining records
of events. We will use java.util.logging.Logger to log messages and save them to a file for
future reference.

STEP 1 – IMPORT THE PROJECT

Import the zip file from the 2nd exercise of tutorial week 3 into your IDE. This will provide
you with the base code for the client-server chat application.

STEP 2 - SET UP LOGGING

Add Logger to Classes: In each class (e.g., SimpleChatClient and SimpleChatServer),


import java.util.logging.Logger and create a Logger instance.

STEP 3 - SET UP FILEHANDLER

Configure a FileHandler to save logs to a text file. This should be done in a static block
to ensure it is set up when the class is loaded.
static {
try {
FileHandler fileHandler = new FileHandler("logs.txt", true);
logger.addHandler(fileHandler);
} catch (IOException e) {
logger.log(Level.SEVERE, "Failed to set up file handler for
logger", e);
}
}

STEP 3- CONFIGURE THE LOGGER

• Specify Log File Name: Use FileHandler to specify the log file name and set it to
append mode.
• Format Log Messages: Use SimpleFormatter to format the log messages for
readability.
• Add FileHandler to Logger: Attach the FileHandler to the Logger instance.

STEP 4 - ADD LOGGING STATEMENTS

• Log Informational Messages: Add logging statements at key points in your code to
log informational messages. For example, log when the server starts, when a client
connects, and when messages are sent or received.

• Log Exceptions: Use logger.log(Level.SEVERE, "message", exception) to log


exceptions.

STEP 5 - TEST THE APPLICATION

• Run the Server and Client Applications: Start the server application first, then run
the client application to connect to the server.

• Check the Log Files: Verify that the log files (logs.txt) are created and contain the
expected log messages. This will help you ensure that all relevant events are being
logged.

EXERCISE 2 – HTTP SERVER

In this exercise, you will learn how to build a basic HTTP client-server application in
Java. The server will handle incoming HTTP GET requests and send back a simple text
response. The client will send a GET request to the server and print the server's
response.

PROJECT STRUCTURE

Please create a new project and call it as Tutorial-week04-EX2. Then, create two Java
files:

1. MyHttpServer.java: Contains the code for the HTTP server.


2. MyHttpClient.java: Contains the code for the HTTP client.

STEP 1: CREATE THE SERVER CLASS AND MAIN METHOD

STEP 2: CREATE THE HTTPSERVER INSTANCE


STEP 3: CREATE THE HTTPHANDLER (INNER CLASS)
STEP 4: IMPLEMENT REQUEST HANDLING IN A SEPARATE THREAD
STEP 5: IMPLEMENT REQUEST PROCESSING AND RESPONSE

Please include the following codes insdie RequestHandlerThread class:

@Override
public void run() {
try {
// Get request information
String requestMethod = exchange.getRequestMethod();
URI requestURI = exchange.getRequestURI();
Headers requestHeaders = exchange.getRequestHeaders();

// Display request information


System.out.println("\n=== INCOMING REQUEST ===");
System.out.println("Method: " + requestMethod);
System.out.println("URI: " + requestURI);
System.out.println("Headers:");
printHeaders(requestHeaders);

// Prepare response with request information


StringBuilder responseContent = new StringBuilder();
responseContent.append("Request Details:\n");
responseContent.append("Method:
").append(requestMethod).append("\n");
responseContent.append("URI:
").append(requestURI).append("\n");
responseContent.append("Headers:\n");
requestHeaders.forEach((key, value) ->
responseContent.append(key).append(":
").append(value).append("\n"));
responseContent.append("\nHandled by thread:
").append(Thread.currentThread().getName());

String response = responseContent.toString();

// Get response headers


Headers responseHeaders = exchange.getResponseHeaders();

// Send response
exchange.sendResponseHeaders(200,
response.getBytes().length);

// Display response information


System.out.println("\n=== OUTGOING RESPONSE ===");
System.out.println("Status: 200 OK");
System.out.println("Headers:");
printHeaders(responseHeaders);
System.out.println("Body length: " +
response.getBytes().length + " bytes");

// Send response body


try (OutputStream os = exchange.getResponseBody()) {
os.write(response.getBytes());
}

} catch (IOException e) {
e.printStackTrace();
} finally {
exchange.close();
}
}
STEP 6: IMPLEMENT PRINTHEADERS METHOD

STEP 7: CREATE A CONTEXT AND START THE SERVER


STEP 8: CREATE THE CLIENT CLASS AND MAIN METHOD

STEP 9: CREATE THE URL AND OPEN A CONNECTION


STEP 10: IMPLEMENTING PRINT HEADER METHOD
STEP 11: GET AND DISPLAY DEFAULT REQUEST HEADERS

STEP 12: SET THE REQUEST METHOD AND GET THE RESPONSE CODE
STEP 13:

STEP 14: RUN AND TEST THE PROGRAM

RUNNING THE SERVER


1. Right-click on MyHttpServer.java in the Projects window.
2. Select "Run File."
3. The server will start, and you should see the "Server starting on port 8080" message
in the Output window (usually at the bottom).

RUNNING THE CLIENT


1. Right-click on MyHttpClient.java in the Projects window.
2. Select "Run File."
3. A new Output window will appear, showing the client's output, including the
response code and the server's message.

STEP 15: TEST THE PROGRAM IN A WEB BROWSER

Open a browser and go to http://localhost:8080/hello). The browser will interact with


your server running from within NetBeans.

STEP 16: OBSERVING OUTPUT

• Server Output: When the server receives a request (either from MyHttpClient or
from the web browser), you will likely see some additional output in the server's
terminal or NetBeans Output window, indicating that a request has been handled.
You might also see the thread name printed as part of the response string.
• Client Output: The MyHttpClient program will print the response code and the
response message to its console (either the terminal or the NetBeans Output
window).
• Web Browser: The web browser will display the server's response message in the
browser window.

You might also like