Spring Cloud Alibaba(二)服务注册与发现

---

一、服务注册与发现介绍

随着业务的发展，用户量和业务复杂度逐渐增加，系统为了支撑更大的流量需要做很多优化，比如升级服务器配置提升性能。在软件方面，我们会采用微服务架构、对业务服务进行微服务化拆分、水平扩容等来提升系统性能，以及解决业务的复杂性问题。
在微服务架构下，一个业务服务会被拆分成多个微服务，各个服务之间相互通信完成整体的功能。另外，为了避免单点故障，微服务都会采取集群方式的高可用部署，集群规模越大，性能也会越高，如图所示。

服务消费者要去调用多个服务提供者组成的集群。首先，服务消费者需要在本地配置文件中维护服务提供者集群的每个节点的请求地址。其次，服务提供者集群中如果某个节点下线或者宕机，服务消费者的本地配置中需要同步删除这个节点的请求地址，防止请求发送到已宕机的节点上造成请求失败。为了解决这类的问题，就需要引入服务注册中心，它主要有以下功能:

• 服务地址的管理。
• 服务注册。
• 服务动态感知。

（一）常见注册中心

能够实现这类功能的组件很多，比如ZooKeeper、Eureka Consul、Etcd、Nacos等。在这一章中主要介绍Alibaba的Nacos。

• Zookeeper：zookeeper是一个分布式服务框架，是Apache Hadoop 的一个子项目，它主要是用来解决分布式
  应用中经常遇到的一些数据管理问题，如：统一命名服务、状态同步服务、集群管理、分布式应用
  配置项的管理等。

• Eureka：Eureka是Springcloud Netflix中的重要组件，主要作用就是做服务注册和发现。但是现在已经闭
  源

• Consul：Consul是基于GO语言开发的开源工具，主要面向分布式，服务化的系统提供服务注册、服务发现
  和配置管理的功能。Consul的功能都很实用，其中包括：服务注册/发现、健康检查、Key/Value
  存储、多数据中心和分布式一致性保证等特性。Consul本身只是一个二进制的可执行文件，所以
  安装和部署都非常简单，只需要从官网下载后，在执行对应的启动脚本即可。

• Nacos：Nacos是一个更易于构建云原生应用的动态服务发现、配置管理和服务管理平台。它是 Spring
  Cloud Alibaba 组件之一，负责服务注册发现和服务配置，可以这样认为nacos=eureka+config。

二、Alibaba Nacos 介绍

Nacos致力于解决微服务中的统一配置服务注册与发现等问题。它提供了一组简单易用的特性集，帮助开发者快速实现动态服务发现，服务配置，服务元数据及流量管理。
Nacos的关键特性如下：

• 服务发现和服务健康监测：
  Nacos支持基于DNS和基于RPC的服务发现。服务提供者使用原生SDK、OpenAPI或一个独立的Agent TODO注册Service后，服务消费者可以使用DNS或HTTP&API查找和发现服务。
  Nacos提供对服务的实时的健康检查，阻止向不健康的主机或服务实例发送请求。Nacos支持传输层(PING或TCP)和应用层(如HTTP、MySOL用户自定义)的健康检查。对于复杂的云环境和网络拓扑环境中(
  如VPC边缘网络等)服务的健康检查，Nacos提供了aent上报和服务端主动检测两种健康检查模式。Nacos还提供了统一的健康检查仪表盘，帮助用户根据健康状态管理服务的可用性及流量。

• 动态配置服务：
  业务服务一般都会维护一个本地配置文件，然后把一些常量配置到这个文件中。这种方式在某些场景中会存在问题，比如配置需要变更时要重新部署应用。而动态配置服务可以以中心化、外部化和动态化的方式管理所有环境的应用配置和服务配置，可以使配置管理变得更加高效和敏捷。配置中心化管理让实现无状态服务变得更简单，让服务按需弹性扩展变得更容易。
  另外，Nacos提供了一个简洁易用的UI(控制台样例Demo)帮助用户管理所有服务和应用的配置。Nacos还提供了包括配置版本跟踪、金丝雀发布，一键回滚配置及客户端配置更新状态跟踪在内的一系列开箱即用的配置管理特性，帮助用户更安全地在生产环境中管理配置变更，降低配置变更带来的风险。

