1、服务治理介绍

先来思考一个问题

通过上一章的操作，我们已经可以实现微服务之间的调用。但是我们把服务提供者的网络地址

（ip，端口）等硬编码到了代码中，这种做法存在许多问题：

l 一旦服务提供者地址变化，就需要手工修改代码

l 一旦是多个服务提供者，无法实现负载均衡功能

l 一旦服务变得越来越多，人工维护==调用关系==困难

那么应该怎么解决呢，这时候就需要通过注册中心动态的实现服务治理。

什么是服务治理

服务治理是微服务架构中最核心最基本的模块。用于实现各个微服务的自动化注册与发现。

服务注册：在服务治理框架中，都会构建一个*注册中心*，每个服务单元向注册中心登记自己提供服务的详细信息。并在注册中心形成一张服务的*清单*，服务注册中心需要以*心跳30s 90s*的方式去监测清单中的服务是否可用，如果不可用，需要在服务清单中剔除不可用的服务。

服务发现：服务调用方向服务注册中心咨询服务，并获取*所有服务*的实例清单，实现对具体服务实例的访问。

1.1 常见的服务治理组件

eureka: 它是netflix公司提供的一款组件，这款组件已经停止更新。

nacos: 它是阿里巴巴提供的一款服务治理组件。

zookeeper: 它是apache公司提供的服务治理组件。

consul: 服务治理的组

1.2 安装nacos治理组件

Releases · alibaba/nacos · GitHub

解压到当前目录---不要带中文

修改完，保存

在浏览器访问

http://localhost:8848/nacos

账号：nacos

密码：nacos

1.3 微服务注册到注册中心

（1）引入nacos的依赖

<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

（2）配置文件指定注册中心的地址

# 注册中心的地址
spring.cloud.nacos.discovery.server-addr=localhost:8848

（3）为微服务起名

# 起名字单词之间使用-划线
spring.application.name=qy163-product

完成版application.properties配置类

# 端口号：8080~8090
server.port=8080

#数据源
spring.datasource.url=jdbc:mysql://localhost:3306/springcloud-product?serverTimezone=Asia/Shanghai
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.username=root
spring.datasource.password=admin

#打印 sql日志
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

# 注册中心的地址
spring.cloud.nacos.discovery.server-addr=localhost:8848

# 起名字单词之间使用-划线
spring.application.name=qy163-product

（4）修改订单微服务的代码

package com.aaa.order.controller;

import com.aaa.order.service.OrderService;
import com.aaa.pojo.Order;
import com.aaa.pojo.Product;
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.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import java.util.List;

/**
 * @program: parent
 * @author: Jmy
 * @create: 2023-05-12 18:56
 **/
@RestController
@RequestMapping("/order")
public class OrderController {

    @Autowired
    private OrderService orderService;

    //该类默认没有交给spring容器管理
    @Autowired
    private RestTemplate restTemplate;

    //在springcloud中提供了一个类DiscoveryClient 该类可以从注册中心naco拉取指定的服务清单
    @Autowired
    private DiscoveryClient discoveryClient;

    @GetMapping("save")
    public String save(Integer pid,Integer num){ //需要传入 商品id，数量信息
        Order order = new Order();
        order.setUid(1);
        order.setUsername("猪八戒");
        order.setNumber(num);

        List<ServiceInstance> instances = discoveryClient.getInstances("qy163-product");
        ServiceInstance serviceInstance = instances.get(0);//获取第一个服务实例
        //System.out.println(serviceInstance.getUri());//http://192.168.126.1:8080
        String path = serviceInstance.getUri().toString();
        
        //商品信息的设置：远程调用商品微服务的接口，基于Http协议进行远程调用
        //两种基于HTTP调用的方式:
        //第一种：可以使用httpclient工具jar 自己封装工具类（不用）
        //第二种：spring框架中提供了一个工具类，RestTemplate

        Product product = restTemplate.getForObject(path+"/product/getById/" + pid, Product.class);
        if(product == null){
            return "下单失败";
        }

        order.setPid(product.getPid());
        order.setPname(product.getPname());
        order.setPprice(product.getPprice());

        orderService.save(order);

        return "下单成功";
    }
}

2、实现负载均衡

2.1 什么是负载均衡

负载均衡就是将负载（工作任务，访问请求）进行分摊到多个操作单元（服务器,组件）上进行执行

可以手动完成负载均衡

2.2集群的搭建

2.3修改Order调用方

package com.aaa.order.controller;

import com.aaa.order.service.OrderService;
import com.aaa.pojo.Order;
import com.aaa.pojo.Product;
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.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import java.util.List;
import java.util.Random;

/**
 * @program: parent
 * @author: Jmy
 * @create: 2023-05-12 18:56
 **/
@RestController
@RequestMapping("/order")
public class OrderController {

    @Autowired
    private OrderService orderService;

