devbox
煮酒与君饮
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

SpringCloud实战【九】: SpringCloud服务间调用_springcloud服务与服务之间的调用

作者：煮酒与君饮 | 2024-07-18 02:18:38

赞

踩

springcloud服务与服务之间的调用

目录

1 服务间调用

2 RestTemplate方式调用

2.1 创建演示项目

2.2 RestTemplate 实例化

2.3 RestTemplate 调用方式一

2.4 RestTemplate 调用方式二

2.5 RestTemplate 调用方式三

3 负载均衡策略

3.1 默认负载均衡策略 

3.2 编码指定负载均衡策略

3.3 配置文件指定负载均衡策略

4 Feign方式调用

1 服务间调用

        微服务的特点是服务数量特别多，服务和服务之间也需要有交互，这就涉及到服务间的调用，即服务与服务之间如何通信。提到服务与服务之间的通信，最通用的莫过于HttpClient，在其它的通信架构中基本都使用HttpClient来作为底层的通讯模型。在SpringCloud中依然可以使用HttpClient进行服务与服务调用，只不过如果采用HttpClient调用的话，会有一些弊端，例如: 如果同一个服务有多个负载的话，采用HttpClient调用时，没有办法处理负载均衡的问题。还有另一个问题就是HttpClient只是提供了核心调用的方法并没有对调用进行封装，所以在使用上不太方便，需要自己对HttpClient进行简单的封装。

        在SpringCloud提供了两种方式来解决服务与服务通信的问题，RestTemplate和Feign。虽然从名字上看这两种调用的方式不同，但在底层还是和HttpClient一样，采用Http的方式进行调用的。只不过是对HttpClient进行的封装。下面就一起来探讨一下这两种方式的区别。

2 RestTemplate方式调用

2.1 创建演示项目

        要演示服务之间的调用，需要有服务端（Server）和客户端(Clinet)，服务端提供服务供客户端调用。服务端和客户端都需要注册到Eureka提供的注册中心中，所以还需要创建注册中心项目。所以本篇我们需要创建服务提供者（服务端）项目，服务调用方（客户端）项目和注册中心项目。

        实际上Server端和Client端是相互的，不一定Client端一定要调用Server端，Server端一样可以调用Client端。下面我们分别看一下Server端和Client端的实现。Server端的配置如下：

  1. #端口号
  2. server:
  3.   port: 8001
  4. #Eureka实例名，集群中根据这里相互识别
  5. spring:
  6.   application:
  7.     name: hello-service
  8.  
  9. eureka:
  10.   #客户端
  11.   client:
  12.     #注册中心地址
  13.     service-url:
  14.       defaultZone: http://localhost:7001/eureka/

创建一个Controller,并编写一个简单的接口来供Client调用。下面为Controller的源码。

  1. import org.springframework.web.bind.annotation.RequestMapping;
  2. import org.springframework.web.bind.annotation.RestController;
  3.  
  4. @RestController
  5. public class ServerController {
  6.     @RequestMapping("/helloServer")
  7.     public String hello(){
  8.         return "hello-server";
  9.     }
  10. }

下面我们访问一下这个接口看看，是否能正确返回数据。

在浏览器中输入：http://192.168.1.6:8001/helloServer

得到如下图所示的结果：

 我们看已经成功的返回了接口的数据了。下面我们看一下eureka。看看是否成功的检测到了server端的服务。

在浏览器中输入：http://localhost:7001/

下面为eureka管理界面地址:

可以看到Eureka已经成功的检测到了Server端注册成功了。

        下面我们看一下client端的代码，创建一个Controller，并编写一个接口。下面为具体配置及代码。

  1. import org.springframework.web.bind.annotation.RequestMapping;
  2. import org.springframework.web.bind.annotation.RestController;
  3.  
  4. @RestController
  5. public class ClientController {
  6.     @RequestMapping("/helloClient")
  7.     public String hello(){
  8.         return "hello-client";
  9.     }
  10. }

配置如下所示：

  1. #端口号
  2. server:
  3.   port: 8002
  4. #Eureka实例名，集群中根据这里相互识别
  5. spring:
  6.   application:
  7.     name: hello-client
  8.  
  9. eureka:
  10.   #客户端
  11.   client:
  12.     #注册中心地址
  13.     service-url:
  14.       defaultZone: http://localhost:7001/eureka/

浏览器访问：http://192.168.1.6:8002/helloClient

得到如下所示的结果：

现在我们在访问一下Eureka地址看一下Client服务注册的是否成功：

可以看到注册中心也已经有客户端的服务了。 

