Apache Servicemix :: Bundles :: Spring AOP framework introduction and use tutorial
Apache Servicemix :: Bundles :: Spring AOP framework introduction and use tutorial
The Spring framework is a lightweight Java development framework that provides a series of powerful functions and tools to build an enterprise -level application.One of them is the Spring AOP (facing the cut -off programming) framework, which allows developers to dynamically weave extra behavior into the code by runtime to achieve the separation of horizontal section attention points.
A core concept of Spring Aop is cut surface, which is a modular unit that is used to encapsulate and cross -cutting the behavior.The cut surface can contain points and notifications.The cut point defines which connection points in the application will be intercepted, and the notification determines the specific behavior to be executed when the cut point is intercepted.The notification can be executed when the method is executed before/after the method is thrown abnormal.
In order to use the Spring AOP framework, you must first ensure that your project has introduced the corresponding Spring AOP dependencies.You can use Maven or Gradle to build tools to add dependencies.
Below is an example code using Spring AOP to perform the execution time of real -time monitoring of a segment of code:
Add the following dependencies to pom.xml:
<dependencies>
<!-- Spring AOP -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>5.3.10</version>
</dependency>
</dependencies>
Create a timer cutting surface Timeloggeraspect.java:
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
@Aspect
@Component
public class TimeLoggerAspect {
@Pointcut("execution(* com.example.myapp.services.*.*(..))")
private void timeLoggerMethods() {}
@Before("timeLoggerMethods()")
public void logStartTime() {
System.out.println ("Method Start Time:" + System.Currenttimemillis ());
}
@After("timeLoggerMethods()")
public void logEndTime() {
System.out.println ("Method Ending Time:" + System.Currenttimemillis ());
}
}
In the above code, we define a cut point `TimeloggerMethods ()`, it matches coming from coming.Then, in the @BeFore notification, print the current time as the start time before the method execution; in the @AFTER notification, the current time is printed as the end time after the method execution.
Next, we need to enable Spring Aop in the Spring configuration file.Create a file called ApplicationContext.xml, and add the following:
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<context:component-scan base-package="com.example.myapp" />
<aop:aspectj-autoproxy />
</beans>
In the configuration file above, we use the `Context: Component-SCAN>` to specify a package that needs to be scanned to ensure that the Spring can identify the existence of the cut surface.Then use the `AOP: Aspectj-Autoproxy>` to enable the Spring Aop.
Finally, add the following code at the entrance of your application, such as your main class:
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Main {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
MyService myService = context.getBean(MyService.class);
myService.doSomething();
}
}
In the above code, we loaded the Spring configuration file and obtained the instance of MyService, and then called the `dosomething () method.During the execution process of the method, the start time and end time of the method will be intercepted by TimeLoggeraspect.
The above is a simple example of using the Spring AOP framework to implement the timing function.For more detailed Spring AOP usage, please refer to the official Spring document.
