2010-2 - COTEMIG - Tópicos Especiais - Java Web

1.       Introdução

2.       Perspectiva

3.       Plugins

4.       Workspace

1.       Adicionando views para uma perspectiva

2.       Arrumando o workbench

3.       Manipulando recursos com ferramentas externas

5.       O primeiro projeto Java

1.       A primeira classe Java

6.       Importando um projeto existente

 

O Eclipse é um framework para integrar diferentes tipos de aplicações. Uma de suas aplicações é a JDT(Java Development Tooling), a qual já vem com o Eclipse.

Essas aplicações são oferecidas em forma de plugins e automaticamente reconhecidas e integradas pela plataforma. Tendo seus próprios recursos para gerenciamento de mecanismo, que são geralmente arquivos no seu Hard Disk. Eles residem no seu workspace, uma pasta especial localizada no seu sistema de arquivos. As aplicações instaladas comunicam-se entre si, com isso, se uma aplicação altera um recurso qualquer, todas as outras aplicações instaladas serão notificadas sobre essa mudança, garantindo uma consistência e integração em todo o seu ambiente de desenvolvimento.

Um usuário sempre trabalha no workbench, a parte "visível" da plataforma(GUI). A perspectiva escolhida determina a aparência atual do workbench. A perspectiva é uma coleção conhecida como "views e editores" que contribuem com ações especiais para o menu e a toolbar.

A maioria das views mostra informações especiais sobre os recursos. Dependendo da view somente partes ou relacionamentos internos dos recursos poderão ser mostrados. Como no caso de arquivos do tipo XML.

Um editor trabalha diretamente sobre um recurso(classes Java como exemplo). O Eclipse segue um ciclo de carrega-altera-salva que somente se um editor salvar suas alterações, a plataforma será capaz de notificar as outras aplicações.

Views especiais podem ser conectadas diretamente a um editor, adicionando recursos complementares ao manuseamento dos recursos. Por exemplo a Outline View da perspectiva Java é conectada diretamente ao Editor Java.

O que torna o Eclipse uma IDE especial, é a extrema flexibilidade na qual podem ser combinadas views e editores. Dessa forma o workbench pode ser arrumado de uma forma livre e que melhor adapte o desenvolvedor. As views e editores podem ser adicionados em uma perspectiva aberta (mesmo se eles foram definidos em um plugin totalmente diferente). Portanto é possível ter a total liberdade para criar o ambiente de desenvolvimento que melhor agrade ao desenvolvedor, de uma forma agradável e customizada.

 

Para abrir uma nova perspectiva no seu worbench faça:

1. Escolha 'Window -> Open Perspective' no menu principal:

2. Escolha 'Other' para ver todas as perspectivas instaladas:

 

Como default a pasta root do workspace é $ECLIPSE_HOME/workspace. Caso seja necessário atuar com em vários projetos, ou mesmo compartilhar uma maquina para armazenamento dos projetos, faz mais sentido separar o workspace. Pode ser escolhido um diretório arbitrário para o wokspace, para ter uma pasta especifica como root basta usar a opção -data na inicialização do Eclipse. Por exemplo "eclipse -data c:MeuWorkspace".

1.       Abra a perspectiva, ex. perspectiva Java.

2.       Escolha 'Show View -> Navigator' no menu:

 

A navigator view será adicionada na perspectiva Java.

 

1.       Clique na barra de titulo da view ou do editor e arraste para outra posição dentro do workbench

2.       A aparencia do workbench será ajustada automaticamente:

Para adicionar uma view ou um editor como uma tab faça:

Se um recurso existente no workspce for alterado por uma ferramenta externa, a notificação não chegara ao Eclipse automaticamente. Mas se o recurso alterado externamente estiver aberto em um editor no Eclipse, será recebida uma notificação perguntando se é desejado carregar as alterações ocorridas.

Caso sejam criados arquivos ou pastas para o seu projetos externamente, será preciso notificar ao Eclipse:

1.       Selecione a pasta na qual foram criados novos arquivos / pastas na view (ex. Navigator)

2.       Escolha 'File -> Refresh'

Como criar um projeto Java simples, onde o código fonte esta separado na sua pasta de "saída'.

Criação do projeto Java:

Não importa se será criado um novo projeto ou será importado um projeto existente, é necessário criar um projeto Java no Eclipse antes.

