SpringCloud 全家桶基本介绍及使用

最新推荐文章于 2024-08-17 19:48:03 发布
最新推荐文章于 2024-08-17 19:48:03 发布
阅读量2.1k 收藏 3
点赞数 1
文章标签： spring cloud java 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wscxyey/article/details/112981941
版权

SpringCloud 全家桶基本介绍及使用

1.微服务生态关系：

分为：SpringCloud Netflix,SpringCloud Apache,SpringCloud Alibaba

Netflix有：Eureka（注册中心）、Feign(服务调用、远程调用)、ribbon(负载均衡及重试)、Hystrix(熔断及降级)、Zuul(网关)，Config(配置中心)

SpringCloud Apache官方：Service Registry(服务注册) Service Discovery（服务发现）、OpenFeign或者Restemplate(远程服务调用)、LoadBalance(负载均衡)、Circuit Breaker(熔断降级)、Gateway（网关）

SpringCloud Alibaba: 很火，后续单独做介绍

Netflix很多组件都不在维护，SpringBoot新版本官方逐渐把Netflix的组件移除，目前仅仅保留了Eureka,但是很多老项目还使用旧的组件，而且springcloud 组件很多思想都是相通的，还是有学习的必要。

2.单体应用和微服务

单体应用：把所有的功能及模块整合到一起，打成一个jar或者war包，部署到服务器启动应用
优点：适用于简单的项目，开发，测试及部署都简单
缺点：不适用于大型项目，随着项目不断发展功能越来越多，单体应用劣势就显示出来。

  1. 复杂度高：代码量巨大，多达百万或者千万，添加一个小功能可能会造成其他隐患。
  2. 技术债务：不坏不修复，不敢修复
  3. 持续部署困难：编译时间长，部署时间长，改一个小功能，全部部署，会导致无关的功能暂停使用
  4. 可靠性差：一个小的bug，造成整个应用无法崩溃无法使用
  5. 扩展受限：不利于扩展
  6. 阻碍创新：不利于引进新的技术。传统应用springmvc 改为springboot需要大量改动。

微服务：把整个系统按照业务拆分，拆分成一个个小服务，就是微服务，所有的微服务组成一个整体。分久必合合久必分

微服务优点

  1. 独立部署。不依赖其他服务，耦合性低，不用管其他服务的部署对自己的影响。
  2. 易于开发和维护：关注特定业务，所以业务清晰，代码量少，模块变的易开发、易理解、易维护。
  3. 启动块：功能少，代码少，所以启动快，有需要停机维护的服务，不会长时间暂停服务。
  4. 局部修改容易：只需要部署 相应的服务即可，适合敏捷开发。
  5. 技术栈不受限：java，node.js等
  6. 按需伸缩：某个服务受限，可以按需增加内存，cpu等。
  7. 职责专一。专门团队负责专门业务，有利于团队分工。
  8. 代码复用。不需要重复写。底层实现通过接口方式提供。
  9. 便于团队协作：每个团队只需要提供API就行，定义好API后，可以并行开发。

微服务缺点

  1. 分布式固有的复杂性：容错（某个服务宕机），网络延时，调用关系、分布式事务等，都会带来复杂。
  2. 分布式事务的挑战：每个服务有自己的数据库，有点在于不同服务可以选择适合自身业务的数据库。订单用MySQL，评论用Mongodb等。目前最理想解决方案是：柔性事务的最终一致性。
  3. 接口调整成本高：改一个接口，调用方都要改。
  4. 测试难度提升：一个接口改变，所有调用方都得测。自动化测试就变的重要了。API文档的管理也尤为重要。推荐：yapi。
  5. 运维要求高：需要维护 几十 上百个服务。监控变的复杂。并且还要关注多个集群，不像原来单体，一个应用正常运行即可。
  6. 重复工作：比如java的工具类可以在共享common.jar中，但在多语言下行不通，C++无法直接用java的jar包。

