Microservices with Spring Boot, Netflix OSS and Maven - Monolithic Build

In the overview post I mentioned that it's possible to pack all microservice into one application. This application is fully functionally, without the need of any change, without Eureka and without remote calls. In the demo the module all-in-one showcases this monolithic application. In this short blog entry I will describe how it works.

Actually it's very simple. It's done with the dependency injection of Spring. Nevertheless is a quite cool setup.

Microservice Setup and Configuration

Let's look into the UserController of the frontend-service module and take a look what's normally happens if you start the FrontendApplication.

• the UserController requires the UserHystrixClient 
• the UserHystrixClient requires the UserClient 
• the UserClient has the @FeignClient annotation 
• thereby a Spring service is created, given that the FrontendApplication has this configuration: @EnableFeignClients({"at.rseiler.concept.microservice.client"}) 
• this Spring service is then injected into the UserHystrixClient 
• => that's it. It's this simple.

Monolithic Setup and Configuration

Now the explanation what happens if the MonolithApplication is started.

• the UserController requires the UserHystrixClient (no difference)
• the UserHystrixClient requires the UserClient (no difference)
• the UserClient has the @FeignClient annotation, but no service is created. Because MonolithApplication doesn't has the @EnableFeignClients annotation.
• the UserService of the user-service implements the UserClient and its annotated with @RestController. 
• thereby a Spring service is created 
• this Spring service is then injected into the UserHystrixClient 
• => that's it. It's this simple.

In the end the "magic" is done with the Spring configuration. Because we don't need the Feign clients in the monolithic application we don't need to create them. However the REST endpoints are created, because of the @RestController annotation. So it's if two microservices defines the same endpoint then you get an exception at the startup.

Improved Setup

It's also possible to improve the setup so that the REST endpoints aren't created in the monolithic application. To do that you need to improve the configuration. Each @RestController annotated class needs additional a @Service annotation. In the monolithic application only the @Service are defined as includeFilters for the at.rseiler.concept.microservice.*.rest package and the @RestController annotation will be ignored. In a microservice configuration the configuration is reversed. Only the @RestController is defined as includeFilters.

Conclusion

By the expressive Spring dependency injection configuration it's possible to do very cool things. It's only necessary to think outside of the box and use the power of the configuration options. The only downside could be that it's probably confusing for others if an class has a @RestController annotation and a @Service annotation. So you either good documentation to explain this or keep it simple and don't do both. I chose the second approach for the microservice example.