Springcloud技术分享

Spring Cloud 是一套完整的微服务解决方案，基于 Spring Boot 框架，准确的说，它不是一个框架，而是一个大的容器，它将市面上较好的微服务框架集成进来，从而简化了开发者的代码量。

Spring Cloud 是什么？

Spring Cloud 是一系列框架的有序集合，它利用 Spring Boot 的开发便利性简化了分布式系统的开发，比如服务发现、服务网关、服务路由、链路追踪等。Spring Cloud 并不重复造轮子，而是将市面上开发得比较好的模块集成进去，进行封装，从而减少了各模块的开发成本。换句话说：Spring Cloud 提供了构建分布式系统所需的“全家桶”。

Spring Cloud 现状

目前，国内使用 Spring Cloud 技术的公司并不多见，不是因为 Spring Cloud 不好，主要原因有以下几点：

Spring Cloud 中文文档较少，出现问题网上没有太多的解决方案。

国内创业型公司技术老大大多是阿里系员工，而阿里系多采用 Dubbo 来构建微服务架构。

大型公司基本都有自己的分布式解决方案，而中小型公司的架构很多用不上微服务，所以没有采用 Spring Cloud 的必要性。

但是，微服务架构是一个趋势，而 Spring Cloud 是微服务解决方案的佼佼者，这也是作者写本系列课程的意义所在。

Spring Cloud 优缺点

其主要优点有：

集大成者，Spring Cloud 包含了微服务架构的方方面面。

约定优于配置，基于注解，没有配置文件。

轻量级组件，Spring Cloud 整合的组件大多比较轻量级，且都是各自领域的佼佼者。

开发简便，Spring Cloud 对各个组件进行了大量的封装，从而简化了开发。

开发灵活，Spring Cloud 的组件都是解耦的，开发人员可以灵活按需选择组件。

接下来，我们看下它的缺点：

项目结构复杂，每一个组件或者每一个服务都需要创建一个项目。

部署门槛高，项目部署需要配合 Docker 等容器技术进行集群部署，而要想深入了解 Docker，学习成本高。

Spring Cloud 的优势是显而易见的。因此对于想研究微服务架构的同学来说，学习 Spring Cloud 是一个不错的选择。

Spring Cloud 和 Dubbo 对比

Dubbo 只是实现了服务治理，而 Spring Cloud 实现了微服务架构的方方面面，服务治理只是其中的一个方面。下面通过一张图对其进行比较：

下面我们就简单的进行springcloud的学习吧，本文章涉及springcloud的相关重要组件的使用。

1. 项目初始化配置

1. 1. 新建maven工程

使用idea创建maven项目

1. 2. 在parent项目pom中导入以下依赖

  1. <parent>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-starter-parent</artifactId>
  4.     <version>2.3.4.RELEASE</version>
  5. </parent>
  6. <properties>
  7.     <spring.cloud-version>Hoxton.SR8</spring.cloud-version>
  8. </properties>
  9. <dependencyManagement>
  10. <dependencies>
  11.   <dependency>
  12.     <groupId>org.springframework.cloud</groupId>
  13.     <artifactId>spring-cloud-dependencies</artifactId>
  14.     <version>${spring.cloud-version}</version>
  15.     <type>pom</type>
  16.     <scope>import</scope>
  17.   </dependency>
  18. </dependencies>
  19. </dependencyManagement>

2. Eureka

Eureka是Spring Cloud Netflix的核心组件之一，其还包括Ribbon、Hystrix、Feign这些Spring Cloud Netflix主要组件。其实除了eureka还有些比较常用的服务发现组件如Consul，Zookeeper等，目前对于springcloud支持最好的应该还是eureka。

eureka组成

  1. Eureka Server：服务的注册中心，负责维护注册的服务列表。
  2. Service Provider：服务提供方，作为一个Eureka Client，向Eureka Server做服务注册、续约和下线等操作，注册的主要数据包括服务名、机器ip、端口号、域名等等。
  3. Service Consumer：服务消费方，作为一个Eureka Client，向Eureka Server获取Service Provider的注册信息，并通过远程调用与Service Provider进行通信。

2. 1. 创建子module，命名为eureka-server

