Wie erhalten Sie RequestMapping-Anfrage in AOP-Rat von einem Spring-Controller?

Question

eine Art von Steuerung mit einer Anfrage Mapping

@RequestMapping(value="/some/path", method=RequestMethod.POST) 

Gegeben Wie würden Sie die Methode Wert (RequestMethod.POST) in der Aspekte Klasse abrufen?

Ich möchte alle Controller-Methoden verfolgen, die eine POST-Anfrage ausführen.

Danke

Answer 1

Die Lösung gefunden.

import org.aspectj.lang.reflect.MethodSignature; 
import java.lang.reflect.Method; 

@Pointcut("within(@org.springframework.stereotype.Controller *)") 
public void controller() {} 

// In advice 
MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature(); 
Method method = methodSignature .getMethod(); 
RequestMethod[] requestMethods = method.getAnnotation(RequestMapping.class).method(); 

Achten Sie darauf, welche Klasse Sie importieren.

Answer 2

@ AL13N: Ihre eigene Antwort ist korrekt, aber Sie müssen keine Spiegelung verwenden, wenn Sie die Anmerkung nur an einen Parameter binden. Hier ist ein Beispiel in POJO + AspectJ. Im Frühjahr AOP sollte es das gleiche sein, aber:

Proben Controller mit Hauptmethode:

package de.scrum_master.app; 

import org.springframework.stereotype.Controller; 
import org.springframework.web.bind.annotation.RequestMapping; 
import org.springframework.web.bind.annotation.RequestMethod; 

@Controller 
public class MyController { 
    @RequestMapping(value="/some/path", method=RequestMethod.POST) 
    public void foo() { 
     System.out.println("foo"); 
    } 
    public void bar() { 
     System.out.println("bar"); 
    } 

    public static void main(String[] args) { 
     MyController controller = new MyController(); 
     controller.foo(); 
     controller.bar(); 
    } 
} 

Richtung:

package de.scrum_master.aspect; 

import org.aspectj.lang.JoinPoint; 
import org.aspectj.lang.annotation.Before; 
import org.aspectj.lang.annotation.Pointcut; 
import org.springframework.web.bind.annotation.RequestMapping; 

public aspect RequestMappingInterceptor { 
    @Pointcut(
     "within(@org.springframework.stereotype.Controller *) && " + 
     "@annotation(requestMapping) && " + 
     "execution(* *(..))" 
    ) 
    public void controller(RequestMapping requestMapping) {} 

    @Before("controller(requestMapping)") 
    public void advice(JoinPoint thisJoinPoint, RequestMapping requestMapping) { 
     System.out.println(thisJoinPoint); 
     System.out.println(" " + requestMapping); 
     System.out.println(" " + requestMapping.method()[0]); 
    } 
} 

BTW, der && execution(* *(..)) Teil des pointcut ist im Spring AOP wahrscheinlich nicht nötig, da es sowieso Ausführungspunkte kennt. In AspectJ müssen Sie call() und andere Arten von Pointcuts ausschließen, da AspectJ leistungsfähiger ist. Es tut aber nicht weh und ist sicherer und expliziter.

Console Ausgabe:

execution(void de.scrum_master.app.MyController.foo()) 
    @org.springframework.web.bind.annotation.RequestMapping(headers=[], name=, value=[/some/path], produces=[], method=[POST], params=[], consumes=[]) 
    POST 
foo 
bar 

Edit: Swapped Parameter, um dem joinpoint die erste Beratung Methodenparameter zu machen, weil Frühling AOP in dieser Größenordnung zu bestehen scheint, während AspectJ nicht der Fall ist.