(2½ hours)

Total Marks: 75

N. B.: (1) All questions are compulsory.

(2) Make suitable assumptions wherever necessary and state the assumptions made.
(3) Answers to the same question must be written together.
(4) Numbers to the right indicate marks.
(5) Draw neat labeled diagrams wherever necessary.
(6) Use of Non-programmable calculators is allowed.

1. Attempt any two of the following: 10

a. Explain the use of adapter class with suitable example.

Java provides a special feature, called an adapter class that can simplify the creation of event
handlers in certain situations. An adapter class provides an empty implementation of all
methods in an event listener interface. Adapter classes are useful when you want to receive and
process only some of the events that are handled by a particular event listener interface.
You can define a new class to act as an event listener by extending one of the adapter classes
and implementing only those events in which you are interested.

For example, the MouseMotionAdapter class has two methods, mouseDragged( )

and mouseMoved( ), which are the methods defined by the MouseMotionListener
interface. If you were interested in only mouse drag events, then you could simply extend
MouseMotionAdapter and override mouseDragged( ). The empty implementation of
mouseMoved( ) would handle the mouse motion events for you.
The following example demonstrates an adapter. It displays a message in the status bar of an
applet viewer or browser when the mouse is clicked or dragged. However, all other mouse
events are silently ignored. The program has three classes. AdapterDemo extends Applet. Its
init( ) method creates an instance of MyMouseAdapter and registers that object to receive
notifications of mouse events. It also creates an instance of MyMouseMotionAdapter
and registers that object to receive notifications of mouse motion events. Both of the
constructors take a reference to the applet as an argument.

MyMouseAdapter extends MouseAdapter and overrides the mouseClicked( ) method.

The other mouse events are silently ignored by code inherited from the MouseAdapter class.
MyMouseMotionAdapter extends MouseMotionAdapter and overrides the mouseDragged( )
method. The other mouse motion event is silently ignored by code inherited from the
MouseMotionAdapter class.

Note that both of the event listener classes save a reference to the applet. This information is
provided as an argument to their constructors and is used later to invoke the showStatus( )
method.
// Demonstrate an adapter.
import java.awt.*;
import java.awt.event.*;
import java.applet.*;
/*
<applet code="AdapterDemo" width=300 height=100>
</applet>
*/
public class AdapterDemo extends Applet {
public void init() {
addMouseListener(new MyMouseAdapter(this));
addMouseMotionListener(new MyMouseMotionAdapter(this));
 }
}
class MyMouseAdapter extends MouseAdapter {
AdapterDemo adapterDemo;
public MyMouseAdapter(AdapterDemo adapterDemo) {
this.adapterDemo = adapterDemo;
}
// Handle mouse clicked.
public void mouseClicked(MouseEvent me) {
adapterDemo.showStatus("Mouse clicked");
}
}
class MyMouseMotionAdapter extends MouseMotionAdapter {
AdapterDemo adapterDemo;
public MyMouseMotionAdapter(AdapterDemo adapterDemo) {
this.adapterDemo = adapterDemo;
}
// Handle mouse dragged.
public void mouseDragged(MouseEvent me) {
adapterDemo.showStatus("Mouse dragged");
}
}

As you can see by looking at the program, not having to implement all of the methods defined
by the MouseMotionListener and MouseListener interfaces saves you a considerable amount
of effort and prevents your code from becoming cluttered with empty methods. As an exercise,
you might want to try rewriting one of the keyboard input examples shown earlier so that it
uses a KeyAdapter.
b. Explain Delegation Event model. What are two steps in using the java delegation
event model?

The modern approach to handling events is based on the delegation event model, which
defines standard and consistent mechanisms to generate and process events. Its concept is
quite simple: a source generates an event and sends it to one or more listeners. In this scheme,
the listener simply waits until it receives an event. Once received, the listener processes the
event and then returns. The advantage of this design is that the application logic that
processes events is cleanly separated from the user interface logic that generates those events.
A user interface element is able to “delegate” the processing of an event to a separate piece of
code.
In the delegation event model, listeners must register with a source in order to receive an
event notification. This provides an important benefit: notifications are sent only to listeners
that want to receive them .Previously, an event was propagated up the
containment hierarchy until it was handled by a component. This required components to
receive events that they did not process, and it wasted valuable time.

The delegation event model eliminates this overhead.

1) Events
In the delegation model, an event is an object that describes a state change in a source. It can
be generated as a consequence of a person interacting with the elements in a graphical user
interface. Some of the activities that cause events to be generated are pressing a button,
entering a character via the keyboard, selecting an item in a list, and clicking the mouse.
Many other user operations could also be cited as examples. Events may also occur that are
not directly caused by interactions with a user interface.
For example, an event may be generated when a timer expires, a counter exceeds a value,
software or hardware failure occurs, or an operation is completed.
2)Event Sources
 A source is an object that generates an event. This occurs when the internal state of that
object changes in some way. Sources may generate more than one type of event.
A source must register listeners in order for the listeners to receive notifications about a
specific type of event. Each type of event has its own registration method.

