1. © Yaron Kanza Advanced Java Server Pages Written by Dr. Yaron Kanza, Edited by permission from author by Liron Blecher

2. Agenda Java Beans in JSP Custom JSP tags - TagLib JSP Expression Language

3. Motivation Software components (e.g. objects, data structures, primitives) are extensively used in Web applications For example: Service local variables Attributes forwarded in requests Session attributes, such as user information Application attributes, such as access counters See tutorial at http://docs.oracle.com/javase/tutorial/javabeans/http://docs.oracle.com/javase/tutorial/javabeans/ 3

4. Motivation Standard actions are used to manipulate components: declaration, reading from the suitable context, setting of new values (according to input parameters), storing inside the suitable context, etc. Java Beans provide a specification for automatic handling and manipulation of software components in JSP (and other technologies...) 4

5. Java Beans: The Idea Java Beans are simply objects of classes that follow some (natural) coding convention: An empty constructor A readable property has a matching getter A writable property has a matching setter Use JSP actions to access and manipulate the bean, and special action attributes to specify the properties of the bean, e.g., its scope JSP programmers do not wish to write cumbersome code or class files 5

6. Example 1: Access Counter In the following example, we use a Bean to maintain an access counter for requests to the pages 6

7. Counter Bean - CounterBean.java package myUtils; public class CounterBean { private int counter; public CounterBean() { counter = 0; } public int getCounter() { return counter; } public void setCounter(int i) { counter = i; } public void increment() { ++counter; } } 7 Bean must reside in a package A Bean is created by an empty constructor Counter setter and getter Other methods can be implemented as well A Bean is a concept and therefore there’s no need to extend any class or implement any interface! (though it would’ve been very Java-ish to create an empty interface “Bean”)

8. 8 Bean Example <jsp:useBean id="accessCounter" class=“myUtils.CounterBean" scope="application"/> Welcome to Page A Accesses to this application: Page B pageA.jsp Invokes getCounter() An instance named according to the given id is either found in the relevant scope or is created The default scope is page You could also use the type attribute in order to instantiate a data type which is either superclass of class or an interface that class implements

9. 9 Bean Example <jsp:useBean id="accessCounter" class=“myUtils.CounterBean" scope="application"/> Welcome to Page B Accesses to this application: Page A pageB.jsp A very similar JSP Since an instance named according to the given id can be found in the application scope, no instantiation takes place Counter Bean – cont.

