Explore topic-wise InterviewSolutions in .

Setting cookies with JSP involves three steps −

• Creating a Cookie object − You call the Cookie constructor with a cookie name and a cookie value, both of which are strings.

• Setting the maximum age − You use setMaxAge to specify how long (in seconds) the cookie should be valid.

• Sending the Cookie into the HTTP response headers − You use response.addCookie to add cookies in the HTTP response header

Cookies are usually set in an HTTP header (although JavaScript can also set a cookie directly on a browser).If the browser is configured to store cookies, it will then keep this information until the expiry date. If the user points the browser at any page that matches the path and domain of the cookie, it will resend the cookie to the server.

Cookies are text files stored on the client computer and they are kept for various information tracking purpose.

Filters are defined in the deployment descriptor file web.xml and then mapped to either servlet or JSP names or URL patterns in your application's deployment descriptor.

When the JSP container starts up your web application, it creates an instance of each filter that you have declared in the deployment descriptor. The filters execute in the order that they are declared in the deployment descriptor.

JSP Filters are Java classes that can be used in JSP Programming for the following purposes −

• To intercept requests from a client before they access a resource at back end.

• To manipulate responses from server before they are sent back to the client.

JSP handles form data parsing automatically using the following methods depending on the situation −

• getParameter() − You call request.getParameter() method to get the value of a form parameter.

• getParameterValues() − Call this method if the parameter appears more than once and returns multiple values, for example checkbox.

• getParameterNames() − Call this method if you want a complete list of all parameters in the current request.

• getInputStream() − Call this method to read binary data stream coming from the client.

The GET method sends the encoded user information appended to the page request. The page and the encoded information are separated by the ? Character.

The POST method packages the information in exactly the same way as GET methods, but instead of sending it as a text string after a ? in the URL it sends it as a separate message. This message comes to the backend program in the form of the standard input which you can parse and use for your processing.

This object is an actual reference to the instance of the page. It can be thought of as an object that represents the entire JSP page.

The page object is really a direct synonym for the this object.

The pageContext object is an instance of a javax.servlet.jsp.PageContext object. The pageContext object is used to represent the entire JSP page.

This object stores references to the request and response objects for each request. The application, config, session, and out objects are derived by accessing attributes of this object.

The pageContext object also contains information about the directives issued to the JSP page, including the buffering information, the errorPageURL, and page scope.

The config object is an instantiation of javax.servlet.ServletConfig and is a direct wrapper around the ServletConfig object for the generated servlet.

This object allows the JSP programmer access to the Servlet or JSP engine initialization parameters such as the paths or file locations etc.

The application object is direct wrapper around the ServletContext object for the generated Servlet and in reality an instance of a javax.servlet.ServletContext object.

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.

The session object is an instance of javax.servlet.http.HttpSession and is used to track client session between client requests

The JspWriter object contains most of the same methods as the java.io.PrintWriter class. However, JspWriter has some additional methods designed to deal with buffering. Unlike the PrintWriter object, JspWriter throws IOExceptions.

The out implicit object is an instance of a javax.servlet.jsp.JspWriter object and is used to send content in a response.

The response object is an instance of a javax.servlet.http.HttpServletRequest object. Just as the server creates the request object, it also creates an object to represent the response to the client.

The response object also defines the interfaces that deal with creating new HTTP headers. Through this object the JSP programmer can add new cookies or date stamps, HTTP status codes etc.

Using getHeaderNames() method of HttpServletRequest to read the HTTP header information. This method returns an Enumeration that contains the header information associated with the current HTTP request.

The request object is an instance of a javax.servlet.http.HttpServletRequest object. Each time a client requests a page the JSP engine creates a new object to represent that request.

The request object provides methods to get HTTP header information including form data, cookies, HTTP methods etc.

request, response, out, session, application, config, pageContext, page, Exception

JSP Implicit Objects are the Java objects that the JSP Container makes available to developers in each page and developer can call them directly without being explicitly declared. JSP Implicit Objects are also called pre-defined variables.

The scope attribute identifies the lifecycle of the Action element. It has four possible values: (a) page, (b)request, (c)session, and (d) application.

The plugin action is used to insert Java components into a JSP page. It determines the type of browser and inserts the <object> or <embed> tags as needed.

If the needed plugin is not present, it downloads the plugin and then executes the Java component. The Java component can be either an Applet or a JavaBean.

The forward action terminates the action of the current page and forwards the request to another resource such as a static page, another JSP page, or a Java Servlet.

The simple syntax of this action is as follows −

<jsp:forward page = "Relative URL" />

The getProperty action is used to retrieve the value of a given property and converts it to a string, and finally inserts it into the output.

The setProperty action sets the properties of a Bean. The Bean must have been previously defined before this action.

The useBean action is quite versatile. It first searches for an existing object utilizing the id and scope variables. If an object is not found, it then tries to create the specified object.