Here is the general form:

public void addTypeListener(TypeListener el)
Here, Type is the name of the event and el is a reference to the event listener. For
example, the method that registers a keyboard event listener is called addKeyListener( ).

3) Event Listeners
A listener is an object that is notified when an event occurs. It has two major
2 requirements.
First, it must have been registered with one or more sources to receive notifications about
specific types of events. Second, it must implement methods to receive and process these
notifications.
Just follow these two steps:
Implement the appropriate interface in the listener so that it can receive the type of event
desired.
Implement code to register and unregister (if necessary) the listener as a recipient for the
event notifications.
A source may generate several types of events. Each event must be registered separately.
Also, an object may register to receive several types of events, but it must implement all of
the interfaces that are required to receive these events.
c. Explain the various Layout Managers available in AWT

BorderLayout

Every content pane is initialized to use a BorderLayout. A BorderLayout places

components in up to five areas: top, bottom, left, right, and center. All extra space is
placed in the center area. Tool bars that are created using JToolBar must be created within a
BorderLayout container, if you want to be able to drag and drop the bars away from their
starting positions.

BoxLayout

The BoxLayout class puts components in a single row or column. It respects the
components' requested maximum sizes and also lets you align components
 CardLayout

The CardLayout class lets you implement an area that contains different components at
different times. A CardLayout is often controlled by a combo box, with the state of the
combo box determining which panel (group of components) the CardLayout displays. An 6
alternative to using CardLayout is using a tabbed pane, which provides similar functionality
but with a pre-defined GUI.

FlowLayout

FlowLayout is the default layout manager for every JPanel. It simply lays out components in
a single row, starting a new row if its container is not sufficiently wide. Both panels in
CardLayoutDemo, shown previously, use FlowLayout.

GridBagLayout

GridBagLayout is a sophisticated, flexible layout manager. It aligns components by

placing them within a grid of cells, allowing components to span more than one cell. The
rows in the grid can have different heights, and grid columns can have different widths.

GridLayout

GridLayout simply makes a bunch of components equal in size and displays them in the
requested number of rows and columns.
d. Write AWT based Java program that will read a string from user and display the length
of the string.

2. Attempt any two of the following: 10

a. Write a Java program using swing components that displays table containing student
information (Name, Address, 10th %, 12th %, Emailed, Contact No.).
b. What is use of JcolorChooser? Write down the constructors and methods of the same.

JColorChooser provides a pane of controls designed to allow a user to manipulate and select
a color.
Constructors
JColorChooser(): Creates a color chooser pane with an initial color of white.

JColorChooser(Color initialColor): Creates a color chooser pane with the specified initial
color.

JColorChooser(ColorSelectionModel model): Creates a color chooser pane with the

specified ColorSelectionModel.

Methods
Color getColor(): Gets the current color value from the color chooser.

void setColor(Color color): Sets the current color of the color chooser to the specified color.

void setColor(int c): Sets the current color of the color chooser to the specified color.

void setColor(int r, int g, int b): Sets the current color of the color chooser to the specified
RGB color.

static Color showDialog(Component component, String title, Color initialColor):

Shows a modal color-chooser dialog and blocks until the dialog is hidden.
c. Distinguish Between AWT & JFC

JFC (Swing) is a huge set of components which includes labels, frames, tables, trees,
andstyled text documents. Almost all Swing components are derived from a single parent
called JComponent which extends the AWT Container class. Swing is a layer on top of
AWT rather than a substitution for it.

AWT Swing
AWT stands for Abstract windows Swing is also called as JFC’s (Java
toolkit. Foundation
classes).
AWT components are called Swings are called light weight
Heavyweight component. component because
swing components sits on the top of
AWT
components and do the work.
AWT components require java.awt Swing components require javax.swing
package. package.
AWT components are platform Swing components are made in purely
dependent. java and
they are platform independent.
This feature is not supported in AWT. We can have different look and feel in
Swing. Swing has many advanced
features like JTabel, Jtabbed pane which
is not available in AWT. Also. Swing
components are called "lightweight"
because they do not require a native OS
object to implement their functionality.
JDialog and JFrame are heavyweight,
because they do have a peer. So
components like JButton, JTextArea,
 etc., are lightweight because they do not
have an OS peer.
With AWT, you have 21 "peers" (one With Swing, you would have only one
for each control and one for the peer, the operating system's window
dialog itself). A "peer" is a widget object. All of the buttons, entry fields,
provided by the operating system, etc. are drawn by the Swing package on
such as a button object or an entry the drawing surface provided by the
field object. window object. This is the reason that
Swing has more code. It has to draw the
button or other control and implement
its behavior instead of relying on the
host operating system to perform those
functions.
AWT is a thin layer of code on top of Swing is much larger. Swing also has
the OS. very much
richer functionality.
Using AWT, you have to implement a Swing has them built in.
lot of things yourself.

d. Explain Root Pane, Glass Pane, Layered Pane, Content Pane and Desktop Pane.

