pedrocacique

Torneio Marvel - Parte 1 - Configurando o Projeto

13 de março de 2016

Olá pessoas!

Em uma das disciplinas que leciono na Universidade Presbiteriana Mackenzie, estamos trabalhando com um projeto estruturado em uma arquitetura em camadas. Como prova dos conceitos estudados em sala, estou desenvolvendo com os alunos um projeto chamado Torneio Marvel, que funciona como um Super Trunfo de heróis.

Para este projeto, estamos desenvolvendo um sistema em Java, no Netbeans, que tenha um banco de dados próprio e parte da informação obtida por meio de um webservice de terceiros (no caso, a API de desenvolvimento da Marvel).

Estamos usando o serviço fornecido pela própria Marvel e não temos nenhum fim lucrativo para este projeto, sendo o seu objetivo maior o aprendizado da tecnologia. Para conhecer mais sobre o serviço acesse: http://developer.marvel.com

Antes de começarmos, atenção para os direitos de uso e cópia do projeto:

Creative Commons License
Torneio Marvel by Pedro Cacique is licensed under a Creative Commons Attribution-NonCommercial 4.0 International License.

E ainda:

"Data provided by Marvel. © 2014 Marvel"

www.marvel.com

Quero compartilhar aqui o desenvolvimento, pois acho que podemos usar a base deste projeto para muitos outros.

Estou dividindo a apresentação em algumas etapas, que serão distribuídas nos posts seguintes.

  1. Preparação do projeto

  2. Persistência de dados

  3. Estrutura do projeto e Design Patterns

  4. Consumo de webservices

  5. Lógica do jogo

  6. Camada de Apresentação

  7. Log de utilização com JMS

Bom, vamos começar então com a preparação do projeto no Netbeans.

Fique a vontade para enviar dúvidas ou mesmo sugestões de melhorias. Lembre-se que esta não é uma fórmula absoluta e possivelmente existam outras melhores. Assim, caso tenha alguma sugestão ou mesmo correção, sinta-se a vontade para comentar cada post ou mesmo enviar-me uma mensagem privada.

Bom trabalho!

Preparação do Projeto

Usaremos a IDE Netbeans para o desenvolvimento e ao longo dos posts, compartilharei alguns atalhos para as tarefas principais.

Criaremos um projeto com base na arquitetura JEE, que define cinco camadas para elaboração do projeto.

Observe que estamos tratando de um sistema Cliente-Servidor multicamadas. A camada cliente, que roda no computador do usuário é responsável pela apresentação. Nela serão criadas as páginas de interface com o usuário. Usaremos tecnologias como HTML, CSS e JS.

Na Camada Web, teremos a parte da apresentação que é desenvolvida no lado do servidor. Temos aqui os nossos JSPs, por exemplo. Que apesar de rodarem no servidor, não possuem lógica de negócios do nosso sistema.

A Camada de Negócios é a responsável por toda a lógica do sistema. Aqui teremos os Beans de Sessão do nosso sistema, os EJBs.

Por fim, temos as camadas relacionadas à persistência dos dados. A camada de Dados contém os dados puramente como são armazenados. Seja em um banco de dados relacional ou em qualquer outra forma de armazenamento. A Camada de Persistência (algumas vezes omitida na definição JEE) é a responsável pelo acesso aos dados. Nela são comumente encontradas classes que implementam padrões de design como o DAO (Data Access Object).

Comecemos criando um projeto do tipo Enterprise Application:

Vamos chamá-lo de TorneioMarvel

E em seguida, criaremos de uma vez os módulos EJB e WAR, que farão parte do projeto principal:

Observe que ao criarmos um projeto do tipo Enterprise Application, são criados três projetos distintos. O primeiro (com o ícone de um triângulo) é o principal, responsável pela gerência dos outros dois. O segundo (com o ícone de um grão de café, ou algo parecido) é o módulo EJB que será executado inteiramente no servidor de aplicações. O último (com o ícone de um globo azul) é o projeto web, que terá parte das camadas de apresentação e parte da camada de lógica. 

Como trabalharemos com um banco de dados, tenho o costume de inicializar a conexão nesta primeira parte do projeto, garantindo que ela esteja pronta para quando começarmos a persistência dos dados.

Estabelecendo a conexão com o banco de dados

Usaremos o Sistema Gerenciador de Banco de Dados (SGBD) Derby, por já vir com a instalação do Netbeans e pela facilidade de implementação para o nosso projeto. Usaremos ainda o GlassFish (também acompanha a instalação do Netbeans) como servidor de aplicações.

