一个微服务架构的系统中，不同服务之间是会相互调用的，如一个订单服务需要取用户数据，则需要调用用户服务，有多个用户服务实例时，Eureka会负载均衡到其中一个服务实例，和上一章一样，我们先通过Java版的服务发现及调用服务来做例子并移植到.net core版本。

　　1.Java版服务调用

　　1.1创建订单服务

　　和前面一样创建一个空的Maven项目，并改造成为一个Eureka客户端，修改下配置文件，服务名为userservice,端口设置为6661

　　1.2使用Ribbon做客户端负载均衡

　　添加ribbon的依赖，ribbon是一个客户端的负载均衡组件，服务间相互调用通过它来负载均衡　　

  1. <dependency>
  2.     <groupId>org.springframework.cloud</groupId>
  3.     <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
  4. </dependency>

　　创建一个OrderController,同样创建一个User实体（实际项目中如果有多处调用同一个实体可以独立出来一个实体模块），在启动类中创建一个方法restTemplate()来注入restTemplate,并加上@Bean配置注解， @LoadBalanced负载均衡注解　　

  1. @Bean
  2. @LoadBalanced
  3. RestTemplate restTemplate() {
  4.     return new RestTemplate();
  5. }

　　参考官网文档：http://cloud.spring.io/spring-cloud-static/Finchley.SR1/single/spring-cloud.html#_spring_resttemplate_as_a_load_balancer_client

　　搜索：Spring RestTemplate as a Load Balancer Client

　　

　　

　　1.3订单服务调用用户服务

　　创建一个Service类用来封装调用其他服务，这里创建一个UserService类，封装userservice服务的方法，创建一个restTemplate变量加上@Autowired注解来实现自动扫描注入　　

  1. package com.tz.orderservice;
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.core.ParameterizedTypeReference;
  5. import org.springframework.http.HttpMethod;
  6. import org.springframework.http.ResponseEntity;
  7. import org.springframework.web.client.RestTemplate;
  9. import java.util.ArrayList;
  10. import java.util.List;
  12. @Service
  13. public class UserService {
  15.     @Autowired
  16.     private RestTemplate restTemplate;
  18.     public List<User> getAll() {
  19.         ParameterizedTypeReference<List<User>> responseType = new ParameterizedTypeReference<List<User>>(){};
  20.         ResponseEntity<List<User>> resp = restTemplate.exchange("http://userservice/user/getall",
  21.                 HttpMethod.GET, null, responseType);
  22.         List<User> list = resp.getBody();
  23.         return list;
  24.     }    
  25. }

 　　订单Controller中创建获取用户信息的方法

  1. @RestController
  2. @RequestMapping("/order")
  3. public class OrderController {
  5.     @Autowired
  6.     private UserService userService;
  8.     @RequestMapping("/getalluser")
  9.     public List<User> getAllUser(){
  10.         return userService.getAll();
  11.     }
  12. }

 

　　启动Eureka Server，启动两个userservice实例，启动orderservice，刷新服务注册中心，发现订单服务orderservice已经注册成功

　　

　　浏览器访问订单服务的获取用户信息方法，可以看到成功调用了用户服务的方法

　　

　　2. .net core版服务调用

 　　2.1创建订单服务

 　　按照上一章的方法创建一个.net Core的微服务，端口设置为6660，创建一个IUserService的接口，这里使用异步方法 　　

  1. public interface IUserService
  2. {
  3.     Task<List<User>> getAll() ;
  5.     Task<string> getPort();
  6. }

 

 　　2.2订单服务调用用户服务

　　创建一个UserService类，实现IUserService接口来调用服务

　　参考：http://steeltoe.io/docs/steeltoe-discovery/#1-2-6-discovering-services

　　Json序列化组件：Newtonsoft.Json　　

  1. public class UserService : IUserService
  2. {
  3.     DiscoveryHttpClientHandler _handler;
  4.     private const string serviceUrl = "http://userservice/user";
  5.     public UserService(IDiscoveryClient client)
  6.     {
  7.         _handler = new DiscoveryHttpClientHandler(client);
  8.     }
  9.     public async Task<List<User>> getAll()
  10.     {
  11.         var client = GetClient();
  12.         var json= await client.GetStringAsync(serviceUrl+"/getall");
  13.         List<User> list= JsonConvert.DeserializeObject<List<User>>(json);
  14.         return list;
  15.     }
  17.     public async Task<string> getPort()
  18.     {
  19.         var client = GetClient();
  20.         return await client.GetStringAsync(serviceUrl + "/getport");
  21.     }
  22. private HttpClient GetClient()
  23.     {
  24.         var client = new HttpClient(_handler, false);
  25.         return client;
  26.     }
  27. }

 

　　

　　在Startup类的ConfigureServices中配置UserService的依赖注入

  1. public void ConfigureServices(IServiceCollection services)
  2. {
  3.     //添加注入配置
  4.     services.AddScoped<Controllers.IUserService, Controllers.UserService>();
  5.     //判断是否能获取Eureka配置
  6.     if (Configuration.GetSection("eureka").GetChildren().Any())
  7.     {
  8.         //添加Steeltoe服务发现客户端服务配置
  9.         services.AddDiscoveryClient(Configuration);
  10.     }
  11.     services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
  12. }

　　

　　创建一个OrderController,使用IUserService接口来调用，在构造方法中注入实例　　

  1. [Route("[controller]")]
  2. [ApiController]
  3. public class OrderController : ControllerBase
  4. {
  5.     private readonly IUserService userService;
  6.     //构造方法来注入实例
  7.     public OrderController(IUserService userService)
  8.     {
  9.         this.userService = userService;
  10.     }
  12.     [Route("getalluser")]
  13.     [HttpGet]
  14.     public async Task<List<User>> getAll()
  15.     {
  16.         List<User> list = await userService.getAll();
  17.         return list;
  18.     }
  20.     [Route("getuserserviceport")]
  21.     [HttpGet]
  22.     public async Task<string> getUserServicePort()
  23.     {
  24.         var port = await userService.getPort();
  25.         return port;
  26.     }
  28. }

 

 

　　启动项目，在刷新下Eureka Server，端口为6660的orderservice实例就注册到了服务中心

　　

　　在浏览器中输入：http://localhost:6660/order/getuserserviceport，来调用userservice的获取端口的方法，多刷新几次就可以看到端口会不断的切换，说明已经实现了负载均衡。

　　

　　

　　.net core版的服务调用完成。

版权声明：本文为townsend原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/townsend/p/9531882.html