Spring Cloud 框架学习总结

最新推荐文章于 2024-07-10 11:11:58 发布

RayChim

最新推荐文章于 2024-07-10 11:11:58 发布

阅读量164

点赞数

文章标签： spring cloud 分布式 ribbon

本文链接：https://blog.csdn.net/javachim/article/details/115010636

版权

Eureka 服务注册：建立服务中心，微服务通过注册的方式进行互通
Acturator 微服务指标监控端点：微服务信息监控
Ribbon负载均衡策略：在高可用配置环境下，设置指定的均衡方式来决定调用哪个服务器
RestTemplate 服务间的通信(采用字符串拼接的方式，比较容易出错)：建立微服务与微服务之间的访问以及调用
OpenFeign 服务间的通信(采用接口与注解的方式简化)：建立微服务与微服务之间的访问以及调用
Hystrix 熔断机制：每个服务都有很多依赖服务，而每个依赖服务都有可能出现问题。如果一个服务和他的依赖服务没有有效的隔离，那么每一个依赖服务都有可能出现故障进而拖垮整个服务。
Zuul API网关：.统一访问出入口，微服务对前台透明。安全，过滤，流控等API管理功能，易于监控，方便管理
Zuul 服务降级：微服务没有响应调用，或者微服务关闭后调用服务降级业务逻辑方法
Zuul RateLimit 网关限流：对入口流量进行控制，使用令牌桶的方式限制请求的个数，超出的请求会被限制访问，状态码:429
Spring Cloud Config配置中心：将项目所需配置文件使用Git进行管理
Sleuth 链路追踪：为服务之间调用提供日志跟踪数据，遵循OpenTracting的规范，实现跨平台特性
Zipkin 可视化链路追踪客户端：链路追踪可视化客户端

服务注册与发现

Eureka 注册组件

1.EurekaServer服务端搭建

1.application.yml

#端口号
server:
port: 8761

eureka:
instance:
	#实例(服务）的名称
	appname: provider-service
	#主机名称、或者IP地址
	hostname: localhost
#客户端访问地址
client:
	service-url:
	defaulatZone: http://localhost:8761/eureka/
#不自注册
	register-with-eureka: false
	#获取其他服务的注册地址
	fetch-registry: false

入口主类注解
@EnableEurekaServer

Eureka高可用配置（双节点-多节点）

新建两个application.yml

1、application-p8761.yml

			server:
				port: 8761
			eureka:
			instance:
				appname: provider-service
				hostname: server1
			client:
				service-url:
				defaultZone:
					http://server2:8762/eureka/

2、application-p8762.yml

			server:
				port: 8762
			eureka:
			instance:
				appname: provider-service
				hostname: server2
			client:
				service-url:
				defaultZone:
					http://server1:8761/eureka/

3.入口主类配置注解
@SpringBootApplication
@EnableEurekaServer
4.客户端application.yml配置

		server:
			port: 8090
		spring:
			application:
				#服务名
				name: order-service
		eureka:
			client:
				service-url:
				defaultZone: http://server1:8761/eureka/,http://server2:8761/eureka/

Acturator 微服务监控端点

1.添加pom.xml依赖

	 <dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-actuator</artifactId>
	 </dependency>

application.yml配置

		server:
			port: 8090
		spring:
			application:
				#服务名
				name: order-service
		eureka:
			client:
				service-url:
					#多个服务用逗号分开
					defaultZone: http://server1:8761/eureka/,http://server2:8761/eureka/
		management:
			endpoints:
				web:
				exposure:
					#include: "*" 开启所有端点，不推荐
					include:
					#- health 健康检查	- info基本信息	- env 环境信息	- beans 管理对象信息 - shutdown 通过post请求关闭服务
					- health
					- info
					- env
					- beans
					- shutdown
			endpoint:
				health:
					show-details: always #显示完整应用的健康数据
				shutdown: 
					enabled: true #开启shutdown功能

通过输入localhost/acturator/info 查看对应的基本信息

服务间通信

RestTemplate对象与LoadBalanced注解
RestTemplate介绍
RestTemplate是Spring Cloud访问Restful API的请求对象
RestTemplate与HttpClient、OKHttp职能类似

@LoadBalanced注解
@LoadBalanced 是Ribbon提供的客户端负载均衡注解
通常RestTemplate与@LoadBalanced 联合使用
创建订单服务
Spring Initializr
web->Spring Web
Spring Cloud Discovery -> Eureka Discover Client
Spring Cloud Routing -> Ribbon
确保pom.xml引入ribbon

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