Swing offers some top-level containers such as - JApplet, JDialog, and JFrame. There are some
problems for mixing lightweight and heavyweight components together in Swing, we can't just
add anything but first, we must get something called a "content pane," and then we can add
Swing components to that.

The Root Pane :

We don't directly create a JRootPane object. As an alternative, we get a JRootPane when we
instantiate JInternalFrame or one of the top-level Swing containers, such as JApplet, JDialog,
and JFrame. It’s a lightweight container used behind the scenes by these toplevel containers.
As the preceding figure shows, a root pane has four parts:
1) The layered pane: It Serves to position its contents, which consist of the content pane and the
optional menu bar. It can also hold other components in a specified order. JLayeredPane adds
depth to a JFC/Swing container, allowing components to overlap each other when needed.It
allows for the definition of a several layers within itself for the child components.
JLayeredPane manages its list of children like Container, but allows for the definition of a
several layers within itself.
2) The content pane: The container of the root pane's visible components, excluding the menu
bar.
3) The optional menu bar: It is the home for the root pane's container's menus. If the container
has a menu bar, we generally use the container's setJMenuBar method to put the menu bar
in the appropriate place.
4) The glass pane: It is hidden, by default. If we make the glass pane visible, then it's like a sheet
of glass over all the other parts of the root pane. It's completely 9 transparent.The glass pane
is useful when we want to be able to catch events or paint over an area that already contains
one or more components. We can display an image over multiple components using the glass
pane.

JdesktopPane:
The concept of showing multiple windows inside a large frame is implemented using
Desktop pane. If we minimize the application frame, all of its windows are hidden at the same
time. In Windows environment, this is called as the multiple document interfaceor MDI. Using
it we can resize the internal frames inDesktop pane by dragging the resize corners.To achieve
this we have follow these steps:
 1. We can use a regular JFrame window for the program.
2. Set the content pane of the JFrame to a JDesktopPane.

3. Attempt any two of the following: 10

a. What are servlets? What are the advantages of servlet over CGI?

What are Servlet?

A Java servlet is a server side program that services HTTP requests and return the results
as HTTP responses. A good analogy for a servlet is a non-visual applet and runs on a
webserver.it has a lifecycle similar to that of an applet and runs inside a JVM at the web
server.The javax.Servlet and javax.Servlet.http packages provide interfaces and classes for
writing servlets. All servlets must implement the Servlet interface, which defines lifecycle
methods. When implementing a generic service, we can use or extend the GenericServlet class
provided with the Java Servlet API. The HttpServlet class provides methods, such as doGet()
and doPost(), for handling HTTP-specific services.

What are the advantages of servlet over CGI?

•Servlets are loaded into memory once and run from memory thereafter.
•Servlets are swapped as a thread, not as a process.
•Servlets are powerful object oriented abstraction of http.
•Servlets are portable across multiple web servers and platforms.
•Servlets are tightly integrated with web server.
•Servlets run within the secure and reliable scope of JVM
•Servlets provide direct database access using native and ODBC based Dbdrivers.
•Being on the server side provide code protection.
•Servlets are robust, scalable, secure CGI replacement.

b. What is Request Dispatcher? What are its two methods?

RequestDispatcher in Servlet
The RequestDispacher interface provides the facility of dispatching the request to another
resource it may be html, servlet or jsp.This interface can also be used to include the content
of antoher resource also. It is one of the way of servlet collaboration.

Methods of RequestDispatcher interface:

1. public void forward(ServletRequest request,ServletResponse response)throws

ServletException,java.io.IOException:Forwards a request from a servlet to
another resource (servlet, JSP file, or HTML file) on the server.

2. public void include(ServletRequest request,ServletResponse response)throws

ServletException,java.io.IOException:Includes the content of a resource
(servlet, JSP page, or HTML file) in the resp
c. Explain the ServletRequest interface of servlet API.

When a servlet accepts a call from a client, it receives two objects.

ServletRequest encapsulates the communication from the client to server.
ServletResponse encapsulates the communication from the server to client.

ServletRequest interface allows the Servlet to access information such as

Names of parameter passed by client
Protocol scheme such as HTTP POST and PUT methods being used by client.
Names of the remote host that made the request.
Servlet that receives it
An input stream for reading binary data from the request body.

Subclass os ServletRequest allow the servlet to retrieve more protocol specific data.
Eg. HttpServletRequest :Defines an object to provide client request information to a servlet.
The servlet container creates a ServletRequest object and passes it as an argument to the
servlet's service method. A ServletRequest object provides data including parameter name and
values, attributes, and an input stream.

Methods
java.lang.Object getAttribute(java.lang.String name) Returns the value of the named attribute
as an Object, or null if no attribute of the given name exists.
java.util.Enumeration getAttributeNames() Returns an Enumeration containing the names of
the attributes available to this request.
java.lang.String getParameter(java.lang.String name) Returns the value of a request parameter
as a String, or null if the parameter does not exist.
java.util.Enumeration getParameterNames() Returns an Enumeration of String objects
containing the names of the parameters contained in this request.
java.lang.String[] getParameterValues(java.lang.String name) Returns an array of String
objects containing all of the values the given request parameter has, or null if the parameter
does not exist.
RequestDispatcher getRequestDispatcher(java.lang.String path) Returns a RequestDispatcher
object that acts as a wrapper for the resource located at the given path.
java.lang.String getServerName() Returns the host name of the server that received the request.
void removeAttribute(java.lang.String name) Removes an attribute from this request.
void setAttribute(java.lang.String name, java.lang.Object o) Stores an attribute in this request.
d. Write a servlet program to display the factorial of a given number.
4. Attempt any two of the following: 10
a. List and explain the Directive tags of JSP.