2. 2. 在eureka-server中添加以下依赖

  1. <dependency>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-starter-web</artifactId>
  4. </dependency>
  5. <dependency>
  6.     <groupId>org.springframework.cloud</groupId>
  7.     <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
  8. </dependency>
  9. <dependency>
  10.     <groupId>org.springframework.boot</groupId>
  11.     <artifactId>spring-boot-starter-security</artifactId>
  12. </dependency>

2. 3. 在application.yml中添加以下配置

  1. server:
  2.   port: 8900 #应用的端口号
  3. eureka:
  4.   client:
  5.     service-url:
  6.       defaultZone: http://user:123@localhost:8900/eureka #eureka服务的的注册地址
  7.     fetch-registry: false #是否去注册中心拉取其他服务地址
  8.     register-with-eureka: false #是否注册到eureka
  9. spring:
  10.   application:
  11.     name: eureka-server   #应用名称 还可以用eureka.instance.hostname = eureka-server
  12.   security: #配置自定义Auth账号密码
  13.     user:
  14.       name: user
  15.       password: 123

2. 4. 在启动类上架注解

  1. @SpringBootApplication
  2. @EnableEurekaServer

在启动类中加入以下方法,防止spring的Auth拦截eureka请求

  1. @EnableWebSecurity
  2.     static class WebSecurityConfig extends WebSecurityConfigurerAdapter {
  3.         @Override
  4.         protected void configure(HttpSecurity http) throws Exception {
  5.             http.csrf().ignoringAntMatchers("/eureka/**");
  6.             super.configure(http);
  7.         }
  8.     }

2. 5. 创建module名为provider-user为服务提供者

2. 5. 1. 在pom中添加以下依赖
  1. <dependency>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-starter-web</artifactId>
  4. </dependency>
  5. <dependency>
  6.     <groupId>org.springframework.cloud</groupId>
  7.     <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
  8. </dependency>
2. 5. 2. application.yml配置
  1. server:
  2.   port: 7900 #程序启动入口
  3. spring:
  4.   application:
  5.     name: provider-user #应用名称
  6. eureka:
  7.   client:
  8.     service-url:
  9.       defaultZone: http://user:123@${eureka.instance.hostname}:${server.port}/eureka/
2. 5. 3. 启动类加注解
  1. @SpringBootApplication
  2. @EnableEurekaClient

Controller相关代码如下：

  1. @RestController
  2. public class UserController {
  3.     @GetMapping (value = "/user/{id}")
  4.     public User getUser(@PathVariable Long id){
  5.         User user = new User();
  6.         user.setId(id);
  7.         user.setDate(new Date());
  8.         System.out.println("7900");
  9.         return user;
  10.     }
  11.     @PostMapping (value = "/user")
  12.     public User getPostUser(@RequestBody User user){
  13.         return user;
  14.     }
  15. }

2. 6. 创建module名为consumer-order为服务提供者

2. 6. 1. pom依赖同服务提供者
2. 6. 2. application.yml配置
  1. server:
  2.   port: 8010
  3. spring:
  4.   application:
  5.     name: consumer-order
  6. eureka:
  7.   client:
  8.     serviceUrl:
  9.       defaultZone: http://user:123@${eureka.instance.hostname}:${server.port}/eureka/
2. 6. 3. 启动类
  1. @SpringBootApplication
  2. @EnableEurekaClient
  3. public class ConsumerApp
  4. {
  5.     @Bean
  6.     public RestTemplate restTemplate(){
  7.         return new RestTemplate();
  8.     }
  9.     public static void main( String[] args )
  10.     {
  11.         SpringApplication.run(ConsumerApp.class,args);
  12.     }
  13. }
2. 6. 4. Controller层代码
  1. @RestController
  2. public class OrderController {
  4.     @Autowired
  5.     private RestTemplate restTemplate;
  6.     @GetMapping (value = "/order/{id}")
  7.     public User getOrder(@PathVariable Long id){
  8.         //获取数据
  9.         User user = new User();
  10.         user.setId(id);
  11.         user.setDate(new Date());
  12.         user = restTemplate.getForObject("http://provider-user:7900/user/"+id,User.class);
  13.         return user;
  14.     }
  15. }

2. 7. 启动应用

分别启动Eureka-server、provider-user、consumer-order三个服务

2. 8. 访问地址

http://localhost:8900就可以看到两个服务已经注册到eureka注册中心上了

2. 9. eureka高可用配置

