Unit-1

1. Explain MVC architecture with diagram.

MVC (Model-View-Controller) architecture is a software design pattern commonly used in web
development to organize code into three interconnected components: Model, View, and Controller.
Here's an explanation of each component along with a diagram:

1. Model: The Model represents the data and business logic of the application. It encapsulates
the application's data and behaviour. This component is responsible for managing the data
and the rules for manipulating that data. It communicates with the database or any other
data source to retrieve or update data.

2. View: The View represents the presentation layer of the application. It is responsible for
rendering the user interface and displaying data to the user. Views receive data from the
Model and present it to the user in a suitable format, such as HTML for web applications.

3. Controller: The Controller acts as an intermediary between the Model and the View. It
receives user input, processes it (often by interacting with the Model), and decides which
View to render in response. The Controller handles the flow of the application, routing
requests to the appropriate components.

Here's a diagram illustrating the flow of data and interactions in the MVC architecture:

In this diagram:
  The user interacts with the application through the View, typically by sending requests (e.g.,
clicking buttons, filling forms).

 The Controller receives these user inputs, processes them, and interacts with the Model to
fetch or manipulate data.

 The Model represents the data and business logic of the application. It communicates with
the database or any other data source.

 Once the Model has processed the data, the Controller selects an appropriate View and
passes the processed data to it.

 The View then renders the data received from the Controller and presents it to the user in a
suitable format (e.g., HTML for web applications).

This separation of concerns in MVC architecture makes the code base easier to maintain, test, and
scale, as changes in one component do not necessarily require changes in the others.

2. What is java EE? List and explain feature of them.

Java EE (Java Enterprise Edition) is a set of specifications, APIs (Application Programming Interfaces),
and runtime environments that provide a platform for developing and running enterprise-scale
applications. It offers a robust and scalable infrastructure for building distributed, multitiered, and
web-based applications. Here are some key features of Java EE along with explanations:

1. Component-based Architecture: Java EE applications are built using components, such as

Servlets, JavaServer Pages (JSP), Enterprise JavaBeans (EJB), and JavaServer Faces (JSF).
These components encapsulate the application's business logic, presentation, and data
access layers, promoting modular, reusable, and maintainable code.

2. Enterprise Containers: Java EE applications run within enterprise containers provided by

Java EE-compliant application servers, such as Apache TomEE, WildFly (formerly JBoss), IBM
WebSphere, and Oracle WebLogic. These containers manage the execution and lifecycle of
application components, handling tasks such as resource pooling, concurrency, transaction
management, security, and scalability.

3. Distributed Computing: Java EE supports distributed computing by enabling communication

and collaboration between distributed components across different networked systems. It
provides APIs for remote method invocation (RMI), messaging (Java Message Service - JMS),
web services (JAX-WS, JAX-RS), and distributed transactions (Java Transaction API - JTA),
facilitating the development of distributed applications.

4. Web Development Support: Java EE offers a comprehensive set of APIs and tools for
building web applications, including Servlets, JSP, JSF, Expression Language (EL), Java
Persistence API (JPA) for database access, and Java API for WebSocket (WebSocket API) for
real-time communication. These technologies enable the development of dynamic,
interactive, and scalable web applications.

5. Security: Security is a critical aspect of enterprise applications, and Java EE provides robust
mechanisms for securing applications and data. It includes features such as authentication,
authorization, data integrity, and confidentiality. Java EE security features can be configured
and customized to meet specific application requirements, ensuring that sensitive
information is protected from unauthorized access and malicious attacks.
 6. Transaction Management: Java EE provides support for managing transactions within
enterprise applications. It offers a high-level API (Java Transaction API - JTA) for coordinating
distributed transactions across multiple resources, such as databases, message queues, and
other enterprise systems. Java EE containers handle transaction management transparently,
ensuring data consistency and reliability in transactional operations.

7. Concurrency and Scalability: Java EE applications can efficiently handle concurrent requests
and scale to meet growing demands. Java EE containers manage concurrency and scalability
by providing features such as thread pooling, connection pooling, load balancing, and
clustering. These features enable applications to handle large numbers of users and
maintain performance under heavy loads.

8. Integration with Existing Systems: Java EE supports integration with existing enterprise
systems and legacy applications through standards-based APIs and protocols. It provides
connectors for integrating with enterprise information systems (EIS) such as databases,
messaging systems, and legacy applications. Java EE also supports interoperability with other
technologies and platforms through standard protocols such as HTTP, SOAP, and REST.

3. Give the characteristics of the HTTP protocol and explain the GET,
HEAD and PUT methods of the HTTP protocol.
HTTP (Hypertext Transfer Protocol) is the underlying protocol used for communication on the World
Wide Web. It is a stateless, application-layer protocol that operates over TCP/IP, facilitating the
transfer of hypertext documents, such as HTML files, between clients (e.g., web browsers) and
servers. Here are some characteristics of the HTTP protocol:

1. Stateless: HTTP is stateless, meaning each request from a client to a server is independent
and unrelated to previous requests. The server does not maintain any information about
past requests, which simplifies implementation and improves scalability.

2. Text-based Protocol: HTTP messages are text-based, consisting of headers and an optional
message body. This makes HTTP human-readable and easy to debug using tools like web
browsers' developer tools or network monitoring software.

3. Request-Response Model: HTTP follows a request-response model, where clients send

requests to servers, and servers respond with corresponding responses. Each request
consists of a method, URI (Uniform Resource Identifier), protocol version, headers, and an
optional message body.

4. Connection-Oriented: HTTP can be either connection-oriented or connectionless. By default,

HTTP/1.1 maintains persistent connections, allowing multiple requests and responses to be
sent over a single TCP connection, thus reducing latency and improving performance.

5. Cacheability: HTTP supports caching of responses, allowing clients to store and reuse
previously retrieved resources. This reduces server load and improves performance by
minimizing network traffic.

Now, let's explain the GET, HEAD, and PUT methods of the HTTP protocol:

1. GET Method:

 The GET method is used to request data from a specified resource.

  It is a safe and idempotent operation, meaning it should not have any side effects on
the server's state, and making multiple identical GET requests should produce the
same result.

 GET requests are typically used to retrieve data, such as web pages, images, or other
resources, identified by a URL.

 The data returned by a GET request is included in the response body.

 Example: GET /index.html HTTP/1.1

2. HEAD Method:

 The HEAD method is similar to GET but requests only the headers of a resource,
without the response body.

 It is often used to retrieve metadata about a resource, such as its content type, last
modification date, or content length, without actually fetching the resource's
content.

 HEAD requests are useful for checking resource availability, determining caching
information, or verifying resource integrity.

 The response to a HEAD request contains the same headers as a corresponding GET
request but without the response body.

 Example: HEAD /index.html HTTP/1.1

3. PUT Method:

 The PUT method is used to upload or replace a resource at the specified URI.

 It is an idempotent operation, meaning repeated PUT requests with the same data
should have the same result.

 PUT requests are often used to update or create resources on the server.

 The request body of a PUT request contains the data to be stored or updated at the
specified URI.

 PUT requests are typically used in RESTful APIs for creating or updating resources.

 Example: PUT /documents/document1.txt HTTP/1.1

4. Explain various types of JDBC drivers and comment on selection of

driver.
JDBC (Java Database Connectivity) is a Java API for connecting and interacting with relational
databases. There are four types of JDBC drivers, each with its own characteristics and advantages.
Let's discuss each type:

1. Type 1: JDBC-ODBC Bridge Driver:

 This driver uses the JDBC API to interact with an ODBC (Open Database Connectivity)
driver, typically provided by the database vendor.
  It translates JDBC calls into ODBC calls, allowing Java applications to connect to any
database for which an ODBC driver is available.

 Advantages:

 Easy to set up and use.

 Platform-independent, as it relies on the ODBC driver provided by the

operating system.

 Disadvantages:

 Performance overhead due to the additional translation layer.

 Limited portability and compatibility, as it relies on the availability of an

ODBC driver.

2. Type 2: Native-API Driver:

 This driver uses a database-specific native client library to interact directly with the
database.

 It communicates with the database using the vendor's proprietary network protocol.

 Advantages:

 Better performance compared to the JDBC-ODBC Bridge driver, as it

bypasses the ODBC layer.

 Platform-specific optimizations, leading to improved efficiency.

 Disadvantages:

 Requires database-specific native libraries, making it less portable.

 May have compatibility issues across different versions of the database.

3. Type 3: Network Protocol Driver (Middleware Driver):

 This driver communicates with a middleware server, which acts as an intermediate

layer between the client application and the database server.

 The middleware server converts JDBC calls into a database-independent protocol,

which is then translated to the database-specific protocol by the database server.

 Advantages:

 Platform-independent, as it relies on the middleware server to provide

connectivity.

 Decouples the client application from the database server, providing

flexibility and scalability.

 Disadvantages:

 Performance overhead due to additional network hops and protocol

conversions.
  Requires middleware server installation and configuration.

4. Type 4: Thin (Direct) Driver:

 Also known as the JDBC Net-Protocol driver, this driver communicates directly with
the database server using a database-specific network protocol (e.g., TCP/IP).

 It does not require any native database libraries or middleware servers, making it
highly portable and efficient.

 Advantages:

 High performance and efficiency, as it communicates directly with the

database server.

 Platform-independent, as it is implemented entirely in Java.

 Disadvantages:

 Database-specific implementation, requiring separate drivers for different

databases.

 May lack some advanced features provided by native or middleware drivers.

Selection of the appropriate JDBC driver depends on various factors, including:

 Performance requirements: Thin drivers typically offer better performance compared to

drivers with additional translation layers.

 Portability: Thin drivers are more portable and platform-independent, while native and
middleware drivers may be platform-specific.

 Compatibility: Ensure that the selected driver is compatible with the target database and
environment.

 Deployment considerations: Consider ease of deployment, maintenance, and licensing

requirements associated with different driver types.

5. Explain the use of CallableStatement and PreparedStatement with

example.

Both CallableStatement and PreparedStatement are interfaces provided by the JDBC API to execute
SQL statements against a database. They offer advantages over regular Statement objects in terms
of performance, security, and code reusability.

PreparedStatement:

 PreparedStatement is used to execute parameterized SQL queries. It precompiles the SQL