Directive Tag gives special instruction to Web Container at the time of page translation.
Directive tags are of three types: page, include and taglib.

Directive Description

<%@ page ... %> defines page dependent properties such as language, session,
errorPage etc.

<%@ include ... defines file to be included.

%>

<%@ taglib ... declares tag library used in the page

%>

The Page directive defines a number of page dependent properties which communicates with
the Web Container at the time of translation. Basic syntax of using the page directive is <%@
page attribute="value" %> where attributes can be one of the following :

• import attribute
• language attribute
• extends attribute
• session attribute
• isThreadSafe attribute
• isErrorPage attribute
• errorPage attribute
• contentType attribute
• autoFlush attribute
• buffer attribute

The include directive tells the Web Container to copy everything in the included file and
paste it into current JSP file. Syntax of include directive is:

<%@ include file="filename.jsp" %>

The taglib directive is used to define tag library that the current JSP page uses. A JSP page
might include several tag library. JavaServer Pages Standard Tag Library (JSTL), is a
collection of useful JSP tags, which provides mahy commonly used core functionalities. It
has support for many general, structural tasks such as iteration and conditionals, readymade
 tags for manipulating XML documents, internationalization tags, and for performing SQL
operations. Syntax of taglib directive is:
<%@ taglib prefix="prefixOfTag" uri="uriOfTagLibrary" %>
The prefix is used to distinguish the custom tag from other libary custom tag. Prefix is
prepended to the custom tag name. Every custom tag must have a prefix.
b. Explain JDBC architecture.

JDBC is a Java API for executing SQL statements and supports basic SQL functionality. The
JDBC (Java Database Connectivity) is an API that defines interfaces and classes for writing
database applications in Java by making database connections. It is a program designed to
access many popular database products on a number of operating system platforms.Using
JDBC we can send SQL, PL/SQL statements to almost any relational database. It provides
RDBMS access by allowing us to embed SQL inside Java code.

JDBC Architecture
The main function of the JDBC API is to provide a means for the developer to issue SQL
statements and process the results in a consistent, databaseindependently. JDBC provides
wealthy object-oriented access to databases by defining classes and interfaces that represent
objects such as:
•Database connections : (Short explanation Expected)
•SQL statements : (Short explanation Expected)
•Result Set: (Short explanation Expected)
•Database metadata: (Short explanation Expected)
•Prepared statements: (Short explanation Expected)
•Binary Large Objects (BLOBs): (Short explanation Expected)
•Character Large Objects (CLOBs): (Short explanation Expected)
•Callable statements : (Short explanation Expected)
•Database drivers: (Short explanation Expected)
•Driver manager: (Short explanation Expected)
The JDBC API uses a Driver Manager and databaseprecise drivers to provide clear
connectivity to heterogeneous databases. The JDBC driver manager ensures that the correct
driver is used to access each data source. The Driver Manager is capable of supporting
multiple concurrent drivers connected to multiple heterogeneous databases.

Layers of the JDBC Architecture

c. Write the purpose of the following JDBC classes

 i. DriverManager ii. ResultSet iii. Statement iv. Connection v. PreparedStatement

DriverManager : Loads all the drivers in the memory at run time.

ResultSet : is a database result set generated from currently executed SQL statement.
Statement : interface represents a static SQL statement that can be used to retrieve Resultset
object(s). The objective is to pass to the database the SQL command for execution and to
retrieve output results from the database in th eform of Resultset.
Connection : interface reprsents a connection with a data source. Can be used to retrieve
information regarding the tables in th edatabase to which connection is opened.
PreparedStatement : is an SQL statement that is pre-compled and stored. This object can then
be executed multiple times much more efficiently than preparing and issuing the same
statement each time it is needed.
d. What are the advantages and disadvantages of Java Server pages?

JavaServer Pages (JSP) is a serverside development technology that is used to create dynamic
web pages and applications. It is introduced after Java Servlets. With Servlets Java became a
full-fledged application server programming language. This is achieved by embedding Java
code into HTML, XML, DHTML, or other document types. When a client such as a web
browser makes a request to the Java application container, which is typically a web server,
the static page is converted behind the scenes, and displayed as dynamic content to the
viewer.

1 Advantage of JSP:
• The JSP serves all facilities of Java i.e. write once run anywhere.
• JSP is ideal for Web based Technology.
• The JSP pages are translated and compiled into JAVA Servlet but are easier to
develop than JAVA Servlet.
• The JSP uses simplified scripting language based syntax for embedding HTML
into JSP.
• JSP containers provide easy coding for accessing standard objects and actions.
• JSP acquire all the benefits provided by JAVA Servlets and web container
environment.
• The JSP use HTTP as default request /response communication model.

