W21 answers

Q.1 (a) Usage of InetAddress Class

The InetAddress class in Java provides methods for working with Internet Protocol (IP)
addresses. Here's what you can do with it:
Functionality:
 Get Local Host Address: Retrieve the IP address of the machine running your Java program:
Java
InetAddress localhost = InetAddress.getLocalHost();
System.out.println("Localhost IP Address: " + localhost.getHostAddress());
 Resolve Hostname to IP: Translate a hostname (e.g., "www.google.com") to its
corresponding IP address:
Java
InetAddress googleIP = InetAddress.getByName("www.google.com");
System.out.println("Google IP Address: " + googleIP.getHostAddress());
 Get Hostname from IP: Convert an IP address back to its hostname (if available):
Java
String googleHostname = googleIP.getHostName();
System.out.println("Google Hostname: " + googleHostname);
 Check Reachability: Test if a specific host is reachable over the network:
Java
if (googleIP.isReachable(timeout)) {
System.out.println("Google is reachable!");
} else {
System.out.println("Google is unreachable!");
}

Q.1 (b) PreparedStatement and CallableStatement with Example

1. PreparedStatement:
 Protects against SQL injection attacks by separating SQL syntax from dynamic data.
 Pre-compiles the SQL statement for improved performance.
Example:
Java
String sql = "INSERT INTO users (username, email) VALUES (?, ?)";
PreparedStatement statement = connection.prepareStatement(sql);
statement.setString(1, "johndoe"); // Bind value to first parameter
statement.setString(2, "[email protected]"); // Bind value to second parameter
statement.executeUpdate();
statement.close();
2. CallableStatement:
 Used for calling stored procedures or functions in the database.
 Allows for retrieving output parameters or result sets from stored procedures.
Example:
Java
String sql = "{call get_user_details(?)}";
CallableStatement statement = connection.prepareCall(sql);
statement.setString(1, "johndoe"); // Set input parameter
statement.registerOutParameter(2, Types.VARCHAR); // Register output parameter
statement.execute();
String name = statement.getString(2); // Retrieve output parameter value
statement.close();

Q.1 (c) JSP Page Directives

JSP page directives are special instructions embedded within JSP pages to control how the
page is processed and compiled. They start with < and end with > followed by @. Common
directives include:
 <%@ page ... %>: Defines page-level attributes like content type, encoding, session tracking,
and error page handling.
Java
<%@ page contentType="text/html;charset=UTF-8" pageEncoding="UTF-8" %>
 <%@ include file="..." %>: Includes another JSP or HTML file within the current page.
Java
<%@ include file="header.jsp" %>
 <%@ taglib prefix="..." uri="..." %>: Declares a tag library prefix for using custom tags
within the JSP page.
Java
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
 <%@ error page="..." %>: Specifies a JSP page to redirect to in case of errors during page
processing.
Java
<%@ error page="error.jsp" %>
These directives help manage the overall structure and behavior of JSP pages.

Q.2 (a) Difference Between HTTP GET and POST Methods

Both HTTP GET and POST methods are used to send data from a client (web browser) to a
server. However, they differ in their key characteristics:
 Feature HTTP GET HTTP POST

Data Appended to the URL as query

Sent in the request body
Transmission parameters

Theoretically larger limit

Data Size Limit Limited by URL length restrictions
(implementation dependent)

Repeating the request with the same Repeating the request might have side
Idempotency
data should produce the same result effects (e.g., creating duplicate data)

GET requests can be cached by

Caching POST requests are generally not cached
browsers

More secure (data hidden within

Security Less secure (data exposed in URL)
request body)

When to Use Each:

 Use GET for retrieving data from a server, typically when the data doesn't modify server
state (e.g., searching for products on an e-commerce site).
 Use POST for sending data to the server that might alter server state (e.g., submitting a form
with user input, logging in to an account).

Q.2 (b) Four Implicit Objects in JSP

JSP provides several implicit objects that offer pre-defined functionality within JSP pages.
Here are four commonly used ones:

1. request (ServletRequest): Represents the current HTTP request object. It allows you to
access data submitted through forms (using GET or POST), query parameters, and headers.
Java
String name = request.getParameter("username");
2. response (HttpServletResponse): Represents the current HTTP response object. It allows
you to manipulate the response sent back to the client (e.g., setting content type, headers,
or writing content).
Java
 response.setContentType("text/html");
response.getWriter().println("<h1>Hello, Client!</h1>");
3. session (HttpSession): Represents the current HTTP session object. It allows you to store
and retrieve user-specific data across multiple page requests within the same session.
Java
session.setAttribute("user", userObject);
String username = (String) session.getAttribute("user");
4. application (ServletContext): Represents the ServletContext object for the web application.
It allows you to access application-wide resources and configurations.
Java
String appVersion = (String) application.getAttribute("appVersion");

