Spring AOP – @Before Advice Type
Spring AOP – @Before Advice Type
As we have discussed, AOP (Aspect-Oriented Programming) is one of the powerful features of the Spring framework. It complements the Object-Oriented Programming (OOPs). AOP provides some concepts and terminology, and Advice is one of them.
Advice: An action taken by an aspect at a particular join point is called Advice. In other words, an advice is an interceptor, retaining a chain of interceptors "around" the join point is called Advice. It represents the code that is executed by an aspect at a particular join point. There are three types of advice available in AOP: "around," "before" and "after" advice.
Before Advice: It is executed before a method is invoked. Also, it is performed before a join point, but it cannot prevent the execution flow proceeding to the join point.
Here, we are using the @Before annotation for declaring a method as before advice.
Example of @Before Advice
Let’s understand the @Before advice type with the help of an example. In this example, we are going to create the following Java classes step by step:
- Add Maven dependencies required in the project
Along with Spring dependencies, Spring AOP projects require one more dependency of AspectJ, which will be added inside the pom.xml.
Below is given the dependency of AspectJ:
pom.xml
aspectj aspectjweaver 1.5.4
- Create the DAO class
In this step, we are going to create a DAO class named StudentAccountDao.java, that contains the actual business logic of the application.
StudentAccountDao.java
import org.springframework.stereotype.Component; @Component public class StudentAccountDao { public void newAccount() { System.out.println(getClass() + " : To open a new acount" ); } }
- Create the Class that performs component scanning
In this step, we are going to create a class that performs component scanning. We use @EnableAspectJAutoProxy annotation that enables support for handling components marked as @Aspect.
DemoAOP.java
import org.springframework.context.annotation.ComponentScan; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.EnableAspectJAutoProxy; @Configuration @EnableAspectJAutoProxy @ComponentScan(" com.app.SpringAspectOP ") public class DemoAOP { }
- Create the Aspect class
In this step, we are going to create an aspect class named AspectClass that contains the aspect logic, such as all AOP advice types that are defined in this class.
AspectClass.java
import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Before; import org.springframework.stereotype.Component; @Aspect @Component public class AspectClass { @Before("execution(public void newAccount())") public void BeforeNewAccount() { System.out.println( " @Before Advice - Executing the @Before advice " ); } }
- Create the main class
In this step, we are going to create the main class named App.java that contains the main method.
App.java
import org.springframework.context.annotation.AnnotationConfigApplicationContext; public class App { public static void main( String[] args ) { AnnotationConfigApplicationContext appcontext = new AnnotationConfigApplicationContext(DemoAOP.class); StudentAccountDao studacc = appcontext.getBean("studentAccountDao", StudentAccountDao.class); studacc.newAccount(); appcontext.close(); } }
Output
In the following output we can see that @Before advice is executed before executing the actual method.