标签：Feign 服务 SpringCloud RestTemplate Nacos nacos spring order cloud

认识微服务

单体架构

将业务的所有功能集中在一个项目中开发打成一个包部署

优点：

架构简单
部署成本低

缺点：

耦合度高

分布式架构

根据业务功能对系统进行拆分，每个业务模块作为独立项目开发，称为一个服务

优点：

降低耦合度
有利于业务升级扩展

缺点：

治理服务麻烦

服务治理

分布式架构要考虑的问题：

服务拆分粒度如何？
服务集群地址如何维护？
服务之间如何实现远程调用？
服务健康状态如何感知？

微服务

微服务是一种经过良好架构设计的分布式架构方案，微服务架构特征:

单一职责:微服务拆分粒度更小，每一个服务都对应唯一的业务能力，做到单一职责，避免重复业务开发
面向服务∶微服务对外暴露业务接口
自治：团队独立、技术独立、数据独立、部署独立
隔离性强:服务调用做好隔离、容错、降级，避免出现级联问题

总结

微服务结构

微服务这种方案需要技术框架来落地，全球的互联网公司都在积极尝试自己的微服务洛地技木。仕国内取灿名的别定SpringCloud和阿里巴巴的Dubbo。

微服务技术对比

SpringCloud

Spring Cloud是目前国内使用最广的微服务框架
官网地址：https://spring.io/projects/spring-cloud
SpringCloud集成了各种微服务功能组件，并基于SpringBoot实现了这些组件的自动装配，从而提供了良好的开箱即用体验:

SpringCloud和SpringBoot的兼容版本问题

SpringCloud各种版本是对应springBoot的各种版本。所以用之前最好看看兼容对应的SpringBoot版本。
一下是官网推荐https://spring.io/projects/spring-cloud#overview

我们这里是跟着课堂老师的版本一起来的

服务拆分注意事项

不同的微服，不要重复开发相同的业务
微服务数据独立，不要访问其它微服务的数据库
微服务可以将自己的业务暴露为接口，供其它微服务调用

RestTemplate方法

要想实现远程调用，其实啊就是发送一次HTTP请求，所以我们的Speing就提供了一个专门的类RestTemplate()
代码实现：

