Qual é o conceito básico por trás dos ganchos?

Eu sou intermediário em PHP. Para aprimorar minhas habilidades, começo a aprender o Drupal 7. Enquanto aprendia os conceitos da arquitetura do Drupal, os termos ganchos e bootstrapping me intrigaram bastante. Eu li o livro "Pro Drupal development" e alguma documentação em drupal.org, mas é muito avançado para mim aprender como os ganchos funcionam no Drupal para exibir a página da web.

Alguém pode me dizer o que são ganchos em palavras simples?

As outras respostas são ótimas, precisas, detalhadas, mas não tenho certeza de que sejam as "palavras simples" que explicam os ossos do conceito que o solicitante estava procurando.

Penso em ganchos como um ponto em que o código pausa e grita "Mais alguém tem algo a acrescentar aqui? ". Qualquer módulo pode ter uma função que responda a isso e é acionado com os dados apropriados passados ​​para ele naquele ponto do código.

Um bom exemplo direto é hook_node_delete () . Qualquer módulo pode usá-lo para fazer as coisas acontecerem toda vez que um nó é excluído. Os documentos informam que esse gancho transmite ao módulo o objeto do nó excluído para o qual trabalhar e descreve outras informações úteis, como o momento exato em que é chamado (por exemplo, antes de os dados do nó serem realmente excluídos do banco de dados) e onde no código do Drupal o gancho é chamado (que pode ser mais de um local).

Você pode explorar quais ganchos existem e descobrir quais dados são passados ​​para eles, explorando coisas que começam com "hook_" na API do Drupal .

Os ganchos funcionam de acordo com as convenções de um nome: usando hook_node_deletecomo exemplo, quando o processo de exclusão do nó atingir o ponto em que o gancho é chamado, para cada módulo com uma função como essa em [modulename]_node_delete()que a palavra gancho no nome do gancho é substituída pelo nome do módulo (por exemplo, my_amazing_module_node_delete()), essas funções são chamadas.

Por quê? Portanto, qualquer módulo pode fazer qualquer coisa nesses pontos-chave: por exemplo, você pode olhar para o nó excluído e fazer coisas se ele atender a uma determinada condição (por exemplo, envie um email para um administrador ou inicie algum processo longo).

Alguns ganchos permitem alterar as coisas que foram geradas antes de serem processadas. Por exemplo, hook_menu_alter () passa os itens de menu atuais que o sistema gerou. Qualquer módulo pode definir uma função some_modulename_menu_alter () e examiná-los, alterá-los opcionalmente (excluir alguns, adicionar alguns, classificá-los ...) e passar o menu recém-alterado novamente.

É simples, realmente poderoso e está no centro de como o Drupal funciona como um sistema modular. As implementações de ganchos estão no coração da maioria dos módulos Drupal.

Ao examinar o código de um módulo Drupal, você pode identificar quais funções são provenientes de ganchos (em oposição a funções que são simplesmente chamadas de dentro do próprio código do módulo), pois a comunidade Drupal impõe uma convenção na qual cada implementação de um gancho tem um comente assim à frente dele (observe o bit "Gancho de implementos _..."):

/**
 * Implements hook_some_hook().
 *
 * Some descriptive summary of what this does
 */
