Web Application Development 
Lab Class 8  Autumn 2009 Aim: Servlets are core technology for the development of Java‐based web applications. However, you may have found the way they handle the dynamic generation of an html document to be a little tedious. Java Server Pages (JSP) takes a different perspective of embedding Java in standard html. As we will see in the lecture, JSP is based on Servlet technology. But the JSP engine enables many of the more tedious aspects of writing Servlets to be bypassed. This lab class will introduce some JSP basics, and then set you to work on developing a simple JSP‐based Web application. Task 1 – A simple interactive JSP example: The simplest JSP page is simply pure unadulterated html. We have seen this already many times in the course. Start a new Java/Web Applications project in NetBeans. Once the generation of this has completed,  create a New JSP file. Call it index.jsp. Edit the html part of the template as follows: 
 
     
         
         
     
     
    
Please enter user name:
 
    
 
      UserName: 
 
       
    
 
     
     
  
COM2017    Lab Class 8 
  2 
As you can see, when the form is submitted, it will send the request to a new JSP page, helloJSP.jsp. This in turn will generate a dynamic html page and send it for rendering in the browser. Here is the content of the helloJSP.jsp file: 
<%@page import="java.util.*" info="This is a simplest JSP 
 with Java code embedded" contentType="text/html"%> 
<%@page pageEncoding="UTF-8"%> 
 
 
 
<%! Date today; %> 
 
 
     
         
         
     
    <%-- This is the simplest JSP (comment from JSP tag)  
       --%> 
 
     
 
         
     Hello <%= request.getParameter("userName") %>!
 
 
        <% today = new Date(); %> 
        <%= today %> 
     
     
  You will see that there are a number of different forms of JSP element tags. The first line is a JSP directive to import the Java utility classes, and set the content type of the page. Further down is a JSP declaration element (<%! Date 
today; %>) that will result in the enclosed Java code being inserted into the generated Servlet. 
COM2017    Lab Class 8 
  3 
Note also that there are two different kinds of comment. The first one will not be sent to the client, whereas the second one will (that is, the client will be able to see it if View Source is selected in the browser window). The expression scripting element <%= …. %> will insert the result of evaluating its enclosed Java statement as a string into the html document. Finally, the code inside the <% … %> “scriptlet” will be inserted into the service() method of the generated Servlet code. Run the project now. Take a look at the source of the dynamic html page that is returned  to the browser following submission of the form data. You will see that it is pure html. Task 2: Integrating a Servlet with JSP As a general design principle, it makes a lot of sense to use a Servlet for a Controller, and then delegate responsibility for generating dynamic html to JSP. We will illustrate this with a simple example here. Actually, there is some business logic in this Servlet as well, so strictly it captures Model and Controller. But this is a very simple example, so not really worth factoring the Model out into a Bean. Start another Java/Web project in NetBeans, and use the following for your index page (name the project “FirstServlet”). 
 
     
         
         
     
     
    
Conference Registration
 
 
    
 
        
Name: 
 
         
        
Status:
 
        Student 
        Faculty
 
         
    
 
     
  
COM2017    Lab Class 8 
  4 
Now create a new Servlet. Name it DispatchServlet and save it in a package called “servlets”. (You can choose your own names of course, but be sure to modify the references to the names in the example files, and check naming is consistent in the web.xml file in your project). We are just going to fetch some data, so a GET request is appropriate. So you will now need to override the doGet() method in the Servlet: 
protected void doGet(HttpServletRequest request,  
 HttpServletResponse response) 
    throws ServletException, IOException { 
        String status=request.getParameter("status"); 
        int orgFee = 500; 
 
        if (status != null && status.equals("student")) { 
            int studentFee = orgFee/2; 
            request.setAttribute("regFee", "" +  
 studentFee); 
            request.getRequestDispatcher("/output.jsp"). 
 forward(request, response); 
            return; 
        } 
        else if (status !=null &&  
 status.equals("faculty")) { 
            request.setAttribute("regFee", "" + orgFee); 
            request.getRequestDispatcher("/output.jsp"). 
 forward(request, response); 
            return; 
        } 
    }   Note what is happening here. We are adding an attribute to the request object (the value of the registration fee that is payable) and then forwarding the request to a JSP, which will then generate the response. Notice a little subtlety here. So far we have talked about a request message. Now we see that message is implicitly wrapped as an object, to which we add a new attribute. 
output.jsp now gets the user name and status from the request parameters, the fee payable from the request object’s new attribute and displays the result:  
COM2017    Lab Class 8 
  5 
 
     
         
         
     
     
        
Thank you, 
 <%=request.getParameter("userName") %>  
 
        Your <%=request.getParameter("status") %> 
 registration fee is 
        <%=request.getAttribute("regFee") %> 
     
  Task 3: Integrating Multiple JSP Pages You have now seen how to forward a request. Sometimes, you may want to 
include some dynamically generated content in a standard template. We will now see how to integrate multiple JSP pages through the use of include actions. As the logic of the example is very simple, we are just going to use a JSP for the controller. We will submit a user name through a simple form. The test JSP will determine if it is blank or not. If blank, then it will forward the request to an error page. Otherwise it will just compose a welcome message with the index page and display that. Here are the files. They are very simple, and you should by now be able to get a clear view of how this all works just from the following: 
COM2017    Lab Class 8 
  6 
index.jsp 
 
     
         
         
     
     
    
Please Enter the User Name:
 
    
 
        UserName:  
 
 
         
         
    
 
 
     
 
 
COM2017    Lab Class 8 
  7 
test.jsp 
 
     
         
         
     
     
    <% 
        if (!request.getParameter("userName").equals("")) 
    { 
    %> 
        <%@ include file="index.jsp" %> 
         
         
    <% 
    } 
        else 
    { 
    %> 
         
    <% 
    } 
    %> 
     
     
     
 
 
COM2017    Lab Class 8 
  8 
helloJSP.jsp 
 
     
         
         
     
     
        Hello <%=request.getParameter("userName")%>! 
     
     
 
 
 errorJSP.jsp 
 
     
         
         
     
     
        
Input is not valid!  
Please input your name again:
 
        <%@ include file="index.jsp" %> 
     
     
 
 
COM2017    Lab Class 8 
  9 
Task 4: Now it’s your turn You now have enough knowledge to develop a Servlet and some JSP pages to handle basic login functionality. Using forwarding and include actions will be a little less slick than using Ajax, but it will give you some good practice. The index page should be a login screen asking for user name and password. Store existing user names and passwords in a JavaBean. You need to design the Bean so that you can: 
• Check a user is already registered; 
• If a user name is known, check the submitted password matches the stored one; 
• Allow a new username/password pair to be stored (having first checked that the username is not already in use). If the user name is not known, return to the index page but with an “unknown user” message. If the user name is known, but the password is incorrect, return to the index page but with an “incorrect password” message. Provide a facility for a new user to register their username and password (provided the password is not already in use). Use the standard approach of requiring them to enter their password twice.