1 / 58

JSP – Java Server Page

JSP – Java Server Page. DBI – Representation and Management of Data on the Internet. What is JSP. http://java.sun.com/products/jsp A way to create dynamic web pages Based on Java Technology Large library base Platform independence Server side processing

damia
Download Presentation

JSP – Java Server Page

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. JSP – Java Server Page DBI – Representation and Management of Data on the Internet

  2. What is JSP • http://java.sun.com/products/jsp • A way to create dynamic web pages • Based on Java Technology • Large library base • Platform independence • Server side processing • Separates the graphical design from the dynamic content

  3. Relationships • In servlets, • HTML code is printed from java code • In JSP pages • Java code is embadded in HTML code Java HTML Java HTML

  4. In General Lines • JSP-enabled server • picks up .jsp page • parses it • converts it to runnable form • runs it • Converts page to a Java servlet (JspPage), with your code inside the _jspService()method • compiles it • runs servlet protocol

  5. Separating Graphical Design and Dynamic Content • Not a new idea (e.g. PHP, mod_perl, shtml, ASP) • Graphical Design and System Design are two separate and distinct specialities: • Different languages (HTML vs. Java) • Different goals • Different Training • Should be separated for optimal project management • JSP does this by allowing special Java tags in HTML

  6. An Example <html> <body> <b>I’m HTML code.</b><br> <% out.println(“I’m Java code.”) %> </body> </html>

  7. Sending a Request

  8. Translating and Executing JSP Pages • A JSP page is executed in a JSP container, generally installed in a Web server • Think of a “JSP container” as a JVM with suitable software installed • The underlying semantic model is that of a servlet • A typical JSP container will translate the JSP page to a Java servlet • By default translation and compilation of a JSP page is likely to occur the first time it is accessed • With Tomcat 3.1, you can find the generated Java and the class files in a subdirectory underjakarta-tomcat/work.

  9. Compilation

  10. public void _jspService(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { request.setContentType("text/html"); HttpSession session = request.getSession(true); JspWriter out = response.getWriter(); out.println("<H1>A Random Number</H1>"); out.println(Math.random()); ... } Translation <H1>A Random Number</H1> <%= Math.random() %>

  11. JSP Features • Standard directives guiding translation of a JSP page to a servlet • Standard actions in the form of predefined JSP tags • Script language declarations, scriptlets, and expressions for including Java (or other language) fragments that embed dynamic content • A portable tag extension mechanism, for building tag libraries—effectively extending the JSP language

  12. JSP vs. Javascript • Javascript • Client side • Less secure • Browser Dependent • Unstable

  13. JSP vs. ASP • Active Server Pages (ASP) • Similarities: • Server side dynamic web page generators • Share similar syntax <% %> • Modular programming (e.g. ActiveX, JavaBeans) • Focus on database connectivity • Differences: • ASP is a product while JSP is a specification

  14. JSP vs. ASP (cont.) • JSP • Based on Java Technology • Platform independence • Unix, AS400, VMS, Windows • More vendors choice • ASP • Microsoft programming languages • Near Monopoly

  15. JSP vs. Servlets • But JSP pages are converted to Servlets? Aren’t they the same? • Similarities • Provide identical results to the end user • JSP is an additional module to the Servlet Engine

  16. JSP versus Servlets (cont.) • Differences • Servlets: “HTML in Java code” • HTML code inaccessible to Graphics Designer • Everything very accessible to Programmer • JSP: “Java Code Scriptlets in HTML” • HTML code very accessible to Graphics Designer • Java code very accessible to Programmer (Seperating content from appearance)

  17. More Details Writing JSP Pages

  18. Template HTML • The HTML code that wraps the code is like a template • Created as an ordinary HTML • The dynamic parts are created on runtime and are inserted into the template

  19. JSP Scripting Elements • JSP scripting elements let you insert Java code into the servlet that will be generated from the JSP page. • There are three forms: • Expressions of the form <%=expression%> that are evaluated and inserted into the output, • Scriptlets of the form <%code%> that are inserted into the servlet's service method, and • Declarations of the form <%!code%> that are inserted into the body of the servlet class, outside of any existing methods

  20. JSP Expressions • A JSP expression is used to insert Java values directly into the output • It has the following form: <%= Java Expression %> • The Java expression is • evaluated, • converted to a string, and • inserted in the page • This evaluation is performed at run-time (when the page is requested), and thus has full access to information about the request

  21. Predefined Variables • The following predefined variables can be used: • request, the HttpServletRequest • response, the HttpServletResponse • session, the HttpSession associated with the request (if any) • out, the PrintWriter (a buffered version of type JspWriter) used to send output to the client • (more will be said later)

  22. Examples • For example, the following shows the date/time that the page was requested: Current time: <%= new java.util.Date() %> • For example, the following shows the hostname: Your hostname: <%= request.getRemoteHost() %>

  23. <BODY> <H2>JSP Expressions</H2> <UL> <LI>Current time:<%= new java.util.Date() %> <LI>Your hostname:<%= request.getRemoteHost() %> <LI>Your session ID:<%= session.getId() %> <LI>The <CODE>testParam</CODE> form parameter: <%= request.getParameter("testParam") %> </UL> </BODY>

  24. JSP Scriplets • JSP scriptlets let you insert arbitrary code into the servlet method that will be built to generate the page • Scriptlets have the following form: <% Java Code %> • Scriptlets have access to the same automatically defined variables as expressions

  25. Producing Code • Scriplets produce output HTML by printing into the out variable • Example: <% String queryData = request.getQueryString(); out.println("Attached GET data: " + queryData); %>

  26. HTML Code in Scriptlets • HTML code before and after the scriplets is converted to print methods: <% if (Math.random() < 0.5) { %> Have a <B>nice</B> day! <% } else { %> Have a <B>lousy</B> day! <% } %> if (Math.random() < 0.5) { out.println("Have a <B>nice</B> day!"); } else { out.println("Have a <B>lousy</B> day!"); }

  27. <%= foo() %> <% bar(); %> public void _jspService(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { request.setContentType("text/html"); HttpSession session = request.getSession(true); JspWriter out = response.getWriter(); out.println(foo()); bar(); ... }

  28. Example of Using Scriplets (1) <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"> <HTML> <HEAD> <TITLE>Color Testing</TITLE> </HEAD> <% String bgColor = request.getParameter("bgColor"); boolean hasExplicitColor; if (bgColor != null) { hasExplicitColor = true; } else { hasExplicitColor = false; bgColor = "WHITE"; } %>

  29. Example of Using Scriplets (2) <BODY BGCOLOR="<%= bgColor %>"> <H2 ALIGN="CENTER">Color Testing</H2> <% if (hasExplicitColor) { out.println("You supplied an explicit background color of "+ bgColor + "."); } else { out.println("Using default background color of WHITE. " + "Supply the bgColor request attribute to try " + "a standard color, an RRGGBB value, or to see "+ "if your browser supports X11 color names."); } %> </BODY> </HTML>

  30. JSP Declaration • A JSP declaration lets you define methods or fields that get inserted into the main body of the servlet class (outside of the service method processing the request) • It has the following form: <%! Java Code %> • Declarations do not produce output • They are used, for example, to define variables

  31. Example • We want to print out the number of times the current page has been requested since the server booted (or the servlet class was changed and reloaded): <%! private int accessCount = 0; %> Accesses to page since server reboot: <%= ++accessCount %>

  32. JSP Directives • A JSP directive affects the overall structure of the servlet class • It usually has the following form: <%@ directive attribute="value" %> • Multiple attribute settings for a single directive can be combined: <%@ directive attribute1="value1" attribute2="value2" ... attributeN="valueN" %>

  33. Directives • There are three main types of directive: • page, which lets you do things like • import classes • customize the servlet superclass • include, which lets you • insert a file into the servlet class at the time the JSP file is translated into a servlet • taglib directive • indicates a library of custom tags that the page can include

  34. The page Directive • The page directive lets you define the following attributes: • import="package.class“ <%@ page import="java.util.*" %> • contentType="MIME-Type" <%@ page contentType="text/plain" %> (it is the same as <%response.setContentType("text/plain"); %>)

  35. More Page Directives • isThreadSafe=“true|false” • Normal servlet processing or implementing SingleThreadModel • session=“true|false” • Allowing/disallowing sessions • buffer=“sizekb|none” • specifies the buffer size for the JspWriterout • autoflush=“true|false” • Flush buffer when full or throws an exception when buffer isfull

  36. And More Directives • extends=“package.class” • info=“message” • A message for the getServletInfo method • errorPage=“url” • Define a JSP page that handles uncaught exceptions • isErrorPage=“true|false” • language=“java”

  37. The include Directive • This directive lets you include files at the time the JSP page is translated into a servlet • The directive looks like this: <%@ include file="relative url" %>

  38. Predefined Variables • As we have seen before, there are variables that can be used in the code • There are eight automatically defined variables, sometimes called implicit objects • The available variables are request, response, out, session, application,config, pageContext, and page

  39. request • This is the HttpServletRequest associated with the request • It lets you • look at the request parameters (via getParameter), • the request type (GET, POST, HEAD, etc.), and • the incoming HTTP headers (cookies, etc.)

  40. response • This is the HttpServletResponse associated with the response to the client • Since the output stream (see out below) is buffered, it is legal to set HTTP status codes and response headers, even though this is not permitted in regular servlets once any output has been sent to the client

  41. out • This is the PrintWriter used to send output to the client • However, in order to make the response object useful, this is a buffered version of PrintWriter called JspWriter • Note that you can adjust the buffer size, or even turn buffering off, through use of the buffer attribute of the page directive • Usually out is used in scriptlets, since JSP expressions automatically get placed in the output stream, and thus rarely need to refer to out explicitly

  42. session • This is the HttpSession object associated with the request • Sessions are created automatically, so this variable is bound even if there was no incoming session reference (unless session was turned off using the session attribute of the page directive)

  43. application • This is the ServletContext as obtained via getServletConfig().getContext()

  44. config • This is the ServletContext as obtained via getServletConfig().getContext()

  45. pageContext • JSP introduced a new class called PageContext • It encapsulate use of server-specific features like higher performance JspWriters • The idea is that, if you access the server-specific features through this class rather than directly, your code will still run on "regular" servlet/JSP engines

  46. page • This is simply a synonym for this • It is not very useful in Java • It was created as a placeholder for the time when the scripting language could be something other than Java

  47. Actions • JSP actions use constructs in XML syntax to control the behavior of the servlet engine • You can • dynamically insert a file, • reuse JavaBeans components, • forward the user to another page, or • generate HTML for the Java plugin

  48. Available Actions • Available actions include: • jsp:include - Include a file at the time the page is requested • jsp:useBean - Find or instantiate a JavaBean • jsp:setProperty - Set the property of a JavaBean • jsp:getProperty - Insert the property of a JavaBean into the output • jsp:forward - Forward the requester to a new page • jsp:plugin - Generate browser-specific code that makes an OBJECT or EMBED tag for the Java plugin

  49. The jsp:include Action • This action lets you insert files into the page being generated • The file inserted when page is requested • The syntax looks like this: <jsp:include page="relative URL" flush="true" />

More Related