Java Development 2.0: Olá Google App Engine

Rápido desenvolvimento de aplicativo da Web otimizando Groovy, Eclipse e JDO

As soluções de software livre e infraestruturas emprestadas estão mudando o caráter do desenvolvimento ™ em Java, permitindo que você ofereça software melhor e a um custo baixo rapidamente. Andrew Glover, cunhando o termo Java development 2.0 para abranger o força acumulativa desses fenômenos, lança uma nova série sobre algumas das ferramentas e tecnologias relevantes. Esta primeira parte anuncia a chegada do Java development 2.0 e explica como você pode concretizar seus conceitos rapidamente com o App Engine do Google para Java.

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.



17/Dez/2009

O universo Java é um rico ecossistema com um amplo elenco de desenvolvedores, negócios e os — mais importantes— aplicativos, muitos dos quais foram amadurecendo ao longo de mais de uma década. A comunidade Java internacional investiu intensivamente dinheiro, tempo e capacidade cerebral na plataforma, e essas contribuições renderam uma infinidade de ferramentas comerciais e de software livre, estruturas e, efetivamente, soluções.

Esses inúmeros investimentos na plataforma Java alteraram sutilmente como o desenvolvimento em Java é feito. Duas novas tendências estão mudando rapidamente seu caráter:

Sobre esta série

O horizonte do desenvolvimento em Java mudou radicalmente desde que a tecnologia Java apareceu pela primeira vez. Graças às estruturas de software livre maduras e às infraestruturas de implementação com rentabilidade confiável, agora é possível montar, testar, executar e manter aplicativos Java rapidamente e de forma barata. Nesta série, Andrew Glover explora a gama de tecnologias e ferramentas que torna possível esse novo paradigma de desenvolvimento em Java.

  • Capitalizando completamente nas ferramentas e estruturas de software livre para construir aplicativos de cima a baixo
  • Alugando (ou tomando emprestado) as infraestruturas de aplicativo necessárias em todos os níveis para gerenciamento do ciclo de vida do software, incluindo a execução dos próprios aplicativos

Nenhum dos aspectos do que eu chamo de Java development 2.0 é novo ou revolucionário, mas as tecnologias capacitadoras amadureceram ao ponto de hoje ser possível, como nunca antes na história da tecnologia Java, montar aplicativos melhores e e de forma barata — certamente um dos desejos predominantes nos negócios no mundo todo.

Este artigo lança uma nova série que explorará o Java development 2.0 em profundidade. Aprenderemos sobre a construção e implementação de aplicativos da Web com o EC2 da Amazon, usando o App Engine do Google, potencializando o CouchDB (que está sendo chamado de banco de dados para a Web), e outras ferramentas e tecnologias que fornecem os blocos de construção para a montagem, teste e implementação de aplicativos rapidamente e por menos dinheiro do que era possível até agora.

Primeira parada: o Google App Engine para Java (consulte Recursos). Eu vou apresentar a vocês a plataforma via a metodologia consagrada "Hello World", e depois mostrar como criar um aplicativo da Web funcional usando Groovy, Java Data Objects (JDO), e o plug-in Eclipse para o Google App Engine. Primeiro, porém, é necessária uma rápida visão geral do valor de negócios do Java development 2.0.

O Rápido e o Barato

As palavrasrápido e barato nunca foram frequentemente associadas ao desenvolvimento em Java. De fato, elas geralmente configuram impressões de desenvolvimento de software menos sério — uma esfera de pequenas empresas com poucos recursos. Porém, a verdade, é que TI é um centro de custos para muitas empresas (grandes e pequenas), o que as motiva a manter os custos de TI baixos enquanto extraem o máximo de valor possível.

