2019-11-21
06:32:12
2167
springCloud微服务入门
一.微服务场景模拟
首先，我们需要模拟一个服务调用的场景。方便后面学习微服务架构
为方便管理，先新建一个maven工程做为父工程(springCloud-demo)
1.1 服务提供者(user-service)
在springCloud-demo中创建模块(子工程)，新建一个spring Initializr项目，对外提供查询用户的服务;
因为需要连接数据库和通过web访问，所以需要在新建模块时选择添加Web，JDBC，MyBatis，MySQL依赖;
再点击下一步，选择项目路径后点击完成；
1.1.1 pom.xml文件
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://http://cdn.xiongsihao.com.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.0.6.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.xsh.demo</groupId>
<artifactId>user-service</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>user-service</name>
<description>Demo project for Spring Boot</description>
<properties>
<java.version>1.8</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>2.1.0</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
因为要使用通用mapper，所以我们需要手动加一条依赖：
通用mapper封装了增删改查方法，可以通过继承Mapper接口而直接调用
<dependency>
<groupId>tk.mybatis</groupId>
<artifactId>mapper-spring-boot-starter</artifactId>
<version>2.0.2</version>
</dependency>
1.1.2 User实体类
@Table(name = "tb_user")
public class User implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
// 用户名
private String userName;
// 密码
private String password;
// 姓名
private String name;
// 年龄
private Integer age;
// 性别，1男性，2女性
private Integer sex;
// 出生日期
private Date birthday;
// 创建时间
private Date created;
// 更新时间
private Date updated;
// 备注
private String note;
// 此处已省略省略getters和setters方法
}
1.1.3 mapper接口层
@Repository /*为了在service层注入该接口不报错而加上该注解，也可以不加*/
public interface UserMapper extends Mapper<User> {
/*继承了通用Mapper接口，可直接调用简单的增删改查方法，User为指定返回的实体类*/
}
1.1.4 service服务层
@Service
public class UserService {
@Autowired
private UserMapper userMapper;
public User queryUserById(long id){
return this.userMapper.selectByPrimaryKey(id);
}
}
1.1.5 controller控制层
@RestController
@RequestMapping("user")
public class UserController {
@Autowired
private UserService userService;
@GetMapping("/{id}")
public User queryById(@PathVariable("id") long id) {
return this.userService.queryById(id);
}
}
1.1.6 属性文件application.yml
server:
port: 8081
spring:
datasource:
url: jdbc:mysql://localhost:3306/test
username: root
password: 123456
mybatis:
type-aliases-package: com.xsh.demo.domain #指定实体类包路径
1.1.7 完成部署，启动测试
在启动类上加上@MapperScan注解指定接口包路径，方便启动类扫描该包
@MapperScan("com.xsh.demo.mapper")
启动启动类，输入网址http://localhost:8081/user/1访问成功
1.2 服务调用者(user-consumer)
继续在springCloud-demo中创建模块(子工程)，新建一个spring Initializr项目，来调用其它接口的服务;
因为是调用user-service的功能，因此不需要mybatis相关依赖了，只需要引入Web依赖
当一个项目有多个启动类时，右下角会提示Run Dashboard,点击同意打开Run Dashboard面板方便管理
1.2.1 pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://http://cdn.xiongsihao.com.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.0.6.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.xsh.demo</groupId>
<artifactId>user-consumer</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>user-consumer</name>
<description>Demo project for Spring Boot</description>
<properties>
<java.version>1.8</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
1.2.2 在启动类中注册RestTemplate
@SpringBootApplication
public class UserConsumerApplication {
public static void main(String[] args) {
SpringApplication.run(UserConsumerApplication.class, args);
}
@Bean
public RestTemplate restTemplate(){
return new RestTemplate();
}
}
1.2.3 User实体类
因为此时的User实体类只是作为一个返回类型，不需要连接数据库，所以只要添加属性不需要添加相关注解
public class User {
private Long id;
private String userName;
private String password;
private String name;
private Integer age;
private Integer sex;
private Date birthday;
private Date created;
private Date updated;
private String note;
// 此处省略getter和setter方法
}
1.2.4 mapper接口
注意：这里不是调用mapper查数据库，而是通过RestTemplate远程查询user-service中的接口
@Component
public class UserMapper {
@Autowired
private RestTemplate restTemplate;
public User queryUserById(Long id){
String url = "http://localhost:8081/user/" + id;
return this.restTemplate.getForObject(url, User.class);
}
}
1.2.5 service服务层
在服务层对接口就行加强: 接口只实现一次查询一个，服务层加强后可一次查询多个
@Service
public class UserService {
@Autowired
private UserMapper userMapper;
public List<User> querUserByIds(List<Long> ids){
List<User> users = new ArrayList<>();
for (Long id : ids) {
User user = this.userMapper.queryUserById(id);
users.add(user);
}
return users;
}
}
1.2.6 controller控制层
@RestController
@RequestMapping("consume")
public class UserController {
@Autowired
private UserService userService;
@GetMapping
public List<User> consume(@RequestParam("ids") List<Long> ids) {
return this.userService.querUserByIds(ids);
}
}
1.2.7 完成部署，启动测试
在application.yml配置服务端口（不配置默认为8080），然后启动启动类
server:
port: 8082
输入网址http://localhost:8082/consumer?ids=1,2,3访问成功
1.3问题
use-service：一个提供根据id查询用户的微服务
user-consumer：一个服务调用者，通过RestTemplate远程调用user-service
存在的问题:
- 在consumer中，我们把url地址硬编码到了代码中，不方便后期维护
- consumer需要记忆user-service的地址，如果出现变更，可能得不到通知，地址将失效
- consumer不清楚user-service的状态，服务宕机也不知道
- user-service只有1台服务，不具备高可用性
- 即便user-service形成集群，consumer还需自己实现负载均衡
上面的问题，概括一下就是分布式服务必然要面临的问题：
- 服务管理
- 如何自动注册和发现
- 如何实现状态监管
- 如何实现动态路由
- 服务如何实现负载均衡
- 服务如何解决容灾问题
- 服务如何实现统一配置
二. Eureka注册中心
实现了服务的自动注册、发现、状态监控
2.1 原理图
基本架构：
- Eureka：就是服务注册中心（可以是一个集群），对外暴露自己的地址
- 提供者：启动后向Eureka注册自己信息（地址，提供什么服务）
- 消费者：向Eureka订阅服务，Eureka会将对应服务的所有提供者地址列表发送给消费者，并且定期更新
- 心跳(续约)：提供者定期通过http方式向Eureka刷新自己的状态
2.2 搭建Eureka注册中心
2.2.1 创建Eureka项目
在springCloud-demo中创建模块(子工程)，新建一个spring Initializr项目，名字叫eureka
选择依赖:
2.2.2 导入相关依赖
已在创建spring Initializr时添加无需再次导入
完整的pom.xml文件:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://http://cdn.xiongsihao.com.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.0.6.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.xsh.demo</groupId>
<artifactId>eureka</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>eureka</name>
<description>Demo project for Spring Boot</description>
<properties>
<java.version>1.8</java.version>
<spring-cloud.version>Finchley.SR2</spring-cloud.version>
</properties>
<dependencies>
<!-- Eureka服务端 -->
<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-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<dependencyManagement>
<!-- SpringCloud依赖，一定要放到dependencyManagement中，起到管理版本的作用 -->
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>${spring-cloud.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
<repositories>
<repository>
<id>spring-milestones</id>
<name>Spring Milestones</name>
<url>https://repo.spring.io/milestone</url>
</repository>
</repositories>
</project>
2.2.3 更改默认配置
server:
port: 10086 #当前服务端口
spring:
application:
name: eureka-server # 应用名称，会在Eureka中显示
eureka:
client:
service-url: # EurekaServer的地址，现在是自己的地址，因为是自己作为eureka服务
defaultZone: http://127.0.0.1:10086/eureka
#register-with-eureka: false # 此应用为注册中心，false：不向注册中心注册自己
#fetch-registry: false # 注册中心职责是维护服务实例，false：不检索服务。
2.2.4 在启动类上添加注解
@SpringBootApplication
@EnableEurekaServer // 声明这个应用是一个EurekaServer
public class EurekaApplication {
public static void main(String[] args) {
SpringApplication.run(EurekaApplication.class, args);
}
}
启动服务并访问: http://localhost:10086 可显示eureka信息
2.3 将user-service注册进Eureka
2.3.1 添加相关依赖
先添加SpringCloud依赖：
<!-- SpringCloud的依赖 -->
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>Finchley.SR2</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
<!-- Spring的仓库地址 -->
<repositories>
<repository>
<id>spring-milestones</id>
<name>Spring Milestones</name>
<url>https://repo.spring.io/milestone</url>
<snapshots>
<enabled>false</enabled>
</snapshots>
</repository>
</repositories>
再添加Eureka客户端依赖:
<!-- Eureka客户端 -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
2.3.2 更改默认配置
server:
port: 8081
spring:
datasource:
url: jdbc:mysql://localhost:3306/test
username: root
password: 123456
application:
name: user-service # 当前微服务名称
mybatis:
type-aliases-package: com.xsh.demo.domain #指定实体类包路径
eureka:
client:
service-url: # Eureka服务地址
defaultZone: http://127.0.0.1:10086/eureka
注意： 还添加了spring.application.name属性来指定应用名称，将来会作为应用的id使用。
2.3.3 在启动类上添加注解
@EnableDiscoveryClient // 开启EurekaClient功能
重启user-service项目，刷新eureka服务页面，发现user-service已经注册进去了
2.4 将user-consumer注册进Eureka
2.4.1 添加相关依赖
先添加SpringCloud依赖：
<!-- SpringCloud的依赖 -->
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>Finchley.SR2</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
<!-- Spring的仓库地址 -->
<repositories>
<repository>
<id>spring-milestones</id>
<name>Spring Milestones</name>
<url>https://repo.spring.io/milestone</url>
<snapshots>
<enabled>false</enabled>
</snapshots>
</repository>
</repositories>
再添加Eureka客户端依赖:
<!-- Eureka客户端 -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
2.4.2 更改默认配置
server:
port: 8082
spring:
application:
name: consumer # 应用名称
eureka:
client:
service-url: # EurekaServer地址
defaultZone: http://127.0.0.1:10086/eureka
2.4.3 在启动类上添加注解
@EnableDiscoveryClient // 开启EurekaClient功能
重启user-consumer项目，刷新eureka服务页面，发现consumer也已经注册进去了
2.5 解决地址硬编码的问题
修改user-consumer的UseMapper方法, 用DiscoveryClient类的方法，根据服务名称，获取服务实例
@Component
public class UserMapper {
@Autowired
private RestTemplate restTemplate;
@Autowired
private DiscoveryClient discoveryClient;// Eureka客户端，可以获取到服务实例信息
public User queryUserById(Long id){
// 根据服务名称，获取服务实例
List<ServiceInstance> instances = discoveryClient.getInstances("user-service");
// 因为只有一个UserService,因此我们直接get(0)获取实例
ServiceInstance instance = instances.get(0);
System.out.println("当前实例服务的host地址为"+instance.getHost());
System.out.println("当前实例服务的端口为"+instance.getPort());
System.out.println("当前实例服务的uri为"+instance.getUri());
String url = "http://"+instance.getHost()+":"+instance.getPort()+"/user/" + id;
return this.restTemplate.getForObject(url, User.class);
}
}
这样就解决了地址硬编码的问题，没有直接写入地址和端口
2.6 高可用的Eureka Server
Eureka Server即服务的注册中心，在刚才的案例中，我们只有一个EurekaServer，事实上EurekaServer也可以是一个集群，形成高可用的Eureka中心（一个EurekaServer出现故障还有其它的EurekaServer）。
服务同步
多个Eureka Server之间也会互相注册为服务，当服务提供者注册到Eureka Server集群中的某个节点时，该节点会把服务的信息同步给集群中的每个节点，从而实现数据同步。因此，无论客户端访问到Eureka Server集群中的任意一个节点，都可以获取到完整的服务列表信息。
动手搭建高可用的EurekaServer
所谓的高可用注册中心，其实就是把EurekaServer自己也作为一个服务进行注册，这样多个EurekaServer之间就能互相发现对方，从而形成集群。因此我们做了以下修改：
假设要搭建两条EurekaServer的集群，端口分别为：10086和10087
先开启端口号为10086的服务，把自己注册到10087的eureka服务中
server:
port: 10086 #当前服务端口
spring:
application:
name: eureka-server # 应用名称，会在Eureka中显示
eureka:
client:
service-url:
defaultZone: http://127.0.0.1:10087/eureka #因为此时没有10087的eureka服务，所以会正常报错
开启了10086端口的服务后，再拷贝当前设置或新建一个设置 启动类为当前项目的启动类，命名为EurekaApplication2
因为10086端口的服务已在启动状态，所以此时修改application.yml文件不影响已开启的10086服务
将当前服务的端口改为10087，并注册进10086的eureka，运行EurekaApplication2启动类，实现自己注册自己
server:
port: 10087 #当前服务端口
spring:
application:
name: eureka-server # 应用名称，会在Eureka中显示
eureka:
client:
service-url:
defaultZone: http://127.0.0.1:10086/eureka
访问http://localhost:10086/ 或者 http://localhost:10087/ 都可以查看eureka监控页面，实现数据同步
2.7 客户端注册服务到集群
因为EurekaServer不止一个，因此注册服务的时候，service-url参数需要变化：
eureka:
client:
service-url: # EurekaServer地址,多个地址以','隔开
defaultZone: http://127.0.0.1:10086/eureka,http://127.0.0.1:10087/eureka
2.8 Eureka详解
2.8.1 服务提供者
服务提供者要向EurekaServer注册服务，并且完成服务续约等工作。
服务注册
服务提供者在启动时，会检测配置属性中的：eureka.client.register-with-erueka=true参数是否正确，事实上默认就是true。如果值确实为true，则会向EurekaServer发起一个Rest请求，并携带自己的元数据信息，Eureka Server会把这些信息保存到一个双层Map结构中。第一层Map的Key就是服务名称，第二层Map的key是服务的实例id。
服务续约
在注册服务完成以后，服务提供者会维持一个心跳（定时向EurekaServer发起Rest请求），告诉EurekaServer：“我还活着”。这个我们称为服务的续约（renew）；
有两个重要参数可以修改服务续约的行为：
eureka:
instance:
lease-expiration-duration-in-seconds: 90
lease-renewal-interval-in-seconds: 30
- lease-renewal-interval-in-seconds：服务续约(renew)的间隔，默认为30秒
- lease-expiration-duration-in-seconds：服务失效时间，默认值90秒
也就是说，默认情况下每个30秒服务会向注册中心发送一次心跳，证明自己还活着。如果超过90秒没有发送心跳，EurekaServer就会认为该服务宕机，会从服务列表中移除，这两个值在生产环境不要修改，默认即可。
但是在开发时，这个值有点太长了，经常我们关掉一个服务，会发现Eureka依然认为服务在活着。所以我们在开发阶段可以适当调小。
eureka:
instance:
lease-expiration-duration-in-seconds: 10 # 10秒即过期
lease-renewal-interval-in-seconds: 5 # 5秒一次心跳
2.8.2 实例id
先来看一下服务状态信息：
在Eureka监控页面，查看服务注册信息：
在status一列中，显示以下信息：
- UP(1)：代表现在是启动了1个示例，没有集群
- localhost:user-service:8081：是示例的名称（instance-id），
- 默认格式是：
${hostname} + ${spring.application.name} + ${server.port} - instance-id是区分同一服务的不同实例的唯一标准，因此不能重复。
- 默认格式是：
我们可以通过instance-id属性来修改它的构成：
eureka:
instance:
instance-id: ${spring.application.name}:${server.port}
2.8.3 服务消费者
获取服务列表
当服务消费者启动时，会检测eureka.client.fetch-registry=true参数的值，如果为true，则会从Eureka Server服务的列表只读备份，然后缓存在本地。并且每隔30秒会重新获取并更新数据。我们可以通过下面的参数来修改：
eureka:
client:
registry-fetch-interval-seconds: 5
生产环境中，我们不需要修改这个值。
但是为了开发环境下，能够快速得到服务的最新状态，我们可以将其设置小一点。
2.8.4 失效剔除和自我保护
服务下线
当服务进行正常的关闭操作时，它会触发一个服务下线的REST请求给Eureka Server,告诉服务注册中心：“我要下线了”，服务中心接收到请求之后，将该服务置为下线状态
失效剔除
有些时候，我们的服务提供方并不一定会正常下线，可能因为内存溢出、网络故障等原因导致服务无法正常工作。Eureka Server需要将这样的服务剔除出服务列表。因此它会开启一个定时任务，每隔60秒对所有失效的服务（超过90秒未响应）进行剔除。
可以通过eureka.server.eviction-interval-timer-in-ms参数对其进行修改，单位是毫秒，生产环境不要修改。
这个会对我们开发带来极大的不变，你对服务重启，隔了60秒Eureka才反应过来。开发阶段可以适当调整，比如10S
自我保护
我们关停一个服务，就会在Eureka面板看到一条警告：
这是触发了Eureka的自我保护机制。当一个服务未按时进行心跳续约时，Eureka会统计最近15分钟心跳失败的服务实例的比例是否超过了85%。在生产环境下，因为网络延迟等原因，心跳失败实例的比例很有可能超标，但是此时就把服务剔除列表并不妥当，因为服务可能没有宕机。Eureka就会把当前实例的注册信息保护起来，不予剔除。生产环境下这很有效，保证了大多数服务依然可用。
但是这给我们的开发带来了麻烦， 因此开发阶段我们都会关闭自我保护模式：
eureka:
server:
enable-self-preservation: false # 关闭自我保护模式（默认为打开）
eviction-interval-timer-in-ms: 1000 # 扫描失效服务的间隔时间（默认为60*1000ms）
三. Ribbon负载均衡
实际环境中，我们往往会开启很多个user-service的集群。此时我们获取的服务列表中就会有多个，到底该访问哪一个呢？
一般这种情况下我们就需要编写负载均衡算法，在多个实例列表中进行选择。
不过Eureka中已经帮我们集成了负载均衡组件：Ribbon，简单修改代码即可使用。
什么是Ribbon：
3.1 启动两个服务实例
将UserServiceApplication的启动配置拷贝一个命名为UserServiceApplication2
因为UserServiceApplication已经在运行状态，所以此时修改UserServiceApplication的配置文件中的端口不影响已开启的服务;
将端口8081改为8083，并启动UserServiceApplication2；此时开启的服务提供者有8081和8083
3.2.开启负载均衡
因为Eureka中已经集成了Ribbon，所以我们无需引入新的依赖。直接修改代码：
在RestTemplate的配置方法上添加@LoadBalanced注解：
@Bean
@LoadBalanced
public RestTemplate restTemplate() {
return new RestTemplate(new OkHttp3ClientHttpRequestFactory());
}
3.3 测试负载均衡
修改调用方式user-consumer，不再手动获取服务的ip和端口，而是直接通过服务名称调用：
@Component
public class UserMapper {
@Autowired
private RestTemplate restTemplate;
public User queryUserById(Long id){
String url = "http://user-service/user/"+id;
return this.restTemplate.getForObject(url, User.class);
}
}
3.4 负载均衡策略
Ribbon默认的负载均衡策略是简单的轮询,就是当存在多个服务时，按顺序调用，我们可以测试一下：
拦截中是使用RibbonLoadBalanceClient来进行负载均衡的，其中有一个choose方法，所以编写一个测试类 :
@SpringBootTest
@RunWith(SpringRunner.class)
public class LoadBalanceTest {
@Autowired
RibbonLoadBalancerClient client;
@Test
public void test(){
for (int i = 0; i < 100; i++) {
ServiceInstance instance = this.client.choose("user-service");
System.out.println(instance.getUri());//打印查看调用的哪个服务
}
}
}
默认为轮询调用，运行结果:
SpringBoot也帮我们提供了修改负载均衡规则的配置入口：
user-service: #服务提供方的服务id
ribbon: #将负载均衡策略从默认的轮询改为随机
NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule
格式是：{服务名称}.ribbon.NFLoadBalancerRuleClassName，值就是IRule的实现类。
再次运行测试类，发现调用服务结果从轮询变成了随机：
3.5 重试机制
Eureka为了实现更高的服务可用性，牺牲了一定的一致性，极端情况下它宁愿接收故障实例也不愿丢掉健康实例，正如我们上面所说的自我保护机制。
但是，此时如果我们调用了这些不正常的服务，调用就会失败，从而导致其它服务不能正常工作！这显然不是我们愿意看到的。
现在先关闭一个user-service实例 8083，因为服务剔除的延迟，consumer并不会立即得到最新的服务列表，此时再次访问http://localhost:8082/consumer?ids=1,2,3 并刷新多次，会有几率得到错误提示，因为刚好调用的是8083的服务
但是此时，8081服务其实是正常的。
因此Spring Cloud 整合了Spring Retry 来增强RestTemplate的重试能力，当一次服务调用失败后，不会立即抛出一次，而是再次重试另一个服务。
只需要简单配置即可实现Ribbon的重试, 在user-consumer的配置文件中追加以下配置：
spring:
cloud:
loadbalancer:
retry:
enabled: true # 开启Spring Cloud的重试功能
user-service: #服务提供者id
ribbon:
ConnectTimeout: 250 # Ribbon的连接超时时间
ReadTimeout: 1000 # Ribbon的数据读取超时时间
OkToRetryOnAllOperations: true # 是否对所有操作都进行重试
MaxAutoRetriesNextServer: 10 # 切换实例的重试次数
MaxAutoRetries: 1 # 对当前实例的重试次数
根据如上配置，当访问到某个服务超时后，它会再次尝试访问下一个服务实例，如果不行就再换一个实例，如果切换后还不行，则返回失败。切换实例次数取决于MaxAutoRetriesNextServer参数的值
还需引入spring-retry依赖，支持重试机制
<dependency>
<groupId>org.springframework.retry</groupId>
<artifactId>spring-retry</artifactId>
</dependency>
重启user-consumer服务并重试 关闭8083服务，再次访问http://localhost:8082/consumer?ids=1,2,3 并刷新多次，发现没有错误提示信息了
四. Hystrix
Hystrix是Netflix开源的一个延迟和容错库，用于隔离访问远程服务、第三方库，防止出现级联失败。
4.1 雪崩问题
微服务中,服务间调用关系错宗复杂,一个请求可能需要调用多个微服务接口才能实现,会形成非常复杂的调用链路：
当调用链路中的其中一个服务出现异常，请求阻塞，用户得不到响应，则tomcat的这个线程不会被释放，于是越来愈多的用户请求到来，越来越多的线程被阻塞，服务器支持的线程和并发数有限,请求一直阻塞,会导致服务器资源耗尽,从而导致所有其它服务都不可用,形成雪崩效应。
Hystrix解决雪崩问题的手段有两个: 1.线程隔离 2. 服务熔断
Hystrix为每个依赖服务调用分配一个小的线程池,如果线程池已满调用将被立即拒绝,默认不采用排队加速失败判定时间；
用户的请求将不再直接访问服务,而是通过线程池中的空闲线程来访问服务,如果线程池已满,或者请求超时,则会进行降级处理,什么是服务降级?
服务降级: 优先保证核心服务,而非核心服务不可用或弱可用。
用户的请求故障时,不会被阻塞,更不会无休止的等待或者看到系统崩溃,至少可以看到一个执行结果(例如返回友好的提示信息)
服务降级虽然会导致请求失败,但是不会导致阻塞,而且最多会影响这个依赖服务对应的线程池中的资源,对其它服务没有响应。
4.2 服务降级,熔断
4.2.1 添加相关依赖
在user-consumer的pom.xml文件中引入以下依赖
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
</dependency>
4.2.2 在启动类上添加注解
在服务调用方启动类上添加注解
@EnableCircuitBreaker //开启熔断器
4.2.3 新增服务调用方的controller层方法
增加一个controller方法来测试hystrix
@RestController
@RequestMapping("hystrix")
public class hystrixController {
@Autowired
private RestTemplate restTemplate;
@GetMapping
@HystrixCommand(fallbackMethod = "queryUserFallback")
public String queryUser(@RequestParam("id") Long id) {
String url = "http://user-service/user/"+id;
return this.restTemplate.getForObject(url, String.class);
}
public String queryUserFallback(Long id){
return "服务器正忙，请稍后在试!";
}
}
-
通过@HystrixCommand注解的fallbackMethod参数来指定对应熔断方法
-
局部一对一熔断方法的返回值和参数要和被熔断方法一致
4.2.4 测试熔断
将开启的服务提供者全部关闭，这样就模拟了服务提供者不可用的情况下，触发服务调用方的熔断方法；
当我们再次访问控制层的hystrix测试方法时，因为服务提供者已不可用，所以提示自定义的熔断方法:
4.2.5 全局熔断方法
@RestController
@RequestMapping("hystrix")
@DefaultProperties(defaultFallback = "fallBackMethod")
public class hystrixController {
@Autowired
private RestTemplate restTemplate;
@GetMapping
@HystrixCommand
public String queryUser(@RequestParam("id") Long id) {
String url = "http://user-service/user/"+id;
return this.restTemplate.getForObject(url, String.class);
}
public String fallBackMethod(){
return "服务请求失败，请稍后重试!";
}
}
-
通过在控制层类上注解@DefaultProperties，defaultFallback的值指定全局熔断方法，这样就不用一个方法一个熔断类了，只需要在被熔断方法上加@HystrixCommand注解
-
全局熔断方法的返回值要和被熔断方法一致，但参数列表必须为空，因为被熔断方法可能参数不一样
-
定义了全局熔断方法后，也还可以在被熔断方法上注解 @HystrixCommand(fallbackMethod = "")
来制定其它熔断类
4.2.6 优化
因为Ribbon重试机制默认为1000ms触发,而Hystix默认也是1000ms触发，因此重试机制没有被触发，而是先触发了熔断;
当存在部分服务提供者不可用时，访问到不可用服务，重试机制没有被触发就被熔断了，这是我们不希望看到的；
所以，Ribbon的超时时间一定要小于Hystix的超时时间，这样当访问到不可用服务时先触发重试机制，当重试后还是服务错误就触发熔断。
我们可以通过hystrix.command.default.execution.isolation.thread.timeoutInMilliseconds来设置Hystrix超时时间。
hystrix:
command:
default:
execution:
isolation:
thread:
timeoutInMilliseconds: 6000 # 设置hystrix的熔断触发时间为6000ms
线上环境因为多台服务之间相互调用会存在网络延迟，并不是服务不可用，所以会把hystrix熔断触发时间调大一点，这样就不会在正常网络延迟情况下触发熔断
为了测试熔断触发时间，需要在服务提供方方法内加入Thread.sleep( );线程等待，防止服务提供方方法运行完毕后时间未到触发熔断而直接返回熔断,如已开启Ribbon重试机制需先关闭；
如熔断触发时间设置为6秒，我们可以在服务提供方方法内线程等待15秒，然后运行服务提供方服务，这样服务提供方方法未运行完毕而触发熔断,f12查看熔断响应时间刚好为设置的时间6000ms；
除此之外: 还能优化服务调用方user-consumer的启动类注解
//@SpringBootApplication
//@EnableDiscoveryClient
//@EnableCircuitBreaker
@SpringCloudApplication //相当于以上3个注解
public class UserConsumerApplication {
public static void main(String[] args) {
SpringApplication.run(UserConsumerApplication.class, args);
}
@Bean
@LoadBalanced
public RestTemplate restTemplate(){
return new RestTemplate();
}
}
4.2.7 熔断请求优化
以上案例中虽然访问到不可用服务时会触发熔断，但每次访问失败都会发送请求；
熔断状态机的3个状态:
- Closed: 关闭状态,所有请求都正常访问。.
- Open: 打开状态,所有请求都会被降级。Hystix会对请求情况计数,当一定时间内失败请求百分比达到阈值,则触发熔断,断路器会完全打开。默认失败比例的阈值是50%,请求次数最少不低于20次。.
- Half Open: 半开状态, open状态不是永久的,打开后会进入休眠时间(默认是55) 。随后断路器会自动进入半开状态。此时会释放部分请求通过,若这些请求都是健康的,则会完全关闭断路器,否则继续保持打开,再次进行休眠计时
模拟失败请求百分比达到阈值，修改user-consumer的controller方法，再去掉前面在user-service中加的Thread.sleep( );和将熔断触发时间改小：
@RestController
@RequestMapping("hystrix")
@DefaultProperties(defaultFallback = "fallBackMethod")
public class hystrixController {
@Autowired
private RestTemplate restTemplate;
@GetMapping
@HystrixCommand
public String queryUser(@RequestParam("id") Long id) throws InterruptedException {
if(id == 1){
throw new RuntimeException();//模拟失败请求百分比达到阈值
}
String url = "http://user-service/user/"+id;
return this.restTemplate.getForObject(url, String.class);
}
public String fallBackMethod(){
return "服务请求失败，请稍后重试!";
}
}
重启服务提供方和服务调用方，连续访问http://localhost:8082/hystrix?id=1 20次以上，模拟失败请求百分比达到阈值，再访问http://localhost:8082/hystrix?id=2，发现此时id=2也被熔断了，再连续刷新id=2的请求，发现过一段时间后id=2又能正常访问，这就是熔断状态机的Half Open: 半开状态。
默认的熔断触发要求较高，休眠时间较短，为了测试方便，可以通过配置修改熔断策略:
circuitBreaker.requestVolumeThreshold=10
circuitBreaker.sleepwindowInMilliseconds=10000
circuitBreaker.errorThresholdPercentage=50
requestVolumeThreshold: 触发熔断的最小请求次数,默认20
sleepwindowInMilliseconds: 休眠时长,默认是5000毫秒
errorThresholdPercentage: 触发熔断的失败请求最小占比,默认50%
五. feign
Feign可以把Rest的请求进行隐藏，伪装成类似SpringMVC的Controller一样。你不用再自己拼接url，拼接参数等等操作，一切都交给Feign去做。
5.1 引入依赖
在服务调用者的pom.xml文件中引入依赖
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>
5.2 在调用者启动类上添加注解
@SpringCloudApplication
@EnableFeignClients //开启Feign功能
public class UserConsumerApplication {
public static void main(String[] args) {
SpringApplication.run(UserConsumerApplication.class, args);
}
//因为开启了feign后不再需要RestTemplate,所以可以去掉
/* @Bean
@LoadBalanced
public RestTemplate restTemplate(){
return new RestTemplate();
}*/
}
5.3 新建Feign的客户端接口
@FeignClient("user-service") //指定调用的服务提供方的微服务id
public interface UserClient {
@GetMapping("user/{id}")
public User queryById(@PathVariable("id") long id);//需要调用的方法
}
- 首先这是一个接口，Feign会通过动态代理，帮我们生成实现类。这点跟mybatis的mapper很像
@FeignClient，声明这是一个Feign客户端，类似@Mapper注解。同时通过value属性指定服务名称- 接口中的定义方法，完全采用SpringMVC的注解，Feign会根据注解帮我们生成URL，并访问获取结果
5.4 新建一个服务调用方的控制层方法
@RestController
@RequestMapping("feign")
public class feignController {
@Autowired
private UserClient userClient;
@GetMapping
@HystrixCommand
public String queryUser(@RequestParam("id") Long id){
return this.userClient.queryById(id).toString();//通过feign客户端调用远程服务
}
}
5.5 测试feign
重启user-consumer访问http://localhost:8082/feign?id=2 ，能正常访问
5.6 feign集成Ribbon和hystrix
feign的依赖包中已经集成了Ribbon和hystrix,可以直接使用;
可以通过ribbon.xx来进行全局配置。也可以通过服务名.ribbon.xx来对指定服务配置
虽然feign集成了hystrix,但是默认是关闭的,可以通过配置开启：
feign:
hystrix:
enabled: true # 开启Feign的熔断功能
在feign中使用hystrix的熔断方法:
（1）需要先创建一个熔断类去实现feign的客户端接口:
@Component //将熔断类注入spring容器
public class UserClientFallback implements UserClient{
@Override
public User queryById(long id) {
User user=new User();
user.setUserName("服务器正忙，请稍后重试");
return user;
}
}
（2）再去客户端接口中指定该熔断类:
通过fallback来指定熔断类
@FeignClient(value = "user-service",fallback = UserClientFallback.class)
public interface UserClient {
@GetMapping("user/{id}")
public User queryById(@PathVariable("id") long id);//需要调用的方法
}
将服务提供方全部关闭并将hystrix的熔断触发时间调小，重启user-consumer访问http://localhost:8082/feign?id=2 可正常触发熔断
六.Zuul网关
不管是来自于客户端（PC或移动端）的请求，还是服务内部调用。一切对服务的请求都会经过Zuul这个网关，然后再由网关来实现 鉴权、动态路由等等操作。Zuul就是我们服务的统一入口。
6.1新建Zuul模块
在项目中新建一个Spring Initializr模块，命名为zuul,并引入Spring Cloud Routing中的Zuul依赖；
点击下一步完成新建zuul模块；
6.2 相关依赖
因为在新建模块时已经引入zuul依赖，所以无需再引入
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://http://cdn.xiongsihao.com.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.0.6.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.xsh.demo</groupId>
<artifactId>zuul</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>zuul</name>
<description>Demo project for Spring Boot</description>
<properties>
<java.version>1.8</java.version>
<spring-cloud.version>Finchley.SR2</spring-cloud.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-zuul</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>${spring-cloud.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
<repositories>
<repository>
<id>spring-milestones</id>
<name>Spring Milestones</name>
<url>https://repo.spring.io/milestone</url>
</repository>
</repositories>
</project>
6.3 修改默认配置,编写路由规则
server:
port: 10010 #服务端口
spring:
application:
name: Zuul #服务名
zuul:
routes:
user-service: #路由名称，可以随便写，习惯上写路由到哪个服务就写哪个的服务名称
path: /user-service/** #将/user-service/**开头的请求路由到http://localhost:8081
url: http://localhost:8081
6.4 在启动类上添加注解
@EnableZuulProxy //启用Zuul组件
6.5 测试路由
开启zuul模块启动类，访问 http://localhost:10010/user-service/user/1
可以通过user-service路由到http://localhost:8081
6.6 面向服务的路由
在刚才的路由规则中，我们把路径对应的服务地址写死了,user-service固定为http://localhost:8081！如果同一服务有多个实例的话，这样做显然就不合理了。
我们应该根据服务的名称，去Eureka注册中心查找 服务对应的所有实例列表，然后进行动态路由才对！
6.6.1 Zuul集成Eureka
-
在zuul模块内添加Eureka客户端依赖
<dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId> </dependency> -
添加Eureka配置(将当前zuul服务注入到eureka)
eureka: client: service-url: defaultZone: http://localhost:10086/eureka -
修改路由规则
zuul: routes: user-service: #路由名称，可以随便写，习惯上写路由到哪个服务就写哪个的服务名称 path: /user-service/** #将/user-service/**开头的请求路由到http://localhost:8081 #url: http://localhost:8081 serviceId: user-service将url改为serviceId实现动态路由
-
在zuul启动类上添加注解开启Eureka
@EnableDiscoveryClient //开启Eureka客户端发现功能
6.6.2 Zuul的四种路由
-
通过路径访问固定路由
zuul: routes: user-service: #路由名称，可以随便写，习惯上写路由到哪个服务就写哪个的服务名称 path: /user-service/** #将/user-service/**开头的请求路由到http://localhost:8081 url: http://localhost:8081 -
通过服务id访问动态路由
zuul: routes: user-service: #路由名称，可以随便写，习惯上写路由到哪个服务就写哪个的服务名称 path: /user-service/** #将/user-service/**开头的请求路由到http://localhost:8081 serviceId: user-service -
当路由名称和服务id名称一致时(路由名称可定义多个)
zuul: routes: user-service: /user-service/** #将/user-service/**开头的请求路由到服务id为user-service的服务 -
不配置zuul路由(默认的路由规则)
如果不配置zuul路由,默认情况下，一切服务的映射路径就是服务名本身
例如不配置zuul也可以通过http://localhost:10010/user-service/user/1正常访问,因为请求路径为/user-service/**,则默认路由到user-service
6.6.3 路由前缀
虽然不配置路由默认为映射路径就是服务名本身，但是一般还是选择使用第三种配置路由方法,可以使用路由前缀方便管理,分辨出哪些服务经过了路由
zuul:
prefix: /api # 添加路由前缀
routes:
user-service: /user-service/**
6.7 Zuul过滤器
Zuul作为网关的其中一个重要功能，就是实现请求的鉴权。而这个动作我们往往是通过Zuul提供的过滤器来实现的。
6.7.1.ZuulFilter
ZuulFilter是过滤器的顶级父类。在这里我们看一下其中定义的4个最重要的方法：
public abstract ZuulFilter implements IZuulFilter{
abstract public String filterType();
abstract public int filterOrder();
boolean shouldFilter();// 来自IZuulFilter
Object run() throws ZuulException;// IZuulFilter
}
shouldFilter：返回一个Boolean值，判断该过滤器是否需要执行。返回true执行，返回false不执行。run：过滤器的具体业务逻辑。filterType：返回字符串，代表过滤器的类型。包含以下4种：pre：请求在被路由之前执行routing：在路由请求时调用post：在routing和errror过滤器之后调用error：处理请求时发生错误调用
filterOrder：通过返回的int值来定义过滤器的执行顺序，数字越小优先级越高。
6.7.2 过滤器执行生命周期
- 正常流程：
- 请求到达首先会经过pre类型过滤器，而后到达routing类型，进行路由，请求就到达真正的服务提供者，执行请求，返回结果后，会到达post过滤器。而后返回响应。
- 异常流程：
- 整个过程中，pre或者routing过滤器出现异常，都会直接进入error过滤器，再error处理完毕后，会将请求交给POST过滤器，最后返回给用户。
- 如果是error过滤器自己出现异常，最终也会进入POST过滤器，而后返回。
- 如果是POST过滤器出现异常，会跳转到error过滤器，但是与pre和routing不同的时，请求不会再到达POST过滤器了。
6.7.3 使用场景
场景非常多：
- 请求鉴权：一般放在pre类型，如果发现没有访问权限，直接就拦截了
- 异常处理：一般会在error类型和post类型过滤器中结合来处理。
- 服务调用时长统计：pre和post结合使用。
6.7.4 自定义过滤器类
模拟一个登录的校验。基本逻辑：如果请求中有access-token参数，则认为请求有效，放行。
@Component
public class LoginFilter extends ZuulFilter {
/*返回字符串，代表过滤器的类型*/
@Override
public String filterType() {
// 登录校验，肯定是在前置拦截
return "pre";
}
/*执行顺序，返回值越小优先级越高*/
@Override
public int filterOrder() {
return 1;
}
/*是否执行该过滤器*/
@Override
public boolean shouldFilter() {
return true;
}
/*编写过滤器的业务逻辑*/
@Override
public Object run() throws ZuulException {
// 登录校验逻辑。
// 1）获取Zuul提供的请求上下文对象
RequestContext context = RequestContext.getCurrentContext();
// 2) 从上下文中获取request对象
HttpServletRequest request = context.getRequest();
// 3) 从请求中获取access-token
String token = request.getParameter("access-token");
// 4) 判断,通过StringUtils的isBlank方法判断token是否为空，如果为空返回true
if(StringUtils.isBlank(token)){
// 没有token，登录校验失败，拦截;setSendZuulResponse设置是否转发请求，因为要拦截所以设置为false
context.setSendZuulResponse(false);
// 因为浏览器只识别状态码，所以设置一个状态码；返回401状态码。也可以考虑重定向到登录页。
context.setResponseStatusCode(HttpStatus.UNAUTHORIZED.value());
//设置响应内容
context.setResponseBody("request error!");
}
// 校验通过，可以考虑把用户信息放入上下文，继续向后执行
return null; /*返回值为null，就代表该过滤器什么都不做*/
}
}
6.4.5 测试自定义过滤器
重启zuul启动类,
访问http://localhost:10010/api/user-service/user/1?access-token=XXX，可正常访问
访问http://localhost:10010/api/user-service/user/1，因为请求中没有access-token参数，所以拦截器拦截，不能正常访问
6.8 zuul集成负载均衡和熔断
Zuul中默认就已经集成了Ribbon负载均衡和Hystix熔断机制。但是所有的超时策略都是走的默认值，比如熔断超时时间只有1S，很容易就触发了。因此建议我们手动进行配置：
zuul:
retryable: true
ribbon:
ConnectTimeout: 250 # 连接超时时间(ms)
ReadTimeout: 2000 # 通信超时时间(ms)
OkToRetryOnAllOperations: true # 是否对所有操作重试
MaxAutoRetriesNextServer: 2 # 同一服务不同实例的重试次数
MaxAutoRetries: 1 # 同一实例的重试次数
hystrix:
command:
default:
execution:
isolation:
thread:
timeoutInMillisecond: 6000 # 熔断超时时长：6000ms
springCloud
评论