JSP e Servlets e Servlets e Servlets - Dei-Isep

JSP e Servlets
Instituto Superior de Engenharia do Porto
2003/2004
Linguagens de Programação II
Filipe Costa – 1020525
Índex
Introdução ao JSP, descrição e comparação
JSP
Funcionamento
Servlets
Sintax
Exemplo de Scriptlet
Comandos
JavaBeans
Comandos
Sessões
Conclusão
JSP e Servlets
3
4
4
5
5
6
7
9
11
2
Introdução
JSP (JavaServer Pages) é uma tecnologia que possibilita o desenvolvimento de páginas
web dinâmicas utilizando todas as potencialidades do Java como linguagem orientada a
objectos. Tal como em ASP e PHP, os ficheiros JSP são ficheiros html que contêm
algumas secções de código Java que possibilita conteúdos dinâmicos e automaticamente
actualizáveis, quer por acesso a bases de dados, ficheiros ou outras fontes na rede,
possibilitando também o conceito de utilizadores e sessões nas páginas de Internet, já
que sem estas tecnologias era impossível implementar este tipo de funções apenas em
html.
A comparação entre PHP e JSP pode ser feita como analogia entre o C e Java em termos
de uma linguagem ser orientada por objectos e a outra apenas em programação corrida o
que traz vantagens em ser bastante mais simples, e como desvantagens ser menos
poderosa e permitindo menos reutilização de código.
O Java ainda como tecnologia feita para máquinas virtuais (VM) é também muito mais
versátil em termos de se poder deslocar o código para todas as máquinas desde que
tenham um VM que faz a emulação de uma máquina Java. Esta vantagem aplica-se
também ao JSP sendo uma linguagem multi-plantaforma possibilitando que o servidor
possa ter qualquer arquitectura (Windows, Linux, Mac, …).
JSP e Servlets
3
JSP
Funcionamento
Convém fazer a distinção entre código JSP e applets Java para páginas (normalmente
aplicações em que o código Java é processados pelo cliente), pois a primeira é dinâmica
com o servidor e a segunda é interactiva na própria máquina sendo compilada ai mesmo
mas podendo também ser dinâmica com o servidor ou com qualquer outro recurso.
Como nota essencial fica que o JSP não é compilado na máquina do cliente e como tal é
impossível existirem aplicações a correrem na máquina se não estiver uma ligação
estabelecida com o servidor ou de JSP
JSP funciona então do seguinte modo:
(1) O computador cliente envia um pedido ao servidor de transferência do
ficheiro.jsp;
(2) O servidor analisa o ficheiro.jsp e verifica se tem código Java, se não tiver
código Java poderá ser devolvido ao cliente;
(3) Gera um servlet.java do ficheiro;
(4) Compila o servlet.java para um ficheiro.class;
(5) Executa o ficheiro no servidor;
(6) Por fim devolve o resultado da execução do Java englobando também o código
html que se encontrava no ficheiro base.
Servlets
A grande diferença entre fazer um código servlet ou JSP está no conteúdo em Java que
se pretende introduzir. Se o objectivo é realizar uma página toda em Java com pouco ou
nenhum conteúdo estático então poderá ser feito um servlet que consiste em fazer uma
classe. Se o pretendido é realizar uma página com pouco conteúdo dinâmico e com
muitos elementos estáticos então o JSP é mais apropriado. Normalmente um servidor
que suporte servlets suporta também JSP o que torna a decisão exclusivamente do
programador.
JSP e Servlets
4
Como a figura anterior dá para observar, qualquer código JSP é convertido em servlets,
e esses são depois tratados pelo servidor e devolvidos ao cliente em forma de string no
meio do código html original.
Classes e interfaces especificas do JSP:
Package javax.servlet.jsp
Package javax.servlet.jsp.tagext
Sintaxe
Comentários: <! -- … -->
Comentário ao nível de html e visível inclusivamente quando o cliente visualiza
o html da página;
Comentários: <% -- … --%>
Comentário ao nível do JSP, apenas visível na compilação e na programação;
Scripting: <% … %>
Permite a escrita de código Java nas JSP.
<% código %>;
<%! declaração %>;
<%= expressão %>.
Directivas: <%@ directiva Lista-atributos %>
Mensagens enviadas ao programa que compila/executa JSPs (container)
Directivas:
page, include, taglib;
Acções <jsp:comando> … <\jsp: comando>
Marcas JSP pré-definidas que encapsulam funcionalidades.
Comandos: jsp:useBean;
jsp:setProperty;
jsp:getProperty;
jsp:param;
jsp:include;
jsp:forward;
jsp:plugin;
jsp:params;
jsp:fallback …
Exemplo de Scriptlet
No seguinte exemplo é pedido ao utilizador o seu nome e é impresso no ecrã logo
depois uma mensagem personalizada para esse utilizador.
...
<body>
<% // begin scriptlet
String name = request.getParameter( "firstName" );
//Objecto HttpServletRequest
if ( name != null ) {
%> <%-- end scriptlet to insert fixed template data --%>
<h1>
JSP e Servlets
5
Hello <%= name %>, <br />
Welcome to JavaServer Pages!
</h1>
<% // continue scriptlet
} // end if
else {
%> <%-- end scriptlet to insert fixed template data --%>
<form action = "welcome.jsp" method = "get">
<p>Type your first name and press Submit</p>
<p><input type = "text" name = "firstName" />
<input type = "submit" value = "Submit" />
</p>
</form>
<% // continue scriptlet
} // end else
%> <%-- end scriptlet --%>
</body>
...
Comandos JSP
Acções
Acção
<jsp:include>
Descrição
Inclui dinamicamente outro recurso num JSP. Quando a JSP é
executado, o recurso referenciado é incluído e processado. Se o
recurso é alterado entre pedidos as alterações são incluídas na
próxima chamada da página
<jsp:forward> Redirecciona 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
Directivas
language
Qual a linguagem usada
extends
Superclasse pelo servidor para a
compilação dos servlets
Importa classes que sejam
necessárias para a compilação do
código
Permite o uso de sessões nas
páginas para que se possa guardar
import
session
JSP e Servlets
<%@ page language = "java"
%>
<%@ page extends =
"com.taglib... %>
<%@ page import = "java.util.*"
%>
Por defeito está definido para
existirem sessões
6
buffer
autoFlush
isThreadSafe
info
errorPage
IsErrorPage
contentType
informações necessárias do
utilizador para futuras consultas
Controla o buffer de saida para
uma página JSP. Por defeito é 8kb
Limpa o buffer quando cheio
Possibilita que quando existam
múltiplos pedidos de execução de
servlets sejam tratados ao mesmo
tempo
Informações várias que podem ser
incluídas na página, usualmente o
autor, data e versão
Identificação de outra página para
tratar erros que possam acontecer
Esta flag está em true o que
possibilita que as excepções sejam
enviadas para a página de
tratamento de erros
Identifica o tipo de mime e
character usado pelo JSP
<%@ page session = "false" %>
<%@ page buffer = "none" %>
<%@ page autoFlush = "true"
%>
<%@ page info =
"visualbuilder.com test page,
copyright 2001. " %>
<%@ page errorPage =
"/error/error.jsp" %>
JavaBeans
Para a reutilização de código eficaz foram criados os JavaBeans que mais não são do
que classes de Java com determinadas regras:
Deve existir um construtor público e sem parâmetros;
• Nenhum atributo pode ser público;
• Os atributos são acedidos através de métodos públicos setXxx, getXxx e isXxx.
Estas regras determinam um padrão que possibilita o uso de Beans como componentes
em ferramentas de desenvolvimento, sendo depois facilitada a reutilização de código
noutras aplicações.
Existem três tipos de Java Beans:
•
•
•
Visuais, utilizados no desenvolvimento de interfaces;
Dados, que fornecem um padrão para acesso a valores;
Serviços, usados para cálculos, acesso a tabelas e algoritmos específicos.
Em JSP (sendo uma linguagem que não usa interfaces gráficos) apenas os dois últimos
tipos são usados.
Comandos JavaBeans
Estes JavaBeans como classes normais com determinadas características são assim
muito conhecidas para todos os alunos que estudam Java, não apresentando quaisquer
diferenças para as classes de Java normais, como mostra o exemplo:
JSP e Servlets
7
class Hora
{
private int hora, minuto, segundos;
public Hora()
{
hora = minuto = 0;
}
public int getSegundos()
{
return hora*3600+60*minuto;
}
public void setSegundos(int s)
{
segundo=s;
}
}
useBean - Criar/seleccionar
Para a utilização dos JavaBeans no código JSP deverá primeiro ser criado um
objecto da classe para depois serem utilizados os métodos da respectiva classe
(como qualquer classe em Java que não seja abstracta). Essa criação efectua-se
da seguinte maneira:
Permite ao JSP gerir, criar ou seleccionar um objecto Java. Exemplo de uso de
JavaBean em JSP e analogia com código Java:
JavaBean
<jsp:useBean id = “obj” class = “Hora”/>
Java
Hora obj = new Hora();
Cria um novo objecto “obj” do tipo de classe Hora
getProperty - Recuperar Propriedade
JavaBean
<jsp:getProperty name = “obj” property =
“Segundos” />
Java
obj.getSegundos()
Esta Marca retorna no local em que estiver o valor da propriedade recuperada
setProperty - Alterar Propriedade
JavaBean
<jsp:setProperty name = “obj” property =
“Segundos” value = “60”/>
Java
obj.setSegundos(60)
Define a propriedade segundos como 60
JSP e Servlets
8
scope - Utilização de Beans em outras páginas
A criação padrão disponibiliza o Bean apenas para a página actual, para alterar o
nível de acesso usa-se o atributo scope.
scope pode ter quatro valores:
page - mantém o Bean até que a página seja mostrada;
request - mantém o Bean até que a resposta seja toda enviada;
session - o Bean existe durante a sessão;
application - o Bean dura enquanto a aplicação Web actual estiver activa.
<jsp:useBean id = “obj” class = “Hora” scope=“page”>
Para se aceder a propriedades indexadas previamente na mesma página ou então por
uma página que tenha englobado a actual no campo scope quando o objecto foi criado,
apenas se terá de usar normalmente não sendo necessária qualquer declaração adicional:
<%for(int i=0; i<10; i++) { %>
<%=obj.getPropriedade(i)%> <br>
<%}%>
getParameter – Inserção directa nas propriedades de Java Beans
<jsp:setProperty name=“obj” property=“nome” param =“nome”/>
Nome do parâmetro no atributo para inserir directamente: Quando a
propriedade e o parâmetro têm o mesmo nome poderá utilizar-se property=“*” – para uma associação total
Sessões
Como foi dito acima, o JSP define automaticamente o uso de sessões a true, o que
possibilita o uso de objectos em futuras sessões noutras páginas ou até na mesma
página. Este tipo de informações são normalmente guardados em cookies e cada vez
mais fundamentais para navegar em sites cada vez mais dinâmicos e com usernames e
passwords. Se os cookies não estiverem activos no browser, ou se forem recusados por
qualquer outro motivo torna quase impossível o uso de cookies, existindo outra maneira
de o fazer, não é a melhor e alguns browsers não a suportam. Os objectos que são
guardados na sessão são associados a um sessionID que permitirá assim o uso apenas
onde se destina. Os cookies são encriptados o que possibilita alguma privacidade e
segurança no manuseamento de informação pessoal e por vezes confidencial.
Para se armazenar um objecto terá de se realizar o seguinte código:
<%
Foo foo = new Foo();
session.putValue("foo",foo);
%>
Para mais tarde se aceder ao objecto guardado na sessão:
JSP e Servlets
9
<%
Foo myFoo = (Foo) session.getValue("foo");
%>
Não sendo obrigatório o isso de sessões nas páginas JSP, poderá desactivar-se as
sessões com o seguinte código: <%@ page session = "false" %> .
Não existe também limite para o número de objectos que se pode guardar numa sessão
mas não é recomendável que se guarde inúmeros objectos pois torna a navegação
bastante pesada, e por vezes o elevado número de objectos é desnecessário. Os
servidores normalmente colocam o tempo máximo de um objecto de sessão em 30
minutos mas poderá ser alterado usando este comando: setMaxInvalidationInterval(int
secs) .
JSP e Servlets
10
Conclusão
O JSP tem como principais atractivos o encapsulamento de funções e classes que traz
como consequência uma grande reutilização de código. Para se tirar total proveito da
linguagem será necessário ter conhecimento de muitas classes já construídas o que
possibilita uma programação que não quer inventar a roda mas sim fabricar automóveis
com os conhecimentos existentes até agora. No entanto para se fazerem aplicações mais
simples a utilização de PHP por exemplo será muito mais simples, versátil e intuitiva
por não ser tão poderosa é de mais fácil implementação. O grande beneficio do PHP é
que normalmente o uso de aplicações dinâmicas na web é para fins pouco complexos
como acesso a bases de dados, autenticações de utilizadores, sistemas de compras de
produtos ou para funções de cálculos lógicos, o que torna o PHP um alvo ideal pela sua
facilidade de utilização. O Java neste tipo de implementações não traz grandes
benefícios, e estando o PHP e ASP mais divulgados e mais facilitados no seu uso
normalmente é sobre estas duas linguagens que as escolhas dos programadores recaiem.
JSP e Servlets
11