Estudo Comparativo Entre Frameworks Java para

UNVERSIDADE TECNOLGICA FEDERAL DO PARAN PROGRAMA DE PS-GRADUAO EM TECNOLOGIA ESPECIALIZAO EM TECNOLOGIA JAVA
REBECA SUCH TOBIAS FRANCO
ESTUDO COMPARATIVO ENTRE FRAMEWORKS JAVA PARA DESENVOLVIMENTO DE APLICAES WEB: JSF 2.0, GRAILS E SPRING WEB MVC
MONOGRAFIA DE ESPECIALIZAO
CURITIBA - PR 2011
REBECA SUCH TOBIAS FRANCO
ESTUDO COMPARATIVO ENTRE FRAMEWORKS JAVA PARA DESENVOLVIMENTO DE APLICAES WEB: JSF 2.0, GRAILS E SPRING WEB MVC
Monografia de especializao apresentada ao Departamento Acadmico de Informtica da Universidade Tecnolgica Federal do Paran como requisito parcial para obteno do ttulo de Especialista em Tecnologia Java. Orientador: Prof. Almeida. MSc. Leandro Batista de
Co-orientador: Prof. MSc. Maurcio Correia Lemes Neto.
CURITIBA - PR 2011
AGRADECIMENTOS
Primeiramente a Deus, pela vida, sade e inspirao que me permitiram escrever este trabalho. Aos meus pais, Valdimir e Snia, que sempre me incentivaram a estudar e lutar pelos meus objetivos. Ao meu irmo, Gabriel, que compartilha do mesmo interesse que eu pela informtica e me emprestou livros que me ajudaram no desenvolvimento deste trabalho. Ao meu marido, Jonas, por sempre me apoiar em tudo o que eu fao e por compreender o tempo em que estive ocupada me dedicando a esta ps-graduao. Aos colegas de curso, que tornaram os momentos de estudo mais agradveis. Aos professores, que transmitiram seu conhecimento e experincia, permitindo que nos tornssemos melhores profissionais.
A mente que se abre a uma nova ideia jamais voltar ao seu tamanho original. (Albert Einstein).
RESUMO
FRANCO, Rebeca S. T. Estudo Comparativo entre Frameworks Java para Desenvolvimento de Aplicaes Web: JSF 2.0, Grails e Spring Web MVC. 2011. Monografia (Especializao em Tecnologia Java) Programa de Ps-Graduao em Tecnologia, Universidade Tecnolgica Federal do Paran. Curitiba, 2011.
A plataforma Java a mais utilizada para o desenvolvimento de aplicaes web corporativas. O mercado exige que o software seja desenvolvido com o menor tempo e custo possvel e com qualidade. Para isso tornou-se essencial a utilizao de frameworks, pois eles aumentam a produtividade, maximizam o reuso e reduzem a possibilidade de erros. Atualmente existem diversos frameworks web disponveis para a plataforma Java. Este trabalho apresenta alguns conceitos relacionados ao desenvolvimento web em Java e descreve trs dos principais frameworks utilizados recentemente para essa finalidade: JSF 2.0, Spring Web MVC e Grails. Tambm realiza uma comparao entre eles. Atravs da implementao de um prottipo de um sistema financeiro so verificadas na prtica as comparaes tericas apresentadas e verifica-se qual dos frameworks apresenta mais vantagens ao desenvolvedor. Conclui-se que Grails o mais fcil de aprender e o mais simples de ser utilizado.
Palavras-chave: Java. Frameworks Web. JSF. Grails. Spring Web MVC.
ABSTRACT
FRANCO, Rebeca S. T. Comparative Study between Java Frameworks for Development of Web Applications: JSF 2.0, Grails and Spring Web MVC. 2011. Monografia (Especializao em Tecnologia Java) Programa de Ps-Graduao em Tecnologia, Universidade Tecnolgica Federal do Paran. Curitiba, 2011.
The Java platform is the most used for the development of corporate web applications. The market demands that the software has to be developed with the least time and cost as possible and with quality and for that, the use of frameworks has become essential, because they increase productivity, maximize reuse and reduce the possibility of errors. Currently, there are many web frameworks available for Java. This paper presents some concepts related to web development in Java and describes three major frameworks presently used for this purpose: JSF 2.0, Spring Web MVC and Grails. It also makes a comparison between these frameworks. Through the implementation of a prototype of a financial system, its possible to observe in practice the theoretical comparisons presented and define which framework has more advantages to the developer. It is concluded that Grails is the easiest to learn and the more simple to be used.
Keywords: Java. Web frameworks. JSF. Grails. Spring Web MVC.
LISTA DE FIGURAS
Figura 1 Componentes do Grails ........................................................................................... 22 Figura 2 Arquitetura JSF baseada no modelo MVC ............................................................. 25 Figura 3 Fluxo de informaes no Spring Web MVC........................................................... 26 Figura 4 Utilizao de JSON com o padro jQuery JavaScript para verificar disponibilidade de nome .................................................................................................................................... 37 Figura 5 Controlador Spring que informa ao cliente se o nome do usurio est disponvel . 37 Figura 6 Grfico de buscas realizadas dos frameworks JSF, Grails e Spring Web MVC..... 40 Figura 7 Grfico de buscas realizadas dos frameworks Grails e Spring Web MVC............. 41 Figura 8 Empregos disponveis no site da Catho para cada framework ................................ 41 Figura 9 Literatura disponvel para cada framework............................................................. 42 Figura 10 Artigos disponveis para cada framework no DevMedia ...................................... 43 Figura 11 Diagrama de Classes do Sistema de Controle Financeiro ..................................... 44 Figura 12 Diagrama de Casos de Usos do Sistema de Controle Financeiro ......................... 45 Figura 13 Classe de domnio Categoria do prottipo em JSF 2.0 ......................................... 46 Figura 14 Classe CategoriaDaoImp do prottipo em JSF 2.0 ............................................... 47 Figura 15 Classe HibernateUtil do prottipo em JSF 2.0 ...................................................... 48 Figura 16 Arquivo hibernate.cfg.xml do prottipo em JSF 2.0............................................. 48 Figura 17 Classe CategoriaBean do prottipo em JSF 2.0 (parte 1) ..................................... 49 Figura 18 Classe CategoriaBean do prottipo em JSF 2.0 (parte 2) ..................................... 50 Figura 19 Interface do prottipo em JSF 2.0 criada com PrimeFaces .................................... 51 Figura 20 Arquivo web.xml do prottipo em JSF 2.0 ........................................................... 52 Figura 21 Validao dos atributos da classe Usuario utilizando anotaes do Hibernate Validator ................................................................................................................................... 52 Figura 22 Mensagens exibidas pelo Hibernate Validator ..................................................... 53 Figura 23 Classe CategoriaDaoImp do prottipo em Spring Web MVC .............................. 54 Figura 24 Classe CategoriaController do prottipo em Spring Web MVC .......................... 55 Figura 25 Arquivo config.properties do prottipo em Spring Web MVC ............................ 56 Figura 26 Arquivo applicationContext.xml do prottipo em Spring Web MVC .................. 56 Figura 27 Arquivo dispatcher-servlet.xml do prottipo em Spring Web MVC .................... 57 Figura 28 Arquivo web.xml do prottipo em Spring Web MVC .......................................... 57 Figura 29 Classe de domnio Usuario do prottipo em Grails .............................................. 58 Figura 30 Opo para gerar controles e vises do sistema automaticamente em Grails ....... 59 Figura 31 Pgina inicial do sistema gerada automaticamente pelo framework Grails .......... 59 Figura 32 Pgina de listagem de usurio gerada automaticamente pelo framework Grails .. 60 Figura 33 Pgina de incluso de usurio gerada automaticamente pelo framework Grails .. 60 Figura 34 Exibio da descrio do grupo na combobox...................................................... 61 Figura 35 Configurao do arquivo dataSource para integrao com o PostgreSQL ........... 63 Figura 36 Script gerado automaticamente para criao da tabela usurio ............................ 63 Figura 37 Utilizao dos mtodos beforeInsert() e beforeUpdate() ...................................... 64
LISTA DE QUADROS
Quadro 1 - Anotaes do Hibernate Validator ........................................................................ 28 Quadro 2 - Constraints do Grails .............................................................................................. 30 Quadro 3 - Constraints do Grails que afetam o scaffolding ..................................................... 30 Quadro 4 Tratamento de expresses booleanas ..................................................................... 33 Quadro 5 Classes que implementam isCase(b) na GDK para switch(a) ............................... 33 Quadro 6 Atributos suportados pela tag <f:ajax>.................................................................. 36 Quadro 7 Atributos suportados pela tag <g:remoteLink> ..................................................... 38 Quadro 8 Atributos suportados pela tag <g:formRemote> ................................................... 39 Quadro 9 Atributos suportados pela tag <g:submitToRemote> ............................................ 39 Quadro 10 Comparao entre os frameworks ....................................................................... 66
LISTA DE TABELAS
Tabela 1 Linhas de cdigo do prottipo de cada um dos frameworks .................................. 67
LISTA DE SIGLAS
Ajax API CoC CRUD DAO DI DSL EJB GDK GORM GSP HTTP IDE IoC JDK JPA JSF JSON JSP JSR JSTL JVM LGPL MVC ORM POJO UI Asynchronous JavaScript and XML Application Programming Interface Convention over Configuration Create/Read/Update/Delete Data Access Object Dependency Injection Domain Specific Language Enterprise JavaBeans Groovy Development Kit Grails Object Relation Mapping Groovy Server Pages Hypertext Transfer Protocol Integrated Development Environment Inversion of Control Java Development Kit Java Persistence API JavaServer Faces JavaScript Object Notation JavaServer Pages Java Specification Request JavaServer Pages Standard Tag Library Java Virtual Machine GNU Lesser General Public License Model-View-Controller Object-Relational Mapping Plain Old Java Object User Interface
SUMRIO
1 INTRODUO ............................................................................................................... 12 1.1 FRAMEWORKS WEB ...................................................................................................... 12 1.2 OBJETIVO GERAL ........................................................................................................... 12 1.3 OBJETIVOS ESPECFICOS ............................................................................................. 13 1.4 JUSTIFICATIVA ............................................................................................................... 13 1.5 METODOLOGIA............................................................................................................... 13 1.6 ORGANIZAO DO TRABALHO ................................................................................. 14 2 FUNDAMENTAO TERICA ................................................................................. 15 2.1 PADRES DE PROJETO.................................................................................................. 15 2.2 MVC ................................................................................................................................... 15 2.3 FRONT CONTROLLER .................................................................................................... 15 2.4 INVERSO DE CONTROLE ........................................................................................... 16 2.5 INJEO DE DEPENDNCIA ........................................................................................ 16 2.6 PROGRAMAO POR CONVENO .......................................................................... 16 2.7 PARADIGMA DE ORIENTAO A ASPECTOS .......................................................... 16 2.8 JAVABEANS ..................................................................................................................... 17 2.9 FRAMEWORK .................................................................................................................. 17 2.10 HIBERNATE ................................................................................................................... 18 2.11 FRAMEWORK JSF .......................................................................................................... 18 2.12 FRAMEWORK SPRING WEB MVC.............................................................................. 20 2.13 FRAMEWORK GRAILS ................................................................................................. 21 3 COMPARAO ENTRE OS FRAMEWORKS ......................................................... 24 3.1 IMPLEMENTAO DO PADRO MVC ....................................................................... 24 3.1.1 JSF 2.0 ............................................................................................................................. 24 3.1.2 Spring Web MVC ............................................................................................................ 25 3.1.3 Grails ............................................................................................................................... 26 3.2 VALIDAO .................................................................................................................... 27 3.2.1 JSF 2.0 ............................................................................................................................. 27 3.2.2 Spring .............................................................................................................................. 28 3.2.3 Grails ............................................................................................................................... 29 3.3 LINGUAGEM JAVA X GROOVY ................................................................................... 31 3.4 SUPORTE AO GROOVY ................................................................................................. 34 3.4.1 JSF 2.0 ............................................................................................................................. 34 3.4.2 Spring Web MVC ............................................................................................................ 34 3.4.3 Grails ............................................................................................................................... 35 3.5 SUPORTE A AJAX ........................................................................................................... 35 3.5.1 JSF 2.0 ............................................................................................................................. 36 3.5.2 Spring .............................................................................................................................. 36 3.5.3 Grails ............................................................................................................................... 38 3.6 POPULARIDADE ............................................................................................................. 39 3.7 VAGAS DE EMPREGO .................................................................................................... 41 3.8 LIVROS DISPONVEIS ................................................................................................... 42 3.9 FRUNS DE DISCUSSO.............................................................................................. 43 3.10 ARTIGOS PUBLICADOS ............................................................................................... 43 4 SISTEMA DE CONTROLE FINANCEIRO ................................................................ 44 4.1 PROTTIPO DESENVOLVIDO EM JSF 2.0 .................................................................. 45 4.2 PROTTIPO DESENVOLVIDO EM SPRING WEB MVC ............................................ 53
4.3 PROTTIPO DESENVOLVIDO EM GRAILS ................................................................ 58 5 CONSIDERAES FINAIS ......................................................................................... 65 REFERNCIAS ....................................................................................................................... 68 APNDICES ............................................................................................................................ 71
12
1 INTRODUO
1.1 FRAMEWORKS WEB
O ambiente mais utilizado atualmente para o desenvolvimento de aplicaes corporativas na plataforma Java o ambiente web. No incio eram utilizados somente Servlets (classes Java que processam requisies dinamicamente e constroem respostas) e JSPs (JavaServer Pages documentos textos executados como Servlets e apropriados para gerao de pginas web), porm logo se percebeu que essa forma de trabalhar no era to produtiva e organizada. Comearam ento a serem utilizados alguns padres, como o MVC (Model-View-Controller) e o Front Controller e tornou-se comum as empresas implementarem esses padres e criarem solues baseadas em miniframeworks caseiros. Mas ainda existia um grande retrabalho para reimplementar o padro todo a cada projeto. O Struts foi o primeiro framework de sucesso criado para a plataforma Java. Ele foi lanado em 2000, permitindo a criao de um controlador reutilizvel entre os projetos e disponibilizando vrias funcionalidades j prontas, aumentando significativamente a produtividade dos desenvolvedores. Com isso ele se tornou a principal soluo MVC no mercado (CAELUM). Porm, com a evoluo da linguagem Java surgiram mais facilidades e o Struts passou a ser considerado um framework muito trabalhoso. Novos frameworks foram desenvolvidos para facilitar cada vez mais o processo de desenvolvimento de software, existindo atualmente inmeras opes.
1.2 OBJETIVO GERAL
O objetivo deste trabalho desenvolver um estudo sobre alguns dos frameworks web em Java mais utilizados atualmente no mercado: JSF 2.0, Spring Web MVC e Grails.
13
1.3 OBJETIVOS ESPECFICOS
Os objetivos especficos so descrever e comparar as caractersticas mais relevantes desses trs frameworks, como implementao do padro MVC, validao, suporte a Ajax, publicaes disponveis e vagas de emprego oferecidas, e verificar qual deles oferece mais vantagens ao desenvolvedor.
1.4 JUSTIFICATIVA
A utilizao de frameworks para o desenvolvimento de aplicaes web se tornou essencial nos ltimos anos, pois eles fornecem muitos benefcios, como: ganho de produtividade, reduo da possibilidade de erros, maior nvel de abstrao, compatibilidade e integrao entre aplicaes, reduo de custos e maximizao de reuso. Porm, existem inmeras opes de frameworks, tornando a escolha do melhor uma tarefa difcil. Esse trabalho ir auxiliar nessa deciso, pois ir comparar os frameworks web em Java mais relevantes em nossa regio.
1.5 METODOLOGIA
Para o desenvolvimento desse trabalho foi realizado um levantamento bibliogrfico sobre alguns conceitos de programao web em plataforma Java e sobre os frameworks JSF 2.0, Grails e Spring Web MVC para caracterizao dos mesmos. Em seguida foi feita uma comparao entre esses frameworks. Tambm foi desenvolvido um prottipo de uma aplicao de controle financeiro em cada um dos frameworks para demonstrar melhor algumas de suas caractersticas e diferenas.
14
1.6 ORGANIZAO DO TRABALHO
O trabalho est organizado da seguinte maneira: O captulo 2 descreve alguns conceitos importantes utilizados na programao web em Java e caracteriza os frameworks JSF, Spring Web MVC e Grails. O captulo 3 faz uma comparao de vrias caractersticas relevantes dos trs frameworks e das linguagens Java e Groovy. O captulo 4 descreve a implementao do prottipo de um sistema de controle financeiro em cada um dos frameworks, enfatizando as diferenas entre cada um. No captulo 5 so apresentadas as consideraes finais e concluses obtidas neste trabalho.
15
2 FUNDAMENTAO TERICA
2.1 PADRES DE PROJETO
Padres de projeto so solues para problemas recorrentes no desenvolvimento de software e que podem ser reusadas por outros desenvolvedores. Os componentes essenciais de um padro de projeto so: nome, objetivo, problema, soluo e consequncias.
2.2 MVC
De acordo com Gonalves (2007), Model-View-Controller (MVC) um conceito de engenharia de software para desenvolvimento e design, que prope a separao de uma aplicao em trs partes distintas: modelo, viso e controle. O modelo usado para definir e gerenciar o domnio da informao, a viso responsvel por exibir os dados ou informaes da aplicao e o controle controla as duas camadas anteriores, exibindo a interface correta ou executando algum trabalho complementar para a aplicao. O MVC o padro de arquitetura de software mais recomendado para aplicaes interativas, conforme Singh (2002).
2.3 FRONT CONTROLLER
Front Controller (Controlador Frontal) um padro bastante utilizado em frameworks MVC, onde um nico servlet responsvel por receber todas as requisies, delegar o processamento para os outros componentes da aplicao e devolver uma resposta ao usurio.
16
2.4 INVERSO DE CONTROLE
Conforme Machado (2008), Inverso de Controle (Inversion of Control, ou IoC) consiste na mudana do fluxo de controle de um programa, onde ao invs do programador determinar quando um procedimento ser executado, ele apenas determina qual procedimento deve ser executado para um determinado evento. Isso propicia o reaproveitamento do cdigo que contm o fluxo de controle, do design e do comportamento da aplicao, possibilitando que seja atingido um baixo acoplamento na arquitetura e um alto nvel de testabilidade.
2.5 INJEO DE DEPENDNCIA
Injeo de Dependncia (Dependency Injection, ou DI) um padro de projeto cujo objetivo desacoplar os componentes de uma aplicao, instanciando-os externamente classe e controlando suas instncias atravs de um gerenciador. Consiste em uma implementao que faz uso de Inverso de Controle.
2.6 PROGRAMAO POR CONVENO
Programao por conveno, ou CoC (Convention Over Configuration), um paradigma que visa diminuir a quantidade de decises que o desenvolvedor precisa tomar, tomando como padro algo que comumente usado, uma conveno.
2.7 PARADIGMA DE ORIENTAO A ASPECTOS
Segundo Torsten (2011), o paradigma de orientao a aspectos consiste na decomposio do sistema em partes no entrelaadas e espalhadas (fase de decomposio) e
17
em juntar essas partes novamente de forma significativa para obter o sistema desejado (processo de composio). A programao orientada a aspectos possibilita que os interesses comuns do sistema sejam separados em aspectos, que encapsulam comportamentos que afetam mltiplas classes. Como consequncia so obtidos benefcios como: melhor modularizao, possibilidade de reutilizao de grande parte dos mdulos desenvolvidos e facilidade de manuteno e evoluo do software.
2.8 JAVABEANS
De acordo com a especificao do JavaBeans (Sun Microsystems, 1997), Java Bean um componente reutilizvel de software que pode ser manipulado visualmente com a ajuda de uma ferramenta de desenvolvimento". As classes JavaBeans devem: implementar a interface java.io.Serializable; possuir um construtor sem argumentos; possibilitar o acesso s suas propriedades atravs de mtodos get e set; possibilitar a incluso de qualquer mtodo de tratamento de eventos.
2.9 FRAMEWORK
Coad (1992) define um framework como um esqueleto de classes, objetos e relacionamentos agrupados para construir aplicaes especficas. Johnson e Woolf (1998) descrevem framework como um conjunto de classes abstratas e concretas que prov uma infraestrutura genrica de solues para um conjunto de problemas. Os frameworks permitem a reutilizao de toda a arquitetura de um domnio especfico, no somente de componentes isolados, diminuindo o tempo e o esforo exigidos na produo de software.
18
2.10 HIBERNATE
O Hibernate um framework de persistncia escrito na linguagem Java, com cdigo aberto e distribudo com licena LGPL (GNU Lesser General Public License).
Historicamente, o Hibernate facilitou o armazenamento e recuperao de objetos de domnio Java atravs do Mapeamento Objeto/Relacional. Hoje, o Hibernate uma coleo de projetos relacionados que permitem aos desenvolvedores utilizarem modelos de domnio POJO em suas aplicaes de forma a estender muito alm do Mapeamento Objeto/Relacional. (JBoss Community).
2.11 FRAMEWORK JSF
Conforme Nunes e Magalhes (2010), JavaServer Faces (JSF) uma especificao tcnica do Java Community Process (JCP), publicada em 2004, com o objetivo de padronizar um framework para desenvolvimento da camada de apresentao em aplicaes web. JSF um framework baseado em componentes. Com isso, para criar uma tabela, por exemplo, ao invs de criar um loop para adicionar linhas e colunas com tags HTML, adicionado um componente tabela pgina. Os principais objetivos desse framework so maximizar a produtividade, minimizar a complexidade de manuteno, evoluir a experincia do usurio com uso de tcnicas Ajax e proporcionar melhor integrao com outras tecnologias web. Conforme descrito no tutorial do Java 6 The Java EE 6 Tutorial (Oracle, 2011), os principais componentes da tecnologia JavaServer Faces so: Uma API para representar componentes UI (User Interface) e gerenciar seu estado; manipulao de eventos, validao do lado servidor, e converso de dados; definio de navegao de pgina; suporte internacionalizao e acessibilidade; e possibilidade de extenso para todas essas caractersticas. Tag libraries (blibliotecas de tags) para adicionar componentes s pginas web e conectar componentes a objetos do lado do servidor. Uma tpica aplicao JavaServer Faces inclui: Um conjunto de pginas web nos quais os componentes so definidos. Um conjunto de tags para adicionar componentes pgina web.
19
Um conjunto de backing beans, que so componentes JavaBeans que definem propriedades e funes para componentes de uma pgina. Um descritor de deploy web (arquivo web.xml). Opcionalmente, um ou mais arquivos de recursos de configurao da aplicao, como o arquivo faces-config.xml, os quais podem ser usados para definir uma pgina de regras de navegao e configurar beans e outros objetos e componentes customizados. Opcionalmente, um conjunto de objetos customizados, que podem incluir componentes customizados, validadores, conversores, ou listeners, criados pelo desenvolvedor da aplicao. Um conjunto de tags customizadas para representar objetos customizados na pgina. A verso mais atual do JSF a 2.0 (JSR - Java Specification Requests - 314), que introduziu solues como gerenciamento de recursos, Facelets, suporte a Ajax, configurao com anotaes e novos escopos. JSF uma especificao, portanto necessrio escolher uma implementao. A implementao de referncia da Oracle a Mojarra, mas existem vrias outras, como: MyFaces, ADF (Application Development Framework) e Shale. Alm disso, existem extenses de implementaes, como o ICEFaces, que altera o comportamento padro do JSF e possui vrios componentes visuais. JSF tambm possui vrios Kit Componentes, como Apache Tomahawk, JBoss Ajax4JSF, JBoss RichFaces, Yahoo for JSF, DynaFaces, Jenia Faces, Web Galileo Faces, Mojarra UI, RestFaces, GMaps4JSF e PrimeFaces. JSF permite ainda integrao com outras tecnologias e frameworks, como Spring, Java Persistence API (JPA), Enterprise JavaBeans (EJB) e JBoss Seam. JSF o framework Java mais utilizado para desenvolvimento de aplicaes web. Alguns dos principais motivos para isso so: oferece um excelente conjunto de funcionalidades, possui bons materiais de estudo e exige pouco conhecimento inicial para construo de interfaces de usurios tradicionais.
20
2.12 FRAMEWORK SPRING WEB MVC
Spring um framework leve com inverso de controle e orientado a aspectos. Spring Web MVC um mdulo robusto e flexvel desse framework para desenvolvimento rpido de aplicaes web utilizando o padro de projeto MVC. As principais caractersticas do Spring Web MVC, de acordo com sua documentao de referncia (Johnson et al., 2011), so: Clara separao de papis. Cada papel controlador, validador, objeto de comando, objeto de formulrio, objeto de modelo, DispatcherServlet, mapeamento de tratadores, resolvedores de visualizao podem ser definidos por um objeto especializado. Configurao simples e eficiente de classes de aplicaes e frameworks como JavaBeans. Essa capacidade de configurao inclui fcil referncia em diferentes contextos, como as dos controladores web para objetos de negcio e validadores. Adaptabilidade, no-intruso e flexibilidade. Definio de qualquer assinatura de mtodo de controle que for necessria, possivelmente usando uma das anotaes de parmetros (como @RequestParam, @RequestHeader, @PathVariable, etc.) para um determinado cenrio. Reusabilidade do cdigo de negcio, no sendo necessria duplicao. Usam-se objetos de negcio existentes como comandos ou objetos de formulrios ao invs de replic-los para estender uma base de classe particular do framework. Vnculos e validaes customizveis. Validao de tipos no nvel da aplicao, que verificam o valor, localizam datas e nmeros e permitem anlise manual e converso para objetos de negcio ao invs de somente objetos String de formulrios. Mapeamento de tratadores e resolvedores de visualizao customizveis. Estratgias de mapeamento de tratadores e resoluo de visualizao variam de uma simples configurao baseada na URL at sofisticadas estratgias de resoluo para este propsito. Spring mais sofisticado que frameworks MVC que utilizam uma tcnica particular. Modelo flexvel de transferncia. Modelo de transferncia com mapeamento nome/valor suporta fcil integrao com qualquer tecnologia de viso.
21
Localidade customizvel e resoluo de temas, suporte para JSPs com ou sem tag library Spring, suporte para JavaServer Pages Standard Tag Library (JSTL), suporte para Velocity (engine baseado em Java para a construo de templates) sem necessidade de plugins extras, etc. Uma biblioteca de tags conhecida como Spring tag library que providencia suporte para caractersticas como vnculo de dados e temas. Essas tags customizadas permitem a mxima flexibilidade em termos de cdigo de marcao. JSP form tag library, introduzido no Spring 2.0, que torna a escrita de formulrios em pginas JSP muito mais fcil. Beans cujo ciclo de vida tem como escopo a solicitao atual HTTP ou a sesso HTTP. Essa no uma caracterstica do Spring MVC em si, mas sim do container WebApplicationContext que o Spring usa.
2.13 FRAMEWORK GRAILS
O framework Grails foi criado em 2006. Ele foi baseado nas ideias do Ruby on Rails e utiliza a linguagem Groovy, por isso seu nome inicial era Groovy on Rails, mas precisou ser trocado a pedido de David Heinemeier Hansson (o criador do Ruby on Rails). Seu foco a alta produtividade e simples configurao. Groovy uma linguagem de scripting, orientada a objetos e dinamicamente tipada, que roda de forma nativa na Java Virtual Machine (JVM), o que permite que todo cdigo Java pr-existente possa ser reaproveitado. Segundo Subramaniam (2008) o Groovy traz o melhor dos dois mundos: uma linguagem flexvel, de alta produtividade, gil e dinmica que funciona no rico framework da Plataforma Java. Esse framework utiliza o princpio Dont Repeat Yourself (DRY) e reduz drasticamente a complexidade de construir aplicaes web na plataforma Java. Algumas das vantagens oferecidas pelo Grails so: Uma camada para mapeamento objeto-relacional fcil de usar construda no Hibernate. Uma tecnologia de viso expressiva, chamada Groovy Server Pages (GSP).
22
Uma camada de controle construda no Spring MVC. Um ambiente em linha de comando construdo no Groovy: Gant. Um container TomCat integrado que configurado para recarregar quando necessrio. Injeo de dependncia com o container Spring embutido. Suporte internacionalizao (i18n) construda sobre o conceito MessageSource do ncleo do Spring. Uma camada de servios transacionais construda na abstrao de transaes do Spring.
Figura 1 Componentes do Grails Fonte: Infonova (2008)
Outra grande vantagem oferecida pelo Grails o fato de se tratar de um ambiente completo de desenvolvimento, dispensando a necessidade de baixar arquivos .jar da internet para poder trabalhar adequadamente. Grails usa conveno sobre configurao, ou seja, o nome e a localizao de arquivos so usados ao invs de configurao explcita. Para isso existe uma estrutura de diretrio padro: grails-app - diretrio de nvel superior para os arquivos fontes de Groovy o conf arquivos de configurao. o controllers controladores web. o domain o domnio da aplicao. o i18n suporte para internacionalizao (i18n).
23
o services a camada de servios. o taglib tag libraries. o views Groovy Server Pages. scripts scripts Gant. src arquivos fontes de apoio. o groovy outros arquivos fontes Groovy o java outros arquivos fontes Java test testes de unidade e integrao. Grails possui uma propriedade chamada Scaffolding que permite que uma aplicao inteira seja gerada atravs das classes de domnio, incluindo as vises necessrias e as actions de controle para operaes CRUD (create/read/update/delete). A verso mais recente do Grails a 1.3.7, que empacota o Groovy 1.7.8. Atualmente existem 623 plugins disponveis para esse framework, que podem ser baixados atravs do endereo http://grails.org/plugin/category/all.
24
3 COMPARAO ENTRE OS FRAMEWORKS
Os frameworks JSF, Grails e Spring Web MVC possuem vrios atributos em comum, como a arquitetura em MVC, utilizao do padro Front Controller, suporte a validao e converso de dados, internacionalizao e manipulao de erros. Neste captulo sero comparados algumas de suas principais caractersticas.
3.1 IMPLEMENTAO DO PADRO MVC
3.1.1 JSF 2.0
No JSF a camada de controle composta por: FacesServlet recebe as requisies da WEB, redireciona-as para o modelo e remete uma resposta. Arquivos de configurao - realizam associaes e mapeamentos de aes e definem as regras de navegao. Manipuladores de eventos recebem os dados vindos da camada de visualizao, acessam o modelo e devolvem o resultado ao FacesServlet. A camada modelo representada por objetos de negcio (Java Beans), que executam uma lgica de negcio ao receber os dados oriundos da camada de visualizao. A camada de visualizao representada por uma hierarquia de componentes (component tree), que possibilita a unio de componentes para construir interfaces mais ricas e complexas. Na verso 2.0 o padro para montagem de templates o Facelets (extenso xhtml), mas tambm podem ser utilizadas outras tecnologias como JSP e Clay.
25
Figura 2 Arquitetura JSF baseada no modelo MVC Fonte: Pitanga
3.1.2 Spring Web MVC
No Spring Web MVC, a camada de controle composta por: DispatcherServlet processa todas as requisies do usurio e invoca elementos Controller apropriados. HandlerMapping baseado na URL da requisio indica ao DispatcherServlet qual o controlador a ser invocado. HandlerAdapter responsvel por delegar a requisio para mais processamentos. ViewResolver interface que devolve ao DispatcherServlet qual viso deve ser buscada e instanciada, baseada em seu nome e localizao. Controlador processa os dados e executa alguma regra de negcio da aplicao. Para criar um controlador em Spring 3.0 basta usar a anotao @Controller na classe. Muitos dos mtodos das subclasses do Controller retornam um objeto org.springframework.web.servlet.ModelandView. Esse objeto encapsula o modelo (como um objeto java.util.Map que mantm JavaBeans que a interface View ir compor) e o nome da viso, possibilitando retornar ambos em um valor de retorno de um mtodo para o Dispatcher.
26
A camada de viso do Spring representada por vrias tecnologias: JSP, JSTL, Velocity, FreeMarker, JasperReport, XSLT, Tiles, PDF e Excel.
Figura 3 Fluxo de informaes no Spring Web MVC Fonte: Saab (2011)
3.1.3 Grails
De acordo com Seifeddine (2009), o modelo do Grails representado com classes de domnio assim como os outros frameworks apresentados, porm essas so automaticamente persistidas e podem at mesmo gerar o esquema de dados. Grails trata as classes de domnio como o componente central e mais importante da aplicao. Grails utiliza o framework de persistncia Hibernate, que prov uma soluo de mapeamento objeto-relacional (ORM Object Relational Mapping) para aplicaes. Ao invs de construir sua prpria soluo ORM a partir do zero, Grails envolveu o Hibernate em uma API Groovy, chamada Grails Object Relation Mapping (GORM), que prov a linguagem Domain Specific Language (DSL) que usa conveno das prprias classes para construir o mapeamento, tornando desnecessria a utilizao de arquivos externos, como XML, no Hibernate. Os controladores basicamente manipulam as solicitaes e preparam a resposta. Para criar um controlador em Grails basta criar uma classe cujo nome termine com Controller e salv-la no diretrio grails-app/controllers/.
27
Vises em Grails so tipicamente Groovy Server Pages (GSP) que so uma extenso de JSP, porm mais flexveis e convenientes para se trabalhar, mas Grails suporta ambos os tipos. Cada viso GSP tem acesso a um modelo que mapeado basicamente com chaves e valores que podem ser passados pelo controlador e usados na viso.
3.2 VALIDAO
3.2.1 JSF 2.0
JSF possui um amplo suporte para validao dos dados de entrada. possvel usar os validadores padres do JSF ou mtodos ou classes prprias para validao. Se o valor de um componente no for aceito, uma mensagem de erro gerada para esse componente especfico e o atributo da classe associado ao mesmo no modificado. As validaes do JSF so todas feitas do lado do servidor. Caso seja necessrio alguma validao do lado cliente necessrio que o desenvolvedor crie seus prprios validadores em JavaScript. A interface que define o modelo de validao do JSF a Validator. Os validadores padres do JSF 2.0 so: BeanValidator Delega a validao do bean para a Bean Validation API (JSR 303), que permite validar dados de forma gil e rpida atravs do uso de anotaes. Conforme Tosin (2010) essa API independe da camada da aplicao onde usada e da forma de programar (pode ser usada em aplicaes web e desktop) e no est atrelada ao mecanismo de persistncia usado. Outra grande vantagem da Bean Validation API possibilitar a validao de dados nas classes de domnio da aplicao, assim ao invs de verificar os dados nas diversas camadas o processo fica centralizado, pois os objetos destas classes normalmente trafegam entre as camadas da aplicao. A implementao de referncia da JSR 303 o Hibernate Validator, cujas anotaes disponveis esto descritas no Quadro 1.
28
DoubleRangeValidator Checa se o valor do componente correspondente est de acordo com o valor mnimo e mximo especificado. LengthValidator Checa o nmero de caracteres da String que representa o valor do componente associado. LongRangeValidator Checa se o valor do componente correspondente est de acordo com o valor mnimo e mximo especificado. MethodExpressionValidator Envolve um MethodExpression e realiza a validao atravs da execuo de um mtodo em um objeto identificado pelo MethodExpression. RegexValidator Checa o valor de acordo com uma expresso regular (que uma propriedade pattern). RequiredValidator Checa se o valor vazio. A exceo que lanada quando o mtodo validate() de uma classe de validao falha a ValidationException. A anotao @FacesValidator em uma classe a torna uma classe de validao.
Annotation @CreditCardNumber @Email @Length @NotBlank @NotEmpty @Range @ScriptAssert
Descrio Verifica se o elemento representa um nmero vlido de carto de crdito. Verifica se a string contm um e-mail com formato vlido. Verifica se a string est entre o valor mnimo e mximo definidos. Verifica se a string no vazia ou nula. Verifica se a string, collection, map ou array no nula ou vazia. Verifica se o elemento est no padro definido. Uma restrio de nvel da classe, que avalia uma expresso de script contra o elemento anotado. @URL Verifica se a string uma url vlida. Quadro 1 - Anotaes do Hibernate Validator Fonte: Adaptado de http://docs.jboss.org/hibernate/validator/4.1/api/.
3.2.2 Spring
No framework Spring pode-se criar uma classe para ser invocada pelo controlador para validar dados de formulrios. Essa classe deve ser concreta e implementar a interface org.springframework.validation.Validator. A interface Validator requer a implementao de dois mtodos:
29
1. boolean supports (Class<?> clazz) Esse mtodo verifica se a classe de validao pode validar instncias do parmetro clazz. Sua implementao geralmente consiste em:
return NomeClasse.class.isAssignableFrom(classe);
onde NomeClasse a classe ou superclasse da instncia atual do objeto a ser validado. 2. void validate(Object target, Errors errors) Esse mtodo valida o objeto target fornecido, que deve ser uma classe em que o mtodo supports retorne true (pode ser null). O parmetro errors pode ser usado para fornecer qualquer resultado de validao de erros (no pode ser null). Outra notvel classe de validao org.springframework.validation.ValidationUtils, que prov mtodos convenientes para invocar um Validator e rejeitar campos vazios.
3.2.3 Grails
Para validao de propriedades das classes de domnio do Grails so declaradas constraints usando blocos de cdigo esttico Groovy. As constraints disponveis na verso 1.3.7 do Grails esto representadas no Quadro 2. Exemplo de uma declarao de constraint em Groovy:
class Usuario { ... static constraints = { email (blank:false, email:true, unique:true) senha (blank:false, maxSize:12, minSize:6) nomeCompleto (blank:false, matches:"[a-zA-Z ]+", maxSize:50, minSize:6) CPF (blank:false, matches:"[0-9]+", size:11..11) dataNascimento (blank:false, max:new Date()) } }
Alm das constraints do Quadro 2 existem outras que afetam o scaffolding. Geralmente no uma boa prtica incluir informaes de interface de usurio no domnio, mas uma grande convenincia quando se usa a extenso do scaffolding do Grails. Essas constraints esto representadas no Quadro 3.
30
Constraint blank creditCard email inList matches max maxSize min minSize notEqual nullable range scale size unique url validator
Descrio Verifica se o valor da String no branco. Verifica se o valor da String um nmero de carto de crdito vlido. Verifica se o valor da String um endereo de e-mail vlido. Verifica se o valor da String est dentro de um intervalo ou conjunto de valores limitados. Verifica se o valor da String est de acordo com uma expresso regular. Assegura que um valor no excede o valor mximo informado. Assegura que o tamanho de um valor no excede o valor mximo informado. Assegura que um valor no inferior ao valor mnimo informado. Assegura que o tamanho de um valor no inferior ao valor mnimo informado. Assegura que uma propriedade no igual ao valor especificado. Permite que uma propriedade seja atribuda como null o valor default false para propriedade da classe de domnio. Usa um intervalo Groovy para assegurar que o valor de uma propriedade ocorre dentro de um intervalo especfico. Atribui a escala desejada para nmeros de ponto flutuante. Usa um intervalo Groovy para restringir uma coleo de nmeros ou o tamanho de uma String. Restringe uma propriedade como nica no nvel da base de dados. Verifica se o valor de uma String uma URL vlida. Adiciona uma validao customizada a um campo.
Exemplo login(blank:false) numCartao(creditCard:true) email(email:true) nome(inList:"Joe", "Fred", "Bob" ) login(matches:[a-zA-Z]+) idade(max:new Date()) preo(max:999F) filhos(maxSize:25) idade(min:new Date()) preo(min:0F) filhos(minSize:25) login(notEqual:Bob) idade(nullable:true) age(range:18..65) salary(scale:2) filhos(size:5..15) login(unique:true) homePage(url:true) teste(validator: {return (x > y})
Quadro 2 - Constraints do Grails Fonte: Adaptado de http://grails.org/doc/latest/ref/Constraints/Usage.html.
Descrio Boolean que determina se uma propriedade no scaffolding vista. O valor default true. Boolean que determina se uma propriedade pode ser editada nas vises do scaffolding. Se for false, no campo do formulrio associado exibido como somente leitura. format Especifica um formato de exibio para campos como datas. Por exemplo, yyyy-MM-dd. password Boolean que indica se um campo deve ser mostrado como password. Somente funciona com campos que normalmente podem ser exibidos como um campo de texto. widget Controla qual componente usado para mostrar a propriedade. Por exemplo, textArea ir forar o scaffolding a usar uma tag <textArea>. Quadro 3 - Constraints do Grails que afetam o scaffolding Fonte: Adaptado de http://grails.org/doc/latest/ref/Constraints/Usage.html.
Constraint display editable
31
3.3 LINGUAGEM JAVA X GROOVY
A linguagem Groovy tenta ser o mais natural possvel para desenvolvedores Java, entretanto existem algumas diferenas bsicas, conforme listado em sua documentao oficial: Importaes default. Os seguintes pacotes e classes so importados por default, sendo desnecessrio usar import explcito para utiliz-los: o java.io.* o java.lang.* o java.math.BigDecimal o java.math.BigInteger o java.net.* o java.util.* o groovy.lang.* o groovy.util.* == significa sempre igualdade. Em Java == significa igualdade para tipos primitivos e identidade para objetos. Em Groovy, para verificar identidade utilizado o mtodo is. Para verificar se uma varivel nula usa-se ==, como em Java. in uma palavra chave, no pode ser usada como varivel. Na declarao do contedo de arrays so utilizados colchetes ao invs de chaves. Exemplo:
int[] a = [1,2,3]
Existem mais formas de escrever um for loop. Exemplos:

for (int i=0; i < 10; i++){} //igual ao Java for (i in 0..10){} 10.times{}
Ponto e vrgula so opcionais. Apenas so necessrios pontos e vrgulas para separar sentenas escritas em uma mesma linha. A palavra-chave return opcional. O valor de retorno de um ltimo comando de um mtodo corresponde ao seu retorno, portanto desnecessrio escrever o return.
32
Todo cdigo que no estiver dentro de uma classe considerado um script. Um arquivo Groovy pode conter uma ou mais classes que no precisam ter o mesmo nome do arquivo que as contm. O arquivo pode conter cdigo de scripting alm das classes. possvel utilizar a palavra chave this ao invs de mtodos estticos. Mtodos e classes so pblicos por default. Classes internas (inner class) no so suportadas no momento. Na maioria dos casos so usadas closures para substitu-las. A clusula throws na assinatura de um mtodo no checada pelo compilador Groovy. Em Groovy no h diferena entre excees checadas (checked) e no checadas (unchecked). No ocorrem erros de compilao quando se usa membros no definidos ou so passados argumentos do tipo errado. Ao invs disse lanada a exceo MissingMethodException em tempo de execuo, pois Groovy uma linguagem dinmica. No Groovy no existem tipos primitivos, apenas objetos. Os tipos primitivos do Java so convertidos para suas respectivas classes encapsuladoras de forma transparente para o programador. Mtodos getters e setters criados de forma dinmica. Na declarao de beans em Groovy no necessrio criar os cdigos getters e setters, a menos que se queira sobrescrever um desses mtodos de forma customizada. Evoluo das expresses booleanas. Com essa evoluo, mostrada no Quadro 4, as expresses ficam mais simples, conforme o exemplo:
if (stringExemplo != null && !stringExemplo.isEmpty()) {...} //cdigo Java if (stringExemplo()) {} //cdigo Groovy
Instruo switch aceita qualquer objeto. Os comandos case aceitam qualquer objeto que implemente o mtodo isCase(), como detalhado no Quadro 5.
33
Tipo da Expresso Condio para ser verdadeira Boolean Verdadeira (true) Collection No vazia Character Valor diferente de zero CharSequence Tamanho > 0 Enumeration Ter mais elementos para enumerar Iterator Ter prximo elemento Number Valor double diferente de zero Map No vazio Matcher Ter ao menos uma correspondncia Object[] Tamanho > 0 Qualquer outro tipo No nulo Quadro 4 Tratamento de expresses booleanas Fonte: Adaptado de Seifeddine (2009).
Classe Condio para ser verdadeira Object a == b Class a instanceof b Collection b.contains(a) Range b.contains(a) Pattern b matches in a? String a == b Closure b.call(a) Quadro 5 Classes que implementam isCase(b) na GDK para switch(a) Fonte: Adaptado de Seifeddine (2009).
Alm de apresentar algumas diferenas em relao linguagem Java, Groovy possui alguns recursos extras, como: Closures. Uma closure em Groovy um pedao de cdigo que definido para ser executado mais adiante. Exemplo:
def imprimirSoma = {a, b -> print a+b} imprimirSoma(1,2) //imprime 3
O smbolo -> opcional para definies de menos de dois parmetros. Em closures de somente um parmetro pode ser usado o it:
def imprimir = {print it} imprimir("Testando clausula Groovy!")
Sintaxe nativa para listas e mapas. Suporte a Groovy Markup e GPath. Suporte nativo para expresses regulares. Interao de polimorfismo Tipos dinmicos e estticos so suportados, ento possvel omitir tipos de declaraes em mtodos, campos e variveis.
34
possvel incluir expresses dentro de strings. Muitos mtodos de ajuda foram includos na JDK. Sintaxe simples para escrita de beans e adio de eventos listeners.
Navegao segura usando o operador ?. para impedir que sejam lanadas
excees do tipo NullPointerException. Exemplo:

Pessoa pessoa = Pessoa.find("Maria") String cep = pessoa?.endereco?.cep
Neste caso a string CEP ser nula se pessoa ou endereo forem nulos e no ocorrer lanamento de NullPointerException. Operador Elvis. Consiste em um encurtamento do operador ternrio Java. Exemplo:
String nomePai = usuario.nomePai != null ? usuario.nomePai : "No consta"; //cdigo Java String nomePai = usuario.nomePai ?: No consta //cdigo Groovy
3.4 SUPORTE AO GROOVY
3.4.1 JSF 2.0
possvel utilizar a linguagem Groovy em aplicaes JSF. Para isto basta mudar o sufixo dos cdigos de .java para .groovy e utilizar um compilador Groovy para compila-los para um arquivo .class. JSF lida com arquivos .class, no importando como eles foram gerados.
3.4.2 Spring Web MVC
O Spring 3.0 suporta as linguagens dinmicas JRuby, Groovy e BeanShell. Para definir beans de cdigo dessas linguagens utilizada a tag <lang:language/> na configurao
35
do XML. No caso do Groovy o elemento utilizado <lang:groovy/>, conforme exemplo seguinte, disponvel na Documentao de Referncia do Spring 3.0 (Johnson et al., 2011).
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:lang="http://www.springframework.org/schema/lang" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/lang http://www.springframework.org/schema/lang/spring-lang-3.0.xsd">  <lang:groovy id="messenger" script-source="classpath:Messenger.groovy"> <lang:property name="message" value="I Can Do The Frug" /> </lang:groovy>  <bean id="bookingService" class="x.y.DefaultBookingService"> <property name="messenger" ref="messenger" /> </bean> </beans>
3.4.3 Grails
O framework Grails totalmente baseado na linguagem Groovy.
3.5 SUPORTE A AJAX
O uso de Asynchronous JavaScript and XML (Ajax) atualmente considerado essencial para desenvolver aplicaes web mais dinmicas, criativas e competitivas. A principal vantagem oferecida pelo Ajax a reduo de dados trafegados pela rede, evitando que o usurio precise aguardar a pgina ser recarregada a cada interao com o servidor.
36
3.5.1 JSF 2.0
JSF 2.0 possui suporte embutido a Ajax, com uma biblioteca JavaScript padro. A tag <f:ajax> utilizada para atribuir um comportamento Ajax a um componente. Exemplo:
<h:inputText value=#{usuarioBean.nome}> <f:ajax event=keyup/> </h:inputText>
Atributo disable event execute
Descrio Desabilita a tag se o valor for true O evento que dispara a requisio Ajax. Uma lista de componentes separados por espao que o JSF executa no servidor durante a chamada Ajax. Palavras chaves vlidas para o atributo execute so: @this, @form, @all, @none. O valor default @this. immediate Se o valor for true, JSF processa as entradas no incio do ciclo de vida. onerror Uma funo JavaScript que JSF invoca na chamada Ajax que resulta em um erro. onevent Uma funo JavaScript que JSF chama para eventos Ajax. Essa funo ser chamada trs vezes durante o ciclo de vida de uma chamada Ajax com sucesso: begin, complete, success. listener Faz a ligao com um mtodo public void processAjaxBehavior (javax.faces.event.AjaxBehaviorEvent event) throws javax.faces.event.AbortProcessingException. Com isso possvel executar um cdigo Java quando um evento qualquer disparado. render Uma lista de componentes separada por espao que JSF renderiza no cliente aps a chamada Ajax retornar do servidor. Pode-se usar as mesmas palavras chaves do atributo execute. O valor default @none. Quadro 6 Atributos suportados pela tag <f:ajax> Fonte: Adaptado de Geary, Horstmann (2010).
3.5.2 Spring
Spring 3.0 simplificou muitas tarefas, como invocao de mtodos assncronos e chamadas Ajax. Essa verso do Spring prov suporte oficial para Ajax remoto com JavaScript Object Notation (JSON) como parte do Spring MVC. Conforme Donald (2010), isso inclui suporte para gerar respostas JSON e ligar requisies JSON usando o modelo de programao @Controller do Spring MVC. Segundo Tarantelli (2002), JSON um formato leve para intercmbio de dados computacionais que se tornou uma alternativa para XML em Ajax, oferecendo como
37
vantagem o fato de ser muito mais fcil escrever um analisador JSON. Em JavaScript possvel analisar um arquivo JSON usando a funo eval(). As Figuras 4 e 5 mostram um exemplo de um formulrio que verifica se o nome preenchido pelo usurio em um campo est disponvel e caso no esteja exibe uma mensagem de erro e permanece desativado at que seja informado um nome disponvel. De acordo com a documentao de referncia do Spring Web Flow (Donald et al.), Spring Javascript prov algumas extenses simples do Spring MVC que fazem uso do Tiles para desenvolvimento em Ajax. A principal interface para integrao das bibliotecas Ajax com o Spring Web Flow a org.springframework.js.AjaxHandler. A
SpringJavascriptAjaxHandler a biblioteca padro, que capaz de detectar uma requisio Ajax submetida por uma API Spring JS do lado cliente e responder apropriadamente no caso em que um redirecionamento solicitado. Para integrar uma biblioteca Ajax diferente, um AjaxHandler customizado pode ser injetado no FlowHandlerAdapter ou FlowController.
Figura 4 Utilizao de JSON com o padro jQuery JavaScript para verificar disponibilidade de nome Fonte: Donald (2010)
Figura 5 Controlador Spring que informa ao cliente se o nome do usurio est disponvel Fonte: Donald (2010)
38
3.5.3 Grails
Grails possui suporte a Ajax atravs das tags: <g:remoteLink> - cria um link HTML que executa uma requisio e opcionalmente define a resposta em um elemento. Seus atributos esto descritos no Quadro 7. <g:formRemote> - cria uma tag de formulrio que utiliza uma uri remota para executar uma chamada ajax serializando os elementos do formulrio, submetendo como uma requisio normal caso javascript no seja suportado. Seus atributos esto descritos no Quadro 8. <g:submitToRemote> - cria um boto que submete o formulrio como uma chamada ajax serializando os campos em parmetros. Seus atributos esto descritos no Quadro 9. Para utilizar Ajax alm de inserir uma dessas tags para fazer o POST, deve ser adicionada a biblioteca na tag <head> da pgina: <g:javascript library=prototype/>. Prototype a biblioteca padro do Grails, mas podem ser utilizadas outras atravs da adio de plugins, como Yahoo UI, Dojo Toolkit, jQuery e Google Web Toolkit.
Atributo action (opcional) controller (opcional) id (opcional) fragment (opcional) mapping (opcional) params (opcional) update (opcional)
before (opcional) after (opcional) asynchronous (opcional) method (opcional) O mtodo a ser usado para executar a chamada (padro para post). Quadro 7 Atributos suportados pela tag <g:remoteLink> Fonte: Adaptado de http://www.grails.org/doc/latest/ref/Tags/remoteLink.html.
Descrio Nome da action a ser usada no link, se no for especificada a action default ser usado. Nome do controlador a ser usado no link, se no especificado ser usado o controlador atual. Id utilizado no link. O fragmento do link (ncora) a ser usado. O nome da URL mapping a ser usado para reescrever o link. Um map contendo os parmetros da requisio. Um map contendo os elementos para atualizao para estados de sucesso (success) ou falha (failure), ou uma string com o elemento para atualizao nos casos em que falhas de eventos seriam ignoradas. A funo javascript a ser chamada antes da chamada da funo remota. A funo javascript a ser chamada aps a chamada funo remota. Indica se a chamada deve ser feita de maneira assncrona ou no (o padro true).
39
Atributo name (obrigatrio) url (obrigatrio) id (opcional) action (opcional) controller (opcional) update (opcional)
before (opcional) after (opcional) asynchronous (opcional) method (opcional) O mtodo a ser usado para executar a chamada (padro para post). Quadro 8 Atributos suportados pela tag <g:formRemote> Fonte: Adaptado de http://www.grails.org/doc/latest/ref/Tags/formRemote.html.
Descrio O nome do formulrio. Este atributo ser atribudo ao atributo id se no estiver presente, caso contrrio, o valor desse atributo ser omitido A url para submeter como um map (contendo valores para controlador, action, id e parmetros) ou uma string URL. O id do formulrio renderizado sada. Se id no est definido, o valor do nome ser atribudo. A ao a ser executada como um retorno, se no estiver especificada o padro a url. Nome do controlador a ser usado no link, se no especificado ser usado o controlador atual. Um map contendo os elementos para atualizao para estados de sucesso (success) ou falha (failure), ou uma string com o elemento para atualizao nos casos em que falhas de eventos seriam ignoradas. A funo javascript a ser chamada antes da chamada da funo remota. A funo javascript a ser chamada aps a chamada funo remota. Indica se a chamada deve ser feita de maneira assncrona ou no (o padro true).
Atributo url (opcional) update (opcional)
before (opcional) after (opcional) asynchronous (opcional) method (opcional) O mtodo a ser usado para executar a chamada (padro para post). Quadro 9 Atributos suportados pela tag <g:submitToRemote> Fonte: Adaptado de http://www.grails.org/doc/latest/ref/Tags/submitToRemote.html.
Descrio A url para submeter como um map (contendo valores para controlador, action, id e parmetros) ou uma string URL. Um map contendo os elementos para atualizao para estados de sucesso (success) ou falha (failure), ou uma string com o elemento para atualizao nos casos em que falhas de eventos seriam ignoradas. A funo javascript a ser chamada antes da chamada da funo remota. A funo javascript a ser chamada aps a chamada funo remota. Indica se a chamada deve ser feita de maneira assncrona ou no (o padro true).
Exemplos:
<g:remoteLink action="listarUsuarios" id="1" update="success" params="[sortBy:'nome',offset:offset]">Listar usuario 1</g:remoteLink> <g:formRemote name="meuForm" on404="alert('no encontrado!')" update="testeFormRemote" url="[ controller: 'usuario', action:'listarUsuarios' ]"> Usuario Id: <input name="id" type="text"></input> </g:formRemote> <div id="testeFormRemote"> Essa div exibida com o resultado da ao listarUsuarios</div> <g:form action="listarUsuarios"> Nome: <input name="nome" type="text"></input> <g:submitToRemote update="testeSubmitToRemote" /> </g:form> <div id="testeSubmitToRemote">Essa div exibida com o resultado da ao listarUsuarios</div>
40
3.6 POPULARIDADE
Para determinar o interesse por cada um desses frameworks foi utilizada a ferramenta Google Trends (disponvel no endereo http://www.google.com/trends), que verifica a frequncia de pesquisas de termos. Foram utilizados os seguintes termos para pesquisar os frameworks: JSF: (javaserver faces) | (java server faces) | jsf Grails: (groovy on rails) | grails Spring Web MVC: (spring web mvc) | (spring web) | (spring mvc) No foi possvel pesquisar pelo termo spring por ser muito comum. Na Figura 6 pode-se observar que o JSF , sem dvidas, o framework mais popular. Foi realizada uma nova pesquisa sem o JSF para comparar a popularidade dos frameworks Grails e Spring Web MVC. Como se pode notar na Figura 7, atualmente a popularidade de ambos os frameworks est muito prxima, sendo que o Grails est com uma pequena vantagem.
Figura 6 Grfico de buscas realizadas dos frameworks JSF, Grails e Spring Web MVC
41
Figura 7 Grfico de buscas realizadas dos frameworks Grails e Spring Web MVC
3.7 VAGAS DE EMPREGO
Foi
realizada
uma
pesquisa
de
vagas
disponveis
no
site
da
Catho
(www.catho.com.br) que exigiam conhecimento de um dos trs frameworks apresentados, na data de 22 de junho de 2011. Das 270 vagas oferecidas, 90% exigiam conhecimento em JSF, conforme representado na Figura 8.
Figura 8 Empregos disponveis no site da Catho para cada framework
42
3.8 LIVROS DISPONVEIS
Para verificar a quantidade de livros disponveis para cada framework foi realizada uma busca no site http://books.google.com. Foram pesquisados livros com idioma ingls, utilizando os seguintes critrios: JSF: intitle:java server faces | intitle:javaserver faces | intitle:jsf - foram filtrados os resultados que no se referiam ao framework jsf. Grails: intitle:grails foram filtrados os resultados que no se referiam ao framework grails. Spring Web MVC: framework web mvc intitle:spring foi preciso restringir a pesquisa, pois o termo spring muito comum, tornando invivel filtrar os resultados manualmente. Os resultados obtidos esto representados na Figura 9.
Figura 9 Literatura disponvel para cada framework
43
3.9 FRUNS DE DISCUSSO
Os frameworks Spring e Grails possuem fruns brasileiros exclusivos para discutir assuntos sobre seus contedos, disponveis respectivamente nos endereos
http://www.springbrasil.com.br/forum e http://www.grailsbrasil.com.br. Para esclarecer dvidas do JavaServer Faces o frum mais popular o GUJ, disponvel em http://www.guj.com.br/forums/list.java.
3.10 ARTIGOS PUBLICADOS
Para comparar a quantidade de artigos publicados referentes a cada framework foi realizada uma pesquisa no site DevMedia, que o maior site para desenvolvedores de softwares em lngua portuguesa e est disponvel no endereo http://www.devmedia.com.br. Para o framework JSF foi pesquisada somente a verso 2.0, ainda assim o nmero de publicaes foi bastante superior aos demais frameworks, conforme pode ser observado na Figura 10.
Figura 10 Artigos disponveis para cada framework no DevMedia
44
4 SISTEMA DE CONTROLE FINANCEIRO
Para verificar na prtica algumas das caractersticas comparadas no captulo anterior, foi desenvolvido um prottipo de um sistema de controle financeiro pessoal em cada um dos frameworks. Foram implementadas basicamente operaes CRUD e validaes. As classes e atributos do sistema esto descritos no diagrama de classes da Figura 11. Para melhor compreenso do sistema, as classes esto descritas a seguir: Usuario: representa os usurios do sistema. Categoria: crdito e dbito. Grupo: moradia, lazer, alimentao, educao... Conta: aluguel, financiamento de imvel, ingresso de cinema, compras no supermercado, mensalidade do curso ingls... Lanamento: registro de dbitos ou crditos de uma determinada conta realizados pelo usurio.
Figura 11 Diagrama de Classes do Sistema de Controle Financeiro
45
Os casos de desse sistema esto representados na Figura 12.
Figura 12 Diagrama de Casos de Usos do Sistema de Controle Financeiro
A ferramenta NetBeans IDE 7.0 foi utilizada para desenvolvimento das trs aplicaes. No prottipo em Grails foi utilizada a linguagem Groovy e nos demais foi utilizada a linguagem Java. Para a base de dados foi utilizado o banco de dados PostgreSQL e o framework Hibernate. No houve preocupao em criar a mesma interface para todas as aplicaes, pois o objetivo principal avaliar a facilidade oferecida por cada tecnologia. Na aplicao em Grails, por exemplo, foi utilizada a interface padro, criada de forma automtica.
4.1 PROTTIPO DESENVOLVIDO EM JSF 2.0
Na aplicao em JSF 2.0 as classes de domnio so criadas como POJOs (Plain Old Java Object) com as anotaes do Hibernate, conforme exemplificado na Figura 13. Para a comunicao com o banco de dados foram criadas classes DAO (Data Access Object), como representado na Figura 14. A SessionFactory utilizada pelo Hibernate na classe DAO definida na classe HibernateUtil (Figura 15). A conexo com o banco de dados configurada
46
no arquivo hibernate.cfg.xml. Esse arquivo deve conter ainda o mapeamento das classes, conforme Figura 16.
Figura 13 Classe de domnio Categoria do prottipo em JSF 2.0
47
Figura 14 Classe CategoriaDaoImp do prottipo em JSF 2.0
48
Figura 15 Classe HibernateUtil do prottipo em JSF 2.0
Figura 16 Arquivo hibernate.cfg.xml do prottipo em JSF 2.0
49
As classes controladoras so criadas atravs da anotao @ ManagedBean e contm os mtodos necessrios para realizar a comunicao da camada de viso com o banco de dados, realizando as operaes requisitadas nas pginas JSF e encaminhando o usurio para a pgina adequada. As Figura 17 e 18 representam uma dessas classes criadas no prottipo.
Figura 17 Classe CategoriaBean do prottipo em JSF 2.0 (parte 1)
50
Figura 18 Classe CategoriaBean do prottipo em JSF 2.0 (parte 2)
A viso implementada atravs de pginas xhtml. Foi utilizada a biblioteca de componentes JSF PrimeFaces para criar interfaces mais elegantes (Figura 19). Essa biblioteca est disponvel no endereo http://www.primefaces.org/downloads.html, basta adicion-la s bibliotecas do projeto e declar-la na pgina (xmlns:p="http://primefaces.prime.com.tr/ui").
51
Figura 19 Interface do prottipo em JSF 2.0 criada com PrimeFaces
O arquivo web.xml do prottipo foi configurado como mostrado na Figura 20. A validao no framework JSF pode ser feita na prpria pgina, conforme exemplificado no cdigo seguinte, ou atravs de anotaes do Hibernate Validator, como mostrado nas Figuras 21 e 22.
<h:inputText id="desc" value="#{categoriaBean.categoria.descricao}" required="true" requiredMessage="o campo descrio obrigatrio."/>
52
Figura 20 Arquivo web.xml do prottipo em JSF 2.0
Figura 21 Validao dos atributos da classe Usuario utilizando anotaes do Hibernate Validator
53
Figura 22 Mensagens exibidas pelo Hibernate Validator
O Apndice A contm o cdigo fonte da pgina xhtml da Figura 22.
4.2 PROTTIPO DESENVOLVIDO EM SPRING WEB MVC
Na aplicao em Spring Web MVC as classes de domnio (entidades) so criadas da mesma maneira que na aplicao em JSF. Tambm foi utilizada a validao do Hibernate Validator, portanto essas classes ficaram exatamente iguais s do prottipo anterior. Para o acesso aos dados foram criadas classes DAOs conforme a Figura 23. As classes de controle tratam as requisies do cliente, controlando o fluxo a ser percorrido na chamada de uma determinada viso. A Figura 24 mostra a implementao da classe CategoriaController. As variveis inclusas no ModelMap podem ser acessadas pela viso da seguinte maneira, por exemplo: <c:forEach items="${categorias}" var="categoria"> As propriedades de conexo com o banco de dados e do Hibernate foram definidas no arquivo config.properties, conforme Figura 25. O arquivo applicationContext.xml, exibido na Figura 26, contm mapeamentos Spring que configuram o contexto mnimo da aplicao, como hibernate session factory bean, data source, transaction manager, etc.
54
Para definir o caminhos das vises e a tecnologia utilizada no projeto Spring Web MVC utilizado o arquivo dispatcher-servlet.xml (que trata-se de um Spring DispatcherServlet, que pode ter qualquer outro nome que ser seguido do -servlet no arquivo xml), conforme exemplificado na Figura 27. Esse servlet definido no arquivo web.xml, juntamente com os demais servlets utilizados no projeto (Figura 28). Como boa prtica recomendada pelo Spring, as pginas devem ficar dentro do diretrio WEB-INF para que no possam ser acessadas diretamente atravs da URL. Os Apndices B, C e D contm algumas das pginas criadas neste prottipo.
Figura 23 Classe CategoriaDaoImp do prottipo em Spring Web MVC
55
Figura 24 Classe CategoriaController do prottipo em Spring Web MVC
56
Figura 25 Arquivo config.properties do prottipo em Spring Web MVC
Figura 26 Arquivo applicationContext.xml do prottipo em Spring Web MVC
57
Figura 27 Arquivo dispatcher-servlet.xml do prottipo em Spring Web MVC
Figura 28 Arquivo web.xml do prottipo em Spring Web MVC
58
4.3 PROTTIPO DESENVOLVIDO EM GRAILS
Para desenvolver essa aplicao em Grails inicialmente foram criadas as classes de domnio, com o mapeamento e validao dos atributos, conforme Figura 29. No necessrio criar atributos id, pois estes so gerados automaticamente pelo Grails.
Figura 29 Classe de domnio Usuario do prottipo em Grails
As classes de controle e as pginas de visualizao foram criadas pelo Grails, atravs da seleo das classes de domnio, clique do mouse com o boto direito e clique na opo Gerar tudo, como mostrado na Figura 30. Para cada classe so geradas as pginas de cada operao CRUD, nomeadas como create.gsp, edit.gsp, list.gsp e show.gsp (conforme exemplificado nos Apndices E, F, G e H) e armazenadas em uma pasta com o nome da classe, dentro do diretrio view (exibido como Visualizaes e Layouts no Netbeans). Os controladores so gerados com o nome da classe adicionado da palavra Controller, dentro da pasta controllers (exibida como Controladores no Netbeans).
59
A pgina inicial que foi gerada automaticamente est representada na Figura 31. Ela contm um link para cada um dos controladores do sistema.
Figura 30 Opo para gerar controles e vises do sistema automaticamente em Grails
Figura 31 Pgina inicial do sistema gerada automaticamente pelo framework Grails
60
Clicando em um dos controladores, UsuarioController, por exemplo, aberta uma pgina que lista os usurios cadastrados e apresenta link para incluso de usurio (Figura 32). Nesse exemplo no desejvel que a senha seja exibida na listagem, para isso basta editar a pgina list.gsp dentro da pasta usuario e remover as linhas de cdigo que exibem esse atributo. Clicando no Id de um usurio listado, aberta uma pgina com as informaes desse usurio e opes para edit-lo ou exclu-lo. Os campos do formulrio de incluso e edio j so criados de acordo com o tipo (o campo senha no ir exibir os caracteres digitados e o de data de nascimento j traz as comboboxs para escolha do dia, ms e ano, por exemplo) e com a validao definidos na classe de domnio, como exemplificado na Figura 33.
Figura 32 Pgina de listagem de usurio gerada automaticamente pelo framework Grails
Figura 33 Pgina de incluso de usurio gerada automaticamente pelo framework Grails
61
Nas classes que possuem relacionamento, o combobox da pgina exibe o id, para que exiba outro campo necessrio incluir o atributo optionValue indicando a informao a ser recuperada da classe, conforme cdigo seguinte, que tem como resultado o contedo do campo Grupo exibido na Figuras 34.
<g:select name="grupo.id" from="${Grupo.list()}" optionKey="id" value="${contaInstance?.grupo?.id}" optionValue="${{it.descricao}}"
/>
Figura 34 Exibio da descrio do grupo na combobox
At a verso 1.4.0.M1 (a mais recente at o momento), o arquivo de propriedades de mensagens (messages_pt_BR.properties, dentro da pasta i18n, exibida como Pacotes de Mensagens no NetBeans) ainda no vem com todas as mensagens utilizadas no sistema, por isso as tela so geradas com vrias palavras em ingls. Para que isso no ocorra, basta copiar as demais mensagens do arquivo messages.properties para o messages_pt_BR.properties e traduzi-las. As pginas e controladores gerados automaticamente podem ser alterados para customizao do sistema. Anteriormente, se uma pgina era alterada e precisasse ser gerada novamente devido a alguma modificao na classe era necessrio refazer as alteraes de layout. A partir da verso 1.4.0.M1 se tornou possvel a customizao dos templates gerados pelo Grails. Para isso deve-se executar o comando grails install-templates na pasta onde se encontra o projeto. Esse comando ir criar uma pasta templates no diretrio src, permitindo que o usurio altere o que desejar. Dessa forma, por exemplo, as pginas geradas pelo scaffolding seguiro o padro definido pelo usurio.
62
Inicialmente os dados inseridos no sistema so armazenados em memria. Para integrar a aplicao com o PostgreSQL necessrio adicionar o driver da verso do banco de dados utilizada na pasta lib (exibida no NetBeans como Bibliotecas) e alterar no arquivo DataSource.groovy (dentro da pasta conf, exibida como Configurao no NetBeans) os atributos driverClassName, username, password e url, conforme exemplificado na Figura 35. Como o Grails utiliza o GORM, que encapsula o Hibernate, por default as operaes executadas pelo banco no so exibidas. Caso o desenvolvedor deseje visualiz-las basta acrescentar a linha logSql = true. As tabelas podem ser geradas pela aplicao se o valor do atributo dbCreate for definido como create ou create-drop. O script da tabela gerada para a classe Usuario est exibido na Figura 36. Na classe groovy possvel atribuir valores a propriedades de uma classe a partir de algum evento do banco de dados. Nesse prottipo foram utilizados os mtodos beforeInsert() e beforeUpdate() para definir as datas de insero e alterao de lanamentos, conforme exemplificado na Figura 37.
63
Figura 35 Configurao do arquivo dataSource para integrao com o PostgreSQL
Figura 36 Script gerado automaticamente para criao da tabela usurio
64
Figura 37 Utilizao dos mtodos beforeInsert() e beforeUpdate()
65
5 CONSIDERAES FINAIS
A utilizao dos frameworks facilita muito o desenvolvimento do software, permitindo que sejam construdas aplicaes muito mais robustas, com maior qualidade e em menor tempo, o que essencial para a exigncia e competitividade existentes no mercado de trabalho. JSF 2.0, Spring Web MVC e Grails, conforme demonstrado nesse trabalho, so frameworks fceis de ser utilizados e que oferecem muitos recursos ao desenvolvedor. JSF definido como o framework padro pela Oracle e pela JCP. construdo sob o conceito de componentes, que so a base para a construo da interface com o usurio, e dirigido a eventos. Tem como principais objetivos a facilidade de utilizao. Possui vrios pontos de extenso (como conversores, validadores e listeners) e componentes prontos. Dos frameworks apresentados o mais utilizado no mercado. Spring Web MVC um mdulo do projeto Spring Framework, cujas principais vantagens so o uso do IoC do Spring e a facilidade de renderizao de diversos tipos de sada, como JSP, Tiles, Velocity, Freemaker, Excel e PDF. O framework Grails uma oportunidade de melhorar a produtividade mantendo a plataforma Java, apenas migrando para a linguagem Groovy. Essa linguagem possui sintaxe reduzida e clara e maior poder funcional. Por ser muito semelhante Java, facilmente aprendida por estes desenvolvedores. O uso dos frameworks Hibernate e Spring torna-se muito mais simples com Grails, pois no necessria nenhuma configurao para utiliz-los. As maiores vantagens desse framework so simplificar o aprendizado e reduzir a complexidade de implementao, reduzindo o tempo de desenvolvimento consideravelmente. Os trs frameworks so excelentes. Eles possuem muitas caractersticas em comum e tambm algumas diferenas, resumidas no Quadro 10. A escolha de qual deles utilizar
depender muito do tipo de aplicao a ser desenvolvida. Dependendo do projeto pode ser interessante at mesmo combinar o uso de mais de um framework. No desenvolvimento dos prottipos foi possvel verificar algumas dificuldades que podero ser enfrentadas pelos desenvolvedores: Spring Web MVC a configurao de arquivos bastante trabalhosa (so necessrios vrios arquivos XML, com cabealhos bem extensos), possibilitando a ocorrncia de erros cujas causas so difceis de serem detectadas.
66
JSF para os desenvolvedores habituados a trabalhar com frameworks baseados em aes pode ser um pouco difcil mudar o pensamento para desenvolvimento baseado em componentes. Grails foi o que se mostrou mais simples e fcil de ser utilizado, exigindo menos esforo e tempo de programao para atingir o mesmo resultado dos demais frameworks. As principais justificativas para isso so: as classes Groovy serem bem mais simples e compactas do que as classes Java e no ser necessrio configurar arquivos XML e nem acrescentar arquivos jar (o nico necessrio foi o driver do PostgreSQL), o que torna o aprendizado muito mais fcil, pois evita grande parte dos erros e dificuldades causados por essas etapas no desenvolvimento com JSF ou Spring Web MVC. A Tabela 1 demonstra a diferena entre quantidade de linhas necessrias para implementao do prottipo em cada um dos frameworks. No foram comparadas as quantidades de linhas das pginas porque no foi utilizado o mesmo padro, o que prejudicaria a anlise do resultado. Como sugesto de trabalhos futuros esto concluir o desenvolvimento dos prottipos, adicionando novas funcionalidades para possibilitar a utilizao de todos os recursos demonstrados nesse trabalho e incluir mais frameworks na comparao, como VRaptor, Mentawai e Wicket.
Caractersticas Ajax Annotations Baseado em CoC Curva de Aprendizado DRY Free Front-Controller IoC Linguagem MVC Scaffolding
JSF 2.0 Automtico Sim Componentes based) Configurao Curta
(component-
Spring Web MVC Automtico Sim Ao (action-based) Configurao Mdia Sim Sim Sim Sim Java Sim O scaffolding pode ocorrer a partir de uma base de dados, Entidades JPA ou Java Beans. Sim um mdulo do Spring Sim Sim
Grails Automtico Sim Ao (action-based) Conveno Muito curta Sim Sim Sim Sim Groovy Sim Classes de controle, pginas GSP e tabelas podem ser geradas a partir das classes de domnio. Sim Sim No Sim
Sim Sim Sim Sim Java Sim Classes de domnio podem ser geradas a partir de tabelas e pginas JSF geradas a partir das classes de domnio. Suporte a JSF Suporte a Spring Sim Usa XML Sim Validao Sim Quadro 10 Comparao entre os frameworks
67
Tabela 1 Linhas de cdigo do prottipo de cada um dos frameworks Tipo de arquivo Classes de Controle Classes DAO Classes de Domnio Arquivos XML Total JSF 2.0 394 233 227 79 933 Spring Web MVC 215 165 227 126 733 Grails 315 0 47 0 362
68
REFERNCIAS
CAELUM, Ensino e Inovao. FJ-21 Java para desenvolvimento web. Disponvel em: <http:// www.caelum.com.br/apostilas/>. Acesso em: 16 abr. 2011.
COAD, Peter. Object-oriented patterns. Communications of the ACM, V. 35, n 9, p. 152159, 1992.
CODEHAUS FOUNDATION. Groovy. An agile dynamic language for the Java Platform. 2011. Disponvel em: <http://groovy.codehaus.org/>. Acesso em: 10 maio 2011.
DONALD, Keith. Ajax simplifications in Spring 3.0. Springsource, 2010. Disponvel em: <http://blog.springsource.com/2010/01/25/ajax-simplifications-in-spring-3-0/>. Acesso em: 31 maio 2011.
DONALD, Keith et al. Spring Web Flow Reference Guide. Disponvel em: <http://static.springsource.org/spring-webflow/docs/2.0.x/reference/html/index.html>. Acesso em: 01 jun. 2011.
GEARY, David; HORSTMANN, Cay. Core JavaServer Faces. Ann Arbor, Michigan: Prentice Hall, 2010.
GONCALVES, Edson. Desenvolvendo aplicaes web com JSP, Servlets, Java Server Faces, Hibernate, EJB3 Persistence e Ajax. Rio de Janeiro: Editora Cincia Moderna Ltda., 2007.
HEMRAJANI, Anil. Agile Java development with Spring, Hibernate and Eclipse. Sams Publishing, 2006.
INFONOVA. Agile web development with Groovy & Grails. Bearing Point, Inc., 2008. Disponvel em: < http://pt.scribd.com/doc/14801783/Agile-Web-Development-with-GroovyGrails>. Acesso em: 09 maio 2011.
JBOSS COMMUNITY. Hibernate. Disponvel em: <http://www.hibernate.org/>. Acesso em: 12 jun. 2011.
69
JOHNSON, Ralph E.; WOOLF, B. Type Object. In: Martin, R.C.; Riehle, D.; Buschmann, F. Pattern languages of Program Design 3. Reading-MA, Addison-Wesley, 1998, p. 4765.
JOHNSON, Rod et al. Reference Documentation Spring Framework 3.0. 2011. Disponvel em: <http://static.springsource.org/spring/docs/3.1.0.M1/spring-framework-reference/pdf/ spring-framework-reference.pdf>. Acesso em: 07 maio 2011.
MACHACEK, Jan; VUKOTIC, Aleksa; CHAKRABORTY, Anyrvan; DITT, Jessica. Pro Spring 2.5. Rio de Janeiro: Editora Cincia Moderna Ltda., 2009.
MACHADO, Erich. Inverso de controle. Blog da Locaweb, 2008. Disponvel em: <http://blog.locaweb.com.br/ tecnologia/inversao-de-controle/>. Acesso em: 14 maio 2011.
NUNES, Vinny; Magalhes, Eder. Aprendendo JSF 2.0 com ScrumToys. Java Magazine, Edio 78, Ano VII (2010). Disponvel em: <http://www.devmedia.com.br/post-16559-JSF-20.html>. Acesso em: 28 abr. 2011.
ORACLE. The Java EE 6 Tutorial. 2011. Disponvel em: <http://download.oracle.com/ javaee/6/tutorial/doc/ bnaph.html>. Acesso em: 07 maio 2011.
PITANGA, Talita. JavaServer Faces: A mais nova tecnologia Java para desenvolvimento WEB. Disponvel em: <http://www.guj.com.br/content/articles/jsf/jsf.pdf>. Acesso em: 30 abr. 2011.
SAAB, Felipe N. Spring Framework Parte 5 Spring Web MVC. Java Simples, 2011. Disponvel em: < http://www.javasimples.com.br/spring-2/spring-framework-parte-5-springweb-mvc/>. Acesso em: 30 abr. 2011.
SEIFEDDINE, Mohamed. Introduction to Groovy and Grails. 2009. Disponvel em: < http://www.opensourceconnections.com/wp-content/uploads/2010/01/Introduction_to_ Groovy_and_Grails.pdf>. Acesso em: 17 abr. 2011.
SINGH, I. et al. Designing Enterprise Applications with the J2EE Platform. Second Edition. 2nd ed. New Jersey, USA: Addison-Wesley, 2002.
SUBRAMANIAM, Venkat. Programming Groovy. Dynamic Productivity for the Java Developer. The Pragmatic Programmers, 2008.
70
SUN MICROSYSTEMS. JavaBeans. 1997. Disponvel em: <http://www.oracle.com/ technetwork/java/javase/documentation/spec-136004.html>. Acesso em: 01 jun. 2011.
TARANTELLI, Renato. JSON. World of Bit, 2002. Disponvel <http://worldofbit.com/wob/programacao/json.html>. Acesso em: 22 out. 2011.
em:
TORSTEN. Programao orientada a aspectos. 2011. Disponvel em: <http://www.inf.pucminas.br/professores/torsten/aulas/aula06.html>. Acesso em: 15 maio 2011.
TOSIN, Carlos E. S. Conhecendo o Hibernate Validator. Java Magazine, Edio 83, Ano VII, p110, 2010.
WEISSMANN, Henrique L. Grails: um guia rpido e indireto. Disponvel em: <http://www. itexto.net/devkico/?page_id=220>. Acesso em: 16 abr. 2011.
71
APNDICES
APNDICE A Pgina gerenciaUsuario.xhtml do prottipo em JSF 2.0
<?xml version='1.0' encoding='UTF-8' ?> <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> <html xmlns="http://www.w3.org/1999/xhtml" xmlns:h="http://java.sun.com/jsf/html" xmlns:f="http://java.sun.com/jsf/core" xmlns:p="http://primefaces.prime.com.tr/ui"> <h:head> <title>Controle Financeiro</title> </h:head> <h:body> <p:growl id="aviso" life="10000"/> <p:layout fullPage="true"> <p:layoutUnit position="left" width="200" header="Atividades" resizable="true" closable="true" collapsible="true"> <h:form prependId="false"> <p:commandLink value="Gerenciar Categoria" action="GerenciarCategoria" actionListener="#{categoriaBean.gerenciarCategoria}"/> <br></br> <p:commandLink value="Gerenciar Conta" action="GerenciarConta" actionListener="#{contaBean.gerenciarConta}"/> <br></br> <p:commandLink value="Gerenciar Grupo" action="GerenciarGrupo" actionListener="#{grupoBean.gerenciarGrupo}"/> <br></br> <p:commandLink value="Gerenciar Lanamento" action="GerenciarLancamento" actionListener="#{lancamentoBean.gerenciarLancamento}"/>
72
</h:form> </p:layoutUnit> <p:layoutUnit position="center"> <h1>Controle Financeiro</h1> <br/> <h:form prependId="false"> <p:commandLink value="Novo Usurio" actionListener="#{usuarioBean.prepararAdicionar}" update="infosUsuario" oncomplete="dialogUsuario.show()"/> <br/><br/> <p:dataTable id="tabela" var="usuario" value="#{usuarioBean.listaUsuarios}"> <p:column> <f:facet name="header"> <h:outputText value="Nome"/> </f:facet> <h:outputText value="#{usuario.nome}" /> </p:column> <p:column> <f:facet name="header"> <h:outputText value="E-mail"/> </f:facet> <h:outputText value="#{usuario.email}" /> </p:column> <p:column> <f:facet name="header"> <h:outputText value="CPF"/> </f:facet> <h:outputText value="#{usuario.cpf}" /> </p:column> <p:column> <f:facet name="header"> <h:outputText value="Data Nascimento"/> </f:facet> <h:outputText value="#{usuario.dataNascimento}" /> </p:column> <p:column> <f:facet name="header"> <h:outputText value="Alterar"/> </f:facet> <p:commandLink actionListener="#{usuarioBean.prepararAlterar}" update="infosUsuario" oncomplete="dialogUsuario.show()">
73
<h:graphicImage url="/images/editar.png" styleClass="imagem" style="cursor:pointer; border-width:0px;"/> </p:commandLink> </p:column> <p:column> <f:facet name="header"> <h:outputText value="Excluir"/> </f:facet> <p:commandLink action="#{usuarioBean.excluir}"> <h:graphicImage url="/images/delete.png" styleClass="imagem" style="cursor:pointer; border-width:0px;"/> </p:commandLink> </p:column> </p:dataTable> </h:form> </p:layoutUnit> </p:layout> <p:dialog header="Usuario" widgetVar="dialogUsuario" resizable="false" modal="true" showEffect="slide" width="500"> <h:form prependId="false"> <h:panelGrid id="infosUsuario" columns="2" style="margin-bottom:10px"> <h:outputLabel for="nome" value="Nome:" /> <h:inputText id="nome" value="#{usuarioBean.usuario.nome}"/> <h:outputLabel for="email" value="E-mail:" /> <h:inputText id="email" value="#{usuarioBean.usuario.email}"/> <h:outputLabel for="senha" value="Senha:" /> <h:inputSecret id="senha" value="#{usuarioBean.usuario.senha}"/> <h:outputLabel for="cpf" value="CPF:" /> <h:inputText id="cpf" value="#{usuarioBean.usuario.cpf}"/> <h:outputLabel for="nasc" value="Data Nascimento:" /> <h:inputText id="nasc" value="#{usuarioBean.usuario.dataNascimento}"> <f:convertDateTime type="date" dateStyle="short" pattern="yyyy/MM/dd"/> </h:inputText> <p:commandButton update="aviso, tabela" oncomplete="sucesso(xhr, status, args)" actionListener="#{usuarioBean.salvar(actionEvent)}" value="Salvar"/> </h:panelGrid> </h:form> </p:dialog>
74
<script type="text/javascript"> function sucesso (xhr, status, args){ if(args.sucesso == true) { dialogCategoria.hide(); } } </script> </h:body> </html>
APNDICE B Pgina listarCategorias.jsp do prottipo em Spring Web MVC
<%@ <%@ <%@ <%@ <%@
taglib taglib taglib taglib taglib
prefix="spring" uri="http://www.springframework.org/tags"%> prefix="form" uri="http://www.springframework.org/tags/form"%> prefix="c" uri="http://java.sun.com/jsp/jstl/core"%> prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt"%> prefix="fn" uri="http://java.sun.com/jsp/jstl/functions"%>
<html> <head> <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> <style media="screen"> @import url("<c:url value="/static/styles/style.css"/>"); </style> <title>Lista de Categorias</title> </head> <body> <div> <div id="menu">
75
<%@ include file="menu.jsp" %> </div> <div id="main"> <div> <c:if test="${not empty categorias}"> <table width="600px"> <tr> <td><b>Id</b></td> <td><b>Descrio</b></td> <td><b>Alterar</b></td> <td><b>Excluir</b></td> </tr> <c:forEach items="${categorias}" var="categoria"> <c:url var="url" value="/categoria/${categoria.id}" /> <tr> <td>${categoria.id}</td> <td>${categoria.descricao}</td> <td> <form:form action="${url}/form" method="GET"> <input alt="Alterar Categoria" src="<c:url value="/static/images/editar.png"/>" title="Alterar Categoria" type="image" value="Alterar Categoria"/> </form:form> </td> <td> <form:form action="${url}" method="DELETE"> <input alt="Excluir Categoria" src="<c:url value="/static/images/delete.png"/>" title="Excluir Contato" type="image" value="Excluir Categoria"/> </form:form> </td> </tr> </c:forEach> </table> </c:if> <c:if test="${empty categorias}">No h categorias cadastradas.</c:if> </div> </div> </div> </body> </html>
76
APNDICE C Pgina criarCategoria.jsp do prottipo em Spring Web MVC
<%@ <%@ <%@ <%@ <%@
prefix="spring" uri="http://www.springframework.org/tags"%> prefix="form" uri="http://www.springframework.org/tags/form" %> prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %> prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> <style type="text/css" media="screen"> @import url("<c:url value="/static/styles/style.css"/>"); </style> <title>Criar Categoria</title> </head> <body> <div id="wrap"> <div id="menu"> <%@ include file="menu.jsp" %> </div> <div id="main"> <div id="body"> <c:url var="url" value="/categoria/criar" /> <form:form action="${url}" method="POST" modelAttribute="categoria"> <div> <label for="descricao">Descricao:</label> <form:errors path="descricao" cssClass="errors"/><br /> <form:input cssStyle="width:250px" maxlength="20" path="descricao" size="20"/> </div> <br/> <div class="submit"> <input id="criar" type="submit" value="Criar Categoria"/> </div> </form:form> </div>
77
</div> </div> </body> </html>
APNDICE D Pgina alterarCategoria.jsp do prottipo em Spring Web MVC
<%@ <%@ <%@ <%@ <%@
prefix="spring" uri="http://www.springframework.org/tags"%> prefix="form" uri="http://www.springframework.org/tags/form" %> prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %> prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> <style type="text/css" media="screen"> @import url("<c:url value="/static/styles/style.css"/>"); </style> <title>Atualizar Categoria</title> </head> <body> <div id="wrap"> <div id="menu"> <%@ include file="menu.jsp" %> </div> <div id="main"> <div id="body"> <c:url var="url" value="/categoria/${categoria.id}" /> <form:form action="${url}" method="PUT" modelAttribute="categoria"> <div> <label for="descricao">Descrio:</label> <form:input cssStyle="width:250px" maxlength="30" path="descricao" size="30"/> </div>
78
<br/> <div class="submit"> <input id="atualizar" type="submit" value="Atualizar Categoria"/> </div> <form:hidden path="id"/> </form:form> </div> </div> </div> </body> </html>
APNDICE E Pgina create.gsp para a classe Usuario do prottipo em Grails
<html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /> <meta name="layout" content="main" /> <g:set var="entityName" value="${message(code: 'usuario.label', default: 'Usuario')}" /> <title><g:message code="default.create.label" args="[entityName]" /></title> </head> <body> <div class="nav"> <span class="menuButton"><a class="home" href="${createLink(uri: '/')}"><g:message code="default.home.label"/></a></span> <span class="menuButton"><g:link class="list" action="list"><g:message code="default.list.label" args="[entityName]" /></g:link></span> </div> <div class="body"> <h1><g:message code="default.create.label" args="[entityName]" /></h1> <g:if test="${flash.message}"> <div class="message">${flash.message}</div>
79
</g:if> <g:hasErrors bean="${usuarioInstance}"> <div class="errors"> <g:renderErrors bean="${usuarioInstance}" as="list" /> </div> </g:hasErrors> <g:form action="save" > <div class="dialog"> <table> <tbody> <tr class="prop"> <td valign="top" class="name"> <label for="email"><g:message code="usuario.email.label" default="Email" /></label> </td> <td valign="top" class="value ${hasErrors(bean: usuarioInstance, field: 'email', 'errors')}"> <g:textField name="email" value="${usuarioInstance?.email}" /> </td> </tr> <tr class="prop"> <td valign="top" class="name"> <label for="senha"><g:message code="usuario.senha.label" default="Senha" /></label> </td> <td valign="top" class="value ${hasErrors(bean: usuarioInstance, field: 'senha', 'errors')}"> <g:passwordField name="senha" maxlength="12" value="${usuarioInstance?.senha}" /> </td> </tr> <tr class="prop"> <td valign="top" class="name"> <label for="nomeCompleto"><g:message code="usuario.nomeCompleto.label" default="Nome Completo" /></label> </td>
80
<td valign="top" class="value ${hasErrors(bean: usuarioInstance, field: 'nomeCompleto', 'errors')}"> <g:textField name="nomeCompleto" maxlength="50" value="${usuarioInstance?.nomeCompleto}" /> </td> </tr> <tr class="prop"> <td valign="top" class="name"> <label for="CPF"><g:message code="usuario.CPF.label" default="CPF" /></label> </td> <td valign="top" class="value ${hasErrors(bean: usuarioInstance, field: 'CPF', 'errors')}"> <g:textField name="CPF" maxlength="11" value="${usuarioInstance?.CPF}" /> </td> </tr> <tr class="prop"> <td valign="top" class="name"> <label for="dataNascimento"><g:message code="usuario.dataNascimento.label" default="Data Nascimento" /></label> </td> <td valign="top" class="value ${hasErrors(bean: usuarioInstance, field: 'dataNascimento', 'errors')}"> <g:datePicker name="dataNascimento" precision="day" value="${usuarioInstance?.dataNascimento}" /> </td> </tr> </tbody> </table> </div> <div class="buttons"> <span class="button"><g:submitButton name="create" class="save" value="${message(code: 'default.button.create.label', default: 'Create')}" /></span> </div> </g:form> </div> </body> </html>
81
APNDICE F Pgina edit.gsp para a classe Usuario do prottipo em Grails
<html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /> <meta name="layout" content="main" /> <g:set var="entityName" value="${message(code: 'usuario.label', default: 'Usuario')}" /> <title><g:message code="default.edit.label" args="[entityName]" /></title> </head> <body> <div class="nav"> <span class="menuButton"><a class="home" href="${createLink(uri: '/')}"><g:message code="default.home.label"/></a></span> <span class="menuButton"><g:link class="list" action="list"><g:message code="default.list.label" args="[entityName]" /></g:link></span> <span class="menuButton"><g:link class="create" action="create"><g:message code="default.new.label" args="[entityName]" /></g:link></span> </div> <div class="body"> <h1><g:message code="default.edit.label" args="[entityName]" /></h1> <g:if test="${flash.message}"> <div class="message">${flash.message}</div> </g:if> <g:hasErrors bean="${usuarioInstance}"> <div class="errors"> <g:renderErrors bean="${usuarioInstance}" as="list" /> </div> </g:hasErrors> <g:form method="post" > <g:hiddenField name="id" value="${usuarioInstance?.id}" /> <g:hiddenField name="version" value="${usuarioInstance?.version}" /> <div class="dialog"> <table> <tbody>
82
<tr class="prop"> <td valign="top" class="name"> <label for="email"><g:message code="usuario.email.label" default="Email" /></label> </td> <td valign="top" class="value ${hasErrors(bean: usuarioInstance, field: 'email', 'errors')}"> <g:textField name="email" value="${usuarioInstance?.email}" /> </td> </tr> <tr class="prop"> <td valign="top" class="name"> <label for="senha"><g:message code="usuario.senha.label" default="Senha" /></label> </td> <td valign="top" class="value ${hasErrors(bean: usuarioInstance, field: 'senha', 'errors')}"> <g:passwordField name="senha" maxlength="12" value="${usuarioInstance?.senha}" /> </td> </tr> <tr class="prop"> <td valign="top" class="name"> <label for="nomeCompleto"><g:message code="usuario.nomeCompleto.label" default="Nome Completo" /></label> </td> <td valign="top" class="value ${hasErrors(bean: usuarioInstance, field: 'nomeCompleto', 'errors')}"> <g:textField name="nomeCompleto" maxlength="50" value="${usuarioInstance?.nomeCompleto}" /> </td> </tr> <tr class="prop"> <td valign="top" class="name"> <label for="CPF"><g:message code="usuario.CPF.label" default="CPF" /></label> </td>
83
<td valign="top" class="value ${hasErrors(bean: usuarioInstance, field: 'CPF', 'errors')}"> <g:textField name="CPF" maxlength="11" value="${usuarioInstance?.CPF}" /> </td> </tr> <tr class="prop"> <td valign="top" class="name"> <label for="dataNascimento"><g:message code="usuario.dataNascimento.label" default="Data Nascimento" /></label> </td> <td valign="top" class="value ${hasErrors(bean: usuarioInstance, field: 'dataNascimento', 'errors')}"> <g:datePicker name="dataNascimento" precision="day" value="${usuarioInstance?.dataNascimento}" /> </td> </tr> <tr class="prop"> <td valign="top" class="name"> <label for="lancamento"><g:message code="usuario.lancamento.label" default="Lancamento" /></label> </td> <td valign="top" class="value ${hasErrors(bean: usuarioInstance, field: 'lancamento', 'errors')}"> <ul> <g:each in="${usuarioInstance?.lancamento?}" var="l"> <li><g:link controller="lancamento" action="show" id="${l.id}">${l?.encodeAsHTML()}</g:link></li> </g:each> </ul> <g:link controller="lancamento" action="create" params="['usuario.id': usuarioInstance?.id]">${message(code: 'default.add.label', args: [message(code: 'lancamento.label', default: 'Lancamento')])}</g:link> </td> </tr> </tbody> </table> </div>
84
<div class="buttons"> <span class="button"><g:actionSubmit class="save" action="update" value="${message(code: 'default.button.update.label', default: 'Update')}" /></span> <span class="button"><g:actionSubmit class="delete" action="delete" value="${message(code: 'default.button.delete.label', default: 'Delete')}" onclick="return confirm('${message(code: 'default.button.delete.confirm.message', default: 'Are you sure?')}');" /></span> </div> </g:form> </div> </body> </html>
APNDICE G Pgina list.gsp para a classe Usuario do prottipo em Grails
<html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /> <meta name="layout" content="main" /> <g:set var="entityName" value="${message(code: 'usuario.label', default: 'Usuario')}" /> <title><g:message code="default.list.label" args="[entityName]" /></title> </head> <body> <div class="nav"> <span class="menuButton"><a class="home" href="${createLink(uri: '/')}"><g:message code="default.home.label"/></a></span> <span class="menuButton"><g:link class="create" action="create"><g:message code="default.new.label" args="[entityName]" /></g:link></span> </div> <div class="body"> <h1><g:message code="default.list.label" args="[entityName]" /></h1> <g:if test="${flash.message}">
85
<div class="message">${flash.message}</div> </g:if> <div class="list"> <table> <thead> <tr> <g:sortableColumn property="id" title="${message(code: 'usuario.id.label', default: 'Id')}" /> <g:sortableColumn property="email" title="${message(code: 'usuario.email.label', default: 'Email')}" /> <g:sortableColumn property="nomeCompleto" title="${message(code: 'usuario.nomeCompleto.label', default: 'Nome Completo')}" /> <g:sortableColumn property="CPF" title="${message(code: 'usuario.CPF.label', default: 'CPF')}" /> <g:sortableColumn property="dataNascimento" title="${message(code: 'usuario.dataNascimento.label', default: 'Data Nascimento')}" /> </tr> </thead> <tbody> <g:each in="${usuarioInstanceList}" status="i" var="usuarioInstance"> <tr class="${(i % 2) == 0 ? 'odd' : 'even'}"> <td><g:link action="show" id="${usuarioInstance.id}">${fieldValue(bean: usuarioInstance, field: "id")}</g:link></td> <td>${fieldValue(bean: usuarioInstance, field: "email")}</td> <td>${fieldValue(bean: usuarioInstance, field: "nomeCompleto")}</td> <td>${fieldValue(bean: usuarioInstance, field: "CPF")}</td> <td><g:formatDate date="${usuarioInstance.dataNascimento}" /></td> </tr>
86
</g:each> </tbody> </table> </div> <div class="paginateButtons"> <g:paginate total="${usuarioInstanceTotal}" /> </div> </div> </body> </html>
APNDICE H Pgina show.gsp para a classe Usuario do prottipo em Grails
<html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /> <meta name="layout" content="main" /> <g:set var="entityName" value="${message(code: 'usuario.label', default: 'Usuario')}" /> <title><g:message code="default.show.label" args="[entityName]" /></title> </head> <body> <div class="nav"> <span class="menuButton"><a class="home" href="${createLink(uri: '/')}"><g:message code="default.home.label"/></a></span> <span class="menuButton"><g:link class="list" action="list"><g:message code="default.list.label" args="[entityName]" /></g:link></span> <span class="menuButton"><g:link class="create" action="create"><g:message code="default.new.label" args="[entityName]" /></g:link></span> </div> <div class="body"> <h1><g:message code="default.show.label" args="[entityName]" /></h1>
87
<g:if test="${flash.message}"> <div class="message">${flash.message}</div> </g:if> <div class="dialog"> <table> <tbody> <tr class="prop"> <td valign="top" class="name"><g:message code="usuario.id.label" default="Id" /></td> <td valign="top" class="value">${fieldValue(bean: usuarioInstance, field: "id")}</td> </tr> <tr class="prop"> <td valign="top" class="name"><g:message code="usuario.email.label" default="Email" /></td> <td valign="top" class="value">${fieldValue(bean: usuarioInstance, field: "email")}</td> </tr> <tr class="prop"> <td valign="top" class="name"><g:message code="usuario.senha.label" default="Senha" /></td> <td valign="top" class="value">${fieldValue(bean: usuarioInstance, field: "senha")}</td> </tr> <tr class="prop"> <td valign="top" class="name"><g:message code="usuario.nomeCompleto.label" default="Nome Completo" /></td> <td valign="top" class="value">${fieldValue(bean: usuarioInstance, field: "nomeCompleto")}</td> </tr> <tr class="prop">
88
<td valign="top" class="name"><g:message code="usuario.CPF.label" default="CPF" /></td> <td valign="top" class="value">${fieldValue(bean: usuarioInstance, field: "CPF")}</td> </tr> <tr class="prop"> <td valign="top" class="name"><g:message code="usuario.dataNascimento.label" default="Data Nascimento" /></td> <td valign="top" class="value"><g:formatDate date="${usuarioInstance?.dataNascimento}" /></td> </tr> <tr class="prop"> <td valign="top" class="name"><g:message code="usuario.lancamento.label" default="Lancamento" /></td> <td valign="top" style="text-align: left;" class="value"> <ul> <g:each in="${usuarioInstance.lancamento}" var="l"> <li><g:link controller="lancamento" action="show" id="${l.id}">${l?.encodeAsHTML()}</g:link></li> </g:each> </ul> </td> </tr> </tbody> </table> </div> <div class="buttons"> <g:form> <g:hiddenField name="id" value="${usuarioInstance?.id}" /> <span class="button"><g:actionSubmit class="edit" action="edit" value="${message(code: 'default.button.edit.label', default: 'Edit')}" /></span>
89
<span class="button"><g:actionSubmit class="delete" action="delete" value="${message(code: 'default.button.delete.label', default: 'Delete')}" onclick="return confirm('${message(code: 'default.button.delete.confirm.message', default: 'Are you sure?')}');" /></span> </g:form> </div> </div> </body> </html>

Estudo Comparativo Entre Frameworks Java para

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Estudo Comparativo Entre Frameworks Java para

Uploaded by

Copyright:

Available Formats

UNVERSIDADE TECNOLGICA FEDERAL DO PARAN PROGRAMA DE PS-GRADUAO EM TECNOLOGIA ESPECIALIZAO EM TECNOLOGIA JAVA

REBECA SUCH TOBIAS FRANCO

REBECA SUCH TOBIAS FRANCO

Co-orientador: Prof. MSc. Maurcio Correia Lemes Neto.

Palavras-chave: Java. Frameworks Web. JSF. Grails. Spring Web MVC.

Keywords: Java. Web frameworks. JSF. Grails. Spring Web MVC.

1.1 FRAMEWORKS WEB

1.2 OBJETIVO GERAL

1.3 OBJETIVOS ESPECFICOS

1.6 ORGANIZAO DO TRABALHO

2.1 PADRES DE PROJETO

2.3 FRONT CONTROLLER

2.4 INVERSO DE CONTROLE

2.5 INJEO DE DEPENDNCIA

2.6 PROGRAMAO POR CONVENO

2.7 PARADIGMA DE ORIENTAO A ASPECTOS

2.11 FRAMEWORK JSF

2.12 FRAMEWORK SPRING WEB MVC

2.13 FRAMEWORK GRAILS

Figura 1 Componentes do Grails Fonte: Infonova (2008)

3 COMPARAO ENTRE OS FRAMEWORKS

3.1 IMPLEMENTAO DO PADRO MVC

3.1.1 JSF 2.0

Figura 2 Arquitetura JSF baseada no modelo MVC Fonte: Pitanga

3.1.2 Spring Web MVC

Figura 3 Fluxo de informaes no Spring Web MVC Fonte: Saab (2011)

3.2.1 JSF 2.0

Annotation @CreditCardNumber @Email @Length @NotBlank @NotEmpty @Range @ScriptAssert

Quadro 2 - Constraints do Grails Fonte: Adaptado de http://grails.org/doc/latest/ref/Constraints/Usage.html.

Constraint display editable

3.3 LINGUAGEM JAVA X GROOVY

Existem mais formas de escrever um for loop. Exemplos:

excees do tipo NullPointerException. Exemplo:

3.4 SUPORTE AO GROOVY

3.4.1 JSF 2.0

3.4.2 Spring Web MVC

O framework Grails totalmente baseado na linguagem Groovy.

3.5 SUPORTE A AJAX

3.5.1 JSF 2.0

Atributo disable event execute

Atributo url (opcional) update (opcional)

3.7 VAGAS DE EMPREGO

Figura 8 Empregos disponveis no site da Catho para cada framework

3.8 LIVROS DISPONVEIS

Figura 9 Literatura disponvel para cada framework

3.9 FRUNS DE DISCUSSO

3.10 ARTIGOS PUBLICADOS

Figura 10 Artigos disponveis para cada framework no DevMedia

4 SISTEMA DE CONTROLE FINANCEIRO

Figura 11 Diagrama de Classes do Sistema de Controle Financeiro

Os casos de desse sistema esto representados na Figura 12.

Figura 12 Diagrama de Casos de Usos do Sistema de Controle Financeiro

4.1 PROTTIPO DESENVOLVIDO EM JSF 2.0

Figura 13 Classe de domnio Categoria do prottipo em JSF 2.0

Figura 14 Classe CategoriaDaoImp do prottipo em JSF 2.0

Figura 15 Classe HibernateUtil do prottipo em JSF 2.0

Figura 16 Arquivo hibernate.cfg.xml do prottipo em JSF 2.0

Figura 17 Classe CategoriaBean do prottipo em JSF 2.0 (parte 1)

Figura 18 Classe CategoriaBean do prottipo em JSF 2.0 (parte 2)

Figura 19 Interface do prottipo em JSF 2.0 criada com PrimeFaces

<h:inputText id="desc" value="#{categoriaBean.categoria.descricao}" required="true" requiredMessage="o campo descrio obrigatrio."/>

Figura 20 Arquivo web.xml do prottipo em JSF 2.0

Figura 22 Mensagens exibidas pelo Hibernate Validator