Great question! I've tackled this exact scenario before when building reusable monitoring aspects for Spring applications, and there are a couple of clean ways to separate aspect logic from pointcut configuration in pure Java-based (@Configuration) setups—no XML required, and no need to scatter annotations across your codebase.

Approach 1: Use Spring's AOP API (Most Flexible & Explicit) #

This method fully decouples the aspect logic (what you want to do, e.g., monitoring) from the pointcut definition (which methods to target, via package/type matching). It’s ideal for framework developers providing reusable aspects, while app developers only need to tweak the pointcut rules.

Step 1: Create a Reusable Advice Class

First, build the core aspect logic without any AOP annotations—this is the part framework developers maintain:

import org.aspectj.lang.ProceedingJoinPoint;

public class MonitoringAdvice {
    // Your reusable monitoring logic (e.g., timing, logging)
    public Object monitorMethodExecution(ProceedingJoinPoint joinPoint) throws Throwable {
        long startTime = System.currentTimeMillis();
        try {
            // Let the target method execute
            return joinPoint.proceed();
        } finally {
            // Post-execution monitoring task
            long duration = System.currentTimeMillis() - startTime;
            System.out.printf("Method %s executed in %dms%n", 
                joinPoint.getSignature().toShortString(), duration);
        }
    }
}

Step 2: Configure Pointcut & Bind to Advice in @Configuration

App developers handle this part—define the pointcut using package/type matching expressions, then wire it to the advice:

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.aop.aspectj.AspectJExpressionPointcut;
import org.springframework.aop.support.DefaultPointcutAdvisor;

@Configuration
@EnableAspectJAutoProxy // Enable Spring's AOP proxy support
public class AppAopConfig {

    // Register the reusable advice as a bean
    @Bean
    public MonitoringAdvice monitoringAdvice() {
        return new MonitoringAdvice();
    }

    // Define your pointcut: Use AspectJ expressions for package/type matching
    @Bean
    public AspectJExpressionPointcut monitoringPointcut() {
        AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
        
        // Example 1: Match all methods in the com.app.service package (and sub-packages)
        pointcut.setExpression("execution(* com.app.service..*(..))");
        
        // Example 2: Match all classes implementing the UserService interface
        // pointcut.setExpression("within(com.app.service.UserService+)");
        
        // Example 3: Match all public methods in classes annotated with @Service
        // pointcut.setExpression("execution(public * (@org.springframework.stereotype.Service *).*(..))");
        
        return pointcut;
    }

    // Bind the pointcut and advice into an Advisor (Spring's term for an aspect + pointcut)
    @Bean
    public DefaultPointcutAdvisor monitoringAdvisor(MonitoringAdvice advice, AspectJExpressionPointcut pointcut) {
        DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor();
        advisor.setPointcut(pointcut);
        advisor.setAdvice(advice);
        return advisor;
    }
}

Approach 2: Annotated Aspect with Configurable Pointcut #

If you prefer using @Aspect annotations but still want to separate pointcut configuration, you can inject the pointcut expression via your configuration class:

Step 1: Build a Configurable @Aspect Class

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 ConfigurableMonitoringAspect {

    private final String pointcutExpression;

    // Inject the pointcut expression via constructor
    public ConfigurableMonitoringAspect(String pointcutExpression) {
        this.pointcutExpression = pointcutExpression;
    }

    // Dynamic pointcut referencing the injected expression
    @Pointcut(value = "#{@configurableMonitoringAspect.pointcutExpression}")
    public void monitoredMethods() {}

    // Advice bound to the dynamic pointcut
    @Around("monitoredMethods()")
    public Object monitor(ProceedingJoinPoint joinPoint) throws Throwable {
        // Same monitoring logic as before
        long startTime = System.currentTimeMillis();
        try {
            return joinPoint.proceed();
        } finally {
            long duration = System.currentTimeMillis() - startTime;
            System.out.printf("Monitored method %s took %dms%n", 
                joinPoint.getSignature().getName(), duration);
        }
    }
}

Step 2: Configure the Aspect in @Configuration

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@EnableAspectJAutoProxy
public class AppAopConfig {

    @Bean
    public ConfigurableMonitoringAspect configurableMonitoringAspect() {
        // App developer sets the pointcut expression here
        return new ConfigurableMonitoringAspect("execution(* com.app.repository..*(..))");
    }
}

Key Benefits of These Approaches #

• Full Separation: Framework teams maintain the aspect logic; app teams control which methods to target via pointcut expressions.
• No Annotation Scattering: Avoids missing annotations on methods/classes—use package/type matching to ensure consistent coverage.
• Pure Java Configuration: No XML context required, aligns with modern Spring best practices.

内容的提问来源于stack exchange，提问作者David Karlsen