Can we use JavaScript with JSP Pages?

Yes why not, I have seen some developers getting confused with this. Even though JSP is a server side technology, it’s used to generate client side response and we can add javascript or CSS code like any other HTML page.

How can we prevent implicit session creation in JSP?

By default JSP page creates a session but sometimes we don’t need session in JSP page. We can use JSP page directive session attribute to indicate compiler to not create session by default. It’s default value is true and session is created. To disable the session creation, we can use it like below.

1	<%@ page session ="false" %>

What is difference between JspWriter and Servlet PrintWriter?

PrintWriter is the actual object responsible for writing the content in response. JspWriter uses the PrintWriter object behind the scene and provide buffer support. When the buffer is full or flushed, JspWriter uses the PrintWriter object to write the content into response.

How can we extend JSP technology?

We can extend JSP technology with custom tags to avoid scripting elements and java code in JSP pages.

Provide some JSP Best Practices?

Some of the JSP best practices are:

1. Avoid scripting elements in JSP pages. If JSP EL, action elements and JSTL not serve your needs then create custom tags.
2. Use comment properly, use JSP comments for code level or debugging purpose so that it’s not sent to client.
3. Avoid any business logic in JSP page, JSP pages should be used only for response generation for client.
4. Disable session creation in JSP page where you don’t need it for better performance.
5. Use page, taglib directives at the start of JSP page for better readability.
6. Proper use of jsp include directive or include action based on your requirements, include directive is good for static content whereas include action is good for dynamic content and including resource at runtime.
7. Proper exception handling using JSP error pages to avoid sending container generated response incase JSP pages throw exception in service method.
8. If you are having CSS and JavaScript code in JSP pages, it’s best to place them in separate files and include them in JSP page.
9. Most of the times JSTL is enough for our needs, if you find a scenario where it’s not then check your application design and try to put the logic in a servlet that will do the processing and then set attributes to be used in JSP pages.

Please let me know if I have missed any important JSP interview question, I will be adding more to the list in future.

How do we print “ creates a new line in HTML” in JSP?

We can use c:out escapeXml attribute to escape the HTML elements so that it get’s shown as text in the browser, for this scenario we will write code like below.

What is jsp-config in deployment descriptor?

jsp-config element is used to configure different parameters for JSP pages. Some of it’s usage are:

• Configuring tag libraries for the web application like below.

  1 2 3 4 5 6

  <jsp-config>         <taglib>             <taglib-uri>http://journaldev.com/jsp/tlds/mytags</taglib-uri>             <taglib-location>/WEB-INF/numberformatter.tld</taglib-location>         </taglib> </jsp-config>

• We can control scripting elements in JSP pages.
• We can control JSP Expression Language (EL) evaluation in JSP pages.
• We can define the page encoding for URL pattern.
• To define the buffer size to be used in JSP page out object.
• To denote that the group of resources that match the URL pattern are JSP documents, and thus must be interpreted as XML documents.

When will Container initialize multiple JSP/Servlet Objects?

If we have multiple servlet and servlet-mapping elements in deployment descriptor for a single servlet or JSP page, then container will initialize an object for each of the element and all of these instances will have their own ServletConfig object and init params.

For example, if we configure a single JSP page in web.xml like below.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

<servlet>   <servlet-name>Test</servlet-name>   <jsp-file>/WEB-INF/test.jsp</jsp-file>   <init-param>     <param-name>test</param-name>     <param-value>Test Value</param-value>   </init-param> </servlet>       <servlet-mapping>   <servlet-name>Test</servlet-name>   <url-pattern>/Test.do</url-pattern> </servlet-mapping>       <servlet>   <servlet-name>Test1</servlet-name>   <jsp-file>/WEB-INF/test.jsp</jsp-file> </servlet>       <servlet-mapping>   <servlet-name>Test1</servlet-name>   <url-pattern>/Test1.do</url-pattern> </servlet-mapping>

Then if we can access same JSP page with both the URI pattern and both will have their own init params values.

How to ignore the EL expression evaluation in a JSP?

We can ignore EL evaluation in JSP page by two ways.

1. Using page directive as <%@ page isELIgnored="true" %>
2. Configuring in web.xml – better approach when you want to disable EL evaluation for many JSP pages.

   1 2 3 4 5 6

   <jsp-config>     <jsp-property-group>         <url-pattern>*.jsp</url-pattern>         <el-ignored>true</el-ignored>     </jsp-property-group> </jsp-config>

Why don’t we need to configure JSP standard tags in web.xml?

We don’t need to configure JSP standard tags in web.xml because the TLD files are inside the META-INF directory of the JSTL jar files. When container loads the web application and find TLD files inside the META-INF directory of JAR file, it automatically configures them to be used directly in the application JSP pages. All we need to do it to include it in the JSP page using taglib directive.

How do we catch exception and process it using JSTL?

We can use JSTL Core tags c:catch and c:if to catch exception inside the JSP service method and process it. c:catch tag catches the exception and wraps it into the exception variable and we can use c:if condition tag to process it. Below code snippet provide sample usage.

<c:catch var ="exception">

   <% int x = 5/0;%>

</c:catch>

   

<c:if test = "${exception ne null}">

   <p>Exception is : ${exception} <br />

   Exception Message: ${exception.message}</p>

</c:if>

