SpringCloud

SpringCloud 为开发人员提供了快速构建分布式系统的一些工具，包括配置管理、服务发现、断路器、路由、负载均衡、微代理、事件总线、全局锁、决策竞选、分布式会话等等。它运行环境简单，可以在开发人员的电脑上跑。另外说明spring cloud是基于Springboot的，所以需要开发中对Springboot有一定的了解，如果不了解的话可以看蚂蚁课堂SpringBoot课程。

服务提供者与消费关系

服务提供者:提供服务被人调用

消费者:调用被人服务

服务的注册与发现(Eureka )

在这里，我们需要用的的组件上Spring Cloud Netflix的Eureka ,eureka是一个服务注册和发现模块。

什么是Eureka

官方的介绍在这里Eureka wiki。Eureka是Netflix开源的一个RESTful服务，主要用于服务的注册发现。Eureka由两个组件组成：Eureka服务器和Eureka客户端。Eureka服务器用作服务注册服务器。Eureka客户端是一个java客户端，用来简化与服务器的交互、作为轮询负载均衡器，并提供服务的故障切换支持。Netflix在其生产环境中使用的是另外的客户端，它提供基于流量、资源利用率以及出错状态的加权负载均衡。
Eureka的吸引力来源于以下几点：

开源：大家可以对实现一探究竟，甚至修改源码。

可靠：经过Netflix多年的生产环境考验，使用应该比较靠谱省心

功能齐全：不但提供了完整的注册发现服务，还有Ribbon等可以配合使用的服务。

基于Java：对于Java程序员来说，使用起来，心里比较有底。

spring cloud可以使用Spring Cloud, 与Eureka进行了很好的集成，使用起来非常方便。

实现服务注册

创建EureKaserver 项目

Maven依赖

  1.   <parent>
  2.         <groupId>org.springframework.boot</groupId>
  3.         <artifactId>spring-boot-starter-parent</artifactId>
  4.         <version>1.5.2.RELEASE</version>
  5.         <relativePath /> <!-- lookup parent from repository -->
  6.     </parent>
  7.     <properties>
  8.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  9.         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
  10.         <java.version>1.8</java.version>
  11.     </properties>
  12.  
  13.     <dependencies>
  14.         <!--eureka server -->
  15.         <dependency>
  16.             <groupId>org.springframework.cloud</groupId>
  17.             <artifactId>spring-cloud-starter-eureka-server</artifactId>
  18.         </dependency>
  19.         <!-- spring boot test -->
  20.         <dependency>
  21.             <groupId>org.springframework.boot</groupId>
  22.             <artifactId>spring-boot-starter-test</artifactId>
  23.             <scope>test</scope>
  24.         </dependency>
  25.     </dependencies>
  26.     <dependencyManagement>
  27.         <dependencies>
  28.             <dependency>
  29.                 <groupId>org.springframework.cloud</groupId>
  30.                 <artifactId>spring-cloud-dependencies</artifactId>
  31.                 <version>Dalston.RC1</version>
  32.                 <type>pom</type>
  33.                 <scope>import</scope>
  34.             </dependency>
  35.         </dependencies>
  36.     </dependencyManagement>
  37.     <build>
  38.         <plugins>
  39.             <plugin>
  40.                 <groupId>org.springframework.boot</groupId>
  41.                 <artifactId>spring-boot-maven-plugin</artifactId>
  42.             </plugin>
  43.         </plugins>
  44.     </build>
  45.     <repositories>
  46.         <repository>
  47.             <id>spring-milestones</id>
  48.             <name>Spring Milestones</name>
  49.             <url>https://repo.spring.io/milestone</url>
  50.             <snapshots>
  51.                 <enabled>false</enabled>
  52.             </snapshots>
  53.         </repository>
  54.     </repositories>


配置application.yml

  1. server:
  2.   port: 8888
  3. eureka:
  4.   instance:
  5.     hostname: localhost
  6.   client:
  7.     registerWithEureka: false
  8.     fetchRegistry: false
  9.     serviceUrl:
  10.       defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/

启动EurekaServer

  1. @SpringBootApplication
  2. @EnableEurekaServer
  3. public class App {
  4.     public static void main(String[] args) {
  5.         SpringApplication.run(App.class, args);
  6.     }
  7. }

