Revisao Geral

Prof. Oscar Revisão – Java Server Page

Conceitos 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á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á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ásicos Ciclo de vida da JSP O Browser faz uma requisição ao Servidor Web; O Servidor Web detecta que trata-se de uma página JSP e encaminha a requisição a Engine JSP; A JSP faz o processamento necessário, inclusive acessos a bancos de dados e outros recursos e devolve o HTML para o Servidor Web; O Servidor Web devolve o HTML ao Browser.

Conceitos 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çã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 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 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 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 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 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 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 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çõ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õ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); %>

Scriptlets 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á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 JSP page config request response out session application pageContext exception

Classificaçã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 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 Servlets Objeto Page Subclasse /Interface: javax.servlet.jsp.JspPage Representa 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 Servlets Objeto config Subclasse /Interface: javax.servlet.ServletConfig Armazena 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/Output Objeto request Subclasse/Interface: javax.servlet.ServletRequest Representa a solicitação que acionou o processamento da página atual. Dados de Sessão para Solicitação: <%= request.getSession( ) %>

Input/Output Objeto response Subclasse/Interface: javax.servlet.http.HttpServletResponse Representa a resposta que será enviada de volta para o usuário como resultado do processamento da página JSP. <% response.addCookie(meuCookie) %>

Input/Output Objeto out Subclasse/Interface: javax.servlet.jsp.JspWriter Representa 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 Contextuais Objeto session Subclasse/Interface: javax.servlet.http.HttpSession Representa a sessão atual de um usuário individual. <% session.putValue("nome",request.getParameter("nome")); %>

Objetos Contextuais Objeto application Subclasse/Interface: javax.servlet.ServletContext Representa 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 Contextuais Objeto pageContext Subclasse/Interface: javax.servlet.jsp.PageContext Fornece 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 Erros Objeto Exception Subclasse/Interface: java.lang.Throwable Utilizado 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 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ã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ã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ã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ã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ã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 controle IF if(condicao){ ... }else{ ... } Switch switch(var){ case 1: .... break; case 2: ... break; }

Estruturas de controle FOR for(inicializacao; teste; incremento){ ... } WHILE while(condicao){ ... } DO do{ .... }while(condicao);

Cookies 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); %>

Cookies 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()); } %>

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

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

Session 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ções Tags 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ções Tags 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ções Tags 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ções Tags 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ções Tags 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ções Tags 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ções Tags 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ções Tags 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 get Hours (){ return hours; }

Tags Ações Tags 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ções Tags 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 set Hours ( int h ){ this.hours = h; }

Revisao Geral

Mais conteúdo relacionado

Mais procurados

Destaque

Semelhante a Revisao Geral

Último

Revisao Geral