É aqui que entra a Java development 2.0. Ao potencializar ferramentas de software livre, estruturas e mesmo soluções, as empresas podem montar aplicativos de software rapidamente porque elas mesmas não precisam escrever muito código. Quando comecei a desenvolver com tecnologia Java há mais de 10 anos, o escopo de ferramentas e estruturas disponível aos desenvolvedores era muito menor. Também, aquelas poucas ferramentas não estavam disponíveis gratuitamente. Você precisava comprar um IDE, um banco de dados, uma estrutura object-relational mapping (ORM) (pior ainda, você poderia ter de comprar o driver necessário para se comunicar com o seu banco de dados) e, é claro, as máquinas nas quais implementar o seu aplicativo. Hoje? Tudo que acabei de listar (e mais) está disponível gratuitamente e com alta qualidade.

Além disso, ao tomar emprestado infraestruturas (como aquelas oferecidas pelo EC2 da Amazon ou do Google App Engine), é possível implementar aplicativos de forma muito barata (comparado à compra da infraestrutura completa necessária).

Construir, comprar ou tomar emprestado: Esta é a nova questão

Muitos negócios têm um inventário de hardware para aplicativos em execução como bancos de dados, servidores de aplicativos, sistemas de gerenciamento de mudança e ferramentas de controle de defeitos. Porém, hoje em dia, este inventário pode ser facilmente descartado em favor do uso de alguns pacotes de software como um serviço que executa na infraestrutura de outra pessoa.

A pilha completa de aplicativos que uma equipe pode usar para gerenciar um processo de desenvolvimento pode ser emprestada — isto é, alugada por uma pequena taxa— liberando a empresa de ter de investir em hardware para executá-los. Por exemplo, em vez de comprar uma máquina para executar um sistema de gerenciamento de mudança (como Subversion ou Git, que são, ambos, software livre e gratuitamente disponíveis), uma equipe pode usar um serviço de gerenciamento de mudança compartilhado como o GitHub. A empresa por trás do GitHub incorre no custo de ativos de hardware e cobra uma taxa nominal (geralmente mensal, por usuário) para outras organizações usarem o Git. Este mesmo princípio de alugar software como um serviço de outros provedores pode ser potencializado para controle de defeitos, gerenciamento de etapas de teste e gerenciamento de requisitos (via Hosted JIRA ou Pivotal Tracker, por exemplo).

O mesmo pode ser dito para ativos de hardware subjacentes nos quais outras plataformas de software executam (geralmente customizadas por natureza). Um negócio pode descartar o hardware subjacente para um aplicativo da Web em particular em favor da execução do aplicativo no hardware fornecido pela Amazon, Google, ou outros que atuam no espaço. Essas empresas oferecem a capacidade de alugar hardware em níveis variados, o que literalmente pode hospedar um aplicativo. Também, essas empresas gerenciam escalabilidade, backups e até mesmo segurança. Pense nisso por um segundo: a Amazon e o Google descobriram essas preocupações (e mais) há muito tempo e estão melhores no trato e inovação dos aspectos da execução eficiente de plataformas de software. (Isso é verdade. Aceite isso.)

Ao usar o App Engine do Google, por exemplo, uma empresa de TI pode diminuir o custo geral da compra de uma infraestrutura para executar aplicativos necessários. E ela pode implementar esses aplicativos mais rapidamente porque a variedade de preocupações transversais associadas com a implementação e gerenciamento de aplicativos já é levada em conta e, assim, prevista (e muito provavelmente de uma maneira superior).

Rápido e barato não significa mais baixa qualidade. Pelo contrário, a Java development 2.0 é uma abordagem tática que já assume um processo sólido que enfatiza a qualidade.


Um dia simples com o App Engine do Google

O Google App Engine é uma plataforma autêntica para construção e implementação de aplicativos da Web em Java (e Python) na infraestrutura expansiva do Google. Ele não requer taxas de licenciamento (a menos, é claro, que alguma biblioteca de software que você escolher para potencializar a infraestrutura requeira uma licença) e nenhum custo adiantado para banda larga ou espaço. A infraestrutura do App Engine é completamente gratuita a menos que você atinja um limite de uso — de 500MB de armazenamento e, para citar o Google, "CPU e banda larga suficientes para cerca de 5 milhões de visualizações de página por mês". Basta dizer que, quando você atinge um ponto no qual o Google começa a cobrar de você, o seu aplicativo da Web claramente já gerou tráfego significante (e, portanto, interesse).

