1 / 35

Introduction to JSP with Forms and JavaBeans - Overview and Basic Constructs

Learn about JavaServer Pages (JSP) with forms and JavaBeans. Understand how to embed Java code in HTML tags effectively, generating dynamic web pages. Explore JSP document translation, compilation, and life cycle. Discover basic constructs like directives, declarations, and scriptlets. See examples of JSP tags for form handling and Java package import. Practice form processing architectures using JSP and JavaBeans, with a focus on creating and processing form inputs. Improve your JSP skills with this insightful guide.

blaze
Télécharger la présentation

Introduction to JSP with Forms and JavaBeans - Overview and Basic Constructs

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Introduction to JSPwith Forms and JavaBeans

  2. Overview • 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?)

  3. JSP Document Translation .java file Compilation .class file Reinitialization .class file ready to run Subsequent User Requests Response Document How does JSP work?

  4. Life Cycle • 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)

  5. Hello World <html> <head> <title> Hello JSP </title> </head> <body> <p> Hello World: <%= new java.util.Date() %> </p> </body> </html>

  6. Date_jsp.java (extract) • 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");

  7. Produced

  8. Basic Constructs • 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

  9. Directives • 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”%>

  10. JSP Tags • 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

  11. Declarations • 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; } %>

  12. Scriptlets • 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

  13. Illustrative Example • Demonstrates much of the above <%! int n = 0; %> Page accessed: <%= ++n %> times <% if ( (n % 10) == 0 ) { n = 0; } %>

  14. What happens on next refresh?

  15. JSP objects • Application • Config • Out • Request • Response • Session

  16. Request and Response • 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

  17. Form Handling with JSP • 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

  18. Processing form input • Global object: request, session <% session.putValue(“username”, request.getParameter(“UserName”)) %> <html><body> Thanks for giving us your name, <%= session.getValue(“username”) %> </body></html>

  19. Form Processing • 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>)

  20. Form Processing Architectures • Helper classes for servlets • To generate forms (+ other HTML) • Process the form input • JSP + JavaBeans (more later) • JSP + Tag Library (will be covered later)

  21. JavaBeans • 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

  22. Hotel Booking Form

  23. HTML (body) for Booking Form <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>

  24. Accessing Submitted Values(manual version) <html> <head><title>Bean test</title></head> <body> <h2> <%=request.getParameter("name") %> to stay for <%= request.getParameter("nNights") %> nights. </h2> </body> </html>

  25. JavaBean Version (Auto) <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>

  26. Java Code for Bean Version 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; } }

  27. Resulting Page

  28. Bean Scope • 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

  29. Bean Scope (cont.) • 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)

  30. Beans v. Manual • 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:

  31. Functions <%@ page import="java.util.*" %> <HTML> <BODY> <%!     Date theDate = new Date();     Date getDate()     {         return theDate;     } %> Hello!  The time is now <%= getDate() %> </BODY> </HTML>

  32. Functions • 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

  33. Function – Loop example <% 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 ( inti = 0; i < n; i++ ) { printRecord(i+1); } %> </TABLE>

  34. Functions • 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”/>

  35. JSTL • Next Lecture

More Related