The simplest way to load a bean is as follows −

<jsp:useBean id = "name" class = "package.class" />

Unlike the include directive, which inserts the file at the time the JSP page is translated into a servlet, include action inserts the file at the time the page is requested.

This action lets you insert files into the page being generated. The syntax looks like this −

<jsp:include page = "relative URL" flush = "true" />

Where page is the relative URL of the page to be included.

Flush is the boolean attribute the determines whether the included resource has its buffer flushed before it is included.

• Id attribute − The id attribute uniquely identifies the Action element, and allows the action to be referenced inside the JSP page. If the Action creates an instance of an object the id value can be used to reference it through the implicit object PageContext

• Scope attribute − This attribute identifies the lifecycle of the Action element. The id attribute and the scope attribute are directly related, as the scope attribute determines the lifespan of the object associated with the id. The scope attribute has four possible values: (a) page, (b)request, (c)session, and (d) application.

The taglib directive follows the following syntax −

<% taglib uri = "uri" prefix = "prefixOfTag">

uri attribute value resolves to a location the container understands

prefix attribute informs a container what bits of markup are custom actions.

The taglib directive follows the following syntax −

<% taglib uri = "uri" prefix = "prefixOfTag" >

The include directive is used to includes a file during the translation phase. This directive tells the container to merge the content of other external files with the current JSP during the translation phase. You may code include directives anywhere in your JSP page.

The general usage form of this directive is as follows −

<% include file = "relative url" >

The isScriptingEnabled attribute determines if scripting elements are allowed for use.

The default value (true) enables scriptlets, expressions, and declarations. If the attribute's value is set to false, a translation-time error will be raised if the JSP uses any scriptlets, expressions (non-EL), or declarations.

The isELIgnored option gives you the ability to disable the evaluation of Expression Language (EL) expressions.

The default value of the attribute is true, meaning that expressions, ${...}, are evaluated as dictated by the JSP specification. If the attribute is set to false, then expressions are not evaluated but rather treated as static text.

The session attribute indicates whether or not the JSP page uses HTTP sessions. A value of true means that the JSP page has access to a builtin session object and a value of false means that the JSP page cannot access the builtin session object.

The language attribute indicates the programming language used in scripting the JSP page.

The isThreadSafe option marks a page as being thread-safe. By default, all JSPs are considered thread-safe. If you set the isThreadSafe option to false, the JSP engine makes sure that only one thread at a time is executing your JSP.

The info attribute lets you provide a description of the JSP.

The import attribute serves the same function as, and behaves like, the Java import statement. The value for the import option is the name of the package you want to import.

The extends attribute specifies a superclass that the generated servlet must extend.

The isErrorPage attribute indicates that the current JSP can be used as the error page for another JSP.

The value of isErrorPage is either true or false. The default value of the isErrorPage attribute is false.

The errorPage attribute tells the JSP engine which page to display if there is an error while the current page runs. The value of the errorPage attribute is a relative URL.

The contentType attribute sets the character encoding for the JSP page and for the generated response page. The default content type is text/html, which is the standard content type for HTML pages.

The autoFlush attribute specifies whether buffered output should be flushed automatically when the buffer is filled, or whether an exception should be raised to indicate buffer overflow.

A value of true (default) indicates automatic buffer flushing and a value of false throws an exception.

When buffer is set to “none”, servlet output is immediately directed to the response output object.

The buffer attribute specifies buffering characteristics for the server output response object.

Page directive contains the following 13 attributes.

1. language

2. extends

3. import

4. session

5. isThreadSafe

6. info

7. errorPage

8. isErrorpage

9. contentType

10. isELIgnored

11. buffer

12. autoFlush

13. isScriptingEnabled

The page directive is used to provide instructions to the container that pertain to the current JSP page. You may code page directives anywhere in your JSP page.

Literals are the values, such as a number or a text string, that are written literally as part of a program code. The JSP expression language defines the following literals −

• Boolean − true and false

• Integer − as in Java

• Floating point − as in Java

• String − with single and double quotes; " is escaped as \", ' is escaped as \', and \ is escaped as \\.

• Null − null

jsp:include, jsp:useBean,jsp:setProperty,jsp:getProperty, jsp:forward,jsp:plugin,jsp:element, jsp:attribute, jsp:body, jsp:text

JSP actions use constructs in XML syntax to control the behavior of the servlet engine. You can dynamically insert a file, reuse JavaBeans components, forward the user to another page, or generate HTML for the Java plugin.

Its syntax is as follows −

<jsp:action_name attribute = "value" />

The types directive tags are as follows −

• <% page ... %> − Defines page-dependent attributes, such as scripting language, error page, and buffering requirements.

• <% include ... %> − Includes a file during the translation phase.

• <% taglib ... %> − Declares a tag library, containing custom actions, used in the page.