Spring Cloud Alibaba 致力于提供微服务开发的一站式解决方案。此项目包含开发分布式应用微服务的必需组件,方便开发者通过 Spring Cloud 编程模型轻松使用这些组件来开发分布式应用服务。
依托 Spring Cloud Alibaba,您只需要添加一些注解和少量配置,就可以将 Spring Cloud 应用接入阿里微服务解决方案,通过阿里中间件来迅速搭建分布式应用系统。
Spring Cloud :是一种微服务开发规范,是一套标准接口。所有器实现的框架都 必须要符合 该标准
实现框架:
Spring Cloud Netflix 第一点版本 在去年已经停止更新
Spring Cloud Alibaba 第二代版本,非常的便于介入阿里云各种云服务
- 服务限流降级:默认支持WebServlet、WebFlux、OpenFeign、RestTemplate、Spring Cloud Gateway、Zuul、Dubbo 和 RocketMQ限流降级功能的接入,可以在运行时通过控制台实时修改限流降级规则,还支持查看限流降级Metrics监控。
- 服务注册与发现:适配Spring Cloud 服务注册与发现标准,默认集成了Ribbon的支持。 提供注册中心相关功能(nacos,eureka,zk)
- 分布式配置管理:支持分布式系统中的外部化配置,配置更改时自动刷新。 我们可以让很多实例 去共享 同一个远程的 application.proerties
- 消息驱动能力:基于 Spring Cloud Stream 为微服务应用构建消息驱动能力。 消息推送功能,通知
分布式事务:使用 @GlobalTransactional 注解, 高效并且对业务零侵入地解决分布式事务问题。。 解决跨应用之间的 事务 一致性
阿里云对象存储:阿里云提供的海量、安全、低成本、高可靠的云存储服务。支持在任何应用、任何时间、任何地点存储和访问任意类型的数据。 可以将文件直接存储 阿里云对象存储
分布式任务调度:提供秒级、精准、高可靠、高可用的定时(基于 Cron 表达式)任务调度服务。同时提供分布式的任务执行模型,如网格任务。网格任务支持海量子任务均匀分配到所有 Worker(schedulerx-client)上执行。 Redis + Quartz或者Elastic-Job来解决。
阿里云短信服务:覆盖全球的短信服务,友好、高效、智能的互联化通讯能力,帮助企业迅速搭建客户触达通道。
Sentinel:把流量作为切入点,从流量控制、熔断降级、系统负载保护等多个维度保护服务的稳定性。
Nacos:一个更易于构建云原生应用的动态服务发现、配置管理和服务管理平台。
RocketMQ:一款开源的分布式消息系统,基于高可用分布式集群技术,提供低延时的、高可靠的消息发布与订阅服务。
Dubbo:Apache Dubbo™ 是一款高性能 Java RPC 框架。
Seata:阿里巴巴开源产品,一个易于使用的高性能微服务分布式事务解决方案。
Alibaba Cloud OSS: 阿里云对象存储服务(Object Storage Service,简称 OSS),是阿里云提供的海量、安全、低成本、高可靠的云存储服务。您可以在任何应用、任何时间、任何地点存储和访问任意类型的数据。
Alibaba Cloud SchedulerX: 阿里中间件团队开发的一款分布式任务调度产品,提供秒级、精准、高可靠、高可用的定时(基于 Cron 表达式)任务调度服务。
Alibaba Cloud SMS: 覆盖全球的短信服务,友好、高效、智能的互联化通讯能力,帮助企业迅速搭建客户触达通道。
1.我们需要知道Spring Cloud Alibaba在Spring Cloud家族中的地位,它是一个套件,与Netflix OSS一样,涵盖了非常多的实用组件,其中也有不少内容存在重叠。
2.我们需要知道Netflix OSS下的诸多重要组件先后宣布停止新功能开发的大背景,而Spring Cloud Alibaba是一个新生项目,正处于高速迭代中。对于未来,相信谁都会选。
3.对于中国用户来说,Spring Cloud Alibaba还有一个非常特殊的意义:它将曾经红极一时的Dubbo,以及阿里巴巴的强力消息中间件RocketMQ融入Spring Cloud体系。还在纠结于如何让这些共存的团队,你们所面临过的各种困难与问题,马上就会迎刃而解。不用再烦恼是不是要扩展Dubbo的注册中心,还是自己为RocketMQ实现一套的Spring Cloud Stream的Binder等等问题。
4.对于Spring Cloud Alibaba的上手学习成本如何呢?
如果您已经是Spring Cloud的用户,那么恭喜您,在Spring Cloud Common的抽象和Spring Cloud Alibaba团队的努力下,你会非常容易、甚至不需要改变多少编码模式,就能适应它。如果您第一次接触Spring Cloud,那么也恭喜您,因为这是有史以来,中文文档最全的一个Spring Cloud组件了,相信机制的您一定也能很快的上手使用它
如何引入依赖
pom
1.8
UTF-8
UTF-8
Hoxton.SR1
2.2.0.RELEASE
org.springframework.cloud
spring-cloud-dependencies
${spring-cloud.version}
pom
import
com.alibaba.cloud
spring-cloud-alibaba-dependencies
${spring-cloud-alibaba.version}
pom
import
Nacos 致力于帮助您发现、配置和管理微服务。Nacos 提供了一组简单易用的特性集,帮助您快速实现动态服务发现、服务配置、服务元数据及流量管理。
Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。 Nacos 是构建以“服务”为中心的现代应用架构 (例如微服务范式、云原生范式) 的服务基础设施。
服务发现和服务健康监测
Nacos 支持基于 DNS 和基于 RPC 的服务发现。服务提供者使用 原生SDK、OpenAPI、或一个独立的Agent TODO注册 Service 后,服务消费者可以使用DNS TODO 或HTTP&API查找和发现服务。
相当于dubbo的zookeeper和springcloud的eureka
实现:nacos ,eureka,zookeeper
动态配置服务
动态配置服务可以让您以中心化、外部化和动态化的方式管理所有环境的应用配置和服务配置。
动态配置消除了配置变更时重新部署应用和服务的需要,让配置管理变得更加高效和敏捷。
配置中心化管理让实现无状态服务变得更简单,让服务按需弹性扩展变得更容易。
相当于动态配置的zookeeper和springcloude-nacos-config
动态 DNS 服务
动态 DNS 服务支持权重路由,让您更容易地实现中间层负载均衡、更灵活的路由策略、流量控制以及数据中心内网的简单DNS解析服务。动态DNS服务还能让您更容易地实现以 DNS 协议为基础的服务发现,以帮助您消除耦合到厂商私有服务发现 API 上的风险。
服务及其元数据管理
Nacos 能让您从微服务平台建设的视角管理数据中心的所有服务及元数据,包括管理服务的描述、生命周期、服务的静态依赖分析、服务的健康状态、服务的流量管理、路由及安全策略、服务的 SLA 以及最首要的 metrics 统计数据。
我们可以通过 nacos 完成对注册到nacos 中的所有的实例进行健康检测,包保存其元数据
注册中心:帮助发现其他服务对应的实例
配置中心:全局的配置文件
健康监控管理中心:监控实例的健康状态
环境要求
64 bit OS,支持 Linux/Unix/Mac/Windows,推荐选用 Linux/Unix/Mac。
64 bit JDK 1.8+;下载 & 配置。
Maven 3.2.x+;下载 & 配置。
nacos-server-1.2.0-beta.0.zip
注意下载[nacos-server-1.2.0 以上版本会报错
http://localhost:8848/nacos
1.创建一个服务的生产者 提供服务 springcloud-alibaba-provider
2.创建一个服务的消费者 消费提供的服务springcloud-alibaba-consume
在父工程的pom.xml文件引入以下依赖
pom
org.springframework.boot
spring-boot-starter-parent
2.2.4.RELEASE
1.8
UTF-8
UTF-8
Hoxton.SR1
2.2.0.RELEASE
org.springframework.cloud
spring-cloud-dependencies
${spring-cloud.version}
pom
import
com.alibaba.cloud
spring-cloud-alibaba-dependencies
${spring-cloud-alibaba.version}
pom
import
创建子工程springcloud-alibaba-providerr,引入以下依赖,下面是我的pom.xml文件
springcloudalibaba
com.qf
1.0-SNAPSHOT
4.0.0
springcloud-alibaba-provider
org.springframework.boot
spring-boot-starter-web
org.springframework.boot
spring-boot-starter-actuator
org.springframework.boot
spring-boot-starter-test
test
com.alibaba.cloud
spring-cloud-starter-alibaba-nacos-discovery
com.alibaba.cloud
spring-cloud-starter-alibaba-nacos-config
创建配置文件,application.properties
# 应用名 模块名 注意应用名 不可以使用_
spring.application.name=springcloud-alibaba-provider
#配置nacos 服务器地址
spring.cloud.nacos.server-addr=localhost:8848
#配置tomcat端口号
server.port=8083
#暴露所有应用断点,便于监控
management.endpoints.web.exposure.include=*
创建启动类
package com.qf;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
@EnableDiscoveryClient //激活nacos相关功能
@SpringBootApplication
public class ProviderApplication {
public static void main(String[] args) {
SpringApplication.run(ProviderApplication.class,args);
}
}
创建测试类
package com.qf.controller;
import com.qf.entity.Student;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.*;
@RestController //Controller + ResponseBody 该注解下面的方法返回的都是Json数据
public class HelloController {
@Value("${server.port}")
private Integer port;
@RequestMapping("/getMessage/{msg}") //restFul风格
public String getMessage(@PathVariable("msg") String msg){
return "msg:"+msg + "--from-port:" + port;
}
@RequestMapping("/say")
public String say(@RequestParam("msg") String msg){
return "msg:"+msg + "--from-port:" + port;
}
}
测试启动provider
访问nacos管理界面,可以看到
访问 http://localhost:8083/getMessage/hello 和 http://localhost:8083/say?msg=bye
消费者通过nacos调用服务提供者的接口使用LoadBalanceClient 和 RestTemplate来完成
1.创建springcloud-alibaba-consumer
引入以下pom和provider 一致
springcloudalibaba
com.qf
1.0-SNAPSHOT
4.0.0
springcloud-alibaba-consumer
org.springframework.boot
spring-boot-starter-web
org.springframework.boot
spring-boot-starter-actuator
org.springframework.boot
spring-boot-starter-test
test
com.alibaba.cloud
spring-cloud-starter-alibaba-nacos-discovery
com.alibaba.cloud
spring-cloud-starter-alibaba-nacos-config
2.创建配置文件
#应用名 模块名 注意应用名 不可以使用_
spring.application.name=springcloud-alibaba-consumer
#配置nacos 服务器地址
spring.cloud.nacos.server-addr=localhost:8848
#配置tomcat端口号
server.port=8085
#暴露所有应用断点,便于监控
management.endpoints.web.exposure.include=*
3.创建启动类
package com.qf;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
@EnableDiscoveryClient //激活nacos相关功能
@SpringBootApplication
public class ConsumerApplication {
public static void main(String[] args) {
SpringApplication.run(ConsumerApplication.class,args);
}
}
5.创建配置类
package com.qf.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;
@Configuration //标记当前类是配置类,相当于spring中的bean.xml
public class NacosConfig {
/**
* RestTemplate 就是一个帮助我们发起远程http请求的客户端(类似于postman,浏览器)
* */
@Bean //向容器中加入一个RestTemplate
public RestTemplate getRestTemplate(){
return new RestTemplate();
}
}
6.创建测试类
package com.qf.controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;
import java.util.HashMap;
import java.util.Map;
/**
* 主要用于consumer向provider发起远程请求
* */
@RestController
public class NacosConsumerController {
/**
* loadBalancerClient负载均衡的客户端,用来根据服务名从nacos中获取对应的ip
* */
@Autowired
private LoadBalancerClient loadBalancerClient;
/**
* RestTemplate 就是一个帮助我们发起远程http请求的客户端(类似于postman,浏览器)
* */
@Autowired
private RestTemplate restTemplate;
@RequestMapping("/test1")
public String test1(){
// 调用远程 provider 中的 @RequestMapping("/getMessage/{msg}")
// 现在是 写死 地址,也可以使用 nacos 找到 springcloud-alibaba-provider 对应的ip 端口
// String url = "http://localhost:8083/getMessage/hello";
// serviceInstance 就是远程 provider 实例的 ip 和 端口 的封装
ServiceInstance serviceInstance = loadBalancerClient.choose("springcloud-alibaba-provider");
// 得到远程服务实例的ip
//serviceInstance.getHost();
// 得到端口
// serviceInstance.getPort();
//%s 就是需要替换的参数
String url = String.format("http://%s:%s/getMessage/%s",serviceInstance.getHost(),serviceInstance.getPort(),"hello");
// 使用restTemplate 发起网络请求
return restTemplate.getForObject(url,String.class);
}
@RequestMapping("/test2")
public String test2(){
// 远程调用 @RequestMapping("/say")
// public String say(@RequestParam("msg") String msg)
ServiceInstance serviceInstance= loadBalancerClient.choose("springcloud-alibaba-provider");
String url = String.format("http://%s:%s/say?msg={msg}",serviceInstance.getHost(),serviceInstance.getPort());
//msg值的初始化
Map map = new HashMap();
map.put("msg","hello java2109");
// 使用restTemplate 发起网络请求
return restTemplate.getForObject(url,String.class,map);
}
}
启动服务提供者和服务消费者进行测试,
查看nacos管理界面可以看到:http://localhost:8848/nacos
浏览器访问:http://localhost:8085/test1
RestTemplate:帮助我们发起远程请求的 客户端
使用的都是模板设计模式
LoadBalancerClient:loadBalancerClient 负载均衡的客户端 ,用来 根据服务名 从nacos 中获取对应的ip
如果provider 提供的服务有多个,那么consumer 调用provider时,就需要更多不同的负载均衡算法 选择不同的实例发起请求
是一个客户端的负载均衡器,它提供对大量的HTTP和TCP客户端的访问控制
可以实现服务的远程调用和服务的负载均衡协调
1. 在springcloud-alibaba-consumer中引入负载均衡依赖
org.springframework.cloud
spring-cloud-starter-netflix-ribbon
2.在配置文件中配置负载均衡器(将原来的myConfig类屏蔽)
import com.netflix.loadbalancer.IRule;
import com.netflix.loadbalancer.RandomRule;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;
@Configuration
public class RibbonConfig {
@LoadBalanced // 对RestTemplate 的发起网络请求 进行拦截,
// 运用负载均衡策略(就是按照策略选择对应的ip)
@Bean //向容器中加入一个 RestTemplate
public RestTemplate restTemplate(){
return new RestTemplate();
}
@Bean // 将随机的 策略加入到容器中
public IRule iRule(){
// 创建一个随机的负载均衡策略
IRule rule = new RandomRule();
//2.权重响应时间分配规则 代替ResponseTimeRule 响应时间加权策略
// WeightedResponseTimeRule responseTimeRule=new WeightedResponseTimeRule();
// //3.最低并发策略 分配的时候选择目前并发量最小的
// BestAvailableRule bestAvailableRule=new BestAvailableRule();
// //4.轮训策略
// RoundRobinRule roundRobinRule=new RoundRobinRule();
// //5.重试策略 如果在配置时间内,无法选择服务,尝试选择一个服务 重试机制
// RetryRule retryRule=new RetryRule();
// //6.区域感知策略 就近访问
// ZoneAvoidanceRule zoneAvoidanceRule=new ZoneAvoidanceRule();
7.可用过滤策略 可用根据阈值进行服务过滤
// AvailabilityFilteringRule filteringRule=new AvailabilityFilteringRule();
return rule;
}
}
3.创建RibbonTestController 测试(屏蔽原来 TestController)
package com.qf.controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;
import java.util.HashMap;
import java.util.Map;
@RestController
public class RibbonTestController {
/**
* RestTemplate 就是一个帮助我们发起远程http请求的客户端(类似于postman,浏览器)
* */
@Autowired
private RestTemplate restTemplate;
@RequestMapping("/test1")
public String test1(){
// 调用远程 provider 中的 @RequestMapping("/getMessage/{msg}")
// http://springcloud-alibaba-provider/getMessage/%s
//restTemplate 向 http://springcloud-alibaba-provider服务发起请求,但是会被ribbon 进行拦截,
// 会根据负载均衡策略选择其中一台 provider实例,并替换 springcloud-alibaba-provider为 ip:端口
// %s 就是需要替换的参数
String url = String.format("http://springcloud-alibaba-provider/getMessage/%s","hello");
// 使用restTemplate 发起网络请求
return restTemplate.getForObject(url,String.class);
}
@RequestMapping("/test2")
public String test2(){
// 远程调用 @RequestMapping("/say")
// public String say(@RequestParam("msg") String msg)
String url = String.format("http://springcloud-alibaba-provider/say?msg={msg}");
//msg值的初始化
Map map = new HashMap();
map.put("msg","hello java2109");
// 使用restTemplate 发起网络请求
return restTemplate.getForObject(url,String.class,map);
}
}
4.启动 两个provider (端口一定不同),在启动一个consumer进行测试
然后修改端口号为8084,再次启动
然后启动consumer
然后访问:http://localhost:8848/nacos/
打开新的页面,输入:http://localhost:8085/test1
Ribbon:是一个负载均衡的客户端,他可以拦截RestTemplate 发起的请求,并且将请求路径中的服务名,根据负载均衡策略替换为ip:端口,并发起网络请求
底层原理:使用aop ,动态代理实现
Feign:就是伪装,feign 就是可以将远程的访问调用,伪装成本地的接口调用。
Feign = RestTemplate + Ribbon
Feign 的英文表意为“假装,伪装,变形”, 是一个http请求调用的轻量级框架,可以Java接口注解的方式调用Http请求,而不用像Java中通过封装HTTP请求报文的方式直接调用。Feign通过处理注解,将请求模板化,当实际调用的时候,传入参数,根据参数再应用到请求上,进而转化成真正的请求,这种请求相对而言比较直观。 Feign被广泛应用在Spring Cloud 的解决方案中,是学习基于Spring Cloud 微服务架构不可或缺的重要组件。
1.创建一个springcloud-feign-cosumer工程,导入依赖
org.springframework.boot
spring-boot-starter-web
org.springframework.boot
spring-boot-starter-actuator
org.springframework.boot
spring-boot-starter-test
test
com.alibaba.cloud
spring-cloud-starter-alibaba-nacos-discovery
com.alibaba.cloud
spring-cloud-starter-alibaba-nacos-config
org.springframework.cloud
spring-cloud-starter-openfeign
2.创建配置文件application.properties
# 应用名 模块名 注意应用名 不可以使用_ springcloud-alibaba-feign-consumer
spring.application.name=springcloud-alibaba-feign-consumer
#配置nacos 服务地址
spring.cloud.nacos.server-addr=localhost:8848
server.port=8086
#暴露所有应用断点,便于监控
management.endpoints.web.exposure.include=*
3.创建启动类
package com.qf;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.openfeign.EnableFeignClients;
@EnableFeignClients //激活feign 相关功能
@EnableDiscoveryClient //激活nacos功能
@SpringBootApplication
public class FeignApplication {
public static void main(String[] args) {
SpringApplication.run(FeignApplication.class,args);
}
}
4.创建Feign伪装接口
package com.qf.service;
import com.qf.entity.Student;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.*;
/**
* 伪装 接口
*
* 我们需要向那个一个 服务发起远程调用,就需要将远程的处理器 方法拷贝过来,只剩方法名,没有方法体
* 1.拷贝 provider 中的 处理器方法
* 2.删除方法体
*
* @FeignClient(value = "springcloud-alibaba-provider")
* //标记当前接口 是一个feign伪装接口,feign 更具接口配置的方法,生成对应的实现类
* 向远程服务发起请求 ----》 将改接口实现 完成 RestTemplate 请求
*
*/
@FeignClient(value = "springcloud-alibaba-provider")
public interface FeignService {
@RequestMapping("/getMessage/{msg}") //restFul风格
public String getMessage(@PathVariable("msg") String msg);
@RequestMapping("/say")
public String say(@RequestParam("msg") String msg);
/**
* 更新学生
* @param Student
* @return
*/
@RequestMapping("/updateStudent")
public Student updateStudent(@RequestBody Student student);
}
5.创建FeignTestController使用伪装接口进行测试
package com.qf.controller;
import com.qf.entity.Student;
import com.qf.service.FeignService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class FeignTestController {
@Autowired
private FeignService feignService;
@RequestMapping("/test1")
public String test1(){
// 调用远程 provider 中的 @RequestMapping("/getMessage/{msg}")
return feignService.getMessage("hello BeiJing");
}
@RequestMapping("/test2")
public String test2(){
// 远程调用 @RequestMapping("/say")
// public String say(@RequestParam("msg") String msg)
return feignService.say("hello - java2109");
}
}
启动 两个provider (端口一定不同),再启动Fegin-consumer进行测试
1.创建common工程
2.创建实体类Student
import java.io.Serializable;
/**
* 创建一个实体类
* 1.get set 方法
* 2.toString()
* 3.实现序列化 序列化作用:1.便于保存对象存入磁盘 2.便于网络间传输
*
* 4.如果创建了 有参构造 ,必须创建无参构造 必须注意
*/
public class Student implements Serializable {
private int id;
private String name;
private int age;
private String sex;
private float height;
public Student() {
}
public Student(int id, String name, int age, String sex, float height) {
this.id = id;
this.name = name;
this.age = age;
this.sex = sex;
this.height = height;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public float getHeight() {
return height;
}
public void setHeight(float height) {
this.height = height;
}
@Override
public String toString() {
return "Student{" +
"id=" + id +
", name='" + name + '\'' +
", age=" + age +
", sex='" + sex + '\'' +
", height=" + height +
'}';
}
}
打成jar包,并存入到本地仓库
4.在provider中引入依赖
com.qfedu
springcloud-alibaba-common
1.0-SNAPSHOT
5.在provider 创建接受方法 一定要加 @RequestBody
/**
* 更新学生
* // 普通 的键值对 转对象 updateStudent(Student student),不可以被接受,只能接受json 转对象
*
* Student updateStudent(@RequestBody Student student)
*
* @param Student
* @return
*/
@RequestMapping("/updateStudent")
public Student updateStudent(@RequestBody Student student){
// 修改名字
student.setName(student.getName() +" --port:"+port);
System.out.println("服务提供者 更新student = " + student);
return student;
}
6.在feign-consumer 中引入 common
com.qfedu
springcloud-alibaba-common
1.0-SNAPSHOT
7.在feign-consumer 的 FeignService 中添加
/**
* 更新学生
* @param Student
* @return
*/
@RequestMapping("/updateStudent")
public Student updateStudent(@RequestBody Student student);
8.在FeignTestController添加方法
@RequestMapping("/test3")
public Student test3() {
Student student = new Student(100,"xiaoming", 13,"F",170);
return feignService.updateStudent(student);
}
9.测试
先重新启动 provider ,feign-consumer
然后观察 nacos ,再测试
容错:consumer 调用provider,如果Provider 有异常,消费者也会报错,容错机制就是保证,Provider 有异常,消费依然可以正常的返回兜底数据,客户感觉不到 provider有异常
1.在配置文件中开启容错
#开启 feign 容错机制
feign.hystrix.enabled=true
2.实现容错类
package com.qf.service.impl;
import com.qf.entity.Student;
import com.qf.service.FeignService;
import org.springframework.stereotype.Component;
/**
* Feign 伪装接口的容错实现类
* */
@Component //加入到容器中
public class FeignServiceFallBackImpl implements FeignService {
@Override
public String getMessage(String msg) {
return "feign 触发容错 getMessage 返回数据" + msg;
}
@Override
public String say(String msg) {
return "feign 触发容错 say 返回数据" + msg;
}
@Override
public Student updateStudent(Student student) {
student.setName(student.getName()+"----容错返回");
return student;
}
}
3.在FeignService伪装类接口中配置容错策略
package com.qf.service;
import com.qf.entity.Student;
import com.qf.service.impl.FeignServiceFallBackImpl;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
/**
* 伪装 接口
*
* 我们需要向那个一个 服务发起远程调用,就需要将远程的处理器 方法拷贝过来,只剩方法名,没有方法体
* 1.拷贝 provider 中的 处理器方法
* 2.删除方法体
*
* @FeignClient(value = "springcloud-alibaba-provider")
* //标记当前接口 是一个feign伪装接口,feign 更具接口配置的方法,生成对应的实现类
* 向远程服务发起请求 ----》 将改接口实现 完成 RestTemplate 请求
*
* fallback=FeignServiceFallBackImpl.class 配置容错实现类
*/
@FeignClient(value = "springcloud-alibaba-provider",fallback= FeignServiceFallBackImpl.class)
public interface FeignService {
@RequestMapping("/getMessage/{msg}") //restFul风格
public String getMessage(@PathVariable("msg") String msg);
@RequestMapping("/say")
public String say(@RequestParam("msg") String msg);
/**
* 更新学生
* @param Student
* @return
*/
@RequestMapping("/updateStudent")
public Student updateStudent(@RequestBody Student student);
}
4.进行测试
1.重新启动 feign-consumer 正常返回数据
2.停止provider ,则feign-consumer 返回容错数据
正常访问,此时的provider是正常状态
将provider关掉,继续访问:http://localhost:8086/test1
在分布式系统中,由于服务数量巨多,为了方便服务配置文件统一管理,实时更新,所以需要分布式配置中心组件。
Nacos 提供用于存储配置和其他元数据的 key/value 存储,为分布式系统中的外部化配置提供服务器端和客户端支持。使用 Spring Cloud Alibaba Nacos Config,您可以在 Nacos Server 集中管理你 Spring Cloud 应用的外部属性配置。
Spring Cloud Alibaba Nacos Config 是 Spring Cloud Config Server 和 Client 的替代方案,客户端和服务器上的概念与 Spring Environment 和 PropertySource 有着一致的抽象,在特殊的 bootstrap 阶段,配置被加载到 Spring 环境中。当应用程序通过部署管道从开发到测试再到生产时,您可以管理这些环境之间的配置,并确保应用程序具有迁移时需要运行的所有内容。
1.创建springcloud-alibaba-nacos-fonfig 应用,并引入依赖
org.springframework.boot
spring-boot-starter-web
org.springframework.boot
spring-boot-starter-actuator
org.springframework.boot
spring-boot-starter-test
test
com.alibaba.cloud
spring-cloud-starter-alibaba-nacos-discovery
com.alibaba.cloud
spring-cloud-starter-alibaba-nacos-config
2.nacos 配置文件
springboot 读取配置文件的顺序
bootstrap.properties ---->bootstrap.yaml ------>application.proerties---->application.yaml
bootstrap.properties
#应用springboot 启动前 先去读取bootstrap.properties ,然后去配置中心拉取对应的配置文件
# 应用名 模块名 注意应用名 不可以使用_ springcloud_alibaba_provider
spring.application.name=springcloud-alibaba-nacos-provider
#配置nacos 服务地址
spring.cloud.nacos.server-addr=localhost:8848
server.port=8086
#暴露所有应用断点,便于监控
management.endpoints.web.exposure.include=*
student.name=xiaoming
3.在nacos 配置中创建 对应配置文件
服务名.properties
4.配置启动类
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
@EnableDiscoveryClient
@SpringBootApplication
public class ConfigApplication {
public static void main(String[] args) {
SpringApplication.run(ConfigApplication.class,args);
}
}
5.读取配置文件内容测试
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.netflix.archaius.ConfigurableEnvironmentConfiguration;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class ConfigController {
// 在启动时 获取配置文件一次数据,中间不改变
@Value("${student.name}")
private String studentName;
@Autowired
// ConfigurableEnvironmentConfiguration 实时得到配置中中对应配置文件的数据
private ConfigurableEnvironmentConfiguration configuration;
@RequestMapping("/getStudent")
public String getStudent(){
return "配置文件---studentName:"+studentName +"---与配置中心保持一致的数据:"+configuration.getString("student.name");
}
}
测试
修改文件内容,得到立即的推送
可以在配置文件加入
spring.cloud.nacos.config.refresh.enabled=false
禁止自动刷新
bootstrap.properties application.properties 默认配置都是任何时候都生效的
我们还可以配置自定义环境,便于开发,但是前提必须是要先激活
自定义的环境有:
①开发环境:bootstrap-dev.properties
②测试环境:bootstrap-test.properties
多环境的配置有两种:
第一种是在bootstrap.properties中配置,下面是我的bootstrap.properties文件的内容
#应用SpringBoot 启动前,先去读取bootstrap.properties,然后去配置中心拉去对应的配置文件
#应用名 模块名 主要应用名不可以使用_
spring.application.name=springcloud-alibaba-nacos-config
#配置nacos服务地址
spring.cloud.nacos.server-addr=localhost:8848
#配置tomcat端口号
server.port=8087
#暴露所有应用端点,便于监控
management.endpoints.web.exposure.include=*
# 将该文件中配置的student.name注释掉
#student.name=xiaoming
#激活dev环境 让bootstrap-dev.properties生效
spring.cloud.nacos.config.file-extension=properties
spring.profiles.active=dev
创建bootstrap-dev.properties文件
#应用springboot 启动前 先去读取bootstrap.properties,然后去配置中心拉取对应的配置文件
#配置student.name
student.name=xiaoming-dev
先启动nacos,再启动项目,先访问:http://localhost:8848/nacos 查看服务注册上没
然后访问服务:http://localhost:8086/getStudent
在配置中心创建配置文件springcloud-alibaba-nacos-config-dev.properties
刷新页面:http://localhost:8086/getStudent
修改配置文件的内容,再次发布,再次刷新页面: http://localhost:8086/getStudent
可以看到内容实时在更新
第二种方式:懒得测了,感兴趣的可以测测