Visualizar - Polis Educacional

Transcrição

TIAGO JOSÉ GRILLO
0300744
AVALIAÇÃO COMPARATIVA DE PLATAFORMAS DE DESENVOLVIMENTO DE
APLICAÇÕES WEB.
Jaguariúna
2008
TIAGO JOSÉ GRILLO
0300744
AVALIAÇÃO COMPARATIVA DE PLATAFORMAS DE DESENVOLVIMENTO DE
APLICAÇÕES WEB.
Relatório parcial apresentado à disciplina
Trabalho de Graduação III, do curso de Ciência
da Computação da Faculdade de Jaguariúna,
sob orientação do Prof. Ms. Peter Jandl Junior,
como exigência parcial para conclusão do curso
de graduação.
Jaguariúna
2008
ii
Folha de Aprovação
GRILLO, Tiago José. Avaliação comparativa de plataformas de desenvolvimento
de aplicações. 2008. Monografia defendida e aprovada na FAJ em quarta-feira, 10
de dezembro de 2008 pela banca examinadora constituída pelos professores.
_____________________________
Nome: Prof. Ms. Peter Jandl Jr.
_________________________
Nome: Prof. Ademário Araújo Jr.
_________________________
Nome: Prof. Ms. Fernando Augusto Zancheta
iii
A meus pais pela confiança e incentivo que
me motivaram a concluir mais esta etapa e a
todos que de alguma forma colaboraram para
a realização deste projeto.
iv
Agradecimentos
Primeiramente agradeço a Deus por me dar saúde e perseverança nas horas
difíceis.
Agradeço também a minha família e minha namorada pela compreensão e
apoio que deram, a todos os professores e amigos, pela orientação e apoio quando
solicitado. E em particular:
Ao Prof. Ms. Peter Jandl Jr., pela orientação e paciência infindáveis no
decorrer deste projeto.
Aos meus amigos André, Diego, Regis e Rodrigo pelo apoio direto e nas
discussões técnicas que, em muito, enriqueceram a realização desta pesquisa.
v
“A ciência de hoje é a tecnologia
de amanhã.”
(Teller, Edward)
vi
GRILLO, Tiago José. Avaliação comparativa de plataformas de desenvolvimento de
aplicações. 2008. Monografia (Bacharelado em Ciência da Computação) – Curso de
Ciência da Computação da Faculdade de Jaguariúna.
RESUMO
Esta monografia propõe um estudo comparativo entre três plataformas de
desenvolvimento focadas na internet. O critério utilizado na escolha destas foi uma
pesquisa em rankings. Buscando as dez mais utilizadas pelos profissionais no setor
de desenvolvimento de software no mundo. Após esta análise as plataformas
selecionadas, foram o C# da .Net Framework SDK, o PHP 5 e o Java mais
precisamente sua especificação Java EE (Java Enterprise Edition) da Sun
Microsystens. Com um protótipo simples, mas que contenha as principais
características de um Sistema web como, manipulação de dados (inserção,
alteração e consulta), gerenciamento de seção e navegabilidade, e de iguais
características, desenvolvido nas três plataformas, se pretende mostrar as
vantagens e desvantagens de cada uma delas, além de suas características e
peculiaridades e apontar qual a melhor solução a um determinado problema,
auxiliando os desenvolvedores na escolha da melhor plataforma, evitando
problemas e transtornos neste caminho tão diversificado que é hoje o
desenvolvimento de sistemas web.
Palavras-chave: internet, C#, .Net, PHP, Java, Java EE.
vii
SUMÁRIO
1. INTRODUÇÃO ................................................................................................................................................. 1
2. SISTEMAS WEB .............................................................................................................................................. 2
2.1 HISTÓRICO ..................................................................................................................................................... 2
2.2 ARQUITETURA E ORGANIZAÇÃO WEB ............................................................................................................ 2
2.3 PLATAFORMAS DE DESENVOLVIMENTO ......................................................................................................... 4
2.3.1 Java....................................................................................................................................................... 4
2.3.2 PHP....................................................................................................................................................... 4
2.3.3 C#.......................................................................................................................................................... 5
3. JAVA .................................................................................................................................................................. 6
3.1 HISTÓRICO ..................................................................................................................................................... 6
3.2 PRINCIPAIS CARACTERÍSTICAS ....................................................................................................................... 6
3.3 ESPECIFICAÇÕES DO JAVA ............................................................................................................................. 8
3.4 SERVLET CONTÊINER..................................................................................................................................... 8
3.5 SERVLET ........................................................................................................................................................ 9
3.6 JSP – JAVASERVER PAGES .......................................................................................................................... 11
3.7 JSTL – JAVASERVER PAGES TAG LIBRARY ................................................................................................. 13
3.8 BEANS ......................................................................................................................................................... 14
3.8 JSF – JAVASERVER FACES........................................................................................................................... 14
4. PHP................................................................................................................................................................... 16
4.1 HISTÓRICO ................................................................................................................................................... 16
4.2 PRINCIPAIS CARACTERÍSTICAS ..................................................................................................................... 16
4.3 ESPECIFICAÇÕES .......................................................................................................................................... 17
4.4 A LINGUAGEM PHP ..................................................................................................................................... 17
5. C# (C SHARP) ................................................................................................................................................. 19
5.1 HISTÓRICO ................................................................................................................................................... 19
5.2 A PLATAFORMA .NET .................................................................................................................................. 19
5.2.1 Common Language Runtime (CLR) .................................................................................................... 20
5.3 PRINCIPAIS CARACTERÍSTICAS DO C# .......................................................................................................... 20
5.5 A LINGUAGEM C# ........................................................................................................................................ 21
6. PROTOTIPO ................................................................................................................................................... 22
6.1 DESCRIÇÃO .................................................................................................................................................. 22
6.2 PROTÓTIPO EM JAVA.................................................................................................................................... 24
6.2.1 Tecnologias utilizadas ........................................................................................................................ 24
6.2.2 Processo de desenvolvimento.............................................................................................................. 25
6.3 PROTÓTIPO PHP .......................................................................................................................................... 27
6.4 PROTÓTIPO .NET .......................................................................................................................................... 31
7. ANÁLISE DOS RESULTADOS .................................................................................................................... 35
7.1 AVALIAÇÃO OBJETIVA ................................................................................................................................. 35
7.2 AVALIAÇÃO SUBJETIVA ............................................................................................................................... 37
7.3 DIFICULDADES ENCONTRADAS .................................................................................................................... 38
7.4 QUADRO COMPARATIVO ............................................................................................................................. 38
7.5 ANÁLISE ...................................................................................................................................................... 39
8. CONCLUSÕES ............................................................................................................................................... 40
9. REFERÊNCIAS BIBLIOGRÁFICAS........................................................................................................... 41
viii
LISTA DE SIGLAS
API
ARPANET
C#
CGI
CLR
COM
COM+
CORBA
EJB
FTP
GTK
HTML
HTTP
IMAP
IP
JAVAEE
JAXR
JIT
JMS
JSF
JSP
JSTI
JTA
JVM
LDAP
MSIL
NNTP
ODBC
PDF
PERL
PHP
POO
POP3
RPC
SDK
SNMP
TCP
UDP
XML
Application Programming Interface
Advanced Research Projects Agency Network
C Sharp
Common Gateway Interfaces
Common Language Runtime
Component Services Application
Component Services Application Plus
Common Object Request Broker Architecture
Enterprise JavaBeans Components
File Transfer Protocol
Graphical User Interface Toolkit
Hypertext Markup Language
Hypertext Transfer Protocol
Internet Message Access Protocol
Internet Protocol
Java Enterprise Edition
Java API for Xml Registries
Just In Time
Java Message Service
Java Server Faces
Java Server Page
Pages Standard Tag Library
Java Transaction API
Java Virtual Machine
Lightweight Directory Access Protocol
Microsoft Intermediate Language
Network News Transfor Protocol
Open Database Connection
Portable Document Format
Pratical Extraction And Report Language
PHP Hypertext Preprocessor
Programação Orientada A Objetos
Post Office Protocol
Remote Procedure Call
Software Development Kit
Simple Network Management Protocol
Transmission Control Protocol
User Datagram Protocol
Extensible Markup Language
ix
LISTA DE FIGURAS
FIGURA 1 – ARQUITETURA WEB ............................................................................................................................... 3
FIGURA 2 – REQUISIÇÃO E RESPOSTA ...................................................................................................................... 3
FIGURA 3 – AMBIENTE JAVA .................................................................................................................................... 7
FIGURA 4 – ESTRUTURA DE COMPILAÇÃO ................................................................................................................ 7
FIGURA 5 – REPRESENTAÇÃO APPLICATION SERVER ............................................................................................... 9
FIGURA 6 – IMPRIMIR RESPOSTA ............................................................................................................................ 11
FIGURA 7 – JSP TRADUZIDO PARA SERVLET .......................................................................................................... 12
FIGURA 8 – ESTRUTURA DE DESENVOLVIMENTO .................................................................................................... 15
FIGURA 9 – VISÃO GERAL TELA DE LANÇAMENTO ................................................................................................. 22
FIGURA 10 – DIAGRAMA DE CASO DE USO ........................................................................................................... 23
FIGURA 11 – LANCAPEDIDO.JSP ............................................................................................................................ 25
FIGURA 12 – TRECHO DO CÓDIGO QUE TRATA A EXIBIÇÃO DE MENSAGENS DE ERRO ............................................. 27
FIGURA 13 – OPÇÕES DE TELAS DISPONÍVEIS ...................................................................................................... 28
FIGURA 14 – CONFIGURAÇÃO MESTRE/DETALHE ................................................................................................ 29
FIGURA 15 – CONFIGURAÇÕES TELA DE LOG IN ................................................................................................... 30
FIGURA 16 – LOGIN.PHP ABERTO EM OUTRO EDITOR PARA VISUALIZAÇÃO E MANIPULAÇÃO DO CÓDIGO............ 31
FIGURA 17 – DEFAULT.ASPX, TELA DE LOG IN ........................................................................................................ 32
FIGURA 18 – POSSIBILIDADES DE CRIAÇÃO DE ESTILOS .......................................................................................... 33
FIGURA 19 – EXEMPLO PEDIDOSBLL.CS E A PÁGINA COM O GRIDVIEW ................................................................ 34
FIGURA 20 – EXEMPLO TABELA EM ASP .NET ........................................................................................................ 35
FIGURA 21 – EXEMPLO TABELA EM JSF JAVA ........................................................................................................ 36
FIGURA 22 – EXEMPLO TABELA EM PHP................................................................................................................ 36
x
LISTA DE LISTAGENS
LISTAGEM 1 – INICIALIZAÇÃO DE UMA SERVLET ................................................................................................... 10
LISTAGEM 2 – FINALIZAÇÃO DE UMA SERVLET ...................................................................................................... 10
LISTAGEM 3 – IMPLEMENTAÇÃO DO MÉTODO DE SERVICE ..................................................................................... 10
LISTAGEM 4 – EXEMPLO VÁLIDO DE PAGINA.JSP .................................................................................................... 11
LISTAGEM 5 – CÓDIGO JAVA EM PAGINA.JSP .......................................................................................................... 12
LISTAGEM 6 – FORMULÁRIO ENVIANDO REQUISIÇÃO ............................................................................................. 13
LISTAGEM 7 – EXPRESSION LANGUAGE PARAM ...................................................................................................... 13
LISTAGEM 8 – EXEMPLO DE TAGLIB ....................................................................................................................... 13
LISTAGEM 9 – EXEMPLO DE BEAN .......................................................................................................................... 14
LISTAGEM 10 – EXEMPLO BEAN ............................................................................................................................. 14
LISTAGEM 11 – TAGLIB DE CABEÇARIO.................................................................................................................. 15
LISTAGEM 12 – USO DE TAGLIB E BEAN ................................................................................................................. 15
LISTAGEM 13 – TAGS DELIMITADORAS DO SCRIPT PHP ........................................................................................... 17
LISTAGEM 14 – DECLARAÇÃO DE VARIÁVEL EM PHP ............................................................................................. 17
LISTAGEM 15 – SIMPLES PÁGINA EM PHP ............................................................................................................... 18
LISTAGEM 16 – CLASSE EM PHP ............................................................................................................................. 18
LISTAGEM 17 – UTILIZANDO OBJETO EM PHP ......................................................................................................... 18
LISTAGEM 18 – SINTAXE SIMPLES EM C# ............................................................................................................... 21
LISTAGEM 19 – COMPILADOR .NET VIA LINHA DE COMANDO ................................................................................ 21
LISTAGEM 20– DATABALE DO TOMAHAWK ............................................................................................................ 26
LISTAGEM 21 – FACES-CONFIG.XML ....................................................................................................................... 26
LISTA DE TABELAS
Tabela 1 – Quadro Comparativo.............................................................................................................................38
xi
1. INTRODUÇÃO
A internet com o passar dos anos tem ficado cada vez mais rápida e com esta
mesma velocidade tem se popularizado, tanto para o uso doméstico, quanto para
criar e agilizar alguns meios de negócio, ainda como DEITEL (2005) afirma “Com
certeza, a internet e a World Wide Web são as criações mais importantes e
profundas que já ocorreram na área de tecnologia.”. Isto graças ao seu alcance e
versatilidade, suprindo a necessidade da troca de informação de maneira rápida,
forçando os sistemas a serem distribuídos.
É nesta velocidade também que os profissionais que trabalham com o
desenvolvimento de sistemas tem que evoluir, adaptando-se a diversidade de
plataformas que surgiram para acompanhar este novo modelo de informação, que é
tão vasta que chega a confundir os profissionais da área na hora de definir suas
aplicações e quais tecnologias utilizar. Dentre elas há plataformas de
desenvolvimento que rodam sobre infra-estrutura proprietária e/ou livre e neste
ponto como MORAZ (2005) lembra “...é importante apontar o exemplo de muitas
empresas que, para reduzir os gastos com licença de software, migraram toda a
infra-estrutura web para plataformas livre...”, centradas na web ou de uso geral e
ainda a de avaliar critérios portabilidade, em qual paradigma de programação
trabalha, performance, entre outros.
Este trabalho surge da necessidade de apontar os pontos fortes e fracos de
três tecnologias mais usadas pelos desenvolvedores do mundo todo nos dias atuais
e implementá-las, testá-las e compará-las. Para a escolha das plataformas que
compõe o trabalho foi utilizado o ranking divulgado pelo site Tiobe Software
(http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html, março, 2008).
Desenvolvendo um protótipo que possua as principais características dos
sistemas encontrados na internet, tais como, usabilidade, manipulação de dados
(consultas, alteração e inserção) e interface para interação com o usuário de iguais
especificações e características em cada uma das plataformas escolhidas, salvo
peculiaridades que cada uma das tecnologias venha a possuir.
Com a análise dos testes no protótipo pretende-se mostrar qual a melhor, ou
mais viável, plataforma para a solução de um determinado problema e auxiliar os
profissionais da área a conhecer melhor estas plataformas trazendo mais garantias
ao projeto final e minimizando os riscos.
1
2. SISTEMAS WEB
A internet, uma rede global de computadores, desenvolvida há quase quatro
décadas e originalmente projetada para conectar os principais sistemas de
computadores hoje conecta milhões.
2.1 Histórico
As pesquisas de CONER (2007) contam que nas décadas de sessenta e
setenta durante a guerra fria entre EUA (Estados Unidos da América) e a extinta
União Soviética. Os EUA necessitavam de comunicação entre uma base militar e
outra, surgindo assim a ARPANET (Advanced Research Projects Agency Network).
Em pouco tempo e com algumas mudanças já estava nas universidades. O sucesso
foi tanto que novos e grandes investimentos foram feitos pelos governos e empresas
privadas, tecnologias foram criadas e a internet tornou-se o que conhecemos hoje.
Uma rede de computadores conectados em toda a extensão do globo que oferece
diversos serviços a seus usuários como podem ser o correio eletrônico, o chat, a
web ou as mais recentes investidas as aplicações web.
Lenta no início, mas a cada dia mais rápida e versátil, estando em
praticamente todos os lares, não dá para imaginar se sentar à frente de um micro
computador sem acesso a rede mundial de computadores.
2.2 Arquitetura e organização web
Todos os serviços oferecidos pela internet são realizados por milhares de
computadores que estão permanentemente ligados e conectados, esperando que os
usuários lhes solicitem serviços e servindo-os uma vez solicitados. Em
especificações CONER (2007) diz que por este motivo a internet tem que ser um
sistema heterogêneo, para que possa funcionar em qualquer uma das várias
plataformas de hardware e software realizando as mais diversas tarefas e as
diferentes necessidades das pessoas. Para isto foi criado um complexo e eficiente
sistema de protocolos, tais como, http (Hyper Text Transfer Protocol), que por
finalidade tem a transferência de dados e comunicação entre cliente e servidor na
web, TCP/IP, UDP, FTP, POP3, SMTP, entre outros, cuja as definições são abertas
para aqueles desejem utilizá-los, estes são os responsáveis por garantir que um
computador na rede “entenda” e “converse” com outros dispositivos que estejam
nela.
O protocolo http opera sobre o protocolo TCP/IP, os dois principais
protocolos, como um mecanismo de estrutura requisição/resposta, onde faz a
comunicação entre o cliente e o servidor através de mensagens. O cliente envia uma
mensagem de requisição de um recurso e o servidor envia uma mensagem de
resposta ao cliente com a solicitação. Geralmente este protocolo utiliza a porta 80 da
arquitetura TCP/IP e é usado para a comunicação de sites. O recurso mais comum é
a página escrita na linguagem HTML (Hipertext Markup Language). Como ilustra a
figura 1.
2
Figura 1 – Arquitetura web
De maneira grosseira a internet é dividida em três segmentos, em uma com o
lado do cliente onde se concentra as interações, o design e as solicitações, do outro
lado com os servidores e ai o processamento é feito e tudo aquilo que o usuário
passou é transformado e retorna a ele. E gerenciando todas as requisições e
solicitações está a internet.
As linguagens de programação também se dividem em suas especializações,
as próprias para o lado cliente como o HTML, JavaScript, Flash e as voltadas para o
lado servidor como Java, PHP, C#, Ruby e outras tantas, com representado pela
figura 2.
Figura 2 – Requisição e Resposta
3
2.3 Plataformas de Desenvolvimento
Foram relacionadas por serem as tecnologias em desenvolvimento mais
utilizadas no mundo pelos programados e empresas de software e também por
possuírem várias características em comum como, por exemplo, têm segmentos
voltados para a web, são orientadas a objetos e outras que serão analisadas neste
trabalho. São elas o Java, o PHP e o .Net mais especificamente o C#.
2.3.1 Java
Além de ser o primeiro no ranking das tecnologias mais usadas, conforme
divulgado no site Tiobe Software (março, 2008), tem ganhado adeptos nesta nova
fase da web, onde o objetivo não é mais apenas levar conteúdo de entretenimento,
conhecimento e ligação entre pessoas, mas também sistemas inteiros centrados na
web. Para este fim, o Java oferece APIs (application programming interfaces) que
trazem confiabilidade e dinamismo aos profissionais da área.
O desenvolvimento web no começo era feito com Servlet que funciona como
um pequeno servidor (o nome vem do inglês servidorzinho) que recebe chamadas
de diversos clientes e trabalha estas requisições conforme DEITEL (2005) “Os
servlets são eficazes para desenvolver soluções baseadas na Web que interagem
com bancos de dados em favor dos clientes...”, hoje é muito utilizado nos teclados
virtuais que os bancos utilizam para segurança de seus clientes.
A maior parte das páginas dinâmicas escritas em Java são feitas com o JSP
(JavaServer Pages) que afinal na definição de TEMPLE (2004) é uma página HTML
comum que contem também código Java, ou seja, ele permite que seja inserido
código servidor junto com código cliente, deixando os arquivos difíceis para leitura e
manutenção.
Para melhorar o resultado gerado pelo JSP e conseqüentemente a vida do
programador, a Sun sugeriu o uso do JSTL (JavaServer Pages Standard Tag
Library) esta foi a forma encontrada de padronizar, através da simplificação e
normalização das tags, o trabalho de milhares de programadores de páginas JSP.
GEARY at al (2007) “...programas para a web com Servlets e páginas
JavaServer Pages (JSP), é uma técnica um tanto contra-intuitiva e tediosa.” O JSF
(JavaServer Faces) vai dar a agilidade que faltava na criação de páginas e gerando
tags mais sofisticadas para criação de interfaces com o usuário.
2.3.2 PHP
Já consagrado ao longo dos anos o PHP (um acrônimo recursivo para "PHP:
Hypertext Preprocessor") surge na quarta posição como a plataforma mais utilizada
no mundo, visto na pesquisa do site Tiobe software (março, 2008), com recursos
sofisticados, é uma linguagem interpretada e não compilada, tem comunicação com
os principais bancos de dados disponíveis no mercado e permitem fazer uso de
todas as habilitações oferecidas pela orientação a objetos, presentes nas melhores
linguagens de programação.
É uma linguagem específica, ou seja, totalmente voltada ao desenvolvimento
web, assim como o Java e na colocação de MORAZ (2005) “...temos a liberdade de
escolher o sistema operacional e o servidor web que se deseja utilizar...”, o mesmo
código roda em qualquer plataforma, possui tipagem fraca, ou seja, o tipo de uma
variável não precisa ser definido previamente e sintaxe similar ao C/C++ e ao PERL,
foram os fatores que fizeram o sucesso do PHP.
4
2.3.3 C#
Baseado no C++ e no Java e conforme LOTAR (2007) “Aproveitar o
conhecimento do programador em diferentes tipos de aplicações, como aplicações
Windows ou web.”, a Microsoft cria a plataforma .NET (iniciativa que visa uma
plataforma única para desenvolvimento e execução de sistemas e aplicações) e com
ela a primeira linguagem totalmente baseada neste novo conceito o C# (lê-se C
Sharp) que é orientado a objetos, foi criado praticamente do zero e por este motivo é
a linguagem símbolo do .Net, embora outras linguagens sejam, oficialmente,
suportadas pela plataforma. Também é a linguagem mais integrada com o
framework, por que seu compilador foi o primeiro a ser desenvolvido e muitas das
suas classes ou funções são altamente vinculadas com o .Net Framework, que é o
responsável por executar o código gerado pela máquina virtual do .Net o CLR
(Common Language Runtime) que interpreta o código do desenvolvedor e compila
para o código nativo do sistema, idéia parecida com o da plataforma Java.
5
3. JAVA
Orientado a objetos e de grande portabilidade o Java vem evoluindo para a
internet, com o Java EE e suas APIs que se complementam começando pelos
Servlets, depois o JSP normalizado pelo JSTL e simplificado no JSF.
3.1 Histórico
Segundo JANDL (2002) e DEITEL (2005) em 1992 a Sun Microsystems criou
um time (conhecido como Green Team) para desenvolver inovações tecnológicas.
Esse time foi liderado por James Gosling, considerado o pai do Java, a idéia era de
criar um interpretador (uma máquina virtual) para pequenos dispositivos, facilitando a
reescrita de software para aparelhos eletrônicos.
A idéia não deu certo, tentaram fechar diversos contratos, mas não houve
êxito, hoje sabemos que o Java domina o mercado de aplicações para celulares,
talvez naquela época fosse prematuro ainda.
Com a web nasce à oportunidade de utilizar a idéia e poder rodar pequenas
aplicações dentro do browser. A semelhança era que na Internet havia uma grande
quantidade de sistemas operacionais e browser, com isso seria uma vantagem
poder programar numa única linguagem, independente da plataforma. Foi ai que o
Java 1.0 foi lançado: focado em deixar o browser não apenas um thin client1,
fazendo com que ele possa também realizar operações, não apenas renderizar
HTML. Sabemos que hoje os applets realmente não são o foco do Java.
A tecnologia Java nasceu com um objetivo em mente, foi lançado com outro,
mas no final decolou mesmo no desenvolvimento de aplicações do lado do servidor.
3.2 Principais características
Nas características apontadas por JANDL (2002) se destaca o fato de ser
criada para ser orientada a objetos, por que salvo seus tipos primitivos, tudo em
Java são classes ou instâncias delas e atende assim aos requisitos deste paradigma
de programação. Não trabalha com a manipulação direta da memória livrando o
programador de tarefas mais complexas, houve um tempo em que se existia um
preconceito com Java por ele ser mais lento, isto não existe mais devido a grande
evolução da JVM e também do hardware existente nos dias de hoje.
O Java prevê também um nível de segurança que garante, no caso das
applets, que os programas não executem operações no sistema cliente. A principal
característica do Java é realmente sua máquina virtual que diferente das outras
linguagens onde o código fonte, escrita que o programador utiliza na criação de
programas é diretamente compilado para linguagem de máquina ou código binário,
causando o problema de se ter que escrever um programa para cada sistema
operacional. O ambiente Java é demonstrado pela figura 3.
1
Termo em inglês para cliente magro, ou que não apresenta nenhum processamento.
6
Figura 3 – Ambiente Java
Com a Java escreve-se o código fonte apenas uma vez e este pode ser
executado em qualquer sistema operacional que possua uma JVM. Sendo parte
interpretado, parte compilado o programador escreve seu código e este é compilado
(com o programa disponibilizado junto ao kit de desenvolvimento o javac) e
transformado em bytecode2 os “binários”, a JVM por sua vez interpreta estes
arquivos class3 para os binários do sistema operacional que se esta rodando. Porém
a definição de Java Virtual Machine é bem mais ampla que um simples interpretador
é um computador simulado, ou seja, é neste nível que é controlado e gerenciado o
acesso a memória, gerencia threads, a pilha de execução, etc. A aplicação rodando
sem nenhum envolvimento do sistema operacional ou ainda na definição de JANDL
(2002) “As aplicações e os (applets) miniaplicativos Java são executados sobre a
plataforma Java e, portanto, sob um ambiente uniforme”. A estrutura de como é
compilado o fonte Java segue na figura 4.
Figura 4 – Estrutura de compilação
2
3
Nome dado a linguagem gerada após a compilação e que a JVM utiliza.
Extensão dos arquivos gerados após a compilação do código fonte.
7
Conforme especifica DEITEL (2005) e JANDL (2002), mesmo que não seja
uma boa prática e nem recomendado o Java pode ser compilado diretamente em
código nativo de máquina, com isto se perde a questão de portabilidade um dos
princípios do Java, a JVM também pode gerar código nativo caso perceba que
determinado trecho esteja sendo muito utilizado esta tecnologia é chamada de
Hostpot e o compilador é o JIT (Just inTime Compiler), o compilador que aparece
“bem na hora” que você precisa.
Compilar dinamicamente, a medida do necessário, pode gerar um
desempenho melhor. Uma vez que na compilação estática o código já foi otimizado
baseado em heurísticas e o compilador pode ter tomado uma decisão não tão boa.
Já a JVM, por estar compilando dinamicamente durante a execução, pode perceber
que um determinado código não está com performance adequada e otimizar mais
um pouco aquele trecho, ou ainda mudar a estratégia de otimização. É por esse
motivo que as JVMs mais recentes (como a do Mustang, Java 6), em alguns casos,
chega a ganhar de códigos C compilados com o GCC 3.x, se rodados durante um
certo tempo.
No início havia ainda o preconceito de que o Java seria lento, hoje isto não é
considerado, as JVM evoluíram muito e o processamento das máquinas também,
além de que um profissional que faça um bom programa em Java é bem mais fácil
de se encontrar, do que um profissional que faça um mesmo código em C++, por
exemplo, que tenha uma diferença considerável de desempenho.
3.3 Especificações do Java
Seguindo GEARY at al (2007) a arquitetura Java ainda define em sua API
(bibliotecas com as classes Java que dispões de funcionalidades da plataforma). O
Java EE (Java Enterprise Edition) e é a parte que mais nos interessa no momento, o
Java EE é uma série de especificações bem detalhadas mostrando como deve ser
implementado um software que faz um determinado serviço. A idéia é criar uma
aplicação que utilize estes serviços sem que o programador se preocupe em
desenvolver esta parte do sistema, há implementações para estes serviços pagas e
algumas muito boas livres de qualquer forma com as especificações se pode mudar
de implementação sem modificar a interface da aplicação.
Em sua versão 5 o Java EE dispõe das seguintes APIs:
• JAX-RPC (Java API for XML-Based RPC), JAXR (Java API for XML
Registries), para trabalhar com arquivos XML;
• JSP, JSF, voltado a trabalhos web;
• EJB (Enterprise Javabeans Components) e Java Persistence API, objetos
distribuídos, clusters, acesso remoto a objetos, etc;
• JTA (Java Transaction API), responsável pelo controle de transações no
contêiner;
• JMS (Java Message Service) troca de mensagens síncronas ou não.
Estes são apenas alguns exemplos existem várias outras, aqui o centro dos
estudos será na parte web.
3.4 Servlet Contêiner
TEMPLE at al (2004) explica que com a necessidade de gerar conteúdo
dinâmico, sugiram os primeiros programas CGI (Common Gatway Interface). Através
8
de linguagens como C, C++, Perl, ASP, PHP e outras foi possível gerar este tipo de
conteúdo.
Para melhorar o desempenho deste, surgiu o que viria a ser um Servlet, uma
nova forma de trabalhar com requisições clientes via web economizando o tempo de
processamento de uma chamada e memória usada no processo, além de ser
orientado a objetos e portável. O contêiner é o responsável por dar suporte para as
APIs de Servlet e JSP. Uma representação simbólica é exibida na figura 5.
Figura 5 – Representação Application Server
3.5 Servlet
Trabalha como um pequeno servidor que recebe chamadas (request) de
diversos clientes e retorna algo (response), HTML, gif, jpeg, etc. Como o Java é
orientado a objetos, podemos dizer que uma Servlet é representada como um
objeto.
Conforme TEMPLE at al (2004) diversas requisições podem ser feitas a uma
mesma Servlet tornando-a mais rápida que um programa CGI, por exemplo. O
comportamento das Servlets pode ser definido pela classe HttpServlet do pacote
javax.servlet, que se aplicam as Servlets que trabalham através do protocolo http, a
interface servlet é que define exatamente como uma Servlet funciona possibilitando
o uso de qualquer protocolo baseado em requisição e resposta.
Toda Servlet deve possuir um construtor sem argumentos para que o
contêiner possa criá-la e inicializá-la com o método init conforme a listagem 1, e a
usa durante todo o seu período ativo, até que irá desativá-las através do método
destroy de acordo com a listagem 2, para depois liberar o objeto. Na inicialização de
uma Servlet, quando parâmetros podem ser lidos e variáveis comuns a todas as
requisições devem ser inicializadas, conexão com o banco de dados.
9
Listagem 1 – Inicialização de uma Servlet
void init (ServletConfig config);
Na finalização é quando estes recursos são liberados.
Listagem 2 – Finalização de uma Servlet
void destroy();
O funcionamento básico de uma Servlet se resume a inicialização, chamadas
a métodos de serviço (essas chamadas passam dois argumentos para o método
service, a requisição que o cliente e a resposta que permite enviar dados a este) e
finalização. O exemplo a seguir, listagem 3, mostra uma Servlet implementando o
método service.
Listagem 3 – Implementação do método de service
protected void service(HttpServletRequest request,
HttpServletResponse response) throws ServletException,
IOException {
// Recebe o writer
PrintWriter out = response.getWriter();
// Escreve o texto
out.println("<html>");
out.println("Ola Mundo");
out.println("</html>");
}
O código mostra o método service que não executa nada e mostra uma
mensagem ao usuário, para isto foi “alterado” a resposta que o Servlet envia ao
cliente. O writer de saída do cliente pode ser obtido através do método getWriter da
variável response e então fica simples utilizar um PrintWriter para imprimir algo
como resposta, como é ilustrado na figura 6.
10
Figura 6 – Imprimir Resposta
Toda requisição pode vir acompanhada de parâmetros que são de
fundamental importância no desenvolvimento para a web. No método get é comum
ter uma url que termine com “?parametro=valor” enquanto no método post se envia
parâmetros através de um formulário ou escondidos da url. Independente disto estes
parâmetros podem ser lidos pelo método getParameter.
Por causa da arquitetura da API das Servlets, o método service é o ponto de
partida de uma requisição e delega o processo para o representante adequado, de
acordo com a requisição. As boas práticas de programação com Servlets diz que se
deve implementar sempre o método service e não um dos métodos como doGet,
doPost, doHeader, etc.
3.6 JSP – JavaServer Pages
Tecnologia para criação de páginas com conteúdo dinâmico e estático. Uma
página HTML comum para gerar texto estático, contêm também elementos JSP
(código Java) que produzem conteúdo dinâmico e possui a extensão .jsp,
basicamente é como na listagem 4 que se define o JSP.
Listagem 4 – Exemplo válido de pagina.jsp
<HTML>Ola Mundo</HTML>
11
Seria um código válido. Também poderia conter um código Java que
declarasse uma variável, como na listagem 5.
Listagem 5 – Código java em pagina.jsp
<%
String mensagem = “Ola Mundo”;
%>
As tags <% e %> delimitam o que é código Java, este código é chamado de
scriptlet. Esta não é uma idéia nova, já vem sendo usada por várias linguagens. Na
primeira vez que o JSP é chamado ele é interpretado, sendo transformado em um
Servlet, em seguida é compilado.
Figura 7 – JSP traduzido para Servlet
Porém não é uma prática muito boa misturar código servidor com código
HTML, além de dificultar a leitura imagine a situação onde o designer tem que fazer
alguma alteração na página, ele terá que aprender Java para isto ou poderá ter um
resultado não esperado.
De acordo com TEMPLE (2004) analisou para eliminar um pouco disto a Sun
criou uma linguagem chamada Expression Language que é uma linguagem de
domínio nascida para facilitar a apresentação dos dados e que é interpretada pelo
Servlet contêiner.
Para por exemplo mostrar parâmetros que o cliente envia através de sua
requisição, ou seja, passar um parâmetro de uma página para outra. Existe uma
variável chamada param que na Expression Language é responsável pelos
parâmetros enviados pelo cliente e para ler basta usar ${param.nome_do_param}.
12
Listagem 6 – Formulário enviando requisição
<html>
<form action="parametro.jsp">
Id: <input name="id"/> <input
type="submit"/>
</form>
</html>
Envia parâmetro fornecido pelo cliente, exemplificada na listagem 6.
Listagem 7 – Expression language param
<html>
ID: ${param.id}
</html>
Recebendo parâmetro que o cliente passou através do formulário, visto na
listagem 7. Existem ainda várias outras expressões com outras finalidades para
facilitar o trabalho do programador tanto de funcionalidade quanto de design.
3.7 JSTL – JavaServer Pages Tag Library
A SUN (2005) define a JSTL como um conjunto de marcações (tags) que
encapsulam funcionalidades comuns a muitas aplicações JSP, como laços, controle
de fluxos, internacionalização e manipulação de dados XML e na intenção de
melhorar o processo de criação de páginas reduzindo ou até eliminando o uso de
scriptlets e para padronizar algo que o mercado via como útil surge o JSTL
(JavaServer Pages Standard Tag Library), o conjunto básico de tags é composto
por:
• Core: http://java.sun.com/jsp/core
• XML: http://java.sun.com/jsp/jstl/xml
• Internationalization: http://java.sun.com/jsp/jstl/fmt
• SQL: http://java.sun.com/jsp/jstl/sql
• Functions: http://java.sun.com/jsp/jstl/functions
Facilitando e padronizando o trabalho dos programadores, tornando o código
gerado mais fácil de ser compreendido.
A implementação mais famosa do JSTL é a feita pelo grupo Jakarta em
jakarta.apache.org para utilizá-la primeiro se faz necessário extrair os arquivos para
a pasta lib do projeto, depois temos que escrever um cabeçalho com a tag jsp que
define qual taglib será utilizada e um nome (prefixo) para este.
O prefixo pode ter qualquer valor, mas por padrão da Sun para a taglib core é a
letra c. Um exemplo de cabeçalho fica ficaria como o da listagem 8
Listagem 8 – Exemplo de taglib
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
A url não é uma requisição ao protocolo http e sim em uma busca entre os
arquivos .jar no diretório lib.
13
3.8 Beans
Na análise de GEARY at al (2002) um bean Java é uma classe que expõe
propriedades e eventos a um ambiente como o JSF. Uma propriedade é um valor
nomeado de um determinado tipo que pode ser lido/escrito, get/set, são as
convenções para isto. Por exemplo, uma classe UserBean tem duas propriedades,
name e password ambas do tipo String conforme listagem 11 e listagem 12.
Listagem 9 – Exemplo de bean
public class UserBean {
public String getName() {. . .}
public void setName(String newValue) {. . .}
public String getPassword() {. . .}
public void setPassword(String newValue) {. . .}
...
}
Listagem 10 – Exemplo bean
public class UserBean {
public String getName() {. . .}
public void setName(String newValue) {. . .}
public String getPassword() {. . .}
public void setPassword(String newValue) {. . .}
...
}
Estes métodos podem executar ações arbitrárias, em muitos casos eles
apenas obtêm e definem o campo de uma ocorrência, mas podem executar tarefas
mais sofisticadas. De acordo com a especificação é possível omitir um deles,
tornando a propriedade apenas de escrita ou leitura. No entanto, o JSF lida com
essa situação de forma insatisfatória e gera uma exceção, ao invés de executar uma
ação default, por este motivo é melhor sempre ter ambas as propriedades do beans.
3.8 JSF – JavaServer Faces
Nos estudos de GEARY at al (2007) o JSF é construído por cima dos Servlets
e do JSP mas, do ponto de vista do desenvolvedor o JSF coloca uma face amistosa
por cima da aplicação web, permitindo aos programadores pensar sobre campos de
texto e menus em vez de se preocupar com mudanças de páginas e parâmetros de
requisições, além de conter todos os códigos necessários para manipular eventos e
organizar componentes, muito embora o programador possa abstrair isto e
preocupar-se apenas com a lógica de programação.
No contexto do JSF, os códigos das aplicações estão localizados nos beans e
o design está nas páginas web. Em aplicações JSF, usam-se beans para todos os
dados que devem ser acessíveis a partir de uma página.
É preciso haver uma página JSF para cada tela do navegador, dependendo
do ambiente de desenvolvimento as páginas normalmente terão a extensão .jsp ou
.jsf. As .jsp exigem menos trabalho de configuração. Como nos JSPs os JSFs
14
também exigem a definição das taglibs (bibliotecas de tags) de cabeçalho, sua
sintaxe é a seguinte apresentada na listagem 9.
Listagem 11 – Taglib de cabeçario
<%@ taglib uri=”http://java.sun.com/jsf/core” prefix=”f” %>
<%@ taglib uri=”http://java.sun.com/jsf/html” prefix=”h” %>
Mais uma vez o prefixo pode ser qualquer um que se escolha. A
implementação JSF define dois conjuntos de tags, HTML que geram marcação
específica e para sua aplicação web produzir páginas usando uma tecnologia de
renderização alternativa basta usar uma biblioteca de tags diferente. As tags
principais são independentes da tecnologia.
Embora muito familiar ao HTML ela possui suas peculiaridades como, todas
as tags JSF estão contidas em uma tag f:view, ao invés de usar uma tag form do
HTML usa-se a tag h:form, outro exemplo é a tag input, que fica h:inputText,
h:inputSecret e h:commandButton. As propriedades do campo input estão ligados
as propriedades do bean de nome user.
Listagem 12 – Uso de taglib e bean
< h:inputText values=”#{user.name}” />
Na listagem 10 quando a página é exibida o método getName é chamado
pelo framework para obter o valor atual da propriedade. Já quando a página é
enviada, o método setName é invocado para definir o valor digitado pelo usuário.
Figura 8 – Estrutura de desenvolvimento
15
4. PHP
Neste capítulo um pouco desta linguagem que é uma das primeiras,
específica para web, livre, independente de plataforma, pode ser utiliza com
orientação a objetos e amplamente usada no mundo.
4.1 Histórico
PHP (Hipertext PreProcessor) é uma linguagem de programação utilizada
para criar sites dinâmicos, foi desenvolvido em 1994 por Rasmus Lerdorf em sua
home page pessoal. Nas pesquisas de MORAZ (2005), em 1995 saiu a primeira
versão que pode ser utilizada por outros a Personal Home Page Tools (Ferramenta
para Homepages Pessoais), essa entendia algumas macros especiais mais ainda
muito limitada, em seguida o interpretador foi reescrito para entender dados de
formulários HTML, depois ganhou suporte a MySQL, com isto pessoas começaram a
adicionar-lhe código e seu ritmo de crescimento foi incrível.
A base para o PHP3 teve seu interpretador reescrito por Zeev Suraski e Andi
Gutmans, que utilizaram muitos dos códigos utilitários da versão anterior e outros
tantos foram totalmente reescritos, ganhando ainda mais adeptos pelo mundo todo.
4.2 Principais características
Ainda com base nas pesquisas de MORAZ (2005) que menciona o enfoque,
principal, na implementação de uma linguagem de script, executada do lado do
servidor (server-side). Portanto, permite coletar dados de formulários, gerar páginas
com conteúdo dinâmico ou enviar e receber cookies.
Pode ser utilizado em script no lado do servidor precisando apenas de um
interpretador PHP, um servidor web e um browser. Script de linha de comando
necessitando apenas do interpretador, ideal para scripts executados com o
agendador de tarefas do sistema operacional Windows e em rotinas de
processamento de texto. Aplicações desktop, PHP não é a melhor linguagem para
este fim, com alguns recursos avançados do PHP para aplicações do lado do cliente
temos o PHP-GTK (extensão do PHP para este fim não disponível na distribuição
oficial) para escrever programas neste formato, recurso que habilita a escrever
aplicações multiplataformas.
No PHP pode-se ainda escolher entre programação estrutural, orientada a
objetos ou a mistura de ambas. Embora seja bom frisar que o PHP não possui todos
os recursos da POO (Programação Orientada a Objetos).
Código HTML não é a única saída gerada pelo PHP, elas incluem ainda,
geração de imagens, arquivos PDF e animações Flash criadas dinamicamente, entre
outros.
Talvez a característica mais significativa do PHP seja seu suporte a uma
ampla variedade de bancos de dados, escrever uma página que utilize um banco de
dados é muito simples.
16
4.3 Especificações
Suportado pela maioria dos sistemas operacionais e também pela maioria dos
servidores web existentes hoje, dando liberdade ao desenvolvedor para escolher
qual a plataforma melhor para sua aplicação.
Em relação ao suporte a banco de dados, além dos suportados nativamente,
ele oferece suporte a ODBC (Open Database Connection). Também oferece
comunicação com outros protocolos como LDAP, IMAP, SNMP, NNTP, POP3,
HTTP, COM (em Windows) e outros. Há a possibilidade de abrir sockets de rede e
interagir diretamente com qualquer protocolo.
O PHP implementa objetos Java e os utiliza transparentemente como objetos
PHP, vale lembrar que é possível usar a extensão CORBA para acessar objetos
remotos.
Com e-commerce, podemos aplicar funções prontas e específicas para
Cybescash, CyberMUT, Verysign Payflow Pro e MCVE, práticos sistemas de
pagamento on-line, permitindo que o desenvolvedor abstraia estas implementações.
4.4 A linguagem PHP
O código PHP fica dentro da página HTML, o que pode ser ruim uma vez que
se os designers terão que entender de PHP para fazer seu trabalho, além de
dificultar a diagramação e leitura do código. Não possui nenhuma solução nativa que
nos possibilite separar a linguagem cliente da linguagem servidor, ficando a cargo do
programador tem muita cautela na geração de seus códigos para que estes não se
tornem muito complexos e inviáveis para manutenção futura.
É através das tags <? e ?> que o PHP identifica o que será interpretado do
que já é HTML, visto na listagem 13.
Listagem 13 – Tags delimitadoras do script php
<?
comandos
?>
O PHP utiliza uma checagem dinâmica de tipos, isto é, uma variável pode
conter valores de diferentes tipos em diferentes momentos da execução do script,
por esta razão, não é preciso declarar o tipo de uma variável para utilizá-la O
interpretador é quem decide qual tipo determinada variável irá possuir, verificando
seu conteúdo em tempo de execução. Variáveis em tem como prefixo $, ficando sua
sintaxe como na listagem 14.
Listagem 14 – Declaração de variável em php
$variavel1 = 5674;
$varialvel2 = “String”;
Ainda assim, assim é permitido converter os valores de um tipo para outro,
utilizando o typecasting ou a função settype (há também gettype para recuperar o
tipo de uma determinada variável).
17
Não existe o tipo boolean em PHP, porém ele é capaz de avaliar expressões
e retornar true e false, com valores inteiros. O valor 0 (zero) é utilizado para
representar o tipo falso e qualquer outro valor diferente dele (normalmente 1) é
considerado como verdadeiro.
Um exemplo simples de página com PHP poderia ser visto como na listagem
15.
Listagem 15 – Simples página em php
<html>
<?
echo “Ola Mundo”
?>
</html>
Onde no browsers do usuário seria exibido o texto Ola Mundo, a função echo
é a responsável por imprimir do lado cliente aquilo que foi processado no lado
servidor.
Outro exemplo de página com PHP, porém agora utilizando a notação de
objetos, seria montada da seguinte forma, listagem 16.
Listagem 16 – Classe em php
<?
class Texto {
function olaMundo () {
echo “Ola Mundo”;
}
}
?>
Na página HTML o código ficaria da seguinte forma, listagem 17.
Listagem 17 – Utilizando objeto em php
<html>
<?
$msg = new Texto;
$msg -> olaMundo();
?>
</html>
Gerando o mesmo resultado para o usuário, mas trazendo as facilidades que
o paradigma da orientação a objetos possui que facilita na organização, reutilização
e na manutenção do código que é comprovadamente superior ao da Estrutural.
18
5. C# (C SHARP)
Baseado na plataforma .Net, suporta várias linguagens o C# é a principal por
ter sido criado do zero. Muito parecido com Java e por também possuir uma espécie
de máquina virtual, traz muitas vantagens ao programador, além de ser orientada a
objetos.
5.1 Histórico
Conforme LOTAR (2007), surgiu junto com a Plataforma Microsoft .Net em
uma iniciativa da Microsoft buscando com um conjunto de tecnologias para melhorar
seus sistemas operativos, seu modelo de componentes COM+ em uma plataforma
única para desenvolvimento e execução de sistemas e aplicações baseadas em
serviços, que podem ser publicados e acessados através da internet. A idéia é que
se desenvolva e publique conteúdo independente de modelo de objetos, sistema
operacional e hardware.
Para desenvolvimento e execução de aplicações com esta tecnologia é
preciso ter um conjunto de ferramentas disponibilizadas pela Microsoft,
gratuitamente em seu site, conhecidas como .Net Framework SDK que possui
compiladores para as linguagens que compõem a plataforma como VB.Net, C++, J#,
ASP.Net e C#.
Muito semelhante ao Java, onde se insere uma “camada” entre o sistema ou
dispositivo especifico que executará o código nativo e a linguagem utilizada pelo
desenvolvedor, tornando o código mais portável. Anders Hejlsberg coordenou o time
da Microsoft e é quem leva os méritos pela linguagem, embora vários
desenvolvedores o auxiliassem, ele também foi o responsável pelas linguagens
Turbo Pascal e o Delphi.
A linguagem C# foi criada junto a arquitetura .Net e por esta razão é a que
mais se integra a ela. Criado do zero e sem preocupações com compatibilidades de
sistemas legados de outras versões, seu compilador foi o primeiro a ser
implementado e também grande parte das classes do .Net Framework foram
desenvolvidas em C# tornando sua execução natural ao framework.
5.2 A Plataforma .Net
É executada sobre uma CLR (Common Language Runtime), semelhante a
uma máquina virtual, interagindo com uma Coleção de Bibliotecas Unificadas, que
juntas são o próprio framework.
São oferecidos a estas aplicações diversos serviços que facilitam o
desenvolvimento e manutenção trazendo maior confiabilidade e segurança.
Completamente orientado a objetos, paradigma amplamente utilizado nos dias
atuais, resolve o problema de incompatibilidade entre DLLs, programas
desenvolvidos em .Net são multiplataforma e multilinguagem, chegando ao ponto de
se poder capturar em um programa escrito em C# uma execução escrita em VB.Net
que por sua vez herda de um tipo de execução escrita em COBOL.Net. Hoje já
podemos encontrar terceiros desenvolvendo versões adaptadas do .Net que
disponibilizam muitas outras linguagens a plataforma como APL, CAML, Fortran,
Java, Perl e várias outras.
19
A compilação de códigos produzidos em .Net são compilados duas vezes, na
distribuição e outra na execução, se baseando em um dos princípios da tecnologia
Java (compiladores JIT). Por exemplo, um programa é escrito em qualquer uma das
linguagens de programação disponíveis é compilado pelo framework gerando um
código intermediário em uma linguagem chamada MSIL (Microsoft Intermediate
Language), este por sua vez gera o código binário especifico para o sistema ou
dispositivo que se esta trabalhando. Segundo LOTAR (2003), “Ela foi criada para
resolver uma série de problemas que surgem quando se desenvolve software para a
Internet. Basicamente o que se pretende com a plataforma .NET é uma maior
integração entre os diferentes tipos de dispositivos que existem hoje em dia”, a
intenção da Microsoft era entrar em um mercado em crescente expansão que até
então ela estava fora, com executáveis pequenos, seguros e possuem vários dos
recursos presentes no Windows, como arrastar e soltar, clique com o botão direito,
entre outros a plataforma .Net firmou-se entre os desenvolvedores e usuários de
suas tecnologias.
5.2.1 Common Language Runtime (CLR)
É o aplicativo responsável pela execução das aplicações .Net, uma máquina
virtual, fornecendo e gerenciando os recursos do sistema operacional que executa
por baixo dela. Por esta razão o código gerado pelo compilador é chamado de
gerenciado. A CLR é capaz de executar, atualmente, mais de vinte diferentes
linguagens de programação, interagindo entre si como se fosse uma única
linguagem.
Com um nível de segurança avançado é possível limitar as permissões de
execução do código em função de sua procedência (internet, rede local, etc), o
usuário que a executa ou a empresa que o criou, além deste outros benefícios são
oferecidos como suporte a multilinha gestão ao acesso de objetos remotos que
permite o desenvolvimento de aplicações distribuídas de forma transparente, coleta
de lixo (garbage collector), adequação automática da eficiência das aplicações às
características da máquina onde está sendo executada.
5.3 Principais características do C#
Prosseguindo com os estudos de LOTAR (2007). Sendo a linguagem que, de
certa forma, mais identifica a plataforma .Net é também a mais usada pelos
desenvolvedores da tecnologia. O C# esta de tão ligado a plataforma, que não existe
o conceito de código não-gerenciado (unmanaged code), suas estruturas de dados
primários são objetos correspondentes ao do framework, além de classes,
interfaces, exceções e outras características que entram na mesma definição.
Melhorada em comparação ao C e C++ e como a plataforma totalmente
voltada ao paradigma da orientação a objetos, tirando o trabalho mais complexo do
programador. Ponteiros e aritmética sem checagem só podem ser utilizados em uma
modalidade especial denominada modo inseguro, ou unsafe mode, de normal
objetos são referenciados de maneira segura e operações aritmética são checadas
contra sobrecarga (overflow), liberação de objetos por coleta de lixo (garbage
collector) quando não há mais referência ao mesmo, não é permitida a múltipla
herança de classes, mas se pode implementar diversas classes abstratas.
Segurança quanto às conversões de tipos, permitindo apenas os tipos seguros como
ampliação de inteiros e conversões de tipos derivados para tipos base são feitas de
20
forma implícitas, para os outros tipos é preciso que o programador explicitamente as
marque.
Muito comparada ao Java, vale lembrar que as cada uma tem suas
peculiaridades que podem confundir o desenvolvedor, como por exemplo, C#
implementa propriedades, possui o goto como estrutura de controle, XML para gerar
documentação, indexadores e a mais marcante C# pode apenas ser compilado para
a plataforma Windows.
5.5 A linguagem C#
É uma linguagem simples e poderosa voltada para o desenvolvimento de
aplicativos orientados a serviços, internet, Webservices, etc, entretanto, nada
impede se produzir aplicações desktop com ele. Suas classes podem ser utilizadas
por outras linguagens de programação, como Visual Basic. É possível ainda utilizar
componentes COM, facilitando a migração de sistemas antigos para a nova
tecnologia.
Todos os programas gerados em C# necessariamente são compilados
gerando um arquivo exe e dll. Os fãs e autores especializados em .Net e C# afirmam
também que “Isso torna a execução dos programas mais rápida se comparados com
as linguagens de script (VBScript, JavaScript) que atualmente utilizamos na internet.”
Alfredo LOTAR (2007).
Existem elementos básicos que todos os programas executáveis do C#
necessitam ter, com esta informação um primeiro programa em C# seria o exemplo
da listagem 18.
Listagem 18 – Sintaxe simples em C#
using System;
class HelloWord {
static void main() {
Console.WriteLine(“Hello Word!!”);
}
}
O código acima tem 4 elementos, um namespace declaração, uma classe, um
método principal e um programa declaração. Ele pode ser compilado com a seguinte
linha de comando. Listagem 19.
Listagem 19 – Compilador .Net via linha de comando
csc.exe Hello.cs
É claro que existe IDEs que fazem este trabalho, isso produz um arquivo
chamado Hello.exe, que pode então ser executado. Outros programas podem ser
compilados similarmente, substituindo seu nome do arquivo, em vez de Hello.cs.
Digitando o comando "csc-ajuda" na linha de comando, se tem a ajuda do
compilador com os parâmetros que são aceitos. O nome do arquivo e nome da
classe pode ser totalmente diferente.
21
6. PROTOTIPO
Sistema de Pedidos, onde revendedores lançaram os produtos vendidos a
seus clientes para entrega da Distribuidora.
6.1 Descrição
Para fins de estudo será desenvolvido um Sistema de Pedidos cuja a
definição segue:
O sistema tem a finalidade de receber os pedidos de revendedores
espalhados pelo Brasil. Através de um usuário e senha eles farão o log in no
sistema. Lá podem lançar seu pedido que será composto de código do vendedor
(capturado pelo sistema na hora do logon), código do produto, forma de pagamento,
quantidade e um desconto por item (estes estão previamente cadastrados pela
distribuidora, não sendo possível sua alteração pelo usuário do sistema).
Este desconto será informado através do relatório tabela de preços que o
revendedor pode tirar e imprimir quando quiser. Também terá o relatório de
comissões por período que informará o quanto ele tem a receber junto a
distribuidora.
Ao termino do lançamento do pedido este poderá ser impresso pelo
representante.
Para isto serão criadas telas de logon, tela de lançamento de pedidos e a tela
dos relatórios.
Figura 9 – Visão geral tela de lançamento
22
Figura 10 – Diagrama de Caso de Uso
Como as figuras 9 e 10 mostram é um protótipo simples com o intuito
acadêmico e para completar o entendimento deste segue a descrição dos casos de
uso.
Caso 1: especificação textual do caso de uso “Logar no Sistema”.
Nome: “Logar no Sistema”.
Cenário principal: o caso de uso tem início quando o sistema apresenta uma tela
que pede ao representante o seu nome de usuário e sua senha. Note que o usuário
pode limpar a introdução das informações solicitadas na tela inúmeras vezes e
introduzi-la antes de pressionar o botão Entrar. O usuário ativa o botão Entrar para
confirmar. O sistema lê o usuário, a respectiva senha e verifica se são válidos. Se
ambos forem válidos, o sistema aceita a entrada e o caso de uso termina.
Cenário alternativo 1 (usuário/senha inválida): se o usuário introduz um nome de
usuário e/ou uma senha inválidos, o usuário é informado através de uma mensagem
visual e tem a chance de tentar novamente.
Cenário alternativo 2 (esqueceu a senha): caso o usuário não lembre sua senha
pode solicitar o envio dela para seu e-mail, se este e-mail fornecido pelo usuário
estiver cadastrado na base de dados, então será enviado um e-mail com a senha do
usuário.
Caso 2: especificação textual do caso de uso “Selecionar Ação”.
Nome: “Selecionar ação”.
com as opções das ações que o usuário pode executar no sistema, são elas: “Incluir
Pedido”, “Pesquisar Pedidos”, “Relatório de Comissão” e “Relatório de Preços e
Descontos”.
Caso 3: especificação textual do caso de uso “Lançar Pedidos”.
Nome: “Lançar Pedidos”
para a inclusão do pedido, que é composto dos campos: Condição de Pagamento,
Produto, Quantidade, Desconto, Valor Unitário, Valor Total do Item, Comissão e
Valor Total do Pedido. Destes campos os que o usuário pode alterar são Condição
de Pagamento, Produto, Quantidade, Desconto e Comissão, sendo que os campos
Condição de Pagamento e Produto são fornecidos pelo sistema e os campos
Desconto e Comissão podem ser variados dentro do limite fornecido pelo sistema.
Ao final da inclusão do pedido é exibido o numero do respectivo pedido e o usuário
pode imprimir o pedido.
23
Caso 4: especificação textual do caso de uso “Listar Comissões a Receber”.
Nome: “Listar Comissões a Receber”.
que solicita o período que o usuário deseja saber o quanto de comissão tem para
receber, com isto é exibido um relatório com os valores que pode ser impresso pelo
usuário.
Caso 5: especificação textual do caso de uso “Listar Preços e Descontos de Venda”.
Nome: “Listar Preços e Descontos de Venda”.
com a relação dos produtos, seus preços, o máximo de desconto que pode daquele
produto e quando de comissão sua venda rende.
Caso 6: especificação textual do caso de uso “Imprimir Pedido”.
Nome: “Imprimir Pedido”.
Cenário principal: o caso de uso tem início quando o representante termina de
lançar o pedido, então é exibido uma mensagem na tela com a possibilidade deste
pedido ser impresso.
6.2 Protótipo em Java
Aqui serão abordados as tecnologias utilizadas e o processo de
desenvolvimento do protótipo dentro da plataforma Java.
6.2.1 Tecnologias utilizadas
Utilizando a plataforma Java EE que é parte do Java e é voltada para
aplicações multicamadas, baseadas em componentes que são executados em um
servidor de aplicações (Tomcat neste caso). E as especificações desta plataforma
que foram utilizadas no sistema foram o Servlet, JSP, JSTL e JSF apoiadas por suas
APIs básicas e também de terceiros como a Tomahawk e a Trinidad do projeto
MyFaces do grupo Apache Software Foundation, que fizeram-se necessárias por
possuírem funções que automatizam algumas tarefas e fornecem outras não
existentes nas APIs padrão.
No suporte ao desenvolvimento foi utilizado o servidor Tomcat também do
grupo Apache, como servidor de aplicações que implementa o Java EE, permitindo
assim que o desenvolvedor abstraia diversas especificações e concentre-se no que
lhe interessa, o banco de dados foi o MySql que é distribuído livremente para
aplicações não comerciais e para mapear os atributos entre a base tradicional de
dados e o modelo objeto da aplicação de forma que esta tarefa fosse a mais simples
possível, utilizou-se o framework Hibernate.
A IDE adotada para o projeto foi o Eclipse que embora possua menos
recursos visuais do que a ferramenta inicialmente escolhida, o Netbeans, a curva de
aprendizagem no Eclipse se mostrou mais fácil e rápida exigindo de seu usuário
maior conhecimento na linguagem que na IDE. Já o Netbeans mostrou-se muito ágil
no processo de criação de páginas web. Tornando a experiência muito semelhante
ao desenvolvimento para desktop, em contrapartida quando se faz necessário uma
funcionalidade mais sofisticada ou um ajuste mais refinado o conhecimento na IDE é
exigido.
24
6.2.2 Processo de desenvolvimento
O desenvolvimento teve início pela a criação das classes beans (objetos que
representam os dados no modelo da orientação a objetos) até aqui nada muito novo
e nem específico para a web, pelo contrário é algo tão banal que as principais
plataformas de desenvolvimento automatizam esta tarefa. Em seguida foi criado o
arquivo XML de configuração do Hibernate é ele o responsável por dizer ao
framework como interligar os dados com as classes que os representam a
documentação disponível no site do projeto traz bons exemplos de como proceder.
Com a estrutura básica montada a principal tela, a de lançamento de pedidos,
começou a ser criada. Um exemplo mínimo de página JSF pode ser conferida na
figura 11, lembrando que dentro de um elemento f:view só podemos ter elementos
JSF.
Figura 11 – lancapedido.jsp
A princípio no processo de desenvolvimento a principal dificuldade foi dada ao
produzir grande quantidade de código antes de compilar e testar o que se fazia, por
haver vários frameworks envolvidos no projeto as vezes um “engole” a exceção do
outro e gera uma mensagem de erro não muito significativa o que dificulta e muito
encontrar o real problema no código e prejudica a produtividade. Notada esta
dificuldade se partiu para a estratégia de desenvolver em pequenas etapas, ou seja,
ao final de pequenas tarefas estas já eram compiladas e testadas.
Outro ponto que foi um obstáculo, leve, é saber quando se deve perder mais
tempo com uma funcionalidade um pouco mais sofisticada utilizando os
componentes da core e quando recorrer a bibliotecas de terceiros. Uma boa dica
aqui é sempre que uma funcionalidade se mostrar complicada, procure através de
sites de busca, listas de discussão por outras bibliotecas que já implementaram em
componentes tais funcionalidades.
Esta foi uma prática sempre presente em todo o desenvolvimento, consultar a
referência depois sites de busca em seguida as listas de discussão relacionadas,
este último é um ponto forte da linguagem Java com uma comunidade grande e
ativa, pois quando uma dúvida surgiu e precisou ser levada à lista todos lá, foram
sempre muito prestativos e auxiliaram até a solução do problema, o que facilitou
muito o trabalho.
Como foi mencionado, os componentes facilitam o trabalho simplificando o
código e fornecendo funcionalidades prontas, como por exemplo o datatable da
biblioteca do Tomahawk que gera uma tabela no navegador e de forma simples para
o programador dispõe de colunas ordenadas, paginação, eventos e outros recursos
como mostra a listagem a seguir.
25
Listagem 20– databale do Tomahawk
<t:dataTable id="listaProdutos" value="#{lancaPedidoBBean.produtos}">
<t:column sortable="true" sortPropertyName="codigo" >
<f:facet name="header">
<h:outputText value="Cod."></h:outputText>
</f:facet>
<h:outputText value="#{produto.codigo}"></h:outputText>
</t:column>
<t:column sortable="true" sortPropertyName="descricao">
<f:facet name="header">
<h:outputText value="Descrição"></h:outputText>
</f:facet>
<h:outputText value="#{produto.descricao}"></h:outputText>
</t:column>
</t:dataTable>
Outro ponto que deve ser observado na listagem anterior são os códigos
#{lancaPedidoBBean}, #{produto.codigo} e #{produto.descricao} que são os chamados
backing Beans, classes Java convencionais que são declaradas no faces-config.xml
(arquivo de configuração e mapeamento dos elementos utilizados no JSF) e alguns
de seus métodos ou propriedades são utilizados por uma página JSF, na prática é
quem possui a regra de negócios um exemplo de faces-config é observado na
listagem 21.
Listagem 21 – faces-config.xml
<?xml version="1.0" encoding="UTF-8"?>
<faces-config version="1.2" xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xi="http://www.w3.org/2001/XInclude"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-facesconfig_1_2.xsd">
<managed-bean>
<managed-bean-name>lancaPedidoBBean</managed-bean-name>
<managed-bean-class>
br.grillo.pedido.controller.LancaPedidoBackingBean
</managed-bean-class>
<managed-bean-scope>request</managed-bean-scope>
</managed-bean>
</faces-config>
Todo Backing Bean é um Managed Bean, na verdade a diferença é conceitual
o primeiro é quando um de seus métodos estão associados a uma página JSF, o
segundo é isolado, ou seja, não é associado a nenhuma página, mas a tag é a
mesma para qualquer um dos casos <managed-bean>. Descrevendo de forma
rápida seus atributos, o managed-bean-name é o nome do mapeamento é por este
nome que a página irá chamar os métodos da classe, o managed-bean-class é a
classe que se quer utilizar, managed-bean-scope é o escopo desta classe, ou o
26
tempo de vida dela, estas não são as únicas propriedades há outras para um maior
refinamento do código.
Esta amarração funciona da seguinte forma, durante a execução da
aplicação, sempre que uma página utilizar uma chamada ao bean o JSF vai checar o
arquivo de configuração e ver que existe um managed bean declarado para
determinada chamada e vai instanciar este objeto a todas as requisições que o
utilizarem.
Outro detalhe importante é que na versão 1.2 do JSF para utilizar diretamente
uma tag HTML não é mais necessário utilizar o elemento verbatim, simplificando o
código, aqui foi utilizada uma biblioteca de terceiro (encontrada em
http://jsftutorials.net/htmLib) para adicionar código HTML por que por algum motivo,
talvez um bug, utilizando diretamente o código div o atributo style (estilo) não era
aplicado. Voltando ao verbatim vale lembrar que a maneira antiga ainda funciona
mantendo a compatibilidade.
Os próprios componentes JSF possui algumas validações e de forma simples
podemos capturar estas mensagens e exibi-las para o usuário como é visto na figura
12.
Figura 12 – Trecho do código que trata a exibição de mensagens de erro
Com o JSF utilizar padrões de projetos como MVC (Model-View-Controller),
se torna tão natural que é fácil até para quem não tem um grande conhecimento
sobre o assunto. Esta abordagem torna a organização do projeto muito mais clara e
eficiente, trazendo entre outras vantagens maior escalabilidade ao sistema e
reaproveitamento de código para outros projetos garantida pela Orientação a
Objetos.
6.3 Protótipo PHP
Aqui serão abordados as tecnologias utilizadas
desenvolvimento do protótipo dentro da plataforma PHP.
e
o
processo
de
Com o servidor http da Apache que é livre rodando a instalação do PHP é
bem simples basta descompactar o arquivo fornecido no site do projeto e com
algumas poucas linhas de configuração já esta tudo funcionando. O banco de dados
27
utilizado foi o MySQL projeto amplamente conhecido e muito utilizado entre os
programadores PHP.
A IDE de desenvolvimento foi um ponto de dúvida. Das plataformas
abordadas neste estudo, sem dúvida o PHP é que a possui a mais vasta quantidade
de ferramentas para trabalhar com ele. Entre IDEs livres e proprietárias, a principio a
idéia era escolher uma ferramenta distribuída livremente, então foram testadas as
IDEs Eclipse for PHP que combina toda a experiência do grupo Eclipse com a
familiaridade para quem já o utiliza em outras linguagens e como é característico
desta ferramenta o domínio da plataforma é necessário. Em seguida foi avaliado o
Netbeans com sua extensão para PHP e notou-se algumas facilidades como, por
exemplo, gerar parte do código a partir da fonte de dados, mas nesta breve análise
nada muito significativo em relação a outra IDE livre.
Nas ferramentas proprietárias a abordagem do Delphi for PHP da CodeGear é
sem dúvida muito atraente, porque promete um desenvolvimento similar ao feito em
desktop, com componentes visuais utilizando a estratégia drag-and-drop (arrastar e
largar). A facilidade ainda aumenta se o programador já possuir experiência com o
tradicional Delphi para Object Pascal, talvez o grande problema desta IDE seja a
qualidade do código gerado, quanto mais se altera o projeto mais poluído o código
vai ficando, tornando necessária uma “faxina” em algum momento do trabalho e
também alguns bugs que precisam ser corrigidos em relação ao design. Devido ao
protótipo se tratar de uma aplicação pequena e sem muita navegabilidade e
interatividade, a ferramenta escolhida para esta parte do projeto foi o PHPMaker,
uma IDE que tem como abordagem a geração de código PHP a partir da base de
dados (MySQL), para uma aplicação onde as tabelas estão bem modelas e não há
um grande nível de complexidade, com alguns cliques já se pode ter uma aplicação
completa com tela de log in com controle de sessão, telas para visualização, edição
e inserção de dados. As ferramentas proprietárias utilizadas no estudo foram as
versões trial, ou seja, versões para avaliação.
Em função da IDE escolhida, que torna o desenvolvedor muito dependente
dela, o primeiro passo no desenvolvimento foi justamente o aprendizado da
ferramenta fazendo alguns testes e lendo o arquivo de ajuda fornecido com ela. Uma
vez conectado a base de dados, basta selecionar as tabelas que farão parte da
aplicação, em seguida quais as telas ela terá (inserção, alteração, visualização e
pesquisa entre outras) como mostra a figura 13.
Figura 13 – Opções de telas disponíveis
28
No passo seguinte como a aplicação tem uma tela com tabelas que possuem
a característica Mestre/Detalhe, ou seja, tem o relacionamento conhecido por 1 para
N (1 para muitos), uma tabela (Pedido) contendo os campos que fazem parte do
cabeçalho de um pedido e este cabeçalho pode ter muitos itens. Para esta finalidade
também esta disponível uma configuração específica como é observado na figura
14.
Figura 14 – Configuração Mestre/Detalhe
Facilmente é criado um campo totalizador que exibirá em tempo de execução
o total do pedido conforme seus itens são inseridos. Como a aplicação exige
segurança através do uso de sessão, e o usuário só pode utilizá-la iniciando e
efetuando o log in no sistema, fornecendo seu usuário e senha já cadastrados na
tabela representante, se faz necessário a configuração de mais esta funcionalidade.
Neste ponto vale ressaltar que a ferramenta tem muitas e boas opções para esta
finalidade e como o foco principal deste estudo não é a segurança, foram escolhidas
as opções mais básicas, sem criptografia ou limite de tentativas no log in e outras, a
figura 15 ilustra parte do processo.
29
Figura 15 – Configurações tela de log in
Com as configurações feitas basta clicar no botão generate que as páginas
são geradas já no diretório root do servidor, a partir daí é só ir ao navegador e digitar
o endereço da aplicação e navegar. Caso ao navegar pelas páginas algum ajuste se
faça necessário, basta voltar a IDE, fazer as alterações que deseja e, gerar o código
novamente.
Um grande ponto fraco desta ferramenta é o fraco suporte a Java Script tendo
apenas algumas validações simples e não disponibilizando em sua interface algum
lugar onde possa ser gerado algo novo ou melhorado o que já existe. Isto tem que
ser feito por fora, ou seja, através de outra ferramenta para este fim. O que dificulta e
muito para quem está desenvolvendo, porque até este ponto nada de código foi visto
e agora o programador se vê obrigado a entender o código fonte gerado para
identificar onde a lógica a mais será implementada.
Devido a proposta da IDE que é gerar código PHP, não se teve o cuidado de
separar o máximo possível o código de visualização das páginas geradas (html, css,
etc..) com o código de regra de negócios, tudo fica junto no mesmo arquivo PHP,
como a figura 16 que possui o trecho de código da página login.php exemplifica.
30
Figura 16 – login.php aberto em outro editor para visualização e manipulação do código
Em resumo as dificuldades surgirão quando será preciso fazer algo mais
sofisticado e específico que o “wizard” da ferramenta não disponibiliza, porque será
necessário ver e alterar no código fonte, que embora esteja bem organizado com
arquivos de nomes sugestivos e até bem estruturados, não foi o programador quem
o gerou, então se perde um bom tempo para encontrar as coisas e entendê-las.
Também não há nenhum comentário ou documentação sobre aqueles fontes, o que
para um projeto de médio ou grande porte pode até inviabilizar a evolução e
manutenção da aplicação.
6.4 Protótipo .Net
Aqui serão abordados as tecnologias utilizadas
desenvolvimento do protótipo dentro da plataforma .Net.
e
o
processo
de
Como o .Net é da Microsoft as tecnologias que o cercam também são
proprietárias, pelo menos as mais conceituadas e utilizadas, por esta razão talvez
ele já inicie com uma certa desvantagem em relação as demais plataformas
avaliadas neste estudo. Há um custo na aquisição de licenças que inevitavelmente
será repassado para o cliente encarecendo o produto final.
31
O servidor utilizado foi o IIS (Internet Information Services) da própria
Microsoft, ele já vem com a distribuição do Windows basta ativá-lo. Das três
plataformas esta foi a única onde escolher a IDE não gerou dúvida, o Visual Studio é
unânime entre os desenvolvedores .Net. Há uma outra IDE, o MonoDevelop, mas
este tem o foco para o desenvolvimento utilizando a plataforma em Linux ou Mac
OS, embora seja possível utilizá-lo no Windows, ele surgiu devido ao projeto Mono
uma implementação livre e multiplataforma do .Net, o objetivo desse projeto é criar
um framework de desenvolvimento opensource.
O banco de dados também é o MySQL uma distribuição livre, mas que não é
tão difundido em projetos desta plataforma.
O Visual Studio possui alguns templates que o acompanham e que facilitam o
trabalho do desenvolvedor .Net como por exemplo upload, calendário, menu,
treeview, log in e outros. A tela de log in do projeto foi feita a partir deste template
como é exibido na figura 17, que também mostra alguns dos componentes que a
ferramenta oferece que são utilizados no estilo drag-and-drop.
Figura 17 – Default.aspx, tela de log in
Ainda na tela de log in, para que seja alcançada a execução desejada que é,
só usuários logados podem navegar pelo sistema, se faz necessário editar o
web.config que é o arquivo onde ficam as configurações da aplicação, tais como,
32
cultura, string de conexão, páginas de erro e outras. O ferramenta se revelou
também a que mais, ou pelo menos mais facilmente, fornece opções que visam
melhoria na aparência da página também com sugestões pré definidas ou com um
bom suporte à CSS (Cascading Style Sheets) como a figura 18 exemplifica.
Figura 18 – Possibilidades de criação de estilos
Os templates são realmente uma facilidade principalmente para quem não
tem tanto conhecimento na plataforma .Net, através de wizards se consegue criar
recursos avançados sem precisar conhecer tanto da linguagem. Para quem domina
a sintaxe da linguagem nada impede que as páginas sejam diretamente codificadas
sem ajuda da IDE.
Foi utilizando um destes templates que a tela de lançamento de pedido foi
desenvolvida. Primeiro se insere um GridView, que é uma tabela já com
propriedades prontas para serem relacionadas a um ObjectDataSource,
responsável por obter os dados através das classes de lógica de negócios (Business
Logic Layer) disponibilizado no exemplo, conforme figura 19.
33
Figura 19 – Exemplo PedidosBLL.cs e a página com o GridView
Outra vantagem do .Net é a boa divisão entre o código gerado com as regras
de negócio do lado servidor neste caso C#, e o código ASP para as páginas do lado
do cliente, o que facilita quando se quer alterar apenas o visual da página ou
somente a regra de negócio. Lembrando que o .Net é orientado a objeto suportando
vários padrões de projetos que facilitam o desenvolvimento.
34
7. ANÁLISE DOS RESULTADOS
Será apresentada uma comparação de forma objetiva, subjetiva e as
dificuldades entre as plataformas estudadas. Estes resultados serão apresentados
também através de um quadro comparativo, concluindo com uma análise dos
resultados.
7.1 Avaliação objetiva
Material para consulta, produtividade, modularidade, qualidade e fácil
manutenção são pontos exigidos e importantes para um projeto e escolha da
plataforma. E estes foram os pontos observados durante o estudo.
Nem sempre que um projeto é aceito se tem uma equipe inteira com total
domínio sobre as tecnologias necessárias, então rapidez e eficiência na busca por
soluções de problemas, sanar dúvidas ou até opinião de profissionais com tal
experiência é, muitas vezes, crucial para bom andamento do projeto e neste ponto
as plataformas Java e PHP levam vantagem em relação ao .Net. Isto baseado na
gigantesca comunidade (como são intitulados) que estas duas plataformas possuem,
é fato que grande parte está em inglês, mas também há muita coisa em português.
Já em .Net além do fator do inglês o que se encontra facilmente é bastante conteúdo
básico produzido pelo grupo de desenvolvedores certificados pela própria Microsoft
o msdn (Microsoft Developer Network), pecando quando se precisa de um material
mais sofisticado.
Orientação a objetos é um paradigma que naturalmente favorece a
reutilização de código e aqui as três plataformas oferecem esta metodologia. Porém
o PHP não é baseado em orientação a objetos, isto faz com que às vezes se acabe
deixando a orientação a objeto de lado e prejudicando a modularidade do sistema,
isto é uma desvantagem para o PHP.
No quesito organização do código o Java e o .Net são muito semelhantes pois
possuem uma linguagem para a lógica de negócios e outra para gerar página. O
Java com o JSF por exemplo e o .Net com o Asp, dessa maneira fica fácil a
visualização e compreensão do fonte como ilustra as figuras 20 e 21.
Figura 20 – Exemplo tabela em Asp .Net
35
Figura 21 – Exemplo tabela em JSF Java
Como os trechos de código acima mostram, tanto um quanto o outro possuem
tags próprias, evitando assim que o fonte fique poluído com a mistura de código
servidor e código cliente. O Java ainda necessita de algum código de lógica de
negócios como é observado na figura 21, dentro das tags value, por exemplo. Já o
PHP não tem esta abordagem obrigando o programador a unir ambas as linguagens
em algum momento para gerar as páginas, a figura 22 tem um exemplo de uma
tabela com esta situação.
Figura 22 – Exemplo tabela em PHP
Veja no exemplo acima como se é obrigado a misturar o HTML com o código
PHP para mostrar conteúdo dinâmico para o usuário. Neste exemplo simples é fácil
visualizar o que o código faz, porém quanto maior a complexidade do código, maior
a dificuldade de visualização.
A manutenção talvez seja tão importante quanto o próprio desenvolvimento
em alguns projetos, por esta razão há sempre uma atenção especial sobre este
ponto pelos gerentes, pois esta não depende unicamente da plataforma utilizada,
mas também da forma como é utilizada. Avaliando as abordagens de
desenvolvimento aplicadas durante o estudo é difícil dizer qual plataforma se
destaca. O .Net leva uma certa vantagem pela melhor divisão entre o código lógico e
o código de visualização. Em seguida o Java com JSF que torna natural a
implementação de padrões de projetos, neste caso principalmente o MVC. O PHP é
36
uma plataforma muito robusta e talvez com uma abordagem mais elaborada tenha
um resultado melhor para este quesito, porém aqui a falta de distinção entre o
código lógico e o de visualização e a quantidade de código necessário para realizar
algumas funções que outras plataformas abstraem do programador, são pontos
negativos para o PHP.
7.2 Avaliação subjetiva
Durante o desenvolvimento um fator que foi crucial para as facilidades e
dificuldades é sem dúvida a experiência ou a falta dela. Então se pode afirmar que
os motivos apontados durante o estudo oscilem para mais ou menos, ou até se
alterem, dependendo da equipe e sua experiência.
Outro ponto não diretamente ligado às plataformas que se mostrou
predominante em todo o processo para uma melhor produtividade é a interatividade
com a IDE, porque independente da plataforma o principal contato do programador é
com a ferramenta que utiliza para produzir seu trabalho. E quanto mais esta
disponibilize funcionalidade que automatizem o trabalho melhor é o rendimento de
quem a utiliza.
Ainda sobre a ferramenta outro ponto que marcou o estudo foi a escolha desta.
Algumas plataformas tem tantas ferramentas que até confundem, é claro que a
escolha passa por gosto pessoal ou determinação da instituição a qual se presta o
serviço, mas caso a escolha seja necessária alguns passos a considerar podem
facilitar este processo.
•
•
•
Defina bem suas necessidades: se é um projeto simples ou mais sofisticado e
se terá funcionalidades bem específicas, estes pontos podem ajudar entre
escolher uma ferramenta que automatizem mais ou menos o código gerado.
Se o conhecimento da plataforma é maior, a escolha de uma IDE que lhe
prenda mais a ela talvez seja um problema, no entanto normalmente as IDEs
que mais exigem aprendizado são as que mais geram código de forma
automática ajudando quem não tem tanto conhecimento na plataforma.
Popularidade também deve ser levada em consideração na escolha, porque
quanto mais usuários já utilizam a ferramenta melhor será seu suporte em
caso de dúvidas.
Quando se fala em aplicação para web alguns pontos são quase que
obrigatórios, como o controle de sessão, controle de usuário e navegabilidade.
Nestes pontos a abstração que o Java e o .Net proporcionam torna ágil e simples
implementar estas funcionalidades, coisa que no PHP tem de ser feita de forma mais
manual.
Uma desvantagem para o Java é o fato de existirem muitos frameworks para ele,
o que torna sua escolha mais complicada, porque além de escolher a plataforma
Java tem que escolher o que dentro dela se vai utilizar. Feito isto há ainda várias
decisões de arquitetura que devem ser tomadas como, por exemplo, Java com JSF
e os componentes de um determinado grupo, ou de vários grupos, esta diversidade
de escolha que não é comum às demais plataformas avaliadas tem que ser vista
com cuidado no início do projeto porque pode atrasar ou inviabilizar o mesmo.
37
7.3 Dificuldades encontradas
No PHP a maior dificuldade foi encontrar uma ferramenta que desse suporte a
plataforma de uma maneira prática e intuitiva, embora esta seja uma escolha com
vários parâmetros, entre eles alguns não tão objetivos, o problema foi a quantidade
e a enorme diferença entre cada um. Superado isto, outro fator é o conhecimento
necessário para gerar funcionalidades que outras plataformas mostraram dispor com
tamanha facilidade, controle de sessão, por exemplo.
Para o Java o que pesa contra é a grande diversidade dentro da própria
plataforma, o que sugere um estudo mais aprofundado, tornando um pouco confuso
a decisão pelo o que utilizar.
Dúvidas e dificuldades são comuns ao decorrer de qualquer projeto, então
uma plataforma com um bom grupo de usuários ou com boas informações
disponíveis na internet são de grande importância para o fluxo do projeto, e nisto o
.Net deixa a desejar com exemplos simples e há dificuldade em se obter uma
resposta com rapidez e facilidade.
7.4 Quadro Comparativo
Tabela 1 – Quadro comparativo
Java
PHP
.Net
Ótimo
Ótimo
Razoável
Bom
Ótimo
Bom
IDE
Bom
Bom
Bom
Funcionalidades
transparentes
Ótimo
Razoável
Ótimo
Produtividade
Ótimo
Bom
Ótimo
Modularidade
Bom
Bom
Bom
Suporte a
resolução de
dúvidas
Conhecimento
necessário durante
o desenvolvimento
38
O quadro apresenta poucas diferenças entre as plataformas, pesando a favor
de uma ou outra, detalhes como a experiência da equipe, o projeto em questão e
pontos mais objetivos como as funcionalidades que a plataforma dispõe de maneira
transparente ao desenvolvedor.
Nele quem se destaca é o Java que tem a seu favor a grande comunidade
que possui, enquanto segue empatado com o .Net nos demais quesitos e o PHP
com o contra da falta de funcionalidades pré-prontas para o programador.
7.5 Análise
O PHP é amplamente utilizado em grandes projetos e possui bons geradores
de código desenvolvidos para ele, mas isto surge como uma forma de driblar a não
evolução da plataforma em relação as demais, o que o torna muito eficaz se a
necessidade for algo que alguma destas inúmeras (e para praticamente todas as
necessidades) ferramentas fornece. Agora para fazer algo específico é necessário
um grande conhecimento da plataforma e ainda escrever muito código, pois pouca
coisa é transparente ao programador.
O Java é realmente muito robusto, mas exige um cuidado especial porque
possui diversos meios para um mesmo, ou aparentemente o mesmo, resultado, o
que ocorre menos nas outras plataformas. Este foi então o maior ponto de
dificuldade para o Java, a enorme quantidade de decisões de arquitetura e
implementações que se tem que tomar ao decorrer do projeto, demandando tempo
para quando não há um bom conhecimento de causa.
A similaridade na sintaxe do .Net com o Java é tão grande que para alguém
que trabalha com um e migra para o outro só tem que se adaptar com a forma de
trabalhar que se altera em poucos detalhes. Mesmo com as semelhanças, não
existe no .Net a dificuldade de muitas implementações para uma mesma
funcionalidade. Portanto o ponto fraco desta plataforma que se sobressai em relação
às demais parece ser o fato de ele pertencer a um mundo cheio de licenças
tornando o preço final do produto gerado com ele mais caro.
39
8. CONCLUSÕES
No decorrer deste estudo se mostrou alguns dos pontos fortes e fracos de
cada plataforma aqui avaliada, e também sugerindo como superar os obstáculos que
são encontrados ao desenvolver um sistema para a web.
Outro objetivo era apontar a melhor plataforma para a resolução de um
determinado problema, que neste caso foi um protótipo de um sistema de
lançamento de pedido pela internet. Este objetivo se mostrou mais complexo do que
se previa, devido às inúmeras variáveis que cercam esta questão.
Para o sistema proposto, que é relativamente simples, afinal é um protótipo, o
.Net fica com a escolha de melhor opção devido a seus templates facilitarem em
muito o processo de criação. Com a ressalva de que para um projeto mais
específico seus templates, embora ainda ajudem, não são um grande diferencial.
E o principal objetivo deste estudo foi facilitar a escolha de uma plataforma
em projetos futuros.
As plataformas se mostraram mais eficazes em situações distintas, que
podem ser dividas em duas categorias. Uma são projetos mais gerais, ou seja,
aplicações que não necessitam de funcionalidades muito específicas e para estas o
PHP e o .Net são as melhores escolhas, porque facilitam muito a vida do
programador, seja na geração de código de forma automatizada que é o caso do
.Net ou com boas ferramentas que é o que ocorre com o PHP, tirando do
programador muitas das responsabilidades sobre a regra de negócio. Vantagem que
é perdida se o projeto exigir algo mais sofisticado. O Java é a escolha para projetos
mais elaborados com requisitos que exijam uma maior confiabilidade e robustez, isto
por que tem especificações bem definidas o que diminui a possibilidade de erro por
parte do programador no resultado final, que se vê “obrigado” a gerar um código de
melhor qualidade trazendo garantias para o resultado final. Há também os
frameworks que dão suporte ao programador implementando estas especificações,
deixando para o programador o trabalho de utilizar as funcionalidades, não o
preocupando de como elas são feitas.
Este estudo alcançou seu objetivo, mas fica em aberto uma pesquisa mais
aprofundada sobre as diversas implementações existentes dentro do próprio Java,
pois foi um ponto de dúvida constante durante este trabalho. Apontar qual é melhor
para cada problema, a dificuldade em misturar diferentes implementações ou ainda
se é uma boa prática fazê-las.
Outro estudo seria uma avaliação das tendências de mercado para as
plataformas respondendo, para qual finalidade cada uma é mais utilizada, qual tem o
profissional mais valorizado e ainda qual tem um maior percentual de projetos
considerados bem sucedidos pelas empresas.
40
9. REFERÊNCIAS BIBLIOGRÁFICAS
ARMSTRONG, Eric; BALL, Jennifer; BODOFF, Stephanie; CARSON, Debbie B.;
EVANS, Ian; GREEN, Dale; HAASE, Kim; JENDORCK, Eric. The J2EE™ 1.4
Tutorial. SUN Microsystems, 2005. 1542p.
CONER, Douglas E. Rede de Computadores e Internet. São Paulo: Bookman,
2007. 632p.
DEITEL, Harvey M.; DEITEL, Paul J. Java Como Programar. Tradução Edson
Furmanklewicz. São Paulo: Prentice Hall, 2005. 1152p.
GEARY, David; HORSTMANN, Cay. Core JavaServer Faces. Tradução Patrícia
Azeredo e Fausto Magalhçães. Rio de Janeiro: Alta Books, 2007. 522p.
JANDL JUNIOR, Peter. Introdução ao JAVA. São Paulo: Berkeley, 2002. 518p.
LOTAR, Alfredo. ASP.NET com C# Curso Prático. São Paulo: Novatec, 2003.
384p.
LOTAR, Alfredo. Como programar com ASP.NET e C#. São Paulo: Novatec, 2007.
608p.
MORAZ, Eduardo. Treinamento Prático em PHP. São Paulo: Digerat Books, 2005.
191p.
RAMOS, Ricardo Argenton. Treinamento Prático em UML. São Paulo: Digerat
Books, 2006. 144p.
TEMPLE, André; MELLO, Rodrigo F. de; CALEGARI, Danival T.; SCHIEZARO,
Maurício. Jsp, Servlets e J2EE. 2004. 267p.
VARGAS, Elton da Silva; SILVA, Camila Ceccatto da. HTML – Construindo a
Internet. São Paulo: Viena, 2007. 189p.
41

Visualizar - Polis Educacional

Transcrição

Documentos relacionados

objetivo resumo de qualificações atividades escolaridade

Chat Box em PHP - Comunidade Portuguesa de PHP

Programação de Jogos Eletrônicos

As 52 Palavras Reservadas no Java

Palavras Reservadas

as 50 maiores empresas de software do brasil

Os interessados poderão pré-inscrever

EDITAL SENAI-UFPE-ACCENTURE

Programa 5-03 Paintball

OBI2011 Caderno de Tarefas - Olimpíada Brasileira de Informática

Relatórios na WEB

- Andarilho