2: Disadvantage:
• The JSP implementation is normally causes for poor diagnostics.
• Difficult looping in jsp.
• The space used to store JSP page is comparatively more.
• The first time loading of JSP is little bit time consuming because JSP pages must
be compiled on the server when first accessed.

5. Attempt any two of the following: 10

a. Explain Model-view-controller architecture.

MVC Architecture
The MVC stands for Model, View, and Controller architecture. The MVC architecture
separates the business logic and application data from the presentation data to the user.MVC
is design pattern which allows a developer to write their applications in a specific format,
following the same directory structure, using the same configuration, allowing making unique
chain between the components & documents of the application.
Core parts of MVC architecture.
1) Model: The model object only represents the data of an application. The model object
knows about all the data that need to be displayed. The model is aware about all the
operations that can be applied to transform that object. The model represents enterprise data
and the business rules that govern access to and updates of this data. Model is not concern
about the presentation data and how that data will be displayed to the browser.
 2) View: The view represents the presentation of the application. The view object refers to
the model. It uses the query methods of the model to obtain the contents and renders it. The
view is not dependent on the application logic. It remains same if there is any modification in
the business logic. It is the responsibility of the view's to maintain the consistency in its
presentation when the model (data or logic) changes.
3) Controller: Whenever the user sends a request for something then it always go through
the controller. The controller is responsible for intercepting the requests from view and passes
it to the model for the appropriate action. After the action has been taken on the data, the
controller is responsible for directing the appropriate view to the user. In GUI applications
the views and the controllers often work very closely together.
b. List various phases of JSF lifecycle. Explain in short.

JSF lifecycle
To understand how the framework treats the underlying request & Servlet API also how
Faces processes each request, we’ll go through the JSF request processing lifecycle. A Java
Server Faces page is represented by a tree of UI components, called a view. During the
lifecycle, the Java Server Faces implementation must build the view while considering state
saved from a previous submission of the page. When the client submits a page, the Java
Server Faces implementation performs several tasks, such as validating the data input of
components in the view and converting input data to types specified on the server side. The
Java Server Faces implementation performs all these tasks as a series of steps in the Java
Server Faces request response life cycle.

JSF Life cycle handles two kinds of requests:

Initial request: A user requests the page for the first time.
Postback: A user submits the form contained on a page that was previously loaded into
the browser as a result of executing an initial request.

The phases of the JSF application lifecycle are as follows:

Phase 1: Restore view
In this phase, JSF classes build the tree of UI components for the incoming request. When a
request for a JavaServer Faces page is made, such as when a link or a button is clicked, the
JavaServer Faces implementation begins the restore view phase. The JSF framework
controller uses the view ID means a name of JSP to look up the components for the current
view. If the view isn’t available, the JSF controller creates a new one. If the view already
exists, the JSF controller uses it. The view contains all the GUI components and there is a
great deal of state management by JSF to track the status of the view – typically using HTML
hidden fields.
Phase 2: ApplyRequest values
In this phase, the request parameters are examined and their values are used to set the values
of the corresponding UI components. This process is called decoding. If the conversion of the
value fails, an error message associated with the component is generated. This message will
be displayed during the render response phase, along with any validation errors resulting
from the process validations phase.
Phase 3: Process validations
In this phase triggers calls to all registered Validators.The components validate the new
values coming from the request against the application's validation rules. Any input can be
scanned by any number of Validators.These Validators can be predefined or defined by the
developer. Any validation errors will abort the requesthandling process and skip to rendering
the response with validation and conversion error messages.
Phase 4: Update Model Values
The Update Model phase brings a transfer of state from the UI component tree to any and all
backing beans, according to the value expressions defined for the components themselves. In
this phase converters are invoked to parse string representations of various values to their
proper primitive or object types. If the data cannot be converted to the types specified by the
bean properties, the life cycle calls directly to the render response phase so that the page is re-
 rendered with errors displayed. In Apply Request Values phase, it moves values from client
side HTML form controls to server side UI components; while Update model values phase
the information moves from the UI components to the backing beans.
Phase 5: Invoke Application
This phase handles any application level events. Normally this takes the form of a call to
process the action event generated by the submit button that the user clicked. In this phase…
•Application level events are handled
•Application methods are invoked
•Navigation outcome are calculated
Phase 6: Render Response
The Render Response Phase brings several contrary behaviors together in one process like
values are transferred back to the UI components from the bean including any modifications
that may have been made by the bean itself or by the controller; The UI components save
their state, not just their values, but other attributes having to do with the presentation itself.
This can happen at serverside, but by default state is written into the HTML as hidden input
fields and thus returns to the JSF implementation with the next request. If the request is a
Postback and errors were encountered during the apply request values phase, process
validations phase, or update model values phase, the original page is rendered during this
phase. If the pages contain message or messages tags, any queued error messages are
displayed on the page.

c. What is Facelet? Write the features of Facelet?

