Go Academy · Aula

Hooks e escopos

Personalize consultas

Hooks e escopos é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Go Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Go Academy inclui 4 aulas no total.

Ganchos e escopos

O GORM oferece duas ferramentas de personalização: os ganchos executam código automaticamente em torno de eventos do ciclo de vida, e os escopos agrupam lógica de consulta reutilizável. Juntos, eles mantêm o acesso aos dados limpo e consistente.

O que são ganchos

Ganchos são métodos do seu modelo que o GORM chama antes ou depois de uma operação: BeforeCreate, AfterCreate, BeforeUpdate, BeforeDelete e outros.

Um gancho BeforeCreate

Defina um método com a assinatura correta no modelo. Aqui, definimos um UUID antes de o registro ser inserido.

func (u *User) BeforeCreate(tx *gorm.DB) error {
    u.UUID = uuid.NewString()
    return nil
}

Validação em ganchos

Retorne um erro de um gancho para interromper a operação. O GORM reverte a transação envolvente, portanto dados inválidos nunca chegam ao banco de dados.

func (u *User) BeforeSave(tx *gorm.DB) error {
    if u.Age < 0 {
        return errors.New("age cannot be negative")
    }
    return nil
}

Ganchos executados em uma transação

O argumento tx *gorm.DB é a transação que o GORM está usando. Se você gravar dados relacionados dentro de um gancho, use este tx para que tudo seja confirmado ou revertido atomicamente junto com a operação principal.

O que são os Scopes

Um escopo é uma função que recebe e retorna um *gorm.DB, encapsulando um fragmento de consulta. Você o aplica com db.Scopes(...) e o reutiliza em muitas consultas.

func ActiveUsers(db *gorm.DB) *gorm.DB {
    return db.Where("active = ?", true)
}

Aplicando os Scopes

Passe um ou mais escopos para Scopes. Eles podem ser compostos, permitindo combinar filtros de forma declarativa em uma consulta final.

db.Scopes(ActiveUsers, Recent).Find(&users)

Um gancho executável e uma simulação de escopo

O GORM precisa de um banco de dados, portanto este exemplo executável simula um gancho BeforeCreate e um filtro reutilizável semelhante a um escopo usando funções simples.

package main

import (
    "errors"
    "fmt"
)

type User struct {
    Name   string
    Age    int
    Active bool
}

func beforeCreate(u *User) error {
    if u.Age < 0 {
        return errors.New("age cannot be negative")
    }
    if u.Name == "" {
        u.Name = "anonymous"
    }
    return nil
}

func activeOnly(users []User) []User {
    var out []User
    for _, u := range users {
        if u.Active {
            out = append(out, u)
        }
    }
    return out
}

func main() {
    u := User{Age: 30, Active: true}
    if err := beforeCreate(&u); err != nil {
        fmt.Println("error:", err)
        return
    }
    fmt.Println("created:", u.Name)
    all := []User{u, {Name: "Lin", Active: false}}
    fmt.Println("active count:", len(activeOnly(all)))
}

Escopos para paginação

Um escopo comum gera a paginação a partir de um número de página, encapsulando Offset e Limit para que cada ponto de acesso de listagem use a paginação da mesma forma.

func Paginate(page, size int) func(*gorm.DB) *gorm.DB {
    return func(db *gorm.DB) *gorm.DB {
        return db.Offset((page - 1) * size).Limit(size)
    }
}

Ganchos versus lógica da aplicação

Os ganchos centralizam preocupações transversais, como marcas de data e hora, identificadores amigáveis e campos de auditoria. Mantenha a lógica de negócio complexa nos serviços, não nos ganchos, para que o comportamento permaneça previsível e fácil de testar.

Ignorando ganchos

Para operações em massa, você pode desativar os ganchos com db.Session(&gorm.Session{SkipHooks: true}). Isso acelera importações grandes, mas ignora suas validações; use esse recurso com cuidado.

Verificação rápida

Teste seus conhecimentos sobre ganchos e escopos.

Recapitulação

Você aprendeu sobre ganchos e escopos:

Os ganchos são executados em torno de eventos do ciclo de vida; retornar um erro interrompe a operação e reverte a transação
Os ganchos são executados dentro da transação por meio do argumento tx
Scopes são funções reutilizáveis *gorm.DB aplicadas com Scopes
Use escopos para filtros e paginação
SkipHooks ignora os ganchos em operações em massa

Perguntas Frequentes

A aula “Hooks e escopos” é grátis?

Sim — o texto completo de “Hooks e escopos” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Go Academy, atualize para CoddyKit PRO. O curso de Go Academy inclui 4 aulas no total.

O que vou aprender em “Hooks e escopos”?

Personalize consultas Você pratica Go Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Go Academy?

Nenhuma experiência prévia é necessária. Go Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Hooks e escopos”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Go Academy?

Sim. Cada aula de Go Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Go Academy