Estar em funcionamento com o App Engine não poderia ser mais fácil. O Google até fornece um plug-in do Eclipse que manipula praticamente tudo para você. E o plug-in inclui os componentes essenciais de um aplicativo servlet "Hello World" que o ajuda a iniciar com a plataforma. Em seu recente artigo introdutório no developerWorks ("Google App Engine for Java, Part 1: Rev it up!") Rick Hightower o leva através da implementação do aplicativo Hello World (capturas de tela incluídas). Se você ainda não trabalhou com o artigo do Rick, siga essas etapas:

Com Versão

As implementações do App Engine podem ser com versão — isto é, é possível designar um padrão de cadeia (que pode significar uma versão) para uma implementação. Isso é útil quando você começa a ter múltiplos releases. Via URLs e o console do Google, é possível delimitar qual versão é a "viva" e quais não são (ainda que qualquer implementação com versão seja acessível via uma URL, desde que você não a remova primeiro). Consequentemente, sempre que você quiser implementar uma nova versão do seu projeto para infraestrutura do Google, você deve dar a essa implementação uma versão válida. O padrão da cadeia não pode incluir pontos (1.1 não funciona, mas 1-1 sim). É possível designar versões no arquivo appengine-web.xml localizado no diretório war/WEB-INF já gerado para você quando você criou um novo projeto. Para implementar o seu primeiro projeto, você não precisa lidar com versões (ainda) porque o Google especifica uma versão inicial de 1 no arquivo appengine-web.xml gerado.

  1. Crie uma conta no Google App Engine (é gratuito) clicando no link Inscrever-se sob Introdução em http://code.google.com/appengine/.
  2. Faça o download do plug-in do Google App Engine para Eclipse em http://code.google.com/appengine/downloads.html e instale-o.
  3. Crie um novo projeto clicando no botão Novo Projeto de Aplicativo da Web no Eclipse; no diálogo resultante, desmarque a opção Usar Kit de Ferramentas da Web do Google. Nomeie o projeto e o pacote correspondente da maneira que quiser.
  4. Selecione o seu projeto na hierarquia e clique no botão Implementar Projeto do App Engine .
  5. Insira suas credenciais (aquelas que você usou ao criar uma conta no App Engine na Etapa 1).
  6. Associe seu projeto local com o ID do aplicativo que você criou quando inicialmente criou uma conta do App Engine. (Você pode ter até 10 IDs.)
  7. Clique no botão Implementar . Você verá muito texto preenchendo o console do Eclipse (o plug-in está fazendo muitas coisas nos bastidores, incluindo o aprimoramento de quaisquer classes necessárias que potencializam o serviço impressionante de armazenamento de dados do Google). Depois que esse ruído é eliminado (e tudo funciona corretamente), você deve ver uma mensagem que termina com "Implementação concluída com êxito".
  8. Vá até a página da sua conta do App Engine no Google e localize o link Versões no console do Google. Lá você verá a sua versão implementada e sua URL correpondente. Clique na URL e depois no link para o servlet gerado para visualizar o prosaico, porém, tão gratificante, "Olá, mundo" impresso em texto simples.

Menos Linhas de Código com o Groovlets

Você implementou com sucesso o seu primeiro aplicativo Google App Engine e não escreveu uma linha de código. De fato, se você planejar potencializar o App Engine, você acabará escrevendo algum código— mas lembre-se: muito código está lá, que você pode reutilizar para fazer sua tarefa mais facilmente. Esse código reutilizável poderia ser os serviços que o Google fornece (como seu armazenamento de dados ou serviços de conta do Google) ou bibliotecas de software livre que foram portadas para o trabalho na infraestrutura do Google. Reutilizar o código de outra pessoa significa que você frequentemente acaba escrevendo menos código — e menos código, quase certamente, significa menos defeitos.