Q.2 (c) Client-Server Communication (TCP/IP Sockets)

Here's a Java program demonstrating how a client sends a string to the server, the server
converts it to uppercase, and sends it back:

Server Code (server.java):

Java
import java.io.*;
import java.net.*;

public class Server {

public static void main(String[] args) throws IOException {
ServerSocket serverSocket = new ServerSocket(8080); // Port number

while (true) {
Socket clientSocket = serverSocket.accept();

// Get input from client

BufferedReader in = new BufferedReader(new
InputStreamReader(clientSocket.getInputStream()));
String message = in.readLine();

// Convert to uppercase
String response = message.toUpperCase();

// Send response to client

PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);
out.println(response);

clientSocket.close();
}
}
}
 Client Code (client.java):
Java
import java.io.*;
import java.net.*;

public class Client {

public static void main(String[] args) throws IOException {
Socket clientSocket = new Socket("localhost", 8080); // Server hostname and port

// Send string to server

BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
String message = in.readLine();

PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);

out.println(message);

// Receive response from server

BufferedReader serverIn = new BufferedReader(new
InputStreamReader(clientSocket.getInputStream()));
String response = serverIn.readLine();
System.out.println("Server Response: " + response);

clientSocket.close();
}
}

Explanation:
Server Side:
1. ServerSocket: Creates a ServerSocket on port 8080, waiting for incoming connections from
clients.
2. Client Connection: The server enters an infinite loop, waiting for client connections using
serverSocket.accept(). When a client connects, a new Socket object representing the client
connection is created.
3. Read Client Input: An InputStreamReader and BufferedReader are used to read the string sent
by the client from the input stream of the clientSocket.
4. Convert to Uppercase: The received message is converted to uppercase using
String.toUpperCase().
5. Send Response: A PrintWriter is used to write the uppercase response back to the client's
output stream via the clientSocket.
6. Close Connection: The clientSocket is closed after sending the response.
Client Side:
1. Socket Creation: Creates a Socket object, connecting to the server running on localhost (the
same machine) at port 8080.
2. Send String: Reads a line (the string to be converted) from the user's standard input using
System.in. Sends the string to the server using a PrintWriter.
3. Receive Response: Reads the server's response (uppercase string) from the input stream of
the clientSocket using a BufferedReader.
4. Print Response: Prints the server's response to the console.
5. Close Connection: Closes the clientSocket after receiving the response.
Running the Program:
1. Compile both server.java and client.java using a Java compiler (e.g., javac server.java client.java).
2. Run the server first: java server (This keeps the server listening for client connections).
3. In a separate terminal, run the client: java client.
4. Enter a string in the client terminal and press Enter. The server will convert it to uppercase
and send it back to the client, which will be displayed in the client terminal.
This demonstrates a basic example of client-server communication using TCP/IP sockets for
sending and receiving data in a connection-oriented manner.

Or 2(C)

