SpringCloud入门和框架搭建图文教程

最新推荐文章于 2024-07-04 15:04:30 发布
最新推荐文章于 2024-07-04 15:04:30 发布
阅读量482 收藏
点赞数
分类专栏： SpringCloud 文章标签： SpringCloud
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40313468/article/details/103605457
版权

SpringCloud入门和框架搭建图文教程（部分组件）

一. 微服务架构

1.1 什么是分布式

不同模块部署在不同服务器上

作用：分布式解决网站高并发带来问题

1.2 什么是集群

多台服务器部署相同应用构成一个集群

作用：通过负载均衡设备共同对外提供服务

1.3 什么是RPC

RPC 的全称是 Remote Procedure Call 是一种进程间通信方式。

它允许程序调用另一个地址空间（通常是共享网络的另一台机器上）的过程或函数，而不用程序员显式编码这个远程调用的细节。即无论是调用本地接口/服务的还是远程的接口/服务，本质上编写的调用代码基本相同。
比如两台服务器A，B，一个应用部署在A服务器上，想要调用B服务器上应用提供的函数或者方法，由于不在一个内存空间，不能直接调用，这时候需要通过就可以应用RPC框架的实现来解决

1.4 restful、soap、rpc

（1）RESTful是一种架构设计风格，提供了设计原则和约束条件，而不是架构。而满足这些约束条件和原则的应用程序或设计就是 RESTful架构或服务。
（2）SOAP，简单对象访问协议是一种数据交换协议规范，
是一种轻量的、简单的、基于XML的协议的规范。SOAP协议和HTTP协议一样，都是底层的通信协议，只是请求包的格式不同而已，SOAP包是XML格式的。
SOAP的消息是基于xml并封装成了符合http协议，因此，它符合任何路由器、 防火墙或代理服务器的要求。
soap可以使用任何语言来完成，只要发送正确的soap请求即可，基于soap的服务可以在任何平台无需修改即可正常使用。
（3）RPC就是从一台机器（客户端）上通过参数传递的方式调用另一台机器（服务器）上的一个函数或方法（可以统称为服务）并得到返回的结果。
RPC 会隐藏底层的通讯细节（不需要直接处理Socket通讯或Http通讯）
RPC 是一个请求响应模型。客户端发起请求，服务器返回响应（类似于Http的工作方式）
RPC 在使用形式上像调用本地函数（或方法）一样去调用远程的函数（或方法）。

1.5 rpc远程调用框架

几种比较典型的RPC的实现和调用框架。 
（1）RMI实现，利用java.rmi包实现，基于Java远程方法协议(Java Remote Method Protocol) 
和java的原生序列化。 
（2）Hessian，是一个轻量级的remoting onhttp工具，使用简单的方法提供了RMI的功能。 基于HTTP协议，采用二进制编解码。 
（3）thrift是一种可伸缩的跨语言服务的软件框架。thrift允许你定义一个描述文件，描述数据类型和服务接口。依据该文件，编译器方便地生成RPC客户端和服务器通信代码。

（4）SpringCloud 为开发人员提供了快速构建分布式系统的一些工具，包括配置管理、服务发现、断路器、路由、微代理、事件总线、全局锁、决策竞选、分布式会话等等。

1.6 什么是SOA

业务系统分解为多个组件，让每个组件都独立提供离散，自治，可复用的服务能力

通过服务的组合和编排来实现上层的业务流程

作用：简化维护,降低整体风险,伸缩灵活

​​​​​​​1.7 什么是微服务

架构设计概念,各服务间隔离（分布式也是隔离）,自治（分布式依赖整体组合）其它特性(单一职责,边界,异步通信,独立部署)是分布式概念的跟严格执行

 SOA到微服务架构的演进过程

 作用：各服务可独立应用，组合服务也可系统应用(巨石应用[monolith]的简化实现策略-平台思想)

​​​​​​​二. SpringCloud

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

三. 服务提供者与消费关系

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

  消费者:调用被人服务

四. 服务的注册与发现(Eureka )

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

