• Pre-translated: Before the JSP file has been translated and compiled into the Servlet.

• Translated: The JSP file has been translated and compiled as a Servlet.

• Initialized: Prior to handling the requests in the service method the container calls the jspInit() to initialize the Servlet. Called only once per Servlet instance.

• Servicing: Services the client requests. Container calls this method for each request.

• Out of service:The Servlet instance is out of service. The container calls the jspDestroy() method.

Learn more about JSP

• Declaration Element: is the embedded Java declaration statement, which gets inserted at the Servlet class level.

                                       < %! Calendar c = Calendar.getInstance(); % >

Important: declaring variables via this element is not thread-safe, because this variable ends up in the generated Servlet as an instance variable, not within the body of the _jspservice() method. Ensure their access is either read-only or synchronized.

• Expression Element: is the embedded Java expression, which gets evaluated by the service method.

                                       < %= new Date()%>

• Scriptlet Elements: are the embedded Java statements, which get executed as part of the service method. (Note: Not recommended to use Scriptlet elements because they don't provide reusability and maintainability. Use custom tags (like JSTL, JSF tags, etc) or beans instead).

                                       < %
//Java codes
String userName=null;
userName=request.getParameter("userName");
% >

• Action Elements: A JSP element that provides information for execution phase. • Directive Elements: A JSP element that provides global information for the translation phase.

cbjhvhdvf table

No. The declaration of variables in JSP is not thread-safe, because the declared variables end up in the generated Servlet as an instance variable, not within the body of the _jspservice() method. The following declaration is not thread safe: because these are declarations, and will only be evaluated once when the page is loaded

                                       < %! int a = 5 % >

The following declaration is thread safe: because the variables declared inside the scriplets have the local scope and not shared.

                                       < % int a = 5 % >

JSP resources usually reside directly or under subdirectories (e.g. myPath) of the document root, which are directly accessible to the user through the URL. If you want to protect your Web resources then hiding the JSP files behind the WEB-INF directory can protect the JSP files, css (cascading style sheets) files, Java Script files, pdf files, image files, html files etc from direct access. The request should be made to a servlet who is responsible for authenticating and authorising the user before returning the protected JSP page or its resources.

Custom JSP tag is a tag you define. You define how a tag, its attributes and its body are interpreted, and then group your tags into collections called tag libraries that can be used in any number of JSP files. So basically it is a reusable and extensible JSP only solution. The pre-built tags also can speed up Web development.

Step 1 Create a Custom tag class using only doStartTag()

        package myTagPkg;
public class MyTag extends TagSupport
{
int attr = null;
public int setAttr(int a ttr){this.attr = a ttr}
public int getAttr(){return attr;}
public int doStartTag() throws JspException
{
.......
return 0;
}
public void release(){.....}
}

        tag1
myTagPkg.MyTag
empty

attr
false
false

        /WEB-INF/MyTagURI

/WEB-INF/tags/MyTagDesc.tld

        <@ taglib uri="/WEB-INF/ MyTagURI" prefix="myTag" %>

tag1
myTagPkg.MyTag
empty

attr
false
false

Certain objects that are available for the use in JSP documents without being declared first. These objects are parsed by the JSP engine and inserted into the generated servlet. The implicit objects are listed below:

request response pageContext session application out config page exception

You will need to set the appropriate HTTP header attributes to prevent the dynamic content output by the JSP page from being cached by the browser. Just execute the following scriptlet at the beginning of your JSP pages to prevent them from being cached at the browser. You need both the statements to take care of some of the older browser versions.

        <% response.setHeader("Cache-Control","no-store"); //HTTP 1.1
response.setHeader("Pragma\","no-cache"); //HTTP 1.0
response.setDateHeader ("Expires", 0); //prevents caching at the proxy server
%>

JSPs can be thread-safe by having them implement the SingleThreadModel interface. This is done by adding the directive

        <%@ page isThreadSafe="false" %>

within your JSP page. With this, instead of a single instance of the servlet generated for your JSP page loaded in memory, you will have N instances of the servlet loaded and initialized, with the service method of each instance effectively synchronized. You can typically control the number of instances (N) that are instantiated for all servlets implementing SingleThreadModel through the admin screen for your JSP engine. More importantly, avoid using the tag for variables. If you do use this tag, then you should set isThreadSafe to true, as mentioned above. Otherwise, all requests to that page will access those variables, causing a nasty race condition. SingleThreadModel is not recommended for normal use. There are many pitfalls, including the example above of not being able to use <%! %>. You should try really hard to make them thread-safe the old fashioned way: by making them thread-safe .

Because the servlet init() method is invoked when servlet instance is loaded, it is the perfect location to carry out expensive operations that need only be performed during initialization. By definition, the init() method is thread-safe. The results of operations in the HttpServlet.init() method can be cached safely in servlet instance variables, which become read-only in the servlet service method.

By default, JSP files create HttpSessions. This is in compliance with J2EETM to facilitate the use of JSP implicit objects, which can be referenced in JSP source and tags without explicit declaration. HttpSession is one of those objects. If you do not use HttpSession in your JSP files then you can save some performance overhead with the following JSP page directive:

        
<%@ page session="false"%>

The standard actions available in JSP are as follows:

• < jsp:include >: It includes a response from a servlet or a JSP page into the current page. It differs from an include directive in that it includes a resource at request processing time, whereas the include directive includes a resource at translation time.

• < jsp:forward >: It forwards a response from a servlet or a JSP page to another page.

• < jsp:useBean >: It makes a JavaBean available to a page and instantiates the bean.

• < jsp:setProperty >:It sets the properties for a JavaBean.

• < jsp:getProperty >:It gets the value of a property from a JavaBean component and adds it to the response.

• < jsp:param >: It is used in conjunction with ;, ; to add a parameter to a request. These parameters are provided using the name-value pairs.

• < jsp:plugin >: It is used to include a Java applet or a JavaBean in the current JSP page.