Here's a JDBC program for a banking application using a bank table with the specifieyd
attributes and functionalities:

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class BankingApplication {

private static final String JDBC_DRIVER = "com.mysql.cj.jdbc.Driver"; // Replace with your JDBC driver
class name
private static final String DB_URL = "jdbc:mysql://localhost:3306/your_database_name"; // Replace
with your database URL
private static final String USER = "your_username"; // Replace with your database username
private static final String PASSWORD = "your_password"; // Replace with your database password

public static void main(String[] args) {

Connection connection = null;
PreparedStatement insertStatement = null;
 PreparedStatement selectAllStatement = null;
ResultSet resultSet = null;

try {
// Register JDBC driver
Class.forName(JDBC_DRIVER);

// Open a connection
connection = DriverManager.getConnection(DB_URL, USER, PASSWORD);

// Insert two records using prepared statement

insertStatement = connection.prepareStatement("INSERT INTO bank (AccountNo, CustomerName,
Phone, Address) VALUES (?, ?, ?, ?)");
insertRecord(insertStatement, 12345, "John Doe", "123-456-7890", "123 Main St");
insertRecord(insertStatement, 54321, "Jane Smith", "987-654-3210", "456 Elm St");

// Display all records

selectAllStatement = connection.prepareStatement("SELECT * FROM bank");
resultSet = selectAllStatement.executeQuery();
System.out.println("\nBank Accounts:");
while (resultSet.next()) {
int accountNo = resultSet.getInt("AccountNo");
String customerName = resultSet.getString("CustomerName");
String phone = resultSet.getString("Phone");
String address = resultSet.getString("Address");
System.out.println("Account No: " + accountNo + ", Customer Name: " + customerName + ",
Phone: " + phone + ", Address: " + address);
}

} catch (ClassNotFoundException e) {
System.out.println("Error: JDBC driver not found.");
e.printStackTrace();
} catch (SQLException e) {
System.out.println("Error: SQL exception occurred.");
e.printStackTrace();
} finally {
// Close resources
try {
if (resultSet != null) {
resultSet.close();
}
if (selectAllStatement != null) {
selectAllStatement.close();
}
if (insertStatement != null) {
insertStatement.close();
}
if (connection != null) {
connection.close();
}
} catch (SQLException e) {
 System.out.println("Error: Exception occurred while closing resources.");
e.printStackTrace();
}
}
}

private static void insertRecord(PreparedStatement statement, int accountNo, String customerName,

String phone, String address) throws SQLException {
statement.setInt(1, accountNo);
statement.setString(2, customerName);
statement.setString(3, phone);
statement.setString(4, address);
statement.executeUpdate();
}
}
Explanation:
1. JDBC Driver: Replace placeholders like JDBC_DRIVER, DB_URL, USER, and PASSWORD with your
actual database connection details.
2. Connection: Establishes a connection to the database.
3. Prepared Statements: Uses prepared statements for insertRecord and selectAllStatement to
prevent SQL injection vulnerabilities.
4. Insert Records: The insertRecord method demonstrates inserting two records with prepared
statement parameters.
5. Display Records: The selectAllStatement retrieves all records from the bank table and iterates
through the ResultSet to display each record's details.
6. Error Handling: Includes exception handling for potential ClassNotFoundException and
SQLException occurrences.
7. Resource Closing: Ensures proper closing of ResultSet, PreparedStatement, and Connection
objects using a finally block to avoid resource leaks.
Remember:
 Replace placeholders with your specific database connection information.
 Adapt the program to handle more complex functionalities as needed in your banking
application.

Q.3 (a) Use of execute(), executeUpdate(), and executeQuery() methods

In JDBC, the Statement interface provides several methods for executing SQL statements
against a database:
 execute(String sql):
o Executes a wide range of SQL statements, including:
 SELECT (returns a ResultSet)
 INSERT, UPDATE, DELETE (returns an integer indicating the number of rows affected)
 DDL (Data Definition Language) statements (CREATE, ALTER, DROP) that don't return a
specific result set
o Returns: boolean indicating whether the first result is a ResultSet (true) or not (false).

 executeUpdate(String sql):
o Specifically designed for statements that modify data (INSERT, UPDATE, DELETE).
o Returns: An integer representing the number of rows affected by the statement execution
(useful for counting inserted/updated/deleted rows).
o Throws an exception: If the statement doesn't modify data (e.g., a SELECT statement).

 executeQuery(String sql):
o Executes a SELECT statement and expects to retrieve a result set containing data.
o Returns: A ResultSet object containing the results of the query.
o Throws an exception: If the statement doesn't return a result set (e.g., an INSERT, UPDATE,
or DELETE statement).

Q.3 (b) ServletConfig vs. ServletContext

Both ServletConfig and ServletContext are objects available within a servlet, but they serve
different purposes:
Q.3 (c) Servlet for Storing Student Details

Here's a basic servlet that reads student details from a web form and stores them in a
database (replace placeholders with your actual database connection details):

import java.io.IOException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet("/StoreStudentDetails") // Map this servlet to the URL pattern "/StoreStudentDetails"

public class StoreStudentDetailsServlet extends HttpServlet {
 private static final String JDBC_DRIVER = "com.mysql.cj.jdbc.Driver"; // Replace with your JDBC driver
class name
private static final String DB_URL = "jdbc:mysql://localhost:3306/your_database_name"; // Replace
with your database URL
private static final String USER = "your_username"; // Replace with your database username
private static final String PASSWORD = "your_password"; // Replace with your database password

@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {

Connection connection = null;

PreparedStatement statement = null;

try {
// Get student details from request parameters (assuming form uses POST method)
String name = request.getParameter("name");
String email = request.getParameter("email");
String rollNumber = request.getParameter("rollNumber"); // Assuming roll number is a string

// Database connection
Class.forName(JDBC_DRIVER);
connection = DriverManager.getConnection(DB_URL, USER, PASSWORD);

// Prepare statement for insertion

String sql = "INSERT INTO students (name, email, rollNumber) VALUES (?, ?, ?)";
statement = connection.prepareStatement(sql);

// Set values using prepared statement parameters

statement.setString(1, name);
statement.setString(2, email);
statement.setString(3, rollNumber);

// Execute update to insert the data

statement.executeUpdate();

// Send response (e.g., success message)

response.getWriter().println("Student details stored successfully!");

} catch (ClassNotFoundException e) {
System.out.println("Error: JDBC driver not found.");
e.printStackTrace();
// Handle error appropriately (e.g., display error message to user)
} catch (SQLException e) {
System.out.println("Error: SQL exception occurred.");
e.printStackTrace();
// Handle error appropriately (e.g., display error message to user)
} finally {
// Close resources (connection, statement)
try {
if (statement != null) {
 statement.close();
}
if (connection != null) {
connection.close();
}
} catch (SQLException e) {
System.out.println("Error: Exception occurred while closing resources.");
e.printStackTrace();
}
}
}
}

