Microsoft007: Advance java & Frameworks interview questions

Servlet Interview Questions:

🧾 What is a Servlet in Java?

A Servlet is a Java class used to handle HTTP requests and responses in a web application. Servlets run on a Java-enabled web server (Servlet Container) such as Apache Tomcat, Jetty, or GlassFish.

✅ Servlet = Java class + Web container

Feature	Description
API Package	`javax.servlet` and `javax.servlet.http`
Purpose	Handles client requests (mostly HTTP) and returns responses (like HTML, JSON, etc.)
Execution	Managed by the Servlet container (not manually run like main methods)

🔄 Servlet Lifecycle

Loading & Instantiation – Servlet class is loaded.
Initialization (init()) – Called only once when the servlet is first created.
Request Handling (service()) – Called every time a request comes in.
Destruction (destroy()) – Called once before the servlet is destroyed.

🛠️ Servlet Lifecycle Methods

Method	Description
`init()`	Initializes the servlet, runs once
`service()`	Handles client requests
`doGet()`	Handles HTTP GET requests
`doPost()`	Handles HTTP POST requests
`destroy()`	Cleanup before servlet is taken out of service

📌 Basic Example of a Servlet

import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;

public class HelloServlet extends HttpServlet {
    public void doGet(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
        
        response.setContentType("text/html");
        PrintWriter out = response.getWriter();
        out.println("<h1>Hello from Servlet!</h1>");
    }
}

🧩 How to Deploy a Servlet (Steps)

1. Create servlet class

Write a class that extends HttpServlet and overrides doGet() or doPost().

2. Add to `web.xml` (or use annotations)

Option A: Use `web.xml` (Deployment Descriptor)

xml

<servlet>
    <servlet-name>HelloServlet</servlet-name>
    <servlet-class>HelloServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>HelloServlet</servlet-name>
    <url-pattern>/hello</url-pattern>
</servlet-mapping>

Option B: Use Annotation (`@WebServlet`)

java

@WebServlet("/hello")
public class HelloServlet extends HttpServlet {
    // implementation...
}

3. Build WAR file

Package your servlet and other files into a .war file.

4. Deploy to server

Copy the .war to webapps/ directory in Tomcat or another servlet container.

5. Run

Start the server and access your servlet via browser:

http://localhost:8080/YourApp/hello

🔐 Key Interfaces in Servlet API

Interface	Description
`Servlet`	Basic lifecycle methods
`ServletRequest`	Encapsulates client request info
`ServletResponse`	Encapsulates server response info
`HttpServletRequest`	Extends `ServletRequest` for HTTP-specific info
`HttpServletResponse`	Extends `ServletResponse` for HTTP
`ServletConfig`	Used for passing config info to servlet
`ServletContext`	Represents web application context

📚 Use Cases

Handling form submissions (doPost)
Generating dynamic web content (doGet)
Serving JSON/XML data (for REST APIs)
Backend logic for Java web applications

✅ Summary

Aspect	Value
API	`javax.servlet`
Lifecycle Methods	`init()`, `service()`, `destroy()`
HTTP Methods	`doGet()`, `doPost()`
Deployment	WAR file + Servlet Container
Alternatives	JSP, Spring MVC, REST frameworks

📘 2.What is JSP (JavaServer Pages)?

JSP is a server-side technology used for developing dynamic web pages using Java. It allows embedding Java code inside HTML pages and is part of the Java EE (Jakarta EE) platform.

It is mainly used to generate dynamic content like HTML, XML, or JSON in response to client requests (typically via browser).

🧱 Key Features of JSP

Feature	Description
💡 Simplicity	Easier than writing a servlet for HTML-heavy content
🔄 Compiles to Servlet	JSP is internally compiled into a Java servlet
🛠 Reusable	Supports inclusion (`<jsp:include>`) and tag libraries (JSTL, custom tags)
📦 MVC Support	Used as the View component in MVC architecture
🌐 Web Standard	Works in all Java EE compatible containers like Tomcat, GlassFish, JBoss

🛠 JSP Lifecycle

JSP is automatically compiled into a Servlet by the web container. Here's what happens step by step:

📌 JSP Lifecycle Phases:

Phase	Method Called	Description
Translation	N/A	JSP → Java servlet (only once)
Compilation	N/A	Servlet is compiled into `.class`
Initialization	`jspInit()`	Like `init()` in servlet, runs once
Request Processing	`_jspService()`	Handles request, runs every time
Destruction	`jspDestroy()`	Called before servlet is destroyed

🔤 JSP Syntax & Tags

1. Directives

Used to configure the JSP page.


<%@ page import="java.util.Date" %>
<%@ include file="header.jsp" %>

Directive	Purpose
`page`	Defines page-level attributes (import, session, contentType, etc.)
`include`	Includes a static file at translation time
`taglib`	Declares tag libraries (e.g., JSTL)

2. Scriptlet Elements

Type	Syntax	Description
Scriptlet	`<% ... %>`	Java code block
Expression	`<%= ... %>`	Outputs result of expression
Declaration	`<%! ... %>`	Declares variables or methods

Example:

jsp

<%
   String name = "Swamy";
%>
<h1>Hello <%= name %></h1>

<%! int counter = 0; public int getCount() { return ++counter; } %>

3. Standard Action Tags

Tag	Description
`<jsp:include page="..." />`	Includes content at request time
`<jsp:forward page="..." />`	Forwards request to another resource
`<jsp:param>`	Passes parameters in include/forward
`<jsp:useBean>`	Instantiates JavaBeans
`<jsp:setProperty>`	Sets bean property
`<jsp:getProperty>`	Gets bean property

4. Implicit Objects in JSP

JSP provides several pre-defined implicit objects you can directly use without declaration.

Object	Type	Description
`request`	`HttpServletRequest`	Request data
`response`	`HttpServletResponse`	Response to client
`session`	`HttpSession`	User session data
`application`	`ServletContext`	Application-wide data
`out`	`JspWriter`	Output stream
`config`	`ServletConfig`	Servlet config info
`pageContext`	`PageContext`	JSP page context
`exception`	`Throwable`	Error handling pages only
`page`	`Object`	This JSP page (like `this` in Java)

📦 JavaBean in JSP (MVC Pattern)

Step 1: Create a JavaBean

java

public class UserBean {
    private String name;
    public void setName(String name) { this.name = name; }
    public String getName() { return name; }
}

Step 2: Use in JSP

jsp

<jsp:useBean id="user" class="UserBean" scope="session" />
<jsp:setProperty name="user" property="name" value="Swamy" />
Hello, <jsp:getProperty name="user" property="name" />

📂 JSP Folder Structure (Web Project)

pgsql

MyWebApp/
├── index.jsp
├── login.jsp
├── dashboard.jsp
├── WEB-INF/
│   ├── web.xml
│   ├── classes/
│   └── lib/

🔄 JSP vs Servlet

Feature	JSP	Servlet
Code Focus	HTML with Java	Java with HTML
Readability	Easier for web designers	Easier for backend logic
Output	Directly writes to output	Writes via `PrintWriter`
Compilation	Translated to servlet	Native servlet
Used As	View layer	Controller / business logic

✅ Best Practices

Avoid scriptlets (<% ... %>) – use JSTL or EL (Expression Language)
Separate business logic – use MVC architecture
Prefer @WebServlet + JSP instead of embedding too much Java in JSP
Use JSTL (<c:forEach>, <c:if>, etc.) for conditional logic

📚 JSTL and Expression Language (EL)

Expression Language (EL)

jsp

Hello, ${user.name}

JSTL Example:

jsp

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>

<c:if test="${not empty user}">
    Welcome, ${user.name}
</c:if>

🧪 Complete Example: Form + JSP

`form.html`

html

<form action="greet.jsp">
  Name: <input type="text" name="name" />
  <input type="submit" />
</form>

`greet.jsp`

jsp

<%@ page language="java" %>
<html><body>
  <h2>Hello, <%= request.getParameter("name") %>!</h2>
</body></html>

🚀 Modern Alternatives to JSP

Technology	Benefit
Thymeleaf	Cleaner HTML syntax, Spring friendly
React / Angular	Modern SPA frameworks
JSF (JavaServer Faces)	Component-based Java web framework
Spring Boot + REST + Frontend	Separation of backend and UI

📌 Summary

Topic	Description
JSP	Java-based templating engine for dynamic HTML
Compiles To	Servlet
Lifecycle	Translated → Compiled → Initialized → Serviced → Destroyed
Tags	Scriptlets, directives, JSTL, EL
Use Case	View layer in MVC web applications

1. What is a Servlet?
Java Servlets are server side components that provides a powerful mechanism for developing
server side of web application. Earlier CGI was developed to provide server side capabilities to the web applications. Although CGI played a major role in the explosion of the Internet, its performance,
scalability and reusability issues make it less than optimal solutions. Java Servlets changes all that.
Built from ground up using Sun's write once run anywhere technology java servlets provide excellent
framework for server side processing.

2. What are the types of Servlet?
There are two types of servlets, GenericServlet and HttpServlet. GenericServlet defines the
generic or protocol independent servlet. HttpServlet is subclass of GenericServlet and provides some
http specific functionality like doGet and doPost methods.

3. What are the differences between HttpServlet and Generic Servlets?
HttpServlet Provides an abstract class to be subclassed to create an HTTP servlet suitable for a
Web site. A subclass of HttpServlet must be override at least one method, usually one of these:

· doGet, if the servlet supports HTTP GET requests
· doPost, for HTTP POST requests
· doPut, for HTTP PUT requests
· doDelete, for HTTP DELETE requests
· init and destroy, to manage resources that are held for the life of the servlet
· getServletInfo, which the servlet uses to provide information about itself

There's almost no reason to override the service method. Service handles standard HTTP requests by
dispatching them to the handler methods for each HTTP request type (the doXXX methods listed
above). Likewise, there's almost no reason to override the doOptions and doTrace methods.
GenericServlet defines a generic, protocol-independent servlet. To write an HTTP servlet for use on
the Web, extend HttpServlet instead.
GenericServlet implements the Servlet and ServletConfig interfaces. GenericServlet may be directly
extended by a servlet, although it's more common to extend a protocol-specific subclass such as
HttpServlet.
GenericServlet makes writing servlets easier. It provides simple versions of the lifecycle methods init
and destroy and of the methods in theServletConfig interface. GenericServlet also implements the log
method, declared in the ServletContext interface.
To write a generic servlet, you need only override the abstract service method.

4. Differentiate between Servlet and Applet.
Servlets are server side components that executes on the server whereas applets are client side
components and executes on the web browser. Applets have GUI interface but there is not GUI
interface in case of Servlets.

5. Differentiate between doGet and doPost method?
doGet is used when there is are requirement of sending data appended to a query string in the
URL. The doGet models the GET method of Http and it is used to retrieve the info on the client from
some server as a request to it. The doGet cannot be used to send too much info appended as a query
stream. GET puts the form values into the URL string. GET is limited to about 256 characters (usually
a browser limitation) and creates really ugly URLs.
POST allows you to have extremely dense forms and pass that to the server without clutter or
limitation in size. e.g. you obviously can't send a file from the client to the server via GET. POST has
no limit on the amount of data you can send and because the data does not show up on the URL you
can send passwords. But this does not mean that POST is truly secure. For real security you have to
look into encryption which is an entirely different topic

6. What are methods of HttpServlet?
The methods of HttpServlet class are :
* doGet() is used to handle the GET, conditional GET, and HEAD requests
* doPost() is used to handle POST requests
* doPut() is used to handle PUT requests
* doDelete() is used to handle DELETE requests
* doOptions() is used to handle the OPTIONS requests
* doTrace() is used to handle the TRACE requests

7. What are the advantages of Servlets over CGI programs? What are methods of HttpServlet?
Java Servlets have a number of advantages over CGI and other API's. They are:
1. Platform Independence
Java Servlets are 100% pure Java, so it is platform independence. It can run on any Servlet
enabled web server. For example if you develop an web application in windows machine
running Java web server. You can easily run the same on apache web server (if Apache Serve is
installed) without modification or compilation of code. Platform independency of servlets
provide a great advantages over alternatives of servlets.
2. Performance
Due to interpreted nature of java, programs written in java are slow. But the java servlets runs
very fast. These are due to the way servlets run on web server. For any program initialization
takes significant amount of time. But in case of servlets initialization takes place very first time
it receives a request and remains in memory till times out or server shut downs. After servlet is
loaded, to handle a new request it simply creates a new thread and runs service method of
servlet. In comparison to traditional CGI scripts which creates a new process to serve the
request. This intuitive method of servlets could be use to develop high speed data driven web
sites.
3. Extensibility
Java Servlets are developed in java which is robust, well-designed and object oriented language
which can be extended or polymorphed into new objects. So the java servlets takes all these
advantages and can be extended from existing class the provide the ideal solutions.
4. Safety
Java provides a very good safety features like memory management, exception handling etc.
Servlets inherits all these features and emerged as a very powerful web server extension.
5. Secure
Servlets are server side components, so it inherits the security provided by the web server.
Servlets are also benefited with Java Security Manager.

8. What are the lifecycle methods of Servlet?
The interface javax.servlet.Servlet, defines the three life-cycle methods. These are:
public void init(ServletConfig config) throws ServletException
public void service( ServletRequest req, ServletResponse res) throws ServletException,
IOException
public void destroy()
The container manages the lifecycle of the Servlet. When a new request come to a Servlet, the
container performs the following steps.
1. If an instance of the servlet does not exist, the web container
* Loads the servlet class.
* Creates an instance of the servlet class.
* Initializes the servlet instance by calling the init method. Initialization is covered in
Initializing a Servlet.
2. The container invokes the service method, passing request and response objects.
3. To remove the servlet, container finalizes the servlet by calling the servlet's destroy method.

9. What are the type of protocols supported by HttpServlet?
It extends the GenericServlet base class and provides an framework for handling the HTTP protocol.
So, HttpServlet only supports HTTP and HTTPS protocol.

