Governador | Eduardo Campos
Vice-Governador | João Soares Lyra Neto
Secretário de Educação | Anderson Stevens Leônidas Gomes
Secretário Executivo de Educação Profissional | Paulo Dutra
Gerente Geral da Educação Profissional | Luciane Pulça
Gestor de Educação a Distância | Marcos Paulo de Assis Castro
Coordenador do Curso | Almir Pires
Professor Conteudista | Márcio Augusto Silva Bueno
Equipe Central de Educação a Distância
Andréia Guerra | Augusto Andrade | Eber Gomes | George Bento | Jannine Moreno | Marcos Vinícius Clemente | Maria de Lourdes Cordeiro Marques | Maria Helena Cavalcanti | Mauro de Pinho Vieira | Pedro Luna
SUMÁRIO
UNIDADE 4 ... 7
4. INTERFACE GRÁFICA II ... 7
4.1 Introdução ... 7
4.2 Painel Tabulado (JTabbedPane) ... 7
4.3 Barra de Ferramentas (JToolBar) ... 10
4.4 Painel da Área de Trabalho (JDesktopPane) e Quadro Interno . 12 (JInternalFrame) ... 12
4.5 Painel em Camadas (JLayeredPane) ... 13
4.6 Campo de Senha (JPasswordField) ... 17
4.7 Botão Alternar (JToogleButton) ... 18
4.8 Área de Texto (JTextArea) ... 19
4.9 Campo Formatado (JFormattedTextField) ... 19
3.40 Painel de Texto (JTextPane) ... 20
4.11 Tabela (JTable) ... 22
4.12 Menus ... 24
UNIDADE 5 ... 30
5. APLICAÇÃO WEB I ... 30
5.1 Introdução ... 30
5.2 JSP ... 31
5.3 Criando uma Aplicação Web no Netbeans ... 32
5.4 Avaliando Expressões Java ... 38
5.5 Scriptlets ... 40
5.7 Escopo de Objetos ... 45
5.8 Objetos Disponíveis numa Página JSP ... 46
5.9 Scriptlets e HTML ... 48
5.10 Diretivas ... 51
5.11 Declarações ... 52
5.12 Tag <jsp:forward> ... 53
5.13 Tag <jsp:include> ... 54
5.14 Exemplo ... 55
UNIDADE 6 ... 69
6. APLICAÇÃO WEB II ... 69
6.1 Introdução ... 69
6.2 JavaBeans ... 70
6.3 Exemplo (Segunda Versão) ... 73
6.4 Servlets ... 76
6.5 Padrão MVC ... 87
6.6 Exemplo MVC ... 89
6.6.1 Classes do Modelo ... 90
6.6.2 Controlador ... 92
6.6.3 Visão ... 95
UNIDADE 4
4. INTERFACE GRÁFICA II
Objetivos
Aprender componentes Swing mais avançados. Entender o funcionamento de menus.
4.1 Introdução
Você já sabe criar aplicações gráficas utilizando o Netbeans e os componentes Swing do Java, agora você irá aprender como enriquecer ainda mais os seus aplicativos com a utilização de vários outros componentes disponível no Swing.
Primeiramente você conhecerá alguns dos Contêineres Swing disponíveis, verá como se constrói um logo após você
4.2 Painel Tabulado (JTabbedPane)
Figura 4.1: Caixa de diálogo contendo Painel Tabulado Fonte: Captura de tela do Netbeans
No Netbeans, você clica e arrasta o componente Painel Tabulado para o seu fórmulário, e ele fica só como uma área para que você depois coloque quantos painéis (JPanel) você desejar.
Figura 4.2: Adicionando Painel ao um Painel Tabulado Fonte: Captura de tela do Netbeans
Depois disto, você pode alterar o nome do painel clicando com o botão direito e seleciona a opção Editar texto conforme a figura 4.3
Figura 4.3:Alterar o nome do painel Fonte: Captura de tela do Netbeans
4.3 Barra de Ferramentas (JToolBar)
Muitas aplicações possuem barras de ferramentas que possuem, na maioria das vezes, botões que servem de atalhos para as funcionalidades mais utilizadas.
Normalmente, você irá incluir botões (JButton), botões alternar (JToggleButton) e separador (JSeparator) todos dento da categoria de Controles Swing na janela Paleta do Netbeans.
É lógico que você poderá incluir qualquer outro componente que desejar, porém os três anteriores são os mais utilizados.
O JToolBar tem uma propriedade chamada floatable que permite que o
usuário arraste a barra de ferramentas livremente, se você não deseja este efeito, desmarque esta opção na janela Propriedades.
Uma outra propriedade muito utilizada é a rollover que faz com que as
bordas dos botões não sejam desenhadas e só apareçam quando o cursor do mouse está em cima do botão.
Muitas vezes, os botões que você adiciona na barra de ferramentas possuem figuras, ao invés de texto. Para fazer isto no Netbeans é muito fácil. Primeiro, você seleciona o botão e na janela Propriedades você clica nas reticências (...) ao lado da propriedade icon que abre a caixa de diálogo
Figura 4.4: Caixa de diálogo JButton - Icon Fonte: Captura de tela do Netbeans
Depois, você clica em Importar para o projeto e seleciona a imagem que você quer utilizar no seu botão. Depois, basta selecionar a imagem desejada, dentro da opção Imagem no projeto. Esta é uma opção melhor do que utilizar diretamente uma imagem externa, pois quando você for distribuir o seu projeto, os botões poderão ficar sem as imagens.
Normalmente, você só irá desejar mostrar a imagem no botão, então selecione a propriedade text e apague todo o texto que estiver nela.
Uma propriedade muito utilizada é a mnemonic, por exemplo, se você
A última propriedade de botão que normalmente é alterada, é a toolTipText
que faz com que dá uma dica sobre para que serve o botão quando o usuário passa o mouse por cima.
Saiba que a propriedade toolTipText também existe em muitos outros
componentes. Considere preencher esta propriedade para facilitar a utilização do usuário.
4.4 Painel da Área de Trabalho (JDesktopPane) e Quadro Interno
(JInternalFrame)
Para criar um formulário como este, você precisa arrastar um JDesktopPane para a área de desenho e depois arrastar quantos JInternalFrame você desejar para dentro do JDesktopPane que você adicionou inicialmente.
É necessário configurar os JInternalFrame através das propriedades closable (se pode ser fechada), iconifable (se pode minimizar para um ícone), maximizable (se pode ser maximizada), resizable (se pode ser redimensionada) e title (contendo o título da janela interna).
Se você executar uma aplicação assim, quando o usuário apertar CTRL+TAB ele pode alternar entre as janelas internas.
4.5 Painel em Camadas (JLayeredPane)
Este componente serve para você colocar vários painéis dentro dele, porém somente um deles é visível para o usuário.
Neste tipo de componente fica difícil a edição dentro da área gráfica, pois você irá querer adicionar vários painéis ao JLayeredPane ocupando a área máxima. Existe, portanto, uma maneira mais prática de criar o layout de cada um dos painéis.
Primeiramente, você adiciona o JLayeredPane ao seu formulário e faça ele ocupar toda a área desejada. Depois arraste um JPanel para dentro do JLayeredPane e faça ele ocupar toda a área do JLayeredPane.
JLayeredPane, portanto para adicionar o segundo JPanel você utiliza a janela Inspetor, clicando com o botão direito do mouse sobre o seu JLayeredPane (conforme figura 4.6).
Figura 4.6: Adicionando componente utilizando a janela Inspetor Fonte: Captura de tela do Netbeans
Figura 4.7: Segundo JPanel adicionado Fonte: Captura de tela do Netbeans
Figura 4.8: Layout do primeiro JPanel Fonte: Captura de tela do Netbeans
Observe que na figura 4.8, o jPanel1 (dentro da janela Inspector) está em negrito, e que o título da aba da área de edição está como “FormularioAvancado.java [jPanel1]”, indicando que você está apenas trabalhando com o primeiro painel.
Figura 4.9: Layout do formulário Fonte: Captura de tela do Netbeans
4.6 Campo de Senha (JPasswordField)
Este é um componente que você irá utilizar quando quiser que o usuário digite uma senha que não apareça na tela.
Você utiliza ele da mesma forma que um campo de texto (JTextField), porém, ao invés de utilizar o método getText() para recuperar o que o usuário digitou, é necessário utilizar o método getPassword().
Supondo que o seu campo de senha se chame pfSenha, a linha abaixo irá criar uma String senha com o conteúdo digitado pelo usuário:
String
senha
=
String.valueOf(pfSenha.getPassword());
Agora que você tem a senha como uma String, você pode então comparar com a resposta correta utilizando o método equals.
É interessante também apagar o texto existente na propriedade text do seu campo de senha na janela Propriedades.
4.7 Botão Alternar (JToogleButton)
O botão alternar tem dois estados (apertado e solto) indicando se uma certa funcionalidade está ativada, ou não.
Um exemplo bem comum deste tipo de botão é o que existe em editores de texto, que possui os botões Negrito, Itálico e Sublinhado. Se o botão estiver pressionado, então é porque esta característica está ativada.
Este tipo de botão possui a propriedade selected que você pode consultar
4.8 Área de Texto (JTextArea)
Este componente é indicado quando você deseja que o usuário possa digitar um textos mais longos que no caso o JTextField.
Ele possui barras de rolagem quando o texto não cabe na área reservada para ele. Elas aparecem automaticamente à medida que a pessoa digita o texto. Da mesma forma que o JTextField tem o campo text, portanto, você pode
utilizar os métodos getText e setText para acessar o seu conteúdo, ou alterá-lo.
4.9 Campo Formatado (JFormattedTextField)
Quando você quer que o usuário digite um texto com uma determinada máscara, então o JFormattedTextField é justamente o componente ideal para isto.
Depois de posicionar corretamente o campo formatado, é necessário
Figura 4.10: Caixa de diálogo formatterFactory
Fonte: Captura de tela do Netbeans
É possível ver pela figura 4.10 que existem várias máscaras pré-formatadas para você utilizar: número, data, hora, porcentagem, moeda e máscara. Agora, se você quiser que a máscara apareça no campo, então você deve configurar a sua própria máscara utilizando a última opção disponível na caixa de diálogo da figura 4.10.
3.40 Painel de Texto (JTextPane)
Um painel de texto é um componente que pode ser utilizado quando
deseja-se ter texto formatado com negrito, itálico, etc.
formatado, igual apareceria num navegador. Portanto, muitas vezes
são utilizados para exibir textos de ajuda (
help
) a partir de uma URL
(endereço da internet).
Outro uso deste componente, é quando você quer criar um campo
como sendo um editor de texto, porém não é trivial implementar e
integrar todos os comandos para que o usuário possa simplesmente
digitar texto e apertar CTRL+I (para itálico), CTRL+N (para negrito),
etc.
Portanto, se você precisar criar um editor é necessário você fazer uma
pesquisa mais detalhada neste componente.
O JTextPane é uma subclasse do JEditorPane especializado para
trabalhar com texto formatado. Se você simplesmente quiser exibir
uma página da web na sua aplicação, então existe o campo
page
do
JEditorPane que é utilizado para apontar para uma URL. Você poderia
colocar para testar a seguinte URL na propriedade
page
do seu
componente JEditorPane ou JTextPane:
http://download.oracle.com/javase/6/docs/api/javax/swing/JE
ditorPane.html
Figura 4.11: JEditorPane exibindo uma página da Internet Fonte: Captura de tela do Netbeans
4.11 Tabela (JTable)
Figura 4.12: Editor do Model de uma JTable Fonte: Captura de tela do Netbeans
Para acessar qualquer informação digitada na tabela você precisa
utilizar o seu
model
, da mesma maneira que você utilizou o
model
de
Se você quiser personalizar ao máximo a sua tabela, então será
necessário você pesquisar mais sobre tabelas, pois você teria que
implementar o seu próprio TableModel.
4.12 Menus
Para se ter menus na sua aplicação, você precisa utilizar os componentes disponíveis da janela Paleta do Netbeans (vide figura 4.13).
Primeiramente, você deve arrastar a Barra de Menu (JMenuBar) para o seu formulário e o seu formulário ficará como o exibido na figura 4.14.
Figura 4.14: Formulário com uma Barra de Menu Fonte: Captura de tela do Netbeans
Figura 4.15: Janela Inspetor
Fonte: Captura de tela do Netbeans
Figura 4.16: Edição da Barra de Menus Fonte: Captura de tela do Netbeans
Veja que na figura 4.16 os itens de menu Novo... e Salvar... já tem teclas de atalho (CTRL+N e CRTL+S, respectivamente), enquanto que as opções Abrir e Sair não possuem atalhos definidos.
Figura 4.17: Criando o evento actionPerformed de um item de menu
Fonte: Captura de tela do Netbeans
Saiba Mais
Vocês pode obter mais detalhes sobre Swing nos seguintes sites: http://download.oracle.com/javase/tutorial/ui/index.html http://download.oracle.com/javase/tutorial/uiswing/index.html http://www.metropoledigital.ufrn.br/aulas_avancado/web/disci plinas/desktop/index.html
RESUMO
Nesta aula você entrou em contato com inúmeros componentes Swing, porém aqui não foi possível entrar em todos os detalhes destes componentes, portanto, o interessante é que você viu como utilizar o Netbeans para criar estes componentes, e quais são algumas das propriedades que você precisa alterar. Se você desejar utilizar melhor algum destes componentes, foi dado referências sobre eles para que você possa aprofundar o seu conhecimento.
Atividades de aprendizagem:
1. Crie um aplicação no Netbeans que contenha pelo menos 4 dos componentes vistos nesta aula e ainda adicione um menu neste seu exercício.
2. Aprofunde o seu conhecimento sobre interfaces gráficas no site http://www.metropoledigital.ufrn.br/aulas_avancado/web/disciplinas/deskto p/index.html e realize alguns dos exercícios propostos de lá.
UNIDADE 5
5. APLICAÇÃO WEB I
Objetivos
Aprender a desenvolver aplicações para Web. Entender JSP.
Saber trabalhar com session.
5.1 Introdução
Nesta lição você irá aprender a desenvolver uma aplicação para web utilizando a tecnologia Java EE.
A linguagem de programação que você irá utilizar continua sendo o Java, porém você esta utilizando o Java SE (ou JDK) que é o kit de desenvolvimento Java com uma extensa API. O Java EE (de Enterprise Edition) é construído sobre o Java SE e oferece muitos componentes para o desenvolvimento de aplicações empresariais como JSP, Servlets, Enterprise JavaBeans (EJB), etc.
Você aprenderá como criar uma aplicação web utilizando as facilidades disponíveis na IDE Netbeans e utilizando o servidor de aplicações GlassFish.
5.2 JSP
JSP é uma sigla para Java Server Pages e serve para você desenvolver aplicações web. O JSP é similar ao ASP da Microsoft, só que ao invés de utilizar VB ou C# como linguagem de programação, o JSP utiliza Java. JSP permite que você misture código HTML com Java, portanto, para desenvolver páginas JSP é necessário que você conheça tanto HTML quanto Java.
Para executar uma página JSP é necessário um container web, que é um servidor de aplicações que entenda a especificação Java EE, como o GlassFish que você irá utilizar nestas aulas.
configurar nada a mais, pois você já terá o container web, servidor de banco de dados e tudo o que precisa para já testar a sua aplicação.
5.3 Criando uma Aplicação Web no Netbeans
Ao rodar o Netbeans 7 e criar um novo projeto: opção Novo projeto... do menu Arquivo, você deverá escolher uma Aplicação Web dentro da categoria Java Web (conforme figura 5.1).
Figura 5.1: Novo Projeto
Aperte no botão Próximo e escolha o nome da sua aplicação (vide figura 5.2). Se você quiser, é possível também alterar o diretório onde você irá salvar o seu arquivo. Marque a opção Configurar como projeto principal, se ele já não estiver marcado.
Figura 5.2: Nova Aplicação Web (Tela 1 de 3) Fonte: Captura de tela do Netbeans
Figura 5.3: Nova Aplicação Web (Tela 2 de 3) Fonte: Captura de tela do Netbeans
Você deverá ver a tela do Netbeans conforme a figura 5.5. Se por acaso, você não estiver vendo alguma das janelas, é possível habilitá-las no menu Janela do Netbeans.
Observe que na janela Projetos, além de Pacotes de código-fonte, apareceu um novo item chamado Páginas Web, que é onde estarão todas as páginas web da sua aplicação. Existe uma pasta chamada WEB-INF que contém arquivos de configuração e as classes compiladas da sua aplicação. Você pode ver que a primeira página, chamada index.jsp já foi criada e possui um pequeno código padrão.
Agora, você irá alterar o código da JSP index.jsp para criar a sua aplicação Olá Mundo, conforme exibido na figura 5.6. O arquivo index.jsp é executado automaticamente pelo servidor de aplicação quando na URL só tem o nome da pasta. Se você clicar no botão Executar projeto principal... (ou a tecla F6), você poderá ver o resultado da sua aplicação web.
Figura 5.6: Código do Olá Mundo! Fonte: Conteudista
Figura 5.7: Janela Saída do Netbeans ao executar a aplicação pela primeira vez
Fonte: Captura de tela do Netbeans
Figura 5.8: Aplicação Olá Mundo! sendo executada Fonte: Captura de tela do Chrome
5.4 Avaliando Expressões Java
Figura 5.9: Código do Olá Mundo com data Fonte: Captura de tela do Netbeans
Agora, se você executar a sua aplicação novamente (tecla F6), então você verá que também será mostrada a informação da data e hora do sistema (vide figura 5.10). Se você executar novamente, então aparecerá uma nova página, onde pelo menos os segundos são diferentes.
Uma outra expressão que você pode tentar é “(int) (Math.random() * 6) + 1” (sem as aspas), que irá exibir cada vez que a aplicação for executada (teste clicando no botão de atualizar do seu navegador) um valor entre 1 e 6, como se fosse um dado.
5.5 Scriptlets
Além de exibir expressões Java utilizando <%= %>, é possível escrever qualquer código Java dentro de uma página JSP com scriptlets, que é um bloco de código Java dentro de <% %>.
Observe na figura 5.11 um novo código, onde dentro do scriptlet é declarada e inicializada uma variável do tipo Random (veja a linha 12), e depois é avaliada a expressão utilizando esta variável (veja a linha 16).
Ao executar esta nova versão da página index.jsp você verá o resultado conforme o exibido na figura 5.12.
Figura 5.12: A visualização da página index.jsp no navegador Fonte: Captura de tela do Chrome
Figura 5.13: Código fonte da página index.jsp que o navegador recebeu Fonte: Captura de tela do Chrome
5.6 Execução de uma Página JSP
Para você entender melhor o que acontece quando uma página JSP é solicitada ao servidor web, veja o seu funcionamento na figura 5.14.
Figura 5.14:Execução de uma página JSP
Fonte: Captura de tela do Netbeans
O seu código JSP não é um programa em si, pois ele não tem um método main, portanto ele precisa rodar dentro de um container web.
O GlassFish que é um container web internamente gera um arquivo .java para cada arquivo .jsp solicitado, compila e então executa. Este código .java gerado é um Servlet que é um componente do lado do servidor que trata das requisições para as aplicações web.
O Servlet é gerado na primeira solicitação de uma página .jsp, é então compilado e depois executado. Porém, da segunda solicitação em diante, o Servlet é apenas executado, fazendo com que ele seja mais eficiente.
da página index.jsp na janela Projetos e selecionar a opção Visualizar servlet. Você pode visualizar um trecho do código do servlet na figura 5.15.
Figura 5.15: Trecho de código do servlet da página index.jsp Fonte: Captura de tela do Netbeans
Depois você entenderá melhor sobre servlets para poder criar os seus próprios, porém agora você viu que existe o objeto out já instanciado e pronto para ser utilizado. Saiba que existem outros objetos que você pode utilizar dentro de uma página JSP. Eles serão detalhados nas próximas seções.
5.7 Escopo de Objetos
Quando você começar a criar aplicações web um pouco mais complexas, você verá que são necessárias várias páginas .jsp e/ou servlets para executar uma requisição do usuário.
Neste contexto, vários objetos são criados e você precisa saber como reutilizar os objetos criados em uma página numa outra página.
Os escopos disponíveis são: page, request, session e application. Estes escopos estão ordenados do mais restrito ao mais abrangente.
Veja a seguir os significados destes escopos:
page objetos associados a este escopo só podem ser utilizados na mesma página em que foram criados.
request objetos associados a este escopo só podem ser utilizados por páginas que processam o mesmo request (solicitação).
application objetos associados a este escopo podem ser utilizados em qualquer página dentro da mesma aplicação em que foram criados.
5.8 Objetos Disponíveis numa Página JSP
Os seguintes objetos já foram pré-definidos e são de bastante utilidade quando você precisa escrever uma página JSP. A seguir você tem o nome do objeto (seu tipo):
application (javax.servlet.ServletContext): é o objeto ServletContext associado com o contexto da aplicação (escopo application).
config (javax.servlet.ServletConfig): é o objeto ServletConfig associado com esta página (escopo page).
exception (java.lang.Throwable): é o objeto que permite acessar os dados da exceção pela página JSP (escopo page).
out (javax.servlet.jsp.JspWriter): é o objeto utilizado para enviar a saída para o cliente (escopo page).
pageContext (javax.servlet.jsp.PageContext): encapsula as características específicas de servidor, isto é, dependente do servidor utilizado (escopo page).
request (javax.servlet.ServletRequest): é o objeto ServletRequest associado com esta solicitação (escopo request).
response (javax.servlet.ServletResponse): é o objeto ServletResponse associado com resposta ao cliente (escopo page). session (javax.servlet.http.HttpSession): é o objeto HttpSession associado com esta solicitação (escopo session).
Saiba Mais
http://download.oracle.com/javaee/6/api/javax/servlet/ServletRe quest.html
http://download.oracle.com/javaee/6/api/javax/servlet/ServletRe sponse.html
http://download.oracle.com/javaee/6/api/javax/servlet/http/HttpS ession.html
5.9 Scriptlets e HTML
Você pode utilizar código Java como for, while e if, por exemplo, em conjunto com código HTML. Pode parecer um pouco estranho, mas um trecho de código Java, pode estar dividido em vários scriptlets.
Figura 5.16: Misturando scriptlets com HTML Fonte: Conteudista
de compilação se você esquecer um fecha-chaves, por exemplo. Portanto, escrever códigos com corretas indentações se tornam essenciais para um bom entendimento do seu código.
5.10 Diretivas
É possível importar classes de outros pacotes para não ficar utilizando os nomes completos das classes, como java.util.Date ou java.util.Random. Para isto é necessário utilizar uma diretiva JSP dentro de <%@ %>.
As diretivas disponíveis são:
include – utilizada para incluir o conteúdo de um outro arquivo dentro da página JSP atual, esta inclusão ocorre estaticamente no momento da compilação da página JSP, então alterações futuras na página sendo incluída, o resultado não se reflete na página JSP até que ela seja recompilada;
page – utilizada para configurar várias opções para uma página JSP e também importar classes e pacotes;
taglib – utilizada para incluir uma biblioteca de tags para ser utilizada na página atual.
Para importar a classe java.util.Random e não precisar mais utilizá-la com o seu nome completo dentro de páginas JSP, inclua a seguinte linha no início do arquivo .jsp:
<%@page import="java.util.Random"%>
Para incluir um arquivo HTML dentro de uma página JSP você deverá utilizar a diretiva include que irá incorporar todo o texto do arquivo teste.html:
Você deve colocar este comando no ponto exato do seu arquivo que você deseja incluir o texto inteiro que está contido no arquivo teste.html.
5.11 Declarações
Como você viu, toda página JSP se tornará um servlet, portanto, se você quiser declarar algum atributo ou método a este servlet é possível fazer isto através de uma declaração utilizando <%! %>.
Veja, por exemplo, a declaração do atributo privado r utilizado nos exemplos anteriores:
<%!
private Random r = new Random(); %>
Agora, a variável local r, na realidade virou o atributo r ele será compartilhado por todas as instâncias do servlet gerado, isto é, se você tiver 10 pessoas diferentes acessando a mesma página JSP, então apenas um único objeto Random é criado e ele é compartilhado por todas estas 10 instâncias da página JSP.
5.12 Tag <jsp:forward>
Essa tag é utilizada quando você quiser redirecionar para uma nova página HTML, JSP ou servlet, sem que o usuário que fez a solicitação saiba, pois no navegador ainda permanece o endereço antigo.
Normalmente ela é utilizada para não precisar implementar todos os casos em uma única página, como por exemplo: você tem uma página para a pessoa entrar no sistema digitando um nome e senha, então existe a possibilidade de dar certo ou errado este login, portanto se não existisse esta opção, você teria que criar uma página JSP que tratasse os dois casos, o que complicaria o código.
A sintaxe abaixo serve para quando você tem uma página que não recebe parâmetros:
<jsp:forward page="novaURLrelativa" />
Já, se a página precisa receber parâmetros, então você tem a opção de utilizar a seguinte sintaxe:
<jsp:forward page="novaURLrelativa" >
<jsp:param name="nomeParametro"
value="valorParametro" />
</jsp:forward>
5.13 Tag <jsp:include>
Essa tag é utilizada quando você quiser incluir tanto conteúdo estático, quanto dinâmico, numa página JSP. Para o <jsp:include> fica transparente se o conteúdo a ser incluído é estático, ou dinâmico, o que o torna muito útil quando você não sabe qual o tipo do conteúdo que você deseja incluir. A sintaxe abaixo serve para quando você tem uma página que não recebe parâmetros:
<jsp:include page="novaURLrelativa" flush="true" />
Já, se a página precisa receber parâmetros, então você tem a opção de utilizar a seguinte sintaxe:
<jsp:include page="novaURLrelativa" flush="true" >
<jsp:param name="nomeParametro"
value="valorParametro" />
</jsp:include>
Da mesma forma que o <jsp:forward>, você pode ter tantos parâmetros, quantos forem necessários.
5.14 Exemplo
Agora, você verá um exemplo bem simples. Você terá uma tela para informar o nome e a idade de uma pessoa e irá exibir estas informações em outra página JSP utilizando o objeto implícito session.
Você terá quatro páginas JSP para este exemplo: cadastro.jsp, processamento.jsp erro.jsp e exibicao.jsp.
Para criar uma página JSP, você clica com o botão direito sobre Páginas Web do Netbeans, seleciona a opção Novo JSP. Você verá uma caixa de diálogo como a da figura 5.18, onde você preencherá com o nome da página JSP, neste caso, cadastro.
Quando você apertar o botão Finalizar, você terá uma tela como a da figura 5.19, onde você irá alterar o título da página e o cabeçalho H1. Observe que na linha 16 tem uma linha em branco que é onde você irá incluir o formulário web para digitar as informações e submeter às informações inseridas pelo usuário.
Figura 5.19: Versão inicial de cadastro.jsp Fonte: Captura de tela do Netbeans
Do lado direito da figura 5.19 você visualiza a janela Paleta que contém elementos HTML e formulários HTML para facilitar a escrita da sua página JSP. Você irá incluir na linha 16 um Formulário (dentro da categoria Formulário HTML). Para fazer isto, você pode clicar e arrastar para a linha desejada, ou posicionar o cursor na linha 16 e dar um clique duplo sobre o item Formulário.
Figura 5.20: Caixa de diálogo Inserir Formulário Fonte: Captura de tela do Netbeans
Ao apertar o botão OK, aparecerá no seu código o seguinte código
<form action="processamento.jsp" method="POST">
</form>
Figura 5.21: Caixa de diálogo Inserir Formulário Preenchida
Fonte: Captura de tela do Netbeans
Agora, você irá incluir os textos Nome e Idade na primeira coluna e dois campos de textos chamados nome e idade na segunda coluna. Para incluir o campo de texto, utilize o item Entrada de texto da janela Paleta. Veja a caixa de diálogo para o campo nome na figura 5.23.
Figura 5.23: Caixa de diálogo Inserir Entrada de Texto Fonte: Captura de tela do Netbeans
Figura 5.24: Caixa de diálogo Inserir Button Fonte: Captura de tela do Netbeans
Figura 5.25: Página cadastro.jsp
Fonte: Conteudista
Figura 5.26: Página cadastro.jsp no navegador Fonte: Captura de tela do Chrome
Ainda no código da figura 5.27, você pode ver nas linhas 8 e 9 que está sendo armazenada na variável session o nome e a idade desta pessoa. Como o escopo é de sessão, então, enquanto o usuário estiver com o navegador aberto e interagindo com a sua aplicação web, você estará armazenando estas informações do usuário.
Na linha 6, quando é feita a conversão de String para int pode acontecer um erro que está sendo tratado pelo catch da linha 11 (NumberFormatException), e neste caso você está encaminhando para a página erro.jsp passando o parâmetro msg utilizando o método GET (através da própria URL). O comando pageContext.forward tem a mesma funcionalidade da tag <jsp:forward>, porém utilizando o código Java, ao invés de utilizar tag. Observe que se você quisesse utilizar a tag, precisaria fechar o scriptlet e depois abrir novamente.
Figura 5.27: Página processamento.jsp Fonte: Conteudista
Figura 5.28: Página erro.jsp Fonte: Conteudista
Nesta página, você recupera os atributos armazenados no objeto session, porém como tudo que é armazenado na session é visto como Object (isto é conveniente, pois você pode armazenar qualquer tipo de dado na session), você precisa converter para o tipo correto (vide linhas 3 e 4 da figura 5.29). Tudo que foi armazenado com o método setAttribute é recuperado como o método getAttribute.
Todo tipo de dado primitivo armazenado na session é convertido para o tipo objeto correspondente, portanto a idade que é do tipo int foi convertida automaticamente para o tipo Integer. Então, na hora de recuperar a idade, você recebe um objeto do tipo Integer e extrai o valor do tipo int dele através do método intValue().
Figura 5.29: Página exibicao.jsp Fonte: Conteudista
Você deve agora codificar este exemplo inteiro e testar vários casos de cadastros com e sem sucesso.
Agora, você entendeu como você pode criar uma formulário onde o usuário pode digitar informações, recuperar estas informações em outra página, e como utilizar o objeto session para armazenar dados que serão utilizados em várias páginas JSP.
Saiba Mais
Vocês pode obter mais detalhes sobre JSP e Java EE nos seguintes sites:
http://download.oracle.com/javaee/6/tutorial/doc/index.html http://www.metropoledigital.ufrn.br/aulas_avancado/web/disciplina s/desenv_web/index.html
http://netbeans.org/kb/trails/java-ee_pt_BR.html http://www.oficinadanet.com.br/artigo/1687/mvc_-_o_padrao_de_arquitetura_de_software
http://www.jsptut.com
http://javafree.uol.com.br/artigo/868717/JSP-Java-Server-Pages.html
Atividades de aprendizagem:
1. Altere o exemplo da seção 5.14 para que tenha também os campos
telefone e sexo, e que exista um link da página de exibição para a página
de cadastro.
2. Aprofunde o seu conhecimento sobre JSP no site
http://www.metropoledigital.ufrn.br/aulas_avancado/web/disciplinas/desenv_
RESUMO
Nesta aula você aprendeu como utilizar o Netbeans para criar rapidamente uma aplicação web com o seu servidor embutido GlassFish. Também aprendeu o básico de JSP para criar páginas dinâmicas, e viu como é fácil misturar código Java com HTML.
UNIDADE 6
6. APLICAÇÃO WEB II
Objetivos
Utilizar beans para agilizar o processamento. Aprender sobre o padrão MVC.
Saber criar servlets.
6.1 Introdução
Você aprendeu o básico de JSP para desenvolver uma aplicação web, porém se você não tomar cuidado com o código que você desenvolver, ele ficará muito difícil de dar manutenção e estender.
Agora você irá aprender como desenvolver os seus beans que facilitará a comunicação entre os componentes da sua aplicação web.
6.2 JavaBeans
JavaBeans são classes Java que você já conhece que seguem algumas convenções. Eles são feitos de forma a poderem ser utilizados em aplicações gráficas, de maneira similar como o Netbeans deixa você acessar graficamente as propriedades dos componentes swing que você utilizou nos capítulos 3 e 4.
JavaBeans precisam ser serializáveis, ter o construtor padrão e oferecer métodos get e set para acessar os seus atributos (propriedades).
Portanto, praticamente todas as classes básicas que você já criou estão dentro do padrão JavaBenas (com exceção de implementar a interface java.io.Serializable).
O exemplo passado, onde o usuário digita o seu nome e idade no formulário web mostra que você precisa ficar solicitando cada parâmetro individualmente, e depois armazenar item por item na variável session. Imagine agora, se no seu formulário você tivesse 20 campos, ao invés de 2 campos, o trabalho iria ser muito grande, tanto para armazenar, quanto para recuperar depois.
Então, é possível utilizar um Bean para realizar este trabalho. Veja na figura 6.1 o código do BeanPessoa. Veja que é apenas uma classe como qualquer outra que tenha o construtor padrão e get e set para os seus atributos.
Figura 6.1: Código da classe BeanPessoa Fonte: Conteudista
Agora, você poderá utilizar este bean dentro das suas páginas JSP utilizando a tag <jsp:useBean> que possui a seguinte sintaxe:
<jsp:useBean id= "nomeDaInstância" scope = "escopo"
class = "classe do seu bean"/>
O comando anterior localiza, e se não achar, instancia um bean com o nome e escopo desejado. O escopo é um daqueles visto na seção 5.8. Esta tag também é utilizada em conjunto com a <jsp:getProperty> e <jsp:setProperty>.
<jsp:getProperty name=" nomeInstância "
property="nomeProp" />
A sintaxe da tag <jsp:setProperty> é uma das três seguintes:
<jsp:setProperty name="nomeInstância" property="*"
/>
<jsp:setProperty name="nomeInstância"
property="nomeProp" />
<jsp:setProperty name="nomeInstância"
property="nomeProp"
value="novoValorPropriedade" />
A primeira sintaxe, você deve utilizar quando quiser alterar automaticamente todas as propriedades de um bean a partir dos parâmetros recebidos pela página atual. A segunda sintaxe, é utilizada quando você quiser alterar uma propriedade específica de um bean a partir do parâmetro recebido pela página atual. A terceira e última sintaxe deve ser utilizada quando você quiser alterar uma propriedade do seu bean com um valor que você (programador) desejar.
6.3 Exemplo (Segunda Versão)
Agora, você verá como o exemplo da seção 5.14 deve ser alterado para utilizar o BeanPessoa que foi criado e utilizar estes novos comandos.
A página JSP cadastro.jsp continua inalterada. Veja na figura 6.2 o código da página processamento.jsp para verificar as alterações.
Figura 6.2: Página processamento.jsp Fonte: Conteudista
Como agora você não pode utilizar a cláusula try/catch para a tag <jsp:setProperty>, é necessário informar qual a página de erro deverá ser chamada automaticamente, caso aconteça qualquer erro no processamento da página atual. Você faz isto, incluindo a página de erro no atributo errorPage da diretiva @page (veja linha 1 da figura 6.2).
A primeira vez que esta página for chamada na sessão do usuário a linha 2 da figura 6.2 fará com que o bean pessoa seja instanciado, porém nas próximas execuções, ele simplesmente será recuperado da sessão.
mais propriedades do que as que vieram como parâmetros, elas ficarão sem inicialização.
Na figura 6.3 você pode observar que na linha 2 é utilizado o comando para recuperar o bean pessoa. Depois disto, você pode utilizar a variável pessoa normalmente (como na linha 15) ou você pode ter acesso à um valor deste bean utilizando <jsp:getProperty> (vide linha 19).
Apesar do código da linha 19 ser maior que o da linha 15, ele é mais parecido com o código HTML.
Figura 6.3: Página exibicao.jsp Fonte: Conteudista
para você recuperar a exceção original, você deve utilizar o método getCause() duas vezes (vide linha 11).
Figura 6.4: Página erro.jsp Fonte: Conteudista
A linhas de 12 a 16 da figura 6.4 apresenta o que será exibido para o usuário. Se o erro for do tipo NumberFormatException, será exibida uma mensagem mais fácil do usuário entender (vide linha 13), do que simplesmente imprimir a mensagem encapsulada na exceção. Porém, se for uma outra exceção, que não estava prevista, então é exibida a mensagem padrão da exceção (vide linha 15).
Observe que as linhas 13 e 15 estão utilizando o objeto implícito out para não precisar fechar o scriptlet e depois abrir novamente outro scriptlet. Neste caso, você precisa criar uma String com o código HTML dentro do método out.println().
páginas de erros, e aí o seu código não precisa ser tão genérico, pode ser mais específico e assim, mostrar mensagens mais personalizadas para o usuário.
Uma outra opção é enviar parâmetros à página de erro utilizando o método GET ao definir a página de erro na diretiva @page.
6.4 Servlets
Você já viu que toda página JSP internamente é um servlet que é gerado automaticamente pelo container web. Agora, você irá aprender como escrever o seu servlet.
Na realidade um servlet é uma classe Java que estende a capacidade do servidor para atender às requisições HTTP. Isto é, quando o usuário digita o endereço da sua aplicação web num navegador de internet, a sua aplicação precisa responder a esta solicitação, e a classe Java responsável por atendê-la é o servlet.
Figura 6.5: Caixa de diálogo Novo Servlet (tela 1 de 2) Fonte: Captura de tela do Netbeans
Figura 6.6: Caixa de diálogo Novo Servlet (tela 2 de 2) Fonte: Captura de tela do Netbeans
Note que existe 3 nomes diferentes para o servlet: o nome da classe, o nome do servlet e a URL para acessar o servlet. Elas podem ser iguais, porém o comum é que elas sejam diferentes, pois os usuários não devem saber como é que são os nomes internos dos seus servlet, nem a estrutura de diretório onde eles estão salvos, para não conseguir hackear a sua aplicação facilmente.
Figura 6.7: Janela Projetos do Netbeans Fonte: Captura de tela do Netbeans
Figura 6.8: Código do ServletAloMundo gerado automaticamente Fonte: Captura de tela do Netbeans
Figura 6.9: Execução do ServletAloMundo Fonte: Captura de tela do Chrome
Observe na figura 6.9 que a URL no navegador é
http://localhost:8080/Primeira_Aplicacao_Web/OlaMundo, indicando que o seu servlet é executado sempre que for solicitado o endereço OlaMundo da aplicação Primeira_Aplicacao_Web. Perceba que ninguém sabe pelo endereço que o seu servlet se chama ServletAloMundo e que ele está no pacote servlets.
Você pode então alterar o código para deixar ele de acordo com o da figura 6.10.
Figura 6.10: Trecho de código do ServletAloMundo Fonte: Conteudista
internet que contém a página aberta (vide figura 6.9), que o container web (neste caso, o GlassFish) recompila o servlet e já exibe a nova versão da página.
Note que para gerar uma página web com as mesmas informações em JSP seria muito mais fácil do que ficar utilizando o tempo inteiro o objeto implícito out. Por isso, que os servlets normalmente não são utilizados para exibição de conteúdo, eles são utilizados para receber as requisições HTTP (com ou sem parâmetros), fazer o processamento (chamando as suas classes de negócio apropriadas para isso) e redirecionar para uma página JSP que fará a exibição do resultado para o usuário.
Figura 6.11: Caixa de Diálogo para criação do ServletProcessamento
(tela 1 de 2)
Figura 6.12: Caixa de Diálogo para criação do ServletProcessamento
(tela 2 de 2)
Fonte: Captura de tela do Netbeans
Figura 6.13: Código do ServletProcessamento Fonte: Conteudista
Os servlets não tem os objetos implícitos que você viu que as páginas JSP possuem, portanto, você não pode utilizar pageContext.forward(...). Você precisa utilizar um objeto do tipo RequestDispatcher para realizar a tarefa de fazer o forward para uma página JSP (vide linhas 38 a 40 da figura 6.13). Também, não é possível salvar todos os parâmetros diretamente no bean, como é possível numa página JSP (a não ser que você utilize um framework como o spring ou struts), portanto veja nas linhas de 29 a 34, como é feita a recuperação dos parâmetros, alterando as propriedades do bean e salvando ele na session (que no servlet precisa ser solicitado a partir do objeto request – linha 34).
A página erro.jsp precisa voltar a ter o código da exibido na figura 5.28, pois ela precisa exibir a mensagem recebida como parâmetro, ao invés de capturar a exceção.
Observe que como o servlet está encaminhado a requisição para uma página JSP, então ninguém sabe o nome real da página que está exibindo os dados, e isto não é interessante. Portanto, ao invés de utilizar o forward é melhor utilizar o redirect, conforme exibido na figura 6.14.
Figura 6.14: Código do ServletProcessamento Fonte: Conteudista
Existe mais uma diferença, não é mais possível utilizar o caminho absoluto “/” antes dos nomes das páginas JSP, pois o redirect não está restrito ao contexto da sua aplicação, como o forward.
Saiba Mais
http://www.rponte.com.br/2008/07/12/repitam-comigo-redirect-nao-e-forward/
http://www.mhavila.com.br/topicos/web/http_mime.html#redi rect
A aplicação desenvolvida até o momento, já está se estruturando de
uma forma que existe uma separação entre o código para processar o
que está sendo requisitado pelo usuário e o código utilizado para
exibir páginas web. Na seção a seguir você entenderá melhor como
realizar a separação de códigos (de forma similar à que você fez
utilizando arquitetura em camadas) ao desenvolver uma aplicação
web.
6.5 Padrão MVC
Como você viu no exemplo anterior, normalmente você possui
páginas JSP que não possuem código Java (ou melhor, tem pouco
código Java) e servlet que não tem nenhum código HTML (ou o
mínimo possível).
model (modelo): responsável pelas regras de negócio da sua
aplicação;
view (visão): cria a interface com o usuário exibindo os dados
provenientes do modelo;
controller (controlador): recebe as requisições do usuário, dispara
as ações necessárias utilizando as classes do seu modelo, e finalmente redireciona para uma página da view para exibir a resposta ao usuário.
O exemplo anterior utilizando servlet já está utilizando esta
arquitetura MVC, onde o model é representado por BeanPessoa,
enquanto que o ServletProcessamento é o controller e as páginas
cadastro.jsp, exibicao.jsp e erro.jsp são as views.
Se você tiver a sua aplicação dividida em camadas, como visto na
disciplina Linguagem de Programação I, você poderá reutilizar as
camadas de negócio e de dados como sendo o model, e precisará
implementar os componentes da view e do controller.
6.6 Exemplo MVC
Crie uma nova aplicação web no Netbeans chamada Segunda
Aplicacao Web. Veja na figura 6.15 a estrutura do projeto e todas as
páginas e classes que ele contém.
6.6.1 Classes do Modelo
Primeiramente, o modelo é composto por duas classes Pessoa e
Sistema. Na figura 6.16 você pode ver o código da classe Pessoa e na
figura 6.17 o da classe Sistema.
Figura 6.17: Classe Sistema Fonte: Conteudista
reinicializada (isto ocorre quando um servlet ou página JSP é alterada,
ou o container web é reiniciado).
6.6.2 Controlador
O controlador é responsável por receber as requisições do usuário,
realizar a ação requerida e enviar para a página JSP correspondente
para exibir a resposta ao usuário.
Figura 6.18: Método processRequest do Servlet Controlador Fonte: Conteudista
Preste atenção aos seguintes pontos no código da figura 6.18:
O servlet recebe o parâmetro acao que indica a operação que ele deve realizar (linhas 28, 30, 32, 36), e as variáveis forward e paginaJSP são preenchidas de acordo com a ação desejada;
Normalmente operações que alteram o estado do modelo (neste exemplo, apenas o cadastramento) devem utilizar redirect, pois se o usuário apertar no botão de atualizar do navegador, não deseja-se disparar novamente o cadastramento da mesma pessoa;
Nas operações que não alteram o estado do model, utiliza-se o forward, pois se o usuário apertar o botão de atualizar do navegador várias vezes, apenas a exibição é repetida;
Veja nas linhas de 37 a 48 a sequência de comandos para executar o cadastramento de uma pessoa: 1) pega os parâmetros nome e idade; 2) confere se o nome está ok, e converte a idade para número; 3) pega a instância única do sistema; 4) cria um objeto Pessoa e inicializa ele com os parâmetros recebidos; 5) cadastra a pessoa no sistema e 6) define que irá redirecionar e indica a página
“controlador?acao=exibir”, neste caso;
Neste exemplo simples, só existe um servlet controlador, porém numa
aplicação maior, você terá apenas um servlet geral que receberá as
ações do usuário e irá fazer um forward para os servlets que realmente
irão executar as solicitações do usuário.
Existirão, dois tipos de servlets: os de tarefas e os de página. Os
primeiros realizam tarefas que alteram o seu modelo (cadastrar,
alterar, excluir, ...), e assim, precisam utilizar redirect e os últimos
executam operações que só faz consulta ao modelo, e utilizam
forward.
6.6.3 Visão
As páginas JSP que fazem parte deste componente são: index.jsp (na
pasta principal do projeto) e cadastro.jsp, erro.jsp e exibicao.jsp
(dentro da pasta WEB-INF).
Figura 6.19: Página index.jsp Fonte: Conteudista
Figura 6.20: Página cadastro.jsp
Fonte: Conteudista
Figura 6.21: Página erro.jsp
Fonte: Conteudista
Figura 6.22: Página exibicao.jsp
Fonte: Conteudista
6.7 Estudos Futuros
Outros padrões de projetos que é interessante você estudar são: factory, abstract factory e DAO (data access object), e assim deixar a sua aplicação ainda mais reusável e fácil de desenvolver.
Já existe a versão Java EE 6 que ainda incorpora mais recursos ao desenvolvimento web, também é preciso estudar as chamadas tag libraries, JSF e Unified Expression Language.
Portanto, saiba que estas duas unidades semanais foram apenas a sua introdução a este assunto tão extenso que é o desenvolvimento de aplicações web em Java.
Outros recursos que você também precisa aprender incluem: javascript, AJAX, jQuery, etc.
Saiba Mais
Vocês pode obter mais detalhes sobre JSP e Java EE nos seguintes sites:
http://javafree.uol.com.br/artigo/868717/JSP-Java-Server- http://www.javasimples.com.br/spring-2/spring-framework-parte-1-dependency-injection/
Atividades de aprendizagem:
1. Desenvolva uma pequena aplicação web de uma agenda
telefônica utilizando o padrão MVC e armazenando os dados em
banco de dados através de JDBC.
2. Estude mais sobre o framework Spring e altere a aplicação web do
RESUMO
REFERÊNCIAS
[1] DEITEL, Harvey M.; DEITEL, Paul J.. Java, como programar. 8. ed. Prentice Hall Brasil, 2010.
[2] MECENAS, I. J. Java 6 - Fundamentos, Swing, Bluej E Jdbc. 3. ed. Starlin Alta Consult, 2008.
[3] HORSTMANN, Cay S.; CORNELL, Gary. Core Java, V.1 -
Fundamentos. 8. ed.Prentice Hall Brasil, 2009.
[4] ______. The Java Tutorials. Disponível em http://download.oracle.com/javase/tutorial/. Atualizado em 17/03/2011. Acessado em 16/04/2011.
[1] JANDL JUNIOR, P. Desenvolvendo Aplicações Web com JSP e
JSTL. 1. ed. Novatec, 2009.
[2] BASHAM, B. Use a Cabeça! Servlets e JSP. 2. ed. Starlin Alta Consult, 2008.
[3] GONÇALVES, E. Desenvolvendo Aplicações Web com JSP,
Servlets, JavaServer Faces, Hibernate, EJB 3 Persistence e AJAX.
1. ed.Ciência Moderna, 2007.
