Spring Boot - how to communicate between microservices?

Of course you can. Microservices are just REST-Services. You need to understand how REST-Services work. After that just write 2 Microservices (2 Rest-Services: producer-service and consumer-service) with Spring-boot, let them run under different server-ports, call the consumer-service from the other, and that's it: you have your Microservices. Now this is the primitive way to write Microservices.

To make them evolve, you need to add some "magic" (no rocket science), for example using Ribbon to distribute load between two instances of your "producer-service".

You may use a discovery service which is just a spring-boot application with the annotation @EnableEurekaServer (You need to add the appropriate dependency in your pom) Now add to your first (primitive) Microservices the annotation @EnableDiscoveryClient to the main classes and the defaultZone pointing to your eureka-service in the application.properties (or application.yml) of both, start your eureka-service (discovery service) and the 2 Microservices: those will register on the discovery-service. Of course now you don't need to hard-code the http address of the producer-service in the consumer-service.
Take a look at this tutorial

Edited on 21th of November 2018 at 12:41 GMT

Suppose that your first (trivial) microservice (a pure rest-service) is running on your PC under port 8091.

In the controller of your second (trivial) microservice you call your first service using the RestTemplate.getForEntity(url,responseType,uriVariables) like so for the example in the linked tutorial:

ResponseEntity<CurrencyConversionBean> responseEntity = 
   new RestTemplate().getForEntity(
        "http://localhost:8091/currency-exchange/from/{from}/to/{to}", CurrencyConversionBean.class,  uriVariables);

Where url: the url of your first (micro)(rest)service. responseType: the class/type of the object awaited as response. uriVariables: is a map containing variables for the URI template.

There are different ways to communicate between microservices. But which one to use: depends on the usecase.

1. Api call: That is making actual rest api call to the other service using RestTemplate , FeignClient etc as.

ResponseType obj=  new RestTemplate().getForObject(URL, ResponseType.class, params);

2. But what if the usecase is different, like, you have customer microservice and orders microservice both are using separate database . You have customer name and other details in orders database as well. Once the customer update their name, you have to update the details in Orders database as well . How this can be done. Through API call? Then what if account microservice also needs this update. So Rest api will be an overhead. In this use case we can use MessageQueues like RabbitMQ. Customer microservice will create an event of customer update and which ever microservice is interested in this can subscribe.

Communication through message queue like RabbitMQ

Spring.io rabbit mq guide

That depends on your choice, weather you want sync communication or async communication between your services. For sync services you can use either of these 3rd party tools:

1. Hashcorp Consul
2. Netflix Eureka [You may client load balancing using Netflix RIBBON ]
3. NATS etc

For Async you can use messaging solutions like:

1. Redis [use list/streams]
2. ActiveMQ
3. RabitMQ
4. Kafka
5. NATS etc

As mentioned by @g00glen00b in comments Eureka is not used for communication between microservices. Its for service discovery. There are two ways that I know ofthrough which you can communicate with other Microservices :

1. RestTemplate
2. Feign Client

RestTemplate is very simple to use. It does not require configurations.

e.g.

   ResponseType obj=  new RestTemplate().getForObject(URL, ResponseType.class, params);

url - the URL

responseType - the type of the return value

params- the variables to expand the template

Spring Doc link for your reference

the post seems old but I will try to share my experiences with the new developers who searches solutions for the same problem.

You will need these libraries: Zuul Gateway, Eureka Discovery Server, Eureka Discovery Client, Rest Template (if you develop REST API).

Gateway can manage all the routing for spring boot microservice applications. Using only annotations and application.properties you can set up the whole server. You do NOT need to write single line of Java code.

Discovery server listens evens when new microservice is started or stopped. It registers all microservices which are annotated with @EnableEurekaClient.

Rest Template is a mature rest client library which is very much flexible in terms of custom http request and http response configurations. For instance, you can use client http interceptors configurations to intercept the http request and responses to add more data, or log info etc.

I have open-sourced microservice application on my GitHub page. Free to distribute, fork, clone, commercialize.. Free from desire :-)

All the best..

Two ways to achieve communication b/w two services by making a REST call infact any service over internet consuming REST WebService can be consumed using;

• RestTemplate (Going to be depreciated sooner or later)
• WebClient (Long term support/Recommended)

@Autowired
private RestTemplate restTemplate;

@Autowired
private EurekaClient eurekaClient;
    

@RequestMapping("/dashboard/{myself}")
public EmployeeInfo findme(@PathVariable Long myself) {
    Application application = eurekaClient.getApplication(employeeSearchServiceId);
    InstanceInfo instanceInfo = application.getInstances().get(0);
    
    String url = "http://" + instanceInfo.getIPAddr() + ":" + instanceInfo.getPort() + "/" + "employee/find/" + myself;
    System.out.println("URL" + url);
    
    EmployeeInfo emp = restTemplate.getForObject(url,EmployeeInfo.class);
    System.out.println("RESPONSE " + emp);
    
    return emp;
}

source: https://dzone.com/articles/microservices-communication-service-to-service

We can also use https://cloud.spring.io/spring-cloud-openfeign/reference/html/ which is being developed on top of Netflix Feign project.

Although REST is familiar and therefore easy to implement, if you need more flexible and Java-like communications, Spring's (Spring-to-Spring) HTTP Invoker may be a good choice.

Spring's HTTP invoker is a good choice if you need HTTP-based remoting but also rely on Java serialization. It shares the basic infrastructure with RMI invokers, just using HTTP as transport. Note that HTTP invokers are not only limited to Java-to-Java remoting but also to Spring on both the client and server side. (The latter also applies to Spring's RMI invoker for non-RMI interfaces.)

• https://docs.spring.io/spring/docs/2.5.x/reference/remoting.html
• https://www.baeldung.com/spring-remoting-http-invoker