function my_amazing_module_some_hook() {

Alguns módulos que atuam como APIs definem seus próprios ganchos. Por exemplo, o Views define muitos ganchos que permitem adicionar, ler e editar dados em vários pontos do processo de criação ou exibição de um view. Você pode encontrar informações sobre ganchos criados em módulos personalizados a partir de dois lugares (assumindo que o módulo siga as convenções etc.):

• O código e os comentários no modulename.api.phparquivo na pasta do módulo
• drupalcontrib.org - por exemplo, aqui está a lista dos módulos D7 em que eles têm informações e a página dos ganchos Views

O bootstrapping é, como outros explicaram, basicamente inicializando - não duplicarei as outras boas explicações claras.

Hooks, são principalmente implementações dos padrões Visitor e Observer .

Uma das implementações mais comuns de hooks é hook_menu , que permite que os módulos registrem novos caminhos dentro de um sistema Drupal.

function my_module_menu() {
  return array('myawesomefrontpage' => array(
    'page callback' => 'function_that_will_render_frontpage'
  ));
}

Um padrão muito frequente no Drupal é ter um [DATATYPE]_infogancho e um [DATATYPE]_info_altergancho. Se você deseja criar um novo tipo de campo, implementará o relevante field_info -hook e, se desejar manipular um existente, implementará o correspondente field_info_alter -hook.

Edit: Como aponta Chx de fora nos comentários, o padrão observador é objeto orientado, que Drupal 7 é ainda, na sua maioria, não. Existe, no entanto, uma página wiki, a programação do Drupal de uma perspectiva orientada a objetos (criada por JonBob em 4 de abril de 2005), que explica como o Drupal usa padrões de código orientados a objetos, apesar disso. É interessante notar que menciona observadores, mas não visitantes.

Nota sobre o Drupal 8 Isso ainda é bastante cedo e está sujeito a alterações, mas quero acrescentar que, embora os ganchos tenham sido por algum tempo o padrão de fato na adição de funcionalidades ao Drupal, o conceito de plugins se tornará muito mais visível no Drupal 8, e nos dará novas maneiras de interagir com o Core. Problema relevante e documentação .

Em termos leigos, ganchos são uma espécie de pontes que fornecem uma maneira de os módulos interagirem uns com os outros, alterar a estrutura e os dados uns dos outros, fornecer novos dados etc.

Na maioria dos casos, a palavra hook_nos nomes das funções é substituída pelo nome do seu módulo, e isso fornece uma maneira para o seu módulo acessar a operação de outro módulo. Por exemplo, um módulo principal do drupal chamado "nó" chama vários ganchos. Um deles é hook_node_updatechamado sempre que um nó existente é atualizado. Quando esse gancho é chamado, a mymoduleimplementação de seu módulo (digamos que chamamos ) hook_node_updateé chamada, o que, nesse caso, será uma função no arquivo .module do módulo chamado mymodule_node_update(Obviamente, essa função pode estar em qualquer arquivo na pasta do módulo, desde que também está incluído no arquivo .module). Esse gancho também receberá os parâmetros necessários (variáveis) que podem ser usados, modificados e / ou retornados à função que chamou o gancho.

Quando comecei a aprender Drupal, eu estava no mesmo barco que você está agora, é um pouco difícil de entender no começo, mas depois que você o entende, é tão simples e intuitivo. Boa sorte.

Um dos principais desenvolvedores escreveu um artigo chamado "Drupal programação sob uma perspectiva orientada a objetos" . É um bom trabalho explicar como os ganchos podem ser considerados como implementando muitos dos padrões de design comuns . A melhor explicação para ganchos vem do artigo:

O sistema de ganchos do Drupal é a base para sua abstração de interface. Ganchos definem as operações que podem ser executadas em ou por um módulo. Se um módulo implementa um gancho, ele celebra um contrato para executar uma tarefa específica ou retorna um tipo específico de informação quando o gancho é chamado. O código de chamada não precisa saber nada sobre o módulo ou a maneira como o gancho é implementado para obter um trabalho útil, invocando o gancho.

O Bootstrap é o processo pelo qual o Drupal passa para criar uma página, basicamente executando todo o código do núcleo, tema e módulo em ordem.
É basicamente como o Drupal inicializa e se prepara para fazer seu trabalho como CMS.

É inteligente, pois nos permite colocar ganchos em qualquer lugar em nossos módulos e temas, e o processo de inicialização garante que eles sejam executados no ponto certo.
Por exemplo, se você usar 'hook_form_alter' para adicionar uma caixa de seleção personalizada a um formulário, a inicialização do Drupal garantirá que ele execute esse código, pouco antes de renderizá-lo.

Um problema com a auto-inicialização é que todo o processo demora para ser executado, mesmo se você estiver retornando apenas uma pequena quantidade de dados. Ao usar o Drupal com o módulo de serviços como uma API e retornar muitas respostas XHTML ou JSON pequenas, a execução de todo o bootstrap não é muito eficiente. Algumas pessoas inteligentes estão procurando maneiras inteligentes de contornar isso no Drupal 8.

Mas, para renderizar páginas normais do Drupal, o processo de inicialização funciona muito bem, ele usa o sistema de cache Drupals para acelerar as coisas e fornece controle total sobre todas as partes do site. Se você achar seu site lento, sempre poderá usar algo como APC ou MemCached para ajudar a acelerar as coisas.

Espero que minha resposta seja precisa e explique as coisas simplesmente para você, não sou especialista, mas acho que é assim que funciona.

Bootstrap é o processo durante o qual o Drupal se inicializa; o processo inclui realmente:

• Definindo o erro e os manipuladores de exceção
• Inicializando o valor de algumas variáveis ​​globais especificadas contidas em $_SERVER
• Inicializando algumas variáveis ​​com init_set()
• Localizando a versão em cache da página para veiculação
• Inicializando o banco de dados
• Definindo os manipuladores que carregam arquivos quando uma classe ou interface não é encontrada
• Inicializando as variáveis ​​Drupal
• Inicializando a sessão PHP
• Inicializando a variável de idioma
• Carregando os módulos ativados

Algumas das operações que descrevi são específicas para o Drupal 7 ou superior, mas a maioria das operações é independente da versão do Drupal.

Um gancho é uma função PHP que pode ser chamada pelo Drupal, ou módulos de terceiros, quando necessário para executar uma tarefa. Em vez de ter uma lista prefixada de funções para chamar, a lista é construída verificando os módulos ativados e as funções que eles implementam.
Por exemplo, o Drupal usa hook_node_update(); quando um nó está sendo salvo com node_save () , o código a seguir é executado.

// Call the node specific callback (if any). This can be
// node_invoke($node, 'insert') or
// node_invoke($node, 'update').
node_invoke($node, $op);

O que o node_invoke () faz é o seguinte:

• Obtendo a lista de todos os módulos ativados
• Verificando se os módulos ativados possuem uma função cujo nome termina em "_node_update" e começa com o nome abreviado do módulo
• Chamando essa função, passando $nodecomo parâmetro

Os ganchos podem salvar seus próprios dados em um banco de dados ou alterar o valor retornado de uma função. O último caso é, por exemplo, o que acontece com hook_form_alter () , que altera o valor de $formpassado como referência a drupal_prepare_form () .

Os ganchos Drupal geralmente são chamados usando três funções:

• drupal_alter ()
• module_invoke ()
• module_invoke_all ()

drupal_alter()é a função usada para chamar ganchos específicos cujo objetivo é alterar os dados passados ​​como referência, como hook_form_alter () , hook_hook_info_alter () e hook_tokens_alter () .

Existem outras funções usadas para chamar ganchos, como, por exemplo node_invoke(), mas essas funções usam essencialmente uma das funções listadas anteriormente.

Hooks são pointcuts e module_invoke_allé o tecelão (infelizmente não somos claros na implementação e existem outras funções de tecelagem). Tanto quanto sei, o Drupal é o único sistema a implementar AOP com funções PHP.

Veja outra explicação sobre Como a AOP funciona no Drupal?

Se você quiser ver os ganchos que o Drupal permite, acesse api.drupal.org , vá até a caixa de pesquisa e digite 'hook_'. Isso fornecerá uma grande lista da maioria dos ganchos definidos pelo Drupal. Faça o mesmo para '_alter' e veja ainda mais.

A página Ganchos da API do nó oferece uma lista cronológica de todos os ganchos chamados durante as operações do nó. Você pode ver o módulo Nó e os sistemas de entidade e campo dando voltas um ao outro na chamada de ganchos.

Por exemplo, se você rolar para baixo e olhar para a seção node_load(): O módulo Nó fornecerá um hook_load () e passará o controle para o sistema da entidade que carrega alguns campos. Há uma série de ganchos de campo não listados e, quando isso termina, o sistema da entidade chama hook_entity_load(), antes de passar o controle de volta ao Node que chama hook_node_load().

Isso dá ao seu código a chance de atuar no nó em questão à medida que ele é carregado, peça por peça. Aprender esses ganchos, quando e por que eles são chamados faz parte da aventura da codificação Drupal. :-)

