introdução à java web, Esquemas de Introdução à Computação

Baixe introdução à java web e outras Esquemas em PDF para Introdução à Computação, somente na Docsity!

Apostila Java Web

Sumário

• 1 Introdução........................................................................................................................................
• 2 Estrutura básica de uma aplicação Java Web..................................................................................
• 3 Fundamentos do Java EE.................................................................................................................
• 4 Tecnologia Java Servlets..................................................................................................................
• 5 JavaServer Pages (JSP)..................................................................................................................
• 6 Model View Controller (MVC).....................................................................................................
• 7 JavaServer Faces 2.0 (JSF)............................................................................................................
• 8 Introdução ao PrimeFaces.............................................................................................................
• 9 Desenvolvendo um CRUD com PrimeFaces................................................................................
• 10 Conclusão......................................................................................................................................

Referências Informações retiradas de: Treinamento NetBeans http://netbeans.org/kb/trails/java-ee_pt_BR.html? utm_source=netbeans&utm_campaign=welcomepage Apostila FJ-21 da Caelum www.caelum.com.br/apostilas

2 Estrutura básica de uma aplicação Java Web

O objetivo deste capítulo é compreender a estrutura básica e obrigatória de um aplicativo Java Web. Para tal, vamos utilizar a IDE NetBeans para nos auxiliar nesta tarefa. Siga os passos abaixo para criar um projeto Java Web no NetBeans:

1. Acesse o menu 'Arquivos->Novo Projeto';
2. Em Escolher Projeto selecione 'Categorias = JavaWeb' e em 'Projeto = Aplicação Web', como na imagem 1. Então clique em 'Próximo'. Ilustração 1 : Criar novo projeto Web

3. Em 'Nome e Localização' defina o 'Nome do Projeto = OlaMundoWeb' e os demais campos deixe como padrão.
4. Em 'Servidor e Definições' mantenha o preenchimento padrão e clique em 'Finalizar', como na figura 3. Observe que o servidor que irá executar a aplicação Web é o Tomcat e a versão do JavaEE é a 6. Também é importante observar que o caminho de contexto é '/OlaMundoWeb' que implica que para acessar a aplicação deverá informar 'http:<endereço do servidor>:/OlaMundoWeb'. Ilustração 2 : Criar novo projeto Web - Nome e localização Ilustração 3 : Criar novo projeto Web - Servidor

8. Faça o seguinte teste: acesse a aba 'Projetos' e clique com o botão direito do mouse no nome do projeto, selecione a opção 'Limpar e Construir'. Vá na aba 'Arquivos' e veja que foi criado o arquivo 'OlaMundoWeb.war' na pasta 'dist'. Afinal de contas o que é este arquivo '.war'? Este é o arquivo de distribuição de aplicativos Java EE, quando você for implantar a aplicação que você desenvolveu basta colocar na pasta especificada pelo servidor Java Web. Aqui estamos testando no Tomcat, mas, este arquivo irá funcionar em qualquer servidor Java Web. A extensão 'war' é um acrônimo para 'Web application Archive'.

3 Fundamentos do Java EE

Após sentir o gosto de ver uma aplicação Java Web funcionando é hora de fixar alguns conceitos fundamentais desta tecnologia. Como o Java EE pode te ajudar As aplicações Web de hoje em dia já possuem regras de negócio bastante complicadas. Codificar essas muitas regras já representam um grande trabalho. Além dessas regras, conhecidas como requisitos funcionais de uma aplicação, existem outros requisitos que precisam ser atingidos através da nossa infraestrutura: persistência em banco de dados, transação, acesso remoto, web services, gerenciamento de threads, gerenciamento de conexões HTTP, cache de objetos, gerenciamento da sessão web, balanceamento de carga, entre outros. São chamados de requisitos não-funcionais. Ilustração 6 : Tela Olá Mundo Ilustração 7 : Arquivo de distribuição

Se formos também os responsáveis por escrever código que trate desses outros requisitos, teríamos muito mais trabalho a fazer. Tendo isso em vista, a Sun criou uma série de especificações que, quando implementadas, podem ser usadas por desenvolvedores para tirar proveito e reutilizar toda essa infraestrutura já pronta. O Java EE (Java Enterprise Edition) consiste de uma série de especificações bem detalhadas, dando uma receita de como deve ser implementado um software que faz cada um desses serviços de infraestrutura. Algumas APIS especificadas no Java EE