Na aba de serviços, temos o primeiro serviço relacionado aos bancos de dados e seus gerenciadores. Configuraremos a nossa conexão para que seja salva em uma pasta interna do projeto, assim, podemos levar as configurações do banco juntamente com o projeto principal.

Para configurar o banco de dados, clique com o botão direito sobre o item Java DB e selecione propriedades.

Na janela que se segue, você pode configurar o diretório de instalação do driver do Derby e a localização do banco de dados.

Alguns usuários têm enfrentado dificuldades de conexão do Derby, instalado no diretório do JDK (que veio com o Netbeans). Pode ser interessante apontar a instalação do Java DB para a pasta javadb localizada no diretório de instalação do GlassFish.

Na localização do banco de dados, costumo apontar para a pasta do projeto principal e complemento com /db, para a criação de um novo diretório exclusivo para o banco.

Com o sistema configurado, criaremos o banco de dados para a nossa aplicação. Clique com o botão direito em JavaDB e selecione a opção Criar Banco de Dados.

Em seguida, escolha o nome do seu BD, nome de usuário e senha para acesso do mesmo. Para simplificar, usarei o usuário cacique, com senha 123.

* Observe que você ainda pode alterar a localização do BD nesta etapa, clicando em Propriedades

Quando uma nova é criada, ela é adicionada na lista de conexões, com um ícone que se parece com uma peça de quebra-cabeça amarela. Dê um clique duplo na sua conexão para que ela seja realizada. Observe que o ícone une as duas partes, mostrando que esta conexão está ativa.

Ao maximizar o item, perceba que o esquema principal aparece em negrito e foi criado com o nome de usuário que você definiu anteriormente. Você pode criar outros esquemas, caso deseje. Para o esquema selecionado, você pode visualizar as tabelas, visões e procedimentos do BD.

Preparando os recursos de acesso ao BD

Quando formos trabalhar com a persistência de dados, precisaremos de uma conexão estabelecida com o SGBD. Este passo poderá ser realizado automaticamente com a criação da unidade de persistência. Entretanto, tenho percebido que em alguns casos (sobretudo trabalhando em um macbook), que a criação automática dos recursos nem sempre é uma boa escolha. Por isso, detalharei este processo a seguir.

Ainda na aba de serviços, podemos acessar as configurações dos servidores de aplicações instalados. Você pode adicionar novos servidores clicando com o botão direito sobre o item Servidores.

Usaremos o servidor GlassFish para este projeto. Clique com o botão direito sobre ele e escolha a opção Start para inicializar o servidor. Em seguida, repita o processo escolhendo a opção Exibir Console do Administrador.

Você será direcionado para uma página web de acesso ao console do administrador do Glassfish (normalmente sob o endereço http://localhost:4848/ ).

Configuraremos agora os nossos recursos de JDBC. No menu lateral esquerdo, selecione o item JDBC e em seguida JDBC Connection Pools.

Uma lista de Connection Pools existentes será exibida. Clique sobre o botão New para criar uma nova pool.

Entre com as propriedades da nova pool, criando um nome para ela, determinando o tipo de recurso como java.sql.Driver e em seguida o SGBD Derby. Clique no botão Next, localizado no canto superior esquerdo, para configurar as próximas informações.

Observe que esta nova tela apresenta informações gerais sobre a pool, como números e conexões, tempo de inatividade e tempo máximo de execução, por exemplo. A parte que nos interessa é a final, onde colocaremos as configurações da conexão que criamos.

Entre com a URL da conexão, nome de usuário e senha. Para obter a URL da conexão, volte ao netbeans e clique com o botão direito sobre a conexão que criamos anteriormente e selecione Propriedades. A URL é o primeiro atributo mostrado na janela que se abre. Após inserir os dados solicitados, finalize a pool.

Estamos quase lá!

Vamos, agora, criar o acesso que permitirá a nossa unidade de persistência conectar-se com o BD. No menu esquerdo, selecione agora o primeiro subitem de JDBC, JDBC Resources.

Novamente, clique sobre o botão New para criarmos um novo recurso JDBC. Na tela que se segue, selecione o nome do recurso e a pool que acabamos de criar e finalize.

Pronto!

Já temos o nosso projeto criado, com o seu BD e o recurso JDBC com o seu devido nome JNDI para que possa ser acessado pela unidade de persistência.

Na próxima parte deste tutorial, criaremos as classes de entidade e os mecanismos de persistência dos dados em um EJB.

Que tal fazer um cafezinho enquanto preparo a próxima parte?

Até breve!