Facelets is commonly used term to refer to JavaServer Faces View Defination Framework
which is page declaration language developed for use with Java server Faces technology. The
concept of VDL introduced in JavaServer Faces 2.0 allows declaration of UI components in
different presentation technologies. Both JSP and facelets are considered different
inpmementation of VDL.

Facelet is built specifically for JavServer Faces. It is now theprefered technology for building
JavaServer Faces based applications and offers several advantages over using JSP
technology.

Facelets is a powerful but lightweight page declaration language that is used to build
JavaServer Faces views using HTML style templates and to build component trees. Facelets
features include the following:
• Facelets as presentation technology.
• Templatting and Composite Components through Faceltes.
• New HTML tags for easier page creation.
• Bookmarkability to generate hyperlinks based on component properties at render time .
• New components and event types for additional functionality.
• Resource registration and relocation using annotations.
• Implicit Navigation Rules if none are present in the application configuration resource files.
• Support for Bean Validation.
• Project Stage to describe the status of the application in the project lifecycle.
• Support for Ajax Integration.

d. Explain the benefits of EJB.

• Complete focus only on business logic

• Reusable components
• Portable
• Fast Building Application
• One business logic having many presentation logics
 • Distributed Deployment
• Application Interoperability

6. Attempt any two of the following: 10

a. Explain Architecture of Hibernate framework in detail.

Hibernate architecture has three main components as follows:

1 Connection Management:
Hibernate Connection management service provide well-organized management of the
database connections. Database connection is the most expensive part of interacting with the
database as it requires a lot of resources of open and close the database connection.
2: Transaction management:
Transaction management service of hibernate provides the ability to the user to execute more
than one database statements at a time.
3 Object relational mapping:
Object relational mapping is technique of mapping the data representation from an object
model to a relational data model. This part of hibernate is used to select, insert, update and
delete the records form the underlying table. When we pass an object to a Session.save()
method, Hibernate reads the state of the variables of that object and executes the necessary
query.
4 configuration object
The configuration object represents a configuration or properties file for Hibernate. It is
usually created once during application initialization.
5.Session factory
The seession factory is created with the help of a configuration object during the application
start up.it serves as as factory for spawning session objects when required.
6. session
Session objects are light weight and inexpensive to create. They provide the main interface to
perform actual database operation.
7.Transaction
Transaction represents a unit of work with the database.
 8.Query
Persistent objects are retrieved using a query object.
9.Criteria
Persistent object can also be retrieved using a criteria object.
b. What is value stack in struts? State and exaplin the execution flow of value stack.

Value Stack:Value Stack is nothing but stack of objects. The Value Stack is a storage
area that holds all of the data associated with the processing of a Request.

Execution Flow of Value Stack:

1. The framework receives a request and decides on the action the URL maps to
2. The framework moves the data to the Value Stack whilst preparing for request
processing
3. The framework manipulates the data as required during the action execution
4. The framework reads the data from there and renders the results i.e. Response
page struts to maintain a stack of the following objects in the Value Stack:
1) Temporary Objects: Theseare generated and placed in the Value Stack during
execution. These objects provide temporary storage and are normallygenerated while
processing a request.For example, the current iteration value for a collection being looped
over in JSP tag.
2) The Model Object: If the application user Model objects, the current model object is
placed in the Value Stack before the Action executes.
3) The Action Object: It is the Action that is currently being executed.
4) Named Objects: Any object assigned to an identifier called as a Named Object.These
objects can either be created by the developer of pre-defined such as #application

Accessing Value Stack :The Value Stack can be accessed by simply using the tags
provided for JSP.
•When the Value Stack Is queried for an attribute value, each stack element, in the
provided order, is asked whether it holds the queried property.
•If it holds the queried property, then the value is returned.
•If it does not hold the queried property, then the next element down is queried.
This continues until the last element in the stack is scanned.
c. Write a short on Interceptors in struts.

Interceptors
Interceptors allow developing code that can be run before and/or after the execution of an
action. A request is usually processed as follows:
•A user requests a resource that maps to an action
•The Struts 2 framework invokes the appropriate action to serve the request
If interceptors are written, available and configured, then:
•Before the action is executed the invocation could be intercepted by another
object
•After the action executes, the invocation could be intercepted again by another
object

Such objects who intercept the invocation are called Interceptors. Conceptually, interceptors
are very similar to Servlet Filters or the JDKs Proxy class. Interceptor Configuration:
Interceptors configured in the struts.xml file appear as:
<interceptors>
<interceptor name="test1" class="..."/>
<interceptor name=”test2" class="..."/>
</interceptors>
<action name="WelcomeSturts">
<interceptor-ref name=" test 1"/>
<interceptor-ref name=" test 2"/>
 <result name="SUCCESS">/ Welcome.jsp</result>
<result name="ERROR">/ Error.jsp</result>
</action>

In above code two interceptors named test1 and test2 are defined. Both of these are them
mapped to the action named WelcomeSturts.