Outros sistemas também têm ganchos. Tais como hook_init()e hook_boot(). Isso chega à parte de inicialização da sua pergunta. hook_boot()é chamado pelo Drupal antes do carregamento do sistema de armazenamento em cache. Portanto, se seu módulo precisar fazer alguma coisa antes que o Drupal realmente seja iniciado e você queira que seu código seja executado independentemente do cache, você o implementará hook_boot(). Caso contrário, se você se preocupa apenas com páginas que não são armazenadas em cache, implementa hook_init().

Isso oferece a opção de implementar algo no início do processo de carregamento, antes que o Drupal seja totalmente inicializado, ao mesmo tempo em que oferece alguma flexibilidade sobre o ponto do processo que você deseja interceptar.

Se você precisar se certificar de que o Drupal foi inicializado até um determinado ponto antes de continuar, você pode ligar drupal_bootstrap(). Se você clicar nessa documentação, poderá ver os níveis de inicialização disponíveis, do nada a tudo.

E, finalmente, você pode ver algum código amplamente documentado para qualquer subsistema no projeto Exemplos .

Hooks são funções php, blocos de construção baseados nas convenções de nomenclatura "yourmodulename_hookname", que visam facilitar a capacidade dos desenvolvedores de criar módulos .

Os módulos são o negócio real, pois permitem funcionalidades CORE e personalizadas em seu sistema Drupal. Assim, os módulos são feitos de ganchos e, quando um módulo é ativado na instalação do Drupal, suas funções de ganchos podem ser chamadas de outros módulos, graças à função module.inc module_invoke_all ($ hook) ou module_invoke.