10. Part of the Generated Servlet myUtils.CounterBean accessCounter = null; synchronized (application) { accessCounter = (myUtils.CounterBean) _jspx_page_context.getAttribute("accessCounter", PageContext.APPLICATION_SCOPE); if (accessCounter == null) { accessCounter = new myUtils.CounterBean(); _jspx_page_context.setAttribute("accessCounter", accessCounter, PageContext.APPLICATION_SCOPE); } 10 Similar effect to getServletContext().setAttribute() Similar effect to getServletContext().getAttribute() The instance is created and kept in the application’s scope as required. Note however that accessing this instance is out of the synchronized scope

11. DEMO counter 11

12. Example 2: Session Data In the following example, we use a Bean in order to keep a user's details throughout the session 12

13. package myUtils; public class UserInfoBean { private String firstName; private String lastName; public UserInfoBean() { firstName = lastName = null;} public String getFirstName() {return firstName;} public String getLastName() {return lastName;} public void setFirstName(String string) {firstName = string;} public void setLastName(String string) {lastName = string;} } UserInfoBean.java Example 2: Session Data – cont. 13

14. Information Form Fill in your details: Your First Name: Your Last Name: infoForm.html 14 Example 2: Session Data – cont.

15. Page A Hello, Have a nice session! User Info B infoA.jsp Match all the request parameters to corresponding properties. You could match parameters to properties explicitly using property=… param=… You can also set properties with explicit values using property=… value=… The String values are converted to the right bean’s property types.. 15 Example 2: Session Data – cont.

16. Page B Hello, Have a nice session! User Info A infoB.jsp A very similar JSP This time the request has no parameters so no bean properties are set 16 Example 2: Session Data – cont.

17. Advantages of Java Beans Easy and standard management of data Automatic management of bean sharing and lots more Good programming style Allow standard but not direct access to members You can add code to the setters and getters (e.g. constraint checks) without changing the client code You can change the internal representation of the data without changing the client code Increase of separation between business logic (written by programmers) and HTML (written by GUI artists) 17

18. DEMO session 18

19. Agenda Java Beans in JSP Custom JSP tags - TagLib JSP Expression Language

20. Custom JSP Tags JSP code may use custom tags – tags that are defined and implemented by the programmer The programmer defines how each of the custom tags is translated into Java code There are two methods to define custom tags: Tag libraries - used in old versions of JSP Tag files - much simpler, introduced in JSP 2.0 20

21. Tag Libraries A tag library consists of: Tag handlers - Java classes that define how each of the new tags is translated into Java code A TLD (Tag Library Descriptor) file, which is an XML file that defines the structure and the implementing class of each tag (see a tutorial at http://java.sun.com/products/jsp/tutorial/TagLibrariesTOC.html) http://java.sun.com/products/jsp/tutorial/TagLibrariesTOC.html 21

22. Date Tag Example package my; import javax.servlet.jsp.JspException; import javax.servlet.jsp.tagext.SimpleTagSupport; import java.io.IOException; public class DateTag extends SimpleTagSupport { public void doTag() throws JspException, IOException { getJspContext().getOut().print(new java.util.Date()); } DateTag.java Using the JSP-context, You can also acquire other implicit objects by calling getSession(), getRequest() etc… The class file is placed in webapps/myapp/WEB-INF/classes/my/ The java file is placed in webapps/myapp/WEB-INF/src/my/ Base class of tags which don’t handle the body or the attributes We must use a package (not necessarily named like your application) since this is a helper class which is imported form the JSP’s generated Servlet that is placed within a named package Goal : 22

23. 1.0 2.0 date my.DateTag empty my-taglib.tld Set this value that indicates your tag library version Name of the tag Tag’s class file in /myapp/WEB-INF/classes/my/ This defined tag contains no body 23 Date Tag Example – cont.

24. Hello. The time is: taglibuse.jsp The prefix for this tag must appear before the tag itself (looks like a namespace). The Prefix can’t be empty The path could be a URL. If you choose to use a local path, it must begin with /WEB-INF/tags/ You can add here more tags… 24 Date Tag Example – cont.

25. Taglib with Attributes package my; import javax.servlet.jsp.JspException; import javax.servlet.jsp.tagext.TagSupport; import java.io.IOException; public class DateTag2 extends TagSupport { private boolean isLongFormat = false; public void setIsLongFormat(boolean b) { isLongFormat = b; } public boolean getIsLongFormat() { return isLongFormat; { 25 DateTag2.java Base class of tags which do handle attributes the attribute is defined as not required so it must have a default value Attribute’s setter method Attribute’s getter method This member’s name should be identical to the attribute’s. The setter/getter methods should be named after the attribute (i.e. “get” + capital ( ))

26. public int doStartTag() throws JspException { try { if (isLongFormat) { pageContext.getOut().print(new java.util.Date().getTime()); } else { pageContext.getOut().print(new java.util.Date()); } } catch (Exception e) { throw new JspException("DateTag: " + e.getMessage()); } return SKIP_BODY; } public int doEndTag() { return EVAL_PAGE; } } Invoked when the generated Servlet starts processing the “start tag” Prints the date according to the isLongFormat attribute Signals the generated Servlet there’s no body within the tag to process Invoked when the generated Servlet starts processing the “end tag” Signals the generated Servlet to continue executing the generated Servlet code 26

27. date2 my.DateTag2 empty isLongFormat false my-taglib2.tld Hello. The time is: Milliseconds since the epoch : taglibuse2.jsp Same as before, only with different names for the tagclass You can put several blocks one after another The attribute is “not required” so you have to define a default value in DateTag2.java Uses default attribute value Uses a given attribute value 27

28. How does it work? 28 taglibuse2.jsp taglibuse2_jsp.java JspContext DateTag2 setIsLongFormat() doStartTag() doEndTag() JSP to Java Servlet translation Create the JspContext When the translation engine first encounters it creates a new instance of DateTag2 (so we needn’t worry about concurrency issues) and passes it the JspContext reference The attribute value is set using the setter method. The translator actually translated the attribute string value as it appears in the JSP source, to a boolean value as the Java tag class expects it… “Start tag” is reached “End tag” is reached

29. Tag Files JSP 2.0 provides an extremely simplified way of defining tags The motivation: JSP programmers prefer not to write cumbersome code or class files The idea: for each custom tag, write a tag file tagName.tag that implements the tag translation using JSP code This way, the programmer can avoid creating tag handlers and TLD files 29

30. The Simplified Example Hello. The time is: date.tag taguse.jsp In this new mechanism we use tagdir instead of uri we used in the old taglib implementation 30

31. The Attributes Example 31 <%!private String createDate(String isLong) { if ((isLong == null) || (isLong.equals("false"))) { return new java.util.Date().toString();} else { return new Long(new java.util.Date().getTime()).toString();} } %> Hello. The time is: Milliseconds since the epoch : date3.tag taguse3.jsp Private method declaration Default and isLongFormat=“false” case Calls the private method isLongFormat=“true” case Default case isLongFormat=“true” A new directive The isLongFormat parameter is identified as the isLongFormat attribute because we used the attribute directive

32. Other Capabilities of Custom Tags Attributes You can add validation mechanism for the attributes values Tag Body Tag translation may choose to ignore, include or change the tag body 32

33. DEMO taglib 33

34. Agenda Java Beans in JSP Custom JSP tags - TagLib JSP Expression Language

35. JSP expression language is a comfortable tool to access useful objects in JSP This language provides shortcuts in a somewhat JavaScript-like syntax An expression in EL is written as ${expr} For example: Hi, ${user}. Welcome Note that the EL expression does not violate the XML syntax as opposed to 35

36. EL Variables JSP EL does not recognize JSP's implicit objects, but rather has its own set Each of these objects maps names to values param, paramValues, header,headerValues, cookie, initParam, pageScope, requestScope, sessionScope, applicationScope For example, use the param[“x”] or param.x to get the value of the parameter x Map a parameter name to a single value or to multiple values Map a header name to a single value or to multiple values Maps a cookie name to a single value Maps a context initialization parameter name to a single value 36

37. EL Variables (cont) A variable that is not an EL implicit object is looked up at the page, request, session (if valid) and application scopes That is, x is evaluated as the first non-null element obtained by executing pageContext.getAttribute("x"), request.getAttribute("x"), etc. Might be confusing. Make sure you know what you’re accessing! 37

38. Object Properties In JSP EL, Property prop of Object o is referred to as o[prop] Property prop of Object o is evaluated as follows: If o is a Map object, then o.get(prop) is returned If o is a List or an array, then prop is converted into an integer and o.get(prop) or o[prop] is returned Otherwise, treat o “as a bean”, that is: convert p to a string, and return the corresponding getter of o, that is o.getProp() The term o.p is equivalent to o["p"] 38

39. An Example <% response.addCookie(new Cookie(“nameof",“homer")); session.setAttribute(“homepage", new java.net.URL("http://www.simpsons.com")); String[] strs = {"str1","str2"}; session.setAttribute("arr", strs); %> JSP Expressions Write the parameter x: elcall.jsp 39

40. EL Examples Expression-Language Examples Parameter x : ${param["x"]} Cookie name : ${cookie.nameof.value} Header Connection : ${header.Connection} Path of session attr. homepage : ${sessionScope.homepage.path} Element arr[${param.x}] : ${arr[param.x]} el.jsp The default value is TRUE cookie[“nameof”].getValue() header [“Connection”] sessionScope[“homepage”]. getPath(). You can omit the sessionScope ${…} means evaluate the expression inside the {} Only the ${param.x} is evaluated sessionScope [“arr”][param[“x”] 40 An Example