Introduction to Groovy

O que é Groovy
Groovy é uma linguagem ágil dinâmica
para a plataforma Java com muitas
funcionalidades inspiradas de
linguagens como Python, Ruby e
Smalltalk, disponibilizando tais
funcionalidades para os
desenvolvedores Java em uma sintaxe
muito semelhante a Java.

Comparado
Groovy
new File('.').eachFileRecurse { println it }

Java

import java.io.File;

public class ListFiles {

public static void main(final String... args) {
printFiles(new File("."));
}

private static void printFiles(final File file) {
System.out.println(file);
final File[] files = file.listFiles();
for (final File f : files) {
if (f.isDirectory()) {
printFiles(f);
} else {
System.out.println(f);
}
}
}
}

Fibonnacci
atual = 1
proximo = 1

10.times {
print atual + ' '
novo = proximo
proximo = atual + proximo
atual = novo
}

Importação Automática

Groovy importar automaticamente os
pacotes groovy.lang.*, groovy.util.*,
java.lang.*, java.util.*, java.net.*, and
java.io.*

Executando

• groovysh: Inicia o command-line shell, que é utilizado para
executar código Groovy interativamente. O código é
executado em tempo real, comando-a-comando."

• groovyConsole: Inicia a interface gráﬁca que também é
usada para executar código groovy interativamente; além
disso, o groovyConsole é carregado e executa os scripts
Groovy.

• groovy: Inicia o interpretador que executa scripts Groovy.

O compilador groovyc
groovyc –d classes Fibonacci.groovy

Fibonacci.class
Fibonacci$_run_closure1.class

java -cp $GROOVY_HOME/embeddable/groovy-all-1.0.jar:classes Fibonacci

Breve!

Java
java.net.URLEncoder.encode("a b");

Groovy
URLEncoder.encode 'a b'

Groovy Beans

• Métodos públicos por padrão
• Métodos de acesso por padrão
• Acesso simpliﬁcado a atributos de Beans

Groovy Beans
class Car {

String name

}

def car = new Car();

car.setName(‘Civic’);

car.getNome(); //Civic

Outer Field Access
class Bean {

public Integer value

def getValue() {

value + 1

}

}

def bean = new Bean();

bean.getValue(); //Inner Field Access

car.@value; //Outer Field Access

GStrings

def nick = 'Gina'

def book = 'Groovy in Action'

assert "$nick is $book" == 'Gina is Groovy in Action'

Números

def x = 1

def y = 2

assert x + y == 3

assert x.plus(y) == 3

assert x instanceof Integer

Listas

def nomes = [‘André’,‘Faria’]

assert nomes[1] == ‘Faria’

nomes[2] = ‘Gomes’

Mapas
def http = [

100 : 'CONTINUE',

200 : 'OK',

400 : 'BAD REQUEST' ]

assert http[200] == 'OK'

Intervalos (Ranges)
def x = 1..10

assert x.contains(5)

assert x.contains(15) == false

assert x.size() == 10

assert x.from == 1

assert x.to == 10

assert x.reverse() == 10..1

Null é False

if (null) {

assert false;

} else {

assert true;

}

For in

for (index in 1..10) {

}

For in

def list = [0,1,2,3,4,5]
for (item in list) {

}

Each

def list = [0,1,2,3,4,5]
list.each() { item ->

}

Size

Com Groovy sempre que é preciso saber
o tamanho de um objeto utiliza-se o
método size().

O Java varia entre length, size(),
getLength(), e groupCount().

Operadores
x+y Plus x.plus(y) Number, String, Collection

x-y Minus x.minus(y) Number, String, Collection

Number, String,
x++ Next x.next(y)
Range

Sobrecarga de
Operadores
class Dinheiro {

def valor

Dinheiro (valor) { this.valor = valor }

Dinheiro plus (Dinheiro other) {
new Dinheiro(this.valor + other.valor)
}

}