Uma das minhas bibliotecas de software livre favoritas (e na verdade plataformas) que quase sempre rende menos linhas de código para produzir aplicativos funcionais é o Groovy (consulte Recursos). A equipe do Groovy recentemente lançou versões da plataforma que funcionam no App Engine, permitindo que você potencialize o Groovlets em vez de servlets para terminar um aplicativo funcional rapidamente. Os Groovlets são scripts Groovy simples que agem como servlets. Porque você já tem um servlet que imprime "Olá, mundo", você mostrar como é fácil fazer a mesma coisa com um Groovlet (e você verá quantas linhas de código a menos o Groovy ativa).

Implementar um Groovlet no App Engine com o plug-in do Eclipse requer poucas etapas fáceis:

  1. Faça o download da versão mais recente do Groovy (no momento em que este artigo foi escrito, 1.6.3) em http://groovy.codehaus.org/Download.
  2. Localize o groovy-all-1.6.3.jar e coloque-o no diretório war/WEB-INF/lib do seu projeto do App Engine. A propósito, neste diretório, é possível colocar qualquer biblioteca que o seu aplicativo necessite (com alguns avisos sobre os quais falarei em breve).
  3. Inclua as frases na Listagem 1 (que mapeiam o Groovlets para pedidos especializados) no arquivo web.xml localizado no diretório war/WEB-INF:
    Listagem 1. Atualizando o arquivo web.xml para suportar o Groovlets
    <servlet>
     <servlet-name>GroovyServlet</servlet-name>
     <servlet-class>groovy.servlet.GroovyServlet</servlet-class>
    </servlet>
    <servlet-mapping>
     <servlet-name>GroovyServlet</servlet-name>
     <url-pattern>*.groovy</url-pattern>
    </servlet-mapping>
  4. Inclua um diretório do groovy no seu diretório WEB-INF; é aqui que você armazenará seus Groovlets. No diretório do groovy, crie um novo arquivo chamado helloworld.groovy. Nesse novo arquivo, digite println "Olá, Groovy bebê!"
  5. Atualize aversão do seu aplicativo — digamos para 1-1 — e reimplemente. Localize a URl correspondente via o painel do Google e então navegue para /helloworld.groovy no seu navegador e desfrute do esplendor de uma mensagem moderna impressa a partir do Groovy na infraestrutura do Google.

Isso foi fácil, certo? Tudo o que você precisou fazer foi incluir o JAR do Groovy, atualizar o arquivo web.xml, criar um novo diretório do groovy, escrever um Groovlet, e implementá-lo. Você também notou como o Groovlet faz a mesma coisa como o servlet padrão que o plug-in gerou, mas em uma linha de código? O que você teria de escrever e manter em vez disso: uma classe grande ou uma pequena que faça a mesma coisa?


Groovy + Java = aplicativo funcional. Rapidamente.

Agora, vou mostrar como usar o Groovy com o App Engine do Google pode render um aplicativo funcional rapidamente. Vou usar uma página HTML simples, um Groovlet, e uma classe Java aprimorada para JDO para persistir um evento (neste caso, um triatlo). Por hora vou mantê-lo simples, mas você verá que este aplicativo pode crescer para incluir outros recursos, e em artigos futuros desta série vou implementá-los (usando infraestruturas e tecnologias diferentes, é claro).

JDO Rápido

O Google App Engine oferece a capacidade de persistir dados usando o JDO, que é um padrão Java para persistência (consulte Recursos). Para a maioria dos desenvolvedores em Java, persistir dados geralmente implica em salvar informações em um banco de dados relacional; porém, no caso do Google, o mecanismo de armazenamento subjacente é a sua Grande Tabela de propriedades, que não é relacional. Dito isso, isso realmente não importa: os detalhes de como o Google persiste atributos específicos são amplamente ocultos de você. Basta dizer que você pode usar objetos Java normais (ou objetos Groovy, quanto a isso) para construir um aplicativo que possa armazenar informações como você faria em qualquer outro aplicativo. É apenas isso no caso do Google, você deve usar o JDO. (O Hibernate, contestavelmente a mais popular estrutura ORM para Java, não funciona no App Engine.)

