Advanced Java Server Pages

1. Advanced Java Server Pages An more detailed look at JSPs

2. Custom methods in JSPs • Just as Servlets, JSPs have methods for initialization end destruction • JspInit() corresponds to init() in Servlets • JspDestroy corresponds to destroy() in Servlets • Both JspInit() and JspDestroy() can implemented in your JSPs, i.e you can override the base class • Think before you use them • If you need the init and destroy, is it really a JSP you should be writing? Probably not!

3. Servlets and JSPs • Servlets should be used as front ends for JSPs • The Servlet should handle the control logic • The Servlet can initialize Beans that the JSP can use • The Beans can talk to databases, EJBs and so on • This is basic MVC • But how is this done?

4. Before the explanation • Assume there is a Bean, DataBean that fetches records from a database • The records are fetched to the bean with the fetch() method • The records are returned from the bean with the getRecords() method

5. The Servlet part • Create the Bean instance • Call your methods on the Bean • Add the bean to the request or the session • Get a RequestDispatcher • Use the forward() method in the RequestDispatcher

6. The Servlet part, using the request public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { DataBean db = new DataBean(); db.fetch(); request.setAttribute("dbBean", db); RequestDispatcher rd = request.getRequestDispatcher("jsppage.jsp"); rd.forward(request, response); }

7. The Servlet part, using the session public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { HttpSession ses = request.getSession(); DataBean db = new DataBean(); db.fetch(); ses.setAttribute("dbBean", db); RequestDispatcher rd = request.getRequestDispatcher("jsppage.jsp"); rd.forward(request, response); }

8. The JSP part • The JSP uses the <jsp:useBean ..> to define the bean, but it should not result in a new instance. • The instance that was added in the Servlet is used • The same scope in <jsp:useBean …> as in the Servlet (request and session in our examples) • The same id in <jsp:useBean …> as the name in the Servlet • The JSP uses <jsp:getProperty …> to call methods in the Bean

9. The JSP part, with request <jsp:useBean id=“dbBean" class=“beans.DataBean" scope=“request"> Error, the bean should have been created in the servlet! </jsp:useBean> <jsp:getProperty name=“dbBean” property=“records” /> <%-- property=“records” will look for getRecords() in the bean --%>

10. The JSP part, with session <jsp:useBean id=“dbBean" class=“beans.DataBean" scope=“session"> Error, the bean should have been created in the servlet! </jsp:useBean> <jsp:getProperty name=“dbBean” property=“records” /> <%-- property=“records” will look for getRecords() in the bean --%>

11. Custom Tags • We don’t want Java code in our JSPs • The built in tags <jsp:xxx > is quite limited in functionality • What we need is a way to extend the built in tags with our own • Custom Tags

12. Custom Tags • Custom Tags separates the logic from the presentation even more that <jsp:useBean …> • In our BookShop for example, the JSP with a book list and the shopping cart can consist of two lines of code • <bookshop:bookList /> • <bookshop:shoppingCart />

13. Two types of Custom Tags • Simple Tag (Tag) • A tag with or without arguments • Doesn’t use the Tag body • Implements javax.servlet.jsp.tagext.Tag • Body Tag • With or without arguments • Evaluate the body of the tag • <bookshop:aTag>This is the body</bookshop:aTag> • Implements javax.servlet.jsp.tagext.BodyTag

14. Simple Tag, an example • import javax.servlet.jsp.*; • import javax.servlet.jsp.tagext.*; • public class HelloWorldTag implements Tag • { • private PageContext pageContext; • private Tag parent; • /** • * Constructor • */ • public HelloWorldTag() • { • super(); • } • /** • * Method called at start of Tag • * @return either a EVAL_BODY_INCLUDE or a SKIP_BODY • */ • public int doStartTag() throws javax.servlet.jsp.JspTagException • { • return SKIP_BODY; • }

15. Simple Tag, an example • /** • * Method Called at end of Tag • * @return either EVAL_PAGE or SKIP_PAGE • */ • public int doEndTag() throws javax.servlet.jsp.JspTagException • { • try • { • pageContext.getOut().write("Hello World!"); • } • catch(java.io.IOException e) • { • throw new JspTagException("IO Error: " + e.getMessage()); • } • return EVAL_PAGE; • } • /** • * Method called to releases all resources • */ • public void release() {} • /** Method used by the JSP container to set the current PageContext • * @param pageContext, the current PageContext • */ • public void setPageContext(final javax.servlet.jsp.PageContext pageContext) • { • this.pageContext=pageContext; • }

16. Simple Tag, an example • /** Method used by the JSP container to set the parent of the Tag • * @param parent, the parent Tag • */ • public void setParent(final javax.servlet.jsp.tagext.Tag parent) • { • this.parent=parent; • } • /** Method for retrieving the parent • * @return the parent • */ • public javax.servlet.jsp.tagext.Tag getParent() { • return parent; • } • }