1.       Abrir a perspectiva JavaEE

2.       Abrir o assistente 'File -> New -> Dinamic Web Project'.

 

3.       O dialogo 'New Dinamic Web Project - Dinamic Web Project ':

4.       Escolha um nome para o seu projeto, ex. "meuprojeto". O padrão para a pasta do projeto é workspace_home/meuprojeto .

5.       Pressine 'Next'. O dialogo ' Dinamic Web Project - Java' aparecerá:

Com esse dialogo será editado o arquivo .classpath do projeto.



A tab 'Source' serve para especificar pastas que contenham recursos Java (arquivos .java).

 

6.       Pressine 'Next'. O dialogo ' Dinamic Web Project – Web Module' aparecerá:

7.       Pressione 'Finish'.

Criação da classe Java:

1.       Abra a perspectiva JavaEE

2.       Abra o assistente 'New Java Class'.

Também pode ser escolhido 'File -> New -> Class' e será mostrado o dialogo para escolher 'Java project'.

O dialogo 'New Java Class' aparecerá:

3.       Digite "pacote" como o nome do package Java. (Package)

4.       Digite "Classe" como o nome da classe. (Name)

5.       Deixe desmarcado o checkbox 'public static void main(String[] args)'

6.       Pressione 'Finish'

A nova classe será aberta no editor Java:

 

Criação do JSP:

1.        Abra a perspectiva JavaEE

2.       Clique com o botão direito em WebContent e em seguida 'New -> JSP'.

Para importar um projeto existente, será necessário:

1.       Criar um projeto Java.

2.       Escolha 'File -> Import'. O dialogo 'Import Select' aparecerá.

3.        Selecione 'File System'.

4.       Pressione 'Next'. O dialogo 'Import File System' aparecerá

5.       Especifique o diretório que conterá o projeto importado com o primeiro botão 'Browse'. Esse diretório será o raiz para o seguinte dialogo de seleção.

6.       Selecione as pastas e arquivos que deverão ser importados para dentro do projeto.

7.       Especifique a pasta que na qual serão armazenados os arquivos importados, com o segundo botão 'Browse'.

Poderão ser escolhidas pastas de projetos existentes e seus subdiretórios. A opção 'Create complete folder structure' também cria pastas hierarquicamente no projeto.

 

8.       Pressionw 'Finish'. As pastas e arquivos selecionados serão adicionados ao projeto.

1.       Introdução

2.       Principais APIs do Java Enterprise

3.       Servidor de Aplicações

4.       Container

1.       Configurando o Servidor

5.       Criando um novo projeto

6.       Criando páginas básicas

7.       Primeira página

8.       Principais tags HTML

Para o desenvolvimento de aplicações Java no ambiente Web é necessário conhecer as APIs de Servlets e de JSP. O uso de frameworks tais como Struts, Hibernate, VRaptor ou JSF possibilita uma produtividade maior no desenvolvimento. Para resolver problemas no ambiente web são abordados conceitos de HTTP, session e cookies.

As aplicações web envolvem regras de negócio tais como: 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. A Sun possui especificações que podem ser usadas por desenvolvedores para tirar proveito e reutilizar uma infraestrutura previamente definida. O Java EE (Java Enterprise Edition) consiste de uma série de especificações de como implementar um software para a web utilizando um servidor de aplicação e containers.

·          JavaServer Pages (JSP), Java Servlets, Java Server Faces (JSF) (ambiente Web)

·          Enterprise Javabeans Components (EJB) Java Persistence API (JPA). (objetos distribuídos, clusters, acesso remoto a objetos)

·          Java API for XML Web Services (JAX-WS), Java API for XML Binding (JAX-B) (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 aplicação e estatísticas)

A Sun/Oracle desenvolve o Glassfish que é open source e gratuito. Existem diversos servidores de aplicação compatíveis com a especificação do J2EE 1.4, Java EE 5 e Java EE 6. O JBoss é exemplo interessante pelo fato 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. A partir do java EE 6, o termo “application server web profile” é usado para se referir a servidores que não oferecem tudo, mas um grupo menor de especificações, consideradas essenciais para o desenvolvimento web.

Alguns servidores:

·          RedHat, JBoss Application Server, gratuito, Java EE 5;

·          Sun, GlassFish, gratuito, Java EE 6.

