Google App Engine: Utilizando Spring MVC

O desenvolvimento de software na nuvem não se restringe apenas aos desenvolvedores que atuam em times de grandes empresas de TI. Hoje podemos encontrar uma variedade de infraestruturas ou plataformas como serviço para que qualquer desenvolvedor possa ingressar nesse mundo, inclusive de forma gratuita, como é o caso do Google App Engine.

O Google App Engine, ou GAE, como é popularmente conhecido, é uma plataforma robusta e altamente escalável para hospedagem de aplicações web na nuvem.

Além de fornecer esta plataforma, o Google também disponibiliza um excelente kit de desenvolvimento (SDK) para a criação de aplicações específicas para este ambiente.

Com esse kit é possível simular localmente os serviços de Memcache, Task Queue (serviço de fila para execução de processos em background), Mail e Datastore (banco de dados não relacional altamente escalável) encontrados no App Engine.

Desta forma, o desenvolvedor consegue emular o ambiente do GAE em seu próprio computador, agilizando o desenvolvimento. Então, uma vez que a aplicação esteja pronta em seu computador, basta realizar um simples deploy, tornando-a disponível na nuvem do Google.

Este cenário faz do GAE uma plataforma de desenvolvimento muito atrativa, conquistando a cada dia mais adeptos.

Apesar de todas essas vantagens, o Java Runtime Environment (ou JRE) do GAE não possui todas as classes que conhecemos e estamos acostumados. Na documentação do Google App Engine podemos encontrar uma white list informando as classes do JRE que podem ser utilizadas (veja a seção Links).

Com esta restrição, algumas APIs da plataforma Java EE e alguns frameworks que dependem das classes que ficaram de fora do JRE não podem ser utilizados no GAE. Como exemplo de APIs da Java EE que não são suportadas, podemos citar EJB, JMS e JNDI.

No entanto, mesmo com essas restrições, veremos neste artigo que é possível, e de forma simples, criar aplicações web para o App Engine empregando alguns dos frameworks mais populares do mercado, o Spring MVC e o Apache Tiles.

Google App Engine

O Google App Engine é uma plataforma como serviço (Platform as a Service, ou PaaS) para desenvolvimento e hospedagem de aplicações web criada em 2008 pelo Google.

Nessa plataforma, encontramos diversos serviços que podemos fazer uso sem que tenhamos que nos preocupar com configurações ou infraestrutura. Como exemplos de serviços desse tipo podemos citar o Mail, Memcache, OAuth, Task Queue, XMPP, entre outros.

Em sua versão atual, o App Engine suporta as seguintes linguagens de programação: Java, Python, PHP e Go, mas tem planos para suportar mais linguagens no futuro.

Apesar de todos esses benefícios, a plataforma também possui algumas restrições, a saber:

• Os desenvolvedores têm acesso somente leitura ao sistema de arquivos do diretório da aplicação, ou seja, não é possível escrever dados neste;
• Uma requisição é interrompida caso a aplicação leve mais de 60 segundos para processar e retornar uma resposta;
• Nem todas as classes do Java (JRE) estão disponíveis para uso.

No entanto, mesmo com essas restrições, o GAE é uma ótima opção de Cloud. Isso pode ser facilmente notado pelo fato de grandes empresas como a Rovio, MAG Interactive e Blosson.io passarem a utilizar o App Engine como plataforma para suas aplicações web, e até mesmo mobile.

Spring MVC

O Spring MVC é um módulo do Spring Framework que foi desenvolvido para ser utilizado em aplicações web, tendo como característica fornecer mecanismos para que seja possível aplicar de forma fácil o padrão MVC (Model-View-Controller).

Os desenvolvedores do Spring sentiram a necessidade de desenvolvê-lo porque notaram que os frameworks existentes na época não eram fieis às camadas do MVC, deixando alguns pontos a desejar.

