Baixar Capítulo

APÊNDICE C
Referências rápidas de GDK API
I
Groovy em Ação
DIERK KÖNIG
COM ANDREW GLOVER, PAUL KING
GUILLAUME LAFORGE E JON SKEET
II
Groovy em Ação
APÊNDICE C
Referências rápidas de GDK API
III
Groovy em Ação
DIERK KÖNIG
COM ANDREW GLOVER, PAUL KING
GUILLAUME LAFORGE E JON SKEET
Rio de Janeiro . 2007
IV
Groovy em Ação
Groovy em Ação
Do original Groovy in Action Copyright © 2007 da Editora Alta Books Ltda.
Authorized translation from English language edition, entitled Groovy in Action, by Dierk König,with
Andrew Glover, Paul King, Guillaume Laforge e Jon Skeet, published by Manning Publications Co.Copyright
© 2007 by Manning Publications Co. PORTUGUESE language edition published by Editora Alta
Books, Copyright © 2007 by Editora Alta Books.
Todos os direitos reservados e protegidos pela Lei 5988 de 14/12/73. Nenhuma parte deste
livro, sem autorização prévia por escrito da editora, poderá ser reproduzida ou transmitida
sejam quais forem os meios empregados: eletrônico, mecânico, fotográfico, gravação ou quaisquer
outros. Todo o esforço foi feito para fornecer a mais completa e adequada informação, contudo
a editora e o(s) autor(es) não assumem responsabilidade pelos resultados e usos da informação
fornecida. Recomendamos aos leitores testar a informação, bem como tomar todos os cuidados
necessários (como o backup), antes da efetiva utilização. Este livro não contém CD-ROM, disquete
ou qualquer outra mídia.
Erratas e atualizações: Sempre nos esforçamos para entregar a você, leitor, um livro livre de
erros técnicos ou de conteúdo; porém, nem sempre isso é conseguido, seja por motivo de
alteração de software, interpretação ou mesmo quando alguns deslizes constam na versão original
de alguns livros que traduzimos. Sendo assim, criamos em nosso site, www.altabooks.com.br, a
seção Erratas, onde relataremos, com a devida correção, qualquer erro encontrado em nossos
livros.
Avisos e Renúncia de Direitos: Este livro é vendido como está, sem garantia de qualquer tipo,
seja expressa ou implícita.
Marcas Registradas: Todos os termos mencionados e reconhecidos como Marca Registrada e/ou
comercial são de responsabilidade de seus proprietários. A Editora informa não estar associada
a nenhum produto e/ou fornecedor apresentado no livro. No decorrer da obra, imagens, nomes
de produtos e fabricantes podem ter sido utilizados, e desde já a Editora informa que o uso é
apenas ilustrativo e/ou educativo, não visando ao lucro, favorecimento ou desmerecimento do
produto/fabricante.
Impresso no Brasil
Produção Editorial: Editora Alta Books
Coordenação Editorial: Fernanda Silveira
Tradução: Flávio Martins e Ivan Bosnic
Revisão: Renée Cristine Barbosa
Revisão técnica: Eduardo Velasco
Diagramação: Fernanda Silveira
O código de propriedade intelectual de 1º de Julho de 1992 proíbe expressamente o uso coletivo
sem autorização dos detentores do direito autoral da obra, bem como a cópia ilegal do original.
Esta prática generalizada nos estabelecimentos de ensino, provoca uma brutal baixa nas vendas
dos livros a ponto de impossibilitar os autores de criarem novas obras.
Rua Viúva Cláudio, 291 – Jacaré
Rio de Janeiro – RJ. CEP: 20970-031
Tel: 21 3278-8069/ Fax: 3277-1253
www.altabooks.com.br
e-mail: [email protected]
APÊNDICE C
Referências rápidas de GDK API
Para o amor da minha vida.
- D.K.
V
VI
Groovy em Ação
sumário
introdução
XIV
prefácio
XV
agradecimentos XVII
sobre este livro
XVIII
sobre os autores XXI
sobre o título
XXIII
sobre a ilustração da capa
1
XXIV
Seu caminho para Groovy
1
1.1 A história do Groovy
2
O que é o Groovy? 3; Divertindo-se com Java: integração sem emendas 4; Poder em seu
código: uma linguagem cheia de ferramentas 5; Dirigido à comunidade, porém com suporte
corporativo 8
1.2O que Groovy pode fazer por você 8
Groovy para profissionais Java 9; Groovy para programadores de scripts 9; Groovy para
programadores pragmáticos, extremos e ágeis 10
1.3Executando Groovy
11
Usando groovysh para ‘Hello World’ 11; Usando groovyConsole 14; Usando groovy 15
1.4Compilando e executando Groovy 16
Executando um script compilado Groovy com Java 17; Compilando e rodando com Ant
17
1.5Groovy IDE e suporte do editor 18
IntelliJ IDEA plug-in 19; Plug-in Eclipse 19; Suporte Groovy em outros editores 20
1.6Resumo 20
PARTE 1
2
A LINGUAGEM GROOVY..........................................................................23
Abertura: As bases do Groovy 25
2.1 Aparência geral do código 26
Comentando código Groovy 26; Comparando a sintaxe Groovy com Java 27; Beleza
através da brevidade 27
2.2 Sondando a linguagem com asserções
28
2.3 Groovy num piscar de olhos
30
Declarando classes 31; Usando scripts 31, GroovyBeans 32; Manipulando método 3 3 ;
Números são objetos 34; Usando listas, mapas e escalas 34; Código como objetos: closures
APÊNDICE C
Referências rápidas de GDK API
VII
36; Estruturas de Controle Groovy 38
2.4 O lugar do Groovy no ambiente Java 39
Minha classe é sua classe 39; GDK, a biblioteca Groovy 40; O ciclo de vida Groovy 42
2.5 Resumo 44
3
Os tipos de dados simples do Groovy 47
3.1 Objetos, objetos por toda parte 48
Sistema de tipos do Java – primitivos e referenciais 48; A resposta Groovy – tudo é um
objeto 49; Interoperando com Java – encaixamento e desencaixamento automático 5 1 ;
Sem desencaixamento intermediário 51
3.2 O conceito de typing opcional 52
Atribuindo tipos 52;Tipologia dinâmica versus estática
52
3.3 Cancelando (Overriding) operadores
53
Visão geral de operadores canceláveis (Overridable) 53; Cancelando operadores em ação
55;Fazendo a coerção trabalhar por você 57
3.4 Trabalhando com Strings
58
Variações de literais de string 58; Trabalhando com GStrings 61;Do Java para o Groovy
62;
3.5 Trabalhando com expressões regulares
64
Especificando métodos em literais de strings 65;Aplicando padrões 67;Padrões em ação
69;Padrões e performance 70
3.6 Trabalhando com números
72
Coerção com operadores numéricos 72;Métodos GDK para números 74
3.7 Resumo 75
4
Os tipos de dados coletivos do Groovy
77
4.1 Trabalhando com escalas 78
Especificando escalas 79;Escalas são objetos 80;Escalas em ação 81;tabalhando com listas
83;Especificando listas 83;Usando operadores de lista 84;Usando métodos de lista 86;Listas
em ação 90;
4.3 Trabalhando com Mapas (MAPs)
91
Especificando mapas (MAPs) 92;Usando operadores de mapa 93;Mapas (MAPs) em ação
97;
4.4 Notas sobre coleções Groovy
98
Entendendo modificações concorrentes 98;Distinguindo entre semântica de cópia e de
modificação 99
4.5 Resumo 99
VIII Groovy em Ação
5
Trabalhando com closures
101
5.1 Breve introdução aos closures
102
5.2 O caso para closures 103
Usando iteradores 103;Manipulação de recursos 105
5.3 Declarando closures 107
A declaração simples 107;Usando atribuições para declaração 108;Referindo-se a métodos
como closures 108;Comparando as opções disponíveis 110;
5.4 Usando closures 111
Chamando um closure 111;Mais métodos de closure 113;
5.5 Entendendo escopo 116
O escopo de variável simples 117;O closure scope geral 117;Escopo trabalhando: o teste
clássico de acumulação 120;
5.6 Retorno de closures
121
5.7 Suporte para padrões de projeto
122
Relação ao padrão Visitor 122;Relacionamento com o padrão Builder 123;Relacionamento
com outros padrões 124
5.8 Resumo 124
6
Estruturas de controle Groovy 127
6.1 A verdade Groovy 128
Avaliando testes Boolean 128; Atribuições dentro de testes Boolean 129;
6.2 Estruturas de controle condicionais
131
A indicação humble if 131;O operador condicional ?: 132;A indicação switch
132;Checando sanidade com asserções 135;
6.3 Looping
138
Looping com while 138;Looping com for 138;
6.4 Blocos de saída e métodos
140
Terminação normal: return/break/continue 140;Exceções: throw/try-catch-finally 141;
6.5 Resumo 142
7
Orientação dinâmica a objeto, estilo Groovy 145
7.1 Definindo classes e scripts
146
Definindo campos e variáveis locais 146;Métodos e parâmetros 149;Desreferência segura
com o operador ?. 153;Construtores 154
APÊNDICE C
Referências rápidas de GDK API
IX
7.2 Organizando classes e scripts
156
Relação de arquivo para classe 156;Organizando classes em pacotes 157;Mais
considerações sobre caminhos de classe 160
7.3 Características OO avançadas
162
Usando herança 162;Usando interfaces 162;Multimétodos 163
7.4 Trabalhando com GroovyBeans 164
Declarando Beans 165;Trabalhando com beans 166;Usando métodos bean para qualquer
objeto 169;Campos, accessors, mapas e Expando 170
7.5 Usando características de poder 171
Pedindo objetos com GPaths 171;Injetando o operador spread 175;Categorias mistas com
a palavra-chave use 176
7.6 Programação meta no Groovy 178
Compreendendo o conceito MetaClass 179;Invocação de método e intercessão 180;Intercessão
de método em ação 182;
7.7 Resumo 184
PARTE 2
8
AO REDOR DA BIBLIOTECA GROOVY.......................................................187
Trabalhando com builder 188
8.1 Aprendendo por exemplo – usando um builder 191
Construindo objetos em árvore com NodeBuilder 193;NodeBuilder em ação – um olhar
próximo ao código builder194;Construção compacta com lógica195;
8.3 Trabalhando com MarkupBuilder 197
Construindo XML 197;Construindo HTML 199;
8.4 Automação de tarefas com AntBuilder 200
De scripts Ant para scripts Groovy 201;Como o AntBuilder funciona 202;Scripts de
automação com lógica 203;
8.5 GUIs fáceis com SwingBuilder 204
Lendo uma senha com SwingBuilder 204;Criando widgets Swing 206;Arrumando seus
widgets 209;Referindo-se a widgets 213;Usando ações Swing 215;Usando modelos
216;Colocando tudo junto 218;
8.6 Criando seu próprio Builder
223
Fazendo subclasses de BuilderSupport 224;O exemplo DebugBuilder 226;
8.7 Resumo 228
9
Trabalhando com GDK
231
9.1 Trabalhando com Objects
232
Objetos interativos 232;Métodos convenientes para Object 237;Métodos iterativos de
Object 239;
X
Groovy em Ação
9.2 Trabalhando com arquivos e I/O
242
Atravessando o sistema de arquivos 244;Lendo de fontes de entrada 245;Escrevendo para
destinações de saída 246;Filtros e conversões 248;Fazendo stream de objetos serializados
249;Trabalhando com threads e processos 250;Multilinhas Groovy 251;Integrando
processos externos 252;
9.4 Trabalhando com templates 256
Entendendo o formato template 257;Templates em ação 257;Edições de template avançadas
259;
9.5 Trabalhando com Groovlets 260
Começando com ‘hello world’ 260;O ligamento Groovlet 262;Fazendo templates Groovlets
265;
9.6 Resumo 266
10
Programação para Banco de Dados com Groovy
269
10.1 Operações básicas de banco de dados 271
Preparando o acesso a banco de dados 271;Executando SQL 274;Obtendo
dados278;Juntando tudo 282;
10.2 DataSets para SQL sem SQL 283
Utilizando operações de DataSet 284;Usando DataSet com consultas de banco de dados
287;
10.3 Organizando o trabalho com banco de dados
289
Visão geral da arquitetura 289;Determinando o comportamento da aplicação 2 9 1 ;
Implementando a camada de infra-estrutura 292;Implementando a camada de aplicação
296;
10.4 Groovy e MOR
10.5 Resumo
11
298
299
Integrando Groovy 301
11.1 Preparando-se para a integração
Integrando de forma apropriada 303;Configurando as dependências 304;
11.2 Avaliando expressões e scripts com GroovyShell
305
Começando de forma simples 305;Passando parâmetros dentro de um Binding 307;Criando
classes dinâmicas em tempo de execução 308;Análise gramátical (parsing) de scripts
309;Executando scripts ou classes 310;Parametrização avançada do GroovyShell 310;
11.3 Utilizando o motor de scripts do Groovy
313
Configurando o motor 314;Executando os scripts 314;Definindo um conector de recursos
diferente 315
11.4 Trabalhando com GroovyClassLoader
315
Efetuando parsing e carregando classes Groovy 316;O problema de dependência da galinha
APÊNDICE C
Referências rápidas de GDK API
XI
e do ovo 317;Provendo um carregador de recursos customizado 320;Executando de forma
segura 321
11.5 Integração com Spring
324
Trabalhando com GroovyBeans 325;Beans atualizáveis 327;Scripts alinhados 327;
11.6 O novo Mustang e JSR-223
328
Introdução a JSR-223 328;Gerenciador do motor de script e seus motores de script
329;Motores de script implementando interfaces Compilable e Invocable 330;
11.7 Escolhendo um mecanismo de integração
12
11.8 Resumo
332
333
Trabalhando com XML
335
12.1 Lendo documentos XML 336
Trabalhando com o parser DOM 337;Lendo com o parser do Groovy 341;Lendo com o
parser SAX 345;Lendo com o parser StAX 347;
12.2 Processando XML 348
Processamento in-place 349;Processamento de fluxo 351;Combinação com XPath
355;
12.3 Processamento distribuído com XML
361
Visão geral de web services 362;Lendo RSS e ATOM 363;Usando API baseada em
REST 364;Usando XML-RPC 367;Aplicando SOAP 369;
12.4 Resumo
PARTE 3
13
373
O GROOVY DIÁRIO................................................................................377
Dicas e Truques
379
13.1 Coisas para lembrar 380
Igualdade versus identidade 380;Usando parênteses sabiamente 381;Retornando de
métodos e closures 382;Chamando os métodos no código de builder 382;Acesso qualificado
a ‘‘this’’ 384;Considerando os tipos numéricos 385;Alavancando Ant 386;Scripts são
classes, porém diferentes 389
13.2 Códigos úteis 391
Embaralhar uma coleção 391;Embaralhando texto com expressões regulares 391;Barra
de progresso no console 392;Código com passos que se autocomentam 393;Uso avançado
de GString 394
13.3 Usando groovy pela linha de comando 395
Avaliando um script de linha de comando 395;Usando as opções print e line
396;Usando o modo de escuta 397;Edição in-place pela linha de comando 398;
13.4 Escrevendo scripts de automatização 399
Suportando opções da linha de comando consistentemente 399;Expandindo classpath com
RootLoader 402;Agendando a execução de scripts 404;
XII
Groovy em Ação
13.5 Exemplos de tarefas automatizadas
405
Automatizando ações na web 407;Inspecionando o controle de versões 409;Análise de código
pragmática 410;Mais pontos de interesse 411;
13.6 Planejando o ambiente de trabalho
412
Configuração do ambiente de desenvolvimento 412;Depuração 413;Profiling
417;Refactoring 418;
13.7 Resumo
14
420
Testes Unitários com Groovy 421
14.1 Começando 422
Escrever testes é fácil 423;GroovyTestCase: uma introdução 423;Trabalhando com
GroovyTestCase 424;
14.2 Testes unitários do código Groovy
14.3 Testes unitários do código Java
14.4 Organizando seus testes
425
429
431
14.5 Técnicas de testes avançadas
433
Testando de forma fácil 433;Usando stubs e mocks 435;Usando GroovyLogTestCase
439;
14.6 Integração com IDE
440
Usando GroovyTestSuite 441;Usando AllTestSuite 442;Integração avançada de IDE
444;
14.7 Ferramentas para testes Groovy
446
Cobertura do código com Groovy 446;Extensões de JUnit 448;
14.8 Automatização de build
451
Integração de build com Ant 450;Integração de build com Maven 452;
14.9 Resumo
15
455
Groovy para Windows 457
15.1 Efetuando download e instalação do Scriptom
458
15.2 Por dentro do Scriptom
459
Introdução a Jacob 459;Instanciando um componente ActiveX 460;Invocando métodos
463;Acessando propriedades e valores de retorno 464;Suporte a eventos 465;
15.3 Cenário do mundo real: automatizando localidades
467;
Definindo o formato do nosso documento 468;Modelando a planilha dicionário 469;
Criando o documento Word 471;Produzindo o documento final 472;
15.4 Outras integrações das aplicações 474
APÊNDICE C
Referências rápidas de GDK API
XIII
Acessando o registro do Windows 474;Fazendo o seu próprio sistema de automatização
476;
15.5 Onde obter a documentação
15.6 Resumo
16
477
478
Uma visão do Grails 479
16.1 Preparando o terreno 480
Instalando Grails 480;Arregaçando as mangas 481;
16.2 Projetando o modelo de domínio 484
Pensando em casos de uso 484;Modelando relacionamentos 485;
16.3 Implementando o modelo de domínio
486
Estruturando as classes de domínio 486;Estruturando visualizações e controladores
487;Testando a aplicação web 489;Completando o modelo de domínio 490;
16.4 Customizando visualizações 492
Bootstrapping de dados 492;Trabalhando com Groovy Server Pages
493;Trabalhando com bibliotecas de tag 496;
16.5 Trabalhando com controladores e métodos finders 498
16.6 Elaborando o modelo
501
16.7 Trabalhando com sessão 502
16.8 Terminando 505
Validando restrições 506;Fazendo o deploy da aplicação 507;Despedida 508
apêndice A Instalação e documentação 511
apêndice B Informações da linguagem Groovy
515
apêndice C Referências rápidas de GDK API
519
apêndice D Folha de lembretes
535
XIV
Groovy em Ação
introdução
A primeira vez que integrei o Groovy em um projeto foi há quase dois anos. Existe uma longa e
rica história sobre o uso de “linguagens de script” como uma cola flexível para juntar, de
maneiras diferentes, grandes componentes modulares de uma variedade de frameworks. Groovy
é uma linguagem dessa tradição particularmente interessante, porque não foge da sofisticação
lingüística na busca pela programação concisa, especialmente nos assuntos ligados a XML, onde
é particularmente forte. Groovy vai além da tradição de “cola” das linguagens de script e tornase efetivamente uma linguagem de implementação do seu próprio jeito. Na verdade, embora
Groovy seja freqüentemente pensado e referenciado como uma linguagem de script, ele é realmente
muito mais do que isso.
É uma tradição das linguagens de script possuir um relacionamento desconfortável com o
sistema lingüístico subjacente, com o qual os frameworks são implementados. No caso do Groovy,
eles foram capazes de alavancar o modelo Java subjacente para conseguir uma integração suave
e eficiente. E por causa das semelhanças lingüísticas entre Java e Groovy, torna-se fácil aos
desenvolvedores alternar entre a programação nesses dois ambientes.
Groovy em ação, de Dierk König e seus co-autores é uma clara e detalhada exposição sobre o que
há de mais moderno no Groovy. Fico feliz por tê-lo na minha biblioteca.
James Gosling
Criador do Java
Sun Microsystems, inc.
APÊNDICE C
Referências rápidas de GDK API
XV
prefácio
O progresso fundamental tem a ver com a reinterpretação das idéias básicas.
- Alfred North Whitehead
Nos últimos anos testemunhamos grandes aprimoramentos no desenvolvimento de softwares
com Java – e bem mais do que isso. É fácil perceber essas conquistas quando você está atarefado
com o trabalho diário de desenvolvimento. Trabalhamos com o suporte elaborado de ferramentas,
temos todos os tipos de frameworks para diversas áreas e descobrimos novas formas ágeis de
organização do desenvolvimento de software em equipes. Cada uma dessas disciplinas –
ferramentas, frameworks e metodologias – forçou os seus limites. Ainda estamos aguardando
que outros dois aspectos importantes do desenvolvimento de software contribuam para trazer o
nosso negócio para frente: gerenciamento de habilidades pessoais e linguagens de programação.
A linguagem importa, sim. Ela determina como você percebe o mundo – e determina o seu
mundo. A sua linguagem de programação determina como você pensa sobre as soluções de
software e os problemas subjacentes. O seu conhecimento das linguagens de programação é a
chave para o seu portfólio pessoal como um desenvolvedor de software.
O código fonte é um meio de comunicação: de você para o compilador; para outros membros da
equipe e de volta para você. Há um aspecto técnico e um aspecto humano nessa comunicação. As
linguagens de programação clássicas são focadas no aspecto técnico e são otimizadas para o
desempenho e consumo de recursos. Outras linguagens são focadas no aspecto humano, tentando
revelar a intenção do programador no código o mais claramente possível. Muitas tentativas
foram feitas para interligar os dois aspectos, desde a Programação Literal até a Programação
Lógica, sendo que nenhuma delas tomou o mundo de assalto.
Enquanto é improvável que Groovy domine as linguagens tradicionais, o que o distingue das
tentativas anteriores é que ele permite uma transição leve entre a codificação centrada em máquinas
e a centrada em humanos. Ele é construído em cima da idéia básica da plataforma Java com uma
nova interpretação da aparência do código. Isso significa que, no nível de bytecode, Groovy é
Java, permitindo uma combinação contínua das duas linguagens. Por exemplo, diferente dos
outros projetos que tentam tornar disponíveis as linguagens de script para a plataforma Java,
uma string literal em Groovy é do tipo java.ling.String. Você ganha o melhor dos dois mundos.
Como uma conseqüência direta, Groovy tem o aproveitamento total de frameworks, sendo que a
biblioteca-padrão Java é o mais importante deles. James Strachan e Bob McWhirter fundaram o
projeto Groovy em 2003, reconhecendo que o desenvolvimento de aplicações em Java é
caracterizado pelo uso de múltiplos frameworks e sua junção para criar um produto. Eles
projetaram o Groovy para otimizar justamente esse tipo de trabalho.
Ao mesmo tempo, Richard Monson-Haefel encontrou James, que o introduziu ao Groovy. Richard
imediatamente reconheceu o potencial do Groovy e sugeriu a submissão de Java Specification
Request (JSR-241). Para encurtar a história, essa JSR passou “sem nenhum problema”, como
Richard colocou em seu blog, graças ao apoio adicional de Geir Magnusson Jr. e à visão do
pessoal da Sun Microsystems. Eles não vêem o Groovy como um rival do Java, mas como um
companheiro que atrai desenvolvedores brilhantes, que em outro caso poderiam migrar para
XVI
Groovy em Ação
Ruby ou Python e dessa forma se afastar da plataforma Java. Desde que JSR foi aceita, Groovy é
a segunda linguagem-padrão para a JVM (depois da própria linguagem Java).
O processo da JSR foi o teste decisivo para a comunidade Groovy. Ele mostrou onde os contribuintes
estavam empurrando em direções diferentes e impôs mais estruturação no desenvolvimento do
que alguns estavam dispostos a aceitar. O desenvolvimento ficou mais lento em 2004. Foi aí que
algumas pessoas chaves entraram e tomaram a frente: Guillaume Laforge e Jeremy Rayner
organizaram o que depois foi chamado de Groovy-One. Isso levou a Especificação da Linguagem
Groovy (GLS) e Kit para Teste de Compatibilidade (TCK), e a um parser novo gerado com base
na especificação descritiva da gramática. Eles fizeram a bola rodar de novo – a bola que agora
estava se tornando uma avalanche.
Desde o começo ficou claro que Groovy iria precisar de um livro como Groovy em ação para
introduzir os novatos à linguagem, prover documentação compreensiva e mostrar o que é possível
com Groovy para despertar a curiosidade e a imaginação do leitor.
Jonh Wilson começou essa aventura e passou o bastão a Scott Stirling, o qual, por sua vez,
encontrou algumas contribuições que eu fiz para Groovy Wiki. Ele me convenceu rapidamente
a me juntar ao esforço de escrever o livro. Nesses tempos eu estava juntando cada bit de informação
que podia encontrar sobre o Groovy dentro do meu conhecimento pessoal para tê-lo disponível
off-line. Escrevi anotações pessoais sobre idiomas Groovy que achei úteis. Colocar tudo isso
dentro de um livro parecia natural, mesmo que fosse apenas para os meus propósitos pessoais.
Infelizmente, Scott teve que renunciar, e eu fiquei sozinho durante a metade de um ano,
empurrando as coisas para frente da melhor forma que sabia. Tive muita sorte de obter apoio de
Andrew e Guillaume, ambos especialistas em Groovy bem conhecidos. Andrew comanda as
séries on-line Practically Groovy e Guillaume não é apenas o gerente do projeto Groovy, ele é
coração e alma do Groovy. Desde o primeiro dia do projeto deste livro, eu estava consciente de
que, pelo fato de inglês não ser a minha língua materna, eu não seria capaz de escrever um livro
completo sem uma ajuda séria. Esta foi a razão inicial por ter chamado Dr. Paul King e Jon
Skeet para se juntarem ao projeto. Não poderia ter tido uma sorte maior. Acontece que eles não
apenas olharam incansavelmente cada sentença deste livro não deixando nenhuma pedra sem
revirar, mas também clarearam os argumentos do livro, tornaram o texto mais acessível e corrigiram
erros e fraquezas. Eles também sugeriram exemplos mais convincentes e, por último, mas não
menos importante, contribuíram com o conteúdo. Este livro jamais poderia ter sido realizado
sem o seu aplicado e cuidadoso trabalho.
Mesmo que nunca aconteça o dia em que vamos escutar o Richard dizer que “Groovy é usado
para controlar os vôos no espaço e resolveu o problema da fome mundial”, eu estaria satisfeito se
Groovy, e este livro, ajudassem a empurrar a nossa profissão de desenvolvimento de software um
centímetro para frente.
Dierk König
APÊNDICE C
Referências rápidas de GDK API
XVII
agradecimentos
Estou muito satisfeito por ter tido a oportunidade de escrever este livro. Isso me ajudou a afiar
minhas habilidades de programação em Groovy e Java. Agradeço aos meus co-autores e editores,
especialmente ao meu editor de desenvolvimento Jackie Carter, eu também aprendi muito sobre
escrever. E mais importante de tudo, eu adorei trabalhar com tantas pessoas brilhantes!
Estou profundamente agradecido à nossa equipe de revisão: Jonas Trindler, Jochen Theodorou,
Jeremy Rayner, Christopher DeBracy, Bob McWhirter, Sam Pullara, John Stump, Graeme Rocher,
Jeff Cunningham, Bas Vodde, Guillaume Alleon, Doug Warren, Derek Lane, Scott Shaw, Norman
Richards, Stuart Caborn, Glen Smith, John Wilson e Martin C. Martin. O prêmio de “revisor
mais observador” vai para Marc Guillemot!
Outros amigos que ajudaram com o livro de um jeito ou de outro: Denis Antonioli, Christian
Bauer, Gerald Bauer, Tim Bray, Jesse Eichar, Benjamin Feiermann, James Gosling, Martin
Huber, Stephan Huber, Andy Hunt, Vincent Massol, Richard Monson-Haefel, Johannes Link,
Rolf Pfenninger, Franck Rasolo, Stefan Roock, Rene Schönfeldt, Tomi Schütz, Scott Stirling,
Roman Strobl, Frank Westphal, John Wilson, Dr. Russel Winder, todo o pessoal do Groovy,
assim como os participantes do programa Manning’s Early Access Program.
Agradecimento especial ao Jochen Theodorou, a liderança técnica do projeto Groovy e ao John
Wilson, o mestre Groovy em programação dinâmica, por estarem sempre disponíveis quando
precisamos de conselhos sobre o funcionamento interno do Groovy. Além disso, Jochen foi
revisor técnico deste livro, e verificou o código pela última vez bem antes do livro ser impresso.
Finalmente, um agradecimento especial ao James Gosling por ter escrito a introdução ao Groovy
em ação.
O livro jamais teria chegado às prateleiras sem o suporte e orientação de todos da Manning
Publications, especialmente os nossos editores Marjan Bace e Jackie Carter. Gostaríamos também
de agradecer ao restante da equipe na Manning: Benjamin Berg, Denis Dalinnik, Gabriel
Dobrescu, Dottie Marsico, Mary Piergies, Iain Shigeoka, Hieu Ta, Tiffany Taylor, Karen Tegtmeyer,
Katie Tennant, Ron Tomich, Helen Trimes, Lianna Wlasiuk e Megan Yockey.
Minha família, especialmente os meus pais, que sempre me apoiaram quando os tempos foram
difíceis e – mais importante – encorajaram-me a perseguir as minhas idéias. Muito obrigado.
XVIII Groovy em Ação
sobre este livro
Guia de viagem
Groovy em ação descreve a linguagem Groovy, apresenta as classes e os métodos da biblioteca que
o Groovy adiciona ao Java Development Kit padrão, e o leva por uma série de assuntos que
muito provavelmente você encontrará no seu trabalho diário com o desenvolvimento. O livro é
composto destas três partes:
Parte 1: A linguagem Groovy
Parte 2: Ao redor da biblioteca Groovy
Parte 3: Groovy cotidiano
Um capítulo introdutório explica o que é Groovy e então a parte 1 começa com uma ampla visão
dos recursos da linguagem Groovy, antes de se aprofundar mais sobre os tipos de dados escalares
e coletivos. A descrição da linguagem inclui uma explanação do conceito de closure que é
onipresente no Groovy, descrevendo como ele se relaciona com e como se diferencia das estruturas
de controle. A parte 1 termina com o modelo de orientação a objetos do Groovy e seu Protocolo
Meta-Object, o qual faz do Groovy a linguagem dinâmica que é.
A parte 2 começa a descrição da biblioteca com a apresentação do conceito de builder do Groovy,
suas diversas implementações e sua relação com os motores de templates, junto com o seu uso
em Groovlets para as aplicações web simples. Segue então uma explanação sobre GDK, com os
aprimoramentos do Groovy para a biblioteca Java padrão. Essa é a parte mais importante da
descrição da biblioteca na parte 2. A biblioteca Groovy brilha com o simples, porém poderoso
suporte para programação para banco de dados e manipulação de XML, e incluímos uma
explanação detalhadas sobre ambos os tópicos. Outra grande vantagem do Groovy é a sua completa
e transparente integração com Java e nós explicamos as opções oferecidas pela biblioteca Groovy
para fazer com que isso funcione.
Se a parte 1 fosse um tutorial e parte 2 uma referência, então a parte 3 seria um livro de receitas.
Ela começa com dicas e truques, avisos sobre as armadilhas e idéias erradas mais comuns,
pedaços de código e soluções para tarefas comuns e então o leva através do aspecto organizacional
do seu trabalho diário com Groovy. Uma grande parte do trabalho diário são os testes unitários
e nós descrevemos em detalhes como Groovy ajuda com isso. E, como muitos programadores
trabalham na plataforma Windows, nós descrevemos como você pode aproveitar o seu
conhecimento do Groovy na integração com os componentes COM e ActiveX.
Um capítulo final de bônus traz uma visão sobre como usar Grails, o framework Groovy para
aplicações web. Grails é o exemplo perfeito para entender e apreciar Groovy. Ele explora
completamente as capacidades dinâmicas do Groovy para injetar os recursos em tempo de
execução enquanto usa as bases sólidas da plataforma corporativa Java e o desempenho e a
escalabilidade das bibliotecas de terceiros como Spring e Hibernate. Grails vale ser estudado por
si só; nós o incluímos na parte 3 para demonstrar como a engenharia consciente pode levar a
novos níveis de produtividade ao se apoiar nos ombros dos gigantes.
APÊNDICE C
Referências rápidas de GDK API
XIX
O livro termina com uma série de apêndices cuja função é servir como um guia rápido.
Quem deveria ler este livro?
Este livro é para todos que querem aprender Groovy como uma nova linguagem de programação
ágil. Os usuários Groovy existentes podem usá-lo para aprofundar os seus conhecimentos; e
tanto os programadores novatos como os experientes podem usá-lo como um guia de referência.
Nós nos encontramos olhando o nosso próprio livro para encontrar os detalhes que esquecemos.
Os novatos irão precisar do conhecimento básico do Java, já que o Groovy depende totalmente
dele; esse assunto não é coberto neste livro.
O conhecimento prévio de alguns tópicos irá facilitar a leitura e o entendimento, mas eles não
são pré-requisitos obrigatórios: padrões de design orientado a objetos, Ant, Maven, JUnit, HTML,
XML e Swing. É benéfico – mas não requerido – que tenha tido o contato com alguma outra
linguagem de script. Isso vai lhe possibilitar juntar o que você já sabe com o que está lendo.
Quando apropriado, nós apontamos as semelhanças e as diferenças entre Groovy e outras
linguagens de script.
Convenções de código
Este livro provê exemplos abundantes que mostram como você pode fazer o uso de cada assunto
abordado. O código fonte nas listagens ou em texto aparece em uma fonte tipográfica como esta
para que seja separada do restante do texto. Além disso, nomes de classes e métodos, propriedades
dos objetos e outros termos e conteúdos do texto relacionados ao código são apresentados com
a mesma fonte tipográfica.
Ocasionalmente, o código é itálico, como em reference.dump(). Nesse caso reference não deve ser
informado literalmente, mas substituído com o conteúdo que é requerido, tal como uma referência
apropriada.
Onde o texto contém pronomes “eu” e “nós”, “nós” se refere a todos os autores. “Eu” se refere
ao autor principal de cada capítulo: Guillaume Laforge para capítulos 11 e 15, Andrew Glover,
para capítulo 14 e Dierk König para os outros capítulos.
A maioria dos exemplos de código contém código Groovy. O código é muito compacto e por isso
o apresentamos “do jeito que é” sem nenhuma omissão. A não ser que seja declarado diferente,
você pode copiar e colar em um novo arquivo e executá-lo na mesma hora. Em casos raros onde
isso não foi possível, nós utilizamos ... reticências.
Java, HTML, XML e entradas de linha de comando podem ser muito verbosos. Em muitos
casos, o código fonte original (disponível on-line) foi reformatado; nós adicionamos quebras de
linha e refizemos os recuos para acomodar o espaço de página disponível no livro. Em casos
raros, quando nem isso foi possível, as marcações de continuação da linha foram adicionadas.
As anotações de código acompanham muitas das listagens, destacando os conceitos importantes.
Em alguns casos, pequenas bolas com números indicam uma explicação adicional que acompanha
a listagem.
Você pode efetuar o download do código fonte de todos os exemplos do livro pelo site da editora
em www.altabooks.com.br.
XX
Groovy em Ação
Mantendo-se atualizado
O mundo não pára de girar quando você termina de escrever o livro, e fazer o livro ser produzido
também leva tempo. Por isso, algumas informações em qualquer livro técnico se tornam
desatualizadas rapidamente, especialmente no mundo dinâmico de linguagens ágeis.
Este livro aborda o Groovy 1.0. Groovy irá ver inúmeros aprimoramentos e quando você estiver
lendo isto, é possível que uma versão mais atualizada esteja disponível. As novas versões do
Groovy sempre vêm com uma lista detalhada de alterações. É bem improvável que qualquer
conceito fundamental do Groovy abordado neste livro mude significativamente antes do Groovy
2.0; e mesmo então, a ênfase estará provavelmente em conceitos e recursos adicionais. Desse
ponto de vista o livro é um investimento sábio, mesmo em um mundo que muda tão rapidamente.
Nós faremos o máximo para manter os recursos on-line deste livro razoavelmente atualizados e
oferecer as informações sobre as mudanças da linguagem e da biblioteca conforme o projeto
segue em frente. Por favor, verifique as atualizações na página web do livro em www.manning.com/
koenig.
Fórum Author Online
A aquisição do livro Groovy em ação inclui o acesso gratuito a um fórum privado gerenciado por
Manning Publications onde você pode fazer os comentários sobre o livro, fazer perguntas técnicas
e receber ajuda dos autores e outros usuários (em inglês). Para acessar o fórum e se inscrever, vá
para a página www.manning.com/koenig. Essa página contém as informações sobre como entrar
no fórum depois que estiver registrado, que tipo de ajuda está disponível e as regras de conduta
do fórum. Ela também contém os links do código fonte dos exemplos do livro, errata e outros
downloads.
O comprometimento da Manning com os nossos leitores é de prover um ponto de encontro
onde os diálogos significantes entre os leitores individuais e entre os leitores e os autores devem
ter o seu lugar. Isso não é o comprometimento para uma determinada quantidade de participação
pela parte dos autores, cuja contribuição permanece voluntária (e gratuita). Nós sugerimos que
você tente fazer aos autores algumas perguntas desafiadoras a fim de despertar a sua participação!
O fórum Author Online e os arquivos das discussões prévias estarão acessíveis pelo site da
editora enquanto o livro estiver em produção.
APÊNDICE C
Referências rápidas de GDK API
XXI
sobre os autores
DIERK KÖNIG é formado em administração de empresas e ciência de computação, e trabalhou
com Java durante dez anos como desenvolvedor de software profissional, mentor e instrutor.
Ele é um revisor reconhecido e/ou colaborador de diversos livros, incluindo os clássicos Extreme
Programming Explained (Kent Beck), Test-Driven Development (Kent Beck), Agile Development in the
Large (Eckstein/Josuttis), JUnit (Johannes Link), JUnit and Fit (Frank Westphal) e Refactorings
(Roock/Lippert).
Dierk publica nas principais revistas alemãs sobre desenvolvimento de software e palestra em
conferências internacionais. Recentemente, Skillmatter London ofereceu o seu curso de
treinamento Groovy e Grails e os eventos relacionados. Ele trabalhou na empresa Canoo
Engineering AG em Basle, Suíça, desde 2000 onde ele é sócio-fundador e membro do comitê
executivo. Dierk fundou o projeto open source Canoo WebTest e tem sido seu gerente desde
2001. As suas atividades de consultoria e engenharia são relacionadas às práticas de
desenvolvimento ágil de software e automatização de testes. Ele se juntou ao projeto Groovy em
2004 e trabalha como colaborador desde então.
ANDREW GLOVER é um especialista reconhecido em frameworks e ferramentas de automatização
de testes. É autor de muitas publicações on-line, incluindo DeveloperWorks da IBM e os portais
ONJava e ONLamp de O’Reilly. É co-autor de Java Testing Patterns. Andrew é um palestrante
freqüente em Grupos de Usuários Java ao redor do país e também é palestrante do grupo No
Fluff Just Stuff Software Symposium. O seu interesse em trazer a qualidade para dentro do
software com tecnologias que diminuem os bugs, reduzem o tempo de integração e testes e
melhoram a estabilidade geral do código o levou a fundar Vanward Technologies em 2001.
Vanward foi comprada pela JNetDirect em 2005 e mudou o nome para Stelligent em 2006. Ele
tem um blog ativo sobre a qualidade de software em thediscoblog.com e testearly.com.
DR. PAUL KING tem uma carreira que abrange os cargos técnicos e gerenciais em uma série de
organizações, apoiada com o profundo conhecimento da tecnologia da informação e dos mercados
de telecomunicações e a paixão pela criação de organizações inovadoras. Durante a sua carreira,
Paul prestou serviços de consultoria técnica e estratégica para centenas de organizações na
América do Norte e Ásia. A primeira fase da carreira do Paul se destaca pela sua contribuição
em vários campos de pesquisa, incluindo desenvolvimento de software orientado a objetos,
métodos formais, telecomunicações e sistemas distribuídos. Ele teve várias publicações em
conferências internacionais e em jornais e revistas da área. É um autor premiado e palestrante
cogitado em conferências.
Atualmente, Paul lidera ASERT (Advanced Software Engineering, Research & Training), a qual
é reconhecida como um centro mundial especialista nas áreas de tecnologia middleware,
desenvolvimento ágil e desenvolvimento e deploy das aplicações para Internet. ASERT adquiriu
experiência em ensinar para milhares de estudantes em mais de 15 países, e forneceu serviços de
consultoria por toda a Ásia Pacífica até os sites governamentais e de e-commerce de alto nível.
No seu tempo livre, Paul é taxista e assistente de dever de casa para os sete filhos.
XXII Groovy em Ação
GUILLAUME LAFORGE tem sido o gerente oficial do projeto Groovy desde o fim de 2004,
depois de ter sido colaborador e desenvolvedor do núcleo do projeto. Ele é também o líder da
especificação JSR-241, o esforço contínuo para padronizar a linguagem Groovy através de Java
Community Process da Sun. Guillaume é a “cara pública” do Groovy e freqüentemente é
entrevistado a respeito do Groovy e apresenta o seu projeto em conferências como JavaOne
2006, onde ele falou sobre como linguagens de script podem simplificar o desenvolvimento
corporativo. Na sua vida profissional, Guillaume é arquiteto de software na empresa OCTO
Technology, uma consultoria francesa focada na arquitetura de software e sistemas de informação,
assim com em metodologias ágeis.
JON SKEET é um adepto recente do Groovy, mas esteve ajudando os desenvolvedores de
software através dos esforços da comunidade durante vários anos, principalmente por meio dos
grupos de notícias, do seu site de artigos sobre C# e Java e, mais recentemente, pelo seu blog
sobre as práticas de desenvolvimento de software. Jon é MVP Microsoft desde 2003 pela sua
contribuição à comunidade C#, e adora ver como os mundos .NET e Java têm constantemente
aprendido algo um do outro. Um dia talvez exista um equivalente para C# em Groovy. No meio
tempo, Jon está aguardando pelo tão distante dia quando poderá ensinar a programação em
pares para os seus filhos gêmeos, que nasceram enquanto este livro estava sendo escrito. Até
então, Jon espera que o seu filho mais velho, Tom, saiba mais sobre a computação do que o seu
pai.
APÊNDICE C
Referências rápidas de GDK API
XXIII
sobre o título
Combinando as introduções, visões gerais e exemplos de como fazer, a série de livros Em Ação
(in Action) são desenhados para ajudar a aprender e lembrar. De acordo com os estudos da
ciência cognitiva, as coisas que as pessoas lembram são aquelas que elas descobriram durante a
exploração automotivada.
Embora na editora ninguém seja cientista cognitivo, estamos convencidos de que, para o
aprendizado se tornar permanente, ele deve passar por estágios de exploração, brincadeira e,
interessantemente, recontar o que está sendo aprendido. As pessoas entendem e lembram as
coisas novas, mas apenas as dominam depois de explorá-las ativamente. Os humanos aprendem
em ação. A parte essencial de um guia Em Ação é que ele é guiado por exemplos. Isso encoraja
o leitor a experimentar as coisas, brincar com o código novo e explorar novas idéias.
Existe outra razão, mais cotidiana, para o título deste livro: nossos leitores são ocupados. Eles
usam os livros para fazer um trabalho ou para resolver um problema. Eles precisam de livros
que lhes permitem entrar e sair rapidamente e aprender somente aquilo que querem. Eles
precisam de livros que os ajudem em ação. Os livros desta série são feitos para esses leitores.
XXIV Groovy em Ação
sobre a ilustração da capa
A figura na capa de Groovy em ação é uma “Danzerina del Japón”, uma dançarina japonesa
tomada de um compêndio de roupas regionais publicado pela primeira vez em Madrid em
1799. Embora o artista possa ter capturado “o espírito” de uma dançarina japonesa, a ilustração
não é precisa nos olhares, roupas ou comportamento de uma mulher japonesa ou gueixa daquela
época, quando comparada aos desenhos japoneses do mesmo período. O trabalho artístico desta
coleção certamente não foi pesquisado detalhadamente!
A página de título do livro diz:
Coleccion general de los Trages que usan actualmente todas las Nacionas Del Mundo desubierto, dibujados
y grabados con la mayor exactitud por R.M.V.A.R. Obra muy util y en special para los que tienen la del
viajero universal.
O que nós traduzimos, tão literalmente quanto possível, como:
Coleção geral de trajes que usam todas as nações do mundo conhecido, desenhados e impressos
com a maior exatidão por R.M.V.A.R. Obra muito útil especialmente para aqueles que se têm
como viajantes universais.
Embora não se saiba nada sobre os desenhistas, gravadores e trabalhadores que ilustraram essa
coleção à mão, a “exatidão” da sua execução é evidente neste desenho. A “Danzerina del Japón”
é apenas uma das figuras dessa coleção colorida. Viajar por prazer era um fenômeno relativamente
novo naquela época e os livros como esse eram populares; apresentando tanto ao turista como ao
viajante os habitantes exóticos, reais e imaginários, de outras partes do mundo.
As maneiras de se vestir mudaram desde então e a sua diversidade nacional e regional, tão rica
naquele tempo, desapareceu. É freqüentemente difícil hoje em dia diferenciar o habitante de
um continente do outro. Talvez, olhando de um ponto de vista mais otimista, tenhamos trocado
a diversidade cultural e visual por uma vida pessoal mais variada. Ou por uma vida intelectual
e tecnológica mais variada e interessante.
Nós da Manning celebramos a criatividade, a iniciativa e a diversão do negócio computacional
com a abrangência do livro baseada na rica diversidade da vida regional de dois séculos atrás,
trazida de volta à vida pelas imagens desta coleção.