2.2 RestTemplate 实例化

        我们发现server和client端都已经成功的在注册中心注册成功了。这也就是我们接下来要介绍的服务间调用的前提条件。在开发Spring项目时我们知道如果我们想要使有哪个类或者哪个对象，那就需要在xml中或者用注解的方式实例化对象。所以既然我们打算使用RestTemplate类进行调用，那我们必须要先实例化RestTemplate类。下面我们就看一下怎么在实例化RestTemplate类。因为不论采用的是RestTemplate方式调用还是采用Feign方式，均是在服务的client端进行开发的，在服务的server是无需做任何更改的。所以下面我们看一下client端的改动。下面为项目源码:

  1. package com.springcloud.provider;
  2.  
  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.context.annotation.Bean;
  7. import org.springframework.web.client.RestTemplate;
  8.  
  9. /**
  10.  * @ClassName ClientApplication
  11.  * @Description 服务调用方
  12.  * @Author boy
  13.  */
  14. @SpringBootApplication
  15. @EnableDiscoveryClient
  16. public class ClientApplication {
  17.  
  18.     public static void main(String[] args) {
  19.         SpringApplication.run(ClientApplication.class, args);
  20.     }
  21.  
  22.     @Bean
  23.     public RestTemplate initRestTemplate() {
  24.         return new RestTemplate();
  25.     }
  26. }

2.3 RestTemplate 调用方式一

        为了演示方便我们直接在启动类上添加了一个@Bean注解。然后手动实例化了一个对象，并且要特别注意，在使用RestTemplate时，必须要先实例化，否则会抛出空指针异常。下面我们演示一下怎么使用RestTemplate来调用server端的接口。下面为Controller中的代码的改动，在原来的基础上添加函数helloClient1()

  1. import org.springframework.beans.factory.annotation.Autowired;
  2. import org.springframework.web.bind.annotation.RequestMapping;
  3. import org.springframework.web.bind.annotation.RestController;
  4. import org.springframework.web.client.RestTemplate;
  5.  
  6. @RestController
  7. public class ClientController {
  8.  
  9.     @Autowired
  10.     private RestTemplate template;
  11.  
  12.     @RequestMapping("/helloClient")
  13.     public String hello(){
  14.         return "hello-client";
  15.     }
  16.  
  17.     @RequestMapping("/helloClient1")
  18.     public String helloClient1(){
  19.         String result = template.getForObject("http://127.0.0.1:8001/helloServer", String.class);
  20.         return result;
  21.     }
  22. }

上面的代码比较简单，就不详细的介绍了，主要是RestTemplate中提供了getForObject方法(实际上RestTemplate提供了很多种调用的方法，主要分为Get或者Post)，可以指定要调用接口的地址，指定返回的值的类型。然后就会直接返回要调用接口的结果。下面我们测试一下，还是调用client接口，看看能否正确的返回server端的数据。

浏览器输入：http://192.168.1.6:8002/helloClient1

得到如下结果：

 由上图可以看出，获得的结果是Server端返回的。

2.4 RestTemplate 调用方式二

        我们看结果，已经成功的返回的server端的数据了，虽然返回的数据没有格式化，但返回的结果数据确实是server端的数据。这也就是RestTemplate的简单使用。但上述的代码是有弊端的，因为我们直接将调用的server端的接口地址直接写死了，这样当服务接口变更时，是需要更改客户端代码的，这显示是不合理的。那怎么办呢？这时就知道注册中心的好处了。因为注册中心知道所有服务的地址，这样我们通过注册中心就可以知道server端的接口地址，这样就避免了server端服务更改时，要同步更改client代码了。下面我们在优化一下代码，看看怎么通过注册中心来获取server端的地址，在controller中添加函数helloClient2()。

  1. import org.springframework.beans.factory.annotation.Autowired;
  2. import org.springframework.cloud.client.ServiceInstance;
  3. import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
  4. import org.springframework.web.bind.annotation.RequestMapping;
  5. import org.springframework.web.bind.annotation.RestController;
  6. import org.springframework.web.client.RestTemplate;
  7.  
  8. @RestController
  9. public class ClientController {
  10.  
  11.     @Autowired
  12.     private RestTemplate template;
  13.  
  14.     @Autowired
  15.     private LoadBalancerClient loadBalancerClient;
  16.  
  17.     @RequestMapping("/helloClient")
  18.     public String hello(){
  19.         return "hello-client";
  20.     }
  21.  
  22.     @RequestMapping("/helloClient1")
  23.     public String helloClient1(){
  24.         String result = template.getForObject("http://127.0.0.1:8001/helloServer", String.class);
  25.         return result;
  26.     }
  27.  
  28.     @RequestMapping("/helloClient2")
  29.     public Object helloClient2() {
  30.         ServiceInstance serviceInstance = loadBalancerClient.choose("hello-server");
  31.         String url = String.format("http://%s:%s/helloServer", serviceInstance.getHost(), serviceInstance.getPort());
  32.         String result = template.getForObject(url, String.class);
  33.         return result;
  34.     }
  35. }