Uma característica positiva e marcante do Spring MVC é a facilidade de integração com os diversos módulos do Spring Framework, e também com outros frameworks de mercado, como é o caso do Velocity, Apache Tiles (que abordaremos no próximo tópico), dentre muitos outros.

Apache Tiles

O Tiles é um framework para criação de templates utilizado em interfaces de usuário em aplicações Java voltadas para a web e que possuem como base o padrão MVC.

Através de pequenos fragmentos de página, os chamados tiles, é possível criar templates reutilizáveis que serão construídos em tempo de execução para compor uma página a ser exibida ao usuário.

Essa característica de composição descreve o padrão conhecido como Composite.

O uso do Tiles reduz consideravelmente a duplicidade de código, o tempo de desenvolvimento e a manutenção da aplicação, uma vez que é possível reutilizar cada fragmento de página na criação de templates, inclusive a combinação de templates para compor outros e assim originar páginas mais elaboradas.

Podemos considerar como exemplo muito comum de reutilização de fragmento de página, o seguinte cenário: imagine que sua aplicação possua um sidebar fixo que deve ser exibido em todas as telas, e este possua alguns componentes como logo da empresa, nome da aplicação, nome do usuário logado, botão de logout, entre outros.

Para evitar a replicação deste trecho de código em todas as páginas, podemos, com a ajuda do Apache Tiles, criar um fragmento com o conteúdo do sidebar e incorporá-lo a um template. Feito isso, bastaria às páginas do sistema estender esse template, e todas elas passariam a ser compostas pelo sidebar.

Configuração do projeto

Agora que conhecemos um pouco das principais tecnologias que utilizaremos na aplicação exemplo, passaremos para a fase de preparação e configuração do projeto, para então iniciarmos o desenvolvimento.

O primeiro passo para a configuração da aplicação é criar a estrutura de diretórios do projeto, o que é realizado executando o comando apresentado seguir.

Essa estrutura de diretórios é definida pelo Maven. Este, além de nos auxiliar com a estrutura de diretórios, também será essencial para o gerenciamento das dependências de nossa aplicação.

mvn archetype:generate -DgroupId=br.com.javamagazine -DartifactId=cursos -DarchetypeArtifactId=maven-archetype-webapp -DinteractiveMode=false

Ao executar o comando supracitado, teremos como resultado um projeto chamado “cursos”. Para facilitar o desenvolvimento deste, vamos importá-lo para uma IDE. No caso deste artigo, optamos pelo Eclipse. Assim, execute o seguinte comando na pasta raiz do projeto:

mvn eclipse:eclipse –Dwtpversion=2.0

Com esses passos concluídos, podemos dar início à declaração das dependências da aplicação, como veremos no tópico a seguir.

Configurando o pom.xml

Um arquivo POM, ou Project Object Model, é usado basicamente para declararmos as dependências do projeto, os plugins utilizados para integração com ferramentas externas, e como iremos empacotar nossa aplicação (JAR ou WAR, por exemplo).

Iniciaremos a configuração de nosso pom.xml declarando o plugin do Google App Engine. Essa declaração deve ser inserida entre as tags <plugins> e </plugins> (veja a Listagem 1). Com esse plugin é possível rodar localmente nossa aplicação simulando o ambiente do GAE, ou até mesmo realizar o deploy da aplicação na nuvem.

<build>
<plugins>
  <plugin>
    <groupId>com.google.appengine</groupId>
    <artifactId>appengine-maven-plugin</artifactId>
    <version>${appengine.target.version}</version>
    <configuration>
      <jvmFlags>
        <jvmFlag>-Xdebug</jvmFlag>
        <jvmFlag>
          -agentlib:jdwp=transport=dt_socket,address=1044,server=y,suspend=n
        </jvmFlag>
      </jvmFlags>
      <disableUpdateCheck>true</disableUpdateCheck>
    </configuration>
  </plugin>
 
  <!-- Outras declarações omitidas -->
 
  </plugins>
</build>"