Desenvolvimento em Java 2.0: Gaelyk para Google App Engine

Uma estrutura baseada em Groovy torna o desenvolvimento rápido no Google App Engine ainda mais rápido

A introdução do Google App Engine fez com que várias estruturas emergissem para facilitar o desenvolvimento de aplicativos dirigidos a ele. A estrutura Gaelyk, uma dessas estruturas escrita em Groovy, facilita o desenvolvimento de aplicativos leves que alavancam um armazenamento de dados. E a escalabilidade que se pode alcançar é impressionante.

Andrew Glover, Author and developer

Andrew GloverAndrew Glover é desenvolvedor, autor, palestrante e empresário com uma paixão por desenvolvimento orientado a comportamento, Integração Contínua e desenvolvimento de software Agile. É possível entrar em contato com ele em seu blog.



26/Mar/2010

Esta série explora alguns aspectos da tecnologia que estão moldando o desenvolvimento Java™ agora e no futuro. A premissa do desenvolvimento em Java 2.0 é que o desenvolvimento está acontecendo em um ritmo mais rápido, graças a uma explosão de inovação no mundo do software livre e à transformação do hardware em commodity. É possível pegar emprestado ou alugar a plataforma de hardware para hospedar seu aplicativo (montado, em grande parte, a partir de bibliotecas, ferramentas e estruturas livres) por uma fração do custo de adquirir e manter sua própria infraestrutura.

Sobre esta série

O panorama do desenvolvimento em Java passou por mudanças radicais desde que a tecnologia Java surgiu. Graças a estruturas livres maduras e a infraestruturas de implementação confiáveis para aluguel, agora é possível montar, testar, executar e manter aplicativos Java de maneira rápida e barata. Nesta série, Andrew Glover explora a gama de tecnologias e ferramentas que tornam possível esse novo paradigma de desenvolvimento em Java.

A primeira parte desta série, "Hello Google App Engine", examinou a ideia de utilizar a infraestrutura do Google para hospedar seu aplicativo em Java de graça, mas com desvantagens em termos de flexibilidade. Nos artigos subsequentes, você aprendeu a diferença entre o App Engine e o EC2 da Amazon. A coluna do mês passado ("REST up with CouchDB and Groovy's RESTClient") examinou uma alternativa promissora aos bancos de dados relacionais: CouchDB. A falta de esquema e a orientação a documentos do CouchDB podem parecer novos, mas você já viu outro armazenamento de dados sem esquemas em ação com o Google App Engine.

Este artigo completa o ciclo da série, voltando ao Google App Engine. O mundo do software livre já embarcou na onda do App Engine, com a emergência de estruturas que facilitam o desenvolvimento de aplicativos dirigidos à plataforma. Você verá como um projeto livre chamado Gaelyk está tornando ainda mais fácil a construção de aplicativos que tiram proveito das muitas tecnologias abordadas por esta série até o momento.

O leve é o novo rápido

Apesar da infraestrutura do Google ser predominantemente gratuita (lembre-se, é necessário pagar quando atingir 500mb de armazenamento e ultrapassar a largura de banda para servir 5 milhões de visitas por mês), as desvantagens existem em termos de flexibilidade. A infraestrutura do Google suporta a tecnologia Java, mas não todas as principais bibliotecas Java ou as bibliotecas livres relacionadas. O App Engine é uma plataforma — você deve desenvolvê-la. Porém, previsivelmente, as inovações de software livre estão ajudando a superar os problemas que podem ser vistos como barreiras para a adoção do Google App Engine.

Um desses projetos, denominado Gaelyk, é uma eficiente estrutura que facilita o desenvolvimento de aplicativos leves, escritos em Groovy, que tiram proveito do padrão Model-View-Controller (MVC). E através da mágica da Groovy, o Gaelyk acrescenta alguns recursos fáceis de usar aos APIs do App Engine. Além disso, é possível usar o Gaelyk junto com o plug-in do Google App Engine para Eclipse. O rápido desenvolvimento e implementação dos aplicativos do Google App Engine não poderiam ser mais fáceis.

Persistência Google

A implementação de persistência do Google App Engine é, em grande medida, protegida de você, mas você pode ter certeza de que ele não é um banco de dados relacional. Ainda assim, você, o desenvolvedor, pode salvar, ler, atualizar e excluir objetos de persistência por meio da plataforma Google através do código normal de Java Data Objects (JDO), ou até mesmo por meio do API de persistência de baixo nível do Google.

