RPC,即 Remote Procedure Call(远程过程调用),是一个计算机通信协议。 该协议允许运行于一台计算机的程序调用另一台计算机的子程序,而程序员无需额外地为这个交互作用编程。
Http协议:超文本传输协议,是一种应用层协议。
Spring提供了一个RestTemplate模板工具类,对基于Http的客户端进行了封装,并且实现了对象与json的序列化和反序列化,非常方便。RestTemplate并没有限定Http的客户端类型,而是进行了抽象,目前常用的3种都有支持:
首先在项目中注册一个 RestTemplate
对象,可以在启动类位置注册:
@SpringBootApplication public class HttpDemoApplication { public static void main(String[] args) { SpringApplication.run(HttpDemoApplication.class, args); } @Bean public RestTemplate restTemplate() { // 默认的RestTemplate,底层是走JDK的URLConnection方式。 return new RestTemplate(); } } 复制代码
在测试类中直接 @Autowired
注入:
@RunWith(SpringRunner.class) @SpringBootTest(classes = HttpDemoApplication.class) public class HttpDemoApplicationTests { @Autowired private RestTemplate restTemplate; @Test public void httpGet() { User user = this.restTemplate.getForObject("http://localhost/hello", User.class); System.out.println(user); } } 复制代码
接下来正式介绍微服务。
SpringCloud是Spring旗下的项目之一, 官网地址:http://projects.spring.io/spring-cloud/
SpringCloud将现在非常流行的一些技术整合到一起,实现了诸如:配置管理,服务发现,智能路由,负载均衡,熔断器,控制总线,集群状态等等功能。其主要涉及的组件包括:
netflix
接下来,我们就一一学习SpringCloud中的重要组件。
首先,我们需要模拟一个服务调用的场景。方便后面学习微服务架构
我们新建一个项目,对外提供查询用户的服务。
依赖也已经全部自动引入:
<?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>com.leyou.demo</groupId> <artifactId>user-service-demo</artifactId> <version>0.0.1-SNAPSHOT</version> <packaging>jar</packaging> <name>user-service-demo</name> <description>Demo project for Spring Boot</description> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.0.1.RELEASE</version> <relativePath/> <!-- lookup parent from repository --> </parent> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding> <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>1.3.2</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,所以我们需要手动加一条依赖:
<dependency> <groupId>tk.mybatis</groupId> <artifactId>mapper-spring-boot-starter</artifactId> <version>2.0.2</version> </dependency> 复制代码
非常快捷啊!
添加一个对外查询的接口:
@RestController @RequestMapping("user") public class UserController { @Autowired private UserService userService; @GetMapping("/{id}") public User queryById(@PathVariable("id") Long id) { return this.userService.queryById(id); } } 复制代码
Service:
@Service public class UserService { @Autowired private UserMapper userMapper; public User queryById(Long id) { return this.userMapper.selectByPrimaryKey(id); } } 复制代码
mapper:
@Mapper public interface UserMapper extends tk.mybatis.mapper.common.Mapper<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 } 复制代码
属性文件,这里我们采用了yaml语法,而不是properties:
server: port: 8081 spring: datasource: url: jdbc:mysql://localhost:3306/mydb01 username: root password: 123 hikari: maximum-pool-size: 20 minimum-idle: 10 mybatis: type-aliases-package: com.leyou.userservice.pojo 复制代码
与上面类似,需要注意的是,我们调用user-service的功能,因此不需要mybatis相关依赖了。
pom:
<?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>com.leyou.demo</groupId> <artifactId>user-consumer-demo</artifactId> <version>0.0.1-SNAPSHOT</version> <packaging>jar</packaging> <name>user-consumer-demo</name> <description>Demo project for Spring Boot</description> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.0.1.RELEASE</version> <relativePath/> <!-- lookup parent from repository --> </parent> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding> <java.version>1.8</java.version> </properties> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <!-- 添加OkHttp支持 --> <dependency> <groupId>com.squareup.okhttp3</groupId> <artifactId>okhttp</artifactId> <version>3.9.0</version> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build> </project> 复制代码
首先在启动类中注册 RestTemplate
:
@SpringBootApplication public class UserConsumerDemoApplication { @Bean public RestTemplate restTemplate() { // 这次我们使用了OkHttp客户端,只需要注入工厂即可 return new RestTemplate(new OkHttp3ClientHttpRequestFactory()); } public static void main(String[] args) { SpringApplication.run(UserConsumerDemoApplication.class, args); } } 复制代码
通过RestTemplate远程查询user-service-demo中的接口:
@Component public class UserDao { @Autowired private RestTemplate restTemplate; public User queryUserById(Long id){ String url = "http://localhost:8081/user/" + id; return this.restTemplate.getForObject(url, User.class); } } 复制代码
然后编写user-service,循环查询UserDAO信息:
@Service public class UserService { @Autowired private UserDao userDao; public List<User> querUserByIds(List<Long> ids){ List<User> users = new ArrayList<>(); for (Long id : ids) { User user = this.userDao.queryUserById(id); users.add(user); } return users; } } 复制代码
编写controller:
@RestController @RequestMapping("consume") public class ConsumerController { @Autowired private UserService userService; @GetMapping public List<User> consume(@RequestParam("ids") List<Long> ids) { return this.userService.queryUserByIds(ids); } } 复制代码
其实上面说的问题,概括一下就是分布式服务必然要面临的问题:
以上的问题,我们都将在SpringCloud中得到答案。
基本架构:
接下来我们创建一个项目,启动一个EurekaServer:
依然使用spring提供的快速搭建工具,选择依赖:
完整的Pom文件:
<?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>com.leyou.demo</groupId> <artifactId>eureka-demo</artifactId> <version>0.0.1-SNAPSHOT</version> <packaging>jar</packaging> <name>eureka-demo</name> <description>Demo project for Spring Boot</description> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.0.1.RELEASE</version> <relativePath/> <!-- lookup parent from repository --> </parent> <properties> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding> <java.version>1.8</java.version> <!-- SpringCloud版本,是最新的F系列 --> <spring-cloud.version>Finchley.RC1</spring-cloud.version> </properties> <dependencies> <!-- Eureka服务端 --> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId> </dependency> </dependencies> <dependencyManagement> <dependencies> <!-- SpringCloud依赖,一定要放到dependencyManagement中,起到管理版本的作用即可 --> <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> <snapshots> <enabled>false</enabled> </snapshots> </repository> </repositories> </project> 复制代码
编写启动类:
@SpringBootApplication @EnableEurekaServer // 声明这个应用是一个EurekaServer public class EurekaDemoApplication { public static void main(String[] args) { SpringApplication.run(EurekaDemoApplication.class, args); } } 复制代码
编写配置:
server: port: 10086 # 端口 spring: application: name: eureka-server # 应用名称,会在Eureka中显示 eureka: client: register-with-eureka: false # 是否注册自己的信息到EurekaServer,默认是true fetch-registry: false # 是否拉取其它服务的信息,默认是true service-url: # EurekaServer的地址,现在是自己的地址,如果是集群,需要加上其它Server的地址。 defaultZone: http://127.0.0.1:${server.port}/eureka 复制代码
启动服务,并访问: http://127.0.0.1:10086/eureka
注册服务,就是在服务上添加Eureka的客户端依赖,客户端代码会自动把服务注册到EurekaServer中。
我们在user-service-demo中添加Eureka客户端依赖:
先添加SpringCloud依赖:
<!-- SpringCloud的依赖 --> <dependencyManagement> <dependencies> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-dependencies</artifactId> <version>Finchley.RC1</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> 复制代码
在启动类上开启Eureka客户端功能
通过添加 @EnableDiscoveryClient
来开启Eureka客户端功能
@SpringBootApplication @EnableDiscoveryClient // 开启EurekaClient功能 public class UserServiceDemoApplication { public static void main(String[] args) { SpringApplication.run(UserServiceDemoApplication.class, args); } } 复制代码
编写配置
server: port: 8081 spring: datasource: url: jdbc:mysql://localhost:3306/mydb01 username: root password: 123 hikari: maximum-pool-size: 20 minimum-idle: 10 application: name: user-service # 应用名称 mybatis: type-aliases-package: com.leyou.userservice.pojo eureka: client: service-url: # EurekaServer地址 defaultZone: http://127.0.0.1:10086/eureka instance: prefer-ip-address: true # 当调用getHostname获取实例的hostname时,返回ip而不是host名称 ip-address: 127.0.0.1 # 指定自己的ip信息,不指定的话会自己寻找 复制代码
注意:
重启项目,访问Eureka监控页面http://127.0.0.1:10086/eureka查看
我们发现user-service服务已经注册成功了
接下来我们修改consumer-demo,尝试从EurekaServer获取服务。
方法与消费者类似,只需要在项目中添加EurekaClient依赖,就可以通过服务名称来获取信息了!
1)添加依赖:
先添加SpringCloud依赖:
<!-- SpringCloud的依赖 --> <dependencyManagement> <dependencies> <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-dependencies</artifactId> <version>Finchley.RC1</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)在启动类开启Eureka客户端
@SpringBootApplication @EnableDiscoveryClient // 开启Eureka客户端 public class UserConsumerDemoApplication { @Bean public RestTemplate restTemplate() { return new RestTemplate(new OkHttp3ClientHttpRequestFactory()); } public static void main(String[] args) { SpringApplication.run(UserConsumerDemoApplication.class, args); } } 复制代码
3)修改配置:
server: port: 8080 spring: application: name: consumer # 应用名称 eureka: client: service-url: # EurekaServer地址 defaultZone: http://127.0.0.1:10086/eureka instance: prefer-ip-address: true # 当其它服务获取地址时提供ip而不是hostname ip-address: 127.0.0.1 # 指定自己的ip信息,不指定的话会自己寻找 复制代码
4)修改代码,用DiscoveryClient类的方法,根据服务名称,获取服务实例:
@Service public class UserService { @Autowired private RestTemplate restTemplate; @Autowired private DiscoveryClient discoveryClient;// Eureka客户端,可以获取到服务实例信息 public List<User> queryUserByIds(List<Long> ids) { List<User> users = new ArrayList<>(); // String baseUrl = "http://localhost:8081/user/"; // 根据服务名称,获取服务实例 List<ServiceInstance> instances = discoveryClient.getInstances("user-service"); // 因为只有一个UserService,因此我们直接get(0)获取 ServiceInstance instance = instances.get(0); // 获取ip和端口信息 String baseUrl = "http://"+instance.getHost() + ":" + instance.getPort()+"/user/"; ids.forEach(id -> { // 我们测试多次查询, users.add(this.restTemplate.getForObject(baseUrl + id, User.class)); // 每次间隔500毫秒 try { Thread.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); } }); return users; } } 复制代码
Eureka Server即服务的注册中心,在刚才的案例中,我们只有一个EurekaServer,事实上EurekaServer也可以是一个集群,形成高可用的Eureka中心。
动手搭建高可用的EurekaServer
我们假设要搭建两条EurekaServer的集群,端口分别为:10086和10087
1)我们修改原来的EurekaServer配置:
server: port: 10086 # 端口 spring: application: name: eureka-server # 应用名称,会在Eureka中显示 eureka: client: service-url: # 配置其他Eureka服务的地址,而不是自己,比如10087 defaultZone: http://127.0.0.1:10087/eureka 复制代码
所谓的高可用注册中心,其实就是把EurekaServer自己也作为一个服务进行注册,这样多个EurekaServer之间就能互相发现对方,从而形成集群。因此我们做了以下修改:
2)另外一台配置恰好相反:
server: port: 10087 # 端口 spring: application: name: eureka-server # 应用名称,会在Eureka中显示 eureka: client: service-url: # 配置其他Eureka服务的地址,而不是自己,比如10087 defaultZone: http://127.0.0.1:10086/eureka 复制代码
注意:idea中一个应用不能启动两次,我们需要重新配置一个启动器:
然后启动即可。
3)启动测试:
4)客户端注册服务到集群
因为EurekaServer不止一个,因此注册服务的时候,service-url参数需要变化:
eureka: client: service-url: # EurekaServer地址,多个地址以','隔开 defaultZone: http://127.0.0.1:10086/eureka,http://127.0.0.1:10087/eureka 复制代码
服务提供者要向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 复制代码
也就是说,默认情况下每个30秒服务会向注册中心发送一次心跳,证明自己还活着。如果超过90秒没有发送心跳,EurekaServer就会认为该服务宕机,会从服务列表中移除,这两个值在生产环境不要修改,默认即可。
但是在开发时,这个值有点太长了,经常我们关掉一个服务,会发现Eureka依然认为服务在活着。所以我们在开发阶段可以适当调小。
eureka: instance: lease-expiration-duration-in-seconds: 10 # 10秒即过期 lease-renewal-interval-in-seconds: 5 # 5秒一次心跳 复制代码
实例id
先来看一下服务状态信息:
在Eureka监控页面,查看服务注册信息:
在status一列中,显示以下信息:
${hostname} + ${spring.application.name} + ${server.port}
我们可以通过instance-id属性来修改它的构成:
eureka: instance: instance-id: ${spring.application.name}:${server.port} 复制代码
重启服务再试试看:
获取服务列表
当服务消费者启动时会检测 eureka.client.fetch-registry=true
参数的值,如果为true,则会从Eureka Server服务的列表只读备份,然后缓存在本地。并且 每隔30秒
会重新获取并更新数据。我们可以通过下面的参数来修改:
eureka: client: registry-fetch-interval-seconds: 5 复制代码
生产环境中,我们不需要修改这个值。
但是为了开发环境下,能够快速得到服务的最新状态,我们可以将其设置小一点。
失效剔除
有些时候,我们的服务提供方并不一定会正常下线,可能因为内存溢出、网络故障等原因导致服务无法正常工作。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) 复制代码
在刚才的案例中,我们启动了一个user-service,然后通过DiscoveryClient来获取服务实例信息,然后获取ip和端口来访问。
但是实际环境中,我们往往会开启很多个user-service的集群。此时我们获取的服务列表中就会有多个,到底该访问哪一个呢?
一般这种情况下我们就需要编写负载均衡算法,在多个实例列表中进行选择。
接下来,我们就来使用Ribbon实现负载均衡。
首先我们启动两个user-service实例,一个8081,一个8082。
Eureka监控面板:
因为Eureka中已经集成了Ribbon,所以我们无需引入新的依赖。直接修改代码:
在RestTemplate的配置方法上添加 @LoadBalanced
注解:
@Bean @LoadBalanced public RestTemplate restTemplate() { return new RestTemplate(new OkHttp3ClientHttpRequestFactory()); } 复制代码
修改调用方式,不再手动获取ip和端口,而是直接通过服务名称调用:
@Service public class UserService { @Autowired private RestTemplate restTemplate; @Autowired private DiscoveryClient discoveryClient; public List<User> queryUserByIds(List<Long> ids) { List<User> users = new ArrayList<>(); // 地址直接写服务名称即可 String baseUrl = "http://user-service/user/"; ids.forEach(id -> { // 我们测试多次查询, users.add(this.restTemplate.getForObject(baseUrl + id, User.class)); // 每次间隔500毫秒 try { Thread.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); } }); return users; } } 复制代码
Ribbon默认的负载均衡策略是简单的轮询,我们可以测试一下:
@RunWith(SpringRunner.class) @SpringBootTest(classes = UserConsumerDemoApplication.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.getHost() + ":" + instance.getPort()); } } } 复制代码
结果:
符合了我们的预期推测,确实是轮询方式。
SpringBoot也帮我们提供了修改负载均衡规则的配置入口:
user-service: ribbon: NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule 复制代码
格式是: {服务名称}.ribbon.NFLoadBalancerRuleClassName
Eureka的服务治理强调了CAP原则中的AP,即可用性和可靠性。它与Zookeeper这一类强调CP(一致性,可靠性)的服务治理框架最大的区别在于:Eureka为了实现更高的服务可用性,牺牲了一定的一致性,极端情况下它宁愿接收故障实例也不愿丢掉健康实例,正如我们上面所说的自我保护机制。
但是,此时如果我们调用了这些不正常的服务,调用就会失败,从而导致其它服务不能正常工作!这显然不是我们愿意看到的。
我们现在关闭一个user-service实例:
因为服务剔除的延迟,consumer并不会立即得到最新的服务列表,此时再次访问你会得到错误提示:
但是此时,8081服务其实是正常的。
因此Spring Cloud 整合了Spring Retry 来增强RestTemplate的重试能力,当一次服务调用失败后,不会立即抛出一次,而是再次重试另一个服务。
只需要简单配置即可实现Ribbon的重试:
spring: cloud: loadbalancer: retry: enabled: true # 开启Spring Cloud的重试功能 user-service: ribbon: ConnectTimeout: 250 # Ribbon的连接超时时间 ReadTimeout: 1000 # Ribbon的数据读取超时时间 OkToRetryOnAllOperations: true # 是否对所有操作都进行重试 MaxAutoRetriesNextServer: 1 # 切换实例的重试次数 MaxAutoRetries: 1 # 对当前实例的重试次数 复制代码
根据如上配置,当访问到某个服务超时后,它会再次尝试访问下一个服务实例,如果不行就再换一个实例,如果不行,则返回失败。切换次数取决于 MaxAutoRetriesNextServer
参数的值
引入spring-retry依赖
<dependency> <groupId>org.springframework.retry</groupId> <artifactId>spring-retry</artifactId> </dependency> 复制代码
我们重启user-consumer-demo,测试,发现即使user-service2宕机,也能通过另一台服务实例获取到结果!
Hystix是Netflix开源的一个延迟和容错库,用于隔离访问远程服务、第三方库,防止出现级联失败。
正常工作的情况下,客户端请求调用服务API接口:
当有服务出现异常时,直接进行失败回滚,服务降级处理:
当服务繁忙时,如果服务出现异常,不是粗暴的直接报错,而是返回一个友好的提示,虽然拒绝了用户的访问,但是会返回一个结果。
首先在user-consumer中引入Hystix依赖:
<dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-netflix-hystrix</artifactId> </dependency> 复制代码
我们改造user-consumer,添加一个用来访问的user服务的DAO,并且声明一个失败时的回滚处理函数:
@Component public class UserDao { @Autowired private RestTemplate restTemplate; private static final Logger logger = LoggerFactory.getLogger(UserDao.class); @HystrixCommand(fallbackMethod = "queryUserByIdFallback") public User queryUserById(Long id){ long begin = System.currentTimeMillis(); String url = "http://user-service/user/" + id; User user = this.restTemplate.getForObject(url, User.class); long end = System.currentTimeMillis(); // 记录访问用时: logger.info("访问用时:{}", end - begin); return user; } public User queryUserByIdFallback(Long id){ User user = new User(); user.setId(id); user.setName("用户信息查询出现异常!"); return user; } } 复制代码
@HystrixCommand(fallbackMethod="queryUserByIdFallback")
在原来的业务逻辑中调用这个DAO:
@Service public class UserService { @Autowired private UserDao userDao; public List<User> queryUserByIds(List<Long> ids) { List<User> users = new ArrayList<>(); ids.forEach(id -> { // 我们测试多次查询, users.add(this.userDao.queryUserById(id)); }); return users; } } 复制代码
改造服务提供者,随机休眠一段时间,以触发熔断:
@Service public class UserService { @Autowired private UserMapper userMapper; public User queryById(Long id) throws InterruptedException { // 为了演示超时现象,我们在这里然线程休眠,时间随机 0~2000毫秒 Thread.sleep(new Random().nextInt(2000)); return this.userMapper.selectByPrimaryKey(id); } } 复制代码
然后运行并查看日志:
id为9、10、11的访问时间分别是:
id为12的访问时间:
因此,只有12是正常访问,其它都会触发熔断,我们来查看结果:
虽然熔断实现了,但是我们的重试机制似乎没有生效,是这样吗?
其实这里是因为我们的Ribbon超时时间设置的是1000ms:
而Hystix的超时时间默认也是1000ms,因此重试机制没有被触发,而是先触发了熔断。
所以,Ribbon的超时时间一定要小于Hystix的超时时间。
我们可以通过 hystrix.command.default.execution.isolation.thread.timeoutInMilliseconds
来设置Hystrix超时时间。
hystrix: command: default: execution: isolation: thread: timeoutInMillisecond: 6000 # 设置hystrix的超时时间为6000ms 复制代码
Feign可以把Rest的请求进行隐藏,伪装成类似SpringMVC的Controller一样。你不用再自己拼接url,拼接参数等等操作,一切都交给Feign去做。
<dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-openfeign</artifactId> </dependency> 复制代码
@FeignClient("user-service") public interface UserFeignClient { @GetMapping("/user/{id}") User queryUserById(@PathVariable("id") Long id); } 复制代码
@FeignClient
,声明这是一个Feign客户端,类似 @Mapper
注解。同时通过 value
属性指定服务名称 改造原来的调用逻辑,不再调用UserDao:
@Service public class UserService { @Autowired private UserFeignClient userFeignClient; public List<User> queryUserByIds(List<Long> ids) { List<User> users = new ArrayList<>(); ids.forEach(id -> { // 我们测试多次查询, users.add(this.userFeignClient.queryUserById(id)); }); return users; } } 复制代码
我们在启动类上,添加注解,开启Feign功能
@SpringBootApplication @EnableDiscoveryClient @EnableHystrix @EnableFeignClients // 开启Feign功能 public class UserConsumerDemoApplication { public static void main(String[] args) { SpringApplication.run(UserConsumerDemoApplication.class, args); } } 复制代码
Feign中本身已经集成了Ribbon依赖和自动配置:
因此我们不需要额外引入依赖,也不需要再注册 RestTemplate
对象。
另外,我们可以像上节课中讲的那样去配置Ribbon,可以通过 ribbon.xx
来进行全局配置。也可以通过 服务名.ribbon.xx
来对指定服务配置:
user-service: ribbon: ConnectTimeout: 250 # 连接超时时间(ms) ReadTimeout: 1000 # 通信超时时间(ms) OkToRetryOnAllOperations: true # 是否对所有操作重试 MaxAutoRetriesNextServer: 1 # 同一服务不同实例的重试次数 MaxAutoRetries: 1 # 同一实例的重试次数 复制代码
通过下面的参数来开启:
feign: hystrix: enabled: true # 开启Feign的熔断功能 复制代码
但是,Feign中的Fallback配置不像Ribbon中那样简单了。
1)首先,我们要定义一个类,实现刚才编写的UserFeignClient,作为fallback的处理类
@Component public class UserFeignClientFallback implements UserFeignClient { @Override public User queryUserById(Long id) { User user = new User(); user.setId(id); user.setName("用户查询出现异常!"); return user; } } 复制代码
2)然后在UserFeignClient中,指定刚才编写的实现类
@FeignClient(value = "user-service", fallback = UserFeignClientFallback.class) public interface UserFeignClient { @GetMapping("/user/{id}") User queryUserById(@PathVariable("id") Long id); } 复制代码
Spring Cloud Feign 支持对请求和响应进行GZIP压缩,以减少通信过程中的性能损耗。通过下面的参数即可开启请求与响应的压缩功能:
feign: compression: request: enabled: true # 开启请求压缩 response: enabled: true # 开启响应压缩 复制代码
同时,我们也可以对请求的数据类型,以及触发压缩的大小下限进行设置:
feign: compression: request: enabled: true # 开启请求压缩 mime-types: text/html,application/xml,application/json # 设置压缩的数据类型 min-request-size: 2048 # 设置触发压缩的大小下限 复制代码
注:上面的数据类型、压缩大小下限均为默认值。
前面讲过,通过 logging.level.xx=debug
来设置日志级别。然而这个对Fegin客户端而言不会产生效果。因为 @FeignClient
注解修改的客户端在被代理时,都会创建一个新的Fegin.Logger实例。我们需要额外指定这个日志的级别才可以。
1)设置com.leyou包下的日志级别都为debug
logging: level: com.leyou: debug 复制代码
2)编写配置类,定义日志级别
@Configuration public class FeignConfig { @Bean Logger.Level feignLoggerLevel(){ return Logger.Level.FULL; } } 复制代码
这里指定的Level级别是FULL,Feign支持4种级别:
3)在FeignClient中指定配置类:
@FeignClient(value = "user-service", fallback = UserFeignClientFallback.class, configuration = FeignConfig.class) public interface UserFeignClient { @GetMapping("/user/{id}") User queryUserById(@PathVariable("id") Long id); } 复制代码
4)重启项目,即可看到每次访问的日志:
通过前面的学习,使用Spring Cloud实现微服务的架构基本成型,大致是这样的:
在该架构中,我们的服务集群包含:内部服务Service A和Service B,他们都会注册与订阅服务至Eureka Server,而Open Service是一个对外的服务,通过均衡负载公开至服务调用方。我们把焦点聚集在对外服务这块,直接暴露我们的服务地址,这样的实现是否合理,或者是否有更好的实现方式呢?
先来说说这样架构需要做的一些事儿以及存在的不足:
面对类似上面的问题,我们要如何解决呢?答案是:服务网关!
为了解决上面这些问题,我们需要将权限控制这样的东西从我们的服务单元中抽离出去,而最适合这些逻辑的地方就是处于对外访问最前端的地方,我们需要一个更强大一些的均衡负载器的 服务网关。
服务网关是微服务架构中一个不可或缺的部分。通过服务网关统一向外系统提供REST API的过程中,除了具备服务路由、均衡负载功能之外,它还具备了 权限控制
等功能。Spring Cloud Netflix中的Zuul就担任了这样的一个角色,为微服务架构提供了前门保护的作用,同时将权限控制这些较重的非业务逻辑内容迁移到服务路由层面,使得服务集群主体能够具备更高的可复用性和可测试性。
填写基本信息:
添加Zuul依赖:
通过 @EnableZuulProxy
注解开启Zuul的功能:
@SpringBootApplication @EnableZuulProxy // 开启Zuul的网关功能 public class ZuulDemoApplication { public static void main(String[] args) { SpringApplication.run(ZuulDemoApplication.class, args); } } 复制代码
server: port: 10010 #服务端口 spring: application: name: api-gateway #指定服务名 复制代码
我们需要用Zuul来代理user-service服务,先看一下控制面板中的服务状态:
映射规则:
zuul: routes: user-service: # 这里是路由id,随意写 path: /user-service/** # 这里是映射路径 url: http://127.0.0.1:8081 # 映射路径对应的实际url地址 复制代码
我们将符合 path
规则的一切请求,都代理到 url
参数指定的地址
本例中,我们将 /user-service/**
开头的请求,代理到http://127.0.0.1:8081
访问的路径中需要加上配置规则的映射路径,我们访问: http://127.0.0.1:8081/user-service/user/10
在刚才的路由规则中,我们把路径对应的服务地址写死了!如果同一服务有多个实例的话,这样做显然就不合理了。
我们应该根据服务的名称,去Eureka注册中心查找 服务对应的所有实例列表,然后进行动态路由才对!
<dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId> </dependency> 复制代码
@SpringBootApplication @EnableZuulProxy // 开启Zuul的网关功能 @EnableDiscoveryClient public class ZuulDemoApplication { public static void main(String[] args) { SpringApplication.run(ZuulDemoApplication.class, args); } } 复制代码
eureka: client: registry-fetch-interval-seconds: 5 # 获取服务列表的周期:5s service-url: defaultZone: http://127.0.0.1:10086/eureka instance: prefer-ip-address: true ip-address: 127.0.0.1 复制代码
因为已经有了Eureka客户端,我们可以从Eureka获取服务的地址信息,因此映射时无需指定IP地址,而是通过服务名称来访问,而且Zuul已经集成了Ribbon的负载均衡功能。
zuul: routes: user-service: # 这里是路由id,随意写 path: /user-service/** # 这里是映射路径 serviceId: user-service # 指定服务名称 复制代码
再次启动,这次Zuul进行代理时,会利用Ribbon进行负载均衡访问:
日志中可以看到使用了负载均衡器:
在刚才的配置中,我们的规则是这样的:
zuul.routes.<route>.path=/xxx/**
: 来指定映射路径。 <route>
是自定义的路由名 zuul.routes.<route>.serviceId=/user-service
:来指定服务名。 而大多数情况下,我们的 <route>
路由名称往往和 服务名会写成一样的。因此Zuul就提供了一种简化的配置语法: zuul.routes.<serviceId>=<path>
比方说上面我们关于user-service的配置可以简化为一条:
zuul: routes: user-service: /user-service/** # 这里是映射路径 复制代码
省去了对服务名称的配置。
在使用Zuul的过程中,上面讲述的规则已经大大的简化了配置项。但是当服务较多时,配置也是比较繁琐的。因此Zuul就指定了默认的路由规则:
user-service
,则默认的映射路径就是: /user-service/**
也就是说,刚才的映射规则我们完全不配置也是OK的
配置示例:
zuul: prefix: /api # 添加路由前缀 routes: user-service: # 这里是路由id,随意写 path: /user-service/** # 这里是映射路径 service-id: user-service # 指定服务名称 复制代码
我们通过 zuul.prefix=/api
来指定了路由的前缀,这样在发起请求时,路径就要以/api开头。
路径 /api/user-service/user/1
将会被代理到 /user-service/user/1
Zuul作为网关的其中一个重要功能,就是实现请求的鉴权。而这个动作我们往往是通过Zuul提供的过滤器来实现的。
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 error
filterOrder
:通过返回的int值来定义过滤器的执行顺序,数字越小优先级越高。 这张是Zuul官网提供的请求生命周期图,清晰的表现了一个请求在各个过滤器的执行顺序。
所有内置过滤器列表:
场景非常多:
接下来我们来自定义一个过滤器,模拟一个登录的校验。基本逻辑:如果请求中有access-token参数,则认为请求有效,放行。
@Component public class LoginFilter extends ZuulFilter{ @Override public String filterType() { // 登录校验,肯定是在前置拦截 return "pre"; } @Override public int filterOrder() { // 顺序设置为1 return 1; } @Override public boolean shouldFilter() { // 返回true,代表过滤器生效。 return true; } @Override public Object run() throws ZuulException { // 登录校验逻辑。 // 1)获取Zuul提供的请求上下文对象 RequestContext ctx = RequestContext.getCurrentContext(); // 2) 从上下文中获取request对象 HttpServletRequest req = ctx.getRequest(); // 3) 从请求中获取token String token = req.getParameter("access-token"); // 4) 判断 if(token == null || "".equals(token.trim())){ // 没有token,登录校验失败,拦截 ctx.setSendZuulResponse(false); // 返回401状态码。也可以考虑重定向到登录页。 ctx.setResponseStatusCode(HttpStatus.UNAUTHORIZED.value()); } // 校验通过,可以考虑把用户信息放入上下文,继续向后执行 return null; } } 复制代码
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 复制代码