How do I access parameters specified in a Java Aspect?

Question

I have an annotation called "@ProgressCheck" that we can put on a controller to check the progress of an application. If the application is already submitted or late, then it throws the user to a page appropriate for that situation.

The annotation interface is:

@Retention(RetentionPolicy.RUNTIME)
public @interface ProgressCheck {
}

The "implementation" of that annotation is something like:

@Around("execution(* *(..)) && args(session,..) && @annotation(com.foo.aspects.progress.ProgressCheck)")
public Object progressCheck(ProceedingJoinPoint pjp, HttpSession session) throws Throwable {

    Applicant applicant = this.applicationSessionUtils.getApplicant(session);
    Application application = this.applicationSessionUtils.getApplication(session);

    switch (this.applicantService.getProgress(applicant)) {
    case SUBMITTED:
        return this.modelAndViewFactory.gotoStatusPage(applicant, application);

    case LATE:
        return this.modelAndViewFactory.gotoDeadlineMissed(applicant, application);

    default:
    case IN_PROGRESS:
        return pjp.proceed();
    }
}

Based on values in the session and database, the annotation's "implementation" allows the user to proceed into a controller, or redirects them to another ModelAndView as appropriate.

I'd like to provide parameters to the annotation and then, in this "implementation" logic, use those parameters to further tune the decision. How, from this logic, without knowing where the annotation is applied, do I access those parameters? Or is there another approach I should be using?

Answer 1

The trick is to query the aspect's JoinPoint object to get annotation information about the method (or class or whatever) that's annotated. That's the glue I couldn't figure out.

Here's an example. First, the interface of the aspect. This annotation will only be applied to methods.

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface DayOfWeek {

    public String[] names();

}

Now the implementation of the aspect:

@Aspect
public class DayOfWeekAspect {

    public DayOfWeekAspect() {
    }

    @Around("execution(* *(..)) && args(session,..) && @annotation(edu.berkeley.jazztwo.aspect.ams.roles.DayOfWeek)")
    public Object dayOfWeek(ProceedingJoinPoint joinPoint, HttpSession session) throws Throwable {

        String[] names = this.getNames(this.getAnnotatedMethod(joinPoint));

        for (String name : names) {
            System.out.println("DayOfWeek:   " + name);
        }

        // Do whatever you want with the aspect parameters
        if (checkSomething(names)) {
            // in some cases, go to a different view/controller
            return new ModelAndView(...);
        }

        // Just proceed into the annotated method
        return joinPoint.proceed();
    }

    private Method getAnnotatedMethod(JoinPoint joinPoint) {
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        return methodSignature.getMethod();
    }

    private String[] getNames(Method method) {
        DayOfWeek aspect = method.getAnnotation(DayOfWeek.class);
        if (aspect != null) {
            return aspect.names();
        }
        return new String[0]; // no annotation, return an empty array
    }
}

Then apply the aspect to some method

@DayOfWeek(names = {"Monday", "Wednesday", "Friday"})
@RequestMapping(value = "foo", method = RequestMethod.GET)
public ModelAndView foo(...) {
    ...
}

Then, if you're like me, you scratch your head and wonder why it doesn't work. You finally remember (if you're using XML configuration) that you have to instantiate the bean somewhere in your configuration:

<bean id="dayOfWeekAspect" class="com.foo.bar.DayOfWeekAspect" />     

THEN you can invoke foo and it should print out Monday, Wednesday, and Friday.