1. 1 JSP – Java Server Page DBI – Representation and Management of Data on the Internet

2. 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. 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 Template text

4. 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. 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. 6 An Example Hello World Example Hello World Example

7. 7

8. 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 the page is accessed

9. 9 The Source Code In Tomcat 3.2.1, you can find the generated Java and the class files in a subdirectory under tomcat_home/work.

10. 10 Translation A Random Number 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(" A Random Number "); out.println(Math.random());... }

11. 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. 12 More Details Writing JSP Pages

13. 13 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

14. 14 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: 1.Expressions of the form that are evaluated and inserted into the output, 2.Scriptlets of the form that are inserted into the servlet's service method, and 3.Declarations of the form that are inserted into the body of the servlet class, outside of any existing methods

15. 15 JSP Expressions A JSP expression is used to insert Java values directly into the output It has the following form: The Java expression is –evaluated, –converted to a string, and –inserted into the page This evaluation is performed at runtime (when the page is requested), and thus has full access to information about the request

16. 16 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

17. 17 Examples For example, the following shows the date/time that the page was requested: Current time: For example, the following shows the hostname: Your hostname:

18. 18 JSP Expressions JSP Expressions Current time: Your hostname: Your session ID: The testParam form parameter:

19. 19

20. 20 JSP Scriplets JSP scriptlets let you insert arbitrary code into the servlet method that will be built to generate the page ( _jspService ) Scriptlets have the following form: Scriptlets have access to the same automatically defined variables as expressions

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

22. 22 HTML Code in Scriptlets HTML code before and after the scriplets is converted to print methods: You won the game! You lost the game! if (Math.random() < 0.5) { out.println("You won the game!"); } else { out.println("You lost the game!"); }

23. 23 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();... }

24. 24 Example of Using Scriplets (1) Color Testing <% String bgColor = request.getParameter("bgColor"); boolean hasExplicitColor; if (bgColor != null) { hasExplicitColor = true; } else { hasExplicitColor = false; bgColor = "WHITE"; } %>

25. 25 Example of Using Scriplets (2) "> Color Testing <% 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."); } %>

26. 26

27. 27 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: Declarations do not produce output They are used, for example, to define variables

28. 28 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): Accesses to page since server reboot:

29. 29 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

30. 30 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.)

31. 31 response This is the HttpServletResponse associated with the response to the client The output stream is buffered, Thus, 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

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

33. 33 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 )

34. 34 application This is the ServletContext as obtained via getServletConfig().getContext() Servlets and JSP pages can hold constant data in the ServletContext object Getting and setting attributes is with getAttribute and setAttribute The ServletContext is shared by all the servlets in the server

35. 35 config This is the ServletConfig of the page

36. 36 pageContext JSP introduced a new class called PageContext It encapsulate use of server-specific features like higher performance JspWriter s 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

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

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

39. 39 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

40. 40 The page Directive The page directive lets you define the following attributes: –import="package.class “ –contentType="MIME-Type" (it is the same as )

41. 41 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 JspWriter out autoflush= “ true|false ” –Flush buffer when full or throws an exception when buffer isfull

42. 42 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 ”

43. 43 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:

44. 44 Writing JSP in XML We can replace the JSP tags with XML tags that represent – Expressions –Scriptles –Declarations –Directives

45. 45 Java Expression Code Java Java Declaration <jsp:directive.type Attribute = value/>

46. 46 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

47. 47 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

48. 48 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" />

49. 49 The jsp:forward Action Forwards request to another page Syntax: It has a single attribute, page, which should consist of a relative URL This could be a static value, or could be computed at request time Examples: " />

50. 50 Using Beans JavaBeans are reusable software components that can be manipulated visually in a builder tool –Introspaction – analyze how the bean works –Customization – the user can customize the look of the bean –Events support –Properties support –Persistence – allowing saving the bean on a persistent mechanism and loading it

51. 51 Some Facts about Beans The bean Class should include a constructor with no arguments The bean class should not include public variables (fields) Access to the attributes of the bean is through methods that look like –getName / setName for non-boolean fields –isName / setName for boolean fields

52. 52 The jsp:useBean Action This action lets you load in a JavaBean to be used in the JSP page The simplest syntax for specifying that a bean should be used is: <jsp:useBean id="name“ class="package.class" />

53. 53 Using a Bean <jsp:useBean id="name” class="package.class" /> Create an object of the given class Bind the object to a variable with the given name

