SpringCloud：如何使用SpringCloud搭建一个简单的微服务

缺乏、安全感 2022-02-23 00:48 344阅读 0赞

在构建微服务时，最常用的就是SpringCloud，其中的Netflix-Eureka用的最多，本文主要讲讲如何使用它。

一、配置注册服务器（Registry Server/Eureka Server）

Maven配置：

  1. <project xmlns="http://maven.apache.org/POM/4.0.0"
  2.   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.   <modelVersion>4.0.0</modelVersion>
  6.   <groupId>TestCloud</groupId>
  7.   <artifactId>TestCloud-ServiceRegistry</artifactId>
  8.   <version>0.0.1-SNAPSHOT</version>
  9.   <packaging>jar</packaging>
  11.   <name>TestCloud-ServiceRegistry</name>
  12.   <url>http://maven.apache.org</url>
  14.   <properties>
  15.     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  16.     <maven.compiler.source>1.8</maven.compiler.source>
  17.     <maven.compiler.target>1.8</maven.compiler.target>
  18.     <maven.compiler.encoding>UTF-8</maven.compiler.encoding>
  19.   </properties>
  21.   <parent>
  22.     <groupId>org.springframework.boot</groupId>
  23.     <artifactId>spring-boot-starter-parent</artifactId>
  24.     <version>2.1.3.RELEASE</version>
  25.     <relativePath />
  26.   </parent>
  28.   <dependencyManagement>
  29.     <dependencies>
  30.       <dependency>
  31.         <groupId>org.springframework.cloud</groupId>
  32.         <artifactId>spring-cloud-dependencies</artifactId>
  33.         <version>Greenwich.SR1</version>
  34.         <type>pom</type>
  35.         <scope>import</scope>
  36.       </dependency>
  37.     </dependencies>
  38.   </dependencyManagement>
  40.   <dependencies>
  41.     <dependency>
  42.       <groupId>org.springframework.boot</groupId>
  43.       <artifactId>spring-boot-starter-web</artifactId>
  44.     </dependency>
  45.     <dependency>
  46.       <groupId>org.springframework.cloud</groupId>
  47.       <artifactId>spring-cloud-starter</artifactId>
  48.     </dependency>
  49.     <dependency>
  50.       <groupId>org.springframework.cloud</groupId>
  51.       <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
  52.     </dependency>
  54.     <dependency>
  55.       <groupId>junit</groupId>
  56.       <artifactId>junit</artifactId>
  57.       <scope>test</scope>
  58.     </dependency>
  59.   </dependencies>
  60. </project>

application.properties配置：

server.port=8761

eureka.instance.hostname=localhost
# eureka.datacenter=Main
# eureka.environment=prod

eureka.server.enableSelfPreservation=false

eureka.client.register-with-eureka=false
eureka.client.fetch-registry=false

eureka.server.enableSelfPreservation - 当service server心跳超时后，是否还要将service server保存在列表中一段时间。 当网络发生短暂分区时，不会因为大量service server心跳超时，而将service server从列表中删除，从而造成客户端调用大面积失败的情况。
eureka.client.register-with-eureka - 是否将自身也作为service server注册到Eureka Server。
eureka.client.fetch-registry - 是否将自身作为service client从Eureka Server中获取service server列表。

ServiceRegistry代码：

  1. import org.springframework.boot.SpringApplication;
  2. import org.springframework.boot.autoconfigure.SpringBootApplication;
  3. import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
  5. @SpringBootApplication
  6. @EnableEurekaServer
  7. public class ServiceRegistryEurekaApp {
  9.     public static void main(String[] args) throws Exception {
  10.         SpringApplication.run(ServiceRegistryEurekaApp.class, args);
  11.     }
  12. }

程序运行后，可以通过访问如下地址访问Eureka Server管理控制台：
http://localhost:8761
当有service server注册上来后，可以通过如下地址查看注册的service server的信息：
http://localhost:8761/eureka/apps

二、配置服务服务器（Service Server/Eureka Client）