O JDO é bastante simples. Você cria POJOs — objetos Java simples antigos (que podem ter relacionamentos com outros objetos Java) — que você declara como capazes de persistência via a anotação @PersistenceCapable . Você especifica quais propriedades do objeto serão persistentes via anotações@Persistent . Por exemplo, eu gostaria de armazenar eventos de triatlo (por hora, vou focar no evento e não nos vários resultados relacionados a um triatlo) — isto é, um evento tem um nome (o nome do triatlo), talvez uma descrição (qual tipo de triatlo), e uma data. Até agora o meu JDO se parece com a Listagem 2:

Listagem 2. Um JDO de evento de triatlo simples
import java.util.Date;
import javax.jdo.annotations.PersistenceCapable;
import javax.jdo.annotations.Persistent;
import javax.jdo.annotations.IdentityType;

@PersistenceCapable(identityType = IdentityType.APPLICATION)
public class Triathlon {

 @Persistent
 private Date date;

 @Persistent
 private String name;

 @Persistent
 private String description;

}

A persistência de dados, independentemente do mecanismo subjacente (isto é, relacional ou Grande Tabela do Google) ainda requer na notação de uma chave : uma maneira de garantir exclusividade de vários aspectos de dados para evitar os conflitos de dados. Por exemplo, no caso de um triatlo, a chave poderia ser o nome do triatlo. Se dois triatlos têm o mesmo nome, então a chave poderia ser uma combinação do nome e da data. Independentemente de como você escolher representar uma chave com o App Engine do Google e o JDO, você deve especificar uma chave no seu objeto JDO via a anotação @PrimaryKey . Também é possível escolher estratégia para como uma chave é gerada — por você ou pela infraestrutura do Google. Eu deixarei para o Google e tornarei isso simples: a chave do meu objeto triatlo é representada como um objeto Long Java simples, e eu vou deixar o Google selecionar o valor real especificando uma estratégia de valor. A Listagem 3 inclui a chave primária:

Listagem 3. Incluindo uma chave primária ao JDO Triatlo
import java.util.Date;
import javax.jdo.annotations.IdGeneratorStrategy;
import javax.jdo.annotations.PersistenceCapable;
import javax.jdo.annotations.Persistent;
import javax.jdo.annotations.PrimaryKey;
import javax.jdo.annotations.IdentityType;
import org.apache.commons.lang.builder.EqualsBuilder;
import org.apache.commons.lang.builder.HashCodeBuilder;
import org.apache.commons.lang.builder.ReflectionToStringBuilder;

@PersistenceCapable(identityType = IdentityType.APPLICATION)
public class Triathlon {
 @PrimaryKey
 @Persistent(valueStrategy = IdGeneratorStrategy.IDENTITY)
 private Long id;

 @Persistent
 private Date date;

 @Persistent
 private String name;

 @Persistent
 private String description;

 public Triathlon(Date date, String name, String description) {
  super();
  this.date = date;
  this.name = name;
  this.description = description;
 }

 //...setters and getters left out

 public String toString() {
  return ReflectionToStringBuilder.toString(this);
 }

 public int hashCode() {
  return HashCodeBuilder.reflectionHashCode(this);
 }

 public boolean equals(Object obj) {
  return EqualsBuilder.reflectionEquals(this, obj);
 }
}

Como você pode ver na Listagem 3, meu JDO do triatlo agora tem uma chave gerenciada pela infraestrutura do Google, e eu adicione alguns poucos métodos padrão (toString, hashCodee equals) que ajuda muito a depuração, criação de logs e, é claro, a funcionalidade adequada. Em vez de escrevê-los eu mesmo, estou usando a biblioteca de linguagens comuns Apache (consulte Recursos). Eu também inclui um construtor que facilitará muito a criação de objetos completamente inicializados quando comparado com a chamada de muitos métodos setter.

Eu mantive meu JDO simples de propósito, mas como você pode ver, não há muito a ser feito (isto é, eu deixe de fora quaisquer relacionamentos e omite getters e setters em prol da brevidade). Basta modelar seu domínio e depois decorar o modelo com algumas poucas anotações, e o Google cuida do resto.