打开eureka server 界面

因为没有注册服务当然不可能有服务被发现了。

实现案例订单服务调用会员服务查询用户信息

服务提供者

创建一个服务提供者 会员服务工程 (eurekaMember),提供会员查询服务信息

创建项目service-member

Maven依赖

  1. <parent>
  2.         <groupId>org.springframework.boot</groupId>
  3.         <artifactId>spring-boot-starter-parent</artifactId>
  4.         <version>1.5.2.RELEASE</version>
  5.         <relativePath /> <!-- lookup parent from repository -->
  6.     </parent>
  7.     <properties>
  8.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  9.         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
  10.         <java.version>1.8</java.version>
  11.     </properties>
  12.     <dependencies>
  13.         <dependency>
  14.             <groupId>org.springframework.cloud</groupId>
  15.             <artifactId>spring-cloud-starter-eureka</artifactId>
  16.         </dependency>
  17.         <dependency>
  18.             <groupId>org.springframework.boot</groupId>
  19.             <artifactId>spring-boot-starter-web</artifactId>
  20.         </dependency>
  21.         <dependency>
  22.             <groupId>org.springframework.boot</groupId>
  23.             <artifactId>spring-boot-starter-test</artifactId>
  24.             <scope>test</scope>
  25.         </dependency>
  26.     </dependencies>
  27.     <dependencyManagement>
  28.         <dependencies>
  29.             <dependency>
  30.                 <groupId>org.springframework.cloud</groupId>
  31.                 <artifactId>spring-cloud-dependencies</artifactId>
  32.                 <version>Dalston.RC1</version>
  33.                 <type>pom</type>
  34.                 <scope>import</scope>
  35.             </dependency>
  36.         </dependencies>
  37.     </dependencyManagement>
  38.     <build>
  39.         <plugins>
  40.             <plugin>
  41.                 <groupId>org.springframework.boot</groupId>
  42.                 <artifactId>spring-boot-maven-plugin</artifactId>
  43.             </plugin>
  44.         </plugins>
  45.     </build>
  46.     <repositories>
  47.         <repository>
  48.             <id>spring-milestones</id>
  49.             <name>Spring Milestones</name>
  50.             <url>https://repo.spring.io/milestone</url>
  51.             <snapshots>
  52.                 <enabled>false</enabled>
  53.             </snapshots>
  54.         </repository>
  55.     </repositories>

application.yml配置

  1. eureka:
  2.   client:
  3.     serviceUrl:
  4.       defaultZone: http://localhost:8888/eureka/
  5. server:
  6.   port: 8762
  7. spring:
  8.   application:
  9.     name: service-member

服务接口

  1. @RestController
  2. public class MemberController {
  3.  
  4.     @RequestMapping("/getUserList")
  5.     public List<String> getUserList() {
  6.         List<String> listUser = new ArrayList<String>();
  7.         listUser.add("zhangsan");
  8.         listUser.add("lisi");return listUser;
  9.     }
  10.  
  11. }

发布服务

通过注解@EnableEurekaClient 表明自己是一个eurekaclient.

  1. @SpringBootApplication
  2. @EnableEurekaClient
  3. public class AppMember {
  4.  
  5.     public static void main(String[] args) {
  6.         SpringApplication.run(AppMember.class, args);
  7.     }
  8.  
  9. }

演示效果

需要指明spring.application.name,这个很重要，这在以后的服务与服务之间相互调用一般都是根据这个name 。 
启动工程，打开127.0.0.1:8888 ，即eureka server 的网址：

会发现一个服务已经注册在服务中了，服务名为SERVICE-MEMBER,端口为8762

这时打开 http://127.0.0.1:8762/getUserList ，会在浏览器上看到 :

["zhangsan","lisi"]

服务消费者

创建项目sercice-order

