微服务之间的调用（Ribbon与Feign）

最新推荐文章于 2024-09-21 10:30:00 发布
最新推荐文章于 2024-09-21 10:30:00 发布
阅读量2.1k 收藏 6
点赞数
分类专栏： Spring Cloud

概述

在前面的文章中，我们讲了使用Eureka作为服务注册中心，在服务启动后，各个微服务会将自己注册到Eureka server。那么服务之间是如何调用？又是如何进行负载均衡的呢？本文讲讲服务之间调用及负载均衡Ribbon。

目前，在Spring cloud 中服务之间通过restful方式调用有两种方式 
- restTemplate+Ribbon 
- feign

从实践上看，采用feign的方式更优雅（feign内部也使用了ribbon做负载均衡）。

本文使用如下的项目实例来分别演示这两种写法。 
- hello服务，读取数据库，返回信息 
- world服务，返回信息 
- helloworld服务，调用了hello服务和world服务（restTemplate+Ribbon方式） 
- helloworldfeign服务，调用了hello服务和world服务（feign方式）

项目之间关系.png

本文项目代码：springcloud-demo 
如何理解客户端Ribbon 
zuul也有负载均衡的功能，它是针对外部请求做负载，那客户端ribbon的负载均衡又是怎么一回事？

客户端ribbon的负载均衡，解决的是服务发起方（在Eureka注册的服务）对被调用的服务的负载，比如我们查询商品服务要调用显示库存和商品明细服务，通过商品服务的接口将两个服务组合，可以减少外部应用的请求，比如手机App发起一次请求即可，可以节省网络带宽，也更省电。

ribbon是对服务之间调用做负载，是服务之间的负载均衡，zuul是可以对外部请求做负载均衡。 
Ribbon负载均衡.png

hello服务与world服务

hello服务 
Git项目代码：hello 
pom.xml

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</artifactId>
        </dependency>        
        <!--connect the db-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
            <version>1.5.4.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.31</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
            <version>1.5.6.RELEASE</version>
        </dependency>
    </dependencies>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Dalston.SR2</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47

启动类HelloApplication：

package com.example.hello;

import com.example.hello.model.Info;
import com.example.hello.repository.InfoRepository;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.context.annotation.Bean;


@EnableDiscoveryClient
@SpringBootApplication
public class HelloApplication {

    private static final Logger log= LoggerFactory.getLogger(HelloApplication.class);
    public static final String KEY="Database";
    public static final String VALUE="MYSQL FROM BILLJIANG";

    public static void main(String[] args) {
        SpringApplication.run(HelloApplication.class, args);
    }

    @Bean
    public CommandLineRunner initDatabase(InfoRepository repository){
        return (args) -> {
            repository.save(new Info(KEY,VALUE));
        };
    }
}


 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34

入口类HelloController：

package com.example.hello.controller;

import com.example.hello.HelloApplication;
import com.example.hello.model.HelloMessage;
import com.example.hello.model.Info;
import com.example.hello.repository.InfoRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;


@RestController
public class HelloController {

    @Autowired
    private DiscoveryClient discoveryClient;

    @Autowired
    private InfoRepository infoRepository;

    @GetMapping("/")
    public String home(){
        return "hello";
    }

    @GetMapping("/message")
    public HelloMessage getMessage() {
        HelloMessage helloMessage = new HelloMessage();
        helloMessage.setName(getLocalInstanceInfo());
        helloMessage.setMessage(getInfoFromDatabase());
        return helloMessage;
    }


    private String getLocalInstanceInfo() {
        ServiceInstance serviceInstance = discoveryClient.getLocalServiceInstance();
        return serviceInstance.getServiceId() + ":" + serviceInstance.getHost() + ":" + serviceInstance.getPort();
    }


    private String getInfoFromDatabase() {
        List<Info> infoList = infoRepository.findByName(HelloApplication.KEY);
        for (Info info : infoList) {
            return info.toString();
        }
        return "(no database info)";
    }
}

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53

