Mastering microservice communication with Spring Cloud Feign

Learn how to build resilient microservice communication with HTTP using Feign, Spring Cloud OpenFeign and Resilience4J.

Microservices are complex. People mostly talk about the benefits of using microservices. Independent deployments, horizontal scaling of services, better failure isolation, teams owning separate microservices.

We tend to forget about the difficulties and the disadvantages. One of the most critical problems with microservices is communication. How to achieve a reliable communication channel between the services so messages/requests are not lost. How to avoid overloading certain services to make sure they don’t crash.

I’m going to discuss these points in my course to provide you a guideline on implementing resilient HTTP communication between your services.

Among a lot of things, here’s a high-level overview of the curriculum:

  • Feign request/response mappings using annotations
  • Feign logging
  • Base clients
  • Request interceptors
  • Customizing error handling
  • Request timeout options and following redirects
  • Async HTTP communication
  • Exposing Dropwizard and Micrometer metrics
  • Spring Cloud OpenFeign request/response mappings using annotations
  • Maintainable error handling with Spring Cloud OpenFeign
  • Eureka integration with Feign for service resolution
  • Feign client fallbacks
  • Error-based circuit breaking with Resilience4J
  • Slowness-based circuit breaking with Resilience4J
  • Exposing circuit breaker metrics to Actuator
  • Cutting off traffic when request are taking too long using Resilience4J
  • Client side load balancing to multiple service instances
  • Integration testing Feign clients
  • Circuit breaking integration testing
  • Client side load balancing integration testing

Effective Hibernate with Spring

Many many times I’ve seen and worked with codebases that use JPA with Hibernate. Most of these systems were implemented by developers who knew little about the details of Hibernate.

I created the course to close this gap and improve the quality of applications around the world. I want you to experience how fun it is to work with Hibernate and where it can and cannot help. Just a fairly simple example. It won’t protect you from SQL injection unless you form your queries properly. However, it can help you improve your capabilities to read data and fine tune your write scenarios as well. And that’s what the course is focusing on.

I’m a big fan of the learn through practice concept, and the course is built based on those pillars. After almost every section there is a practice exercise with real coding to really make sure you understand these features. And also, all the sections are walking you through practical examples instead of staying on a hypothetical level.

It’s exceptionally useful if you work with JPA or Hibernate on a daily basis to boost your performance and help achieving strategic goals.

The agenda of the course looks the following

  • Introduction
  • Entity-state transitions
  • Data fetching
  • Projections
  • Concurrency control
  • Flushing
  • Batch operations
  • Closing

You can also find the respective practices here on GitHub.