3.Eureka
注册中心，作于服务的自动注册与发现。分为两部分：Eureka Server和Eureka Client.微服务上线会将自己的IP，端口port,服务名servername提交到注册中心，注册中心维护者一份注册列表。服务的消费者会从注册中心拉取服务注册列表，获取具体的调用路由再去调用服务提供者。为了避免每次都访问注册中心，client会定时去server拉取注册表信息到缓存到client本地。

  1. 客户需要每30秒发送一次心跳来续租，3个30s没有续租，（默认90s续租到期）eureka服务端会在注册列表将这个实例删除。
  2. 客户端会定期从eureka 拉取注册列表进行增量更新，默认30s一次。
  3. 发送心跳续租、拉取注册列表和续租到期时间都可以自己设置。
  4. eureka提供的restful url: 可以查看eureka 的信息

Eureka集群搭建
修改host文件：
进入目录 C:\Windows\System32\drivers\etc，
在host文件上添加

127.0.0.1       euk1.com
127.0.0.1       euk2.com

新建springboot项目
添加依赖

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

在主启动类添加 @EnableEurekaServer 注解

@EnableEurekaServer
@SpringBootApplication
public class CloudEurekaApplication {

	public static void main(String[] args) {
		SpringApplication.run(CloudEurekaApplication.class, args);
	}
}

搭建集群需要两个以上服务，euk1.com 和euk2.com配置文件分别为：

#是否将自己注册到其他Eureka Server,默认为true 需要
spring.application.name=EurekaServer
#web端口，服务是由这个端口处理rest请求的
server.port=7901
eureka.client.register-with-eureka=true
#是否从eureka server获取注册信息， 需要
eureka.client.fetch-registry=true
#设置服务注册中心的URL，用于client和server端交流
#此节点应向其他节点发起请求
eureka.client.serviceUrl.defaultZone=http://euk2.com:7902/eureka/
#主机名，必填
eureka.instance.hostname=euk1.com
management.endpoint.shutdown.enabled=true

#是否将自己注册到其他Eureka Server,默认为true 需要
spring.application.name=EurekaServer
#web端口，服务是由这个端口处理rest请求的
server.port=7902
eureka.client.register-with-eureka=true
#是否从eureka server获取注册信息， 需要
eureka.client.fetch-registry=true
#设置服务注册中心的URL，用于client和server端交流
#此节点应向其他节点发起请求
eureka.client.serviceUrl.defaultZone=http://euk1.com:7901/eureka/
#主机名，必填
eureka.instance.hostname=euk2.com
management.endpoint.shutdown.enabled=true

euk1和euk2的服务名都是EurekaServer，表示他们都是同一个服务，端口分别问7901和7902，他们相互注册和拉取信息

启动项目，浏览器访问：localhost:7901
在这里插入图片描述
eureka server集群搭建成功。

eureka提供的restful url: 可以查看eureka 的信息

http://localhost:7901/eureka/apps
http://localhost:7901/eureka/status

DiscoveryClient接口：是springcloud 服务注册发现的顶级接口

自我保护机制：当Server在短时间内丢失过多客户端时，那么Server会进入自我保护模式，会保护注册表中的微服务不被注销掉。当网络故障恢复后，退出自我保护模式。

客户端每分钟续约数量小于客户端总数的85%时会触发保护机制

Eureka Client:
客户端将信息上报给服务端
引入依赖client

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

将自己的健康信息上报给server,加入健康检查监控依赖

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

配置文件：

server.port=8081
spring.application.name=consumer
#向注册中心注册url
eureka.client.serviceUrl.defaultZone=http://euk1.com:7901/eureka/
#将自己的健康信息上报给server,状态up或者down
eureka.client.healthcheck.enabled=true
management.endpoints.web.exposure.include=*

client 更改健康状态up,down，并将状态信息上报给eureka server. 如果为down则不再调用此服务

import org.springframework.boot.actuate.health.Health;
import org.springframework.boot.actuate.health.HealthIndicator;
import org.springframework.stereotype.Service;

@Service
public class HealthService implements HealthIndicator{
	