Dinheiro a = new Dinheiro(1)
Dinheiro b = new Dinheiro(10)
Dinheiro c = a + b

GStrings
me = 'Tarzan'

you = 'Jane'

line = "me $me - you $you"

assert line == 'me Tarzan - you Jane'

assert line instanceof GString

assert line.strings[0] == 'me '

assert line.strings[1] == ' - you '

assert line.values[0] == 'Tarzan'

assert line.values[1] == 'Jane'

Regex
def pattern = ~/foo/
assert pattern instanceof Pattern
assert pattern.matcher("foo").matches()
assert pattern.matcher("foobar").matches() == false

def cheese = ("cheesecheese" =~ /cheese/).replaceFirst("nice")
assert cheese == "nicecheese"
assert "color" == "colour".replaceFirst(/ou/, "o")

Numbers
10.times { /* code */ }

1.upto(5) { number -> /* code */ }

2.downto(-2) { number -> /* code */ }

valor = ''
0.step(0.5, 0.1) { number ->
valor += number + ' '
}
assert valor == '0 0.1 0.2 0.3 0.4 '

Ranges
range = 5..8
assert range.size() == 4
assert range.get(2) == 7
assert range[2] == 7
assert range instanceof java.util.List
assert range.contains(5)

range = 5..<8
assert range.size() == 3
assert range.get(2) == 7
assert range[2] == 7
assert range instanceof java.util.List
assert ! range.contains(8)

range = 1..10
assert range.from == 1
assert range.to == 10

Ordenação

def listOfCustumers = // ...

listOfCustumers.sort { custumer ->

custumer.dateOfTheFirstPurchase

}

Mapas
def myMap = [a:1, b:2, c:3]

assert myMap instanceof HashMap
assert myMap.size() == 3
assert myMap['a'] == 1

def emptyMap = [:]
assert emptyMap.size() == 0

def explicitMap = new TreeMap()
explicitMap.putAll(myMap)
assert explicitMap['a'] == 1

Any e Every do GDK

def map = [a:1,b:2,c:3]

assert map.every { entry -> entry.value < 10 }

assert map.any { entry -> entry.value < 2 }

FindAll

def map = [a:1,b:2,c:3]

def map2 = map.findAll { entry -> entry.value < 3}

assert map2.size() == 2

Find

def map = [a:1,b:2,c:3]

def x = map.find { entry -> entry.value == 2}

Closures

Closure envelope = { person ->

new Letter(person).send()

}

addressBook.each (envelope)

addressBook.each { new Letter(it).send() }

Closures it

new File('myfile.txt').eachLine { println it }

Import as

import thirdparty.MathLib as TwiceHalfMathLib

import thirdparty2.MathLib as IncMathLib

def math1 = new TwiceHalfMathLib()

def math2 = new IncMathLib()

assert 3 == math1.half(math2.increment(5))

GroovyObject
public interface GroovyObject {

public Object invokeMethod(String name, Object args);

public Object getProperty(String property);

public void setProperty(String property, Object newValue);

public MetaClass getMetaClass();

public void setMetaClass(MetaClass metaClass);

}

Also Interception and Proxies

XML Builder
def builder = new groovy.xml.MarkupBuilder();
builder.numeros {
descricao 'Numeros pares'
for (i in 1..10) {
if (i % 2 == 0) {
numero (valor: i, dobro: i*2 )
}
}
}

<numeros>
<descricao>Numeros pares</descricao>
<numero valor='2' dobro='4' />
</numeros>

Node Builder
def builder = new NodeBuilder();

def funcionarios = builder.funcionarios {

funcionario(nome:'André Faria') {
carro(marca:'Toyota', modelo:'Corolla')
}

funcionario(nome:'Bruno Lui') {
carro(marca:'Fiat', modelo:'Palio')
}

}

def donoDoPalio = funcionarios.grep {
it.carro.any { it.'@modelo' == 'Palio' }
}.'@nome'

