JSP Interview Questions

The JSP While loop is used to iterate the elements where it has one parameter of the condition.

Syntax of While loop:

While(i<n)
{
     //Block of statements
}

JSP stands for Java Server Pages. This technology is used to create dynamic web pages in the form of HyperText Markup Language (HTML). They have embedded Java code pieces in them. They are an extension to the Servlet Technology and generate Servlet from a page. It is common to use both servlets and JSP pages in the same web apps.

The JSP For loop is used for iterating the elements for a certain condition, and it has the following three parameters:

• The variable counter is initialized
• Condition till the loop has to be executed
• The counter has to be incremented

The for loop syntax is as follows:

for(inti=0;i<n;i++)
{
          //block of statements
}

JSP Operators support most of the arithmetic and logical operators that are supported by java within expression language (EL) tags.

Following are the frequently used jsp operators:

Expression Language (EL) was introduced in JSP 2.0. It is a mechanism that simplifies the accessibility of the data stored in Javabean components and other objects like request, session, and application, etc. There are many operators in JSP that are used in EL like arithmetic and logical operators to perform an expression.

JSP is a server-side scripting language as it runs on the server. Whereas, JavaScript runs on the client. Commonly, JSP is more used to change the content of a webpage, and JavaScript for the presentation. Both are quite commonly used on the same page.

The three types of elements with Java Server Pages (JSP) are directive, action, and scripting elements.
Following are the Directive Elements:

The Action elements are:

And lastly, the Scripting elements are:

A Java class that uses the Servlet Application Programming Interface (API) is a Servlet. The Servlet API consists of many classes and interfaces that define some methods. These methods make it possible to process HTTP requests in a web server-independent manner.

A servlet is loaded when a web server receives a request that should be handled by it. Once a servlet has been loaded, the same servlet instance (object) is called to process succeeding requests. Eventually, the webserver needs to shut down the servlet, typically when the web server itself is shut down. 

The 3 life cycle methods are:

• public void init(ServletConfig config)
• public void service(ServletRequest req, ServletResponse res)
• public void destroy( )

These methods define the interactions between the web server and the servlet.

JSP pages are often combined with servlets in the same application. The JSP specification is based on the Java servlet specification. Simply put, a servlet is a piece of code that adds new functionality to a web server, just like CGI and proprietary server extensions such as NSAPI and ISAPI. Compared to other technologies, servlets have a number of advantages: 

• Platform and vendor independence
• Integration
• Efficiency
• Scalability
• Robustness and security

A Java servlet template engine is a technology for separating presentation from processing. Template engines have been developed as open-source products to help get HTML out of the servlets. These template engines are intended to be used together with pure code components (servlets) and use only web pages with scripting code for the presentation part.