O artigo "REST up with CouchDB and Groovy's RESTClient" utilizou um sistema de multas de estacionamento para demonstrar a natureza de um banco de dados orientado a documentos. Seguindo o exemplo, neste artigo criaremos um aplicativo da Web que possibilita a criação, atualização e remoção de multas. A arquitetura de persistência do Google não é orientada a documentos, mas a falta de esquemas permite um modelo bem flexível. Assim, o aplicativo da Web tentará criar um modelo de multa da forma mais precisa possível, capturando:

  • Nome do policial
  • Data
  • Local
  • Infração
  • Qualquer observação associada

Simplesmente deixarei o local como uma caixa de texto genérica, pois é possível representar onde uma infração ocorreu de várias maneiras — como no estacionamento da Best Buy ou na esquina entre a 18th St. e a D St. Basicamente, não tentarei delinear um formato específico, pois de qualquer maneira não é necessariamente relevante ao assunto.

Para começar, é preciso ter o plug-in do Google App Engine para Eclipse instalado (consulte "Hello Google App Engine" para encontrar instruções). Também é preciso fazer o download do arquivo JAR do Gaelyk no site do projeto (consulte Recursos). Lembre-se de onde esse download está, pois ele deverá ser movido para um diretório específico em breve.

A estrutura Gaelyk depende da Groovy, portanto também é preciso instalar o release mais recente da Groovy: um simples arquivo JAR, groovy-all-1.6.5.jar quando este artigo foi escrito (consulte Recursos). Finalmente, é preciso criar um ID de aplicativo através do painel de administração do Google App Engine. (É possível reutilizar aquele que você criou em "Hello Google App Engine" se desejar.)

Em seguida, crie um novo Google Web Application Project no Eclipse, clique no botão Next, e preencha as informações apropriadas. Certifique-se de desmarcar a opção Use Google Web Toolkit, como eu fiz na Figura 1, pois ela não será necessária.

Figura 1. Criando um Google Apps Project no Eclipse
Create a new Google Web Application Project within Eclipse dialog box

Clique no botão Finish, e então você já possuirá o começo de uma base de código.

Agora copie os arquivos JAR da Groovy e do Gaelyk no diretório war/WEB-INF/lib do seu projeto recém-criado, mostrado na Figura 2:

Figura 2. Bibliotecas necessárias do Gaelyk
Picture of your newly created project's war/WEB-INF/lib directory with the Groovy and Gaelyk JARs copied in

Para configurar o Gaelyk, é necessário fornecer ao Google App Engine algumas informações adicionais através da edição do arquivo WEB-INF/appengine-web.xml. Coloque seu ID de aplicativo na seção de aplicativo na parte superior desse arquivo, e adicione o código XML mostrado na Listagem 1:

Listagem 1. Atualizações necessárias para a configuração do App Engine
<static-files>
 <exclude path="/WEB-INF/**.groovy" />
 <exclude path="**.gtpl" />
</static-files>

Essa adição impede que o Google App Engine sirva diversos arquivos estaticamente que você acabará criando como parte do seu uso do Gaelyk. Como verá mais adiante, o Gaelyk tira proveito de um modelo de modelagem. Assim, arquivos terminados em .gtpl agirão como JavaServer Pages (JSPs) e serão processados através da estrutura ao invés do App Engine.

A seguir, abra o arquivo web.xml, também encontrado no diretório WEB-INF. Esse é o arquivo padrão de configuração de aplicativos da Web que todos nós aprendemos a amar ao longo dos anos. (Você trabalhou com esse arquivo quando visitou o App Engine e o EC2 pela primeira vez.) Esse arquivo precisa mapear vários padrões de servlets específicos, portanto faça o seu arquivo ficar parecido com a Listagem 2:

Listagem 2. Arquivo web.xml atualizado
<?xml version="1.0" encoding="utf-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns="http://java.sun.com/xml/ns/javaee"
	xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
    version="2.5">
 <servlet>
  <servlet-name>GroovletServlet</servlet-name>
  <servlet-class>groovyx.gaelyk.GaelykServlet</servlet-class>
 </servlet>
 <servlet>
  <servlet-name>TemplateServlet</servlet-name>
  <servlet-class>groovyx.gaelyk.GaelykTemplateServlet</servlet-class>
 </servlet>
 <servlet-mapping>
  <servlet-name>GroovletServlet</servlet-name>
  <url-pattern>*.groovy</url-pattern>
 </servlet-mapping>
 <servlet-mapping>
  <servlet-name>TemplateServlet</servlet-name>
  <url-pattern>*.gtpl</url-pattern>
 </servlet-mapping>
 <welcome-file-list>
  <welcome-file>index.gtpl</welcome-file>
 </welcome-file-list>
