精华内容
下载资源
问答
  • Ribbon和Feign区别在哪

    2020-08-20 21:02:21
    Ribbon和Feign都是实现负载均衡的组件,Feign的本质是Ribbon,基于Ribbon。 通过一个情景来说明他们的区别:微服务Service作为服务方提供操作展示数据的服务,做一个服务方的集群,以分散访问压力;微服务Cli

    先说一下负载均衡:服务访问量忒大,一个服务器顶不住,服务器一崩那不凉了,怎么办——多用几个服务器,使单个服务器承受的访问量分散开,通过调度算法让他们都有休息的时间,就算有一个服务器凉了,至少还有其他的服务器顶上,不至于服务崩了。实现分散这些访问压力到不同服务器者就是负载也。

    Ribbon和Feign都是实现负载均衡的组件,Feign的本质是Ribbon,基于Ribbon。

    通过一个情景来说明他们的区别:微服务Service作为服务方提供操作展示数据的服务,做一个服务方的集群,以分散访问压力;微服务Client作为访问方,通过远程调用访问Service访问这些数据。

    分析:Service作为服务方肯定有service层,没有controller、Client作为访问方只提供controller,不提供service,也就是说要实现Client的controller去调用Service的service。(下面例子没上dao的代码,这里主要展示Ribbon和Feign用法的区别)

    Ribbon:

    既然是远程调用(一个服务调另一个服务),就要有一个去做调用的任务的类:

    import org.springframework.cloud.client.loadbalancer.LoadBalanced;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.web.client.RestTemplate;
    
    @Configuration
    public class ConfigBean {
        @Bean
        @LoadBalanced //配置 负载均衡实现RestTemplate
        public RestTemplate getRestTemplate(){
            return new RestTemplate();
        }
    }

    然后就可以在controller进行肆无忌惮的远程调用了,当然在调用过程中会通过一些服务调度算法来让Service进行轮流提供服务,默认的是轮询

    import java.util.List;
    
    @RestController
    public class DeptConsumerController {
    
        //消费者不应该有service层
        //RestTemplate模板,供我们直接调用。要注册到bean中
    
        //提供多种边界访问远程http服务的方法,简单的Restful服务模板
        @Autowired
        private RestTemplate restTemplate;
    
        //这里的地址写成变量,通过服务名来访问
        private static final String Rest_URL_PREFIX = "http://SPRINGCLOUD" +
                "-PROVIDER-DEPT";
    
        @RequestMapping("/consumer/dept/get/{id}")
        public Dept get(@PathVariable("id") Long id) {
            return restTemplate.getForObject(Rest_URL_PREFIX + "/dept/get/" + id,
                    Dept.class);
        }
    
    }

    到这里就完成了,通过看controller的代码我们发现这里是通过地址来直接调用另一个微服务的service的,在写法上与我们那种controller直接调service的方式有点不同,为了适应代码习惯和我们的规范,Feign的作用就体现出来了

    Feign:

    可以说Feign是基于Ribbon的,Ribbon的配置不变,只不过Feign在Ribbon的基础上做了一层封装,把远程调用给用户透明化了:在写代码时感觉不是在远程调用,而是正常地controller调service

    Service的service层接口在原来基础上加一个注解 @FeignClient 

    import java.util.List;
    
    // @Service("service")
    @Component
    @FeignClient(value = "SPRINGCLOUD-PROVIDER-DEPT")  //用Feign需要的注解
    public interface DeptClientService {
    
        @GetMapping("/dept/get/{id}")
        Dept queryById(@PathVariable("id")Long id);
    
    }

    这时候Client的controller代码写法就完全和之前那种一个服务内controller调service一样了,感觉不到是在远程调用:

    import java.util.List;
    
    @RestController
    public class DeptConsumerController {
    
        @Autowired
        private DeptClientService service;
    
        @RequestMapping("/consumer/dept/get/{id}")
        public Dept get(@PathVariable("id") Long id) {
            return this.service.queryById(id);
        }
    
    }

    观察对比代码可以发现Feign多出来的这层封装是把 原来地址这行代码:

    通过注解放到了Service的service接口里,不让controller直接通过地址去调用远程接口,调用的过程交给了Feign,相当于在controller和service之间加了一层。

    虽然用Feign在代码上写着会舒服,但毕竟多了一层,多少得影响点性能吧。具体用的时候还是根据具体情况去用。

    作为一个小白我只能单从代码写法上去对比他们的区别,欢迎大佬从底层实现上分析一波。初学cloud,欢迎指正。

    展开全文
  • 从概念上来讲,DubboSpring Cloud并不能放在一起对比,因为Dubbo仅仅是一个RPC框架,实现Java程序的远程调用,实施服务化的中间件则需要自己开发;而Spring Cloud则是实施微服务的一系列套件,包括:服务注册与...

    在业界,一般有两种微服务的实践方法:基于dubbo的微服务架构、基于Spring Cloud的微服务架构。从概念上来讲,Dubbo和Spring Cloud并不能放在一起对比,因为Dubbo仅仅是一个RPC框架,实现Java程序的远程调用,实施服务化的中间件则需要自己开发;而Spring Cloud则是实施微服务的一系列套件,包括:服务注册与发现、断路器、服务状态监控、配置管理、智能路由、一次性令牌、全局锁、分布式会话管理、集群状态管理等。

    在国内基于Dubbo实施服务化,刚开始是基于ZooKeeper进行服务注册与发现,现在已经转成使用Etcd。我这次学习Spring Cloud,则是想成体系得学习下微服务架构的实现,也许能够对基于Dubbo实施微服务架构有所借鉴。


    目前,在Spring cloud 中服务之间通过restful方式调用有两种方式 
    - restTemplate+Ribbon 
    - feign
    Ribbon
    Ribbon 是一个基于 HTTP 和 TCP 客户端的负载均衡器

    它可以在客户端配置 ribbonServerList(服务端列表),然后轮询请求以实现均衡负载

    它在联合 Eureka 使用时

    ribbonServerList 会被 DiscoveryEnabledNIWSServerList 重写,扩展成从 Eureka 注册中心获取服务端列表

    同时它也会用 NIWSDiscoveryPing 来取代 IPing,它将职责委托给 Eureka 来确定服务端是否已经启动

    Feign
    Spring Cloud Netflix 的微服务都是以 HTTP 接口的形式暴露的,所以可以用 Apache 的 HttpClient 或 Spring 的 RestTemplate 去調用

    而 Feign 是一個使用起來更加方便的 HTTP 客戶端,它用起來就好像調用本地方法一樣,完全感覺不到是調用的遠程方法

    总结起来就是:发布到注册中心的服务方接口,是 HTTP 的,也可以不用 Ribbon 或者 Feign,直接浏览器一样能够访问

    只不过 Ribbon 或者 Feign 调用起来要方便一些,最重要的是:它俩都支持软负载均衡

    注意:spring-cloud-starter-feign 里面已经包含了 spring-cloud-starter-ribbon(Feign 中也使用了 Ribbon)

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


    如何理解客户端Ribbon 
    zuul也有负载均衡的功能,它是针对外部请求做负载,那客户端ribbon的负载均衡又是怎么一回事?

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

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

    --------------------- 
    作者:q_0718 
    来源:CSDN 
    原文:https://blog.csdn.net/q_0718/article/details/80269864 
    版权声明:本文为博主原创文章,转载请附上博文链接!

    展开全文
  • ribbon和feign

    2021-08-02 19:47:19
    ribbon和feign区别Ribbon和Feign都是用于调用其他服务的,不过方式不同。 Ribbon和Feign都是用于调用其他服务的,不过方式不同。 **1.启动类使用的注解不同,Ribbon用的是@RibbonClient,Feign用的是@...

    一、 ribbon和feign区别

    Ribbon和Feign都是用于调用其他服务的,不过方式不同。

        1.启动类使用的注解不同,Ribbon用的是@RibbonClient,Feign用的是@EnableFeignClients。
        2.服务的指定位置不同,Ribbon是在@RibbonClient注解上声明,Feign则是在定义抽象方法的接口中使用@FeignClient声明。
        3.调用方式不同,Ribbon需要自己构建http请求,模拟http请求然后使用RestTemplate发送给其他服务,步骤相当繁琐。
        Feign则是在Ribbon的基础上进行了一次改进,采用接口的方式,将需要调用的其他服务的方法定义成抽象方法即可,
        不需要自己构建http请求。不过要注意的是抽象方法的注解、方法签名要和提供服务的方法完全一致。
    

    二、 ribbon的负载均衡策略

    在这里插入图片描述
    Spring Cloud Ribbon是一个基于HTTP和TCP的客户端负载均衡工具,基于Netflix Ribbon实现。
    在这里插入图片描述

    在这里插入图片描述
    AbstractLoadBalancerRule
    负载均衡策略的抽象类,在该抽象类中定义了负载均衡器ILoadBalancer对象,该对象能够在具体实现选择服务策略时,获取到一些负载均衡器中维护的信息作为分配依据,并以此设计一些算法来针对特定场景的高效策略。
    在这里插入图片描述
    RandomRule
    该策略实现了从服务实例清单中随机选择一个服务实例的功能。下面先看一下源码:
    在这里插入图片描述

    分析源码可以看出,IRule接口中Server choose(Object key)函数的实现委托给了该类中的Server choose(ILoadBalancer lb, Object key)函数,该方法增加了一个负载均衡器参数。从具体的实现可以看出,它会使用负载均衡器来获得可用实例列表upList和所有的实例列表allList,并且使用rand.nextInt(serverCount)函数来获取一个随机数,并将该随机数作为upList的索引值来返回具体实例。同时,具体的选择逻辑在一个while (server == null)循环之内,而根据选择逻辑的实现,正常情况下每次都应该选出一个服务实例,如果出现死循环获取不到服务实例时,则很有可能存在并发的Bug。

    RoundRobinRule
    该策略实现了按照线性轮询的方式一次选择每个服务实例的功能。下面看一下源码:

    展开全文
  • ribbon和feign区别

    2019-09-06 22:59:06
    ribbon和feign区别 上一篇文章写了feign的用法,这篇就来谈谈ribbon和feign区别吧。 个人感觉吧,目前为止,还是feign好用一点,为啥呢,因为感觉ribbon要自己写url,其实原理和feign的@feignclient(value=“”...

    ribbon和feign的区别

    上一篇文章写了feign的用法,这篇就来谈谈ribbon和feign的区别吧。

    个人感觉吧,目前为止,还是feign好用一点,为啥呢,因为感觉ribbon要自己写url,其实原理和feign的@feignclient(value=“”)、@requestmapping()类似,但feign实现起来更简单了。

    看一下riddon是怎么实现远程访问的:

    依赖方面的话,好像没有加什么特殊的依赖,,,

    下面实现的是登录,然后成功之后跳转到课程界面;
    先看控制层:

    @Controller
    public class RibbonController {
    
       @Autowired
       private RibbonService service;
    
       @RequestMapping("login")
       public String login(String courseId,String stuId,String pwd){
           Student stu=service.loginService(stuId,pwd);
           if (stu!=null){
               return "redirect:index";
           }
           else {
               return "studentlogin";
           }
       }
       @RequestMapping("index")
       public String fun1(ModelMap mp){
           //System.out.println("到达index");
           List<Course> list=service.courseService();
           System.out.println(list);
           mp.addAttribute("courseList",list);
           return "courseShow";
       }
    }
    

    返回的是界面;

    再看service层:通过url访问到远程模块;

    @Service
    public class RibbonService {
       @Autowired
       private RestTemplate temp;
    
       private String url1="http://stuserver/login?stuId={1}&&pwd={2}";
       private String url2="http://coursesevice/courseShow";
       private String url3="";
    
       public Student loginService(String stuId,String pwd){
           ResponseEntity<Student> msg=temp.getForEntity(url1,Student.class,stuId,pwd);
           return msg.getBody();
       }
    
       public List<Course> courseService() {
           ResponseEntity<Course[]> msg=temp.getForEntity(url2,Course[].class);
           Course[] css=msg.getBody();
           List<Course> list= Arrays.asList(css);
           return list;
       }
    }
    

    远程模块的控制层:

    @Controller
    public class StudentController {
       @Autowired
       private StudentDao dao;
       
       @RequestMapping("login")
       @ResponseBody
       public Student fun(String stuId, String pwd) {
       	Student stu = dao.loginCheck(stuId, pwd);
       	return stu;
       }
    }
    

    dao层:

    @Repository
    public interface StudentDao {
       @Select("select * from student where stuId=#{arg0} and pwd=#{arg1}")
       public Student loginCheck(String stuId,String pwd);
    }
    

    这个arg0和arg1是必须要写成这个样子的,就算是下面写了@param也还是要写arg0…的。

    访问成功;

    具体的一些很专业的词汇我还没背下来,就不献丑了。

    展开全文
  • Ribbon Feign区别

    万次阅读 热门讨论 2019-01-30 16:22:01
    spring cloud的 Netflix 中提供了两个组件实现软负载均衡调用:ribbon feignRibbon 是一个基于 HTTP TCP 客户端 的负载均衡的工具。 它可以 在客户端 配置 ribbonServerList(服务端列表),使用 ...
  • 负载均衡Ribbon和Feign---SpringCloud

    万次阅读 2021-01-15 15:44:20
    负载均衡Ribbon和Feign Ribbon负载均衡(基于客户端) 6.1 负载均衡以及Ribbon Ribbon是什么? Spring Cloud Ribbon 是基于Netflix Ribbon 实现的一套客户端负载均衡的工具。 简单的说,Ribbon 是 Netflix 发布的...
  • Ribbon和Feign区别

    2020-04-24 09:08:55
    Ribbon和Feign区别 Ribbon和Feign都是用于调用其他服务的,不过方式不同。 1.启动类使用的注解不同,Ribbon用的是@RibbonClient,Feign用的是@EnableFeignClients。 2.服务的指定位置不同,Ribbon是在@Ribbon...
  • SpringCloud Ribbon Feign区别

    千次阅读 2019-10-31 14:38:12
    spring cloud的 Netflix 中提供了两个组件实现软负载均衡调用:ribbon feignRibbon 是一个基于 HTTP TCP 客户端 的负载均衡的工具。 它可以 在客户端 配置 RibbonServerList(服务端列表),使用 ...
  • Ribbon和Feign 服务构建区别

    千次阅读 2020-11-10 23:39:41
    feign和ribbon是Spring Cloud的Netflix中提供的两个实现软负载均衡的组件,Ribbon和Feign都是用于调用其他服务的,方式不同。Feign则是在Ribbon的基础上进行了一次改进,采用接口的方式。 pom文件 <!--ribbon--&...
  • Ribbon和feign区别

    2019-08-07 10:57:50
    Ribbon是Netflix发布的负载均衡器,它有助于控制HTTPTCP客户端的行为。为Ribbon配置服务提供者地址列表后,Ribbon就可基于某种负载均衡算法,例如轮询、随机等。当然,我们也可为Ribbon实现自定义的负载均衡算法。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 28,847
精华内容 11,538
关键字:

ribbon和feign区别