Nível: Intermediário Luiz Henrique Zambom Santana, MSc., DB2 Support for LUW, IBM
19/Ago/2009 Resumo. A pureQuery é uma nova plataforma da IBM para acesso a
dados com alto desempenho, simplificando o desenvolvimento e otimização das aplicações
que acessam banco de dados relacionais. Este artigo utiliza o IBM Data Studio Developer
para o desenvolvimento de uma aplicação JavaEE baseada no pureQuery em conjunto ao
Websphere Application Server e ao IBM DB2.
1. Introdução
A pureQuery é uma plataforma de alto desempenho para acesso a dados, que consiste de
APIs que implementam e facilitam o uso de boas práticas, de ferramentas de
desenvolvimento para Java e SQL contidas no Data Studio Developer e a API Data
Studio pureQuery Runtime. Essa plataforma situa-se entre os frameworks
objeto-relacionais como Hibernate, Toplink e Kodo, que permitem o mapeamento entre
tabelas armazenadas em SGBDs relacionais e objetos presentes em aplicações Java.
Este artigo apresenta o pureQuery através de um exemplo prático para o
desenvolvimento de uma aplicação no domínio da Web 2.0. Esse projeto é modelado
segundo o design-pattern Model-View-Controller (MVC), um padrão de facto no
desenvolvimento de aplicações Web, no qual o pureQuery atua majoritariamente na
camada Controller entre a aplicação Java e os dados armazenados no SGBD.
No desenvolvimento da aplicação exemplo utiliza-se o IBM Data Studio Developer, um
ambiente de desenvolvimento de bancos de dados integrado, que acelera o design, o
desenvolvimento e a implementação de aplicativos. Utilizando o Data Studio
Developer, é possível desenvolver e testar rotinas, gerar e implementar serviços da
Web centrados em dados, criar e executar scripts SQL e XQuery, e desenvolver
aplicativos Java que acessam os bancos de dados ou os dados na memória. Além disso,
é possível desempenhar as tarefas de gerenciamento de objetos padrão para o ambiente
de desenvolvimento ou de teste, tais como criação e alteração dos objetos de banco
de dados e gerenciamento de privilégios.
A seqüência desse artigo está estruturada da seguinte forma: seção 2 apresenta uma
visão geral da pureQuery; a seção 3 mostra os passos necessários para a configuração
do ambiente de desenvolvimento da aplicação exemplo; finalmente, a seção 4 apresenta
o desenvolvimento da aplicação exemplo.
2. pureQuery
O pureQuery é uma plataforma de acesso a dados da IBM cujo foco é simplificar o
desenvolvimento, segurança, gerenciamento e otimização de aplicações Java que
acessam dados armazenados em bancos de dados relacionais. Essa plataforma pode ser
utilizada em aplicações Desktop usando Java SE ou em aplicações Java EE utilizando
Servlets ou EJB session beans.
Do ponto de vista de um Engenheiro de Software, o pureQuery é um componente integrado
ao IBM DataStudio, uma IDE baseada no Eclipse, que facilita a modelagem e a
utilização do banco de dados execução design e esquema de runtime para gerenciar
dados relacionais como objetos. Dessa forma, as funcionalidades para o
desenvolvimento de Java já presentes no Eclipse são integradas ao desenvolvimento
centrado ao banco de dados. Através do DataStudio é possível o gerenciamento dos
objetos do banco de dados relacional (e.g., tabelas, índices, stored procedures) em
forma conjunta aos objetos da aplicação orientada a objetos (e.g., classes,
atributos, comportamentos).
A pureQuery oferece três maneiras distintas de acesso a dados relacionais através de
aplicações orientadas a objetos:
- Tabelas a partir de Objetos: permite a criação de tabelas num banco de
dados relacional a partir de objetos de uma aplicação Java;
- Objetos a partir de tabelas: a partir das tabelas de um banco de dados
relacionais, o pureQuery é capaz de criar objetos e interfaces para operações de
CRUD (Create, Replace, Update e Delete) em cada uma dessas tabelas;
- Objetos a partir de SQL: os objetos de uma aplicação podem ser criados a
partir dessas consultas em linguagem SQL. Esses objetos são criados através de
parsing de consultas e da leitura dos metadados do banco de dados acessado.
Na aplicação exemplo, objeto principal desse artigo, a última forma de mapeamento
objeto-relacional será utilizada.
3. Configurando o ambiente
Para o desenvolvimento da aplicação exemplo são necessários:
A primeira tarefa, após instalação dos produtos, é a criação um projeto no Data
Studio Developer. Para tala, como ilustrado na Figura 1, utiliza-se a opção “Arquivo
> Novo > Projeto...> Web > Projeto Dinâmico da Web”. Chamaremos o projeto criado de
MyStory. É importante que a opção “Tempo de Execução” no menu de criação do novo
projeto aponte para o “WebSphere Aplication Server Community”.
Figura 1. Criação de projeto no Data
Studio Developer
Como ilustrado na Figura 2, para que o projeto possa utilizar as funcionalidades do
pureQuery, deve-se clicar com o botão direito sobre o nome do mesmo e escolher as
seguintes opções “pureQuery > incluir Suporte a pureQuery...”.
Figura 2. Habilitando a utilização do
pureQuery no projeto
Na seqüência, iremos criar o banco de dados chamado MYSTORY no DB2. Para tal,
deveremos clicar com o botão direito em “Banco de Dados > Novo” da aba “Explorador
de Origem de Dados”. Na caixa de diálogo “Nova Conexão” deveremos escolher a opção
“DB2 para Linux, UNIX e Windows” e preencher o nome do banco de dados como MYSTORY e
os parâmetros de conexão com o DB2 instalado.
Figura 3. Criação do banco de dados
MYSTORY através do DataStudio
Ao final do processo, o banco de dados MYSTORY deverá aparecer na visualização
“Explorador de Origem de Dados”, como ilustrado pela Figura 4.
Figura 4. Banco de Dados
MYSTORY
A aplicação exemplo, chamada MyStory, consiste de um ambiente para que usuários da
Web possam armazenar e compartilhar fotografias e vídeos familiares. A Figura 4
apresenta o modelo relacional da aplicação.
Figura 5. Modelo relacional do projeto
MyStory
A tabela USER armazena informações sobre os usuários da aplicação, que poderam
inserir novos arquivos, armazenados na tabela FILE, e tecer comentários, armazenados
na tabela COMMENTS, sobre arquivos enviados. A tabela FILE tem um relacionamento do
tipo um-para-um com as tabelas VIDEO e PHOTO a fim de representar uma generalização
das informações presentes em PHOTO e VIDEO, que possuem particularidades conforme o
tipo de mídia envia pelo usuário. Através da visualização “Explorador de Origem de
Dados” podemos criar cada uma dessas tabelas. O resultado final deverá ser
semelhante ao apresentado na Figura 6.
Figura 6. Criação das tabelas da
aplicação MyStory
4. Desenvolvimento com pureQuery
Sob o prisma da Engenharia de Software, a principal vantagem na utilização do
pureQuery é sua integração ao DataStudio, aumentado a produtividade dos engenheiros
envolvidos no processo de desenvolvimento de uma aplicação.
Dentre outras funcionalidades automatizadas, o pureQuery permite que tabelas de um
banco de dados relacional sejam transformadas de forma em classes Java. Adquado ao
padrão Model-View-Controller (MVC), que permite a separação entre as camadas de
interface (View) e a camada de acesso aos dados (Model) para que alterações na
primeira não sejam refletidas na segunda, o pureQuery cria a partir das tabelas
relacionais dois tipos de classes: os beans, representações diretas das tabelas,
possuindo apenas atributos correspondentes aos campos das tabelas; e os controllers,
classes intermediárias entre a inteface com o usuário e a camada modelo, que possuem
os comportamentos correspondentes às operações de CRUD (Create, Replace, Update e
Delete) para cada uma das tabelas.
Para melhor estruturar o projeto MyStory cria-se os pacotes com.ibm.dw.myStory.model
e com.ibm.dw.myStory.controller, como ilustrado na Figura 7.
Figura 7. Pacotes do projeto
MyStory
A partir de cada uma das classes deve-se criar o bean e a controller correspondente.
Para tal, deve-se clicar com o botão direito em cada uma das tabelas criadas na
seção anterior e escolher a opção “Gerar Código do pureQuery...”, como ilustrado na
Figura 8.
Figura 8. Geração de código a partir de
tabelas relacionais
Para cada tabela escolhida, uma caixa de diálogo como a da Figura 9 deverá ser
preenchida. Na primeira parte da caixa deverá ser escolhida o pacote onde a classe
beans será criada, nesse exemplo o pacote com.ibm.dw.model. Para que o pureQuery
gere a classe controller deveremos escolher a opção “Gerar a interface de método
anotado para a tabela” e o pacote com.ibm.dw.controller para sua criação. Vale
ressaltar que o pureQuery possui dos tipos os estilos de programação annotated e
inline. No primeiro, cada consulta SQL é definida como um elemento Java utilizando
anotações da pureQuery (e.g., @Select, @Update e @Call), aumentando a separação
entre as camadas uma vez que não utiliza-se códigos SQL dentre das classes. No
segundo as consultas SQL são criadas na mesma como atributos do tipo String dentro
de cada classe Java, de forma semelhante ao desenvolvimento tradicional baseado em
JDBC para comunicação com o banco de dados. No exemplo desse artigo utilizaremos o
primeiro estilo.
Figura 9. Criação das classes bean e
controller para cada tabela relacional
A Figura 10 apresenta o resultado final após a criação de classes a partir das
tabelas User, File, Photo, Video e Comment. O pacote com.ibm.dw.bean contará com as classes User, File, Photo, Video e
Comment, enquanto o pacote com.ibm.dw.controller contará
com as classes UserDataImpl, FileDataImpl, PhotoDataImpl, VideoDataImpl e
CommentDataImpl.
Figura 10. Classes criadas pelo
pureQuery a partir de tabelas relacionais
4.2. Camada Bean, Controller e View
O projeto MyStory terá pacotes os pacotes Model e Controller preenchidos pelas
classes criadas de forma automatizada pelo pureQuery. Entretanto, essas classes
ainda necessitam de ajustes, uma vez que a modelagem para banco de dados não possuí
abstração suficiente para modelar a herança entre a classe File e suas sub-classes
Video e Photo. Além disso, na versão atual do DataStudio não suporta a criação
automatizada de relacionamentos entre objetos (e.g., auto-relacionamento,
muitos-para-muitos, um-para-muitos). Dessa forma, deveremos adicionar aos beans
User, File, Video, Photo e Comment atributos que sigam o padrão de projetos Wrapper.
Esses atributos irão adaptar os beans para permitir o relacionamento entre os
objetos criados a partir dos mesmos.
O bean User deve ser modificado para que o auto-relacionamento entre usuários possa
ser realizado também em nível de objetos. Como apresentado na Listagem 1, deve-se
adicionar o atributo friendshipWrapper do tipo User. Dessa forma, no comportamento
getFrienshipWrapper, a classe UserDataImpl será utilizada para recuperar-se o
user correspondente ao atributo friendship.
Listagem 1. Bean User
public class User {
// Class variables
protected String username;
protected String friendship;
protected String name;
protected String password;
//Código adicional
private UserDataImpl userData = new UserDataImpl();
private User friendshipWrapper;
public User getFriendshipWrapper() {
return userData.getUser(username);
}
public void setFriendshipWrapper(User friendshipWrapper) {
this.friendshipWrapper = friendshipWrapper;
this.friendship = friendshipWrapper.getUsername();
}
|
No bean um novo atributo deve ser criado para que permitir a relação entre File e
User seja refletida nos objetos. Além disso, uma vez que não haverá arquivos que não
são Vídeos ou Fotos, o bean File deve ser marcado como abstrato impedindo que sejam
instanciados objetos da classe File.
Listagem 2. Bean File
public abstract class File {
// Class variables
protected long id;
protected String user;
protected byte[] file;
//Código adicional
private UserDataImpl userData = new UserDataImpl();
private User userWrapper;
public User getUserWrapper() {
return userData.getUser(user);
}
public void setUserWrapper(User userWrapper) {
this.userWrapper = userWrapper;
this.user = userWrapper.getUsername();
}
|
Nos beans Photo e Video, devemos adicionar a herança a partir da classe File, como
apresentado nas Listagens 3 e 4.
Listagem 3. Bean Photo
public class Photo extends File{
// Class variables
protected long id;
protected String caption;
protected long id_file;
|
Listagem 4. Bean Video
public class Video extends File{
// Class variables
protected long id;
protected String soundquality;
protected long id_file;
|
Como apresentado na Listagem 5, no bean Comment devem ser adicionados os atributos
userWrapper e fileWrapper para que o relacionamento entre as classes User e File com
a classe Comment sejam implementados nos objetos criados a partir dos mesmos.
Listagem 5. Bean Comment
public class Comment {
// Class variables
protected long id;
protected String user;
protected long file;
protected String text;
//Código adicional
private UserDataImpl userData = new UserDataImpl();
private FileDataImpl fileData = new FileDataImpl();
private User userWrapper;
private File fileWrapper;
public User getUserWrapper() {
return userData.getUser(user);
}
public void setUserWrapper(User userWrapper) {
this.userWrapper = userWrapper;
this.user = userWrapper.username;
}
public File getFileWrapper() {
return fileData.getFile(file);
}
public void setFileWrapper(File fileWrapper) {
this.fileWrapper = fileWrapper;
this.file = fileWrapper.getId();
}
|
Ainda seguindo o padrão Wrapper, criaremos na camada Controller as classes dessa
camada serão responsáveis por utilizar as funcionalidades das classes de acesso aos
dados geradas pelo pureQuery (UserDataImpl, FileDataImpl, PhotoImpl, VideoImpl e
CommentImpl) em conjunto com os beans modificados anteriormente. Para tal, criaremos
a inteface InterfaceController, apresentada na Listagem 6, que irá garantir que
todas as novas classes possuam as operações de CRUD.
Listagem 6. Classe InterfaceController
package com.ibm.dw.controller;
public interface InterfaceController <T> {
void create(T object);
T retrieve();
void update(T objetct);
void delete(T object);
}
|
Assim, usando a classe CommentController, apresentada na Listagem 7, poderemos
utilizar os comportamentos Create, Delete, Retrieve e Update na camada View da nossa
aplicação.
Listagem 7. Classe CommentController
package com.ibm.dw.controller;
import com.ibm.dw.model.Comment;
import com.ibm.dw.pq.CommentDataImpl;
public class CommentController implements InterfaceController<Comment>{
private CommentDataImpl data = new CommentDataImpl();
@Override
public void create(Comment object) {
data.createComment(object);
}
@Override
public void delete(Comment object) {
data.deleteComment(object);
}
@Override
public Comment retrieve(Comment object) {
return data.getComment(object);
}
@Override
public void update(Comment object) {
data.createComment(object);
}
|
Para facilitar o entendimento a camada View será implementada utilizando páginas
JavaServer Pages (JSP), porém poderiamos utilizar frameworks como Java Server Faces
(JSF) ou RichFaces. Como apresentado na Figura 11, deve-se criar um arquivo .jsp na
pasta WebContent do projeto.
Figura 11. Criação da camada
view
Para esse exemplo, foram implementadas as funcionalidades: criação de usuários,
login de usuários na aplicação, envio e visualização de imagens. Na
listagem 8 apresenta-se o arquivo .jsp para a inserção de dados de um usuário a ser
criado.
Listagem 8. Classe CommentController
<html>
<head>
<title>pureQuery Fotolog</title>
</head>
<body>
Criar novo usuário
<form action="viewNovoUsuario.jsp">
Nome: <input type="text" name="nome"><br>
Username: <input type="text" name="username"><br>
Password: <input type="password" name="password"><br>
<input type="submit">
</form>
</body>
</html>
|
Os dados inseridos nessa página são enviados para a página viewNovoUsuario.jsp, que
acessará a camada controler para que o usuário seja inserido no banco de dados
através da plataforma pureQuery, como apresentado na Listagem 9.
Listagem 9. Classe CommentController
<%@page import="com.ibm.dw.controller.UserController"%>
<%@page import="com.ibm.dw.model.User"%>
<%
User user = new User();
user.setName(request.getParameter("nome"));
user.setPassword(request.getParameter("password"));
user.setUsername(request.getParameter("username"));
UserController controller = new UserController();
controller.create(user);
%>
|
A Figura 12 apresenta o resultado final do desenvolvimento da aplicação para o
compartilhamento de fotos e vídeos.
Figura 12. Aplicação MyStory
Referências
Azadeh Ahadian (2007), “Understanding pureQuery”, Developer Works. Disponível em: http://www.ibm.com/developerworks/data/library/techarticle/dm-0708ahadian/
e http://www.ibm.com/developerworks/data/library/techarticle/dm-0801ahadian/
Heater Lamber, Vitor Rodrigues e (2008) “Write high performance, Java data access
applications” http://www.ibm.com/developerworks/data/library/techarticle/dm-0804lamb/, http://www.ibm.com/developerworks/data/library/techarticle/dm-0808rodrigues/
e Sonali Surange e Zeus Courtois (2008) “What’s new and exciting in IBM Data Studio
Developer 2.1” http://www.ibm.com/developerworks/data/library/techarticle/dm-0812surange/
Design-pattern: Model-View-Controller, disponível em http://java.sun.com/blueprints/patterns/MVC-detailed.html
Sobre o autor  | 
| | Luiz Henrique Zambom Santana é Analista de Suporte Avançado para DB2 LUW. Possui 11 anos de experiência em TI, cursa Doutorado em Informática em Saúde pela UNIFESP, é mestre pela UFSCar e bacharel em Ciência da Computação pela UNESP (São José do Rio Preto). Possui as certificações Sun Certified Java Programmer (SCJP) 1.5, IBM DB2 9 Advanced DBA for Linux, UNIX and Windows, IBM DB2 9 DBA for Linux, UNIX and Windows e IBM Certified Database Associate DB2 Universal Database V8.1 Family. É também professor de programação no Centro Universitário Nove de Julho (UNINOVE). |
Avalie esta página
| 
