Construindo um CRUD com Spring, REST e Mongo DB parte 1

Apresentação

Construir aplicações web é complicado. Quando se fala em Java, a coisa fica um pouco mais difícil, pois existem várias e várias soluções. Existem frameworks que facilitam a vida do programador, prometendo evitar boilerplate code, o código que lida com tecnologia.

Quando comecei o programar em Java para web tudo era difícil: não existia uma ferramenta para me ajudar com o deploy (logo após a conclusão do meu projeto veio o Ant), programava utilizando servlets (logo após veio o Struts) e não exisitia um jeito de gerenciar minhas dependências (o Maven ainda demorou um pouco para chegar).

Hoje temos um cardápio imenso de frameworks que evitam que o programador coloque a mão em tecnologia e preste atenção mais no negócio. Essa série de blogs tem a intenção de mostrar uma das soluções que usei para implementar um pequeno CRUD bem básico.

No primeiro post (este aqui), vou apresentar como construir as fundações do projeto. Como configurar o Spring MVC, quais as características que usei e subir um servidor Jetty para exemplificar.

No segundo post, vou apresentar como publicar um serviço rest e consumi-lo utilizando AngularJS, um framework MVVM da Google.

No terceiro post, vou apresentar uma implementação do CRUD utilizando dados em memória, ou seja List. Isso ainda é tecnologia, mas o melhor há por vir!

No quarto e último post, vou retirar essa implementação da persistência em memória e substituir por uma solução com Repositories e MongoDB.

Vamos lá para o primeiro post então!

Passo 1 - Criação da Estrutura do Projeto

Para iniciar, usei a IDE Netbeans e criei um projeto WEB, sem servidor pré-definido. Minha intenção é ter um projeto livre de servidor, pronto para eu fazer um deploy em qualquer servidor. Escolhi o servidor Jetty que pode ser inicializado com o Maven.

Depois disso alterei o pom.xml para colocar as dependências do Spring. Segue a tabela com as dependências do Spring.

(1)
groupId.....: javax
artifactId..: javaee-web-api
version.....: 7.0
scope.......: provided

(2)

groupId.....: org.springframework

artifactId..: spring-core

version.....: 4.1.1.RELEASE

(3)

groupId.....: org.springframework

artifactId..: spring-context

version.....: 4.1.1.RELEASE

(4)

groupId.....: org.springframework

artifactId..: spring-context-support

version.....: 4.1.1.RELEASE

(5)

groupId.....: org.springframework

artifactId..: spring-webmvc

version.....: 4.1.1.RELEASE

  

Para que o maven consiga resolver as dependências do spring de forma correta, adicionei a tag repositories para o meu pom.xml, conforme tabela abaixo.

(1)
id..: SpringSource Snapshots
url.: http://repo.springsource.org/libs-snapshot
enabled: true

(2)
id..: SpringSource Milestones
url.: http://repo.springsource.org/libs-milestone

Para iniciar o framework Spring de uma forma programática, criei uma classe chamada AppConfig.java. Essa é uma classe de configuração que elimina a necessidade do arquivo de configuração xml. Ela começa com a annotation @Configuration assinalando que essa classe é de configuração do Spring. Utilizei a annotation @ComponentScan para que o Spring verificasse em alguns pacotes os meus componente de serviço e meus controladores.

Ainda sobre inicialização, criei a classe CRUDPeopleWebInitializer.java que implementa WebApplicationInitializer do framework Spring. Essa classe é responsável pela criação de todos os objetos de minha configuração e inseri-las em um contexto do Spring.

Para publicar meu serviço inicial, criei a classe TestController.java, que publica somente três serviços:

1. http://localhost:8080/crudpeople/testservice/test
2. http://localhost:8080/crudpeople/testservice/echo/{message}
3. http://localhost:8080/crudpeople/testservice/api

Ao acessar o primeiro serviço, o usuário receberá a mensagem testing na tela. O segundo serviço deve ter uma mensagem que será replicada. O terceiro serviço irá mostrar um array das URLs listadas acima.

Anote com @Controller sua classe para que ela vire um componente do Spring. Anote a classe com @RequestMapping para que os métodos passem a ser vistos como um serviço. Adicione um valor padrão que será considerado como um caminho raiz para cada serviço a ser publicado. Indiquei que todos meus serviços produzem uma resposta em JSON. O código abaixo exemplifica o uso dessa anotação:

@RequestMapping(value = "/crudpeople/testservice/*",
        produces = {"application/json;charset=UTF-8"})

Para cada método público que quero publicar como serviço, anoto novamente com @RequestMapping, porém, dessa vez, digo para ele qual o nome do meu serviço a ser publicado. Como exemplo, o meu serviço test:

    @RequestMapping(value = "/test", method = RequestMethod.GET)
    public @ResponseBody
    String test() {
        LOGGER.log(Level.INFO, "Callling /test service");
        return "testing";
    }

Preciso indicar qual o nome do meu serviço (value) e qual o método pelo qual ele será chamado (RequestMethod.GET). Note que ainda existe uma outra anotação @ResponseBody antes do retorno na assinatura do método, o que indica que quando meu método retornar alguma coisa ele retornará o objeto que o método retorna. Poderia criar um objeto mais complexo, ao invés de retornar uma String, mas meu objetivo agora é somente testar a publicação de serviço.

Para acessar, devemos iniciar o servidor Jetty utilizando o maven pela linha de comando. Se gosta de utilizar sua IDE para executar o maven, não existe problemas. Iniciando pela linha de comando deve-se digitar, no diretório raiz do projeto, onde se encontra o arquivo pom.xml:

mvn dependency:resolve clean install jetty:run

O que faz o Jetty ser executado é um plugin na tag build do arquivo pom.xml. Seguem as informações do plugin:

groupId.....: org.mortbay.jetty
artifactId..: jetty-maven-plugin
version.....: ${jetty.maven.plugin}

Defini uma propriedade para a variável ${jetty.maven.plugin} = 8.1.5.v20120716.

Se tudo der certo (e qual a razão de não dar certo?) é possível acessar essas URLs em seu browser. Use o Chrome para uma melhor renderização. As figuras abaixo mostram o resultado desse primeiro passo.

Para acessar o código do projeto no branch do Passo 1, basta baixar o zip no endereço https://github.com/ortolanph/CRUDPeople/tree/passo01.

Próximo passo, usar AngularJS para consumir os serviços e exibir os resultados no browser.