Explanation:
1. Annotations: Uses @WebServlet annotation to map the servlet to the URL pattern
"/StoreStudentDetails".
2. doPost Method: This servlet handles POST requests (assuming the form submits data using
POST method).
3. Get Student Details: Retrieves student name, email, and roll number from the request
parameters submitted through the form.
4. Database Connection: Establishes a connection to the database using JDBC driver and
connection details.
5. Prepared Statement: Creates a prepared statement to prevent SQL injection vulnerabilities.
6. Set Values: Sets the prepared statement parameters with the retrieved student details.
7. Execute Update: Executes the prepared statement to insert the data into the students table.
8. Send Response: Sends a success message to the user's browser.
9. Error Handling: Includes exception handling for ClassNotFoundException and SQLException to
gracefully handle potential errors.
10. Resource Closing: Ensures proper closing of connection and statement objects to avoid
resource leaks.

Or

Q.3 (a) Filters and their Applications

Filter: A filter is a component in Java web applications (servlets and JSPs) that intercepts
requests and responses before they reach the targeted servlet or JSP. It allows you to
perform various tasks like:
 Security: Authentication, authorization, encryption/decryption.
 Logging and Auditing: Track user activity, log requests and responses.
 Data Validation: Ensure data submitted through forms is in the correct format.
 Content Compression: Reduce response size for faster loading times.
 Character Encoding: Set character encoding for request and response data.
 Caching: Improve performance by caching frequently accessed resources.
Filter Applications:

Filters provide a centralized location to apply these functionalities across your entire
application or specific parts of it. This promotes modularity, reusability, and separation of
concerns in your web development.

Q.3 (b) Servlet Lifecycle Methods and Web Container Role

Servlet Lifecycle Methods:

A servlet's lifecycle involves several methods that get called at different stages during its
creation, initialization, and destruction:

 init(ServletConfig config): Called once when the servlet is first loaded. You can use this
method to perform initialization tasks such as loading configuration data or establishing
database connections.
 service(ServletRequest request, ServletResponse response): Called for every HTTP request
that matches the servlet's URL pattern. This is where the core servlet logic resides, handling
the request and generating the response.
 doGet(HttpServletRequest request, HttpServletResponse response): Specifically called for
GET requests.
 doPost(HttpServletRequest request, HttpServletResponse response): Specifically called for
POST requests. (You can have similar methods for other HTTP methods like PUT, DELETE,
etc.)
 destroy(): Called once when the servlet is about to be unloaded from memory. You can use
this method to clean up resources, such as closing database connections.

Web Container Role:

The web container (e.g., Tomcat, Jetty) manages the lifecycle of servlets within a web
application. It's responsible for:
 Loading servlets based on their definitions in the deployment descriptor (web.xml).
 Creating servlet instances.
 Calling the appropriate lifecycle methods (init(), service(), etc.) at the right times.
 Providing them with resources like ServletConfig and ServletContext.
 Handling servlet communication with the client (web browser) by processing requests and
sending responses.
Q.3 (c) Request Dispatcher and Its Methods
Request Dispatcher: An interface provided by the Java Servlet API that allows servlets and
JSPs to forward requests or include content from other resources within the same web
application.
Differences Between forward() and include():
 forward():
o Redirects the request to another resource (servlet or JSP) within the web application.
o The client browser doesn't know about the forwarding. The URL in the browser's address
bar remains the same as the original request.
o Any request parameters or attributes from the original request are not automatically
available in the forwarded resource unless explicitly passed.
 include():
o Includes the content from another resource (servlet or JSP) within the current response.
o The included content is merged into the current response.
o The client browser doesn't receive a separate request for the included resource.
o Request parameters and attributes from the original request are available in the included
resource.
Example Program:

Here's a program demonstrating both methods:

Servlet1.java: (Receives a request and forwards to Servlet2)

Java
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.RequestDispatcher;

public class Servlet1 extends HttpServlet {

 @Override
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {

String message = "Hello from Servlet1!";

request.setAttribute("message1", message); // Set attribute for forwarding

RequestDispatcher dispatcher = getServletContext().getRequestDispatcher("/Servlet2");

dispatcher.forward(request, response); // Forward to Servlet2
}
}
Servlet2.java: (Receives forwarded request and includes another resource)
Java
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.RequestDispatcher;