• 动态DNS服务：
  动态DNS服务支持权重路由，让开发者更容易地实现中间层负载均衡、更灵活的路由策略、流量控制，以及数据中心内网的简单DNS解析服务。

• 服务及其元数据管理：
  Nacos可以使开发者从微服务平台建设的视角管理数据中心的所有服务及数据，包括管理服务的描述，生命周期、服务的静态依赖分析、服务的健康状态、服务的流量管理、路由及安全策略、服务的SLA及最重要的metrics统计数据。
  本书主要围绕Nacos中注册中心的特性及动态配置服务的特性进行展开讲解。

（一）核心功能:

• 服务注册:Nacos Client会通过发送REST请求的方式向NacosServer注册自己的服务，提供自身的元数据，比如ip地址，端口等信息。Nacos Server接收到注册请求后，就会把这些元数据信息存储在一个双层的内存Map中。

• 服务心跳:在服务注册后，NacosClient会维护一个定时心跳来持续通知NacosServer，说明服务一直处于可用状态，防止被剔除。默认5s发送一次心跳。

• 服务同步:NacosServer集群之间会互相同步服务实例，用来保证服务信息的一致性。leader raft服务发现:服务消费者(NacosClient)在调用服务提供者的服务时，会发送一个REST请求给NacosServer，获取上面面注册的服务清单，并且缓存在NacosClient本地,同时会在NacosClient本地开启一个定时任务定时拉取服务端最新的注册表信息更新到本地缓有

• 服务健康检查:NacosServer会开启一个定时任务用来检查注册服务实例的健康情况，对于超过15s没有收到客户端心跳的实例会将它的healthy属性置为false(客户端服务发现时不会发现)，如果某个实例超过30秒没有收到心跳，直接剔除该实例(被剔除的实例如果恢复发送心跳则会重新注册)
  

三、NacosServer安装部署

（一）window单节点安装

1. 下载nacos的GitHub地址下载zip包
2. 解压
3. 到bin目录下创建一个启动脚本start.bat,脚本内容如下：

startup.cmd -m standalone

4. 双击start.bat启动即可

（二）linux安装包方式单节点安装部署

官方快速开始教程连接地址
Nacos支持三种部署模式，分别是单机，集群和多集群。需要注意的是，Nacos依赖Java环境，并且要求使用JDK1.8以上版本。
Nacos的安装方式有两种，一种是源码安装，另一种直接是使用已经编译好的安装包。这里选择使用安装包方式安装。

1. jdk安装配置
在 Linux 中安装和配置 JDK 需要以下步骤：
检查系统中是否已经安装过 JDK 和 JRE。可以使用以下命令来检查：

java -version

如果系统中没有安装 JDK 和 JRE，则需要下载并安装 JDK。
参考 Oracle 官方网站，下载适合系统的 JDK 安装包。下载链接：
https://www.oracle.com/java/technologies/downloads/。
假设安装包为 /opt/jdk-11.0.11_linux-x64_bin.tar.gz。
解压安装包。可以使用以下命令：

tar -zxvf /opt/jdk-11.0.11_linux-x64_bin.tar.gz -C /opt/

配置环境变量。打开 /etc/profile 文件：

sudo vi /etc/profile

在文件末尾添加以下内容：

export JAVA_HOME=/opt/jdk-11.0.11 
export PATH=$JAVA_HOME/bin:$PATH

然后保存并退出文件。执行以下命令使配置文件立即生效：

source /etc/profile

验证 JDK 是否安装配置成功。可以使用以下命令：

java -version

执行该命令后，应该能看到已经安装的 JDK 版本信息。

2. nacos安装

1. 下载nacos的GitHub地址
   
2. 解压Nacos安装包

tar -zxvf nacos-server-2.1.1.tar.gz

解压完成后，会在解压的目录中看到一个nacos的文件夹。

3. 启动Nacos服务
   进入nacos跟目录，执行以下命令：