Two popular template engines are WebMacro (http://www.webmacro.org) and FreeMarker (http://freemarker.sourceforge.net).

• Better performance and quality as JSP is a specification and not a product.
• JSP pages can be used in combination with servlets.
• JSP is an integral part of J2EE, a complete platform for Enterprise-class applications.
• JSP supports both scripting and element-based dynamic content.

Earlier, Common Gateway Interface (CGI) was the only tool for developing dynamic web content and was not very efficient. The web server has to create a new operating system process, load an interpreter and a script, execute the script, and then tear it all down again, for every request that comes in. This is taxing for the server and doesn’t scale well when the number of traffic increases.

Alternatives such as ISAPI from Microsoft, and Java Servlets from Sun Microsystems, offer better performance and scalability. However, they generate web pages by embedding HTML directly in programming language code. JavaServer Pages (JSP) changes all of that.

When a container loads a JSP, it invokes the jspInit() method before servicing any requests.

public void jspInit(){
  // Initialization code...
}

The JSP container has a special servlet called the page compiler. All HTTP requests with URLs that match the .jsp file extension are forwarded to this page compiler by the configuration of the servlet container. The servlet container is turned into a JSP container with this page compiler. When a .jsp page is first called, the page compiler parses and compiles the .jsp page into a servlet class. The JSP servlet class is loaded into memory on the successful compilation. For the subsequent calls, the servlet class for that .jsp page is already in memory. Hence, the page compiler servlet will always compare the timestamp of the JSP servlet with the JSP page. If the .jsp page is more current, recompilation is necessary. With this process, once deployed, JSP pages only go through the time-consuming compilation process once.

The tags used in declaring variables are called JSP Declaration tags. These are used in declaring functions and variables. They are enclosed in <%!%> tag. Following is the syntax for JSP Declaration:

<%@page contentType=”text/html” %>
<html>
<body>
<%!
int a=0;
private int getCount(){
a++;
return a;
}
%>
<p>Values of a are:</p>
<p><%=getCount()%></p>
</body>
</html>

The Java 2 Enterprise Edition (J2EE) takes the task of building an Internet presence and transforms it to the point where developers can use Java to efficiently create multi-tier, server-side applications. In late 1999, Sun Microsystems added a new element to the collection of Enterprise Java tools, called the JavaServer Pages (JSP). The JSP, built on top of Java servlets, is designed to increase the efficiency in which programmers, and even nonprogrammers, can create web content.

JavaServer Pages helps in developing web pages that include dynamic content. A JSP page can change its content based on any number of variable items. A JSP page not only contains standard markup language elements like a regular web page but also contains special JSP elements that allow the server to insert dynamic content in the page. This combination of standard elements and custom elements allows for the creation of powerful web apps. 

References:

• JavaServer Pages, 3rd Edition, O'Reilly.
• Web Development with JavaServer Pages, by Duane and Mark.
• JSP vs Servlet

In MVC,

• M stands for Model
• V stands for View
• C stands for the controller.

It is an architecture that separates business logic, presentation, and data. In this, the flow starts from the view layer, where the request is raised and processed in the controller layer. This is then sent to the model layer to insert data and get back the success or failure message.

The JSP Scriptlet tag allows you to write Java code into a JSP file. The JSP container moves statements in the _jspservice() method while generating servlets from JSP.

For each request of the client, the service method of the JSP gets invoked hence the code inside the Scriptlet executes for every request.

In Scriptlet, a java code is executed every time the JSP is invoked.

Syntax of Scriptlet tag:

<% java code %>

Here <%%> tags are scriptlet tags and within it, we can place the java code.

Various action tags used in JSP are as follows:

• jsp:forward: This action tag forwards the request and response to another resource.
• jsp:include: This action tag is used to include another resource.
• jsp:useBean: This action tag is used to create and locates bean objects.
• jsp:setProperty: This action tag is used to set the value of the property of the bean.
• jsp:getProperty: This action tag is used to print the value of the property of the bean.
• jsp:plugin: This action tag is used to embed another component such as the applet.
• jsp:param: This action tag is used to set the parameter value. It is used in forward and includes mostly.
• jsp:fallback: This action tag can be used to print the message if the plugin is working.

Different JSP elements are used for generating the parts of the page that differ for each request. A JSP page is a regular web page with different JSP elements. The three types of elements with JavaServer Pages are directive, action, and scripting elements. JSP elements are often used to work with JavaBeans.

The elements of the page that are not JSP elements are simply called the “template text”. The template text is commonly HTML, but it could also be any other text.

When a page request of JSP is processed, the template text and the dynamic content generated by the JSP elements are merged, and the result is sent as the response to the browser.

The JSP page is turned into a servlet for all the JSP elements to be processed by the server. Then the servlet is executed. The servlet container and the JSP container—are often combined into one package under the name “web container”.

In the translation phase, the JSP container is responsible for converting the JSP page into a servlet and compiling the servlet. This is used to automatically initiate the translation phase for a page when the first request for the page is received.

In the “request processing” phase, the JSP container is also responsible for invoking the JSP page implementation class to process each request and generate the response.

The exception object is an instance of a subclass of Throwable (e.g., java.lang. NullPointerException). It is only available on the error pages. The following table lists out the important methods available in the Throwable class: 

JSP is used to handle the form data parsing automatically. It dies so by using the following methods depending on the situation:

• getParameter() − To get the value of a form parameter, call the request.getParameter() method.
• getParameterValues() − If a parameter appears more than once and it returns multiple values, call this method.
• getParameterNames() − This method is used if, in the current request, you want a complete list of all parameters.
• getInputStream() − This method is used for reading binary data streams from the client.

The JSTL Core tags are used for the following purposes:

• Iteration
• Conditional logic
• Catch exception
• URL forward
• Redirect, etc.

Following is the syntax to include a tag library:

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

JSTL stands for Java server pages standard tag library. It is a collection of custom JSP tag libraries that provide common functionality for web development.

Following are some of the properties of JSTL:

• Code is Neat and Clean.
• Being a Standard Tag, it provides a rich layer of the portable functionality of JSP pages.
• It has Automatic Javabeans Introspection Support. The JSTL Expression language handles JavaBean code very easily. We don't need to downcast the objects, which have been retrieved as scoped attributes.
• Easier for humans to read and easier for computers to understand.

J2EE is basically a compilation of different Java APIs that have previously been offered as separate packages. J2EE Blueprints describe how they can all be combined. J2EE vendors can use a test suite to test their products for compatibility. J2EE comprises the following enterprise-specific APIs:

• JavaServer Pages ( JSP)
• Java Servlets
• Enterprise JavaBeans (EJB)
• Java Database Connection ( JDBC)
• Java Transaction API ( JTA) and Java Transaction Service ( JTS)
• Java Naming and Directory Interface ( JNDI)
• Java Message Service ( JMS)
• Java IDL and Remote Method Invocation (RMI)
• Java XML

JavaBeans component is a Java class that complies with certain coding conventions. JSP elements often work with JavaBeans. For information that describes application entities, JavaBeans are typically used as containers.