statement and allows for efficient execution of the same SQL statement with different
parameters.

 It helps prevent SQL injection attacks by automatically escaping input parameters.

 PreparedStatement is ideal for executing SQL queries that need to be executed multiple
times with different parameter values.
  Here's an example of using PreparedStatement to insert data into a table:

import java.sql.*;

public class PreparedStatementExample {

public static void main(String[] args) {

try (Connection connection =

DriverManager.getConnection("jdbc:mysql://localhost:3306/mydatabase", "username",
"password")) {

String sql = "INSERT INTO users (name, email) VALUES (?, ?)";

PreparedStatement statement = connection.prepareStatement(sql);

// Set parameters

statement.setString(1, "John Doe");

statement.setString(2, "[email protected]");

// Execute the query

int rowsInserted = statement.executeUpdate();

if (rowsInserted > 0) {

System.out.println("A new user was inserted successfully!");

} catch (SQLException e) {

e.printStackTrace();

CallableStatement:

 CallableStatement is used to execute stored procedures or functions in the database. Stored

procedures are precompiled SQL statements stored in the database server and can accept
input parameters and return values.

 It allows for calling database stored procedures with input parameters and retrieving output
parameters or result sets.

 Here's an example of using CallableStatement to call a stored procedure:

import java.sql.*;
public class CallableStatementExample {

public static void main(String[] args) {

try (Connection connection =

DriverManager.getConnection("jdbc:mysql://localhost:3306/mydatabase", "username",
"password")) {

String sql = "{call getEmployeeName(?, ?)}";

CallableStatement statement = connection.prepareCall(sql);

// Set input parameter

statement.setInt(1, 101);

// Register output parameter

statement.registerOutParameter(2, Types.VARCHAR);

// Execute the stored procedure

statement.execute();

// Get output parameter value

String employeeName = statement.getString(2);

System.out.println("Employee Name: " + employeeName);

} catch (SQLException e) {

e.printStackTrace();

6. Explain Prepared statements with suitable example.

Prepared Statements in JDBC are used to execute parameterized SQL queries. They offer several
advantages over regular Statement objects, such as improved performance, better security, and
code readability. Prepared Statements precompile the SQL statement once and then execute it
multiple times with different parameter values, which reduces overhead and improves efficiency,
especially for repeated executions of the same query.

Here's an explanation of Prepared Statements with a suitable example:

Let's consider a scenario where we need to retrieve information about employees from a database
based on their department ID. We'll use a Prepared Statement to fetch this data.

import java.sql.*;

public class PreparedStatementExample {

public static void main(String[] args) {

try (Connection connection =

DriverManager.getConnection("jdbc:mysql://localhost:3306/company", "username", "password")) {

// Define the SQL query with a placeholder for the department ID

String sql = "SELECT * FROM employees WHERE department_id = ?";

// Create a PreparedStatement object

PreparedStatement statement = connection.prepareStatement(sql);

// Set the value of the parameter (department ID)

int departmentId = 101; // Example department ID

statement.setInt(1, departmentId);

// Execute the query and retrieve the result set

ResultSet resultSet = statement.executeQuery();

// Process the result set

while (resultSet.next()) {

int empId = resultSet.getInt("emp_id");

String empName = resultSet.getString("emp_name");

double empSalary = resultSet.getDouble("emp_salary");

int empDepartmentId = resultSet.getInt("department_id");

// Display the employee information

System.out.println("Employee ID: " + empId);

System.out.println("Employee Name: " + empName);

System.out.println("Employee Salary: " + empSalary);

 System.out.println("Department ID: " + empDepartmentId);

System.out.println();

} catch (SQLException e) {

e.printStackTrace();

1. We establish a connection to the database using DriverManager.getConnection.

2. We define our SQL query with a placeholder (?) for the department ID.

3. We create a PreparedStatement object by calling connection.prepareStatement(sql).

4. We set the value of the department ID parameter using statement.setInt(1, departmentId).

5. We execute the query using statement.executeQuery(), which returns a ResultSet.

6. We iterate through the ResultSet and retrieve employee information.

7. Finally, we display the employee information.

7. Consider Bank table with attributes AccountNo, CustomerName,

Balance, Phone and Address. Write a database application which allows
insertion, updation and deletion of records in Bank table.Print values of
all customers whose balance is greater than 20,000.
import java.sql.*;

public class BankDatabaseApplication {

// Database connection parameters

static final String JDBC_URL = "jdbc:mysql://localhost:3306/bank";

static final String USERNAME = "username";

static final String PASSWORD = "password";

public static void main(String[] args) {

try (Connection connection = DriverManager.getConnection(JDBC_URL, USERNAME,

PASSWORD)) {

// Insert a new record into the Bank table

 insertRecord(connection, "1234567890", "John Doe", 25000, "1234567890", "Address 1");

// Update an existing record in the Bank table

updateRecord(connection, "1234567890", "New Address");

// Delete a record from the Bank table

deleteRecord(connection, "1234567890");

// Print values of all customers whose balance is greater than 20,000

printCustomersWithBalanceGreaterThan(connection, 20000);

} catch (SQLException e) {

e.printStackTrace();

// Method to insert a new record into the Bank table

static void insertRecord(Connection connection, String accountNo, String customerName, double

balance, String phone, String address) throws SQLException {

String sql = "INSERT INTO Bank (AccountNo, CustomerName, Balance, Phone, Address) VALUES
(?, ?, ?, ?, ?)";

try (PreparedStatement statement = connection.prepareStatement(sql)) {

statement.setString(1, accountNo);

statement.setString(2, customerName);

statement.setDouble(3, balance);

statement.setString(4, phone);

statement.setString(5, address);

int rowsInserted = statement.executeUpdate();

System.out.println(rowsInserted + " record(s) inserted.");

// Method to update an existing record in the Bank table

 static void updateRecord(Connection connection, String accountNo, String newAddress) throws
SQLException {

String sql = "UPDATE Bank SET Address = ? WHERE AccountNo = ?";

try (PreparedStatement statement = connection.prepareStatement(sql)) {

statement.setString(1, newAddress);

statement.setString(2, accountNo);

int rowsUpdated = statement.executeUpdate();

System.out.println(rowsUpdated + " record(s) updated.");

// Method to delete a record from the Bank table

static void deleteRecord(Connection connection, String accountNo) throws SQLException {

String sql = "DELETE FROM Bank WHERE AccountNo = ?";

try (PreparedStatement statement = connection.prepareStatement(sql)) {

statement.setString(1, accountNo);

int rowsDeleted = statement.executeUpdate();

System.out.println(rowsDeleted + " record(s) deleted.");

// Method to print values of all customers whose balance is greater than the specified amount

static void printCustomersWithBalanceGreaterThan(Connection connection, double amount)

throws SQLException {

String sql = "SELECT * FROM Bank WHERE Balance > ?";

try (PreparedStatement statement = connection.prepareStatement(sql)) {

statement.setDouble(1, amount);

ResultSet resultSet = statement.executeQuery();

System.out.println("Customers with balance greater than " + amount + ":");

while (resultSet.next()) {

String accountNo = resultSet.getString("AccountNo");

String customerName = resultSet.getString("CustomerName");

 double balance = resultSet.getDouble("Balance");

String phone = resultSet.getString("Phone");

String address = resultSet.getString("Address");

System.out.println("Account No: " + accountNo + ", Customer Name: " + customerName +

", Balance: " + balance + ", Phone: " + phone + ", Address: " + address);

8. Give the use of Statement, PreparedStatement and

CallableStatement object and Write code to insert three records into
student table using PreparedStatement (assume student table with
Name, RollNo, and Branch field).
1. Statement: It is a basic interface used to execute SQL queries without any parameters. It is
generally used for executing static SQL queries where the values are known at compile-time.

2. PreparedStatement: It is a specialized interface used to execute SQL queries with

parameters. PreparedStatements are precompiled and can accept input parameters, making
them suitable for executing the same SQL query multiple times with different parameter
values. They help prevent SQL injection attacks by automatically escaping input parameters.

3. CallableStatement: It is used to execute stored procedures or functions in the database.

CallableStatements can have both input and output parameters and are used to call
database stored procedures or functions. They are particularly useful when dealing with
database procedures that return result sets or output parameters.

Here's an example code to insert three records into the student table using PreparedStatement:

import java.sql.*;

public class InsertRecordsWithPreparedStatement {

// Database connection parameters

static final String JDBC_URL = "jdbc:mysql://localhost:3306/mydatabase";

static final String USERNAME = "username";

static final String PASSWORD = "password";

public static void main(String[] args) {

 try (Connection connection = DriverManager.getConnection(JDBC_URL, USERNAME,
PASSWORD)) {

// Insert three records into the student table

insertRecord(connection, "John Doe", 101, "Computer Science");

insertRecord(connection, "Jane Smith", 102, "Electrical Engineering");

insertRecord(connection, "Alice Johnson", 103, "Mechanical Engineering");

} catch (SQLException e) {

e.printStackTrace();

// Method to insert a record into the student table using PreparedStatement

static void insertRecord(Connection connection, String name, int rollNo, String branch) throws
SQLException {

String sql = "INSERT INTO student (Name, RollNo, Branch) VALUES (?, ?, ?)";

try (PreparedStatement statement = connection.prepareStatement(sql)) {

statement.setString(1, name);

statement.setInt(2, rollNo);

statement.setString(3, branch);

int rowsInserted = statement.executeUpdate();

System.out.println(rowsInserted + " record(s) inserted.");

9. What are the differences between Java Bean and basic java class?
Explain Java Bean Architecture.

Java Bean and basic Java class are both Java programming constructs but serve different purposes
and follow different conventions. Here are the key differences between them:

1. Purpose:

 Java Bean: Java Bean is a reusable software component designed to be manipulated

visually in a builder tool. It is typically used in graphical user interface (GUI)
development, such as Swing or JavaFX applications. Java Beans often encapsulate
 data and behavior related to GUI components, allowing them to be easily integrated
into GUI builder tools.

 Basic Java Class: A basic Java class is a fundamental building block of Java programs.
It encapsulates data and behavior related to a specific concept or entity within an
application. Basic Java classes are not specifically designed to be manipulated
visually in builder tools like Java Beans.

2. Conventions:

 Java Bean: Java Beans follow specific conventions defined by the Java Bean
specification. These conventions include providing a public default constructor,
exposing properties using getter and setter methods, supporting serialization, and
following naming conventions for methods and properties (e.g., getXxx, setXxx).

 Basic Java Class: Basic Java classes do not necessarily follow the conventions defined
by the Java Bean specification. They may or may not have a default constructor,
getter/setter methods, or serialization support, depending on the requirements of
the application.

3. Usage:

 Java Bean: Java Beans are typically used in GUI development, where visual
components need to be easily integrated, configured, and manipulated in builder
tools. They provide a standardized way to represent and manage GUI components.

 Basic Java Class: Basic Java classes are used to model various entities, concepts, or
functionalities within an application. They may represent domain objects, utility
classes, data access objects, or other types of components.

4. Integration:

 Java Bean: Java Beans are designed for easy integration into visual builder tools,
IDEs (Integrated Development Environments), and application frameworks. They
often rely on introspection and reflection mechanisms to enable dynamic
manipulation and configuration.

 Basic Java Class: Basic Java classes are integrated into Java applications using
traditional programming techniques. They are instantiated, configured, and used
directly within the application code.

Java Bean Architecture:

The Java Bean architecture defines a set of conventions and guidelines for creating reusable
software components in Java. Key aspects of Java Bean architecture include:

 Properties: Java Beans encapsulate data using properties, which are accessed through getter
and setter methods. Properties provide a standardized way to access and manipulate the
state of Java Bean objects.

 Events: Java Beans can generate and listen to events, allowing them to communicate with
other components in an application. Events follow the observer design pattern, where
listeners register interest in specific events and are notified when those events occur.
  Customization: Java Beans support customization through properties, events, and methods.
Builders and IDEs can interact with Java Beans to configure their properties, handle events,
and invoke methods dynamically.

 Serialization: Java Beans support serialization, allowing their state to be saved to a

persistent storage or transmitted over a network. This enables Java Beans to be easily
stored, retrieved, and transferred between different environments.

10. What is JDBC driver? What is its role? List the types of drivers and
explain working of type-4 driver. Give the different ways to create the
JDBC connection with example.
JDBC (Java Database Connectivity) driver is a software component that enables Java applications to
interact with databases using the JDBC API. The JDBC driver acts as a bridge between the Java
application and the database server, allowing the application to send SQL queries and commands to
the database and retrieve results.

The role of a JDBC driver includes:

1. Establishing Connection: The JDBC driver establishes a connection to the database server
using the appropriate protocol (e.g., TCP/IP, HTTP) and driver-specific mechanisms.

2. Executing Queries: The JDBC driver executes SQL queries and commands sent by the Java
application against the database server. It translates JDBC calls into database-specific
commands understandable by the database server.

3. Retrieving Results: The JDBC driver retrieves the results of SQL queries and commands from
the database server and provides them back to the Java application in a format usable by
Java code (e.g., ResultSet).

4. Handling Transactions: The JDBC driver manages database transactions, including

committing changes to the database or rolling back transactions in case of errors.

Types of JDBC Drivers:

1. Type 1: JDBC-ODBC Bridge Driver: This driver uses an ODBC (Open Database Connectivity)
driver provided by the operating system to connect to the database. It acts as a bridge
between JDBC and ODBC APIs.

2. Type 2: Native-API Driver: This driver communicates directly with the database server using
a database-specific native client library. It interacts with the database using the vendor's
proprietary network protocol.

3. Type 3: Network Protocol Driver (Middleware Driver): This driver communicates with a
middleware server, which acts as an intermediary between the Java application and the
database server. The middleware server translates JDBC calls into a database-independent
protocol understood by the database server.

4. Type 4: Thin (Direct) Driver: This driver communicates directly with the database server
using a database-specific network protocol (e.g., TCP/IP). It does not require any
intermediate translation layers or additional client libraries.

Working of Type 4 Driver:

  Type 4 JDBC driver, also known as the Thin or Direct driver, communicates directly with the
database server using a database-specific network protocol (e.g., MySQL protocol, Oracle
Net protocol).

 The Type 4 driver is implemented entirely in Java and does not require any native code or
additional client libraries.

 When a Java application requests a database connection using the Type 4 driver, the driver
establishes a direct connection to the database server over the network.

 Once the connection is established, the Type 4 driver sends SQL queries and commands to
the database server and retrieves the results directly.

 Since there are no intermediate translation layers or additional dependencies, the Type 4
driver offers improved performance and portability compared to other driver types.

Different Ways to Create JDBC Connection:

1. Using DriverManager:

Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mydatabase",

"username", "password");

2. Using DataSource (preferred for connection pooling):

DataSource dataSource = new MyDataSource(); // Custom DataSource implementation

Connection connection = dataSource.getConnection();

3. Using JNDI Lookup (Java Naming and Directory Interface):

Context context = new InitialContext();

DataSource dataSource = (DataSource) context.lookup("java:/comp/env/jdbc/mydatabase");

Connection connection = dataSource.getConnection();

11. What is Callable statement? Write a procedure to insert a row into

the table student (roll_no,name,%ge) and call it using callable
statement in JDBC application.
A CallableStatement in JDBC is used to execute stored procedures or functions in the database.
Stored procedures are precompiled SQL statements stored in the database server, which can accept
input parameters and return values. CallableStatements can handle both input and output
parameters, making them suitable for calling stored procedures or functions.

Here's a procedure to insert a row into the table student (roll_no, name, percentage) and call it
using a CallableStatement in a JDBC application:

Assuming we have a stored procedure named insert_student in the database that takes three input
parameters: roll_no, name, and percentage, and inserts a new row into the student table.

Stored Procedure Definition (MySQL Syntax):

DELIMITER //
CREATE PROCEDURE insert_student(

IN p_roll_no INT,

IN p_name VARCHAR(255),

IN p_percentage FLOAT

BEGIN

INSERT INTO student (roll_no, name, percentage) VALUES (p_roll_no, p_name, p_percentage);

END //

DELIMITER ;

Java JDBC Application to Call the Stored Procedure:

import java.sql.*;

public class CallableStatementExample {

// Database connection parameters

static final String JDBC_URL = "jdbc:mysql://localhost:3306/mydatabase";

static final String USERNAME = "username";

static final String PASSWORD = "password";

public static void main(String[] args) {

try (Connection connection = DriverManager.getConnection(JDBC_URL, USERNAME,

PASSWORD)) {

// Call the stored procedure insert_student

callInsertStudentProcedure(connection, 101, "John Doe", 85.5);

} catch (SQLException e) {

e.printStackTrace();

// Method to call the stored procedure insert_student using CallableStatement

static void callInsertStudentProcedure(Connection connection, int rollNo, String name, double

percentage) throws SQLException {
 // Define the SQL query to call the stored procedure

String sql = "{CALL insert_student(?, ?, ?)}";

try (CallableStatement statement = connection.prepareCall(sql)) {

// Set input parameters

statement.setInt(1, rollNo);

statement.setString(2, name);

statement.setDouble(3, percentage);

// Execute the stored procedure

statement.execute();

System.out.println("Row inserted successfully.");

12. Give the hibernate architecture and discuss each part in brief.
Hibernate is an object-relational mapping (ORM) framework for the Java programming language. It
provides a way to map Java objects to relational database tables and vice versa, enabling developers
to work with databases using an object-oriented approach. The Hibernate architecture consists of
several components, each playing a specific role in the framework. Here's an overview of the
Hibernate architecture and its components:

1. Hibernate Configuration:

 The Hibernate configuration is responsible for specifying database connection

settings, mapping files, caching settings, and other configuration options.

 It is typically provided through a configuration file named hibernate.cfg.xml, which

contains database connection details, dialects, and other properties.

2. SessionFactory:

 The SessionFactory is a thread-safe factory for creating Hibernate Sessions.

 It is created once during application initialization, typically at startup.

 The SessionFactory maintains a cache of compiled mappings for efficient creation of

Session objects.

 It is responsible for managing database connections and providing Session objects to

the application.

3. Session:
  A Session is a lightweight and short-lived object representing a single unit of work
with the database.

 It serves as a bridge between the Java application and the underlying database.

 The Session interface provides methods for performing database CRUD operations
(Create, Read, Update, Delete), querying data, and managing transactions.

 Sessions are not thread-safe and should be used in a single-threaded manner.

4. Transaction:

 A Transaction represents a single atomic unit of work with the database.

 It ensures data consistency and integrity by either committing changes to the

database or rolling back changes in case of errors or exceptions.

 Transactions are managed by the application using the Session interface.

 Hibernate supports both programmatic and declarative transaction management.

5. Entities (POJOs):

 Entities, also known as Plain Old Java Objects (POJOs), are Java classes that
represent persistent data stored in the database.

 Entities are typically annotated with Hibernate annotations to specify mappings

between Java objects and database tables.

 Hibernate uses reflection and metadata to map entities to database tables, columns,
and relationships.

6. Mappings:

 Mappings define the relationship between Java objects and database tables.

 They specify how attributes of Java classes are mapped to columns in database
tables.

 Mappings can be defined using XML mapping files or annotations directly within Java
classes.

7. Queries:

 Hibernate provides various ways to query data from the database, including HQL
(Hibernate Query Language), Criteria API, and native SQL queries.

 HQL is a SQL-like query language specific to Hibernate, which operates on entity

objects rather than database tables.

 Criteria API provides a type-safe and object-oriented way to build dynamic queries
using criteria objects.

 Native SQL queries allow executing native SQL queries directly against the database.

8. Caching:
  Hibernate supports caching mechanisms to improve application performance by
reducing the number of database queries.

 It provides first-level cache (Session-level cache) and second-level cache

(SessionFactory-level cache) to cache entities and query results.

 Caching can be configured and customized based on application requirements and

performance considerations.

13. Explain Object Relational Mapping in Hibernate.

Object-Relational Mapping (ORM) is a programming technique used to map object-oriented domain
models to relational database tables. ORM frameworks, like Hibernate, automate the mapping
process, allowing developers to work with objects in their application code, while transparently
persisting and retrieving data from the underlying database.

In the context of Hibernate, Object-Relational Mapping involves the following key concepts:

1. Entities:

 Entities represent persistent data stored in the database.

 They are typically modeled as Java classes, also known as Plain Old Java Objects
(POJOs).

 Each entity class maps to a specific database table, with each attribute of the class
mapping to a column in the table.

 Entities encapsulate both data (attributes/properties) and behavior (methods)

related to the domain model.

2. Mappings:

 Mappings define the relationship between entity classes and database tables.

 They specify how attributes of Java classes are mapped to columns in database
tables, and how relationships between entities are represented in the database
schema.

 Mappings can be defined using XML mapping files or annotations directly within Java
classes (using Hibernate Annotations).

3. Session:

 The Session in Hibernate represents a single unit of work with the database.

 It serves as a gateway between the application code and the underlying database,
allowing CRUD (Create, Read, Update, Delete) operations to be performed on
entities.

 Sessions manage the lifecycle of entities, including fetching, persisting, updating,

and deleting them from the database.

4. Transaction:
  Transactions ensure data consistency and integrity by grouping multiple database
operations into a single atomic unit of work.

 Hibernate supports both programmatic and declarative transaction management,

allowing developers to control transaction boundaries explicitly or configure them
declaratively.

5. Query Language:

 Hibernate provides its own query language called Hibernate Query Language (HQL),
which is similar to SQL but operates on entity objects rather than database tables.

 HQL allows developers to write queries in a more object-oriented manner,

referencing entity properties and relationships directly.

 Additionally, Hibernate supports Criteria API for building dynamic queries using
type-safe criteria objects, and native SQL queries for executing raw SQL statements
against the database.

6. Caching:

 Hibernate supports caching mechanisms to improve application performance by

reducing the number of database queries.

 It provides first-level cache (Session-level cache) and second-level cache

(SessionFactory-level cache) to cache entities and query results.

 Caching can be configured and customized based on application requirements and

performance considerations.

14. Difference between prepared statement and create statement.

The difference between PreparedStatement and Statement in JDBC lies in their purpose, usage, and
benefits:

1. Purpose:

 Statement: The Statement interface in JDBC is used to execute static SQL queries
without any parameters. It is typically used for executing SQL queries where the
values are known at compile-time and do not need to be parameterized.

 PreparedStatement: The PreparedStatement interface is used to execute

parameterized SQL queries. It allows for the execution of the same SQL statement
multiple times with different parameter values. PreparedStatement is ideal for
preventing SQL injection attacks and improving performance when executing
queries repeatedly with varying parameters.

2. Parameterization:

 Statement: Statements do not support parameterization. SQL queries executed

using Statement are constructed as strings with fixed values, making them
susceptible to SQL injection attacks if user inputs are directly concatenated into the
query string.
  PreparedStatement: PreparedStatements support parameterization, allowing for
the insertion of parameters (placeholders) into the SQL query string. Parameters are
then bound to specific values using setter methods, providing protection against SQL
injection attacks by automatically escaping input parameters.

3. Compilation:

 Statement: Statements execute SQL queries directly against the database each time
they are executed. They do not undergo any precompilation process.

 PreparedStatement: PreparedStatements are precompiled by the database server

upon creation. This precompilation process involves parsing, validating, and
optimizing the SQL query, resulting in improved performance when executing the
same query multiple times with different parameter values.

4. Performance:

 Statement: Statements may suffer from performance overhead when executing SQL
queries repeatedly, especially if the same query is executed with different
parameter values, as each execution requires parsing and optimization by the
database server.

 PreparedStatement: PreparedStatements offer better performance compared to

Statements when executing parameterized SQL queries repeatedly. The precompiled
nature of PreparedStatements reduces overhead by avoiding repetitive parsing and
optimization, resulting in faster query execution times.
 Unit-2
1. Write a web application which takes marks of three subject and pass
to servlet. Display the percentage.
To create a simple web application that takes marks of three subjects as input from a form and
passes them to a servlet to calculate and display the percentage, you'll need to follow these steps:

1. Create a HTML form to input marks.

2. Create a servlet to handle form submission, calculate percentage, and display the result.

Here's the code for each step:

1. HTML Form (index.html):

<!DOCTYPE html>

<html>

<head>

<title>Calculate Percentage</title>

</head>

<body>

<h2>Enter Marks of Three Subjects</h2>

<form action="calculate" method="post">

Subject 1 Marks: <input type="text" name="subject1"><br><br>

Subject 2 Marks: <input type="text" name="subject2"><br><br>

Subject 3 Marks: <input type="text" name="subject3"><br><br>

<input type="submit" value="Calculate Percentage">

</form>

</body>

</html>

2. Servlet (CalculatePercentageServlet.java):

import java.io.IOException;

import javax.servlet.ServletException;

import javax.servlet.http.HttpServlet;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;
public class CalculatePercentageServlet extends HttpServlet {

protected void doPost(HttpServletRequest request, HttpServletResponse response) throws

ServletException, IOException {

// Retrieve marks from form parameters

int subject1 = Integer.parseInt(request.getParameter("subject1"));

int subject2 = Integer.parseInt(request.getParameter("subject2"));

int subject3 = Integer.parseInt(request.getParameter("subject3"));

// Calculate percentage

double totalMarks = subject1 + subject2 + subject3;

double percentage = (totalMarks / 300) * 100;

// Display percentage

response.setContentType("text/html");

response.getWriter().println("<html><body>");

response.getWriter().println("<h2>Percentage Calculation Result</h2>");

response.getWriter().println("<p>Marks in Subject 1: " + subject1 + "</p>");

response.getWriter().println("<p>Marks in Subject 2: " + subject2 + "</p>");

response.getWriter().println("<p>Marks in Subject 3: " + subject3 + "</p>");

response.getWriter().println("<p>Total Marks: " + totalMarks + "</p>");

response.getWriter().println("<p>Percentage: " + percentage + "%</p>");

response.getWriter().println("</body></html>");

2. Compare the following terms.

i. Generic Servlet and Http Servlet
ii. DoGet() and DoPost()
iii. Servlet and JSP
iv. Session and Cookie
3. List and explain various stages of JSP Life cycle. Briefly give the
function of each Phase.

The life cycle of a JSP (JavaServer Pages) consists of several stages, each serving a specific purpose in
the processing of a JSP page. Here are the various stages of the JSP life cycle along with their
functions:

1. Translation:

 In the translation phase, the JSP container translates the JSP file into a servlet class.

 The container parses the JSP file, generates Java code for the servlet, and compiles it
into a servlet class.

 This phase happens only once during the initial deployment or when the JSP file is
modified.

2. Compilation:
  During compilation, the generated servlet class is compiled into bytecode by the
Java compiler.

 The resulting bytecode is then loaded by the class loader and instantiated as a
servlet object.

3. Initialization:

 In the initialization phase, the servlet's init() method is called by the container.

 This phase allows the servlet to perform any necessary one-time initialization tasks,
such as loading configuration settings, establishing database connections, or
initializing resources.

4. Request Processing:

 The request processing phase begins when a client sends an HTTP request to access
the JSP page.

 The container creates a servlet instance and invokes its service() method, passing
the request and response objects as parameters.

 The service() method generates dynamic content based on the request parameters,
session attributes, and application logic.

5. Compilation (if changed):

 If the JSP file has been modified since the last translation phase, the container
repeats the translation and compilation phases to update the servlet class.

 This ensures that any changes made to the JSP file are reflected in the generated
servlet code.

6. Request Handling:

 During request handling, the servlet processes the client's request by executing the
generated Java code.

 The servlet retrieves data from the request object, performs any necessary business
logic or data processing, and generates the response content.

7. Destroy:

 The destroy() method of the servlet is called by the container when the servlet is
being removed from service or the web application is being shut down.

 This phase allows the servlet to perform cleanup tasks, release resources, and
gracefully terminate any active connections or threads.

4. List and explain various stages of Servlet Life cycle. Explain role of
web container.
The life cycle of a servlet consists of several stages, each serving a specific purpose in the processing
of client requests and responses. Here are the various stages of the servlet life cycle along with their
explanations:
1. Loading:

 The loading stage occurs when the servlet container loads the servlet class into
memory.

 This typically happens when the servlet container starts up, or when the servlet is
accessed for the first time.

 During loading, the servlet container instantiates the servlet class and initializes it by
calling its init() method.

2. Initialization:

 During initialization, the servlet's init() method is called by the servlet container.

 This phase allows the servlet to perform any necessary one-time initialization tasks,
such as loading configuration settings, establishing database connections, or
initializing resources.

 The init() method is called only once in the servlet's lifecycle, typically during startup
or when the servlet is first accessed.

3. Request Handling:

 The request handling stage begins when the servlet container receives an HTTP
request for the servlet.

 The servlet container creates a new thread or reuses an existing thread from a
thread pool to handle the request.

 The container passes the request and response objects to the servlet's service()
method, which is responsible for processing the request and generating the
response.

 The service() method determines the HTTP request method (e.g., GET, POST, PUT,
DELETE) and delegates the request to the appropriate doXXX() method (e.g.,
doGet(), doPost(), doPut(), doDelete()).

4. Response Generation:

 During the request handling stage, the servlet generates dynamic content based on
the request parameters, session attributes, and application logic.

 The servlet constructs the response by writing data to the response object's output
stream or using other response-related methods.

 The generated response may include HTML content, XML data, JSON objects, or
other types of data depending on the application's requirements.

5. Destroy:

 The destroy stage occurs when the servlet container removes the servlet from
service or shuts down the web application.

 The servlet's destroy() method is called by the servlet container to perform any
necessary cleanup tasks, release resources, and gracefully terminate the servlet.
  The destroy() method allows the servlet to close database connections, release file
handles, or perform other cleanup operations before the servlet instance is garbage-
collected.

The role of the web container (servlet container) is to manage the execution and lifecycle of servlets
within a web application. The web container provides a runtime environment for servlets to handle
HTTP requests and responses, ensuring that servlets are loaded, initialized, and executed properly.
Here are some key responsibilities of the web container:

 Loading and Initialization: The web container loads servlet classes into memory, instantiates
servlet objects, and initializes them by calling their init() method.

 Request Handling: The web container receives HTTP requests from clients, determines
which servlet should handle each request based on the URL mapping configured in the
deployment descriptor (web.xml), and dispatches the request to the appropriate servlet.

 Thread Management: The web container manages a pool of threads to handle concurrent
requests from multiple clients. It assigns a thread to each incoming request, ensuring that
servlets are executed in a thread-safe manner.

 Request and Response Processing: The web container provides request and response
objects to servlets, allowing them to access request parameters, session attributes, and
other HTTP-related information. It also manages the lifecycle of these objects and ensures
that responses are sent back to clients in a timely manner.

 Lifecycle Management: The web container monitors the lifecycle of servlets, including
loading, initialization, request handling, and destruction. It calls the appropriate lifecycle
methods (e.g., init(), service(), destroy()) at the appropriate times to ensure that servlets are
properly managed and resources are released when no longer needed.

 Security: The web container enforces security constraints specified in the deployment
descriptor, such as authentication, authorization, and data encryption. It protects sensitive
resources and prevents unauthorized access to web applications.

 Context Management: The web container maintains a separate servlet context for each web
application deployed on the server. It manages context initialization parameters, shared
resources, and application-wide settings specific to each web application.

5. Explain Request and Response object in Servlet.

In the Servlet API, the HttpServletRequest and HttpServletResponse interfaces represent the request
and response objects, respectively. These objects encapsulate the details of an HTTP request and
response exchanged between a client (typically a web browser) and a servlet running on a web
server. Here's an explanation of each:

HttpServletRequest:

The HttpServletRequest interface provides methods for accessing the details of an HTTP request sent
by the client to the server. Some of the common methods provided by HttpServletRequest include:

1. getParameter(String name): Retrieves the value of a request parameter specified by its

name. Parameters can be sent by HTML forms using GET or POST methods.
 2. getParameterValues(String name): Retrieves an array of values for a request parameter
specified by its name. Useful when dealing with multiple values for a single parameter, such
as in checkbox groups.

3. getMethod(): Retrieves the HTTP method (GET, POST, PUT, DELETE, etc.) used by the client
for the request.

4. getSession(): Retrieves the HttpSession object associated with the request. Sessions allow
maintaining stateful information across multiple requests from the same client.

5. getRequestDispatcher(String path): Creates a RequestDispatcher object for forwarding the

request to another servlet, JSP, or resource on the server.

6. getHeader(String name): Retrieves the value of a request header specified by its name, such
as "User-Agent", "Host", or "Accept-Language".

7. getCookies(): Retrieves an array of Cookie objects representing the cookies sent by the client
with the request.

8. getInputStream(): Retrieves the input stream containing the request body for reading raw
data sent by the client, such as form data or file uploads.

HttpServletResponse:

The HttpServletResponse interface provides methods for constructing and sending an HTTP response
back to the client. Some of the common methods provided by HttpServletResponse include:

1. setContentType(String type): Sets the MIME type of the response content, such as
"text/html", "application/json", or "image/jpeg".

2. setStatus(int sc): Sets the status code of the response, such as 200 for OK, 404 for Not
Found, or 500 for Internal Server Error.

3. sendRedirect(String location): Sends a temporary redirect response to the client, instructing

it to request the specified URL instead.

4. setHeader(String name, String value): Sets a response header with the specified name and
value.

5. getWriter(): Retrieves a PrintWriter object for writing character-based response data, such
as HTML content or JSON strings.

6. sendError(int sc, String msg): Sends an error response with the specified status code and
message to the client.

7. addCookie(Cookie cookie): Adds a Cookie object to the response, which will be sent to the
client and stored on the client's machine.

8. setCharacterEncoding(String charset): Sets the character encoding (charset) of the response

content, such as "UTF-8" or "ISO-8859-1".

These request and response objects play a crucial role in servlet programming, allowing developers
to interact with client requests, process data, and construct appropriate responses dynamically.
They provide a rich set of methods for handling various aspects of the HTTP protocol, such as
parameters, headers, cookies, sessions, and content types, making it possible to build powerful and
interactive web applications.

6. Explain Event Handling in Servlet.

Event handling in servlets typically refers to the handling of various events that occur during the
lifecycle of a servlet, such as initialization, request processing, and destruction. Servlet containers
provide mechanisms for registering listeners and filters to intercept and process these events. Here's
an explanation of some key events in servlets and how event handling is implemented:

1. Servlet Initialization and Destruction:

 Servlet initialization and destruction events occur when the servlet container loads
and unloads servlet instances.

 Developers can implement the javax.servlet.ServletContextListener interface to

handle these events.

 The contextInitialized() method is called by the servlet container when the web
application is initialized, allowing initialization tasks to be performed.

 The contextDestroyed() method is called by the servlet container when the web
application is about to be shut down, allowing cleanup tasks to be performed.

2. Session Lifecycle Events:

 Session lifecycle events occur when HTTP sessions are created, invalidated, or timed
out.

 Developers can implement the javax.servlet.http.HttpSessionListener interface to

handle these events.

 The sessionCreated() method is called when a new session is created, allowing

initialization tasks to be performed.

 The sessionDestroyed() method is called when a session is invalidated or times out,

allowing cleanup tasks to be performed.

3. Request Lifecycle Events:

 Request lifecycle events occur during the processing of HTTP requests by servlets.

 Developers can implement filters (javax.servlet.Filter) to intercept requests and

responses and perform preprocessing and postprocessing tasks.

 Filters are configured in the deployment descriptor (web.xml) and can be applied to
specific URLs or servlet mappings.

 Filters can intercept requests before they reach servlets (doFilter() method invoked
before service() method) and responses before they are sent back to clients.

4. Attribute Changes:

 Servlet contexts, sessions, and request objects can store attributes that represent
application, session, and request scope data.
  Developers can implement listeners (javax.servlet.ServletContextAttributeListener,
javax.servlet.http.HttpSessionAttributeListener,
javax.servlet.ServletRequestAttributeListener) to be notified when attributes are
added, removed, or replaced.

 These listeners allow developers to perform actions based on attribute changes,

such as logging, validation, or synchronization.

5. Other Events:

 Servlet containers may provide additional event listeners for specific purposes, such
as monitoring servlet lifecycle events, tracking session activity, or handling
asynchronous processing.

 Developers can implement custom event listeners by creating classes that

implement the appropriate listener interfaces provided by the Servlet API.

7. Write a Java Servlet to demonstrate the use of Session Management.

import java.io.IOException;

import javax.servlet.ServletException;

import javax.servlet.annotation.WebServlet;

import javax.servlet.http.HttpServlet;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import javax.servlet.http.HttpSession;

@WebServlet("/SessionDemoServlet")

public class SessionDemoServlet extends HttpServlet {

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws

ServletException, IOException {

// Get the current session or create a new one if it doesn't exist

HttpSession session = request.getSession(true);

// Check if the session already contains a "visitCount" attribute

Integer visitCount = (Integer) session.getAttribute("visitCount");

// If "visitCount" attribute doesn't exist, set it to 1

if (visitCount == null) {

visitCount = 1;
 } else {

// If "visitCount" attribute exists, increment its value

visitCount++;

// Store the updated "visitCount" attribute in the session

session.setAttribute("visitCount", visitCount);

// Set the response content type

response.setContentType("text/html");

// Get the PrintWriter object to write the response

PrintWriter out = response.getWriter();

// Write HTML content to display the visit count

out.println("<html>");

out.println("<head><title>Session Demo</title></head>");

out.println("<body>");

out.println("<h1>Session Demo</h1>");

out.println("<p>Number of visits: " + visitCount + "</p>");

out.println("</body>");

out.println("</html>");

// Close the PrintWriter

out.close();

8. What is Filter? Explain filter in servlet.

In servlet programming, a filter is a Java class that intercepts and processes requests and responses
between a client and a servlet, or between a servlet and a web container. Filters provide a way to
perform preprocessing and postprocessing tasks on requests and responses before they reach their
intended destination. Filters are typically used to perform tasks such as authentication, logging, data
compression, encryption, and content transformation.

Here's an explanation of how filters work in servlets:

1. Filter Interface:

 The javax.servlet.Filter interface defines the contract for implementing filters in

servlets.

 A filter class must implement this interface and override the doFilter() method,
which is called by the servlet container to process requests and responses.

2. Filter Configuration:

 Filters are configured in the deployment descriptor (web.xml) of the web

application.

 The web.xml file specifies the filter class, filter name, URL patterns, and initialization
parameters for each filter.

3. Filter Chain:

 When a request is received by the servlet container, it passes the request and
response objects through a chain of filters before reaching the servlet or resource
being requested.

 Each filter in the chain can perform preprocessing tasks on the request and
postprocessing tasks on the response.

 Filters can also modify the request or response objects and control the flow of the
request by deciding whether to forward the request to the next filter or servlet in
the chain.

4. Filter Lifecycle:

 Filters have their own lifecycle, which includes initialization, request processing, and
destruction phases.

 The servlet container initializes filters when the web application is started and
destroys them when the application is shut down.

 The init() method of a filter is called by the container during initialization, allowing
the filter to perform any necessary setup tasks.

 The destroy() method of a filter is called by the container when the filter is being
removed from service, allowing cleanup tasks to be performed.

5. Filter Order and Chaining:

 Filters can be chained together in a specific order to process requests and responses
sequentially.

 The order of filters in the chain is determined by their mapping in the web.xml file
or by using annotations (@WebFilter) in servlet 3.0 and later versions.
  Filters can pass control to the next filter in the chain by calling the doFilter() method
of the FilterChain object passed as a parameter to the doFilter() method.

9. Explain use of ServletConfig and ServletContext object with example.

In servlet programming, the ServletConfig and ServletContext objects are important components
provided by the servlet container to configure and manage servlets within a web application. Let's
understand the use of each object with examples:

ServletConfig:

 The ServletConfig object provides initialization parameters to a specific servlet.

 These parameters are configured in the deployment descriptor (web.xml) or via annotations
(@WebServlet) and are specific to each servlet.

 Servlet initialization parameters can be accessed using the getInitParameter() and

getInitParameterNames() methods of the ServletConfig object.

 Here's an example demonstrating the use of ServletConfig:

import javax.servlet.*;

import javax.servlet.annotation.WebServlet;

import javax.servlet.http.*;

import java.io.*;

@WebServlet("/ServletConfigDemo")

public class ServletConfigDemo extends HttpServlet {

private ServletConfig config;

public void init(ServletConfig config) throws ServletException {

super.init(config);

this.config = config;

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws

ServletException, IOException {

// Accessing servlet initialization parameters

String driver = config.getInitParameter("driver");

String url = config.getInitParameter("url");

 response.setContentType("text/html");

PrintWriter out = response.getWriter();

out.println("<html><body>");

out.println("<h1>Servlet Config Demo</h1>");

out.println("<p>Driver: " + driver + "</p>");

out.println("<p>URL: " + url + "</p>");

out.println("</body></html>");

out.close();

ServletContext:

 The ServletContext object represents the servlet container and provides access to
application-wide resources and configuration settings.

 It is shared across all servlets and JSP pages within a web application.

 Servlet context parameters can be configured in the web.xml file using <context-param>
tags.

 Servlet context attributes can be set and retrieved using the setAttribute() and
getAttribute() methods.

 Here's an example demonstrating the use of ServletContext:

import javax.servlet.*;

import javax.servlet.annotation.WebServlet;

import javax.servlet.http.*;

import java.io.*;

@WebServlet("/ServletContextDemo")

public class ServletContextDemo extends HttpServlet {

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws

ServletException, IOException {

// Accessing servlet context parameters

ServletContext context = getServletContext();

String appName = context.getInitParameter("appName");

 // Setting and accessing servlet context attribute

context.setAttribute("version", "1.0");

String version = (String) context.getAttribute("version");

response.setContentType("text/html");

PrintWriter out = response.getWriter();

out.println("<html><body>");

out.println("<h1>Servlet Context Demo</h1>");

out.println("<p>Application Name: " + appName + "</p>");

out.println("<p>Version: " + version + "</p>");

out.println("</body></html>");

out.close();

In these examples:

 ServletConfigDemo servlet retrieves initialization parameters (driver and url) using the
ServletConfig object.

 ServletContextDemo servlet accesses context parameters (appName) and sets/retrieves

context attributes (version) using the ServletContext object.

These objects provide mechanisms for servlets to obtain configuration information and share
resources across the entire web application, enhancing modularity, reusability, and configurability.

10. Explain various Session Tracking mechanisms in servlet with

example.
Session tracking mechanisms in servlets allow web applications to maintain stateful information
across multiple client requests. There are several techniques for implementing session tracking in
servlets, each with its advantages and use cases. Let's discuss some of the common session tracking
mechanisms along with examples:

1. Cookies:

 Cookies are small pieces of data stored on the client's machine by the web server.

 They are sent back and forth between the client and server with each HTTP request and
response.

 Servlets can use cookies to store session identifiers or other session-related data.
  Example:

import javax.servlet.*;

import javax.servlet.annotation.WebServlet;

import javax.servlet.http.*;

import java.io.*;

@WebServlet("/CookieSessionDemo")

public class CookieSessionDemo extends HttpServlet {

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws

ServletException, IOException {

// Retrieve existing session ID from cookie or generate a new one

String sessionId = null;

Cookie[] cookies = request.getCookies();

if (cookies != null) {

for (Cookie cookie : cookies) {

if (cookie.getName().equals("sessionId")) {

sessionId = cookie.getValue();

break;

if (sessionId == null) {

sessionId = generateSessionId();

Cookie cookie = new Cookie("sessionId", sessionId);

response.addCookie(cookie);

// Use session ID to store and retrieve session data

HttpSession session = request.getSession(true);

Integer visitCount = (Integer) session.getAttribute("visitCount");

if (visitCount == null) {
 visitCount = 1;

} else {

visitCount++;

session.setAttribute("visitCount", visitCount);

// Display visit count

response.setContentType("text/html");

PrintWriter out = response.getWriter();

out.println("<html><body>");

out.println("<h1>Cookie Session Demo</h1>");

out.println("<p>Number of visits: " + visitCount + "</p>");

out.println("</body></html>");

out.close();

private String generateSessionId() {

// Generate a unique session ID

// For simplicity, using a random alphanumeric string

// In a real application, use a more robust session ID generation mechanism

return UUID.randomUUID().toString();

}2. URL Rewriting:

 URL rewriting involves appending session information to URLs as query parameters.

 Servlets can append session IDs or other session-related data to hyperlinks and form actions.

 Example:

import javax.servlet.*;

import javax.servlet.annotation.WebServlet;

import javax.servlet.http.*;

import java.io.*;
@WebServlet("/UrlRewritingSessionDemo")

public class UrlRewritingSessionDemo extends HttpServlet {

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws

ServletException, IOException {

// Retrieve existing session ID or generate a new one

HttpSession session = request.getSession(true);

String sessionId = session.getId();

// Use session ID to store and retrieve session data

Integer visitCount = (Integer) session.getAttribute("visitCount");

if (visitCount == null) {

visitCount = 1;

} else {

visitCount++;

session.setAttribute("visitCount", visitCount);

// Display visit count

response.setContentType("text/html");

PrintWriter out = response.getWriter();

out.println("<html><body>");

out.println("<h1>URL Rewriting Session Demo</h1>");

out.println("<p>Number of visits: " + visitCount + "</p>");

out.println("<a href=\"UrlRewritingSessionDemo?sessionId=" + sessionId + "\">Increment Visit

Count</a>");

out.println("</body></html>");

out.close();

3. Hidden Form Fields:

 Hidden form fields can be used to store session information within HTML forms.
  Servlets can include hidden input fields in HTML forms to carry session identifiers or other
session-related data.

 Example:

import javax.servlet.*;

import javax.servlet.annotation.WebServlet;

import javax.servlet.http.*;

import java.io.*;

@WebServlet("/HiddenFormFieldSessionDemo")

public class HiddenFormFieldSessionDemo extends HttpServlet {

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws

ServletException, IOException {

// Retrieve existing session ID or generate a new one

HttpSession session = request.getSession(true);

String sessionId = session.getId();

// Use session ID to store and retrieve session data

Integer visitCount = (Integer) session.getAttribute("visitCount");

if (visitCount == null) {

visitCount = 1;

} else {

visitCount++;

session.setAttribute("visitCount", visitCount);

// Display visit count and include hidden form field

response.setContentType("text/html");

PrintWriter out = response.getWriter();

out.println("<html><body>");

out.println("<h1>Hidden Form Field Session Demo</h1>");

out.println("<form action=\"HiddenFormFieldSessionDemo\" method=\"post\">");

out.println("<input type=\"hidden\" name=\"sessionId\" value=\"" + sessionId + "\">");

 out.println("<p>Number of visits: " + visitCount + "</p>");

out.println("<input type=\"submit\" value=\"Increment Visit Count\">");

out.println("</form>");

out.println("</body></html>");

out.close();

protected void doPost(HttpServletRequest request, HttpServletResponse response) throws

ServletException, IOException {

doGet(request, response);

11. What is session object in JSP? Explain it with example.

In JSP (JavaServer Pages), the session object is an implicit object provided by the JSP container that
represents an HTTP session between a client and a web server. The session object allows JSP pages
to maintain stateful information across multiple requests from the same client. It provides methods
for storing, retrieving, and managing session attributes, which are key-value pairs containing data
associated with the session.

Here's an example demonstrating the use of the session object in a JSP page:

<%@ page contentType="text/html;charset=UTF-8" language="java" %>

<html>

<head>

<title>Session Example</title>

</head>

<body>

<%

// Retrieve existing session object or create a new one if it doesn't exist

HttpSession session = request.getSession(true);

// Get session attribute or set default value if attribute doesn't exist

Integer visitCount = (Integer) session.getAttribute("visitCount");

if (visitCount == null) {
 visitCount = 1;

} else {

visitCount++;

// Set session attribute with updated value

session.setAttribute("visitCount", visitCount);

%>

<h1>Session Example</h1>

<p>Welcome to our website!</p>

<p>You have visited this page <%= visitCount %> times.</p>

</body>

</html>

In this example:

1. We retrieve the session object using request.getSession(true), which returns the existing
session associated with the client or creates a new session if one doesn't exist.

2. We retrieve the session attribute named "visitCount" using

session.getAttribute("visitCount"). If the attribute doesn't exist, we initialize it to 1.

3. We increment the value of the "visitCount" attribute.

4. We set the updated value of the "visitCount" attribute back into the session using
session.setAttribute("visitCount", visitCount).

5. We use scriptlet tags (<% %>), which allow us to embed Java code directly into the JSP page,
to access the session object and display the visit count.

12. Write a Servlet Registration to get the values from registration.html

html page and display the contents. Write the web.xml file.

Here's an example of a Servlet registration to handle form submission from a registration.html page
and display the submitted contents:

1. Servlet Registration (RegistrationServlet.java):

import java.io.IOException;

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("/registration")

public class RegistrationServlet extends HttpServlet {

protected void doPost(HttpServletRequest request, HttpServletResponse response) throws

ServletException, IOException {

// Retrieve form parameters

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

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

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

// Display registration details

response.setContentType("text/html");

response.getWriter().println("<html><body>");

response.getWriter().println("<h1>Registration Details</h1>");

response.getWriter().println("<p>First Name: " + firstName + "</p>");

response.getWriter().println("<p>Last Name: " + lastName + "</p>");

response.getWriter().println("<p>Email: " + email + "</p>");

response.getWriter().println("</body></html>");

registration.html (the HTML form for user registration):

<!DOCTYPE html>

<html>

<head>

<title>User Registration</title>

</head>

<body>

<h1>User Registration</h1>

<form action="registration" method="post">

 <label for="firstName">First Name:</label>

<input type="text" id="firstName" name="firstName"><br>

<label for="lastName">Last Name:</label>

<input type="text" id="lastName" name="lastName"><br>

<label for="email">Email:</label>

<input type="email" id="email" name="email"><br>

<input type="submit" value="Submit">

</form>

</body>

</html>

web.xml (deployment descriptor specifying servlet mapping):

<?xml version="1.0" encoding="UTF-8"?>

<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"

version="4.0">

<servlet>

<servlet-name>RegistrationServlet</servlet-name>

<servlet-class>RegistrationServlet</servlet-class>

</servlet>

<servlet-mapping>

<servlet-name>RegistrationServlet</servlet-name>

<url-pattern>/registration</url-pattern>

</servlet-mapping>

</web-app>
13. Write a Login Servlet. Take input username and password from html
file login.html and write the web.xml
Here's an example of a Login Servlet that handles user authentication based on a username and
password input from an HTML form (login.html), along with the corresponding web.xml
configuration:

1. Login Servlet (LoginServlet.java):

import java.io.IOException;

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("/login")

public class LoginServlet extends HttpServlet {

protected void doPost(HttpServletRequest request, HttpServletResponse response) throws

ServletException, IOException {

// Retrieve form parameters

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

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

// Perform authentication (dummy example)

boolean isAuthenticated = authenticate(username, password);

// Display authentication result

response.setContentType("text/html");

if (isAuthenticated) {

response.getWriter().println("<html><body>");

response.getWriter().println("<h1>Login Successful</h1>");

response.getWriter().println("<p>Welcome, " + username + "!</p>");

response.getWriter().println("</body></html>");

} else {
 response.getWriter().println("<html><body>");

response.getWriter().println("<h1>Login Failed</h1>");

response.getWriter().println("<p>Invalid username or password.</p>");

response.getWriter().println("</body></html>");

// Dummy authentication method (replace with actual authentication logic)

private boolean authenticate(String username, String password) {

// In a real application, perform authentication against a database or other authentication

mechanism

// For demonstration purposes, we'll use hardcoded credentials

return "admin".equals(username) && "password".equals(password);

login.html (the HTML form for user login):

<!DOCTYPE html>

<html>

<head>

<title>User Login</title>

</head>

<body>

<h1>User Login</h1>

<form action="login" method="post">

<label for="username">Username:</label>

<input type="text" id="username" name="username"><br>

<label for="password">Password:</label>

<input type="password" id="password" name="password"><br>

<input type="submit" value="Login">

 </form>

</body>

</html>

web.xml (deployment descriptor specifying servlet mapping):

<?xml version="1.0" encoding="UTF-8"?>

<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"

version="4.0">

<servlet>

<servlet-name>LoginServlet</servlet-name>

<servlet-class>LoginServlet</servlet-class>

</servlet>

<servlet-mapping>

<servlet-name>LoginServlet</servlet-name>

<url-pattern>/login</url-pattern>

</servlet-mapping>

</web-app>

14. Write a JSP page of Student Information.

<%@ page contentType="text/html;charset=UTF-8" language="java" %>

<html>

<head>

<title>Student Information</title>

</head>

<body>

<h1>Student Information</h1>

<%-- Sample student data (replace with actual data) --%>

<% String studentName = "John Doe"; %>

 <% String studentId = "S123456"; %>

<% String department = "Computer Science"; %>

<% int year = 2; %>

<% String email = "[email protected]"; %>

<table border="1">

<tr>

<td><b>Name:</b></td>

<td><%= studentName %></td>

</tr>

<tr>

<td><b>Student ID:</b></td>

<td><%= studentId %></td>

</tr>

<tr>

<td><b>Department:</b></td>

<td><%= department %></td>

</tr>

<tr>

<td><b>Year:</b></td>

<td><%= year %></td>

</tr>

<tr>

<td><b>Email:</b></td>

<td><%= email %></td>

</tr>

</table>

</body>

</html>
15. Explain JSP Tag library.
A JSP (JavaServer Pages) tag library, often referred to simply as a tag library or custom tag library, is a
collection of reusable components (tags) that encapsulate complex behavior and functionality in JSP
pages. Tag libraries allow developers to extend the capabilities of JSP by providing a higher level of
abstraction, promoting code reuse, and enhancing maintainability.

Here are the key components and concepts related to JSP tag libraries:

1. Custom Tags:

 Custom tags are user-defined tags that provide specialized functionality beyond
what standard JSP tags offer.

 Custom tags can be defined using the JSP Tag Library Descriptor (TLD) file and
implemented as Java classes.

 Custom tags can encapsulate complex logic, HTML generation, database access, or
any other functionality required in a web application.

2. Tag Library Descriptor (TLD):

 The Tag Library Descriptor (TLD) file is an XML file that describes the structure and
behavior of a tag library.

 The TLD file defines the tag names, attributes, and tag handlers associated with the
custom tags in the library.

 It also provides information about tag documentation, tag attributes, and tag
handlers.

3. Tag Handler:

 A tag handler is a Java class that implements the behavior of a custom tag.

 Tag handlers are responsible for processing the custom tag's attributes, generating
output, and performing any necessary actions during tag execution.

 Tag handlers typically extend the javax.servlet.jsp.tagext.TagSupport class or

implement the javax.servlet.jsp.tagext.SimpleTag interface.

4. Tag Library URI:

 The Tag Library URI (Uniform Resource Identifier) is a unique identifier used to
reference a tag library within JSP pages.

 It serves as a namespace for the custom tags defined in the tag library.

 The Tag Library URI is specified in the JSP page using the <%@ taglib %> directive.

5. Tag Library Descriptor Example:

 Here's an example of a simple TLD file defining a custom tag library with a single
custom tag:

<?xml version="1.0" encoding="UTF-8"?>

<taglib xmlns="http://java.sun.com/xml/ns/javaee"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-jsptaglibrary_3_0.xsd"

version="3.0">

<tlib-version>1.0</tlib-version>

<short-name>example</short-name>

<uri>http://example.com/tags</uri>

<tag>

<name>customTag</name>

<tag-class>com.example.CustomTagHandler</tag-class>

<body-content>empty</body-content>

<attribute>

<name>message</name>

<required>true</required>

<rtexprvalue>true</rtexprvalue>

</attribute>

</tag>

</taglib>

Using Custom Tags in JSP:

 To use custom tags in a JSP page, you need to include the tag library directive at the
beginning of the page using the <%@ taglib %> directive.

 Once imported, you can use custom tags within the JSP page by specifying their tag names
and attributes.

 Custom tags can encapsulate complex functionality and provide a cleaner and more
maintainable way to organize and reuse code in JSP pages.

16. Explain the action tags used to access the JavaBeans from a JSP page
with example.

In JSP (JavaServer Pages), action tags are used to perform various tasks within a JSP page, including
accessing JavaBeans (POJOs representing data) and invoking their methods. The key action tags used
for accessing JavaBeans from a JSP page are <jsp:useBean>, <jsp:setProperty>, and
<jsp:getProperty>. Let's discuss each of these action tags with examples:

1. <jsp:useBean>:
The <jsp:useBean> action tag is used to instantiate or locate a JavaBean in a JSP page.

Syntax:

jspCopy code

<jsp:useBean id="beanName" class="fullyQualifiedClassName" scope="scope" />

Attributes:

 id: Name used to refer to the JavaBean within the JSP page.

 class: Fully qualified class name of the JavaBean to instantiate.

 scope: Optional attribute specifying the scope (page, request, session, or application) in
which the JavaBean should be stored.

Example:

jspCopy code

<jsp:useBean id="user" class="com.example.User" scope="session" />

2. <jsp:setProperty>:

The <jsp:setProperty> action tag is used to set property values of a JavaBean.

Syntax:

jspCopy code

<jsp:setProperty name="beanName" property="propertyName" value="propertyValue" />

Attributes:

 name: Name of the JavaBean to set properties for (specified in <jsp:useBean>).

 property: Name of the property to set.

 value: Value to set for the property (optional if using <jsp:getProperty>).

Example:

jspCopy code

<jsp:setProperty name="user" property="firstName" value="John" />

3. <jsp:getProperty>:

The <jsp:getProperty> action tag is used to retrieve property values from a JavaBean and display
them in the JSP page.

Syntax:

jspCopy code

<jsp:getProperty name="beanName" property="propertyName" />

Attributes:

 name: Name of the JavaBean to get properties from (specified in <jsp:useBean>).

  property: Name of the property to retrieve.

Example:

jspCopy code

<%= user.getFirstName() %>

<jsp:getProperty name="user" property="lastName" />

Example JSP Page:

jspCopy code

<%@ page contentType="text/html;charset=UTF-8" language="java" %>

<%@ page import="com.example.User" %>

<html>

<head>

<title>JavaBean Example</title>

</head>

<body>

<jsp:useBean id="user" class="com.example.User" scope="session" />

<jsp:setProperty name="user" property="firstName" value="John" />

<jsp:setProperty name="user" property="lastName" value="Doe" />

<h1>User Information</h1>

<p>First Name: <%= user.getFirstName() %></p>

<p>Last Name: <jsp:getProperty name="user" property="lastName" /></p>

</body>

</html>

In this example:

 We instantiate a User JavaBean using <jsp:useBean> and set its properties (firstName and
lastName) using <jsp:setProperty>.

 We retrieve and display the property values using scriptlet tags (<%= %>) and
<jsp:getProperty>.

17. Explain the features of core tag library for JSP.

The JSTL (JavaServer Pages Standard Tag Library) Core Tag Library provides a set of tags that simplify
common tasks in JSP pages, such as iteration, conditional processing, URL management, and
formatting. Here are the key features of the Core Tag Library for JSP:
1. Iteration Tags:

 <c:forEach>: Iterates over a collection or array, executing the body of the tag for
each element.

 <c:forTokens>: Iterates over a delimited string, splitting it into tokens and executing
the body of the tag for each token.

2. Conditional Tags:

 <c:if>: Evaluates a boolean condition and executes the body of the tag if the
condition is true.

 <c:choose>, <c:when>, <c:otherwise>: Provides support for switch-case-like

conditional processing.

3. URL Management Tags:

 <c:import>: Includes the content of an external resource (such as a JSP page or a

text file) in the current JSP page.

 <c:param>: Adds request parameters to a URL, typically used within <c:url>.

4. Variable Management Tags:

 <c:set>: Sets the value of a scoped variable (page, request, session, or application).

 <c:remove>: Removes a scoped variable from the specified scope.

5. Flow Control Tags:

 <c:redirect>: Redirects the client to a new URL.

 <c:catch>: Catches any Throwable thrown during the execution of its body and
optionally exposes it as a scoped variable.

6. Formatting Tags:

 <fmt:formatDate>: Formats a date according to a specified pattern and locale.

 <fmt:formatNumber>: Formats a number according to a specified pattern and

locale.

7. Localization Tags:

 <fmt:setLocale>: Sets the locale for formatting and parsing dates, numbers, and
messages.

 <fmt:setBundle>: Specifies the resource bundle to use for localization.

8. Escape and URL Encoding Tags:

 <c:out>: Escapes HTML and XML characters in the output, preventing XSS (Cross-Site
Scripting) attacks.

 <c:url>: Encodes URL parameters to ensure proper URL formatting.

9. Miscellaneous Tags:
  <c:catch>: Catches exceptions thrown during tag execution.

 <c:when>: Used within a <c:choose> tag to define conditional blocks.

 <c:otherwise>: Used within a <c:choose> tag to define the default condition block.

18. Explain use of <jsp:useBean> action tag with example.

The <jsp:useBean> action tag is used to either instantiate or locate a JavaBean within a JSP page.
This tag simplifies the process of creating or accessing JavaBeans, which are plain Java objects used
to encapsulate and manage data within a web application. Here's how the <jsp:useBean> action tag
is used, along with an example:

<jsp:useBean id="beanName" class="fullyQualifiedClassName" scope="scope" />

Attributes:

 id: Specifies the name by which the JavaBean will be referred to within the JSP page.

 class: Specifies the fully qualified class name of the JavaBean to be instantiated.

 scope: Optional attribute specifying the scope (page, request, session, or application) in
which the JavaBean should be stored.

Example:

Suppose we have a simple JavaBean named User that represents user information:

package com.example;

public class User {

private String username;

private String email;

// Getters and setters

public String getUsername() {

return username;

public void setUsername(String username) {

this.username = username;

public String getEmail() {

 return email;

public void setEmail(String email) {

this.email = email;

19. List JSP implicit objects and explain any two.

JSP (JavaServer Pages) implicit objects are predefined objects provided by the JSP container that are
available for use without any declaration. These objects represent various components of the JSP
environment and can be accessed directly within JSP pages. Here is a list of common JSP implicit
objects:

1. request: Represents the HTTP request made by the client to the server.

2. response: Represents the HTTP response sent by the server to the client.

3. out: Represents the output stream for sending content to the client.

4. session: Represents the HTTP session associated with the client, allowing data to be
maintained across multiple requests.

5. application: Represents the ServletContext object, providing access to application-wide

resources and configuration parameters.

6. config: Represents the ServletConfig object, providing access to initialization parameters

specified in the deployment descriptor.

7. page: Represents the JSP page itself as a Servlet instance.

8. pageContext: Represents the PageContext object, providing access to various objects and
attributes related to the JSP page.

9. exception: Represents the exception thrown during the execution of the JSP page.

Now, let's explain two of these implicit objects:

1. request:

The request implicit object represents the HTTP request made by the client to the server. It provides
access to information sent by the client, such as form parameters, query string parameters, headers,
and cookies. Developers commonly use this object to retrieve user input and interact with the
client's request.

Example:

jspCopy code

<p>Client's IP Address: <%= request.getRemoteAddr() %></p>

In this example, we use the getRemoteAddr() method of the request object to retrieve the IP
address of the client making the request.

2. session:

The session implicit object represents the HTTP session associated with the client. It allows data to
be maintained across multiple requests from the same client. This object is commonly used to store
user-specific data or state information throughout a user's interaction with the application.

Example:

<%

// Storing user's name in the session

String username = "John";

session.setAttribute("username", username);

%>

In this example, we store the user's name in the session using the setAttribute() method of the
session object. This allows us to access and retrieve the user's name across multiple requests during
the same session.

These are just two examples of JSP implicit objects, but each of the implicit objects provides valuable
functionality and access to different aspects of the JSP environment, enabling developers to build
dynamic and interactive web applications efficiently.

20. Write a servlet which counts the number of digits into an integer
received as parameter.Give the necessary web.xml file to deploy the
servlet.
Here's a servlet code that counts the number of digits in an integer received as a parameter:

import java.io.*;

import javax.servlet.*;

import javax.servlet.http.*;

public class DigitCounterServlet extends HttpServlet {

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws

ServletException, IOException {

// Get the integer parameter from the request

String numberString = request.getParameter("number");

// Validate if the parameter is not null and is a valid integer

if (numberString != null && numberString.matches("\\d+")) {

 // Convert the string to an integer

int number = Integer.parseInt(numberString);

// Count the number of digits

int digitCount = String.valueOf(number).length();

// Send the response

response.setContentType("text/html");

PrintWriter out = response.getWriter();

out.println("<html><body>");

out.println("<h2>Digit Counter Servlet</h2>");

out.println("<p>Number: " + number + "</p>");

out.println("<p>Number of Digits: " + digitCount + "</p>");

out.println("</body></html>");

} else {

// If the parameter is invalid, send an error response

response.sendError(HttpServletResponse.SC_BAD_REQUEST, "Invalid number parameter");

To deploy this servlet, you also need to configure the web.xml deployment descriptor file. Here's the
web.xml file:

<?xml version="1.0" encoding="UTF-8"?>

<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"

version="4.0">

<servlet>

<servlet-name>DigitCounterServlet</servlet-name>

<servlet-class>DigitCounterServlet</servlet-class>
 </servlet>

<servlet-mapping>

<servlet-name>DigitCounterServlet</servlet-name>

<url-pattern>/countDigits</url-pattern>

</servlet-mapping>

</web-app>

21. List the servlet session level events and show that how servlet
destroy event is handled?
In Java servlets, session-level events allow developers to track and respond to changes in session
state. These events are fired by the servlet container (e.g., Apache Tomcat) at various points during
the lifecycle of a session. The following are the session-level events in servlets:

1. Session Creation Event (HttpSessionListener.sessionCreated(HttpSessionEvent event)):

 This event is triggered when a new session is created by the servlet container.

 It provides access to the HttpSession object associated with the newly created
session.

2. Session Destruction Event (HttpSessionListener.sessionDestroyed(HttpSessionEvent

event)):

 This event is triggered when an existing session is invalidated or times out.

 It provides access to the HttpSession object associated with the session being
destroyed.

Now, let's demonstrate how to handle the servlet destroy event:

import javax.servlet.*;

import javax.servlet.http.*;

public class MyServletContextListener implements ServletContextListener {

public void contextInitialized(ServletContextEvent event) {

// Servlet context initialization logic (if any)

public void contextDestroyed(ServletContextEvent event) {

// Servlet context destruction logic (if any)

 }

public class MyHttpSessionListener implements HttpSessionListener {

public void sessionCreated(HttpSessionEvent event) {

// Session creation logic (if any)

public void sessionDestroyed(HttpSessionEvent event) {

// Session destruction logic

HttpSession session = event.getSession();

String sessionId = session.getId();

// Perform cleanup tasks or logging

System.out.println("Session destroyed: " + sessionId);

22. Write a JSP page that prints your resume in well formatted form.
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>

<!DOCTYPE html>

<html>

<head>

<meta charset="UTF-8">

<title>Resume</title>

<style>

body {

font-family: Arial, sans-serif;

margin: 0;

padding: 0;

.container {

max-width: 800px;
 margin: 0 auto;

padding: 20px;

background-color: #f9f9f9;

h1, h2, h3 {

color: #333;

margin-bottom: 10px;

p{

margin: 5px 0;

.section {

margin-bottom: 20px;

.section h2 {

border-bottom: 2px solid #ccc;

padding-bottom: 5px;

margin-bottom: 10px;

.experience {

margin-left: 20px;

.experience p {

margin: 5px 0;

</style>

</head>

<body>

<div class="container">

<h1>John Doe</h1>
 <p>Email: [email protected] | Phone: (123) 456-7890 | LinkedIn:
linkedin.com/in/johndoe</p>

<div class="section">

<h2>Summary</h2>

<p>An experienced software engineer with expertise in Java, JavaScript, and SQL. Strong
problem-solving skills and a passion for learning new technologies.</p>

</div>

<div class="section">

<h2>Experience</h2>

<div class="experience">

<h3>Software Engineer, ABC Software Inc.</h3>

<p>July 2018 - Present</p>

<ul>

<li>Developed web applications using Java, Spring Framework, and Hibernate.</li>

<li>Designed and implemented RESTful APIs for communication with frontend

applications.</li>

<li>Collaborated with cross-functional teams to deliver high-quality software

products.</li>

</ul>

</div>

<div class="experience">

<h3>Software Developer Intern, XYZ Corporation</h3>

<p>January 2017 - May 2017</p>

<ul>

<li>Assisted in the development of a mobile application using React Native.</li>

<li>Participated in code reviews and contributed to team discussions on software

design.</li>

</ul>

</div>

</div>
 <div class="section">

<h2>Education</h2>

<p>Bachelor of Science in Computer Science</p>

<p>University of Example, Graduated May 2018</p>

</div>

</div>

</body>

</html>

23. What are cookies? Write a servlet that reads and prints all the
previous cookies and add a cookie with your name.
Cookies are small pieces of data stored on the client's machine by the web browser. They are
commonly used to store user-specific information or to track user behavior across multiple requests
and sessions. Cookies are sent from the client to the server with every HTTP request, allowing the
server to access and modify the data stored in the cookie.

Here's a servlet that reads and prints all the previous cookies and adds a new cookie with your
name:

import java.io.*;

import javax.servlet.*;

import javax.servlet.http.*;

public class CookieServlet extends HttpServlet {

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws

ServletException, IOException {

// Retrieve all cookies from the request

Cookie[] cookies = request.getCookies();

response.setContentType("text/html");

PrintWriter out = response.getWriter();

out.println("<html><body>");

out.println("<h1>Previous Cookies:</h1>");

if (cookies != null) {
 for (Cookie cookie : cookies) {

out.println("<p>Name: " + cookie.getName() + ", Value: " + cookie.getValue() + "</p>");

} else {

out.println("<p>No previous cookies found.</p>");

// Add a new cookie with your name

Cookie myCookie = new Cookie("MyName", "Your Name");

response.addCookie(myCookie);

out.println("<p>New cookie added with your name.</p>");

out.println("</body></html>");

24. Write a servlet which accept two numbers using POST methods and
display the maximum of them.
import java.io.*;

import javax.servlet.*;

import javax.servlet.http.*;

public class MaxNumberServlet extends HttpServlet {

protected void doPost(HttpServletRequest request, HttpServletResponse response) throws

ServletException, IOException {

// Get the parameters (numbers) from the request

int number1 = Integer.parseInt(request.getParameter("number1"));

int number2 = Integer.parseInt(request.getParameter("number2"));

// Find the maximum of the two numbers

int maxNumber = Math.max(number1, number2);

 // Set the content type of the response

response.setContentType("text/html");

// Write the response

PrintWriter out = response.getWriter();

out.println("<html><body>");

out.println("<h1>Maximum Number</h1>");

out.println("<p>Number 1: " + number1 + "</p>");

out.println("<p>Number 2: " + number2 + "</p>");

out.println("<p>Maximum Number: " + maxNumber + "</p>");

out.println("</body></html>");