Laboratório 8 JSP s, EL, JSTL

Laboratório 8 JSP s, EL, JSTL Introdução JSP significa Java Server Page e representa uma forma de gerar conteúdo dinâmico numa página web. Em termos sintácticos, são documentos constituídos por tags xhtml normalíssimo,mas onde é possível, de forma mais ou menos explícita, embutir código Java. As páginas JSP utilizam tags XML e scriptlets Java por forma a encapsular a lógica que gera o conteúdo da página. Quaisquer tags de formatação, são directamente enviadas para a página de resultado. Por forma a que este objectivo seja atingido, quando uma jsp é solicitada ao servidor aplicacional pela primeira vez, este começa por invocar um compilador de JSPs, que não faz nada mais nada menos do que interpretar todas as tags e scriptlets nela contida, por forma a gerar uma servlet cujo comportamento seja aquele que foi especificado via XML na JSP em causa. Em pedidos posteriores, esta compilação já estará efectuada, sendo que não há necessidade de o compilador de JSPs entrar em funcionamento novamente. A servlet já gerada atenderá o pedido e apresentará a resposta pretendida. No entanto, se tiver havido alguma alteração na JSP original, é suposto que esta seja compilada novamente no próximo pedido que seja feito. É neste sentido que as JSPs representam uma extensão à tecnologia de Servlets. Na prática, uma JSP é uma Servlet, mas simplesmente nós não temos de implementar os métodos da Servlet, especificamos o que esta tem de fazer via XML e quando a página for compilada, os métodos representativos de todo o ciclo de vida da servlet correspondente são implementados automaticamente. Resumindo, são uma linguagem de server-side scripting, tal como o php ou asp. A diferença 2005 ESTSetúbal Susana Cabaço - Computação na Internet 2005/2006 Página 1/18

reside no facto de não serem interpretadas (como php ou asp), mas sim compiladas. O primeiro pedido a uma JSP pode ser mais lento em termos de execução pelo facto de esta ter de ser compilada, mas posteriormente já não há necessidade de re-interpretar todo o código nelas escrito, pelo que todo o processo de execução assiste a uma melhoria significativa no desempenho. Como Criar uma JSP Tipicamente, uma servlet só permite ao programador embeber código html dentro do Java, o que dificulta todo o processo de design. Usando JSPs consegue-se uma separação muito mais eficiente entre a camada de apresentação e o modelo de processamento. Agora passamos a funcionar num modo oposto, dentro das tags é embutida a lógica também sob a forma de tag ou de expressões. A forma mais simples de criar documentos JSP, é Mudar a extensão de um ficheiro HTML para.jsp Colocar o documento num servidor que suporte JSP (no vosso caso, tomcat) Ao fazer isto, a página será transformada numa servlet, sendo que a sua compilação é feita no primeiro acesso. (Podem, aliás, consultar a directoria work do tomcat onde, entre outras coisas se mantém a cache relativa à vossa aplicação. Podem procurar o ficheiro.java e o ficheiro.class correspondentes à implementação e compilação da jsp em causa. É uma forma de identificar e compreender melhor o que é que o tomcar faz afinal com as páginas jsp que desenvolvemos.) Nos acessos subsequentes, o pedido é redirecionada a servlet que foi gerada a partir da página Ao transformar um ficheiro html numa JSP, podemos lá inserir blocos de código (scriptlets): <%... %> e expressões <%=... %> que são os elementos mais frequentes 2005 ESTSetúbal Susana Cabaço - Computação na Internet 2005/2006 Página 2/18

Exemplo: <p>texto repetido: <% for (int i = 0; i < 10; i++) { %> <p>esta é a linha <%=i %> <% }%> Exemplo de uma JSP: Neste exemplo podemos identificar a utilização de: Directivas JSP Beans Scriptlets Java Expressões Acções 2005 ESTSetúbal Susana Cabaço - Computação na Internet 2005/2006 Página 3/18