appliaction.yml

		spring:
		application:
			name: member-service
		eureka:
		client:
			service-url:
			defaultZone:
				http://localhost:8761/eureka

入口类注入@SpringBootApplication @RestTemplate

	@SpringBootApplication
	@EnableEurekaClient
	public class MemberServiceApplication {
		@Bean //注入
		@LoadBalanced //Ribbon负载均衡,默认轮询
		public RestTemplate restTemplate(){
			return new RestTemplate();
		}
	}
	//业务开发,服务间通信
	
	@Controller
	public class MemberController {
		@Resource
		private RestTemplate restTemplate;
	
		@GetMapping("/borrow")
		@ResponseBody
		public String borrow(String sn){
			/*
				RestTemplate负载均衡格式要求：
				http://微服务id/webapi地址
			*/
			Book book = restTemplate.getForObject("http://book-service/bsn?sn=" + sn, Book.class);
			return book.getName() + ":" + book.getDesc() + "图书借阅成功";
		}
	}

业务实体Book与JSON属性对应即可

Ribbon负载均衡策略

Ribbon是一种运用于SpringCloud中的客户端负载均衡工具，它是由Netflix实现的。一般的负载均衡有两种实现方式，一种为客户端实现，一种为服务端实现
客户端负载均衡将负载的功能放到客户端上，在客户端上有一个服务器列表，每次调用由客户端决定调用哪个服务器，缺点就是增加客户端的压力，优点就是简单，不需要额外的服务器。
服务端负载均衡：将客户端的请求发送到服务器上，由服务器选择哪个节点来处理，好处是不要增加客户端的压力，坏处是需要增加服务器，并且配置麻烦，nginx和F5就是服务端负载均衡的代表

RandomRule 随机策略随机选择 Server
RoundRobinRule（默认的）轮训策略按顺序循环选择 Server
RetryRule 重试策略在一个配置时问段内当选择 Server 不成功，则一直尝试选择一个可用的 Server
BestAvailableRule 最低并发策略逐个考察 Server，如果 Server 断路器打开，则忽略，再选择其中并发连接最低的 Server
AvailabilityFilteringRule 可用过滤策略过滤掉一直连接失败并被标记为 circuit tripped 的 Server，过滤掉那些高并发连接的 Server（active connections 超过配置的网值）
ResponseTimeWeightedRule 响应时间加权策略根据 Server 的响应时间分配权重。响应时间越长，权重越低，被选择到的概率就越低；响应时间越短，权重越高，被选择到的概率就越高。这个策略很贴切，综合了各种因素，如：网络、磁盘、IO等，这些因素直接影响着响应时间
ZoneAvoidanceRule 区域权衡策略综合判断 Server 所在区域的性能和 Server 的可用性轮询选择 Server，并且判定一个 AWS Zone 的运行性能是否可用，剔除不可用的 Zone 中的所有 Server
1. 注入pom.xml

	<dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-netflix-ribbon</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
    </dependencies>

application

	@SpringBootApplication
	@EnableDiscoveryClient
	public class app {
	
		@Bean
		@LoadBalanced
		public RestTemplate register(){
			return new RestTemplate();
		}
		//全局配置，如果有局部于全局，以全局为准
		@Bean
		public IRule ribbonRule(){
			return new RoundRobinRule();
		}
		public static void main(String[] args) {
			new SpringApplicationBuilder(app.class)
					.web(WebApplicationType.SERVLET)
					.run(args);
		}
	
	}

controller

	@RestController
	@Slf4j
	public class Controller {
		@Autowired
		private RestTemplate restTemplate;
		@GetMapping("/hello")
		public String hello(){
			return restTemplate.getForObject("http://eureka-client/sayHi",
					String.class);
		}
	}

application.yml

	spring:
	application:
		name: eureka-consumer
	server:
	port: 40000
	## 注册中心地址
	eureka:
	client:
		service-url:
		defaultZone: http://localhost:20000/eureka/
	## 配置局部随机策略
	book-service: 
		ribbon: 
			NFLoadBalancerRuluClassName: com.netflix.loadbalancer.RandomRule

OpenFeign声明式通信