	private Boolean flag = true;
	
	public void setFlag(Boolean flag) {
		this.flag = flag;
	}
	
	public Boolean getFlag() {
		return flag;
	}

	@Override
	public Health health() {
		// TODO Auto-generated method stub
		if(flag) {
			return Health.up().build();
		}
		return Health.down().build();
		
		
	}

}

4.Actuator
健康检查，监控应用
引入依赖

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

默认只暴露health 和 info 两个端口，可以通过配置暴露所有的监控端点：

#健康检查，暴露所有的监控端点
management.endpoints.web.exposure.include=*

访问：http://localhost:7901/actuator 查看所有的监控端点
在这里插入图片描述
查看具体的监控端点：
例如：http://localhost:7901/actuator/health
在这里插入图片描述
5.RestTemplate+LoadBalance
实现远程调用和负载均衡

用于远程调用，发送http请求调用其它微服务接口
RestTemplate 整合LoadBalance

package com.example.demo;

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 BeanConfig {
	
	@Bean
	//开启负载均衡，整合LoadBalance,整合后RestTemplate 只能通过服务名来调用服务，不能通过ip+端口调用服务
	@LoadBalanced
	public RestTemplate restTemplate() {
		return new RestTemplate();
	}
}

实体类People

package com.example.demo;

public class People {
	
	private String name;
	
	private Integer age;
	
	private String tel;
	
	private String addr;
	
	public People() {
		
	}
	
	public People(String name,Integer age,String tel,String addr) {
		super();
		this.name = name;
		this.age = age;
		this.tel = tel;
		this.addr = addr;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Integer getAge() {
		return age;
	}

	public void setAge(Integer age) {
		this.age = age;
	}

	public String getTel() {
		return tel;
	}

	public void setTel(String tel) {
		this.tel = tel;
	}

	public String getAddr() {
		return addr;
	}

	public void setAddr(String addr) {
		this.addr = addr;
	}

}

RestTeamplate 发送get 请求，post 表单请求 或者是post json 请求

package com.example.demo;


import java.util.HashMap;
import java.util.List;
import java.util.Map;


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;

@RestController
public class ControllerDemo01 {
	private static final Logger LOGGER = LoggerFactory.getLogger(ControllerDemo01.class);

	
	@Autowired
	private RestTemplate restTemplate;
	
	@Autowired
	private DiscoveryClient discoveryClient;  //服务注册发现顶级接口
	
	@Autowired
	private LoadBalancerClient loadBalancerClient; //LoadBalance 顶级接口
	
	@RequestMapping("/test1")
	public String test1() {
		List<ServiceInstance> list = discoveryClient.getInstances("PROVIDER");
		LOGGER.info(list.toString());
		ServiceInstance serviceInstance = list.get(0);
		String url = "http://"+serviceInstance.getHost()+":"+serviceInstance.getPort()+"/getPort";
		return restTemplate.getForObject(url, String.class);
	}
	
	@RequestMapping("/test2")
	public String test2() {
		String url = "http://PROVIDER/getPort";
		return restTemplate.getForObject(url, String.class);
		
	}
	
	@RequestMapping("/test3")
	public int test3() {
		ServiceInstance instance = loadBalancerClient.choose("PROVIDER");
		return instance.getPort();
	}
	
	@RequestMapping("/v/test4")
	public String test4() {
		return "test4";
	}
	
	/**
	 * 发送get请求，通过服务名调用，从map获取请求参数
	 * @return
	 */
	@RequestMapping("/getPeopleObject1")
	public People getPeopleObject1() {
		Map<String, Object> map = new HashMap<>();
		map.put("name", "小王");
		map.put("age", 15);
		map.put("tel", "138888888");
		map.put("addr", "中国");
		
		String url = "http://PROVIDER/getPeopleObject?name={name}&age={age}&tel={tel}&addr={addr}";
		People people = restTemplate.getForObject(url, People.class, map);
		return people;
	}
	
