Artigo no estilo: Curso
Por que eu devo ler este artigo:A plataforma Java EE sempre foi considerada um sucesso para o desenvolvimento de aplicações corporativas. Por isso, nesse artigo vamos dar início ao estudo de vários recursos existentes em sua nova versão, a Java EE 7.

Juntamente com essa plataforma, também utilizaremos componentes do framework PrimeFaces para criação das telas de um sistema exemplo (neste caso, de controle de projetos).

Aqui, criaremos a arquitetura da aplicação, o banco de dados, a primeira tela de cadastro e um serviço RESTful para popular dados no banco de dados de cidades e estados, recursos presentes em praticamente toda aplicação web sendo, portanto, um conteúdo fundamental ao seu dia a dia.

A cada nova versão da plataforma Java Enterprise Edition, muitas são as atualizações em especificações, além, é claro, da adição de novas tecnologias.

Neste contexto, dentre as principais novidades lançadas na Java EE 7, podemos citar a nova API de aplicações Batch, que se baseou na já consolidada API Spring Batch, a API JSON-P, para manipulação de documentos no formato JSON, e a Concurrency Utilities, uma nova especificação que traz uma API para lidar com concorrência em aplicações Java EE.

Muito semelhante à API ExecutorService já presente na plataforma Java SE, a Concurrency Utilities busca resolver um problema bastante comum: lidar com threads em aplicações corporativas.

Além das novas especificações, várias tecnologias também obtiveram importantes atualizações como, por exemplo, a JPA 2.1, com o suporte transparente a chamadas de procedures, EJB 3.2, que passou a dar suporte a transações dentro dos métodos de callback do ciclo de vida dos EJBs, Bean Validation 1.1, cujas anotações podem ser utilizadas em parâmetros de métodos, e JSF 2.2, que possibilitou uma melhor integração com o HTML5 e trouxe as novas annotations @ViewScoped e @FlowScoped, que ajudam na criação de telas semelhantes a telas de wizards ou workflow, dando melhor suporte a fluxos de negócio passo a passo.

Ademais, tivemos também a nova versão da especificação JAX-RS, a 2.0, que possui uma nova API de cliente, quando até então era necessário utilizar bibliotecas ou APIs de terceiros, e também a API de JMS 2.0, que reduziu consideravelmente a verbosidade de código das versões anteriores. Assim, agora é mais simples e rápido criar componentes para enviar e receber mensagens JMS.

São muitas as novidades presentes na plataforma Java EE 7 e o leitor pode conhecer cada uma delas ao ler as Edições da Java Magazine 117, 119, 121, 122, 123, 124 e 125. Nessas edições, além dos conceitos teóricos da Java EE, o leitor poderá acompanhar vários exemplos práticos reforçando esses conceitos.

Devido à quantidade de mudanças e novidades, se torna inviável demonstrar todas elas em um único artigo. Sendo assim, vamos explorar alguns desses novos conceitos através de um exemplo prático.

A aplicação Controle de Projetos

A nossa aplicação exemplo tem como objetivo controlar os projetos desenvolvidos por uma empresa, possibilitando para isso a alocação de colaboradores, o controle da situação atual dos projetos e o cadastro de departamentos. Para termos uma ideia de como as classes do modelo de negócio desse sistema se relacionam, a Figura 1 apresenta o diagrama de classes da aplicação.

Figura 1. Diagrama de classes do projeto.

Nesta primeira parte do artigo construiremos a tela para cadastro de projetos. Nessa tela deve ser informado o nome do projeto, o orçamento, a descrição e a sua situação do projeto (em desenvolvimento, pré-venda, em análise e pós-venda).

Como um dos diferenciais, visando explorar mais recursos da plataforma Java EE, no projeto será construído um web service RESTful com JAX-RS, para que possamos, através da chamada a este serviço, inserir dados referentes a cidades e estados na base de dados.

Ao final desse primeiro artigo o leitor terá toda a arquitetura da aplicação criada, o banco de dados e uma tela de cadastro de projetos construída. Além disso, veremos como criar um componente para popular nosso banco de dados com dados de cidades e estados que serão utilizados na tela de cadastro de colaboradores da empresa.

Visão geral da arquitetura do sistema

As principais tecnologias para desenvolver o sistema estão presentes na Java EE 7.

Outras, como o Maven e o PrimeFaces, são amplamente difundidas no mercado e perfeitamente compatíveis com projetos desenvolvidos na plataforma Java EE.

Para configurar o projeto, utilizaremos o gerenciador de dependências Maven. Com essa ferramenta é possível gerenciar projetos Java de forma simplificada, configurando as dependências da aplicação em um único arquivo XML, além de permitir o gerenciamento do ciclo de vida do desenvolvimento (compilação, testes unitários, empacotamento e distribuição).