Maven依赖

  1. <parent>
  2.         <groupId>org.springframework.boot</groupId>
  3.         <artifactId>spring-boot-starter-parent</artifactId>
  4.         <version>1.5.2.RELEASE</version>
  5.         <relativePath /> <!-- lookup parent from repository -->
  6.     </parent>
  7.  
  8.     <properties>
  9.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  10.         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
  11.         <java.version>1.8</java.version>
  12.     </properties>
  13.  
  14.     <dependencies>
  15.         <dependency>
  16.             <groupId>org.springframework.cloud</groupId>
  17.             <artifactId>spring-cloud-starter-eureka</artifactId>
  18.         </dependency>
  19.         <dependency>
  20.             <groupId>org.springframework.cloud</groupId>
  21.             <artifactId>spring-cloud-starter-ribbon</artifactId>
  22.         </dependency>
  23.         <dependency>
  24.             <groupId>org.springframework.boot</groupId>
  25.             <artifactId>spring-boot-starter-web</artifactId>
  26.         </dependency>
  27.  
  28.         <dependency>
  29.             <groupId>org.springframework.boot</groupId>
  30.             <artifactId>spring-boot-starter-test</artifactId>
  31.             <scope>test</scope>
  32.         </dependency>
  33.     </dependencies>
  34.  
  35.     <dependencyManagement>
  36.         <dependencies>
  37.             <dependency>
  38.                 <groupId>org.springframework.cloud</groupId>
  39.                 <artifactId>spring-cloud-dependencies</artifactId>
  40.                 <version>Dalston.RC1</version>
  41.                 <type>pom</type>
  42.                 <scope>import</scope>
  43.             </dependency>
  44.         </dependencies>
  45.     </dependencyManagement>
  46.  
  47.     <build>
  48.         <plugins>
  49.             <plugin>
  50.                 <groupId>org.springframework.boot</groupId>
  51.                 <artifactId>spring-boot-maven-plugin</artifactId>
  52.             </plugin>
  53.         </plugins>
  54.     </build>
  55.  
  56.     <repositories>
  57.         <repository>
  58.             <id>spring-milestones</id>
  59.             <name>Spring Milestones</name>
  60.             <url>https://repo.spring.io/milestone</url>
  61.             <snapshots>
  62.                 <enabled>false</enabled>
  63.             </snapshots>
  64.         </repository>
  65.     </repositories>

application.yml配置

  1. eureka:
  2.   client:
  3.     serviceUrl:
  4.       defaultZone: http://localhost:8888/eureka/
  5. server:
  6.   port: 8764
  7. spring:
  8.   application:
  9.     name: service-order

编写service,调用service-member

  1. @SuppressWarnings("unchecked")
  2. @Service
  3. public class MemberService {
  4.     @Autowired
  5.     RestTemplate restTemplate;
  6.  
  7.     public List<String> getOrderByUserList() {
  8.         return restTemplate.getForObject("http://service-member/getUserList", List.class);
  9.     }
  10. }

演示效果

  1. @EnableEurekaClient
  2. @SpringBootApplication
  3. public class AppOrder {
  4.  
  5.     public static void main(String[] args) {
  6.         SpringApplication.run(AppOrder.class, args);
  7.     }
  8.  
  9.     @Bean
  10.     @LoadBalanced
  11.     RestTemplate restTemplate() {
  12.         return new RestTemplate();
  13.     }
  14.  
  15. }

在工程的启动类中,通过@EnableDiscoveryClient向服务中心注册；并且向程序的ioc注入一个bean: restTemplate;并通过@LoadBalanced注解表明这个restRemplate开启负载均衡的功能。

使用ribbon实现负载均衡

启动两个会员服务工程，端口号分别为8762、8763，订单服务 使用负载均衡策略轮训到会员服务接口。

什么是ribbon

ribbon是一个负载均衡客户端 类似nginx反向代理，可以很好的控制http和tcp的一些行为。Feign默认集成了ribbon。

修改会员服务工程代码区分端口项目

  1.     @Value("${server.port}")
  2.     private String serverPort;
  3.  
  4.     @RequestMapping("/getUserList")
  5.     public List<String> getUserList() {
  6.         List<String> listUser = new ArrayList<String>();
  7.         listUser.add("zhangsan");
  8.         listUser.add("lisi");
  9.         listUser.add("端口号:"+serverPort);
  10.         return listUser;
  11.     }

开启ribbon

@LoadBalanced注解表明这个restRemplate开启负载均衡的功能。

服务消费者（Feign）

什么是Feign

Feign是一个声明式的伪Http客户端，它使得写Http客户端变得更简单。使用Feign，只需要创建一个接口并注解。它具有可插拔的注解特性，可使用Feign 注解和JAX-RS注解。Feign支持可插拔的编码器和解码器。Feign默认集成了Ribbon，并和Eureka结合，默认实现了负载均衡的效果。