• JavaServer Pages (JSP), Java Servlets, Java Server Faces (JSF) (trabalhar para a Web)
• Enterprise Javabeans Components (EJB) e Java Persistence API (JPA). (objetos distribuídos, clusters, acesso remoto a objetos etc)
• Java API for XML Web Services (JAX-WS), Java API for XML Binding (JAX-B) (trabalhar com arquivos xml e webservices)
• Java Autenthication and Authorization Service (JAAS) (API padrão do Java para segurança)
• Java Transaction API (JTA) (controle de transação no contêiner)
• Java Message Service (JMS) (troca de mensagens assíncronas)
• Java Naming and Directory Interface (JNDI) (espaço de nomes e objetos)
• Java Management Extensions (JMX) (administração da sua aplicação e estatísticas sobre a mesma) Servidor de Aplicação Java EE É o nome dado a um servidor que implementa as especificações do Java EE. Existem diversos servidores de aplicação famosos compatíveis com a especificação Java EE. O JBoss é um dos líderes do mercado e tem a vantagem de ser gratuito e open source. Alguns softwares implementam apenas uma parte dessas especificações do Java EE, como o Apache Tomcat, que só implementa JSP e Servlets (como dissemos, duas das principais especificações), portanto não é totalmente correto chamá-lo de servidor de aplicação. A partir do Java EE 6, existe o termo “application server web profile”, para poder se referencia a servidores que não oferecem tudo, mas um grupo menor de especificações, consideradas essenciais para o desenvolvimento web. Alguns servidores de aplicação conhecidos no mercado:
• RedHat, JBoss Application Server, gratuito;
• Sun (Oracle), GlassFish, gratuito;
• Apache, Apache Geronimo, gratuito;
• Oracle/BEA, WebLogic Application Server;
• IBM, IBM Websphere Application Server;
• Sun (Oracle), Sun Java System Application Server (baseado no GlassFish);
• SAP, SAP Application Serve.

pequeno servidor (servidorzinho, em inglês) cujo objetivo é receber chamadas HTTP, processá-las e devolver uma resposta ao cliente. Uma primeira ideia da servlet seria que cada uma delas é responsável por uma página, sendo que ela lê dados da requisição do cliente e responde com outros dados (uma página HTML, uma imagem GIF etc). Como no Java tentamos sempre que possível trabalhar orientado a objetos, nada mais natural que uma servlet seja representada como um objeto a partir de uma classe Java. Cada servlet é, portanto, um objeto Java que recebe tais requisições (request) e produz algo (response), como uma página HTML dinamicamente gerada. O diagrama abaixo mostra três clientes acessando o mesmo servidor através do protocolo HTTP: Criando o primeiro Servlets Vamos considerar o projeto 'OlaMundoWeb' feito no capítulo 2. Siga os passos a seguir para criar o Servlets que tem o objetivo de exibir uma mensagem na tela de um navegador da Internet.

1. Clique com o botão direito do mouse em 'Pacotes de Códigos-Fonte' e selecione 'Novo-

   Outros';

2. Em 'Escolher Tipo de Arquivo' defina 'Categorias = Web' e 'Tipos de Arquivos = Servlet' e então clique no botão 'Próximo', como na figura 9: Ilustração 8 : Servlets Ilustração 9 : Criando Servlet

3. Em 'Nome e Localização' defina os campos conforme a figura 10:
4. Em 'Configurar Implantação do Servlet' mantenha os valores padrões do formulário e então clique em finalizar, como na figura 11: Ilustração 10 : Criando Servlet Ilustração 11 : Criando Servlet

Na linha 35 é obtido o objeto 'out' do tipo 'PrintWriter' através do método 'getWriter' do 'response', com isso, tudo que for impresso fará parte da reposta. Nas linhas 38 até 46 é definido o conteúdo de uma página HTML.

9. Execute o projeto. Não exibiu a página definida no servlet? Isso é porque você ainda não acessou a URL correta. Para acessar acrescente na URL 'OlaMundoServlet', como na imagem 14:
10. Se apareceu a tela acima, parabéns, o seu primeiro Servlet foi criado com sucesso. Exercício Implemente um novo servlet que exiba na tela o nome de uma pessoa e se ela é maior ou menor de idade. O objetivo é que o nome e a idade sejam passados por parâmetro para o servlet e ele irá gerar uma página HTML exibindo as informações desejadas. Os parâmetros podem ser passados via 'get' ou 'post', como você preferir. Dica: para recuperar o parâmetro no Servlet utilize o método 'getParameter' definido na classe 'HttpServletRequest'. Por exemplo, para recuperar o parâmetro chamado 'idade' utilize o método da seguinte forma: 'getParameter(“idade”)'. Veja os protótipos abaixo, que foram chamados via get, pois, foram passados através da URL da página: Ilustração 14 : Página HTML gerada pelo Servlet Ilustração 15 : Exemplo maior de idade

