AJ ANSWER BANK

Unit-5

1Draw the JSF request processing life cycle and briefly give the function of
each phase.
Ans:

● JSFapplication lifecycle consist of six phases which are as follows:

1. Phase-I: Restore View (RV)
2. Phase-II: Apply Request Values (ARV)
3. Phase-III: Process Validations (PV)
4. Phase-IV: Update Model Values (UMV)
5. Phase-V: Invoke Application (IA)
6. Phase-VI: Render Response (RR)

Phase 1: Restore view

● JSF begins the restore view phase as soon as a link or a button is
clicked and JSF receives a request.

Phase 2: Apply request values

● In this phase, the values that are entered by the user will be updated on
each and every individual component defined in the View graph.

Phase 3: Process validation

● This Phase will process any Validations that are configured for UI
Components.

Phase 4: Update model values

● After the JSF checks that the data is valid, it walks over the component
tree and set the corresponding server-side object properties to the
component’s local values.

Phase 5: Invoke application

 ● During this phase, the JSF handles any application-level events, such
as submitting a form / linking to another page.

Phase 6: Render response

● And finally, we have reached the Render Response whose job is to
render the response back the Client Application.

2 List the JSF validation tags and explain any two.

Ans:

f:validateLength
1
Validates the length of a string

f:validateLongRange
2
Validates the range of a numeric value

f:validateDoubleRange
3
Validates the range of a float value

f:validateRegex
4
Validates JSF component with a given regular expression

Custom Validator
5
Creates a custom validator
JSF Tag
<f:validateLength minimum = "5" maximum = "8" />

Tag Attributes
S.No Attribute & Description

minimum
1
A String with a minimum number of characters

maximum
2
A String with a maximum number of characters

f:validateLongRange tag is used to validate the long value in a particular range.

JSF Tag
<f:validateLongRange minimum = "5" maximum = "200" />

Tag Attributes
S.No Attribute & Description

minimum
1
Minimum long value within an optional range
 maximum
2
Maximum long value within an optional range

3 Explain JSF Event Handling and Database Access.

Ans:

● When a user clicks a JSF button or link or changes any value in the text field, JSF
UI component fires an event, which will be handled by the application code.
● To handle such an event, an event handler is to be registered in the application
code.
● When a UI component checks that a user event has occurred, it creates an

instance of the corresponding event class and adds it to an event list.

● Then, Component fires the event, i.e., checks the list of listeners for that event

and calls the event notification method on each listener or handler.

● JSF also provides system level event handlers, which can be used to perform

some tasks when the application starts or is stopping.

Following are some important Event Handler in JSF 2.0 −

valueChangeListener

Value change events get fired when the user makes changes in input

components.

actionListener

Action events get fired when the user clicks a button or link component.
 Application Events

Events firing during JSF lifecycle: PostConstructApplicationEvent,

PreDestroyApplicationEvent , PreRenderViewEvent.

4 Explain JSF Libraries.

Ans:

Libraries provide additional features, components, and utilities that extend the
capabilities of JSF and help developers build robust and interactive web applications
more efficiently.

Here are some commonly used JSF libraries:

1. PrimeFaces: PrimeFaces is a popular JSF component library that offers a wide

range of feature-rich UI components and advanced functionalities.
2. OmniFaces: OmniFaces is a utility library for JSF that provides various utility
classes, components, and validators.
3. BootsFaces: BootsFaces is a JSF library that integrates JSF with the Bootstrap
front-end framework.
4. PrettyFaces: PrettyFaces is a URL mapping library for JSF that simplifies the
management of clean, SEO-friendly URLs.

5 Explain JSF Standard Components in detail.

Ans:

● A JSF standard component is a reusable UI component that is provided by the

JavaServer Faces (JSF) framework.
● JSF standard components are used to create a variety of user interfaces,
including forms, tables, and menus.
● JSF standard components are based on the HTML DOM model, which means
that they can be used to create web pages that are compatible with all major
browsers.
● JSF standard components also support a variety of features, such as validation,
internationalization, and accessibility.
Some of the most commonly used JSF standard components include:

● h:inputText: A text input field

● h:outputText: A text output field
● h:form: A form component

