Grails

Porque vale a pena aprender

• Framework Web MVC similar a RoR, CodeIgniter, Django e Play!
• Full-Stack
• Convention-Over-Configuration
• O ciclo de desenvolvimento é rápido
• Curva de aprendizado baixa
• Extensível via plugins, e existem muitos disponíveis
• Aplicar alterações em configurações e fontes não obriga a reiniciar o servidor
• Bem documentado (online e livros)

Ou seja, o difícil não é fácil

• Atualizar a versão do framework pode ser uma dor de cabeça.
• O framework decide muita coisa por você.
• IDEs às vezes mais atrapalham que ajudam.
• Dilema do Peter Parker.
• Grails ainda é focado apenas em servlet containers.(suporte ao Netty está previsto na v3.0)
• É obrigatório extremamente indicado aprender Groovy, GORM, Gradle e GVM.

É uma linguagem:

• Inspirada em linguagens como Python, Ruby e Smalltalk
• Que roda sobre a JVM
• Extende as funcionalidades do Java
• Dinâmica (type-checking E metaprogramming)
• Permite checagem de tipos estática

Integração de "mão dupla" com Java

1 - Permite o uso de bibliotecas e código Java

2 - Código fonte Groovy compila para bytecode Java

Features

Closures

def quadrado = {it**2}     // parâmetro implícito
println quadrado(5)        // retorna 25

def soma = { a, b -> a+b }
println soma(4, 10)        // retorna 14
                        

• Bloco anônimo de código delimitado por chaves.
• Tem acesso ao estado do escopo onde ele é executado.
• Maximiza o encapsulamento e expressividade / legibilidade.

Groovy Truth

Regra: tudo que não for nulo, vazio, zero (ou explicitamente FALSE, óbvio), será avaliado para TRUE

// True                      | // False
def a = true                 | def b = false
def numbers_full = [1,2,3]   | def numbers = []
def s = 'abc'                | def s = ''
def n = 1                    | def n = 0
def obj = new Object()       | def obj = null
                        

Elvis Operator

Forma reduzida do operador ternário

a ?: b
equivalente à
a != null ? a : b
                        

GStrings

// Múltiplas linhas
"""
Este é um
texto muito
longo
"""

// Interpolação de variáveis e expressões
"1 + 1 = ${1+1}"

// Expressões regulares
"12345 world!".replaceAll(/\d+/, 'Hello')
                        

Collections

// Estruturas nativas para manipulação de coleções

def list = [5, 6, 7, 8]

def range = 5..8

def map = [cidade:"Porto Alegre",
           estado:"RS",
           pais:"Brasil",
           cep:90000001]
map.get("cidade")    // "Porto Alegre"

                        

Traits e Mixins

trait FlyingAbility { String fly() { "I'm flying!" } }
trait WalkAbility { String walk() { "I'm walking!" } }

class Thing implements FlyingAbility { }
def a = new Thing()
assert a.fly() == "I'm flying!"

class Thing { }
def b = new Thing() as FlyingAbility
assert b.fly() == "I'm flying!"

def c = new Thing()
def d = c.withTraits FlyingAbility, WalkAbility
d.fly(); d.walk()
                        

@Mixins estão deprecated a partir da versão 2.3, em favor dos Traits.

Baby steps - do Java ao Groovy

Fonte: chrisdail.com

Criando uma aplicação Grails

// Cria a aplicação
~ grails create-app MinhaApp
                        

// Executa a aplicação
 ~ cd MinhaApp
 ~ grails run-app MinhaApp
                        

//// Convention-over-configuration
|- grails-app
|--- assets          // Conteúdo gerenciado pelo Asset Plugin
|--- conf            // Arquivos de configuração
|--- controllers
|--- domain
|--- i18n            // Internacionalização
|--- services
|--- taglib
|--- utils
|--- views           // Telas, templates
|- src
|--- groovy
|--- java
|- test              // Testes unitários
|- web-app           // Imagens, CSS, JS, HTML ...
                        

Views

• GSP (HTML mesclado com taglibs próprias e/ou do framework)
• Conceito de templates
• Permite scripts em Groovy
• Taglibs são muito simples
• Scaffolding

Scaffolding

// Scaffolding dinâmico, gera as GUIs para CRUD
// em tempo de execução:
//    index, show, edit, delete, create, save, update

class BookController {       | class AnotherController {
    static scaffold = true   |     static scaffold = Book
}                            | }

// Scaffolding estático: cria fisicamente os arquivos das
// interfaces CRUD, de acordo com o template padrão
~ grails generate-views [domain-class-name]
~ grails generate-all [domain-class-name]