OpenFeign是一种声明式服务调用组件，支持 SpringMVC注解（@RequestMapping 、@RequestBody 、@ResponseBody 、@PathVariable 、@RequestParam 等），它能让 REST 调用更加简单，可以快速上手，完成微服务间调用。
OpenFeign参数传递特点：
参数一定要绑定参数名。
方法中的参数类型与参数的个数一定要和被调用的微服务方法中的参数类型和个数保持一致
接口编写时，方法一般与被调用的微服务方法一致。
接口编写时，方法一般与被调用的微服务方法一致，若被调用的微服务方法中使用了SpringMVC注解，在接口中编写的方法也一定要加上 SpringMVC注解
接口中编写的方法返回值一定要与被调用的微服务方法中返回值保持一致。
引入依赖

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

在启动类上加 @EnableFeignClients 注解，使用它的目的是驱动 OpenFeign工作并指定扫描包，对带有 @FeignClient 注解的接口进行扫描，并将它们装配到 Ioc容器中。
如果Feign 接口定义跟启动类不在同一个包名下，还需要指定 basePackages属性的值，即需要扫描的包名。

		@SpringCloudApplication
		@EnableFeignClients
		public class UserApplication {
		
			public static void main(String[] args) {
				SpringApplication.run(UserApplication.class, args);
			}
		
		}

OpenFeign的标注@FeignClient 和@EnableFeignClients

OpenFeign提供了两个重要标注@FeignClient 和@EnableFeignClients。
@FeignClient 标注用于声明Feign客户端可访问的Web服务。
@EnableFeignClients 标注用于修饰Spring Boot应用的入口类，以通知Spring Boot启动应用时，扫描应用中声明的Feign客户端可访问的Web服务。
1. @FeignClient 标注的参数
  name, value (默认"")，两者等价
  qualifier (默认"")
  url (默认"")
  decode404 (默认false)
  configuration (默认FeignClientsConfiguration.class)
  fallback (默认void.class)
  fallbackFactory (默认void.class)
  path (默认"")
  primary (默认true)
2. @FeignClient 标注的configuration参数
  @FeignClient 标注的configuration参数，默认是通过FeignClientsConfiguration类定义的，可以配置Client，Contract，Encoder/Decoder等。
  FeignClientsConfiguration类中的配置方法及默认值如下：
  feignContract: SpringMvcContract
  feignDecoder: ResponseEntityDecoder
  feignEncoder: SpringEncoder
  feignLogger: Slf4jLogger
  feignBuilder: Feign.Builder
  feignClient: LoadBalancerFeignClient（开启Ribbon时）或默认的HttpURLConnection
OpenFeign中Get请求传递对象数据
post方式传递对象使用 @RequestBody 注解描述参数
get方式将对象转换为Map后利用 @RequestParam 注解描述

熔断机制与Hystrix

Hystrix介绍与工作原理

Hystrix是一个延迟和容错库，旨在隔离对远程系统、服务和第三方库的访问点，停止级联故障，并在不可避免发生故障的复杂分布式系统中实现快速恢复。
作用
1. 延迟和容错：停止级联故障。Fallbacks和优雅的降级。Fail fast 和快速恢复。通过中断来隔离线程和信号。
2. 实时监控：实时监控和修改配置。当系统中的服务和属性发生改变时立即更新。在数秒内察觉改变、做出决策、响应变化并看到调整后的结果。
3. 并发性：并发并行执行。并发感知请求缓存。通过请求合并自动批处理。
Hystrix的设计原则是
（1）对依赖服务调用时出现的调用延迟和调用失败进行监控和容错处理
（2）在复杂的分布式系统中，组织某一个依赖服务的故障在整个系统中蔓延。
（3）提供fail-fast和快速恢复的支持。
（4）提供fallback优雅降级的支持。
（5）支持近实时监控、报警及运维操作。

RestTemplate与Hystrix整合

将Hystrix配置到调用者的服务
作用：1秒后没有响应调用，或者微服务关闭后调用服务降级业务逻辑方法
1. 调用者微服务pom.xml 配置添加依赖

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

2. 在入口类增加@EnableHystrix 启动熔断机制
3. 在需要增加的Controler或Service方法上增加@HystrixCommand(fallbackMethod = "服务降级业务逻辑方法")
4. 创建一个服务降级业务逻辑方法

OpenFeign与Hystrix整合

OpenFeign内置Hystrix，feign.hystrix.enable开启即可
在@FeiginClient 增加fallback属性说明Fallback类
Fallback类要实现相同接口，重写服务降级业务逻辑。
1. 调用者微服务pom.xml 配置添加依赖

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

在application.yml 开启hystrix熔断机制

		feign: 
			hystrix:　
				enabled: true

在需要增加的Service方法上增加@FeignClient(name=“XX”,fallback=“指向的类.class”)
创建新的熔断类 implements Service方法类名
重写Service方法，处理对应逻辑。