Sintaxe dos elementos JSP Os elementos que podemos usar para especificar uma JSP são embutidos no código xhtml, como já foi referido, mas no entanto são interpretados no servidor e jamais chegam ao browser. O resultado apresentado é sempre xhtml puro. A sua sintaxe geral é a seguinte: directivas: <%@... %> o Podem ser do tipo: page: para definir atributos relacionados com a página include: para incluir outros ficheiros (html ou jsp) na página taglib: para declarar a utilização de bibliotecas de marcas (tags) personalizadas utilizadas na página Exemplo: <%@page import="java.net.*, java.io.*" session="false" errorpage="/erro.jsp" %> <%@include file="navbar.jsp" %> declarações: <%!... %> : Uma declaração equivale à declaração de uma variável. expressões: <%=... %> : Uma expressão, quando é processada, retorna um valor que é inserido na página de resultado em substituição da expressão original. Equivale a fazer um out.println do valor de uma variável, por exemplo. scriptlets: <%... %>: Uma scriptlet é um bloco de código Java que será executado sempre que a JSP em que se encontra é processada. comentários: <%--... --%> acções: <jsp:acção... /> Marcas Personalizadas: <prefixo:elemento... /> 2005 ESTSetúbal Susana Cabaço - Computação na Internet 2005/2006 Página 4/18

A directiva page pode ter os seguintes atributos: Exemplo: info="texto informativo" default: nenhum language="java" (default) contenttype="text/html; charset=iso-8859-1" (default) extends="acme.fontejsp" default: nenhum import="java.io.*, java.net.*" default: java.lang session="true" (default) buffer="8kb" (default) autoflush="true" (default) isthreadsafe="true" (default) errorpage="/erros/404.jsp" default: nenhum iserrorpage= "false" (default) <%@page autoflush="true" buffer="16kb" contenttype="text/html" errorpage="myerrorpage.jsp" extends="org.apache.jasper.runtime.httpjspbase" import="java.sql.*" info="this page has a set of page directive attributes" language="java" pageencoding="utf-8" session="false" %> <HTML> <HEAD><TITLE>Exemplo da directive page</title></head> <BODY> <P>A página JSP usada para gerar este conteúdo tem definidos valores para todos os atributos da directive page. </P> </BODY> </HTML> 2005 ESTSetúbal Susana Cabaço - Computação na Internet 2005/2006 Página 5/18

A directiva include pode exemplificar-se da seguinte forma: <HTML> <HEAD><TITLE>Exemplo da directiva include</title></head> <BODY> <%@ include file = exemplo2.html %> <!-- incluir nesta página o conteúdo de outra cujo nome é exemplo2.html --> <P> Este texto aparece após o conteúdo do ficheiro exemplo2.html </P> </BODY> </HTML> Exemplos de declarações: <%! public final static String[] meses = {"jan", "fev", "mar", "abr", "mai", "jun"}; // declaração do array meses %> <%! public static String getmes() { /* Declaração do método getmes() na Servlet que vai ser gerada por esta JSP */ Calendar cal = new GregorianCalendar(); return meses[cal.get(calendar.month)]; } %> Exemplo de uma JSP que usa declarações e expressões: <%! String name = "Mark"; String date = "8th April, 2002"; %> <HTML> <HEAD><TITLE>Exemplo da directiva include</title></head> <BODY> <P> Esta página foi modificada pela última vez em <%= date %> por <%= name %>. </P> </BODY> </HTML> Exemplo de uma JSP que usa scriptlets: <%! 2005 ESTSetúbal Susana Cabaço - Computação na Internet 2005/2006 Página 6/18