Com um objeto definido como capaz de persistência, há apenas uma última etapa. Para interagir com o armazenamento de dados subjacente, você precisa trabalhar com um, PersistenceManager, que é uma classe padrão JDO que faz o que indica seu nome: salva, atualizam recupera e remove objetos de uma armazenamento de dados subjacente (bem parecido com o objeto Session de Hibernate). Esta classe é criada via uma factory (PersistenceManagerFactory), que é bastante pesada; assim, o Google recomenda criar um objeto singleton que gerencia uma única instância do factory (que então retornará um PersistenceManager adequado quando você precisar). Consequentemente, eu posso definir um objeto singleton simples para retornar uma instância de umPersistenceManager, como mostrado na Listagem 4:

Listagem 4. Um singleton simples para retornar uma instância dePersistenceManager .
import javax.jdo.JDOHelper;
import javax.jdo.PersistenceManager;
import javax.jdo.PersistenceManagerFactory;

public class PersistenceMgr {

 private static final PersistenceManagerFactory instance =
   JDOHelper.getPersistenceManagerFactory("transactions-optional");

 private PersistenceMgr() {}

 public static PersistenceManager manufacture() {
  return instance.getPersistenceManager();
 }
}

Como você pode ver, meu PersistenceMgr é bem simples. O método um, manufacture, retorna uma instância de PersistenceManager de uma única instância de um PersistenceManagerFactory. Você também notará que não existe nenhum código específico do Google na Listagem 4 ou em qualquer outra listagem potencializando o JDO — todas as referências são a classes e interfaces JDO padrão.

Os dois objetos Java recentemente definidos residem no diretório src do meu projeto, e eu incluí a bilioteca de linguagens comuns no diretório war/WEB-INF/lib.

Com o JDO POJO de triatlo simples e um objeto PersistenceMgr prático, estou pronto para prosseguir. Tudo o que preciso agora é de uma maneira de capturar as informações do triatlo.


Capturando Dados via uma Interface Web

A maioria dos aplicativos da Web segue o mesmo padrão: capturam informações via formulários HTML e os enviam para um recurso do lado do servidor para manipulação. É claro que muito tempero está combinado aqui e ali, mas o padrão permanece o mesmo independentemente da tecnologia ou infraestrutura subjacente. O Google App Engine não é diferente — Eu já codifiquei o recurso do lado do servidor para manipular o salvamento de dados do triatlo. Tudo o que resta é uma maneira de capturar as informações — um formulário — e uma maneira de unir o lado do servidor e o formulário. No jargão do Model-View-Controller (MVC), eu preciso de um controlador, que geralmente é um servlet; eu vou potencializar um Groovlet em vez disso porque prefiro escrever menos código.

Meu formulário HTML é simples: tudo o que fiz foi criar uma página HTML que potencializa algum código Cascading Style Sheets (CSS) simples para tornar o formulário, mostrado na Figura 1, mais parecido com a Web 2.0 do que com páginas HTML de 1998, aproximadamente:

Figura 1. Um formulário HTML simples
Um formulário HTML simples

Como você pode ver na Figura 1, o formulário captura um nome, descrição e uma data. A data, porém, não é tão simples — ela é, de fato, três atributos de uma data.

Groovlet Rapidamente

Os Groovlets tornam a codificação do controlador rápida: eles precisam de menos código e fornecem os objetos necessários. Em um Groovlet, você tem acesso implícito ao pedido e resposta HTML via os objetos request e response , respectivamente. Em meu Groovlet, eu posso capturar todos os atributos do formulário HTML enviados via a chamada request.getParameter("name") , como mostrado na Listagem 5:

Listagem 5. Groovlets em Ação
def triname = request.getParameter("tri_name")
def tridesc = request.getParameter("tri_description")
def month = request.getParameter("tri_month")
def day = request.getParameter("tri_day")
def year = request.getParameter("tri_year")