[root@bogon nacos]# sh bin/startup.sh -m standalone
/java/jdk-11.0.16//bin/java   -Xms512m -Xmx512m -Xmn256m -Dnacos.standalone=true -Dnacos.member.list= -Xlog:gc*:file=/nacos/nacos/logs/nacos_gc.log:time,tags:filecount=10,filesize=102400 -Dloader.path=/nacos/nacos/plugins/health,/nacos/nacos/plugins/cmdb,/nacos/nacos/plugins/selector -Dnacos.home=/nacos/nacos -jar /nacos/nacos/target/nacos-server.jar  --spring.config.additional-location=file:/nacos/nacos/conf/ --logging.config=/nacos/nacos/conf/nacos-logback.xml --server.max-http-header-size=524288
nacos is starting with standalone
nacos is starting，you can check the /nacos/nacos/logs/start.out

这样，就会启动Nacos服务。在启动过程中，如果出现错误，可以查看logs目录下的startup.log文件来查看具体错误信息。

4. 访问Nacos服务
   Nacos默认的访问地址为http://localhost:8848/nacos，可以在浏览器中输入该地址来访问Nacos服务。如果一切正常，将会看到Nacos的登录界面，输入默认账号(nacos)密码(nacos)即可登录。

到此，Nacos服务在Linux环境下的安装部署就完成了。如果想要深入了解更多关于Nacos的使用和配置，可以查看Nacos官方文档（https://nacos.io/zh-cn/docs/what-is-nacos.html）。

（三）linux源码方式单节点安装部署

1、下载Nacos源码并解压缩
在官网 https://github.com/alibaba/nacos/releases 下载源代码，可以选择.tar.gz或.zip格式的文件，解压到你想要安装的目录中。

wget https://github.com/alibaba/nacos/releases/download/2.2.2/nacos-server-2.2.2.tar.gz
tar -zxvf nacos.tar.gz

2、配置Nacos
进入解压后的nacos目录，修改conf/application.properties文件：

# 修改服务地址IP
nacos.inetutils.ip-address=your-server-ip
# 启用standalone模式
nacos.standalone=true
# 修改端口号
server.port=8848
# 修改数据存储位置
spring.datasource.platform=mysql
db.num=1
db.url.0=jdbc:mysql://127.0.0.1:3306/nacos?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true
db.user=your-db-username
db.password=your-db-password

注意要修改以下参数：

your-server-ip：修改为Nacos服务的IP地址
server.port：修改为要使用的端口号
db.url.0：修改为MySQL数据库的连接地址，并设置正确的数据库用户名和密码

3、创建数据库和数据表
使用MySQL客户端创建数据库和数据表，如下所示：

4、启动Nacos
进入解压后的nacos/bin目录，使用以下命令启动Nacos服务：

sh startup.sh -m standalone

如果启动成功，你应该可以在浏览器中访问 http://your-server-ip:8848/nacos 来查看Nacos控制台。

至此，Nacos就成功安装完成了。

（四）Nacos服务注册发现相关API说明

四、Nacos集成SpringBoot实现服务注册与发现

1、创建父工程

创建一个maven工程，然后在pom.xml文件中添加下面内容
各个版本的对应关系参考官网：官网版本对应关系描述地址

<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/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0modelVersion>

    <groupId>org.examplegroupId>
    <artifactId>BK-SpringCloudartifactId>
    <version>1.0-SNAPSHOTversion>

    <parent>
        <artifactId>spring-boot-starter-parentartifactId>
        <groupId>org.springframework.bootgroupId>
        <version>2.6.11version>
    parent>

    <properties>
        <maven.compiler.source>11maven.compiler.source>
        <maven.compiler.target>11maven.compiler.target>
    properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloudgroupId>
                <artifactId>spring-cloud-dependenciesartifactId>
                <version>2021.0.4version>
                <type>pomtype>
				<scope>importscope>
            dependency>
            <dependency>
                <groupId>com.alibaba.cloudgroupId>
                <artifactId>spring-cloud-alibaba-dependenciesartifactId>
                <version>2021.0.4.0version>
                <type>pomtype>
                <scope>importscope>
            dependency>
        dependencies>
    dependencyManagement>