在SpringClourd中提供了LoadBalancerClient接口。通过这个接口我们可以通过用户中心的Application的名字来获取该服务的地址和端口。也就是下图中红色标红的名字(注意名字大小写)。

通过这些我们就可以获取到完整的服务接口地址了，这样就可以直接通过RestTemplate进行接口调用了。下面我们在看一下调用的结果。

浏览器输入：http://192.168.1.6:8002/helloClient2

获得结果：

2.5 RestTemplate 调用方式三

这样我们就解决了第一次服务接口地址写死的问题了。但上述的接口还有一个弊端就是我们每次调用服务时都要先通过Application的名字来获取ServiceInstance对象，然后才可以发起接口调用。实际上在SpringCloud中为我们提供了@LoadBalanced注解，只要将该注解添加到RestTemplate中的获取的地方就可以了。下面为具体修改:

启动类:

  1. import org.springframework.boot.SpringApplication;
  2. import org.springframework.boot.autoconfigure.SpringBootApplication;
  3. import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
  4. import org.springframework.cloud.client.loadbalancer.LoadBalanced;
  5. import org.springframework.context.annotation.Bean;
  6. import org.springframework.web.client.RestTemplate;
  7.  
  8. /**
  9.  * @ClassName ClientApplication
  10.  * @Description 服务调用方
  11.  * @Author boy
  12.  */
  13. @SpringBootApplication
  14. @EnableDiscoveryClient
  15. public class ClientApplication {
  16.  
  17.     public static void main(String[] args) {
  18.         SpringApplication.run(ClientApplication.class, args);
  19.     }
  20.  
  21.     @Bean
  22.     @LoadBalanced
  23.     public RestTemplate initRestTemplate() {
  24.         return new RestTemplate();
  25.     }
  26. }

我们在RestTemplate实例化的地方添加了@LoadBalanced注解，这样在我们使用RestTemplate时就该注解就会自动将调用接口的地址替换成真正的服务地址。下面我们看一下Controller中的改动:

  1. import org.springframework.beans.factory.annotation.Autowired;
  2. import org.springframework.cloud.client.ServiceInstance;
  3. import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
  4. import org.springframework.web.bind.annotation.RequestMapping;
  5. import org.springframework.web.bind.annotation.RestController;
  6. import org.springframework.web.client.RestTemplate;
  7.  
  8. @RestController
  9. public class ClientController {
  10.  
  11.     @Autowired
  12.     private RestTemplate template;
  13.  
  14.     @Autowired
  15.     private LoadBalancerClient loadBalancerClient;
  16.  
  17.     @RequestMapping("/helloClient")
  18.     public String hello(){
  19.         return "hello-client";
  20.     }
  21.  
  22.     @RequestMapping("/helloClient1")
  23.     public String helloClient1(){
  24.         String result = template.getForObject("http://127.0.0.1:8001/helloServer", String.class);
  25.         return result;
  26.     }
  27.  
  28.     @RequestMapping("/helloClient2")
  29.     public Object helloClient2() {
  30.         ServiceInstance serviceInstance = loadBalancerClient.choose("hello-server");
  31.         String url = String.format("http://%s:%s/helloServer", serviceInstance.getHost(), serviceInstance.getPort());
  32.         String result = template.getForObject(url, String.class);
  33.         return result;
  34.     }
  35.  
  36.     @RequestMapping("/helloClient3")
  37.     public Object helloClient3() {
  38.         String url = String.format("http://%s/helloServer", "hello-server");
  39.         String result = template.getForObject(url, String.class);
  40.         return result;
  41.     }
  42. }

代码和第一次的代码基本一样，唯一的区别就是获取服务地址和端口的地方替换成了注册中心中的Application的名字，并且我们的RestTemplate在使用上和第一次没有任何区别，只是在url中不同。下面我们看一下返回的结果。

浏览器输入：http://192.168.1.6:8002/helloClient3

获得结果：

3 负载均衡策略

        上文中演示的Server端只有一个服务，如果Server端有多个服务就会涉及到负载均衡的问题，Spring Cloud提供了Ribbon组件来解决负载均衡的问题，在实战中提供了三种策略来配置负载均衡，分别是默认负载均衡策略、编码指定负载均衡策略和配置文件指定负载均衡策略。如果下图所示：