4.1 服务注册 Eureka的作用

这里先简单说明使用eureka进行业务层隔离，实现项目服务化也可以理解为微服务，先简单上手进行操作，eureka使用分为三块，1是服务注册中心，2是服务生产模块，3是服务消费模块

关系调用说明：

  • 服务生产者启动时，向服务注册中心注册自己提供的服务
  • 服务消费者启动时，在服务注册中心订阅自己所需要的服务
  • 注册中心返回服务提供者的地址信息给消费者
  • 消费者从提供者中调用服务

Eureka包含了Server端和Client端组件。

Server端是服务注册中心，用于提供服务的注册与发现。Eureka支持高可用的配置，当集群中有分片出现故障时，Eureka就会转入自动保护模式，它允许分片故障期间继续提供服务的发现和注册，当故障分片恢复正常时，集群中其他分片会把他们的状态再次同步回来。
Client端组件包含服务消费者与服务生产者。在应用程序运行时，Eureka服务生产者会向注册中心注册自身提供的服务并每30s发送心跳来更新它的服务租约，当一段时间生产者没有向服务中心续租将会被移出服务提供注册表。同时也可以从服务端查询当前注册的服务信息并把他们缓存到本地并周期性的刷新服务状态。

 

 

4.1.1创建eurekaserver 项目

新建父项目，选择maven结构：

选择路径：

Pom文件添加依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <!--Spring Boot的核心启动器-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.1.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.ls.springcloud</groupId>
    <artifactId>springcloud</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>pom</packaging>
    <name>springcloud</name>
    <description>project for Spring Boot</description>

    <modules>
        <module>eureka</module>
    </modules>

    <!--springcloud最新版本Hoxton -->
    <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>Hoxton.RELEASE</spring-cloud.version>
    </properties>

    <dependencies>
        <!--支持@SpringCloudApplication注解-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <!--支持HTTP调用方式，包含了Spring Boot预定义的一些Web开发的常用依赖包 如: spring-webmvc,Tomcat....-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>


    <!--依赖管理-->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <!--告诉Maven包含Spring特定的Maven插件，用于构建和部署SpringBoot应用程序。-->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

新建模块Eureka

pom添加依赖：

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <!--父依赖-->

    <parent>

        <groupId>com.ls.springcloud</groupId>

        <artifactId>springcloud</artifactId>

        <version>0.0.1-SNAPSHOT</version>

    </parent>

    <groupId>com.ls.springcloud</groupId>

    <artifactId>eureka</artifactId>

    <version>0.0.1-SNAPSHOT</version>

    <name>eureka</name>

    <description>eureka 注册中心</description>



    <dependencies>

        <!--eureka注册中心依赖-->

        <dependency>

            <groupId>org.springframework.cloud</groupId>

            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>

        </dependency>

    </dependencies>



    <build>

        <plugins>

            <plugin>

                <groupId>org.springframework.boot</groupId>

                <artifactId>spring-boot-maven-plugin</artifactId>

            </plugin>

        </plugins>

    </build>



</project>
 

添加配置文件application.yml

spring:

  application:

    name: eureka



eureka:

  instance:

    #注册中心地址

    hostname: localhost



  ###客户端调用地址

  client:

    serviceUrl:

      defaultZone: http://${eureka.instance.hostname}:8081/eureka/

    ###是否将自己注册到Eureka服务中,因为该应用本身就是注册中心，不需要再注册自己（集群的时候为true）

    register-with-eureka: false

    ###是否从Eureka中获取注册信息,因为自己为注册中心,不会在该应用中的检索服务信息

    fetch-registry: true

创建启动类：

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;



@SpringBootApplication

@EnableEurekaServer

public class EurekaServerTestApplication {

    public static void main(String[] args) {

        SpringApplication.run(EurekaServerTestApplication.class, args);

    }

}

运行项目访问结果：

http://localhost:8081/ 

此处没有服务注册，所以没有发现服务。

五、服务提供者