Além do Maven, a arquitetura do projeto terá o controle das dependências dos componentes feito pelo CDI 1.1, JPA 2.1 para acesso ao banco de dados na camada de persistência, EJB 3.2 para o desenvolvimento da camada de negócio, RESTful web services para popular dados de cidades e estados no banco de dados e JSF 2.2 para criação das telas do sistema juntamente com os componentes de interface rica do PrimeFaces 5.

Por fim, para fundamentarmos a base da aplicação, será adotado o Eclipse Kepler como IDE e a versão 1.7 do Java Development Kit (JDK).

Depois de pronto, nosso exemplo será implantado no servidor de aplicações GlassFish 4.0, compatível com a versão do Java EE 7. E o banco de dados escolhido para o desenvolvimento dessa solução foi o MySQL. Apesar disso, o leitor pode adotar o banco de dados que estiver mais familiarizado.

Todos os recursos necessários para implementação do sistema de controle de projetos devem estar instalados na máquina. O caminho para download desses pode ser encontrado na seção Links.

Construindo a aplicação Controle de Projetos

Com a arquitetura do projeto definida, podemos dar início à construção da aplicação. Para criar um projeto Maven dentro do Eclipse, clique no menu File, selecione New e depois Other. Feito isso, surgirá uma tela na qual devemos selecionar Maven e clicar em Maven Project.

Na sequência, marque a opção Create a simple Project e clique em Next para darmos prosseguimento à configuração de nosso projeto.

Nesse momento, vamos definir os parâmetros de configuração do Maven no nosso projeto. Portanto, informe no campo Group Id o valor “br.com.devmedia.controleprojeto”, em Artifact Id defina o valor “JMControleProjeto”, em Package especifique o valor “war” e em seguida clique em Finish.

Para completar a configuração inicial do projeto, ainda precisamos determinar algumas propriedades importantes. Assim, clique com o botão direito em cima do projeto JMControleProjeto no Eclipse e escolha a opção Properties.

Na tela que será exibida, selecione a opção Project Facets. Em seguida, vamos ajustar as configurações relacionadas às versões do Java, JSF e do módulo web que vamos fazer uso para desenvolver o sistema. Desse modo, selecione a versão 3.1 para Dynamic Web Module, o que especifica que vamos trabalhar com a última versão da API de Servlets. Na opção Java, escolha a versão 1.7, e por fim, a versão 2.2 para JavaServer Faces.

Depois clique no botão Ok. Após essas configurações a aplicação JMControleProjeto será criada no Eclipse com a estrutura de projetos do Maven.

Por fim, para concluir a criação de nosso projeto, vamos configurar o arquivo web.xml como mostra a Listagem 1.

Listagem 1. Arquivo web.xml da aplicação.

  <?xml version="1.0" encoding="UTF-8"?>
  <web-app version="3.1" xmlns="http://xmlns.jcp.org/xml/ns/javaee" 
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
     xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee 
     http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd">
   
   <display-name>Controle Projeto</display-name>
   
   <welcome-file-list>
    <welcome-file>Home.xhtml</welcome-file>
   </welcome-file-list> 

   
   <servlet>
    <servlet-name>Faces Servlet</servlet-name>
    <servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
   </servlet> 

   <servlet-mapping>
    <servlet-name>Faces Servlet</servlet-name>
    <url-pattern>*.xhtml</url-pattern>
   </servlet-mapping> 

  </web-app> 

Nesse arquivo podemos notar que a versão da API de Servlets que estamos utilizando é a 3.1, versão mais recente oferecida pela plataforma Java EE. Além disso, é definido qual será a página inicial de nosso sistema, neste caso a Home.xhtml, e também configuramos o FacesServlet, responsável por gerenciar todo o ciclo de vida das requisições web utilizando JavaServer Faces (JSF).

Por fim, criamos um mapeamento para que todas as requisições enviadas de páginas com extensão XHTML sejam controladas pelo FacesServlet.

Configurando o arquivo pom.xml

Após configurarmos o web.xml é necessário discriminar as bibliotecas e APIs que serão empregadas para a construção do nosso projeto. Deste modo, abra o arquivo pom.xml e mantenha as configurações da forma como mostra a Listagem 2.

