AOP für alle Methoden in einem Paket

Question

Ich verwende AOP zum ersten Mal. Ich habe den folgenden AOP-Code geschrieben, der gut funktioniert, wenn ich ihn zum Abfangen einer bestimmten Methode verwende.

Kann mir jemand helfen - wie kann ich es einrichten, um alle Methoden in einem bestimmten Paket abzufangen (com.test.model)?

Grundsätzlich, wie appcontext.xml zu konfigurieren.

Muss ich auch etwas wie unten tun, um vor dem Aufruf jeder Methode zu rufen?

AopClass aoptest = (AopClass) _applicationContext.getBean("AopClass"); 
aoptest.addCustomerAround("dummy"); 

Kann jemand helfen?

Bitte lassen Sie mich, wenn etwas mehr Erklärung benötigt wird.

Unten ist mein Code:

Schnittstelle:

package com.test.model; 

import org.springframework.beans.factory.annotation.Autowired; 

public interface AopInterface { 


    @Autowired 
    void addCustomerAround(String name); 
} 

Klasse:

package com.test.model; 

import com.test.model.AopInterface; 
import org.springframework.stereotype.Component; 
import org.springframework.beans.factory.annotation.Autowired; 

@Component 
public class AopClass implements AopInterface { 

    public void addCustomerAround(String name){ 
     System.out.println("addCustomerAround() is running, args : " + name); 
    } 
} 

AOP:

package com.test.model; 

import java.util.Arrays; 

import org.aspectj.lang.ProceedingJoinPoint; 
import org.aspectj.lang.annotation.Around; 
import org.aspectj.lang.annotation.Aspect; 
import org.aspectj.lang.annotation.Pointcut; 



@Aspect 
public class TestAdvice{ 


    @Around("execution(* com.test.model.AopInterface.addCustomerAround(..))") 
     public void testAdvice(ProceedingJoinPoint joinPoint) throws Throwable { 

     System.out.println("testAdvice() is running!"); 


     } 
} 

appcontext:

<!-- Aspect --> 
    <aop:aspectj-autoproxy /> 
    <bean id="AopClass" class="com.test.model.AopClass" /> 
    <bean id="TestAdvice" class="com.test.model.TestAdvice" /> 

Answer 1

einfach gesagt:

@Around("execution(* com.test.model..*.*(..))") 

Das Format eines Ausführungs Ausdruck ist:

execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern) throws-pattern?) 

wo nur ret-type-pattern, name-pattern und param-pattern erforderlich sind, so zumindest wir brauchen einen Ausdruck wie:

execution(ret-type-pattern name-pattern(param-pattern)) 

• ret-type-pattern entspricht dem Rückgabetyp, * für jede
• name-pattern Spiele der Methodenname, können Sie * als Platzhalter verwenden und .. Unterpaket
• param-pattern Spiele zeigen die Methodenparameter, (..) für eine beliebige Anzahl von Parametern

Hier finden Sie weitere Informationen: 10. Aspect Oriented Programming with Spring, es gibt einige nützliche examples.