SpringCloud笔记三：服务消费者ribbon和feign和注册中心高可用

最新推荐文章于 2022-05-22 19:49:07 发布

原创最新推荐文章于 2022-05-22 19:49:07 发布 · 300 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#feign远程调用

【SpringCloud专栏】专栏收录该内容

11 篇文章

订阅专栏

本文探讨了微服务架构中服务间调用的方式，包括RPC和REST(HTTP)，重点介绍了SpringCloud中的ribbon和feign两种服务消费者实现。通过实战案例，展示了如何使用ribbon和feign进行服务调用，以及它们的内部机制和负载均衡策略。

SpringCloud笔记三：服务消费者ribbon和feign和注册中心高可用

文章目录

- - SpringCloud笔记三：服务消费者ribbon和feign和注册中心高可用

常用的服务间调用方式

RPC调用方式

远程过程调用，像调用本地服务一样调用服务器的服务。

支持同步，异步调用。

客户端和服务端之间建立TCP连接，可以一次建立一个，也可以多个调用复用一次连接。

也就是说，建立连接后，每次调用就用这个连接，不需要再次连接了，因为每次建立连接都会消耗资源的。（三次握手）

适合千万级别的用户。

Rpc数据包小，使用谷歌开源protobuf

开发成本高，编码，序列化问题，丢包，分包。

Rest(http)

http请求，支持各种协议和功能。

开发方便成本低。

http数据包大

微服务调用之ribbon实战，订单调用商品服务

开发步骤

1、创建order_service项目

2、开发伪下单接口

3、使用ribbon

启动类增加注解，这个是ribbon的负载均衡策略

@Bean

@LoadBalanced

public RestTemplate restTemplate(){

return new RestTemplate();

}

4、根据名称进行调用商品，获取商品详情。

ribbon介绍

类似于HttpClient，urlConnection

核心代码

@Service
public class PorductOrderServiceImpl implements ProductOrderService {

    @Autowired
    private RestTemplate restTemplate;

    @Override
    public ProductOrder save(int userId, int productId) {
        Object obj = restTemplate.getForObject("http://product-service/api/v1/product/find?id=" + productId, Object.class);
        System.out.println(obj);
        //获取商品详情
        ProductOrder productOrder=new ProductOrder();
        productOrder.setCreateTime(new Date());
        productOrder.setUserId(userId);
        productOrder.setTradeNo(UUID.randomUUID().toString());
        return productOrder;
    }
}

核心配置

server:
  port: 8781

#服务的名称
spring:
  application:
    name: order-service

#指定注册中心地址
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/

Ribbon负载均衡源码分析

引入rbbion的负载均衡器的第二种方式

通过注入：LoadBalancerClient，和在启动类里面添加Bean一样。

@Service
public class PorductOrderServiceImpl implements ProductOrderService {

    /*@Autowired
    private RestTemplate restTemplate;*/

    @Autowired
    private LoadBalancerClient loadBalancerClient;


    @Override
    public ProductOrder save(int userId, int productId) {
        //Map<String,Object> productMap = restTemplate.getForObject("http://product-service/api/v1/product/find?id=" + productId, Map.class);
        //获取商品详情
        ServiceInstance instance = loadBalancerClient.choose("product-service");
        String url=String.format("http://%s:%s/api/v1/product/find?id="+productId,instance.getHost(),instance.getPort());
        RestTemplate restTemplate=new RestTemplate();
        Map<String,Object> productMap1 =restTemplate.getForObject(url,Map.class);
        ProductOrder productOrder=new ProductOrder();
        productOrder.setCreateTime(new Date());
        productOrder.setUserId(userId);
        productOrder.setTradeNo(UUID.randomUUID().toString());
        productOrder.setProductName(productMap.get("name").toString());
        productOrder.setPrice(Integer.parseInt(productMap.get("price").toString()));
        return productOrder;
    }
}

源码分析ribbon的负载均衡类

ctrl+shift+N搜索LoadBalancerClient，查看chose()方法，通过源码得知里面的负载均衡策略。

调用负载均衡步骤
1、首先从注册中心获取provider的列表

2、通过一定的策略选择其中一个节点。

3、再返回restTemplete调用。

调整ribbon的负载均衡策略

调整负载均衡策略官方文档

在yml文件里面进行配置

ribbon默认的负载均衡策略是：轮流进行，下面修改成随机的。

#要调用的服务名
product-service:
		ribbon:
		    #找到IRule的实现类，并将该实现类的权限名copy过来。
			NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule

策略配置

1、如果每个机器配置一样，则建议不修改策略。(推荐)

2、如果部分机器配置强，则可以改为 WeightedResponseTimeRule

微服务调用方式feign

feign

Feign：伪RPC客户端（本质还是http)

Feign官方文档

使用步骤

1、加入依赖,注意新旧版本

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

2、启动类添加@EnableFeignClients注解

3、增加接口并@FeignClient(name=“所调用服务的注册名字”)

@FeignClient(name = "product-service")
public interface ProductClient {

    @GetMapping("api/v1/product/find")
    String findById(@RequestParam(value = "id") int id);
}

4、实现类调用，将响应的json转成JsonNode,然后从里面取值。

@Service
public class PorductOrderServiceImpl implements ProductOrderService {

    /*@Autowired
    private RestTemplate restTemplate;*/

    /* @Autowired
    private LoadBalancerClient loadBalancerClient;*/

    @Autowired
    private ProductClient productClient;



    @Override
    public ProductOrder save(int userId, int productId) {
        //Map<String,Object> productMap = restTemplate.getForObject("http://product-service/api/v1/product/find?id=" + productId, Map.class);
        //获取商品详情
        /* ServiceInstance instance = loadBalancerClient.choose("product-service");
        String url=String.format("http://%s:%s/api/v1/product/find?id="+productId,instance.getHost(),instance.getPort());
        RestTemplate restTemplate=new RestTemplate();
        Map<String,Object> productMap1 =restTemplate.getForObject(url,Map.class);*/
        String response = productClient.findById(productId);
        JsonNode jsonNode = JsonUtils.str2JsonNode(response);

        ProductOrder productOrder=new ProductOrder();
        productOrder.setCreateTime(new Date());
        productOrder.setUserId(userId);
        productOrder.setTradeNo(UUID.randomUUID().toString());
        /*productOrder.setProductName(productMap.get("name").toString());
        productOrder.setPrice(Integer.parseInt(productMap.get("price").toString()));*/
        productOrder.setProductName(jsonNode.get("name").toString());
        productOrder.setPrice(Integer.parseInt(jsonNode.get("price").toString()));
        return productOrder;
    }
}

5、json转JsonNode

public class JsonUtils {

    private static final ObjectMapper objectMapper=new ObjectMapper();

    public static JsonNode str2JsonNode(String str)  {

        try {
            return objectMapper.readTree(str);
        } catch (JsonProcessingException e) {
            return  null;
        }
    }
}

Feign源码解读以及Feign和Ribbon的选择

设置当前线程睡眠

TimeUnit.SECONDS.sleep(10);//该方法会让当前线程睡眠10s,睡眠会放弃cpu,但是不会放弃锁对象。wait()会让出cpu和锁对象。该API还可以设置分钟。

超时配置

默认options readtimeout是60,但是由于Hystrix默认是1s超时.下面是超时配置

#修改feign请求的超时时间
feign:
  client:
    config:
      default:
        connectTimeout: 2000
        readTimeout: 2000

Feign内部的负载均衡策略其实使用的是ribbon
尽量使用Feign，因为Feign解耦性更强。