·          Apache, Apache Geronimo, gratuito, Java EE 5;

·          Oracle/BEA, WebLogic Application Server, Java EE 5;

·          IBM, IBM Websphere Application Server, Java EE 5;

·          Sun, Sun Java System Application Server (baseado no GlassFish), Java EE 5;

·          SAP, SAP Application Server, Java EE 5;

 

O Java EE possui várias especificações, entre elas, algumas específicas para o desenvolvimento de uma aplicação Web:

·          JSP

·          Servlets

·          JSTL

·          JSF

Um Servlet Container é um servidor que suporta funcionalidades específicas para o desenvolvimento de aplicações dinâmicas Web, não necessariamente o Java EE completo. O Apache Tomcat, o Jetty são alguns exemplos.

1) Mude a perspectiva do Eclipse para Java no canto direito superior da tela;

2) Abra a View de Servers na perspectiva atual.

3) Clique com o botão direito dentro da aba Servers e vá em New > Server:

4) Selecione o servidor.

5) Na próxima tela, selecione o diretório onde está o servidor.

6) Start o Servidor.

7) Abra o navegador e acesse a URL http://localhost:8080/ para ver o Servidor rodando.

Para criar um novo projeto Web no Eclipse siga os passos abaixo:

1) Selecione a perspectiva JEE.

2) Clique em New > Project >e Dynamic Web Project,

3) Digite o nome do projeto:

3) Clique em Finish.

Dê uma olhada nas pastas que foram criadas e na estrutura do nosso projeto nesse instante.

O diretório src é onde vamos colocar nosso código fonte Java. Quando compiladas as classes são criadas na pasta build. No Java EE, existe o conceito de contextos Web para diferenciar sites ou projetos distintos em um mesmo servidor. Na prática, é como uma pasta virtual que, quando acessada, remete a algum projeto em questão. O Context Root pode ser mudado em Project > Properties > Web Project > Settings > Context Root. Assim, para acessar o projeto, usa-se a URL: http://localhost:8080/nomeDoProjeto/ . Existe uma pasta dentro do projeto que é a raiz (root) do conteúdo a ser exibido no navegador. Por padrão:  WebContent. Tudo que for colocado na pasta WebContent será acessível na URL do projeto. Por exemplo, uma página de boas vindas: http://localhost:8080/nomeDoProjeto/bemvindo.html .

Para criar o arquivo: nomeDoProjeto/WebContent/bemvindo.html clique com o botão direito em WebContent, em seguida New > HTML Page

Dentro da WebContent há uma pasta chamada WEB-INF que contém configurações e recursos necessários para o projeto rodar no servidor. O web.xml é o arquivo onde ficará armazenada as configurações relativas a aplicação.

<?xml version="1.0" encoding="UTF-8"?>

<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">

  <display-name>oi</display-name>

  <welcome-file-list>

    <welcome-file>index.html</welcome-file>

    <welcome-file>index.htm</welcome-file>

    <welcome-file>index.jsp</welcome-file>

    <welcome-file>default.html</welcome-file>

    <welcome-file>default.htm</welcome-file>

    <welcome-file>default.jsp</welcome-file>

  </welcome-file-list>

</web-app>

Há ainda uma pasta chamada lib dentro da WEB-INF. Quando um projetos necessita usar bibliotecas externas, como por exemplo o driver do MySQL, precisamos copiar a biblioteca para esta pasta lib. Como esse diretório só aceita bibliotecas, apenas colocamos nele arquivos .jar ou arquivos zip com classes dentro. O diretório lib dentro do WEB-INF pode conter todas as bibliotecas necessárias para a aplicação Web, evitando assim que o classpath da máquina que roda a aplicação precise ser alterado.

Há ainda um diretório, oculto no Eclipse, o WEB-INF/classes. Para rodarmos nossa aplicação no servidor, precisamos ter acesso as classes compiladas (não necessariamente ao código fonte). Por isso, os .class são colocados nessa pasta dentro do projeto.

A pasta WEB-INF é muito importante e contém os principais recursos para o funcionamento do projeto e por esta razão o usuário não tem acesso a ela. A pasta WEB-INF é uma pasta invisível ao usuário final. Isso quer dizer que se alguém acessar a URL http://localhost:8080/nomeDoProjeto/WEB-INF verá apenas uma página de erro (404).