    //该类默认没有交给spring容器管理
    @Autowired
    private RestTemplate restTemplate;

    //在springcloud中提供了一个类DiscoveryClient 该类可以从注册中心naco拉取指定的服务清单
    @Autowired
    private DiscoveryClient discoveryClient;

    @GetMapping("save")
    public String save(Integer pid,Integer num){ //需要传入 商品id，数量信息
        Order order = new Order();
        order.setUid(1);
        order.setUsername("猪八戒");
        order.setNumber(num);

        List<ServiceInstance> instances = discoveryClient.getInstances("qy163-product");

        //随机负载均衡
        int i = new Random().nextInt(instances.size());

        ServiceInstance serviceInstance = instances.get(i);//获取第一个服务实例
        //System.out.println(serviceInstance.getUri());//http://192.168.126.1:8080
        String path = serviceInstance.getUri().toString();

        //商品信息的设置：远程调用商品微服务的接口，基于Http协议进行远程调用
        //两种基于HTTP调用的方式:
        //第一种：可以使用httpclient工具jar 自己封装工具类（不用）
        //第二种：spring框架中提供了一个工具类，RestTemplate

        Product product = restTemplate.getForObject(path+"/product/getById/" + pid, Product.class);
        if(product == null){
            return "下单失败";
        }

        order.setPid(product.getPid());
        order.setPname(product.getPname());
        order.setPprice(product.getPprice());

        orderService.save(order);

        return "下单成功";
    }
}

2.4 使用ribbon完成负载均衡

2.4.1什么是ribbon

ribbon：是Netflix发布的一个负载均衡器，有助于控制Http和Tcp客户端行为。在SpringCloud中，nacos一般配合Ribbon进行使用，Ribbon提供了客户端负载均衡的功能，Ribbon利用从nacos中读取到的服务信息，在调用服务节点提供的服务时，会合理（策略）的进行负载。在SpringCloud中可以将注册中心和Ribbon配合使用，Ribbon自动的从注册中心获取服务提供者的列表信息，并基于内置的负载均衡算法，请求服务。

基于Ribbon实现服务调用，是通过拉取到的所有服务列表组成（服务名-请求路径的）映射关系。借助 RestTemplate 最终进行调

2.4.2如何使用ribbon

(1)在RestTemplate类上加个注解@LoadBalance

package com.aaa.order;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

/**
 * @program: parent
 * @author: Jmy
 * @create: 2023-05-12 18:46
 **/
@SpringBootApplication
@MapperScan(basePackages = "com.aaa.order.dao")
public class OrderApp {
    public static void main(String[] args) {
        SpringApplication.run(OrderApp.class,args);
    }

    @Bean
    @LoadBalanced //springcloud在扫描时会帮你完成从注册中心拉取服务清单的功能
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }
}

(2)修改controller层代码

package com.aaa.order.controller;

import com.aaa.order.service.OrderService;
import com.aaa.pojo.Order;
import com.aaa.pojo.Product;
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.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import java.util.List;
import java.util.Random;

/**
 * @program: parent
 * @author: Jmy
 * @create: 2023-05-12 18:56
 **/
@RestController
@RequestMapping("/order")
public class OrderController02 {

    @Autowired
    private OrderService orderService;

    //该类默认没有交给spring容器管理
    @Autowired
    private RestTemplate restTemplate;

    @GetMapping("save")
    public String save(Integer pid,Integer num){ //需要传入 商品id，数量信息
        Order order = new Order();
        order.setUid(1);
        order.setUsername("猪八戒");
        order.setNumber(num);

        //商品信息的设置：远程调用商品微服务的接口，基于Http协议进行远程调用
        //两种基于HTTP调用的方式:
        //第一种：可以使用httpclient工具jar 自己封装工具类（不用）
        //第二种：spring框架中提供了一个工具类，RestTemplate

        Product product = restTemplate.getForObject("http://qy163-product/product/getById/" + pid, Product.class);
        if(product == null){
            return "下单失败";
        }

        order.setPid(product.getPid());
        order.setPname(product.getPname());
        order.setPprice(product.getPprice());

        orderService.save(order);

        return "下单成功";
    }
}

ribbon默认采用的是轮询策略。是否可以修改负载均衡策略。

ribbon内置的负载均衡策略

Ribbon内置了多种负载均衡策略,内部负载均衡的顶级接口为 com.netflix.loadbalancer.IRule , 具体的负载策略如下图所示:

2.4.3如何改变ribbon的负载均衡策略

修改order的配置文件

# 修改ribbon负载均衡策略
qy163-product.ribbon.NFLoadBalancerRuleClassName=com.netflix.loadbalancer.RandomRule

#解释 qy163-product：表示对访问哪个微服务设置负载均衡策略
#com.netflix.loadbalancer.RandomRule：负载均衡策略类

