TOC

Uma Introdução ao Grails 3 e GORM

Uma Introdução ao Grails 3 e GORM

1. Visão geral

Esta é uma introdução rápida ao Grails 3 e GORM.

Vamos, é claro, usar Groovy e - implicitamente - a estrutura também usa Hibernate para ORM, Spring Framework para injeção de dependência, SiteMash para layout e temas, etc.

2. Configuração do DataSource

Podemos começar sem precisar especificar nenhuma configuração explícita da fonte de dados - por padrão, o Grails usa o banco de dados HSQLDB para os ambientes de desenvolvimento e teste.

Mas se você quiser alterar esses padrões, você pode definir sua fonte de dados selecionada noapplication.yml: 

environments:
    development:
        dataSource:
             driverClassName : "com.mysql.jdbc.Driver"
             url : "jdbc:mysql://localhost:8080/test"
             dialect : org.hibernate.dialect.MySQL5InnoDBDialect

Da mesma forma, podemos criar vários ambientes aqui, ao lado dedevelopment, se necessário.

3. Domínio

Grails é capaz de criar a estrutura de banco de dados para nossas classes de domínio, com base na propriedadedbCreate na configuração do banco de dados.

Vamos definir uma dessas classes de domínio aqui: 

Class User {
    String userName
    String password
    String email
    String age
    static constraints = {
        userName blank: false, unique: true
        password size: 5..10, blank: false
        email email: true, blank: true
    }
}

Observe como estamos especificando nossovalidation constraints right in the model, o que mantém as coisas limpas e livres de anotações.

Essas restrições serão verificadas pelo Grails automaticamente quando a entidade estiver sendo persistida e a estrutura lançará exceções de validação apropriadas se alguma dessas restrições for quebrada.

Também podemos especificar mapeamentos GORM na propriedademapping do modelo: 

static mapping = { sort "userName" }

Agora, se chamarmosUser.list() - receberemos os resultadossorted by username.

É claro que poderíamos obter o mesmo resultado passando a classificação para a API da lista: 

User.list(sort: "userName")

4. Operações CRUD

Quando olhamos para as operações da API,scaffolding desempenha um papel muito interessante no início; permite gerar uma API CRUD básica para uma classe de domínio, incluindo:

  • As visões necessárias

  • Ações do controlador para as operações CRUD padrão

  • Dois tipos: Dinâmico e Estático

Veja como isso funciona com andaimes dinâmicos:++ 

class UserController {
    static scaffold = true
}

Ao escrever essa linha única, o framework gerará 7 métodos em tempo de execução: mostrar, editar, excluir, criar, salvar e atualizar. Eles serão publicados como a API para essa entidade de domínio específica.

Exemplo de andaime estático:

  • Para criar uma vista com andaime, use: “grails generate-views User“

  • Para criar o controlador e a visualização com andaime, use: “grails generate-controller User“

  • Para criar tudo em um único comando, use: “grails generate-all User“

Esses comandos geram automaticamente o encanamento necessário para esse objeto de domínio específico.

Vamos agora dar uma olhada rápida no uso dessas operações - por exemplo, para nosso objeto de domínioUser.

Paracreate new “user” record: 

def user = new User(username: "test", password: "test123", email: "[email protected]", age: 14)
user.save()

Parafetch a single record:++ 

def user = User.get(1)

Esta APIget recuperará o objeto de domínio em um modo editável. Para um modo somente leitura, podemos usar a APIread: 

def user = User.read(1)

Paraupdate existing record: `++` 

def user = User.get(1)
user.userName = "testUpdate"
user.age = 20
user.save()

E uma operação de exclusão simples para um registro existente:++ 

def user = User.get(1)
user.delete()

5. Consultas GORM

5.1. find

Vamos começar com a APIfind: 

def user = User.find("from User as u where u.username = 'test' ")

Também podemos usar uma sintaxe diferente para passar o parâmetro: 

def user = User.find("from User as u where u.username?", ['test'])

Também podemos usar um parâmetro nomeado: 

def user = User.find("from User as u where u.username=?", [username: 'test'])

5.2. findBy

O Grails fornece um recurso localizador dinâmico que usa propriedades de domínio para executar uma consulta em tempo de execução e retornar o primeiro registro correspondente: 

def user = User.findByUsername("test")
user = User.findByUsernameAndAge("test", 20)
user = User.findByUsernameLike("tes")
user = User.findByUsernameAndAgeNotEquals("test", "100")

Você pode encontrar mais expressõeshere.

5.3. Critério

Também podemos recuperar dados usando alguns critérios flexíveis: 

def user = User.find { username == "test"}
def user = User.createCriteria()
def results = user.list {
    like ("userName", "te%")
    and
    {
        between("age", 10, 20)
    }
    order("userName", "desc")
}

Uma observação rápida aqui - ao usar uma consulta de critério, use "\ {}" em vez de "()".

5.4. Executar consulta / atualização

O GORM também suporta a sintaxe de consulta HQL - para operações de leitura: 

def user = User.executeQuery(
  "select u.userName from User u where u.userName = ?", ['test'])

Bem como operações de gravação:++ 

def user = User.executeUpdate("delete User u where u.username =?", ['test'])

6. Conclusão

Esta foi uma introdução muito rápida ao Grails e ao GORM - para ser usada como um guia para iniciar o framework.

Related