17. Simple Tag • All methods in the interface must be implemented! • All work is done in the doStartTag() and doEndTag() • The doStartTag() is called at the start of the tag • The doEndTag() is called at the start of the tag • Instead of implementing Tag, extend TagSupport • A helper class included in the package that has implementation for all required methods. Just implement the one that you will use!

18. Simple Tag, with TagSupport (complete) • import javax.servlet.jsp.*; • import javax.servlet.jsp.tagext.*; • public class HelloWorldTag extends TagSupport • { • private PageContext pageContext; • private Tag parent; • /** • * Method Called at end of Tag • * @return either EVAL_PAGE or SKIP_PAGE • */ • public int doEndTag() throws javax.servlet.jsp.JspTagException • { • try • { • pageContext.getOut().write("Hello World!"); • } • catch(java.io.IOException e) • { • throw new JspTagException("IO Error: " + e.getMessage()); • } • return EVAL_PAGE; • } • }

19. Simple Tags • In other words, use TagSupport! • The HelloTag implements our simple tag • Custom Tags are defined in a Tag Library Descriptor (tld)

20. Tag Library Descriptor • <taglib> • <tlibversion>1.0</tlibversion> • <jspversion>1.1</jspversion> • <shortname>mt</shortname> • <uri>/mytag</uri> • <info>My first Tag library</info> • <tag> • <name>helloWorld</name> • <tagclass>tags.HelloWorldTag</tagclass> • <bodycontent>empty</bodycontent> • <info>A Hello world Tag</info> • </tag> • </taglib>

21. Web.xml • The tld is referenced in web.xml • Web.xml binds a tag library to a web application <taglib> <taglib-uri>mytags</taglib-uri> <taglib-location>/WEB-INF/taglib.tld</taglib-location> </taglib>

22. Using your tag • The uri specified in web.xml is used in the JSP • <%@ taglib uri="mytags" prefix="mt" %> • At the start of the page • <mt:helloTag /> • Prints “Hello World”

23. Parameterized tags • Both Tag and BodyTag can take parameters • <mt:helloTag name=“Fredrik” /> • Just as in JavaBeans, use a set-method and a member variable • private String name=“”; • public void setName(_name){ name=_name;}

24. Parameterized tags • import javax.servlet.jsp.*; • import javax.servlet.jsp.tagext.*; • public class HelloNameTag extends TagSupport{ • private String name=“”; • public void setName(String _name){name=_name;} • public int doEndTag() throws javax.servlet.jsp.JspTagException{ • try{ • pageContext.getOut().write("Hello “ + name); • } • catch(java.io.IOException e){ • throw new JspTagException("IO Error: " + e.getMessage()); • } • return EVAL_PAGE; • } • }

25. TLD for HelloName <tag><name>hello</name><tagclass>HelloNameTag</tagclass><bodycontent>empty</bodycontent><info>A Hello Tag</info><attribute><name>name</name><required>false</required><rtexprvalue>false</rtexprvalue></attribute> </tag>

26. Using the parameterized tag • <mt:hello name=“Fredrik”/>

27. BodyTag • Just as with Tag, there are a lot of methods to write if implementing BodyTag • There is a helper class call BodyTagSupport just as with TagSupport • BodyTag is often used for looping over some result

28. Body Tag • package se.upright.education.uu.pvk.tags; • import javax.servlet.jsp.*; • import javax.servlet.jsp.tagext.*; • public class LoopTag extends BodyTagSupport • { • private int iterations = 5; • /** • * Method used by the JSP container to set the parameter Name. • */ • public void setIterations(int _iterations) • { • this.iterations=_iterations; • } • /** • * Method called by the Container to set the BodyContent • */ • public void setBodyContent(BodyContent bodyContent) • { • this.bodyContent=bodyContent; • }

29. Body Tag • public int doAfterBody() throws JspTagException • { • if(iterations>1) • { • //decrease the number of iterations left to do • iterations--; • return EVAL_BODY_TAG; • } • else • { • return SKIP_BODY; • } • }

30. Body Tag • /** • * Method Called at end of tag • * @return either EVAL_PAGE or SKIP_PAGE • */ • public int doEndTag() throws JspTagException • { • try • { • if(bodyContent != null) // Check if we even entered the body • bodyContent.writeOut(bodyContent.getEnclosingWriter()); • } • catch(java.io.IOException e) • { • throw new JspTagException("IO Error: " + e.getMessage()); • } • return EVAL_PAGE; • } • }

31. Body Tag tld <tag> <name>loop</name> <tag-class>se.upright.education.uu.pvk.tags.LoopTag</tag-class> <body-content>JSP</body-content> <attribute> <name>iterations</name> <required>true</required> <rtexprvalue>true</rtexprvalue> </attribute> </tag>

32. Using Body Tag <uu:loop iterations="10"> Looping <br /> </uu:loop>

33. Next Time • Java Standard Tag Library • A Tag Library with common functionallity • XML • XSLT