	@RequestMapping("/getPeopleObject2")
	public People getPeopleObject2() {
		String url = "http://PROVIDER/getPeopleObject?name={1}&age={2}&tel={3}&addr={4}";
		People people = restTemplate.getForObject(url, People.class, "小红",23,"1272272927","美国");
		return people;
	}
	
	/**
	 * 发送post form 表单请求
	 * @return
	 */
	@RequestMapping("/getPeopleObject3")
	public People postPeopleObject3() {
		LinkedMultiValueMap<String, String> map = new LinkedMultiValueMap<>();
		map.add("name", "小王");
		map.add("age", "15");
		map.add("tel", "138888888");
		map.add("addr", "中国");
		String url = "http://PROVIDER/getPeopleObject2";
		HttpHeaders headers = new HttpHeaders();
		headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);
		HttpEntity<MultiValueMap<String, String>> request = new HttpEntity<MultiValueMap<String, String>>(map, headers);
		People people = restTemplate.postForObject(url, request, People.class);
		return people;
	}
	
	/**
	 * 发送post json 请求
	 * @return
	 * @throws JsonProcessingException
	 */
	
	@RequestMapping("/getPeopleObject4")
	public People postPeopleObject4() throws JsonProcessingException {
		ObjectMapper objectMapper = new ObjectMapper();
		People people = new People("json", 20, "272292", "北京");
		String jsonContent = objectMapper.writeValueAsString(people);
		String url = "http://PROVIDER/getPeopleObject3";
		HttpHeaders headers = new HttpHeaders();
		headers.setContentType(MediaType.APPLICATION_JSON);
		
		HttpEntity<String> request = new HttpEntity<String>(jsonContent, headers);
		People people1 = restTemplate.postForObject(url, request, People.class);
		return people1;
	}

}

6.OpenFeign
OpenFeign 默认实现了ribbon，可以实现远程调用及负载均衡
引入依赖

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

主启动类加上@EnableFeignClients注解
在主启动类加@EnableFeignClients注解开启对@FeignClient注解类扫描加载处理，生成代理对象注入到ioc容器。扫描所有@FeignClient注解的类，并将这些信息注入Spring IoC容器中。当定义的Feign接口中的方法被调用时，通过JDK的代理方式，来生成具体的RequestTemplate来远程调用。

@FeignClient(服务名)+@RequestMapping(url路径) http://服务名/url 来远程访问。如果有参数一定要加上@RequestParam，如果发送的是post json 请求，加上@RequestBody

FeignController

package com.example.demo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.example.demo.service.FeignService;

@RestController
public class FeignController {
	
	@Autowired 
	private FeignService feignService;
	
	@RequestMapping("/feignTest")
	public String feignTest() {
		return feignService.feignTest();
	}
	
	@RequestMapping("/feignTest2")
	public String feignTest2() {
		return feignService.feignTest2("王五","20");
	}
	
	@RequestMapping("/feignTest3")
	public String feignTest3() {
		People people = new People("赵六",22,"29742","美国");
		return feignService.feignTest3(people);
	}
	
	@RequestMapping("/feignTest4")
	public String feignTest4() {
		return feignService.feignTest4("天天",30,"12494242","台湾");
	}
	
	@RequestMapping("/feignTest5")
	public String feignTest5() {
		System.out.println("发起请求");
		return feignService.feignTest5();
	}
	

}

FeignService

package com.example.demo.service;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

import com.example.demo.People;

@FeignClient(name="PROVIDER",fallback = FeignServiceFallback.class)
public interface FeignService {
	
	@RequestMapping("/feignTest")
	public String feignTest();

	@RequestMapping("/feignTest2")
	public String feignTest2(@RequestParam String name, @RequestParam String age);
	
	@RequestMapping("/feignTest3")
	public String feignTest3(@RequestBody People people);
	
	@RequestMapping("/feignTest4")
	public String feignTest4(@RequestParam String name,@RequestParam Integer age,@RequestParam String tel,@RequestParam String addr);

	@RequestMapping("/feignTest5")
	public String feignTest5();
	
	

}