project>

2、创建基础公共模块

在pom.xml中添加依赖

<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/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>BK-SpringCloudartifactId>
        <groupId>org.examplegroupId>
        <version>1.0-SNAPSHOTversion>
    parent>
    <modelVersion>4.0.0modelVersion>

    <artifactId>alibaba-commonartifactId>

    <properties>
        <maven.compiler.source>11maven.compiler.source>
        <maven.compiler.target>11maven.compiler.target>
    properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>
        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
        dependency>
        <dependency>
            <groupId>com.alibabagroupId>
            <artifactId>druid-spring-boot-starterartifactId>
            <version>1.2.15version>
        dependency>
        <dependency>
            <groupId>org.mybatis.spring.bootgroupId>
            <artifactId>mybatis-spring-boot-starterartifactId>
            <version>3.0.0version>
        dependency>
        <dependency>
            <groupId>org.projectlombokgroupId>
            <artifactId>lombokartifactId>
        dependency>
    dependencies>
project>

3、创建用户模块

步骤:
1 创建模块 导入依赖

<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/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>BK-SpringCloudartifactId>
        <groupId>org.examplegroupId>
        <version>1.0-SNAPSHOTversion>
    parent>
    <modelVersion>4.0.0modelVersion>

    <artifactId>alibaba-userartifactId>

    <properties>
        <maven.compiler.source>11maven.compiler.source>
        <maven.compiler.target>11maven.compiler.target>
    properties>

    <dependencies>
        <dependency>
            <groupId>org.examplegroupId>
            <artifactId>alibaba-commonartifactId>
            <version>1.0-SNAPSHOTversion>
        dependency>
    dependencies>

project>

2 创建SpringBoot主类

@SpringBootApplication
public class UserApplication {
  public static void main(String[] args) {
      SpringApplication.run(UserApplication.class,args);
  }
}

3 加入配置文件

spring:
  application:
    name: user-server
  datasource:
    druid:
      url: jdbc:mysql://127.0.0.1:3306/user?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
      driver-class-name: com.mysql.cj.jdbc.Driver
      username: root
      password: 123456
server:
  port: 7001

4 创建必要的接口和实现类(controller service dao)

@RestController
@RequestMapping("/user")
public class UserController {

    @GetMapping("/test")
    public String test(){
        return "aaaaaa";
    }
}

4、将用户模块作为微服务注册到nacos

接下来开始修改alibaba-user模块的代码， 将其注册到nacos服务上

1. 在pom.xml中添加nacos的依赖

        
        <dependency>
            <groupId>com.alibaba.cloudgroupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discoveryartifactId>
        dependency>

2. 在主类上添加@EnableDiscoveryClient注解

@SpringBootApplication
@EnableDiscoveryClient
public class UserApplication {
  public static void main(String[] args) {
      SpringApplication.run(UserApplication.class,args);
  }
}

3. 在application.yml中添加nacos服务的地址

spring:
  application:
    name: user-server
  datasource:
    druid:
      url: jdbc:mysql://127.0.0.1:3306/user?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
      driver-class-name: com.mysql.cj.jdbc.Driver
      username: root
      password: 123456
  cloud:
    nacos:
      discovery:
        server-addr: 192.168.109.149:8848
server:
  port: 7001

4. 启动服务， 观察nacos的控制面板中是否有注册上来的商品微服务
   

五、Nacos高可用部署

（一）集群模式

1、将nacos安装包解压出三份作为三个节点

[root@localhost nacos]# ll
total 108168
drwxr-xr-x. 8 root root       125 May 10 15:07 nacos8848
drwxr-xr-x. 8 root root       125 May 10 15:08 nacos8850
drwxr-xr-x. 8 root root       125 May 10 15:09 nacos8852
-rw-r--r--. 1 root root 110763952 May 10 09:38 nacos-server-2.1.1.tar.gz

2、修改conf/cluster.conf

