JSP Elements

1. JSP Elements Chapter 2

2. A JSP page is made out of a page template, which consists of HTML code and JSP elements such as scripting elements, directive elements, and action elements • Scripting elements consist of code delimited by particular sequences of characters. <% and %> • Implicit objects: application, config, exception, out, pageContext, request, response, and session • request.getHeader(“user-agent”)

3. Directive elements are messages to the JSP container <%@page language="java" contentType="text/html"%> • include and taglib • Action elements specify activities that, like the scripting elements, need to be performed when the page is requested • Action elements can use, modify, and/or create objects, and they may affect the way data is sent to the output.<jsp:include page=“another.jsp”/> • JSTL – standardized tag library • EL – additional JSP component that provides easy access to external objects.

4. Scripting Elements and Java • Scripting elements let you embed Java code in an HTML page. • Every Java executable—whether it’s a free-standing program running directly within a runtime environment, an applet executing inside a browser, or a servlet executing in a container such as Tomcat—boils down to instantiating classes into objects and executing their methods.

5. Scriptlets • A scriptlet is a block of Java code enclosed between <%and %>. • For example, this code includes two scriptlets that let you switch an HTML element on or off depending on a condition: <% if (condition) { %> <p>This is only shown if the condition is satisfied</p> <% } %>

6. Expression • An expression scripting element inserts into the page the result of a Java expression enclosed in the pair <%=and %>. • For example, in the following snippet of code, the expression scripting element inserts the current date into the generated HTML page: <%@page import="java.util.Date"%> Server date and time: <%=new Date()%> • In practice, it means that every Java expression will do, except the execution of a method of type void.

7. Declarations • A declaration scripting element is a Java variable declaration enclosed between <%!and %>. • It results in an instance variable shared by all requests for the same page

8. Data Types and Variables

9. String aString = “abcdxyz”; • int k = aString.length(); • char c = aString.charAt(4); • Static final NAME = “John Doe”; • Declaration • <% int k = 0; %> // new variable is created for each incoming HTTP client request • <%! int k = 0; %> // new variable is created for each new instance of the servlet • <%! static int k = 0; %> //the variable is shared among all instances of the servlet

11. Objects and Arrays • To create an object of a certain type (i.e., to instantiate a class), use the keyword new. Integer integerVar = new Integer(55); • Arrays of any object type or primitive data typeint[] intArray1; int[] intArray2 = {10, 100, 1000}; String[] stringArray = {"a", "bb"}; int[] array = new int[10];int[][] table1 = {{11, 12, 13}, {21, 22}}; int[][] table = new int[2][3];

12. int[][] table = new int[2][]; //allowed declaration

13. Operators, Assignments, and Comparisons • a += b; // same as a = a + b; • a++; // same as a += 1; • a--; // same as a -= 1; • Comparisons • !=, >, >=, <, <=

14. Comparison warning String s1 = "abc"; String s2 = "abc"; String s3 = "abcd".substring(0,3); boolean b1 = (s1 == "abc"); // parentheses not needed but nice! boolean b2 = (s1 == s2); boolean b3 = (s1 == s3); • &&, ||, ! – can be used to form more complex conditions ((a1 == a2) && !(b1 || b2))

15. Selections • The following statement assigns to the string variable sa different string depending on a condition: if (a == 1) { s = "yes"; } else { s = "no"; } • You can omit the else part. String s = (a== 1) ? "yes" : "no";

16. Or switch(a) { case 1: s = "yes"; break; default: s = "no"; break; }

17. Iterations • for (initial-assignment; end-condition; iteration-expression) { statements; } • while (end-condition) { statements; } • for (;end-condition;) { statements; } • do { statements; } while (end-condition);

18. Java variation of for loop String concatenate(Set<String> ss) { String conc = ""; Iterator<String> iter = ss.iterator(); while (iter.hasNext()) { conc += iter.next(); } return conc; } String concatenate(Set<String> ss) { String conc = ""; for (String s : ss) { conc += s; } return conc; }

19. Implicit Objects • Most commonly used implicit objects defined by Tomcat are out and request, followed by application and session. • In general, <%=the_mysterious_object.getClass().getName()%>

20. The application Object • Provides access to the resource shared within the web applicationif (application.getAttribute("do_it") != null) { /* ...place your "switchable" functionality here... */ }

