SpringCloud-微服务架构之浅尝辄止

SpringCloud

SpringCloud的简单了解

1. 微服务框架
   • 单一职责：微服务中每一个服务都对应唯一的业务能力，做到单一职责
   • 微：微服务的服务拆分粒度很小，例如一个用户管理就可以作为一个服务。每个服务虽小，但“五脏俱全”。
   • 面向服务：面向服务是说每个服务都要对外暴露服务接口API。并不关心服务的技术实现，做到与平台和语言无关，也不限定用什么技术实现，只要提供Rest的接口即可。
   • 自治：自治是说服务间互相独立，互不干扰
     • 团队独立：每个服务都是一个独立的开发团队，人数不能过多。
     • 技术独立：因为是面向服务，提供Rest接口，使用什么技术没有别人干涉
     • 前后端分离：采用前后端分离开发，提供统一Rest接口，后端不用再为PC、移动段开发不同接口
     • 数据库分离：每个服务都使用自己的数据源
     • 部署独立，服务间虽然有调用，但要做到服务重启不影响其它服务。有利于持续集成和持续交付。每个服务都是独立的组件，可复用，可替换，降低耦合，易维护

SpringCloud核心组件–Eureka

1. Eureka : 注册中心, 下图为基本架构
   
   • Eureka : 服务注册中心,对外暴露自己的地址
   • 提供者 : 启动后向Eureka注册自己信息,(地址,提供什么服务)
   • 消费者 : 向Eureka订阅服务,Eureka会将对应服务的所有提供者地址列表发送给消费者,并且定时更新.
   • 心跳 : 提供者定期通过http方式向Eureka刷新自己的状态.
2. Eureka的快速入门 – 服务端

   1. 添加依赖

       <dependencies>
              <!-- Eureka服务端 -->
              <dependency>
                  <groupId>org.springframework.cloud</groupId>
                  <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
              </dependency>
        </dependencies>
      

   2. 加上注解

      @EnableEurekaServer     // 声明这个应用是一个EurekaServer
      @SpringBootApplication(exclude= {DataSourceAutoConfiguration.class})
      public class EurekaDemoApplication {
          public static void main(String[] args) {
              SpringApplication.run(EurekaDemoApplication.class,args);
          }
      }
      

   3. 进行配置

      server:
        port: 10086  # 端口
      
      spring:
        application:
          name: eureka-server # 应用名称,会在eureka中显示
      
      eureka:
        client:
          register-with-eureka: false # 是否注册自己的信息到EurekaServer，默认是true
          fetch-registry: false # 是否拉取其它服务的信息，默认是true
          service-url: # EurekaServer的地址，现在是自己的地址，如果是集群，需要加上其它Server的地址。
            defaultZone: http://127.0.0.1:10086/eureka
      

3. Eureka的快速入门 – 客户端
   1. 添加依赖 : 把服务端依赖server改为client即可
   2. 加上注解 : 把@EnableEurekaServer改为@EnableDiscoveryClient // 开启EurekaClient功能
   3. 进行配置 :

      server:
        port: 10000  # 端口
      
      spring:
        application:
          name: user-provider# 应用名称,会在eureka中显示
      
      eureka:
        client:
          service-url: # 向服务端注册信息
            defaultZone: http://127.0.0.1:10086/eureka
         server:
      	    eviction-interval-timer-in-ms: 30000  # 服务续约(renew)的间隔
      	    lease-expiration-duration-in-seconds: 90000 # 服务失效时间
      

• 小提示 : -Dserver.port=8088 等同于修改了server的端口号

负载均衡Robbin

1. 通过负载均衡算法，在多个实例列表中进行选择,从而实现负载均衡的功能.
2. 使用 :

   1. 在RestTemplate 上添加@LoadBalanced注解

      @Bean
          @LoadBalanced
          public RestTemplate restTemplate(){
              return new RestTemplate();
          }
      

   2. 修改URL表达式 :

       // 地址直接写服务名称即可
       String baseUrl = "http://user-service/user/";
      

Hystix

1. 概念 : Hystix，即熔断器。是Netflix开源的一个延迟和容错库，用于隔离访问远程服务、第三方库，防止出现级联失败。
   
2. 解决的问题 : 雪崩效应
   远程调用微服务时,如果有一个服务挂掉啦,调用该服务的进程都会出现问题,调用的多啦都无法实现功能且占用系统资源,引起系统雪崩效应.
3. 使用 :

   1. 消费端添加依赖 :

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

   2. 启动类上加上注解 : @EnableCircuitBreaker

   3. 编写降级逻辑 : 成功的话正常操作,失败友好处理.

       @HystrixCommand(fallbackMethod = "queryUserByIdFallback")
       public String xxx(xx){
      	 xx;
      	 return : "xx"
       }
        public String queryUserByIdFallback(xx){
        	xx;
        	 return : "服务器太忙,请稍后重试"
      }
      

   4. 为了简化开发,通常在类上添加@DefaultProperties(defaultFallback = “queryUserByIdFallback”) 在方法上声明使用熔断隔离 @HystrixCommand()

   5. 自定义超时时长 :

      hystrix:
        command:
        	default:
              execution:
                isolation:
                  thread:
                    timeoutInMillisecond: 6000 # 设置hystrix的超时时间为6000ms
      

