# SpringCloud教程由入门到精通
# 1.初识微服务
随着互联网行业的发展，对服务的要求也越来越高，服务架构也从单体架构逐渐演变为现在流行的微服务架构。这些架构之间有怎样的差别呢？
## 1.1.单体架构
**单体架构**：将业务的所有功能集中在一个项目中开发，打成一个包部署。
单体架构的优缺点如下：
**优点：**
- 架构简单
- 部署成本低
**缺点：**
- 耦合度高（维护困难、升级困难）
## 1.2.分布式架构
**分布式架构**：根据业务功能对系统做拆分，每个业务功能模块作为独立项目开发，称为一个服务。
分布式架构的优缺点：
**优点：**
- 降低服务耦合
- 有利于服务升级和拓展
**缺点：**
- 服务调用关系错综复杂
分布式架构虽然降低了服务耦合，但是服务拆分时也有很多问题需要思考：
- 服务拆分的粒度如何界定？
- 服务之间如何调用？
- 服务的调用关系如何管理？
- 服务健康状态如何感知？
人们需要制定一套行之有效的标准来约束分布式架构。
在解决这些问题的时候，出现了很多技术，比如webservice,ESB,dubbo,springcloud等等
## 1.3.微服务
微服务的架构特征：
- 单一职责：微服务拆分粒度更小，每一个服务都对应唯一的业务能力，做到单一职责，避免重复业务开发
比如，用户模块可以根据会员级别享受不同的折扣，然后再进一步的拆分为：会员服务，用户服务，积分服务，会员金币等等。
- 自治：团队独立、技术独立、数据独立，独立部署和交付
- 面向服务：服务提供统一标准的接口（对外暴露业务接口）， 与语言和技术无关
- 隔离性强：服务调用做好隔离、容错、降级，避免出现级联问题
微服务的上述特性其实是在给分布式架构制定一个标准，进一步降低服务之间的耦合度，提供服务的独立性和灵活性。做到高内聚，低耦合。
因此，可以认为**微服务**是一种经过良好架构设计的**分布式架构的最佳实践方案** 。
但方案该怎么落地？选用什么样的技术栈？全球的互联网公司都在积极尝试自己的微服务落地方案。
其中在Java领域最引人注目的就是SpringCloud提供的方案了。
## 1.4 微服务技术比对
## 1.5.SpringCloud
SpringCloud是目前国内使用最广泛的微服务框架。
官网地址：https://spring.io/projects/spring-cloud
SpringCloud集成了各种微服务功能组件，并基于SpringBoot实现了这些组件的自动装配，从而提供了良好的开箱即用体验。
其中常见的组件包括：
另外，SpringCloud底层是依赖于SpringBoot的，并且有版本的兼容关系，如下：
我们课堂学习的版本是 Hoxton.SR10，因此对应的SpringBoot版本是2.3.x版本。
## 1.5.总结
- 单体架构：简单方便，高度耦合，扩展性差，适合小型项目。例如：学生管理系统
- 分布式架构：松耦合，扩展性好，但架构复杂，难度大。适合大型互联网项目，例如：京东、淘宝
- 微服务：一种良好的分布式架构方案
①优点：拆分粒度更小、服务更独立、耦合度更低
②缺点：架构非常复杂，运维、监控、部署难度提高
- SpringCloud是微服务架构的一站式解决方案，集成了各种优秀微服务功能组件
# 2.服务拆分和远程调用
任何分布式架构都离不开服务的拆分，微服务也是一样。
## 2.1.服务拆分原则
这里我总结了微服务拆分时的几个原则：
- 不同微服务，不要重复开发相同业务
- 微服务数据独立，不要访问其它微服务的数据库
- 微服务可以将自己的业务暴露为接口，供其它微服务调用
## 2.2.服务拆分示例
### 2.2.1.项目工程结构设计
以微服务springcloud-shop为例，其结构如下：
springcloud-shop：父工程，管理依赖
- order-service：订单微服务，负责订单相关业务
- user-service：用户微服务，负责用户相关业务
要求：
- 订单微服务和用户微服务都必须有各自的数据库，相互独立
- 订单服务和用户服务都对外暴露Restful的接口
- 订单服务如果需要查询用户信息，只能调用用户服务的Restful接口，不能查询用户数据库
### 2.2.2.创建Maven项目工程
导入提供的sql语句
创建项目工程springcloud-shop，导入父工程依赖
~~~xml
<?xml version="1.0" encoding="UTF-8"?>
<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.0</modelVersion>
<groupId>cn.hxzy</groupId>
<artifactId>springcloud-shop</artifactId>
<packaging>pom</packaging>
<version>1.0</version>
<modules>
<module>user-service</module>
<module>order-service</module>
<module>eureka-server</module>
</modules>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.3.9.RELEASE</version>
<relativePath/>
</parent>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<java.version>1.8</java.version>
<spring-cloud.version>Hoxton.SR10</spring-cloud.version>
<mysql.version>8.0.18</mysql.version>
<mybatis.version>2.1.1</mybatis.version>
</properties>
<dependencyManagement>
<dependencies>
<!-- springCloud -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>${spring-cloud.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<!-- mysql驱动 -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${mysql.version}</version>
</dependency>
<!--mybatis-->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>${mybatis.version}</version>
</dependency>
</dependencies>
</dependencyManagement>
<dependencies>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.20</version>
</dependency>
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.3.1.tmp</version>
</dependency>
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-generator</artifactId>
<version>3.3.1.tmp</version>
</dependency>
<dependency>
<groupId>org.apache.velocity</groupId>
<artifactId>velocity</artifactId>
<version>1.7</version>
</dependency>
<!--swagger2 核心依赖-->
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger2</artifactId>
<version>2.9.2</version>
</dependency>
<!-- swagger-ui为项目提供api展示及测试的界面-->
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger-ui</artifactId>
<version>2.9.2</version>
</dependency>
</dependencies>
</project>
~~~
创建user-service，order-service模块，导入依赖
~~~xml
<?xml version="1.0" encoding="UTF-8"?>
<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>springcloud-shop</artifactId>
<groupId>cn.hxzy</groupId>
<version>1.0</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>user-service</artifactId>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
</dependency>
</dependencies>
<build>
<finalName>app</finalName>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
~~~
order-service依赖于user-service依赖一样，只需要修改即可。
~~~xml
<artifactId>order-service</artifactId>
~~~
## 2.3.实现远程调用案例
在order-service服务中，有一个根据id查询订单的接口，根据id查询订单，返回值是Order对象。其中的user为null
在user-service中有一个根据id查询用户的接口
### 2.3.1.案例需求：
修改order-service中的根据id查询订单业务，要求在查询订单的同时，根据订单中包含的userId查询出用户信息，一起返回。
因此，我们需要在order-service中 向user-service发起一个http的请求，调用http://localhost:8081/user/{userId}这个接口。
大概的步骤是这样的：
- 注册一个RestTemplate的实例到Spring容器
- 修改order-service服务中的OrderService类中的queryOrderById方法，根据Order对象中的userId查询User
- 将查询的User填充到Order对象，一起返回
### 2.3.2.注册RestTemplate
首先，我们在order-service服务中的OrderServiceApplication启动类中，注册RestTemplate实例：
```java
package cn.hxzy;
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.web.client.RestTemplate;
@SpringBootApplication
@MapperScan("cn.hxzy.mapper")
public class OrderServiceApplication {
public static void main(String[] args) {
SpringApplication.run(OrderServiceApplication.class,args);
}
@Bean
public RestTemplate restTemplate(){
return new RestTemplate();
}
}
```
### 2.3.3.实现远程调用
在order-service服务中的cn.hxzy.service.impl包下的实现类中，添加如下代码
~~~java
package cn.hxzy.service.impl;
import cn.hxzy.pojo.Order;
import cn.hxzy.mapper.OrderMapper;
import cn.hxzy.pojo.User;
import cn.hxzy.service.OrderService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;
/**
* <p>
* 服务实现类
* </p>
*
* @author shujun.Meng
* @since 2021-08-23
*/
@Service
public class OrderServiceImpl extends ServiceImpl<OrderMapper, Order> implements OrderService {
@Autowired
private OrderMapper orderMapper;
@Autowired
private RestTemplate restTemplate;
public Order selectOrderById(Long orderId){
//1、查询订单
Order order=orderMapper.selectById(orderId);
//2、利用RestTemplate发起http请求，查询用户
String url="http://localhost:8081/user/"+order.getUserId();
//3、发送http请求，实现远程调用
User user = restTemplate.getForObject(url, User.class);
//4、封装user到Order
order.setUser(user);
System.out.println(user);
System.out.println(order);
//5、返回user
return order;
}
}
~~~
### 2.3.4 idea启动多模块服务配置
找到父工程的.idea文件，找到workspace.xml文件，找到<component name="RunDashboard">节点，添加如下配置
~~~xml
<option name="configurationTypes">
<set>
<option value="SpringBootApplicationConfigurationType" />
</set>
</option>
~~~
## 2.4.提供者与消费者
在服务调用关系中，会有两个不同的角色：
**服务提供者**：一次业务中，被其它微服务调用的服务。（提供接口给其它微服务）
**服务消费者**：一次业务中，调用其它微服务的服务。（调用其它微服务提供的接口）
但是，服务提供者与服务消费者的角色并不是绝对的，而是相对于业务而言。
如果服务A调用了服务B，而服务B又调用了服务C，服务B的角色是什么？
- 对于A调用B的业务而言：A是服务消费者，B是服务提供者
- 对于B调用C的业务而言：B是服务消费者，C是服务提供者
因此，服务B既可以是服务提供者，也可以是服务消费者。
# 3.Eureka注册中心
假如我们的服务提供者user-service部署了多个实例，如图：
大家思考几个问题：
- order-service在发起远程调用的时候，该如何得知user-service实例的ip地址和端口？
- 有多个user-service实例地址，order-service调用时该如何选择？
- order-service如何得知某个user-service实例是否依然健康，是不是已经宕机？
## 3.1.Eureka的结构和作用
这些问题都需要利用SpringCloud中的注册中心来解决，其中最广为人知的注册中心就是Eureka，其结构如下：
回答之前的各个问题。
问题1：order-service如何得知user-service实例地址？
获取地址信息的流程如下：
- user-service服务实例启动后，将自己的信息注册到eureka-server（Eureka服务端）。这个叫服务注册
- eureka-server保存服务名称到服务实例地址列表的映射关系
- order-service根据服务名称，拉取实例地址列表。这个叫服务发现或服务拉取
问题2：order-service如何从多个user-service实例中选择具体的实例？
- order-service从实例列表中利用负载均衡算法选中一个实例地址
- 向该实例地址发起远程调用
问题3：order-service如何得知某个user-service实例是否依然健康，是不是已经宕机？
- user-service会每隔一段时间（默认30秒）向eureka-server发起请求，报告自己状态，称为心跳
- 当超过一定时间没有发送心跳时，eureka-server会认为微服务实例故障，将该实例从服务列表中剔除
- order-service拉取服务时，就能将故障实例排除了
> 注意：一个微服务，既可以是服务提供者，又可以是服务消费者，因此eureka将服务注册、服务发现等功能统一封装到了eureka-client端
因此，接下来我们动手实践的步骤包括：
## 3.2.搭建eureka-server
首先大家注册中心服务端：eureka-server，这必须是一个独立的微服务
### 3.2.1.创建eureka-server服务
在父工程下，创建一个子模块eureka-server
### 3.2.2.引入eureka依赖
引入SpringCloud为eureka提供的starter依赖：
```xml
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>
```
### 3.2.3.编写启动类
给eureka-server服务编写一个启动类，一定要添加一个@EnableEurekaServer注解，开启eureka的注册中心功能：
```java
package cn.hxzy;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
//springboot的自动配置，如果你没有配置DataSource就会导致启动编译错误
//如果你是要连数据库的话那就在yml或properties文件下配置数据库的账户密码地址
//不想连接数据库的话就添加(exclude = DataSourceAutoConfiguration.class)
@SpringBootApplication(exclude = DataSourceAutoConfiguration.class)
@EnableEurekaServer
public class EurekaApplication {
public static void main(String[] args) {
SpringApplication.run(EurekaApplication.class,args);
}
}
```
### 3.2.4.编写配置文件
编写一个application.yml文件，内容如下：
```yaml
server:
port: 10086
spring:
application:
name: eureka-server
eureka:
client:
service-url:
defaultZone: http://127.0.0.1:10086/eureka
```
### 3.2.5.启动服务
启动微服务，然后在浏览器访问：http://127.0.0.1:10086
看到下面结果应该是成功了：
## 3.3.服务注册
下面，我们将user-service注册到eureka-server中去。
### 1）引入依赖
在user-service的pom文件中，引入下面的eureka-client依赖：
```xml
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
```
### 2）配置文件
在user-service中，修改application.yml文件，添加服务名称、eureka地址：
```yaml
spring:
application:
name: userservice
eureka:
client:
service-url:
defaultZone: http://127.0.0.1:10086/eureka
```
### 3）启动多个user-service实例
为了演示一个服务有多个实例的场景，我们添加一个SpringBoot的启动配置，再启动一个user-service。
首先，复制原来的user-service启动配置：
然后，在弹出的窗口中，填写信息：
现在，SpringBoot窗口会出现两个user-service启动配置，不过，第一个是8081端口，第二个是8091端口。
启动两个user-service实例
查看eureka-server管理页面：
## 3.4.服务发现
下面，我们将order-service的逻辑修改：向eureka-server拉取user-service的信息，实现服务发现。
### 1）引入依赖
之前说过，服务发现、服务注册统一都封装在eureka-client依赖，因此这一步与服务注册时一致。
在order-service的pom文件中，引入下面的eureka-client依赖：
```xml
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
```
### 2）配置文件
服务发现也需要知道eureka地址，因此第二步与服务注册一致，都是配置eureka信息：
在order-service中，修改application.yml文件，添加服务名称、eureka地址：
```yaml
spring:
application:
name: orderservice
eureka:
client:
service-url:
defaultZone: http://127.0.0.1:10086/eureka
```
### 3）服务拉取和负载均衡
最后，我们要去eureka-server中拉取user-service服务的实例列表，并且实现负载均衡。
不过这些动作不用我们去做，只需要添加一些注解即可。
在order-service的OrderServiceApplication中，给RestTemplate这个Bean添加一个@LoadBalanced注解：
~~~java
@Bean
@LoadBalanced
public RestTemplate restTemplate(){
return new RestTemplate();
}
~~~
修改order-service服务中的cn.hxzy.service包下的OrderService类中的selectOrderById方法。修改访问的url路径，用服务名代替ip、端口：
~~~java
String url="http://userservice/user/"+order.getUserId();
~~~
spring会自动帮助我们从eureka-server端，根据userservice这个服务名称，获取实例列表，而后完成负载均衡。
# 4.Ribbon负载均衡
上一节中，我们添加了@LoadBalanced注解，即可实现负载均衡功能，这是什么原理呢？
## 4.1.Ribbon实现负载均衡
SpringCloud底层其实是利用了一个名为Ribbon的组件，来实现负载均衡功能的。
那么我们发出的请求明明是http://userservice/user/1，怎么变成了http://localhost:8081的呢？
## 4.2.自定义负载均衡策略
通过定义IRule实现可以修改负载均衡规则，有两种方式：
1. 代码方式：在order-service中的OrderServiceApplication类中，定义一个新的IRule：
```java
@Bean
public IRule randomRule(){
return new RandomRule();
}
```
变成随机的机制
2. 配置文件方式：在order-service的application.yml文件中，添加新的配置也可以修改规则：
```yaml
user-service: # 给某个微服务配置负载均衡规则，这里是userservice服务
ribbon:
NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule # 负载均衡规则
```
> **注意**，一般用默认的负载均衡规则，不做修改。
## 4.3.饥饿加载
Ribbon默认是采用懒加载，即第一次访问时才会去创建LoadBalanceClient，请求时间会很长。
而饥饿加载则会在项目启动时创建，降低第一次访问的耗时，通过下面配置开启饥饿加载：
```yaml
ribbon:
eager-load:
enabled: true
clients: userservice
```
# 5.Nacos注册中心
国内公司一般都推崇阿里巴巴的技术，比如注册中心，SpringCloudAlibaba也推出了一个名为Nacos的注册中心。
## 5.1.认识和安装Nacos
[Nacos](https://nacos.io/)是阿里巴巴的产品，现在是[SpringCloud](https://spring.io/projects/spring-cloud)中的一个组件。相比[Eureka](https://github.com/Netflix/eureka)功能更加丰富，在国内受欢迎程度较高。
安装方式可以参考资料《Nacos安装指南.md》
## 5.2.服务注册到nacos
Nacos是SpringCloudAlibaba的组件，而SpringCloudAlibaba也遵循SpringCloud中定义的服务注册、服务发现规范。因此使用Nacos和使用Eureka对于微服务来说，并没有太大区别。
主要差异在于：
- 依赖不同
- 服务地址不同
### 1）引入依赖
在父工程的pom文件中的`<dependencyManagement>`中引入SpringCloudAlibaba的依赖：
```xml
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-alibaba-dependencies</artifactId>
<version>2.2.6.RELEASE</version>
<type>pom</type>
<scope>import</scope>
</dependency>
```
然后在user-service和order-service中的pom文件中引入nacos-discovery依赖：
```xml
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
```
> **注意**：不要忘了注释掉eureka的依赖。
### 2）配置nacos地址
在user-service和order-service的application.yml中添加nacos地址：
```yaml
spring:
cloud:
nacos:
server-addr: localhost:8848
```
> **注意**：不要忘了注释掉eureka的地址
### 3）重启
重启微服务后，登录nacos管理页面，可以看到微服务信息：
## 5.3.服务分级存储模型
一个**服务**可以有多个**实例**，例如我们的user-service，可以有:
- 127.0.0.1:8081
- 127.0.0.1:8082
- 127.0.0.1:8083
假如这些实例分布于全国各地的不同机房，例如：
- 127.0.0.1:8081，在杭州机房
- 127.0.0.1:8082，在杭州机房
- 127.0.0.1:8083，在上海机房
Nacos就将同一机房内的实例 划分为一个**集群**。
也就是说，user-service是服务，一个服务可以包含多个集群，如杭州、上海，每个集群下可以有多个实例，形成分级模型，如图：
微服务互相访问时，应该尽可能访问同集群实例，因为本地访问速度更快。当本集群内不可用时，才访问其它集群。例如：
杭州机房内的order-service应该优先访问同机房的user-service。局域网内的访问，距离比较近，速度比较快，而跨地区的访问，因为路程比较远，延迟就比较高。
### 5.3.1.给user-service配置集群
修改user-service的application.yml文件，添加集群配置：
```yaml
spring:
cloud:
nacos:
server-addr: localhost:8848
discovery:
cluster-name: HZ # 集群名称
```
重启两个user-service实例后，我们可以在nacos控制台看到下面结果：
我们再次复制一个user-service启动配置，添加属性：
```sh
-Dserver.port=8083 -Dspring.cloud.nacos.discovery.cluster-name=SH
```
启动UserApplication3后再次查看nacos控制台：
### 5.3.2.同集群优先的负载均衡
默认的`ZoneAvoidanceRule`并不能实现根据同集群优先来实现负载均衡。
因此Nacos中提供了一个`NacosRule`的实现，可以优先从同集群中挑选实例。
1）给order-service配置集群信息
修改order-service的application.yml文件，添加集群配置：
```sh
spring:
cloud:
nacos:
server-addr: localhost:8848
discovery:
cluster-name: HZ # 集群名称
```
2）修改负载均衡规则
修改order-service的application.yml文件，修改负载均衡规则：
```yaml
user-service:
ribbon:
NFLoadBalancerRuleClassName: com.alibaba.cloud.nacos.ribbon.NacosRule # 负载均衡规则
```
## 5.4.权重配置
实际部署中会出现这样的场景：
服务器设备性能有差异，部分实例所在机器性能较好，另一些较差，我们希望性能好的机器承担更多的用户请求。
但默认情况下NacosRule是同集群内随机挑选，不会考虑机器的性能问题。
因此，Nacos提供了权重配置来控制访问频率，权重越大则访问频率越高。
在nacos控制台，找到user-service的实例列表，点击编辑，即可修改权重：
在弹出的编辑窗口，修改权重：
> **注意**：如果权重修改为0，则该实例永远不会被访问
## 5.5.环境隔离
Nacos提供了namespace来实现环境隔离功能。
- nacos中可以有多个namespace
- namespace下可以有group、service等
- 不同namespace之间相互隔离，例如不同namespace的服务互相不可见
### 1）创建namespace
默认情况下，所有service、data、group都在同一个namespace，名为public：
我们可以点击页面新增按钮，添加一个namespace：
然后，填写表单：
就能在页面看到一个新的namespace：
### 2）给微服务配置namespace
给微服务配置namespace只能通过修改配置来实现。
例如，修改order-service的application.yml文件：
```yaml
spring:
cloud:
nacos:
server-addr: localhost:8848
discovery:
cluster-name: HZ
namespace: 492a7d5d-237b-46a1-a99a-fa8e98e4b0f9 # 命名空间，填ID
```
重启order-service后，访问控制台，可以看到下面的结果：
此时访问order-service，因为namespace不同，会导致找不到userservice，控制台会报错：
## 5.6.Nacos与Eureka的区别
Nacos的服务实例分为两种l类型：
- 临时实例：如果实例宕机超过一定时间，会从服务列表剔除，默认的类型。
- 非临时实例：如果实例宕机，不会从服务列表剔除，也可以叫永久实例。
配置一个服务实例为永久实例：
```yaml
spring:
cloud:
nacos:
discovery:
ephemeral: false # 设置为非临时实例
```
Nacos和Eureka整体结构类似，服务注册、服务拉取、心跳等待，但是也存在一些差异：
- Nacos与eureka的共同点
- 都支持服务注册和服务拉取
- 都支持服务提供者心跳方式做健康检测
- Nacos与Eureka的区别
- Nacos支持服务端主动检测提供者状态：临时实例采用心跳模式，非临时实例采用主动检测模式
- 临时实例心跳不正常会被剔除，非临时实例则不会被剔除
- Nacos支持服务列表变更的消息推送模式，服务列表更新更及时
# 6.Nacos配置管理
Nacos除了可以做注册中心，同样可以做配置管理来使用。
## 6.1.统一配置管理
当微服务部署的实例越来越多，达到数十、数百时，逐个修改微服务配置就会让人抓狂，而且很容易出错。我们需要一种统一配置管理方案，可以集中管理所有实例的配置。
Nacos一方面可以将配置集中管理，另一方可以在配置变更时，及时通知微服务，实现配置的热更新。
### 1）在nacos中添加配置文件
如何在nacos中管理配置呢？
然后在弹出的表单中，填写配置信息：
> 注意：项目的核心配置，需要热更新的配置才有放到nacos管理的必要。基本不会变更的一些配置还是保存在微服务本地比较好。
### 2）从微服务拉取配置
微服务要拉取nacos中管理的配置，并且与本地的application.yml配置合并，才能完成项目启动。
但如果尚未读取application.yml，又如何得知nacos地址呢？
因此spring引入了一种新的配置文件：bootstrap.yaml文件，会在application.yml之前被读取，流程如下：
1）引入nacos-config依赖
首先，在user-service服务中，引入nacos-config的客户端依赖：
```xml
<!--nacos配置管理依赖-->
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
</dependency>
```
2）添加bootstrap.yaml
然后，在user-service中添加一个bootstrap.yaml文件，内容如下：
```yaml
spring:
application:
name: userservice # 服务名称
profiles:
active: dev #开发环境，这里是dev
cloud:
nacos:
server-addr: localhost:8848 # Nacos地址
config:
file-extension: yaml # 文件后缀名
```
这里会根据spring.cloud.nacos.server-addr获取nacos地址，再根据
`${spring.application.name}-${spring.profiles.active}.${spring.cloud.nacos.config.file-extension}`作为文件id，来读取配置。
本例中，就是去读取`userservice-dev.yaml`：
3）读取nacos配置
在user-service中的UserController中添加业务逻辑，读取pattern.dateformat配置：
完整代码：
```java
package cn.hxzy.web;
import cn.hxzy.pojo.User;
import cn.hxzy.service.UserService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.*;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
@RestController
@RequestMapping("/user")
public class UserController {
@Autowired
private UserService userService;
@Value("${pattern.dateformat}")
private String dateformat;
@GetMapping("now")
public String now(){
return LocalDateTime.now().format(DateTimeFormatter.ofPattern(dateformat));
}
}
```
## 6.2.配置热更新
我们最终的目的，是修改nacos中的配置后，微服务中无需重启即可让配置生效，也就是**配置热更新**。
要实现配置热更新，可以使用两种方式：
### 1）方式一
在@Value注入的变量所在类上添加注解@RefreshScope：
### 2）方式二
使用@ConfigurationProperties注解代替@Value注解。
在user-service服务中，添加一个类，读取patterrn.dateformat属性：
```java
package cn.hxzy.config;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
@Component
@Data
@ConfigurationProperties(prefix = "pattern")
public class PatternProperties {
private String dateformat;
}
```
在UserController中使用这个类代替@Value：
完整代码：
```java
package cn.hxzy.web;
import cn.hxzy.config.PatternProperties;
import cn.hxzy.pojo.User;
import cn.hxzy.service.UserService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
@Slf4j
@RestController
@RequestMapping("/user")
public class UserController {
@Autowired
private UserService userService;
@Autowired
private PatternProperties patternProperties;
@GetMapping("now")
public String now(){
return LocalDateTime.now().format(DateTimeFormatter.ofPattern(patternProperties.getDateformat()));
}
}
```
# 7.Feign远程调用
先来看我们以前利用RestTemplate发起远程调用的代码：
~~~java
//2、利用RestTemplate发起http请求，查询用户
//String url="http://localhost:8081/user/"+order.getUserId();
String url="http://user-service/user/"+order.getUserId();
//3、发送http请求，实现远程调用
User user = restTemplate.getForObject(url, User.class);
~~~
这段代码，已经在使用ribbon的基础上做了优化，但仍然存在下面的问题：
- 代码可读性差，编程体验不统一
- 参数复杂URL难以维护
Feign是一个声明式的http客户端，官方地址：https://github.com/OpenFeign/feign
其作用就是帮助我们优雅的实现http请求的发送，解决上面提到的问题。
## 7.1.Feign替代RestTemplate
Fegin的使用步骤如下：
### 1）引入依赖
我们在order-service服务的pom文件中引入feign的客户端依赖：
```xml
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>
```
### 2）添加注解
在order-service的启动类添加注解开启Feign的功能：
~~~java
@EnableFeignClients
@SpringBootApplication
@MapperScan("cn.hxzy.mapper")
~~~
### 3）编写Feign的客户端
在order-service中新建一个clients包，在包下创建UserClient接口，内容如下：
```java
package cn.hxzy.clients;
import cn.hxzy.pojo.User;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
@FeignClient("user-service")
public interface UserClient {
@GetMapping("/user/{id}")
User findById(@PathVariable("id") Long id);
}
```
这个客户端主要是基于SpringMVC的注解来声明远程调用的信息，比如：
- 服务名称：userservice
- 请求方式：GET
- 请求路径：/user/{id}
- 请求参数：Long id
- 返回值类型：User
这样，Feign就可以帮助我们发送http请求，无需自己使用RestTemplate来发送了。
### 4）改造代码
修改order-service中的OrderServiceImpl类中的selectOrderById方法，使用Feign客户端代替RestTemplate：
~~~java
@Autowired
private OrderMapper orderMapper;
@Autowired
private UserClient userClient;
public Order selectOrderById(Long orderId){
//1、查询订单
Order order=orderMapper.selectById(orderId);
//2、利用Feign远程调用
User user = userClient.findById(order.getUserId());
//3、封装user到Order
order.setUser(user);
//4、返回user
return order;
}
~~~
是不是看起来优雅多了，接下来启动服务进行测试。
启动nacos
~~~bash
startup.cmd -m standalone
~~~
### 5）使用步骤总结
使用Feign的步骤：
① 引入依赖
② 添加@EnableFeignClients注解
③ 编写FeignClient接口
④ 使用FeignClient中定义的方法代替RestTemplate，自动装配到所调用的类中
### 6）Feign的功能
#### 6.1 远程调用
Feign是在RestTemplate的基础上进行了一次改进，采用接口的方式，将需要调用的其他服务方法定义成接口即可，不需要自己构建http请求。不过需要注意的是接口里面的抽象方法的注解，方法签名(方法名称和参数类型)要和提供服务的方法完全一致。
#### 6.2 实现负载均衡
Feign实现负载均衡早期使用Ribbon组件，现在改成了loadbalancer负载均衡器，所以使用Feign的时候，需要单独配置负载均衡器
~~~xml
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-loadbalancer</artifactId>
</dependency>
~~~
## 7.2.自定义Feign的日志配置
Feign可以支持很多的自定义配置，如下表所示：
| 类型 | 作用 | 说明 |
| ---------------------- | :----------- | :--------------------------------------------- |
| **feign.Logger.Level** | 修改日志级别 | 包含四种不同的级别：NONE、BASIC、HEADERS、FULL |
**feign.Logger.Level**而日志的级别分为四种：
- NONE：不记录任何日志信息，这是默认值。
- BASIC：仅记录请求的方法，URL以及响应状态码和执行时间
- HEADERS：在BASIC的基础上，额外记录了请求和响应的头信息
- FULL：记录所有请求和响应的明细，包括头信息、请求体、元数据。
一般情况下，默认值就能满足我们使用，如果要自定义时，只需要创建自定义的@Bean覆盖默认Bean即可。
下面以日志为例来演示如何自定义配置。
### 7.2.1.配置文件方式
基于配置文件修改feign的日志级别可以针对单个服务
局部生效，基于配置文件修改feign的日志级别可以针对单个服务进行配置
找到order-service的yml文件：
（在配置文件的顶格写，注意不是spring.cloud节点下）
```yaml
feign:
client:
config:
user-service: # 针对某个微服务的配置
loggerLevel: FULL # 日志级别
```
全局生效，针对所有服务的配置：
```yaml
feign:
client:
config:
default: # 这里用default就是全局配置，如果是写服务名称，则是针对某个微服务的配置
loggerLevel: FULL # 日志级别
```
### 7.2.2.Java代码方式
也可以基于Java代码来修改日志级别，先声明一个类，然后声明一个Logger.Level的对象：
```java
public class DefaultFeignConfiguration {
@Bean
public Logger.Level feignLogLevel(){
return Logger.Level.BASIC; // 日志级别为BASIC
}
}
```
如果要**全局生效**，将其放到启动类的@EnableFeignClients这个注解中：
```java
@EnableFeignClients(defaultConfiguration = DefaultFeignConfiguration .class)
```
如果是**局部生效**，则把它放到对应的@FeignClient这个注解中：
```java
@FeignClient(value = "userservice", configuration = DefaultFeignConfiguration .class)
```
## 7.3.Feign使用优化
Feign底层的客户端实现默认使用URL Connection的方式，Feign是一个声明式客户端，它只是帮助我们把我们的声明变成http请求，最终发http请求时，还是会用到别的客户端，URL Connection是JDK中自带的，它的实现性能不太好，而且它不支持连接池，如果使用了连接池可以减少连接创建和销毁的性能损耗。
Feign底层发起http请求，依赖于其它的框架。其底层客户端实现包括：
- URLConnection：默认实现，不支持连接池
- Apache HttpClient ：支持连接池（推荐Apache出品的）
- OKHttp：支持连接池
因此提高Feign的性能主要手段就是使用连接池代替默认的URLConnection。
这里我们用Apache的HttpClient来演示。
1）引入依赖
在order-service的pom文件中引入Apache的HttpClient依赖：
```xml
<!--httpClient的依赖 -->
<dependency>
<groupId>io.github.openfeign</groupId>
<artifactId>feign-httpclient</artifactId>
</dependency>
```
2）配置连接池
在order-service的application.yml中添加配置：
```yaml
feign:
client:
config:
user-service: # 针对某个微服务的配置
loggerLevel: BASIC # 日志级别
httpclient:
enabled: true # 开启feign对HttpClient的支持
max-connections: 200 # 最大的连接数
max-connections-per-route: 50 # 每个路径的最大连接数
```
总结，Feign的优化：
1.日志级别尽量用basic或NONE
2.使用HttpClient或OKHttp代替URLConnection
① 引入feign-httpClient依赖
② 配置文件开启httpClient功能，设置连接池参数
## 7.4.Feign的最佳实践
所谓最佳实践，就是使用过程中总结的经验，最好的一种使用方式。
观察可以发现，Feign的客户端与服务提供者的controller代码非常相似：
Feign客户端：
~~~java
@FeignClient("userservice")
public interface UserClient {
@GetMapping("/user/{id}")
User findById(@PathVariable("id") Long id);
}
~~~
UserController：
~~~java
@GetMapping("/{id}")
public User selectUserById(@PathVariable("id") Long id){
return userService.getById(id);
}
~~~
现在还有一个模块，也要调用user-service，有没有一种办法简化这种重复的代码编写呢？
### 7.4.1.抽取方式
将Feign的Client抽取为独立模块，并且把接口有关的POJO、默认的Feign配置都放到这个模块中，提供给所有消费者使用。
例如，将UserClient、User、FeignClient的默认配置都抽取到一个feign-api包中，所有微服务引用该依赖包，即可直接使用。
### 7.4.2.实现基于抽取的最佳实践
#### 1）抽取FeignClient
首先创建一个module，命名为feign-api
创建cn.hxzy.feign包，然后，把order-service中编写的UserClient、User、配置信息等都复制到feign-api项目的feign包中
在feign-api中然后引入feign的starter依赖
pom.xml的依赖项转移：
~~~xml
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>
<!-- 负载均衡器-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-loadbalancer</artifactId>
</dependency>
</dependencies>
~~~
#### 2）在order-service中使用feign-api
删除order-service中的UserClient、User，yml配置等。
#### 3) 引入feign-api的依赖
在order-service的pom文件中中引入feign-api的依赖：
```xml
<!--引入feign的统一Api-->
<dependency>
<groupId>cn.hxzy</groupId>
<artifactId>feign-api</artifactId>
<version>1.0</version>
</dependency>
```
修改order-service中的所有与上述三个组件有关的导包部分，改成导入feign-api中的包
#### 3）重启测试
重启后，如果发现服务报错的情况
这是因为UserClient现在在cn.hxzy.feign.clients包下，
而order-service的@EnableFeignClients注解是在cn.hxzy包下，不在同一个包，无法扫描到UserClient。
#### 4）解决扫描包问题
方式一：
指定Feign应该扫描的包：
~~~java
@EnableFeignClients(basePackages = "cn.hxzy.feign.clients")
~~~
方式二：
指定需要加载的Client接口：
~~~java
@EnableFeignClients(clients = {UserClient.class})
~~~
# 8.Gateway服务网关
Spring Cloud Gateway 是 Spring Cloud 的一个全新项目，该项目是基于 Spring 5.0，Spring Boot 2.0 和 Project Reactor 等响应式编程和事件流技术开发的网关，它旨在为微服务架构提供一种简单有效的统一的 API 路由管理方式。
## 8.1.为什么需要网关
Gateway网关是我们服务的守门神，所有微服务的统一入口。
网关的**核心功能特性**：
- 请求路由
- 权限控制
- 限流
架构图：
**权限控制**：网关作为微服务入口，需要校验用户是是否有请求资格，如果没有则进行拦截。
**路由和负载均衡**：一切请求都必须先经过gateway，但网关不处理业务，而是根据某种规则，把请求转发到某个微服务，这个过程叫做路由。当然路由的目标服务有多个时，还需要做负载均衡。
**限流**：当请求流量过高时，在网关中按照下游的微服务能够接受的速度来放行请求，避免服务压力过大。
在SpringCloud中网关的实现包括两种：
- gateway
- zuul
Zuul是基于Servlet的实现，属于阻塞式编程。而SpringCloudGateway则是基于Spring5中提供的WebFlux，属于响应式编程的实现，具备更好的性能。
## 8.2.gateway快速入门
下面，我们就演示下网关的基本路由功能。基本步骤如下：
1. 创建SpringBoot工程gateway，引入网关依赖
2. 编写启动类
3. 编写基础配置和路由规则
4. 启动网关服务进行测试
### 1）创建gateway服务，引入依赖
创建gateway微服务服务，引入依赖：
```xml
<dependencies>
<!--网关-->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>
<!--nacos服务发现依赖-->
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
</dependencies>
```
### 2）编写启动类
```java
package cn.hxzy;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication(exclude = DataSourceAutoConfiguration.class)
public class GatewayApplication {
public static void main(String[] args) {
SpringApplication.run(GatewayApplication.class, args);
}
}
```
### 3）编写基础配置和路由规则
创建application.yml文件，内容如下：
```yaml
server:
port: 81 # 网关端口
spring:
application:
name: gateway # 服务名称
cloud:
nacos:
server-addr: localhost:8848 # nacos地址
gateway:
routes: # 网关路由配置
- id: user-service # 路由id，自定义，只要唯一即可
# uri: http://127.0.0.1:8081 # 路由的目标地址 http就是固定地址
uri: lb://user-service # 路由的目标地址 lb（loadBalance）就是负载均衡，后面跟服务名称
predicates: # 路由断言，也就是判断请求是否符合路由规则的条件
- Path=/user/** # 这个是按照路径匹配，只要以/user/开头就符合要求
- id: order-service
uri: lb://order-service
predicates:
- Path=/order/**
```
我们将符合`Path` 规则的一切请求，都代理到 `uri`参数指定的地址。
本例中，我们将 `/user/**`开头的请求，代理到`lb://user-service`，lb是负载均衡，根据服务名拉取服务列表，实现负载均衡。
### 4）重启测试
重启网关，访问http://localhost:81/user/1时，符合`/user/**`规则，请求转发到uri：http://userservice/user/1，查看结果
### 5）网关路由的流程图
整个访问的流程如下：
总结：
网关搭建步骤：
1. 创建项目，引入nacos服务发现和gateway依赖
2. 配置application.yml，包括服务基本信息、nacos地址、路由
路由配置包括：
1. 路由id：路由的唯一标示
2. 路由目标（uri）：路由的目标地址，http代表固定地址，lb代表根据服务名负载均衡
3. 路由断言（predicates）：判断路由的规则
## 8.3.过滤器工厂
GatewayFilter是网关中提供的一种过滤器，可以对进入网关的请求和微服务返回的响应做处理：
### 8.3.1.路由过滤器的种类
Spring提供了31种不同的路由过滤器工厂。例如：
| **名称** | **说明** |
| -------------------- | ---------------------------- |
| AddRequestHeader | 给当前请求添加一个请求头 |
| RemoveRequestHeader | 移除请求中的一个请求头 |
| AddResponseHeader | 给响应结果中添加一个响应头 |
| RemoveResponseHeader | 从响应结果中移除有一个响应头 |
| RequestRateLimiter | 限制请求的流量 |
### 8.3.2.请求头过滤器
下面我们以AddRequestHeader 为例来讲解。
> **需求**：给所有进入userservice的请求添加一个请求头：Truth=Request header information!
只需要修改gateway服务的application.yml文件，添加路由过滤即可：
```yaml
spring:
cloud:
gateway:
routes:
- id: user-service
uri: lb://userservice
predicates:
- Path=/user/**
filters: # 过滤器
- AddRequestHeader=header,hello! # 添加请求头
```
当前过滤器写在userservice路由下，因此仅仅对访问userservice的请求有效。
UserController的方法参数上，添加一个参数
~~~
@RequestHeader(value="header",required=false) String header
~~~
### 8.3.3.默认过滤器
如果要对所有的路由都生效，则可以将过滤器工厂写到default下。格式如下：
```yaml
spring:
cloud:
gateway:
routes:
- id: user-service
uri: lb://userservice
predicates:
- Path=/user/**
default-filters: # 默认过滤项
- AddRequestHeader=Request header information!
```
### 8.3.4.总结
过滤器的作用是什么？
① 对路由的请求或响应做加工处理，比如添加请求头
② 配置在路由下的过滤器只对当前路由的请求生效
defaultFilters的作用是什么？
① 对所有路由都生效的过滤器
# 9、Gateway网关综合案例
**问题描述**：
- 如何在网关中实现登录操作？
- 如何在网关转发之前做是否登录校验？
- 网关如何将用户信息传递给微服务？
- 如何在微服务之间传递用户信息？
**准备工作**：
- 改造user表，添加字段userNo，password两个字段
- 实体类添加对应的属性，改造用户编号，订单编号为Long类型
## 9.1 实现登录
添加通用模块sys-common模块
### 9.1.1 导入依赖
~~~xml
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
<dependency>
<groupId>io.jsonwebtoken</groupId>
<artifactId>jjwt</artifactId>
<version>0.9.1</version>
</dependency>
<!--jdk9以后移除了-->
<dependency>
<groupId>javax.xml.bind</groupId>
<artifactId>jaxb-api</artifactId>
<version>2.3.1</version>
</dependency>
<!--引入公共模块-->
<dependency>
<groupId>cn.hxzy.common</groupId>
<artifactId>sys-common</artifactId>
<version>0.0.1-SNAPSHOT</version>
<exclusions>
<exclusion>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</exclusion>
</exclusions>
</dependency>
~~~
### 9.1.2 引入Jwt工具类
~~~java
package cn.hxzy.utils;
import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import lombok.Data;
import org.springframework.stereotype.Component;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
@Data
@Component
public class JwtUtils {
//密钥
private static String secret = "qW21YIUd";
// 过期时间 毫秒
private static Long expiration = 60 * 60 * 1000L;// 60 * 60 *1000 一个小时
/**
* 从数据声明生成令牌
* <p>
* /
*
* @param claims 数据声明
* @return 令牌
*/
private static String generateToken(Map<String, Object> claims) {
Date expirationDate = new Date(System.currentTimeMillis() + expiration);
return
Jwts.builder().setClaims(claims).setExpiration(expirationDate).signWith(SignatureAlgorithm.HS512, secret).compact();
}
/**
* 从令牌中获取数据声明
*
* @param token 令牌
* @return 数据声明
*/
public static Claims getClaimsFromToken(String token) {
Claims claims;
try {
claims = Jwts.parser().setSigningKey(secret).parseClaimsJws(token).getBody();
} catch (Exception e) {
claims = null;
}
return claims;
}
/**
* 生成令牌
*
* @param userId 用户编号
* @return 令牌
*/
public static String createJWT(String userId) {
Map<String, Object> claims = new HashMap<>();
claims.put(Claims.SUBJECT, userId);
claims.put(Claims.ISSUED_AT, new Date());
return generateToken(claims);
}
/**
* 从令牌中获取用户
*
* @param token 令牌
* @return 用户JSON格式字符串
*/
public static String getUserIdFromToken(String token) {
String userId;
try {
Claims claims = getClaimsFromToken(token);
userId = claims.getSubject();
} catch (Exception e) {
userId = null;
}
return userId;
}
/**
* 判断令牌是否过期
*
* @param token
* @return 是否过期
*/
public static Boolean isTokenExpired(String token) {
Claims claims = getClaimsFromToken(token);
Date expiration = claims.getExpiration();
return expiration.before(new Date());
}
/**
* 刷新令牌
*
* @param token 原令牌
* @return 新令牌
*/
public static String refreshToken(String token) {
String refreshedToken;
try {
Claims claims = getClaimsFromToken(token);
claims.put(Claims.ISSUED_AT, new Date());
refreshedToken = generateToken(claims);
} catch (Exception e) {
refreshedToken = null;
}
return refreshedToken;
}
/**
* 验证令牌
*
* @param token 令牌
* @param userId 用户编号
* @return 是否有效
*/
public static Boolean validateToken(String token, String userId) {
String id = getUserIdFromToken(token);
return id.equals(userId)&&!isTokenExpired(token);
}
}
~~~
### 9.1.3 添加登录业务
在user-service模块的UserController中，添加登录业务模块
~~~java
@PostMapping("/login")
public String login(@RequestBody User user) {
QueryWrapper<User> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("user_no", user.getUserNo());
queryWrapper.eq("pass_word", user.getPassWord());
User userInfo = userService.getOne(queryWrapper);
if (userInfo != null) {
return JwtUtils.createJWT(userInfo.getId().toString());
}
return "";
}
~~~
## 9.2 实现是否登录校验
### 9.2.1 网关配置添加忽略路径数组
~~~yml
shop:
auth:
excludePaths:
- /user/login
- /search/**
- /goods/**
- /hello
~~~
### 9.2.2 创建AuthProperties类
在网关模块下，创建config包，添加AuthProperties类
~~~java
package cn.hxzy.config;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
import java.util.List;
@Data
@Component
@ConfigurationProperties(prefix = "shop.auth")
public class AuthProperties {
private List<String> excludePaths;
}
~~~
在网关启动类上添加@ConfigurationPropertiesScan注解
### 9.2.3 自定义网关登录校验过滤器
网关提供了过滤器31种，但每一种过滤器的作用都是固定的，如果我们希望拦截请求，做自己的业务逻辑则没办法实现。
所以需要我们自定义网关过滤器GlobalFilter，处理一切进入网关的请求和微服务响应。
定义方式是实现GlobalFilter接口。
GlobalFilter：也叫做全局过滤器，作用范围是所有路由；声明后自动生效。
```java
public interface GlobalFilter {
/**
* 处理当前请求，有必要的话通过{@link GatewayFilterChain}将请求交给下一个过滤器处理
*
* @param exchange 请求上下文，里面可以获取Request、Response等信息
* @param chain 用来把请求委托给下一个过滤器
* @return {@code Mono<Void>} 返回标示当前过滤器业务结束
*/
Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain);
}
```
在filter中编写自定义逻辑，可以实现下列功能：
- 登录状态判断
- 权限校验
**创建全局过滤器**
~~~java
package cn.hxzy.filter;
import cn.hxzy.config.AuthProperties;
import cn.hxzy.utils.JwtUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.annotation.Order;
import org.springframework.http.HttpStatus;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.stereotype.Component;
import org.springframework.util.AntPathMatcher;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;
import java.util.List;
@Component
@Order(0)
public class AuthorizeFilter implements GlobalFilter {
@Autowired
private AuthProperties authProperties;
//路径匹配器
private final AntPathMatcher antPathMatcher = new AntPathMatcher();
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
//1、获取请求对象
ServerHttpRequest request = exchange.getRequest();
//2、判断是否要做登录拦截
if (isExclude(request.getPath().toString())) {
return chain.filter(exchange);
}
//3、获取token
String token = null;
List<String> headers = request.getHeaders().get("Authorization");
if (headers != null && !headers.isEmpty()) {
token = headers.get(0);
}
//4、校验并解析token
try {
String userId = JwtUtils.getUserIdFromToken(token);
} catch (Exception e) {
//校验失败，拦截
ServerHttpResponse response = exchange.getResponse();
response.setStatusCode(HttpStatus.UNAUTHORIZED);
//拦截，终止,后续所有的拦截器就不会再执行了，请求也不会转发了
return response.setComplete();
}
//5、传递用户信息
//TODO
//6、放行
return chain.filter(exchange);
}
//判断路由的是否需要放行
private boolean isExclude(String path) {
for (String item:authProperties.getExcludePaths()){
if(antPathMatcher.match(item,path)){
return true;
}
}
return false;
}
}
~~~
### 9.2.4 过滤器执行顺序
~~~java
@Order(0)
~~~
请求进入网关会碰到三类过滤器：当前路由的过滤器、DefaultFilter、GlobalFilter
请求路由后，会将当前路由过滤器和DefaultFilter、GlobalFilter，合并到一个过滤器链（集合）中，排序后依次执行每个过滤器：
排序的规则是什么呢？
- 每一个过滤器都必须指定一个int类型的order值，**order值越小，优先级越高，执行顺序越靠前**。
- GlobalFilter通过实现Ordered接口，或者添加@Order注解来指定order值，由我们自己指定
- 路由过滤器和defaultFilter的order由Spring指定，默认是按照声明顺序从1递增。
- 当过滤器的order值一样时，会按照 defaultFilter > 路由过滤器 > GlobalFilter的顺序执行。
### 9.2.5 测试登录校验
启动项目，使用postman工具测试登录api，登录成功后，颁发令牌。
### 9.2.6 WebFlux和Spring MVC的主要区别
WebFlux和Spring MVC的主要区别在于它们的处理模型、编程模型、以及适用场景。
处理模型：
Spring MVC是基于同步的模型，每个请求都会占用一个线程，处理完后才能释放，这种模型适合处理传统的Web应用程序，特别是那些主要涉及创建、读取、更新和删除(CRUD)操作的应用程序。它与Servlet容器兼容，并且有大量的文档和社区支持。
WebFlux则是基于异步的模型，采用了非阻塞的编程模型，使用少量的线程处理大量请求，能够更好地利用系统资源，提高并发能力。它支持响应式编程，可以处理高并发、高负载的场景，适用于需要处理大量非阻塞 I/O 操作的应用。
编程模型：
Spring MVC的控制器方法返回的是一个对象，该对象会被序列化为JSON或者其他格式返回给客户端。
WebFlux的控制器方法返回的是一个Mono或者Flux对象，这是Reactor框架中的响应式处理类型，能够支持异步处理和流式处理。
适用场景：
Spring MVC更适合传统的Web应用程序，特别是那些主要涉及CRUD操作的应用程序，因为它与Servlet容器兼容，并且有大量的文档和社区支持。
WebFlux则更适合处理高并发、高负载、非阻塞I/O操作的场景。它的非阻塞特性可以提供更好的性能和可伸缩性，适用于需要快速响应的应用程序，如实时交易或游戏服务器。
总的来说，WebFlux更适合处理需要高并发、高负载、非阻塞I/O操作的场景，而Spring MVC更适合传统的同步请求响应场景。选择使用哪种方式取决于项目的需求和性能要求。
## 9.3 网关传递登录用户
### 9.3.1 网关中添加传递用户信息代码
在网关的登录校验过滤器中，把获取到的用户写入请求头
- 修改网关模块中的登录校验拦截器，在校验成功后保存用户到下游请求的请求头中。
- 要修改转发到微服务的请求，需要用到ServerWebExchange类提供的API，示例如第5步：
~~~java
package cn.hxzy.filter;
import cn.hxzy.config.AuthProperties;
import cn.hxzy.utils.JwtUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.annotation.Order;
import org.springframework.http.HttpStatus;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.stereotype.Component;
import org.springframework.util.AntPathMatcher;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;
import java.util.List;
@Component
@Order(0)
public class AuthorizeFilter implements GlobalFilter {
@Autowired
private AuthProperties authProperties;
private final AntPathMatcher antPathMatcher = new AntPathMatcher();
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
//1、获取请求对象
ServerHttpRequest request = exchange.getRequest();
//2、判断是否要做登录拦截
if (isExclude(request.getPath().toString())) {
return chain.filter(exchange);
}
//3、获取token
String token = null;
List<String> headers = request.getHeaders().get("Authorization");
if (headers != null && !headers.isEmpty()) {
token = headers.get(0);
}
//4、校验并解析token
String userId = null;
try {
userId = JwtUtils.getUserIdFromToken(token);
} catch (Exception e) {
//校验失败，拦截
ServerHttpResponse response = exchange.getResponse();
response.setStatusCode(HttpStatus.UNAUTHORIZED);
//拦截，终止,后续所有的拦截器就不会再执行了，请求也不会转发了
return response.setComplete();
}
String userInfo=userId.toString();
//5、传递用户信息
ServerWebExchange swe = exchange
.mutate().request(builder -> {
builder.header("user-info", userInfo);
}).build();
//6、放行
return chain.filter(swe);
}
//判断路由的是否需要放行
private boolean isExclude(String path) {
for (String item:authProperties.getExcludePaths()){
if(antPathMatcher.match(item,path)){
return true;
}
}
return false;
}
}
~~~
### 9.3.2 在通用模块添加工具类
在sys-common模块中编写SpringMVC拦截器，获取登录用户
由于每个微服务都可能有获取登录用户的需求，因此我们直接在sys-common模块定义拦截器，这样微服务只需要引入依赖即可生效，无需重复编写。
在sys-common模块的utils包下，创建UserContext工具类
~~~java
package cn.hxzy.utils;
public class UserContext {
private static final ThreadLocal<Long> threadLocal=new ThreadLocal<>();
public static void setUser(Long userId){
threadLocal.set(userId);
}
public static Long getUser(){
return threadLocal.get();
}
public static void removeUser(){
threadLocal.remove();
}
}
~~~
### 9.3.3 在通用模块添加拦截器
在sys-common模块下，创建interceptors包，添加自定义UserInfoInterceptor拦截器
~~~java
package cn.hxzy.interceptors;
import cn.hxzy.utils.UserContext;
import org.springframework.util.ObjectUtils;
import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class UserInfoInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
//1、获取用户登录信息
String userId = request.getHeader("user-info");
//2、判断用户信息是否为空
if(!ObjectUtils.isEmpty(userId)){
UserContext.setUser(Long.valueOf(userId));
}
//3、放行
return true;
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
UserContext.removeUser();
}
}
~~~
### 9.3.4 配置拦截器
在sys-common模块下添加config包，创建MvcConfig配置类，实现WebMvcConfigurer接口
~~~java
package cn.hxzy.config;
import cn.hxzy.interceptors.UserInfoInterceptor;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.DispatcherServlet;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
@Configuration
@ConditionalOnClass(DispatcherServlet.class)
public class MvcConfig implements WebMvcConfigurer {
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(new UserInfoInterceptor());
}
}
~~~
### 9.3.5 配置spring.factories
在sys-common模块的resources路径下，添加META-INF目录，然后在之下添加spring.factories文件，进行扫描路径的配置
~~~properties
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
cn.hxzy.config.MvcConfig
~~~
### 9.3.6 测试登录用户信息传递
在OrderController的获取订单方法中，测试获取登录用户信息
~~~java
@GetMapping("/getOrder/{id}")
public Order query(@PathVariable Long id,@RequestHeader(value = "user-info",required = false) String userId){
System.out.println("orderservice:userId="+userId);
Order order = orderService.selectOrderById(id);
return order;
}
~~~
## 9.4 远程调用接口OpenFeign传递用户信息
微服务项目中的很多业务要多个微服务共同合作完成，而这个过程中也需要传递登录用户信息
### 9.4.1 添加拦截器
在feign-api模块下，config包中的DefaultFeignConfiguration类中添加拦截器
OpenFeign中提供了一个拦截器接口，所有由OpenFeign发起的请求都会先调用拦截器处理请求
其中的RequestTemplate类中提供了一些方法可以让我们修改请求头
~~~java
package cn.hxzy.feignapi.config;
import cn.hxzy.utils.UserContext;
import feign.Logger;
import feign.RequestInterceptor;
import feign.RequestTemplate;
import org.springframework.context.annotation.Bean;
public class DefaultFeignConfiguration {
@Bean
public Logger.Level feignLogLevel(){
return Logger.Level.BASIC; // 日志级别为BASIC
}
@Bean
public RequestInterceptor requestInterceptor(){
return template -> {
Long userId = UserContext.getUser();
if(userId!=null){
template.header("user-info",userId.toString());
}
};
}
}
~~~
### 9.4.2 测试OpenFeign传递用户信息
在user-service模块的controller中，获取用户信息的方法中添加代码进行测试
~~~java
@GetMapping("/getUser/{id}")
public User getUserInfo(@PathVariable("id") Long id,@RequestHeader(value = "user-info",required = false) String userId) {
System.out.println("userservice:userId="+userId);
User user = userService.getById(id);
return user;
}
~~~
# 10、前端请求Nginx反向代理Gateway集群
## 10.1.解决跨域问题
跨域问题：浏览器禁止请求的发起者与服务端发生跨域axios请求，请求被浏览器拦截的问题
在gateway服务的application.yml文件中，添加下面的配置：
```yaml
spring:
cloud:
gateway:
globalcors: # 全局的跨域处理
add-to-simple-url-handler-mapping: true # 解决options请求被拦截问题
corsConfigurations:
'[/**]':
allowedOrigins: "*" # 允许哪些网站的跨域请求
allowedMethods: # 允许的跨域ajax的请求方式
- "GET"
- "POST"
- "DELETE"
- "PUT"
- "OPTIONS"
allowedHeaders: "*" # 允许在请求中携带的头信息
allowCredentials: true # 是否允许携带cookie
maxAge: 3600 # 这次跨域检测的有效期
```
## 10.2 前端页面配置
Nginx反向代理Gateway集群
所有业务线到Nginx，然后分发到网关1（81端口）和网关2（82端口）
再启动一台Gateway实例，设置端口为82
~~~bash
--server.port=82
~~~
前端代码：
~~~html
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
<title></title>
</head>
<body>
<div id="app">
<input type="button" value="获取订单数据" @click="getOrder" /><br/>
<span >{{message}}</span>
</div>
</body>
<script src="https://cdn.staticfile.net/vue/2.7.0/vue.min.js"></script>
<script src="https://unpkg.com/axios/dist/axios.min.js"></script>
<script>
axios.default.withCredentials = true
new Vue({
el: "#app",
data: {
message:""
},
methods: {
getOrder() {
axios({
method: "get",
url: "/ipport/order/getOrder/101"
}).then(res => {
this.message=res.data
})
}
}
})
</script>
</html>
~~~
## 10.3 nginx.conf配置
~~~conf
worker_processes 1;
events {
worker_connections 1024;
}
http {
include mime.types;
default_type application/octet-stream;
sendfile on;
keepalive_timeout 65;
upstream gatewayaddr {
server 127.0.0.1:81 weight=1;
server 127.0.0.1:82 weight=1;
}
server {
listen 80;
server_name localhost;
location / {
root html;
index index.html index.htm;
}
location /ippost/ {
proxy_pass http://gatewayaddr/;
}
error_page 500 502 503 504 /50x.html;
location = /50x.html {
root html;
}
}
}
~~~
## 10.4 测试使用nginx反向代理到网关
测试：部署运行前端页面，访问网关。
springcloud3
最新推荐文章于 2024-08-11 20:00:32 发布
7568
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