简而言之：

  • Feign 采用的是基于接口的注解
  • Feign 整合了ribbon

创建service-order-feign工程

Maven依赖

  1. <parent>
  2.         <groupId>org.springframework.boot</groupId>
  3.         <artifactId>spring-boot-starter-parent</artifactId>
  4.         <version>1.5.2.RELEASE</version>
  5.         <relativePath /> <!-- lookup parent from repository -->
  6.     </parent>
  7.  
  8.     <properties>
  9.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  10.         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
  11.         <java.version>1.8</java.version>
  12.     </properties>
  13.  
  14.     <dependencies>
  15.         <dependency>
  16.             <groupId>org.springframework.cloud</groupId>
  17.             <artifactId>spring-cloud-starter-eureka</artifactId>
  18.         </dependency>
  19.         <dependency>
  20.             <groupId>org.springframework.cloud</groupId>
  21.             <artifactId>spring-cloud-starter-ribbon</artifactId>
  22.         </dependency>
  23.         <dependency>
  24.             <groupId>org.springframework.boot</groupId>
  25.             <artifactId>spring-boot-starter-web</artifactId>
  26.         </dependency>
  27.         <dependency>
  28.             <groupId>org.springframework.cloud</groupId>
  29.             <artifactId>spring-cloud-starter-feign</artifactId>
  30.         </dependency>
  31.         <dependency>
  32.             <groupId>org.springframework.boot</groupId>
  33.             <artifactId>spring-boot-starter-test</artifactId>
  34.             <scope>test</scope>
  35.         </dependency>
  36.     </dependencies>
  37.  
  38.     <dependencyManagement>
  39.         <dependencies>
  40.             <dependency>
  41.                 <groupId>org.springframework.cloud</groupId>
  42.                 <artifactId>spring-cloud-dependencies</artifactId>
  43.                 <version>Dalston.RC1</version>
  44.                 <type>pom</type>
  45.                 <scope>import</scope>
  46.             </dependency>
  47.         </dependencies>
  48.     </dependencyManagement>
  49.  
  50.     <build>
  51.         <plugins>
  52.             <plugin>
  53.                 <groupId>org.springframework.boot</groupId>
  54.                 <artifactId>spring-boot-maven-plugin</artifactId>
  55.             </plugin>
  56.         </plugins>
  57.     </build>
  58.  
  59.     <repositories>
  60.         <repository>
  61.             <id>spring-milestones</id>
  62.             <name>Spring Milestones</name>
  63.             <url>https://repo.spring.io/milestone</url>
  64.             <snapshots>
  65.                 <enabled>false</enabled>
  66.             </snapshots>
  67.         </repository>
  68.     </repositories>

application.yml配置

  1. eureka:
  2.   client:
  3.     serviceUrl:
  4.       defaultZone: http://localhost:8888/eureka/
  5. server:
  6.   port: 8765
  7. spring:
  8.   application:
  9.     name: service-order-feign

编写service,调用service-member

  1. @FeignClient("service-member")
  2. public interface MemberFeign {
  3.     @RequestMapping("/getUserList")
  4.     public List<String> getOrderByUserList();
  5. }

@FeignClient 需要调用服务名称，@RequestMapping服务请求名称

演示效果

  1. @SpringBootApplication
  2. @EnableEurekaClient
  3. @EnableFeignClients
  4. public class OrderFeignApp {
  5.  
  6.     public static void main(String[] args) {
  7.         SpringApplication.run(OrderFeignApp.class, args);
  8.     }
  9.  
  10. }

路由网关(zuul)

什么是网关

Zuul的主要功能是路由转发和过滤器。路由功能是微服务的一部分，比如／api/user转发到到user服务，/api/shop转发到到shop服务。zuul默认和Ribbon结合实现了负载均衡的功能， 类似于nginx转发。

搭建SpringCloud网关

创建工程service-zuul

