AOP per tutti i metodi in un pacchetto

Question

Sto utilizzando AOP per la prima volta. Ho scritto il codice AOP qui sotto che funziona bene quando lo uso per intercettare un particolare metodo.

Qualcuno può guidarmi: come posso configurarlo per intercettare tutti i metodi in un determinato pacchetto (com.test.model)?

Fondamentalmente come configurare appcontext.xml.

Inoltre, devo fare qualcosa di simile per chiamare prima di chiamare ogni metodo?

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

Qualcuno può aiutare?

Per favore fammi sapere se sono necessarie ulteriori spiegazioni.

Qui di seguito è il mio codice:

Interfaccia:

package com.test.model; 

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

public interface AopInterface { 


    @Autowired 
    void addCustomerAround(String name); 
} 

Classe:

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

Basta mettere:

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

Il formato di un'espressione esecuzione è:

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

dove solo ret-type-pattern, sono richiesti name-pattern e param-pattern, così almeno noi bisogno di un'espressione come:

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

• ret-type-pattern corrisponde il tipo di ritorno, * per qualsiasi
• name-pattern corrisponde il nome del metodo, è possibile utilizzare * come jolly e .. per indicare il sub-pacchetto
• param-pattern partite i parametri del metodo, (..) per qualsiasi numero di parametri

Puoi trovare maggiori informazioni qui: 10. Aspect Oriented Programming with Spring, ci sono alcuni utili examples.