public class Servlet2 extends HttpServlet {

@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {

String message1 = (String) request.getAttribute("message1"); // Get forwarded attribute

// Use the forwarded message and potentially process further

String message2 = "Content included from includedResource.jsp";

// Include content using RequestDispatcher

RequestDispatcher dispatcher = getServletContext().getRequestDispatcher("/includedResource.jsp");
request.setAttribute("message2", message2); // Set attribute for included JSP
dispatcher.include(request, response); // Include content from includedResource.jsp

// Write remaining content to the response after inclusion

response.getWriter().println("<br>Additional content from Servlet2 after including.");
}
}
includedResource.jsp: (Included JSP content)
Java
<html>
<body>
<h1>Included Content</h1>
<p>This content is included from includedResource.jsp using RequestDispatcher.include().</p>
<p>Value from Servlet2: <%= request.getAttribute("message2") %></p>
 </body>
</html>
Explanation:
1. Servlet1:
o Receives a request and sets a message attribute (message1).
o Uses getRequestDispatcher to obtain a RequestDispatcher object for "/Servlet2".
o Uses forward(request, response) to forward the request to Servlet2, passing along the request
object and response object.
2. Servlet2:
o Receives the forwarded request.
o Retrieves the forwarded attribute (message1) set by Servlet1.
o Sets another message attribute (message2).
o Uses getRequestDispatcher to obtain a RequestDispatcher object for "/includedResource.jsp".
o Uses include(request, response) to include the content from includedResource.jsp into the current
response. It passes along the request and response objects, making message2 available in the
JSP.
o Writes additional content to the response after inclusion.
3. includedResource.jsp:
o Accesses the attribute (message2) set by Servlet2 using JSP expression syntax (<%=
request.getAttribute("message2") %>).
o Displays the included content and the attribute value.
JSP Include Directive vs. jsp:include Tag and JSTL Core Tags with JSF Lifecycle

Q.4 (a) Difference Between Include Directive and jsp:include Action Tag
Both the include directive (<%@ include file="..." %>) and the jsp:include action tag allow you to
include content from another JSP file within the current JSP. However, they differ in key
aspects:

Feature Include Directive jsp:include Action Tag

Translation time (when JSP is Runtime (when JSP is processed by the

Inclusion Time
converted to servlet) web container)

File Path Absolute path or relative path Relative path within the current JSP's
Requirement within web application directory only
 Can pass attributes to the included file
Attribute Support No
using var and flush

More flexible (dynamic inclusion

Flexibility Less flexible (static inclusion)
based on conditions)

Choosing the Right Approach:

 Use the include directive for simple static inclusions at translation time.
 Use the jsp:include action tag for dynamic inclusions with runtime flexibility, passing
attributes, and conditional logic.
Q.4 (b) Four JSTL Core Tags
The Java Server Pages Standard Tag Library (JSTL) Core provides a set of commonly used
tags for simplifying JSP development:
1. c:forEach: Iterates over a collection of objects (e.g., an array or list) and executes its body
for each item.
Java
<c:forEach var="item" items="${myList}">
<p>Item: ${item.name}</p>
</c:forEach>
2. c:if: Performs conditional logic based on an expression's evaluation to true or false.
Java
<c:if test="${user.loggedIn}">
Welcome back, ${user.name}!
</c:if>
3. c:choose: Provides more comprehensive conditional branching with when and otherwise
options.
Java
<c:choose>
<c:when test="${status == 'success'}">
Operation successful!
</c:when>
<c:when test="${status == 'error'}">
An error occurred.
</c:when>
<c:otherwise>
Operation status unknown.
</c:otherwise>
</c:choose>
4. c:out: Outputs the value of an expression without any additional formatting.
Java
 The current date is: <c:out value="${currentDate}" />

Q.4 (c) JSF Request Processing Lifecycle

JavaServer Faces (JSF) applications follow a specific request processing lifecycle that
manages the interaction between the user, the web container, and the JSF components.
Here's a breakdown of the key phases:
1. Restore View (if applicable):
o If the user has previously visited the page, the JSF framework restores the view state from
the client (typically stored in a hidden form field) and recreates the managed beans and
components associated with the view.
2. Process Faces Events:
o The framework processes any events triggered by the user interacting with JSF components
(e.g., button clicks, form submissions).
3. Apply Validators:
o If applicable, validators associated with input components are invoked to validate user
input.
4. Update Model Values:
o Validated user input is used to update the state of managed beans and the underlying
model objects.
5. Invoke Application Logic:
o The framework invokes methods on managed beans to perform application logic and
potentially access backend resources.
6. Render Response:
o The final response is sent back to the client's web browser.
Refer for more gfg
Or

Q.4 (a) JSF Facelets and Facelets Tags