Maven依赖

  1. <parent>
  2.         <groupId>org.springframework.boot</groupId>
  3.         <artifactId>spring-boot-starter-parent</artifactId>
  4.         <version>1.5.2.RELEASE</version>
  5.         <relativePath /> <!-- lookup parent from repository -->
  6.     </parent>
  7.  
  8.     <properties>
  9.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  10.         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
  11.         <java.version>1.8</java.version>
  12.     </properties>
  13.  
  14.     <dependencies>
  15.         <dependency>
  16.             <groupId>org.springframework.cloud</groupId>
  17.             <artifactId>spring-cloud-starter-eureka</artifactId>
  18.         </dependency>
  19.         <dependency>
  20.             <groupId>org.springframework.cloud</groupId>
  21.             <artifactId>spring-cloud-starter-zuul</artifactId>
  22.         </dependency>
  23.         <dependency>
  24.             <groupId>org.springframework.boot</groupId>
  25.             <artifactId>spring-boot-starter-web</artifactId>
  26.         </dependency>
  27.  
  28.         <dependency>
  29.             <groupId>org.springframework.boot</groupId>
  30.             <artifactId>spring-boot-starter-test</artifactId>
  31.             <scope>test</scope>
  32.         </dependency>
  33.     </dependencies>
  34.  
  35.     <dependencyManagement>
  36.         <dependencies>
  37.             <dependency>
  38.                 <groupId>org.springframework.cloud</groupId>
  39.                 <artifactId>spring-cloud-dependencies</artifactId>
  40.                 <version>Dalston.RC1</version>
  41.                 <type>pom</type>
  42.                 <scope>import</scope>
  43.             </dependency>
  44.         </dependencies>
  45.     </dependencyManagement>
  46.  
  47.     <build>
  48.         <plugins>
  49.             <plugin>
  50.                 <groupId>org.springframework.boot</groupId>
  51.                 <artifactId>spring-boot-maven-plugin</artifactId>
  52.             </plugin>
  53.         </plugins>
  54.     </build>
  55.  
  56.     <repositories>
  57.         <repository>
  58.             <id>spring-milestones</id>
  59.             <name>Spring Milestones</name>
  60.             <url>https://repo.spring.io/milestone</url>
  61.             <snapshots>
  62.                 <enabled>false</enabled>
  63.             </snapshots>
  64.         </repository>
  65.     </repositories>