10. What is ServletContext?
ServletContext is an Interface that defines a set of methods that a servlet uses to communicate
with its servlet container, for example, to get the MIME type of a file, dispatch requests, or write to a
log file. There is one context per "web application" per Java Virtual Machine. (A "web application" is a
collection of servlets and content installed under a specific subset of the server's URL namespace such
as /catalog and possibly installed via a .warfile.)

11. What is meant by Pre-initialization of Servlet?
When servlet container is loaded, all the servlets defined in the web.xml file does not initialized
by default. But the container receives the request it loads the servlet. But in some cases if you want
your servlet to be initialized when context is loaded, you have to use a concept called pre-initialization
of Servlet. In case of Pre-initialization, the servlet is loaded when context is loaded. You can specify
<load-on-startup>1</load-on-startup>
in between the <servlet></servlet> tag.

12. What mechanisms are used by a Servlet Container to maintain session information?
Servlet Container uses Cookies, URL rewriting, and HTTPS protocol information to maintain
the session.

13. What do you understand by servlet mapping?
Servlet mapping defines an association between a URL pattern and a servlet. You can use one
servlet to process a number of url pattern (request pattern). For example in case of Struts *.do url
patterns are processed by Struts Controller Servlet.

14. What must be implemented by all Servlets?
The Servlet Interface must be implemented by all servlets.
15. What are the differences between Servlet and Applet?
Servlets are server side components that runs on the Servlet container. Applets are client side
components and runs on the web browsers. Servlets have no GUI interface.

16. What are the uses of Servlets?
*Servlets are used to process the client request.
* A Servlet can handle multiple request concurrently and be used to develop high performance
system
* A Servlet can be used to load balance among serveral servers, as Servlet can easily forward
request.

17. What are the objects that are received when a servlets accepts call from client?
The objects are ServeltRequest and ServletResponse . The ServeltRequest encapsulates the
communication from the client to the server. While ServletResponse encapsulates the communication
from the Servlet back to the client.

JSP Interview Questions:

--------------------------------------------

1. What is JSP ?

Describe its concept. Java Server Pages (JSP) is a server side component for the generation of dynamic information as the response. Best suitable to implement view components (presentation layer components). It is part of SUN‘s J2EE platform.

2 . Explain the benefits of JSP?

These are some of the benefits due to the usage of JSP they are: Portability, reusability and logic components of the language can be used across various platforms. Memory and exception management. Has wide range of API which increases the output functionality. Low maintenance and easy deployment. Robust performance on multiple requests.

3. Is JSP technology extensible?

Yes, it is. JSP technology is extensible through the development of custom actions, or tags, which are encapsulated in tag libraries.

5 What are the advantages of JSP over Servlet?

1. Best suitable for view components

2. we can separate presentation and business logic

3. The JSP author not required to have strong java knowledge

4. If we are performing any changes to the JSP, then not required to recompile and reload explicitly

5. We can reduce development time.

6. Differences between Servlets and JSP?

Servlets

JSP

1. Best suitable for processing logic

1. Best suitable for presentation logic

2. we cannot separate business and presentation logic

2. Separation of presentation and business logic is possible

3. Servlet developer should have strong knowledge in Java

3.JSP author is not required to have strong knowledge in Java

4. For source code changes ,we have to perform explicitly compilation

4. For source code changes ,it is not required to perform explicit compilation

5. Relatively development time is more

5. Relatively development time is less

7 . Explain the differences between ASP and JSP?

The big difference between both of these technologies lies with the design of the software. JSP technology is server and platform independent whereas ASP relies primarily on Microsoft technologies.

8 . Can I stop JSP execution while in the midst of processing a request?

Yes. Preemptive termination of request processing on an error condition is a good way to maximize the throughput of a high-volume JSP engine. The trick (assuming Java is your scripting language) is to use the return statement when we want to terminate further processing.

9. How to Protect JSPs from direct access ?

If the JSP is secured resource then we can place inside WEB-INF folder so that end user is not allowed to access directly by the name. We can provide the url pattern by configuring in web.xml

<web-app>

The JSP API contains only one package : javax.servlet.jsp It contains the following 2 interfaces:

1. JspPage:

This interface defines the two life cycle methods jspInit() and jspDestroy().

1. HttpJspPage:

This interface defines only one life cyle method _jspService() method.

Every generated servlet for the jsps should implement either JspPage or HttpJspPage interface either directly or indirectly.

11. What are the lifecycle phases of a JSP?

Life cycle of JSP contains the following phases:

1. Page translation: -converting from .jsp file to .java file
2. Page compilation: converting .java to .class file
3. Page loading : This class file is loaded.
4. Create an instance :- Instance of servlet is created
5. jspInit() method is called
6. _jspService() is called to handle service calls
7. jspDestroy() is called to destroy it when the servlet is not required.

The jspInit()- The container calls the jspInit() to initialize te servlet instance.It is called before any other method, and is called only once for a servlet instance.
The _jspservice()- The container calls the _jspservice() for each request, passing it the request and the response objects.
The jspDestroy()- The container calls this when it decides take the instance out of service. It is the last method called n the servlet instance.

13. Difference between _jspService() and other life cycle methods?

JSP contains three life cycle methods namely jspInit( ), _jspService() and jspDestroy(). In these, jspInit() and jspDestroy() can be overridden and we cannot override _jspService().

Webcontainer always generate _jspService() method with JSP content. If we are writing _jspService() method , then generated servlet contains 2 _jspService() methods which will cause compile time error.

To show this difference _jspService() method is prefixed with ‗_‘ by the JSP container and the other two methods jspInit() and jspDestroy() has no special prefixes.

The jspInit() method of the javax.servlet.jsp.JspPage interface is similar to the init() method of servlets. This method is invoked by the container only once when a JSP page is initialized. It can be overridden by a page author to initialize resources such as database and network connections, and to allow a JSP page to read persistent configuration data.

SThe _jspService() method of the javax.servlet.jsp.HttpJspPage interface is invoked every time a new request comes to a JSP page. This method takes the HttpServletRequest and HttpServletResponse objects as its arguments. A page author cannot override this method, as its implementation is provided by the container.

16. What is the jspDestroy() method?

The jspDestroy() method of the javax.servlet.jsp.JspPage interface is invoked by the container when a JSP page is about to be destroyed. This method is similar to the destroy() method of servlets. It can be overridden by a page author to perform any cleanup operation such as closing a database connection.

We can override jspInit() and jspDestroy() methods but we cannot override _jspService() method.

18. How can I override the jspInit() and jspDestroy() methods within a JSP page?

By using JSP declation tag

<%! public void jspInit() { . . . } %>
<%! public void jspDestroy() { . . . } %>

19 . Explain about translation and execution of Java Server pages?

A java server page is executed within a Java container. A Java container converts a Java file into a servlet. Conversion happens only once when the application is deployed onto the web server. During the process of compilation Java compiler checks for modifications if any modifications are present it would modify and then execute it.

20 . Why is _jspService() method starting with an '_' while other life cycle methods do not? _jspService() method will be written by the container hence any methods which are not to be overridden by the end user are typically written starting with an '_'. This is the reason why we don't override _jspService() method in any JSP page.

Add jsp_precompile as a request parameter and send a request to the JSP file. This will make the jsp pre-compile.

http://localhost:8080/jsp1/test.jsp?jsp_precompile=true

It causes excution of JSP life cycle until jspInit() method without executing _jspService() method.

22. The benefits of pre-compiling a JSP page?

It removes the start-up lag that occurs when a container must translate a JSP page upon receipt of the first request.

Inside JSP four types of scripting elements are allowed.

1. Scriptlet <% any java code %> Can be used to place java code.

2. declarative <%! Java declaration %> Can be used to declare class level variables and methods

3. expression: <%= java expression %> To print java expressions in the JSP

4. comment <%-- jsp comment --%>

24. What is a Scriptlet?

JSP scriptlet can be used to place java code.

Syntax:

Any java code

The java code present in the scriptlet will be placed directly inside _jspService() method .

25. What is a JSP declarative?

JSP declarations are used to declare class variables and methods (both instance and static) in a JSP page. These declations will be placed directly at class level in the generated servlet and these are available to the entire JSP.

Syntax:

<%! This is my declarative %>

Eg: <%! int j = 10; %>

We can declare methods by using JSP declarative tag. <%! public int add(inti,intj){ return i+j; } %>

27. What is the difference b/w variable declared inside a declaration and variable declared in scriplet ?

Variable declared inside declaration part is treated as a instance variable and will be placed directly at class level in the generated servlet.

<%! int k = 10; %>

Variable declared in a scriptlet will be placed inside _jspService() method of generated servlet.It acts as local variable.

<% int k = 10;

What is a Expression?

JSP Expression can be used to print expression to the JSP.

Syntax: <%= java expression %> Eg: <%= new java.util.Date() %>

The expression in expression tag should not ends with semi-colon The expression value will become argument to the out.pritln() method in the generated servlet

Three types of comments are allowed in JSP

1. JSP Comment:

<%-- this is jsp comment --%>

This is also known as hidden comment and it is visible only in the JSP and in rest of phases of JSP life cycle it is not visible.

1. HTML Comment:

<!-- this is HTMl comment -- >

This is also known as template text comment or output comment. It is visible in all phases of JSP including source code of generated response.

1. Java Comments.

With in the script lets we can use even java comments .

<% // single line java comment /* this is multiline comment */

This type of comments also known as scripting comments and these are visible in the generated servlet also.

29. What is output comment?

The comment which is visible in the source of the response is called output comment.

<!-- this is HTMl comment -- >

30. What is a Hidden Comment?

<%-- this is jsp comment --%>

This is also known as JSP comment and it is visible only in the JSP and in rest of phases of JSP life cycle it is not visible.

31. How is scripting disabled?

Scripting is disabled by setting the scripting-invalid element of the deployment descriptor to true. It is a subelement of jsp-property-group. Its valid values are true and false. The syntax for disabling scripting is as follows:

<jsp-property-group> <url-pattern>*.jsp</url-pattern> <scripting-invalid>true</scripting-invalid> </jsp-property-group>

32. What are the JSP implicit objects?

JSP Implicit objects are created by the web container. These implicit objects are Java objects that implement interfaces in the Servlet and JSP API. Scripting elements in a JSP page can make use of these JSP implicit objects. There are nine (9) JSP implicit objects available.

JSP Implicit Objects are as follows:

1. request

2. response

3. pageContext

4. session

5. application

6. out

7. config

8. page

9. exception

request implicit object:

The JSP implicit request object is an instance of a java class that implements the javax.servlet.http.HttpServletRequest interface. It represents the request made by the client. The request implicit object is generally used to get request parameters, request attributes, header information and query string values. Let's see the simple example of request implicit object where we are printing the name of the user with welcome message.

Example of request implicit object

index.html

1. <html>

2. <body>

3. <form action="welcome.jsp">

4. <input type="text" name="uname">

5. <input type="submit" value="go"><br/>

6. </form>

7. </body>

8. </html>

welcome.jsp

1. <html>

2. <body>

3. <% String name=request.getParameter("uname");

5. out.print("welcome "+name);

6. %>

7. </body>

8.</html>

response implicit object:

The JSP implicit response object is an instance of a java class that implements the javax.servlet.http.HttpServletResponse interface. It represents the response to be given to the client. The response implicit object is generally used to set the response content type, add cookie and redirect the response. Let's see the example of response implicit object where we are redirecting the request to the Google.

index.html

1. <html>

2. <body>

3. <form action="welcome.jsp">

4. <input type="text" name="uname">

5. <input type="submit" value="go"><br/>

6. </form>

7. </body>

8. </html>

welcome.jsp

1. <html>

2. <body>