Maven配置：

  1. <project xmlns="http://maven.apache.org/POM/4.0.0"
  2.   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.   <modelVersion>4.0.0</modelVersion>
  6.   <groupId>TestCloud</groupId>
  7.   <artifactId>TestCloud-ServiceServer1</artifactId>
  8.   <version>0.0.1-SNAPSHOT</version>
  9.   <packaging>jar</packaging>
  11.   <name>TestCloud-ServiceServer1</name>
  12.   <url>http://maven.apache.org</url>
  14.   <properties>
  15.     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  16.   </properties>
  18.   <parent>
  19.     <groupId>org.springframework.boot</groupId>
  20.     <artifactId>spring-boot-starter-parent</artifactId>
  21.     <version>2.1.3.RELEASE</version>
  22.     <relativePath />
  23.   </parent>
  25.   <dependencyManagement>
  26.     <dependencies>
  27.       <dependency>
  28.         <groupId>org.springframework.cloud</groupId>
  29.         <artifactId>spring-cloud-dependencies</artifactId>
  30.         <version>Greenwich.SR1</version>
  31.         <type>pom</type>
  32.         <scope>import</scope>
  33.       </dependency>
  34.     </dependencies>
  35.   </dependencyManagement>
  37.   <dependencies>
  38.     <dependency>
  39.       <groupId>org.springframework.boot</groupId>
  40.       <artifactId>spring-boot-starter-webflux</artifactId>
  41.     </dependency>
  42.     <dependency>
  43.       <groupId>org.springframework.boot</groupId>
  44.       <artifactId>spring-boot-starter-actuator</artifactId>
  45.     </dependency>
  46.     <dependency>
  47.       <groupId>org.springframework.cloud</groupId>
  48.       <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
  49.     </dependency>
  51.     <dependency>
  52.       <groupId>junit</groupId>
  53.       <artifactId>junit</artifactId>
  54.       <scope>test</scope>
  55.     </dependency>
  56.   </dependencies>
  58.   <build>
  59.     <plugins>
  60.       <plugin>
  61.         <groupId>org.springframework.boot</groupId>
  62.         <artifactId>spring-boot-maven-plugin</artifactId>
  63.       </plugin>
  64.     </plugins>
  65.   </build>
  66. </project>

bootstrap.properties配置：

spring.profiles.active=test

spring.application.name=TestServer

# spring.main.allow-bean-definition-overriding=true
# spring.cloud.config.uri=http://localhost:8888

spring.cloud.discovery.enabled=true
spring.cloud.service-registry.auto-registration.enabled=true

spring.cloud.config.uri - 表示以后需要访问的配置服务器的地址。
spring.application.name - 表示此service注册到Registry上的服务名称。
spring.cloud.discovery.enabled - 表示是否打开发现服务，默认值为true。
spring.cloud.service-registry.auto-registration.enabled - 表示是否启动后自动注册，默认值为true。

注册可以使用Netflix-Eureka，也可以使用Zookeeper，以下使用Netflix-Eureka为例进行讲解。

application.properties配置：

server.port=8081

# http://localhost:8081/actuator/refresh
management.endpoints.web.exposure.include=refresh
# management.endpoints.jmx.exposure.exclude=*
# management.context-path=/base

eureka.client.enabled=true
eureka.client.serviceUrl.defaultZone=http://localhost:8761/eureka/

eureka.client.register-with-eureka=true
eureka.client.fetch-registry=true

# eureka.client.healthcheck.enabled=true
# eureka.instance.statusPageUrlPath=${management.context-path}/info
# eureka.instance.healthCheckUrlPath=${management.context-path}/health

# eureka.instance.instanceId=${spring.application.name}:${random.int}

# hostname为此实例提供给外部调用的域名
eureka.instance.hostname=localhost
eureka.instance.leaseRenewalIntervalInSeconds=10
eureka.instance.leaseExpirationDurationInSeconds=20

eureka.instance.metadataMap.versions=v1

management.endpoints.web.exposure.include - 表示可以放开给外部访问的方法，访问方式：http://localhost:8081/actuator/XXX，其中XXX表示实际调用的方法。比如：management.endpoints.web.exposure.include=refresh表示允许通过访问http://localhost:8081/actuator/refresh，访问结果为重新加载@RefreshScope范围内的配置信息。

eureka.client.enabled - 表示是否启用eureka client
eureka.client.serviceUrl.defaultZone - 表示eureka client可以访问的eureka server的地址

eureka.instance.hostname - 为此实例提供给外部调用的域名。
eureka.instance.leaseRenewalIntervalInSeconds - 心跳间隔。如果连续3次心跳都无回复，表示心跳超时。
eureka.instance.leaseExpirationDurationInSeconds - 心跳超时后，此服务会在eureka server的列表中保持多长时间。

eureka.instance.metadataMap.versions - eureka.instance.metadataMap中可以添加用户自定义的任意属性。

此处分为application.properties和bootstrap.properties两个配置文件，主要是为以后连接Config Server做准备，因为service server启动后必须先访问Config Server获取配置信息，然后才能初始化service server。

