Armazenando dados no App Engine

Olá a todos,

                Em outros posts sobre o App Engine mostramos como desenvolver a camada de apresentação com o uso de páginas JSP ou com o Framework GWT. Também já fizemos um teste simples construindo uma regra de negócio no lado Server, que comunica com a camada de apresentação através do protocolo RPC, que é proprietário do GWT. Por fim fizemos nossa primeira integração entre plataformas comunicando a camada de apresentação, desenvolvida com o uso do GWT, com um serviço WCF através do protocolo REST utilizando o formato JSON.

Arquitetura com os assuntos demonstrado ate o momento

                Entretanto até o momento não tínhamos abordado a camada de persistência. Esse será o assunto desse post, onde veremos como podemos gravar as informações de nossos sistemas no Data Storage do App Engine. Para manipular os dados armazenados nesse Data Storage temos duas opções: podemos utilizar APIs de baixo nível diretamente ou através da biblioteca JDO. Como esse é o primeiro post em que abordamos o assunto utilizaremos a biblioteca JDO.

                O App Engine Data Storage é um mecanismo que nos permite gravar os dados de forma estruturada. A estrutura dos dados é definida através de classes, portanto o Data Storage não é um banco de dados relacional. Porém podemos utilizar comandos de pesquisa muito semelhantes ao transact SQL para realizar pesquisas nessa base de dados. Na verdade esse mecanismo de persistência de dados é muito semelhante às tables do Windows Azure Data Storage e ao banco de dados Caché.

               A principal vantagem do App Engine Data Storage em relação ao mecanismo do Windows Azure é a possibilidade de aninharmos tipos de dados. Assim no App Engine podemos criar uma classe, que define uma estrutura de dados, onde algumas de suas propriedades podem ser outras classes que também definem estruturas de dados do Data Storage. Para exemplificar: podemos criar uma classe (estrutura) endereço e utilizá-la como propriedade em outra classe, que seria do tipo pessoa. A classe pessoa poderia também possuir uma lista (List) de endereços. Desse modo podemos utilizar o Data Storage do App Engine como um banco de dados hierárquico preparado para lidar com altíssimo volume de acessos.

                Nosso exemplo será um cadastro de logins, com os campos login e senha. Alteraremos uma tela já utilizada na nossa prova de conceito adicionando os controles necessários para esse exemplo.

               A primeira tarefa que devemos realizar é definir nossa estrutura de dados através de uma classe. Essa classe deverá ser criada na subpasta client (lembre-se que estamos utilizando o GWT). Para indicar que essa classe será utilizada pelo JDO devemos decorá-la com o atributo PersistenceCapable. Além disso devemos decorar com o atributo Persistent cada variável membro dessa classe que desejamos persistir no Data Storage.

Classe que define a estrutura dos dados que serao gravados

               Toda classe definida como uma estrutura de dados do Data Storage deve possuir um campo de identificador único, semelhante à uma primary key em um banco de dados relacional. Porém a variável membro que será o identificador único deverá ser decorada com o atributo PrimaryKey. Nesse ponto temos duas observações importantes. Primeiro, por limitação do GWT para utilizarmos a passagem de objetos entre as camadas (client e Server) o tipo de dado da variável que será a primary key não poderá deverá ser do tipo Key. Segundo, esse campo não poderá ser um tipo nativo, como string ou long, mas sim classes que representem esses tipos como String ou Long.

               O próximo passo será alterar a tela adicionando os controles para permitir a pesquisa e inclusão dos dados. Incluiremos um botão para realizar a pesquisa e outro botão para gravar um novo login ou atualizar algum já existente. Deverão ser adicionados caixas de texto para que possamos digitar o login e senha que serão gravados e uma tabela que exibirá os logins já criados.

                A terceira etapa é escrevermos a classe que faz o uso do JDO. Como estamos utilizando o Eclipse com o plugin do App Engine as configurações no projeto para utilizarmos o JDO já estão preparadas para nós. Caso necessite ou queira saber como realizar as configurações pode ser vista aqui. A comunicação com o JDO é realizada através de objetos do tipo PersistenceManager, que são criados através do objeto PersistenceManagerFactory. Porém o objeto do tipo PersistenceManagerFactory demanda um tempo razoável para criá-lo, em contrapartida precisamos somente de uma instância dele para todo o projeto. Portanto podemos encapsular esse objeto em um classe, que deverá ser criada na subpasta Server, modificada com o atributo final para termos somente uma instância dessa classe na memória do nosso processo.

Classe para recuperar os objetos do tipo PersistenceManager

               A última etapa é escrevermos o código para gravar e pesquisar os dados no Data Storage. Para gravarmos um novo dado devemos criar uma nova instância da classe e atribuir valores às suas propriedades. Em seguida temos que obter uma instância da classe PersistenceManager para em seguida gravarmos os dados através do método makePersistent desse objeto. A atualização de dados deve ser realizada com o mesmo método, porém utilizando uma instância recuperada do Data Storage.

Codigo para gravar os dados no Data Storage

               Para pesquisarmos os dados no Data Storage precisamos montar uma query de pesquisa semelhante a uma query transact SQL, porém utilizamos nome de classes no lugar de nome de tabelas. Deveremos então obter uma instância da classe PersistenceManager e executarmos o método newQuery, passando como parâmetro a query. O retorno será uma lista (List) do tipo de objeto que define a estrutura dos dados.

Codigo para pesquisar os dados no Data Storage

               Restará apenas escrever o código para realizar a chamada dos métodos do lado Server, conforme já demonstrado em outro post. Poderemos então gravar novos dados e pesquisar os dados já existentes. Temos então um exemplo simples de como gravar e pesquisar dados no mecanismo de persistência do App Engine. Demonstramos também como trafegar objetos complexos entre as camadas do GWT. O código-fonte utilizado nesse post está disponibilizado no meu Sky Drive com o nome POCAppEngine JDO.zip.

Abraço a todos e até o próximo post.