// Customizar os templates:
~ grails install-templates
                        

// Exemplo de uso:

${flash.message}

                        

Assets pipeline *

• Otimização e organização do uso de recursos estáticos nas páginas.
• Atualização on-the-fly, alterações são disponibilizadas sem reload.
• Redução do tamanho das dependências, através da compressão, minificação e cache (UglifyJS).
• Dependências e ordem de carga são configuráveis diretamente nos CSS e JS.
• Suporte à compilação de recursos estáticos LESS, SASS/SCSS, Handlebars, Ember, CoffeScript.

* na versão 2.4 substituiu o plugin Resources

Controllers

// Gera um controller para CRUD (template pré-definido)
~ grails generate-controller [domain-class-name]

// Ou pode ser criado diretamente
package org.sample
class SampleController {
    def world() {
        render "Hello World!"
    }
}

// Por convenção, o mapeamento para as
// seguintes URL e view será:

Requisição -> grails-app/sample/world
Retorno    -> grails-app/views/sample/world.gsp

                        

Escopos

• servletContext -> compartilha entre toda a aplicação
• session -> apenas na sessão do usuário
• request -> objetos referentes à requisição corrente
• params -> mapa contendo os parâmetros passados no request
• flash -> temporário, mantém o conteúdo apenas até o próximo request

class SomeController {
    def find() {
        def findBy = params["findBy"]
        def appContext = request["foo"]
        def loggedUser = session["logged_user"]
    }
}
                        

UrlMappings

• Por convenção os mapeamentos são definidos no formato /controller/action/id
• As configurações são armazenadas no arquivo grails-app/conf/UrlMappings.groovy
• Permite agrupar ações que compartilham caminhos (2.3 em diante)
• É possível configurar redirecionamentos para URIs
• Mapeamento REST para controllers por convenção (2.3 em diante)

//
// Mapeamento padrão de uma aplicação recém criada
//
class UrlMappings {
        static mappings = {
        "/$controller/$action?/$id?(.$format)?"{
            constraints {
                // apply constraints here
            }
        }

        "/"(view:"/index")
        "500"(view:'/error')
        }
}
                        

Services

• Declarados em grails-app/services/
• Injetados nas classes que os utilizam
• Transacionais por padrão
• Singletons

Dê preferência por serviços para orquestrar interações entre recursos da aplicação (domain objects) ou externas (IO).

class SomeService {
    void someMethod(param) {
        // do something
    }
}
/******************************/
class FirstController {
    def someService

    def someAction() {
        try {
            someService.someMethod(params.id)
        } catch(e) {
            log.error e
        }
    }
}
                        

Persistência

• GORM == Hibernate sem dor
• grails-app/conf/DataSource.groovy
• Dynamic finders
• Criteria queries
• Database migrations
• Herança de domínios

/// DataSource.groovy
dataSource {
    pooled = true
}

hibernate {
    cache.use_second_level_cache = true
    cache.use_query_cache = false
    cache.region.factory_class=
            'org.hibernate.cache.ehcache.EhCacheRegionFactory'
}

environments {
    development {
        dataSource {
            dbCreate = "create-drop"
            url = "jdbc:h2:mem:devDb;MVCC=TRUE;LOCK_TIMEOUT=10000"
            driverClassName = "org.h2.Driver"
            ...
        }
    }
    production {
        dataSource {
             dbCreate = "update"
             url = "jdbc:postgresql://192.168.0.1/SOME_DATABASE"
             driverClassName = "org.postgresql.Driver"
             ...
        }
    }
}

class Book {
    String title
    static belongsTo = Author
    static hasMany = [authors : Author]
    static constraints = {name nullable: false}
}

class Author {
    String name
    static hasMany = [books : Book]
}

def a = new Author(name:"Author One")
a.addToBooks(new Book(title:"Book One"))
a.addToBooks(new Book(title:"Book Two"))
a.save()
                        

// Acesso direto por id
def book = Book.get(1)
// Dynamic Finders
def book = Book.findByTitle("Book One")
def books = Book.findByTitleIlike("Book%")
def books = Book.findByAuthor(Author.get(1))
// Where Queries
def query = Book.where{title like "Book%"}
def aQuery = query.where{authors {name == "Author One"}}
Book b = aQuery.find()
// Criteria Queries
def c = Book.createCriteria()
def results = c.list(max:4, sort:"title") {
    and {
        ilike("title", "Book%")
        authors{
            eq("name", "Author One")
        }
    }
    maxResults(10)
    order("holderLastName", "desc")
}
                        

Referências

• Grails
• Mr. Haki - Groovy and Grails Goodness
• Groovy - Site oficial
• e muitas outras fontes online ...