配置文件application.yml:


#随机端口
server:
  port: 0

#服务注册中心
eureka:
  client:
    service-url:
      default-zone: http://localhost:8761/eureka
  instance:
    instance-id: ${spring.application.name}:${spring.application.instance_id:${random.value}}

#数据源
spring:
  application:
    name: hello
  datasource:
    url: jdbc:mysql://127.0.0.1:3306/${{MYSQL_DATABASE}:foodb}
    username: ${{MYSQL_USERNAME}:root}
    password: ${{MYSQL_PASSWORD}:billjiang}
    testWhileIdle: true
    validationQuery: SELECT 1
  jpa:
    show-sql: true
    hibernate:
      ddl-auto: update
      naming-strategy: org.hibernate.cfg.ImprovedNamingStrategy
      properties:
        hibernate:
        dialect: org.hibernate.dialect.MySQL5Dialect
  zipkin:
    base-url: http://127.0.0.1:9411
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33

其他类略，请参照源码：

world 
world服务与hello服务类似，不过没有连接数据库 
项目代码：world

helloworld调用hello服务和world服务

采用restTemplate+Ribbon调用服务。 
项目代码：helloworld

启动类HelloworldApplication： 
配置restTemplate的Bean

package com.example.helloworld;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
@EnableDiscoveryClient
public class HelloworldApplication {

    public static void main(String[] args) {
        SpringApplication.run(HelloworldApplication.class, args);
    }

    @Bean
    @LoadBalanced
    RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24

入口类HelloworldController：

package com.example.helloworld.controller;

import com.example.helloworld.model.HelloMessage;
import com.example.helloworld.model.HelloworldMessage;
import com.example.helloworld.model.WorldMessage;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

/**
 * @author billjiang 475572229@qq.com
 * @create 17-8-22
 */
@RestController
public class HelloworldController {

    private static final Logger log = LoggerFactory.getLogger(HelloworldController.class);

    private static final String HELLO_SERVICE_NAME = "hello";

    private static final String WORLD_SERVICE_NAME = "world";

    @Autowired
    private RestTemplate restTemplate;

    @GetMapping("/")
    public String home() {
        return "hello world";
    }

    @GetMapping("/message")
    public HelloworldMessage getMessage() {
        HelloMessage hello = getMessageFromHelloService();
        WorldMessage world = getMessageFromWorldService();
        HelloworldMessage helloworld = new HelloworldMessage();
        helloworld.setHello(hello);
        helloworld.setWord(world);
        log.debug("Result helloworld message:{}", helloworld);
        return helloworld;
    }

    private HelloMessage getMessageFromHelloService() {
        HelloMessage hello = restTemplate.getForObject("http://hello/message", HelloMessage.class);
        log.debug("From hello service : {}.", hello);
        return hello;
    }

    private WorldMessage getMessageFromWorldService() {
        WorldMessage world = restTemplate.getForObject("http://world/message", WorldMessage.class);
        log.debug("From world service : {}.", world);
        return world;
    }


}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59

测试：

helloworldfeign调用hello服务和world服务

feign方式调用服务，项目代码参考：helloworldfeign 
pom.xml引入feignx

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

配置启动类注解：

package com.example.helloworldfeign;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.netflix.feign.EnableFeignClients;

@SpringBootApplication
@EnableDiscoveryClient
@EnableFeignClients
public class HelloworldFeignApplication {

    public static void main(String[] args) {
        SpringApplication.run(HelloworldFeignApplication.class, args);
    }
}

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

被调用接口HelloService

package com.example.helloworldfeign.service;

import com.example.helloworldfeign.model.HelloMessage;
import org.springframework.cloud.netflix.feign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;

/**
 * @author billjiang 475572229@qq.com
 * @create 17-8-23
 */
@FeignClient(value="hello")
public interface HelloService {

