CRUD usando Java EE em 7 passos

Nessa postagem vamos mostrar um dos CRUD mais rápidos que você irá fazer na sua vida! Iremos usar o ótimo projeto Wildfly Swarm e o eclipse como ambiente desenvolvimento.
Notem que não estamos focando em detalhes de arquitetura no nosso projeto, não estamos seguindo boas práticas, o objetivo é as pessoas verem as coisas acontecendo.

Um CRUD, (create, retrieve, update and delete) é sobre fazer as 5 operações básicas com um objeto armazenado em uma fonte de dados.

O que iremos precisar? 

Em primeiro lugar, certifique-se de ter baixado o Eclipse Mars ou um mais novo, o importante é incluir suporte ao Maven.

Falando em Maven, se você tiver instalado o mesmo na sua máquina, abra o eclipse e aponte para a sua instalação. Vá em Preferences -> Maven -> Installations. Nessa tela você clica em Add e aponte para o diretório de instalação do Maven.

Sugerimos também ter o Java Development Kit 8 instalado.

Isso é basicamente tudo o que precisamos! Vamos aos passos.

Passo 1: Gere o projeto do site do Wildfly Swarm

O primeiro passo é ir ao site http://wildfly-swarm.io/generator e gerar um projeto com as seguintes dependências: EJB, JAX-RS with CDI e JPA. Entre o Group ID e o Artifact ID que você quiser, eu entrei com org.aprendendojee.crud e crud respectivamente.

Gerando o projeto no site do Wildfly Swarm

 "Deszipe" o arquivo em algum lugar na sua máquina.

 

 Passo 2: Importe o projeto no Eclipse

Esse passo é bem fácil. Abra o eclipse, vá em File -> Import... Vai aparecer uma janela com todos os tipos possíveis de projetos que você pode importar. Procure por Existing Maven Projects, selecione e na próxima tela aponte para o diretório onde você descompactou o arquivo baixado (esse é o diretório que tem o arquivo pom.xml).

Importando o projeto baixado

Note que esse passo pode demorar um bom tempo se você estiver com um repositório limpo. É esse momento que o Eclipse faz um build do projeto para baixar as bibliotecas requeridas.

Passo 3: Crie as classes do projeto

Esse é o passo que assusta as pessoas, pois ainda há o mito de como Java EE é difícil... Vamos mostrar hoje que não.
Vamos criar primeiramente uma classe de modelo. Classes de modelo são aquelas que representam o negócio da aplicação, classes que representam coisas da vida real. Para esse nosso pequeno projeto de demo, vamos criar uma classe produto com os seguintes campos privados:

• ID: Um campo do tipo long para identificar unicamente um produto;
• Nome: Campo do tipo String que representa o nome do produto;
• Preço: Campo float com o preço do produto;
• Quantidade: Um campo do tipo int com a quantidade em estoque.

Assim criamos essa classe em um pacote de usa escolha e com os campos privados. Agora vem uma parte chata que pode ser automatizada pelo eclipse. Clique com o botão direito sobre a classe Produto, vá em Source -> Generate getters and setters, selecione todos os campos e clique em OK. Magic.

Agora vamos criar outra classe, a que tem as operações que precisamos. Vamos chamar ela de ProdutoService. essa classe tem 4 métodos:

• buscarTodos: busca todos os produtos que temos no nosso banco de dados e retorna um java.util.List com eles.
• criar: cria o produto passado como parâmetro;
• atualizar: atualiza o produto se presente no banco de dados;
• apagar: apaga o identificado pelo ID passado como parâmetro.

Esse classe ainda deve ter um atributo do tipo javax.persistence.EntityManager. Mais pra frente vai ficar claro o uso do mesmo, mas o nome desse atributo é em e é com ele que fazemos as operações com nosso banco de dados.

Por fim, crie uma classe que representa a aplicação. Chamamos a nossa de ProdutoApp. Como vamos usar Web Services REST, essa classe deve estender de javax.ws.rs.core.Application.

A classe que vai mais código é a ProdutoServiceo, mas hoje em dia é muito fácil implementar um CRUD com o entity manager, veja:

• Podemos criar uma query e listar os resultados usando o método createNamedQuery. Nosso método buscarTodos vai fazer o seguinte: em.createNamedQuery("select p from Produto p", Produto.class).getResultList();
• Criar um objeto pode ser feito através de em.persist(produto)
• Atualizar é unir o estado do objeto passado com o estado do objeto no banco de dados. Assim fazer o seguinte: em.merge(produto)
• Para apagar o objeto pegamos o ID passado como parâmetro e  usamos o método em.remove: Produto p = em.find(Produto.class, id); em.remove(p);

Pronto, a partir desse ponto não precisamos mais escrever código Java! Só anotar.

Passo 4: Anote as classes corretamente

Nosso projeto está quase terminado, mas as classes estão vazias, são códigos sem significado. Vamos dar significado ao código adicionando anotações Java
A classe produto precisa se tornar uma entidade, para isso adicionamos a anotação @javax.persistence.Entity  sob a declaração da classe e antes da declaração do campo ID adicionamos as anotações javax.persistence.Id
 e javax.persistence.GeneratedValue, que respectivamente dizem que o campo ID vai identificar a entidade unicamente e que o valor desse campo deve ser gerado automaticamente. Aqui vai o código inteiro da nossa classe:

Código completo da clsase Produto

Agora vamos anotar a classe ProdutoService. A declaração da classe deve ter as seguintes anotações:   

• @javax.ejb.Stateless: que transforma a classe em um EJB sem estado, ou seja, o ciclo de vida dela passa a ser controlado pelo container e outras funcionalidades sao implementas pelo container, como gerenciamento de transações
• @javax.ws.rs.Path: transforma a classe em um Web Service REST! Já falamos sobre isso no nosso artigo sobre introdução ao JAX-RS;
• @javax.ws.rs.Consumes  e @javax.ws.rs.Produces  são usados para informar o formato de dados usado no nosso Web Service. No nosso caso usamos JSON e informamos isso usando a constante APPLICATION_JSON da classe javax.ws.rs.core.MediaType

Agora anotamos o atributo em, que criamos anteriormente, com @javax.persistence.PersistenceContext. Com ela o container irá criar para nós uma instância do EntityManager e injetar na classe!

Por fim, anotamos os métodos com anotações JAX-RS, como @PathParam, @GET, @DELETE e @PUT para satisfazer o esquema de URIs do nosso Web Service REST. Como já falamos, isso foi explicado no post de introdução ao JAX-RS. Veja como fica nossa classe:

Classe ProdutoService que faz as chamados com o EntityManager

 Por fim, nossa classe ProdutoApp deve receber a anotação javax.ws.rs.ApplicationPath("rest") indicando que os Web Services REST ficam na URL "rest".


Pronto! Chega de Java.

Passo 5: Configure o acesso ao banco de dados

Vamos usar um banco de dados em memória que pode ser facilmente modificado. O acesso ao banco de dados é configurado através de um datasource e por padrão o WildflySwarm vai criar um datasource de acesso a um banco de dados em memória. No entanto, você pode criar seu próprio Datasource. Para fins de simplicidade, nesse tutorial estamos criando somente o arquivo persistence.xml,  Esse é o único XML da aplicação e ele deve ficar no diretório src/main/content/META-INF - O conteúdo do arquivo é o seguinte:

Passo 6: Crie uma página WEB para poder acessar o serviço

Esse passo já não é mais sequer relacionado com Java ou Java EE, mas adicionamos a nossa página WEB para referência. O arquivo index.html fica no diretório src/main/webapp/ e usa JQuery e simples HTML para mostrar e permitir alteração dos dados. É realmente uma página muito simples, veja todo o conteúdo:



Como podem ver usamos JQuery e também um arquivo Javascript adicional. O arquivo index.js, que também está em src/main/webapp/, pode ser visto a seguir:





Passo 7: Testar!

A hora mais legal é ver tudo em funcionamento! Para isso, clique com o botão direito sobre o projeto e então Run As -> Maven Build... Na janela que aparecer escreve wildfly-swarm:run 



 Clique em Run e aguarde o servidor subir(a primeira vez pode demorar um pouco mais, pois dependências serão baixadas). Quando ler a seguinte linha no console, você pode acessar a aplicação:

INFO  [org.wildfly.extension.undertow] (ServerService Thread Pool -- 13) WFLYUT0021: Registered web context: /

 
Agora use seu navegador e acesse localhost:8080



FIM!

Conclusão

Mostramos como criar um CRUD com Java EE em alguns passos. O código está no github: https://github.com/AprendendoJava/blog-aprendendo-jee/tree/master/crud-wildfly-swarm