4. 熔断原理 :
   1. 就跟电路上的闸差不多。它有三种状态：关闭，开启和半开。最开始是关闭状态的，这个时候所有请求都可以通过；如果错误请求达到一定的阈值，就会变成开启状态，就会让所有请求短路，直接返回失败的响应；一段时间后，断路器会变成半开状态，如果下一个请求成功了，就关闭断路器，反之就开启断路器。”
   2. 如何设置
      1. hystrix.command.default.circuitBreaker.requestVolumeThreshold（当在配置时间窗口内达到此数量的失败后，进行短路。默认20个）简言之，10s内请求失败数量达到20个，断路器就会变成打开状态。
      2. hystrix.command.default.circuitBreaker.sleepWindowInMilliseconds（短路多久以后开始尝试是否恢复，默认5s）
      3. hystrix.command.default.circuitBreaker.errorThresholdPercentage（出错百分比阈值，当达到此阈值后，开始短路。默认50%）

Feign

1. 为什么叫伪装？
   Feign可以把Rest的请求进行隐藏，伪装成类似SpringMVC的Controller一样。你不用再自己拼接url，拼接参数等等操作，一切都交给Feign去做。
2. 快速入门

   1. 创建maven项目并导入依赖

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

   2. 创建feign的客户端

      @FeignClient("user-service")
      public interface UserFeignClient {
      
          @GetMapping("/user/{id}")
          User queryUserById(@PathVariable("id") Long id);
      }
      

      • 首先这是一个接口，Feign会通过动态代理，帮我们生成实现类。这点跟mybatis的mapper很像
      • @FeignClient，声明这是一个Feign客户端，类似@Mapper注解。同时通过value属性指定服务名称
      • 接口中的定义方法，完全采用SpringMVC的注解，Feign会根据注解帮我们生成URL，并访问获取结果改造原来的调用逻辑，不再调用UserDao：

   3. 在启动类上开启feign功能

      @SpringBootApplication
      @EnableDiscoveryClient
      @EnableHystrix
      @EnableFeignClients // 开启Feign功能
      public class UserConsumerDemoApplication {
          public static void main(String[] args) {
              SpringApplication.run(UserConsumerDemoApplication.class, args);
          }
      }
      

      1. 比较之前,减去了RestTemplate实例,因为feign内置了RestTemplate.

   4. 负载均衡 : feign集成了ribbon,可以通过服务名.ribbon.xx来对指定服务配置

      user-service:
        ribbon:
          ConnectTimeout: 250 # 连接超时时间(ms)
          ReadTimeout: 1000 # 通信超时时间(ms)
          OkToRetryOnAllOperations: true # 是否对所有操作重试
          MaxAutoRetriesNextServer: 1 # 同一服务不同实例的重试次数
          MaxAutoRetries: 1 # 同一实例的重试次数
      

   5. Hystix支持 : feign默认不开启

      1. 开启hystrix功能

         feign:
           hystrix:
             enabled: true # 开启Feign的熔断功能
         

      2. 使用

         1. 我们要定义一个类，实现刚才编写的UserFeignClient，作为fallback的处理类

            @Component
            public class UserFeignClientFallback implements UserFeignClient {
                @Override
                public User queryUserById(Long id) {
                    User user = new User();
                    user.setId(id);
                    user.setName("用户查询出现异常！");
                    return user;
                }
            }
            

         2. 然后在UserFeignClient中，指定刚才编写的实现类

            @FeignClient(value = "user-service", fallback = UserFeignClientFallback.class)
            public interface UserFeignClient {
            
                @GetMapping("/user/{id}")
                User queryUserById(@PathVariable("id") Long id);
            }
            

   6. 请求压缩 : Spring Cloud Feign 支持对请求和响应进行GZIP压缩，以减少通信过程中的性能损耗。通过下面的参数即可开启请求与响应的压缩功能

      feign:
        compression:
          request:
            enabled: true # 开启请求压缩
          response:
            enabled: true # 开启响应压缩
      

Zuul网关

1. Zuul就是网关,起到限流,安全等的作用
2. 快速入门

   1. 创建maven工程

   2. 添加依赖

   3. 编写启动类

      @SpringBootApplication
      @EnableZuulProxy // 开启Zuul的网关功能
      @EnableDiscoveryClient
      public class ZuulDemoApplication {
      public static void main(String[] args) {
      		SpringApplication.run(ZuulDemoApplication.class, args);
      	}
      }
      

   4. 编写配置

      server:
        port: 10010 #服务端口
      spring: 
        application:  
          name: api-gateway #指定服务名
      

   5. 编写路由规则

      eureka:
        client:
          registry-fetch-interval-seconds: 5 # 获取服务列表的周期：5s
          service-url:
            defaultZone: http://127.0.0.1:10086/eureka
        instance:
          prefer-ip-address: true
          ip-address: 127.0.0.1
      zuul:
       routes:
      	user-service: /user-service/** # 这里是映射路径
      

   6. 路由前缀

      zuul:
        prefix: /api # 添加路由前缀
        routes:
            user-service: # 这里是路由id，随意写
              path: /user-service/** # 这里是映射路径
              service-id: user-service # 指定服务名称
      

本文地址：https://blog.csdn.net/zwq56693/article/details/107216995