三个节点的cluster.conf一致
vim /nacos/conf/cluster.conf

192.168.109.149:8848
192.168.109.149:8850
192.168.109.149:8852

3、修改conf/application.conf

修改各个节点的端口号vim /nacos/conf/application.conf

server.port=8850

server.port=8848

server.port=8850

4、关闭日志打印

nacos日志文件占用过多，将日志打印关闭
修改application.conf

server.tomcat.accesslog.enabled=false

5、修改各个节点的数据库配置

创建各个节点使用的数据库并分配权限
创建数据库的脚本文件再目录/nacos/nacos/conf/nacos-mysql.sql

创建用用户并分配权限
CREATE USER 'qlx'@'%' IDENTIFIED BY '123456';
GRANT ALL PRIVILEGES ON *.* TO 'qlx'@'%';
FLUSH PRIVILEGES;

配置各个节点的数据库vim /nacos/conf/application.conf

### If use MySQL as datasource:
spring.datasource.platform=mysql

### Count of DB:
db.num=1

### Connect URL of DB:
db.url.0=jdbc:mysql://192.168.43.45:3306/nacos8848?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true&useUnicode=true&useSSL=false&serverTimezone=Asia/Shanghai
db.user.0=qlx
db.password.0=123456

6、配置 JVM 参数

-Xms2g代表初始分配内存2g;
-Xmx2g代表jvm内存最大值;
-Xmn1g代表新生代内存为1g;
在nacos启动脚本startup.sh中的JVM Configuration下修改jvm启动参数，调小分配给jvm的内存

#===========================================================================================
# JVM Configuration
#===========================================================================================
if [[ "${MODE}" == "standalone" ]]; then
    JAVA_OPT="${JAVA_OPT} -Xms512m -Xmx512m -Xmn256m"
    JAVA_OPT="${JAVA_OPT} -Dnacos.standalone=true"
else
    if [[ "${EMBEDDED_STORAGE}" == "embedded" ]]; then
        JAVA_OPT="${JAVA_OPT} -DembeddedStorage=true"
    fi
    JAVA_OPT="${JAVA_OPT} -server -Xms512m -Xmx512m -Xmn256m -XX:MetaspaceSize=128m -XX:MaxMetaspaceSize=320m"
    JAVA_OPT="${JAVA_OPT} -XX:-OmitStackTraceInFastThrow -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=${BASE_DIR}/logs/java_heapdump.hprof"
    JAVA_OPT="${JAVA_OPT} -XX:-UseLargePages"
fi

7、启动各个节点

5、安装nginx

如果系统是centos8，出现yum源失效问题，可以参考这篇文章解决：yum源失效解决

1. 安装nginx

yum install -y nginx

直至出现 Complete!

在 CentOS 8 中使用 yum install -y nginx 安装 Nginx 后，Nginx 的相关文件会被安装到以下目录下：

Nginx 安装程序：/usr/sbin/nginx
配置文件：/etc/nginx/nginx.conf
网站文件：/usr/share/nginx/html
日志文件目录：/var/log/nginx
启动 Nginx 可以使用systemctl start nginx 命令。
如果要在系统启动时自动启动 Nginx，可以使用 systemctl enable nginx 命令将其加入自启动项中。
如果需要停止 Nginx，可以使用 systemctl stop nginx 命令。

2. 启动nginx

systemctl start nginx.service

3. 启动后在浏览器上访问
   

4. Nginx常用命令

查看版本：nginx -v
查看nginx安装目录：ps -ef | grep nginx
检查配置文件：nginx -t
启动：systemctl start nginx.service
停止：systemctl stop nginx.service
重启：systemctl restart nginx.service
设置开机自启动：systemctl enable nginx.service
停止开机自启动：systemctl disable nginx.service
查看当前状态：systemctl status nginx.service
查看所有已启动的服务：systemctl list-utils --type=service
重启nginx：service nginx restart(其他的：start, stop, try-restart, reload, force-reload, status)

5. Nginx绑定到指定端口
   这里添加nginx可以绑定8090端口semanage port -a -t http_port_t -p tcp 8090
   查看http允许访问的端口semanage port -l | grep http_port_t

