Creating a web server request and response callback parameters

1. WEB SERVER
Prepared By: Bareen Shaikh

2. Topics
5.1 Creating Web Server
5.2 Handling HTTP requests
5.3 Sending Requests
5.4 HTTP Streaming

3. Introduction
 Web Application needs Web Server.
 Communication between Client & Server using HTTP.
 IIS web server for ASP.NET web application.
 Apache web server for PHP and Java web application.
 Create Node.Js web server for Node.js application.

4. Creating Node.Js web server
 Node.js makes create a simple web server that processes
incoming requests asynchronously.
 Following example is a simple Nodejs web server example
var http = require('http'); // http Node.js core module
var server = http.createServer(function (req, res) {
//handle request
}); server.listen(8080); //listen for any incoming requests
console.log('Node.js web server at port 8080 is running..')

5. Creating Node.Js web server
In the above example,
 http core module is imported using require() function.
 As http module is a core module of Node.js, no need to install it
using NPM.
 Next step is call createServer() method of http
 In that specify callback function with request and response
parameter.
 Finally, call listen() method of server object.
 Which start listening to incoming requests on port 8080.
 Can specify any unused port here.

6. createServer()
const http = require('http');
const server = http.createServer((request, response) => {
// Task to be done!
});
OR
const http = require('http');
const server = http.createServer();
server.on('request', (request, response) => {
// Task to be done
});

7. CreateServer() Explanation
 The function that's passed in to createServer is called once
for every HTTP request.
 It works as a request handler.
 The server object returned by createServer is an EventEmitter.
 HTTP request hits the server, node calls the request handler
function for dealing with the transaction,request and response

8. Simple Hello World Example
var http = require('http');
//create a server object:
var server=http.createServer(function (req, res) {
res.write('Hello World!'); //write a response to the client
res.end(); //end the response
});server.listen(8080); //the server object listens on port
8080

9. HTTP Request and Response
 The http.createServer() method
includes request and response parameters
 The request object can be used to get information about
the current HTTP request e.g.,methods, url, request header,
and data.
 The response object can be used to send a response for a
current HTTP request.

10. Handling http request
 The first thing while handling request is to check method
and URL, so that appropriate actions can be taken.
 Node.js makes this relatively painless by putting handy
properties onto the request object as follows
const { method, url ,header} = request;
 Parameter:
method here will GET/POST/PUT normal HTTP
method/verb.
url is the full URL without the server, protocol or port.

11. Request Body
let body = [];
request.on('data', (chunk) => {
body.push(chunk);
}).on('end', () => {
body = Buffer.concat(body).toString();
// body has the entire request body, stored in it as
a string
});

12. Request Body explanation
 request object passed in to a handler implements
the ReadableStream interface.
 This stream can be listened or piped.
 Data can be read out of the stream by listening to the
stream's 'data' and 'end' events.
 The chunk emitted in each 'data' event is a Buffer.
 Most probably data going to be string data, the best is
to collect the data in an array,
 At the 'end', concatenate and stringify it.

13. Error handling while http request
request.on('error', (err) => {
// This prints the error message and stack trace to `stderr`.
console.error(err.stack);
});
 The request object is a ReadableStream, which is
an EventEmitter
 An error in the request stream presents itself by emitting
an 'error' event.
 If event listener is not handle in program then the error will
be thrown.

14. Overall Program of HTTP request
const http = require('http');
http.createServer((request, response) =>
{
const { headers, method, url } = request;
let body = []; request.on('error', (err) =>
{
console.error(err);
}).on('data', (chunk) => {
body.push(chunk); }).on('end', () => {
body = Buffer.concat(body).toString();
});
}).listen(8080);

15. HTTP Response
 response object is an instance of ServerResponse which is
a WritableStream.
 It contains many methods for sending data back to the
client.
 HTTP Status code
 HTTP status code on a response always be 200.
 Not every HTTP response warrants this such as
response.statusCode = 404; // Tell the client that the resource
wasn't found.

16. Setting Response Headers
 Headers are set through a convenient method
called setHeader()
 response.setHeader('Content-Type', ‘text/html');
 Explicitly Sending Header Data with method
called writeHead() which writes the status code and the
headers to the stream.
 response.writeHead(200, { 'Content-Type': ‘text/html’});

17. Sending Response Body
 response object is a WritableStream writing a response
body out to the client.
 response.write() method is used to write streams.
response.write('<html>');
response.write('<body>');
response.write('<h1>Hello, World!</h1>');
response.write('</body>');
response.write('</html>');
response.end()
OR
response.end('<html><body><h1>Hello,
World!</h1></body></html>');

18. Error handling while http response
response.on('error', (err) => {
// This prints the error message and stack trace to `stderr`.
console.error(err.stack);
});
 The response object is a WritableStream, which is
an EventEmitter.
 An error in the response stream presents itself by emitting
an 'error' event.
 If event listener is not handle in program then the error will
be thrown.

19. Put overall code together of http request
and response

20. Simplified overall program
const http = require('http');
http.createServer((request, response) => {
let body = [];
request.on('data', (chunk) => {
body.push(chunk);
}).on('end', () => {
body = Buffer.concat(body).toString();
response.end(body);
});
}).listen(8080);