Introduction to JSP - PowerPoint

Shared by: HC120729222048
Tags
Stats
views:: 4
posted:: 7/29/2012
language:
pages:: 35
Public Domain
Document Sample
							   Embeds Java code
   In HTML tags
   When used well
       Simple way to generate dynamic web-pages
   When misused (complex embedded Java)
       Terribly messy (and may violate OaOO)
   Keep the embedded Java simple
       Use external helper classes (Beans?)
    JSP Document

                            Translation
       .java file

                            Compilation

      .class file

                           Reinitialization

.class file ready to run

                     Subsequent
                    User Requests

 Response Document
   A JSP page is translated into a Java Servlet
   And then compiled
   On Tomcat, the compilation happens the first
    time a page is requested
   First request can be very slow!
   Afterwards, just as fast as a Servlet (because it
    is then a servlet)
<html>
<head> <title> Hello JSP </title>
  </head>
<body>
<p> Hello World:
   <%= new java.util.Date() %>
</p>
</body>
</html>
   This extract shows the part that produces the output – compare it
    with the JSP:
        out = pageContext.getOut();
        _jspx_out = out;

        out.write("<html>\r\n");
        out.write("<head> ");
        out.write("<title> Hello JSP ");
        out.write("</title> ");
        out.write("</head>\r\n");
        out.write("<body> \r\n");
        out.write("<p> Hello World:\r\n    ");
        out.print( new java.util.Date() );
        out.write("\r\n");
        out.write("</p>\r\n");
        out.write("</body>\r\n");
        out.write("</html>\r\n");
   So far we’ve seen literals:
       E.g. <html>
       Copied straight to output (to browser)
   And expressions:
     E.g. <%= new java.util.Date() %>
     Return a value included in the output
   Also have:
       Directives, Declarations and Scriptlets
   Instructions to the compiler
   Examples:
       Include another page (compile-time)
         <%@ include file="header.jsp" %>
         <jsp:include page="page.jsp" flush="true" />
        What is the difference ???
       Import some Java packages (comma sep.)
         <%@ page import=“java.util.Collection”%>
   These are tags that start with the word jsp as in
    the previous example
   These are mainly for handling form beans as
    will be shown later apart from 3 tags.
   <jsp:forward, to forward user to another page
       <jsp:forward page="/servlet/login" />
   <jsp:plugin, to import plugin as a java applet in
    the client browser.
       <jsp:plugin type=applet code="Molecule.class"
        codebase="/html">
   <jsp:include, to include the result of a jsp page
   Used to declare variables and methods
   Go in the declaration section of the Servlet
   Can then be used later in the JSP page
   Note the syntax
   Examples:
       <%! int count = 0 %>
       <%! double sqr(double x) {
              return x * x; } %>
   These are sections of Java code embedded in
    the page
   Unlike expressions, they do not return a value
   But may write directly to the page
       Get the writer: response.getWriter()
   They go in the service method of the servlet
   Get executed each time a page is requested
 Demonstrates much of the above
<%! int n = 0; %>
Page accessed: <%= ++n %> times
<% if ( (n % 10) == 0 ) {
    n = 0;
}
%>
   Application
   Config
   Out
   Request
   Response
   Session
   Each JSP page has access to two special objects
   The Request object carries information passed
    by the HTTP request (e.g. made by the
    browser)
   This includes any submitted form data
   The Response object is used to pass
    information back to the Client (browser)
   E.g. response.getWriter() provides an
    output stream for direct writing to the client
   JSP makes form handling easy
   Can use request.getParameter() to get
    submitted values
   Or can define a JavaBean to grab the values
    semi-automatically.
   We’ll see this in action later with a simple
    example
   Global object: request, session

<% session.putValue(“username”,
  request.getParameter(“UserName”))
  %>

<html><body>
Thanks for giving us your name, <%=
  session.getValue(“username”) %>
</body></html>
   The form can specify whether data is supplied
    via a GET or POST request
   POST is the usual way
   Therefore, a servlet should implement the
    doPost() method to process a form
   JSP hides these GET/POST details (see
    request.getParameter and
    <jsp:setProperty>)
   Helper classes for servlets
       To generate forms (+ other HTML)
       Process the form input
   JSP + JavaBeans (more later)
   JSP + Tag Library (will be covered later)
   Come in two types
       Simple (this course)
       Enterprise (EJB: more complex, not covered)
   Simple JavaBeans
     Data bound classes
     Define properties (fields)
     Define get/set methods
   See following example
<body>
<h3 align="center">Welcome to the Hotel
   California</h3>
<form method="POST" action="BookHotel.jsp">
<p>Name: <input type="text" name="name"
   size="20"></p>
<p>How many nights:
<select size="1" name="nNights">
  <option selected="">1</option>
  <option>2</option>
  <option>3</option>
</select></p>
<p>
<input type="submit" value="Submit" name="B1">
</p>
</form>
</body>
<html>
<head><title>Bean test</title></head>
<body>
<h2>
 <%=request.getParameter("name") %>
  to stay for
  <%= request.getParameter("nNights") %>
  nights.
</h2>
</body>
</html>
<jsp:useBean id='roomBooking'
         scope='page'
         class='beans.HotelBean'
          />

<jsp:setProperty name='roomBooking' property='*'
   />

<html>
<head><title>Bean test</title></head>

<body>
<h2> <%=roomBooking.getName()%>
     to stay for
     <%= roomBooking.getnNights() %> nights. </h2>
</body>
</html>
package beans;
public class HotelBean {
    String name;
    int nNights;

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getnNights() {
        return nNights;
    }
    public void setnNights(int nNights) {
        this.nNights = nNights;
    }
}
   Note the setting: scope='page'
   Scope has four possible settings:
   Page
       Bean exists for execution of that page only
   Request
       Like page, but survives any forward or include
        requests
   Session
       The Bean exists for multiple requests within the
        web application, from a particular web browser
        instance
       Used for shopping baskets etc.
   Application
       The Bean exists for all requests from all users, for
        all pages that use it.
       Survives until the Web Application Server is
        restarted
       Can be used for a database connection (or
        connection pool)
   For this example, consider the differences:
     JavaBean JSP page: more complex
     JavaBean also required an external class
      definition
   Discussion question:
       When would JavaBean solutions be better than
        manual versions?
   Answer:
<%@ page import="java.util.*" %>
<HTML>
<BODY>
<%!
  Date theDate = new Date();
  Date getDate() {
     return theDate;
}
%>
Hello! The time is now <%= getDate() %>
</BODY>
</HTML>
   The JSP can get really intractable with lots of
    scriplets
   A direct example of using scriplet is a for loop
    to display records from a database in a table
    format.
   Put the code for the view in a function and call
    it as much as you need
<%
     public void printRecord(int Number){
        out.print(“<TR>”);
        out.print(“<TD>Number</TD>”);
        out.print(“<TD>” +Number+“</TD>”);
        out.print(“</TR>”);
     }
%>
<TABLE BORDER=2>
<%
  for ( int i = 0; i < n; i++ )
 {
         printRecord(i+1);
 }
%>
</TABLE>
 This doesn’t look anymore like an HTML code.
 What is the point of JSP then, is it to get messy
  code!!
 So, sun devised a remedy for that and the final
  result looked really good, but not the
  development
 The solution is called JSP Standard Tag Library
  or JSTL.
 The last example will be written in one tag as

<mylib: for start=“1” end=“10”/>
   Next Lecture