```
package cn.itcast.order;

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

@MapperScan("cn.itcast.order.mapper")
@SpringBootApplication
@Configuration
public class OrderApplication {

    public static void main(String[] args) {
        SpringApplication.run(OrderApplication.class, args);
    }
//吧RestTemplate 注入到Spring容器当中
    @Bean
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }
}

代码实现二：
  远程调用现实RestTemplate中的getForObject();
~~~java

package cn.itcast.order.service;

import cn.itcast.order.mapper.OrderMapper;
import cn.itcast.order.pojo.Order;
import cn.itcast.order.pojo.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

import javax.annotation.Resource;

@Service
public class OrderService {

    @Autowired
    private OrderMapper orderMapper;
    @Autowired
    private RestTemplate restTemplate;

    public Order queryOrderById(Long orderId) {
        // 1.查询订单
        Order order = orderMapper.findById(orderId);

//        2.利用RestTemplate发起http请求，查询用户
        String url = "http://localhost:8081/user/" + order.getUserId();
        User user = restTemplate.getForObject(url, User.class);
//        封装user到order
        order.setUser(user);

        // 4.返回
        return order;
    }
}

RestTemplate总结

1.微服务调用方式

基于RestTemplate发起的HTTP请求实现远程调用
http请求做远程调用是与语言无关的调用，只要知道对方的ip、端口、接口路径、请求参数即可。

提供者与消费者

服务提供者：一次业务中，被其他微服务调用的服务。（提供接口给其他微服务）
服务消费者：一次业务中，调用其他微服务的服务。（调用其他微服务提供的接口）

Eureka注册中心

远程调用出现的问题

服务消费者该如何获取服务提供者的地址信息?
如果有多个服务提供者，消费者该如何选择?
消费者如何得知服务提供者的健康状态?

Eureka的作用

消费者该如何获取服务提供者具体信息?
如果有多个服务提供者，消费者该如何选择?
消费者如何感知服务提供者健康状态?

搭建Eureka注册中心

搭建EurekaServer服务步骤如下：

创建项目，引入spring-cloud-starter-netflix-eureka-server的依赖

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

编写启动类，添加@EnableEurekaServer注解
添加application.yml文件，编写下面的配置：

格式不对，请自行补充

server:
  port: 10086 #服务端口
spring:
  application:
    name: eurekaserver #Eureka服务名称
eureka:
  client:
    service-url:    #Eureka地址信息
      defaultZone: http://127.0.0.1:10086/eureka/

注册Eureka(user-server)

将user-service服务注册到EurekaServer步骤如下：

在user-service项目引入spring-cloud-starter-netflix-eureka-client的依赖

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

在application.yml文件，编写下面的配置：

server:
  port: 10086 #服务端口
spring:
  application:
    name: user-server #Eureka服务名称
eureka:
  client:
    service-url:    #Eureka地址信息
      defaultZone: http://127.0.0.1:10086/eureka/

另外，我们可以将user-service多次启动，模拟多实例部署，但为了避免端口冲突，需要修改端口设置:

服务发现

引入eureka-client依赖
在配置文件中(application)配置eureka的地址
给RestTemplate添加LoadBalanced注解
给服务提供者的服务名称设置远程调用

@LoadBalanced注解

在Spring Cloud微服务应用体系中，远程调用都应负载均衡。我们在使用RestTemplate作为远程调用客户端的时候，开启负载均衡极其简单一个@LoadBalanced注解就搞定了。

    //吧RestTemplate 注入到Spring容器当中
    @Bean
    @LoadBalanced // 标注此注解后，RestTemplate就具有了客户端负载均衡能力
    public RestTemplate restTemplate(){
        return new RestTemplate();
    }

Ribbon负载均衡的原理

我们负载均衡其实是由我们Ribbon组件实现的

负载均衡的流程

负载均衡策略

通过上面的源码我们知道IRule接口决定了负载均衡的策略。

IRule接口

Ribbon的负载均衡规则是一个叫做IRule的接口来定义的，每一个子接口都是一种规则:

通过定义IRule实现可以修改负载均衡规则，有两种方式:

代码方式:在order-service中的OrderApplication类中，定义一个新的IRule:（作用于全局）

    @Bean
    public IRule randomRule(){
        return new RandomRule();
    }

配置文件方式:在order-service的application.yml文件中，添加新的配置也可以修改规则:

userservice: 
 ribbon: 
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule# 负载均衡规则

饥饿加载

Ribbon默认是采用懒加载，即第一次访问时才会去创建LoadBalanceClient，请求时间会很长。而饥饿加载则会在项目启动时创建，降低第一次访问的耗时，通过下面配置开启饥饿加载:

ribbon:
  eager-load:
    enabled: true #开启饥饿加载
    clients: #指定饥饿加载的服务名称（这个client是一个集合就代表着可以有多个服务）
      - userserver

总结

Nacos注册中心

认识Nacos

Nacos是阿里巴巴的产品，现在是SpringCloud中的一个组件。Nacos相比Eureka的功能更加丰富，在国内受欢迎程度更高

Nacos的安装

在Nacos的GitHub页面，提供有下载链接，可以下载编译好的Nacos服务端或者源代码：
GitHub主页：https://github.com/alibaba/nacos

GitHub的Release下载页：https://github.com/alibaba/nacos/releases

然后直接在一个没有中文目录下解压就完事了

启动命令
startup.cmd -m standalone
注销命令
startup.cmd

服务注册到Nacos

在cloud-demo父工程中添加spring-cloud-alilbaba的管理依赖

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-alibaba-dependencies</artifactId>
    <version>2.2.5.RELEASE</version>
    <type>pom</type>
    <scope>import</scope>
</dependency>

添加nacos的客户端依赖：

<!-- nacos客户端依赖包 -->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

配置Nacos的服务地址

spring: 
  cloud:
    nacos:
      server-addr: localhost:8848 #nacos服务地址

Nacos服务分级存储模型

服务跨集群调用的问题

服务调用尽可能选择本地集群的服务，跨集群调用延迟较高
本地集群不可访问时，再去访问其它集群

服务集群属性

修改application.yml，添加如下内容:

spring:
  cloud:
    nacos:
      server-addr: localhost:8848 # nacos 服务端地址
      discovery:
        cluster-name: HZ # 配置集群名称，也就是机房位置，例如：HZ，杭州

在Nacos控制台可以看到集群变化

总结

根据集群负载均衡

修改order-service中的application.yml，设置集群为HZ：

spring:
  cloud:
    nacos:
      server-addr: localhost:8848 # nacos 服务端地址
      discovery:
        cluster-name: HZ # 配置集群名称，也就是机房位置

然后在order-service中设置负载均衡的IRule为NacosRule，这个规则优先会寻找与自己同集群的服务：

userservice: #要做配置的微服务名称
  ribbon:
    NFLoadBalancerRuleClassName: com.alibaba.cloud.nacos.ribbon.NacosRule # 负载均衡规则

根据权重负载均衡

实际部署中会出现一下场景：

服务器设备性能有差异，部分实例所在机器性能较好，另一些较差，我们希望性能好的机器承担更多的用户请求

Nacos提供了权重配置来控制访问频率，权重越大则访问频率越高

控制到修改权重值

在Nacos控制台可以设置实例的权重值，首先选中实例后面的编辑按钮
将权重设置为0.1，测试可以发现8081被访问到的频率大大降低

Namespace(环境隔离)

Nacos中服务存储和数据存储的最外层都是一个名为namespace的东西，用来做最外层隔离

在Nacos控制台可以创建namespace，用来隔离不同环境
然后填写一个新的命名空间信息：
保存后会在控制台看到这个命名空间的id：
修改order-service的application.yml，添加namespace：

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/heima?useSSL=false
    username: root
    password: 123456    driver-class-name: com.mysql.jdbc.Driver 
  cloud:
    nacos:
      server-addr: localhost:8848
      discovery:
        cluster-name: SH # 上海
        namespace: 492a7d5d-237b-46a1-a99a-fa8e98e4b0f9 # 命名空间，填ID

隔离之后此时访问order-service，因为namespace不同，会导致找不到userservice，控制台会报错:

Nacos和Eureka的区别

nacos注册中心细节分析

临时实例和非临时实例

服务注册到Nacos时，可以选择注册为临时或非临时实例，通过下面的配置来设置

spring:
  cloud:    nacos:
      discovery:
        ephemeral: false # 设置为非临时实例

Nacos统一配置管理

统一配置管理

配置热更新

在Nacos中添加配置信息：
在弹出表单中填写配置信息：
配置获取的步骤如下：

4.引入Nacos的配置管理客户端依赖：

<!--nacos配置管理依赖-->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
</dependency>

在userservice中的resource目录添加一个bootstrap.yml文件，这个文件是引导文件，优先级高于application.yml：

spring:
  application:
    name: userservice # 服务名称  profiles:
    active: dev #开发环境，这里是dev 
  cloud:
    nacos:
      server-addr: localhost:8848 # Nacos地址
      config:
        file-extension: yaml # 文件后缀名

我们在user-service中将pattern.dateformat这个属性注入到UserController中做测试：

@RestController
@RequestMapping("/user")
public class UserController {
    // 注入nacos中的配置属性    @Value("${pattern.dateformat}")
    private String dateformat;
    // 编写controller，通过日期格式化器来格式化现在时间并返回
    @GetMapping("now")
    public String now(){
        return LocalDate.now().format(
                DateTimeFormatter.ofPattern(dateformat, Locale.CHINA)
        );
    }
    // ... 略
}

7.总结
将配置交给Nacos管理的步骤
在Nacos中添加配置文件
在微服务中引入nacos的config依赖
在微服务中添加bootstrap.yml，配置nacos地址、当前环境、服务名称、文件后缀名。这些决定了程序启动时去nacos读取哪个文件

配置自动刷新

Nacos中的配置文件变更后，微服务无需重启就可以感知。不过需要通过下面两种配置实现：

@RefreshScope

方式一：在@Value注入的变量所在类上添加注解@RefreshScope

@ConfigurationProperties注解

Nacos中的配置文件变更后，微服务无需重启就可以感知。不过需要通过下面两种配置实现：

@Component@Data
@ConfigurationProperties(prefix = "pattern")
public class PatternProperties {
    private String dateformat;
}

总结
Nacos配置更改后，微服务可以实现热更新，方式：
通过@Value注解注入，结合@RefreshScope来刷新
通过@ConfigurationProperties注入，自动刷新
注意事项：
不是所有的配置都适合放到配置中心，维护起来比较麻烦
建议将一些关键参数，需要运行时调整的参数放到nacos配置中心，一般都是自定义配置

配置共享

微服务启动时会从nacos读取多个配置文件：

[spring.application.name]-[spring.profiles.active].yaml，例如：userservice-dev.yaml
[spring.application.name].yaml，例如：userservice.yaml
无论profile如何变化，[spring.application.name].yaml这个文件一定会加载，因此多环境共享配置可以写入这个文

多种配置的优先级：

总结
微服务会从nacos读取的配置文件：
[服务名]-[spring.profile.active].yaml，环境配置
[服务名].yaml，默认配置，多环境共享
优先级：
[服务名]-[环境].yaml >[服务名].yaml > 本地配置

不同微服务之间可以共享配置文件，通过下面的两种方式来指定：

方式一：

spring:
  application:
    name: userservice # 服务名称  profiles:
    active: dev # 环境，
  cloud:    nacos:
      server-addr: localhost:8848 # Nacos地址
      config: 
        file-extension: yaml # 文件后缀名
        shared-configs: # 多微服务间共享的配置列表
          - dataId: common.yaml # 要共享的配置文件id

方式二：

pring:
  application:
    name: userservice # 服务名称
  profiles:
    active: dev # 环境，
  cloud:    nacos:
     server-addr: localhost:8848 # Nacos地址
      config: 
        file-extension: yaml # 文件后缀名
        extends-configs: # 多微服务间共享的配置列表
          - dataId: extend.yaml # 要共享的配置文件id

多种配置的优先级：

总结
微服务默认读取的配置文件：
[服务名]-[spring.profile.active].yaml，默认配置
[服务名].yaml，多环境共享
不同微服务共享的配置文件：
通过shared-configs指定
通过extension-configs指定
优先级：
环境配置 >服务名.yaml > extension-config > extension-configs > shared-configs > 本地配置

Nacos集群搭建

在企业环境中Nacos一定是要部署为集群状态的，因为在企业当中都是强调高可用

搭建集群

搭建集群步骤

搭建数据库，初始化数据库表结构
下载Nacos安装包

配置Nacos

进入nacos的conf目录，修改配置文件cluster.conf.example，重命名为cluster.conf：

#it is ip
#example
127.0.0.1:8845
127.0.0.1.8846
127.0.0.1.8847

然后修改application.properties文件，添加数据库配置

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&useUnicode=true&useSSL=false&serverTimezone=UTC
db.user.0=root
db.password.0=123456

启动Nacos集群
1. 将nacos文件夹复制三份，分别命名为：nacos1、nacos2、nacos3
  
  2.然后分别修改三个文件夹中的application.properties中的端口号
```
erver.port=****
```
  3.然后启动三个Nacos
Nginx方向代理
修改nginx.conf文件添加如下代理

#端口号集群
upstream nacos-cluster {
    server 127.0.0.1:8845;
	server 127.0.0.1:8846;
	server 127.0.0.1:8847;
}

server {
    listen       80;
    #通过localhost IP地址代理到各个端口号
    server_name  localhost;

    location /nacos {
        proxy_pass http://nacos-cluster;
    }
}

HTTP客户端Feign

RestTemplate存在的问题

        // 2.利用RestTemplate发起http请求，查询用户
        String url = "http://userserver/user/" + order.getUserId();
        User user = restTemplate.getForObject(url, User.class);

以上代码存在的问题

代码可读性差
参数复杂URL难以维护

Feign介绍

Feign是一个声明式的http客户端，官方地址: https://github.com/OpenFeign/feign
其作用就是帮助我们优雅的实现http请求的发送，解决上面提到的问题。

定义和使用Feign

引入依赖
我们在order-service服务的pom文件中引入feign的依赖：

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

添加注解
1. @EnableFeignClients注解：feign自动装配的开关

在order-service的启动类添加注解开启Feign的功能：

3. 配置Feign的接口

package cn.itcast.order.client;

import cn.itcast.order.pojo.User;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

@FeignClient("userservice")//生命服务名称
public interface UserClient {
    @GetMapping("/user/{id}")
    User findById(@PathVariable("id") Long id);
}

总结

Feign的自定义配置

Feign可以支持很多的自定义配置，如下表所示：

类型	作用	说明
feign.Logger.Level	修改日志级别	包含四种不同的级别：NONE、BASIC、HEADERS、FULL
feign.codec.Decoder	响应结果的解析器	http远程调用的结果做解析，例如解析json字符串为java对象
feign.codec.Encoder	请求参数编码	将请求参数编码，便于通过http请求发送
feign. Contract	支持的注解格式	默认是SpringMVC的注解
feign. Retryer	失败重试机制	请求失败的重试机制，默认是没有，不过会使用Ribbon的重试

修改配置的两种方式

配置文件

基于配置文件修改feign的日志级别可以针对单个服务：

feign:  
  client:
    config: 
      userservice: # 针对某个微服务的配置
        loggerLevel: FULL #  日志级别

也可以针对所有服务：

feign:  
  client:
    config: 
      default: # 这里用default就是全局配置，如果是写服务名称，则是针对某个微服务的配置
        loggerLevel: FULL #  日志级别

而日志的级别分为四种：

NONE：不记录任何日志信息，这是默认值。
BASIC：仅记录请求的方法，URL以及响应状态码和执行时间
HEADERS：在BASIC的基础上，额外记录了请求和响应的头信息
FULL：记录所有请求和响应的明细，包括头信息、请求体、元数据。

Java代码方式
也可以基于Java代码来修改日志级别，先声明一个类，然后声明一个Logger.Level的对象：

public class DefaultFeignConfiguration  {
    @Bean
    public Logger.Level feignLogLevel(){
        return Logger.Level.BASIC; // 日志级别为BASIC
    }
}

如果要全局生效，将其放到启动类的@EnableFeignClients这个注解中：

@EnableFeignClients(defaultConfiguration = DefaultFeignConfiguration .class)

如果是局部生效，则把它放到对应的@FeignClient这个注解中：

@FeignClient(value = "userservice", configuration = DefaultFeignConfiguration .class)

Feign的性能优化

Feign底层发起http请求，依赖于其它的框架。其底层客户端实现包括：

•URLConnection：默认实现，不支持连接池

•Apache HttpClient ：支持连接池

•OKHttp：支持连接池

因此提高Feign的性能主要手段就是使用连接池代替默认的URLConnection。
这里我们用Apache的HttpClient来演示。

引入依赖
在order-service的pom文件中引入Apache的HttpClient依赖（注：这里呢我们的Spirng已经接管了ApacheHttpClient了）：

<!--httpClient的依赖 -->
<dependency>
    <groupId>io.github.openfeign</groupId>
    <artifactId>feign-httpclient</artifactId>
</dependency>

配置连接池
在order-service的application.yml中添加配置：

feign:
client:
 config:
   default: # default全局的配置
     loggerLevel: BASIC # 日志级别，BASIC就是基本的请求和响应信息
httpclient:
 enabled: true # 开启feign对HttpClient的支持
 max-connections: 200 # 最大的连接数
 max-connections-per-route: 50 # 每个路径的最大连接数

接下来，在FeignClientFactoryBean中的loadBalance方法中打断点：

Debug方式启动order-service服务，可以看到这里的client，底层就是Apache HttpClient：

总结

Feign最佳实践

所谓最近实践，就是使用过程中总结的经验，最好的一种使用方式。

自习观察可以发现，Feign的客户端与服务提供者的controller代码非常相似：

feign客户端：

UserController：

有没有一种办法简化这种重复的代码编写呢？

继承方式

一样的代码可以通过继承来共享：

1）定义一个API接口，利用定义方法，并基于SpringMVC注解做声明。

2）Feign客户端和Controller都集成改接口

优点：

简单
实现了代码共享

缺点：

服务提供方、服务消费方紧耦合
参数列表中的注解映射并不会继承，因此Controller中必须再次声明方法、参数列表、注解

抽取方式

将Feign的Client抽取为独立模块，并且把接口有关的POJO、默认的Feign配置都放到这个模块中，提供给所有消费者使用。

例如，将UserClient、User、Feign的默认配置都抽取到一个feign-api包中，所有微服务引用该依赖包，即可直接使用。

总结

实现基于抽取的最佳实践

抽取
首先创建一个module，命名为feign-api：

项目结构：

在feign-api中然后引入feign的starter依赖

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

然后，order-service中编写的UserClient、User、DefaultFeignConfiguration都复制到feign-api项目中

2. 在order-service中使用feign-api
首先，删除order-service中的UserClient、User、DefaultFeignConfiguration等类或接口。
在order-service的pom文件中中引入feign-api的依赖：

<dependency>
    <groupId>cn.itcast.demo</groupId>
    <artifactId>feign-api</artifactId>
    <version>1.0</version>
</dependency>

修改order-service中的所有与上述三个组件有关的导包部分，改成导入feign-api中的包
3. 重启测试
重启后，发现服务报错了：

这是因为UserClient现在在cn.itcast.feign.clients包下，

而order-service的@EnableFeignClients注解是在cn.itcast.order包下，不在同一个包，无法扫描到UserClient。

解决扫描包问题
方式一：

指定Feign应该扫描的包：

@EnableFeignClients(basePackages = "cn.itcast.feign.clients")