Listagem 2. POM.xml com as configurações das dependências do projeto.

  1   <project xmlns="http://maven.apache.org/POM/4.0.0" 
  2      xmlns:xsi="http://www.w3.org/2001/XMLSchema-     instance"      
  3      xsi:schemaLocation="http://maven.apache.org/POM/4.0.0  http://maven.apache.org/xsd/maven-
  4        4.0.0.xsd">
  5    <modelVersion>4.0.0</modelVersion>
  6    <groupId>br.com.devmedia.controleprojeto</groupId>
  7    <artifactId>JMControleProjeto</artifactId>
  8    <version>0.0.1-SNAPSHOT</version>
  9    <packaging>war</packaging>
  10   <name>JMControleProjeto</name>
  11  
  12   <dependencies>
  13    <!-- Java EE 7 -->
  14     <dependency>
  15      <groupId>javax</groupId>
  16      <artifactId>javaee-api</artifactId>
  17      <version>7.0</version>
  18    </dependency>
  19 
  20    <!-- Servlet 3.1 -->
  21    <dependency>
  22     <groupId>javax.servlet</groupId>
  23     <artifactId>javax.servlet-api</artifactId>
  24     <version>3.1.0</version>
  25     <scope>provided</scope>
  26    </dependency>
  27   
  28   <!-- jsf 2 -->
  29    <dependency>
  30     <groupId>org.glassfish</groupId>
  31     <artifactId>javax.faces</artifactId>
  32     <version>2.2.8</version>
  33     <scope>compile</scope>
  34   </dependency>
  35 
  36   <!-- PrimeFaces-->
  37   <dependency>
  38      <groupId>org.primefaces</groupId>
  39      <artifactId>primefaces</artifactId>
  40     <version>5.0</version>
  41   </dependency>
  42   
  43   <!-- Hibernate -->
  44   <dependency>
  45    <groupId>org.hibernate</groupId>
  46     <artifactId>hibernate-core</artifactId>
  47    <version>4.3.6.Final</version>
  48   </dependency>
  49   <dependency>
  50    <groupId>org.hibernate</groupId>
  51     <artifactId>hibernate-entitymanager</artifactId>
  52     <version>4.3.6.Final</version>
  53   </dependency>  
  54  <dependency>
  55   <groupId>org.hibernate.javax.persistence</groupId>
  56    <artifactId>hibernate-jpa-2.0-api</artifactId>
  57    <version>1.0.1.Final</version>
  58  </dependency>
  59  <!-- Junit para Testes Unitarios -->
  60   <dependency>
  61     <groupId>junit</groupId>
  62     <artifactId>junit</artifactId>
  63     <version>4.11</version>
  64     <scope>test</scope>
  65   </dependency>
  66  </dependencies>
  67  
  68  <build>
  69   <finalName>JMControleProjeto</finalName>
  70   <plugins>
  71     <plugin>
  72        <artifactId>maven-compiler-plugin</artifactId>
  73        <version>3.0</version>
  74        <configuration>
  75           <source>1.7</source>
  76           <target>1.7</target>
  77        </configuration>
  78      </plugin>
  79    </plugins>
  80  </build>
  81  
  82</project>

Nesse arquivo informamos todas as ferramentas que serão utilizadas e suas respectivas versões. Vamos agora entender melhor cada uma das configurações presentes no pom.xml que acabamos de definir:

· Linhas 05 a 10: Configuração do projeto Maven. Nessas linhas informamos o groupId, que é a identificação do grupo ao qual o projeto pertence (em geral considera-se a estrutura de pacotes da aplicação); o artifactId, nome do artefato .war gerado no processo de build (neste caso JMControleProjeto.war); version, que define a versão atual do projeto; packaging, que especifica o tipo de empacotamento utilizado; e a tag name, que determina o nome do projeto;

· Linhas 14 a 18: configura a versão da Java EE que iremos utilizar, no caso a versão 7;

· Linhas 21 a 26: informa que iremos trabalhar com a versão 3.1 da API de Servlets;

· Linhas 29 a 34: configura a dependência da versão JSF 2.2, que será fornecida pelas bibliotecas presentes no servidor GlassFish;

· Linhas 37 a 41: informa a dependência do framework PrimeFaces 5.0;

· Linhas 44 a 57: configura a dependência do Hibernate como framework de persistência. A versão do Hibernate escolhida implementa a versão JPA 2.0;

· Linhas 60 a 66: informa a dependência para o framework de teste unitário JUnit;

· Linhas 70 a 79: configura que o projeto será compilado com a versão 7 do Java.

Definidas as dependências do projeto, podemos agora criar o banco de dados e configurar o datasource no servidor de aplicações.

Criando o banco de dados e o datasource

...

Quer ler esse conteúdo completo? Seja um assinante e descubra as vantagens.
  • 473 Cursos
  • 10K Artigos
  • 100 DevCasts
  • 30 Projetos
  • 80 Guias
Tenha acesso completo