创建一个服务提供者 (eureka client),当client向server注册时，它会提供一些元数据，例如主机和端口，URL，主页等。Eureka server 从每个client实例接收心跳消息。 如果心跳超时，则通常将该实例从注册server中删除

5.1 创建项目eurekaclient

Pom文件添加依赖：

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0"

         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

    <parent>

        <artifactId>springcloud</artifactId>

        <groupId>com.ls.springcloud</groupId>

        <version>0.0.1-SNAPSHOT</version>

    </parent>

    <modelVersion>4.0.0</modelVersion>



    <artifactId>client</artifactId>



    <dependencies>

        <dependency>

            <groupId>org.springframework.cloud</groupId>

            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>

        </dependency>

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-web</artifactId>

        </dependency>

    </dependencies>



    <build>

        <plugins>

            <plugin>

                <groupId>org.springframework.boot</groupId>

                <artifactId>spring-boot-maven-plugin</artifactId>

            </plugin>

        </plugins>

    </build>





</project>

添加application.yml配置文件

server:

  port: 8082

  enable-self-preservation: false



spring:

  application:

    name: eureka-server



eureka:

  instance:

    #注册中心地址

    hostname: localhost

  client:

    serviceUrl:

      defaultZone: http://${eureka.instance.hostname}:8081/eureka/

创建启动类：

@EnableEurekaClient

@SpringBootApplication  

public class EurekaClientApplication {



    public static void main(String[] args) {

        SpringApplication.run(EurekaClientApplication.class, args);

    }

}

创建controller：

@RestController

public class UserController {





    @Value("${server.port}")

    String port;



    @RequestMapping("/hi")

    public String home(@RequestParam String name) {

        return "hi " + name + ",i am from port:" + port;

    }







}

查看注册中心：

表示该服务已经注册，可以查看端口。

访问：http://localhost:8082/hi?name=li

六、服务消费者（rest+ribbon）

在微服务架构中，业务都会被拆分成一个独立的服务，服务与服务的通讯是基于http restful的。Spring cloud有两种服务调用方式，一种是ribbon+restTemplate，另一种是feign。

6.1 什么是ribbon

ribbon是一个负载均衡客户端，可以很好的控制htt和tcp的一些行为。Feign默认集成了ribbon。

6.2 创建ribbon

Pom文件添加依赖：

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0"

         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

    <parent>

        <artifactId>springcloud</artifactId>

        <groupId>com.ls.springcloud</groupId>

        <version>0.0.1-SNAPSHOT</version>

    </parent>

    <modelVersion>4.0.0</modelVersion>



    <artifactId>ribbon</artifactId>



    <dependencies>

        <dependency>

            <groupId>org.springframework.cloud</groupId>

            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>

        </dependency>

        <dependency>

            <groupId>org.springframework.cloud</groupId>

            <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>

        </dependency>

        <dependency>

            <groupId>org.springframework.boot</groupId>

            <artifactId>spring-boot-starter-web</artifactId>

        </dependency>

    </dependencies>





    <build>

        <plugins>

            <plugin>

                <groupId>org.springframework.boot</groupId>

                <artifactId>spring-boot-maven-plugin</artifactId>

            </plugin>

        </plugins>

    </build>







</project>

添加配置文件：

server:

  port: 8084

  enable-self-preservation: false



spring:

  application:

    name: ribbon



eureka:

  instance:

    #注册中心地址

    hostname: localhost

  client:

    serviceUrl:

      defaultZone: http://${eureka.instance.hostname}:8081/eureka/
添加启动类
package com.ls.ribbon;



import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.EnableAutoConfiguration;

import org.springframework.cloud.client.loadbalancer.LoadBalanced;

import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.ComponentScan;

import org.springframework.web.client.RestTemplate;



@EnableAutoConfiguration

@ComponentScan(basePackages={"com.ls.ribbon.controller","com.ls.ribbon.service"})

@EnableEurekaClient

public class DemoApplication {



    public static void main(String[] args) {

        SpringApplication.run(DemoApplication.class, args);

    }



    @Bean