54. 54 Using a Bean <jsp:useBean id=“db” class=“dbiClasses.WebDatabase" /> <% dbiClasses.WebDatabase db = new dbiClasses.WebDatabase(); %>

55. 55 Using a Bean <jsp:useBean id=“handler“ class=“ConnectionHandler" type=“Runnable”/> <% Runnable handler = new ConnectionHandler(); %>

56. 56 More on Beans Creating a Bean with jsp:useBean is like creating an object The scope of the bean can be beyond the page where it is declared Beans are used for resource collaboration

57. 57 Getting the Properties of a Bean Use jsp:getProperty to get a property of a bean Use the attributes name and property to get the requested property <jsp:getProperty name=“db” property=“login” />

58. 58 Setting the Properties of a Bean Use jsp:setProperty to set a property of a bean Use the attributes name, property and value to set the value to the property <jsp:setProperty name=“db” property=“login” value=“snoopy”/>

59. 59 Example package dbiTests; public class SimpleBean { private String message="No message specified"; public String getMessage() { return(message); } public void setMessage(String message) { this.message = message; }

60. 60 Reusing JavaBeans in JSP Reusing JavaBeans in JSP <jsp:setProperty name="test" property="message" value="Hello WWW" /> Message:

61. 61 Getting the Values from the Request <jsp:setProperty name=“db” property=“login” value=‘<%= request.getParameter(“login”)%>’ />

62. 62 Getting the Parameter Automatically If we wand that the value of the parameter dblogin of the request will be set to the bean db automatically we can use: <jsp:setProperty name=“db” property=“login” param=“dblogin” />

63. 63 All Input Parameters What will the following do? <jsp:setProperty name=“db” property=“*” />

64. 64 Shared Beans So far, we assumed that object that were created using jsp:useBean were bound to to the local variables in the _jspService method The scope attribute of jsp:useBean gives us more possibilities

65. 65 The page Value of scope The default value of scope The object has a binding to the local variable The object is positioned in the PageContext for the current request A servlet can get the value by pageCotext.getAttribute

66. 66 The application Value of scope The object has a binding to the local variable The object is positioned in the ServletContext A servlet can get the value by application.getServletCotext().getAttri bute Allows both servlets and JSP pages to work with the same object Allows a servlet to create a bean that will be used in JSP pages

67. 67 The session Value of scope The object has a binding to the local variable The object is positioned in the HttpSession for the current request A servlet can get the value by session.getAttribute

68. 68 The request Value of scope The object has a binding to the local variable The object is positioned in the ServletRequest for the current request A servlet can get the value by request.getAttribute

69. 69 A Conditional Bean The jsp:useBean component will create a new bean only if there is no existing bean with the same id and scope If an existing bean is found, it will be bound to the variable defined by id Since bean objects are not always created you can have a java code that is executed only if a new bean is created

70. 70 Example of Conditional Bean public class AccessCounterBean { private String firstPage; private int accessCount = 1; public String getFirstPage() { return(firstPage); } public void setFirstPage(String firstPage) { this.firstPage = firstPage; } public int getAccessCount() { return(accessCount++); }

71. 71 Example of Conditional Bean <jsp:useBean id=“counter“ class=“AccessCounterBean" scope=“application”/> <jsp:setProperty name=“counter” property=“firstPage” value=“Current Page Name”/>

72. 72 Comments –A JSP comment –Ignored by JSP-to-scriptlet translator –Any embedded JSP scripting elements, directives, or actions are ignored –An HTML comment –Passed through to resultant HTML –Any embedded JSP scripting elements, directives, or actions are executed normally /* comment */ or // comment –Java comment –Part of the Java code

73. 73 Quoting Conventions <\% - used in template text (static HTML) and in attributes where you really want “ <% ” %\> - used in scripting elements and in attributes where you really want “ %> ” \‘ \” - for using quotes in attributes \\ for having \ in an attribute

74. 74 Init and Destroy JSP pages, like regular servlets, sometimes want to use init and destroy Problem: the servlet that gets built from the JSP page might already use init and destroy –Overriding them would cause problems –Thus, it is illegal to use JSP declarations to declare init or destroy

75. 75 Init and Destroy Solution: use jspInit and jspDestroy –The auto-generated servlet is guaranteed to call these methods from init and destroy –The standard versions of jspInit and jspDestroy are empty (placeholders for you to override)

76. 76 JSP vs. Javascript Javascript –Client side –Less secure –Browser Dependent –Unstable

77. 77 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

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

79. 79 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

80. 80 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)