Pastas de um projeto:

·          src - código fonte Java (.java)

·          build - onde são compiladas as classes (.class)

·          WebContent – raiz  (páginas, imagens, css etc vão aqui)

·          WebContent/WEB-INF/ - pasta oculta com configurações e recursos do projeto

·          WebContent/WEB-INF/lib/ - bibliotecas .jar

·          WebContent/WEB-INF/classes/ - arquivos compilados copiados.

·          META-INF é opcional. É onde fica o arquivo de manifesto como usado em arquivos .jar.

Para criar um página básica é necessário um conhecimento básico de HTML (Hypertext Markup Language). HTML é uma linguagem de marcação composta por tags que definem o comportamento da página. Essas tags dizem como a página será visualizada, através da definição dos componentes visuais que aparecerão na tela. É possível exibir tabelas, parágrafos, blocos de texto, imagens e assim por diante. Todo arquivo HTML deve conter a extensão .html, e seu conteúdo deve estar dentro da tag <html>. Em um HTML bem formado, todas as tags que são abertas também são fechadas, dessa forma, todo o seu código num arquivo .html ficará dentro de <html> e </html>. Além disso, podemos também definir alguns dados de cabeçalhos para nossa página, como por exemplo, o título que será colocado na janela do navegador, através das tags <head> e <title>. Para escrevermos algo que seja exibido dentro do navegador, no corpo da nossa página, usamos a tag <body> dentro de <html>.

1) Crie o arquivo WebContent/index.html com o seguinte conteúdo:

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<html>

<head>

<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">

<title>Projeto</title>

</head>

<body>

Primeiro texto

</body>

</html>

2) Inicie (ou reinicie) o Servidor clicando no botão de play na aba Servers.

3) Acesse pelo navegador: http://localhost:8080/nomeDoProjeto/index.html

·          table: define uma tabela;

·          tr: colocada dentro de um table para definir uma linha da tabela;

·          td: colocada dentro de um tr para definir uma célula;

·          p: define que o texto dentro dela estará em um parágrafo;

·          h1 - h6: define cabeçalhos, do h1 ao h6, onde menor o número, maior o tamanho do texto;

·          a: cria um link para outra página, ou para algum ponto da mesma página;

·          img: acrescenta uma imagem no documento a ser exibido.

1.       Estrutura básica de um Servlet

2.       Compilando, instalando e chamando um Servlet

3.       Geração de HTML

4.       Lendo parâmetros de inicialização

5.       Criando um Servlet

Um Servlet é um objeto Java que recebe requisições (request) e retorna (response) uma página HTML dinamicamente gerada. Com o Sevlet é possível executar código de uma classe Java a partir de requisições HTTP. Esse acesso é feito através de configurações do servidor. Os Servlets, são mapeados através de um arquivo XML (o web.xml dentro do diretório WEB-INF). Um Servlet mapeado está pronto para ser requisitado, processado pelo Container e devolver um código HTML. Os Servlets são classes que estendem HttpServlet. Assim é possível recebe um parâmetro pela requisição (request) e por exemplo imprimr este parâmetro no console:

public class MeuServlet extends HttpServlet {

 

     private static final long serialVersionUID = 1L;

      

    public MeuServlet() {

           super();

     }

 

     protected void doGet(

           HttpServletRequest request,

           HttpServletResponse response)

           throws ServletException, IOException {

     }

 

     protected void doPost(

           HttpServletRequest request,

           HttpServletResponse response)

           throws ServletException, IOException {

 

     }

 

    protected void service(

           HttpServletRequest request,

           HttpServletResponse response)

            throws ServletException, IOException {

           

            String nome = request.getParameter("nome");

 

            PrintWriter out = response.getWriter();

            out.println("Ola: " + nome);

        }

    

    

}

É possível definir no formulário da requisição a forma como os dados são enviados para o servidor através do atributo method, usando GET ou POST:

<form action="MeuServlet" method="GET">

Da mesma forma, é possível definir no Servlet métodos distintos para tratar um ou outro caso. No POST os dados são passados dentro do corpo do protocolo HTTP, sem aparecer na URL que é mostrada no navegador e processados por doPost(), enquanto que no GET os dados aparecem na URL e são processados pelo doGet().

Há um método particular para instruções que devem ocorrer na inicialização de um Servlet ou na sua destruição, são eles:

void init (ServletConfig config);

void destroy();

No Eclipse, o mapeamento do Servlet é automático, com a sua criação e apresenta duas novas TAGs dentro do arquivo web.xml:

 

<servlet>

  <description></description>

  <display-name>MeuServlet</display-name>

  <servlet-name>MeuServlet</servlet-name>

  <servlet-class>controle.MeuServlet</servlet-class>

</servlet>

 

<servlet-mapping>

  <servlet-name>MeuServlet</servlet-name>

  <url-pattern>/MeuServlet</url-pattern>

</servlet-mapping>

Você pode acessar a classe Servlet através da URL http://localhost:8080/meuprojeto/MeuServlet?nome=Maria, ou com um formulário:

<html>

  <body>

    <form action="MeuServlet">Informe o nome:

      <input name="nome" type="text" />

      <input type="submit" value="Enviar" />

    </form>

  </body>

</html>

Um Servlet é uma classe que estenda HttpServlet. Sobrescrevendo o método service é possível atender requisições e gerar as respostas.

public class OiMundo extends HttpServlet {

     protected void service (

           HttpServletRequest request,

           HttpServletResponse response)

           throws ServletException, IOException {

 

           PrintWriter out = response.getWriter();

 

           out.println("<html>");

           out.println("<body>");

           out.println("Meu Servlet");

           out.println("</body>");

           out.println("</html>");

}

}

 

Um parâmetro fornecido na solicitação pode ser utilizado na Servlet.

            String nome = request.getParameter("nome");

Para criar um Servlet no Eclipse siga os passos abaixo:

1)        No diretório src do projeto, clique em New > Servlet

1) Crie o Servlet MeuServlet no pacote controle.

a) Para escrever a estrutura do método service, dentro da classe, escreva apenas service e dê Ctrl+espaço: o Eclipse gera pra você o método.

A anotação @Override serve para notificar o compilador que estamos sobrescrevendo o método service da classe mãe, se por algum acaso errarmos o nome do método ou trocarmos a ordem dos parâmetros, o compilador irá reclamar e você vai perceber o erro ainda em tempo de compilação.

b) Escreva a implementação do método service dentro dele.

           PrintWriter out = response.getWriter();

 

           out.println("<html>");

           out.println("<body>");

           out.println("Meu Servlet");

           out.println("</body>");

           out.println("</html>");

 

 

2)        Veja o mapeamento do Servlet dentro do arquivo web.xml.

3)        Rode o servidor e faça a chamada do Servlet mapeado na própria URL do navegdor.

4)         Crie o Servlet MeuServlet no pacote controle.

5)        Crie um formulário para passar parâmetros para o Servlet MeuServlet conforme o exemplo.

6)        Rode o arquivo HTML com o formulário e passe parâmetros para o Servlet.

7)        Explore a utilização dos métodos doGet() e doPost().

8)        Crie o Servlet abaixo:

public class VisualizaClienteServlet extends HttpServlet {

 

     protected void service(

           HttpServletRequest request,

           HttpServletResponse response)

           throws IOException, ServletException {

 

           PrintWriter out = response.getWriter();

 

           String nome = request.getParameter("nome");

           String endereco = request.getParameter("endereco");

           String email = request.getParameter("email");

           String dataEmTexto = request.getParameter("dataNascimento");

           Calendar dataNascimento = null;

    

           try {

             Date date = new SimpleDateFormat("dd/MM/yyyy").parse(dataEmTexto);

             dataNascimento = Calendar.getInstance();

             dataNascimento.setTime(date);

           } catch (ParseException e) {

             out.println("Erro de conversão da data");

             return; //para a execução do método

           }

 

           out.println("<html>");

           out.println("<body>");

           out.println("Cliente ");

           out.println("</body>");

           out.println("</html>");

     }

}

 

9)        Crie o formulário correspondente com o nome formcliente.html

<html>

<body>

<form action="adicionaContato">

Nome: <input type="text" name="nome" /><br />

E-mail: <input type="text" name="email" /><br />

Endereço: <input type="text" name="endereco" /><br />

Data Nascimento: <input type="text" name="dataNascimento" /><br />

<input type="submit" value="Gravar" />

</form>

</body>

</html>

10)     Modifique o Servlet VisualizaClienteServlet para que os dados sejam mostrados no console.