    @LoadBalanced

    RestTemplate restTemplate() {

        return new RestTemplate();

    }





}

创建controller：

package com.ls.ribbon.controller;



import com.ls.ribbon.service.HelloService;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RequestParam;

import org.springframework.web.bind.annotation.RestController;



@RestController

public class HelloControler {

        @Autowired

        private HelloService helloService;



        @RequestMapping(value = "/hi")

        public String hi(@RequestParam String name) {

            return helloService.hiService(name);

        }



}

创建service：

package com.ls.ribbon.service;



//import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import org.springframework.web.client.RestTemplate;



@Service

public class HelloService {

    @Autowired

    RestTemplate restTemplate;







    public String hiService(String name) {

        return restTemplate.getForObject("http://EUREKA-CLIENT/hi?name="+name,String.class);

    }





}

演示效果：

注册中心：

http://localhost:8084/hi?name=li

这说明当我们通过调用restTemplate.getForObject(“http://EUREKA-CLIENT /hi?name=“+name,String.class)方法时，已经做了负载均衡，访问了不同的端口的服务实例。

七、服务消费者（Feign）

7.1 什么是Feign

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

简而言之：

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

7.2 准备工作

启动eureka，端口为8081; 启动eureka-client 两次，端口分别为8082 、8083.

7.3 创建一个Feign服务

7.1 新建Feign模块

添加依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>springcloud</artifactId>
        <groupId>com.ls.springcloud</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>Feign</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <!--引入feign 依赖，包含ribbon负载均衡，也包含Hystrix服务容错。-->
        <!--Spring Cloud Feign在构建被@FeignClient注解修饰的服务客户端是，会为每一个客户端都创建一个feign.Logger实例，我们可以利用该日志对象进行Log分析。-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

    </dependencies>


    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>


</project>

7.2 添加配置文件

server:

  port: 8085

  enable-self-preservation: false



spring:

  application:

    name: feign



eureka:

  instance:

    #注册中心地址

    hostname: localhost

  client:

    serviceUrl:

      defaultZone: http://${eureka.instance.hostname}:8081/eureka/

7.3 创建Controller

package com.ls.controller;

import com.ls.service.FeignService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;


@RestController
public class IndexController {

   @Autowired
   private FeignService feignService;

   @RequestMapping(value = "/hi",method = RequestMethod.GET)
   public String hi(String name) {
      return feignService.hi(name);
   }

  
}

7.4 创建service

@Repository
@FeignClient(value = "EUREKA-CLIENT")
public interface FeignService {
   @RequestMapping(value = "/hi", method = RequestMethod.GET)
   public String hi(@RequestParam(value = "name") String name);
}

7.5 创建启动类

@SpringBootApplication
@EnableEurekaClient
@EnableFeignClients
public class SericeFeignApp {
   public static void main(String[] args) {
      SpringApplication.run(SericeFeignApp.class, args);
   }
}

7.6 运行结果：

http://localhost:8085/hi?name=li 刷新交替显示8082 8083

八、 Hystrix断路器

在微服务架构中，根据业务来拆分成一个个的服务，服务与服务之间可以相互调用（RPC），在Spring Cloud可以用RestTemplate+Ribbon和Feign来调用。为了保证其高可用，单个服务通常会集群部署。由于网络原因或者自身的原因，服务并不能保证100%可用，如果单个服务出现问题，调用这个服务就会出现线程阻塞，此时若有大量的请求涌入，Servlet容器的线程资源会被消耗完毕，导致服务瘫痪。服务与服务之间的依赖性，故障会传播，会对整个微服务系统造成灾难性的严重后果，这就是服务故障的“雪崩”效应。

为了解决这个问题，业界提出了断路器模型。

8.1 什么是Hystrix

Netflix开源了Hystrix组件，实现了断路器模式，SpringCloud对这一组件进行了整合。 在微服务架构中，一个请求需要调用多个服务是非常常见的，如下图：

较底层的服务如果出现故障，会导致连锁故障。当对特定的服务的调用的不可用达到一个阀值（Hystric 是5秒20次） 断路器将会被打开。

断路打开后，可用避免连锁故障，fallback方法可以直接返回一个固定值。


这篇文章基于上一篇文章的工程，首先启动上一篇文章的工程，启动eureka工程；启动eureka工程，它的端口为8082。

8.2 在ribbon使用断路器

改造ribbon代码，在pom文件添加依赖：

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

改造Service：

package com.ls.ribbon.service;

import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

@Service
public class HelloService {
    @Autowired
    RestTemplate restTemplate;


    @HystrixCommand(fallbackMethod = "error")
    public String hiService(String name) {
        return restTemplate.getForObject("http://EUREKA-CLIENT/hi?name="+name,String.class);
    }

    public String error(String name){
        return "参数为:"+name+",调用EUREKA-CLIENT 失败啦!";
    }
}

 

修改Controller：

@EnableEurekaClient
@EnableCircuitBreaker // 开启hystrix断路器
@SpringBootApplication
public class DemoApplication {

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

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


}

运行结果：

关闭8082端口，访问会回调error方法： http://localhost:8084/hi?name=li

8.3 在Feign中使用断路器

Feign是自带断路器的，在D版本的Spring Cloud中，它没有默认打开。需要在配置文件中配置打开它，在配置文件加以下代码：

feign:
  hystrix:
    enabled: true

基于service-feign工程进行改造，只需要在FeignClient的SchedualServiceHi接口的注解中加上fallback的指定类就行了：

改造Service：


package com.ls.service;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.stereotype.Repository;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;

@Repository
@FeignClient(value = "EUREKA-CLIENT",fallback=SchedualServiceHiHystric.class)
public interface FeignService {
   @RequestMapping(value = "/hi", method = RequestMethod.GET)
   public String hi(@RequestParam(value = "name") String name);
}

 

SchedualServiceHiHystric：

package com.ls.service;

import org.springframework.stereotype.Component;

@Component
public class SchedualServiceHiHystric implements FeignService {

    public String hi(String name) {
        return "feign ... name:" + name + " 系統錯誤,调用接口失败~!!";
    }
}

运行结果：http://localhost:8085/hi?name=li

 

 

九、使用Zuul构建API Gateway

9.1 什么是API Gateway

在Spring Cloud微服务系统中，一种常见的负载均衡方式是，客户端的请求首先经过负载均衡（zuul、Ngnix），再到达服务网关（zuul集群），然后再到具体的服务。

9.2 什么是Zuul

  • Routing in an integral part of a microservice architecture. For example, / may be mapped to your web application, /api/users is mapped to the user service and /api/shop is mapped to the shop service. Zuul is a JVM based router and server side load balancer by Netflix.
  • 路由在微服务架构的一个组成部分。 例如，/可以映射到您的Web应用程序，/ api / users映射到用户服务，并且/ api / shop映射到商店服务。 Zuul是Netflix的基于JVM的路由器和服务器端负载均衡器。
  • 其功能包括 
     
    • 验证
    • 见解
    • 压力测试
    • 金丝雀测试
    • 动态路由
    • 服务迁移
    • 减载
    • 安全
    • 静态响应处理
    • 主动/主动流量管理
  • Zuul的规则引擎允许规则和过滤器基本上用任何JVM语言编写，内置支持Java和Groovy。

9.3 创建Zuul工程

Pom文件添加依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>springcloud</artifactId>
        <groupId>com.ls.springcloud</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>zuul</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
</project>

添加配置文件

server:
  port: 8086
  enable-self-preservation: false

spring:
  application:
    name: zuul

eureka:
  instance:
    #注册中心地址
    hostname: localhost
  client:
    serviceUrl:
      defaultZone: http://${eureka.instance.hostname}:8081/eureka/

zuul:
  routes:
    api-a:
      path: /api-a/**
      service-id: ribbon
    api-b:
      path: /api-b/**
      service-id: feign
  host:
    socket-timeout-millis: 60000
    connect-timeout-millis: 60000

添加启动类

package com.ls.zuul;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.netflix.zuul.EnableZuulProxy;

/**
 * @description:
 * @author: LiShun
 * @time: 2020/1/7 9:01
 */
@EnableZuulProxy  // 开启zuul
@EnableEurekaClient
@SpringBootApplication
public class ZuulApplication {
    public static void main(String[] args) {
        SpringApplication.run(ZuulApplication.class,args);
    }
}

首先指定服务注册中心的地址为http://localhost:8081/eureka/，服务的端口为8086，服务名为zuul；以/api-a/ 开头的请求都转发给ribbon服务；以/api-b/开头的请求都转发给feign服务；

依次运行这五个工程;打开浏览器访问：http://localhost:8086/api-a/hi?name=li ;浏览器显示：

 

十、分布式配置中心

10.1 码云创建仓库和配置文件

  1. 在Gitee上新建一个项目https://gitee.com/ls99802/springcloud.git

2在项目下新建子目录spring-cloud-config-file，然后新建三个文件

3内容分别是 from=git-dev-1.0、from=git-test-1.0、from=git-1.0

4 新建一个分支feature，新分支里面新建三个同名的文件，不过内容分别是from=git-dev-2.0、from=git-test-2.0、from=git-2.0

10.2 构建Config Server

新建模块Config-server

Pom文件添加依赖

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

添加配置文件application.yml

server:
  port: 8087
  enable-self-preservation: false

spring:
  application:
    name: config-server
  cloud:
    config:
      server:
        git:
          uri: https://gitee.com/ls199802/springcloud   #git仓库地址
          searchPaths: spring-cloud-config-file
          label: master              #默认分支
          username:                  #公开仓库不需要账号密码
          password:


eureka:
  instance:
    #注册中心地址
    hostname: localhost
  client:
    serviceUrl:
      defaultZone: http://${eureka.instance.hostname}:8081/eureka/

创建启动类：

@SpringBootApplication
@EnableConfigServer    // 开启Spring Cloud Config 的服务端功能
@EnableDiscoveryClient
public class ConfigApplication {

// 分别测试master分支和feature分支

    //http://localhost:8087/xx/dev/feature

    //http://localhost:8087/xx/test/master

    //http://localhost:8087/xx/dev/master

    //http://localhost:8087/xx/test   //默认master分支


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

启动并验证:

　　　　访问配置信息的URL与配置文件的映射关系如下：

    • /{application}/{profile} [/{label}]
    • /{application}-{profile}.yml
    • /{label}/{application}-{profile}.yml
    • /{application}-{profile}.properties
    • /{label}/{appliction}-{profile}.properties

上面的url会映射{application}-{profile}.properties对应的配置文件，其中{label}对应Git上不同的分支，默认是master。

访问：http://localhost:8087/springcloud/dev/feature

可以看到远程配置文件中参数的值。

10.3 创建config-client客户端

Pom文件添加依赖：

<dependencies>
    <!-- 引入config依赖 -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-config-client</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
</dependencies>

配置文件bootstrap.yml：

配置文件必须是bootstrap.yml或bootstrap.properties否则还是访问的是本机的8888端口。

spring:
  application:
    name: springcloud  #对应gitee创建的项目
  cloud:
    config:
      profile: dev  #读取配置文件后缀
      label: master  #默认分支
      discovery:
        service-id: config-server # 配置中心的服务名称
        enabled: true  # 这里必须设置为true 否则还是会访问8888端口

eureka:
  client:
    service-url:
      defaultZone: http://localhost:8081/eureka
server:
  port: 8088

创建controller获取配置文件参数的值

@RestController
public class Test {

    // 通过@Value将gitee远程配置文件的from值写入到from中
    @Value("${from}")
    private String from;

    // 客户端启动时候获取分支上的配置参数${from}时候,配置中心会从git仓库拉取colo-dev.properties,colo.properties等文件到本地
    @RequestMapping(value= "/hi")
    private String hi() {
        System.out.println(from);
        return from;
    }
}

创建启动类

@EnableEurekaClient
@SpringBootApplication
public class TestApplication {
    public static void main(String[] args) {
        SpringApplication.run(TestApplication.class, args);
    }

}

启动测试

获取到了远程配置文件参数的值，创建客户端成功。

欢迎交流学习。

知 行 合 一
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
史上最全SpringCloud微服务视频教程教程
03-17
详细讲解  微服务技术架构概述 euraka注册中心原理 服务调用工具rest与fegin SpringCloud调用服务原理剖析 SpringCloud实现服务负载均衡原理 使用ribbon客户端实现负载均衡 使用Zuul搭建服务网关解决跨域问题 搭建SpringCloud分布式配置中心 服务雪崩效应解决办法  使用hystrix实现服务降级、熔断机制、解决雪崩效应
Spring Cloud 微服务权限系统搭建教程 脚手架
07-21
"Spring Cloud 微服务权限系统搭建教程 脚手架" Spring Cloud 是一个基于 Java 的微服务架构开发框架，旨在简化分布式系统的开发和部署。FEBS Cloud 是基于 Spring Cloud Hoxton.RELEASE、Spring Cloud OAuth2、...
SpringCloud学习笔记
心猿意碼
07-22 217
SpringCloud 微服务架构 什么是分布式 不同模块部署在不同服务器上 作用：分布式解决网站高并发带来问题 什么是集群 多台服务器部署相同应用构成一个集群 作用：通过负载均衡设备共同对外提供服务 什么是RPC RPC 的全称是 Remote Procedure Call 是一种进程间通信方式。 它允许程序调用另一个地址空间（通常是共享网络的另一台机器上）的过...
Spring Cloud 概述
最新发布
weixin_73616913的博客
07-04 786
Spring Cloud 的官网： spring.ioSpring Cloud 包含了很多的工具，这些工具能够让我们在分布式系统中进行比较快速的开发，Spring Cloud 提供的这些工具，也可以帮助我们解决在分布式微服务中的一系列问题。简单来说,Spring Cloud 就是分布式微服务架构的⼀站式解决方案, 是微服务架构落地的多种技术的集合.
spring cloud起步
I_forever的专栏
05-12 213
访问报错：分析：从错误来看是因为Dept转JSON的时候出错了。查看Dept，因为使用了lombok这个插件所以Dept的代码如下：解决方法：手动生成setter和getter方法目前不清楚为什么会出现这个问题。待以后补充。...
一、Spring Cloud 起步
weixin_30367873的博客
05-20 72
吐槽 Spring Cloud 版本之间的变化有些大呀！！坑死人了！！ Spring-Cloud 版本：Finchley.SR2 Spring-Boot 版本：2.0.9.RELEASE 目录： 1.搭建Eureka注册中心； 2.搭建服务提供者，并向注册中心注册自己； 3.搭建服务消费者，消费服务； 1 搭建Eureka注册中心 　　pom..xml ...
命令行抓tomcat的内存使用情况
weixin_33951761的博客
03-16 208
一个窗口kill -3 26921 另一个窗口抓内存日志 tail -333f catalina.out |grep -A 6 ‘par new generation’ 我的官网 我的官网http://guan2ye.com 我的CSDN地址http://blog.csdn.net/chenjianandiyi...
springcloud实战项目框架搭建完整版
11-24
这个"springcloud实战项目框架搭建完整版"将带你了解并实践这一过程。 首先，我们需要理解Spring Boot。Spring Boot是Spring框架的一个延伸，旨在简化Java Web应用的初始搭建以及开发过程。它内置了Tomcat服务器，...
SpringCloud微服务框架搭建
02-24
比如两台服务器A，B，一个应用部署在A服务器上，想要调用B服务器上应用提供的函数或者方法，由于不在一个内存空间，不能直接调用，这时候需要通过就可以应用RPC框架的实现来解决（1）RESTful是一种架
Spring Cloud 入门教程.zip
07-03
本次为您带来的是最新的 Java 框架零基础从入门到精通的教程笔记项目，无论您是完全没有基础的小白，还是想要进一步提升的开发者，这套教程都将是您的理想之选。 教程内容丰富详实，涵盖了从基础知识的细致讲解，到...
springcloud框架搭建模板
01-15
在这个"springcloud框架搭建模板"中，我们将关注几个核心组件的使用：Spring Cloud Gateway、Nacos以及一个客户端微服务。 首先，Spring Cloud Gateway作为整个系统的入口点，它充当了API网关的角色。Gateway是...
springcloud入门实例（一：微服务框架搭建）
u014627099的博客
01-08 763
        在这个数据量越来越大、客户需求越来越高的时代，作为一个写java web后端代码的程序员，不会写微服务确实是有点说不过去，现在最常见的微服务框架一个是dubbo，另一个就是springcloud了。两者有很多的不同，比较显著的一个是dubbo符合CAP中的CP原则，符合高一致性，而springcloud符合AP原则，符合高可用性；另外从社区来说的话，.......就不说了，总之现如...
【SpringCloud】最全最细！微服务框架
u014685437的博客
05-29 1万+
单体架构特点?简单方便，高度耦合，扩展性差，适合小型项目。例如: 学生管理系统分布式架构特点?松耦合，扩展性好，但架构复杂，难度大。适合大型互联网项目，例如:京东、淘宝微服务:一种良好的分布式架构方案优点: 拆分粒度更小、服务更独立、耦合度更低缺点:架构非常复杂，运维、监控、部署难度提高。
SpringCloud简述
1 Byte 的博客
12-10 435
一、概念定义 Spring Cloud是一个微服务框架，相比Dubbo等RPC框架,Spring Cloud提供的全套的分布式系统解决方案。 Spring Cloud对微服务基础框架Netflix的多个开源组件进行了封装，同时又实现了和云端平台以及和Spring Boot开发框架的集成。 Spring Cloud为微服务架构开发涉及的配置管...
一文搞懂SpringCloud，详解干货，做好笔记
灰灰的博客
03-14 2195
微服务架构简单的说就是将单体应用进一步拆分，拆分成更小的服务，每个服务都是一个可以独立运行的项目。这么多小服务，如何管理他们？(服务治理 注册中心[服务注册 发现 剔除])这么多小服务，他们之间如何通讯？这么多小服务，客户端怎么访问他们？(网关)这么多小服务，一旦出现问题了，应该如何自处理？(容错)这么多小服务，一旦出现问题了，应该如何排错?(链路追踪)对于上面的问题，是任何一个微服务设计者都不能绕过去的，因此大部分的微服务产品都针对每一个问题提供了相应的组件来解决它们。
部署k8s的dashboard访问页面时Client sent an HTTP request to an HTTPS server.
weixin_43822977的博客
07-20 7474
地址栏输入 ip：端口 会报错。 应该这样输入: https://ip:端口
微服务框架SpringCloud
m0_70967938的博客
05-15 536
微服务是一种经过良好架构设计的分布式架构方案。能解决单体架构的缺点.
spring cloud搭建教程
热门推荐
ANGEL CITY
04-26 5万+
Spring cloud是一个基于Spring Boot实现的服务治理工具包,在微服务架构中用于管理和协调服务的微服务:就是把一个单体项目,拆分为多个微服务,每个微服务可以独立技术选型,独立开发,独立部署,独立运维.并且多个服务相互协调,相互配合,最终完成用户的价值. Spring Cloud是一系列框架的有序集合。其主要的设施有，服务发现与注册，配置中心，消息总线，负载均衡，断路器，数据监控等，通过Spring Boot的方式，可以实现一键启动，和部署。
springcloud微服务架构（eureka、nacos、ribbon、feign、gateway等组件的详细介绍和使用）
m0_62498006的博客
08-06 1万+
通过学习springcloud，在其中就有微服务的一些组件，如eureka、nacos、ribbon、feign、gateway等组件的详细介绍和使用，还包括了底层逻辑。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值