Recently our team needed to measure the performance of a client’s application, which heavily depends on third API providers, such as Spotify, Yelp and TripAdvisor. Our goal was to mock the response from these providers in an easy way, which will later help us to measure the performance of the code base without concerning the […]
Recently our team needed to measure the performance of a client’s application, which heavily depends on third API providers, such as Spotify, Yelp and TripAdvisor. Our goal was to mock the response from these providers in an easy way, which will later help us to measure the performance of the code base without concerning the response time from the third party APIs.My immediate enlightenment was to get advantage of the Aspect Oriented Programming with the spring aop project. The idea is to intercept the calls to the external providers and execute a custom method which will fake their response.As usual this tutorial can be completed step by step or you can directly clone a simple demo project from https://github.com/boykodimitroff/aspectj-demoThe provided git project is a basic Spring Boot application with included Spring AOP dependency.Let’s take a look of the following classeu.dreamix.rest.RestController.java
package eu.dreamix.rest;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
/**
* Created by bdimitrov on 6/6/17.
*/
@RestController
@RequestMapping("/rest/")
public class SpotifyController {
@RequestMapping(value = "/spotify", method = RequestMethod.GET)
public ResponseEntity
As I mentioned at the beginning we are going to mock an existing functionality, so SpotifyController.java is just a basic rest controller with one method, the returned object of which will be mocked.
The meaningful work unit regarding our task is in the following class
eu.dreamix.aspect.SpotifyAspect.java
package eu.dreamix.aspect;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.ResponseEntity;
/**
* Created by bdimitrov on 6/6/17.
*/
@Aspect
@Configuration
public class SpotifyAspect {
@Pointcut("execution(* eu.dreamix.rest.SpotifyController.callSpotify(..))")
public void inSpotifyController() {}
@Around("inSpotifyController()")
public ResponseEntity mockSpotify() {
return ResponseEntity.ok("Mocked Spotify call");
}
}
Three terms needs clarification here. Aspect, advice and pointcut.
Aspect
The key unit of modularity in Object Oriented Programming is the class, whereas in Aspect Oriented Programming the unit of modularity is the aspect. For example, a logging module would be called AOP aspect for logging. An application can have any number of aspects depending on the requirement.
Advice
This is the actual action to be taken either before or after the method execution. This is an actual piece of code that is invoked during the program execution. There is third type of advice which we are going to use in our demo. It is the Around advice.
Pointcut
Pointcut defines at what point in the application, the associated advice should be applied. You can specify pointcuts using expressions or patterns.
Taking the theory in mind, let’s get back to our aspect.
The expression "execution(* eu.dreamix.rest.SpotifyController.callSpotify(..))" in the @Pointcut declaration tells the framework to catch the execution of a method with name callSpotify in a specified package regarding the return type(*) and method parameters(...). We can define various expressions according to our needs. For example * *.callSpotify(...) will catch all methods in all classes with name callSpotify.
The method marked with @Around annotation is our advice. This means that the real execution of the callSpotify method will be skipped and mockSpotify() method will be called instead. Other advices are @Before and @After which respectively will be called before or after the pointcut defined method and will not skip the method execution.
If you want to get deeper into Spring AOP you can check this very useful documentation.
Do you find the article useful? Have you used Spring AOP before and how?
Sign up for our newsletter and never miss an article
[mc4wp_form id=8036]
Manage Consent
To provide the best experiences, we use technologies like cookies to store and/or access device information. Consenting to these technologies will allow us to process data such as browsing behavior or unique IDs on this site. Not consenting or withdrawing consent, may adversely affect certain features and functions.
Functional
Always active
The technical storage or access is strictly necessary for the legitimate purpose of enabling the use of a specific service explicitly requested by the subscriber or user, or for the sole purpose of carrying out the transmission of a communication over an electronic communications network.
Preferences
The technical storage or access is necessary for the legitimate purpose of storing preferences that are not requested by the subscriber or user.
Statistics
The technical storage or access that is used exclusively for statistical purposes.The technical storage or access that is used exclusively for anonymous statistical purposes. Without a subpoena, voluntary compliance on the part of your Internet Service Provider, or additional records from a third party, information stored or retrieved for this purpose alone cannot usually be used to identify you.
Marketing
The technical storage or access is required to create user profiles to send advertising, or to track the user on a website or across several websites for similar marketing purposes.