Hystrix超时设置

超时的总时长为连接时间（connectTimeout）加读取时间（readTimeout），熔断时间≥总时间
在application.yml 开启hystrix熔断机制添加超时设置(defaulat为全局默认设置)

		feign: 
			hystrix:　
				enabled: true
			client:
				config: 
					defaulat: 
						connectTimeout: 1000
						readTimeout: 2000
		hystrix: 
			command: 
				#单独配置超时
				#"类名#方法名(参数类型1，参数类型2，参数类型n)"
				"类名"#方法名(String，int，Object)
				execution: 
						isolation:
							thread:
							#不能小于总时长
								timeoutInMilliseconds: 4000
				#强制开启熔断器，默认走熔断机制
				circuitBreaker: 
					forceOpen: true
				defaulat: 
					execution: 
						isolation:
							thread:
								timeoutInMilliseconds: 3000

Hystrix Dashboard监控

使用步骤
1.Hystrix Client 依赖hystrix-metrics-event-stream
2.Hystrix Client 注册HystrixMetricsStreamServlet
3.监控微服务依赖sping-cloud-starter-netflix-hystrix-dashboard
4.监控微服务利用@EnableHystrixDashboard开启仪表盘

pom.xml 导入依赖
登陆网址https://search.maven.org/ 搜索hystrix-metrics-event-stream 选中版本点击之后在浏览器右侧复制依赖信息

		<dependency>
			<groupId>com.netflix.hystrix</groupId>
			<artifactId>hystrix-metrics-event-stream</artifactId>
			<version>1.5.18</version>
		</dependency>

在入口类增加Bean注入

		@Bean
		public class ServletRegistrationBean hystrixServlet() {
			HystrixMetriceStreamServlet servlet = new HystrixMetricsStreamServlet();
			ServletRegistrationBean registrationBean = new ServletRegistrationBean(servlet);
			配置URL映射
			registrationBean.addUrlMappings("/hystrix.stream");
			registrationBean.setName("HystrixMetriceStreamServlet");
			//第二个被加载的启动的servlet
			registrationBean.setLoadOnStartup(1);
			return registrationBean;
		}

创建监控表服务
Spring Initializr
Spring Cloud Discovery -> Eureka Discovery Client
Spting Cloud Circuit Breaker -> Hystrix Dashboard
pom.xml 导入依赖

			<dependency>
				<groupId>org.springframework.cloud</groupId>
				<artifactId>spring-cloud-starter-netflix-hystrix-dashboard</artifactId>
			</dependency>

application.yml

			server: 
				port: 端口号9100
			spring: 
				application: 
					name: hystrix-dashboard
			eureka: 
				client: 
					service-url: 
						defaulatZone: 
							http://localhost:端口号/eureka

入口类增加@EnableHystrixDashboard开启仪表盘
5. 访问localhost:端口号9100/hystrix
6. 在地址栏填入需要监控的地址栏、加载延迟与标题。

Hystrix 熔断实验

使用postman批量发送请求进行测试

Hystrix熔断设置

在application.yml 开启hystrix熔断设置

		feign: 
			hystrix:　
				enabled: true
			client:
				config: 
					defaulat: 
						connectTimeout: 1000
						readTimeout: 2000
		hystrix: 
			command: 
				#单独配置超时
				#"类名#方法名(参数类型1，参数类型2，参数类型n)"
				"类名"#方法名(String，int，Object)
				execution: 
						isolation:
							thread:
							#不能小于总时长
								timeoutInMilliseconds: 4000
				#强制开启熔断器，默认走熔断机制
				circuitBreaker: 
					forceOpen: true
					requestVolumeThreshold: 50
					errorThreshouldPercentage: 60
					sleepWindowInMilliseconds: 5000
				defaulat: 
					#总时长
					execution: 
						isolation:
							thread:
								timeoutInMilliseconds: 3000
					#在当20秒的时间内，最近50此调用请求，请求错误率超过60%，则出发熔断5秒，期间快速失败。
					circuitBreaker: 
						requestVolumeThreshold: 50
						errorThreshouldPercentage: 60
						sleepWindowInMilliseconds: 5000
					metrics: 
						rollingStats: 
							timeInMilliseconds: 20000

API网关与Zuul

API网关

主要分为 Netflix Zuul 与 Spring Cloud Gateway
功能
认证和安全、负载卸载、性能检测、静态资源处理、动态路由、压力测试
作用
统一访问出入口，微服务对前台透明
安全，过滤，流控等API管理功能
易于监控，方便管理