How can we handle exceptions thrown by JSP service method?

To handle exceptions thrown by the JSP page, all we need is an error page and define the error page in JSP using page directive.

To create a JSP error page, we need to set page directive attribute isErrorPage value to true, then we can access exception implicit object in the JSP and use it to send customized error message to the client.

We need to define exception and error handler JSP pages in the deployment descriptor like below.

<error-page>

     <error-code>404</error-code>

     <location>/error.jsp</location>

</error-page>

   

<error-page>

     <exception-type>java.lang.Throwable</exception-type>

     <location>/error.jsp</location>

</error-page>

What is JSP Standard Tag Library, provide some example usage?

JSP Standard Tag Library or JSTL is more versatile than JSP EL or Action elements because we can loop through a collection or escape HTML tags to show them like text in response.

JSTL is part of the Java EE API and included in most servlet containers. But to use JSTL in our JSP pages, we need to download the JSTL jars for your servlet container. Most of the times, you can find them in the example projects and you can use them. You need to include these libraries in the project WEB-INF/lib directory. These jars are container specific, for example in Tomcat, we need to include jstl.jar and standard.jar jar files in project build path.

How to use JSP EL to get HTTP method name?

We can use pageContext JSP EL implicit object to get the request object reference and use dot operator to get the HTTP method name in JSP page. The JSP EL code for this will be${pageContext.request.method}.

Give an example where you need JSP Custom Tag?

Let’s say we want to show a number with formatting with commas and spaces. This can be very useful for user when the number is really long. So we want some custom tags like below:

<mytags:formatNumber number="123456.789" format="#,###.00"/>

Based on the number and format passed, it should write the formatted number in JSP page, for above example it should print 123,456.79

We know that JSTL doesn’t provide any inbuilt tags to achieve this, so we will create our own custom tag implementation and use it in the JSP page.

What is JSP Custom Tag and what are it’s components?

Sometimes JSP EL, Action Tags and JSTL tags are not enough and we might get tempted to write java code to perform some operations in JSP page. Fortunately JSP is extendable and we can create our own custom tags to perform certain operations.

We can create JSP Custom Tags with following components:

• JSP Custom Tag Handler
• Creating Tag Library Descriptor (TLD) File
• Deployment Descriptor Configuration for TLD

We can add custom tag library in JSP page using taglib directive and then use it.

What are the types of JSTL tags?

Based on the JSTL functions, they are categorized into five types.

1. Core Tags – Core tags provide support for iteration, conditional logic, catch exception, url, forward or redirect response etc.
2. Formatting and Localization Tags – These tags are provided for formatting of Numbers, Dates and i18n support through locales and resource bundles.
3. SQL Tags – JSTL SQL Tags provide support for interaction with relational databases such as Oracle, MySql etc.
4. XML Tags – XML tags are used to work with XML documents such as parsing XML, transforming XML data and XPath expressions evaluation.
5. JSTL Functions Tags – JSTL tags provide a number of functions that we can use to perform common operation, most of them are for String manipulation such as String Concatenation, Split String etc.

What are JSP EL implicit objects and how it’s different from JSP implicit Objects?

JSP Expression Language provides many implicit objects that we can use to get attributes from different scopes and parameter values. Note that these are different from JSP implicit objects and contains only the attributes in given scope. The only common implicit object in JSP EL and JSP page is pageContext object.

Below table provides list of implicit object in JSP EL.

JSP EL Implicit Objects	Type	Description
pageScope	Map	A map that contains the attributes set with page scope.
requestScope	Map	Used to get the attribute value with request scope.
sessionScope	Map	Used to get the attribute value with session scope.
applicationScope	Map	Used to get the attributes value from application scope.
param	Map	Used to get the request parameter value, returns a single value
paramValues	Map	Used to get the request param values in an array, useful when request parameter contain multiple values.
header	Map	Used to get request header information.
headerValues	Map	Used to get header values in an array.
cookie	Map	Used to get the cookie value in the JSP
initParam	Map	Used to get the context init params, we can’t use it for servlet init params
pageContext	pageContext	Same as JSP implicit pageContext object, used to get the request, session references etc. example usage is getting request HTTP Method name.

What is JSP Expression Language and what are it’s benefits?

Most of the times we use JSP for view purposes and all the business logic is present in servlet code or model classes. When we receive client request in servlet, we process it and then add attributes in request/session/context scope to be retrieved in JSP code. We also use request params, headers, cookies and init params in JSP to create response views.

We can use scriptlets and JSP expressions to retrieve attributes and parameters in JSP with java code and use it for view purpose. But for web designers, java code is hard to understand and that’s why JSP Specs 2.0 introduced Expression Language (EL) through which we can get attributes and parameters easily using HTML like tags.

Expression language syntax is ${name} and we can use EL implicit objects and EL operators to retrieve the attributes from different scopes and use them in JSP page.

What is difference between include directive and jsp:include action?

The difference between JSP include directive and include action is that in include directive the content to other resource is added to the generated servlet code at the time of translation whereas with include action it happens at runtime.

Another difference is that in JSP include action, we can pass params to be used in the included resource with jsp:param action element but in JSP include directive we can’t pass any params.

When included resource is static such as header, footer, image files then we should use include directive for faster performance but if the included resource is dynamic and requires some parameters for processing then we should use include action tag.