两个节点

  1. #高可用配置，两个节点
  2. spring:
  3.   application:
  4.     name: eureka-server-ha
  5.   profiles:
  6.     active: peer1
  8. eureka:
  9.   client:
  10.     serviceUrl:
  11.       defaultZone: https://peer1/eureka/,http://peer2/eureka/
  12. ---
  13. server:
  14.   port: 8901
  15. spring:
  16.   profiles: peer1
  17. eureka:
  18.   instance:
  19.     hostname: peer1
  21. ---
  22. server:
  23.   port: 8902
  24. spring:
  25.   profiles: peer2
  26. eureka:
  27.   instance:
  28.     hostname: peer2

三个节点

  1. #高可用配置，三个
  2. spring:
  3.   application:
  4.     name: eureka-server-ha
  5.   profiles:
  6.     active: peer3
  7. eureka:
  8.   client:
  9.     serviceUrl:
  10.       defaultZone: http://peer1:8901/eureka/,http://peer2:8902/eureka/,http://peer3:8903/eureka/
  11. ---
  12. spring:
  13.   profiles: peer1
  14. eureka:
  15.   instance:
  16.     hostname: peer1
  17. server:
  18.   port: 8901
  19. ---
  20. spring:
  21.   profiles: peer2
  22. eureka:
  23.   instance:
  24.     hostname: peer2
  25. server:
  26.   port: 8902
  27. ---
  28. spring:
  29.   profiles: peer3
  30. eureka:
  31.   instance:
  32.     hostname: peer3
  33. server:
  34.   port: 8903

3. Ribbon

配合eureka使用的一个负载均衡组件，一般情况下我们都是自定义负载均衡策略使用

3. 1. 方式一(默认)

轮询规则

在启动类中restTemplate()方法加入注解@LoadBalanced

RestTemplate 是由 Spring Web 模块提供的工具类，与 SpringCloud 无关，是独立存在的，因 SpringCloud 对 RestTemplate 进行了一定的扩展，所以 RestTemplate 具备了负载均衡的功能

  1. @Bean
  2. @LoadBalanced
  3. public RestTemplate restTemplate(){
  4.     return new RestTemplate();
  5. }

在启动类上加注解

  1. @RibbonClient(name = "provider-user")

3. 2. 方式二(配置文件自定义)

在application.yml中加入以下配置

  1. #使用配置文件方式实现负载均衡，优先级，配置文件>注解或java代码配置>cloud默认配置
  2. provider-user:
  3.   ribbon:
  4.     NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule

3. 3. 方式三(Java代码自定义)

自定义一个配置类，返回规则

  1. @RibbonClient(name = "provider-user",configuration = RibbonConfiguration.class)
  2. public class RibbonConfiguration {
  3.     @Bean
  4.     public IRule getRule(){
  5.         return new RandomRule();
  6.     }
  7. }

4. Feign学习

什么是feign，是声明式的webservice客户端，解决远程调用，支持JAX-RS,即RestFulWebService。Feign是一种声明式、模板化的HTTP客户端。在Spring Cloud中使用Feign, 我们可以做到使用HTTP请求远程服务时能与调用本地方法一样的编码体验，开发者完全感知不到这是远程方法，更感知不到这是个HTTP请求，这整个调用过程和Dubbo的RPC非常类似。开发起来非常的优雅。

4. 1. 引入依赖

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

4. 2. 使用注解@FeignClient编写feign调用的客户端接口

  1. @FeignClient("provider-user")
  2. public interface UserFeignClient {
  3.     @RequestMapping (value = "/user/{id}", method = RequestMethod.GET)
  4.     public User getUser(@PathVariable Long id);
  5.     @RequestMapping (value = "/user", method = RequestMethod.POST)
  6.     public User postUser(@RequestBody User user);
  7. }

4. 3. 在启动类加注解@EnableFeignClients

4. 4. Controller层的调用方法

  1. @Autowired
  2. private UserFeignClient userFeignClient;
  3. @GetMapping (value = "/user/{id}")
  4. public User getUser(@PathVariable Long id){
  5.     //获取数据
  6.     return this.userFeignClient.getUser(id);
  7. }
  8. @GetMapping (value = "/user")
  9. public User postUser(User user){
  10.     return this.userFeignClient.postUser(user);
  11. }

5. hystrix学习

hystrix是Netflix的一个类库，在微服务中，具有多层服务调用，主要实现断路器模式的类库