Portanto, para entender corretamente o que são ganchos, você deve realmente sujar as mãos e tentar o desenvolvimento de módulos. Para esse fim, comece baixando e experimentando alguns dos Exemplos para desenvolvedores do Drupal ; você também deve se familiarizar com a criação de módulos .

Aqui estão alguns exemplos úteis do Drupal para desenvolvedores mencionados acima:

exemplo de implementação hook_block_view () no módulo block_example

/**
 * @file examples/block_example/block_example.module line 127
 *
 * Implements hook_block_view().
 *
 * This hook generates the contents of the blocks themselves.
 */
function block_example_block_view($delta = '') {
  //The $delta parameter tells us which block is being requested.
  switch ($delta) {
    case 'example_configurable_text':
      // The subject is displayed at the top of the block. Note that it
      // should be passed through t() for translation. The title configured
      // for the block using Drupal UI supercedes this one.
      $block['subject'] = t('Title of first block (example_configurable_text)');

Este gancho dá acesso à criação de blocos do Drupal para exibir blocos personalizados em seu site. É possível porque o block.module possui uma função _block_render_block que permite que todos os módulos definam sua visualização hook_block (observe a última linha module_invoke):

/**
 * @file modules/block/block.module, line 838
 *
 * Render the content and subject for a set of blocks.
 *
 * @param $region_blocks
 *   An array of block objects such as returned for one region by _block_load_blocks().
 *
 * @return
 *   An array of visible blocks as expected by drupal_render().
 */
function _block_render_blocks($region_blocks) {
  ...
  foreach ($region_blocks as $key => $block) {
    ...
    $array = module_invoke($block->module, 'block_view', $block->delta);

Exemplo de implementação hook_menu () no módulo render_example

/**
 * @file examples/render_example/render_example.module line 22
 * 
 * Implements hook_menu().
 */
function render_example_menu() {
  ...
  $items['examples/render_example/arrays'] = array(
    'title' => 'Render array examples',
    'page callback' => 'render_example_arrays',
    'access callback' => TRUE,
  );

Esse gancho está vinculado ao sistema de roteamento de URL do Drupal e define padrões de URL com retornos de chamada de renderização associados usados ​​pelo seu módulo. É chamado a partir de system.module .

Sobre o bootstrap, basicamente, você só precisa saber que ele é executado em cada solicitação de página. Eu realmente recomendo que você leia esta resposta do stackoverflow , que explica como o bootstrap e os ganchos estão relacionados, mas separados.

Em relação à exibição da página da Web, a exibição em html do site do Drupal é obtida principalmente com matrizes de renderização e temas.

Em qualquer lugar que um módulo chamar module_implements () http://api.drupal.org/api/drupal/includes%21module.inc/function/module_implements/7, o Drupal acionará todas as funções nomeadas corretamente na ordem correta, com base no seu peso. Essas funções são chamadas de funções de gancho, porque na documentação dos módulos que usam implementos do módulo, você vê coisas como hook_menu (quando o menu chama todas as funções projetadas para retornar itens de menu). A palavra "gancho" só precisa ser substituída pelo nome do módulo que o implementa e o Drupal faz o resto.

Há também uma função drupal_alter () que dispara todas as funções alter nomeadas corretamente, com a intenção de permitir alterar as coisas que foram registradas anteriormente por outro gancho.

Geralmente, os alteradores passam os argumentos por referência, para que você possa editar o objeto diretamente, enquanto ganchos "normais" geralmente levam você a retornar coisas novas.

A idéia é que qualquer módulo (incluindo o seu) possa ser facilmente estendido, solicitando ao Drupal que chame todas as funções de gancho necessárias e recupere o que eles retornam para serem processados. O módulo que chama as funções de gancho não precisa saber nada sobre os módulos que implementam os ganchos, e os módulos que implementam o gancho realmente não precisam saber nada sobre o módulo que chama o gancho. A única coisa que os dois módulos precisam saber é a estrutura dos dados que estão sendo retornados ou alterados.

Na prática, os ganchos costumam ser usados ​​para:

• responder a eventos, como hook_user_login é chamado quando um usuário faz login
• registrar algo novo que possa ser usado para estender o sistema como hook_menu
• tema / render html ou construir / validar / enviar formulários

Você tem muitas respostas acima, mas eu quero dar uma resposta de maneira muito mais simples para entender o conceito muito básico por trás dos ganchos. Os ganchos são realmente funções integradas no núcleo drupal para gerenciar coisas diferentes e executam diferentes tarefas no núcleo. Você pode sincronizar suas próprias funções com essas funções integradas do núcleo drupal para adicionar sua funcionalidade em suas próprias funções chamando ganchos diferentes.

Espero que você entenda o ponto!

Para mim, é tudo sobre a função module_implements quando se trata de ganchos e núcleo (D7). Uma coisa que eu acho que é crucial entender é que, ao escrever um gancho para modificar alguma coisa, você nunca tem a última palavra no que acontece com as estruturas de dados com as quais está lidando. Seu gancho simplesmente entra na linha (fila) de funções que TAMBÉM agem nas mesmas estruturas de dados, sejam menus, links de menus, blocos, nós, usuários ou qualquer entidade ou elemento de renderização.

Então, para realmente ver seus ganchos serem utilizados da maneira esperada, você precisa saber ou estar ciente de onde você (seu gancho) está alinhado. Isso é determinado pelo peso da sua cápsula. O núcleo Drupal simplesmente chama os ganchos adequadamente nomeados na ordem crescente de peso e o que quer que aconteça com os dados acontece.

Escrevi ganchos antes que não tiveram nenhum efeito, apenas para descobrir, depois de horas de agitação na cabeça, que o peso do meu módulo era muito leve e os ganchos subseqüentes estavam efetivamente fazendo o que eu fazia ou totalmente ignorando tudo isso.

Um gancho bem escrito não "manuseia" ou "força" a si próprio para ser o último, mas "agrada a outros", garantindo que eles mantenham as estruturas de dados conforme o esperado pelos demais ganchos na linha.

E falando em "The Line" de ganchos. Ao longo dos anos, procurei coisas no Drupal no google, essa imagem parece ser uma boa representação do pré-processo e da lista de possibilidades de processos.

De uma maneira muito mais simples, os ganchos ajudam o desenvolvedor a alterar a funcionalidade existente de acordo com os requisitos sem fazer alterações no código existente. Mais como função abstrata em php.

Exemplo: você criou um módulo para reservar uma passagem de ônibus. De acordo com o seu código, se o bilhete for reservado uma vez, o local de retirada não é editável, o que era sua exigência para esse projeto. Suponha que seu amigo precise do mesmo módulo para requisitos semelhantes, com a exceção de que o usuário pode alterar o local de retirada. De alguma forma, ele precisa usar seu módulo e você não deseja que ele faça nenhuma alteração no código. Então você fornece uma interface (gancho no nosso caso) onde ele pode implementar suas alterações sem fazer alterações no seu módulo.

De drupal a drupal-7, temos ganchos para módulos, além de temas. Para saber como o gancho funciona, verifique drupal.org hooks para criar um gancho personalizado, verifique este link

Hooks. Permita que os módulos interajam com o núcleo do Drupal. O sistema de módulos do Drupal é baseado no conceito de "ganchos". Um gancho é uma função PHP chamada foo_bar (), onde "foo" é o nome do módulo (cujo nome de arquivo é, portanto, foo.module) e "bar" é o nome do gancho.