O JDO que eu codifiquei anteriormente potencializa um objeto Date Java; porém, na Listagem 5, estou lidando com três atributos distintos de Date. Assim, eu preciso de um objetoDateFormat para converter a combinação month, day, year em um DateJava, como mostrado na Listagem 6:

Listagem 6. Formatação de data em ação
def formatter = new SimpleDateFormat("MM/dd/yyyy")
def tridate = formatter.parse("${month}/${day}/${year}")

Por último, com todos os parâmetros obtidos de um formulário HTML enviado, eu posso persisti-los na Listagem 7 para a infraestrutura do Google via o meu JDO e o objeto PersistenceMgr da Listagem 4:

Listagem 7. JDO para persistência facilmente
def triathlon = new Triathlon(tridate, triname, tridesc)
def mgr = PersistenceMgr.manufacture()

try {
 mgr.makePersistent(triathlon)
} finally {
 mgr.close()
}

É isso! É claro, quanto mais páginas são incluídas no meu aplicativo simples (como quando se capturam os resultados de um triatlo particular), eu então provavelmente encaminharia ou redirecionaria para outro formulário, o que capturaria então as informações adicionais, bem parecido com um assistente. Independentemente disso, em poucos fragmentos de código curtos, eu rapidamente colocaria um aplicativo da Web simples que persiste dados na infraestrutura do Google via JDO (codificado em Java normal) e um Groovlet (codificado em Groovy, é claro). A implementação de um aplicativo é tão fácil quando a especificação de uma versão no arquivo appengine-web.xml e quanto clicar no botão Implementar.

Ainda que esse aplicativo da Web de um formulário para capturar eventos de triatlo não faça muita coisa, por assim dizer, eu simplesmente implementei para um ambiente onipresente e amorfo. Eu não precisei acionar um contêiner da Web ou mesmo especificar onde implementar o aplicativo. (Ele está residindo na Califórnia, minha unidade de disco rígido, ou na lua?) A beleza é que isso não importa — o Google cuidou disso. De tudo isso. Também, é uma aposta segura de que o Google descobriu como escalar globalmente para que alguém que esteja visualizando o aplicativo na Índia tenha a mesma experiência de alguém, digamos, na Argentina.

Como tudo isso dito, você precisa manter algumas coisas em mente. A infraestrutura do Google suporta tecnologia Java, mas não tudo; se você se lembra como o J2ME surgiu alguns anos atrás, as limitações do App Engine são de alguma forma similares por natureza. Isto é, nem todas as bibliotecas Java principais e bibliotecas de software livre relacionadas são suportadas.Como eu mencionei, o Hibernate não pode ser usado (principalmente porque com o App Engine você não tem um banco de dados relacional). Eu também enfrentei alguns desafios ao usar algumas das bibliotecas de software livre que integravam a codificação base64 (o Google requer que você use o seu serviço de Busca de URL em vez disso). O App Engine é uma plataforma — para a qual você deve desenvolver e que, por hora, é uma via de mão única.


O Futuro Está Aqui

Alan Kay, um dos pais da programação orientada para objeto, é citado como tendo dito, "A melhor maneira de prever o futuro é inventá-lo." Eu concordo com Alan Kay. Independentemente do que as outras pessoas estão sugerindo que o futuro reserva para a tecnologia Java, eu acho que o futuro já está aqui.

Como você viu no artigo, o Google App é uma plataforma para o futuro — desde que você brinque na caixa de areia dele. (Lembre-se do que eu abordei somente alguns poucos grãos dessa caixa de areia; o App Engine tem muitos recursos). Se desejar mais flexibilidade (isto é, desejar uma base relacional e não puder viver sem o Hibernate), mas também gostar da ideia de tomar emprestado a infraestrutura escalável de outra pessoa, as alternativas estão disponíveis. O EC2 da Amazon é literalmente um servidor virtual em uma infraestrutura amorfa que você também pode chamar sob demanda. Você irá conferir isso no Java development 2.0 da parte do próximo mês .

Recursos

Aprender

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
ArticleID=457461
ArticleTitle=Java Development 2.0: Olá Google App Engine
publish-date=12172009