Java代码：

  1. import org.springframework.boot.SpringApplication;
  2. import org.springframework.boot.autoconfigure.SpringBootApplication;
  3. import org.springframework.boot.autoconfigure.task.TaskSchedulingAutoConfiguration;
  4. import org.springframework.context.ConfigurableApplicationContext;
  6. @SpringBootApplication(exclude = { TaskSchedulingAutoConfiguration.class })
  7. public class AppBoot {
  9.   public static void main(String[] args) {
  10.     ConfigurableApplicationContext ctx = SpringApplication.run(AppBoot.class, args);
  11.     ctx.registerShutdownHook();
  12.   }
  13. }

AppBoot负责启动整个应用

  1. import java.util.concurrent.Executor;
  3. import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
  4. import org.springframework.cloud.client.serviceregistry.ServiceRegistry;
  5. import org.springframework.context.annotation.Bean;
  6. import org.springframework.context.annotation.Configuration;
  7. import org.springframework.scheduling.annotation.EnableAsync;
  8. import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
  10. @Configuration
  11. @EnableDiscoveryClient
  12. @EnableAsync
  13. public class AppConf {
  15.   private ServiceRegistry registry;
  17.   public AppConf(ServiceRegistry registry) {
  18.     this.registry = registry;
  19.   }
  21.   public ServiceRegistry getRegistry() {
  22.     return registry;
  23.   }
  25.   @Bean(name = "taskExecutor")
  26.   public Executor taskExecutor() {
  27.     ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
  28.     executor.setCorePoolSize(10);
  29.     executor.setMaxPoolSize(20);
  30.     executor.setQueueCapacity(200);
  31.     executor.setKeepAliveSeconds(60);
  32.     executor.setThreadNamePrefix("taskExec-");
  33.     // executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
  34.     return executor;
  35.   }
  36. }

AppConf中获取ServiceRegistry，并生成一个线程池供以后使用。

  1. import java.util.List;
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.cloud.client.ServiceInstance;
  5. import org.springframework.cloud.client.discovery.DiscoveryClient;
  6. import org.springframework.cloud.client.serviceregistry.Registration;
  7. import org.springframework.web.bind.annotation.PathVariable;
  8. import org.springframework.web.bind.annotation.RequestMapping;
  9. import org.springframework.web.bind.annotation.RestController;
  11. @RestController
  12. @RequestMapping("/appCtrl")
  13. public class AppController {
  15.   @Autowired
  16.   private Registration registration;
  18.   @Autowired
  19.   private DiscoveryClient discoveryClient;
  21.   @Autowired
  22.   private AppConf configuration;
  24.   @RequestMapping("/register")
  25.   public void register() {
  26.     configuration.getRegistry().register(registration);
  28.     System.out.println("Host:" + registration.getHost());
  29.     System.out.println("Port:" + registration.getPort());
  30.     System.out.println("InstanceId:" + registration.getInstanceId());
  31.     System.out.println("ServiceId:" + registration.getServiceId());
  32.     System.out.println("Uri:" + registration.getUri());
  33.   }
  35.   @RequestMapping("/deregister")
  36.   public void deregister() {
  37.     configuration.getRegistry().deregister(registration);
  38.   }
  40.   @RequestMapping("/service-instances/{applicationName}")
  41.   public List<ServiceInstance> serviceInstancesByApplicationName(@PathVariable String applicationName) {
  42.     return this.discoveryClient.getInstances(applicationName);
  43.   }
  44. }

registration本身也是一个service instance，它保存了当前Service Server的相关信息。discoveryClient可以获取Eureka Server上已注册的service instance。AppController可以注册此服务到Eureka Server，或从Eureka Server撤销此服务，也可以获取注册的服务信息。

应用启动后，就可以从Eureka Server的控制台上看到TestServer注册成功了。

关于service server自身的一些信息，可以直接访问http://localhost:8081/actuator中的一些命令获取。

如果不知道/actuator下面有哪些命令，可以通过访问http://localhost:8081/actuator获取所有可用的命令，返回结果为：

