Java Server Pages

JavaServer Pages Basicamente JavaServer Pages (JSP), são páginas Web que contém código

Java

Este código é executado no servidor, antes da resposta ser devolvida ao Browser

A tecnologia JSP é utilizada para a geração dinâmica de código HTML A tecnologia JSP é utilizada para a geração dinâmica de código HTML.

JSP é uma extensão dos Servlets Java

Um documento JSP deve finalizar com a extensão ".jsp" (.jspx)

A tecnologia faz um encapsulamento dos servlets, permitindo que o código HMTL e o código Java possam coexistir de uma maneira harmônica

Desta forma é possível que Web Designers possam utilizar a linguagem Java de forma sutil.

Uma página JSP é um documento texto que descreve como processar um pedido

Programação para InternetFlávio de Oliveira Silva, M.Sc.

p g q p p(request) a fim de criar uma resposta (response)

137

JavaServer Pages Em linha gerais a tecnologia Servlet, permite que o código HTML será

inserido no código Java

A tecnologia JSP permite que o código Java seja inserido no HTML a fim de ser processado pelo Servidorde ser processado pelo Servidor

Exemplo de código JSP (hello.jsp)<HTML>

<BODY>

<% out.println("HELLO JSP WORLD!"); %>

</BODY>

</HTML>


Quando o browser solicita a página JSP, o servidor, que deve ser um Web Contêiner, realizará algumas operações especiais, antes de devolver a resposta.

138

JavaServer PagesProcesso Execução

1. Inicialmente uma página JSP é solicitada pelo Navegador (hello.jsp)

2. O contêiner de Servlets/JSP recupera a página. Caso seja a primeira vez que a mesma é carregada um servlet é gerado (hello_jsp.java).

3. Em seguida o servlet é compilado (hello_jsp.class)

4. O servlet então é executado e o código HTML é então produzido

5. Finalmente a resposta é enviada ao navegador

6. Caso o servlet já exista e a página JSP não tenha sido modificada, o processo é abreviado e consiste apenas em executar o servlet e devolver a resposta ao navegador


139

JavaServerPagesGeração do Código No eclipse o código é gerado na seguinte pasta:

\workspace\.metadata\.plugins\org.eclipse.wst.server.core\tmp0\work\Catalina\localhost

No Tomcat o código é gerado na seguinte pasta: No Tomcat o código é gerado na seguinte pasta: \tomcat\work\Catalina\localhost


140

JavaServer Pages Uma página JSP contém dois tipos de elementos

Elementos Template Parte estática de uma página WEB

Pode ser escrito utilizando HTML, texto; WML; XML

Em linhas gerais é tudo aquilo que existe na página e que não é elemento JSP

Elementos JSP Scripts

Diretivas

Page


Include

Taglib

Ações Padrão

Ações Personalizadas (Tag Extension)

JSTL

141

JavaServer PagesScripts Script é um mecanismo através do qual é possível a adição de pequenas

partes de código (normalmente Java) em uma página JSP

Uma página JSP não deve conter apenas Scripts, pois acaba transformando se em código Java dificultando desta forma atransformando-se em código Java, dificultando desta forma a manutenção da mesma

A adição do código Java pode ser feita utilizando uma sintaxe própria.

Os elementos para a criação dos scripts podem indicar: Scriplets (Código Java)

Declarações

Expressões


Comentários

Linguagem de Expressões (JSP EL)

142

Scripts - Sintaxe Sintaxe básica da linguagem JSP

ELEMENTO DESCRIÇÃO

<% ... %> Utilizado para inserir CÓDIGO Java em uma página JSP

<%= ... %> Utilizado para inserir EXPRESSÕES. O resultado da

expressão é adicionado à página de resposta. Também utilizado para indicar atributos de ações durante que serão enviados com o pedido

<%! ... %> Utilizado para inserir DECLARAÇÕES. Desta foram é possível declarar

variáveis de instância e métodos na classe que implementará a página JSP

<% %>Utilizado para inserir COMENTÁRIOS. Permite remover um bloco de código


143

<%‐‐... ‐‐%>p g

JSP

${...} Utilizado pela Linguagem de Expressões JSP (JSP EL) Permite uma nova

forma para escrita e uso de expressões em uma página JSP

Scriplets – ExemploCódigo Java A parte relativa ao código java está dentro dos elementos Scriptlets

Dentro dos elementos é necessário código java

Qualquer código HTML que será visto na página deverá ser colocado fora do elementos de Scriptletselementos de Scriptlets

O texto que não está entre os elementos <% %> pode ser lido como out.write(texto);<html>

<head>

<title>Utilizando Java em uma Página JSP</title>

</head>

<body>

