Aspect-Oriented Programming (AOP) in Spring Boot

What is the main purpose of AOP in Spring Boot?

In Spring AOP, what does the term Join Point refer to?

Which of the following is not a valid advice type in Spring AOP?

What does this aspect do?

@Aspect
@Component
public class LoggingAspect {
    @Before("execution(* com.example.service.UserService.*(..))")
    public void logBefore() {
        System.out.println("Before method in UserService");
    }
}

Which pointcut expression matches all methods in all classes under com.app.repository package?

What does this @Around advice do?

@Around("execution(* com.example.service.PaymentService.*(..))")
public Object logExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable {
    long start = System.currentTimeMillis();
    Object result = joinPoint.proceed();
    long end = System.currentTimeMillis();
    System.out.println("Execution time: " + (end - start) + " ms");
    return result;
}

What is the purpose of this advice?

@AfterThrowing(
    pointcut = "execution(* com.example.service.OrderService.*(..))",
    throwing = "ex")
public void logException(Exception ex) {
    System.out.println("Exception caught: " + ex.getMessage());
}

How does Spring AOP implement aspects internally by default?

If multiple aspects apply to the same join point, how can their execution order be controlled?

What does the following code achieve?

@Pointcut("execution(* com.example.controller.*.*(..))")
public void controllerMethods() {}

@Before("controllerMethods()")
public void logBeforeController() {
    System.out.println("Controller method invoked");
}