Sintaxis del filtro de Grails, o, Cómo llamar a un filtro de Grails fuera de Grails

Question

Grails proporciona filters que se ejecuta antes que sus controladores. Están definidas en las clases que se ven así:

class SecurityFilters { 
    def filters = { 
     myFilter(controller:'*', action:'*') { // What are those weird colons?? 
      print "I'm filtering!" 
      // Code that does the filtering goes here 
     } 
    } 
} 

Estos gran trabajo pero me gustaría entender la sintaxis mejor, ya que no se parece a ningún código maravilloso que he visto antes. En particular, la línea de arriba que comienza con myFilter parece muy extraña. ¿Es esta una definición de método para un método llamado myFilter? Si es así, ¿qué significa :'*' después de cada parámetro? Pensé que podría ser un valor de parámetro predeterminado, pero eso sería ='*'. He visto parámetros nombrados utilizando dos puntos en el método llamadas a anteriormente, pero esta no podría ser una llamada a un método porque no he definido myFilter() en ningún otro lado.

Creo que entendería mucho mejor si alguien pudiera decirme cómo ejecutar el código de filtrado de una clase normal de Groovy. En otras palabras, si tengo un archivo MyFilters.groovy que contiene las líneas de arriba, ¿cómo podría terminar este código de Groovy para que se imprima "Estoy filtrando"?

import MyFilters 
def mf = new MyFilters() 
mf.filters.somethingGoesHere // Help! How do I finish this line so it calls my filtering code? 

Answer 1

El siguiente código Groovy imprimiría "estoy filtrando!":

class SecurityFilters { 
    def filters = { 
     myFilter(controller:'*', action:'*') { // What are those weird colons?? 
      print "I'm filtering!" 
      // Code that does the filtering goes here 
     } 
    } 
} 

class FilterDelegate { 
    def methodMissing(String methodName, args) { 
     // methodName == myFilter 
     // args[0] == [controller:*, action:*] 
     // args[1] == {print "I'm filtering!"} 
     args[1].call() 
    } 
} 

def sf = new SecurityFilters() 
def filtersClosure = sf.filters 
filtersClosure.delegate = new FilterDelegate() 
filtersClosure.call() 

En este ejemplo filtros es un cierre que llama a un método llamado myFilter y pasa un mapa y un cierre. Puede pensar en myFilter como:

myFilter([controller:'*', action:'*'], closure) 

El mapa puede contener claves como controlador, acción o uri. El comodín (*) se usa cuando Grails intenta hacer coincidir el URI de la solicitud HTTP cuando intenta determinar a qué cierre llamar.

Mi comprensión de cómo maneja Grails los filtros es que se utiliza una clase de cargador delegado. La clase de cargador proporciona un método MethodMissing y crea un FilterConfig para cada llamada de método dentro del cierre de filtros. Cuando se realiza una solicitud HTTP, Grails examina todos los objetos FilterConfig e intenta encontrar un ámbito coincidente (busca en el mapa un controlador, acción o uri y usa expresiones regulares para hacer coincidir comodines). Si encuentra una coincidencia, llama al cierre que se pasó al método en la clase de filtro.

Answer 2

No es fácil llamar a los filtros fuera de los griales porque dependen de una gran cantidad de tuberías que no se configurarán. La línea
myFilter (controlador: '', acción: '')
es una definición de método que tiene dos argumentos, un controlador y un patrón de acción. * significa aplicar este filtro a cualquier objeto del tipo de procedimiento. Por ejemplo, si queremos asegurarnos de que los usuarios no puedan crear nada a menos que estén autorizados, usaríamos el siguiente filtro. Controlador
: '*', acción: 'crear'
Esto significa que cada vez que se llama a una acción create, se ejecuta el código almacenado en ese cuerpo de función, pero para list, show o edit no se ejecuta ningún filtro. Si realmente quieres detalles, siempre puedes descargar el código fuente de los griales.
editar:
El código se compila ya que es una función definida en un filtro.