Sistema de Controle de Vendas utilizando dispositivos móveis

CURSO DE ANÁLISE E DESENVOLVIMENTO DE SISTEMAS
DANIEL VIANA AZEVEDO
FABIANO DOS SANTOS FERNANDES
RODOLFO GOMES DO NASCIMENTO
Sistema de Controle de Vendas utilizando dispositivos móveis
CAMPOS DOS GOYTACAZES/RJ
2011
II
DANIEL VIANA AZEVEDO
FABIANO DOS SANTOS FERNANDES
RODOLFO GOMES DO NASCIMENTO
Sistema de Controle de Vendas utilizando dispositivos móveis
Monografia de Conclusão de Curso Análise e
Desenvolvimento de Sistemas apresentada no
Instituto Federal de Educação, Ciências e
Tecnologia
Orientador: Profº Ricardo José dos Santos
Barcelos, MSC.
CAMPOS DOS GOYTACAZES/RJ
2011
III
DANIEL VIANA AZEVEDO
FABIANO DOS SANTOS FERNANDES
RODOLFO GOMES DO NASCIMENTO
Sistema de Controle de Vendas utilizando dispositivos móveis
Monografia de Conclusão de Curso Análise e
Desenvolvimento de Sistemas apresentada no
Instituto Federal de Educação, Ciências e
Tecnologia
Aprovada em ___ de _______________________ de 2011
Banca Avaliadora:
__________________________________________________________________
Prof. Ricardo José dos Santos Barcelos (orientador)
Mestre em Engenharia de Produção pela UENF
Instituto Federal de Educação, Ciência e Tecnologia Fluminense.
__________________________________________________________________
Prof. Fábio Duncan de Souza
Mestre em Pesquisa Operacional e Inteligência Computacional pela UCAM
Instituto Federal de Educação, Ciência e Tecnologia Fluminense.
__________________________________________________________________
Prof. Luiz Gustavo Lourenço Moura
Mestre em Informática pela UFRJ
Instituto Federal de Educação, Ciência e Tecnologia Fluminense.
IV
RESUMO
A expansão dos dispositivos móveis vem aumentando com o passar do tempo. O grande
aumento nas vendas destes aparelhos tem várias causas, como a queda nos preços e a grande
diversidade de modelos. Essa rápida e constante popularização tem como consequência a
necessidade de criação de novos serviços e aplicações. A partir desta realidade, este projeto
consiste no desenvolvimento de um aplicativo (protótipo) baseado na realização de vendas
remotas desenvolvido na plataforma J2ME, que é direcionada para dispositivos com recursos
de hardware e software limitados. Os usuários utilizarão a aplicação instalada em um terminal
móvel (aparelho celular GSM) com acesso à Internet, onde remotamente acessarão os dados
contidos na base de dados e através deste acesso será possível realizar e visualizar vendas.
Palavras-chaves: J2ME. Terminal móvel. Vendas remotas. Base de dados.
V
ABSTRACT
The expansion of mobile devices has been increasing over time. The large increase in sales of
these devices has several causes, such as falling prices and the great diversity of models. This
rapid and sustained popularity has resulted in the need to create new services and applications.
From this fact, this project is to develop an application (prototype) based on remote execution
of sales developed in J2ME, which is aimed at devices with limited hardware and software.
The users use the application installed on a mobile handset (GSM cell phone) with internet
access, where remotely access data contained in the database and through this access will be
possible and view sales.
Keywords: J2ME. Terminal mobile. Remote sales. Database.
VI
LISTA DE FIGURAS
FIGURA 1 –Arquitetura da linguagem Java .............................................................................. 8
FIGURA 2 – Arquitetura J2ME ............................................................................................... 10
FIGURA 3 – Comunicação entre a MIDlet e o Banco de Dados ............................................. 21
FIGURA 4 – Trecho da programação utilizando o commandAction .............................................. 24
FIGURA 5 – Variáveis de busca e busca com o banco de dados ................................................... 25
FIGURA 6 – Código tentativa de conexão entre o banco e a página JSP........................................ 26
FIGURA 7 – Código de separação dos campos............................................................................ 26
FIGURA 8 – Código de ligação da MIDlet estoque.java com a classe acessoWEB.java ................. 27
FIGURA 9 – Métodos public void lerVenda() e public void inicia_thread()................................... 28
FIGURA 10 – Trecho da programação utilizando uma Estrutura de repetição .......................... 29
FIGURA 11 – Método recebedados_produto............................................................................... 30
FIGURA 12 – Objetos do formulário de Vendas ......................................................................... 30
FIGURA 13 – Command cm_gravar .......................................................................................... 31
FIGURA 14 – Método inserirVenda ........................................................................................... 31
FIGURA 15 – Código SQL de inserção ...................................................................................... 32
FIGURA 16 – Tela de lista dos produtos..................................................................................... 33
FIGURA 17 – Funcionalidades do menu..................................................................................... 34
FIGURA 18 – Formulário de Vendas ......................................................................................... 34
FIGURA 19 – Tela de lista de produtos atualizada após a venda................................................... 35
FIGURA 20 – Tela de visualização das vendas efetuadas. ............................................................ 35
FIGURA 21 – Tela de ajuda ...................................................................................................... 36
VII
LISTA DE TABELAS
TABELA 1 – Vendas mundiais de dispositivos móveis para usuários em 2010 (milhões de
unidades)..................................................................................................................................... 3
VIII
LISTA DE ABREVIATURAS E SIGLAS
API – Application Programing Interface
BSD - Berkeley Software Distribution
CDC – Connected Device Configuration
CLDC – Connected Limited Device Configuration
EJB - Enterprise JavaBeans
GSM - Global System for Mobile Communication
HTML – Hipertext Markup Language
HTTP – Hipertext Transfer Protocol
IDE - Integrated Development Environment
J2EE – Java 2 Enterprise Edition
J2ME – Java 2 Micro Edition
J2SE – Java 2 Standard Edition
JAD – Java Descriptor
JAR – Java Archive
JVM – Java Virtual Machine
KVM – Kilobyte Virtual Machine
MIDP – Mobile Information Device Profile
PC – Personal Computer
PDA – Personal Digital Assitant
PHP - Hypertext Preprocessor
URL – Unified Resource Locator
IX
SGBD – Sistema Gerenciador do Banco de dados
SQL – Structured Query Language
SSL - Security Socket Layer
SUN – Stanford University Network
XML – Extensible Markup Language
Sumário
LISTA DE ABREVIATURAS E SIGLAS ........................................................................... VIII
Capitulo I .................................................................................................................................... 3
Introdução ................................................................................................................................... 3
1.1 Motivação ......................................................................................................................... 4
1.2 Objetivo ............................................................................................................................ 5
1.3 Estrutura da Monografia ................................................................................................... 5
Capitulo II ................................................................................................................................... 7
2. Tecnologias e Ferramentas utilizadas ..................................................................................... 7
2.1 Java ................................................................................................................................... 7
2.2 J2ME – Java 2 Micro Edition ........................................................................................... 9
2.3 PostgreSQL ..................................................................................................................... 12
2.4 NetBeans ......................................................................................................................... 14
2.5 GlassFish ......................................................................................................................... 15
2.6 GSM - GlobalSystemforMobileCommunication ............................................................. 16
Capitulo III ............................................................................................................................... 18
3. Desenvolvimento do Protótipo ............................................................................................. 18
3.1 Requisitos de hardware .................................................................................................. 18
3.2 Requisitos de software .................................................................................................... 19
3.3 Diagrama de Casos de Uso ............................................................................................. 19
3.3.1 Descrição dos casos de uso ...................................................................................... 19
3.4 Estrutura de comunicação entre a MIDlet e o banco de dados ....................................... 20
3.6 Modelo Entidade Relacionamento – Banco de dados..................................................... 21
3.7 Detalhes do desenvolvimento do Projeto........................................................................ 22
Capítulo IV ............................................................................................................................... 33
4. Utilização do Protótipo ......................................................................................................... 33
Capítulo V ................................................................................................................................ 37
5. Conclusão ............................................................................................................................. 37
5.1 Trabalhos Futuros ........................................................................................................... 37
REFERÊNCIA BIBLIOGRÁFICA .......................................................................................... 38
ANEXO .................................................................................................................................... 40
3
Capitulo I
Introdução
Segundo (Bogo, 2000), a Internet é um conjunto de redes de computadores
interligadas que tem em comum protocolos e serviços, de forma que os usuários conectados
possam usufruir de serviços de informação e comunicação de alcance mundial. A cada dia
surgem novas aplicações e serviço prestado via internet para dispositivos móveis, como o
envio e leitura de e-mails, transações bancárias, acessam a redes sociais, entre outros. Isto
ocorre principalmente devido aos custos mais acessíveis e à extensa variedade de modelos e
funcionalidades existentes para esses dispositivos. São celulares, smartphones (celulares com
funcionalidades avançadas), PDAs (computador de bolso), Ipods (reprodutor de conteúdo
multimídia avançado), e os tablets (computador pessoal compacto).
Segundo estudo realizado pela (Gartner, 2010), empresa especializada em pesquisa e
aconselhamento sobre tecnologia, aponta-se que vendas de dispositivos móveis para usuários
finais totalizaram 1,6 bilhão de unidades em 2010, um aumento de 31,8% em relação ao ano
anterior. Já as vendas de smartphones aumentaram 72,1% em comparação ao mesmo período
e foram responsáveis por 19% do total das vendas de dispositivos móveis em 2010. A Tabela
1 apresenta dados do estudo feito pela Gartner.
Tabela 1 – Vendas mundiais de dispositivos móveis para usuários em 2010 (milhares de
unidades)
Fonte: Gartner (Fevereiro de 2011)
4
Com o aumento das vendas de dispositivos móveis, é comum indivíduos utilizarem
dispositivos móveis em locais como a fila do metrô, na sala de espera do consultório médico,
no ponto de parada de ônibus, para acessar informações meteorológicas, ler jornais, enviar emails, dentre as inúmeras possibilidades que estes aparelhos proporcionam.A rápida expansão
destes aparelhos possibilita a evolução e diversificação dos serviços prestados via internet, e
adaptando-os a esta nova realidade.
O termo mobilidade cada vez mais é observado no cenário tecnológico. A liberdade de
conversar com os amigos remotamente ou à distância, a partir de uma lanchonete ou
restaurante vem atraindo as pessoas de todas as classes sociais.
1.1 Motivação
Grande parte de vendedores utilizam pastas com talões de vendas, ocasionando perda
de produtividade devido ao tempo gasto no seu preenchimento e excesso de peso,
ocasionando um cansaço físico maior por conta da necessidade deste durante seu trabalho.
Também é observada a necessidade de constante comunicação entre o vendedor e a sua base
para consultar preços, disponibilidade de material, entre outras necessidades, o que gera mais
um desgaste para o mesmo.
Porem existe aplicações que visam corrigir ou minimizar esses problemas, mas em
comum estas aplicações funcionam em arquiteturas dedicadas, como o Palm (computadores
de mão), e no caso destes dispositivos, os custos são elevados em comparação com um celular
GSM com função de acesso a internet, e pode demandar um treinamento maior por parte do
usuário.
Sendo assim, vários representantes de vendas não possuem dispositivos que os
auxiliem nas vendas e na comunicação com a sua base. Para efetuar uma venda, estes
representantes necessitam ligar para a fábrica diariamente e consultar preços e a
disponibilidade do produto no estoque. As vendas não são atualizadas em tempo real,
podendo ocorrer à venda de determinado produto que já não se encontra em estoque.
A realidade apresentada motivou a criação deste projeto, que consiste no
desenvolvimento de uma aplicação (protótipo), para realização remota de vendas utilizando a
5
J2ME. Para a sua implementação, foi utilizada a interface de desenvolvimento Netbeans
(http://www.oficinadanet.com.br/artigo/1061/o_que_e_o_netbeans), por ser uma IDE não
utilizada no curso de Análise e Desenvolvimento de Sistemas, sendo assim necessário muito
estudo para sua utilização neste projeto. Também foi necessário o uso de um banco de dados
para o armazenamento dos dados. Sendo assim, foi utilizado o PostegreSQL
(http://wiki.postgresql.org/wiki/Introdu%C3%A7%C3%A3o_e_Hist%C3%B3rico), por ser
um banco de dados robusto, com instalação simples e rápida. Os aparelhos utilizados foram os
modelos 5530 e E63 da NOKIA1, que utilizam a tecnologia GSM, com sistema operacional
Symbian, e que possuem suporte à tecnologia Java/J2ME.
1.2 Objetivo
Considerando as dificuldades apresentadas, o protótipo criado é potencialmente
atrativo para vendedores, representantes comerciais e empresas do setor de vendas, tendo por
objetivo facilitar o trabalho destes profissionais, mas não resolvê-los totalmente, levando em
consideração que podem haver dificuldades quanto à sua utilização devido a fatores externos,
como perda de sinal e a falta de internet em determinadas áreas, dificuldades que poderiam
ser sanadas pelos próprios fornecedores dos serviços de telefonia e internet.
Com o protótipo desenvolvido, o usuário pode efetuar e visualizar vendas, consultar
produtos e acessar a ajuda na utilização do protótipo, bastando que haja um aparelho celular
com suporte a tecnologia Java e conexão com a internet.
1.3 Estrutura da Monografia
Esta monografia apresenta cinco capítulos, incluindo esta introdução:
 CAPÍTULO I – INTRODUÇÃO:
Este capítulo apresenta o crescimento de aplicações e usuários de dispositivos móveis,
apresentando os métodos de trabalho de alguns representantes e vendedores, motivando o
1
NOKIA fabricante mundial de dispositivos móveis.
6
desenvolvimento de uma aplicação (protótipo) potencialmente atrativo para estes
profissionais, levando em consideração as necessidades e o objetivo apresentado.
 CAPÍTULO II – TECNOLOGIAS E FERRAMENTAS UTILIZADAS:
São apresentadas as tecnologias e as ferramentas utilizadas no desenvolvimento do
trabalho, suas características, vantagens e evolução até as versões utilizadas.
 CAPÍTULO III – DESENVOLVIMENTO DO PROTÓTIPO:
Descreve todas as fases do projeto com os requisitos de hardware e software, o
diagrama de casos de uso detalhado, a estrutura da aplicação, as ferramentas e tecnologias
utilizadas no desenvolvimento, a implementação do banco de dados e a evolução do protótipo.
 CAPÍTULO IV – UTILIZAÇÃO DO PROTÓTIPO:
Mostra o funcionamento e funcionalidades do protótipo através das telas geradas pelo
emulador.
 CAPÍTULO V – CONCLUSÃO:
Apresenta os resultados alcançados, descrevendo suas contribuições para os
interessados do ramo de vendas e futuras implementações que podem ser desenvolvida.
7
Capitulo II
2. Tecnologias e Ferramentas utilizadas
Para o desenvolvimento de uma aplicação em J2ME é necessária uma JVM e uma IDE
de desenvolvimento. No site http://www.java.com/pt_BR/download/ está disponível a versão
atual do Java para download. Com a instalação do Java será instalada a máquina virtual, que é
necessária para a execução da aplicação.
Neste projeto foi utilizada a IDE NetBeans na versão 6.9.1. Esta ferramenta se
encontra disponível para download em http://netbeans.org/downloads/6.9.1/. Neste site há
varias opções de download desta ferramenta, para o desenvolvimento em várias linguagens. A
versão utilizada neste projeto acompanha o servidor webGlassFish, que será o responsável por
fazer a ligação da MIDlet com as páginas JSP.
Para a visualização do andamento da aplicação, é necessário que haja um emulador
instalado, lembrando que existem vários tipos de emuladores de acordo com cada fabricante
de celulares. Este projeto utiliza o WirelessToolkit 2.5.2 for CLDC, disponível em
http://www.oracle.com/technetwork/java/index-jsp-137162.html.
Na
instalação
do
WirelessToolkit, o mesmo reconhece a maquina virtual Java instalada.
O banco de dados utilizado no desenvolvimento do protótipo é o PostgreSQL na
versão 8.3, disponível em http://www.postgresql.org/download/windows site do PostgreSQL
para download.
2.1 Java
Segundo (Silveira, 2003), Java é uma linguagem de alto nível, com sintaxe similar à
do C++. Esta é uma linguagem simples, orientada a objeto, tipada (usa variáveis com tipos
específicos), independente de arquitetura (pode ser utilizada em qualquer plataforma sem
alteração do código fonte), robusta, segura, extensível, bem estruturada, distribuída,
multithreaded (multitarefas) e com garbage collection (coleta de lixo). A simplicidade da
linguagem Java deriva do fato de não possuir sobrecarga de operadores, structs, unions,
aritmética de ponteiros, herança múltipla, diretiva de pré-processamento e a memória alocada
8
dinamicamente é gerenciada pela própria linguagem, que usa algoritmos de garbage
collection para desalocar (liberar) regiões de memória que não estão mais em uso no software.
A plataforma de desenvolvimento é bastante versátil, subdivida em várias edições,
cada uma possuindo um propósito específico (Muchow, 2001):

Java SE - Projetado para funcionar em computadores desktop e estações de
trabalho;

Java EE - Com suporte embutido para Servlets, JSP, XML, esta edição é
destinada a aplicações baseadas em servidor;

Java ME - Projetado para dispositivos com pouca memória de vídeo e poder de
processamento (dispositivos móveis);

Java Card para desenvolvimento em Smart Cards, etc.
Em 1998, a Sun2 introduziu o nome "Java 2" junto com o lançamento do Java 1.2. Esta
convenção de nomenclatura se aplica a todas as edições do Java Standard Edition, Enterprise
Edition, e Micro Edition (Muchow 2001). A figura 2 apresenta as configurações de hardware
e software, necessárias para cada edição da linguagem java e onde se aplica cada uma. Em
destaque a J2ME para dispositivos móveis (celulares) de menor processamento e memória
limitada, que utilizão a KVM (kilobyte virtual machine).
Figura 1 - Arquitetura da linguagem Java.
Fonte: http://javaminas.wordpress.com
2
Sun é uma empresa da Oracle Corporation, fabricante de computadores, semicondutor e software.
9
Com a linguagem de programação Java, pode-se criar um aplicativo que funcione
tanto no Linux3 quanto no Windows4. Mas a linguagem Java não se limita apenas a esses
sistemas operacionais. É possível desenvolver aplicações para uma infinidade de plataformas,
desde que haja suporte a Java Virtual Machine ou, em português, Máquina Virtual Java.
(Alecrim, 2005)
A JVM é um mecanismo que permite executar código em Java em qualquer
plataforma. Segundo a definição da Sun, a JVM pode ser entendida como "uma máquina
imaginária implementada via software ou hardware que executa instruções vindas de
bytecodes (código em bytes). (Alecrim, 2005)
Segundo a (Oracle5, 2011) a tecnologia Java esta presente em mais de 4,5 bilhões de
dispositivos, incluindo:

Mais de 800 milhões de PCs (computadores pessoais).

2,1 bilhões de telefone celulares e outros dispositivos portáteis.

3,5 milhões de cartões inteligentes.
Além de impressoras, webcams, jogos, sistemas de operação para automóveis,
terminais lotéricos, dispositivos médicos, guichês de pagamento de estacionamento, entre
outros.
2.2 J2ME – Java 2 Micro Edition
De acordo com a Sun, Java 2 Micro Edition é uma API (Interface de Programação de
Aplicações)
que tem por objetivo desenvolver aplicativos para aparelhos com pequena
capacidade de memóriacomo micro processadores. É um padrão que provê um ambiente
flexível para aplicações que executem em dispositivos como celulares, PDAs, TVs, sistemas
de navegação de carros e outros dispositivos.
Neste projeto foi utilizado J2ME no desenvolvimento do protótipo, por esta ser
utilizada por mais de dois bilhões de aparelhos, segundo (Kozovits, 2009), ser associada a
3
Linux sistema operacional de código livre.
Windows sistema operacional multitarefa com interface gráfica.
5
Oracle Corporation é uma empresa multinacional de tecnologia e informação dos Estados Unidos.
4
10
tecnologia GSM (Global System for Mobile Communication) e por possuir uma comunidade de
desenvolvedores.
A máquina virtual J2ME foi projetada para ser utilizada em dispositivos móveis que
possuem memória limitada, display (tela) menor e menos poder de processamento. É chamada
Kilobyte Virtual Machine (KVM) numa alusão à pequena quantidade de memória exigida, que
está na ordem dos kilobytes. É a base da arquitetura, localizada sobre o sistema operacional
instalado na máquina, seguida pelas configurações que suporta os Perfis.
Segundo (Corbera, 2003), esta plataforma consiste de máquinas virtuais (KVM) e
APIs de configuração (CDC e CLDC) atuando em conjunto com profiles (perfis). O perfil
utilizado neste projeto foi o MIDP, que tem como base o CLDC. Ele fornece funcionalidades
para o desenvolvimento de aplicativos para uma grande variedade de celulares e é atualmente
a tecnologia mais usada para desenvolvimento de aplicativos para esses dispositivos. Os
aplicativos desenvolvidos com base no MIDP são chamados de MIDlets. A MIDlet é uma
classe Java com estrutura já pronta. O ciclo de vida de uma MIDlet é composto de três
métodos, sendo eles: startApp (método que irá inicializar a aplicação), pauseApp (método que
irá pausar a aplicação) e destroyApp (método que irá finalizar a aplicação). A Figura 2
apresenta a arquitetura da J2ME disposta em camada:
Figura 2 - Arquitetura J2ME
Fonte: www.inforede.net/Technical/Layer_1/Wireless_Mobile/Tutorial%20J2ME%20Parte%201.pdf
11
Segundo (Pereira, 2008), o CDC e o CLDC são configurações de dispositivos
conectáveis. O CDC é uma configuração de hardware que têm memória considerável e maior
poder de processamento, tais aparelhos têm uma conexão permanente e de maior largura de
banda (medida de frequência em Hertz de um sistema ou sinal). Neste grupo podemos incluir
os computadores de bordo, televisores e tabletes PCs. Diferentemente do CDC, o CLDC
abrange aparelhos em que a conexão é interrompida e de pequena largura de banda. Esta
configuração foi projetada visando suprir as necessidades de dispositivos com pouca
memória, limitações gráficas e baixo poder de processamento. Os aparelhos com esta
característica são os PDA’s, aparelhos celulares e os smartcards (cartões inteligentes).
Lembrando que as APIs de configuração atuam integradas com a JVM instalada nos
dispositivos.
No padrão Mobile Information Device Profile ou Perfil de Dispositivo de Informação
Móvel, o objetivo é definir bibliotecas e APIs especificamente para dispositivos com
comunicação wireless, como telefones celulares. O principal objetivo da especificação MIDP
são as APIs de componentes, interface com o usuário e tratamento de eventos, comunicação
via rede e armazenamento persistente.
Segundo (Schmitt, 2004), uma aplicação MIDP contém no mínimo uma classe MIDlet,
podendo em alguns casos conter mais de um MIDlet, sendo chamada de MIDlet Suite. A
aplicação MIDP, para ser instalada no dispositivo, necessita ser empacotada (compactada),
criando um Java Archive (JAR) que obrigatoriamente contém um arquivo de manifesto (este
arquivo descreve configurações básicas para que o MIDlet execute, tais como nome do
MDIlet, localização do jar e outras), englobando as informações sobre o MIDlet contido no
pacote JAR. Este arquivo contendo as informações sobre a aplicação, configuração e perfil
utilizado na mesma, é denominado Java Application Descriptor.
A MIDP que estamos utilizando é a 2.1, que reforça a MIDP 2.0 e o dispositivo móvel
deve possuir as seguintes características: (Pereira, 2008)

256 kb de memória não volátil

18 kb de memória volátil

8 kb de memória não volátil (dados persistentes do programador)

Display 96×54, 1-bit, 1:1

Rede: two-way (duas vias) e wireless
12

Exigência de suporte à conexão segura

Biblioteca de multimídia

Formulário de entrada de dados aprimorada

Sensível melhoria na API de suporte a Games

Conceito de aplicações confiáveis (Trusted) e não confiáveis (Untrusted)
O Sun Java Wireless ToolKité uma caixa de ferramentas "state-of-the-art” (de última
geração) para o desenvolvimento de aplicações sem fio que são baseados em Connected
J2ME LimitedDevice Configuration e Mobile Information Device Profile, e projetado para
rodar em telefones celulares, assistentes digitais pessoais mainstream (corrente principal), e
outros pequenos dispositivos móveis. O toolkit inclui os ambientes de emulação, de
otimização de desempenho e recursos de ajuste, documentação e exemplos que os
desenvolvedores precisam para serem eficientes e bem sucedidos.
2.3 PostgreSQL
Segundo (Biazus, 2009) o PostgreSQL é um SGBD, objeto-relacional de código
aberto, desenvolvido pelo Departamento de Ciência da Computação da Universidade da
Califórnia em Berkley há mais de 15 anos, derivado do projeto POSTGRES. É extremamente
robusto e confiável, além de ser extremamente flexível e rico em recursos. O PostgreSQL é
considerado objeto-relacional por implementar, além das características de um SGBD
relacional, possui características de orientação a objetos, como herança e tipos personalizados.
OPOSTGRES foi originalmente patrocinado pelo DARPA (Agência de Pesquisa de
Projeto Avançado de Defesa), ARO (Army Research Office), NSF (National Sciencia
Foundation) e ESL Inc (Electromagnetic Systems Laboratory Incoporated). A implementação
do projeto POSTGRES iniciou-se em 1986. A primeira versão lançada para o público externo
foi em 1989. Devido a uma crítica feita ao seu sistema de regras, o POSTGRES teve essa parte
re-implementada e lançada em uma segunda versão em 1990. Em 1991 foi lançada a versão 3,
com melhorias no executor de consultas e algumas partes do código foram re-escritas. As
versões subsequentes, até o Postgres95, foram focadas em confiabilidade e portabilidade. O
POSTGRES foi utilizado para diversos sistemas de pesquisa e de produção, uma aplicação de
análise financeira, e diversos sistemas de informações geográficas. O código do POSTGRES é
13
comercializado pela Illustra Information Technologies (posteriormente incorporada à
Informix, que agora pertence à IBM).(Biazus, 2009)
Em 1996 o nome Postgres95 tornou-se inadequado, o projeto foi rebatizado
"PostgreSQL", para enfatizar a relação do POSTGRES original com a linguagem SQL. A
numeração da versão voltou a seguir o padrão anterior ao Postgres95 (considerada a 5.0), e a
primeira versão do PostgreSQL foi a 6.0. Enquanto a ênfase do Postgres95 foi a correção de
falhas e otimização do código, o desenvolvimento das primeiras versões do PostgreSQL foi à
melhoria de recursos e implementação de novos recursos, sempre seguindo os padrões de
SQL anteriormente estabelecidos. (Biazus, 2009)
A equipe do projeto cresceu e se espalhou pelo mundo. O PostgreSQLGlobal
Development Group tem membros nos Estados Unidos, Canadá, Japão, Rússia, vários países
da Europa e alguns outros. Esse grupo é formado essencialmente por empresas especializadas
em PostgreSQL, empresas usuárias do sistema, além dos pesquisadores acadêmicos e
programadores independentes. Além da programação, essa comunidade é responsável pela
documentação, tradução, criação de ferramentas de modelagem e gerenciamento, e elaboração
de extensões e acessórios. Pela riqueza de recursos e conformidade com os padrões, ele é um
SGBD muito adequado para o estudo universitário do modelo relacional, além de ser uma
ótima opção para empresas implementarem soluções de alta confiabilidade sem altos custos
de licenciamento. É um programa distribuído sob a licença BSD, o que torna o seu código
fonte disponível e o seu uso livre para aplicações comerciais ou não. O PostgreSQL foi
implementado em diversos ambientes de produção no mundo, entre eles, o banco de dados
que armazena os registros de domínio .org, mantido pela empresa Afilias.
Abaixo são mostrados alguns recursos utilizado na versão mais recente do
PostgreSQL: (Biazus, 2009)

Sub-consultas;

Controle de concorrência multi-versão;

Integridade Referencial;

Funções armazenadas (Stored Procedures), que podem ser escritas em várias
linguagens de programação (PL/PgSQL, Perl, Python, Ruby, e outras);

Gatilhos (Triggers);

Tipos definidos pelo usuário;
14

Esquemas;

Conexões SSL;

Áreas de armazenamento;

Pontos de salvamento;

Commit (conjunto de mudanças permanentes) em duas fases

Arquivamento e restauração do banco a partir de logs de transação

Diversas ferramentas de replicação

Extensões para dados geoespaciais, indexação de textos, xml e várias outras.
2.4 NetBeans
No desenvolvimento deste protótipo foi utilizada a ferramenta NetBeans, pois a
ferramenta similar Eclipse necessita de uma perspectiva de desenvolvimento para aplicações
J2ME, isto é, o conjunto de bibliotecas e classes de apoio ao desenvolvimento móvel, e o
NetBeans já possui esta perspectiva de desenvolvimento.
A seguir são apresentadas alguns dos principais recursos disponíveis para o
desenvolvimento de aplicações móveis Java no NetBeans: (Developer, 2011)

Editor visual de fluxo da aplicação (Visual Flow Designer);

Editor visual de formulários (Visual Form Designer);

Analisador de códigos;

Um sistema de compilação de projeto modular;

Suporte ao porte de aplicações;

Configuração das conexões sem fio (disponível no pacote All);

Suporte ao desenvolvimento de gráficos vetoriais escaláveis para Java ME através da
API JSR 226;

Várias opções de distribuição de aplicações, incluindo a distribuição para dispositivos
Nokia usando o softwareNokia PC Suite;

Suporte a projetos;

Ferramentas de desenvolvimento integrado;

Suporte a execução de testes usando J2MEUnit;

Suporte integrado a ofuscação e otimização de código;
15
O NetBeans Java foi desenvolvido pela empresa Sun Microsystems, é gratuito e de
código aberto para desenvolvedores de software. Esta IDE (Ambiente Integrado para
Desenvolvimento) é executada em diversas plataformas como: Windows, Linux, Solaris e
MacOS, de fácil instalação e usabilidade. É uma ferramenta que auxilia programadores a
escrever, compilar, debugar e instalar aplicações.
Segundo a (Redação Oficina da Net, 2008), oNetBeans foi iniciado em 1996 por dois
estudantes tchecos na Universidade de Charles, em Praga, quando a linguagem de programação
Java ainda não era utilizada como atualmente. Primeiramente o nome do projeto era Xelfi, em
referência ao Delphi, pois, a pretensão deste projeto era possuir funcionalidades semelhantes aos
IDEs, então populares do Delphi que eram mais atrativas por serem ferramentas visuais e mais
fáceis de usarem, porém com o objetivo de ser totalmente desenvolvido em Java.
Em 1999 o projeto já havia evoluído para uma IDE proprietária, com o nome de
NetBeansDeveloperX2. Nessa época a empresa Sun Microsystems havia desistido de sua IDE Java
Workshop e procurando por novas iniciativas adquiriu o projeto NetBeansDeveloperX2
incorporando-o a sua linha de softwares (programa).
Por alguns meses a Sun mudou o nome do projeto para Forte for Java e o manteve por um
bom tempo como software proprietário, porém, em junho de 2000 a Sun disponibilizou o código
fonte do IDE NetBeans tornando-o uma plataforma OpenSource (código aberto). Desde então a
comunidade de desenvolvedores que utilizam e contribuem com o projeto não parou de crescer,
tornando-se uma das IDEs mais populares atualmente.
2.5 GlassFish
Segundo (Souza, 2011), para executarem, aplicações corporativas devem ser
implantadas em servidores de aplicação Java. Um destes servidores é o GlassFish,
desenvolvido pela Oracle e disponibilizado em versões gratuita e comercial. O GlassFish
nasceu em 2005 como um projeto da Sun a partir do servidor de aplicações comercial já
existente na empresa, o Sun Java ApplicationServer 9. Sua versão 1.0 foi desenvolvida para
servir de implementação de referência do padrão Java EE 5, uma implementação completa da
especificação construída para demonstrar como ela funciona.
16
O GlassFish 3.0 foi desenvolvido como implementação de referência do padrão Java
EE 6 e, agora em sua versão 3.1, conta com novas funcionalidades que adicionam
características, como a alta disponibilidade, escalabilidade e tolerância a falhas, que são
essenciais para um servidor de produção que hospede aplicações de médio e grande porte.
(Souza, 2011)
Como o objetivo desta primeira versão era prover uma implementação de referência
para o Java EE 5, ainda faltavam funcionalidades que tornassem o GlassFish um servidor para
uso em produção, como alta disponibilidade e tolerância a falhas. Assim, este foi o objetivo
da versão 2.0 do GlassFish, que adicionou capacidade de clustering (técnica para fazer
agrupamentos automáticos de dados segundo seu grau de semelhança) ao servidor.
(Souza, 2011) Com a disponibilização, em dezembro de 2009, da nova versão do
padrão para aplicações corporativas, o Java EE 6, o GlassFish foi utilizado como
implementação de referência: o GlassFish 3.0 provia uma implementação completa da
especificação Java EE 6, porém sem funcionalidades que o tornassem um servidor de
produção escalável e disponível. No final de fevereiro de 2011, as anteriores funcionalidades
de clustering além de uma série de outras melhorias foram adicionadas ao servidor com o
lançamento do GlassFish 3.1. Algumas destas melhorias são citadas a seguir, conforme o
(GlassFish, 2011):

Evocação dinâmica de serviços, somente os serviços utilizados são iniciados;

Melhorias de extensibilidade, tanto no servidor quanto na interface de administração;

Ciclos de inicialização e implantação (deploy) 29% mais rápidos que na versão 3.0.1.
2.6 GSM - GlobalSystemforMobileCommunication
Segundo (Guenzburger, 2011), trata-se de um padrão aberto para telefonia celular
digital presente na Europa desde 1992 e, nas Américas, desde 1983. No mercado mundial, o
GSM é utilizado por 71% dos indivíduos que possuem celulares e, no Brasil, também é a
tecnologia mais utilizada.
17
Dados da ANATEL (Agência Nacional de Telecomunicação) indicam que o Brasil
terminou em maio/2011 com 215 milhões de celulares, sendo que, 86,47% destes celulares
operavam com tecnologia GSM. (Anatel, 2011)
Uma das principais vantagens desta tecnologia é a proteção contra clonagem (cópia).
Com esta tecnologia, o cliente fica protegido e não tem seu celular clonado. A clonagem não
existe na tecnologia GSM por funcionar em redes 100% digitais criptografadas –
diferentemente de outros sistemas, que alternam entre analógico e digital, conforme a
localização do celular. (Guenzburger, 2011)
A tecnologia GSM tem como diferencial o chip, que contém todas as informações do
usuário. Os chips são processadores potentes e, ao mesmo tempo pequenos, com 2,6 cm por
1,5 cm.
18
Capitulo III
3. Desenvolvimento do Protótipo
3.1 Requisitos de hardware
O MIDP foi construído para funcionar em cima do CLDC. Ele fornece
funcionalidades para o desenvolvimento de aplicativos para uma grande variedade de
celulares e é atualmente a tecnologia mais usada para desenvolvimento de aplicativos para
esses dispositivos. Os aplicativos desenvolvidos com base no MIDP são chamados de
MIDlets.
Para tanto, um MIDP deve possuir as seguintes características mínimas de hardware
(além daquelas que são requeridas pelo CLDC): (Devmedia, 2011)
-
Display:

Tamanho da tela: 96x54;

Profundidade: 1 bit;

Formato do pixel (proporção de aspecto): 1:1;
-
Input:

Teclado de telefone (one-handed keypad) e/ou

Teclado QWERTY(two-handed keyboard) e/ou

Tela sensível ao toque (touch screen)
-
-
Memória:

128Kbytes para os componentes MIDP;

8Kbytes para dados das aplicações;

32Kbytes para o JAVA runtime;
Rede:
19

2-vias, wireless, possivelmente intermitente, e com faixa limitada
3.2 Requisitos de software
Os MIDPs possuem uma grande variedade de softwares de sistema. Por essa razão, o
MIDP estabeleceu requisitos mínimos de sistema: (Devmedia, 2011)
-
Um kernel para controlar o hardware, que possua uma entidade escalonável
para rodar a Máquina Virtual Java;
-
Um mecanismo para ler e escrever na memória para suportar as APIs;
-
Acesso de leitura e escrita à rede sem fio;
3.3 Diagrama de Casos de Uso
3.3.1 Descrição dos casos de uso

Efetuar venda:
Ator do caso de uso: Usuário
Pré-condições: O aparelho deve estar conectado com o banco de dados.
Fluxo Principal:
20
1 – O usuário acessa a aplicação e o protótipo lista todos os produtos na tela do
celular.
2 – O usuário localiza o produto a ser vendido e acessa o formulário de vendas.
3 – O usuário preenche os campos do formulário e finaliza a venda com
sucesso.
Fluxos Alternativos:
3.1 – A venda não é efetuada caso haja algum campo em branco.

Visualizar venda:
Ator do caso de uso: Usuário.
Pré-condições: O protótipo com a base de dados e deve haver no mínimo uma
venda efetuada com sucesso.
Fluxo Principal:
1 – O usuário acessa a opção visualizar vendas no meu do aparelho.
2 – O usuário visualiza todas as vendas listadas pelo protótipo.
3 – O usuário fecha a tela de visualização.

Acessar ajuda:
Ator do caso de uso: Usuário.
Pré-condições: O programa deve estar em execução no aparelho celular.
Fluxo Principal:
1 – O usuário acessa a opção de ajuda no menu do protótipo.
2 – O protótipo mostra um texto de ajuda para o usuário.
3 – O usuário fecha a tela de ajuda.
3.4 Estrutura de comunicação entre a MIDlet e o banco de dados
A MIDlet é a classe Java executada em dispositivos móveis como celulares. Para que
haja uma comunicação entre a MIDlet e o servidor de banco de dados é necessário uma
aplicação Web direcionada (por meio de código) para acessar o banco, assim esta busca e
21
armazena os dados cadastrados no banco. Desta forma, a MIDlet através de um método
(ações), busca as informações armazenada na aplicação Web e mostra na tela do celular.
Para a MIDlet armazenar os dados no banco, esta se comunica com a aplicação Web,
que direciona as informações recebidas para o banco de dados. A Figura 4 apresenta a
estrutura de comunicação entre a MIDlet e o banco de dados.
Figura 3 – Estrutura de comunicação entre a MIDlet e o Banco de Dados
Neste protótipo foi utilizado um emulador da Sun que executa a MIDlet, fazendo a
comunicação com o banco de dados através de páginas JSPs desenvolvidas em JEE. O
processo de desenvolvimento do protótipo foi testado por meio de localhost (localização do
sistema que está sendo usado).
3.6 Modelo Entidade Relacionamento – Banco de dados
O Modelo Entidade Relacionamento (MER) apresenta a ligação das tabelas no
PostgreSQL. Este tem como finalidade descrever a estrutura lógica de um banco de dados. O
MER relaciona as entidades e os seus respectivos atributos. Uma entidade serve tanto para
depósito quanto para recuperação de dados. Toda entidade possui atributos, ou seja,
características que informam sobre a entidade. Relacionamento é a interação entre os objetos
que indicam a dinâmica dos negócios. Os relacionamentos são identificados por verbos
porque representam as ações que uma entidade exerce sobre outra.
22
Todas as tabelas criadas não aceitam valores nulos, ou seja, precisam receber dados de
acordo com o tipo aceito pelo campo. Estas características de cada campo são definidas no
momento da criação da tabela.
Para toda venda efetuada com sucesso, será disparada uma trigger que atualiza o
campo quantidade_produto da tabela produto, pois é necessário que a quantidade vendida seja
subtraída na quantidade do produto que existe em estoque. Assim a lista de produtos exibida
na tela do protótipo vai está sempre atualizada.
3.7 Detalhes do desenvolvimento do Projeto
A ferramenta de desenvolvimento utilizada foi o NetBeans. Após a seleção de criação
de um novo projeto, o programa mostra as opções para a escolha do tipo do projeto. A
categoria utilizada foi a Java ME. Na tela seguinte o programador pode decidir sobre qual será
o nome da aplicação e onde ela será armazenada no computador.
23
Após definido o nome e o local, o próximo passo é selecionar a plataforma do
emulador, que é o WirelessToolkit 2.5.2 for CLDC (já instalado anteriormente), com as
configurações de dispositivos CLDC-1.1 e o Perfil de dispositivos MIDP-2.1.
Definido o tipo do projeto, o nome e as suas configurações, foi criado o projeto, este
necessita de uma MIDlet (estoque.java) que é uma classe Java. Esta MIDlet necessita
importar
uma
biblioteca
específica
para
aplicações
em
J2ME
(import
javax.microedition.midlet.MIDlet). Também foram criadas duas classes Java comuns que
implementam a interface Runnable com todos os seus métodos. O Runnable é uma interface
que tem alguns métodos que precisam estar inicializados.
Na classe MIDlet são inseridos os elementos gráficos que irão aparecer no celular,
para isso é preciso importar a biblioteca (import javax.microedition.lcdui.*), onde o pacote
lcdui* irá disponibilizar todos os seus métodos, e através dele podemos criar e manipular
componentes e formulários.
Após a importação das bibliotecas, já é possível iniciar a criação dos objetos, com
destaque para o objeto display que vai herdar todas as características da classe Display
(private Display display;). Essa classe é responsável pela manipulação da tela do celular,
identificando suas características, como: a cor da tela, se ela é colorida ou não, a capacidade
de memória, entre outras características. Sendo assim este objeto irá adequar a aplicação às
características do celular.
Também são utilizados outros objetos, como: Form, Command, TextField, os
componentes List e Vector.
A tela inicial recebe uma lista onde são exibidos todos os produtos cadastrados no
banco de dados, e também exibe o menu de comandos (command). Para que o command
execute a ação desejada, é preciso implementar o CommandListener com seu método
commandAction. Este método fornece todas as opções para os comandos, de forma que a cada
comando solicitado ele execute sua ação. A Figura 4 apresenta o código do método
commandAction.
24
Figura 4 –Trecho da programação utilizando o commandAction
Quando o comando command cm_sair é selecionado executa o método de fechar a
aplicação, assim como o command cm_voltar retorna a aplicação para a tela inicial,
independente do formulário que esteja sendo utilizado no momento. O command cm_vender
executa a ação de chamar o formulário de Vendas.
Como não existe banco de dados para dispositivos móveis, é necessária a criação de
outro projeto destinado a aplicações Web. A criação deste novo projeto é semelhante à criação
do projeto móvel. A diferença está no tipo de projeto, que é o JEE para aplicativos
corporativos, em seguida são definidos o nome (EstoqueWEB) o local a ser salvo (de
preferência o mesmo local onde foi armazenado o projeto móvel). Após isso, o programador
define qual será o servidor Web a ser utilizado e as suas configurações. O servidor utilizado é
o GlassFish, configurado de acordo com a versão JEE5, com o módulo de aplicativo Web,
nomeado de EstoqueWEB-war. Neste módulo se encontram as páginas JSP, as bibliotecas e
os pacotes de código fonte, entre outros componentes.
O projeto Web é o responsável pela comunicação entre o celular e o banco de dados.
Para isso foi criado três páginas JSPs que fazem a função de comunicação entre a aplicação e
o banco.
25
A página JSP responsável pela pesquisa dos produtos cadastrados na tabela (produto) é
a lista_produto.jsp Para efetuar esta comunicação, a página precisa importar a biblioteca
<%@page import = "java.sql.*" %>. Esta biblioteca importa os itens necessários para a
conexão com o banco de dados. Após importar as bibliotecas são criadas algumas variáveis
que serão responsáveis para fazer a conexão e busca dos dados no banco de dados, entre essas
variáveis estão a variável driver, que armazena o driver de conexão com o banco, a variável
conexão que armazena as configurações da conexão com o banco, a variável url que recebe as
informações via localhost, a variável usuário que vai receber o nome do usuário do banco, a
variável senha que recebe a senha do banco, a variável Connection responsável pela conexão,
o Statement responsável por indicar o caminho e o ResultSet que armazena os dados no banco.
A Figura 5 apresenta o código de criação das variáveis responsáveis pela busca dos dados no
banco.
Figura 5 – Variáveis de busca e busca com o banco de dados.
Logo em seguida, a classe forName irá carregar o driver (org.postgresql.Driver), que é
o responsável por fazer a conexão com o banco. O DriverManager irá gerenciar a conexão
com a url, com usuário e senha, e o ResultSet está armazenando os dados do banco que estão
sendo mostrados pelo Statement que indica o caminho, neste caso o caminho é toda a tabela
de produtos. A Figura 6 apresenta o código da tentativa de conexão da página
lista_produtos.jsp com a tabela produto do banco de dados Em seguida o código que mostra a
tentativa de conexão com a tabela produto:
26
Figura 6 – Código de conexão entre o banco e a página JSP
Para que sejam exibidos na tela do celular todos os produtos de modo organizado (em
ordem), foi criada uma estrutura de repetição que irá fazer a verificação de todos os registros.
Assim, a cada campo que ele for buscando, estará exibindo na página os campos separados
pelo caractere (,) e após a busca de um produto do banco, o caracter (#) é inserido, estes
caracteres são necessários para uma organização dos campos na tela do celular. A Figura 7
apresenta o código utilizado para exibir na página os campos separados pelos caracteres
citados.
Figura7 – Código de separação dos campos
Desse modo a página lista_produto.jsp está conectando com o banco de dados,
buscando e armazenando nele os campos da tabela produto e estes separados pelos caracteres ,
e #.
Após o ciclo de repetições, é necessário mostrar na página um caracter diferente para
auxiliar na manipulação dos dados (out.println("^");).
27
Com a página JSP conectando com o banco e buscando os valores dos campos
cadastrados na tabela produtos, é preciso conectar a aplicação do celular com a página JSP.
Utilizamos a classe Java acessoWEB.java. Esta classe importa as bibliotecas import java.io.*
que possibilitam manipular dados de entrada e saída, a biblioteca
import java.util.Vector
necessária
a
para
trazer
os
dados
através
de
vetores
e
biblioteca
import
javax.microedition.io.HttpConnection, que possibilita acesso a uma conexão no servidor.
Após importar as bibliotecas, é criado o objeto HttpConnection para conexão, uma variável
que vai receber a url da página lista_produto.jsp, o objeto InputStream que será objeto
responsável por buscar os dados e exibir na tela. Como essa classe vai trabalhar diretamente
com a MIDlet estoque.java, criamos um objeto especifico para a classe estoque e uma variável
que recebe a url. Quando a classe acessoWEB.java for executada ela recebe o parâmetro
vindo da MIDlet estoque.java. A Figura 8 apresenta o código de criação dos objetos contidos
na classe acessoWEB.java responsáveis pela conexão e busca dos dados armazenados na
página JSP e o método de ligação entre a MIDlet e a classe, para que estas estejam
trabalhando ligadas diretamente.
Figura 8 – Código de ligação da MIDlet estoque.java com a classe acessoWEB.java
Assim o objeto estoque (obj_estoque) receberá o obj_estoque referente à MIDlet
estoque.java (estoque obj_estoque) passado por parâmetro. Está ligação é necessária para a
manipulação dos dados através da MIDlet.
Para buscar os dados da página JSP, para que eles sejam manipulados e mostrados na
MIDlet, foram criados alguns métodos, um método (public void lerVenda()), Este método fica
responsável por ler a página lista_produto.jsp através da variável url. Também foi criado o
método (public void inicia_thread()), este fica responsável por iniciar todo o processo do
28
método de execução (public void run()). A Figura 9 apresenta o código do método
responsável por ler a página JSP e o método responsável pela inicialização:
Figura 9 – Métodos public void lerVenda() e public void inicia_thread()
Depois de realizado todo esse processo os valores da tabela produto já estarão sendo
exibidos na tela do celular, mas eles não estão ordenados. Por isso, foi preciso manipular
esses dados (código, descrição, valor e quantidade) para que eles fiquem organizados de
maneira que o usuário entenda. Assim foi preciso criar uma variável do tipo vetor que
receberá todos os dados e mostrará na tela. O objeto conexão (obj_conexao_http) buscará a
página JSP com todos os caracteres, após isso uma condição faz a verificação do objeto, se o
objeto conseguir buscar a página, o inputStream (obj_inputstream) vai receber a conexão e
armazenar todos os dados byte a byte da página JSP. Em seguida foi criada uma variável
(caracter_lido) que irá receber a leitura do obj_inptstream e um ciclo de repetições,
verificando byte a byte os valores da variável caracter_lido até encontrar o caracter final (^) e
uma variável (stringbuffer) do tipo StringBuffer que é responsável por juntar esses bytes
separados pelos caracteres específicos para forma um valor. Neste primeiro ciclo, é criado um
vetor (dados = new String[4];) com 4 posições do tipo string, este será responsável por fechar
4 ciclos seguinte. Os três primeiros ciclos são responsáveis por verificar byte a byte do
caracter_lido até encontrar o caracter especifico (,) para seu fechamento. O quarto ciclo
verifica todos os caracteres até encontrar o caracter especifico (#), que indica que um
elemento da tabela produto foi separado dos demais. Antes que cada ciclo termine os
caracteres são reunidos pelo StringBuffer formando um elemento e este é adicionado no vetor
de dados (vetor_dados.addElement(dados);). Após o término dos quatro ciclos, volta para o
primeiro ciclo e a ordenação dos elementos da tabela produto vão sendo separados. Toda essa
29
verificação é feita até que o ciclo principal identifique o último caracter (^). A Figura 9
apresenta o código do ciclo principal que vai ler todos os dados byte a byte até encontrar o
caracter (^) e o primeiro ciclo (referente ao código do produto) dos quatros ciclos
responsáveis para separar os valores dos campos da tabela produto.
Figura 10 – Trecho da programação utilizando uma Estrutura de repetição
Feito todos os ciclos até ter encontrado o último caracter (^), voltamos a MIDlet
estoque.java e criamos outro método (recebedados_produto(Vector vetor_dados)), que está
recebendo por parâmetros o vetor_dados da classe acessoWEB.java onde contem todos os
elementos dos ciclos feito anteriormente. Este método esta inserindo o vetor_dados na MIDlet
e buscando seu tamanho para uma sequência de repetições até o tamanho total do vetor.
Dentro dessa repetição, foi criado um vetor do tipo String (dados), que estará recebendo de
um a um os elementos do vetor_dados e a tela inicial que é uma lista, estará mostrando cada
elemento inserido no do vetor dados de acordo com a sua posição e separados por um caracter
especifico (-). Mas para a visualização dos produtos com seus campos na tela, é preciso que
na classe acessoWEB.java, seja referenciado o método recebedados_produto, logo após o
fechamento do ciclo principal, passando como parâmetro o vetor_dados. Assim serão
mostrados na tela do celular todos os valores dos campos da tabela produto ordenados em
código_produto, descrição_produto, valor_produto e quantidade_produto. A Figura 10
apresenta o código de criação do método recebedados_produto na MIDlet.
30
Figura 11 – Método recebedados_produto
Desta forma está concluída a primeira parte, onde todos os produtos com os seus campos
estão sendo mostrados na tela inicial do protótipo.
Para efetuar uma venda, quando o usuário acessar o comando cm_vender, este executa
a ação de direcionar para o formulário de venda. A Figura 11 apresenta o código de inserção
dos objetos TextField e Command, que são utilizado no formulário de vendas.
Figura 12 – Objetos do formulário de Vendas
Após o preenchimento dos campos, é necessário que estes sejam gravados na tabela
vendas. Para esse comando (cm_gravar) gravar os valores no banco, foi preciso criar um
objeto na MIDlet do tipo acessoWEB, referente a classe acessoWEB.java. Este objeto faz com
que a MIDlet trabalhe diretamente com a classe, assim ele recebe os valores inseridos em cada
TextField do formulário de venda e através desse método a classe acessoWEB recebe por
parâmetros os valores enviado pelos obj_acessoWEB. A Figura 12 apresenta o código do
commandcm_gravar, que envia os valores recebido pelo TextField para classe
acessoWEB.java.
31
Figura 13 – Command cm_gravar.
Na classe acessoWEB.java tem um método inserirVenda, responsável por enviar os
dados recebido por parâmetros dos TextField da MIDlet para a página vender_produto.jsp,
através da variável url que envia esses dados para a tabela de vendas do banco de dados. A
Figura 13 apresenta o código do método inserirVenda.
Figura 14 – Método inserirVenda
A página vender_produto.jsp, possui a ligação com o banco do mesmo modo feito
com a lista_produtos.jsp, porem a variável Stringsql responsável pelo código SQL, vai
receber o comando INSERT passando como parâmetro os valores recebidos por parâmetro no
método inserirVenda, mas para isso precisa a MIDlet se comunicar com a página. Esta
comunicação foi feita do mesmo modo em que a lista_produto.jsp e com a MIDlet, utilizando
o obj_conexao_http e obj_inputstream. A Figura 14 apresenta o código da variável sql
inserindo por parâmetro os valores recebido da MIDlet.
32
Figura 15 – Código SQL de inserção.
Com a venda sendo concluída e gravada no banco, foi criado um comando
(cm_visualizar) na MIDlet para listar as vendas efetuadas, este comando segue o mesmo
raciocínio feito para lista os produtos na tela inicial do protótipo, porem ele utiliza uma classe
chamada acesso.java no lugar da classe acessoWEB.java.
Foi criado um comando (cm_ajuda) para auxiliar o usuário no manuseio da aplicação.
Este comando quando solicitado abre uma tela que ajuda o usuário a manusear a aplicação de
maneira correta.
33
Capítulo IV
4. Utilização do Protótipo
Este capítulo apresenta como utilizar o protótipo, através das telas geradas pelo
emulador (Wireless ToolKit) da Sun, onde ao ser iniciado ele acessa a tabela de produtos,
através da ligação com o banco de dados e lista todos os produtos separados pelos seus
respectivos campos: código, descrição, valor e quantidade. A Figura 15 apresenta a tela inicial
do protótipo com os produtos da tabela produto listado.
Figura 16 – Tela de lista dos produtos.
34
A Figura 16 apresenta a tela do protótipo com as funcionalidades do menu, onde
mostra a opção de vender produtos listados na tela, visualizar as vendas realizadas e a opção
de ajuda.
Figura 17 – Funcionalidades do menu.
A Figura 17 apresenta a tela com o formulário de vendas, esta tela abre quando a
opção Vender Produto é escolhido, assim pode ser realizada uma venda preenchendo os
campos, código do produto referente ao produto visualizado na tela inicial, a quantidade de
produto a ser vendido, o código do vendedor que efetuará a venda, o CNPJ do cliente que vai
receber o produto e a data da venda para um controle das vendas efetuadas.
Figura 18 – Formulário de Vendas.
35
Após a venda efetuada, a tela inicial do protótipo é exibida com a quantidade de
produto vendido atualizando a quantidade de produto da tabela produto. A Figura 18
apresenta a tela com a quantidade de produto atualizado no estoque.
Figura 19 – Tela de lista de produtos atualizada após a venda.
A figura 19 apresenta a tela de visualização das vendas efetuadas, esta tela é mostrada
quando a opção Visualizar Vendas é acessada no menu do protótipo. Assim todas as vendas
registradas na tabela vendas do banco são listadas na tela.
Figura 20 – Tela de visualização das vendas efetuadas.
36
A Figura 20 apresenta o formulário de ajuda, este é exibido quando a opção Ajuda no
menu é acessada. Esta opção mostra um texto ensinando como utilizar o protótipo, assim o
usuário em caso de dúvida pode está recorrendo a este formulário para uma solução.
Figura 21 – Tela de ajuda.
37
Capítulo V
5. Conclusão
Os serviços de telefonia móvel vêm crescendo e se expandindo em todos os setores da
sociedade, com o surgimento cada vez maior de novos serviços para estes dispositivos.
A ideia desse projeto foi desenvolver uma aplicação, que facilite o acesso a
informações importantes contidas em uma base de dados, através de um aparelho celular,
tendo em vista que não há a necessidade de recorrer frequentemente à empresa para verificar
informações de determinado produto.
O desenvolvimento deste projeto proporcionou o ganho de novos conhecimentos, além
de aprimorar os já adquiridos no que diz respeito à plataforma J2ME, ferramenta de
desenvolvimento NetBeans e o aprimoramento em banco de dados, servidor de aplicação e
orientação a objetos.
Entre as dificuldades encontradas, destaca-se o pouco conhecimento na linguagem
J2ME. Já conhecíamos a linguagem Java nas edições J2SE e J2EE, mas não possuíamos
conhecimento algum em J2ME. Foi necessário muito empenho e tempo gasto com o estudo,
análise e testes desta linguagem.
Para finalizar, dentro do que foi exposto acima, verificamos que muitos profissionais
do setor de vendas necessitam efetuar vendas com base em dados de produtos catalogados em
várias pastas de trabalho. A partir disso, sugerimos a implantação deste protótipo, para maior
qualidade no atendimento ao cliente e apoio ao profissional de vendas.
5.1 Trabalhos Futuros
Após a conclusão do desenvolvimento deste projeto, foi verificado que o protótipo pode
ser aprimorado com a implementação de novas funcionalidades, como o armazenamento
temporário de dados em casos de perda de sinal. Neste caso os dados poderiam ser
armazenados temporariamente e após restabelecer o sinal, estes acessariam o banco e
registrariam a venda e a funcionalidade de efetuar a venda de mais de um produto em uma
mesma venda.
38
REFERÊNCIA BIBLIOGRÁFICA
ALECRIM, E. Máquina Virtual Java (Java Virtual Machine). 2005. Disponível
em:<http://www.infowester.com/jvm.php>. Acesso em 12 de março. 2011.
ANATEL. Brasil fecha maio com mais de 215 milhões de acessos móveis. 2011. Disponível
em:
<http://www.anatel.gov.br/Portal/exibirPortalNoticias.do?acao=carregaNoticia&codigo=2291
7>. Acesso em 18 de junho. 2011.
BOGO, K. C. A História da Internet: Como Tudo Começou... 2000. Disponível em:
<http://kplus.cosmo.com.br/materia.asp?co=11&rv=Vivencia >. Acesso em: 09 de março.
2011.
CORBERA, R. P. O que é J2ME. 2003. Disponível em:
<http://www.inforede.net/Technical/Layer_1/Wireless_Mobile/Tutorial%20J2ME%20Parte%
201.pdf>. Acesso em 03 de março. 2011.
COUTINHO, N., & BIAZUS, D. Introdução e Histórico. 2009. Disponível em:
<http://wiki.postgresql.org/wiki/Introdu%C3%A7%C3%A3o_e_Hist%C3%B3rico>. Acesso
em 28 de abril. 2011.
Developer, N. Desenvolvendo aplicações em Java ME usando NetBeans IDE.2011.
Disponível
em:<http://www.developer.nokia.com/Community/Wiki/Desenvolvendo_aplica%C3%A7%C
3%B5es_em_Java_ME_usando_Netbeans_IDE>. Acesso em 07 de julho. 2011.
EQUIPE DEVMEDIA. Iniciando o desenvolvimento de aplicações J2ME – Parte 1. 2011.
Disponível em:<http://www.devmedia.com.br/post-8351-Iniciando-o-desenvolvimento-deaplicacoes-J2ME-Parte-01.html>. Acesso em 12 de março. 2011.
GARTNER. Gartner diz que vendas mundiais de smartphones cresceram 72% em 2010.
2011. Disponível em: <http://targethd.net/2011/02/17/gartner-diz-que-vendas-mundiais-desmartphones-cresceram-72-em-2010/>. Acesso em 28 de junho. 2011.
39
GUENZBURGER, R. GSM, a melhor tecnologia sem clonagem. 2011. Disponível
em:<http://info.abril.com.br/infosmb/edicoes/001/arquivos/5625_1.shtml>.Acesso em 28
maio. 2011.
KNUDSEN, J., & LI, S. Beginning J2ME. New York: Spring-Verlag New York Inc.2005.
Kozovits, L. E. Um panorama do Mercado de Jogos e Mobile Entertainment. Rio de Janeiro.
RJ, Brasil. 2009.
MUCHOW, J. W. Core J2ME Technology & MIDP.Palo Alto: Prentice Hall. 2001.
ORACLE. Saiba mais sobre a tecnologia Java. 2011.Disponível em: <http://www.java.com
/pt_BR/about/>. Acesso em 24 de maio. 2011.
PEREIRA, P. B. Entendendo arquitetura JME: CDC, CLDC, MIDP 1.0, MIDP 2.0 2 MIDP
2.1. 2008. Disponível em: <http://devmobile.blog.br/2008/07/24/componentes-da-arquiteturajme/>. Acesso em 12 de março. 2011.
REDAÇÃO OFICINA DA NET. O que é NetBeans. 2011.Disponível em:
<http://www.oficinadanet.com.br/artigo/1061/o_que_e_o_netbeans>.Acesso em 11 de março.
2011.
SCHMITT JR., A. J. 2004. Protótipo de front end de controle de acesso usando J2ME.
Trabalho de Conclusão de Curso (Bacharelado em Ciência da Computação) . Blumenau:
Centro de Ciências Exatas e Naturais, Universidade Regional de Blumenau.
SILVEIRA, I. F. Linguagem Java.2011.Disponível em:
<http://www.infowester.com/lingjava.php>. Acesso em 12 de março. 2011.
SOUZA, V. E. Novidades no GrassFish 3.1.2011.Disponível em:
<http://www.devmedia.com.br/post-21124-Novidades-do-GlassFish-3-1.html>. Acesso em 29
de maio. 2011.
WIKIDOT.COM. GlassFish. 2009.Disponível em:
<http://pesquompile.wikidot.com/glassfish>.Acesso em 12 de março.2011.
40
ANEXO
41
Código de programação.
MIDlet – estoque.java
import java.util.Vector;
import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
public class estoque extends MIDlet implements CommandListener {
private Vector vetor_dados, vetor_dados2;
private Display display;
private acessoWEB obj_acessoWEB;
private acesso obj_acesso;
private List lista, lista2;
private Form frm_vender, frm_ajuda;
private Command cm_sair, cm_vender, cm_gravar, cm_voltar, cm_ajuda, cm_visualizar;
private TextField tf_ajuda, tf_codigo_produto1, tf_data, tf_quantidade_produto_venda,
tf_codigo_vendedor, tf_cnpj;
public void startApp() {
display = Display.getDisplay(this);
lista = new List("Lista de Produtos", List.EXCLUSIVE);
lista2 = new List("Lista de Vendas", List.EXCLUSIVE);
obj_acessoWEB = new acessoWEB(this);
obj_acesso = new acesso(this);
frm_vender = new Form("Venda : ");
frm_ajuda = new Form("Ajuda : ");
cm_sair = new Command("Sair", Command.EXIT, 1);
cm_vender = new Command("Vender Produto", Command.SCREEN, 1);
cm_visualizar = new Command("Visualizar Vendas", Command.SCREEN, 2);
cm_ajuda = new Command("Ajuda", Command.SCREEN, 3);
cm_voltar = new Command("Voltar", Command.EXIT, 1);
cm_gravar = new Command("Gravar", Command.EXIT, 1);
tf_codigo_produto1 = new TextField("Código do Produto :", "", 5, TextField.NUMERIC);
tf_quantidade_produto_venda = new TextField("Quantidade de Produto :", "", 6,
TextField.NUMERIC);
tf_codigo_vendedor
=
new
TextField("Código
Vendedor
:",
"",
5,
TextField.NUMERIC);
tf_cnpj = new TextField("CNPJ do Cliente ( 00000000/0000-00 ) :", "", 16,
TextField.ANY);
tf_data = new TextField("Data da Venda ( yyyy / mm / dd ) :", "", 10, TextField.ANY);
tf_ajuda = new TextField("Ajuda !","Bem Vindo ao Estoque móvel. Aqui você aprende
como "
+ "utilizar essa ferramenta. Na tela inicial ao se entrar no programa, aparecerá "
+ "listado todos os produtos com: código, descrição, valor e quantidade. Estes "
+ "estarão separados por um hífen. Na parte inferior do lado direito, aparecerá "
+ "um menu, onde terá as opções: vender produto, visualizar venda e ajuda. Na "
+ "opção Vender Produto, aparecerá uma nova tela, onde você terá que colocar o "
+ "código do produto que será vendido, código este que foi listado na tela inicial,"
+ " a quantidade de produto que o cliente deseja comprar, o CNPJ do cliente "
+ "respeitando o modelo mostrado e a data que também tem que ser respeitado o
modelo."
42
+ " Após ter preenchido tudo corretamente vá à opção gravar e a venda será
gravada. "
+ "Para ter certeza que a venda foi efetuada, feche a aplicação e entre novamente, "
+ "agora acesse a opção Visualizar Venda e aparecerão todas as vendas realizadas, "
+ "listadas na ordem da data, se aparecer a sua venda, isso significa que esta foi "
+ "realizada com sucesso, senão faça o processo de efetuar venda novamente. Agora
"
+ "você já sabe como utilizar está ferramenta. Boa sorte." , 1121, TextField.ANY);
lista.addCommand(cm_sair);
lista.addCommand(cm_vender);
lista.addCommand(cm_visualizar);
lista.addCommand(cm_ajuda);
lista2.addCommand(cm_voltar);
frm_vender.append(tf_codigo_produto1);
frm_vender.append(tf_quantidade_produto_venda);
frm_vender.append(tf_codigo_vendedor);
frm_vender.append(tf_cnpj);
frm_vender.append(tf_data);
frm_vender.addCommand(cm_voltar);
frm_vender.addCommand(cm_gravar);
frm_ajuda.addCommand(cm_voltar);
frm_ajuda.append(tf_ajuda);
lista.setCommandListener(this);
lista2.setCommandListener(this);
frm_vender.setCommandListener(this);
frm_ajuda.setCommandListener(this);
display.setCurrent(lista);
obj_acessoWEB.lerVenda();
obj_acesso.inicia_thread();
}
public void pauseApp()
{
}
public void destroyApp(boolean unconditional)
{
}
public void commandAction(Command c, Displayable d)
{
if (c == cm_sair)
{
destroyApp(true);
notifyDestroyed();
}
else if (c == cm_voltar)
{
display.setCurrent(lista);
}
else if (c == cm_vender)
{
display.setCurrent(frm_vender);
43
}
else if (c == cm_gravar)//os parametros nao sao todos string a quntidade é inteira e o
valor real
{
obj_acessoWEB.inserirVenda(tf_codigo_produto1.getString(),
tf_quantidade_produto_venda.getString(),
tf_codigo_vendedor.getString(),
tf_cnpj.getString(), tf_data.getString());
display.setCurrent(lista);
}
else if ( c == cm_visualizar)
{
display.setCurrent(lista2);
}
else if (c == cm_ajuda)
{
display.setCurrent(frm_ajuda);
}
}
public void recebedados_produto(Vector vetor_dados)
{
this.vetor_dados = vetor_dados;
int tamanho = vetor_dados.size();
for (int i=0; i < tamanho; i++)
{
String [] dados = (String[]) vetor_dados.elementAt(i);
lista.append(dados[0] + " - " + dados[1] + " - " + dados[2] + " - "+ dados[3], null);
}
}
public void recebedados_vendas(Vector vetor_dados2)
{
this.vetor_dados2 = vetor_dados2;
int tamanho2 = vetor_dados2.size();
for (int j=0; j < tamanho2; j++)
{
String [] dados2 = (String[]) vetor_dados2.elementAt(j);
lista2.append(dados2[0] + " - " + dados2[1] + " - " + dados2[2] + " - "+ dados2[3]+ " "+ dados2[4] + " - " + dados2[5], null);
}
}
}
MIDlet – acessoWEB.java
import javax.microedition.midlet.*;
import java.io.*;
import java.util.Vector;
import javax.microedition.io.Connector;
import javax.microedition.io.HttpConnection;
public class acessoWEB implements Runnable
{
private Vector vetor_dados;
44
private HttpConnection obj_conexao_http;
private String url;
private InputStream obj_inputstream;
private estoque obj_estoque;
private Thread thread;
private String acao="lerVenda";
public acessoWEB(estoque obj_estoque)
{
this.obj_estoque = obj_estoque;
}
public void lerVenda()
{
acao="lerVenda";
url = "http://localhost:8080/EstoqueWEB-war/lista_produto.jsp";
inicia_thread();
}
public void inserirVenda(String codigo_produto, String quantidade_produto_venda, String
codigo_vendedor, String cnpj, String data)
{
acao="insereVenda";
url="http://localhost:8080/EstoqueWEBwar/vender_produto.jsp?codigo_produto="+codigo_produto+"&quantidade="+quantidade_pr
oduto_venda+"&codigo_vendedor="+codigo_vendedor+"&cnpj="+cnpj+"&data="+data;
inicia_thread();
}
public void run() {
try
{
if (acao.equals("lerVenda"))
{
vetor_dados = new Vector();//irá armazenar os dados para jogar na tela do celular
String [] dados;
obj_conexao_http = (HttpConnection) Connector.open(url);
if (obj_conexao_http.getResponseCode() == HttpConnection.HTTP_OK)
{
obj_inputstream = obj_conexao_http.openInputStream();
int i = 1, caracter_lido = obj_inputstream.read();
StringBuffer stringbuffer = new StringBuffer();
while(caracter_lido != '^')
{
dados = new String[4];
while(caracter_lido != ',')
{
stringbuffer.append((char) caracter_lido);
caracter_lido = obj_inputstream.read();
}
System.out.println("Código do Produto = " + stringbuffer.toString().trim());
dados[0] = stringbuffer.toString().trim();
stringbuffer.delete(0, stringbuffer.length());
caracter_lido = obj_inputstream.read();
45
while(caracter_lido != ',')
{
stringbuffer.append((char) caracter_lido);
caracter_lido = obj_inputstream.read();
}
System.out.println("Descrição do Produto = " + stringbuffer.toString().trim());
dados[1] = stringbuffer.toString().trim();
stringbuffer.delete(0, stringbuffer.length());
caracter_lido = obj_inputstream.read();
while(caracter_lido != ',')
{
stringbuffer.append((char) caracter_lido);
caracter_lido = obj_inputstream.read();
}
System.out.println("Valor do Produto = " + stringbuffer.toString().trim());
dados[2] = stringbuffer.toString().trim();
stringbuffer.delete(0, stringbuffer.length());
caracter_lido = obj_inputstream.read();
while(caracter_lido != '#')
{
stringbuffer.append((char) caracter_lido);
caracter_lido = obj_inputstream.read();
}
System.out.println("Quantidade
do
Produto
=
"
+
stringbuffer.toString().trim());
dados[3] = stringbuffer.toString().trim();
stringbuffer.delete(0, stringbuffer.length());
caracter_lido = obj_inputstream.read();
vetor_dados.addElement(dados);
}
obj_estoque.recebedados_produto(vetor_dados);
}
}
else if (acao.equals("insereVenda"))
{
obj_conexao_http = (HttpConnection) Connector.open(url);
if (obj_conexao_http.getResponseCode() == HttpConnection.HTTP_OK)
{
obj_inputstream = obj_conexao_http.openInputStream();
}
}
}
catch(IOException io)
{
System.out.println(" Erro de IOException = " +io);
}
catch(SecurityException se)
{
System.out.println(" Erro de SecurityException = " +se);
}
46
}
public void inicia_thread()
{
thread = new Thread(this);
thread.start();
}
MIDlet – acesso.java
import javax.microedition.midlet.*;
import java.io.*;
import java.util.Vector;
import javax.microedition.io.Connector;
import javax.microedition.io.HttpConnection;
public class acesso implements Runnable
{
private Vector vetor_dados2;
private HttpConnection obj_conexao_http2;
private String url;
private InputStream obj_inputstream2;
private estoque obj_estoque2;
private Thread thread2;
private String acao2="verVenda";
public acesso(estoque obj_estoque2)
{
this.obj_estoque2 = obj_estoque2;
}
public void run() {
url = "http://localhost:8080/EstoqueWEB-war/visualizar_vendas.jsp";
try
{
vetor_dados2 = new Vector();
String [] dados2 = new String[6];
obj_conexao_http2 = (HttpConnection) Connector.open(url);
if (obj_conexao_http2.getResponseCode() == HttpConnection.HTTP_OK)
{
obj_inputstream2 = obj_conexao_http2.openInputStream();
int caracter_lido2 = obj_inputstream2.read();
StringBuffer stringbuffer2 = new StringBuffer();
while(caracter_lido2 != '^')
{
dados2 = new String[6];
//lendo o código de venda
while(caracter_lido2 != ',')
{
stringbuffer2.append((char) caracter_lido2);
caracter_lido2 = obj_inputstream2.read();
}
dados2[0] = stringbuffer2.toString().trim();
stringbuffer2.delete(0, stringbuffer2.length());
47
caracter_lido2 = obj_inputstream2.read();
while(caracter_lido2 != ',')
{
stringbuffer2.append((char) caracter_lido2);
caracter_lido2 = obj_inputstream2.read();
}
dados2[1] = stringbuffer2.toString().trim();
stringbuffer2.delete(0, stringbuffer2.length());
caracter_lido2 = obj_inputstream2.read();
while(caracter_lido2 != ',')
{
stringbuffer2.append((char) caracter_lido2);
caracter_lido2 = obj_inputstream2.read();
}
dados2[2] = stringbuffer2.toString().trim();
stringbuffer2.delete(0, stringbuffer2.length());
caracter_lido2 = obj_inputstream2.read();
while(caracter_lido2 != ',')
{
stringbuffer2.append((char) caracter_lido2);
caracter_lido2 = obj_inputstream2.read();
}
dados2[3] = stringbuffer2.toString().trim();
stringbuffer2.delete(0, stringbuffer2.length());
caracter_lido2 = obj_inputstream2.read();
while(caracter_lido2 != ',')
{
stringbuffer2.append((char) caracter_lido2);
caracter_lido2 = obj_inputstream2.read();
}
dados2[4] = stringbuffer2.toString().trim();
stringbuffer2.delete(0, stringbuffer2.length());
caracter_lido2 = obj_inputstream2.read();
while(caracter_lido2 != '#')
{
stringbuffer2.append((char) caracter_lido2);
caracter_lido2 = obj_inputstream2.read();
}
dados2[5] = stringbuffer2.toString().trim();
stringbuffer2.delete(0, stringbuffer2.length());
caracter_lido2 = obj_inputstream2.read();
vetor_dados2.addElement(dados2);
}
obj_estoque2.recebedados_vendas(vetor_dados2);
}
}
catch(IOException io)
{
System.out.println(" Erro de IOException = " +io);
}
48
catch(SecurityException se)
{
System.out.println(" Erro de SecurityException = " +se);
}
}
public void inicia_thread()
{
thread2 = new Thread(this);
thread2.start();
}
}
Página JSP – vender_produto.jsp
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<%@page import = "java.sql.*" %><%-- importa tudo do java que é necessário para se
conectar com o banco de dados--%>
<%
String driver = "org.postgresql.Driver";
String url = "jdbc:postgresql://localhost:5432/postgres";
String usuario = "postgres";
String senha = "123";
Connection conexao;
Statement statement;
ResultSet resultset;
try //tentar fazer a conxão
{
Class.forName(driver);
conexao = DriverManager.getConnection(url, usuario, senha);
System.out.println( "Conexão estabelecida com sucesso ");
statement = conexao.createStatement();
String sql = "insert into vendas(codigo_produto, quantidade_produto_venda,
codigo_vendedor, cnpj, data) values " +
"('"+request.getParameter("codigo_produto")+"','"+request.getParameter("quantidade")+"','"+
request.getParameter("codigo_vendedor")+"','"+request.getParameter("cnpj")+"','"+request.ge
tParameter("data")+"')";
int cadastrou = statement.executeUpdate(sql);
if (cadastrou == 1)
out.println("Cadastro feito com sucesso");
else
out.println("Não conseguiu cadastrar");
}
catch(Exception erro)
{
out.print("erro : "+erro);
}
%>
Página JSP – lista_produto.jsp
<%@page import="javax.swing.JOptionPane"%>
<%@page contentType="text/html" pageEncoding="UTF-8"%>
49
<%@page import = "java.sql.*" %><%-- importa tudo do java que é necessario para se
conectar com o banco de dados--%>
<%
String driver = "org.postgresql.Driver";
String url = "jdbc:postgresql://localhost:5432/postgres";
String usuario = "postgres";
String senha = "123";
Connection conexao;
Statement statement;
ResultSet resultset;
try //tentar fazer a conxão
{
Class.forName(driver);
conexao = DriverManager.getConnection(url, usuario, senha);
System.out.println( "Conexão estabelecida com sucesso ");
statement = conexao.createStatement();
resultset = statement.executeQuery("select * from produto order by
produto.codigo_produto");
while (resultset.next())
{
out.print(resultset.getInt(1));
out.print(","+resultset.getString(2));
out.print(","+resultset.getFloat(3));
out.print(","+resultset.getInt(4)+"#");
}
}
catch(ClassNotFoundException Driver)
{
out.print("driver não localizado : "+Driver);
}
catch(SQLException Fonte)
{
out.print("deu erro na conexão " + "com a fonte de dados: "+ Fonte);
}
out.println("^");
%>
Página JSP – visualizar_vendas.jsp
<%@page import="javax.swing.JOptionPane"%>
<%@page contentType="text/html" pageEncoding="UTF-8"%>
<%@page import = "java.sql.*" %><%-- importa tudo do java que é necessário para se
conectar com o banco de dados--%>
<%
String driver = "org.postgresql.Driver";
String url = "jdbc:postgresql://localhost:5432/postgres";
String usuario = "postgres";
String senha = "123";
Connection conexao;
Statement statement;
ResultSet resultset;
50
try //tentar fazer a conxão
{
Class.forName(driver);
conexao = DriverManager.getConnection(url, usuario, senha);
System.out.println( "Conexão estabelecida com sucesso ");
statement = conexao.createStatement();
resultset = statement.executeQuery("select * from vendas order by vendas.data");
while (resultset.next())
{
out.print(resultset.getInt(1));
out.print(","+resultset.getInt(2));
out.print(","+resultset.getInt(3));
out.print(","+resultset.getInt(4));
out.print(","+resultset.getString(5));
out.print(","+resultset.getString(6)+"#");
}
}
catch(ClassNotFoundException Driver)
{
out.print("driver não localizado : "+Driver);
}
catch(SQLException Fonte)
{
out.print("deu erro na conexão " + "com a fonte de dados: "+ Fonte);
}
out.println("^");
%>