Explore topic-wise InterviewSolutions in .

JavaBeans and taglib fundamentals were introduced for reusability. But following are the major differences between them −

• Taglibs are for generating presentation elements while JavaBeans are good for storing information and state.

• Use custom tags to implement actions and JavaBeans to present information.

JSP engines will always instantiate a new tag handler instance every time a tag is encountered in a JSP page. A pool of tag instances are maintained and reusing them where possible. When a tag is encountered, the JSP engine will try to find a Tag instance that is not being used and use the same and then release it.

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

• By include directive − For example −

<% include file = ”header.jsp” %>

• By include action − For example −

<% include file = ”header.jsp” %>

• By using pageContext implicit object For example −

<% pageContext.include(“/header.jsp”); %>

• By using RequestDispatcher object − For example −

<% RequestDispatcher rd = request.getRequestDispatcher(“/header.jsp”); Rd.include(request,response);%>

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

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>

It causes compilation error, as two variables with same name can't be declared. This happens because, when a page is included statically, entire code of included page becomes part of the new page. at this time there are two declarations of variable 'a'. Hence compilation error.

_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.

We can override jspinit() and jspDestroy() methods but not _jspService().

Using <%jsp:param> tag.

<% page session = "false">

No. You are supposed to make use of only a JSPWriter object (given to you in the form of the implicit object out) for replying to clients.

A JSPWriter can be viewed as a buffered version of the stream object returned by response.getWriter(), although from an implementational perspective, it is not.

Use the following ways to pass control of a request from one servlet to another or one jsp to another −

• The RequestDispatcher object ‘s forward method to pass the control.

• Using the response.sendRedirect method.

Yes. However, unlike Servlet, you are not required to implement HTTP-protocol specific methods like doGet() or doPost() within your JSP page. You can obtain the data for the FORM input elements via the request implicit object within a scriptlet or expression.

Static resources should always be included using the JSP include directive. This way, the inclusion is performed just once during the translation phase. Do note that you should always supply a relative URL for the file attribute. Although you can also include static resources using the action, this is not advisable as the inclusion is then performed for each and every request.

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

<%-- comment --%> is JSP comment and is ignored by the JSP engine.

<!-- comment --> is an HTML comment and is ignored by the browser.

This is a particular cultural or geographical region. It is usually referred to as a language symbol followed by a country symbol which are separated by an underscore. For example "en_US" represents english locale for US.

Localization means adding resources to a web site to adapt it to a particular geographical or cultural region for example Hindi translation to a web site.

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

Example: <% page errorPage = "error.jsp" %>

It will redirect the browser to the JSP page error.jsp if an uncaught exception is encountered during request processing. Within error.jsp, will have to indicate that it is an error-processing page, using the directive: <% page isErrorPage="true" %>

• Checked exceptions − Achecked exception is an exception that is typically a user error or a problem that cannot be foreseen by the programmer. For example, if a file is to be opened, but the file cannot be found, an exception occurs. These exceptions cannot simply be ignored at the time of compilation.

• Runtime exceptions − A runtime exception is an exception that occurs that probably could have been avoided by the programmer. As opposed to checked exceptions, runtime exceptions are ignored at the time of compliation.

• Errors − These are not exceptions at all, but problems that arise beyond the control of the user or the programmer. Errors are typically ignored in your code because you can rarely do anything about an error. For example, if a stack overflow occurs, an error will arise. They are also ignored at the time of compilation.

We can disable using isELIgnored attribute of the page directive −

<% page isELIgnored = "true|false" %>

If it is true, EL expressions are ignored when they appear in static text or tag attributes. If it is false, EL expressions are evaluated by the container.

The JSP expression language supports the following implicit objects −

• pageScope − Scoped variables from page scope

• requestScope − Scoped variables from request scope

• sessionScope − Scoped variables from session scope

• applicationScope − Scoped variables from application scope

• param − Request parameters as strings

• paramValues − Request parameters as collections of strings

• headerHTTP − request headers as strings

• headerValues − HTTP request headers as collections of strings

• initParam − Context-initialization parameters

• cookie − Cookie values

• pageContext − The JSP PageContext object for the current page

JSP Expression Language (EL) makes it possible to easily access application data stored in JavaBeans components. JSP EL allows you to create expressions both (a) arithmetic and (b) logical. A simple syntax for JSP EL is −

 ${expr}

Here expr specifies the expression itself.

A custom tag is a user-defined JSP language element. When a JSP page containing a custom tag is translated into a servlet, the tag is converted to operations on an object called a tag handler. The Web container then invokes those operations when the JSP page's servlet is executed.

The JSTL XML tags provide a JSP-centric way of creating and manipulating XML documents. Following is the syntax to include JSTL XML library in your JSP.

<% taglib prefix = "x" uri = "http://java.sun.com/jsp/jstl/xml" %>

The JSTL SQL tag library provides tags for interacting with relational databases (RDBMSs) such as Oracle, mySQL, or Microsoft SQL Server.

Following is the syntax to include JSTL SQL library in your JSP −

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