application.yml配置

  1. eureka:
  2.   client:
  3.     serviceUrl:
  4.       defaultZone: http://localhost:8888/eureka/
  5. server:
  6.   port: 8769
  7. spring:
  8.   application:
  9.     name: service-zuul
  10. zuul:
  11.   routes:
  12.     api-a:
  13.       path: /api-member/**
  14.       service-id: service-member
  15.     api-b:
  16.       path: /api-order/**
  17.       service-id: service-order

发送请求http://127.0.0.1:8769/api-member/getMemberAll

转发到http://127.0.0.1:8762/getMemberAll

开启网关 @EnableZuulProxy

服务过滤

  1. @Component
  2. public class MyFilter extends ZuulFilter {
  3.  
  4.     private static Logger log = LoggerFactory.getLogger(MyFilter.class);
  5.  
  6.     @Override
  7.     public String filterType() {
  8.         return "pre";
  9.     }
  10.  
  11.     @Override
  12.     public int filterOrder() {
  13.         return 0;
  14.     }
  15.  
  16.     public boolean shouldFilter() {
  17.         return true;
  18.     }
  19.  
  20.     public Object run() {
  21.         RequestContext ctx = RequestContext.getCurrentContext();
  22.         HttpServletRequest request = ctx.getRequest();
  23.         log.info(String.format("%s >>> %s", request.getMethod(), request.getRequestURL().toString()));
  24.         Object accessToken = request.getParameter("token");
  25.         if (accessToken != null) {
  26.             return null;
  27.         }
  28.         log.warn("token is empty");
  29.         ctx.setSendZuulResponse(false);
  30.         ctx.setResponseStatusCode(401);
  31.         try {
  32.             ctx.getResponse().getWriter().write("token is empty");
  33.         } catch (Exception e) {
  34.         }
  35.         return null;
  36.  
  37.     }
  38. }

如果请求参数中没有传入token参数 直接返回报错信息

断路器(Hystrix)

为什么需要 Hystrix?

在微服务架构中，我们将业务拆分成一个个的服务，服务与服务之间可以相互调用（RPC）。为了保证其高可用，单个服务又必须集群部署。由于网络原因或者自身的原因，服务并不能保证服务的100%可用，如果单个服务出现问题，调用这个服务就会出现网络延迟，此时若有大量的网络涌入，会形成任务累计，导致服务瘫痪，甚至导致服务“雪崩”。为了解决这个问题，就出现断路器模型。

什么是服务雪崩

分布式系统中经常会出现某个基础服务不可用造成整个系统不可用的情况, 这种现象被称为服务雪崩效应. 为了应对服务雪崩, 一种常见的做法是手动服务降级. 而Hystrix的出现,给我们提供了另一种选择.

服务雪崩应对策略

针对造成服务雪崩的不同原因, 可以使用不同的应对策略:

  1. 流量控制
  2. 改进缓存模式
  3. 服务自动扩容
  4. 服务调用者降级服务

流量控制 的具体措施包括:

  • 网关限流
  • 用户交互限流
  • 关闭重试

Hystrix作用

服务的降级

什么是服务降级

所有的RPC技术里面服务降级是一个最为重要的话题，所谓的降级指的是当服务的提供方不可使用的时候，程序不会出现异常，而会出现本地的操作调

service-order工程新增Maven依赖

  1. <dependency>
  2.     <groupId>org.springframework.cloud</groupId>
  3.     <artifactId>spring-cloud-starter-hystrix</artifactId>
  4. </dependency>

Rest方式使用断路器

  1. Rest请求方式接口改造
  2. @HystrixCommand(fallbackMethod = "orderError")
  3. public List<String> getOrderUserAll() {
  4. return restTemplate.getForObject("http://service-member/getMemberAll", List.class);
  5. }
  6.  
  7. public List<String> orderError() {
  8.     List<String> listUser = new ArrayList<String>();
  9.     listUser.add("not orderUser list");
  10.     return listUser;
  11. }
  1. 启动方式
  2. @EnableEurekaClient
  3. @EnableHystrix
  4. @SpringBootApplication
  5. public class OrderApp {
  6.  
  7.     public static void main(String[] args) {
  8.         SpringApplication.run(OrderApp.class, args);
  9.     }
  10.  
  11.     @Bean
  12.     @LoadBalanced
  13.     RestTemplate restTemplate() {
  14.         return new RestTemplate();
  15.     }
  16.  
  17. }

@HystrixCommand 作用:服务发生错误，回调方法。

@EnableHystrix 启动断路器

Fegin使用断路器

改造service-order-feign工程

  1. @FeignClient(value="service-member",fallback=MemberFeignService.class)
  2. public interface MemberFeign {
  3.     @RequestMapping("/getMemberAll")
  4.     public List<String> getOrderByUserList();
  5. }
  6. @Component
  7. public class MemberFeignService implements MemberFeign {
  8.  
  9.     public List<String> getOrderByUserList() {
  10.         List<String> listUser = new ArrayList<String>();
  11.         listUser.add("not orderUser list");
  12.         return listUser;
  13.     }
  14. }

配置文件新增

  1. feign:
  2.    hystrix:
  3.      enabled: true

分布式配置中心

什么是配置中心

在分布式系统中，由于服务数量巨多，为了方便服务配置文件统一管理，实时更新，所以需要分布式配置中心组件。在Spring Cloud中，有分布式配置中心组件spring cloud config ，它支持配置服务放在配置服务的内存中（即本地），也支持放在远程Git仓库中。在spring cloud config 组件中，分两个角色，一是config server，二是config client。

Spring Cloud（2）主要组件应用实例的更多相关文章

  1. 0.9.0.RELEASE版本的spring cloud alibaba sentinel+gateway网关实例

    sentinel除了让服务提供方.消费方用之外,网关也能用它来限流.我们基于上次整的网关(参见0.9.0.RELEASE版本的spring cloud alibaba nacos+gateway网关实 ...

  2. Spring cloud的各类组件

    Spring cloud 的各类组件 1.注册中心 eureka 2.ribbon 3.feign 4.hystirx 断路器 5.高速缓存器 redis 6.断路器Dashboard监控仪表盘

  3. spring cloud链路追踪组件sleuth和zipkin

    spring cloud链路追踪组件sleuth     主要作用就是日志埋点 操作方法 1.增加依赖             <dependency>      <groupId& ...

  4. Spring Boot版本，Spring Cloud版本与组件版本关系

    我们在学习Spring Cloud时,可能总是碰到以下问题: 1.Spring Boot版本与Spring Cloud版本关系 2.启动时,报莫名其妙的错,稀里糊涂的换个版本就好了 3.这么多版本,用 ...

  5. 一句话概括下spring框架及spring cloud框架主要组件

    作为java的屌丝,基本上跟上spring屌丝的步伐,也就跟上了主流技术.spring 顶级项目:Spring IO platform:用于系统部署,是可集成的,构建现代化应用的版本平台,具体来说当你 ...

  6. Spring Cloud(Dalston.SR5)--Eureka 服务实例健康检查

    默认情况下,Eureka 客户端每隔 30 秒会发送一次心跳给服务器端,告知正常存活,但是,实际环境中有可能出现这种情况,客户端表面上可以正常发送心跳,但实际上服务是不可用的,例如,一个需要访问数据的 ...

  7. Spring Cloud的常规组件和简单实战（一）

    最近一段时间在学习Spring Cloud,从Eureka到Hystrix,常用的配置和方法都有涉及一些,以此笔记来记录一下学习到的东西,也分享一下.内容以实战为起点,主要以介绍常规用法为主,最后也会 ...

  8. 0.9.0.RELEASE版本的spring cloud alibaba nacos+gateway网关实例

    gateway就是用来替换zuul的,功能都差不多,我们看下它怎么来跟nacos一起玩.老套路,三板斧: 1.pom: <?xml version="1.0" encodin ...

  9. Spring Cloud 5大组件

    服务发现——Netflix Eureka 客服端负载均衡——Netflix Ribbon 断路器——Netflix Hystrix 服务网关——Netflix Zuul 分布式配置——Spring C ...

  10. Spring Cloud ----> 几个组件的总结

    Spring Cloud Eureka 多个服务,对应多个Eureka Client 只有一个Eureka Server ,充当注册中心的角色每个Eureka Client 有ip 地址和端口号,它们 ...

随机推荐

  1. 阶段3 1.Mybatis_03.自定义Mybatis框架_7.自定义Mybatis的编码-实现基于注解配置的查询所有

    注解的方式,这里进行修改.上面注释的是原来xml的方式. 在dao类里面加上注解 创建注解类 声明注解的生命周期为Runntime 改变注解出现的位置,在Mehtod方法上 写完之后这里就不报错了. ...

  2. 测开之路一百五十一：ajax的作用和基本实现原理

    有些情况需要请求和刷新部分资源,但是又不希望整个页面都刷新,这个时候就需要用ajax来处理,即页面的某一部分触发请求和刷新内容 准备两个视图和html from flask import Flask, ...

  3. 自动爬取代理IP例子

    import time import json import datetime import threading import requests from lxml import etree from ...

  4. css让字体细长

    transform: scale(1,3); -ms-transform: scale(1,3); -webkit-transform: scale(1,3); -moz-transform: sca ...

  5. Selenium学习之==>常见面试题

    转自:http://www.imdsx.cn/ 一.selenium中如何判断元素是否存在? expected_conditions模块提供了多种校验方式,我常用的一种是presence_of_ele ...

  6. sql 、linq、lambda 查询语句

    http://www.cnblogs.com/lei2007/archive/2011/07/21/2113161.html

  7. CSS——插入形式 基本格式 常见css代码

    常见css代码 无下划线链接 字体颜色   +   左边距 背景颜色 字体.字体颜色.大小 文本对齐方式[取代了<center>]

  8. Java ——异常处理

    本节重点思维导图 详细戳——> 异常处理

  9. Centos7安装protobuf3.6.1

    简介 最近学习go语言,需要安装protobuf,但是网上的教程很多都不太适用于centos7 的系统.现在总结下protobuf在centos7下的安装教程. protobuf是Google开发出来 ...

  10. C函数调用过程原理及函数栈帧分析（转）

    在x86的计算机系统中,内存空间中的栈主要用于保存函数的参数,返回值,返回地址,本地变量等.一切的函数调用都要将不同的数据.地址压入或者弹出栈.因此,为了更好地理解函数的调用,我们需要先来看看栈是怎么 ...