    @GetMapping("/message")
    HelloMessage hello();


}

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

被调用接口WorldService

package com.example.helloworldfeign.service;

import com.example.helloworldfeign.model.WorldMessage;
import org.springframework.cloud.netflix.feign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;

/**
 * @author billjiang 475572229@qq.com
 * @create 17-8-23
 */
@FeignClient(value="world")
public interface WorldService {

    @GetMapping("/message")
    WorldMessage world();

}

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

入口类HelloworldController：

package com.example.helloworldfeign.controller;

import com.example.helloworldfeign.model.HelloMessage;
import com.example.helloworldfeign.model.HelloworldMessage;
import com.example.helloworldfeign.model.WorldMessage;
import com.example.helloworldfeign.service.HelloService;
import com.example.helloworldfeign.service.WorldService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author billjiang 475572229@qq.com
 * @create 17-8-23
 */
@RestController
public class HelloworldController {

    private static final Logger log = LoggerFactory.getLogger(HelloworldController.class);

    private static final String HELLO_SERVICE_NAME = "hello";

    private static final String WORLD_SERVICE_NAME = "world";

    @Autowired
    private HelloService helloService;

    @Autowired
    private WorldService worldService;

    @GetMapping("/")
    public String home() {
        return "hello world";
    }

    @GetMapping("/message")
    public HelloworldMessage getMessage() {
        HelloMessage hello = helloService.hello();
        WorldMessage world = worldService.world();
        HelloworldMessage helloworld = new HelloworldMessage();
        helloworld.setHello(hello);
        helloworld.setWord(world);
        log.debug("Result helloworld message:{}", helloworld);
        return helloworld;
    }

}

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50

为了更好的地查看效果，hello服务和world服务可以启动多个实例，并把调用实例的ip和端口输出来。

yao不ke及
关注
专栏目录
微服务之间的最佳调用方式
倚天码农的博客
09-20 2万+
在微服务架构中，需要调用很多服务才能完成一项功能。服务之间如何互相调用就变成微服务架构中的一个关键问题。服务调用有两种方式，一种是RPC方式，另一种是事件驱动（Event-driven）方式，也就是发消息方式。消息方式是松耦合方式，比紧耦合的RPC方式要优越，但RPC方式如果用在适合的场景也有它的一席之地. 耦合的种类：我们总在谈耦合，那么耦合到底意味着什么呢？ 时间耦合：客户端和服务端必须同...
微服务之间的调用
yebadi_的博客
08-17 372
服务注册中心使用Nacos 1.依赖使用 <!--服务注册--> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId> </dependency>
【图文详解】什么是微服务？什么是SpringCloud？
最新发布
luming的博客
09-21 3603
通过本篇文章你可以知道什么是微服务，什么是SpringCloud，如何选择SpringCloud，SpringCloud和SpringBoot的关系，SpringCloud都包含了些什么
【软件架构】微服务架构java多模块项目，微服务之间相互调用方法
weixin_46453070的博客
03-26 3582
在Java多模块项目中实现微服务架构时，微服务之间的相互调用通常可以通过以下几种方式实现：这些方式可以根据具体项目需求和技术选型来选择。在Java多模块项目中，可以将不同的微服务模块实现为独立的模块，每个模块负责实现一个特定的业务功能，通过以上方式来实现微服务之间的相互调用。下面是对上述六种调用方式的适用场景的简要总结：Feign：HTTP/RESTful API调用：RPC（远程过程调用）调用：消息队列：服务代理：事件驱动：根据具体的业务需求、性能要求、开发团队技术栈等因素，可以选择合适的调用方式来进行微
Spring Cloud微服务eureka+ribbon+feign案例代码.zip
11-12
在Spring Cloud中，Ribbon与Eureka结合，可以在调用服务时自动从Eureka注册表中获取服务实例列表，并根据一定的策略（如轮询、随机等）选择一个实例进行请求。Ribbon提供了多种负载均衡策略，开发者可以根据需求进行...
springcloud微服务ribbon与feign的区别
weixin_37518151的博客
01-10 3426
ribbon ribbon是一种基于http和tcp客户端的负载均衡器 feign feign是一种使用起来更简单的http客户端,ribbon和feign都支持软负载均衡 注意：spring-cloud-starter-feign 里面已经包含了 spring-cloud-starter-ribbon（Feign 中也使用了 Ribbon） ribbon和feign都是用来调用其他服务的，不过方式不一样 1，启动类使用的注解不一样，ribbon使用@RibbonClient, feign使用@
SpringCloud学习（四、微服务访问之Ribbon、Feign）
MagicMHD的博客
12-31 473
上一节，我们已经把数据微服务注册好了，并且开放了两个端口可以访问到数据微服务，8001、8002： 下面我们就要访问前面注册好的这个数据微服务了！springcloud 提供了两种方式，一种是 Ribbon，一种是 Feign。 一、Ribbon Ribbon 是使用 restTemplate 进行调用，并进行客户端负载均衡。 什么是客户端负载均衡呢？ 在前面 注册数据微服务里...
微服务与中间件系列——Feign
qq_51553982的博客
08-24 593
将FeignClient抽取为独立模块，并且把接口有关的POJO、默认的Feign配置都放到这个模块中，提供给所有消费者使用。如下你可以分为client中暴露的服务达到访问实际在service模块中的服务。这里是对日志的配置修改，在开发中可以采用Basic，上线后请关闭日志以确保性能。其作用就是帮助我们优雅的实现http请求的发送，解决上面提到的问题。采用连接池可以优化Feign的性能，代替URLConnection。一般来说我们需要自己配置日志级别。写服务的名称则是某个服务生效。
spring cloud 微服务架构 Eureka Gateway Ribbon Feign
redswallowxu的专栏
01-15 3779
前面一片已经简单了讲了Eureka Zuul Ribbon Feign。这章只单独讲Gateway以及Gateway和Zuul的区别。 Gateway简介： Spring Cloud Gateway是Spring官方基于Spring 5.0，Spring Boot 2.0和Project Reactor等技术开发的网关，Spring Cloud Gateway旨在为微服务架构提供一种简单而有效的统一的API路由管理方式。Spring Cloud Gateway作为Spring Cloud生态系中的...
随着业务的发展，单体架构变为微服务架构，并且系统规模也变得越来越大，各微服务间的调用关系也变得越来越复杂。.zip
06-16
随着业务的发展，单体架构变为微服务架构，并且系统规模也变得越来越大，各微服务间的调用关系也变得越来越复杂。在微服务的应用中，一个由客户端发起的请求在后端系统中会经过多个不同的微服务调用来协同产生最后的请求结果
微服务服务间调用方式
热门推荐
淺雨吖的博客
10-21 1万+
服务间调用的方式，RestTemplate|OpenFeign介绍，一文包含OpenFeign和RestTemplate的基础内容
说说微服务之间如何进行调用
weixin_42601134的博客
02-15 1546
微服务架构中，不同的微服务之间需要相互调用以完成业务逻辑。下面是微服务之间进行调用的一些常用方法： RESTful API：这是最常用的微服务之间的通信方式。每个微服务都暴露一组RESTful API接口，其他微服务可以通过HTTP请求来调用它们的接口。RESTful API具有简单、灵活、可扩展的特点，适用于大部分的微服务场景。 RPC调用：Remote Procedure Call(RPC...
微服务 服务调用关系
weixin_45452920的博客
10-08 350
一个服务可以同时是服务提供者和服务消费者。服务提供者：暴露接口给其他微服务调用。服务消费者：调用其他微服务提供的接口。提供者与消费者角色其实是相对的。
微服务调用ribbon与feign
wufewu的博客
12-01 3307
一.Ribbon Ribbon是Netflix发布的开源项目，主要功能是提供客户端的软件负载均衡算法，将Netflix的中间层服务连接在一起。 参考文档：http://cloud.spring.io/spring-cloud-static/Dalston.SR5/single/spring-cloud.html#spring-cloud-ribbon 第16节 项目环境：https://blo...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值