The JSTL formatting tags are used to format and display text, the date, the time, and numbers for internationalized Web sites. Following is the syntax to include Formatting library in your JSP −

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

The <c:url> tag formats a URL into a string and stores it into a variable. This tag automatically performs URL rewriting when necessary.

The <c:redirect > tag redirects the browser to an alternate URL by providing automatically URL rewriting, it supports context-relative URLs, and it supports the <c:param> tag.

The <c:param> tag allows proper URL request parameter to be specified with URL and it does any necessary URL encoding required.

The <c:forEach >, <c:forTokens> tags exist as a good alternative to embedding a Java for, while, or do-while loop via a scriptlet.

The <c:choose> works like a Java switch statement in that it lets you choose between a number of alternatives. Where the switch statement has case statements, the <c:choose> tag has <c:when> tags. A a switch statement has default clause to specify a default action and similar way <c:choose> has <otherwise> as default clause.

The <c:if> tag evaluates an expression and displays its body content only if the expression evaluates to true.

The <c:catch> tag catches any Throwable that occurs in its body and optionally exposes it. Simply it is used for error handling and to deal more gracefully with the problem.

The <c:remove > tag removes a variable from either a specified scope or the first scope where the variable is found (if no scope is specified).

The <c:set > tag is JSTL-friendly version of the setProperty action. The tag is helpful because it evaluates an expression and uses the results to set a value of a JavaBean or a java.util.Map object.

Types of JSTL tags are −

• Core Tags

• Formatting tags

• SQL tags

• XML tags

• JSTL Functions

The simplest way of refreshing a Webpage is using method setIntHeader() of response object. Following is the signature of this method −

public void setIntHeader(String header, int headerValue)

This method sends back header "Refresh" to the browser along with an integer value which indicates time interval in seconds.

Consider a webpage which is displaying live game score or stock market status or currency exchange ration. For all such type of pages, you would need to refresh your Webpage regularly using refresh or reload button with your browser.

JSP makes this job easy by providing you a mechanism where you can make a webpage in such a way that it would refresh automatically after a given interval.

You can follow the below steps −

• Define a database table with a single count, let us say hitcount. Assign a zero value to it.

• With every hit, read the table to get the value of hitcount.

• Increase the value of hitcount by one and update the table with new value.

• Display new value of hitcount as total page hit counts.

• If you want to count hits for all the pages, implement above logic for all the pages.

To implement a hit counter you can make use of Application Implicit object and associated methods getAttribute() and setAttribute().

This object is a representation of the JSP page through its entire lifecycle. This object is created when the JSP page is initialized and will be removed when the JSP page is removed by the jspDestroy() method.

A hit counter tells you about the number of visits on a particular page of your web site.

The <jsp:forward> element forwards the request object containing the client request information from one JSP file to another file. The target file can be an HTML file, another JSP file, or a servlet, as long as it is in the same application context as the forwarding JSP file.

sendRedirect sends HTTP temporary redirect response to the browser, and browser creates a new request to go the redirected page.

Page redirection is generally used when a document moves to a new location and we need to send the client to this new location or may be because of load balancing, or for simple randomization.

You can hard code this in your program or this directory name could also be added using an external configuration such as a context-param element in web.xml.

To upload a single file you should use a single <input .../> tag with attribute type = "file".To allow multiple files uploading, include more than one input tags with different values for the name attribute.

When you are done with a user's session data, you have several options −

• Remove a particular attribute − You can call public void removeAttribute(String name) method to delete the value associated with the a particular key.

• Delete the whole session − You can call public void invalidate() method to discard an entire session.

• Setting Session timeout − You can call public void setMaxInactiveInterval(int interval) method to set the timeout for a session individually.

• Log the user out − The servers that support servlets 2.4, you can call logout to log the client out of the Web server and invalidate all sessions belonging to all the users.

• web.xml Configuration − If you are using Tomcat, apart from the above mentioned methods, you can configure session time out in web.xml file as follows.

Session management can be achieved by the use of −

• Cookies − A webserver can assign a unique session ID as a cookie to each web client and for subsequent requests from the client they can be recognized using the received cookie.

• Hidden Form Fields − A web server can send a hidden HTML form field along with a unique session ID as follows −

<input type = "hidden" name = "sessionid" value = "12345">

This implies that when the form is submitted, the specified name and value will be getting included in GET or POST method.

• URL Rewriting − In URL rewriting some extra information is added on the end of each URL that identifies the session. This URL rewriting can be useful where a cookie is disabled.

• The session Object − JSP makes use of servlet provided HttpSession Interface which provides a way to identify a user across more than one page request or visit to a Web site and to store information about that user.

To delete cookies is very simple. If you want to delete a cookie then you simply need to follow up following three steps −

• Read an already existing cookie and store it in Cookie object.

• Set cookie age as zero using setMaxAge() method to delete an existing cookie.

• Add this cookie back into response header.

To read cookies, you need to create an array of javax.servlet.http.Cookie objects by calling the getCookies( ) method of HttpServletRequest. Then cycle through the array, and use getName() and getValue() methods to access each cookie and associated value.