We know servlet program is placed in WEB-INF folder. WEB-INF is a private directory of deployed web application. So any web resource program that is placed in WEB-INF folder or its subfolder (like classes) must be configured in web.xml file to make the underlying container and server recognizing web resource program.

A JSP program can have two types of objects.

• Explicit objects

• Implicit objects [Read more…] about Exploring Implicit Objects

JSP comment

Used for commenting JSP tags base code (or JSP code) of JSP program. A JSP page compiler recognizes JSP comments. As JSP comments are visible in source, code of  JSP program and not visible in any other process of JSP program execution so these are called hidden comments. They are written like this:

<%–……..–>

HTML Comments

Used for commenting html code and text of JSP program. Html interceptor recognizes this type of comments. We use html comment on scripting JSP tags (scriptlet, declaration and expression) but we cannot use these comments on other JSP tags. They are written like this:

<!– ……………..–>Script comments

Java compiler recognizes this type of comments.

//:-used for commenting one line of code

/*….* /: -used for commenting multiple line of code

                                        Visibility Chart of JSP Comments

A JSP page contains tags. The tags are in the form of scripting tags, directive tags and comments. Tags help programmers to develop Java codeless JSP program. Implicit objects increase the functionality of JSP page. Scripting element also helps in generating dynamic content and displaying dynamic content. [Read more…] about JSP Scripting Elements

Life cycle of a program includes the phases starting from creating objects for the class, execution, and at last destruction of objects. For this life cycle, JSP needs some life cycle methods.

The method that is called by container automatically and directly when event is raised is called life cycle method. The methods which are called internally from this life cycle methods are called life cycle convince helper methods.

Life cycle of JSP is similar to Servlet life cycle.

In the execution phase of JSP page, first JSP page is translated into an equivalent Servlet, then the source file of the Servlet is compiled into a .class file. Every time a JSP page is requested, its corresponding Servlet will be executed. So life cycle of JSP is similar to Servlet life cycle.

JSP Life-Cycle Methods

The methods called by the container automatically when event is raised are called life-cycle methods.

As you know, JSP page is first converted into an equivalent Servlet program, so life cycle method of JSP is same as Servlet life-cycle method. But Sun Microsystems has given three life-cycle convince methods as alternatives to original life-cycle methods.

Like:

for init(-) _jspInit()

service(-,-)….._jspService(-,-)

destroy () ……._jspDestroy ()

init(-) method internally calls the convince method _jsplnit() from super class of JSP equivalent servlet class.

service(-,-) internally calls the convince method _jspService(-,-) from super class of JSP equivalent servlet class.

destroy() internally calls the convince method _jspDestroy() from super class of JSP equivalent servlet class.

The super class for JSP equivalent Servlet is server dependent. In Tomcat server, the super class is org.apache.jasper.runtime.Http]spBase. Every JSP equivalent Servlet is HttpServlet by default.

Main Stages of The Life-Cycle Of A JSP Page

• JSP Page compilation

• Source Code Compilation

• Life Cycle ConvinceMethodExecution

JSP Page Compilation

Page compilation: The process of converting JSP code into an equivalent Servlet program code is called JSP page compilation.

In this phase, web container translates the JSP page into an equivalent Servlet code. The main objective of page translation is to convert the tag based code into more Java code for smooth execution by the JVM. The translation of JSP is automatically done by the server at the time of deploying web application or JSP receives the request for the first time.

In this phase, web container performs the activity like locating requested JSP page, validating the syntactic correctness of the JSP pages, and generating source code of equivalent Servlet code for JSP page.

i. Source code compilation:

In this stage, JSP container compiles the Java source code i.e. the equivalent servlet code and converts into Java byte (.class) code. Generally, most servers like web logic, discard the generated source code after compilation phase.

ii. Life cycle convinces methods execution:

Initialization: After the compilation phase, web container loads the class file. To create instance of Servlet class, ISP container uses the no-argument constructor. After that the container initializes the objects by invoking the init(ServletConfig) method. This method is called jsplnit() method.

Request processing: In this stage, web container uses the successfully initialized ISP equivalent Servlet objects to process client request. As per Servlet life cycle web container invokes service(-,-) method on the Servlet object by passing the request object of HttpServletRequest and response object of HttpServletResponse. In case of JSP equivalent Servlet. the container invokes the _jspService() method.

Destroying: If Servlet container wants to destroy the instances then it performs the following activities-First it allows time to currently executing threads to complete their operations and simultaneously it makes Servlet instance unavailable for other requests. After the current threads complete their operations on service( -,-) method, then the container calls the destroy() method on a Servlet instance, which invokes the jspDestroy() method.

Creating a Simple JSP Page

Here we are creating a simple web application which will show current system date and addition of numbers. Till know we have not discussed the various tags like scriptlets, directives. So this will give you an idea about how ISP program is designed, used, deployed in server, and accessed through browser windows.

Procedure to Develop and Deploy JSP-based Web Application

Settings needed: A web server or application server (here we have taken Tomcat

server)

Jar file to be set in the CLASSPATH: Servlet-api.jar or jsp-api.jar file have to be set to the CLASSPATH.

To set jar file to CLASSPATH: Copy the path of the jar file from the address bar of folder where Tomcat is installed as shown:

F:\ Tomcat 6.0\lib \servlet-apLjar

then

Right click on my computer

Click properties

Click advanced tab

Click environment variables

Click ‘new’ button of system variables and set

variable name: CLASSPATH

variable value: F:\ Tomcat 6.0\lib \servlet-api.jar; (paste and insert ‘;’ at the end) click OK for installation Tomcat server.

Development of Web Application

Step 1 Create a deployment directory structure like this

Here WEB-INF, web.xml is case sensitive and .jsp file should be placed parallel to WEB-INF folder

Step 2 Welcome.jsp

<html>

<hl> <center> Welcome to JSP </center> </hl>

<b> <center> <font size=5>Systems date and time is :- </font> </center> </b>

<% java.util.Date d=new java.util.Date (); %>

<body> <font color=“red” size=6/> <center>

<%

out.println (d.toString ());

%>

</center>

</html>

Save this file as Welcome.jsp, the extension is .jsp

Step 3 Configuration of web.xml in JSP program is optional

You can make web.xml as

web.xml

<web-app/>

Deploy the web application

Step 4 Start the Tomcat server

Click F:\Tomcat 6.0\bin\tomcat6.exe file (or) Open command prompt and specify the path of bin folder of Tomcat and type as given below:

F:\Tomcat 6.0\bin>java -jar bootstrap.jar and press enter

Step5 Copy the JspApp folder and paste in F:\ Tomcat 6.0\ webapps folder

Step6 Testing of web application

Open browser window and write in the address bar of browser as follows:

https://ecomputernotes.com:8080/JspApp/Welcome.jsp

localhost: Because system is not in network, if system is in network then type IP address of the system in place of local host.

8080: It is the port number of Tomcat. You can give any 4-digit number at the time of Tomcat installation.

JspApp: is the JSP application folder name.

After giving request to browser window, the JSP equivalent Servlet code (JES) and .class file will create in F:\Tomcat 6.0\work\catalina\localhost\jspApp\org\apache\jsp

And the JES code will like this…

package org.apache.jsp;

import javax.servlet.*;

import javax.servlet.http.*;

import javax.servlet.jsp.*;

public final class Welcome_jspextends org.apache.jasper.runtime.HttpJsp

Base implements org.apache.jasper.runtime.JspSourceDependent

{

     private static final JspFactory_jspxFactory =

     JspFactory.getDefaultFactory();

     private static java.util.List_jspx_dependants;

     private javax.el.ExpressionFactory_el_expressionfactory;

     private org.apache.AnnotationProcessor_jsp_annotationprocessor;

     public object getDependants ()

     {

           return_jspx_dependants;

     }

      public void_jsplnit ()

      {

            _el_expressionfactory = _jspxFactory.getJspApplicationContext

            (getServletConfig ().getServletContext ()).getExpressionFactory ();

            _jsp_annotationprocessor = (org.apache.Annotationprocessor)

            getServletConfig ().getServletContext ().getAttribute

            (org.apache.Annotationprocessor.class.getName ());

      }

       public void_jspDestroy ()

       {

       }

       public void_jspService (HttpServletRequest request, HttpServlet

       Response response) throws java.io.IOExcption, Servletexception

       {

            PageContext pageContext = null;

            HttpSession session = null;

            ServletContext application = null;

            ServletConfig config = null”;

            JspWriter out= null;

            Object page= this;

            JspWriter_jspx_out = null;

            PageContext_jspx_page_context = null;

            try

           {

                response.setContentType (“text/html”);

                pageContext = _jspxFactory.getPageContext (this, request,

                response, null, true, 8192, true);

               _jspx-page_context = pageContext;

               application = pageContext.getServletContext ();

               config = pageContext.getServletConfig          ();

               session = pageContext.getSession ();

               out = pageContext.getOut ();

              _jspx_out = out;

              out.write (“<html>\r\n”);

              out.write (“<hl> <center> Welcome to JSP </center> </hl>\r\n”);

              out.write (“<b> <center> font size=5>Systems date and time is:-

              </font> </center> </b>\r\n”);

              java.util.Date d=new java.util.Date();

              out.write (“\r\n”) ;

              out.write (“<body> <font color=\“red\” size=6/> <center>\r\n”);

              out.println (d.toString ());

              out.write (“\r\n”);

              out.write(“</center>\r\n”) ;

              out.write(“</html>\r\n”) ;

           }

           catch (Throwable t)

          {

               if (! (t instanceof SkipPageException))

              {

                   out = _jspx_out;

                   if (out != null && out.getBufferSize () !=0)

                   try

                  {

                       out.clearBuffer ();

                  }

                  catch (java.io.IOException e)

                 {

                 }

                 if (_jspx-page_context != null)_jspx_page_context.handlePage

                 Exception (t);

              }

          }

          finally

         {

              _jspxFactory.releasePageContext (_jspx_page_context) ;

         }

      }

}

Here the point to consider is that the JES file name is Welcome_jsp.java and class name is Welcome_jsp.class and all implicit object is visible in _jspService (-,-) method. You can see the implicit objects are visible inside _jspService (-,-) method.

A JSP page mainly comprises the following types of code.

• HTML Code

HTML code is used for displaying the HTML output like text field, check box, option menu where user can give requested data to the web application and also for generating other static content of the web page. HTML codes can be embedded easily in the JSP page.

• Scripting Code

Scripting code means the codes which have nested in some other code without any extension. Like JavaScript code it is used in JSP page to get some more dynamism like email id validation, password field length validation, etc.

• Scripting Tags

Java codes are placed inside the scripting tags. There are three types of scripting tags in JSP: Scriptlet Tag, Declaration Tag, Expression Tag.

Template Text

Template text is a combination of normal text and HTML code. It is the uninterrupted data of a JSP page. It is guides the end user when entering data in the required fields.

For web application development JSP generally supports two types of architecture.

i.  Model 1 and

ii. Model 2 architecture

JSP Model-I Architecture

In model 1 architecture, the web browser directly accesses the JSP pages. If there is need of, generating output from database jsp page interacts with JavaBeans, which is present inside the web container of model 1 architecture.

JSP Model II Architecture

In model 2 architecture, the browser accesses the JSP page indirectly. The Servlet program acts as controller between JSP page and browser window. If JSP page needs to interact with database for response then servlet program creates the instances of JavaBeans, and JavaBeans invokes the database server.

• Supports tags based programming

JSP supports tag-based programming. As it is a tag-based programming extensive knowledge of Java is not required. Non-Java users can learn it easily. This tag increases the readability of code. Gives built-in JSP tags and also allows to develop custom JSP tags and also to use third party supplied JSP tags.

• Implicit objects

JSP gives nine implicit objects. We can use them directly in our program without writing any additional code to access.

• Code separation

It allows separate presentation logic (html code) and business logic (java code). So does not look bulky. Here we do not have to put html code inside pw.printin() .

• Exception handling

Exception handling is optional in JSP. Container takes care of exception handling. And also implicit object exception is given to get the exception type, but it is only visible inside error page.

• Easy loading

After modifications we do not need to recompile and reload it. We just have to save it and then directly we can send request; and the modifications will be visible. JSP also contains many more features like Standard directives, Scripting elements, Tag extension mechanism, Template content.

We know that Servlet is a server side technology, so why has Sun Microsystems given JSP?

Servlet is a Java code based programming. To know servlet, strong Java knowledge is required. However, while working with ASP.net, PHP like technologies we can go for tag-based programming which is easier. So in initial days programmer did not like Servlet. To attract non-java programmers like ASP.net programmers and PHP programmer Sun Microsystems has introduced a server side technology which is tag based all features of servlet.

JSP enables us to mix up static HTML with dynamically generated content of servlet. the Take example of an online-shopping website, its initial page is mostly same for all visitors, except small changes like welcome message “Hi Mr / Ms Xxx” for registered users. When we develop this by servlet then we have to develop this entire page by writing coding in the Servlet program. However, JSP makes separate parts for static content and dynamic content.

Advantage of JSP over Servlet

Advantages over All Other Technologies

• Versus active server pages (ASP)

ASP is given by Microsoft. It is also a tag-based programming language. ASP code is not portable. However, JSP code is portable because it is written in Java (i.e., we can reuse the code in other operating systems and also in other web server). We can use Java for JSP, so we need not stick with a particular server product or IIS.

• Versus PHP

It is an HTML embedded scripting language and it is also open source software like Java. It is similar to JSP and ASP. It is not suitable for large scale application and banking applications where money transaction occurs because of security reasons. For PHP we have to learn one new language.

• Versus JavaScript

JavaScript is in no way related with Java programming. It is normally used to generate HTML dynamically on the client machine. JavaScript is not suitable for network programming and to access server-side resources. Java is more powerful, flexible, reliable and portable than PHP.

• Versus HTML

Regular HTML, that is static HTML, does not contain dynamic information. So it does not react to user input and is also not fit for accessing server side resources. JSP contains both static and non-static content. As static part, it contains HTML.

There are some problems with Servlet programming.

For non-java programmers Servlet is not suitable as they need to have extensive knowledge of Java Servlet. The presentation logic (HTML code) will be mixed up with Java code (pw.println()). Lots of coding is written inside pw.println() to write html code. Modification done in one code may affect another code. Writing HTML code in Servlet programming is a complex process and it makes Servlet looks bulky.

In Servlet programming implicit objects are there but we need to write some additional code to get them access. Modifications done in source code of servlet program will be effected only after recompilation and reloading of the web application in case of most of servers. Programmers should explicitly take care of exception handling. Servlet programming is not thread safe by default. So we need to write additional codes to make the Servlet program thread safe.

JSP technology is the Java Platform Technology (enterprise technology) for delivering dynamic content to web user (the person who is giving request from browser window) in a portable, secure and well-defined way. JSP has been built on top of the Servlet API and utilizes Servlet semantics. It uses HTML and XML templates and Java code to generate JSP page. JSP is secure, fast and independent of server platforms.

Although JSP technology is going to be a powerful successor to basic Servlets, there is a relation between JSP and Servlet. Servlets are powerful and sometimes they are a bit cumbersome when it comes to generating complex HTML. But JSP is handy with HTML and JavaScript. JSP is also powerful compared to other web technologies like PHP, ASP as it is developed as per Java specifications.

Most Servlets contain codes to handle application logic and to handle output formatting. This can make it difficult to separate and reuse portions of the code when a different output format is needed. For these reasons, web application developers turn towards JSP as their preferred servlet environment. It also contains many more features like platform independent, server independent.

Evolution of Web Applications

Over the past few years, web server applications have evolved from static to dynamic application. This evolution became necessary due to some deficiencies in earlier website design. For example, to put more business processes on the web, both in business-to-consumer (B2C) or business-to-business (B2B) markets, conventional website design technologies are not enough.

The main issues every developer faces while developing web applications are as follows:

1. Scalability – A successful web site will have more users and as the number of users increase, the web applications have to scale correspondingly.

2. Integration of data and business logic – The web is just another way to conduct business, and so it should be able to use the same middle-tier and data-access code.

3. Manageability – Websites just keep getting bigger and we need some viable mechanism to manage the ever-increasing content and its interaction with business systems.

4. Personalization – Adding a personal touch to the web page becomes an essential factor to retain customers. Knowing their preferences, allowing them to configure the information they view, remembering their past transactions or frequent search keywords are all important in providing feedback and interaction from what is otherwise a fairly one-sided conversation.

Apart from these general needs of a business-oriented website, the necessity for new technologies to create robust, dynamic and compact server-side web applications has been realized. The main characteristics of today’s dynamic web server applications are as follows:

• Serve HTML and XML, and stream data to the web client

• Separate presentation, logic and data

• Interface to databases, other Java application server middleware to provide transactional support

• Track client sessions

Now let us have a look on the role of Java technology and platform in this regard.

Java’s Role for Server Applications

Sun Microsystems, having consulted many expert partners from other IT related industries, has come out with a number of open APIs for the technologies and services on server side. This collection of APIs is named as Java 2 Enterprise Edition (J2EE). The J2EE specification provides a platform for enterprise applications, with full API support for enterprise code and guarantees of portability between server implementations. Also, it brings a clear division between code which deals with presentation, business logic and data.

The J2EE specification meets the needs of web applications because it provides the following:

• Rich interaction with a web server via servlets and built-in support for sessions available in both Servlets and EJBs.

• The use of EJBs to mirror the user interaction with data by providing automatic session and transaction support to EJBs operating in the EJBs server.

• Entity EJBs to represent data as an object and seamless integration with the Java data access APIs.

• Flexible template-based output using JSP and XML.

This family of APIs means that the final web page can be generated from a user input request, which was processed by a Servlet or JSP and a session EJB, which represents the user’s session with the server, using data extracted from a database and put into an entity EJE. Thus, the Java revolution of portable code and open APIs is married with an evolution in existing products such as database, application, mail and web servers. The wide availability of products to run Java applications on the server has made Java lucrative in a very competitive market. This makes server-side Java a very exciting area.

The Java Server Pages 1.2 specification provides web developers with a framework to build applications containing dynamic web content such as HTML, DHTML and XML. A JSP page is a text based document containing static HTML and dynamic actions which describe how to process a response to the client in a more powerful and flexible manner. Most of a JSP file is plain HTML but it also has, interspersed with it, special JSP tags.

There are many JSP tags such as:

• <%@page language=”java” %> – this is a JSP directive denoted by <%@,

• scrip lets indicated by <%..%> tags and

• <%@include file=”sample.html”%>- this directive includes the contents of the file sample.html in the response at that point.

To process JSP file, we need a JSP engine that can be connected with a web server or can be accommodated inside a web server. Firstly when a web browser seeks a JSP file through an URL from the web server, the web server recognizes the .jsp file extension in the URL requested by the browser and understands that the requested resource is a JavaServer Page. Then the web server passes the request to the JSP engine. The JSP page is then translated into a Java class, which is then compiled into a Servlet.

This translation and compilation phase occurs only when the JSP file is requested for the first time, or if it undergoes any changes to the extent of getting retranslated and recompiled. For each additional request of JSP page thereafter, the request directly goes to the Servlet byte code, which is already in memory. Thus when a request comes for a Servlet, an init() method is called when the Servlet is first loaded into the virtual machine, to perform any global initialization that every request of the Servlet will need. Then the individual machine requests are sent to a service() method, where the response is put together. The Servlet creates a new thread to run service() method for each request. The request from the browser is converted into a Java object that is used to send the response back to the browser. The Servlet code performs the operations specified by the JSP elements in the .jsp file.

TAG Based Programming 

Programming may be code based or tag based. Code-based programming is difficult to write and understand. However, tag-based program is easier and program length is less as compared to codes based programming. Tags reduce the development time and maintenance cost and increases the reusability of code.

We have some ideas on tag-based programming like HTML, JavaScript and CSS, etc. JSP is also totally tag based. JSP tags implement the functionality of tags into tag implementation classes. So to develop JSP page, large amount of Java code is not needed. So this helps the programmer to develop java codeless JSP program by which developing separate presentation logic and business logic has become easier.