Feign 连接超时、请求超时重试配置

package com.example.demo;

import java.util.concurrent.TimeUnit;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import feign.Request;
import feign.Retryer;

@Configuration
public class FeignConfig {
	//连接超时
	private static int connectTimeoutMillis = 1000;
	//请求超时
	private static int readTimeoutMillis = 2000;
	
	@Bean
	public Request.Options options(){
		return new Request.Options(connectTimeoutMillis, TimeUnit.MILLISECONDS, readTimeoutMillis, TimeUnit.MILLISECONDS, true);
	}
	
	//重试
	@Bean
	public Retryer feignRetryer() {
		return new Retryer.Default(100, 1000, 4);
	}

}

7.Hystrix

熔断降级。比喻：保险丝过载熔断。熔断请求不再处理，执行降级方法
默认情况：

触发条件：最少20个请求，失败达到50%

每当20个请求中，有50%失败时，熔断器就会打开，此时在调用此服务，将会直接返回失败，不再调远程服务。直到5s钟之后，重新检测该触发条件，判断是否吧熔断器关闭，或者继续打开。达到熔断之后，那么后面它就直接不去调该微服务

作用：

  1. 为系统提供保护机制。在依赖的服务出现高延迟或失败时，为系统提供保护和控制。
  2. 防止雪崩。
  3. 快速失败：Fail Fast。同时能快速恢复。侧重点是：（不去真正的请求服务，发生异常再返回），而是直接失败。
  4. 监控：Hystrix可以实时监控运行指标和配置的变化，提供近实时的监控、报警、运维控制。
  5. 回退机制：fallback，当请求失败、超时、被拒绝，或当断路器被打开时，执行回退逻辑。回退逻辑我们自定义，提供优雅的服务降级。
  6. 自我修复：断路器打开一段时间后，会自动进入“半开”状态，可以进行打开，关闭，半开状态的转换。

添加依赖

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

主启动类添加@EnableCircuitBreaker，旧版本是@EnableHystrixBreaker

RestTemplate + Hystrix

package com.example.demo;

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 com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;


@RestController
public class HystrixController {
	
	@Autowired
	private RestTemplate restTemplate;
	
	
	@RequestMapping("/hystrixTest1")
	@HystrixCommand(fallbackMethod = "back")
	public String hystrixTest1() {
		String url = "http://PROVIDER/getPort";
		return restTemplate.getForObject(url, String.class);
	}
	
	private String back() {
		System.out.println("降级方法！！！");
		return "降级方法";
	}
	

}

OpenFeign+hystrix
配置文件：

#Feign整合Hystrix
feign.circuitbreaker.enabled=true
#旧版
#feign.hystrix.enabled=true

package com.example.demo.service;

import org.springframework.stereotype.Component;

import com.example.demo.People;

@Component
public class FeignServiceFallback implements FeignService {
	
	public String feignTest() {
		return "feignTest 降级";
	}