5. 1. 引入依赖

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

5. 2. 在启动类上加注解

  1. @EnableCircuitBreaker
    1. 在Controller层类的方法上加注解，并编写退回方法，需同名
  1. @HystrixCommand(fallbackMethod = "findByIdFallBack")
  2. public User getOrder(@PathVariable Long id){
  3.     //获取数据
  4.     User user = new User();
  5.     user.setId(id);
  6.     user.setDate(new Date());
  7.     user = restTemplate.getForObject("http://provider-user/user/"+id,User.class);
  8.     System.out.println(Thread.currentThread().getId());
  9.     return user;
  10. }
  11. public User findByIdFallBack(Long id){
  12.     System.out.println(Thread.currentThread().getId());
  13.     User user = new User();
  14.     user.setId(1L);
  15.     return user;
  16. }

6. springboot的健康监控actuator

actuator主要用于服务健康监控,springboot 1.X和2.x有所不同，本次为2.X

6. 1. 引入依赖包

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

6. 2. 配置

  1. #健康监控配置
  2. management:
  3.   endpoint:
  4.     health:
  5.       show-details: always #是否健康监控显示细节
  6.   endpoints:
  7.     web:
  8.       exposure:
  9.         include: hystrix.stream #hystrix保护机制，不直接暴露监控状态
  10.       base-path: / #暴露的端点链接

6. 3. 访问

1.X版本

  1. localhost:8080/health

2.X版本

  1. localhost:8080/actuator/health

7. feign配合Hystrix使用

7. 1. 配置文件

  1. feign:
  2.   hystrix:
  3.     enabled: true # 总开关，可以通过java单独控制client

7. 2. 启动类注解

  1. @EnableFeignClients

7. 3. 控制层

  1. @RestController
  2. public class OrderFeignController {
  3.     @Autowired
  4.     private UserFeignClient userFeignClient;
  5.     @Autowired
  6.     private UserFeignNotHystrixClient userFeignNotHystrixClient;
  7.     @GetMapping (value = "/order/{id}")
  8.     public User getUser(@PathVariable Long id){
  9.         //获取数据
  10.         return userFeignClient.getUser(id);
  11.     }
  13.     /**
  14.      * 测试Feign客户端单独控制
  15.      * @param id
  16.      * @return
  17.      */
  18.     @GetMapping(value = "/user/{id}")
  19.     public User getUserNotHystrix(@PathVariable Long id){
  20.         //获取数据
  21.         return userFeignNotHystrixClient.getUserNotHystrix(id);
  22.     }
  23. }

7. 4. 两个FeignClient

一个加了configuration一个没有，加了可以通过注解重写feignBuilder方法单独控制，默认是返回HystrixFeignBuilder

  1. @FeignClient(name = "provider-user", fallback = HystrixClientFallback.class)
  2. public interface UserFeignClient {
  3.     @RequestMapping (value = "/user/{id}", method = RequestMethod.GET)
  4.     User getUser(@PathVariable Long id);
  5. }
  7. @Component
  8. public class HystrixClientFallback implements UserFeignClient{
  9.     @Override
  10.     public User getUser(Long id) {
  11.         System.out.println(Thread.currentThread().getId());
  12.         User user = new User();
  13.         user.setId(1L);
  14.         return user;
  15.     }
  16. }
  1. @FeignClient(name = "provider-user1",configuration = ConfigurationNotHystrix.class,fallback = HystrixClientNotHystrixFallback.class)
  2. public interface UserFeignNotHystrixClient {
  3.     @RequestMapping (value = "/user/{id}", method = RequestMethod.GET)
  4.     User getUserNotHystrix(@PathVariable Long id);
  5. }
  7. @Component
  8. public class HystrixClientNotHystrixFallback implements UserFeignNotHystrixClient{
  9.     @Override
  10.     public User getUserNotHystrix(Long id) {
  11.         System.out.println(Thread.currentThread().getId());
  12.         User user = new User();
  13.         user.setId(1L);
  14.         return user;
  15.     }
  16. }

7. 5. 配置类

  1. @Configuration
  2. public class ConfigurationNotHystrix {
  4.     @Bean
  5.     @Scope("prototype")
  6.     public Feign.Builder feignBuilder(){
  7.         return Feign.builder();
  8.     }
  9. }

