View
1.760
Download
0
Category
Preview:
DESCRIPTION
Arquivo de revisão geral da disciplina de desenvolvimento web - JSP
Citation preview
Prof. Oscar
Revisão – Java Server PageRevisão – Java Server Page
Conceitos básicosConceitos básicos
JEE ou J2EE Java Enterprise Edition – Plataforma de desenvolvimento
Java, voltada para aplicações corporativas, aplicações de rede, internet, etc.
JSP Tecnologia especificada pela SUN que combina Java e
HTML para fornecer conteúdo dinâmico a páginas web.
<html><head>
<title>Aula 1</title></head>
<body>
<h1>Bom dia <% out.println(“usuario”); %></h1>
</body></html>
Conceitos básicosConceitos básicos
Servlet Servlet é uma classe Java que dinamicamente processa
requisições e respostas, proporcionando ao desenvolvedor um conteúdo dinâmico em um servidor web.
package uniban;
import java.io.*;
public class Aula extends HttpServlet {
public void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {
response.setContentType("text/html");
PrintWriter out = response.getWriter();
out.println("<html>");
out.println("<body>");
out.println("<h1>Bom dia usuario</h1>");
out.println("</body>");
out.println("</html>");
} }
Conceitos básicosConceitos básicos
Vantagens do JSP
Geração de conteúdo dinâmico; Aproveita as vantagens do Java por ser uma tecnologia
baseada nessa linguagem; O uso do Java, conduz uma alta produtividade; Portatibilidade de plataforma; Performance
Conceitos básicosConceitos básicos
Ciclo de vida da JSP1. O Browser faz uma requisição ao Servidor Web;
2. O Servidor Web detecta que trata-se de uma página JSP e encaminha a requisição a Engine JSP;
3. A JSP faz o processamento necessário, inclusive acessos a bancos de dados e outros recursos e devolve o HTML para o Servidor Web;
4. O Servidor Web devolve o HTML ao Browser.
Conceitos básicosConceitos básicos
Diagrama
Conceitos básicosConceitos básicos
IDE – Integrated Development Environment Ambientes de desenvolvimento com o intuito de
desenvolver programas, aplicativos e ferramentas de forma atimizada.Eclipse, NetBeans, etc.
Descritores de distribuiçãoDescritores de distribuição
Descritores de distribuição são arquivos XML cujos elementos descrevem como instalar e montar componentes em um ambiente específico.
web.xml display-name - O elemento fornece um nome que podem
ser utilizados para rotular a aplicação Web. welcome-file-list - O elemento instruí o servidor qual
arquivo usar quando o servidor receber URLs que referem-se a um nome de diretório mas não a um nome de arquivo.
Diretivas JSPDiretivas JSP
As diretivas JSP são usadas para demonstrar informações de processamentos especiais a respeito da página para o container JSP.
Diretiva Page Diretiva include Diretiva taglib
Diretiva pageDiretiva page
A diretiva page é a diretiva JSP mais complicada, principalmente porque ela suporta uma ampla gama de atributos e funcionalidades associadas a ela.
Ao todo são 11 atributos para essa diretiva.
Sintaxe:
<%@ page atributo1=”valor1” atributo2=”valor2” ... %>
Diretiva pageDiretiva page
Atributo Info Usado para inserir inf. sumarizadas da página web;
Atributo ContentType indica qual o tipo extensão gerada na resposta da JSP. “text/html”,
“text/xml”, etc.
Atributo Import É capaz de estender um conjunto de classes Java que poderão ser
usadas nas páginas JSPs.
Atributo Session Indica se a página está participando do gerenciamento de sessão;
Diretiva pageDiretiva page
Atributo errorPage Indica uma página alternativa que será exibida caso aconteça um
erro não previsto durante o processamento de uma página JSP no container.
Atributo isErrorPage Responsável por definir uma página JSP que servirá como a página
de erro padrão para um grupo de páginas JSP. Sendo do tipo boolean.
Diretiva includeDiretiva include
Permite que os autores da página incluam o conteúdo de um arquivo em outro.
O arquivo a ser incluído é identificado através de um URL local e a diretiva tem o efeito de substituir a si mesma pelo conteúdo do arquivo indicado.
Sintaxe:
<%@ include file=”URL” %>
Diretiva taglibDiretiva taglib
É usada para notificar o container JSP que uma página se apóia em uma ou mais bibliotecas de tag(s) personalizadas.
Sintaxe:
<%@ taglib uri=”/testeTags” prefix=”mcp” %>
...
<mcp:endProgram/>
...
Elem. de criação de scriptsElem. de criação de scripts
Permitem que os programadores embutam diretamente código em uma página JSP que gera o output nos resultados enviados de volta ao cliente.
Declarações <%! %> Expressões <%= %> Scriptlets <% %> Comentários <%-- --%>
DeclaraçõesDeclarações
Permite que seja definido métodos ou campos que são inseridos dentro do corpo principal da classe do servlet.
<%! private int accessCount = 0; %>
Acessos à página desde a inicialização do servidor:
<%= ++accessCount %>
ExpressõesExpressões
As expressões de JSP é explicitamente objetivado para geração de output. A expressão é avaliada, convertida para uma string, e inserida na página em tempo de execução.
<%= var %>
<% out.print(var); %>
ScriptletsScriptlets
Os scriptlets podem conter instruções JAVA, executando determinadas tarefas como incluir ajuste de cabeçalhos e códigos de estado para a resposta, invocar efeitos ou atualizar um banco de dados, ou executar código que contenha laços, condicionais, ou outras construções complexas.
<%
if(var==1){
out.print(var);
}
%>
ComentáriosComentários
Os comentários JSP são independentes do tipo de conteúdo e são utilizados para ignorar a tradução da página no código fonte de servlet.
<%-- comentário do código ... --%>
<% /* comentários */ %>
Objetos Implícitos JSPObjetos Implícitos JSP
page config request response out
session application pageContext exception
Classificação dos ObjetosClassificação dos Objetos
Objetos relacionados ao servlet:Baseiam-se na implementação da página JSP
como um servlet.São eles: page e config
Objetos Input/Output:Concentram-se na entrada e saída de uma página
JSP.São eles: response, request e out.
Classificação dos ObjetosClassificação dos Objetos
Objetos Contextuais:Fornecem à página JSP acesso ao contexto
dentro do qual ela está sendo processada.São eles: session, application e pageContext
Objetos para Tratamento de Erros:Esta última categoria tem apenas um membro, o
objeto exception que é fornecido com o propósito de tratamento de erros dentro da JSP.
Objetos relacionados a ServletsObjetos relacionados a Servlets
Objeto PageSubclasse /Interface: javax.servlet.jsp.JspPageRepresenta o próprio servlet (página JSP) ou
mais especificamente uma instância da classe de servlet a qual a página foi traduzida.
<%@ page info="Demonstração do Objeto Implícito Page" %>Page Info: <%= getServletInfo() %>
Objetos relacionados a ServletsObjetos relacionados a Servlets
Objeto configSubclasse /Interface: javax.servlet.ServletConfigArmazena os dados de configuração do servlet
na forma de parâmetros de inicialização para o servlet no qual uma página JSP é compilada.
Input/OutputInput/Output
Objeto requestSubclasse/Interface: javax.servlet.ServletRequestRepresenta a solicitação que acionou o
processamento da página atual.
Dados de Sessão para Solicitação:<%= request.getSession( ) %>
Input/OutputInput/Output
Objeto responseSubclasse/Interface:
javax.servlet.http.HttpServletResponseRepresenta a resposta que será enviada de volta
para o usuário como resultado do processamento da página JSP.
<% response.addCookie(meuCookie) %>
Input/OutputInput/Output
Objeto outSubclasse/Interface: javax.servlet.jsp.JspWriterRepresenta o fluxo de saída para uma página,
cujo conteúdo será enviado para o navegador como o corpo de sua resposta.
<% out.println(“Olá Mundo!”) %>
Tamanho do Buffer de Saída: <%= out.getBufferSize() %> Tamanho da porção não usada: <%= out.getRemaining() %>
Objetos ContextuaisObjetos Contextuais
Objeto sessionSubclasse/Interface:
javax.servlet.http.HttpSessionRepresenta a sessão atual de um usuário
individual.
<% session.putValue("nome",request.getParameter("nome")); %>
Objetos ContextuaisObjetos Contextuais
Objeto applicationSubclasse/Interface: javax.servlet.ServletContextRepresenta a aplicação à qual a página JSP
pertence. As páginas JSP estão agrupadas em aplicação de acordo com seus URLs.
Nome/Versão do container servlet:<%= application.getServerInfo() %>
Objetos ContextuaisObjetos Contextuais
Objeto pageContextSubclasse/Interface:
javax.servlet.jsp.PageContextFornece acesso a todos os outros objetos
implícitos. Fornece métodos para acessar os atributos dos objetos que aceitam atributos. Implementa métodos para transferir controle da página atual para uma outra página.
Tratamento de ErrosTratamento de Erros
Objeto ExceptionSubclasse/Interface: java.lang.ThrowableUtilizado para tratamento de erros não pegos ou
exceções.Encontra-se disponível apenas para a página
designada como página de erro.
Tratamento de ErrosTratamento de Erros
Na página JSP normal:
<%@page errorPage="error.jsp" %>
Na página para controle de erro:
<%@page isErrorPage="true" %>Erro:<%= exception.toString() %> Mensagem:<%= exception.getMessage() %>
Métodos de conversãoMétodos de conversão
Os dados recebidos podem ser manipulados diretamente em páginas JSP dentro de scriptlets, expressões ou declarações e são utilizados através de variáveis, que de acordo com Java, devem ser declaradas como a sintaxe abaixo:
<% String nome = "Texto - String"; %>
Métodos de conversãoMétodos de conversão
Integer.parseInt
<%
String input = "19";
int count = Integer.parseInt(input);
%>
Double.parseDouble
<%
String input = "3.98";
double preco = Double.parseDouble(input);
%>
Métodos de conversãoMétodos de conversão
Float.parseFloat
<%
String input = "20.93";
float preco = Float.parseFloat(input);
%>
Long.parseLong
<%
String input = "7000000000000";
long counter = Long.parseLong(input);
%>
Métodos de conversãoMétodos de conversão
Convertendo String em Data
<%
String strData = "12/09/2009";
Date dtData = new Date(strData);
out.print(dtData);
%>
Sat Sep 12 00:00:00 BRT 2009
Métodos de conversãoMétodos de conversão
Formatação de data
<%
DateFormat form = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss");
out.println(form.format(Calendar.getInstance().getTime()));
%>
04/10/2009 02:34:19
Estruturas de controleEstruturas de controle
IF
if(condicao){
...
}else{
...
}
Switch
switch(var){
case 1: ....
break;
case 2: ...
break;
}
Estruturas de controleEstruturas de controle
FOR
for(inicializacao; teste; incremento){
...
}
WHILE
while(condicao){
...
}
DO
do{
....
}while(condicao);
CookiesCookies
Cookie é um mecanismo padrão fornecido pelo protocolo HTTP e que permite gravarmos pequenas quantidades de dados persistentes no navegador de um usuário.
Gravando um cookie
<%
Cookie cookieJSP = new Cookie("nome_cookie", "valor_cookie");
// Define o tempo de vida com 2 dias
cookieJSP.setMaxAge(2 * 24 * 60 * 60);
// Grava o cookie na máquina do usuário
response.addCookie(cookieJSP);
%>
CookiesCookies
Lendo um cookie
<%
Cookie listaCookies[] = request.getCookies();
int numCookies = listaCookies.length;
for (int i = 0 ; i < numCookies ; ++i) {
out.print(listaCookies[i].getName());
out.print(listaCookies[i].getValue());
}
%>
SessionSession
Session é um mecanismo que permite gravação de uma pequena quantidade de informação na sessão do servidor identificado por uma identificação - ID.
Mecanismo:
O browser abre uma conexão com o servidor, faz a solicitação, o servidor envia a resposta e fecha a conexão. Portanto a conexão existe para uma única solicitação/resposta.
A idéia da sessão web é manter o estado do usuário entre várias conexões.
Na primeira conexão, o servidor gera um único session ID para o cliente e a devolve juntamente com a resposta. Nas próximas conexões, o cliente envia junto com a solicitação o seu session ID o que permite ao servidor identificá-lo.
SessionSession
Definindo a sessão:
<%@ page session="true" %>
<%
session.setAttribute("nome_sessao", user);
session.putValue("nome_sessao", user);
%>
Recuperando a sessão:
<%
session.getAttribute("nome_sessao");
session.getValue("nome_sessao");
%>
SessionSession
Define o tempo máximo (em segundos) entre solicitações pelo qual a sessão será mantida.
session.setMaxInactiveInterval(tempo);
Recupera o tempo máximo definido para a sessão.
session.getMaxInactiveInterval();
Descarta somente o atributo da sessão informada ao parâmetro
session.removeValue("nome_sessao");
Tags AçõesTags AçõesTags Standard ActionsTags Standard Actions
Forward
A ação <jsp:forward> é usada para transferir permanentemente controle de uma página JSP para outro local no servidor. Qualquer conteúdo gerado pela página atual é descartado e o processamento da solicitação começa novamente no local alternativo.
<jsp:forward page="processa.jsp" />
Tags AçõesTags AçõesTags Standard ActionsTags Standard Actions
Include
A ação <jsp:include> permite que os desenvolvedores de página incorporem o conteúdo gerado por outro documento local no output da página atual. O output do documento incluído é inserido no output da página original do lugar da <jsp:include>, depois o processamento da página original continua.
<jsp:include page="header.jsp" />
Tags AçõesTags AçõesTags Standard ActionsTags Standard Actions
Plugin
A ação <jsp:plugin> permite o uso de plug-in de Java da Sun Microsystems, fornecendo um mecanismo compatível com várias plataformas para incorporar applets ou um JavaBean no navegador do usuário final.
<jsp:plugin type="applet" codebase="plugins"
code="br.com.aula.plugins.applets.calcula"
width="300" height="300">
<jsp:params>
<jsp:param name="param1" value="<%= valor1 %>"/>
</jsp:params>
</jsp:plugin>
Tags AçõesTags AçõesTags Standard ActionsTags Standard Actions
Plugin - Applet
Applet é um software aplicativo que é executado no contexto de um browser. Uma applet geralmente executa funções bem específicas e foram introduzidas na primeira versão da plataforma Java em 1995.
Applets em Java podem adicionar recursos que não são possíveis em HTML, podendo funcionar em qualquer browser, desde que tenha instalado a JVM no cliente.
Tags AçõesTags AçõesTags Standard ActionsTags Standard Actions
JavaBeans
JavaBeans são componentes de software escritos em Java. Os próprios componentes são chamados de Beans e devem aderir as especificações delineadas na API de JavaBeans.
Assim como muitos componentes de software, os Beans encapsulam tanto o estado quanto o comportamento da informação.
Tags AçõesTags AçõesTags Standard ActionsTags Standard Actions
A tag <jsp:useBean>
A tag <jsp:useBean> diz a página que você quer disponibilizar um Bean para ela.
A tag é utilizada para criar um Bean ou pegar um Bean existente no servidor.
Exemplo:
<jsp:useBean id="myClock" class="java.util.Date" />
<%= myClock %>
Tags AçõesTags AçõesTags Standard ActionsTags Standard Actions
A tag <jsp:getProperty>
A principal maneira de acessar as propriedades de um Bean em JSP é através da tag <jsp:getProperty>. A tag <jsp:getProperty> produz conteúdo que podemos ver na HTML gerada pela página e espera-se dois atributos para uso da mesma: nome e propriedade.
Tags AçõesTags AçõesTags Standard ActionsTags Standard Actions
A tag <jsp:getProperty>
<jsp:useBean id="time" class="br.com.aula.beans.TimeBean" />
<jsp:getProperty name="time" property="hours" />
public class TimeBean{
.....
public int getHours(){
return hours;
}
Tags AçõesTags AçõesTags Standard ActionsTags Standard Actions
A tag <jsp:setProperty>
Usamos a tag <jsp:setProperty> para modificar as propriedades dos Beans. A tag <jsp:setProperty> pode ser usada em qualquer lugar dentro da página para modificar as propriedades de um Bean, desde que a propriedade tenha sido tornada gravável pelo programador do Bean.
Tags AçõesTags AçõesTags Standard ActionsTags Standard Actions
A tag <jsp:setProperty>
<jsp:useBean id="time" class="br.com.aula.beans.TimeBean" />
<jsp:setProperty name="time" property="hours" value="55" />
public class TimeBean{
.....
public void setHours( int h ){
this.hours = h;
}
Recommended