3. <% response.sendRedirect(“http://www.google.com”);%>

4. </body>

5.</html>

out implicit object

The JSP implicit out object is an instance of the javax.servlet.jsp.JspWriter class. It represents the output content to be sent to the client. The out implicit object is used to write the output content. In case of servlet you need to write:

PrintWriter out=response.getWriter();

But in JSP, you don't need to write this code. we are simply displaying date and time.

index.jsp

1. <html>

2. <body>

3. <% out.print("Today is:"+java.util.Calendar.getInstance().getTime()); %>

4. </body>

5. </html>

session implicit object

The JSP implicit session object is an instance of a java class that implements the javax.servlet.http.HttpSession interface. It represents a client specific conversation. The session implicit object is used to store session state for a single user.The Java developer can use this object to set,get or remove attribute or to get session information.

Example of session implicit object

index.html

1. <html>

2. <body>

3. <form action="welcome.jsp">

4. <input type="text" name="uname">

5. <input type="submit" value="go"><br/>

6. </form>

7. </body>

8. </html>

welcome.jsp

1. <html>

2. <body>

3. <% String name=request.getParameter("uname");

4 out.print("Welcome "+name);

5 session.setAttribute("user",name);

6 <a href="second.jsp">second jsp page</a>

7 %>

8 </body>

9 </html>

second.jsp

1. <html>

2. <body>

3. <% String name=(String)session.getAttribute("user");

6. out.print("Hello "+name);

7. %>

9. </body>

10. </html>

application implicit object

The JSP implicit application object is an instance of a java class that implements the javax.servlet.ServletContext interface. It gives facility for a JSP page to obtain and set information about the web application in which it is running.

Example of application implicit object:

index.html

1. <html>

2. <body>

3. <form action="welcome">

4. <input type="text" name="uname">

5. <input type="submit" value="go"><br/>

6. </form>

7. </body>

8. </html>

web.xml file

1. <web-app>

3. <servlet>

4. <servlet-name>swamy</servlet-name>

5. <jsp-file>/welcome.jsp</jsp-file>

6. </servlet>

7. <servlet-mapping>

9. <servlet-name>swamy</servlet-name>

10. <url-pattern>/welcome</url-pattern>

11. </servlet-mapping>

12. <context-param>

14. <param-name>dname</param-name>

15. <param-value>sun.jdbc.odbc.JdbcOdbcDriver</param-value>

16. </context-param>

17. </web-app>

welcome.jsp

1. <html>

2. <body>

3. <%out.print("Welcome "+request.getParameter("uname"));

4 String driver=application.getInitParameter("dname");

5 out.print("driver name is="+driver);

6 %>

11. </body>

12. </html>

exception implicit object:

The JSP implicit exception object is an instance of the java.lang.Throwable class. It is available in JSP error pages only. It represents the occured exception that caused the control to pass to the JSP error page.i.e This object can be used to print the exception. But it can only be used in error pages. It is better to learn it after page directive. Let's see a simple example:

error.jsp

1. <%@ page isErrorPage="true" %>

2. <html>

3. <body>

4. Sorry following exception occured:<%= exception %>

6. </body>

8. </html>

config implicit object:

The JSP implicit config object is an instance of the java class that implements javax.servlet.ServletConfig interface. It gives facility for a JSP page to obtain the initialization parameters available.(or) This object can be used to get configuration information for a particular JSP page. This variable information can be used for one jsp page only.

Example of config implicit object:

index.html

1. <html>

2. <body>

3. <form action="welcome">

4. <input type="text" name="uname">

5. <input type="submit" value="go"><br/>

6. </form>

7. </body>

8. </html>

web.xml file

1. <web-app>

2. <servlet>

4. <servlet-name>shiva</servlet-name>

5. <jsp-file>/welcome.jsp</jsp-file>

6. <init-param>

8. <param-name>dname</param-name>

9. <param-value>sun.jdbc.odbc.JdbcOdbcDriver</param-value>

10. </init-param>

11. </servlet>

14. <servlet-mapping>

15. <servlet-name>shiva</servlet-name>

16. <url-pattern>/welcome</url-pattern>

17. </servlet-mapping>

18. </web-app>

welcome.jsp

1. <html>

2. <body>

3. <%out.print("Welcome "+request.getParameter("uname"));

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

8. out.print("driver name is="+driver);

9. %>

12. </body>

13. </html>

page implicit object

The JSP implicit page object is an instance of the java.lang.Object class. It represents the current JSP page. That is, it serves as a reference to the java servlet object that implements the JSP page on which it is accessed. It is not advisable to use this page implict object often as it consumes large memory.

It is written as:Object page=this;For using this object it must be cast to Servlet type. For example:

<% (HttpServlet)page.log("message"); %>

Since, it is of type Object it is less used because you can use this object directly in jsp.

For example:

<% this.log(“message”); %>

pageContext implicit object

The JSP implicit pageContext object is an instance of the javax.servlet.jsp.PageContext abstract class. It provides useful context information. That is it provides methods to get and set attributes in different scopes and for transferring requests to other resources. Also it contains the reference to implicit objects.
The scopes are : Page,request,session,application

In JSP, page scope is the default scope.

Example of pageContext implicit object

index.html

1. <html>

2. <body>

3. <form action="welcome.jsp">

4. <input type="text" name="uname">

5. <input type="submit" value="go"><br/>

6. </form>

7. </body>

8. </html>

welcome.jsp

1. <html>

2. <body>

3. <%String name=request.getParameter("uname");

6. out.print("Welcome "+name);

7. pageContext.setAttribute("user",name,PageContext.SESSION_SCOPE);

<a href="second.jsp">second jsp page</a>

13. </body>

14. </html>

second.jsp

1. <html>

2. <body>

3. <% String name=(String)pageContext.getAttribute("user",

PageContext.SESSION_SCOPE);

6. out.print("Hello "+name);

8. %>

9. </body>

10. </html>

33. How does JSP handle run-time exceptions?

You can use the errorPage attribute of the page directive to have uncaught run-time exceptions automatically forwarded to an error processing page.

For example: <%@ page errorPage="error.jsp" %> redirects the browser to the JSP page error.jsp if an uncaught exception is encountered during request processing.

Within error.jsp, if you indicate that it is an error-processing page, via the directive:

<%@ page isErrorPage="true" %>

In the error pages we can access exception implicit object.

34. How can I implement a thread-safe JSP page?

What are the advantages and Disadvantages of using it?

You can make your JSPs thread-safe by having them implement the SingleThreadModel interface. This is done by adding the directive in the JSP.

<%@ page isThreadSafe="false" %>

The generated servlet can handle only one client request at time so that we can make JSP as thread safe. We can overcome data inconsistency problems by this approach.

The main limitation is it may affect the performance of the system.

ServletContext: Gives the information about the container and it represents an application. PageContext: Gives the information about the Request and it can provide all other implicit JSP objects .

Yes, there is. The page implicit object is equivalent to "this", and returns a reference to the generated servlet.

Yes . By using getOutputStream() method on response implicit object we can get it.

session object is by default available to the JSP. We can make it unavailable by using page directive as follows. <%@ page session="false">

39. What's a better approach for enabling thread-safe servlets and JSPs?

SingleThreadModel Interface or Synchronization?

Synchronized keyword is recommended to use to get thread-safety.

Page directive contains the following 13 attributes.

1. language

2. extends

3. import

4. session

5. isThreadSafe

6. info

7. errorPage

8. isError page

9. contentType

10. isELIgnored

11. buffer

12. autoFlush

13. pageEncoding

41 . Explain about autoflush?

This command is used to autoflush the contents. If a value of true is used it indicates to flush the buffer whenever it is full. In case of false it indicates that an exception should be thrown whenever the buffer is full. If you are trying to access the page at the time of conversion of a JSP into servlet will result in error.

42. How do you restrict page errors display in the JSP page?

You first set "errorPage" attribute of PAGE directive to the name of the error page (ie errorPage="error.jsp")in your jsp page . Then in the error.jsp page set "isErrorpage=TRUE". When an error occur in your jsp page, then the control will be automatically forward to error page.

There are four types of scopes are allowed in the JSP.

1. page - with in the same page

2. request - after forward or include also you will get the request scope data.

3. session - after senRedirect also you will get the session scope data. All data stored in session is available to end user till session closed or browser closed.

4. application - Data will be available throughout the application. One user can store data in application scope and other can get the data from application scope.

If we want to make our data available to the entire application then we have to use application scope.

45. What are the different scope valiues for the <jsp:useBean>?

The different scope values for <jsp:useBean> are

1. page 2. request 3.session 4.application

46. How do I use a scriptlet to initialize a newly instantiated bean?

jsp:useBean action may optionally have a body. If the body is specified, its contents will be automatically invoked when the specified bean is instantiated. Typically, the body will contain

scriptlets or jsp:setProperty tags to initialize the newly instantiated bean, although you are not restricted to using those alone.

The following example shows the ―today‖ property of the Foo bean initialized to the current date when it is instantiated. Note that here, we make use of a JSP expression within the jsp:setProperty action.

<jsp:useBean id="foo" class="com.Bar.Foo" >

<jsp:setProperty name="foo" property="x" value="<%=java.text.DateFormat.getDateInstance().format(new java.util.Date()) %>" / >

<%-- scriptlets calling bean setter methods go here --%>

</jsp:useBean >

47 . Can a JSP page instantiate a serialized bean?

No problem! The use Bean action specifies the beanName attribute, which can be used for indicating a serialized bean. For example: A couple of important points to note. Although you would have to name your serialized file "filename.ser", you only indicate "filename" as the value for the beanName attribute. Also, you will have to place your serialized file within the WEB-INF/jspbeans directory for it to be located by the JSP engine.

48.How do we include static files within a jsp page ?

We can include static files in JSP by using include directive (static include)

<%@ include file=‖header.jsp‖ %>

The content of the header.jsp will be included in the current jsp at translation time. Hence this inclusion is also known as static include.

In JSP, we can perform inclusion in the following ways.

1. By include directive:

<%@ include file=‖header.jsp‖ %>

The content of the header.jsp will be included in the current jsp at translation time. Hence this inclusion is also known as static include.

1. By include action:

<jsp:include page=‖header.jsp‖ />

The response of the jsp will be included in the current page response at request processing time(run time) hence it is also known as dynamic include.

1. by using pageContext implicit object

<% pageContext.include(―/header.jsp‖);

This inclusion also happened at request processing time(run time).

1. by using RequestDispatcher object

<% RequestDispatcher rd = request.getRequestDispatcher(―/header.jsp‖); Rd.incliude(request,response);

50.In which situation we can use static include and dynamic include in JSPs ?

If the target resource ( included resource) won‘t change frequently, then it is recommended to use static include. <%@ include file=‖header.jsp‖ %>

If the target resource(Included page) will change frequently , then it is recommended to use dynamic include.

< jsp:include page=‖header.jsp‖ />

1. What is MVC?

Model-View-Controller (MVC) is a design pattern put together to help control change. MVC decouples interface from business logic and data. Model: The model contains the core of the application's functionality. The model enca psulates the state of the application. Sometimes the only functionality it contains is state. It knows nothing about the view or controller. View: The view provides the presentation of the model. It is the look of the application. The view can access the model getters, but it has no knowledge of the setters. In addition, it knows nothing about the controller. The view should be notified when changes to the model occur. Controller: The controller reacts to the user input. It creates and sets the model.

Q 2. What is a framework?

Framework is made up of the set of classes which allow us to use a library in a best possible way for a specific requirement.

Q 3. What is Struts framework?

Struts framework is an open-source framework for developing the web applications in Java EE, based on MVC-2 architecture. It uses and extends the Java Servlet API. Struts is robust architecture and can be used for the development of application of any size. Struts framework makes it much easier to design scalable, reliable Web applications with Java. Struts provides its own Controller component and integrates with other technologies to provide the Model and the View. For the Model, Struts can interact with standard data access technologies, like JDBC and EJB, as well as most any third-party packages, like Hibernate, iBATIS, or Object Relational Bridge. For the View, Struts works well with JavaServer Pages, including JSTL and JSF, as well as Velocity Templates, XSLT, and other presentation systems.

Jakarta Struts is open source implementation of MVC (Model-View-Controller) pattern for the development of web based applications. Jakarta Struts is robust architecture and can be used for the development of application of any size. Struts framework makes it much easier to design scalable, reliable Web applications with Java.

The class org.apache.struts.action.ActionServlet is the called the ActionServlet. In the the Jakarta Struts Framework this class plays the role of controller. All the requests to the server goes through the controller. Controller is responsible for handling all the requests.

ActionServlet performs the role of Controller:

 Process user requests

 Determine what the user is trying to achieve according to the request

 Pull data from the model (if necessary) to be given to the appropriate view,

 Select the proper view to respond to the user

 Delegates most of this grunt work to Action classes

 Is responsible for initialization and clean-up of resources

Q 7. What is Action Class?

Any java class which extends from org.apache.struts.action.Action is called Action class. The Action is part of the controller. The purpose of Action Class is to translate the HttpServletRequest to the business logic. To use the Action, we need to Subclass and overwrite the execute() method. The ActionServlet (commad) passes the parameterized class to Action Form using the execute() method. There should be no database interactions in the action. The action should receive the request, call business objects (which then handle database, or interface with J2EE, etc) and then determine where to go next. Even better, the business objects could be handed to the action at runtime (IoC style) thus removing any dependencies on the model. The return type of the execute method is ActionForward which is used by the Struts Framework to forward the request to the file as per the value of the returned ActionForward object..

Q 8. Write code of any Action Class?

package com.microsoft007;
import javax.servlet.http.*;
import org.apache.struts.action.*;
public class TestAction extends Action {
public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request,HttpServletResponse response) throws Exception {
return mapping.findForward("success");
} }

Q 9. What is ActionForm?

Any java class which extends from org.apache.struts.action.ActionForm is called ActionForm. An ActionForm is also called JavaBean. ActionForm maintains the session state for web application and the ActionForm object is automatically populated on the server side with data entered from a form on the client side.

Struts Framework provides the functionality to validate the form data. It can be use to validate the data on the users browser as well as on the server side. Struts Framework emits the java scripts and it can be used validate the form data on the client browser. Server side validation of form can be accomplished by sub classing your From Bean with DynaValidatorForm class. The Validator framework was developed by David Winterfeldt as third-party add-on to Struts. Now the Validator framework is a part of Jakarta Commons project and it can be used with or without Struts. The Validator framework comes integrated with the Struts Framework and can be used without doing any extra settings.

Following tag displays all the errors: <html:errors/>

Q12. What is RequestProcessor?

The controller is responsible for intercepting and translating user input into actions to be performed by the model. The controller is responsible for selecting the next view based on user input and the outcome of model operations. The Controller receives the request from the browser, invoke a business operation and coordinating the view to return to the client.The controller is implemented by a java servlet, this servlet is centralized point of control for the web application. In struts framework the controller responsibilities are implemented by several different components like The ActionServlet Class The RequestProcessor Class The Action Class The ActionServlet extends the javax.servlet.http.httpServlet class. The ActionServlet class is not abstract and therefore can be used as a concrete controller by your application. The controller is implemented by the ActionServlet class. All incoming requests are mapped to the central controller in the deployment descriptor as follows.
<servlet>
<servlet-name>action</servlet-name>
<servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
</servlet>
All request URIs with the pattern *.do are mapped to this servlet in the deployment descriptor as follows. <servlet-mapping>
<servlet-name>action</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping> A request URI that matches this pattern will have the following form. http://localhost:8080/mycontext/actionName.do The preceding mapping is called extension mapping, however, you can also specify path mapping where a pattern ends with /* as shown below.
<servlet-mapping>

