>> 欢迎您 客人: 登录 | 注册 | 在线 | 搜索 | 风格 | 帮助 | 统计 | 文章 返回首页
>>分享流行的Java框架以及开源软件,对孙卫琴的《精通Spring》、《Spring Cloud Alibaba微服务开发零基础入门到实操》提供技术支持 书籍支持  卫琴直播  品书摘要  在线测试  资源下载  联系我们
Java技术网站 → 『 Java开发技术 』 → 『 Spring框架和各种开源软件技术专题 』 → SpringCloud快速入门
发表一个新主题 开启一个新投票 回复文章 您是本文章第 27309 个阅读者 刷新本主题
 * 贴子主题:  SpringCloud快速入门 回复文章 点赞(0)  收藏  
作者:sunshine    发表时间：2019-08-17 18:06:29     消息  查看  搜索  好友  邮件  复制  引用
                    

SpringCloud快速入门

  一、  网站的架构演变

     网络架构由最开始的三层mvc渐渐演变。传统的三层架构后来在互联网公司让几百人几千人同时开发一个项目已经变得不可行，并且会产生代码冲突的问题。基于SOA面向服务开发的架构，渐渐产生了微服务架构。微服务的架构的特点就是项目拆分成各个子项目，进行解耦操作，提供外部访问接口，属于敏捷开发，其实也可以视为面向接口开发。

      一旦有了多个子项目，比如把淘宝网的订单系统和会员系统分开来看，就回产生如何管理接口、负载均衡、高并发情况下怎么限流断路等问题。那么这就有SpringCloud出现了。

     那么springCloud的组件大概有哪些呢，我先简单介绍下：
  1. Eureka  服务注册中心
  2. 服务消费者 Rest 和 Fegin  --消费实现负载均衡ribbon
  3. 接口网关Zuul
  4. Hystrix  关于服务雪崩的解决方案--服务熔断、服务降级、隔离资源。

  二、  Eureka

    eureka是个什么东西呢？它是一个服务注册中心。就拿上面的例子来说，如果要查看会员的订单详情，那么就要在会员系统的tomcat里面调用订单系统的tomcat里的方法。那么直接通过接口访问吗显然这是不安全的。因此我们需要一个统一管理远程RPC调用的注册中心：

         点击在新窗口中浏览原图 CTRL+鼠标滚轮放大或缩小

   如图所示，会员系统和订单都是独立能够运行的SpringBoot项目，把SpringBoot注册进eureka中，这样我们就可以通过eureka让会员系统远程调用订单系统。具体配置要怎么做呢？

   首先我们要创建eureka注册中心，这里建议用idea的工具创建SpringBoot项目。

         点击在新窗口中浏览原图 CTRL+鼠标滚轮放大或缩小

   选择如图的包，如果没有则直接复制pom文件        

  1.        <?xml version= "1.0" encoding= "UTF-8" ?>
  2.       < project  xmlns= "http://maven.apache.org/POM/4.0.0"  xmlns:xsi= "http://www.w3.org/2001/XMLSchema-instance"
  3.                xsi:schemaLocation= "http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.           < modelVersion>4.0.0 </ modelVersion>
  5.           < parent>
  6.               < groupId>org.springframework.boot </ groupId>
  7.               < artifactId>spring-boot-starter-parent </ artifactId>
  8.               < version>2.1.3.RELEASE </ version>
  9.               < relativePath/>  <!-- lookup parent from repository -->
  10.           </ parent>
  11.           < groupId>my </ groupId>
  12.           < artifactId>learning </ artifactId>
  13.           < version>0.0.1-SNAPSHOT </ version>
  14.           < name>learning </ name>
  15.           < description>Demo project for Spring Boot </ description>
  17.           < properties>
  18.               < java.version>1.8 </ java.version>
  19.               < spring-cloud.version>Greenwich.SR1 </ spring-cloud.version>
  20.           </ properties>
  22.           < dependencies>
  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-netflix-eureka-server </ artifactId>
  30.               </ dependency>
  32.               < dependency>
  33.                   < groupId>org.springframework.boot </ groupId>
  34.                   < artifactId>spring-boot-starter-test </ artifactId>
  35.                   < scope>test </ scope>
  36.               </ dependency>
  37.           </ dependencies>
  39.           < dependencyManagement>
  40.               < dependencies>
  41.                   < dependency>
  42.                       < groupId>org.springframework.cloud </ groupId>
  43.                       < artifactId>spring-cloud-dependencies </ artifactId>
  44.                       < version>${spring-cloud.version} </ version>
  45.                       < type>pom </ type>
  46.                       < scope>import </ scope>
  47.                   </ dependency>
  48.               </ dependencies>
  49.           </ dependencyManagement>
  51.           < build>
  52.               < plugins>
  53.                   < plugin>
  54.                       < groupId>org.springframework.boot </ groupId>
  55.                       < artifactId>spring-boot-maven-plugin </ artifactId>
  56.                   </ plugin>
  57.               </ plugins>
  58.           </ build>
  60.           < repositories>
  61.               < repository>
  62.                   < id>spring-milestones </ id>
  63.                   < name>Spring Milestones </ name>
  64.                   < url>https://repo.spring.io/milestone </ url>
  65.               </ repository>
  66.           </ repositories>
  68.       </ project>

      然后我们去yml文件中做如下配置        

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

       然后在启动类里添加表示为eureka注册中心        

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

       通过localhost:8888可以进到如下页面就表示eureka注册中心启动成功

         点击在新窗口中浏览原图 CTRL+鼠标滚轮放大或缩小

      OK，那么我们要怎么把订单系统和会员系统注册进去呢？同样创建两个SpringBoot项目，创建方式和导包方式和注册中心一样。我们关注的只有yml文件是如何把这个springBoot项目注册进去的，那么我们来看看yml文件如何配置        

  1.      eureka:
  2.        client:
  3.          serviceUrl:
  4.       #      eureka的注册中心地址
  5.            defaultZone: http: //localhost:8888/eureka/
  6.      server:
  7.       #  此项目端口号
  8.        port:  8889
  9.      spring:
  10.        application:
  11.       #    注册进eureka的名字
  12.          name: order-server

        创建controller包并且启动        

  1.       @RestController
  2.       public   class  ordercontroller {
  3.           @RequestMapping( "orderTest")
  4.            public String  orderTest (){
  5.               return  "this is order";
  6.          }
  7.      }
  9.       //  启动类
  10.       @EnableEurekaClient  
  11.       @SpringBootApplication
  12.       public   class  DemoApplication {
  14.            public  static  void  main (String[] args) {
  15.              SpringApplication.run(DemoApplication.class, args);
  16.          }
  18.      }

        再次打开注册中心网页，就发现已经注册进去

         点击在新窗口中浏览原图 CTRL+鼠标滚轮放大或缩小

     重复以上步骤把会员系统也注册进去

         点击在新窗口中浏览原图 CTRL+鼠标滚轮放大或缩小    

    三、  PRC远程调用的方法

     远程调用的方法有两种，我们一一来细说。

     1.  第一种，通过rest的方式来调用，首先我们要导入rest的pom依赖，我们要使用用户调用订单，就在用户里添加调用依赖。先解释一下什么是ribbon-----ribbon是一个负载均衡客户端 类似nginx反向代理，可以很好的控制htt和tcp的一些行为。
   <dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-starter-ribbon</artifactId>
  </dependency>
  1.       //  在启动类里把ribbon类注入spring
  2.       @EnableEurekaClient
  3.       @SpringBootApplication
  4.       public   class  DemoApplication {
  6.            public  static  void  main (String[] args) {
  7.              SpringApplication.run(DemoApplication.class, args);
  8.          }
  9.           @Bean
  10.           @LoadBalanced         // 开启负载均衡
  11.            public RestTemplate  restTemplate (){
  12.               return  new RestTemplate();
  13.          }
  14.      }
  16.       public   class  memService{
  17.           @Autowired
  18.           private RestTemplate restTemplate;
  19.           @RequestMapping( "/memTest")
  20.            public String  memTest (){
  21.              String str = restTemplate.getForObject( "http://order-server/orderTest",String.class);
  22.               return str;
  23.          }
  24.      }

       然后我们调用会员系统的接口访问，看他会不会走到订单系统里

         点击在新窗口中浏览原图 CTRL+鼠标滚轮放大或缩小

    这就是Rest远程调用的结果。

             2.  Feigin

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

     简而言之：

          ·Feign 采用的是基于接口的注解

          ·Feign 整合了ribbon

     第一步依然是导入依赖    
     < dependency >    
     < groupId >org.springframework.cloud </ groupId >    
   < artifactId >spring-cloud-starter-feign </ artifactId >
   </ dependency >
  1.       @Service
  2.       @FeignClient( "order-server")
  3.       public   interface  orderFeign {
  4.           @RequestMapping( "/orderTest")
  5.            public String  orderTest ();
  6.      }
  7.       @RestController
  8.       public   class  memController {
  9.           @Autowired
  10.           private OrderFeign orderFeign;
  11.           @RequestMapping( "/memTest")
  12.            public String  memTest (){
  13.              String str = orderFeign.orderTest();
  14.               return str;
  15.          }
  16.      }
  18.       // 启动类
  19.       @EnableEurekaClient
  20.       @EnableFeignClients
  21.       @SpringBootApplication
  22.       public   class  DemoApplication {
  24.            public  static  void  main (String[] args) {
  25.              SpringApplication.run(DemoApplication.class, args);
  26.          }
  28.      }

       点击在新窗口中浏览原图 CTRL+鼠标滚轮放大或缩小

         因此成功。这两个方式使用ribbon均衡负载，一个需要手动启动，fegin是自动启动。    

  四、  路由网关（ZUUL）

         路由网关有什么作用呢？上面订单和会员系统已经注册进服务中心，两者之间是通过网址直接访问。但是如果在浏览器里由订单访问会员，会因为域名不同而导致跨域问题。跨域问题的解决方案可以使用http client设置、设置请求头、nginx转发解决，那么在SpringCloud里面当然提供了一套解决方案，那就是网关ZUUL。

         点击在新窗口中浏览原图 CTRL+鼠标滚轮放大或缩小

         如图所示，当一个客户端如果直接访问时，会因为域名不同导致跨域问题。而我们所需要做的就是在前面设置一个网关变成my.com/vip  my.com/order，这样就不会产生跨域的问题。接下来我们来设置zuul。

             第一步首先也要注册进eureka,导入依赖。        

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

        第二步配置yml文件..        

  1.       #注册进eureka
  2.      eureka:
  3.        client:
  4.          serviceUrl:
  5.            defaultZone: http: //localhost:8888/eureka/
  6.       #配置网关端口号
  7.      server:
  8.        port:  8080
  9.      spring:
  10.        application:
  11.          name: zuul-server
  12.       #配置网关转发详情
  13.      zuul:
  14.        routes:
  15.          api-a:
  16.            path: /member  /**
  17.             service-id: member-server
  18.           api-b:
  19.             path: /order/**
  20.             service-id: order-server

  1.       //  开启网关
  2.       @EnableZuulProxy
  3.       @SpringBootApplication
  4.       public   class  DemoApplication {
  6.            public  static  void  main (String[] args) {
  7.              SpringApplication.run(DemoApplication.class, args);
  8.          }
  10.      }

       点击在新窗口中浏览原图 CTRL+鼠标滚轮放大或缩小

          访问配置的网关地址8080，调用member-server里的方法，成功！还可以使用网关过滤信息。具体怎样过滤不做赘述。    

  五、  断路器（Hystrix)

   为什么需要 Hystrix?

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

   什么 是服务雪崩

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

          通俗来说： 就是对一个方法的PRC调用并发数量太大        

    服务雪崩应对策略

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

           1.  流量控制

           2.  改进缓存模式

           3.  服务自动扩容

           服务调用者降级服务

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

           · 网关限流

           · 用户交互限流

           · 关闭重试                      

     什么 是服务降级

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

         通俗解释来说：就是上面例子里的会员系统访问订单系统，执行远程RPC调用方法，但是当达到一定并发量的时候，比如200个人同时访问 orderTest()方法时，tomcat的容量设置的只有150个，剩余的50个人就在外面等待一直等待。服务降级就是不让他们一直等待，调用本地的方法来fallback消息。而不再去PRC方法。

         Hystrix的作用

          1.断路器机制

          断路器很好理解, 当Hystrix Command请求后端服务失败数量超过一定比例(默认50%), 断路器会切换到开路状态(Open). 这时所有请求会直接失败而不会发送到后端服务. 断路器保持在开路状态一段时间后(默认5秒), 自动切换到半开路状态(HALF-OPEN). 这时会判断下一次请求的返回情况, 如果请求成功, 断路器切回闭路状态(CLOSED), 否则重新切换到开路状态(OPEN). Hystrix的断路器就像我们家庭电路中的保险丝, 一旦后端服务不可用, 断路器会直接切断请求链, 避免发送大量无效请求影响系统吞吐量, 并且断路器有自我检测并恢复的能力.

          2.Fallback

          Fallback相当于是降级操作. 对于查询操作, 我们可以实现一个fallback方法, 当请求后端服务出现异常的时候, 可以使用fallback方法返回的值. fallback方法的返回值一般是设置的默认值或者来自缓存.

          3.资源隔离

          在Hystrix中, 主要通过线程池来实现资源隔离. 通常在使用的时候我们会根据调用的远程服务划分出多个线程池. 例如调用产品服务的Command放入A线程池, 调用账户服务的Command放入B线程池. 这样做的主要优点是运行环境被隔离开了. 这样就算调用服务的代码存在bug或者由于其他原因导致自己所在线程池被耗尽时, 不会对系统的其他服务造成影响. 但是带来的代价就是维护多个线程池会对系统带来额外的性能开销. 如果是对性能有严格要求而且确信自己调用服务的客户端代码不会出问题的话, 可以使用Hystrix的信号模式(Semaphores)来隔离资源.

         第一步首先是导入依赖        

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

           Rest方式调用        

  1.       @HystrixCommand(fallbackMethod =  "testError")
  2.       @RequestMapping( "/memTest")
  3.            public String  memTest (){
  4.              String str = restTemplate.getForObject( "http://order-server/orderTest",String.class);
  5.               return str;
  6.          }
  7.            public String  testError (){
  8.               //远程调用失败，调用此方法
  9.          }
  12.       //启动方式
  13.       @EnableEurekaClient
  14.       @EnableHystrix
  15.       @SpringBootApplication
  16.       public   class  MemApp {
  18.        public  static  void  main (String[] args) {
  19.      SpringApplication.run(OrderApp.class, args);
  20.      }

   Fegin方式调用
          yml文件新增配置
   feign:

            <u><u>hystrix</u></u>:

               enabled:   true
      注册一个继承了Fegin接口的类到Spring容器中        

  1.       @Component
  2.       public   class  MemberFeignService  implements  orderFeign {
  4.      public String errorMsg {
  5.      return  "出错啦";
  6.      }
  7.      }
  9.       @Service
  10.       @FeignClient( "order-server"，fallback=MemberFeignService.class)
  11.       public   interface  orderFeign {
  12.           @RequestMapping( "/orderTest")
  13.            public String  orderTest ();
  14.      }

         所以整个流程就是并发访问量太大导致服务雪崩。然后出发PRC的熔断机制。最后会根据情况来进行隔离资源。

                                                                                        
----------------------------
原文链接:https://blog.csdn.net/weixin_44448094/article/details/88535475

程序猿的技术大观园：www.javathinker.net



[这个贴子最后由 flybird 在 2020-03-05 10:39:23 重新编辑]
Java精品书籍推荐
Java最新视频教程推荐
  Java面向对象编程-->Java语言的基本语法和规范
  JavaWeb开发-->使用过滤器
  JSP与Hibernate开发-->Spring、JPA与Hibernate的整合
  Java网络编程-->基于MVC和RMI的分布式应用
  精通Spring-->Vue CLI脚手架工具
  Vue3开发-->Vue CLI脚手架工具
本站其他相关文章
  git 常用指令总结
  微服务架构模型
  @Service注解的使用
  Spring MVC记录日志的三种方式
  SpringMVC 中 @ControllerAdvice 注解的三种使用场景！
  Spring MVC处理静态资源文件的方式
  【项目实践】后端接口统一规范的同时，如何优雅地扩展规范
  Spring MVC数据验证
  微服务架构的优点和缺点
  Spring+JPA+ehcache开启二级本地缓存
  分布式消息队列RocketMQ部署与监控
  Spring MVC：切面的应用
  Spring @Transactional注解失效解决方案
  Spring AOP的本质
  大话微服务」深入聊聊SpringCloud之客户端负载均衡机制
  更多...
 IPIP: 已设置保密
楼主      
该用户目前不在线 nihaota 
  
威望: 0
级别: 新手上路
魅力: 1315
经验: 1315
现金: 2944
发文章数: 243 篇
注册时间: 0001-01-01
 消息  查看  搜索  好友  邮件  复制  引用

讨债公司
发文章时间 2022-10-28 20:58:23
 IPIP: 已设置保密 第 1 楼     
共1页 1条记录 当前第1页
发表一个新主题 开启一个新投票 回复文章

中文版权所有： JavaThinker技术网站 Copyright 2016-2026 沪ICP备16029593号-2
荟萃Java程序员智慧的结晶，分享交流Java前沿技术。  联系我们
如有技术文章涉及侵权，请与本站管理员联系。