1. JSF Facelets:
o JSF Facelets is a templating technology used with JSF applications. It provides a separation
of concerns between the UI (XHTML) and the JSF components.
o Facelets allows you to define templates (XHTML files) containing static content and
placeholders for JSF components. These components are then dynamically inserted into the
template when the page is rendered.
2. Facelets Tags:
o Facelets provides various tags for defining templates, managing component composition,
and handling conditional logic:
 ui:composition: Defines a template that can be reused across multiple pages.
 ui:insert: Marks a placeholder within a template where a JSF component will be inserted.
 ui:component: Renders a JSF component within a template.
 ui:repeat: Iterates over a collection and renders the component body for each item.
 c:if (from JSTL Core): Provides conditional logic for displaying content based on an
expression.
Example:
template.xhtml: (Template with placeholders)
HTML, XML
<!DOCTYPE html>
<html>
<head>
<title>My JSF Application</title>
</head>
<body>
<header>
<h1>My Application</h1>
</header>

<ui:insert name="content">
</ui:insert>

<footer>
Copyright &copy; 2024
</footer>
</body>
</html>
page.xhtml: (Uses the template and inserts components)
HTML, XML
<%@ taglib uri="http://java.sun.com/jsf/html" prefix="h" %>
<%@ taglib uri="http://java.sun.com/jsf/core" prefix="f" %>
<%@ taglib prefix="ui" uri="http://java.sun.com/jsf/facelets" %>

<ui:composition template="/template.xhtml">
<ui:define name="content">
<h:outputText value="Welcome to the page!" />
 </ui:define>
</ui:composition>

Q.4 (b) JSF Standard Converter Tags and Explanations

JSF provides standard converter tags for converting user input from String format to specific
data types used by JSF components. Here are three examples:

1. f:convertNumber: Converts user input to a numeric type (e.g., Integer, Double) based on
attributes like type and locale.
HTML, XML
<h:inputText value="#{bean.age}" converter="f:convertNumber" type="integer" />
2. f:convertDateTime: Converts user input to a date/time object based on attributes like
pattern, locale, and timeZone.
HTML, XML
<h:inputText value="#{bean.dob}" converter="f:convertDateTime" pattern="yyyy-MM-dd" />
3. f:convertBoolean: Converts user input (e.g., checkbox value "on" or "off") to a boolean
value.
HTML, XML
<h:selectBooleanCheckbox value="#{bean.subscribed}" converter="f:convertBoolean" />

These converter tags help ensure that JSF components receive data in the expected format
and avoid potential errors or unexpected behavior.

Q.4 (c) JSP Login Module with Reset Password (Database Example)

This example demonstrates a basic login module with a reset password feature using JSP
and JDBC. However, it's important to note that implementing secure login and password
reset mechanisms requires additional security practices like password hashing and salting:

login.jsp: (Login form)

Java
<%@ page import="java.sql.*" %>
<%-- Replace with your database connection details --%>
<% String jdbcDriver = "com.mysql.cj.jdbc.Driver";
String dbURL = "jdbc:mysql://localhost:3306/your_database_name";
String username = "your_username";
String password = "your_password"; %>
<%! Connection connection = null;
PreparedStatement stmt = null;
String message = ""; %>
<% try {
 Class.forName(jdbcDriver);
connection = DriverManager.getConnection(dbURL, username, password);

String email = request.getParameter("email");

String pwd = request.getParameter("password");

Java
if (email != null && pwd != null) {
// Prepare statement to check user credentials
String sql = "SELECT * FROM users WHERE email = ? AND password = ?";
stmt = connection.prepareStatement(sql);
stmt.setString(1, email);
stmt.setString(2, pwd); // **Security Risk: Don't store passwords in plain text!**

ResultSet rs = stmt.executeQuery();
if (rs.next()) {
// Login successful - redirect to a welcome page or dashboard
session.setAttribute("user", email); // Set session attribute for user identification
response.sendRedirect("welcome.jsp");
return;
} else {
message = "Invalid email or password.";
}
}
} catch (SQLException e) {
e.printStackTrace();
message = "Error: Database connection failed.";
} finally {
try {
if (rs != null) rs.close();
if (stmt != null) stmt.close();
if (connection != null) connection.close();
} catch (SQLException e) {
e.printStackTrace();
}
} %>