25. The config Object • The config object is an instance of the org.apache.catalina.core.StandardWrapperFacadeclass, which Tomcat defines to implement the interface javax.servlet.ServletConfig. • Tomcat uses this object to pass information to the servlets. config.getServletName() • The exception Object • The exception object is an instance of a subclass of Throwable(e.g., java.lang.NullPointerException) and is only available in error pages.

28. The out Object • Use out like System.out <% out.print("abc"); %> <%="abc"%> abc out.print("a string" + intVar + obj.methodReturningString() + ".");

29. Spaces <%@page trimDirectiveWhitespaces="true"%>

30. The pageContext Object • A class to access all objects and attributes of a JSP page • The PageContext class defines several fields, including PAGE_SCOPE, REQUEST_SCOPE, SESSION_SCOPE, and APPLICATION_SCOPE, which identify the four possible scopes. pageContext.removeAttribute("attrName", PAGE_SCOPE)

31. The request Object • The request variable gives you access within your JSP page to the HTTP request sent to it by the client. • Note: You cannot mix methods that handle parameters with methods that handle the request content, or methods that access the request content in different ways.

34. Example: User Authentication

35. To password-protect all the pages inside a particular folder of an application, you have to edit the WEB-INF/web.xml file in the application’s root directory. • Listing 2-11 shows you the code you need to insert inside the <web-app> element to limit the access of the pages in the folder /tests/auth/this/to users with the role canDoThis, and of the pages in the folder /tests/auth/that/to users with the role canDoThat.

39. The response Object • The response variable gives you access within your JSP page to the HTTP response to be sent back to the client. • The HttpServletResponse interface includes the definition of 41 status codes (of type public static final int) to be returned to the client as part of the response. • The HTTP status codes are all between 100 and 599. • The range 100–199 is reserved to provide information, • 200–299to report successful completion of the requested operation, • 300–399to report warnings, • 400–499to report client errors, and • 500–599 to report server errors. • You will find the full list of errors at http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html. • The normal status code is SC_OK (200), and the most common error is SC_NOT_FOUND (404), • Working with Tomcat, the most common server error is SC_INTERNAL_SERVER_ERROR (500). • You get it when there is an error in a JSP. You can use these constants as arguments of the sendErrorandsetStatusmethods.

40. The session Object • The term session refers to all the interactions a client has with a server from the moment the user views the first page of an application to the moment they quit the browser (or the session expires because too much time has elapsed since the last request). • When Tomcat receives an HTTP request from a client, it checks whether the request contains a cookie that by default is named JSESSIONID. session.setAttribute("MyAppOperator", "");booleanisOperator = (session.getAttribute("MyAppOperator") != null); if (isOperator) { ...

41. session.setAttribute("upref", preferences); In all the pages of your application, you can then retrieve that information with something like this: UserPrefs preferences = (UserPrefs)session.getAttribute("upref");

42. Directive Elements • <%@directive-name attr1="value1" [attr2="value2"...] %> • The page Directive • Tell Tomcat that the scripting language is Java and that the output is to be HTML: • <%@page language="java" contentType="text/html"%> • Tell Tomcat which external class definitions your code needs • <%@page import="java.util.ArrayList"%> • <%@page import="java.util.Iterator"%> • <%@page import="myBeans.OneOfMyBeans"%> • <%@page import="java.util.ArrayList, java.util.Iterator"%> // for multiple class

43. In addition to language, contentType, and import, the page directive also supports autoFlush, buffer, errorPage, extends, info, isELIgnored, isErrorPage, isScriptingEnabled, isThreadSafe, pageEncoding, session, and trimDirectiveWhitespaces.

46. Remaining page directives • extends tells Tomcat which class the servlet should extend. • info defines a string that the servlet can access with its getServletInfo()method. • isELIgnored tells Tomcat whether to ignore EL expressions. • isScriptingEnabled tells Tomcat whether to ignore scripting elements. • pageEncoding specifies the character set used in the JSP page itself. • session tells Tomcat to include or exclude the page from HTTP sessions.

47. The include Directive • The includedirective lets you insert into a JSP page the unprocessed content of another text file. <%@include file="some_jsp_code.jspf"%> • The taglibDirective • You can extend the number of available JSP tags by directing Tomcat to use external self-contained tag libraries. The taglib directory identifies a tag library and specifies what prefix you use to identify its tags. <%@tagliburi="http://mysite.com/mytags" prefix=”my”%> <my:oneOfMyTags> ... </my:oneOfMyTags> • The following code includes the core JSP Standard Tag Library: <%@tagliburi="http://java.sun.com/jsp/jstl/core" prefix="c"%>