负载均衡算法有很多种，常用的有轮询法、随机法、权重法、原地址哈希法、最小链接数法等，默认负载均衡策略使用轮询法，编码或者配置文件指定负载均衡策略可以选择随机法、轮询法、权重法三种中的一种。下面我们就一起来研究这几种负载均衡策略的使用方法。

3.1 默认负载均衡策略 

        注解@LoadBalanced会自动采用默信的负载策略，默认负载均衡策略使用轮询法实现负载均衡。为了演示负载均衡策略，新增一个Server服务，并且为了演示这两个Server返回结果的不同，可以让接口返回的数据不一致来方便测试。下面为新增的Server服务端的配置信息及Controller源码。

application.yml:

  1. #端口号
  2. server:
  3.   port: 8003
  4. #Eureka实例名，集群中根据这里相互识别
  5. spring:
  6.   application:
  7.     name: hello-server
  8.  
  9. eureka:
  10.   #客户端
  11.   client:
  12.     #注册中心地址
  13.     service-url:
  14.       defaultZone: http://localhost:7001/eureka/

ServerController：

  1. import org.springframework.web.bind.annotation.RequestMapping;
  2. import org.springframework.web.bind.annotation.RestController;
  3.  
  4. @RestController
  5. public class ServerController {
  6.     @RequestMapping("/helloServer")
  7.     public String hello(){
  8.         return "hello-server1";
  9.     }
  10. }

启动服务，然后浏览器输入：http://192.168.1.6:8002/helloClient3

会依次得到如下结果：

可以频繁的调用client中的接口，并观察发现它们会交替返回的，所以基本可以确定Spring Cloud默认的负载策略为轮询方式。 

打开注册中心可以看到服务提供者HELLO-SERVICE的数量变为2，如下图所示：

3.2 编码指定负载均衡策略

        SpringCloud底层采用的是Ribbon来实现的负载均衡。Ribbon是一个负载均衡器，Ribbon的核心组件为IRule，它也就是所有负载策略的父类。如下所示为IRule接口的源码:

  1. public interface IRule {
  2.     Server choose(Object var1);
  3.  
  4.     void setLoadBalancer(ILoadBalancer var1);
  5.  
  6.     ILoadBalancer getLoadBalancer();
  7. }

该类只提供了3个方法，它们的作用分别是选择一个服务名字、设置ILoadBalancer和返回ILoadBalancer。下面我们看一下IRule接口的常见策略子类。常见的有RandomRule、RoundRobinRule、WeightedResponseTimeRule等。分别对应着随机、轮询、和权重。下面我们看一下怎么更改默认的策略方式。更改默认策略也是在Client端中操作的，Client端的代码更改:

  1. import com.netflix.loadbalancer.IRule;
  2. import com.netflix.loadbalancer.RandomRule;
  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.context.annotation.Bean;
  8. import org.springframework.web.client.RestTemplate;
  9.  
  10. /**
  11.  * @ClassName ClientApplication
  12.  * @Description 服务调用方
  13.  * @Author boy
  14.  */
  15. @SpringBootApplication
  16. @EnableDiscoveryClient
  17. public class ClientApplication {
  18.  
  19.     public static void main(String[] args) {
  20.         SpringApplication.run(ClientApplication.class, args);
  21.     }
  22.  
  23.     @Bean
  24.     @LoadBalanced
  25.     public RestTemplate initRestTemplate() {
  26.         return new RestTemplate();
  27.     }
  28.  
  29.     @Bean
  30.     public IRule initIRule() {
  31.         return new RandomRule();
  32.     }
  33. }

可以看到在启动类上新实例化了一个IRule对象，并且指定该对象实例化的子类为RandomRule，也就是随机的方式。所以当Client端启动服务调用服务时，就会采用随机的方式进行调用，因为已经将IRule对象默认的实例化方式更改了。

下面我们测试一下，浏览器输入：http://192.168.1.6:8002/helloClient3

多次调用刷新浏览器就会发现，Client接口返回的结果不在是轮询的方式了，而是变成了随机了，这就说明已经成功的将SpringCloud默认的负载策略更改了。