<!DOCTYPE html>
<html>
<head>
<title>Login</title>
</head>
<body>
<h1>Login</h1>
<form action="" method="post">
<label for="email">Email:</label>
<input type="text" name="email" id="email" required><br>
<label for="password">Password:</label>
<input type="password" name="password" id="password" required><br>
<input type="submit" value="Login">
</form>
 <% if (!message.isEmpty()) { %>
<p style="color: red;"><%= message %></p>
<% } %>
<a href="reset_password.jsp">Forgot password?</a>
</body>
</html>
reset_password.jsp: (Reset password form)
Java
<%@ page import="java.sql.*" %>
<%-- Replace with your database connection details --%>
<% String jdbcDriver = "com.mysql.cj.jdbc.Driver";
String dbURL = "jdbc:mysql://localhost:3306/your_database_name";
String username = "your_username";
String password = "your_password"; %>
<%! Connection connection = null;
PreparedStatement stmt = null;
String message = ""; %>
<% try {
Class.forName(jdbcDriver);
connection = DriverManager.getConnection(dbURL, username, password);

String email = request.getParameter("email");

String newPwd = request.getParameter("new_password"); // Assuming a new_password parameter

if (email != null && newPwd != null) {

// Prepare statement to update password for the email
String sql = "UPDATE users SET password = ? WHERE email = ?";
stmt = connection.prepareStatement(sql);
stmt.setString(1, newPwd); // **Security Risk: Don't store passwords in plain text!**
stmt.setString(2, email);
int rowsUpdated = stmt.executeUpdate();

if (rowsUpdated > 0) {
message = "Password reset successfully!";
} else {
message = "Error: No user found with that email.";
}
}
} catch (SQLException e) {
e.printStackTrace();
message = "Error: Database connection failed.";
} finally {
try {
if (stmt != null) stmt.close();
if (connection != null) connection.close();
} catch (SQLException e) {
e.printStackTrace();
}
} %>
<!DOCTYPE html>
<html>
<head>
<title>Reset Password</title>
</head>
<body>
<h1>Reset Password</h1>
<form action="" method="post">
<label for="email">Email:</label>
<input type="text" name="email" id="email" required><br>
<label for="new_password">New Password:</label>
<input type="password" name="new_password" id="new_password" required><br>
<input type="submit" value="Reset Password">
</form>
<% if (!message.isEmpty()) { %>
<p><%= message %></p>
<% } %>
<a href="login.jsp">Back to LoginJava

</a>
</body>
</html>
welcome.jsp: (Welcome page after successful login)
Java
<%@ page import="java.io.IOException" %>
<% String user = (String) session.getAttribute("user");
if (user == null) {
response.sendRedirect("login.jsp"); // Redirect to login if no user in session
return;
}
%>

<!DOCTYPE html>
<html>
<head>
<title>Welcome</title>
</head>
<body>
<h1>Welcome, <%= user %>!</h1>
<p>You are successfully logged in.</p>
<a href="logout.jsp">Logout</a>
</body>
</html>
logout.jsp: (Logout page)
Java
<%@ page import="java.io.IOException" %>
<% session.invalidate(); // Invalidate session to log out
response.sendRedirect("login.jsp"); %>
 Q.5 (a) Dependency Injection Explained
Dependency Injection (DI) is a design pattern that promotes loose coupling between
objects. It focuses on providing an object with its dependencies (other objects it needs to
function) rather than creating them itself. This approach offers several benefits:
Benefits:
 Testability: Easier to write unit tests by injecting mock dependencies.
 Maintainability: Code becomes more modular and easier to modify.
 Flexibility: Allows swapping out dependencies based on context.
 Decoupling: Objects rely less on specific implementations of their dependencies.
Dependency Injection Techniques:
 Constructor Injection: Dependencies are passed as arguments to the object's constructor.
 Setter Injection: Dependencies are injected using setter methods within the object.
 Interface Injection: Objects depend on interfaces, allowing for different implementations.
Example (Constructor Injection):
Java
public class UserService {

private final UserRepository userRepository;

public UserService(UserRepository userRepository) {

this.userRepository = userRepository;
}

public User getUserById(Long id) {

return userRepository.findById(id);
}
}
In this example, UserService has a dependency on UserRepository. Instead of creating a
UserRepository instance itself, it receives it through the constructor. This allows for
dependency injection frameworks like Spring to manage the lifecycle and potentially
provide mock implementations for testing purposes.

Q.5 (b) HQL (Hibernate Query Language) vs. SQL

Hibernate Query Language (HQL) is an object-oriented query language used with Hibernate
to interact with relational databases. Here's a comparison between HQL and SQL:

Feature HQL SQL

 Focus Objects and their properties Tables and columns

Syntax Java-like syntax SQL-like syntax

More portable across different database Less portable, may require vendor-
Portability
vendors specific code

Type
Supports type safety (less error-prone) Doesn't enforce type safety
Safety

Offers some protection against SQL Requires careful parameter binding for
Security
injection security

Q.5 (c) Hibernate Architecture

Hibernate acts as an Object-Relational Mapper (ORM) that simplifies accessing and

persisting data between Java objects and relational databases. Here's a breakdown of its key
components:

1. Configuration: Defines how Hibernate interacts with the database, including connection
details, dialect, and mapping information.
2. SessionFactory: A factory-like object responsible for creating Session objects used for
interacting with the database.
3. Session: Provides a unit of work for database operations. It manages transactions and
provides methods for saving, loading, updating, and deleting data.
4. Criteria API: An object-oriented API for constructing complex queries using criteria builders.
5. HQL (Hibernate Query Language): An object-oriented query language for interacting with
the database using Java-like syntax.
6. Persistence API: (JPA) Provides a standard interface for persistence providers like Hibernate.
7. Mapping Files (hbm.xml): (Optional) Configuration files that define mappings between Java
classes and database tables. Can be replaced by annotations in JPA.
 Benefits of Hibernate:
 Abstraction: Hides the complexities of JDBC and SQL, allowing developers to work with
