Dubbo implements service routing and load balancing
Maven coordinates and brief introduction of dependent class libraries:
-Dubbo: The core library of the Dubbo framework, providing functions such as service governance and remote communication. Maven coordinates are 'org. apache. dubbo: dubbo'.
-Dubbo spring boot starter: Used to integrate Dubbo's starting dependency in Spring Boot applications. Maven coordinates are 'org. apache. dubbo. boot: dubbo spring boot starter'.
-Dubbo admin: Dubbo's visual management interface, which allows you to configure and monitor Dubbo. Maven coordinates are 'org. apache. dubbo: dubbo admin'.
The following is a complete example of implementing Dubbo service routing and load balancing, including the complete Java code:
Firstly, create two Spring Boot projects for service providers and one consumer, namely 'provider1', 'provider2', and 'consumer'. In the pom.xml file of these three modules, it is necessary to add Dubbo related dependencies.
`The pom.xml file for provider1 `:
<dependencies>
<dependency>
<groupId>org.apache.dubbo</groupId>
<artifactId>dubbo</artifactId>
<version>2.7.13</version>
</dependency>
</dependencies>
`The pom.xml file for provider2 `:
<dependencies>
<dependency>
<groupId>org.apache.dubbo</groupId>
<artifactId>dubbo</artifactId>
<version>2.7.13</version>
</dependency>
</dependencies>
`Pom.xml file for consumer ':
<dependencies>
<dependency>
<groupId>org.apache.dubbo.boot</groupId>
<artifactId>dubbo-spring-boot-starter</artifactId>
<version>2.7.13</version>
</dependency>
</dependencies>
1. Add the '@ Enable Dubbo' annotation on the main application classes of 'provider1' and 'provider2' to enable the Dubbo component.
`Provider1Application. java `:
import org.apache.dubbo.config.spring.context.annotation.EnableDubbo;
@EnableDubbo
@SpringBootApplication
public class Provider1Application {
public static void main(String[] args) {
SpringApplication.run(Provider1Application.class, args);
}
}
`Provider2Application. java `:
import org.apache.dubbo.config.spring.context.annotation.EnableDubbo;
@EnableDubbo
@SpringBootApplication
public class Provider2Application {
public static void main(String[] args) {
SpringApplication.run(Provider2Application.class, args);
}
}
2. Configure Dubbo in the 'application. yml' files of the 'provider1' and 'provider2' modules.
`Provider1/src/main/resources/application. yml `:
yaml
server:
port: 8081
spring:
dubbo:
application:
name: provider1
registry:
address: zookeeper://127.0.0.1:2181
protocol:
name: dubbo
port: -1
`Provider2/src/main/resources/application. yml `:
yaml
server:
port: 8082
spring:
dubbo:
application:
name: provider2
registry:
address: zookeeper://127.0.0.1:2181
protocol:
name: dubbo
port: -1
3. Create the interface 'HelloService. java' and define the service interface:
public interface HelloService {
String sayHello(String name);
}
4. Implement the 'HelloService' interface in the 'provider1' and 'provider2' modules.
`Provider1/src/main/java/com/example/service/impl/HelloServiceImpl. java `:
import com.example.service.HelloService;
import org.apache.dubbo.config.annotation.DubboService;
@DubboService(version = "1.0.0", weight = 100)
public class HelloServiceImpl implements HelloService {
@Override
public String sayHello(String name) {
return "Hello, " + name + " from provider1";
}
}
`Provider2/src/main/java/com/example/service/impl/HelloServiceImpl. java `:
import com.example.service.HelloService;
import org.apache.dubbo.config.annotation.DubboService;
@DubboService(version = "1.0.0", weight = 200)
public class HelloServiceImpl implements HelloService {
@Override
public String sayHello(String name) {
return "Hello, " + name + " from provider2";
}
}
5. Create the 'application. yml' file for the consumer module and configure Dubbo.
`Consumer/src/main/resources/application. yml `:
yaml
server:
port: 8080
spring:
dubbo:
application:
name: consumer
registry:
address: zookeeper://127.0.0.1:2181
protocol:
name: dubbo
port: -1
6. Create consumer 'ConsumerController. java' and implement consumer controller:
import com.example.service.HelloService;
import org.apache.dubbo.config.annotation.DubboReference;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/hello")
public class ConsumerController {
@DubboReference(version = "1.0.0", loadbalance = "random")
private HelloService helloService;
@GetMapping("/{name}")
public String sayHello(@PathVariable("name") String name) {
return helloService.sayHello(name);
}
}
7. Create the 'ConsumerApplication. java' startup class:
import org.apache.dubbo.config.spring.context.annotation.EnableDubbo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@EnableDubbo
@SpringBootApplication
public class ConsumerApplication {
public static void main(String[] args) {
SpringApplication.run(ConsumerApplication.class, args);
}
}
Finally, start the three modules' provider1 ',' provider2 ', and' consumer 'to access` http://localhost:8080/hello/world `Will output greeting information from 'provider1' or 'provider2'.
Summary:
Dubbo is an excellent distributed application framework that implements service routing and load balancing functions. Through the Dubbo framework, service invocation and data transmission can be achieved between service providers and consumers through simple configuration and annotations, making the development and management of distributed systems more convenient. When using Dubbo to achieve service routing and load balancing, it is mainly necessary to use Dubbo's annotations and configurations to publish, consume, and route services.