3.3 配置文件指定负载均衡策略

        上面介绍了使用编码的方式指定负载均衡策略，那么有没有更优雅的方式指定负载均衡策略呢，显然是有的，可以在配置文件中通过配置的方式指定负载均衡策略。下面为具体的配置。(备注:为了不影响测试效果，我们需要将刚刚在启动类中的实例化的IRule注释掉)

  1. #端口号
  2. server:
  3.   port: 8002
  4. #Eureka实例名，集群中根据这里相互识别
  5. spring:
  6.   application:
  7.     name: hello-client
  8.  
  9. eureka:
  10.   #客户端
  11.   client:
  12.     #注册中心地址
  13.     service-url:
  14.       defaultZone: http://localhost:7001/eureka/
  15.  
  16. hello-server:
  17.         ribbon:
  18.           NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule

在配置文件中指定了注册中心中的Server端的Application名字，然后指定了默认的负载策略类。下面我们测试一下。

 浏览器输入：http://192.168.1.6:8002/helloClient3

多次调用刷新浏览器就会发现，Client接口返回的结果和使用编码指定负载均衡策略返回结果规律一致，都是随机的。

4 Feign方式调用

        在实际的开发中，服务间TestTemplate方式调用可以使用上述三种方式来控制负载均衡策略。Spring Cloud还提供了另一种服务间调用方式也就是Feign方式。使用Feign方式和RestTemplate不同，需要先添加Feign的依赖，具体依赖如下(备注:该依赖同样是在client端添加的):

pom.xml ：

  1. <dependency>
  2. 　　<groupId>org.springframework.cloud</groupId>
  3. 　　<artifactId>spring-cloud-starter-openfeign</artifactId>
  4. 　　<version>2.1.1.RELEASE</version>
  5. </dependency>

然后还需要在启动类中添加@EnableFeignClients注解。

ClientApplication.java ：

  1. import com.netflix.loadbalancer.IRule;
  2. import com.netflix.loadbalancer.RandomRule;
  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.feign.EnableFeignClients;
  8. import org.springframework.context.annotation.Bean;
  9. import org.springframework.web.client.RestTemplate;
  10.  
  11. /**
  12.  * @ClassName ClientApplication
  13.  * @Description 服务调用方
  14.  * @Author boy
  15.  */
  16. @EnableFeignClients
  17. @SpringBootApplication
  18. @EnableDiscoveryClient
  19. public class ClientApplication {
  20.  
  21.     public static void main(String[] args) {
  22.         SpringApplication.run(ClientApplication.class, args);
  23.     }
  24.  
  25.     @Bean
  26.     @LoadBalanced
  27.     public RestTemplate initRestTemplate() {
  28.         return new RestTemplate();
  29.     }
  30.  
  31. //    @Bean
  32. //    public IRule initIRule() {
  33. //        return new RandomRule();
  34. //    }
  35. }

接下来需要在Client端创建一个新的接口并定义Client端需要调用的服务方法。具体代码如下:

ServerApi.java ：

  1. import org.springframework.cloud.openfeign.FeignClient;
  2. import org.springframework.web.bind.annotation.RequestMapping;
  3.  
  4. @FeignClient(name = "hello-server")
  5. public interface ServerApi {
  6.  
  7.     @RequestMapping("/helloServer")
  8.     String helloServer();
  9. }

上述接口基本上和server端的Controller一致，唯一的不同就是指定了@FeignClient注解，该注解的需要指定一个名字，也就是注册中心中Applicaiton的名字，也就是要调用的服务名字。下面我们看一下Controller层的代码，为了不和前面的演示想混淆，重新创建新的Controller:

ClientFeignController.java ：

  1. import com.springcloud.provider.service.ServerApi;
  2. import org.springframework.beans.factory.annotation.Autowired;
  3. import org.springframework.web.bind.annotation.RequestMapping;
  4. import org.springframework.web.bind.annotation.RestController;
  5.  
  6. /**
  7.  * @ClassName ClientFeignController
  8.  * @Description TODO
  9.  * @Author boy
  10.  * @Date 2021/10/16 10:42 AM
  11.  */
  12. @RestController
  13. public class ClientFeignController {
  14.  
  15.     @Autowired
  16.     private ServerApi serverApi;
  17.  
  18.     @RequestMapping("/helloClient4")
  19.     public String helloClient(){
  20.         return serverApi.helloServer();
  21.     }
  22. }

在Controller中直接使用了自定义的接口，并直接调用接口中定义的方法，下面我们调用一下Client接口看看这样的方式是否可以调用成功。

浏览器输入：http://localhost:8002/helloClient4/

会随机得到 hello-server 和 hello-server1 的返回结果。因为前面在配置文件中已经指定了负载均衡策略的算法为随机法。

本文涉及的源码：https://github.com/xiaoyususu/springcloud-resttemplate-feign.git

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/煮酒与君饮/article/detail/843094
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号