objects.
 Object-Relational Mapping: Simplifies the persistence layer with automatic data
conversion.
 Reduced Code: Less boilerplate code compared to JDBC and raw SQL.
 Querying: Offers HQL and Criteria API for flexible object-oriented querying.
 Transaction Management: Provides support for managing database transactions.

By understanding the architecture and features of Hibernate, developers can build

applications with a more robust and efficient data persistence layer.

Or

Q.5 (a) Spring Web MVC Features

Spring Web MVC is a powerful framework for building web applications in Java. It follows
the Model-View-Controller (MVC) design pattern, providing a clean separation of concerns
and several key features:
 Model-View-Controller (MVC) Pattern: Enforces a clear separation between business logic
(Model), data presentation (View), and user interaction handling (Controller).
 Dispatcher Servlet: Acts as a central front controller, handling incoming requests, routing
them to appropriate controllers, and invoking the corresponding views.
 Handler Mapping: Maps URLs to controller methods for efficient request handling.
 Content Negotiation: Allows the framework to determine the most appropriate response
format (e.g., JSON, XML) based on client preferences and controller capabilities.
 Data Binding: Automatically binds data from request parameters or form submissions to
Model objects, simplifying data access in controllers.
 Form Validation: Provides mechanisms for validating user input using annotations or
custom validation logic.
 View Technologies: Supports various view technologies like JSP, FreeMarker, Thymeleaf,
allowing for flexible front-end development.
 Exception Handling: Offers centralized exception handling mechanisms for a robust and
predictable user experience.
 Integration with other Spring modules: Seamlessly integrates with other Spring frameworks
like Spring Security, Spring Data JPA, for comprehensive web application development.
Benefits of Spring Web MVC:
 Separation of Concerns: Improves code organization, maintainability, and testability.
 Increased Productivity: Reduces boilerplate code and simplifies web development tasks.
 Flexibility: Supports various view technologies and allows for customization.
 Improved Testability: MVC pattern promotes modularity, making components easier to test
in isolation.
 Scalability: Well-suited for building large and complex web applications.

Q.5 (b) ORM (Object-Relational Mapping) and Hibernate Mappings

Object-Relational Mapping (ORM) is a programming technique that simplifies working with
relational databases using object-oriented programming languages like Java. Tools like
Hibernate act as ORMs, providing the glue between objects and database tables.
Object/Relational Mappings in Hibernate:
Hibernate defines mappings between Java classes and database tables. Here's how it works:
1. Annotations or XML Files: You define mappings using annotations on your Java classes or
through separate XML files (hbm.xml).
2. Java Classes as Entities: Class properties are mapped to database table columns.
3. JPA Annotations: Common annotations include @Entity (for entity classes), @Id (for primary
key fields), and @Column (for mapping properties to columns).
4. Relationships: Hibernate can map relationships between entities, such as one-to-many,
many-to-one, etc.
5. Persistence: Hibernate handles data persistence automatically, converting objects to
database rows and vice versa.
Benefits of ORM with Hibernate:
 Reduced Code: Less code needed compared to manual database access with JDBC.
 Improved Maintainability: Changes to object models can be reflected in database schema
changes.
 Object-Oriented Approach: Developers work with objects instead of raw SQL, improving
code readability.
 Portability: Less reliance on specific database vendors due to the object-oriented
abstraction.
 Q.5 (c) Spring MVC Framework Architecture
Spring MVC follows a layered architecture that promotes separation of concerns and
modularity:
1. Presentation Layer:
o Views: Responsible for rendering the UI using technologies like JSP, FreeMarker, Thymeleaf.
o Controllers: Handle user interactions (requests), interact with the Model, and select
appropriate Views.
2. Business Logic Layer:
o Model Objects: Represent data and business logic of the application.
o Services: Implement core application logic and interact with the data access layer.
3. Data Access Layer:
o Repositories/Data Access Objects: Interact with the database using technologies like JDBC
or JPA (Hibernate).
Components in Spring MVC:
 Dispatcher Servlet: Front controller that receives requests, maps them to controllers, and
manages the lifecycle.
 Handler Mapping: Maps URLs to controllers.
 View Resolver: Determines the appropriate view technology and view name based on
controller logic.
 Model (Model and View Model): Holds data for the view layer, can be Model objects
directly or simplified View Models.
By understanding the architecture, you can leverage Spring MVC's components to build
well-structured and maintainable web applications.