String[] names = {"Ruth", "Matilda", "Millicent", "Micah"}; %> <HTML> <HEAD><TITLE>Chapter 2 - Embedding Code</TITLE></HEAD> <BODY> <H1>List of people</h1> <TABLE BORDER="1"> <TH>Name</TH> <% for (int i=0; i<names.length; i++) { %> <TR><TD> <%= names[i]%> </TD></TR> <% } %> </TABLE> </BODY> </HTML> No que diz respeito a comentários no código, os comentários xhtml não servem para comentar JSP: <!-- Texto ignorado pelo browser mas não pelo servidor. Tags são processados --> Comentários JSP: podem ser usados para comentar blocos JSP <%-- Texto, código Java, <HTML> ou tags <%JSP%> ignorados pelo servidor --%> Pode-se também usar comentários Java quando dentro de scriptlets, expressões ou declarações: <% código JSP... /* texto ou comandos Java ignorados pelo servidor */... mais código %> As acções, numa JSP, proporcionam acesso a tarefas a serem realizadas, nomeadamente: incluir conteúdos de outros recursos redireccionar os pedidos para outros recursos interagir com JavaBeans ou outros objectos Java Há um conjunto de acções standard que podem ser executadas: 2005 ESTSetúbal Susana Cabaço - Computação na Internet 2005/2006 Página 7/18

Acção <jsp:include> <jsp:forward> <jsp:plugin> <jsp:param> <jsp:usebean> <jsp:setproperty> <jsp:getproperty> Descrição Inclui Dinamicamente outro recurso num JSP. Quando a JSP é executadam o recurso referenciado é incluido e processado. Se o recurso é alterado entre pedidos as alterações são incluidas na proxima chamada da página Redireciona o processamento para outro JSP, servlet ou página estática. Esta acção termina com a execução da página JSP corrente. Permite gerar uma página HTML que contenha as construções apropriadas (dependentes do browser) para que se faça o download do plug-in Java e a subsequente execução da applet especificada A tag <jsp:plugin> é substituída pela tag <object> ou pela tag <embed>, dependendo do browser do cliente Usado em conjunto com as acções include, forward and plugin. Permite definir duplos do tipo (nome; valor) que podem ser lidos quando a acção é executada Associa uma instância de um JavaBean, definido com um determinada abragencia e icom um id. Modifica o valor de uma propriedade da instancia do JavaBean. Possui um funcionalidade especial a qual permite modifcar o atributo pelo uso de um parametro lido num pedido, desde que seja utilizado o mesmo identificador. Obtem e converta uma propriedade numa String de modo a ser possível incluir na resposta. Objectos Implícitos Os objectos implícitos são variáveis locais previamente inicializadas. Exceptuando o objecto session e exception, que dependem de uma directiva page para serem activados/desactivados, os objectos implícitos estão disponíveis numa JSP através de qualquer bloco de scriptlet. Essencialmente, são os seguintes: Objectos da servlet a. page b. config Entrada e saída a. request b. response c. out 2005 ESTSetúbal Susana Cabaço - Computação na Internet 2005/2006 Página 8/18

Objectos contextuais a. session b. application c. pagecontext Controle de excepções a. Exception Estes objectos são representados pelas seguintes APIs: Objeto Classe ou Interface Descrição page javax.servlet.jsp.httpjsppage Instância de servlet da página config javax.servlet.servletconfig Dados de configuração do servlet request javax.servlet.http.httpservletreq uest Dados de solicitação, incluindo parâmetros response javax.servlet.http.httpservletres Dados da resposta ponse out javax.servlet.jsp.jspwriter Fluxo de saída para o conteúdo da página session javax.servlet.http.httpsession Dados de sessão específicos do utilizador application javax.servlet.servletcontext Dados partilhados por todas as páginas de aplicação pagecontex t javax.servlet.jsp.pagecontext Dados de contexto para execução da página exception javax.lang.throwable Erros não capturados ou excepções No fundo, estamos a falar dos mesmos objectos aos quais já tínhamos acesso numa Servlet, sendo que a API onde estão definidos é exactamente a mesma, tal como são os mesmos os métodos e atributos que os constituem. A diferença reside na forma como são utilizados. Exemplo de obtenção dos valores de parâmetros na JSP: <% String nome = request.getparameter("nome"); String idstr = request.getparameter("id"); int id = Integer.parseInt(idStr); 2005 ESTSetúbal Susana Cabaço - Computação na Internet 2005/2006 Página 9/18

