CODEWITHSUNDEEP
spring-bootmockitospring-aop
gtludwig
gtludwig

Reputation: 5611

Is it worthy using AOP in a Spring-boot application?

A few days ago, I posted this question asking whether there is a newer approach to Spring AOP and mockito.

While I understand how to use AOP, I am still missing on its returned value. The whole endeavour has shown me that it's not really popular - at least there aren't that many recent posts.

If I comment out the annotations @Aspect and @Configuration in my LoggingAspect class, effectively rendering it non-aop, all my tests are green. If I switch it back on, I start getting a load of NullPointerExceptions and loads of other errors on my mocked test classes.

I wonder if it is worth the hassle.

EDIT adding more detail from my specific implementation.

Controller:

@RestController
public class EndpointController {

    private EndpointService endpointService;

    @Autowired    
    public EndpointController(EndpointService endpointService) {
        this.endpointService = endpointService;
    }

    @PostMapping(path = "/endpoint", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
    private @ResponseBody EndpointResponse doSomething(//... //, @RequestBody SomeObject someObject) throws Exception {
        return endpointService.doSomething(someObject);
    }
}

In my test class, I have:

@RunWith(SpringRunner.class)
public class EndpointControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @Test
    public void shouldBeSuccessfulAccessingTheEndpoint() throws Exception {
        SomeObject someObject = new SomeObject(// values //);

        ObjectMapper mapper = new ObjectMapper();
        String payload = mapper.writeValueAsString(someObject);

        mockMvc.perform(post("/endpoint").contentType(MediaType.APPLICTION_JSON).content(payload)).andExpect(status().isOK));
    }
}

It fails and throws a NullPointerException. When debugging, the endpointService is always null.

Upvotes: 0

Views: 95

Answers (2)

duffymo
duffymo

Reputation: 308763

AOP is as valid as ever. It's used for transactions, logging, metrics, etc.

I think there was period where it might have been overused as decorators.

Production and testing are different matters.

If you're unit testing a class, it suggests that you aren't testing the aspects. You could make those aspects conditional based on profile.

If the proper operation of your object depends on the aspect, because it modifies the input, perhaps you should rethink.

Upvotes: 1

Peter Walser
Peter Walser

Reputation: 15706

AOP is great for cross-cutting concerns:

  • Logging (we use it for access and performance logging)
  • Validation (such as used by Bean Validation, JSR-380)
  • Transactional scopes (built into frameworks such as JEE and Spring)
  • Security checks (e.g. Shiro)
  • and many more.

It could be used for other purposes, such as extending/wrapping existing functionality, though that is definitely not something I'd recommend, and fortunately never became popular, as it seems.

Upvotes: 1

Related Questions