Laboratório 8 JSP s, EL, JSTL

(1)

Computação na Internet 2005/2006

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.

(2)

Computação na Internet 2005/2006

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): • <% ... %>

(3)

Computação na Internet 2005/2006

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

(4)

Computação na Internet 2005/2006

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

(5)

Computação na Internet 2005/2006

A directiva page pode ter os seguintes atributos:

• 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)

Exemplo: <%@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>

(6)

Computação na Internet 2005/2006

A directiva include pode exemplificar-se da seguinte forma: <HTML>

<HEAD><TITLE>Exemplo da directiva include</TITLE></HEAD> <BODY>

<%@ include file =”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: <%!

(7)

Computação na Internet 2005/2006

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:

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

(8)

Computação na Internet 2005/2006

Acção Descrição

<jsp:include> 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

<jsp:forward> 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.

<jsp:plugin> 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

<jsp:param> 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

<jsp:useBean> Associa uma instância de um JavaBean, definido com um determinada abragencia e icom um id.

<jsp:setProperty> 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.

<jsp:getProperty> 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

(9)

Computação na Internet 2005/2006

• Objectos contextuais a. session b. application c. pageContext • Controle de excepções a. Exception

Estes objectos são representados pelas seguintes APIs: Objeto

Objeto Objeto

Objeto Classe ou InterfaceClasse ou Interface Classe ou InterfaceClasse ou Interface DescriçãoDescriçãoDescriçãoDescrição page

page page

page javax.servlet.jsp.HttpJspPage Instância de servlet da

página

config config config

config javax.servlet.ServletConfig Dados de configuração do

servlet request request request request javax.servlet.http.HttpServletReq uest Dados de solicitação, incluindo parâmetros response response response response javax.servlet.http.HttpServletRes ponse Dados da resposta out out out

out javax.servlet.jsp.JspWriter Fluxo de saída para o

conteúdo da página

session session session

session javax.servlet.http.HttpSession Dados de sessão específicos

do utilizador

application application application

application javax.servlet.ServletContext Dados partilhados por todas

as páginas de aplicação pageContex pageContex pageContex pageContex t tt t

javax.servlet.jsp.PageContext Dados de contexto para execução da página

exception exception exception

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");

(10)

Computação na Internet 2005/2006

%>

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

Controller

Model

View

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):

(11)

Computação na Internet 2005/2006

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

(12)

Computação na Internet 2005/2006

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 {

(13)

Computação na Internet 2005/2006

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/scoped-vars.jsp"); dispatcher.forward(request, response); } } JSP a processar: <!DOCTYPE …> …

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

(14)

Computação na Internet 2005/2006

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

session-scoped 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

(15)

Computação na Internet 2005/2006

Exemplo de aplicação numa JSP:

<html> <head> <title>Expression Language Examples</title> <% pageContext.setAttribute("pageColor", "yellow"); %> </head>

<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;} }

(16)

Computação na Internet 2005/2006

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>

(17)

Computação na Internet 2005/2006

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>

(18)

Computação na Internet 2005/2006

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.