PJP | Wipro Pre Joining Program using Project | Learning library

I am not a Spring user, so I cannot tell you

• if there is any way to influence the order of advisor application for any advised bean in a generic, non-invasive way,
• where exactly Spring creates the list of advisors associated with an advised bean while wiring the application.

What I did find out, however, is that once the list of advisors for an advised bean has been set, it is simply applied in the order of elements in the list. You can influence aspect precedence via @Order or implementing @Ordered, but I have no idea if that approach can somehow be applied to method validation advisors.

Because I was curious, I created a proof-of-concept, hacky workaround. Here is my MCVE replicating your original situation:

Service, controller and helper classes:

I inspected your project on GitHub, thanks for the link. There is so much wrong with it, I hardly know where to begin:

1. You committed library JARs instead of doing proper dependency management using Maven, Gradle or, if you insist to stay on Ant, something like Ivy. Dependencies should be downloaded during the build, not committed into a source code management (SCM) repository. Using Maven or Gradle also would have the advantage that IDEs like IntelliJ IDEA or Eclipse can automatically import your projects and also know where to find the dependencies and share them between projects, instead of you redundantly committing them to each of your project SCM repositories and manually adding them to your IDE project configuration. That is just ugly.

2. One of the JARs in your project is aspectj-1.9.6.jar. This is not what you want but an executable installer, the purpose of which is to install AspectJ locally. In there, you also find nested JARs such as aspectjrt.jar (runtime), aspectjtools.jar (compiler), aspectjweaver.jar (load-time weaving agent). You would have to execute that installer and then copy the libraries you need to your lib directory.

3. In order for the Java compiler to recognise your AspectJ imports, you need the AspectJ runtime on your classpath, i.e. you can download aspectjrt-1.9.6.jar from Maven Central (select "Downloads → jar" in the top right menu). Then you simply copy it to lib and add this to your Ant script:

Your pointcut

As it goes from Spring docs Spring AOP does support Spring beans' method execution join points. To make field access join points work you need to use AspectJ's backend with load time weaving for AOP.

But for your case it's not required to use field join points, you can put your annotation on the getter and this should work.

It's easier to do if you set it as json not html. This is what I did:

The problem is your code, you are creating instances of those rules yourself inside a bean method and expose them as a List. Which means the bean is of type List not your own SSRule and thus it won't work.

Instead make an @Bean method, or use the detected instance to inject into the list. As your SSRule is annotated you will already have an instance, just inject that into your @Bean method.

The correct answer to your question, even though you might not like it, is: Neither Spring AOP as a syntactical subset of AspectJ nor native AspectJ provide a dedicated syntax to achieve what you wish to do. The best you can actually do is to use a nested syntax like you suggested yourself and use a reasonable number of nesting levels.

In my answer here you find solutions for both class- and method-level meta annotations.

Update: You misunderstood what

Following aspect code would advice a target method annotated with @AnnotationName

When trying to recreate your situation, I had to

• guess about which libraries and versions you use,

• replace the Lombok logging annotation by a regularly created SLF4J logger, because, as the AspectJ compiler tells you in a warning message, Lombok's byte code modifications do not work with the AspectJ compiler: java: You aren't using a compiler supported by lombok, so lombok will not work and has been disabled. (...) Lombok supports: sun/apple javac 1.6, ECJ. When using Spring AOP instead, it probably works with Lombok, because there you are simply using the normal Java compiler. I however tested in native AspectJ.

• fix many syntax errors in your aspect and test Java code as well as several syntax errors in your aspect pointcuts. The classes did not even compile and the aspect cannot have done anything meaningful with faulty pointcuts. If you modify original code in order to create a stand-alone example, please test before posting it. You should have a little bit more pride as a developer when presenting your work publicly. This was your free shot, because you are new on SO, but next time I will just close the question.

Please do read the MCVE article, try to understand it and ask better questions in the future.