	@Override
	public String feignTest2(String name, String age) {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public String feignTest3(People people) {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public String feignTest4(String name, Integer age, String tel, String addr) {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public String feignTest5() {
		// TODO Auto-generated method stub
		return null;
	}

}

8.HystrixDashboard

添加依赖

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

主启动类
@EnableHystrixDashboard

暴露所有监控端点 management.endpoints.web.exposure.include=*

允许被hystrix-dashboard 监控 hystrix.dashboard.proxy-stream-allow-list=*

访问： http://localhost:8081/hystrix 图形化界面

页面输入： localhost:8081/actuator/hystrix.stream，健康上报
在这里插入图片描述
访问方法，图像化界面监控
在这里插入图片描述

9.Sleuth + zipkin

Sleuth 链路追踪
如果能跟踪每个请求，中间请求经过哪些微服务，请求耗时，网络延迟，业务逻辑耗时等。我们就能更好地分析系统瓶颈、解决系统问题。因此链路跟踪很重要。
span(跨度)，基本工作单元。一次链路调用，创建一个span
trace(跟踪)，一组共享“root span”的span组成的树状结构 称为 trace，trace也有一个64位ID，trace中所有span共享一个trace id。类似于一颗 span 树
zipkin：图形化界面，Sleuth将日志发送到zipkin，zipkin收集日志以图形化的方式将信息展示出来

添加依赖

		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-zipkin</artifactId>
			<version>2.2.6.RELEASE</version>
		</dependency>

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

配置文件
#sleuth+zipkin
#设置采样率
spring.sleuth.sampler.rate=1
spring.zipkin.base-url=http://127.0.0.1:9411/
访问localhost:9411
在这里插入图片描述

10.SpringCloud Admin

admin serve和admin client
新建项目admin server
添加依赖

<dependency>
			<groupId>de.codecentric</groupId>
			<artifactId>spring-boot-admin-starter-server</artifactId>
</dependency>

主启动类 @EnableAdminServer
启动admin server

admin client:
添加依赖：

	<!-- Admin 服务 -->
      <dependency>
        <groupId>de.codecentric</groupId>
        <artifactId>spring-boot-admin-starter-client</artifactId>
        <version>2.2.1</version>
      </dependency>

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

配置文件

#spring cloud admin
management.endpoints.web.exposure.include=*
management.endpoint.health.show-details=always
spring.boot.admin.client.url=http://localhost:8080

浏览器访问admin
http://localhost:8080/
在这里插入图片描述

11.SpringCloud gateway
网关

待更新。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

wscxyey
关注
Spring全家桶--SpringCloud（高级）
2401_84004078的博客
04-03 786
面试前的“练手”还是很重要的，所以开始面试之前一定要准备好啊，不然也是耽搁面试官和自己的时间。我自己是刷了不少面试题的，所以在面试过程中才能够做到心中有数，基本上会清楚面试过程中会问到哪些知识点，高频题又有哪些，所以刷题是面试前期准备过程中非常重要的一点。《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》点击传送门即可获取！o";//sentinel系统默认的提示：Blocked by Sentinel (flow limiting)
springcloud全家桶(eureka+ribbon+feign+hystrix+turbine)
11-16
spring-cloud微服务框架demo，可以完整运行。这里面包含的组件和内容有: spring cloud eureka，服务注册和服务发现 spring cloud config，动态配置项 ribbon，客户端负载均衡 feign， hystrix，熔断 turbine Spring Cloud Starters 同一个服务中的多数据库支持（AOP） 全链路traceId追踪 velocity 前端模板 mybatis, pageHelper (分页), druid (连接池) redis（序列化采用的是jdk默认序列化方案） slf4j & logback(及其配置) 国际化配置 全局错误信息catch 线程池 服务健康检查, 服务全链路健康检查
springCloud全家桶
weixin_34130269的博客
03-18 126
Spring Cloud 入门教程(一): 服务注册 eureka是一个高可用的组件，它没有后端缓存，每一个实例注册之后需要向注册中心发送心跳，在默认情况下erureka server也是一个eureka client ,必须要指定一个 server。 Spring Cloud 入门教程(二)： 配置管理 假如需要搭建同多台服务器时，当然可以每台服务器做同样配置，但维护和同步会很...
Spring Cloud 入门，一篇搞定！
最新发布
hooheha的博客
08-17 700
SpringCloud是目前国内使用最广泛的微服务框架。官网地址：https://spring.io/projects/spring-cloud。SpringCloud集成了各种微服务功能组件，并基于SpringBoot实现了这些组件的自动装配，从而提供了良好的开箱即用体验。原理流程：Ribbon 通过 @LoadBalanced 注解标记了 RestTemplate 工具类，所以 Ribbon 就会去拦截 RestTemplate 所发起的 HTTP 请求，并做出一系列对策。
spring cloud 全家桶 简单介绍
m0_67392273的博客
08-24 273
注册中心,可以看到各个服务运行状态,并且各个微服务调用都通过注册中心来找到内网ip进行调用。显示各个服务运行的详细状态,线程池,内存环境,系统环境属性,spring各种bean运行状态,zuul版本是servlet, F版本的是webFlux框架,并且F版本可设置统一过滤器,鉴权服务, 四种模式: 用户名密码模式, 客户端模式, 授权码模式,简化模式过于复杂.单个微服务过滤器,限流过滤器, 相同的是都有负载均衡,熔断机制,重试规则。对外的网关,分为zuul版本和F版本,两者最大区别是底层容器不同,
Spring Cloud 全家桶
Sylvia_baby的博客
06-27 746
做了一点笔记，按照下面的顺序来Spring Cloud EurekaSpring Cloud RibbonSpring Cloud FeignSpring Cloud HystrixSpring Cloud ZuulSpring Cloud ConfigSpring Cloud Bus还是需要再深入学习的，这只是一个简单的了解...
Spring Cloud全家桶
weixin_38446891的博客
02-07 532
但区别于springMvc的是，springBoot专注于微服务方面的接口开发，和前端解耦，虽然springBoot也可以做成springMvc前后台一起开发，但是这就有点不符合springBoot框架的初衷了；对于springCloud框架来说，它和springBoot一样，注重的是微服务的开发，但是springCloud更关注的是全局微服务的整合和管理，相当于管理多个springBoot框架的单体微服务；但他们的基础都是Spring的ioc、aop等. ioc 提供了依赖注入的容器，
springcloud知识点脑图demo全家桶菜鸟入门
01-18
本资源“springcloud知识点脑图demo全家桶菜鸟入门”显然是为了帮助初学者掌握Spring Cloud的基础知识和实践应用。这里我们将深入探讨其中提到的关键组件——Eureka、OpenFeign、Redis以及Nacos。 首先，Eureka是...
springCloud微服务全家桶和分布式事务-springCloudFamily-FESCAR.zip
01-31
4. **实战演练**：通过示例项目，实际操作Spring Cloud全家桶组件的配置和使用，以及FESCAR的事务管理。 5. **性能优化**：了解如何评估和优化微服务的性能，包括服务调用的延迟、资源利用率等。 在这个压缩包的...
Spring全家桶知识笔记.pdf
10-29
Spring全家桶是企业级应用开发中广受欢迎的解决方案，它包括了一系列的模块和工具，可以...在不断的发展中，Spring全家桶还包含了Spring Boot、Spring Cloud等更多模块，帮助开发者快速搭建和部署基于微服务的应用。
01-Spring Cloud 全家桶之微服务组件迭代与升级
qq_35068291的博客
03-24 491
Spring Cloud Spring Cloud 自 2016 年 1 月发布第一个 Angel.SR5 版本，到目前 2020 年 3 月发布 Hoxton.SR3 版本，已经历经了 4 年时间。这 4 年时间里，Spring Cloud 一共发布了 46 个版本，支持的组件数从 5 个增加到 21 个。Spring Cloud 在 2019 年 12 月对外宣布后续 RoadMap： 下一个版本 Ilford 版本是一个大版本。这个版本基于 Spring Framework 5.3 & Sp
springCloud全家桶使用样例
04-15
本代码示例是springCloud全家桶使用样例，其中包含了技术点有springboot+Eureka+Ribbon+Feign，可以帮助刚接触springCloud的同学快速入门
springcloud
12-26
springcloud在微服务架构中，需要几个基础的服务治理组件，包括服务注册与发现(eureka)、服务消费(consume)、负载均衡(hibbon)、断路器(hystrix)、智能路由(zuul)、配置管理(config)等;
SpringCloud全家桶
shizhesx的博客
01-15 153
Eureka（服务发现组件） 1、什么是服务发现？ 2、服务发现方式 3、服务发现组件 Eureka Eureka是Netflflix开发的服务发现框架，SpringCloud将它集成在自己的子项目spring-cloud-netflflix中，实现 SpringCloud的服务发现功能。Eureka包含两个组件：Eureka Server和Eureka Client。 ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值