- Hour 3: Introduction to Servlets
- How JSPs Become Servlets
- The Basic Structure of an HttpServlet
- Translating a Simple JSP into a Servlet
- Summary
- Q&A
- Workshop
Translating a Simple JSP into a Servlet
Since the underlying implementation of a JSP is a Servlet, let's take a look at a JSP and then look at the equivalent Servlet code. The equivalent Servlet code does the same output as the JSP, but you will see there is much more work to do. Throughout the book when you are shown new JSP tags, the equivalent Servlet code will also be shown to deepen your understanding of the inner workings of the JSP.
Writing a Simple JSP
Listing 3.2 is a JSP that creates a table of the powers of 2. This is very similar to the first JSP that you created in Hour 2, "Building Your First JSP."
Listing 3.2 A Simple JSP (PowersOf2.jsp)
1: <HTML>
2: <HEAD><TITLE>Powers of 2</TITLE></HEAD>
3: <BODY>
4: <CENTER>
5: <H2>Behold The Powers Of 2</H2>
6: </CENTER>
7: <TABLE BORDER="2" ALIGN="center">
8: <TH>Exponent</TH><TH>2^Exponent</TH>
9: <% for (int i=0; i<10; i++) {%>
10: <TR><TD><%= i%></TD>
11: <TD><%= Math.pow(2, i)%></TD>
12: </TR>
13: <% } //end for loop %>
14: </TABLE>
15: </BODY>
16: </HTML>
You will be learning about the various tags used by JSPs throughout the book, but let's take a moment and see what is happening in this JSP.
Line 1 and 16 are the opening and closing <HTML> tags that specify this page to be an HTML document. Line 2 creates the head section of the document and creates a title to be Powers of 2. The <BODY> tag starts on line 3 and closes on line 15, which wraps around the content of the page. Lines 4–6 create a heading on the page in level 2 heading that is centered on the page. The heading is Behold The Powers Of 2. The output of this page is going to be a table, with the exponent in one column and the result of 2 raised to that exponent in the second column. Line 7 creates the table, with a border of size 2 pixels that is centered on the page. The table headings are created in line 8 using the <TH> tags.
Now for the Java embedded in the HTML document. Line 9 uses a JSP tag called a scriptlet tag, <%, which is closed by %>. The scriptlet tag allows you to insert Java code into your JSP. Line 9 uses this tag to insert the for loop into the page. Hour 9, "Controlling JSPs with Java Scriplets," will explain these tags in more detail.
During the for loop, this page creates rows in the table and adds the exponent number followed by the evaluation of 2, raised to the exponent. Line 10 creates the table row with the <TR> tag and specifies the first column data to be the exponent, which is simply the value of the variable i. Notice there is a new tag inserting the value of i; it is not the scriptlet tag that you saw in line 9. This new tag, <%=, is called an expression tag. This allows you to insert a Java expression that will be evaluated and the result is inserted into your JSP. The expression tag will be covered in more detail in Hour 8, "Inserting Java Expresions in a JSP."
After the exponent is inserted into the page, the power of 2 raised to the exponent is inserted, again using the expression tags. This is shown in line 11. Line 12 simply ends the table-row definition. The for loop needs to be closed. The scriptlet tags can be used to insert the final close curly brace to end the for loop. Line 13 contains this scriptlet.
The output of the JSP can be seen in Figure 3.4.
){kind=link}
Now let's take a look at the equivalent Servlet code. This is the code that will produce the same output as the JSP. Earlier you learned that JSPs are translated into Servlets. The JSP code would be translated to this Servlet code.
Figure 3.4 View POWERSOF2.JSP in a browser.
Listing 3.3 A simple Servlet ()
1: package com.sams.jspin24hrs.hour3;
2: import java.io.*;
3: import javax.servlet.*;
4: import javax.servlet.http.*;
5: public class PowersOf2 extends HttpServlet
6: {
7: public void service(HttpServletRequest request,
8: HttpServletResponse response)
9: throws IOException, ServletException
10: {
11: response.setContentType("text/html");
12: ServletOutputStream out = response.getOutputStream();
13: out.print("<HTML>");
14: out.print("<HEAD><TITLE>Powers of 2</TITLE></HEAD>");
15: out.print("<BODY>");
16: out.print("<CENTER>");
17: out.print("<H2>Behold The Powers Of 2</H2>");
18: out.print("</CENTER>");
19: out.print("<TABLE BORDER='2' ALIGN='center'>");
20: out.print("<TH>Exponent</TH><TH>2^Exponent</TH>");
21: for (int i=0; i<10; i++)
22: {
23: out.print("<TR><TD>" + i + "</TD>");
24: out.print("<TD>" + Math.pow(2, i) + "</TD>");
25: out.print("</TR>");
26: } //end for loop
27: out.print("</TABLE></BODY></HTML>");
28: out.close();
29: }
30: }
The output of the Servlet is shown in Figure 3.5.
){kind=link}
Figure 3.5 The JSP equivalent servlet looks the same in a browser.
Notice that the output is the same as the output of the JSP. Although the output is the same, it required more work for the Servlet, making JSPs more desirable. You do not need a deep understanding of Java in order to write your JSPs as you do with Servlets.