</web-app>

Observe que o arquivo web.xml especifica que o arquivo de abertura seja o index.gtpl; portanto, renomeie o arquivo index.html que o plug-in do Eclipse gerou para você para index.gtpl. (Simplesmente selecione o arquivo e pressione F2, se estiver no Windows®.)

Com as bibliotecas apropriadas em seus lugares e os dois arquivos XML configurados corretamente, é possível confirmar se tudo está funcionando através da edição do arquivo index.gtpl para que ele tenha o mesmo conteúdo da Listagem 3:

Listagem 3. Um arquivo GTPL simples
<html>
 <head><title>A Simple GTPL</title></head>
  <body>
   <b><% print "Hello Gaelyk!".replace(" ", " from ") %></b>
   <p>
   <ol>
    <% def wrd = "Groovy"
       wrd.each{ letter ->
    %>
    <li><%= letter %></li>
    <% } %>
   </ol>
   </p>
  </body>
</html>

Como é possível observar, os arquivos GTPL (ou modelos Gaelyk/Groovy) no Gaelyk são iguais às JSPs: é possível adicionar comportamentos em scriptlets (neste caso, o comportamento é Groovy). Observe que também é possível usar encerramentos e fazer referências a variáveis mais tarde.

Salve seu arquivo index.gtpl e então selecione o diretório base do projeto no Eclipse, clique com o botão direito do mouse, selecione Run As, e selecione a opção Web Application que contém o logotipo G azul, como mostrado na Figura 3:

Figura 3. Executando como um aplicativo da Web do Google
Screenshot of selecting the Web Application option that contains a blue G logo

Como padrão, esse ativador inicia uma instância local do Jetty na porta 8080. Se desejar mudar as portas, selecione a opção Run Configurations e configure a porta através do painel de opções fornecido pelo plug-in.

Agora que a instância local do seu aplicativo da Web do Gaelyk está sendo executado, abra o navegador da Web e vá para http://localhost:8080. O resultado do seu belo index.gtpl deve ser parecido com a Figura 4:

Figura 4. Hello world!
Screenshot of output of index.gtpl at http://localhost:8080

Foi fácil, não foi?


Persistência fácil

O sistema de multas é simples. Ele oferece um formulário da Web para criar as multas e uma funcionalidade de lista para visualizar, excluir e editar as multas. Começarei criando um simples formulário HTML através de um modelo do Gaelyk, e o chamarei de createticket.gtpl. Esse formulário, mostrado na Figura 5, tem o objetivo de capturar dados relevantes associados a uma multa específica:

Figura 5. Um simples formulário de multa
Screenshot of a blank simple ticket form

O formulário fará o envio um groovlet; da mesma maneira, crie um folder da groovy dentro do diretório WEB-INF do seu projeto. É lá que você colocará seus groovlets. (Você fez a mesma coisa em "Hello Google App Engine".) O formulário de criação de multa fará o envio a um arquivo createticket.groovy. Crie esse arquivo no diretório da groovy recém-criado.

É certamente possível usar códigos do JDO e do Java Persistence API (JPA) no Gaelyk, mas há outra maneira conveniente de fazer a interface com o armazenamento de dados subjacente: o uso do objeto Entity do Google. A equipe do Gaelyk aprimorou o objeto Entity com um pouco de mágica Groovy para tornar o trabalho com objetos persistentes incrivelmente simples.

Neste caso, eu gostaria de capturar os elementos de formulário enviados através da página createticket.gtpl e criar uma nova multa no sistema. Usando a classe Entity, eu não preciso definir um objeto similar ao POJO para representar uma multa (como fiz em "Hello Google App Engine" quando criei um objeto JDO de Triathlon). Eu simplesmente modelarei a multa à moda Groovy e a salvarei quase sem esforço.

Consequentemente, posso pegar os parâmetros enviados pelo formulário através do conveniente objeto params do Gaelyk (que, falando nisso, o Grails também oferece) e criar uma instância Entity, como mostrado na Listagem 4:

Listagem 4. Criando uma Entity
def formatter = new SimpleDateFormat("MM/dd/yyyy")
def offensedate = formatter.parse("${params.of_month}/${params.of_day}/${params.of_year}")