[root@localhost nginx]# semanage port -a -t http_port_t -p tcp 8090
[root@localhost nginx]# semanage port -l | grep http_port_t
http_port_t                    tcp      8090, 80, 81, 443, 488, 8008, 8009, 8443, 9000
pegasus_http_port_t            tcp      5988
[root@localhost nginx]# systemctl start nginx.service

如果没有设置绑定，则nginx无法绑定该端口，在查看nginx状态时可以看到如下问题

[root@localhost nginx]# systemctl status nginx.service

May 11 14:41:16 localhost.localdomain nginx[8545]: nginx: [emerg] bind() to 0.0.0.0:8090 failed (13: Permission denied)

6. 配置反向代理配置

 upstream nacos_cluster {
	 server 192.168.159.8:8848;
	 server 192.168.159.8:8850;
	 server 192.168.159.8:8852;
 }
 server {
	 listen 8090;
	 server_name localhost;

 	#charset koi8‐r;

 	#access_log logs/host.access.log main;

	 location /nacos/ {
	 	proxy_pass http://nacos_cluster/nacos/;
	 }
 }

7. 重启nginx

systemctl restart nginx.service

8. 外网访问测试是否部署成功
   http://xxx.x.x.x:8090/nacos
9. springboot工程配置nacos注册中心

spring:
  cloud:
    nacos:
      discovery:
        server-addr: 192.168.109.149:8090/nacso

10.访问各个节点nacos页面查看服务注册情况

六、远程调用 & 负载均衡

（一）RestTemplate远程调用

RestTemplate是Spring提供的一个访问Http服务的客户端类

1、导依赖

        <dependency>
            <groupId>com.alibaba.cloudgroupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discoveryartifactId>
        dependency>

2、添加配置类

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

3、应用

@RestController
@RequestMapping("/user")
public class UserController {

    @Autowired
    private DiscoveryClient discoveryClient;
    @Autowired
    private RestTemplate restTemplate;

    @GetMapping("/test")
    public Integer test(){
//      从nacos中获取服务实例
        ServiceInstance serviceInstance = discoveryClient.getInstances("order-server").get(0);
//      获取服务IP和端口号
        String url = serviceInstance.getHost() + ":" +
                serviceInstance.getPort();
//      通过restTemplate调用订单微服务
        Integer num = restTemplate.getForObject("http://" + url + "/order/getOrderNum", Integer.class);
        return num;
    }
}

（二）RestTemplate负载均衡

1、添加依赖

<dependencies>
        
        <dependency>
            <groupId>com.alibaba.cloudgroupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discoveryartifactId>
        dependency>
        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-loadbalancerartifactId>
        dependency>
        <dependency>
            <groupId>org.examplegroupId>
            <artifactId>alibaba-commonartifactId>
            <version>1.0-SNAPSHOTversion>
        dependency>
    dependencies>

2、添加 @LoadBalanced 注解

在 MyConfig 类中创建了一个 RestTemplate Bean，并添加了 @LoadBalanced 注解，用于启用负载均衡能力。

@Configuration
public class RestConfig {

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

3、应用

需要注意的是，这里使用的是 RestTemplate 类，而不是 RibbonLoadBalancingHttpClient 类。因为 Spring Cloud Alibaba 中包含了一个名为 LoadBalancerInterceptor 的拦截器，该拦截器会自动判断是否需要启用负载均衡能力。

    @Autowired
    private DiscoveryClient discoveryClient;
    @Autowired
    private RestTemplate restTemplate;