Netflix Zuul
Zuul核心实现是Servlet，
Spring Cloud内置Zuul
1.x 版本采用同步方式通信
2.x 版本提供异步通信

Zuul入门

创建Zuul微服务
Spring Initializr
web->Spring Web
Spring Cloud Discovery -> Eureka Discover Client
Spring Cloud Routing -> Zuul
1. pom.xml 配置

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

入口主类配置
@SpringBootApplication
@EnableEurekaClient
@EnableZuulProxy
application.yml加上以下的配置代码：

		spring:
		application:
			name: service-zuul
		zuul:
			routes:
				api-a:#网关别名
				path: /api-a/**#映射路径
				serviceId: service-ribbon#微服务ID
				
				api-b:
				path: /api-b/**
				serviceId: service-feign
		server: 
			port: 443#https默认为443，端口默认80

通过输入配置好的serviceId去访问对应的微服务
例如 localhost/api-a/路径

Zuul负载均衡与服务降级

pom.xml 配置

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

入口主类配置

		@SpringBootApplication
		@EnableEurekaClient
		@EnableZuulProxy
		public class ZuulApplication {
			@Bean
			public IRule ribbonRule(){
				return new RandomRule();
			}
		}

application.yml加上以下的配置代码：

		spring:
		application:
			name: zuul-proxy
		eureka:
			client: 
				service-url: 
					defaulatZone:
						http://localhost:端口/eureka
		zuul:
			routes:
				api-a:#网关别名
				path: /api-a/**#映射路径
				serviceId: service-ribbon#微服务ID
				
				api-b:
				path: /api-b/**
				serviceId: service-feign
		server: 
			port: 443#https默认为443，端口默认80
		#配置指定微服务负载均衡
		book-service: 
			ribbon: 
				NFLoadBalancerRuluClassName: com.netflix.loadbalancer.RandomRule

4.在服务上创建fallback包，然后新建一个降级类实现 FallbackProvider
//组件扫描一定要加入

		@Component
		public class BookServiceFallback implements FallbackProvider {
			@Override
			public String getRoute() {//设置为哪个微服务提供降级
				return "book-service";
			}
			
			/**
			 * 如果需要配置默认服务降级，return *
			 * @Override 
			 * public String getRoute() {
			 * 	return "*";
			 * }
			 */
			/**
			 * 回退逻辑
			 * @param route 当前请求所访问的微服务名称
			 * @param cause 抛出的异常
			 * @return 
			 */
			@Override
			public ClientHttpResponse fallbackResponse(String route, Throwable cause) {
				return new ClientHttpResponse() {
					@Override
					public HttpStatus getStatusCode() throws IOException {
						return HttpStatus.BAD_GATEWAY;
					}

					@Override
					public int getRawStatusCode() throws IOException {
						return HttpStatus.BAD_REQUEST.value();
					}

					@Override
					public String getStatusText() throws IOException {
						return HttpStatus.BAD_REQUEST.getReasonPhrase();
					}

					@Override
					public void close() {

					}

					@Override
					public InputStream getBody() throws IOException {
						return new ByteArrayInputStream((route+fallback).getBytes());
					}

					@Override
					public HttpHeaders getHeaders() {
						HttpHeaders headers = new HttpHeaders();
						headers.setContentType(MediaType.APPLICATION_JSON);
						return headers;
					}
				};
			}
		}

RateLimit进行网关限流

描述
微服务网关是应用入口，必须对入口流量进行控制
RateLimit是Spring Cloud Zuul的限流组件
RateLimit采用“令牌桶”算法实现限流
使用步骤
依赖spring-cloud-zuul-ratelimit
配置存储组件（关系数据库、redis、缓存）
配置限流策略

pom.xml 配置

		<!-配置ratelimit依赖->
		<dependency>
		  <groupId>com.marcosbarbero.cloud</groupId>
		  <artifactId>spring-cloud-zuul-ratelimit</artifactId>
		  <version>2.2.7.RELEASE</version>
		</dependency>
		<!-配置数据库依赖->
		<dependency>
		  <groupId>org.springframework.boot</groupId>
		  <artifactId>spring-boot-starter-data-jpa</artifactId>
		</dependency>
		<!-配置MySQL数据库->
		<dependency>
		  <groupId>mysql</groupId>
		  <artifactId>mysql-connector-java</artifactId>
		  <version>5.1.47</version>
		</dependency>

使用数据库创建一个新的接收表