% f (i t i 0 i 5 i ) { %


<% for (int i=0; i<5;i++) { %>

<h1>Repetido 5 Vezes.<h1>

<% } %>

</body>

</html>

144

Scriplets – Exemplo 2Código Java

<html>

<body>

Good

<%

java.util.Calendar currTime = new java.util.GregorianCalendar();java.util.Calendar currTime new java.util.GregorianCalendar();

if (currTime.get(currTime.HOUR_OF_DAY) < 12)

{

%> Morning!

<%

}

else if (currTime.get(currTime.HOUR_OF_DAY) < 18)

{

%> Afternoon!

<%

}


else

{

%> Evening!

<%

}

%>

</body>

</html>

145

JSP - Expressões Exemplo Expressões JSP são elementos que inicialmente são avaliados (executados) pelo

contêiner

O resultado da expressão é então inserido na página JSP, no local onde havia anteriormente a expressãoanteriormente a expressão

O resultado da expressão é sempre convertido em String, caso isto não seja possível ocorrerá um erro.<% java.util.Calendar currDate = new java.util.GregorianCalendar();

int month = currDate.get(currDate.MONTH)+1;

int day = currDate.get(currDate.DAY_OF_MONTH);

int year = currDate.get(currDate.YEAR);

%>

<html>


<html>

<body>

<h1>A Data Atual é: <%= month %>/<%= day %>/<%= year %> </h1>

</body>

</html>

146

JSP - Expressões Exemplo 2 Com as expressões é possível acessar variáveis e utilizar métodos

<%

String Stime;

java.util.Calendar currTime = new java.util.GregorianCalendar();

if (currTime.get(currTime.HOUR_OF_DAY) < 12){

Stime = "Morning!";

} else

if (currTime.get(currTime.HOUR_OF_DAY) < 18) {

Stime = "Afternoon!";

}

else {

Stime = "Evening!";

}


%>

<html>

<body>

Good <%= Stime %>

</body>

</html>

147

JSP - ComentáriosExemplo Os comentários podem ser feitos utilizando recursos de HTML; da linguagem Java ou

elementos JSP <% %>

Os elementos comentários feitos com elementos JSP não aparecerão no código do Servlet gerado para a página JSP<html>

<body>

<h1> COMENTÁRIOS - JSP <h1>



<% //Esta linha aparecerá no código do Servlet gerado para a página JSP. %>

<% /* %>

Este bloco está comentando...

Este texto aparecerá no código do Servlet gerado para a página JSP.

<% */ %>

<%-- Esta linha não aparecerá no código do Servlet. --%>

<%--


<%

<%

out.println("Este bloco não será visto no código Java gerado.");

%>

--%>

<body>

<html>

148

Objetos Implícitos – JSPScripts Utilizados em Scripts (Scriplets) JSP

Nome Objeto

Classe Descrição Escopo

R d S l iapplication javax.servlet.ServletContext

Representa o contexto do Servlet existente no Contêiner

Aplicação

session javax.servlet.http.HttpSession

Cria um ambiente que permite a troca de informações entre diferentes iterações do tipo pedido/resposta entre o cliente o servidor web.

Somente válida para o protocolo HTTP

Sessão

request javax.servlet.http.HttpServletRequest(depende do protocolo ‐Ex: HTTP)

Representa o pedido feito pelo cliente Pedido

response javax.servlet.http.HttpServletResponse

(depende do protocolo ‐Ex: HTTP) Representa a resposta que será enviada ao cliente Página

Representa o contexto de uma página, incluindo


149

pageContext javax.servlet.jsp.PageContext p p g ,todos os outros objetos implícitos, métodos e

recursos da página Web Página

out javax.servlet.jsp.JspWriter Representa a stream da saída padrão Página

config javax.servlet.ServletConfig Representa a configuração do Servlet responsável

pela criação da página JSP Página

page java.lang.ObjectRepresenta a instância da página. Seu sinônimo é a

palavra this para uso nos Scripts Página

Objetos Implícitosout - Exemplo Não é necessário definir o objeto out, visto que o mesmo é declarado e

inicializado, de forma implícita, no momento da geração do código da página JSP

Exemplo de código JSP (hello jsp) Exemplo de código JSP (hello.jsp)<HTML>

<BODY>

<% out.println("HELLO JSP WORLD!"); %>

</BODY>

</HTML>


150

Objeto Implícitorequest – Exemplo No exemplo abaixo dois parâmetros são enviados – firstName e

lastName.

Os mesmos são obtidos utilizando o objeto implícito param//<% // Recupera os parâmetros

String firstName = request.getParameter("firstName");

String lastName = request.getParameter("lastName");

%>

<html>

<body>

<h1>Olá <%=firstName%> <%=lastName%>!</h1>


<h1>Olá <%=firstName%> <%=lastName%>!</h1>

<p>Seja bem vindo ao nosso site!</p>

</body>

</html>

151

Objeto sessionExemplo utilizando Scriplet<html>

<head>

<title>Sessão - Exemplo</title>

</head>

<body>

<%

//Verifica se já existe atributo chamado "COUNT" nesta sessão

Integer count = (Integer)session.getAttribute("COUNT");

if ( count == null ) {

// Caso não exista, um objeto é criado e adicionado à sessão

count = new Integer(1);

session.setAttribute("COUNT", count);

}

else {

// Caso exista, o seu valor é incrementado e atualizado na sessão.

count = new Integer(count intValue() + 1);


count = new Integer(count.intValue() + 1);

session.setAttribute("COUNT", count);

}

out.println("<b>Esta página foi acessada: " + count + " vezes nesta sessão.</b>");

%>

</body>

</html>

152

Linguagem de ExpressõesJSP EL A especificação JSP 2.0 oferece uma linguagem de expressões (JSP

Expresssion Language – JSP EL)

A JSL EL utiliza os delimitadores ${...}

Dentro destes delimitadores é possível uma série facilidades como: Avaliar (executar) expressões lógicas, relacionais e aritméticas

Acessar métodos de objetos

A JSP EL facilita a escrita de páginas JSP e além disso é possível criar páginas sem os elementos Scriplets (<%...%>), Declarações (<%!...%>) e Expressões (<%=...%>), vistos anteriormente.

Exemplo:


153

SINTAXE TRADICIONAL SINTAXE USANDO JSP EL

request.getAttribute("nome") ; ${nome}

gerente.getPessoa().getNome(); ${gerente.getPessoa.nome}

JSP / JSP ELObjetos Implícitos A JSP EL realiza o acesso a vários objetos que estão implicitamente disponíveis

em uma página JSP

Estes objetos são automaticamente declarados em uma página JSP e estão disponíveis para pelos elementos definidos pela JSPdisponíveis para pelos elementos definidos pela JSP

Desta forma pode-se fazer uso do mesmos diretamente no código sem que seja necessária a sua declaração

Certos objetos são de uso próprio pela JSP EL e certos são compartilhados entre os scripts JSP e as expressões definidas pela JSP EL

Cada objeto possui um escopo próprio, indicando o tempo de duração dos objetos, variáveis e atributos

Escopos


Página (PAGE_SCOPE)

Pedido (REQUEST_SCOPE)

Sessão (SESSION_SCOPE)

Aplicação (APPLICATION_SCOPE)

154

JSP / JSP ELObjetos Implícitos - Escopo Página (PAGE_SCOPE)

Objetos com este escopo são acessíveis somente na página em que foram criados.

Todas as referências são destruídas após o envio da resposta ao cliente pela página JSP ou então caso o pedido seja encaminhado para outro localp j p

Pedido (REQUEST_SCOPE) Objetos com este escopo são acessíveis no momento em que o processamento do

pedido é feito. Assim que o pedido é processado as referências para os objetos são destruídos

Caso o pedido seja encaminhado (forwarded) para uma outra página dentro da mesma aplicação os objetos com este escopo podem ser acessados

Sessão (SESSION_SCOPE) Objetos com este escopo são acessíveis por várias diferentes páginas, deste que


tenha sido criadas por uma mesma sessão.

Todas as referências para os objetos são destruídas após ao final da sessão.

Aplicação (APPLICATION_SCOPE) Objetos com este escopo são acessíveis por todos os servlets (e páginas JSP) que

estão em uma mesma aplicação, mesmo que não exista uma sessão.

Objetos possui o mesmo tempo de vida que o objeto ServletContext

155

JSP EL - Variáveis A linguagem JSP EL permite o acesso direto a qualquer variável

armazenada nos vários escopos (Page, Request, Session, Application)

Desta forma a expressão ${product} equivale à seguinte linha de código:

<% pageContext.findAttribute("product"); %>

A procura é feita na seguinte ordem de escopo: 1. Page

2. Request

3. Session

4. Application

A primeira instância encontrada é retornada


156

JSP EL - Operadores Aritméticos

+ adição

- subtração

* multiplicação multiplicação

/ divisão (div)

% módulo(mod)

Lógicos and

or

not

Relacionais


==

!=

< (lt)

> (gt)

<= (lte)

>= (gte)

157

JSP EL - Operadores Empty (Vazio)

Retorna verdadeiro caso um elemento seja nulo ou vazio

Caso um objeto do tipo Map; Collection; array é vazio ou seja não possui elementos

Caso Uma String seja nula ou vazia (comprimento = 0) Caso Uma String seja nula ou vazia (comprimento 0)

Exemplo: ${empty user}

Condicional Avalia (executa a expressão) B ou C, dependendo do resultado da avaliação de A (A ?

B : C)

bool-expr ? true-expr : false-expr

Exemplo: ${numItems != 0 ? sum/numItems : 0}

Equivale a

if (b lE ) { t t E }


if (boolExpr) { return trueExpr; }

else { return falseExpr; }

158

JSP EL – OperadoresPrecedência Da esquerda para a direita, de cima para baixo:

[] .

()

( á i ) t ! E t - (unário) not ! Empty

* / div % mod

+ - (binário)

< > <= >= lt gt le ge

== != eq ne

&& and

|| or

?


? :

159

Objetos Implícitos – JSP EL Os objetos obtidos são da classe java.util.map

O mapa contém pares de valores do tipo (key, value)

Nome Objeto DescriçãoRepresenta o contexto de uma página incluindo todos os outros objetos implícitos métodos

pageContextRepresenta o contexto de uma página, incluindo todos os outros objetos implícitos, métodos

e recursos da página Web requestScope Um mapa (map) que o nome dos atributos existentes no pedido e seus valores pageScope Um mapa (map) que o nome dos atributos existentes na página e seus valores sessionScope Um mapa (map) que o nome dos atributos existentes em uma sessão e seus valores

applicationScope Um mapa (map) que o nome dos atributos existentes em uma aplicação e seus valores

param Uma mapa que contém um parâmetro utilizado pela Página. Equivale ao método:

ServletRequest.getParameter(String name)

paramValues Uma mapa que contém todos os valores de um dado parâmetro utilizado pela Página.

Equivale ao método: ServletRequest.getParameterValues(String name)

h dUma mapa que contém todos os nomes dos headers em uma página. Equivale ao método:


160

header p q p g q

HttpServletRequest.getHeader(String name)

headerValues Uma mapa que contém o nome de um header e um String[] com seus seus valores. Equivale

ao método: HttpServletRequest.getHeaders(String name)

cookie Um mapa que contém os parametros e valores de um único cookie. Equivale ao método:

HttpServletRequest.getCookies()

initParam Um map com os parâmetros de inicialização do contexto, juntamente com seus valores.

Equivale ao método: ServletContext.getInitParameter(String name)

Objetos Implícitos – JSP EL A partir do objeto pageContext existente na JSP EL é possível acessar os

outros objetos implícitos existentes na linguagem JSP (request; response; session; application; out; config; page)

A linguagem apresenta os operadores e [] que permite o acesso a A linguagem apresenta os operadores . e [] que permite o acesso a métodos e atributos de objetos

Para acessar os atributos de um objeto (bean) pode ser utilizada a seguinte sintaxe: person.name (linguage java - person.getName();)

O operador [] permite o acesso ao dicionários (java.util.Map e java.util.Hashtable) da seguinte forma:

table["person"] (linguagem java - table.get("person“)


Este operadores são intercambiáveis e é possível a seguinte utilização:

person.name == person["name"]

161

Objeto param – JSP ELExemplo No exemplo abaixo dois parâmetros são enviados – firstName e lastName.

Os mesmos são obtidos utilizando a JSP EL

Operador .<html>

<body>

<h1>Olá ${param.firstName} ${param.lastName}!</h1>


</body>

</html>

No caso de parâmetros a sintaxe do operador . apresenta uma diferença e neste caso o nome do parâmetro deve ser fornecido como uma String (" ")


neste caso o nome do parâmetro deve ser fornecido como uma String ( )<html>

<body>

<h1>Olá ${param["firstName"]} ${param["lastName"]}!</h1>


</body>

</html>162

JSP Diretivas Diretivas são mensagens para o contêiner de Servlets e JSP

As diretivas possuem a seguinte sintaxe:

<%@ directiveName {attribute="value"} %>

As diretivas afetam a página de maneira global As diretivas afetam a página de maneira global

Existem três diferentes tipos de diretivas

page Permite a configuração da linguagem JSP

include Utilizada para inserir texto e/ou código JSP em tempo de compilação

taglibJSP i it t ã d d (t )


JSP possuem um mecanismo que permite a extensão dos marcadores (tags) utilizados pela linguagem.

Cada marcador (tag) possui um código java associado ao mesmo, desta forma, ocorre uma separação entre o código JSP e a linguagem Java

Os arquivos contendo marcadores são conhecidos como Tag Libraries (bibliotecas de Tags)

163

Diretiva - page Define uma série de parâmetros que afeta uma página JSP

Uma página pode possuir várias diretivas page

Possui a seguinte sintaxe: <%@ page {attribute ="value"} %>

O valor attribute possui os seguintes valores: O valor attribute, possui os seguintes valores: language="scriptingLanguage"

pageEncoding – (IANA – Character Sets)

isELIgnored="true | false"

extends="className"

import="importList"

session="true | false"

buffer="none | size in kb"


autoFlush="true | false"

isThreadSafe="true | false"

info="text"

errorPage="error_url"

isErrorPage="true | false"

contentType="ctinfo" (IANA – MIME Media Types)

164

Diretiva – page - AtributosATRIBUTO DEFINIÇÃO

language="scriptingLanguage"Indica qual a linguagem será utilizada para compilar o arquivo JSP. A única linguagem atualmente

disponível é Java.

pageEncodingIndica o conjunto de caracteres que será utilizado na página JSP. O valor padrão é "ISO‐8859‐1".

Deve ser um valor válido definido pela IANA

d d b l l d ( )isELIgnored Permite desabilitar ou não a linguagem de expressões JSP (JSP EL)

extends="className" Define uma classe pai que a página JSP estenderá. Deve‐se utilizar o nome completo da classe

import="importList" Indica uma lista de classes que pode ser importada para a página JSP. Semelhante ao #import da linguagem Java. O seguinte pacotes são importados automaticamente: java.lang.*, javax.servlet.*;

javax.servlet.jsp.*; javax.servlet.http.*

session="true | false"Indica se a página utilizará o objeto Sessão. O valor default é true. Caso o atributo seja false então

não é possível utilizar sessões com a determinada página

buffer="none | size in kb" Indica o tamanho máximo do buffer de saída (out). O valor default é 8 KB

autoFlush="true | false"Indica se o buffer será esvaziado. O valor default é true. Caso o buffer fique cheio uma exceção

será disparada

isThreadSafe="true | false"Indica que uma mesma página pode receber múltiplas requisições simultâneas. O valor default é true Caso false seja utilizado então a página poderá ser requisitada por um único usuário de cada


isThreadSafe= true | false true. Caso false seja utilizado então a página poderá ser requisitada por um único usuário de cada vez.

info="text"Representa uma informação sobre a página que pode ser acessado através do método

Servlet.getServletInfo()

errorPage="error_url"Indica que a página é uma página de erro e que pode ser utilizada para tal por outra página JSP. O

padrão é false. Em caso de true um objeto implícito exception é declarado para a página

isErrorPage="true | false" Indica que a página é uma página de erro. O padrão é false

contentType="ctinfo" Representa o tipo MIME e o conjunto de caracteres da resposta enviada ao cliente

165

Diretiva – page - Exemplos <%@ page info="Página Inicial" %>

<%@page pageEncoding="UTF-8"%>

<%@ page contentType="text/xml" %>

<%@ page contentType="text/html:charset=ISO 8859 1" %> <%@ page contentType="text/html:charset=ISO-8859-1" %>

<%@ page language="java" %>

<%@ page import="java.sql.*" %>

<%@ page import="java.sql.*,java.util.*" %>

<%@ page session="true" %>

<%@ page buffer="16" %>

<%@ page buffer="16kb" %>

<%@ i Th dS f "f l " %>


<%@ page isThreadSafe="false" %>

<%@ page errorPage="handleError.jsp" %>

<%@ page isErrorPage="true" %>

<%@ page extends="JSPSuperclass"%>

166

Diretiva - include Permite a inclusão de texto no momento em que a página é gerada

A diretiva include é utilizada para adicionar conteúdo estático à página JSP

Através desta diretiva é possível dividir o código de uma página em vários componentes que são agregados de acordo com o necessáriocomponentes que são agregados de acordo com o necessário

Utiliza a seguinte sintaxe:

<%@ include file="relativeURLspec" %>

Exemplo: <%@ include file="copyright.html" %>

Para adicionar conteúdo dinâmico (e também para estático) deve ser utilizada a ação padrão <jsp:include>. Desta forma esta ação deverá ser utilizada para incluir uma página JSP em outra.

Esta ação possui a seguinte sintaxe:


ç p g

<jsp:include page="includedFileName" flush="true"/> O atributo flush indica se o buffer de saída deve ser esvaziado antes da inclusão ou

não. Seu valor padrão é false

167

Diretiva - taglib Esta diretiva permite estender o conjunto de marcadores (tag) que é

interpretado pelo contêiner de servlets/JSP. Desta forma novas ações podem ser criadas.

O conceito é separar o código Java da criação da página Desta forma O conceito é separar o código Java da criação da página. Desta forma cada tag que se parece com um marcador HTML ou XML, na realidade contém um código Java associado ao mesmo.

Para que o contêiner possa interpretar corretamente as tags é necessário informar a localização de uma arquivo que descreve cada uma destas tags (tag library)

Desta forma a diretiva carrega o arquivo que fica então disponível para uso na página JSP


uso na página JSP

168

Diretiva - taglib Utiliza a seguinte sintaxe:

<%@ tablib prefix="prefixName" uri="tagLibraryURI" %>

Exemplo:

<%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %>

O prefixo deve ser único em uma página JSP pois será utilizado como uma referência para a tag library incluída naquela página.

Na página JSP qualquer tag existente na tag library, incluída, poderá ser acessada da seguinte forma:

<c:tagName>


...

</c:tagName>

169

Diretiva – taglib Para utilizar uma tag library é necessário configurar a mesma no contexto no

contêiner de Servlets/JSP

Para isto é necessário: Criar uma pasta tld, dentro da pasta WEB-INF. Criar uma pasta tld, dentro da pasta WEB INF.

Nesta pasta deve ser colocado o arquivo TLD (Tag Library Descriptor - tldFileName) que descreve a tab libray (versão; descrição; etc.) e cada uma das tags (nome, parâmetros, classe java)

Na pasta lib, existente dentro da pasta WEB-INF, deve ser colocado os aqruivos.class e/ou .jar que contém a implementação de cada tag.

Caso este arquivo possua dependências que não estejam disponíveis é necessário que os mesmos sejam também colocados na pasta lib

Finalmente é necessário colocar no arquivo WEB.XML as informações sobre a taglib di í l li ã d i t f


library disponível para aplicação da seguinte forma:<taglib>

<taglib-uri>http://java.sun.com/jstl/core</taglib-uri>

<taglib-location>/WEB-INF/tld/tldFileName.tld</taglib-location>

</taglib>

170

JSP – Ações Padrão Ação padrão são tags (marcadores) pré-definidos que são utilizados para

encapsular um código Java.

Estas tags ao serem adicionadas à página, incluem algum comportamento padrão definido pela tagcomportamento padrão, definido, pela tag.

As ações são escritas classes Java existentes no contêiner de Servlets/JSP.

Todas as ações padrão começam com o prefixo jsp <jsp:actionName ...

Estas ações são externas ao Servlet criado e são realizadas em tempo de execução.


171

Ações Padrão – jsp:include Permite a inclusão de conteúdo dinâmico/estático em tempo de execução

Possui a seguinte sintaxe:

<jsp:include page="urlSpec" flush="true|false"/>

ou entãoou então

<jsp:include page="urlSpec" flush="true|false">

<jsp:param name="name" value="value" />

</jsp:include>

O valor "urlSpec" é relativo ao contexto da aplicação, ou seja, a partir da raiz da aplicação.

É possível enviar parâmetros juntamente com a operação de inclusão, utilizando a ação padrão <jsp:param, conforme mostrado acima


a ação padrão jsp:param, conforme mostrado acima

O parâmetro pode ser obtido de duas formas:<% ... request.getParameter("name"); %> //usando Scripts${param["name"]} //usando JSP EL

${param.name} //usando JSP EL

172

Ações Padrão – jsp:forward Permite transferir a requisição para outra página ao invés de retornar para a

origem

A requisição pode ser encaminhada para outra página JSP ou então para um ServletServlet

Este recurso pode ser utilizado para escolher entre várias possíveis repostas e então a requisição é encaminhada para a página JSP ou Servlet que tratarão a requisição incial.


<jsp:forward page="destinationPage"/>

ou então

<jsp:forward page="destinationPage">


<jsp:param name="name" value="value" />

</jsp:include>

O valor "urlSpec" é relativo ao contexto da aplicação, ou seja, a partir da raiz da aplicação.

173

Ações Padrão – jsp:forward Permite transferir a requisição para outra página ao invés de retornar para a

origem

A requisição pode ser encaminhada para outra página JSP ou então para um Servlet

Este recurso pode ser utilizado para escolher entre várias possíveis repostas e então a requisição é encaminhada para a página JSP ou Servlet que tratarão a requisição inicial.


<jsp:forward page="destinationPage"/>

ou então

<jsp:forward page="destinationPage">

/


jsp:param name="name" value="value" />

</jsp:include>

Exemplo:<% String whereTo = "/templates/"+someValue; %>

<jsp:forward page="<%= whereTo %>" />

<jsp:forward page="${whereTo}" />

174

jsp:forward – Usando Scripts<html>

<body>

<%

if ( (request.getParameter("perfil")).equals("professor") ) {q g p q p

%>

<jsp:forward page="professor.jsp">

<jsp:param name="user" value='<%=request.getParameter("user")%>'/>

</jsp:forward>

<%

}

else { %>

<jsp:forward page="aluno.jsp">


<jsp:forward page aluno.jsp >

<jsp:param name="user" value='<%=request.getParameter("user")%>'/>

</jsp:forward>

<%} %>

</body>

</html>

175

jsp:forward – Usando JSP EL<html>

<body>

<%

if ((request getParameter("perfil")) equals("professor")){if ((request.getParameter("perfil")).equals("professor")){

%>


<jsp:param name="user" value='${param["user"] }'/>

</jsp:forward>

<% }

else { %>

<j f d " l j ">



<jsp:param name="user" value='${param["user"]}'/>

</jsp:forward>

<% } %>

</body>

</html>176

JavaBeans JavaBean é um componente de software reutilizável criado segundo a especificação

JavaBeans. Pode-se dizer que JavaBean é uma classe Java que construída segundo um padrão pré-definido.

No geral um JavaBean deve satisfazer os seguintes requisitos:

Implementar a interface java.io.Serializable

Possuir um construtor padrão, que não recebe nenhum argumento

Possuir propriedades (atributos) que podem estar disponíveis para leitura/escrita; somente leitura ou somente escrita

A leitura (acesso) às suas propriedades é feita através de métodos getters (getXXX) que devem possuir a seguinte sintaxe:

PropertyClass propName;

PropertyClass getPropName();

A it ( difi ã ) d i d d é f it t é d ét d tt


A escrita (modificação) de suas propriedades é feita através de métodos setters (setXXX) que devem possui a seguinte sintaxe:

PropertyClass propName;

setPropName(PropertyClass propNewValue)

Deve estar contido em um pacote, logo é necessário que exista no seu código a seguinte expressão: package PackageName;

177

JavaBeans Através dos JavaBeans é possível encapsular dados recebidos de outras

partes da aplicação

Estes dados podem então ser repassados entre páginas JSP e Servlets usando Scripts JSP ou então utilizando a JSP ELusando Scripts JSP ou então utilizando a JSP EL

Podem ser usados com JSP para remover grande parte do código Java de uma página JSP

O conceito de JavaBeans engloba outros aspectos não relacionados porém o desenvolvimento aplicações Servlets/JSP


178

JavaBean - Exemplopackage model;

public class User implements java.io.Serializable {

private String name;

private String password;p g p

public User(){

this.name = "";

this.password = "";

}

public String getName(){ return this.name; }

public String getPassword(){ return this.password; }

public setName(String n){

name=n;


name n;

}

public setPassword(String p){

password=p;

}

}

179

JavaBean – Ações JSP JSP possui algumas ações que permitem a manipulação deJavaBeans

jsp:useBean

jsp:getProperty

j tP t jsp:setProperty

Através destas ações é possível Criar Novos objetos (beans)

Acessar os valores de suas propriedades

Modificar as propriedades armanazenadas em um JavaBean

Podem ser usados com JSP para remover grande parte do código Java de uma página JSP


180

jsp:useBean Permite adicionar uma instância de um objeto (JavaBean) a uma página JSP


<jsp:useBean id="name" scope= "scopeValue" class= "className" />

O valor id deve ser único em uma página JSP A partir deste valor é possível O valor id deve ser único em uma página JSP. A partir deste valor é possível acessar o objeto. Ao indicar um nome para o bean, o contêiner procurar por este nome e caso não encontre um novo bean é criado

O escopo indica o tempo de duração do bean. É possível utilizar os seguintes valores para o escopo:page; request; session; application.

O escopo padrão é o escopo "page"

O valor className indica no nome da classe Java que implementa o bean. Deve conter o nome completo da mesma a partir da pasta /WEB-INF/Classes


(myPackage.ClassName)

Além disso esta ação criar uma variável que fica disponível para os Scripts JSP

Exemplo: <jsp:useBean id="myBean" class="model.User"/>

181

jsp:getProperty Permite acessar as propriedades de um bean.

Além disso o valor da propriedade acessada é então convertido para String e colocado na saída padrão(out) a fim de ser impresso em uma página

Utiliza a seguinte sintaxe: Utiliza a seguinte sintaxe:

<jsp:getProperty name="beanId" property="propertyName"/>

O valor beanId equivale a um bean, válido e existente

Indica o nome da propriedade associada ao Bean. Equivale ao nome do atributo existente no bean.

O beanId informado será procurado em todos os escopos disponíveis na página JSP

Exemplos:


p

<jsp:getProperty name="myBean" property="name"/>

<%= ((User)request.getAttribute("myBean")). getName() %>

<%= myBean.getName() %>

182

jsp:setProperty Permite modificar as propriedades encapsuladas em bean.


<jsp:setProperty name="beanId" property="propName" value="propValue" />

Exemplo: Exemplo:

<jsp:setProperty name="myBean" property="name" value="Flavio"/>

A partir dos parâmetros enviados para uma página JSP é possível enviar os valores diretamente para um bean (que deve ser inicialmente criado). Uma parâmetro recebido pode ser passado diretamente para um Bean utilizando a

seguinte sintaxe:

<jsp:setProperty name= "Id" param="parName" property="propName" />

Exemplo: <jsp:setProperty name="myBean" param="user" property="name"/>


Caso o nome dos parâmetros sejam exatamente iguais ao atributos do bean então é possível utilizar a seguinte sintaxe:

<jsp:setProperty name= " beanId" property= " * " />

Exemplo:

<jsp:setProperty name="myBean" property="*"/>

183

jsp:setProperty No momento em que um bean é criado é possível ajustar as suas

propriedades utilizado a tag jsp:setProperty

Desta forma o objeto é construído e seus atributos são ajustados da seguinte forma:seguinte forma:

<jsp:useBean id="myBean" class="model.User">

<jsp:setProperty name="myBean" property="name" value="Flavio"/>

<jsp:setProperty name="myBean" property= "password" value="123"/>

</jsp:useBean>


184

Ações Personalizadas – Tag Extension As ações Padrão facilitam a utilização da JSP pois o código das páginas fica

centralizado em marcadores (tags) e o código Java fica separado do código existente na página JSP

O conjunto de ações padrão disponíveis pela especificação JSP é insuficiente, O conjunto de ações padrão disponíveis pela especificação JSP é insuficiente, mesmo para pequenas tarefas.

A especificação prevê a criação de novos marcadores (tags)

Desta forma é possível associar uma série de funcionalidades às páginas criadas com JSP

Normalmente estes novos marcadores são agrupados e conhecidos como Tag Libraries

Além de ser possível a criação de novas Tags é possível a utilização de várias T Lib i di í i i i d id d


Tag Libraries disponíveis, para as mais variadas necessidades.

Existe uma especificação que um contém um conjunto de tags que normalmente utilizados em aplicações JSP, conhecida como JSTL (JavaServer Pages Standard Tag Library)

185

Diretiva – taglib – JSTL 1.1Servlets 2.4 – JSP 2.0 (Tomcat 5.x) Para utilizar uma tag library é necessário configurar a mesma no contexto no

contêiner de Servlets/JSP

Para isto é necessário: Criar uma pasta tld, dentro da pasta WEB-INF. Criar uma pasta tld, dentro da pasta WEB INF.

Nesta pasta deve ser colocado o arquivo TLD (Tag Library Descriptor - tldFileName) que descreve a tab libray (versão; descrição; etc.) e cada uma das tags (nome, parâmetros, classe java)

Na pasta lib, existente dentro da pasta WEB-INF, deve ser colocado os arquivos .class e/ou .jar que contém a implementação de cada tag. JSTL 1.1 - jstl.jar e standard.jar

Caso este arquivo possua dependências que não estejam disponíveis é necessário que os mesmos sejam também colocados na pasta lib

Fi l é á i l i WEB XML i f b


Finalmente é necessário colocar no arquivo WEB.XML as informações sobre a taglibrary disponível para aplicação da seguinte forma:

<taglib>

<taglib-uri>http://java.sun.com/jsp/jstl/core</taglib-uri>

<taglib-location>/WEB-INF/tld/tldFileName.tld</taglib-location>

</taglib>

186

Diretiva – taglib – JSTL 1.2Servlets 2.5 - JSP 2.1 (Tomcat 6) Para utilizar uma tag library é necessário configurar a mesma no contexto

no contêiner de Servlets/JSP

Para isto é necessário:N t lib i t t d t d t WEB INF d l d Na pasta lib, existente dentro da pasta WEB-INF, deve ser colocado os arquivos .class e/ou .jar que contém a implementação de cada tag. jstl-impl-1.2.jar e jstl-api-1.2.jar

Conteiner realizará a procura dos arquivos TLDs a paritr da pasta /WEB-INF

Caso exista um arquivo JAR dentro desta pasta o contêiner fará a procurapelos arquivos TLDs na pasta /META-INF Este comportamento é válido a partir da JSP 2.0


187

JSTL – JSP Standard Tag Library A JSTL (JavaServer Pages Standard Tag Library) define um conjunto de tags,

que normalmente são utilizados por aplicações JSP.

A JSTL engloba quatro tag libraries que possuem diferentes funcionalidadesLIBRARY NAME FUNCIONALIDADES

Core

Ações para seleção (if/then); saída de dados; criação e destruição de objetos em uma página JSP; manipulação de propriedades de JavaBeans; tratamento de exceções; iteração sobre coleções; construção de URLs a acesso ao seu

conteúdo

Formatting Internacionalização e formatação de dados; recursos para apresentação de

dados em diferentes localidades (idiomas); Formatação de dados (numéricos; percentuais; monetários; datas) segundo as características de cada localidade

SQLAcesso a banco de dados: Especificar uma fonte de dados; consultas(query); atualizações (update); transações(transactions) e iteração sobre os dados


A documentação para todas as tags está disponível no link abaixo: JSTL –Documentação Completa

188

SQL atualizações (update); transações(transactions) e iteração sobre os dados obtidos em uma consulta

XML Parsing de documentos XML; Acesso de informações através de XPATH e

transformação utilizando XSTL Functions Manipulação de Strings e informações sobre itens em uma coleção

JSTL - Versões JSTL 1.2

J2EE 5/Servlets 2.5 / JSP 2.1 / Tomcat 6 https://jstl.dev.java.net/download.html

Arquivos jstl-impl-1.2.jar

jstl-api-1.2.jar

JSTL 1.1 J2EE 1.4/ Servlets 2.4 / JSP 2.0 / Tomcat 5.0 e 5.x

http://jakarta.apache.org/site/downloads/downloads_taglibs-standard cgi


standard.cgi

Arquivos jstl.jar

standard.jar

189

JSTL – JSP Standard Tag LibraryCore Contém tags que executam operações de seleção (if/then) e controle

(forEach; choose; etc.)

AÇÃO (TAG) DESCRIÇÃOh h h h ' b dc:catch Catches exceptions thrown in the action's body

c:choose Chooses one of potentially many code fragments

c:forEach Iterates over a collection of objects, or iterates a fixed number of

times c:forTokens Iterates over tokens in a string

c:if Conditionally performs some functionality

c:import Imports a URL c:otherwise Specifies default functionality in a <c:choose> action

c:out Sends output to the current JspWriterS ifi URL f i l


190

c:param Specifies a URL parameter for <c:import> or <c:url> c:redirect Redirects a response to a specified URL c:remove Removes a scoped variable c:set Creates a scoped variable

c:url Creates a URL, with URL rewriting as appropriate c:when Specifies one of several conditions in a <c:choose> action

JSTL – JSP Standard Tag LibraryFormatação Permite a formatação de dados; Trabalhar com vários idiomas; etc.

AÇÃO (TAG) DESCRIÇÃO

fmt:bundle Sets a localization context for enclosed <fmt:message> and formatting

actionsactions

fmt:setBundle Sets a localization context for <fmt:message> and formatting actions fmt:setLocale Sets the locale used by <fmt:message> and formatting actions fmt:formatDate Formats a date in a locale‐sensitive manner

fmt:formatNumber Formats a number, currency, or percent in a locale‐sensitive manner

fmt:message Retrieves a message from a resource bundle fmt:param Supplies a parameter for an enclosing <fmt:message> action

fmt:parseDate Parses a date in a locale‐sensitive manner fmt:parseNumber Parses a number, currency, or percent in a locale‐sensitive manner

fmt:requestEncoding Sets the request encoding for a JSP page


191

fmt:requestEncoding Sets the request encoding for a JSP page fmt:setTimeZone Sets the time zone used by date and time formatting actions fmt:timeZone Sets the time zone used by enclosed date and time formatting actions

JSTL – JSP Standard Tag LibrarySQL Permite o acesso a dados e a execução de comandos SQL

AÇÃO (TAG) DESCRIÇÃOAÇÃO (TAG) DESCRIÇÃO

sql:dateParam Specifies a date parameter for <sql:query> or <sql:update>

sql:param Specifies a parameter for <sql:query> or <sql:update>

sql:query Executes a database query

sql:setDataSource Sets a data source for <sql:query>, <sql:update>, and

<sql:transaction> actions

sql:transaction Wraps a transaction around enclosed <sql:query> and

<sql:update> actions


192

sql:update Executes a database update

JSTL – JSP Standard Tag LibrarySQL - Exemplo<%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %>

<%@ taglib prefix="sql" uri="http://java.sun.com/jstl/sql" %>

<sql:setDataSource driver="sun.jdbc.odbc.JdbcOdbcDriver"

url="jdbc:odbc:ShopingDbase" var = "ds" />j p g

<sql:query sql="select name, price from products" var="results"

dataSource="${ds}"/>

<html>

<body>

<table border="4">

<tr><th>Name</th><th>Descrição</th></tr>

<c:forEach var="row" items="${results.rows}">

<tr><td><c:out value="${row.name}"/></td>


<tr><td><c:out value ${row.name} /></td>

<td><c:out value="${row.price}"/></td></tr>

</c:forEach>

</table>

</body>

</html>

193

jsp:forward – Tag Library<%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %>

<html>

<body>

<c:choose>

<c:when test='${param.perfil == "professor"}'>


<jsp:param name="user" value='${param.user}'/>

</jsp:forward>

</c:when>

<c:otherwise>


<jsp:param name="user" value='${param.user}'/>


<jsp:param name user value ${param.user} />

</jsp:forward>

</c:otherwise>

</c:choose>

</body>

</html>

194

JSTL – JSP Standard Tag LibraryXML Manipulação de arquivos XML

AÇÃO (TAG) DESCRIÇÃO

x:choose XML version of <c:choose>

x:forEach XML version of <c:forEach>

x:if XML version of <c:if>

x:otherwise XML version of <c:otherwise>

x:out XML version of <c:out>

x:param XML version of <c:param>; specifies a transformation parameter for an

<x:transform> action

x:parse Parses an XML document


195

x:parse Parses an XML document

x:set XML version of <c:set>

x:transform Transforms an XML document

x:when XML version of <c:when>

JSTL - JSP Standard Tag LibraryStrings Funções para a manipulação de Strings em geral

AÇÃO (TAG) DESCRIÇÃOfn:contains() Tests if an input string contains the specified substring.

fn:containsIgnoreCase() Tests if an input string contains the specified substring in a case insensitive way. g p g p g yfn:endsWith() Tests if an input string ends with the specified suffix. fn:escapeXml() Escapes characters that could be interpreted as XML markup. fn:indexOf() Returns the index withing a string of the first occurrence of a specified substring. fn:join() Joins all elements of an array into a string.

fn:length() Retorna o número de itens em uma coleção ou o número de caracteres em uma

String

fn:replace() Returns a string resulting from replacing in an input string all occurrences of a

before" string into an "after" substring. "fn:split() Splits a string into an array of substrings.


196

fn:startsWith() Tests if an input string starts with the specified prefix. fn:substring() Returns a subset of a string.

fn:substringAfter() Returns a subset of a string following a specific substring. fn:substringBefore() Returns a subset of a string before a specific substring. fn:toLowerCase() Converts all of the characters of a string to lower case. fn:toUpperCase() Converts all of the characters of a string to upper case

fn:trim() Removes white spaces from both ends of a string.

Aplicação Exemplo - Servlets Servlets Associados


197

Aplicação Exemplo - Servlets Servlets envolvidos


198

Aplicação Exemplo – Servlets e JSP Servlets e Páginas JSP envolvidas


199

Documents

Java Server Pages