Referências Informações retiradas de: Apostila FJ-21 da Caelum www.caelum.com.br/apostilas

5 JavaServer Pages (JSP)

Até agora, vimos que podemos escrever conteúdo dinâmico através de Servlets. No entanto, se toda hora criarmos Servlets para fazermos esse trabalho, teremos muitos problemas na manutenção das nossas páginas e também na legibilidade do nosso código, pois sempre aparece código Java misturado com código HTML. Imagine todo um sistema criado com Servlets fazendo a geração do HTML. Para não termos que criar todos os nossos conteúdos dinâmicos dentro de classes, misturando fortemente HTML com código Java, precisamos usar uma tecnologia que podemos usar o HTML de forma direta, e que também vá possibilitar a utilização do Java. Algo similar ao ASP e PHP. Essa tecnologia é o JavaServer Pages (JSP). Se na tecnologia Servlets você gerava páginas HTML através de codigo Java, no JSP você escreve código no meio de uma página HTML. Isto é possível através do recurso chamado Scriplet que é o código Java escrito entre <% e %>. Esse nome é composto da palavra script (pedaço de código em linguagem de script) com o sufixo let, que indica algo pequeno. Podemos avançar mais um pouco e utilizar uma das variáveis já implicitas no JSP: todo arquivo JSP já possui uma variável chamada out (do tipo JspWriter) que permite imprimir para o response através do método println: <% out.println(nome); %> A variável out é um objeto implícito na nossa página JSP e existem outras de acordo com a especificação. Repare também que sua funcionalidade é semelhante ao out que utilizávamos nas Servlets mas sem precisarmos declará-lo antes. Ilustração 16 : Exemplo menor de idade

'request'. Nas linhas a seguir são impressos na tela as informações necessárias.

5. Execute o projeto e acesse a URL 'http://localhost:8084/OlaMundoWeb/maioridade.jsp? nome=Josefina&idade=44' e então verifique se resultou na imagem abaixo:
6. Teste com outras idades e veja os resultados. Ilustração 18 : Arquivo 'maioridade.jsp' Ilustração 19 : Tela gerada pelo arquivo JSP

7. Se deu tudo como esperado sua primeira JSP está 100%. Exercício Implemente uma página JSP que receba 5 números inteiros como parâmetro e exiba na tela qual o maior número. Dica : caso você deseje criar um método a parte para encontrar o maior número é necessário implementá-lo em um scriptlet diferenciado que deve ser circundado com '<%! %>'. Por exemplo: <%! String concatenarNome(String nome, String sobrenome){ return nome + sobrenome; } %> Verifique o protótipo abaixo para este exercício: Aprofundado mais em JSP O objetivo das nossas aulas é apenas ter uma noção básica do funcionamento da tecnologia JSP, porém, caso deseje conhecer mais sobre o desenvolvimento de páignas JSP complexas é necessário realizar um estudo aprofundado sobre Expression Language, Taglibs e JSTL. Referências Informações retiradas de: Apostila FJ-21 da Caelum www.caelum.com.br/apostilas Ilustração 20 : Protótipo do exercício

• Stripes;
• Jboss Seam;
• Spring MVC;
• Wicket. Referências Informações retiradas de: Apostila FJ-21 da Caelum www.caelum.com.br/apostilas

7 JavaServer Faces 2.0 (JSF)

Entre os vários frameworks MVC Java, o JavaServer Faces (JSF) é o de maior destaque simplesmente por fazer parte da especificação do Java EE. O JSF consiste em uma API para representação de componentes e gerência do seu estado, manipulação de eventos, validação no lado do servidor, e conversão de dados; definição de navegação de páginas e suporte a internacionalização. Para isso, ele é baseado no uso de bibliotecas de tags que produzem um ambiente web rico. O JSF é apenas uma especificação, assim como a máquina virtual Java. Ou seja, nós encontramos no mercado diversas implementações do JSF. Abaixo as implementações mais famosas:

• MyFaces
• ICEfaces
• RichFaces
• Oracle ADF
• PrimeFaces
• OpenFaces A imagem 22 ilustra o funcionamento básico do JSF. O cliente faz um requisição HTTP ao Web Container que irá processar as regras de negócio em código Java e produzir uma resposta em HTML.

O ciclo de vida de uma requisição JSF é ilustrado na figura 23: Ilustração 22 : Fluxo do JSF Ilustração 23 : Ciclo de vida do JSF