SpringCloud中的OpenFeign及LoadBalancer的学习

        本文仅用于记录自己学习SpringCloud中的OpenFeign以及LoadBalancer的学习过程，包含服务调用以及负载均衡两个模块，若介绍有误，还请手下留情，敬请批评指正，遵循共同学习进步的原则。 

一、OpenFeign

引入依赖

<dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>

启动类加注解

        

@SpringBootApplication
@EnableFeignClients  //启用
@EnableDiscoveryClient
public class MainFeign82 {
    public static void main(String[] args) {
        SpringApplication.run(MainFeign82.class,args);
    }
}

common模块加上接口

@FeignClient(value = "cloud-payment-service") //对应的服务名字
public interface PayFeignApi {

    //以下是需要暴露的服务的接口
    @PostMapping(value = "/pay/add")
    public ReturnData addPay(@RequestBody PayDTO payDTO);

    @GetMapping(value = "/pay/getPayById/{id}")
    public ReturnData getPayById(@PathVariable("id") Integer id);

    @GetMapping(value = "/pay/get/info")
    public String getInfo();
}

主类的相应模块加上Controller的相关接口

@RestController
@RequestMapping("/feign")
public class OrderController {

    @Resource
    private PayFeignApi payFeignApi;

    @PostMapping("/pay/add")
    public ReturnData addOrder(@RequestBody PayDTO payDTO){
        return payFeignApi.addPay(payDTO);
    }

    @GetMapping("/pay/getPayById/{id}")
    public ReturnData getOrder(@PathVariable("id") Integer id){
        return payFeignApi.getPayById(id);
    }

    @GetMapping("/pay/get/info")
    private String getInfo(){
        return  payFeignApi.getInfo();
    }

   
}

高级特性：

1.OpenFeign超时控制

默认等待60s

yml配置时间

spring:
  cloud:
    openfeign:
      client:
        config:
          default:
            connect-timeout: 3000  ###全局配置
            read-timeout: 3000
          cloud-payment-service:  ###指定配置
            connect-timeout: 5000
            read-timeout: 5000
​

2.重试机制

加配置

@Configuration
public class FeignConfig {

    @Bean
    public Retryer retryer(){
//        return Retryer.NEVER_RETRY; //默认不走重试策略
        return new Retryer.Default(100,1,3); //启动时间period(毫秒)，最大重试时间间隔(秒),重试次数(初始 + 重复次数 例:1+2) 
    }
}

3.OpenFeign使用Apache HC5

引入依赖

<dependency>
            <groupId>org.apache.httpcomponents.client5</groupId>
            <artifactId>httpclient5</artifactId>
            <version>5.3</version>
        </dependency>
        <!--feign-hc5-->
        <dependency>
            <groupId>io.github.openfeign</groupId>
            <artifactId>feign-hc5</artifactId>
            <version>13.1</version>
        </dependency>

 配置开启

#  Apache HttpClient5 配置开启
spring:
  cloud:
    openfeign:
      httpclient:
        hc5:
          enabled: true

4.请求响应压缩

spring:
  cloud:
    openfeign:
      compression:
        request:
          enabled: true
          min-request-size: 2048 #最小触发压缩的大小
          mime-types: text/xml,application/xml,application/json #触发压缩数据类型
        response:
          enabled: true

5.日志打印

日志级别介绍

public static enum Level {
        NONE,
        BASIC,
        HEADERS,
        FULL;

        private Level() {
        }
    }

配置Bean

@Configuration
public class FeignConfig {

    @Bean
    Logger.Level feignLoggerLevel(){
        return Logger.Level.FULL;
    }
}

yml配置 必须以debug启动

logging:
  level:
    com:  #包名
      lllmark:
        cloud:
          apis:
            PayFeignApi: debug #类名 debug值

二、有关Load Balancer的负载均衡

引入依赖

<dependency>
        <groupId>org.springframework.cloud</groupId>
         <artifactId>spring-cloud-starter-loadbalancer</artifactId>
</dependency>

此处是基于RestTamplate的配置

@Configuration
public class RestTemplateConfig {
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate(){
        return  new RestTemplate();
    }
}

捕捉到服务的原理

@Resource
    private DiscoveryClient discoveryClient;

    @GetMapping("/discovery")
    public String discovery(){
        List<String> services = discoveryClient.getServices();
        for (String element: services){
            System.out.println(element);
        }
        System.out.println("===================");
        List<ServiceInstance> instances = discoveryClient.getInstances("cloud-payment-service");
        for (ServiceInstance instance : instances){
            System.out.println(instance.getServiceId() + "\t" + instance.getPort() +"\t" + instance.getUri());
        }
        return instances.get(0).getServiceId()+":"+instances.get(0).getPort();
    }

负载均衡策略

默认为轮询

改变成随机策略

​

@LoadBalancerClient(value = "cloud-payment-service", configuration = RestTemplateConfig.class)

@Configuration
//@LoadBalancerClients({@LoadBalancerClient(value = "cloud-payment-service", 
//configuration = RestTemplateConfig.class)
//})
public class RestTemplateConfig {
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate(){
        return  new RestTemplate();
    }

    @Bean
    ReactorLoadBalancer<ServiceInstance> randomLoadBalancer(Environment environment,
                                                            LoadBalancerClientFactory loadBalancerClientFactory) {
        String name = environment.getProperty(LoadBalancerClientFactory.PROPERTY_NAME);
        return new RandomLoadBalancer(loadBalancerClientFactory
                .getLazyProvider(name, ServiceInstanceListSupplier.class),
                name);
    }
}

[点击并拖拽以移动]
​