    @GetMapping("/test2")
    public Integer test2(){
        String url = "http://order-server/order/getOrderNum";
        Integer num = restTemplate.getForObject(url,Integer.class);
        return num;
    }

（三）loadbalancer负载均衡策略

OpenFeign是一个用于客户端服务调用的工具，同样也支持负载均衡。OpenFeign的负载均衡策略主要有以下几种：

• 轮询策略（Round Robin）：即依次按照服务的实例列表进行轮流调用，均衡地将请求分配给每一个实例。
• 随机策略（Random）：即直接从服务实例列表中随机选择一个实例进行调用。
• 最小连接策略（Least Connections）：即根据当前实例的连接数来进行调用，当前连接数越小的实例被选中的概率越大。
• 响应时间加权策略（Response Time Weighted）：即根据服务实例的响应时间来进行调用，响应时间越短的实例被选中的概率越大。
• IP Hash算法策略（IP Hash）：即根据客户端请求的IP地址来进行hash算法计算，将请求分发到同一IP地址的服务实例上。

在实际开发中，根据具体的业务场景选择合适的负载均衡策略非常重要，可以保证服务的高可用性和性能。

七、基于Feign实现服务调用

（一）什么是Feign

Feign是Spring Cloud提供的一个声明式的伪Http客户端， 它使得调用远程服务就像调用本地服务
一样简单， 只需要创建一个接口并添加一个注解即可。
Nacos很好的兼容了Feign， Feign默认集成了 Ribbon， 所以在Nacos下使用Fegin默认就实现了负
载均衡的效果

（二）Feign应用

1、加入Fegin的依赖

  <dependencies>
        
        <dependency>
            <groupId>com.alibaba.cloudgroupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discoveryartifactId>
        dependency>
        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-loadbalancerartifactId>
        dependency>

        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-openfeignartifactId>
        dependency>
        <dependency>
            <groupId>org.examplegroupId>
            <artifactId>alibaba-commonartifactId>
            <version>1.0-SNAPSHOTversion>
        dependency>
    dependencies>

2、在启动类上添加@EnableFeignClients注解

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

3、创建feign接口

@FeignClient(value = "order-server",path = "/order")//声明调用的提供者的name
public interface OrderFeign {
    //指定调用提供者的哪个方法
//@FeignClient+@GetMapping 就是一个完整的请求路径 http://serviceproduct/product/{pid}
    @GetMapping("/getOrderNum")
    Integer getOrderNum();
}

4、controller调用feign

    @Autowired
    private OrderFeign orderFeign;

    @GetMapping("/test")
    public Integer test(){
        return orderFeign.getOrderNum();
    }

（三）超时时间配置

1、局部配置超时时间

feign:
  client:
    config:
      order-server:
        connectTimeout: 3000
        readTimeout: 3000
#        loggerLevel: debug

2、全局配置超时时间

（1）方式1

 @Bean
    public Request.Options options(){
        return new Request.Options(5000,5000);
    }

其中的参数(5000,5000)表示该请求的超时时间，即在5000毫秒(5秒)内一直没有收到响应，请求就会超时并被取消。
第一个参数代表请求的连接超时时间；
第二个参数代表请求的读取超时时间；
（2）方式2

feign:
  client:
    config:
      default:
        #建立连接所用的时间，适用于网络状况正常的情况下，两端连接所需要的时间
        ConnectTimeOut: 5000
        #指建立连接后从服务端读取到可用资源所用的时间
        ReadTimeOut: 5000

（四）Nacos 领域模型划分

1、命名空间划分

NameSpace(默认的NameSpace是”public“ NameSpace可以进行资源隔离，比如我们dev环境下的NameSpace下的服务是调用不到prod的NameSpace下的微服务)

（1）创建命名空间dev

（2）配置微服务命名空间

spring:
  application:
    name: order-server
  cloud:
    nacos:
      discovery:
        server-addr: 192.168.109.149:8848
        namespace: a251bbaa-b80f-4eac-8322-da1922ec6805

2、group划分

spring:
  cloud:
    nacos:
      discovery:
        server-addr: 192.168.109.149:8848
        group: group2

3、集群模式

详见前面集群搭建

（五）日志配置

1、局部日志配置

方式一：

（1） 日志级别设置

注意：这里类上没有@Configuration注解

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

（2） 配置目标feign

@FeignClient(value = "repository-server",path = "/repositoty",configuration = FeginConfig.class)
public interface RepositotyFeign {
    @GetMapping("/getNum/{goodId}")
    Integer getNum(@PathVariable("goodId") Integer goodId);
}

方式二

feign:
  client:
    config:
      repository-server:
        loggerLevel: debug

2、全局日志配置

（1）添加配置文件

注意：这里类上有@Configuration注解

@Configuration
public class FeginConfig {
    @Bean
    public Logger.Level feignLoggerLevel(){
        return Logger.Level.FULL;
    }
}

（2）将springboot的日志级别调低

logging:
  level:
    com.buba.feign: debug

（六）契约配置

使用 Feign 契约注解：
可以通过 Feign 提供的契约注解来手动定义请求和响应的格式，例如：

@RequestLine("POST /users")
@Headers("Content-Type: application/json")
User createUser(User user);

使用 Feign 契约接口：
Feign 还支持使用 Java 接口来定义契约，例如：

interface UserFeignClient {
    @RequestMapping(method = RequestMethod.POST, value = "/users", consumes = "application/json")
    User createUser(User user);
}

通过上述方法，我们可以方便地配置 Feign 契约，从而实现服务间的通信。

（七）负载均衡策略配置

OpenFeign 和 Spring Cloud LoadBalancer 可以结合来实现服务发现和负载均衡的功能，可以通过配置 LoadBalancer 接口的实现来控制负载均衡策略。

下面是一些常用的负载均衡策略：
OpenFeign 和 Spring Cloud LoadBalancer 可以结合来实现服务发现和负载均衡的功能，可以通过配置 LoadBalancer 接口的实现来控制负载均衡策略。

下面是一些常用的负载均衡策略：

1. 随机策略：

@Configuration
public class LoadBalancerConfiguration {
 
