List<ServiceInstance> instances =discoveryClient.getInstances("productservice");
//服務(wù)可能有多個(gè), 獲取第?個(gè)
EurekaServiceInstance instance = (EurekaServiceInstance)instances.get(0);

 private static AtomicInteger atomicInteger = new AtomicInteger(1);
    private static List<ServiceInstance> instances;
    @PostConstruct
    public void init(){
        //根據(jù)應(yīng)?名稱獲取服務(wù)列表
        instances = discoveryClient.getInstances("product-service");
    }
    public OrderInfo selectOrderById(Integer orderId) {
        OrderInfo orderInfo = orderMapper.selectOrderById(orderId);
        //String url = "http://127.0.0.1:9090/product/"+ orderInfo.getProductId();
        //服務(wù)可能有多個(gè), 輪詢獲取實(shí)例
        int index = atomicInteger.getAndIncrement() % instances.size();
        ServiceInstance instance =instances.get(index);
        log.info(instance.getInstanceId());
        //拼接url
        String url = instance.getUri()+"/product/"+ orderInfo.getProductId();
        ProductInfo productInfo = restTemplate.getForObject(url,
                ProductInfo.class);
        orderInfo.setProductInfo(productInfo);
        return orderInfo;
    }

@Configuration
public class BeanConfig {
  @Bean
  @LoadBalanced
  public RestTemplate restTemplate(){
     return new RestTemplate();
 }
}

  public OrderInfo selectOrderById(Integer orderId) {
        OrderInfo orderInfo = orderMapper.selectOrderById(orderId);
        //String url = "http://127.0.0.1:9090/product/"+ orderInfo.getProductId();
        String url = "http://product-service/product/"+ orderInfo.getProductId();
        ProductInfo productInfo = restTemplate.getForObject(url,ProductInfo.class);
        orderInfo.setProductInfo(productInfo);
        return orderInfo;
    }

 public class LoadBalancerConfig {
        @Bean
        ReactorLoadBalancer<ServiceInstance> randomLoadBalancer(Environment
                      environment,LoadBalancerClientFactory loadBalancerClientFactory) {
            String name =
                    environment.getProperty(LoadBalancerClientFactory.PROPERTY_NAME);
            System.out.println("=============="+name);
            return new
                    RandomLoadBalancer(loadBalancerClientFactory.getLazyProvider(name,
                    ServiceInstanceListSupplier.class), name);
        }
    }

    @LoadBalancerClient(name = "product-service", configuration =LoadBalancerConfig.class)
    @Configuration
    public class BeanConfig {
        @Bean
        @LoadBalanced
        public RestTemplate restTemplate(){
            return new RestTemplate();
        }
    }

 public class LoadBalancerInterceptor implements ClientHttpRequestInterceptor {
        public ClientHttpResponse intercept(final HttpRequest request, final
        byte[] body, final ClientHttpRequestExecution execution) throws IOException {
            URI originalUri = request.getURI();
            String serviceName = originalUri.getHost();
            Assert.state(serviceName != null, "Request URI does not contain a 
                    valid hostname: " + originalUri);
            return (ClientHttpResponse)this.loadBalancer.execute(serviceName,
                    this.requestFactory.createRequest(request, body, execution));
        }
    }

 public class BlockingLoadBalancerClient implements LoadBalancerClient {
        public <T> T execute(String serviceId, LoadBalancerRequest<T> request)
                throws IOException {
            String hint = this.getHint(serviceId);
            LoadBalancerRequestAdapter<T, TimedRequestContext> lbRequest = new
                    LoadBalancerRequestAdapter(request, this.buildRequestContext(request, hint));
            Set<LoadBalancerLifecycle> supportedLifecycleProcessors =
                    this.getSupportedLifecycleProcessors(serviceId);
            supportedLifecycleProcessors.forEach((lifecycle) -> {
                lifecycle.onStart(lbRequest);
            });
            //根據(jù)serviceId,和負(fù)載均衡策略, 選擇處理的服務(wù)
            ServiceInstance serviceInstance = this.choose(serviceId, lbRequest);
            if (serviceInstance == null) {
                supportedLifecycleProcessors.forEach((lifecycle) -> {
                    lifecycle.onComplete(new CompletionContext(Status.DISCARD,
                            lbRequest, new EmptyResponse()));
                });
                throw new IllegalStateException("No instances available for " +
                        serviceId);
            } else {
                return this.execute(serviceId, serviceInstance, lbRequest);
            }
        }
        /**
         * 根據(jù)serviceId,和負(fù)載均衡策略, 選擇處理的服務(wù)
         *
         */
        public <T> ServiceInstance choose(String serviceId, Request<T> request) {
            //獲取負(fù)載均衡器
            ReactiveLoadBalancer<ServiceInstance> loadBalancer =
                    this.loadBalancerClientFactory.getInstance(serviceId);
            if (loadBalancer == null) {
                return null;
            } else {
                //根據(jù)負(fù)載均衡算法, 在列表中選擇?個(gè)服務(wù)實(shí)例
                Response<ServiceInstance> loadBalancerResponse =
                        (Response)Mono.from(loadBalancer.choose(request)).block();
                return loadBalancerResponse == null ? null :
                        (ServiceInstance)loadBalancerResponse.getServer();
            }
        }
    }