PART – A

1.Define XPATH? List down the advantages of XPATH

XPath (XML Path Language) is a query language used to select nodes from an XML document. It allows you to
navigate through elements and attributes in an XML document using path expressions, similar to navigating a file system.

Advantages of XPath:

1. Flexibility: Locate elements using various criteria like attributes, text content, or position.

2. DOM Navigation: Supports both upward and downward traversal in the DOM.

3. Versatile Matching: Includes functions like contains () and starts-with () for dynamic attributes.

4. Integration: Usable in multiple programming languages and technologies.

5. Standard Functions: Offers over 200 built-in functions for various operations.

2.Is PHP and XML the same? Justify your answer.

No, PHP and XML are not the same.

PHP:

• Type: Server-side scripting language.

• Purpose: Creates dynamic web pages and applications.

• Execution: Runs on the server.

XML:

• Type: Markup language.

• Purpose: Structures, stores, and transports data.

• Execution: Not executable; used for data representation.

3.Write short notes on cookies ? and state down the purpose of cookies ?

Cookies

Cookies are small text files stored on a user’s device by a web browser. They contain data such as user preferences, login
information, and session identifiers, which help websites remember users and their interactions.

Purpose of Cookies

1. Session Management: Maintain user sessions, such as keeping users logged in as they navigate through a
website.

2. Personalization: Store user preferences and settings to provide a customized browsing experience.

3. Tracking and Analytics: Collect data on user behavior and interactions to improve website functionality and user
experience.

4. Security: Enhance security by storing authentication tokens and preventing unauthorized access.
4.Define JSON ? Write the structure of JSON ? Whether it is platform independent?

JSON

JSON (JavaScript Object Notation) is a lightweight, text-based format for storing and exchanging data.

structure of JSON

JSON Structure

JSON is built on two structures:

1. Objects: Collections of key/value pairs, enclosed Arrays: Ordered lists of values, enclosed in square

in curly braces {}. brackets [].

JSON JSON

{ "name": "John", "age": 30, "city": "New York" } [ "apple", "banana", "cherry"]

platform independent

JSON is platform-independent. It can be used across different programming languages and platforms.

PART – B

5.(a).(i).Define Servlet? What are the different phases of Java Servlet Life Cycle?
What is a Servlet?
A Servlet is a Java class that is used to handle HTTP requests and generate HTTP responses in a web application. It is part
of the Java EE (Enterprise Edition) specification and operates on the server-side. Servlets run inside a servlet container
(like Apache Tomcat), which manages their lifecycle and facilitates communication between the client and the server.
Phases of Java Servlet Life Cycle
The life cycle of a servlet is managed by the Servlet Container (such as Apache Tomcat). The servlet life cycle involves the
following key phases:
1. Loading and Instantiation:
o The servlet container loads the servlet class into memory when the servlet is first requested or on
startup (depending on configuration).
o The container creates an instance of the servlet using its default constructor (if no constructor is
explicitly defined).
2. Initialization (init() method):
o After instantiation, the container calls the init() method to initialize the servlet.
o This method is called only once during the servlet's life cycle, right after the servlet is loaded.
o The init() method is used to perform initialization tasks, like opening a database connection or loading
configuration data.
3. Request Handling (service() method):
o Once the servlet is initialized, it is ready to handle client requests.
 o For each client request, the container calls the service() method, passing the request and response
objects as parameters.
o The service() method processes the request and generates a response. This is the method where the
actual business logic and content generation take place.
4. Destruction (destroy() method):
o The destroy() method is called when the servlet is about to be unloaded, usually when the web
application is stopped or the servlet container is shut down.
o This method is used to release resources like closing database connections, stopping background
threads, etc.
o The servlet instance is removed from memory once the destroy() method finishes execution.

Illustrate the different functionalities of servlet container

1. Servlet Lifecycle Management

The servlet container is responsible for managing the lifecycle of servlets.
• Loading the Servlet
• Initializing the Servlet
• Request Handling
• Destroying the Servlet
2. Request and Response Handling
The servlet container manages all HTTP requests and responses:
• Request Routing
• ServletRequest and ServletResponse Objects.
• Handling Different HTTP Methods
3. Session Management
One of the key functionalities of a servlet container is managing user sessions:
• Session Tracking
• Session Lifecycle
4. Security Management
The servlet container is responsible for enforcing security policies:
• Authentication
• Authorization
 • SSL/TLS Support