def ticket = new Entity("ticket")
ticket.officer = params.officer
ticket.license = params.plate
ticket.issuseDate = offensedate
ticket.location = params.location
ticket.notes = params.notes
ticket.offense = params.offense

Observe que a variável ticket é uma instância de Entity. A Cadeia de caracteres "ticket" representa o tipo de entidade que ela é. Isso será útil na procura de multas. Em seguida, eu automaticamente designei valores à instância Entity associada às multas. Agora ticket.officer representa o valor do parâmetro officer enviado através do formulário da página da Web. Devido ao fato do formulário conter três campos para a data, eu também criei uma instância de data usando SimpleDateFormat e defini esse valor para issueDate.

Neste momento, tenho um objeto que representa uma multa. Tudo o que preciso fazer agora é salvá-lo com:

ticket.save()

Agora que dei persistência à multa, encaminharei os usuários para uma página na qual eles possam visualizar a multa. Isso também é fácil. Simplesmente encaminho para um groovlet de visualização de multa (para processamento):

redirect "viewticket.groovy?id=${ticket.key.id}"

Como é possível observar, criei um parâmetro denominado id e o defini como a chave da instância de multa salva, que o Google App Engine gerou. Da mesma forma, o groovlet de criação de multa é conciso e ainda assim altamente funcional — tudo facilitado pelo Gaelyk.


Visualizações fáceis

No exemplo anterior, depois que eu criei a instância ticket, redirecionei o pedido para outro Groovlet — um que facilitasse a visualização da multa. Nesse Groovlet, codifiquei uma leitura do Google App Engine, por assim dizer. O id que foi transmitido é então usado para encontrar a instância recém-criada. Neste caso, estou usando o KeyFactory do Google, que é usado para criar uma instância do objeto Key do Google. A Key então é usada para encontrar a instância de multa correspondente através de datastoreService, que o Gaelyk adicionou automaticamente à ligação de qualquer instância de Groovlet dentro da estrutura, como é possível observar na Listagem 5:

Listagem 5. Visualizando uma Entity
import com.google.appengine.api.datastore.KeyFactory

if (params["id"]) {
 def id = Long.parseLong(params["id"])
 try {
   def key = KeyFactory.createKey("ticket", id)
   def ticket = datastoreService.get(key)

   request.setAttribute "ticket", ticket

   forward "viewticket.gtpl"

   } catch (Throwable t) {
    //forward to some error page...
   }
} else {
 forward "index.gtpl"
}

Uma vez que o ticket correspondente tenha sido encontrado, a multa é colocada no objeto de HTTP request (que já está presente em um Groovlet) e então o processamento é encaminhado para a página viewticket.gtpl. Assim como qualquer outra JSP em um aplicativo da Web, essa página exibe os atributos correspondentes associados à multa passada.

Como é possível ver na Listagem 6, o Gaelyk suporta includes. Isto é, nos seus arquivos .gtpl, é possível incluir outros arquivos, exatamente como é possível fazer em JSPs normais. Da mesma maneira, todos os arquivos .gtpl têm uma instância do objeto de HTTP Request à mão (através da variável request).

Listagem 6. Visualizando um único GTPL Entity
<% include "/WEB-INF/includes/header.gtpl" %>

<% def ticket = request.getAttribute("ticket") %>

<div class="info">
 <h2>Parking Ticket</h2>
 </div>

<table>
<tr>
	<th>Issuing Officer</th>
	<th>Vehicle Plate</th>
	<th>Date</th>
	<th>Offense</th>
	<th>Location</th>
	<th>Notes</th>
  </tr>
 <tr>
	<td>${ticket.officer} </td>
	<td>${ticket.license}</td>
	<td>${ticket.issuseDate}</td>
	<td>${ticket.offense}</td>
	<td>${ticket.location}</td>
	<td>${ticket.notes}</td>
  </tr>
 </table>

<% include "/WEB-INF/includes/footer.gtpl" %>

Como é provavelmente possível ver agora, o Gaelyk torna simples a construção de aplicativos leves da Web no Google App Engine. E trabalhar com o armazenamento de persistência do App Engine não poderia ser mais fácil. Realmente é preciso algum tempo para nos acostumarmos com o API de baixo nível usado para trabalhar com objetos Entity. As consultas requerem algum raciocínio (mais ou menos como as consultas com o CouchDB, de certa maneira). Por exemplo, a visualização da lista das multas criadas requer um código como o da Listagem 7:

Listagem 7. Visualizando uma coleção de Entitys
import com.google.appengine.api.datastore.Query
import static com.google.appengine.api.datastore.FetchOptions.Builder.withLimit

try {
 def query = new Query("ticket")
 query.addSort("issuseDate", Query.SortDirection.DESCENDING)
 def preparedQuery = datastoreService.prepare(query)
 def tickets = preparedQuery.asList( withLimit(10) )

 request.setAttribute "tickets", tickets
forward "index.gtpl"
} catch (Throwable t) {
 forward "index.gtpl"
}

A Listagem 7 utiliza o objeto Query do App Engine. Como você pode ver, é possível adicionar recursos de classificação às consultas e até limitar quantos resultados são retornados. Nenhum SQL é usado, mas você pode ter certeza de que os dados armazenados podem ser recuperados, ainda que de forma um pouco diferente.

Assim como em "Hello Google App Engine," a implementação na nuvem é muito simples Através do plug-in, simplesmente clique em Deploy App Engine Project e deixe que o Google faça o resto. Na verdade, é possível fazer o download do código deste artigo e fazer exatamente isso. O código preencherá algumas lacunas que não tive espaço para abordar em um único artigo. Por exemplo, eu implementei a remoção de multas, e a interação do usuário com o sistema de multas foi levemente aprimorado, então você verá um pouco mais do Gaelyk em ação.


O desenvolvimento rápido tornado fácil

O armazenamento de dados em nuvem e sem esquemas, apoiado pelas inovações de software livre, são certamente parte do futuro do desenvolvimento em Java. Ambos têm barreiras pequenas para a adoção; no exemplo deste artigo, tanto o hardware quanto o software são completamente gratuitos. E quando o Google começar a cobrar dinheiro, você com certeza já estará ganhando — 5 milhões de visitas por mês é uma enorme quantidade de tráfego. A estrutura Gaelyk traz um ritmo ainda mais rápido ao desenvolvimento da Web. O desenvolvimento em Java continua se tornando cada vez melhor, não é mesmo?


Download

DescriçãoNomeTamanho
Source code for this article's examplesj-javadev2-6.zip8.3MB

Recursos

Aprender

  • Gaelyk: Aprenda mais sobre esse leve kit de ferramentas da Groovy para o Google App Engine para Java.
  • Google App Engine: Visite a base inicial do App Engine do Google.
  • "Java development 2.0: Hello Google App Engine" (Andrew Glover, developerWorks, agosto de 2009): Entenda o desenvolvimento em Java 2.0 e como você pode trazer seus conceitos à realidade rapidamente com o App Engine do Google para Java.
  • Practically Groovy (Andrew Glover e Scott Davis, developerWorks): Essa série explora os usos práticos da Groovy, ajudando você a aprender quando e como aplicá-los com êxito.
  • Computação em nuvem: Visite a Central de Computação em Nuvem da IBM® para encontrar uma gama de recursos em nuvem.
  • Procure na livraria tecnológica livros sobre esses e outros tópicos técnicos.
  • área de tecnologia Java do developerWorks: Encontre centenas de artigos sobre cada aspecto da programação Java.

Obter produtos e tecnologias

Discutir

Comentários

developerWorks: Conecte-se

Los campos obligatorios están marcados con un asterisco (*).


Precisa de um ID IBM?
Esqueceu seu ID IBM?


Esqueceu sua senha?
Alterar sua senha

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


A primeira vez que você entrar no developerWorks, um perfil é criado para você. Informações no seu perfil (seu nome, país / região, e nome da empresa) é apresentado ao público e vai acompanhar qualquer conteúdo que você postar, a menos que você opte por esconder o nome da empresa. Você pode atualizar sua conta IBM a qualquer momento.

Todas as informações enviadas são seguras.

Elija su nombre para mostrar



Ao se conectar ao developerWorks pela primeira vez, é criado um perfil para você e é necessário selecionar um nome de exibição. O nome de exibição acompanhará o conteúdo que você postar no developerWorks.

Escolha um nome de exibição de 3 - 31 caracteres. Seu nome de exibição deve ser exclusivo na comunidade do developerWorks e não deve ser o seu endereço de email por motivo de privacidade.

Los campos obligatorios están marcados con un asterisco (*).

(Escolha um nome de exibição de 3 - 31 caracteres.)

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


Todas as informações enviadas são seguras.


static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=80
Zone=Tecnologia Java, Cloud computing
ArticleID=477912
ArticleTitle=Desenvolvimento em Java 2.0: Gaelyk para Google App Engine
publish-date=03262010