{“_links”:{
“self”:{“href”:”http://localhost:8081/actuator","templated":false
“archaius”:{“href”:”http://localhost:8081/actuator/archaius","templated":false
“auditevents”:{“href”:”http://localhost:8081/actuator/auditevents","templated":false
“beans”:{“href”:”http://localhost:8081/actuator/beans","templated":false
“caches-cache”:{“href”:”http://localhost:8081/actuator/caches/\{cache\}","templated":true
“caches”:{“href”:”http://localhost:8081/actuator/caches","templated":false
“health”:{“href”:”http://localhost:8081/actuator/health","templated":false
“health-component-instance”:{“href”:”http://localhost:8081/actuator/health/\{component\}/\{instance\}","templated":true
“health-component”:{“href”:”http://localhost:8081/actuator/health/\{component\}","templated":true
“conditions”:{“href”:”http://localhost:8081/actuator/conditions","templated":false
“configprops”:{“href”:”http://localhost:8081/actuator/configprops","templated":false
“env”:{“href”:”http://localhost:8081/actuator/env","templated":false
“env-toMatch”:{“href”:”http://localhost:8081/actuator/env/\{toMatch\}","templated":true
“info”:{“href”:”http://localhost:8081/actuator/info","templated":false
“loggers”:{“href”:”http://localhost:8081/actuator/loggers","templated":false
“loggers-name”:{“href”:”http://localhost:8081/actuator/loggers/\{name\}","templated":true
“heapdump”:{“href”:”http://localhost:8081/actuator/heapdump","templated":false
“threaddump”:{“href”:”http://localhost:8081/actuator/threaddump","templated":false
“metrics”:{“href”:”http://localhost:8081/actuator/metrics","templated":false
“metrics-requiredMetricName”:{“href”:”http://localhost:8081/actuator/metrics/\{requiredMetricName\}","templated":true
“scheduledtasks”:{“href”:”http://localhost:8081/actuator/scheduledtasks","templated":false
“httptrace”:{“href”:”http://localhost:8081/actuator/httptrace","templated":false
“mappings”:{“href”:”http://localhost:8081/actuator/mappings","templated":false
“refresh”:{“href”:”http://localhost:8081/actuator/refresh","templated":false
“features”:{“href”:”http://localhost:8081/actuator/features","templated":false
“service-registry”:{“href”:”http://localhost:8081/actuator/service-registry","templated":false\}
}}

再写一些业务代码，用于提供其它方法供调用：

  1. import org.slf4j.Logger;
  2. import org.slf4j.LoggerFactory;
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.beans.factory.annotation.Value;
  5. import org.springframework.cloud.context.config.annotation.RefreshScope;
  6. import org.springframework.web.bind.annotation.RequestMapping;
  7. import org.springframework.web.bind.annotation.RestController;
  9. import com.jjhgame.test.service.TestService;
  11. @RefreshScope
  12. @RestController
  13. @RequestMapping("/base")
  14. public class MessageRestController {
  16.   private static Logger log = LoggerFactory.getLogger(MessageRestController.class);
  18.   @Autowired
  19.   private TestService testService;
  21.   @Value("${message:Hello default}")
  22.   private String message;
  24.   @RequestMapping("/message")
  25.   String getMessage() {
  26.     String ret = this.message + ":" + System.currentTimeMillis();
  27.     String result = testService.getResult();
  28.     return result;
  29.   }
  30. }
  32. import org.slf4j.Logger;
  33. import org.slf4j.LoggerFactory;
  34. import org.springframework.scheduling.annotation.Async;
  35. import org.springframework.stereotype.Service;
  37. import com.jjhgame.test.web.MessageRestController;
  39. @Service
  40. public class TestService {
  42.   private static Logger log = LoggerFactory.getLogger(MessageRestController.class);
  44.   @Async("taskExecutor")
  45.   public String getResult() {
  46.     String name = "" + Thread.currentThread().getName();
  48.     log.info("==============" + name);
  50.     return name;
  51.   }
  52. }

每次调用由@RefreshScope注释的Bean时，Bean都会重新生成。如果启动时连接了Config Server，@RefreshScope范围中的message会在调用http://localhost:8081/actuator/refresh后，重新从Config Server中获取新的值。

三、测试客户端

Maven配置：

  1. <project xmlns="http://maven.apache.org/POM/4.0.0"
  2.   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.   <modelVersion>4.0.0</modelVersion>
  6.   <groupId>TestCloud</groupId>
  7.   <artifactId>TestCloud-Client</artifactId>
  8.   <version>0.0.1-SNAPSHOT</version>
  9.   <packaging>jar</packaging>
  11.   <name>TestCloud-Client</name>
  12.   <url>http://maven.apache.org</url>
  14.   <properties>
  15.     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  16.   </properties>
  18.   <parent>
  19.     <groupId>org.springframework.boot</groupId>
  20.     <artifactId>spring-boot-starter-parent</artifactId>
  21.     <version>2.1.3.RELEASE</version>
  22.     <relativePath />
  23.   </parent>
  25.   <dependencyManagement>
  26.     <dependencies>
  27.       <dependency>
  28.         <groupId>org.springframework.cloud</groupId>
  29.         <artifactId>spring-cloud-dependencies</artifactId>
  30.         <version>Greenwich.SR1</version>
  31.         <type>pom</type>
  32.         <scope>import</scope>
  33.       </dependency>
  34.     </dependencies>
  35.   </dependencyManagement>
  37.   <dependencies>
  38.     <dependency>
  39.       <groupId>org.springframework.boot</groupId>
  40.       <artifactId>spring-boot-starter-web</artifactId>
  41.     </dependency>
  42.     <dependency>
  43.       <groupId>org.springframework.boot</groupId>
  44.       <artifactId>spring-boot-starter-actuator</artifactId>
  45.     </dependency>
  46.     <dependency>
  47.       <groupId>org.springframework.cloud</groupId>
  48.       <artifactId>spring-cloud-starter-config</artifactId>
  49.     </dependency>
  50.     <dependency>
  51.       <groupId>org.springframework.cloud</groupId>
  52.       <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
  53.     </dependency>
  54.     <dependency>
  55.       <groupId>org.springframework.cloud</groupId>
  56.       <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
  57.     </dependency>
  58.     <dependency>
  59.       <groupId>org.springframework.cloud</groupId>
  60.       <artifactId>spring-cloud-starter-openfeign</artifactId>
  61.     </dependency>
  63.   </dependencies>
  65.   <build>
  66.     <plugins>
  67.       <plugin>
  68.         <groupId>org.springframework.boot</groupId>
  69.         <artifactId>spring-boot-maven-plugin</artifactId>
  70.       </plugin>
  71.     </plugins>
  72.   </build>
  73. </project>

application.properties配置：

spring.application.name=TestClient

server.port=7001

server.serviceName=TestServer

eureka.client.register-with-eureka=false
eureka.client.fetch-registry=true
eureka.client.serviceUrl.defaultZone=http://localhost:8761/eureka/

TestServer.ribbon.eureka.enabled=true
TestServer.ribbon.ServerListRefreshInterval=5

#TestServer.ribbon.NFLoadBalancerRuleClassName=com.netflix.loadbalancer.DynamicServerListLoadBalancer
#TestServer.ribbon.NIWSServerListClassName=com.netflix.niws.loadbalancer.DiscoveryEnabledNIWSServerList

eureka.client.register-with-eureka - false 表示不将自身注册成为service server。
eureka.client.fetch-registry - true表示从eureka server上获取服务列表。
eureka.client.serviceUrl.defaultZone - 设置eureka server的访问地址。

TestServer.ribbon.eureka.enabled - 表示是否对TestServer服务开启ribbon组件。
TestServer.ribbon.ServerListRefreshInterval - 表示对TestServer服务开启ribbon组件后，从eureka server上获取最新服务可访问地址的时间间隔。

下面分别以RibbonClient和FeignClient两种形式给出示例代码：

  1. import org.springframework.beans.factory.annotation.Autowired;
  2. import org.springframework.beans.factory.annotation.Value;
  3. import org.springframework.boot.SpringApplication;
  4. import org.springframework.boot.autoconfigure.SpringBootApplication;
  5. import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
  6. import org.springframework.cloud.client.loadbalancer.LoadBalanced;
  7. import org.springframework.cloud.netflix.ribbon.RibbonClient;
  8. import org.springframework.context.annotation.Bean;
  9. import org.springframework.web.bind.annotation.RequestMapping;
  10. import org.springframework.web.bind.annotation.RestController;
  11. import org.springframework.web.client.RestTemplate;
  13. @EnableDiscoveryClient
  14. @SpringBootApplication
  15. @RestController
  16. @RibbonClient(name = "${server.serviceName}", configuration = MyConfiguration.class)
  17. public class ClientApp {
  19.   @Value("${server.serviceName}")
  20.   private String serviceName;
  22.   @LoadBalanced
  23.   @Bean
  24.   RestTemplate restTemplate() {
  25.     return new RestTemplate();
  26.   }
  28.   @Autowired
  29.   RestTemplate restTemplate;
  31.   @RequestMapping("/hi")
  32.   public String hi() {
  33.     String greeting = this.restTemplate.getForObject("http://" + serviceName + "/base/message", String.class);
  34.     return String.format("%s!", greeting);
  35.   }
  37.   public static void main(String[] args) {
  38.     SpringApplication.run(ClientApp.class, args);
  39.   }
  40. }
  42. import org.springframework.beans.factory.annotation.Autowired;
  43. import org.springframework.beans.factory.annotation.Value;
  44. import org.springframework.boot.SpringApplication;
  45. import org.springframework.boot.autoconfigure.SpringBootApplication;
  46. import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
  47. import org.springframework.cloud.netflix.ribbon.RibbonClient;
  48. import org.springframework.cloud.openfeign.EnableFeignClients;
  49. import org.springframework.cloud.openfeign.FeignClient;
  50. import org.springframework.web.bind.annotation.RequestMapping;
  51. import org.springframework.web.bind.annotation.RequestMethod;
  52. import org.springframework.web.bind.annotation.RestController;
  54. @EnableDiscoveryClient
  55. @SpringBootApplication
  56. @RestController
  57. @EnableFeignClients
  58. @RibbonClient(name = "${server.serviceName}", configuration = MyConfiguration.class)
  59. public class FeignClientApp {
  61.   @Value("${server.serviceName}")
  62.   private String serviceName;
  64.   @Autowired
  65.   private MessageClient client;
  67.   @RequestMapping("/hihi")
  68.   public String message() {
  69.     return client.message();
  70.   }
  72.   @FeignClient(name = "${server.serviceName}")
  73.   interface MessageClient {
  74.     @RequestMapping(value = "/base/message", method = RequestMethod.GET)
  75.     String message();
  76.   }
  78.   public static void main(String[] args) {
  79.     SpringApplication.run(FeignClientApp.class, args);
  80.   }
  82. }
  84. import org.springframework.beans.factory.annotation.Autowired;
  85. import org.springframework.context.annotation.Bean;
  87. import com.netflix.client.config.IClientConfig;
  88. import com.netflix.loadbalancer.AvailabilityFilteringRule;
  89. import com.netflix.loadbalancer.IPing;
  90. import com.netflix.loadbalancer.IRule;
  91. import com.netflix.loadbalancer.PingUrl;
  93. public class MyConfiguration {
  95.   @Autowired
  96.   IClientConfig ribbonClientConfig;
  98.   @Bean
  99.   public IPing ribbonPing(IClientConfig config) {
  100.     return new PingUrl(false, "/base/home");
  101.   }
  103.   @Bean
  104.   public IRule ribbonRule(IClientConfig config) {
  105.     return new AvailabilityFilteringRule();
  106.   }
  107. }

通过以下两个地址，就可以测试一下代码运行结果：

http://localhost:7001/hihi
http://localhost:7001/hi

另外，下表为Spring Cloud Netflix提供给Ribbon的默认值：














































Bean Type Bean Name Class Name

IClientConfig

ribbonClientConfig

DefaultClientConfigImpl

IRule

ribbonRule

ZoneAvoidanceRule

IPing

ribbonPing

DummyPing

ServerList<Server>

ribbonServerList

ConfigurationBasedServerList

ServerListFilter<Server>

ribbonServerListFilter

ZonePreferenceServerListFilter

ILoadBalancer

ribbonLoadBalancer

ZoneAwareLoadBalancer

ServerListUpdater

ribbonServerListUpdater

PollingServerListUpdater

参考文档

Client Side Load Balancer: Ribbon
Spring Cloud Netflix Eureka - The Hidden Manual
Multi-version Service Discovery using Spring Cloud Netflix Eureka and Ribbon
Spring Cloud Series - Microservices Registration and Discovery using Spring Cloud, Eureka, Ribbon and Feign
Microservice Registration and Discovery with Spring Cloud and Netflix’s Eureka
Client Side Load Balancing with Ribbon and Spring Cloud

发表评论

表情：
评论列表 （有 0 条评论，344人围观）

还没有评论，来说两句吧...

相关阅读

    相关 springcloud微服务-项目搭建

    前言：      乐优商城这个视频还可以，于是拿来练练手，我对着视频搭环境一直在service服务模块卡住了，注册中心和网关可以启动，服务模块却一直启动不了，报各种奇怪的错，

    小灰灰小灰灰/ 0 赞/ 428 阅读

    相关 SpringCloud微服务框架搭建

    一、微服务架构 1.1什么是分布式 不同模块部署在不同服务器上 作用：分布式解决网站高并发带来问题 1.2什么是集群 多台服务器部署相同应用构成一个集群

    小鱼儿小鱼儿/ 0 赞/ 608 阅读