5. Servlet Mapping and URL Routing
The servlet container manages the mapping of URLs to specific servlets:
• URL Pattern Matching
• Filter and Listener Handling
6. Concurrency Management
The servlet container handles concurrent requests to the same servlet:
• Thread Management
• Servlet Instance Pooling
• Request Queueing
5.(a).(ii). Discuss in detail about the HttpServlet Class and its interface.

1. HttpServlet Class
The HttpServlet class is part of the Java Servlet API, which provides the necessary functionality for handling HTTP
requests and responses. It extends the GenericServlet class, which is a protocol-independent servlet. While
GenericServlet is capable of handling all types of requests, HttpServlet is specifically designed to handle HTTP requests,
making it the preferred choice for web applications.
Key Features of HttpServlet:
• Inheritance: HttpServlet extends GenericServlet, and implements Servlet and Serializable interfaces. This means
it inherits basic servlet functionality and can be serialized for use in distributed applications.
• Request-Response Handling: The primary role of HttpServlet is to process HTTP requests and generate HTTP
responses. It overrides methods like doGet(), doPost(), doPut(), doDelete(), etc., to handle different types of
HTTP methods.
• Lifecycle: The servlet container (e.g., Tomcat, Jetty) manages the lifecycle of a servlet. The lifecycle methods of
the HttpServlet class include:
o init(): Called once when the servlet is first loaded into memory. It’s used to initialize the servlet and its
resources.
o service(): Handles the actual request. The service() method is called by the servlet container whenever a
request is made. This method determines which HTTP method (GET, POST, etc.) the client used, and calls
the corresponding method (like doGet(), doPost()).
o destroy(): Called when the servlet is removed from service. Used to clean up resources.
• HttpServlet Methods: The class provides default implementations for the HTTP-specific methods like:
o doGet(HttpServletRequest request, HttpServletResponse response): Handles HTTP GET requests. This
method retrieves data from the server and sends it back to the client.
o doPost(HttpServletRequest request, HttpServletResponse response): Handles HTTP POST requests. Used
when submitting data to the server (such as forms).
o doPut(HttpServletRequest request, HttpServletResponse response): Handles HTTP PUT requests. Used
for updating resources.
o doDelete(HttpServletRequest request, HttpServletResponse response): Handles HTTP DELETE requests.
Used for deleting resources.
 o doHead(HttpServletRequest request, HttpServletResponse response): Similar to doGet() but does not
return a message body, only headers.
2. HttpServlet Interface
The HttpServlet class itself does not directly implement an interface called HttpServlet, but it relies on an interface
known as Servlet and extends it. Below are the main interfaces and their relationship:
Servlet Interface:
The HttpServlet class implicitly implements the Servlet interface through its parent class, GenericServlet. The Servlet
interface defines the essential lifecycle methods required by all servlets:
• init(ServletConfig config): Initializes the servlet with configuration parameters.
• service(ServletRequest req, ServletResponse res): Processes incoming requests.
• destroy(): Releases resources before the servlet is destroyed.
HttpServletRequest and HttpServletResponse Interfaces:
• HttpServletRequest: Represents the request from the client, providing methods to get request parameters,
attributes, headers, etc.
Methods include:
o getParameter(String name): Gets a request parameter by name.
o getSession(): Gets the session associated with the request.
o getHeader(String name): Retrieves the header value for the specified header.
• HttpServletResponse: Represents the response that will be sent back to the client, providing methods to set
status codes, headers, and send the response body.
Methods include:
o setStatus(int sc): Sets the HTTP status code.
o setHeader(String name, String value): Sets a header for the response.
o getWriter(): Returns a PrintWriter to send character data.
5.(b).(i). Explain the Java script array handling and array methods.

JavaScript arrays are versatile and powerful tools for handling collections of data. Here’s a concise overview of array
handling and some commonly used array methods:
Array Handling
• Creation: Arrays can be created using square brackets [] or the Array constructor.
• let fruits = ["Apple", "Banana", "Mango"];
• let numbers = new Array(1, 2, 3, 4);
• Accessing Elements: Elements are accessed using their index, starting from 0.
• console.log(fruits[0]); // Output: Apple
• Modifying Elements: You can change the value of an element by assigning a new value to its index.
• fruits[1] = "Orange";
Array Methods
 1. push(): Adds one or more elements to the end of an array and returns the new length.