6 Write a short note on JSF Facelets. List the JSF facelets tags and explain any two.
Ans:

● JSF Facelets is a view technology that is used to create JavaServer Faces (JSF)
views.
● Facelets is based on XHTML, which is a markup language that is based on XML.
● Facelets pages are compiled into component trees, which are then rendered by
the JSF implementation.

Following are important Facelets Tags:

Templates

We'll demonstrate how to use templates using the following tags

<ui:insert>
1
<ui:define>

<ui:include>

<ui:composition>

Parameters

We'll demonstrate how to pass parameters to a template file using the

2 following tag

<ui:param>
 Custom
3
We'll demonstrate how to create custom tags

Remove
4
We'll demonstrate capability to remove JSF code from generated HTML page

Custom tag:

JSF provides the developer with a powerful capability to define own custom tags,

which can be used to render custom contents.

Defining a custom tag in JSF is a three-step process.

Step Description

1a Create a xhtml file and define contents in it using ui:composition tag

Create a tag library descriptor (.taglib.xml file) and declares the above
1b
custom tag in it.

1c Register the tag libray descriptor in web.xml

Remove tag:

● ui:remove tag is used to prevent the JSF specific code to be rendered on

the client side.
● It is used especially to prevent commented out code to be rendered on the
client side.

7 What is the JSF tag library? Explain any four html tag.
Ans:
● JSF framework provides a standard HTML tag library.
● Each tag will rendered into corresponding html output.
● Two types of JSF Tag library
○ <%@taglib uri=" http://java.sun.com/jsf/core" prefix=" f" %>
○ <%@taglib uri=" http://java.sun.com/jsf/html" prefix=" h" %>

Sr JSF Tag HTML Tag

1 h:inputText HTML input of type="text"

2 h:inputSecret HTML input of type="password",

3 h:inputHidden HTML input of type="hidden".

4 h:selectMany Checkbox A group of HTML check boxes

5 h:selectOne Listbox Single HTML list box

8 Explain working of JSF expression language.

Ans:

● The JSF Expression Language (EL) is a powerful tool that can be used to access
and manipulate data in JSF applications.
● EL expressions are written in a simple syntax that is similar to Java.
● JSF provides a rich expression language.
● We can write normal operations using #{operation-expression} notation.

Following are some of the advantages of JSF Expression languages:

● Provides easy access to elements of a collection which can be a list, map or an

array.
 ● Provides easy access to predefined objects such as a request.

● Arithmetic, logical and relational operations can be done using expression

language.

● Automatic type conversion.

● Shows missing values as empty strings instead of NullPointerException.

Unit-7

1 Explain architecture of Spring MVC Framework.

Ans:

The Spring MVC framework is a Java framework that is used to develop web
applications. It is built on the Model-View-Controller (MVC) design pattern, which
separates the application's concerns into three parts:

● Model: The model represents the application's data.

● View: The view is responsible for displaying the model data to the user.
● Controller: The controller handles user requests and updates the model data.

The Spring MVC framework provides a number of components that make it easy
to develop web applications using the MVC pattern. These components include:

● Controllers: Controllers are responsible for handling user requests and updating
the model data.
● Views: Views are responsible for displaying the model data to the user.
● Handlers: Handlers are responsible for mapping requests to controllers.
● Validators: Validators are responsible for validating model objects.

2 What is Spring Web MVC framework? List its key features.

Ans:

Spring Web MVC is a Java framework that is used to develop web applications.
It is built on the Model-View-Controller (MVC) design pattern, which separates the
application's concerns into three parts:

● Model: The model represents the application's data.

● View: The view is responsible for displaying the model data to the user.
● Controller: The controller handles user requests and updates the model data.

Spring Web MVC also provides a number of features that make it easy to develop web
applications, such as:

● Internationalization: Spring Web MVC supports internationalization, which allows

you to develop web applications that can be used by users from different
countries.
● Security: Spring Web MVC supports security, which allows you to protect your
web applications from unauthorized access.
● Testing: Spring Web MVC supports testing, which allows you to test your web
applications to ensure that they work correctly.

3 Write Spring bean life cycle.

Ans:

The following are the steps in the Spring bean life cycle:

1. Instantiation: The first step in the life cycle of a bean is instantiation. The Spring
IoC container instantiates the bean using the configured bean definition.
2. BeanPostProcessors: After the bean is instantiated, it is passed to any
registered BeanPostProcessors. BeanPostProcessors can modify the bean
before it is initialized.
3. Initialization: The next step in the life cycle of a bean is initialization. The bean is
initialized by calling its init() method. The init() method is called by the Spring IoC
container.
4. Use: After the bean is initialized, it is ready to be used. The bean can be used by
other beans or by the application code.
5. Destruction: When the bean is no longer needed, it is destroyed by the Spring
IoC container. The Spring IoC container calls the bean's destroy() method to
destroy the bean.
4 Explain Managing Transaction.
Ans:
● Transaction management is the process of ensuring that all of the operations
within a single transaction are either all committed or all rolled back.
● This ensures that the database remains in a consistent state, even if an error
occurs during the transaction.

There are two main types of transactions:

● Local transactions: Local transactions are managed by the application itself.

● Distributed transactions:Distributed transactions are managed by a transaction
manager.

There are two main types of transactions:

● Local transactions: Local transactions are managed by the application itself. The
application code must explicitly start and end the transaction.
● Distributed transactions: Distributed transactions involve multiple resources, such
as databases and web services. Distributed transactions are managed by a
transaction manager.

The following are the steps involved in managing a transaction:

1. Start the transaction: This can be done explicitly by calling a method on the
transaction manager or implicitly by using a framework such as Spring.
2. Execute the operations: The next step is to execute the operations that are part
of the transaction.
3. Commit the transaction: If all of the operations succeed, the transaction is
committed.
4. Roll back the transaction: If an error occurs during the transaction, the
transaction is rolled back.

public class Student {

private int rollNo;

private String name;

