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

groovy filter

Question

Grails proporciona filtros que se ejecutan antes que sus controladores. Están definidos en 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
       }
   }
}

Funcionan muy bien, pero me gustaría entender mejor la sintaxis, ya que no se parece a ningún código de Groovy que haya 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 sería =''*'' . He visto parámetros nombrados utilizando dos puntos en las llamadas a métodos anteriores, pero esta no podría ser una llamada a un método porque no he definido myFilter() 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

No puede llamar fácilmente a los filtros fuera de los griales porque dependen de una gran cantidad de plomería que no se configurará. La línea
myFilter (controlador: '' '', acción: '' '')
es una definición de método que toma 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 de creación, se ejecuta el código almacenado en ese cuerpo de función, pero para la lista, mostrar o editar no se ejecutará 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.

Answer 2

El siguiente código de Groovy imprimirá "¡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, los filtros son un cierre que llama a un método llamado myFilter y pasa un mapa y un cierre. Puedes 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 usa 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.