使用ribbon完成了从nacos自动拉取服务，并完成负载均衡功能。

3、使用Openfeign完成远程调用

上面服务之间的调用使用的是RestTemplate. 使用Resttemplate远程调用，它不符合我们的编程习惯。Controller---Service---Dao 再Controller注入一个service对象，然后调用service中的方法，根据方法传递相应的参数以及接受方法的返回的结果。

我们可以使用Openfeign组件来完成。

什么是OpenFeign

OpenFeign是Spring Cloud提供的一个声明式的伪Http客户端，它使得调用远程服务就像调用本地服务一样简单，只需要创建一个接口并添加一个注解即可。

Nacos很好的兼容了OpenFeign， OpenFeign负载均衡默认集成了 Ribbon，所以在Nacos下使用OpenFegin默认就实现了负载均衡的效果。

总结: openfeign就是为了完成服务的远程调用，它就像调用本地方法一样。

3.1如何使用OpenFeign

(1) 依赖openfeign依赖

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

(2)定义接口并添加@FeignClient（value="服务提供者的名"）注解

package com.aaa.order.feign;

import com.aaa.pojo.Product;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

/**
 * @program: parent
 * @author: Jmy
 * @create: 2023-05-14 14:18
 **/

//@FeignClient(value="服务提供者的名字")
@FeignClient(value = "qy163-product")
public interface ProductFeign {

    //抽象方法一定要和服务提供者的接口方法一模一样
    @GetMapping("/product/getById/{pid}")
    public Product getById(@PathVariable Integer pid);
}

(3)在主启动类开启openfeign注解驱动

package com.aaa.order;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.cloud.openfeign.EnableFeignClients;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

/**
 * @program: parent
 * @author: Jmy
 * @create: 2023-05-12 18:46
 **/
@SpringBootApplication
@MapperScan(basePackages = "com.aaa.order.dao")
@EnableFeignClients //开启openFeign注解驱动
public class OrderApp {
    public static void main(String[] args) {
        SpringApplication.run(OrderApp.class,args);
    }

    @Bean
    @LoadBalanced //springcloud在扫描时会帮你完成从注册中心拉取服务清单的功能
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }
}

(4)在使用的类中注入Openfeign注解

package com.aaa.order.controller;

import com.aaa.order.feign.ProductFeign;
import com.aaa.order.service.OrderService;
import com.aaa.pojo.Order;
import com.aaa.pojo.Product;
import org.checkerframework.checker.units.qual.A;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

/**
 * @program: parent
 * @author: Jmy
 * @create: 2023-05-12 18:56
 **/
@RestController
@RequestMapping("/order")
public class OrderController03 {

    @Autowired
    private OrderService orderService;

     //注入openfeign接口
    @Autowired
    private ProductFeign productFeign;

    @GetMapping("save")
    public String save(Integer pid,Integer num){ //需要传入 商品id，数量信息
        //springCloud扫描到@FeignClient注解后，就会为该注解接口生成一个代理实现类，再把代理实现类注册改为相应的属性
        
        
        Order order = new Order();
        //用户信息--登录中获取
        order.setUid(1);
        order.setUsername("猪八戒");
        order.setNumber(num);

        Product product = productFeign.getById(pid);
        if(product == null){
            return "下单失败";
        }

        order.setPid(product.getPid());
        order.setPname(product.getPname());
        order.setPprice(product.getPprice());

        orderService.save(order);

        return "下单成功";
    }
}

总结

4、eureka作为注册中心[了解]

它的官网没有提供下载包。只能自己创建eureka的服务端。

（1）搭建eureka服务

（2）引入相关依赖

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.aaa</groupId>
        <artifactId>parent</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <artifactId>eureka</artifactId>

    <dependencies>
        <!--eureka-server-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>

    </dependencies>
    <build>
        <finalName>eureka</finalName>
    </build>
</project>

（3）配置文件

server.port=7001

eureka.instance.hostname=localhost
#是否把该服务注册到eureka服务上
eureka.client.register-with-eureka=false
#是否该服务从注册中心eureka上拉取服务
eureka.client.fetch-registry=false

#微服务访问eureka访问的地址
eureka.client.service-url.defaultZone=http://localhost:7001/eureka/

#安全设置
security.basic.enabled=false

（4）主启动类

package com.aaa;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

/**
 * @program: parent
 * @author: Jmy
 * @create: 2023-05-14 14:54
 **/

@SpringBootApplication
@EnableEurekaServer //开启eureka服务
public class EurekaApp {
    public static void main(String[] args) {
        SpringApplication.run(EurekaApp.class,args);
    }

}

其他微服务可以注册到eureka

(1)在product的pom里加入依赖

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>

(2)修改配置文件

eureka.client.service-url.defaultZone=http://localhost:7001/eureka/

三十四、服务治理、实现负载均衡、