print donoDoPalio //Bruno Lui

Ant Builder

TARGET_DIR = 'documentos'
FOTOS_DIR = 'fotos'
ant = new AntBuilder()

ant.delete(dir:TARGET_DIR)
ant.copy(todir:TARGET_DIR){
fileset(dir:FOTOS_DIR, includes:'*.doc', excludes:'~*')
}

Swing Builder
import groovy.swing.SwingBuilder

data = [
[nick:'MrG', full:'Guillaume Laforge' ],
[nick:'jez', full:'Jeremy Rayner' ],
[nick:'fraz', full:'Franck Rasolo' ],
[nick:'sormuras', full:'Christian Stein' ],
[nick:'blackdrag', full:'Jochen Theodorou' ],
[nick:'Mittie', full:'Dierk Koenig' ]
]

swing = new SwingBuilder()
frame = swing.frame(title:'Table Demo') {
scrollPane {
table() {
tableModel(list:data) {
propertyColumn(header:'Nickname', propertyName:'nick')
propertyColumn(header:'Full Name',propertyName:'full')
}
}
}
}
frame.pack()
frame.show()

Template
def mensagem = '''
Querido amigo ${destinatario}

Gostaria de pedir que me ajudasse a realizar essas ${tarefas.size} tarefas:

<% tarefas.each() { %> - ${it}
<% } %>
'''

def engine = new groovy.text.SimpleTemplateEngine();
def template = engine.createTemplate(mensagem);
def parametros = [
destinatario: 'Zé das Couves',
tarefas: ['comprar um ovo de páscoa', 'regar as plantas']
]

print template.make(parametros).toString()

Querido amigo Zé das Couves

Gostaria de pedir que me ajudasse a realizar essas 2 tarefas:

- comprar um ovo de páscoa
- regar as plantas

Groovylets
<!DOCTYPE web-app
PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.2//EN"
"http://java.sun.com/j2ee/dtds/web-app_2_2.dtd" >

<web-app>
<display-name>Groovlet Demonstrator</display-name>
<description>
Showing the use of Groovlets for Groovy in Action
</description>

<servlet>
<servlet-name>Groovy</servlet-name>
<servlet-class>groovy.servlet.GroovyServlet</servlet-class>
</servlet>

<servlet-mapping>
<servlet-name>Groovy</servlet-name>
<url-pattern>*</url-pattern>
</servlet-mapping>

</web-app>

Groovylets
html.html{
head { title 'Groovlet Demonstrator' }
body {
h1 'Variables in the Binding:'
table(summary:'binding') {
tbody {
binding.variables.each { key, value ->
tr {
td key.toString()
td(value ? value.toString() : 'null')
}
}
}
}
}
}

Groovylets + Templates
<html>
<head>
<title>Think of a Number</title>
</head>
<body>
<h1>Think of a Number</h1>
Your guess $guess is <%
switch (guess) {
case goal : out << 'correct!'; break
case {it < goal} : out << 'too low' ; break
case {it > goal} : out << 'too high'; break
}
%>
<p>What"s your guess (0..100)?</p>
<form action='Templater.groovy'>
<input type='text' name='guess'>
<button type='submit'>Guess</button>
<button type='submit' name='restart' value='true'>New Game
</button>
</form>
</body>
</html>

def engine = new groovy.text.SimpleTemplateEngine()
def source = getClass().classLoader.getResource('/Number.template.html')
def template = engine.createTemplate(source)
out << template.make(goal:50, guess:49)

Groovy Shell

final GroovyShell groovyShell = new GroovyShell();

final String result = (String) groovyShell.evaluate(" new File('.').eachFile { println it } ");

System.out.println(result);

Introduction to Groovy

More Related Content

What's hot

Similar to Introduction to Groovy

More from André Faria Gomes

Recently uploaded

Introduction to Groovy