Logger AOP - 拦截对公共方法的所有调用

Question

I need to solve this:

In the LoggerAOP class, using Spring AOP, intercept all calls to the public methods annotated with the LogExecution annotation, and call the log method on the logger field with the intercepted method's name as the data argument.

    import org.aspectj.lang.*;
    import org.aspectj.lang.annotation.*;
    import org.springframework.context.annotation.*;
    import org.springframework.stereotype.Component;
    import org.springframework.beans.factory.annotation.*;
    import java.lang.annotation.*;
    import java.util.*;
    
    @Aspect
    @Component
    public class LoggerAOP {
        @Autowired private Logger logger;
        
        public void loggingAdvice(JoinPoint jp) {
    
        }
        
        public static void main(String[] args) {
            AnnotationConfigApplicationContext config = new AnnotationConfigApplicationContext();
            config.register(Config.class);
            config.refresh();
                
            NameRepository repository = config.getBean(NameRepository.class);
            System.out.println(repository.getNames());
        }
    }
@Component
class NameRepository {
    @LogExecution
    public List<String> getNames() {
        List<String> names = new ArrayList<>();
        names.add("John");
        names.add("Mary");
        return names;
    }
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@interface LogExecution {}

interface Logger {
    public void log(String data);
}

@Configuration
@EnableAspectJAutoProxy
@Import({LoggerAOP.class, NameRepository.class})
class Config {
    @Bean
    public Logger logger() {
        return (message) -> System.out.println(message);
    }
}

I'm new to Spring so I still have to learn a few things.

Answer 1

The code shared with the question works as a spring application without any issues. Based on the code shared, following aspect would advice all the public methods of beans annotated with @LogExecution within package rg.so and its subpackages. The code uses @Around advice.

@Around("@annotation(logExecution) && within(rg.so..*)")
public Object loggingAdvice(ProceedingJoinPoint pjp, LogExecution logExecution) {
    logger.log("Before method call :"+pjp.getSignature());
    Object obj = null;
    try {
        obj = pjp.proceed();
    } catch (Throwable e) {
        e.printStackTrace();
        logger.log("On error during method call :"+ pjp.getSignature());
    }
    logger.log("After method call :"+pjp.getSignature());
    return obj;
}

Official documentation to refer

Spring AOP: https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#aop

Around advice: https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#aop-ataspectj-around-advice

Writing good pointcuts: https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#writing-good-pointcuts