Interceptor Stack: We can bind Interceptor together using an Interceptor Stack which
can be referenced together. We can use the same set of interceptors multiple times. So,
instead of configuring a number of interceptors every time, an interceptor stack can be
configured with all the required interceptors held within. To use Intercept Stack we need
to modify the struts.xml file as follows:

<interceptors>
<interceptor name="test1" class="..."/>
<interceptor name= test2" class="..."/>
<interceptor-stack name="MyStack">
<interceptor-ref name=" test1"/>
<interceptor-ref name=" test2"/>
</interceptor-stack>
</interceptors>
<action name="WelcomeSturts " class="test.WelcomeSturts ">
<result name="SUCCESS">/ Welcome.jsp</result>
<result name="ERROR">/ Error.jsp</result>
</action>

In above code two interceptors named test1and test2 are defined and a stack
named MyStackgroup them both.The stack holding both these interceptors is then
mapped to the Action named WelcomeStruts.
Execution Flow of Interceptors: Interceptors are executed as follows:
1. The framework receives a request and decides on the action the URL maps to
2. The framework consults the application's configuration file, to discover which
interceptors should fire and in what sequence
3. The framework starts the invocation process by executing the first Interceptor in
the Stack
4. After all the interceptors are invoked, the framework causes the action itself to be
executed.

d. Explain structure of hibernate.cfg.xml file.

Hibernate uses the “hibernate.cfg.xml” file to create the connection & setup the required
environment.
This file contains information such as…..
1) Database Connection 2) Resource mapping

hibernate.cfg.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration
DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="hibernate.connection.url"> jdbc:mysql://localhost:3306/Feedback
</property>
<property name="hibernate.connection.username">root</property>
 <property name="hibernate.connection.password">root</property>
</session-factory>
</hibernate-configuration>

Explaination:
1. hibernate.connection.driver_class: It is the JDBC connection class for the specific
database.
2. hibernate.connection.url: It is the full JDBC URL to the database.
3. hibernate.connection.username: It is the username used to connection the database.
4. hibernate.connection.password: It is the password used to authenticate the username.
5. hibernate.dialect: It is the name of SQL dialect for the database.

7. Attempt any three of the following: 15

a. What is CheckBoxGroup? Explain with Example.

A check box is a control that is used when there are multiple options and multiple
selections to turn an option on or off. It consists of a small box that can either contain a
check mark or not.
CheckboxGroup
It is possible to create a set of mutually exclusive check boxes in which one and only one
check box in the group can be checked at any one time. These check boxes are often
called radio buttons. Check box groups are objects of type CheckboxGroup. Only the
default constructor is defined, which creates an empty group.
Methods:
Checkbox getSelectedCheckbox( ) : Reads the selected radio button option from group
void setSelectedCheckbox(Checkbox which): Selects radio button option of a group.
Example:
import java.applet.*;
import java.awt.*;
/*
<applet code="TCBCBG" width=200 height=150>
</applet>
*/
public class TCBCBG extends Applet {
Checkbox morning,noon,evening;
public void init() {
this.add(new Label("How will you pay for your pizza?"));
CheckboxGroup cbg = new CheckboxGroup();
this.add(new Checkbox("Visa", cbg, false));
this.add(new Checkbox("Cash", cbg, true)); // the default
this.add(new Label("Select Time Slots for Delivery"));
morning = new Checkbox("Morning", null, true);
noon = new Checkbox("Afternoon");
evening = new Checkbox("Evening");
this.add(morning);
this.add(noon);
this.add(evening);
}
}

b. Write a java program to demonstrate the use of Tabbed Panes.

c. What is the purpose of WEB-INF file? Explain.

A Web application exists as a structured hierarchy of directories. The root of this hierarchy
serves as the document root for files that are part of the application.
 A special directory exists within the application hierarchy named “WEB-INF”. This directory
contains all things related to the application that aren’t in the document root of the application.
The WEB-INF node is not part of the public document tree of the application. No file contained
in the WEB-INF directory may be served directly to a client by the container. However, the
contents of the WEBINF directory are visible to servlet code using the getResource and
getResourceAsStream method calls on the ServletContext, and may be exposed using the
RequestDispatcher calls. Hence, if the Application Developer needs access, from servlet code,
to application specific configuration information that he does not wish to be exposed directly
to the Web client, he may place it under this directory. Since requests are matched to resource
mappings in a case-sensitive manner, client requests for ‘/WEB-INF/foo’, ‘/WEb-iNf/foo’, for
example, should not result in contents of the Web application located under /WEB-INF being
returned, nor any form of directory listing thereof.

The contents of the WEB-INF directory are:

