 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.java file.class file.class file ready to run Response Document Translation Compilation Reinitialization Subsequent User Requests

 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)

Hello JSP Hello World:

 This extract shows the part that produces the output – compare it with the JSP: out = pageContext.getOut(); _jspx_out = out; out.write(" \r\n"); out.write(" "); out.write(" Hello JSP "); out.write(" "); out.write(" \r\n"); out.write(" Hello World:\r\n "); out.print( new java.util.Date() ); out.write("\r\n");

 So far we’ve seen literals:  E.g.  Copied straight to output (to browser)  And expressions:  E.g.  Return a value included in the output  Also have:  Directives, Declarations and Scriptlets

 Instructions to the compiler  Examples:  Include another page (compile-time)  What is the difference ???  Import some Java packages (comma sep.) 

 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:plugin, to import plugin as a java applet in the client browser.   <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: 

 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 Page accessed: 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 Thanks for giving us your name,

 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 )

 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

Welcome to the Hotel California Name: How many nights: 1 2 3

Bean test to stay for nights.

<jsp:useBean id='roomBooking' scope='page' class='beans.HotelBean' /> Bean test to stay for nights.

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:

<%! Date theDate = new Date(); Date getDate() { return theDate; } %> Hello! The time is now

 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(“ ”); out.print(“ Number ”); out.print(“ ” +Number+“ ”); out.print(“ ”); } %> <% for ( int i = 0; i < n; i++ ) { printRecord(i+1); } %>

 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

 Next Lecture