7. 6. 获取异常信息代码

  1. @FeignClient(name = "hello", fallbackFactory = HystrixClientFallbackFactory.class)
  2. protected interface HystrixClient {
  3.     @RequestMapping(method = RequestMethod.GET, value = "/hello")
  4.     Hello iFailSometimes();
  5. }
  7. @Component
  8. static class HystrixClientFallbackFactory implements FallbackFactory<HystrixClient> {
  9.     @Override
  10.     public HystrixClient create(Throwable cause) {
  11.         return new HystrixClient() {
  12.             @Override
  13.             public Hello iFailSometimes() {
  14.                 return new Hello("fallback; reason was: " + cause.getMessage());
  15.             }
  16.         };
  17.     }
  18. }

8. Zuul

Zuul是Spring Cloud全家桶中的微服务API网关。

所有从设备或网站来的请求都会经过Zuul到达后端的Netflix应用程序。作为一个边界性质的应用程序，Zuul提供了动态路由、监控、弹性负载和安全功能。Zuul底层利用各种filter实现如下功能：

认证和安全 识别每个需要认证的资源，拒绝不符合要求的请求。

性能监测 在服务边界追踪并统计数据，提供精确的生产视图。

动态路由 根据需要将请求动态路由到后端集群。

压力测试 逐渐增加对集群的流量以了解其性能。

负载卸载 预先为每种类型的请求分配容量，当请求超过容量时自动丢弃。

静态资源处理 直接在边界返回某些响应。

8. 1. 编写一个Zuul网关

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

application.yml 配置

  1. zuul:
  2.   ignoredServices: '*' #剔除的链接，*代表所有
  3.   routes:
  4.     lyh-provider-user: /myusers/** #自定义的反向代理url

8. 2. Zuul的fallback机制

需要实现回退的接口FallbackProvider，当服务不可用时，就会走fallback，源码如下

  1. @Component
  2. public class ZuulFallbackProvider implements FallbackProvider {
  3.     /**
  4.      * fallback的路由返回服务名，“*”匹配所有
  5.      * @return
  6.      */
  7.     @Override
  8.     public String getRoute() {
  9.         return "lyh-provider-user";
  10.     }
  12.     /**
  13.      * fallbacl响应，可以用于异常信息的记录
  14.      * @param route
  15.      * @param cause
  16.      * @return
  17.      */
  18.     @Override
  19.     public ClientHttpResponse fallbackResponse(String route, Throwable cause) {
  20.         if (cause instanceof HystrixTimeoutException) {
  21.             return response(HttpStatus.GATEWAY_TIMEOUT);
  22.         } else {
  23.             return response(HttpStatus.INTERNAL_SERVER_ERROR);
  24.         }
  25.     }
  26.     private ClientHttpResponse response(final HttpStatus status) {
  27.         return new ClientHttpResponse() {
  28.             @Override
  29.             public HttpStatus getStatusCode() throws IOException {
  30.                 //当fallback时返回给调用者的状态码
  31.                 return status;
  32.             }
  34.             @Override
  35.             public int getRawStatusCode() throws IOException {
  36.                 return status.value();
  37.             }
  39.             @Override
  40.             public String getStatusText() throws IOException {
  41.                 //状态码的文本形式
  42.                 return status.getReasonPhrase();
  43.             }
  45.             @Override
  46.             public void close() {
  47.             }
  49.             @Override
  50.             public InputStream getBody() throws IOException {
  51.                 //响应体
  52.                 return new ByteArrayInputStream("fallback".getBytes());
  53.             }
  55.             @Override
  56.             public HttpHeaders getHeaders() {
  57.                 //设定headers
  58.                 HttpHeaders headers = new HttpHeaders();
  59.                 headers.setContentType(MediaType.APPLICATION_JSON);
  60.                 return headers;
  61.             }
  62.         };
  63.     }
  64. }

8. 3. Zuul 的Filter

8. 3. 1. Zuul中的Filter

Zuul是围绕一系列Filter展开的，这些Filter在整个HTTP请求过程中执行一连串的操作。

Zuul Filter有以下几个特征：

Type：用以表示路由过程中的阶段（内置包含PRE、ROUTING、POST和ERROR）

Execution Order：表示相同Type的Filter的执行顺序

Criteria：执行条件

Action：执行体

