Introduction Based on servlet technology, Java Server Pages (JSP) is one of the most important elements of Java server programming. Java Server Pages combine HTML or XML with nuggets of Java code to produce dynamic web pages. Each page is automatically compiled to a servlet by the JSP engine the first time it is requested, and then executed. JSP provides a variety of ways to talk to Java classes, servlets, applets and the web server. NOTE: We'll be explaining JSP using the Java Server Development Kit or the JSWDK which can be downloaded from Sun's site at www.javasoft.com. All new development on JSP/servlets has been passed on to the apache team. The reason we are teaching you the older version is because it is easier. There are cosmetic changes from the one we are doing to the jakarta version which we will go back to in the last chapter. Download the zip file from the Sun site on the Internet and unzip it. It will create a sub directory jswdk-1.0.1. cd into this sub directory and then move into the bin sub directory. Here run a batch file named startserver. If you get an error in the Java Web Server window and if you are using jdk 1.2.2 like we are, add the following to the classpath variable. set CLASSPATH=c:\jdk1.2.2\lib\tools.jar;%CLASSPATH%
Let us begin by creating a simple jsp file. To do so, create a file that
has a .jsp extension and save this file to the examples\jsp subdirectory.
You can save it in the examples subdirectory or the jsp subdirectory,
either is fine. We have named the file e1.jsp and it contains only one
word, 'hi'. Open this file in the browser by giving the url as 'hi' will now be displayed in your browser window. Congratulations! You have written the world's smallest JSP program. The browser initially takes a long time to show you the result but in future it will be very quick. Now go to the subdirectory named work, where you will find a subdirectory ending with the word examples. Change to this directory. C:\jswdk-1.0.1\work>dir Volume in drive C is SONAL . <DIR> 06-05-00 7:31p . C:\jswdk-1.0.1\work>cd %3A808~1
C:\jswdk-1.0.1\work\%3A8080%2Fexamples>dir Volume in drive C is SONAL . <DIR> 06-05-00 7:31p . C_0003~1 DAT 59 06-05-00 7:31p C_0003a. C_0003A <DIR> 06-05-00 7:32p C_0003a JSP_00~1 CLA 2,530 06-05-00 7:32p jsp_0005ce_00031_0002ejspe1.class 3 file(s) 5,204 bytes C:\jswdk-1.0.1\work\%3A8080%2Fexamples> Now open the java file by saying edit *.java package C_0003a.jswdk_0002d_00031_0005f_00030_ import javax.servlet.*; static char[][] _jspx_html_data = null; public jsp_0005ce_00031_0002ejspe1_jsp_1( ) { private static boolean _jspx_inited = false; public final void _jspx_init() throws JspException { public void _jspService(HttpServletRequest request, HttpServletResponse
response) JspFactory _jspxFactory = null; if (_jspx_inited == false) { out.print(_jspx_html_data[0]); } catch (Throwable t) { Edit shows you a Java program which has been created by the Java Web Server. The JSP file that you ran from the browser was converted into a servlet. The static data in the jsp file was stored in a new file with the .dat extension in the subdirectory work. The JSP engine writes this code for you. All your html code is stored in the file with the .dat extension. At first _jspx_init is called which opens the .dat file with the static text. Then _jspService is called. Now you know why it takes a long time for the output to show up in the browser. It takes some time to convert the jsp file into a servlet and then compile the servlet to a .class file and then run the servlet. JSP Expressions A JSP Expression is a great tool for embedding values within your HTML code. Anything between <%= and %> tags will be evaluated, converted to a string, and then displayed. Now let's create another file where we start with hi and then send %="bye" %. e2.jsp Partial Output of the servlet code generated by the jsp engine for the .jsp file is enclosed with the dotted lines.. ---------------- When you view this file in your browser, it will display hi, bye and no, all on the same line. Note that you must save the file as e2.jsp and not e1.jsp. Let's understand what we have just done. The JSP engine takes over and it saves hi to disk in the .dat file. Then it sees the tag '<%'. It understands this character and for it anything within <% %> is JSP. A tag is anything that starts with an angle bracket. '<%' is also used in Active Server Pages. The '=' sign tells the engine to add the line 'out.print' in the Java program and also whatever is given in double quotes as a parameter to print. It automatically puts the open and close bracket and a semicolon at the end. The next line with 'no' is also saved to disk as another array. In effect, you have saved two arrays of chars on disk. If you look at the code, it all looks the same. The only difference is that it says print the first array, then the newly added line, out.print("bye"), and then it finally print the second array. _jspx_init uses the function readObject to read the contents of the .dat file into an array _jspx_html_data. Thus the array member _jspx_html_data[0] will contain hi and _jspx_html_data[1] will contain bye. out looks like JspWriter and is initialized in _jspService. It is used to create the html file which will be sent across. e3.jsp ------------------ Now remove the '=' sign in the JSP file and write out.println ("no"); Since there is no '=' sign, the jspengine does not add its own out.print. This jsp statement gets added in as is. The JSP engine assumes it to be Java code. This means that if you do not write good Java code here, you will get horrible errors. This happens when javac compiles the Java program. They will be displayed in your Java server window. This implies that whenever you put an '=' sign, you must use something that will be converted to a string in Java. This is because the out.print that is added takes only a single string as its parameter. Hence bye is enclosed within double quotes. Try giving it without quotes and you will be presented with an error. The bye is assumed to be a variable. If you put a semicolon then it takes the semicolon as a part of the double quotes. There is supposed to be no space between the % and =. It must be typed in like this, <%= In a nutshell, we have html code and then there are Java Server Pages, where we have html, and Java code within that html. The html tags and text are saved to disk and the Java code comes as is. Thus in a jsp program we get to mix html and java code. All the java code written so far can be placed in a jsp program along with html but within the <% tag. e4.jsp Output in Browser Error message in the java server window. at com.sun.jsp.compiler.Main.compile(Main.java:347) Here it assumed that bye was a variable and the error is detected by javac on compiling the servlet generated by the jsp engine. Moving on to the next example, where we are now writing System.out.println("no")
within the % tag. ---------------- If you carefully study the code, you will observe that there are seven variables created and one of them is out. Hence in JSP you are allowed to use out and you can use any of these seven variables in your program. These are the predefined objects available to you. System.out.println can also be used anywhere in a jsp tag as it is a valid java statement. Do not forget the terminating semicolon as java code written in a tag is added verbatim to the function _jspx_service(). JSP Declarations A JSP declaration can be thought of as the definition of class level variables and methods that are to be used throughout the page. In the next example, we have hi and then bye. The JSP code begins with int j preceded by an exclamation, and thereafter it has int i with a semicolon. e6.jsp -------------------- public jsp_0005ce_00036_0002ejspe6_jsp_1( ) { Whenever anything is put in an exclamation it is called a declaration. This is done outside any function but within the class that is public. The line int j comes up when your class starts with {. Whenever you put any statement in <%, it is placed in jspservice and becomes local. It is visible from then onwards. If you want to make a variable global then use an exclamation. You can create functions and global variables in a class. Unlike C, where 'global' is applicable to the file, here it is limited to a class. Now we will mix java with html code. --------------- But what is the purpose of all this? This is a method of generating dynamic code. The Perl family of scripting languages generates the entire page. The focus is on Perl writing the entire html page whereas ASP, PHP, JSP opted to have an html page where the code would be inserted. In the html page, you can put ASP, PHP or Java code to give the page dynamism and free yourself of the tedium of trying to create every possible page the visitor must be shown by hand. The file that you are writing is an html file, which means you can use an existing html editor. For Java Server Pages, servlets are the foundation. Normally, a web page has a static template i.e. things which are permenant. With JSP, you separate the static and the dynamic, and insert dynamism into a web page. We will also use beans extensively in the Java Server Pages and one of the chapters will explain to you how you can create your own custom tags. A JSP page is a text-based document that describes how to process a request and create a response. JSP pages in servlet classes are what Sun calls its web components and these pages are delivered by a JSP container. When you look at a JSP page, you will see 3 classes of scripting elements. These are declarations, scriptlets and expressions. The following example has been taken from the Net from a great FAQ that
we stumbled upon. We don't mind if you take our programs too. We have
not mentioned any names here because there were too many brains behind
it. The code looks complicated but you can easily understand it. The for statement goes on four times. Since the for statement is not part of html, it is enclosed within the % and the angle brackets. The '{' bracket starts the for loop. The set of statements to be executed within the for is a combination of HTML and JSP. H is an html tag that stands for heading. Along with H is a number that displays the heading in a different format. We have not used a number directly because we want it to be the value of i. i is a variable initialized in the for loop. The <%= is used to display the value of i which is 1 as of now. Hence the tag becomes H1. Following this is Hello. To close the tag, the same rules are followed, the closing tag becomes </H1>. The '}' bracket within the % and the angle brackets is used to close the for loop. When i becomes 2, the statement will be <H2>Hello</H2> and the same follows for 3 and 4. This is how Hello can be seen in all 4 tags. View the actual code in the Java file and you will realize that it is much easier to comprehend. View Source <H1>Hello</H1> <H2>Hello</H2> <H3>Hello</H3> <H4>Hello</H4> hi ------------------- out.print(_jspx_html_data[0]); There are 5 sets of html data in the JSP file. The first one is blank,
the second one is <h, the next one is >hello</h, the third set
is > and then finally, there is hi. These are the different values
assigned to the variables in the for loop.
dat file Let's go one step further, give two hyphens after %. Whenever you start with a <%- and end it with -%>, it signals a comment. e9.jsp The good thing about comments is that they soon disappear. They are present only in your JSP file and will not be seen in the servlet. That's why we have written my name there, it doesn't show up. So whenever you want to include comments but hide them from the client, this is what you use. All this happens on the server, nothing comes over on to the client hence nobody knows of it. If you want normal comments, use the html comments which are given as <!- . JSP Directives A JSP Directive is a statement that gives the JSP engine information for the page that follows. Anything with a <%@ sign is called a Directive. In the following program, we have used a directive named page. The other possible directives in JSP1.0 are include and taglib. e10.jsp public String getServletInfo() {
e11.jsp ----------------- import javax.servlet.*; When you give import as an attribute and then look at the Java generated file, you will see that at the end of the imports, there is import java.applet.*. You don't have to put a semicolon. This means that if you are a referring to some Java code in some classes, you don't have to preface them i.e. give full names, you just put imports. In case you have more than one import, then separate them using commas, they will all be added at the end. If there are two similar imports, it is not considered an error. A point to be noted here is that if the match is found earlier in the file, then the import added by you is not used. e12.jsp -------------- Normally, extends is not used because by default every class extends HttpJspBase. But if you do so then HttpJspBase is replaced with java.util.Dictionary. At times, when you want to write complicated code then you can have a class that is derived from HttpJspBase, from which you can further extend your classes. You must derive from HttpJspBase or else you will end up with a load of errors. e13.jsp
------------ Since we have given the buffer as 1000, the getPageContext function makes the buffer parameter 1000KB i.e. 1000 multiplied by 1024. This is the amount of buffering space required. Buffering improves speed since its better to write a larger number of characters at one go than a small number many times. You will have multiple requests being sent to your web server. You may
want either one instance of the servlet or you may want 20 of them running
at a time. If you want the servlet to create multiple instances of itself
then you must give isThreadsafe=false. The default is true. --------------- By saying isThreadSafe=false, the JSP engine will implement SingleThreadModel and it can load multiple instances of the servlet instead of one. This class in that sense doesn't have any function prototypes and hence we don't have to add any code in the file. It can however, check to see if we have implemented certain interfaces. e16.jsp Most of these attributes have a default value of true or false, so you don't need to specify them. There is one more attribute named session. By default, session is true, so you see the session object in _jspservice function. The following are the variables that are created in the _jspservice function: JspFactory _jspxFactory = null; When you make the page session false, session that looks like HttpSession, is not created at all. The next script has the contentType initialized to text/plain. By default, the value assigned to this attribute is text/html. e17.jsp ---------- The tag b is not recognized by the browser anymore and thus we see <b> Bye in the browser. The Content type depends upon the file being sent over. If you initialize IsErrorPage to true, it will actually create an object called exception that looks like Throwable. This is then initialized by the getAttribute function. e18.jsp ----------- The request variable is given to us as a parameter in the jspservice
function. getAttribute takes one parameter which is a variable and returns
a value. Instead of a variable we call it an attribute. This is used to
initialize the new variable named exception which looks like jspException.
The concept of exceptions has already been discussed in one of the previous
chapters. <% If we stop here , in the browse we get the following error . We start by using page directive errorPage, which is also an attribute
and its value is a jsp file f1.jsp. If you look at the code you will realize
that it throws new HandleErrorPageException, which has f1.jsp as a parameter.
f1.jsp is your error page and because of this throw, it will now go to
f1.jsp. In abc we have a throw, we throw an IOException. Since an exception
is thrown, the catch in the servlet will catch it as the try and catch
around abc have been commented out. The servlet catch has HandleErrorPageException,
where the first parameter is f1.jsp and the last one is out. out is used
to display output. t is throwable as a parameter to catch. If you look
at f1.jsp, it has to start with isErrorPage=true and we use exception.printStackTrace
to print where the exception took place. Output abc(jsp_0005ce_00031_00039_0002ejspe19_jsp_1.java:23) <pre> ------------------ In _jspservice f1.jsp error page exception.printStackTrace prints out the text. In this way you can have a separate page for error handling. All that you should do is create a page named anything.jsp and in every JSP page redirect the errors to it. Within the try and catch is abc, so the code of abc will be called. You
can have a 'try' and 'catch' within another 'try' and 'catch' pair, nested
as many levels deep as you want. abc throws an IOException, so the exception
will be called. Now that we have uncommented the try and catch near abc, the earlier catch was not called and down in the web server window we see hi in exception, which proves that only the inner try catch was activated. e20.jsp
------------------- Output in browser A @ in a JSP file signals a directive. The earlier examples had 'page', while in the program shown above, we use include. include takes a string which has to be filename which is aa.html here. e20.jsp contains hi, then the include and finally a bye. aa.html simply contains 'In aa.html'. As always, your entire JSP is converted into a .dat file. Since it is on two lines, you will see only two prints in the Java file. The point that we are trying to make is that the .dat file is made at the time of the creation of the servlet. This is called the Translation Phase. You can change aa.html, add some more text and then refresh the server. The new text within the html file will not be displayed because the .dat file isn't created again. The only way to incorporate the new changes is by either recompiling the Java file or stopping and restarting the server.Stopserver deletes all the files in the work directory, so all the files are created from scratch when you want to view them. There are two phases in JSP. One of them is the Translation Phase, which it happens only once. Then, the service function 'jspservice' is called for every request. So far we have included a .html file, so now let's try it out with JSP. e21.jsp ---------------- There is no java file for aa.jsp. dat file
With this example you will realize that if you have JSP code in include, then all the JSP code will be put in the service function. Thus whenever you want something dynamic, create a JSP file and use it with the include directive. Now each time you click on refresh the date function will be reexecuted, so you see a different date and time every time. Let's go one step further. e22.jsp zz.jsp We now have 2 java files created for the 2 jsp files. out.print(_jspx_html_data[0]); The first line in e22.jsp has hi and the second line is jsp:include page="zz.jsp" within angle brackets. If you notice there is no % sign like we had earlier. Such a line is called an 'action'. Each time you refresh the file, it gets the filename and requests the server for that file. Unlike the earlier example, this is dynamic. When you see the generated java code, there is no data stored anywhere, so you check the .dat file. In the Java file, the array size is 2, for hi and bye, hence you see 0 and 1. pageContext.include is what the jsp:include is converted to in the Java file. It is this pageContext.include that regenerates the file each time. Now the problem with using include as an action is that you cannot have Java code with it and in addition, you cannot change headers and cookies. e23.jsp a40.html ----------------- In e23.jsp, the first line is hi. Then a40.html, which contains bye, is included. Now change 'bye' in the html file to 'over' and click on refresh. This time you will see over instead of bye. include here is an action. In the next script, we have a new action called forward. e24.jsp cc.jsp ------------------ This example introduces a new action named forward. page=cc.jsp implies that we are sending a page with it. Hence every time you try to load e23.jsp, you will be forwarded to cc.jsp. Forward becomes pagecontext.forward in the Java file. This will simply go to the page mentioned. A valid question to ask here would be, 'will it come back to e23.jsp?' The answer is no. That's because the last line before the closing brace is a return. So whenever you have forward as an action, the file passed to pagecontext.forward becomes your active html file and everything else is forgotten. Bear in mind that the http protocol is a stateless protocol. Each time you connect to the web server you are disconnected after you receive the page. So if you are on the Amazon.com site and you buy 6 books, moving from one page to the other, it becomes a session and this session has to be tracked. This is where the session object comes into use. z.htm
------------------ Run in browse is follows http://127.0.0.1:8080/examples/jsp/z.html
http://127.0.0.1:8080/examples/jsp/e26.jsp?aa=bye If you want to read data from a form, you can say request.getParameter("aa") where aa is some name that you have given in the form. This returns bye since that is what we typed in our text box. The form has an action which will execute the JSP code on the server when the user clicks on the submit button. This will bring up a new page with the url containing ?aa=bye. The JSP engine then sends the value 'bye' to be displayed on the screen. When the button named submit is clicked, the browser will look for a
tag named form and within that tag an attribute named action. It will
then create a url with action and at the end add a ?. Now it takes all
the input statements, figures out what you have written in them and converts
then to a name value pair seperated by '=', like so With JSP it is very easy to extract these values, thereby making it the preferred tool for Web programmers. In the following example we have created two functions, one named jspInit
and the other named jspDestroy. ---------------- In the next script, we have response.sendRedirect and within the round brackets a url has been specified. The job of this function is to take you to the site that has been passed as a parameter. This page then becomes the active Page. e27.jsp Normally, one is not supposed to write anything before or after sendRedirect.
But if you do write something, it will not be displayed. http://127.0.0.1:8080/examples/jsp/e9.jsp The address bar in the browser also changes its url, which means that the browser asked for a new url. Every http page starts with a header. Normally, it will be 200 OK. 200
is called the http status code. There are around 20 to 30 predefined status
codes, where 200 means OK, 404 is file not found and so on. Redirection
has a status code of 304. In the next script, we have response.setStatus.
SC_MOVED_PERMANENTLY is a status code informing the browser to read the next header line because the file has been moved. The next line sets the header variable Location to a location or a url from where the file is to be picked up. When you use response.sendRedirect or you use setStatus the status code is sent over to the client with more information in the header. When this reaches the browser, the browser asks for the new file, which in our case is e9.jsp. Finally, the user sees e9.jsp. Now let's take a case where we want the user to visit a certain page,
barring which he will not be allowed to browse our site. It's like a login
page and unless the user doesn't go there first, he can't browse through
the rest of the site. e31.jsp Also see the output in the Java Web Server. In the browser it shows. Here we have two files, e30.jsp and e31.jsp. The directive, page session="true", is not required but we will retain it. Then we have login as the text to be displayed. s is a variable that looks like HttpSession and it is initialized to the return value of request.getSession. This function returns details of the current session. getSession will either create a new session or will return a handle to the current session. Of all the variables, we are currently interested in the value of the variable EID which you must put in capital letters. Since we haven't declared a variable named EID, it will be null for now. response.encodeRedirectUrl will create a url of the string given within the brackets and return a string. This is stored in s1. response.sendRedirect will take you straight to e31.jsp In e31.jsp, session.putValue creates the variable EID and initializes it to 'sonal'. request.getParameter will return the value of Origin, which is e30.jsp, and as previously mentioned response.encodeRedirectUrl will convert this into a url. Finally, there is a redirection to e30.jsp again. Within e30.jsp the value of EID is already set, which is why you will not see login again. Instead you see hi. This proves that both s and the session are the same. What we are trying to say is that as long as it is the same user on the
website, he will not have to login again, but if the user shuts down the
browser and starts another copy, the entire process has to be repeated.
The next program provides further insight into sessions. e33.jsp In e32.jsp, we first write hi. request.getSession will return the current session handle which is stored in s. Then s.putValue will create 'vij' if not present and initialize it to 'sonal'. The next page where we have bye is along the same lines as earlier. s is a handle to HttpSession. s.getValue of vij will return 'sonal'. We first want you to run e33.jsp. Here, you will see bye and null because at the moment vij has no value. After doing so, run e32.jsp. You will see hi on this page and now once again reload e33.jsp. You will see 'sonal' displayed on your screen. The point to be noted here is that there are two types of objects, implicit objects and explicit objects. Session and out are examples of implicit objects; they are already created. The explicit objects are not created by default, they have to be created and initialized. This is what you will learn in the next chapter. Applets are not allowed to write data to disk but with servlets no such
rules apply. The next example confirms this. C:\jswdk-1.0.1>dir pp.txt Volume in drive C is SONAL PP TXT 4 06-13-00 3:15p pp.txt C:\jswdk-1.0.1>type pp.txt hi FileOutputStream is used when you want to open a particular file in output
mode i.e. for writing. Since the file named pp.txt is not present on the
disk, it will first be created. To write to this file you need a handle
to it. new PrintWriter will return a handle to this file, so p now becomes
a pointer to pp.txt. We then say p.println ("hi") which will
write the text 'hi' to the file. You can give the complete path along
with the filename, or use the default which is the jswdk-1.0.1 subdirectory.
If you want to read from a file then use FileInputStream instead of FileOutputStream.
For the grand finale of this chapter, we have one last example. The web-inf directory has a file named servlet.properties. This example
prints the properties and their values within this file. We had done something
similar in the servlet chapter. We have not shown you the contents of
this file as it will obviously differ on your machine. keepgenerated=true servlet.properties has things like keepgenerated=true. This property, if it is true, will not delete the Java code from the work directory once it has been created and compiled. Normally, when you have errors, you would like them to be displayed on your web page and not on the console of the web server. To do so, you say setErrorToClient=true. The client will now see the errors in his browser. They will now nolonger be displayed on the server console. In our program, getServletConfig allows us to find the parameters that have been set by the Java Web Server. This returns an object that looks like ServletConfig(). cfg.getInitParameterNames() returns an enumeration which in turn has a member hasMoreElements. e.nextElement gives us the name of the element and getInitParameter along with the name will tell us its value. Thus, they are all stored as a name-value pair. Since we only have one property at the moment, it will display keepgenerated and its value true and then the for loop will terminate. Conclusion Java Server Pages bring together the power of Java Servlets and HTML coding thereby give the developers a powerful method to create Server-Side web applications. In this chapter, we learnt the following: A Java Server Page file consists of HTML tags, content, JSP directives,
JSP declarations, JSP scriptlets and action tags. Initially, the JSP engine
parses the JSP file which then generates a new servlet with the desired
content. If the file changes, then a new servlet is generated; otherwise,
the compiled version is used. |