<servlet-name>action</servlet-name>
<url-pattern>/do/*</url-pattern>
<url-pattern>*.do</url-pattern>
A request URI that matches this pattern will have the following form. http://localhost:8080/mycontext/do/action_Name The class org.apache.struts.action.requestProcessor process the request from the controller. You can sublass the RequestProcessor with your own version and modify how the request is processed. Once the controller receives a client request, it delegates the handling of the request to a helper class. This helper knows how to execute the business operation associated with the requested action. In the Struts framework this helper class is descended of org.apache.struts.action.Action class. It acts as a bridge between a client-side user action and business operation. The Action class decouples the client request from the business model. This decoupling allows for more than one-to-one mapping between the user request and an action. The Action class also can perform other functions such as authorization, logging before invoking business operation. the Struts Action class contains several methods, but most important method is the execute() method. public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception The execute() method is called by the controller when a request is received from a client. The controller creates an instance of the Action class if one doesn?t already exist. The strut framework will create only a single instance of each Action class in your application. Action are mapped in the struts configuration file and this configuration is loaded into memory at startup and made available to the framework at runtime. Each Action element is represented in memory by an instance of the org.apache.struts.action. ActionMapping class. The ActionMapping object contains a path attribute that is matched against a portion of the URI of the incoming request.
<action> path= "/somerequest" type="com.somepackage.someAction" scope="request" name="someForm" validate="true" input="somejsp.jsp">
<forward name="Success" path="/action/xys" redirect="true"/>
<forward name="Failure" path="/somejsp.jsp" redirect="true"/>
</action>
Once this is done the controller should determine which view to return to the client. The execute method signature in Action class has a return type org.apache. struts.action.ActionForward class. The ActionForward class represents a destination to which the controller may send control once an action has completed. Instead of specifying an actual JSP page in the code, you can declaratively associate as action forward through out the application. The action forward are specified in the configuration file.
<action> path= "/somerequest" type="com.somepackage.someAction" scope="request" name="someForm"

validate="true" input="somejsp.jsp">
<forward name="Success" path="/action/xys" redirect="true"/>
<forward name="Failure" path="/somejsp.jsp" redirect="true"/>
</action>
The action forward mappings also can be specified in a global section, independent of any specific action mapping.
<global-forwards>
<forward name="Success" path="/action/somejsp.jsp" />
<forward name="Failure" path="/someotherjsp.jsp" />
</global-forwards>

In Struts you can handle the exceptions in two ways:
a) Declarative Exception Handling: You can either define global exception handling tags in your struts-config.xml or define the exception handling tags within <action>..</action> tag.
Example: <exception key="database.error.duplicate" path="/UserExists.jsp" type="mybank.account.DuplicateUserException"/>
b) Programmatic Exception Handling: Here you can use try{}catch{} block to handle the exception.

The different kinds of actions in Struts are: ForwardAction, IncludeAction, DispatchAction, LookupDispatchAction, SwitchAction

Q15. What is DispatchAction?

The DispatchAction class is used to group related actions into one class. Using this class, you can have a method for each logical action compared than a single execute method. The DispatchAction dispatches to one of the logical actions represented by the methods. It picks a method to invoke based on an incoming request parameter. The value of the incoming parameter is the name of the method that the DispatchAction will invoke.

Q16. How to use DispatchAction?

To use the DispatchAction, follow these steps :

1. Create a class that extends DispatchAction (instead of Action)

2. In a new class, add a method for every function you need to perform on the service – The method has the same signature as the execute() method of an Action class.

3. Do not override execute() method – Because DispatchAction class itself provides execute() method.

4. Add an entry to struts-config.xml

The LookupDispatchAction is a subclass of DispatchAction. It does a reverse lookup on the resource bundle to get the key and then gets the method whose name is associated with the key into the Resource Bundle.

Q18. What is the use of LookupDispatchAction?

LookupDispatchAction is useful if the method name in the Action is not driven by its name in the front end, but by the Locale independent key into the resource bundle. Since the key is always the same, the LookupDispatchAction shields your application from the side effects of I18N.

The difference between LookupDispatchAction and DispatchAction is that the actual method that gets called in LookupDispatchAction is based on a lookup of a key value instead of specifying the method name directly.

Q20. What is SwitchAction?

The SwitchAction class provides a means to switch from a resource in one module to another resource in a different module. SwitchAction is useful only if you have multiple modules in your Struts application. The SwitchAction class can be used as is, without extending.

Q21. What if <action> element has <forward> declaration with same name as global forward?

In this case the global forward is not used. Instead the <action> element‘s <forward> takes precendence.

An ActionForm represents an HTML form that the user interacts with over one or more pages. You will provide properties to hold the state of the form with getters and setters to access them. Whereas, using DynaActionForm there is no need of providing properties to hold the state. Instead these properties and their type are declared in the struts-config.xml. The DynaActionForm bloats up the Struts config file with the xml based definition. This gets

annoying as the Struts Config file grow larger. The DynaActionForm is not strongly typed as the ActionForm. This means there is no compile time checking for the form fields. Detecting them at runtime is painful and makes you go through redeployment. ActionForm can be cleanly organized in packages as against the flat organization in the Struts Config file. ActionForm were designed to act as a Firewall between HTTP and the Action classes, i.e. isolate and encapsulate the HTTP request parameters from direct use in Actions. With DynaActionForm, the property access is no different than using request.get Parameter( .. ).

 DynaActionForm construction at runtime requires a lot of Java Reflection (Introspection) machinery that can be avoided.

The lifecycle of ActionForm invoked by the RequestProcessor is as follows:

 Retrieve or Create Form Bean associated with Action

 "Store" FormBean in appropriate scope (request or session)

 Reset the properties of the FormBean

 Populate the properties of the FormBean

 Validate the properties of the FormBean

 Pass FormBean to Action

<struts-config>

<form-beans> <form-bean name="login" type=" LoginForm" />

</form-beans>

<global-forwards>

</global-forwards>

<action-mappings>

<action

path="/login"

type="LoginAction" >

</action>

</action-mappings>

<message-resources parameter="MessageResources" />

<plug-in className="org.apache.struts.validator.ValidatorPlugIn">

<set-property

property="pathnames"

value="/org/apache/struts/validator/validator-rules.xml,

/WEB-INF/validation.xml"/>

</plug-in>

</struts-config>

Q25. What are the core classes of the Struts Framework?

A: Core classes of Struts Framework are ActionForm, Action, ActionMapping, Action Forward, ActionServlet etc.

Q26. What is action mappings?

An action mapping is a configuration file entry that, in general, associates an action name with an action. An action mapping can contain a reference to a form bean that the action can use, and can additionally define a list of local forwards that is visible only to this action.

validate () and reset() methods defined inActionForm class. validate() : Used to validate properties after they have been populated; Called before FormBean is handed to Action. Returns a collection of ActionMessage as ActionErrors. Following is the method signature for the validate() method. public ActionErrors validate(ActionMapping mapping, HttpServletRequest request) reset(): reset() method is called by Struts Framework with each request that uses the defined ActionForm. The purpose of this method is to reset all of the ActionForm's data members prior to the new request values being set. public void reset() {}

The Validator Framework uses two XML configuration files validator-rules.xml and validation.xml. The validator-rules.xml defines the standard validation routines, these are reusable and used in validation.xml. to define the form specific validations. The validation.xml defines the validations applied to a form bean.

Q29. How you will enable front-end validation based on the xml in validation.xml?

The <html:javascript> tag to allow front-end validation based on the xml in validation.xml. For example the code: <html:javascript formName="logonForm" dynamicJavascript="true" staticJavascript="true" /> generates the client side java script for the form "logonForm" as defined in the validation.xml file. The <html:javascript> when added in the jsp file generates the client site validation script.

perform() method defined in Struts 1.0. but it is was deprecated in the Struts Version 1.1. In Struts 1.x, Action.perform() is the method called by the ActionServlet. This is typically where your business logic resides, or at least the flow control to your JavaBeans and EJBs that handle your business logic. As we already mentioned, to support declarative exception handling, the method signature changed in perform. Now execute just throws Exception. Action.perform() is now deprecated; however, the Struts v1.1 ActionServlet is smart enough to know whether or not it should call perform or execute in the Action, depending on which one is available.

Q31. What are the various Struts tag libraries?

Struts is very rich framework and it provides very good and user friendly way to develop web

application forms. Struts provide many tag libraries to ease the development of web applications. These tag libraries are:
* Bean tag library - Tags for accessing JavaBeans and their properties.
* HTML tag library - Tags to output standard HTML, including forms, text boxes, checkboxes, radio buttons etc..
* Logic tag library - Tags for generating conditional output, iteration capabilities and flow management
* Tiles or Template tag library - For the application using tiles
* Nested tag library - For using the nested beans in the application

Q32. What are the difference between <bean:message> and <bean:write>?

<bean:message>: This tag is used to output locale-specific text (from the properties files) from a MessageResources bundle. <bean:write>: This tag is used to output property values from a bean. <bean:write> is a commonly used tag which enables the programmers to easily present the data.

Q33. What are difference between ActionErrors and ActionMessage?

ActionMessage: A class that encapsulates messages. Messages can be either global or they are specific to a particular bean property. Each individual message is described by an ActionMessage object, which contains a message key (to be looked up in an appropriate message resources database), and up to four placeholder arguments used for parametric substitution in the resulting message. ActionErrors: A class that encapsulates the error messages being reported by the validate() method of an ActionForm. Validation errors are either global to the entire ActionForm bean they are associated with, or they are specific to a particular bean property (and, therefore, a particular input field on the corresponding form).

Q34. What is the use of ForwardAction?

The ForwardAction class is useful when you‘re trying to integrate Struts into an existing application that uses Servlets to perform business logic functions. You can use this class to take advantage of the Struts controller and its functionality, without having to rewrite the existing Servlets. Use ForwardAction to forward a request to another resource in your application, such as a Servlet that already does business logic processing or even another JSP page. By using this predefined action, you don‘t have to write your own Action class. You just have to set up the struts-config file properly to use ForwardAction.

Q35. What is IncludeAction?

The IncludeAction class is useful when you want to integrate Struts into an application that uses Servlets. Use the IncludeAction class to include another resource in the response to the request being processed.

Q36. What are the steps need to use DynaActionForm?

Using a DynaActionForm instead of a custom subclass of ActionForm is relatively straightforward. You need to make changes in two places: In struts-config.xml: change your <form-bean> to be an org.apache.struts.action.Dyna ActionForm instead of some subclass of ActionForm

 <form-bean name="loginForm"

type="org.apache.struts.action.DynaActionForm" >
<form-property name="userName" type="java.lang.String"/> <form-property name="password" type="java.lang.String" />
</form-bean>

 In your Action subclass that uses your form bean:

o import org.apache.struts.action.DynaActionForm

o downcast the ActionForm parameter in execute() to a DynaActionForm

o access the form fields with get(field) rather than getField()

The ActionServlet plays the role of controller wich is responsible for handling the request and selecting the correct Application Module and storing ApplicationConfig and MessageResource bundle in the request object. If we modify the ActionServlet the Controller may or may not work what happens that depends on your modification, You have not specify whether you want to create your own custom ActionServlet by extending ActionServlet and overriding the methods in it or what exactly you want to modify.

1.what is the advantage of Hibernate over jdbc?

There are so many
1) Hibernate is data base independent, your code will work for all ORACLE,MySQL ,SQLServer etc. In case of JDBC query must be data base specific. So hibernate based persistance logic is database independent persistance logic and JDBC based persistance logic is database dependent logic.
2) As Hibernate is set of Objects , 3) No need to learn SQL language.You can treat TABLE as a Object . Only Java knowledge is need. In case of JDBC you need to learn SQL.
3) Dont need Query tuning in case of Hibernate. If you use Criteria Quires in Hibernate then hibernate automatically tuned your query and return best result with performance. In case of JDBC you need to tune your queries.
4) You will get benefit of Cache. Hibernate support two level of cache. First level and 2nd level. So you can store your data into Cache for better performance. In case of JDBC you need to implement your java cache
5) Hibernate supports Query cache and It will provide the statistics about your query and database status. JDBC Not provides any statistics.
6) Development fast in case of Hibernate because you dont need to write queries
7) No need to create any connection pool in case of Hibernate. You can use c3p0. In case of JDBC you need to write your own connection pool
8) In the xml file you can see all the relations between tables in case of Hibernate. Easy readability.
9) You can load your objects on start up using lazy=false in case of Hibernate. JDBC Dont have such support.
10 ) Hibernate Supports automatic versioning of rows but JDBC Not.

2.What is Hibernate?

Hibernate is an open source, light weight Object Relational Mapping tool to develop the database independent persistence login in java and j2ee based applications. Hibernate is a pure Java object-relational mapping (ORM) and persistence framework that allows you to map plain old Java objects to relational database tables using (XML) configuration and mapping files. Its purpose is to relieve the developer from a significant amount of relational data persistence-related programming tasks

3.What is ORM ?

ORM stands for object/relational mapping, means providing the mapping between class with table and member variables with columns is called ORM. ORM is the automated persistence of objects in a Java application to the tables in a relational database.

4.What does ORM consists of ?

An ORM solution consists of the following four pieces:

 API for performing basic CRUD operations

 API to express queries referring to classes

 Facilities to specify metadata

 Optimization facilities : dirty checking,lazy associations fetching

5.What are the ORM levels ?

The ORM levels are:

 Pure relational (stored procedure.)

 Light objects mapping (JDBC)

 Medium object mapping

 Full object Mapping (composition,inheritance, polymorphism, persistence by reachability)

6.Why do you need ORM tools like hibernate?

The main advantage of ORM like hibernate is that it can develop the database independent persistence logic. Apart from this, ORM provides following benefits:

 Improved productivity

o High-level object-oriented API

o Less Java code to write

o No SQL to write

 Improved performance

o Sophisticated caching

o Lazy loading

o Eager loading

 Improved maintainability

o A lot less code to write

 Improved portability

 ORM framework generates database-specific SQL for you

7.What Does Hibernate Simplify?

Hibernate simplifies:

 Saving and retrieving your domain objects

 Making database column and table name changes

 Centralizing pre save and post retrieve logic

 Complex joins for retrieving related items

 Schema creation from object model

8.What is the main difference between Entity Beans and Hibernate ?

1)In Entity Bean at a time we can interact with only one data Base. Where as in Hibernate we can able to establishes the connections to more than One Data Base. Only thing we need to write one more configuration file.
2) EJB need container like Weblogic, WebSphare but hibernate don't nned. It can be run on tomcat.
3) Entity Beans does not support OOPS concepts where as Hibernate does.
4) Hibernate supports multi level cacheing, where as Entity Beans doesn't.
5) In Hibernate C3P0 can be used as a connection pool.
6) Hibernate is container independent. EJB not.

9.What are the Core interfaces and classes of Hibernate framework?

The five core interfaces are used in just about every Hibernate application. Using these interfaces, you can store and retrieve persistent objects and control transactions.

 Configuration class (org.hibernate.cfg package)

 Session interface (org.hibernate package)

 SessionFactory interface (org.hibernate package)

 Transaction interface (org.hibernate package)

 Query and Criteria interfaces (org.hibernate package)

The general flow of Hibernate communication with RDBMS is :

 Load the Hibernate configuration file and create configuration object. It will automatically load all hbm mapping files because mapping file can be configured in configuration file.

 Create session factory from configuration object

 Get one session from this session factory

 Create HQL Query

 Execute query to get list containing Java objects.

11.What is the need for Hibernate mapping file?

Hibernate mapping file is used to provides the mapping between java class with table member variables with column names of the table. And also we can configure primary key generation algorithm, relations and so on. Typical mapping file look as follows:

12.What are the important tags of hibernate.cfg.xml?

This file can be used to provide the database information like driverclass name, url, database usename, database password, dialect, connection pooling mapping file and so on. Following are the important tags of hibernate.cfg.xml:

13.What role does the Session interface play in Hibernate?

The main runtime interface between a Java application and Hibernate The Session interface is the primary interface used by Hibernate applications. It is a single-threaded, short-lived object representing a conversation between the application and the persistent store. It allows you to create query objects to retrieve persistent objects. The main function of the Session is to offer create, read and delete operations for instances of mapped entity classes. Instances may exist in one of three states: transient: never persistent, not associated with any Session persistent: associated with a unique Session detached: previously persistent, not associated with any Session Session session = sessionFactory.openSession(); Session interface role:

 Wraps a JDBC connection

 Factory for Transaction

 Holds a mandatory (first-level) cache of persistent objects, used when navigating the object graph or looking up objects by identifier

14.What role does the SessionFactory interface play in Hibernate?

SessionFactorys are immutable. The behaviour of a SessionFactory is controlled by properties supplied at configuration time. These properties are defined on Environment. The application obtains Session instances from a SessionFactory. There is typically a single SessionFactory for the whole application—created during application initialization. The SessionFactory caches generate SQL statements and other mapping metadata that Hibernate uses at runtime. It also holds cached data that has been read in one unit of work and may be reused in a future unit of work Implementors must be threadsafe. SessionFactory sessionFactory = configuration.buildSessionFactory();

15.What are the most common ways to specify the Hibernate configuration properties?

The most common methods of Hibernate configuration are:

 Programmatic configuration

By using setProperty(-) method of org.hibernate.cfg.Configuration.

 XML configuration (hibernate.cfg.xml)

 By using .properties file

 By Using annotaions.(from Hibernate 3.3 on words)

16.How do you map Java Objects with Database tables?

 First we need to write Java domain objects (beans with setter and getter).

 Write hbm.xml, where we map java class to table and database columns to Java class variables.

Example : <hibernate-mapping>
<class name="com.sample.EmployeeBean" table="EMPLOYEE">
<id name=‖eid‖ colume=‖id‖/>
<property name="ename" column="NAME" length="255" not-null="true" type="java.lang.String"/> <property name="address" column="ADDR" length="255" not-null="true" type="java.lang.String"/> </class>
</hibernate-mapping>

17.How do you define sequence generated primary key algorithm in hibernate?

By using <id>, <generator> tags we can configure the primary key and primary key generation algorithm. Example:- <id name="userid" column="USER_ID" type="java.lang.Long">
<generator class="sequence">
<param name="table">SEQ_NAME</param>
<generator> </id>

18.What is component mapping in Hibernate?

 A component is an object saved as a value, not as a reference

 A component can be saved directly without needing to declare interfaces or identifier properties

 Required to define an empty constructor

 Shared references not supported

19 . Difference between getCurrentSession() and openSession() in Hibernate ?

getCurrentSession() : Obtains the current session. The "current session" refers to a Hibernate Session bound by Hibernate behind the scenes, to the transaction scope. A Session is opened when getCurrentSession() is called for the first time and closed when the transaction ends. It is also flushed automatically before the transaction commits. You can call getCurrentSession() as often and anywhere you want as long as the transaction runs. Only the

Session that you obtained with sf.getCurrentSession() is flushed and closed automatically. openSession() : If you decide to use manage the Session yourself the go for sf.openSession() , you have to flush() and close() it. It does not flush and close() automatically.
Example :
Transaction tx =session.berginTransaction();
Session session = factory.openSession();
try { tx.begin(); // Do some work
session.createQuery(...);
session.persist(...);
session.flush(); // Extra work you need to do
tx.commit();
}
catch (RuntimeException e) {
tx.rollback();
throw e; // or display error message
}
finally {
session.close(); // Extra work you need to do
}

20.What are the types of Hibernate instance states ?

Three types of instance states:

 Transient -The instance is not associated with any persistence context

 Persistent -The instance is associated with a persistence context

 Detached -The instance was associated with a persistence context which has been closed – currently not associated

21.What are the types of inheritance models in Hibernate?

There are three types of inheritance models in Hibernate:

 Table per class hierarchy

 Table per subclass

 Table per concrete class

22.What is Hibernate Query Language (HQL)?

Hibernate Query Language is query language which is used to develop the data independent query language in the application. This HQL queries are not related to any database. Hibernate offers a query language that embodies a very powerful and flexible mechanism to query, store, update, and retrieve objects from a database. This language, the Hibernate query Language (HQL), is an object-oriented extension to SQL.

23.What are the ways to express joins in HQL?

HQL provides four ways of expressing (inner and outer) joins:-

 An implicit association join

 An ordinary join in the FROM clause

 A fetch join in the FROM clause.

 A theta-style join in the WHERE clause.

24 . Transaction with plain JDBC in Hibernate ?

If you don't have JTA and don't want to deploy it along with your application, you will usually have to fall back to JDBC transaction demarcation. Instead of calling the JDBC API you better use Hibernate's Transaction and the built-in session-per-request functionality: To enable the thread-bound strategy in your Hibernate configuration: set hibernate.transaction.factory_class to org.hibernate.transaction.JDBCTransactionFactory set hibernate.current_session_context_class to thread Session session = factory.openSession();
Transaction tx = null;
try {
tx = session.beginTransaction(); // Do some work
session.load(...);
session.persist(...);
tx.commit(); // Flush happens automatically
}
catch (RuntimeException e) {
tx.rollback();
throw e; // or display error message
}
finally {
session.close();
}

25 . What are the general considerations or best practices for defining your Hibernate persistent classes?

1.You must have a default no-argument constructor for your persistent classes and there should be getXXX()and setXXX() methods for all your persistable instance variables.
2.You should implement the equals() and hashCode() methods based on your business key and it is important not to use the id field in your equals() and hashCode() definition if the id field is a surrogate key (i.e. Hibernate managed identifier). This is because the Hibernate only generates and sets the field when saving the object.
3. It is recommended to implement the Serializable interface. This is potentially useful if you want to migrate around a multi-processor cluster.
4.The persistent class should not be final because if it is final then lazy loading cannot be used by creating proxy objects.

The session.update method is used to update the persistence object in the in the database. The session.lock() method simply reattaches the object to the session without checking or updating the database on the assumption that the database in sync with the detached object. It is the best practice to use either session.update(..) or session.saveOrUpdate(). Use session.lock() only if you are absolutely sure that the detached object is in sync with your detached object or if it does not matter because you will be overwriting all the columns that would have changed later on within the same transaction.

27.What are the Collection types in Hibernate ?

 Set

 List

 Array

 Map

 Bag

sorted collection vs. order collection :-

sorted collection

order collection

A sorted collection is sorting a collection by utilizing the sorting features provided by the Java collections framework. The sorting occurs in the

Order collection is sorting a collection by specifying the order-by clause for sorting this collection when retrieval.

memory of JVM which running Hibernate, after the data being read from database using java comparator.

If your collection is not large, it will be more efficient way to sort it.

If your collection is very large, it will be more efficient way to sort it .

29.What are the ways to express joins in HQL?

HQL provides four ways of expressing (inner and outer) joins:-

 An implicit association join

 An ordinary join in the FROM clause

 A fetch join in the FROM clause.

 A theta-style join in the WHERE clause.

30.What do you mean by Named – SQL query?

Named SQL queries are defined in the mapping xml document and called wherever required.
Example:
<sql-query name = "empdetails">
<return alias="emp" class="com.sample.Employee"/>
SELECT emp.EMP_ID AS {emp.empid}, emp.EMP_ADDRESS AS {emp.address}, emp.EMP_NAME AS {emp.name} FROM Employee EMP WHERE emp.NAME LIKE :name
</sql-query>

Invoke Named Query : List people = session.getNamedQuery("empdetails") .setString("TomBrady", name) .setMaxResults(50) .list();

31.How do you invoke Stored Procedures?

<sql-query name="selectAllEmployees_SP" callable="true">
<return alias="emp" class="employee">
<return-property name="empid" column="EMP_ID"/>
<return-property name="name" column="EMP_NAME"/>
<return-property name="address" column="EMP_ADDRESS"/>
{ ? = call selectAllEmployees() }
</return>
</sql-query>

32.Explain Criteria API?

The interface org.hibernate.Criteria represents a query against a particular persistent class. The Session is a factory for Criteria instances. Criteria is a simplified API for retrieving entities by

composing Criterion objects. This is a very convenient approach for functionality like "search" screens where there is a variable number of conditions to be placed upon the result set.
Example : List employees = session.createCriteria(Employee.class) .add(Restrictions.like("name", "a%") ) .add(Restrictions.like("address", "Boston")) .addOrder(Order.asc("name") ) .list();

33.What’s the difference between load() and get()?

Load()	Get()
1)Only use the load() method if you are sure that the object exists. 2) load() method will throw an exception called as ObjectNotFoundException if the unique id is not found in the database. 3) load() just returns a proxy by default and database won‘t be hit until the proxy is first invoked.	If you are not sure that the object exists, then use one of the get() methods. get() method will return null if the unique id is not found in the database. 3) get() will hit the database immediately.

34.What is the difference between and merge and update ?

Use update() if you are sure that the session does not contain an already persistent instance with the same identifier, and merge() if you want to merge your modifications at any time without consideration of the state of the session.

35.Define cascade and inverse option in one-many mapping?

cascade - enable operations to cascade to child entities. cascade="all|none|save-update|delete|all-delete-orphan" inverse - mark this collection as the "inverse" end of a bidirectional association. inverse="true|false" Essentially "inverse" indicates which end of a relationship should be ignored, so when persisting a parent who has a collection of children, should you ask the parent for its list of children, or ask the children who the parents are?

36.Define HibernateTemplate?

org.springframework.orm.hibernate.HibernateTemplate is a helper class which provides different methods for querying/retrieving data from the database. It also converts checked HibernateExceptions into unchecked DataAccessExceptions.

37.What are the benefits does HibernateTemplate provide?

The benefits of HibernateTemplate are :

 HibernateTemplate, a Spring Template class simplifies interactions with Hibernate Session.

 Common functions are simplified to single method calls.

 Sessions are automatically closed.

 Exceptions are automatically caught and converted to runtime exceptions.

38. How do you switch between relational databases without code changes?

Using Hibernate SQL Dialects , we can switch databases. Hibernate will generate appropriate hql queries based on the dialect defined.

39.If you want to see the Hibernate generated SQL statements on console, what should we do?

By using ―show_sql‖ property of the hibernate configuration file In Hibernate configuration file set as follows: <property name="show_sql">true</property>

40.What are derived properties?

The properties that are not mapped to a column, but calculated at runtime by evaluation of an expression are called derived properties. The expression can be defined using the formula attribute of the element.

41.Define cascade and inverse option in one-many mapping?

42 . Explain about transaction file?

Transactions denote a work file which can save changes made or revert back the changes. A transaction can be started by session.beginTransaction() and it uses JDBC connection, CORBA or JTA. When this session starts several transactions may occur.

43 . Difference between session.save() , session.saveOrUpdate() and session.persist()?

All methods are used to store the data in to database session.save() : save() method uSave does an insert and will fail if the primary key is already persistent. session.saveOrUpdate() : saveOrUpdate() insert the data in the database if that primary key data not available and it update the data if primary key data not availabt session.persist() :it is the same like session.save(). But session.save() return Serializable object but session.persist() return void.
For Example :
if you do :- System.out.println(session.save(question)); This will print the generated primary key.
if you do :- System.out.println(session.persist(question)); Compile time error because session.persist() return void.

44 . Explain about the id field?

This id field is used to configure the primary key in the mapping file, and also we can configure primary key generation algorithm.

45.What is the use of dynamic-insert and dynamic-update attributes in a class mapping?

Criteria is a simplified API for retrieving entities by composing Criterion objects. This is a very convenient approach for functionality like "search" screens where there is a variable number of conditions to be placed upon the result set.

 dynamic-update (defaults to false): Specifies that UPDATE SQL should be generated at runtime and contain only those columns whose values have changed

 dynamic-insert (defaults to false): Specifies that INSERT SQL should be generated at runtime and contain only the columns whose values are not null.

46.What is automatic dirty checking?

Automatic dirty checking is a feature that saves us the effort of explicitly asking Hibernate to update the database when we modify the state of an object inside a transaction.

47.What are Callback interfaces?

Callback interfaces allow the application to receive a notification when something interesting happens to an object—for example, when an object is loaded, saved, or deleted. Hibernate applications don't need to implement these callbacks, but they're useful for implementing certain kinds of generic functionality.

48.What is Hibernate proxy?

The proxy attribute enables lazy initialization of persistent instances of the class. Hibernate will initially return CGLIB proxies which implement the named interface. The actual persistent object will be loaded when a method of the proxy is invoked.

49.How can Hibernate be configured to access an instance variable directly and not through a setter method ?

By mapping the property with access="field" in Hibernate metadata. This forces hibernate to bypass the setter method and access the instance variable directly while initializing a newly loaded object.

50.How can a whole class be mapped as immutable?

Mark the class as mutable="false" (Default is true),. This specifies that instances of the class are (not) mutable. Immutable classes, may not be updated or deleted by the application.

Transparent persistence is provided for Plain old Java objects or POJOs. For proper functioning of the applications importance should be given to the methods equals () and hash Code methods (). It has a requirement which should be strictly followed in the applications which is a no-argument constructor.

52 . Explain about the dirty checking feature of Hibernate?

Dirty checking feature of the Hibernate allows users or developers to avoid time consuming data base write actions. This feature makes necessary updations and changes to the fields which require a change, remaining fields are left unchanged or untouched.

53 . What is the effect when a transient mapped object is passed onto a Sessions save?

When a Sessions save () is passed to a transient mapped object it makes the method to become more persistent. Garbage collection and termination of the Java virtual machine stays as long as it is deleted explicitly. It may head back to its transient state.

54 . Explain about addClass function?

This function translates a Java class name into file name. This translated file name is then loaded as an input stream from the Java class loader. This addClass function is important if you want efficient usage of classes in your code.

1. What is IOC (or Dependency Injection)?

The basic concept of the Inversion of Control pattern (also known as dependency injection) is that you do not create your objects but describe how they should be created. You don't directly connect your components and services together in code but describe which services are needed by which components in a configuration file. A container (in the case of the Spring framework, the IOC container) is then responsible for hooking it all up. i.e., Applying IoC, objects are given their dependencies at creation time by some external entity that coordinates each object in the system. That is, dependencies are injected into objects. So, IoC means an inversion of responsibility with regard to how an object obtains references to collaborating objects.

2. What are the different types of IOC (dependency injection) ?

There are three types of dependency injection:

 Constructor Injection (e.g. Pico container, Spring etc): Dependencies are provided as constructor parameters.

 Setter Injection (e.g. Spring): Dependencies are assigned through JavaBeans properties (ex: setter methods).

 Interface Injection (e.g. Avalon): Injection is done through an interface.

Note: Spring supports only Constructor and Setter Injection

3. What are the benefits of IOC (Dependency Injection)?

Benefits of IOC (Dependency Injection) are as follows:

 Minimizes the amount of code in your application. With IOC containers you do not care about how services are created and how you get references to the ones you need. You can also easily add additional services by adding a new constructor or a setter method with little or no extra configuration.

 Make your application more testable by not requiring any singletons or JNDI lookup mechanisms in your unit test cases. IOC containers make unit testing and switching implementations very easy by manually allowing you to inject your own objects into the object under test.

 Loose coupling is promoted with minimal effort and least intrusive mechanism. The factory design pattern is more intrusive because components or services need to be requested explicitly whereas in IOC the dependency is injected into requesting piece of code. Also some containers promote the design to interfaces not to implementations design concept by encouraging managed objects to implement a well-defined service interface of your own.

 IOC containers support eager instantiation and lazy loading of services. Containers also provide support for instantiation of managed objects, cyclical dependencies, life cycles management, and dependency resolution between managed objects etc.

4. What is Spring ?

Spring is an open source framework created to address the complexity of enterprise application development. One of the chief advantages of the Spring framework is its layered architecture, which allows you to be selective about which of its components you use while also providing a cohesive framework for J2EE application development.

The advantages of Spring are as follows:

 Spring has layered architecture. Use what you need and leave you don't need now.

 Spring Enables POJO Programming. There is no behind the scene magic here. POJO programming enables continuous integration and testability.

 Dependency Injection and Inversion of Control Simplifies JDBC

 Open source and no vendor lock-in.

6. What are features of Spring ?

Lightweight: spring is lightweight when it comes to size and transparency. The basic version of spring framework is around 1MB. And the processing overhead is also very negligible.

Inversion of control (IOC): Loose coupling is achieved in spring using the technique Inversion of Control. The objects give their dependencies instead of creating or looking for dependent objects.

Aspect oriented (AOP): Spring supports Aspect oriented programming and enables cohesive development by separating application business logic from system services.

Container: Spring contains and manages the life cycle and configuration of application objects.

MVC Framework: Spring comes with MVC web application framework, built on core Spring functionality. This framework is highly configurable via strategy interfaces, and accommodates multiple view technologies like JSP, Velocity, Tiles, iText, and POI. But other frameworks can be easily used instead of Spring MVC Framework.

Transaction Management: Spring framework provides a generic abstraction layer for transaction management. This allowing the developer to add the pluggable transaction managers, and making it easy to demarcate transactions without dealing with low-level issues. Spring's transaction support is not tied to J2EE environments and it can be also used in container less environments.

JDBC Exception Handling: The JDBC abstraction layer of the Spring offers a meaningful exception hierarchy, which

simplifies the error handling strategy. Integration with Hibernate, JDO, and iBATIS: Spring provides best Integration services with Hibernate, JDO and iBATIS contexts for Web-based applications. As a result, the Spring framework supports integration with Jakarta Struts. The Web module also eases the tasks of handling multi-part requests and binding request parameters to domain objects.

This module is built on the application context module, providing a context that is appropriate for web-based applications. This module also contains support for several web-oriented tasks such as transparently handling multipart requests for file uploads and programmatic binding of request parameters to your business objects. It also contains integration support with Jakarta Struts.

8. What are the types of Dependency Injection Spring supports?

Setter Injection: Setter-based DI is realized by calling setter methods on your beans after invoking a no-argument constructor or no-argument static factory method to instantiate your bean.

Constructor Injection: Constructor-based DI is realized by invoking a constructor with a number of arguments, each representing a collaborator.

9. What is Bean Factory ?

A BeanFactory is like a factory class that contains a collection of beans. The BeanFactory holds Bean Definitions of multiple beans within itself and then instantiates the bean whenever asked for by clients.

 BeanFactory is able to create associations between collaborating objects as they are instantiated. This removes the burden of configuration from bean itself and the beans client.

 BeanFactory also takes part in the life cycle of a bean, making calls to custom initialization and destruction methods.

A bean factory is fine to simple applications, but to take advantage of the full power of the Spring framework, you may want to move up to Springs more advanced container, the application context. On the surface, an application context is same as a bean factory.Both load bean definitions, wire beans together, and dispense beans upon request. But it also provides:

 A means for resolving text messages, including support for internationalization.

 A generic way to load file resources.

 Events to beans that are registered as listeners.

11. What is the difference between Bean Factory and Application Context ?

On the surface, an application context is same as a bean factory. But application context offers much more..

 Application contexts provide a means for resolving text messages, including support for i18n of those messages.

 Application contexts provide a generic way to load file resources, such as images.

 Application contexts can publish events to beans that are registered as listeners.

 Certain operations on the container or beans in the container, which have to be handled in a programmatic fashion with a bean factory, can be handled declaratively in an application context.

 ResourceLoader support: Spring‘s Resource interface us a flexible generic abstraction for handling low-level resources. An application context itself is a ResourceLoader, Hence provides an application with access to deployment-specific Resource instances.

 MessageSource support: The application context implements MessageSource, an interface used to obtain localized messages, with the actual implementation being pluggable

12. What are the common implementations of the Application Context ?

The three commonly used implementation of 'Application Context' are

 ClassPathXmlApplicationContext : It Loads context definition from an XML file located in the classpath, treating context definitions as classpath resources. The application context is loaded from the application's classpath by using the code . ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");

 FileSystemXmlApplicationContext : It loads context definition from an XML file in the filesystem. The application context is loaded from the file system by using the code . ApplicationContext context = new FileSystemXmlApplicationContext("bean.xml");

 XmlWebApplicationContext : It loads context definition from an XML file contained within a web application.

13. How is a typical spring implementation look like ?

For a typical Spring Application we need the following files:

 An interface that defines the functions.

 An Implementation that contains properties, its setter and getter methods, functions etc.,

 Spring AOP (Aspect Oriented Programming)

 A XML file called Spring configuration file.

 Client program that uses the function.

14. What is the typical Bean life cycle in Spring Bean Factory Container ?

Bean life cycle in Spring Bean Factory Container is as follows:

 The spring container finds the bean‘s definition from the XML file and instantiates the bean.

 Using the dependency injection, spring populates all of the properties as specified in the bean definition

 If the bean implements the BeanNameAware interface, the factory calls setBeanName() passing the bean‘s ID.

 If the bean implements the BeanFactoryAware interface, the factory calls setBeanFactory(), passing an instance of itself.

 If there are any BeanPostProcessors associated with the bean, their post- ProcessBeforeInitialization() methods will be called.

 If an init-method is specified for the bean, it will be called.

 Finally, if there are any BeanPostProcessors associated with the bean, their postProcessAfterInitialization() methods will be called.

15. What do you mean by Bean wiring ?

The act of creating associations between application components (beans) within the Spring container is reffered to as Bean wiring.

The Spring container is able to autowire relationships between collaborating beans. This means that it is possible to automatically let Spring resolve collaborators (other beans) for your bean by inspecting the contents of the BeanFactory. The autowiring functionality has five modes.

 no

 byName

 byType

 constructor

 autodirect

17. What is DelegatingVariableResolver?

Spring provides a custom JavaServer Faces VariableResolver implementation that extends the standard Java Server Faces managed beans mechanism which lets you use JSF and Spring together. This variable resolver is called as DelegatingVariableResolver

18. How to integrate Java Server Faces (JSF) with Spring?

JSF and Spring do share some of the same features, most noticeably in the area of IOC services. By declaring JSF managed-beans in the faces-config.xml configuration file, you allow the FacesServlet to instantiate that bean at startup. Your JSF pages have access to these beans and all of their properties.We can integrate JSF and Spring in two ways:

 DelegatingVariableResolver: Spring comes with a JSF variable resolver that lets you use JSF and Spring together.

<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<faces-config>
<application>
<variable-resolver> org.springframework.web.jsf.DelegatingVariableResolver </variable-resolver> </application>
</faces-config>
The DelegatingVariableResolver will first delegate value lookups to the default resolver of the underlying JSF implementation, and then to Spring's 'business context' WebApplicationContext. This allows one to easily inject dependencies into one's JSF-managed beans.

 FacesContextUtils:custom VariableResolver works well when mapping one's properties to beans in faces-config.xml, but at times one may need to grab a bean explicitly. The FacesContextUtils class makes this easy. It is similar to WebApplicationContextUtils, except that it takes a FacesContext parameter rather than a ServletContext parameter.

ApplicationContext ctx = FacesContextUtils.getWebApplicationContext(FacesContext.getCurrentInstance());

19. What is Java Server Faces (JSF) - Spring integration mechanism?

Spring provides a custom JavaServer Faces VariableResolver implementation that extends the standard JavaServer Faces managed beans mechanism. When asked to resolve a variable name, the following algorithm is performed:

 Does a bean with the specified name already exist in some scope (request, session, application)? If so, return it

 Is there a standard JavaServer Faces managed bean definition for this variable name? If so, invoke it in the usual way, and return the bean that was created.

 Is there configuration information for this variable name in the Spring WebApplicationContext for this application? If so, use it to create and configure an instance, and return that instance to the caller.

 If there is no managed bean or Spring definition for this variable name, return null instead.

 BeanFactory also takes part in the life cycle of a bean, making calls to custom initialization and destruction methods.

As a result of this algorithm, you can transparently use either JavaServer Faces or Spring facilities to create beans on demand.

20. What is Significance of JSF- Spring integration ?

Spring - JSF integration is useful when an event handler wishes to explicitly invoke the bean factory to create beans on demand, such as a bean that encapsulates the business logic to be performed when a submit button is pressed.

21. How to integrate your Struts application with Spring?

To integrate your Struts application with Spring, we have two options:

 Configure Spring to manage your Actions as beans, using the ContextLoaderPlugin, and set their dependencies in a Spring context file.

 Subclass Spring's ActionSupport classes and grab your Spring-managed beans explicitly using a getWebApplicationContext() method.

22. What are ORM’s Spring supports ?

Spring supports the following ORM’s :

 Hibernate

 iBatis

 JPA (Java Persistence API)

 TopLink

 JDO (Java Data Objects)

 OJB

23. What are the ways to access Hibernate using Spring ?

There are two approaches to Spring‘s Hibernate integration:

 Inversion of Control with a HibernateTemplate and Callback

 Extending HibernateDaoSupport and Applying an AOP Interceptor

24. How to integrate Spring and Hibernate using HibernateDaoSupport?

Spring and Hibernate can integrate using Spring‘s SessionFactory called LocalSessionFactory. The integration process is of 3 steps.

 Configure the Hibernate SessionFactory

 Extend your DAO Implementation from HibernateDaoSupport

 Wire in Transaction Support with AOP

25. What are Bean scopes in Spring Framework ?

The Spring Framework supports exactly five scopes (of which three are available only if you are using a web-aware ApplicationContext). The scopes supported are listed below:

Scope Description

singleton

singleton scope is nothing but a single bean definition to a single object instance per Spring IoC container.

prototype

where as prototype scope is a single bean definition to any number of object instances.

request

where as request scope is a single bean definition to the lifecycle of a single HTTP request; that is each and every HTTP request will have its own instance of a bean created off the back of a single bean definition. Only valid in the context of a web-aware Spring ApplicationContext.

session

where as session scope is a single bean definition to the lifecycle of a HTTP Session. Only valid in the context of a web-aware Spring ApplicationContext.

global session

where as global session scope is a single bean definition to the lifecycle of a global HTTP Session. Typically only valid when used in a portlet context. Only valid in the context of a web-aware Spring ApplicationContext.

26. What is AOP?

Aspect-oriented programming, or AOP, is a programming technique that allows programmers to modularize crosscutting concerns, or behavior that cuts across the typical divisions of responsibility, such as logging and transaction management. The core construct of AOP is the aspect, which encapsulates behaviors affecting multiple classes into reusable modules.

27. How the AOP used in Spring?

AOP is used in the Spring Framework:To provide declarative enterprise services, especially as a replacement for EJB declarative services. The most important such service is declarative transaction management, which builds on the Spring Framework's transaction abstraction.To allow users to implement custom aspects, complementing their use of OOP with AOP.

28. What do you mean by Aspect ?

A modularization of a concern that cuts across multiple objects. Transaction management is a good example of a crosscutting concern in J2EE applications. In Spring AOP, aspects are implemented using regular classes (the schema-based approach) or regular classes annotated with the @Aspect annotation (@AspectJ style).

29. What do you mean by JointPoint?

A point during the execution of a program, such as the execution of a method or the handling of an exception. In Spring AOP, a join point always represents a method execution.

30. What do you mean by Advice?

Action taken by an aspect at a particular join point. Different types of advice include "around," "before" and "after" advice. Many AOP frameworks, including Spring, model an advice as an interceptor, maintaining a chain of interceptors "around" the join point.

31. What are the types of Advice?

Types of advice:

 Before advice: Advice that executes before a join point, but which does not have the ability to prevent execution flow proceeding to the join point (unless it throws an exception).

 After returning advice: Advice to be executed after a join point completes normally: for example, if a method returns without throwing an exception.

 After throwing advice: Advice to be executed if a method exits by throwing an exception.

 After (finally) advice: Advice to be executed regardless of the means by which a join point exits (normal or exceptional return).

 Around advice: Advice that surrounds a join point such as a method invocation. This is the most powerful kind of advice. Around advice can perform custom behavior before and after the method invocation. It is also responsible for choosing whether to proceed to

the join point or to shortcut the advised method execution by returning its own return value or throwing an exception

32. What are the types of the transaction management Spring supports ?

Spring Framework supports:

 Programmatic transaction management.

 Declarative transaction management.

33. What are the benefits of the Spring Framework transaction management ?

The Spring Framework provides a consistent abstraction for transaction management that delivers the following benefits:

 Provides a consistent programming model across different transaction APIs such as JTA, JDBC, Hibernate, JPA, and JDO.

 Supports declarative transaction management.

 Provides a simpler API for programmatic transaction management than a number of complex transaction APIs such as JTA.

 Integrates very well with Spring's various data access abstractions.

34. Why most users of the Spring Framework choose declarative transaction management ?

Most users of the Spring Framework choose declarative transaction management because it is the option with the least impact on application code, and hence is most consistent with the ideals of a non-invasive lightweight container.

35. Explain the similarities and differences between EJB CMT and the Spring Framework's declarative transaction management ?

The basic approach is similar: it is possible to specify transaction behavior (or lack of it) down to individual method level. It is possible to make a setRollbackOnly() call within a transaction context if necessary. The differences are:

 Unlike EJB CMT, which is tied to JTA, the Spring Framework's declarative transaction management works in any environment. It can work with JDBC, JDO, Hibernate or other transactions under the covers, with configuration changes only.

 The Spring Framework enables declarative transaction management to be applied to any class, not merely special classes such as EJBs.

 The Spring Framework offers declarative rollback rules: this is a feature with no EJB equivalent. Both programmatic and declarative support for rollback rules is provided.

 The Spring Framework gives you an opportunity to customize transactional behavior, using AOP. With EJB CMT, you have no way to influence the container's transaction management other than setRollbackOnly().

 The Spring Framework does not support propagation of transaction contexts across remote calls, as do high-end application servers.

36. What are object/relational mapping integration module?

Spring also supports for using of an object/relational mapping (ORM) tool over straight JDBC by providing the ORM module. Spring provide support to tie into several popular ORM frameworks, including Hibernate, JDO, and iBATIS SQL Maps. Spring‘s transaction management supports each of these ORM frameworks as well as JDBC.

37. When to use programmatic and declarative transaction management ?

Programmatic transaction management is usually a good idea only if you have a small number of transactional operations. On the other hand, if your application has numerous transactional operations, declarative transaction management is usually worthwhile. It keeps transaction management out of business logic, and is not difficult to configure.

38. Explain about the Spring DAO support ?

The Data Access Object (DAO) support in Spring is aimed at making it easy to work with data access technologies like JDBC, Hibernate or JDO in a consistent way. This allows one to switch between the persistence technologies fairly easily and it also allows one to code without worrying about catching exceptions that are specific to each technology.

39. What are the exceptions thrown by the Spring DAO classes ?

Spring DAO classes throw exceptions which are subclasses of DataAccessException(org.springframework.dao.DataAccessException).Spring provides a convenient translation from technology-specific exceptions like SQLException to its own exception class hierarchy with the DataAccessException as the root exception. These exceptions wrap the original exception.

40. What is SQLExceptionTranslator ?

SQLExceptionTranslator, is an interface to be implemented by classes that can translate between SQLExceptions and Spring's own data-access-strategy-agnostic org.springframework.dao.DataAccessException.

41. What is Spring's JdbcTemplate ?

Spring's JdbcTemplate is central class to interact with a database through JDBC. JdbcTemplate provides many convenience methods for doing things such as converting database data into primitives or objects, executing prepared and callable statements, and providing custom database error handling. JdbcTemplate template = new JdbcTemplate(myDataSource);

PreparedStatementCreator:

 Is one of the most common used interfaces for writing data to database.

 Has one method – createPreparedStatement(Connection)

 Responsible for creating a PreparedStatement.

 Does not need to handle SQLExceptions.

43. What is SQLProvider ?

SQLProvider:

 Has one method – getSql()

 Typically implemented by PreparedStatementCreator implementers.

 Useful for debugging.

44. What is RowCallbackHandler ?

The RowCallbackHandler interface extracts values from each row of a ResultSet.

 Has one method – processRow(ResultSet)

 Called for each row in ResultSet.

 Typically stateful.

Spring and EJB feature comparison.

Feature

EJB

Spring

Transaction management

 Must use a JTA transaction manager.

 Supports transactions that span remote method calls.

 Supports multiple transaction environments through its PlatformTransactionManager interface, including JTA, Hibernate, JDO, and JDBC.

 Does not natively support distributed transactions—it must be used with a JTA transaction manager.

Declarative transaction support

 Can define transactions declaratively through the deployment descriptor.

 Can define transaction behavior per method or per class by using the wildcard character *.

 Cannot declaratively define rollback behavior—this must be done programmatically.

 Can define transactions declaratively through the Spring configuration file or through class metadata.

 Can define which methods to apply transaction behavior explicitly or by using regular expressions.

 Can declaratively define rollback behavior per method and per exception type.

Persistence

Supports programmatic bean-managed persistence and declarative container managed persistence.

Provides a framework for integrating with several persistence technologies, including JDBC, Hibernate, JDO, and iBATIS.

Declarative security

 Supports declarative security through users and roles. The management and implementation of users and roles is container specific.

 Declarative security is configured in the deployment descriptor.

 No security implementation out-of-the box.

 Acegi, an open source security framework built on top of Spring, provides declarative security through the Spring configuration file or class metadata.

Distributed computing

Provides container-managed remote method calls.

Provides proxying for remote calls via RMI, JAX-RPC, and web services.

46 . Do I need any other SOAP framework to run Spring Web Services?

You don't need any other SOAP framework to use Spring Web services, though it can use

some of the features of Axis 1 and 2.

If you get the following Exception: NAMESPACE_ERR: An attempt is made to create or change an object in a way which is incorrect with regard to namespaces. Most often, this exception is related to an older version of Xalan being used. Make sure to upgrade to 2.7.0.

48 .Does Spring-WS run under Java 1.3?

Spring Web Services requires Java 1.4 or higher.

49. Does Spring-WS work under Java 1.4?

Spring Web Services works under Java 1.4, but it requires some effort to make it work. Java 1.4 is bundled with the older XML parser Crimson, which does not handle namespaces correctly. Additionally, it is bundled with an older version of Xalan, which also has problems. Unfortunately, placing newer versions of these on the class path does not override them. . The only solution that works is to add newer versions of Xerces and Xalan in the lib/endorsed directory of your JDK, as explained in those FAQs (i.e.$JAVA_HOME/lib/endorsed). The following libraries are known to work with Java 1.4.2:

Library

Version

Xerces

2.8.1

Xalan

2.7.0

XML-APIs

1.3.04

SAAJ

1.2

If you want to use WS-Security, note that the XwsSecurityInterceptor requires Java 5, because an underlying library (XWSS) requires it. Instead, you can use the Wss4jSecurityInterceptor.

50 .Does Spring-WS work under Java 1.6?

Java 1.6 ships with SAAJ 1.3, JAXB 2.0, and JAXP 1.4 (a custom version of Xerces and Xalan). Overriding these libraries by putting different version on the classpath will result in various classloading issues, or exceptions in org.apache.xml.serializer.ToXMLSAXHandler. The only option for using more recent versions is to put the newer version in the endorsed directory (see above).

51 . Why do the Spring-WS unit tests fail under Mac OS X?

For some reason, Apple decided to include a Java 1.4 compatibility jar with their JDK 1.5. This jar includes the XML parsers which were included in Java 1.4. No other JDK distribution does this, so it is unclear what the purpose of this compatibility jar is. The jar can be found at /System/Library/Frameworks/JavaVM.framework/Versions/1.5.0/Classes/.compatibility/14compatibility.jar. You can safely remove or rename it, and the tests will run again.

52 . What is SAAJ?

SAAJ is the SOAP with Attachments API for Java. Like most Java EE libraries, it consists of a set of interfaces (saaj-api.jar), and implementations (saaj-impl.jar). When running in a Application Server, the implementation is typically provided by the application server. Previously, SAAJ has been part of JAXM, but it has been released as a seperate API as part of the , and also as part of J2EE 1.4. SAAJ is generally known as the packagejavax.xml.soap. Spring-WS uses this standard SAAJ library to create representations of SOAP messages. Alternatively, it can use

53 . What version of SAAJ does my application server support?

Application Server

SAAJ Version

BEA WebLogic 8

1.1

BEA WebLogic 9

1.1/1.2*

BEA WebLogic 10

1.3**

IBM WebSphere 6

1.2

SUN Glassfish 1

1.3

JBoss 4.2

1.3***

54 .I get a NoSuchMethodError when using SAAJ. What can I do about it?

If you get the following stack trace:
org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'org.springframework.ws.soap.saaj.SaajSoapMessageFactory' defined in ServletContext resource [/WEB-INF/springws-servlet.xml]: Invocation of init method failed; nested exception is java.lang.NoSuchMethodError: javax.xml.soap.MessageFactory.newInstance(Ljava/lang/String;)Ljavax/xml/soap/MessageFacto

ry; Caused by: java.lang.NoSuchMethodError: javax.xml.soap.MessageFactory.newInstance(Ljava/lang/String;)Ljavax/xml/soap/MessageFactory; Like most J2EE libraries, SAAJ consists of two parts: the API that consists of interfaces (saaj-api.jar) and the implementation (saaj-impl.jar). The stack trace is due to the fact that you are using a new version of the API (SAAJ 1.3), while your application server provides an earlier version of the implementation (SAAJ 1.2 or even 1.1). Spring-WS supports all three versions of SAAJ (1.1 through 1.3), but things break when it sees the 1.3 API, while there is no 1.3 implementation. The solution therefore is quite simple: to remove the newer 1.3 version of the API, from the class path, and replace it with the version supported by your application server.

55 . I get an UnsupportedOperationException "This class does not support SAAJ 1.1" when I use SAAJ under WebLogic 9. What can I do about it?

WebLogic 9 has a known bug in the SAAJ 1.2 implementation: it implement all the 1.2 interfaces, but throws UnsupportedOperationExceptions when you call them. Confusingly, the exception message is This class does not support SAAJ 1.1, even though it supports SAAJ 1.1 just fine; it just doesn't support SAAJ 1.2. See alsot Spring-WS has a workaround for this, we basically use SAAJ 1.1 only when dealing with WebLogic 9. Unfortunately, other frameworks which depend on SAAJ, such as XWSS, do not have this workaround. These frameworks happily call SAAJ 1.2 methods, which throw this exception. The solution is to not use BEA's version of SAAJ, but to use another implementation, like the one from Axis 1, or SUN. In you application context, use the following:
<bean id="messageFactory" class="org.springframework.ws.soap.saaj.SaajSoapMessageFactory"> <property name="messageFactory"> <bean class="com.sun.xml.messaging.saaj.soap.MessageFactoryImpl"/>
</property>
</bean>

56 . I get an UnsupportedOperationException "This class does not support SAAJ 1.1" when I use SAAJ under WebLogic 10. What can I do about it?

Weblogic 10 ships with two SAAJ implementations. By default the buggy 9.x implementation is used (which lives in the package weblogic.webservice.core.soap), but there is a new implementation, which supports SAAJ 1.3 (which lives in the package weblogic.xml.saaj). By looking at the DEBUG logging when Spring Web Services starts up, you can see which SAAJ implementation is used. To use this new version, you have to create a message factory bean like so: <bean id="messageFactory" class="org.springframework.ws.soap.saaj.SaajSoapMessageFactory"> <property name="messageFactory">

The SAAJ implementation provided by JBoss has some issues. The solution is therefore not to use the JBoss implementation, but to use another implementation. For instance, you can use SUN's reference implementation like so: <bean id="messageFactory" class="org.springframework.ws.soap.saaj.SaajSoapMessageFactory">
<property name="messageFactory">
<bean class="com.sun.xml.messaging.saaj.soap.ver1_1.SOAPMessageFactory1_1Impl"/>
</property>
</bean>

58 . Does Spring-WS run on IBM WebSphere?

WebSphere bundles some libraries which are out-of-date, and need to be upgraded with more recent versions. Specifically, this includes XML-apis, Xerces, Xalan, and WSDL4J. There are a couple of ways to upgrade these libraries, all using parent-last or application-first classloading.

 Package the libraries as part of the WAR (in WEB-INF/lib), and run the web application with the parent-last (application-first) classloading.

 Package the libraries as part of the EAR, add class-path entries to the manifest of the web application, and run the entire application with the parent-last classloading.

 Create a new classloader in the WebSphere console, and associate the libraries with. Set this classloader to parent-last.

The last approach has the advantage of restricting the parent-last classloading to the conflicting libraries only, and not to the entire application.

Note that Spring-WS only requires you to write the XSD; the WSDL can be generated from that.

The &WSDL query parameter does not work. The &WSDL query parameter is a way to get a WSDL of a class. In SWS, a service is generally not implemented as a single class, but as a collection of endpoints. There are two ways to expose a WSDL:

 Simply add the WSDL to the root of the WAR, and the file is served normally. This has the disadvantage that the "location" attribute in the WSDL is static, i.e. it does not

necessarily reflect the host name of the server. You can transform locations by using a WsdlDefinitionHandlerAdapter.

 Use theMessageDispatcherServlet, which is done is the samples. Every WsdlDefinition listed in the *-servlet.xml will be exposed under the bean name. So if you define a WsdlDefinition namedecho, it will be exposed as echo.wsdl (i.e.http://localhost:8080/echo/echo.wsdl).

Spring comes with a full-featured MVC framework for building web applications. Although Spring can easily be integrated with other MVC frameworks, such as Struts, Spring‘s MVC framework uses IoC to provide for a clean separation of controller logic from business objects. It also allows you to declaratively bind request parameters to your business objects. It also can take advantage of any of Spring‘s other services, such as I18N messaging and validation.

62 What is a BeanFactory?

A BeanFactory is an implementation of the factory pattern that applies Inversion of Control to separate the application‘s configuration and dependencies from the actual application code.

63 What is AOP Alliance?

AOP Alliance is an open-source project whose goal is to promote adoption of AOP and interoperability among different AOP implementations by defining a common set of interfaces and components.

64 What is Spring configuration file?

Spring configuration file is an XML file. This file contains the classes information and describes how these classes are configured and introduced to each other.

These applications are like any Java application. They are made up of several classes, each performing a specific purpose within the application. But these classes are configured and introduced to each other through an XML file. This XML file describes how to configure the classes, known as theSpring configuration file.

66 What is XMLBeanFactory?

BeanFactory has many implementations in Spring. But one of the most useful one is org.springframework.beans.factory.xml.XmlBeanFactory, which loads its beans based on the definitions contained in an XML file. To create an XmlBeanFactory, pass a java.io.InputStream to the constructor. The InputStream will provide the XML to the factory. For example, the following code snippet uses a java.io.FileInputStream to provide a bean definition XML file to XmlBeanFactory.

BeanFactory factory = new XmlBeanFactory(new FileInputStream("beans.xml"));
To retrieve the bean from a BeanFactory, call the getBean() method by passing the name of the bean you want to retrieve.

MyBean myBean = (MyBean) factory.getBean("myBean")

67 . What are important ApplicationContext implementations in spring framework?

 ClassPathXmlApplicationContext – This context loads a context definition from an XML file located in the class path, treating context definition files as class path resources.

 FileSystemXmlApplicationContext – This context loads a context definition from an XML file in the filesystem.

 XmlWebApplicationContext – This context loads the context definitions from an XML file contained within a web application.

 The spring container finds the bean‘s definition from the XML file and instantiates the bean.

 Using the dependency injection, spring populates all of the properties as specified in the bean definition.

 If the bean implements the BeanNameAware interface, the factory calls setBeanName() passing the bean‘s ID.

 If the bean implements the BeanFactoryAware interface, the factory calls setBeanFactory(), passing an instance of itself.

 If there are any BeanPostProcessors associated with the bean, their post- ProcessBeforeInitialization() methods will be called.

 If an init-method is specified for the bean, it will be called.

 Finally, if there are any BeanPostProcessors associated with the bean, their postProcessAfterInitialization() methods will be called.

69 What is bean wiring?

Combining together beans within the Spring container is known as bean wiring or wiring. When wiring beans, you should tell the container what beans are needed and how the container should use dependency injection to tie them together.

<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean id="foo" class="com.act.Foo"/>
<bean id="bar" class="com.act.Bar"/>
</beans>

Beans defined in spring framework are singleton beans. There is an attribute in bean tag named ‗singleton‘ if specified true then bean becomes singleton and if set to false then the bean becomes a prototype bean. By default it is set to true. So, all the beans in spring framework are by default singleton beans.

There are two important bean lifecycle methods. The first one is setup which is called when the bean is loaded in to the container. The second method is the teardown method which is called when the bean is unloaded from the container.

73 . How can you override beans default lifecycle methods?

The bean tag has two more important attributes with which you can define your own custom initialization and destroy methods. Here I have shown a small demonstration. Two new methods fooSetup and fooTeardown are to be added to your Foo class.

When wiring beans, if a bean element is embedded to a property tag directly, then that bean is said to the Inner Bean. The drawback of this bean is that it cannot be reused anywhere else.

There are two types of bean injections.

 By setter

 By constructor

76. What is Auto wiring?

You can wire the beans as you wish. But spring framework also does this work for you. It can auto wire the related beans together. All you have to do is just set the autowire attribute of bean tag to an autowire type.

77 . What are different types of Autowire types?

There are four different types by which autowiring can be done.

o byName

o byType

o constructor

o autodetect

There are a lot of events related to ApplicationContext of spring framework. All the events are subclasses of org.springframework.context.Application-Event. They are

 ContextClosedEvent – This is fired when the context is closed.

 ContextRefreshedEvent – This is fired when the context is initialized or refreshed.

 RequestHandledEvent – This is fired when the web context handles any request.

79. What is an Aspect?

An aspect is the cross-cutting functionality that you are implementing. It is the aspect of your application you are modularizing. An example of an aspect is logging. Logging is something that is required throughout an application. However, because applications tend to be broken down into layers based on functionality, reusing a logging module through inheritance does not make sense. However, you can create a logging aspect and apply it throughout your application using AOP.

80 . What is a Jointpoint?

A joinpoint is a point in the execution of the application where an aspect can be plugged in. This point could be a method being called, an exception being thrown, or even a field being modified. These are the points where your aspect‘s code can be inserted into the normal flow of your application to add new behavior.

81 What is an Advice?

Advice is the implementation of an aspect. It is something like telling your application of a new behavior. Generally, and advice is inserted into an application at joinpoints.

82 What is a Pointcut?

A pointcut is something that defines at what joinpoints an advice should be applied. Advices can be applied at any joinpoint that is supported by the AOP framework. These Pointcuts allow you to specify where theadvice can be applied.

83 What is an Introduction in AOP?

An introduction allows the user to add new methods or attributes to an existing class. This can then be introduced to an existing class without having to change the structure of the class, but give them the new behavior and state.

84 What is a Target?

A target is the class that is being advised. The class can be a third party class or your own class to which you want to add your own custom behavior. By using the concepts of AOP, the target class is free to center on its major concern, unaware to any advice that is being applied.

85 . What is a Proxy?

A proxy is an object that is created after applying advice to a target object. When you think of client objects the target object and the proxy object are the same.

86 .What is meant by Weaving?

The process of applying aspects to a target object to create a new proxy object is called as Weaving. The aspects are woven intothe target object at the specified joinpoints.

87 What are the different points where weaving can be applied?

 Compile Time

 Classload Time

 Runtime

88 . What are the different advice types in spring?

 Around : Intercepts the calls to the target method

 Before : This is called before the target method is invoked

 After : This is called after the target method is returned

 Throws : This is called when the target method throws and exception

 Around : org.aopalliance.intercept.MethodInterceptor

 Before : org.springframework.aop.BeforeAdvice

 After : org.springframework.aop.AfterReturningAdvice

 Throws : org.springframework.aop.ThrowsAdvice

89 What are the different types of AutoProxying?

 BeanNameAutoProxyCreator

 DefaultAdvisorAutoProxyCreator

 Metadata autoproxying

90 What kind of exceptions those spring DAO classes throw?

 The springâ€™s DAO class does not throw any technology related exceptions such as SQLException. They throw exceptions which are subclasses of DataAccessException.

 DataAccessException is a RuntimeException. This is an Unchecked Exception. The user is not forced to handle these kinds of exceptions.

 <bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean"> <property name="jndiName"> <value>java:comp/env/jdbc/myDatasource</value> </property> </bean>

93 How can you create a DataSource connection pool?

<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
<property name="driver"> <value>${db.driver}</value> </property>
<property name="url"> <value>${db.url}</value> </property>
<property name="username"> <value>${db.username}</value> </property>
<property name="password"> <value>${db.password}</value> </property>
</bean>

94 How JDBC can be used more efficiently in spring framework?

 JDBC can be used more efficiently with the help of a template class provided by spring framework called as JdbcTemplate.

95 How JdbcTemplate can be used?

 With use of Spring JDBC framework the burden of resource management and error handling is reduced a lot. So it leaves developers to write the statements and queries to get the data to and from the database.

 JdbcTemplate template = new JdbcTemplate(myDataSource); A simple DAO class looks like this.

 public class StudentDaoJdbc implements StudentDao { private JdbcTemplate jdbcTemplate;

 public void setJdbcTemplate(JdbcTemplate jdbcTemplate) { this.jdbcTemplate = jdbcTemplate; } more.. } The configuration is shown below.

 <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource"> <ref bean="dataSource"/> </property>
</bean>
<bean id="studentDao" class="StudentDaoJdbc">
<property name="jdbcTemplate"> <ref bean="jdbcTemplate"/> </property>
</bean>
<bean id="courseDao" class="CourseDaoJdbc">
<property name="jdbcTemplate"> <ref bean="jdbcTemplate"/> </property>
</bean>

96 How do you write data to backend in spring using JdbcTemplate?

 The JdbcTemplate uses several of these callbacks when writing data to the database. The usefulness you will find in each of these interfaces will vary. There are two simple interfaces. One is PreparedStatementCreator and the other interface is BatchPreparedStatementSetter.

97 Explain about PreparedStatementCreator?

 PreparedStatementCreator is one of the most common used interfaces for writing data to database. The interface has one method createPreparedStatement().

 PreparedStatement createPreparedStatement(Connection conn) throws SQLException; When this interface is implemented, we should create and return a PreparedStatement from the Connection argument, and the exception handling is automatically taken care off. When this interface is implemented, another interface SqlProvider is also implemented which has a method called getSql() which is used to provide sql strings to JdbcTemplate.

 If the user what to update more than one row at a shot then he can go for BatchPreparedStatementSetter. This interface provides two methods

 setValues(PreparedStatement ps, int i) throws SQLException; int getBatchSize(); The getBatchSize() tells the JdbcTemplate class how many statements to create. And this also determines how many times setValues() will be called.

99. Explain about RowCallbackHandler and why it is used?

 In order to navigate through the records we generally go for ResultSet. But spring provides an interface that handles this entire burden and leaves the user to decide what to do with each row. The interface provided by spring is RowCallbackHandler. There is a method processRow() which needs to be implemented so that it is applicable for each and everyrow.

 void processRow(java.sql.ResultSet rs);

100 What is JDBC abstraction and DAO module?

 Using this module we can keep up the database code clean and simple, and prevent problems that result from a failure to close database resources. A new layer of meaningful exceptions on top of the error messages given by several database servers is bought in this module. In addition, this module uses Spring‘s AOP module to provide transaction management services for objects in a Spring application.

Thursday, 11 April 2013

Advance java & Frameworks interview questions

🧾 What is a Servlet in Java?

✅ Servlet = Java class + Web container

🔄 Servlet Lifecycle

🛠️ Servlet Lifecycle Methods

📌 Basic Example of a Servlet

🧩 How to Deploy a Servlet (Steps)

1. Create servlet class

2. Add to `web.xml` (or use annotations)

Option A: Use `web.xml` (Deployment Descriptor)

Option B: Use Annotation (`@WebServlet`)

3. Build WAR file

4. Deploy to server

5. Run

🔐 Key Interfaces in Servlet API

📚 Use Cases

✅ Summary

📘 2.What is JSP (JavaServer Pages)?

🧱 Key Features of JSP

🛠 JSP Lifecycle

📌 JSP Lifecycle Phases:

1. Directives

2. Scriptlet Elements

3. Standard Action Tags

4. Implicit Objects in JSP

Step 1: Create a JavaBean

Step 2: Use in JSP

📂 JSP Folder Structure (Web Project)

🔄 JSP vs Servlet

✅ Best Practices

📚 JSTL and Expression Language (EL)

Expression Language (EL)

JSTL Example:

🧪 Complete Example: Form + JSP

`form.html`

`greet.jsp`

🚀 Modern Alternatives to JSP

No comments:

Post a Comment

Thursday, 11 April 2013

Advance java & Frameworks interview questions

🧾 What is a Servlet in Java?

✅ Servlet = Java class + Web container

🔄 Servlet Lifecycle

🛠️ Servlet Lifecycle Methods

📌 Basic Example of a Servlet

🧩 How to Deploy a Servlet (Steps)

1. Create servlet class

2. Add to web.xml (or use annotations)

Option A: Use web.xml (Deployment Descriptor)

Option B: Use Annotation (@WebServlet)

3. Build WAR file

4. Deploy to server

5. Run

🔐 Key Interfaces in Servlet API

📚 Use Cases

✅ Summary

📘 2.What is JSP (JavaServer Pages)?

🧱 Key Features of JSP

🛠 JSP Lifecycle

📌 JSP Lifecycle Phases:

1. Directives

2. Scriptlet Elements

3. Standard Action Tags

4. Implicit Objects in JSP

Step 1: Create a JavaBean

Step 2: Use in JSP

📂 JSP Folder Structure (Web Project)

🔄 JSP vs Servlet

✅ Best Practices

📚 JSTL and Expression Language (EL)

Expression Language (EL)

JSTL Example:

🧪 Complete Example: Form + JSP

form.html

greet.jsp

🚀 Modern Alternatives to JSP

No comments:

Post a Comment

2. Add to `web.xml` (or use annotations)

Option A: Use `web.xml` (Deployment Descriptor)

Option B: Use Annotation (`@WebServlet`)

`form.html`

`greet.jsp`