Zuul提供了动态读取、编译和执行Filter的框架。各个Filter间没有直接联系，但是都通过RequestContext共享一些状态数据。

尽管Zuul支持任何基于JVM的语言，但是过滤器目前是用Groovy编写的。 每个过滤器的源代码被写入到Zuul服务器上的一组指定的目录中，这些目录将被定期轮询检查是否更新。Zuul会读取已更新的过滤器，动态编译到正在运行的服务器中，并后续请求中调用。

8. 3. 2. Filter Types

以下提供四种标准的Filter类型及其在请求生命周期中所处的位置：

PRE Filter：在请求路由到目标之前执行。一般用于请求认证、负载均衡和日志记录。

ROUTING Filter：处理目标请求。这里使用Apache HttpClient或Netflix Ribbon构造对目标的HTTP请求。

POST Filter：在目标请求返回后执行。一般会在此步骤添加响应头、收集统计和性能数据等。

ERROR Filter：整个流程某块出错时执行。

除了上述默认的四种Filter类型外，Zuul还允许自定义Filter类型并显示执行。例如，我们定义一个STATIC类型的Filter，它直接在Zuul中生成一个响应，而非将请求在转发到目标。

8. 3. 3. Zuul请求生命周期



一图胜千言，下面通过官方的一张图来了解Zuul请求的生命周期。

8. 3. 4. 自定义一个filter

需要继承ZuulFilter类

  1. public class PreZuulFilter extends ZuulFilter {
  2.     @Override
  3.     public String filterType() {
  4.         return "pre";
  5.     }
  7.     @Override
  8.     public int filterOrder() {
  9.         return 5;
  10.     }
  12.     @Override
  13.     public boolean shouldFilter() {
  14.         return true;
  15.     }
  17.     @Override
  18.     public Object run() throws ZuulException {
  19.         String requestURI = RequestContext.getCurrentContext().getRequest().getRequestURI();
  20.         System.out.println(requestURI);
  21.         return requestURI;
  22.     }
  23. }

将自定义的filter通过@Bean注入

  1. @Bean
  2.     public PreZuulFilter preZuulFilter(){
  3.         return new PreZuulFilter();
  4.     }

filter配置

  1. zuul:
  2.   PreZuulFilter:  #过滤器类名
  3.     pre:  #过滤类型
  4.       disable: false
8. 3. 5. zuul上传下载

zuul一样可以正常的上传下载，要注意的是他使用的是默认大小配置，想要上传大文件 需要在访问的地址前加/zuul/服务地址，同时需要配置超时时间

  1. #当上传大文件是在serviceid前加zuul/ 如：zuul/servcieid/*,且需要配置ribbon的超时时间和hystrix的超时时间，防止报错后走hystrix的退回代码
  2. hystrix.command.default.execution.isolation.thread.timeoutInMilliseconds: 60000
  3. ribbon:
  4.   ConnectTimeout: 3000
  5.   ReadTimeout: 60000

9. springCloud的Config

9. 1. 什么是spring cloud config

在分布式系统中，spring cloud config 提供一个服务端和客户端去提供可扩展的配置服务。我们可用用配置服务中心区集中的管理所有的服务的各种环境配置文件。配置服务中心采用Git的方式存储配置文件，因此我们很容易部署修改，有助于对环境配置进行版本管理。

Spring Cloud Config就是云端存储配置信息的,它具有中心化,版本控制,支持动态更新,平台独立,语言独立等特性。其特点是：

  1. a.提供服务端和客户端支持(spring cloud config server和spring cloud config client)
  2. b.集中式管理分布式环境下的应用配置
  3. c.基于Spring环境，无缝与Spring应用集成
  4. d.可用于任何语言开发的程序
  5. e.默认实现基于git仓库，可以进行版本管理

spring cloud config包括两部分：

  • spring cloud config server 作为配置中心的服务端
  1. 拉取配置时更新git仓库副本，保证是最新结果
  2. 支持数据结构丰富，yml, json, properties 等
  3. 配合 eureke 可实现服务发现，配合 cloud bus 可实现配置推送更新
  4. 配置存储基于 git 仓库，可进行版本管理
  5. 简单可靠，有丰富的配套方案
  • Spring Cloud Config Client 客户端

Spring Boot项目不需要改动任何代码，加入一个启动配置文件指明使用ConfigServer上哪个配置文件即可

9. 2. 简单的使用

