七、【SpringCloud】Feign：负载均衡

狂神-SpringCloud笔记目录

---

---

七、Feign：负载均衡

7.1 Feign简介

Ribbon基于客户端。

Feign是声明式Web Service客户端，它让微服务之间的调用变得更简单，类似controller调用service。

SpringCloud集成了Ribbon和Eureka，也可以使用Feigin提供负载均衡的http客户端。

（Feign就是在Ribbon的基础上加了一层，将使用方式转变为面向接口编程的方式）

只需要创建一个接口，然后添加注解即可~

Feign，主要是社区版，大家都习惯面向接口编程。这个是很多开发人员的规范。调用微服务访问两种方法

1. 微服务名字 【ribbon 是通过微服务名字去访问】
2. 接口和注解 【feign】

Feign能干什么？

• Feign旨在使编写Java Http客户端变得更容易
• 前面在使用Ribbon + RestTemplate时，利用RestTemplate对Http请求的封装处理，形成了一套模板化的调用方法。但是在实际开发中，由于对服务依赖的调用可能不止一处，往往一个接口会被多处调用，所以通常都会针对每个微服务自行封装一个客户端类来包装这些依赖服务的调用。所以，Feign在此基础上做了进一步的封装，由他来帮助我们定义和实现依赖服务接口的定义，在Feign的实现下，我们只需要创建一个接口并使用注解的方式来配置它 (类似以前Dao接口上标注Mapper注解，现在是一个微服务接口上面标注一个Feign注解)，即可完成对服务提供方的接口绑定，简化了使用Spring Cloud Ribbon 时，自动封装服务调用客户端的开发量。

Feign默认集成了Ribbon

• 利用Ribbon维护了MicroServiceCloud-Dept的服务列表信息，并且通过轮询实现了客户端的负载均衡，而与Ribbon不同的是，通过Feign只需要定义服务绑定接口且以声明式的方法，优雅而简单的实现了服务调用。

7.2 Feign的使用步骤

1. 创建springcloud-consumer-fdept-feign模块

   

   拷贝springcloud-consumer-dept-80模块下的pom.xml，resource，以及java代码到springcloud-consumer-feign模块，并添加feign依赖。

   <!--Feign的依赖-->
   <dependency>
       <groupId>org.springframework.cloud</groupId>
       <artifactId>spring-cloud-starter-feign</artifactId>
       <version>1.4.6.RELEASE</version>
   </dependency>
   

   通过Ribbon实现：原来的controller：DeptConsumerController.java

   @RestController
   public class DeptConsumerController {
   
       /**
        * 理解：消费者，不应该有service层~
        * RestTemplate .... 供我们直接调用就可以了！ 注册到Spring中
        * (地址：url, 实体：Map ,Class<T> responseType)
        * <p>
        * 提供多种便捷访问远程http服务的方法，简单的Restful服务模板~
        */
       @Autowired
       private RestTemplate restTemplate;
   
       /**
        * 服务提供方地址前缀
        * <p>
        * Ribbon:我们这里的地址，应该是一个变量，通过服务名来访问
        */
   //    private static final String REST_URL_PREFIX = "http://localhost:8001";
       private static final String REST_URL_PREFIX = "http://SPRINGCLOUD-PROVIDER-DEPT";
   
       /**
        * 消费方添加部门信息
        * @param dept
        * @return
        */
       @RequestMapping("/consumer/dept/add")
       public boolean add(Dept dept) {
           // postForObject(服务提供方地址(接口),参数实体,返回类型.class)
           return restTemplate.postForObject(REST_URL_PREFIX + "/dept/add", dept, Boolean.class);
       }
   
       /**
        * 消费方根据id查询部门信息
        * @param id
        * @return
        */
       @RequestMapping("/consumer/dept/get/{id}")
       public Dept get(@PathVariable("id") Long id) {
           // getForObject(服务提供方地址(接口),返回类型.class)
           return restTemplate.getForObject(REST_URL_PREFIX + "/dept/get/" + id, Dept.class);
       }
   
       /**
        * 消费方查询部门信息列表
        * @return
        */
       @RequestMapping("/consumer/dept/list")
       public List<Dept> list() {
           return restTemplate.getForObject(REST_URL_PREFIX + "/dept/list", List.class);
       }
   }
   

   通过Feign实现： 改造后controller：DeptConsumerController.java

    package com.wlw.springcloud.controller;
    
    import com.wlw.springcloud.pojo.Dept;
    import com.wlw.springcloud.service.DeptClientService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    import org.springframework.web.client.RestTemplate;
    
    import java.util.List;
    
    @RestController
    public class DeptController {
    
        //这是Ribbon 之前的写法：
        //@Autowired
        //提供多种便捷访问远程http服务的方法，简单的restful服务模板
        // （url，实体：map，Class<T>，responseType）
        //private RestTemplate restTemplate;
    
        //利用Ribbon来做负载均衡时:我们这里的地址，应该是一个变量，通过服务名来访问（服务提供者在配置文件中配置的名字）
        //private static final String REST_URL_PREFIX = "http://localhost:8001";
        //private static final String REST_URL_PREFIX = "http://SPRINGCLOUD-PROVIDER-DEPT";
    
    /*    @RequestMapping("/consumer/dept/add")
        public boolean add(Dept dept){
            //这个地方就是使用Restful来实现访问服务端中的接口（http协议？ 不是rpc）
            return restTemplate.postForObject(REST_URL_PREFIX + "/dept/add", dept,Boolean.class);
        }
     */
    
        //这是Feign：
        @Autowired
        private DeptClientService service ;
    
        @RequestMapping("/consumer/dept/add")
        public boolean add(Dept dept){
            return service.addDept(dept);
        }
    
        @GetMapping("/consumer/dept/get/{id}")
        public Dept get(@PathVariable("id") Long id){
            return service.queryById(id);
        }
    
        @RequestMapping("/consumer/dept/list")
        public List<Dept> list(){
            return service.queryAll();
        }
    
    }
   
   

   Feign和Ribbon二者对比，前者显现出面向接口编程特点，代码看起来更清爽，而且Feign调用方式更符合我们之前在做SSM或者SprngBoot项目时，Controller层调用Service层的编程习惯！

   主配置类：

    package com.wlw.springcloud;
   
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
    import org.springframework.cloud.openfeign.EnableFeignClients;
    import org.springframework.context.annotation.ComponentScan;
    
    //Ribbon 和 Eureka 整合以后，客户端可以直接调用，不用关心IP地址和端口号
    @SpringBootApplication
    @EnableEurekaClient
    @EnableFeignClients(basePackages = {"com.wlw.springcloud"}) //扫描哪下面的包 中的注解@FeignClien
    public class DeptConsumer_80_feign {
        public static void main(String[] args) {
            SpringApplication.run(DeptConsumer_80_feign.class,args);
        }
    }
   
   