%> <p>bom dia <%=nome %>! (cod: <%=id %> Modelo MVC MVC significa Model View Controller e, essencialmente, consiste numa estratégia para separar dados ou lógica da aplicação (model) da interface do utilizador (view) e do fluxo da aplicação (controller). Pode ser representado da forma seguinte: User View Model Controller O que se pretende, na implementação das vossas JSPs é que recorram ao modelo MVC, com uma estratégia centrada num único controlador que atende todos os pedidos, e os encaminha para os devidos recursos que efectuam o processamento adequado para o efeito. Vão seguir o modelo seguinte (JSP modelo2): 2005 ESTSetúbal Susana Cabaço - Computação na Internet 2005/2006 Página 10/18

MVC Funcionamento Servlet processa os parâmetros e controla a execução da aplicação Beans são responsáveis pelo modelo de negócio JSP gere a saída enviada para o Browser Benefícios Especialização dos componentes Servlets: Controle da aplicação Beans: Modelo do negócio e envia objectos e/ou Beans para uma vista. JSP: simplificação do código Em termos tecnológicos, vão recorrer, para implementar as vossas aplicações segundo este modelo, a elementos como: EL (Expression Language) Beans (para o modelo aplicacional) JSTL (bibliotecas de tags que escondem lógica de processamento e vêm em substituição de scriptlets Java por forma a que uma JSP seja constituída apenas 2005 ESTSetúbal Susana Cabaço - Computação na Internet 2005/2006 Página 11/18

por tags e seja assim mais fácil não só de compreeder, mas também de desenvolver) Expression Language A expression language oferece uma sintaxe para definir expressões que pode ser utilizada em texto estático ou como valor de qualquer atributo de uma marca que aceite uma expressão. Como usar uma expressão EL num atributo: Associado a uma só expressão: <some:tag value="${expr}"/> A expressão é avaliada e o resultado é convertido para o tipo esperado como valor do atributo. Intercalar texto com várias expressões text: <some:tag value="some${expr}${expr}text${expr}"/> As expressões são avaliadas da esquerda para a direita. Cada expressão é convertida para uma string e ligada com o texto. A string final é convertida no tipo esperado para o atributo. Somente texto: <some:tag value="sometext"/> A string é convertida no tipo esperado para o atributo.. Exemplo: ${produto} equivale a: <%= pagecontext.findattribute( produto") %> que por sua vez equivale a: <jsp:usebean id= produto type="somepackage.someclass scope="..."> <%= produto %> Aplicação a uma servlet e ao seu resultado: public class ScopedVars extends HttpServlet { public void doget(httpservletrequest request, HttpServletResponse response) throws ServletException, IOException { 2005 ESTSetúbal Susana Cabaço - Computação na Internet 2005/2006 Página 12/18

request.setattribute("attribute1", "First Value"); HttpSession session = request.getsession(); session.setattribute("attribute2", "Second Value"); ServletContext application = getservletcontext(); application.setattribute("attribute3", new java.util.date()); request.setattribute("repeated", "Request"); session.setattribute("repeated", "Session"); application.setattribute("repeated", "ServletContext"); RequestDispatcher dispatcher = request.getrequestdispatcher("/el/scopedvars.jsp"); dispatcher.forward(request, response); } } JSP a processar: <!DOCTYPE > <TABLE BORDER=5 ALIGN="CENTER"> <TR><TH CLASS="TITLE"> Accessing Scoped Variables </TABLE> <P> <UL> <LI><B>attribute1:</B> ${attribute1} <LI><B>attribute2:</B> ${attribute2} <LI><B>attribute3:</B> ${attribute3} <LI><B>Source of "repeated" attribute:</b> ${repeated} </UL> </BODY></HTML> Em EL, os objectos implícitos que estão disponíveis na JSP surgem agora através de expressões com recurso a: param: Mapeia o nome de um parametro de pedido com seu valor paramvalues: Mapeia o nome de um parametro de pedido com um array de valores header: Mapeia o nome de um cabeçalho com o seu valor headervalues: Mapeia o nome de um cabeçalho com um array de valores 2005 ESTSetúbal Susana Cabaço - Computação na Internet 2005/2006 Página 13/18

cookie: Mapeia o nome de um cookie com o objecto initparam: Mapeia o parametro de inicalização do contexto com o seu valor pagescope: Mapeia uma variavel de página com os seus valores requestscope: Mapeia uma variavel de pedido com os seus valores sessionscope: Mapeia uma variavel de sessão com os seus valores applicationscope: Mapeia uma variavel de aplicação com os seus valores Exemplos: ${param.foo} => booyah ${param["foo"]} => booyah \${param["foo"]} => ${param["foo"]} ${header["host"]} => localhost:8080 ${header["accept"]} => */* ${header["user-agent"]} => Mozilla/5.0 (Macintosh; U; PPC Mac OS X; en-us) AppleWebKit/124 (KHTML, like Gecko) Safari/125 Em termos de operadores, em EL não deixam de estar disponíveis os mesmos e com as mesmas precedências que se utilizam em Java. Exemplos: Expressão EL Resultado ${1 > (4/2)} false ${4.0 >= 3} true ${100.0 == 100} true ${(10*10) ne 100} false ${'a' < 'b'} true ${'hip' gt 'hit'} false ${4 > 3} true ${1.2E4 + 1.4} 12001.4 ${3 div 4} 0.75 ${10 mod 4} 2 ${!empty param.add} True if the request parameter named Add is null or an empty string ${pagecontext.request.contextpath} The context path ${sessionscope.cart.numberofitems} The value of the numberofitems property of the sessionscoped attribute named cart ${param['mycom.productid']} The value of the request parameter named mycom.productid ${header["host"]} The host ${departments[deptname]} The value of the entry named deptname in the departments map ${requestscope['javax.servlet. forward.servlet_path']} The value of the request-scoped attribute named javax.servlet. forward.servlet_path 2005 ESTSetúbal Susana Cabaço - Computação na Internet 2005/2006 Página 14/18

Exemplo de aplicação numa JSP: <html> <head> <title>expression Language Examples</title> <% pagecontext.setattribute("pagecolor", "yellow"); %> </head> <body bgcolor= ${pagescope.pagecolor} "> <h1>welcome to the ${param.department} Department</h1> Here are some basic comparisons:<p> Is 1 less than 2? ${1<2} <br> Does 5 equal 5? ${5==5} <br> Is 6 greater than 7? ${6 gt 7} <br> <p>now for some math:<br> 6 + 7 = ${6+7} <br> 8 x 9 = ${8*9} <br> <hr>you appear to be using the following browser: ${header["user-agent"]} </body> </html> Beans Um Bean, no contexto de uma JSP, consiste essencialmente num objecto Java normalíssimo, que apresenta um conjunto de atributos e métodos get e set para cada um deles. Inclui-se na página com recurso à directiva usebean. As directivas set e getproperty permitem alterar e obter os valores do objecto. Em alternativa, podemos usar a EL para aceder às propriedades de um objecto. Os JavaBeans são utilizados essencialmente para recolher dados dos forms, passar esses dados aos elementos do modelo de negócio que os vão processar. São também usados na produção dos resultados a apresentar ao cliente no sentido de que os módulos aplicacionais, uma vez terminado o processamento, preenchem os devidos beans com informação que depois é retirada dos mesmos para ser vista na página de resultado. Exemplo de um bean que representa uma pessoa: public class Person { private String name; private String password; public String getname(){ return name;} public void setname(string s){name = s;} public String getpassword(){return password;} public void setpassword(string s){password = s;} } 2005 ESTSetúbal Susana Cabaço - Computação na Internet 2005/2006 Página 15/18

Exemplo que combina numa JSP a utilização de um Bean Java com a EL: <html> <head> <title>expression Language Accessing Objects</title> <%-- create a single Person object --%> <jsp:usebean id="man" class="person"> <jsp:setproperty name="man" property="name" value="nick"/> <jsp:setproperty name="man" property="password" value="pass"/> </jsp:usebean> The person is called ${man.name}. The password is ${man.password}. </body> </html> JSTL JSTL significa JSP Standard Tag Library e consiste essencialmente, num conjunto de tags, que oferecem controle sobre o processamento das páginas sem aumento de complexidade. Permitem substituir os scriptlets e assim estimular a separação entre apresentação e lógica, resultando num investimento significativo no sentido de conseguir seguir o modelo MVC. Como usar: 1. Fazer o download da última versão do site da Sun 2. Copiar os JARs das bibliotecas desejadas para o directório WEB-INF/lib/ da sua aplicação Web e os arquivos TLD para o directório WEB-INF/ 3. Declarar cada taglib e associá-la com seu TLD no deployment descriptor web.xml. 4. Incluir em cada página que usa as marcas: <%@ taglib uri="uri_da_taglib prefix="prefixo" %> 5. Usar as marcas da biblioteca com o prefixo definido no passo anterior <prefixo:nometag atributo="...">... </prefixo:nometag> 2005 ESTSetúbal Susana Cabaço - Computação na Internet 2005/2006 Página 16/18

Existem quatro bibliotecas de Marcas JSTL: Core library: tags para condicionais, iterações, urls,...: <%@taglib uri="http://java.sun.com/jstl/ea/core" prefix="c" /> Exemplo: <c:if test="..."... >...</c:if> XML library: tags para processamento XML: <%@taglib uri="http://java.sun.com/jstl/ea/xml" prefix="x" /> Exemplo: <x:parse>...</x:parse> Internationalization library: <%@ taglib uri="http://java.sun.com/jstl/ea/fmt" prefix="fmt" /> Exemplo: <fmt:message key="..." /> SQL library: <%@ taglib uri="http://java.sun.com/jstl/ea/sql" prefix="sql" /> Exemplo: <sql:update>...</sql:update> Ao longo deste trabalho, tal como no projecto, vamo-nos focar essencialmente na Core Library. Exemplo de uma JSP que processa tags JSTL (com utilização de um JavaBean): <%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %> <jsp:usebean id="person" scope="session" class="com.conygre.jspdevhandbook.chapter5.person" /> <jsp:setproperty name="person" property="*" /> <html> <head><title>chapter 5 - Display details</title></head> <body> <h1>your details (or, the details you entered!)</h1> <table> <tr> <td>first name</td> <td><c:out value="${person.firstname}" /></td> </tr> <tr> <td>last name</td> 2005 ESTSetúbal Susana Cabaço - Computação na Internet 2005/2006 Página 17/18

<td><c:out value="${person.lastname}" /></td> </tr> <tr> <td>age</td> <td><c:out value="${person.age}" /> </td></tr> </table> </body> </html> Trabalho de Laboratório: O que se pretende neste trabalho de laboratório é que, da mesma forma que já transformaram a geração da vossa página xhtml simples por forma a ser efectuada por uma servlet, o façam agora através de uma JSP. 1. Definir o cabeçalho e o rodapé da página em ficheiros separados que devem ser incluídos na página principal de forma declarativa, com recurso ao ficheiro web.xml. 2. Transformar o vosso código da página original para passar a ser gerado por uma JSP 3. Criar um conjunto de objectos java a serem utilizados na página como beans que são usados para recolher os dados submetidos e para mostrar, nas páginas seguintes, os resultados do processamento 4. Numa primeira fase, o processamento dos dados na vossa página poderá ser efectuado com recurso a scriptlets Java. 5. Na fase seguinte: a. Passar a implementar as mesmas JSPs com recurso à expression language por forma a evitar a utilização de scriptlets e seguir o modelo MVC b. A página de resultado, igual à que anteriormente geravam para mostrar os dados preenchidos no form pelo utilizador, deve agora ser alterada por forma a que seja uma JSP e que recorra às taglibs JSTL disponíveis para processar uma lista de valores e apresentar o mesmo resultado que apresentavam antes. Devem igualmente recorrer à EL. 2005 ESTSetúbal Susana Cabaço - Computação na Internet 2005/2006 Página 18/18