服务端配置使用

首先需要添加相关依赖

  1. <dependency>
  2.   <groupId>org.springframework.cloud</groupId>
  3.   <artifactId>spring-cloud-config-server</artifactId>
  4. </dependency>
  5. <dependency>
  6.   <groupId>org.springframework.cloud</groupId>
  7.   <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
  8. </dependency>

启动类

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

本地方式配合Eureka配置

  1. spring:
  2.   application:
  3.     name: config-server
  4.   cloud:
  5.     config:
  6.       name: config-server
  7.       server:
  8.         native:
  9.           search-locations: classpath:/config
  10.         bootstrap: true
  11.         #配置git方式
  12.         #git:
  13.           #uri:  #配置git仓库地址
  14.           #username: #访问git仓库的用户名
  15.           #password: #访问git仓库的用户密码
  16.           #search-paths: #配置仓库路径
  17.       #label: master #git使用，默认master
  18.   profiles:
  19.     active: native  #开启本地配置
  20. server:
  21.   port: 8080
  22. eureka:
  23.   client:
  24.     service-url:
  25.       defaultZone: http://user:123@localhost:8761/eureka

在resources下创建 文件夹config，在config下创建文件

  1. lyh-provider-user-dev.yml
  2. 内容为：
  3. profile: lyh-provider-user-dev
  5. lyh-provider-user-pro.yml
  6. 内容为：
  7. profile: lyh-provider-user-pro

客户端配置

添加依赖

  1. <dependency>
  2.     <groupId>org.springframework.boot</groupId>
  3.     <artifactId>spring-boot-starter-web</artifactId>
  4. </dependency>
  5. <dependency>
  6.     <groupId>org.springframework.cloud</groupId>
  7.     <artifactId>spring-cloud-starter-config</artifactId>
  8. </dependency>
  9. <dependency>
  10.     <groupId>org.springframework.cloud</groupId>
  11.     <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
  12. </dependency>
  13. <dependency>
  14.     <groupId>org.springframework.cloud</groupId>
  15.     <artifactId>spring-cloud-starter-bus-amqp</artifactId>
  16. </dependency>
  17. <dependency>
  18.     <groupId>org.springframework.boot</groupId>
  19.     <artifactId>spring-boot-starter-actuator</artifactId>
  20. </dependency>
  1. server:
  2.   port: 7900 #程序启动入口
  3. spring:
  4.   application:
  5.     name: lyh-provider-user #应用名称
  6.   cloud:
  7.     config:
  8.       profile: dev
  9.       discovery: #使用eureka的发现寻找config-server的服务
  10.         enabled: true
  11.         service-id: config-server
  12.       name: lyh-provider-user
  13.       #uri: http://localhost:8080   这里可以是git地址
  14. #trace信息 配置
  15.     bus:
  16.       trace:
  17.         enabled: true
  18. #配合rabbitmq实现自动刷新参数
  19.     rabbitmq: #配置rabbitmq实现自动刷新
  20.       host: localhost
  21.       port: 5672
  22.       username: guest
  23.       password: guest
  24. eureka:
  25.   client:
  26.     service-url:
  27.       defaultZone: http://user:123@localhost:8761/eureka
  28. #健康监控配置
  29. management:
  30.   endpoint:
  31.     health:
  32.       show-details: always #是否健康监控显示细节
  33.     refresh:
  34.       enabled: true
  35.   endpoints:
  36.     web:
  37.       exposure:
  38.         include: "*"  #放开所有地址，跳过安全拦截
  39.       base-path: /

客户端测试代码，@RefreshScope注解实现参数的刷新

  1. @RestController
  2. @RefreshScope
  3. public class UserController {
  4.     @Value("${profile}")
  5.     private String profile;
  6.     @GetMapping (value = "/profile")
  7.     public String getProfile(){
  8.        return this.profile;
  9.     }
  10. }

访问后我们就能拿到config服务的profile配置上数据