    @Bean
    public LoadBalancerInterceptor loadBalancerInterceptor(LoadBalancerClient loadBalancerClient) {
        return new LoadBalancerInterceptor(loadBalancerClient);
    }
    
    @Bean
    public LoadBalancerClient loadBalancerClient() {
        return LoadBalancerClient.builder().build();
    }
    
    @Bean
    public RandomLoadBalancer randomLoadBalancer() {
        return new RandomLoadBalancer();
    }
}

2. 轮询策略：

@Configuration
public class LoadBalancerConfiguration {
 
    @Bean
    public LoadBalancerInterceptor loadBalancerInterceptor(LoadBalancerClient loadBalancerClient) {
        return new LoadBalancerInterceptor(loadBalancerClient);
    }
    
    @Bean
    public LoadBalancerClient loadBalancerClient() {
        return LoadBalancerClient.builder().build();
    }
    
    @Bean
    public RoundRobinLoadBalancer roundRobinLoadBalancer() {
        return new RoundRobinLoadBalancer();
    }
}

3. 带权重的轮询策略：

@Configuration
public class LoadBalancerConfiguration {
 
    @Bean
    public LoadBalancerInterceptor loadBalancerInterceptor(LoadBalancerClient loadBalancerClient) {
        return new LoadBalancerInterceptor(loadBalancerClient);
    }
    
    @Bean
    public LoadBalancerClient loadBalancerClient() {
        return LoadBalancerClient.builder().build();
    }
    
    @Bean
    public WeightedResponseTimeLoadBalancer weightedResponseTimeLoadBalancer() {
        return new WeightedResponseTimeLoadBalancer();
    }
}

4. 响应时间加权策略：

@Configuration
public class LoadBalancerConfiguration {
 
    @Bean
    public LoadBalancerInterceptor loadBalancerInterceptor(LoadBalancerClient loadBalancerClient) {
        return new LoadBalancerInterceptor(loadBalancerClient);
    }
    
    @Bean
    public LoadBalancerClient loadBalancerClient() {
        return LoadBalancerClient.builder().build();
    }
    
    @Bean
    public BestAvailableRuleLoadBalancer bestAvailableRuleLoadBalancer() {
        return new BestAvailableRuleLoadBalancer();
    }
}

在配置了 LoadBalancer 接口的实现后，OpenFeign 就会使用 LoadBalancer 进行服务发现和负载均衡，从而通过多个实例来提高服务的可用性和性能。

（八）Feign自定义拦截器

1、局部拦截器

2、全局拦截器