2. 改造springcloud-api模块

   pom.xml添加feign依赖

   <!--Feign的依赖-->
   <dependency> 
      	 <groupId>org.springframework.cloud</groupId>
         <artifactId>spring-cloud-starter-feign</artifactId>
         <version>1.4.6.RELEASE</version>
   </dependency>
   

   新建service包，并新建DeptClientService.java接口，

    package com.wlw.springcloud.service;
    
    import com.wlw.springcloud.pojo.Dept;
    import jdk.nashorn.internal.ir.annotations.Reference;
    import org.springframework.cloud.openfeign.FeignClient;
    import org.springframework.stereotype.Component;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.PathVariable;
    
    import java.util.List;
    
    /**
     * feign:写一个接口（DeptClientService 接口）
     * 加一个注解（@FeignClient(value = "SPRINGCLOUD-PROVIDER-DEPT")）
     */
    
    //和 @Reference 是一样的 value 是微服务的名字，（类似于Bibbon在配置文件中配置的服务名字）
    @FeignClient(value = "SPRINGCLOUD-PROVIDER-DEPT",fallbackFactory = DeptClientServiceFallbackFactory.class)
    @Component
    public interface DeptClientService {
    
        @GetMapping("/dept/get/{id}")
        public Dept queryById(@PathVariable("id") Long id);
    
        @GetMapping("/dept/list")
        public List<Dept> queryAll();
    
        @GetMapping("/dept/add")
        public boolean addDept(Dept dept);
    }
   
   

7.3 Feign和Ribbon如何选择？

根据个人习惯而定，如果喜欢REST风格使用Ribbon；如果喜欢社区版的面向接口风格使用Feign.

Feign 本质上也是实现了 Ribbon，只不过后者是在调用方式上，为了满足一些开发者习惯的接口调用习惯！Feign 的作用就是替代原先Ribbon在Controller层中RestTemplate，使代码的可读性变高，但是性能变低了。

package com.wlw.springcloud.controller;
@RestControllerpublic 
class DeptController {
 	//private RestTemplate restTemplate;
 	//利用Ribbon来做负载均衡时:我们这里的地址，应该是一个变量，通过服务名来访问（服务提供者在配置文件中配置的名字）    
 	//private static final String REST_URL_PREFIX = "http://localhost:8001";    	
 	//private static final String REST_URL_PREFIX = "http://SPRINGCLOUD-PROVIDER-DEPT";
}

下面我们关闭springcloud-consumer-dept-80 这个服务消费方，换用springcloud-consumer-dept-feign(端口还是80) 来代替：(依然可以正常访问，就是调用方式相比于Ribbon变化了)