 public int getRollNo() {

return rollNo;

public void setRollNo(int rollNo) {

this.rollNo = rollNo;

public String getName() {

return name;

public void setName(String name) {

this.name = name;

6 What is Spring IoC container.

Ans:

● The Spring IoC container is a central component of the Spring Framework.

● It is responsible for managing the objects in an application, including their
creation, configuration, and dependencies.

The Spring IoC container provides a number of features that make it an effective tool for
managing objects in an application. These features include:
 ● Object instantiation: The IoC container can automatically instantiate objects
based on their configuration.
● Object configuration: The IoC container can configure objects with properties
and annotations.
● Object dependency injection: The IoC container can inject dependencies into
objects at runtime.
● Object lifecycle management: The IoC container can manage the lifecycle of
objects, including their creation, destruction, and pooling.

unit-6

1 Explain Hibernate Architecture and Object Relational Mapping in Hibernate

with java code and required XML files.
Ans:

● Hibernate is an Object-Relational Mapping (ORM) framework for Java that

provides a high-level abstraction layer over the database.
● This allows developers to work with objects in Java instead of SQL
statements, which makes development much easier and more
maintainable.

Hibernate architecture consists of the following layers:

● Session Factory: The session factory is a central object in Hibernate that

provides access to the database.
● Session: A session is an object that represents a connection to the database.
● Transaction: A transaction is a unit of work that encompasses all of the changes
made to the database by a session.
● Object/Relational Mapping: Object/Relational Mapping (ORM) is the process of
mapping objects in Java to tables in a database.

2 Explain the OR mapping in hibernate.

Ans:

● Object-Relational (OR) mapping is a technique used to map objects in Java to

tables in a relational database.
 ● This allows developers to work with objects in Java instead of SQL statements,
which makes development much easier and more maintainable.
● Hibernate is an Object-Relational Mapping (ORM) framework for Java that
provides a high-level abstraction layer over the database.
● This allows developers to work with objects in Java instead of SQL statements,
which makes development much easier and more maintainable.
● Hibernate OR mapping is done using XML files.

3 What is HQL? How does it differ from SQL? Give its advantages.

Ans:

● HQL stands for Hibernate Query Language.

● It is a powerful object-oriented query language provided by the Hibernate
framework
● It is an Object-Relational Mapping (ORM) tool for Java.

Here are some key differences between HQL and SQL:

1. Object-oriented approach: HQL is designed to work with objects

2. Entity-based queries: With HQL, you can write queries using entity names
3. Syntax differences: HQL has a syntax similar to SQL but with some differences

Advantages of HQL:

● Object-oriented querying: HQL allows developers to express queries using the

object model of their application.
● Database portability: HQL provides a level of abstraction that allows you to write
database-independent queries.
● Object manipulation: HQL supports not only querying but also manipulation of
objects.

4 Give the hibernate architecture and discuss each part in brief.

ans:

Hibernate architecture consists of the following layers:

 ● Session Factory: The session factory is a central object in Hibernate that
provides access to the database.
● It is created once and reused throughout the application.
● Session: A session is a transient object that represents a connection to the
database.
● It is used to execute queries and persist objects.
● Transaction: A transaction is a unit of work that encompasses all of the changes
made to the database by a session.
● Transactions are used to ensure that all of the changes are committed to the
database or rolled back if an error occurs.
● Object/Relational Mapping: Object/Relational Mapping (ORM) is the process of
mapping objects in Java to tables in a database.
● Hibernate provides a powerful ORM engine that automatically maps objects to
tables and vice versa.

5 How can you implement OR Mapping in Hibernate? Give an example.

Ans:

● Hibernate Object-Relational (OR) mapping is a technique used to map objects in

Java to tables in a relational database.
● This allows developers to work with objects in Java instead of SQL statements,
which makes development much easier and more maintainable.
● To implement OR mapping in Hibernate, you need to create a mapping file that
defines the mapping between the Java objects and the database tables.

The mapping file is an XML file that contains the following elements:

● class: Defines the Java class that is being mapped to the database table.
● id: Defines the primary key of the table.
● property: Defines a column in the table and the corresponding property in the
Java class.

6 Write a note on hibernate.

Ans:

● Hibernate is an Object-Relational Mapping (ORM) framework for Java that

provides a high-level abstraction layer over the database.
● This allows developers to work with objects in Java instead of SQL statements,
which makes development much easier.
 ● Hibernate is a popular ORM framework and is used by many large and small
organizations.
● It is open source and free to use.

Here are some of the benefits of using Hibernate:

● Increased productivity: Hibernate can help you to increase your productivity by

eliminating the need to write SQL statements to access the database. This can
free you up to focus on other aspects of your application development.
● Reduced errors: Hibernate can help you to reduce errors by automatically
mapping Java objects to database tables. This can help to ensure that your data
is stored and retrieved correctly.
● Improved performance: Hibernate can help to improve the performance of your
application by using caching and other techniques to reduce the number of
database queries that are executed.

7 Draw and explain the architecture of Hibernate.

Ans: refer Q4 for theory

8 What is HQL? How is it different from SQL? List its advantages.
Ans:
Same as Q3

9 What is OR mapping? Give an example of a Hibernate XML mapping file.

Ans:
Refer Q2 for OR mapping

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

<hibernate-mapping package="com.example">
<class name="Person" table="person">
 <id name="id" column="id" type="integer" />
<property name="name" column="name" type="string" />
<property name="age" column="age" type="integer" />
</class>
</hibernate-mapping>

10 Explain use of DatabaseMetaData with an example.

Ans:

● The DatabaseMetaData interface provides information about the database that a

Java application is connected to.
● This information can be used to determine the capabilities of the database, such
as the types of data that can be stored in the database.
● DatabaseMetaData can be used to get information about many other aspects of
the database, such as the supported data types, the supported queries, and the
supported stored procedures.

The following are some of the methods that can be used to get information about the
database using DatabaseMetaData:

● getDatabaseProductName() - Gets the name of the database.

● getDatabaseProductVersion() - Gets the version of the database.
● getDriverName() - Gets the name of the driver that is being used to connect to
the database.
● getURL() - Gets the URL of the database.

11 What is ORM? Explain object/relational mappings in hibernate.

Ans:

Refer Q2/Q5

12 Discuss Hibernate Query Language.

Ans:
 ● Hibernate Query Language (HQL) is same as SQL (Structured Query Language)
but it doesn't depends on the table of the database.
● Instead of table name, we use class name in HQL. So it is database independent
query language.

Advantage of HQL

○ database independent

○ supports polymorphic queries

○ easy to learn for Java Programmer

The query interface provides many methods:

1. public int executeUpdate() is used to execute the update or delete query.

2. public List list() returns the result of the relation as a list.

13 What are the advantages of Hibernate over JDBC?

Ans:

- The advantages of Hibernate over JDBC are:

1. Hibernate code will work well for all databases, for ex: Oracle,MySQL, etc. whereas
JDBC is database specific.

2. No knowledge of SQL is needed because Hibernate is a set of objects and a table is

treated as an object, whereas to work with JDBC, one needs to know SQL.

3. Query tuning is not required in Hibernate. The query tuning is automatic in hibernate
by using criteria queries, and the result of performance is at its best. Whereas in JDBC
the query tuning is to be done by the database authors.

4. With the support of the cache of hibernate, the data can be placed in the cache for
better performance. Whereas in JDBC the java cache is to be implemented.
14 What is the difference between first level cache and second level cache.

Ans:

Sr. Key First level cache Second level cache

No
.

1 Basic First level cache is a Second level cache is session

session level cache and it factory level cache and it is

is always associated with available across all sessions

session level object

2 Enabled It is enabled by default. It is not enabled by default.

3 Availabilit It is available for a session It is available across all sessions.

4 Configurati No Extra configuration We have to decide which

on required concurrency strategy to use and

also need to configure cache

expiration and physical cache

attributes.
 Unit-3 New Questions

13 What is doFilter() method? What are its parameters? Give its use with proper
example.

Ans:

● The doFilter() method is a method in the javax.servlet.Filter

interface.
● The doFilter() method can be used to perform any kind of filtering on the
request and response.

The doFilter() method has three parameters:

● ServletRequest: This is the request object that contains the request

information from the client.
● ServletResponse: This is the response object that will be used to send the
response to the client.
● FilterChain: This is an object that allows the filter to pass the request and
response to the next filter in the chain.

For example, a filter could be used to:

● Authenticate the user.

● Check for malicious content.
● Encrypt the request or response.
● Log the request or response.

14 List out different types of servlet event and explain it.

Ans:

Here are the different types of servlet events:

Servlet context events

 ● ServletContextInitializedEvent is fired when the servlet context is initialized.
● ServletContextDestroyedEvent is fired when the servlet context is destroyed.
● ServletContextAttributeAddedEvent is fired when an attribute is added to the
servlet context.
● ServletContextAttributeRemovedEvent is fired when an attribute is removed from
the servlet context.

Session events

● HttpSessionCreatedEvent is fired when an HTTP session is created.

● HttpSessionDestroyedEvent is fired when an HTTP session is destroyed.
● HttpSessionBindingEvent is fired when an attribute is bound to an HTTP session.
● HttpSessionBindingUnboundEvent is fired when an attribute is unbound from an
HTTP session.

15 What is servlet filters? Give the necessary API for filters and explain their use

Ans:

A servlet filter is a Java class that intercepts HTTP requests and responses before they
are passed to a servlet. Filters can be used to perform a variety of tasks, such as:

● Authentication and authorization

● Logging
● Content filtering
● Performance optimization

17 Give the characteristics of the HTTP protocol and explain the GET, HEAD and PUT
methods of the HTTP protocol.

Ans:

Here are some of the characteristics of the HTTP protocol:

● Request-response: HTTP is a request-response protocol, which means that a

client sends a request to a server, and the server sends a response back to the
client..
 ● Caching: HTTP supports caching, which means that the client can store a copy
of a resource in its local cache. This can improve performance by reducing the
number of requests that need to be made to the server.
● Compression: HTTP supports compression, which can reduce the size of the
data that is transferred between the client and the server. This can improve
performance by reducing the amount of bandwidth that is used.

The GET, HEAD, and PUT methods are the most common HTTP methods.

● GET: The GET method is used to retrieve a resource from the server. The
resource can be a file, a web page, or any other type of data.
● HEAD: The HEAD method is similar to GET, but it only retrieves the headers of
the resource. The headers contain information about the resource, such as its
size and last modified date.
● PUT: The PUT method is used to create or update a resource on the server. The
resource can be a file, a web page, or any other type of data.

18 Explain MVC architecture in detail.

Ans:

MVC stands for Model-View-Controller. It is a software design pattern that separates the
application into three parts:

● Model: The model represents the data and business logic of the application.
● View: The view is responsible for displaying the data to the user.
● Controller: The controller receives user input and updates the model and view
accordingly.

● The MVC architecture is a popular choice for web applications because it makes
the code easier to maintain and test.
● It also makes it easier to scale the application, as each part can be independently
developed and deployed.
● The MVC architecture is a powerful tool that can be used to create complex and
scalable web applications.

Here are some of the benefits of using the MVC architecture:

 ● Separation of concerns: The MVC architecture separates the application into
three distinct parts, each with its own responsibility. This makes the code easier
to understand, maintain, and test.
● Scalability: The MVC architecture is designed to be scalable.
● Reusability: The MVC architecture makes it easy to reuse code in different
applications.

19 What is Request Dispatcher? What is the difference between Request dispatcher’s

forward() and include() method?

Ans:

A request dispatcher is an object that allows a servlet to forward or include another

resource in the response.

Feature includ forwar

e() d()

Includes the content of the target resource in the Yes No

response of the current resource

Forwards the request to the target resource No Yes

Processes the current resource after forwarding the Yes No

request

Unit-4 New Questions

12 What is XML tag library? Explain the XML core tags and show their use.

Ans:

● The XML tag library is a collection of tags that can be used to parse, transform,
and manipulate XML data in JSP pages.
● The XML tag library is part of the JSTL (JavaServer Pages Standard Tag
Library),
● It is a collection of reusable tags that can be used to simplify the development of
JSP pages.

The XML core tags are a set of tags that provide basic functionality for working with
XML data. The following are the XML core tags:

● x:parse - The x:parse tag parses an XML document and stores the resulting XML
document object model (DOM) in the specified variable.
● x:out - The x:out tag evaluates an XPath expression and writes the result of the
evaluation to the current JSP writer.
● x:set - The x:set tag evaluates an XPath expression and stores the result of the
evaluation in a scoped variable.

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

Ans:

Here are the action tags used to access JavaBeans from a JSP page:

● jsp:useBean - This tag is used to create or locate a JavaBean object.

● attributes:
○ id - The id of the JavaBean object.
○ scope - The scope of the JavaBean object.
○ class - The fully qualified name of the JavaBean class.
● jsp:setProperty - This tag is used to set the value of a property of a JavaBean
object.
● attributes:
○ beanName - The name of the JavaBean object.
○ property - The name of the property to set.
 ○ value - The value of the property.
● jsp:getProperty - This tag is used to get the value of a property of a JavaBean
object.
● attributes:
○ beanName - The name of the JavaBean object.
○ property - The name of the property to get.

15 Show the use of JSP inbuilt objects: request and response, with their use in
application.

Ans:

Here are some examples of how to use the JSP inbuilt objects: request and response,
with their use in application:

● Request object: The request object is used to access information about the
HTTP request that was made to the JSP page.
● For example, you can use the request object to get the user's IP address, the
browser they are using, and the URL of the page that they were on before they
came to the JSP page.
● Response object: The response object is used to send information back to the
client.
● For example, you can use the response object to set the content type of the
response, to send cookies to the client, and to redirect the client to another page.

16 Explain transaction handling using JSTL.

Ans:

● Transaction handling in JSTL is done using the sql:transaction tag.

● The sql:transaction tag allows you to group multiple SQL statements into a
single transaction.
● This is useful for ensuring that all of the statements are either committed or rolled
back if an error occurs.

The syntax for the sql:transaction tag is as follows:

 <sql:transaction [dataSource] [isolation] [timeout]>

<!-- SQL statements -->

</sql:transaction>

17 Discuss JSP Exception Handling

Ans:

● JSP exception handling is the process of handling errors that occur during the
execution of a JSP page.
● JSP exceptions can be handled using try-catch blocks or error pages.

Try-catch blocks

● Try-catch blocks are the most common way to handle JSP exceptions.
● A try-catch block consists of a try block and a catch block.
● The try block contains the code that is executed in the event of an error.
● The catch block contains the code that is executed if an error occurs.

Error pages

● Error pages are another way to handle JSP exceptions.

● An error page is a JSP page that is used to display an error message to the user
if an exception occurs.