• The /WEB-INF/web.xml deployment descriptor.
• The /WEB-INF/classes/ directory for servlet and utility classes. The classes in this directory
must be available to the application class loader.
• The /WEB-INF/lib/*.jar area for Java ARchive files. These files contain servlets, beans, and
other utility classes useful to the Web application. The Web application class loader must be
able to load classes from any of these archive files. The Web application class loader must load
classes from the WEB-INF/ classes directory first, and then from library JARs in the WEB-
INF/lib directory. Also, any requests from the client to access the resources in WEB-INF/
directory must be returned with a SC_NOT_FOUND(404) response.
d. Write a JDBC program that inserts values in database. [table Name : Book,
Fileds : Bookid, Title, Author, Publisher]
e. What are the different types of enterprise beans? Explain.

Enterprise java beans are reusable modules of code that combine related tasks into well-
defined interface. These enterprise beans EJB components contain the method that executes
business logic and access data sources.
1: Session beans:

A) Stateful Session Beans: Stateful Session Beans are business objects having state, means
they can keep track of which calling client they are dealing with throughout a session and
thus access to the bean instance is strictly limited to “only one client at a time”. In the case of
concurrent access to a single bean is attempted anyway the container serializes those requests,
but via the @AccessTimeout annotation the container can throw an exception instead.
Stateful session beans' state may be persisted automatically by the container to free up
memory after the client hasn't accessed the bean for some time.
Example:
The hotel check out may be handled by a stateful session bean that would use its state to keep
track of where the customer is in the checkout process, possibly holding locks on the items
the customer is charged for services.

B) Stateless Session Beans: Stateless Session Beans are business objects that do not have
state associated with them. Access to a single bean instance is limited to only one client at a
time and thus concurrent access to the bean is banned. In case concurrent access to a single
bean is attempted anyway the container simply routes each request to a different instance.
Instances of Stateless Session beans are typically pooled. If a second client accesses a
specific bean right after a method call on it made by a first client has finished, it might get the
same instance. Example: Sending an Email to customer support may be handled by a
stateless bean since this is a oneoff operation and not part of a multistep process.

C) Singleton Session Beans: Singleton Session Beans are business objects having a global
shared state in a JVM. Concurrent access to the one and only bean instance can be controlled
by the container or by the bean itself. Container Managed concurrency can be tuned using the
 @Lock annotation, that designates whether a read lock or a write lock will be used for a
method call. Also the Singleton Session Beans can explicitly request to be instantiated when
the EJB container starts up, using the @Startup annotation.
Examples: Loading a daily price list that will be the same for every user might be done with
a singleton session bean, since this will prevent the application having to do the same query
to a database over and over again.

2.Message Driven Beans:

Message Driven Beans are business objects whose execution is happened by the messages
instead by method calls. Like session beans, a Message Driven Beans does not have any
type of client view, i.e. clients cannot lookup a Message Driven Beans instance. It just
listens for any incoming message on, for example, a JMS queue or topic and processes
them automatically. Message Driven Beans can support many messaging protocols. The
difference between session- and message driven beans is only in method calling and
messaging.
Example: Submitting a job to a work bunch might be done by sending a JMS message to
a 'message queue' and could also be handled by a Message Driven Bean.
f. What is OGNL? Explain the execution flow of OGNL.

OGNL [Object-Graph Navigation Language]

The Object-Graph Navigation Language is a fully featured expression language for

Retrieving and Setting properties of the Java object s. It helps data transfer and type
conversion.
In the Value Stack,Searching or evaluating, a particular expression can be done using
OGNL. OGNL provides a mechanism to navigate object graphs using a dot notation and
evaluate expressions, including calling methods on the objects being retrieved.

OGNL supportsType conversion, calling methods, Collectionmanipulation, Generation,

Projection across collections, Expression evaluation, Lambda expressions etc
OGNL Examples

The following are a few examples where OGNL is used:

emp.name:
It returns the value that is actually returned when getEmp().getName() is Invoked
emp.toSpring():
It returns the value that is actually returned when getEmp().toString() is invoked.
@test.auth.name@fName():
It returns the value that is actual returned when the static method named fName()
is invoked on the class name.
firstName in {"Sharanam","vaishali"}:
invokes getfName() and determines the value returned is either Tushar or
Sonali. If it is, then returns True.

Execution flow of OGNL :

1. A user enters the data in and data entry form and submits the form
2. The Request enters the Struts 2 framework and is made available to the Java Language as an
HttpServletRequest object.
3. The request paramets are stored as name/value paris where the name are the Names of the
data entry from's text fields and the Value are the Value entered by the user when the form is
submitted
4. Now the OGNL comes into picture , to handle the transfer and type conversion of the data
from these request parameters
5. Using the OGNL expression , the value stack is scanned to locate the destination property
where the data has to be moved
6. On locating the correct property in the Value Stack, the data is moved to the property by
invoking the property's SETTER method with the appropriate value. The value stack acts as a
place holder for viewing the data model throughout the execution
7. Whilst moving such data, OGNL consults its set of available type converters to determine if
any of them can handle this particular conversion, if a conversion is required. The value is
converted and set on the object's property. This makes the data available them action begins its
job, immediately after the available Interceptors ate fired.
8. After Action completes to its job successfully, a Result fires that renders the result they to
the user.
9. Results have access to the Value Stack, via the OGNL expression language with the help of
tags. These tags retrieve data from the Value Stack by referencing specific values using OGNL
expressions.
10. Whilst rendering the view , once again, the value that is accessed from the value Slack is
converted from the java type to a String that is written on the HTML page