Conteúdo


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

Comments

Conteúdos da série:

Esse conteúdo é a parte # de # na série: Desenvolvimento em Java 2.0

Fique ligado em conteúdos adicionais dessa série.

Esse conteúdo é parte da série:Desenvolvimento em Java 2.0

Fique ligado em conteúdos adicionais dessa série.

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.

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.

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
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
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
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
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
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?


Recursos para download


Temas relacionados


Comentários

Acesse ou registre-se para adicionar e acompanhar os comentários.

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