fruits.push("Kiwi"); // ["Apple", "Orange", "Mango", "Kiwi"]
2. pop(): Removes the last element from an array and returns that element.
let lastFruit = fruits.pop(); // "Kiwi"
3. shift(): Removes the first element from an array and returns that element.
let firstFruit = fruits.shift(); // "Apple"
4. unshift(): Adds one or more elements to the beginning of an array and returns the new length.
fruits.unshift("Strawberry"); // ["Strawberry", "Orange", "Mango"]
5. slice(): Returns a shallow copy of a portion of an array into a new array object.
let citrus = fruits.slice(1, 3); // ["Orange", "Mango"]
6. splice(): Adds or removes elements from an array.
fruits.splice(1, 1, "Lemon", "Pineapple"); // ["Strawberry", "Lemon", "Pineapple", "Mango"]
7. forEach(): Executes a provided function once for each array element.
fruits.forEach(function(item, index) {
console.log(item, index);
});
8. map(): Creates a new array with the results of calling a provided function on every element in the calling array.
let upperCaseFruits = fruits.map(fruit => fruit.toUpperCase());
9. filter(): Creates a new array with all elements that pass the test implemented by the provided function.
let longNames = fruits.filter(fruit => fruit.length > 5);
10. reduce(): Executes a reducer function on each element of the array, resulting in a single output value.
let totalLength = fruits.reduce((total, fruit) => total + fruit.length, 0);
5.(b).(ii). Explain the following Java script objects. 1) RegEp. 2) Math.

1. RegExp (Regular Expression) Object in JavaScript

Definition:
The RegExp object in JavaScript is used for working with regular expressions, which are patterns used to match character
combinations in strings. A regular expression can be used for various tasks like searching, replacing, and validating strings
based on a given pattern.
Key Features:
• Pattern Matching: Regular expressions allow you to find patterns in strings, such as matching phone numbers,
email addresses, dates, etc.
• Flags: Flags are used to modify the behavior of a regular expression. Common flags include:
o g: Global search (find all matches, not just the first).
o i: Case-insensitive search.
o m: Multi-line search.
A regular expression can be created using either a regular expression literal (syntax: /pattern/flags) or the RegExp
constructor (syntax: new RegExp('pattern', 'flags')).
Example:
Using RegExp to find matches in a string:
javascript
let str = "The quick brown fox jumps over the lazy dog";
let pattern = /quick/;
console.log(pattern.test(str));
Output: true (match found)

2. Math Object in JavaScript