Springcloud技术分享的更多相关文章

  1. fir.im Weekly - 新开发时代，需要什么样的技术分享

    "2016年,当我们迎来了如Xcode 8.Swift 3.SiriKit.Android N.Android Instant Apps.React Native等诸多移动开发技术.开发工具 ...

  2. 【转发】网易邮箱前端技术分享之javascript编码规范

    网易邮箱前端技术分享之javascript编码规范 发布日期:2013-11-26 10:06 来源:网易邮箱前端技术中心 作者:网易邮箱 点击:533 网易邮箱是国内最早使用ajax技术的邮箱.早在 ...

  3. CDN技术分享

    CDN技术分享目录 网络应用服务发展 CDN技术 1.CDN是什么?为什么我们需要它?(简介) 2.CDN能做什么?(作用) 3.CDN是如何工作?(原理) 4.CDN有那些具体应用?(应用) 我们项 ...

  4. 【转】apache kafka技术分享系列(目录索引)

    转自:  http://blog.csdn.net/lizhitao/article/details/39499283   估计大神会不定期更新,所以还是访问这个链接看最新的目录list比较好 apa ...

  5. 感知开源的力量-APICloud Studio开源技术分享会

    2014.9.15 中国领先的“云端一体”移动应用云服务提供商APICloud正式发布2015.9.15,APICloud上线一周年,迎来第一个生日这一天,APICloud 举办APICloud St ...

  6. HTML5学堂 全新的HTML5/前端技术分享平台

    HTML5学堂 全新的HTML5/前端技术分享平台 HTML5学堂是做什么的? HTML5学堂~http://www.h5course.com~由多名热爱H5的讲师们组成的一个组织.致力于构建一个前端 ...

  7. 内部技术分享的 PPT

    本文的基础是搞了一次内部的技术分享,在此也分享一下本次的PPT的一些内容.先列一下大概内容吧. EF-Code First API(WCF.WebAPI) Xaml MVVM AOP Xamarin. ...

  8. 恒天云技术分享系列5 – 虚拟化平台性能对比（KVM & VMware）

    恒天云技术分享系列:http://www.hengtianyun.com/download-show-id-14.html 概述 本性能测试报告将详细陈述各虚拟化平台基准性能测试的主要结论和详细结果. ...

  9. 恒天云技术分享系列4 – OpenStack网络攻击与防御

    恒天云技术分享系列:http://www.hengtianyun.com/download-show-id-13.html 云主机的网络结构本质上和传统的网络结构一致,区别大概有两点. 1.软网络管理 ...

随机推荐

  1. P1004 方格取数(四维动态规划)

    题目描述 设有N \times NN×N的方格图(N \le 9)(N≤9),我们将其中的某些方格中填入正整数,而其他的方格中则放入数字00.如下图所示(见样例): A 0 0 0 0 0 0 0 0 ...

  2. python模块：excel的读和修改xlrd/xultils

    一.xlrd xlrd只能对excel进行读取,不可编辑修改.该模块属于第三方模块,需要安装模块包并引入.pip install xlrd 常用的方法: import xlrd book = xlrd ...

  3. iptables防火墙说明即使用

    防火墙是架设在公网和私网之间的服务器,隔离公网和私网,保护私网. RHEL7默认使用firewalld作为防火墙. 但firewalld底层还是调用包过滤防火墙iptables #systemctl ...

  4. 最好用的流程编辑器bpmn-js系列之基本使用

    最好用的流程编辑器bpmn-js系列文章 BPMN(Business Process Modeling Notation)是由业务流程管理倡议组织BPMI(The Business Process M ...

  5. HTTP协议（二）---请求和响应

    HTTP通过请求和响应的交换达成通信. HTTP请求 请求报文由请求行(请求方法.请求URI.协议版本).请求首部字段以及内容实体(可能没有)构成. 下面是一个GET请求,没有内容实体: 下面是 一个 ...

  6. java 多线程-3

    十.同步机制解决Thread继承安全问题 创建三个窗口买票,共100张票.用继承来实现 方式一:同步代码块 public class RunMainExtends { public static vo ...

  7. Linux实战（1）：装机一键设置脚本-初级版

    #!/bin/bash #此脚本作用是装完centos后所执行的一系列设置,基本是必须设置的操作,主要分为几大功能:修改yum源,安装ifconfig,安装ping,修改selinux配置 #第一部分 ...

  8. ams入门了解

    另一篇介绍文  https://www.cnblogs.com/clds/p/4985893.html 转载自https://www.cnblogs.com/onlysun/p/4533798.htm ...

  9. QQDIV失效补救

    {"styleId":22,"bgId":3807,"cardId":3807,"renderInfo":{" ...

  10. 12.扩展：向量空间模型算法(Vector Space Model)