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