CREATE TABLE rate (
	rate_key VARCHAR(255) NOT NULL,
	remaining BIGINT,
	remaining——quota BIGINT,
	reset BIGINT,
	expiration TIMESTAMP,
	PRIMARY KEY(rate_key)
);

入口主类配置

		@SpringBootApplication
		@EnableEurekaClient
		@EnableZuulProxy
		public class ZuulApplication {
			@Bean
			public IRule ribbonRule(){
				return new RandomRule();
			}
		}

application.yml加上以下的配置代码：

		spring:
			application:
				name: zuul-proxy
			datasource: 
				driver-class-name: com.mysql.jdbc.Driver
				url: jdbc:mysql://localhost:3306/ratelimit?characterEncoding=utf8&useSSL=false
				username: root
				password: root
			jpa: 
				database-platform: org.hibernate.dialect.MySQLDialect
		eureka:
			client: 
				service-url: 
					defaulatZone:
						http://localhost:端口/eureka
		zuul:
			ratelimit:
				enabled: true
				repository: jpa
				#默认策略
				defaulat-policy-list:
					-	limit: 10
						refresh-interval: 5
						type: 
							-	url
				policy-list:
				#在zuul与api-a通信时
				#每两秒内，允许两个请求访问
				#其余请求会被限制访问，状态码:429
					api-a:
					-	limit: 2
						refresh-interval: 2
						type:
							-	origin
					api-b:
					-	limit: 2
						refresh-interval: 2
						type:
							-	origin
					
			routes:
				api-a:#网关别名
				path: /api-a/**#映射路径
				serviceId: service-ribbon#微服务ID
				
				api-b:
				path: /api-b/**
				serviceId: service-feign
		server: 
			port: 443#https默认为443，端口默认80
		#配置指定微服务负载均衡
		book-service: 
			ribbon: 
				NFLoadBalancerRuluClassName: com.netflix.loadbalancer.RandomRule

Zuul自定义过滤器

pom.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>com.forezp</groupId>
			<artifactId>service-zuul</artifactId>
			<version>0.0.1-SNAPSHOT</version>
			<packaging>jar</packaging>
		
			<name>service-zuul</name>
			<description>Demo project for Spring Boot</description>
		
			<parent>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-starter-parent</artifactId>
				<version>1.5.2.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.cloud</groupId>
					<artifactId>spring-cloud-starter-eureka</artifactId>
				</dependency>
				<dependency>
					<groupId>org.springframework.cloud</groupId>
					<artifactId>spring-cloud-starter-zuul</artifactId>
				</dependency>
				<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>
		
			<dependencyManagement>
				<dependencies>
					<dependency>
						<groupId>org.springframework.cloud</groupId>
						<artifactId>spring-cloud-dependencies</artifactId>
						<version>Dalston.RC1</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>

2.在其入口applicaton类加上注解@EnableZuulProxy，开启zuul的功能：

		@EnableZuulProxy
		@EnableEurekaClient
		@SpringBootApplication
		public class ServiceZuulApplication {
		
			public static void main(String[] args) {
				SpringApplication.run(ServiceZuulApplication.class, args);
			}
		}

3.加上配置文件application.yml加上以下的配置代码：

		eureka:
		client:
			serviceUrl:
			defaultZone: http://localhost:8761/eureka/
		server:
		port: 8769
		spring:
		application:
			name: service-zuul
		zuul:
			routes:
				api-a:#网关别名
				path: /api-a/**#映射路径
				serviceId: service-ribbon#微服务ID
				
				api-b:
				path: /api-b/**
				serviceId: service-feign

配置中心

Spring Cloud Config配置中心
mitee.com 码云，配置托管仓库
1. 创建一个新的配置中心服务
Spring Initializr
web -> Spring Web
Spring Cloud Discovery -> Eureka Discover Client
Spring Cloud Config -> Config Server
2. 在入口类加入 @EnableDiscoveryClient @EnableConfigServer 启动配置中心服务器
3. application.yml加上以下的配置代码：

		spring:
			application:
				name: config-server
			#配置中心服务仓库
			cloud: 
				config: 
					server: 
						git: 
							uri: https://gitee.com/raychim/sc-config
							username: RayChim
							password: 
		eureka:
			client: 
				service-url: 
					defaulatZone:
						http://localhost:8761/eureka
		server: 
			port: 5000
		#配置指定微服务负载均衡

在git上传新文件testserice-dev.yml
使用localhost:5000/分支名/testserice-dev.yml 得到文件
默认为master，可以不写
自动解析文件，可以使用testserice-dev.json 或 testserice-dev.properties 等得到不同的解析对象

微服务与配置中心通信
1. 创建一个新的配置中心微服务客户端
Spring Initializr
web -> Spring Web
Spring Cloud Discovery -> Eureka Discover Client
Spring Cloud Config -> Config Client
2. 在入口类加入 @EnableEurekaClient
3. 不需要application.yml文件改名为 bootstrap.yml
spring:
cloud:
config:
label: master
uri: http://localhost:5000
name: book-service #找到仓库中的book-service-dev.yml 文件
profile: dev

运行时刷新配置参数

导入监控依赖

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-actuator</artifactId>
		</dependency>

在服务层增加一个controller处理刷新(通过IOC动态刷新)
添加 @Controller @RefreshScope

		@Controller
		@RefreshScope
		public class RefreshController {
			@Value("${custom.title}")
			public String title;
			@GetMapping("/title")
			@ResponseBody
			public String showTitle()｛
				return title;
			｝
		}

bootstrap.yml

		spring: 
			cloud: 
				config: 
					label: master
					uri: http://localhost:5000
					name: book-service  #找到仓库中的book-service-dev.yml 文件
					profile: dev

在Git book-service-dev.yml文件增加所需的title并增加全局刷新的配置

		server: 
			port: 8000
		eureka: 
			client: 
				service-url: 
					defaultZone: 
						http://localhost:8761/eureka/
		spring: 
			application:
				name: book-service
		costom:
			title: CONFIG_TITLE_8001
		management: 
			endpoints: 
				web: 
					exposure: 
						include: "*"

浏览器输入 localhost:8001/actuator/refresh (不支持Get请求，使用postman发送post请求)
自动刷新时在Spring容器中刷新，如果修改端口号将需要重启服务才可以刷新成功

Spring-Retry重置机制

通过加入重试机制，提高应用启动的可靠性
触发条件：
1. 配置中心无法与仓库正常通信
2. 微服务无法配置中心正常通信

导入重试依赖

		<dependency>
			<groupId>org.springframework.retry</groupId>
			<artifactId>spring-retry</artifactId>
			<version>1.2.4.RELEASE<version>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-aop</artifactId>
		</dependency>

bootstrap.yml

		spring: 
			cloud: 
				config: 
					label: master
					uri: http://localhost:5000
					name: book-service  #找到仓库中的book-service-dev.yml 文件
					profile: dev
				#增加一下重试配置
				fail-fast: true #是否快速失败
				retry: 
					initial-interval: 5000 #初始间隔时间
					max-attempts: 4	#最大尝试次数
					max-interval: 30000 #最大间隔时间
					multiplier: 2	#倍数（每次重试时间加倍）

config多仓库配置

创建一个新的配置中心服务
Spring Initializr
web -> Spring Web
Spring Cloud Discovery -> Eureka Discover Client
Spring Cloud Config -> Config Server
在入口类加入 @EnableDiscoveryClient @EnableConfigServer 启动配置中心服务器
application.yml加上以下的配置代码：

		spring:
			application:
				name: config-server
			#配置中心服务仓库
			cloud: 
				config: 
					server: 
						git: 
							#将文件名使用{application}传入
							uri: https://gitee.com/raychim/{application}
							username: RayChim
							password: 
		eureka:
			client: 
				service-url: 
					defaulatZone:
						http://localhost:8761/eureka
		server: 
			port: 5000
		#配置指定微服务负载均衡

微服务与配置中心通信
创建一个新的配置中心微服务客户端
Spring Initializr
web -> Spring Web
Spring Cloud Discovery -> Eureka Discover Client
Spring Cloud Config -> Config Client
在入口类加入 @EnableEurekaClient
不需要application.yml文件改名为 bootstrap.yml

		spring: 
			application: 
				name: book-service #Git上仓库的名字
			cloud: 
				config: 
					label: master
					uri: http://localhost:5000
					#不需要name 去找到对应的文件名二十通过上方的application定义的name动态的找到名字
					#name: book-service  #找到仓库中的book-service-dev.yml 文件
					profile: dev
				#增加一下重试配置
				fail-fast: true #是否快速失败
				retry: 
					initial-interval: 5000 #初始间隔时间
					max-attempts: 4	#最大尝试次数
					max-interval: 30000 #最大间隔时间
					multiplier: 2	#倍数（每次重试时间加倍）

根据application定义的name属性在Git新建一个book-service仓库，添加book-service-dev.yml文件

配置中心高可用

1.创建多一个配置中心
根据之前创建的启动服务复制多一份,在Program arguments增加参数
–server.port=5001
2. bootstrap.yml

		spring: 
			cloud: 
				config: 
					label: master
					uri: http://localhost:5000
					name: book-service  #找到仓库中的book-service-dev.yml 文件
					profile: dev
				#增加一下重试配置
				fail-fast: true #是否快速失败
				retry: 
					initial-interval: 5000 #初始间隔时间
					max-attempts: 4	#最大尝试次数
					max-interval: 30000 #最大间隔时间
					multiplier: 2	#倍数（每次重试时间加倍）
				discovery: 
					enabled: true #启用配置中心高可用
					service-id: config-server

链路追踪

链路追踪Sleuth_Zipkin
Sleuth作用
解决分布式系统的追踪问题
1. 为服务之间调用提供链路跟踪
2. 通过日志提供链路跟踪数据
3. 遵循OpenTracting的规范，实现跨平台特性
Trace：轨迹
[微服务ID(服务定义的名字), Trace ID(轨迹ID), Span ID(步骤ID), 导出标识]
Zipkin(分布式链路追踪系统)
作用:
1. 用于手机Sleuth产生的跟踪日志
2. 采用可视化方式提供对链路跟踪的分析与展现
3. 采用C/S(客户端与服务端)模式，需单独服务

微服务整合Sleuth

pom.xml依赖(在服务的日志中开启跟踪数据) 需要在追踪的每个依赖中都增加

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

独立运行Zipkin服务端

通过jar包启动

访问官网zipkin.io 下载Jar包(但是只能通过Linux系统命令行下载)
可以通过https://dl.bintray.com/openzipkin/maven/io/zipkin/java/zipkin-server/ 下载Jar包
运行命令 java -jar jar包名即可启动

微服务与Zipkin服务端整合

创建一个Zipkin Service project
Spring Initializr
web -> Spring Web
Spring Cloud Discovery -> Eureka Discover Client
pom.xml依赖

		<!-- zipkin-server服务端程序 -->
		<dependency>
			<groupId>io.zipkin.java</groupId>
			<artifactId>zipkin.server</artifactId>
			<version>2.11.8</version>
		</dependency>
			<!-- zipkin-server Web界面 -->
		<dependency>
			<groupId>io.zipkin.java</groupId>
			<artifactId>zipkin-autoconfigure-ui</artifactId>
			<version>2.11.8</version>
		</dependency>

在入口类加入 @SpringBootApplication @EnableDiscoveryClient @EnableZipkinServer 启动配置中心服务器
application.yml加上以下的配置代码：

		server: 
			port: 9411
		spring:
			application:
				name: zipkin-server
		eureka:
			client: 
				service-url: 
					defaulatZone:
						http://localhost:8761/eureka
		#必须添加解决zipkin与spring Actuactor监控项冲突问题
		management: 
            metrics: 
                web: 
                    server:
                        auto-time-requests: false

在所需追踪的微服务上的pom.xml添加依赖

		<!-- 开启跟踪数据 -->
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-sleuth</artifactId>
		</dependency>
		<!-- Zipkin客户端 -->
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-zipkin</artifactId>
		</dependency>

在所需追踪的微服务上的application.yml加上以下的配置代码：

		server: 
			port: 8003
		spring:
			application:
				name: c-server
			sleuth: 
				sampler: #采样器
					probability: 1.0#采样率，采样率是采集Trace的比率，默认0.1
					rate: 10000 #每秒数据采集量，最多n条/秒Trace
			#设置zipkin服务端地址
			zipkin: 
				base-url: http://localhost:8411
		eureka:
			client: 
				service-url: 
					defaulatZone:
						http://localhost:8761/eureka
		#必须添加解决zipkin与spring Actuactor监控项冲突问题
		management: 
            metrics: 
                web: 
                    server:
                        auto-time-requests: false

RayChim

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring Cloud 框架学习总结

Spring Cloud 框架学习总结Eureka 服务注册：建立服务中心，微服务通过注册的方式进行互通Acturator 微服务指标监控端点：微服务信息监控Ribbon负载均衡策略：在高可用配置环境下，设置指定的均衡方式来决定调用哪个服务器RestTemplate 服务间的通信(采用字符串拼接的方式，比较容易出错)：建立微服务与微服务之间的访问以及调用OpenFeign 服务间的通信(采用接口与注解的方式简化)：建立微服务与微服务之间的访问以及调用Hystrix 熔断机制：每个服务都有很多
复制链接

扫一扫