Definition:
The Math object in JavaScript provides mathematical functions and constants. It is a built-in object, meaning you do not
need to create an instance of it to use its methods and properties. The Math object includes a variety of functions for
performing basic arithmetic, trigonometric operations, generating random numbers, and other mathematical tasks.
Key Features:
• Mathematical Constants:
o Math.PI: The constant π (approximately 3.14159).
o Math.E: The constant e (approximately 2.71828).
• Mathematical Functions:
o Math.abs(x): Returns the absolute value of x.
o Math.ceil(x): Returns the smallest integer greater than or equal to x.
o Math.floor(x): Returns the largest integer less than or equal to x.
o Math.random(): Returns a random number between 0 (inclusive) and 1 (exclusive).
o Math.round(x): Rounds x to the nearest integer.
o Math.max(x, y, ...): Returns the largest of the given numbers.
o Math.min(x, y, ...): Returns the smallest of the given numbers.
o Math.pow(base, exponent): Returns the value of base raised to the power of exponent.
Example:
javascript
// Using Math.PI
let radius = 5;
let area = Math.PI * Math.pow(radius, 2);
console.log("Area of circle: " + area);
Output: Area of circle: 78.53981633974483
6.(a).(i).Briefly discuss about XML and DTD. Write a DTD for employee details including employee name (first name
and last name), employee ID, Date of Birth (month, date and year) and address (city and state)
XML (Extensible Markup Language)
Definition: XML (Extensible Markup Language) is a markup language designed to store and transport data in a format
that is both human-readable and machine-readable. Unlike HTML, which focuses on displaying data, XML is used to
describe data and its structure. It allows users to define custom tags and provides a way to structure data hierarchically.
DTD (Document Type Definition)
Definition: A DTD (Document Type Definition) defines the structure and legal elements of an XML document. It provides
a way to specify the allowed tags, attributes, and the hierarchy of elements in an XML document. DTD can be declared
either inline within the XML document or as an external reference. It helps validate XML data and ensure it conforms to
a specified structure.
DTD for Employee Details
We need to create a DTD that defines the structure for storing employee details, including the employee's name (first
name and last name), employee ID, date of birth (month, date, and year), and address (city and state).
DTD Example:
xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE employee [
<!ELEMENT employee (name, employeeID, dateOfBirth, address)>
<!ELEMENT name (first, last)>
<!ELEMENT first (#PCDATA)>
<!ELEMENT last (#PCDATA)>
<!ELEMENT employeeID (#PCDATA)>
<!ELEMENT dateOfBirth (month, day, year)>
<!ELEMENT month (#PCDATA)>
<!ELEMENT day (#PCDATA)>
<!ELEMENT year (#PCDATA)>
<!ELEMENT address (city, state)>
<!ELEMENT city (#PCDATA)>
<!ELEMENT state (#PCDATA)>
]>
<employee>
<name>
<first>John</first>
<last>Doe</last>
</name>
 <employeeID>12345</employeeID>
<dateOfBirth>
<month>March</month>
<day>25</day>
<year>1990</year>
</dateOfBirth>
<address>
<city>New York</city>
<state>NY</state>
</address>
</employee>
6.(a).(ii).Describe the process of generating dynamic content using servlets
Generating dynamic content using servlets involves creating a Java-based web application where the content returned to
the client (usually in the form of HTML, XML, or JSON) is generated on-the-fly based on client requests. Servlets process
these requests and generate responses dynamically, allowing the content to change based on parameters, user input,
session data, or other factors.
Steps in Generating Dynamic Content Using Servlets
1. Client Sends a Request to the Web Server:
o The process starts when a client (usually a web browser) sends an HTTP request to a web server. This
request could be for a particular resource (like a webpage) or to submit data (like through a form).
o The request is typically a GET or POST request, but it could be other HTTP methods (PUT, DELETE, etc.).
2. Web Server Routes the Request to the Servlet:
o The web server, such as Apache Tomcat or Jetty, receives the HTTP request and routes it to a servlet,
based on the URL pattern mapped to that servlet in the web application's web.xml (deployment
descriptor) or annotations.
o If a servlet is configured for a specific URL (e.g., /products, /login, etc.), the server forwards the request
to the associated servlet class.
3. Servlet Handles the Request:
o The servlet receives the HTTP request via the HttpServletRequest object. This object contains all the
details about the request, such as query parameters, headers, session data, and form data.
o The servlet processes the request by performing logic based on the parameters or session data. For
example, if the request is a form submission, the servlet might retrieve values from the form using
methods like request.getParameter().
4. Servlet Generates Dynamic Content:
o Once the servlet has processed the request, it generates the appropriate response. This is typically done
by creating HTML or other content in Java code.
o The servlet interacts with the HttpServletResponse object to send back dynamic content. This could be
HTML pages, JSON data, or XML, depending on the type of request and the application's needs.
 o To generate HTML dynamically, the servlet often writes HTML markup and data into the response using
methods like response.getWriter().
6.(b).(i).Write a Servlet program to display the waiting list status, given the PNR number of a train. Create a JSP to
display the information at the client end.
WaitingListServlet.java (Servlet)
import javax.servlet.*;
import javax.servlet.http.*;
import java.io.IOException;

public class WaitingListServlet extends HttpServlet {

@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
IOException {
String pnr = request.getParameter("pnr");
String status = getWaitingListStatus(pnr);

// Pass data to JSP

request.setAttribute("pnr", pnr);
request.setAttribute("status", status);
request.getRequestDispatcher("displayStatus.jsp").forward(request, response);
}

private String getWaitingListStatus(String pnr) {

switch (pnr) {
case "1234567890": return "5 passengers in waiting list.";
case "0987654321": return "No passengers in the waiting list.";
default: return "Invalid PNR number.";
}
}
}
displayStatus.jsp (JSP Page)
<%@ page language="java" contentType="text/html; charset=UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<title>PNR Status</title>
<style>
body { font-family: Arial, sans-serif; margin: 20px; }
h2 { color: #4CAF50; }
table { border-collapse: collapse; margin-top: 20px; }
table, th, td { border: 1px solid black; padding: 8px; text-align: left; }
</style>
</head>
<body>
<h2>PNR Waiting List Status</h2>
<table>
<tr>
<th>PNR</th>
<th>Status</th>
</tr>
<tr>
<td>${pnr}</td>
<td>${status}</td>
</tr>
</table>
<br>
<a href="index.html">Back</a>
</body>
</html>
index.html (Input Form)
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Check PNR Status</title>
<style>
body { font-family: Arial, sans-serif; margin: 20px; }
 label, input { display: block; margin: 10px 0; }
input[type="submit"] { background: #4CAF50; color: white; padding: 10px 20px; border: none; cursor: pointer; }
input[type="submit"]:hover { background: #45a049; }
</style>
</head>
<body>
<h2>Check Waiting List Status</h2>
<form action="WaitingListServlet" method="get">
<label for="pnr">Enter PNR Number:</label>
<input type="text" id="pnr" name="pnr" required>
<input type="submit" value="Check Status">
</form>
</body>
</html>
6.(b).(ii). What is DOM? Explain the concept of DOM tree with the help of suitable example. Also explain the basic
terminologies used in DOM tree.
The DOM (Document Object Model) is a programming interface for web documents. It represents the structure of an
HTML or XML document as a tree of objects, where each node in the tree is an object representing a part of the
document. The DOM allows programs and scripts to dynamically access, manipulate, and update the content, structure,
and style of a document.
DOM Tree Concept
The DOM organizes a document into a tree-like structure called the DOM Tree, where:
• The root of the tree represents the document itself.
• Branches represent the hierarchy of elements and content within the document.
• Each node in the tree corresponds to an element, attribute, or text within the document.
Example of a DOM Tree
Sample HTML Document:
html
<!DOCTYPE html>
<html>
<head>
<title>Example Page</title>
</head>
<body>
<h1>Welcome to the DOM</h1>
 <p>This is a paragraph.</p>
<ul>
<li>Item 1</li>
<li>Item 2</li>
</ul>
</body>
</html>
Corresponding DOM Tree:
css
Document
└── html

├── head
│ └── title
│ └── "Example Page"
└── body

├── h1
│ └── "Welcome to the DOM"

├── p
│ └── "This is a paragraph."
└── ul

├── li
│ └── "Item 1"
└── li
└── "Item 2"
Basic Terminologies in DOM Tree
1. Node:
o The fundamental building block of the DOM tree.
o Types of nodes:
▪ Element Node: Represents an HTML element (e.g., <p>, <ul>).
▪ Text Node: Represents the text content inside an element.
▪ Attribute Node: Represents an attribute of an element (e.g., class, id).
▪ Document Node: Represents the entire document.
2. Root Node:
 o The topmost node in the DOM tree (e.g., <html> for HTML documents).
3. Parent Node:
o A node that has child nodes. For example, <body> is the parent node of <h1>, <p>, and <ul>.
4. Child Node:
o A node directly under a parent node. For example, <li> is a child node of <ul>.
5. Sibling Nodes:
o Nodes that share the same parent. For example, <h1> and <p> are sibling nodes under <body>.
6. Leaf Node:
o A node with no children. For example, text nodes like "Welcome to the DOM" are leaf nodes.
7.(a).(i). Explain in detail about the following terms: i. XSL and XSLT Transformation ii. Compare DOM & SAX
i. XSL (Extensible Stylesheet Language)
• XSL is a family of technologies used to define how XML documents are displayed or transformed.
• It includes three main components:
1. XSLT (XSL Transformations): Defines rules to transform XML documents into different formats such as
HTML, plain text, or another XML.
2. XPath (XML Path Language): A language to navigate and select specific parts of an XML document.
3. XSL-FO (Formatting Objects): Specifies how XML content should be formatted for output, such as in PDFs.
XSLT Transformation
• XSLT is used to transform XML documents into different formats.
• It applies a set of rules (templates) defined in an XSLT stylesheet to the input XML document.
• The transformation process:
1. The XSLT processor reads the XML document and the XSLT stylesheet.
2. It applies the transformation rules to produce the desired output.
ii.
7.(a).(ii). How Session Tracking achieved by URL rewriting

Session Tracking with URL Rewriting

Session tracking using URL rewriting is a technique where a unique session ID is appended to the URL of every client
request and response to maintain the session state. This technique is used when cookies are disabled or not supported
by the client.

How URL Rewriting Works

1. Assign a Session ID:

o When a client makes an initial request, the server generates a unique session ID and associates it with
the session object.

o The session ID is then appended to the URL as a query parameter.

2. Include the Session ID in Subsequent URLs:

o Every link or action in the response includes the session ID in the URL.

o The client sends this session ID back to the server with each subsequent request.

3. Server Identifies the Session:

o The server extracts the session ID from the URL, retrieves the corresponding session, and processes the
request.

7.(a).(iii). Explain XML Schema? What is meant by an XML namespeace.

XML Schema
An XML Schema describes the structure of an XML document, just like a DTD.
An XML document with correct syntax is called "Well Formed".
An XML document validated against an XML Schema is both "Well Formed" and "Valid".
XML Namespace
An XML namespace is a mechanism to avoid naming conflicts in XML documents by providing unique names for
elements and attributes. It is especially useful when combining XML documents from different XML vocabularies or when
elements from different schemas share the same element names.