Springcloud使用入门

88579432 2019-12-02

Springcloud是一款微服务框架，它基于Springboot，可以使用它用来管理纵向拆分的项目，将一个个的小项目变成微服务。下面简单的搭建一个微服务，使用eureka组件实现注册中心，使用ribbon组件实现微服务调用，使用zuul网关实现真实服务地址和访问地址的分离，其他技术后续补充。

springcloud和nginx

前面学习过nginx，它除了可以实现动静分离，还可以实现负载均衡，即可以将项目做成分布式tomcat集群，前端访问可以随机或者按照权重值访问后端服务。但是nginx有一个小缺点，如果单台服务器出现问题、或者需要添加服务器，需要修改conf.xml配置文件，或某台服务器出现问题如何容错等，ngnix是无法实现。简单来说它缺少管理者的因子，需要人为‘‘介入‘‘，在这种情况下，springcloud就可以弥补nginx的不足，它不仅仅可以实现分布式，负载均衡，并且对微服务有管理、容错、监听的能力。

springcloud

springcloud是spring家族的一员，它是一个微服务框架，用在大型分布式应用的开发，官网：https://spring.io/projects/spring-cloud，除了springcloud外，其他比较出名的微服务框架还有dubbo。

Springcloud使用入门

如果一个项目比较小，直接使用springboot，或者ssm做成单体项目就可以，但是如果一个项目比较大，就需要考虑到拆分，比较常见的就是横向拆分和纵向拆分。

（1）纵向拆分：大项目分成很多小项目，如电商网站的登录注册系统、商品系统、秒杀系统、搜索系统、购物车系统等，都是拆分后的小项目，这就是纵向拆分。

（2）横向拆分：一个纵向拆分后的项目，也可以继续拆分，如有人专门做控制层，有人做业务层，这就是横向拆分。

springcloud是如何对拆分后的项目进行管理的呢，这就需要用到它的关键组件，这里暂时先记录eureka、ribbon和zuul三种组件，其他组件如config、feign和hystrix后续单独补充。

（1）eureka：服务治理组件，利用它的注册和发现机制，实现整体微服务的管理，提供其他服务注册，并可以发现其他服务，springcloud只提供了一种这种治理组件。

（2）ribbon：通过eureka发现机制，可以负载均衡、随机或者根据权重来调用其他提供服务的组件。

（3）zuul：网关组件，唯一对外暴露接口地址的组件，实现外界访问地址和内部请求地址的分离，对外影藏了真实的地址。

下面使用一下这几个组件。

eureka

整个springcloud的核心组件之一，它就像一个‘‘管理者‘‘，利用自己的注册和发现的能力，来管理着一批注册在它身上的微服务。即其他服务可以注册在eureka注册中心，它管理着一批这样的已经注册的微服务，并对外提供服务，同时注册中心会将其他服务注册的信息保存到本地，通过定时更新来维护和其他服务的关系。简单来说注册中心就像‘‘工商局‘‘，各种公司之类的服务提供者都在这里注册，完了就可以对外提供服务了。

a.搭建eureka注册中心

使用IDEA，搭建一个eureka注册中心，搭建是基于springboot，需要利用springboot的自动配置和‘约定大于配置‘的特点，来配合springcloud简化搭建过程，注意两者版本的兼容，可以参考文末博客。

（1）pom文件导入springboot父pom、以及springcloud依赖。

<?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">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.boe</groupId>
  <artifactId>Eureka-server01</artifactId>
  <version>1.0-SNAPSHOT</version>

  <name>Eureka-server01</name>
  <!-- FIXME change it to the project‘s website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>

  <!--使用springboot的资源，结构特性。另外使用springcloud的所有依赖环境-->

  <!-- 基于springboot，继承springboot-parent，引入springboot的父pom文件 -->
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <!--1.5.9是稳定版本-->
    <version>1.5.9.RELEASE</version>
  </parent>

  <!--导入springcloud的父pom资源，声明式依赖，子工程手动导入时就导包，不导入就不导入包-->
  <dependencyManagement>
    <dependencies>
      <!--导入springcloud-->
      <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-dependencies</artifactId>
        <version>Edgware.RELEASE</version>
        <!--注意通过坐标找到的spring-cloud-dependencies-Edgware.RELEASE.pom文件中，打包方式为pom，因此需要这里type为pom-->
        <type>pom</type>
        <!--maven scope方式常用有很多种，默认为compile，还有test、provided、system等-->
        <scope>import</scope>
      </dependency>

    </dependencies>
  </dependencyManagement>

  <!--以上两步，完成继承父springboot pom依赖，并导入springcloud的依赖管理-->

  <dependencies>

    <!--引入eureka注册中心的依赖-->
    <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-starter-eureka-server</artifactId>
      <!--建议使用下面的artifactId-->
      <!--<artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>-->
    </dependency>

    <!-- spring-boot-starter-web 已经在eureka-server中传递，因此这里不需要配置springboot的starter-web-->

    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <!--springboot运行jar包的插件，可以直接使用java -jar jar包名来运行springboot-->
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>

      <!--指定jar包运行的main class-->
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-jar-plugin</artifactId>
        <!--<configuration>-->
          <!--<archive>-->
            <!--<manifest>-->
              <!--<addClasspath>true</addClasspath>-->
              <!--<mainClass>com.StarterEurekaServer</mainClass> &lt;!&ndash; 此处为主入口&ndash;&gt;-->
            <!--</manifest>-->
          <!--</archive>-->
        <!--</configuration>-->
      </plugin>

    </plugins>
  </build>

</project>

（2）资源目录下添加application.properties文件，添加服务端口、服务名、注册eureka中心地址等信息。

# 端口
server.port=8088
# 客户端通过ip底层注册
# eureka.client.prefer-ip-address=true
eureka.client.preferIpAddress=true
#暂时先关闭,当前注册中心作为客户端
# 在注册中心本身,使得具有注册和发现的能力,如果要实现HA，需要改成true,这样就会访问注册中心的接口
eureka.client.regist-with-eureka=false
# 关闭发现抓取注册信息的能力
eureka.client.fetch-registry=false
# 注册中心的地址，http请求的接口
eureka.client.serviceUrl.defaultZone=http://localhost:8088/eureka

# 当前工程提供一个服务名称,相同功能的工程创建集群，都是一个名称，以当前服务名为key保存在当前服务的所有节点信息的map对象中
# 如果是同一个name，就可以创建HA高可用
spring.application.name=eureka-server

# 可以关闭自我保护，没有收到续约，就从注册中心剔除服务
# eureka.server.enable-self-preservation=false

（3）写一个启动类，来启动注册中心，需要使用@EnableEurekaServer注解，来表名启动的是一个注册中心服务类。

package com;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

/**
 * eureka server启动类
 */
@SpringBootApplication
@EnableEurekaServer
public class StarterEurekaServer {
    public static void main(String[] args) {
        SpringApplication.run(StarterEurekaServer.class,args);
        System.out.println("I am eureka server01");
    }
}

（4）启动后，访问注册中心地址localhost:8088，就可以查看注册中心注册的实例，这里有一个就是eureka服务自己本身，以后如果有注册的服务，都能在这里查看。

Springcloud使用入门

b.搭建一个微服务并注册

Eureka注册中心搭建起来后，接下里搭建一个微服务并注册在Eureka注册中心，并使用它提供的服务。

（1）pom文件与上面类似，这次搭建的是服务提供者，因此引入eureka客户端依赖(spring-cloud-starter-eureka)就可以。

<?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">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.boe</groupId>
  <artifactId>Client01</artifactId>
  <version>1.0-SNAPSHOT</version>

  <name>Client01</name>
  <!-- FIXME change it to the project‘s website -->
  <url>http://www.example.com</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.7</maven.compiler.source>
    <maven.compiler.target>1.7</maven.compiler.target>
  </properties>

  <!--使用springboot的资源，结构特性。另外使用springcloud的所有依赖环境-->

  <!-- 基于springboot，继承springboot-parent，引入springboot的父pom文件 -->
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.5.9.RELEASE</version>
  </parent>

  <!--导入springcloud的父pom资源-->
  <dependencyManagement>
    <dependencies>
      <!--导入springcloud-->
      <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-dependencies</artifactId>
        <version>Edgware.RELEASE</version>
        <!--注意通过坐标找到的spring-cloud-dependencies-Edgware.RELEASE.pom文件中，打包方式为pom，因此需要这里type为pom-->
        <type>pom</type>
        <scope>import</scope>
      </dependency>

    </dependencies>
  </dependencyManagement>

  <!--以上两步，完成继承父springboot pom依赖，并导入springcloud的依赖-->

  <dependencies>

    <!--引入eureka客户端依赖-->
    <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-starter-eureka</artifactId>
    </dependency>

    <!-- spring-boot-starter-web 已经在eureka-server中传递，因此这里不需要配置springboot的starter-web-->

    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <!--springboot运行jar包的插件-->
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
    </plugins>
  </build>

</project>

（2）application.properties文件指定服务的端口号、服务名以及注册的中心地址url等信息。

# 客户端端口
server.port=9088

# 客户端通过ip底层注册
# eureka.client.prefer-ip-address=true
eureka.client.preferIpAddress=true

# eureka-client的注册，和发现功能需设置为true，默认为true，也可以不用设置
eureka.client.regist-with-eureka=true
# 发现抓取注册信息的内容
eureka.client.fetch-registry=true

# 定义服务名称
spring.application.name=service-hi


# 注册中心的地址
eureka.client.serviceUrl.defaultZone=http://localhost:8088/eureka

（3）写一个启动类，类似注册中心的启动类，只是注解需要修改成@EnableEurekaClient，这样的服务只有注册和发现的能力，不具备管理的能力。

package com;

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

/**
 * Eureka client服务提供者启动类
 */
@SpringBootApplication
@EnableEurekaClient
public class StarterEurekaClient {
    public static void main(String[] args) {
        SpringApplication.run(StarterEurekaClient.class,args);
        System.out.println("I am client01");
    }
}

（4）写个controller层的测试类，访问这个地址可以返回信息，如果能正常访问到，说明注册后的服务能正常使用。

package com.boe.Controller;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MyController {
    //可以通过@Value注解，获取application.properties里的参数
    @Value("${server.port}")
    private String port;

    //写一个测试方法
    @RequestMapping("hello")
    public String test(String name){
        return "I am "+name+", and I come form "+port;
    }

}

（5）访问发现可以正常返回测试信息，并且注册中心页面也增添了一条注册信息，这样就实现了微服务的注册并提供服务的功能。

Springcloud使用入门

c.高可用eureka注册中心

高可用是分布式集群必不可少的一个特点，当其中一个节点宕机后，不影响整体的功能。eureka注册中心不仅对外可以提供服务注册，同时自己也作为注册微服务，可以注册在另外一台eureka注册中心，利用这个特点可以配置eureka高可用集群，这里配置3台eureka注册中心，实现集群HA服务。

eureka01注册到eureka02和eureka03，其他依次类推，这样完成注册后，每个eureka服务中心从对方抓得到的服务map信息就一致了，因为服务名一致，会纳入一个服务来管理，实现HA高可用。

Springcloud使用入门

想实现如上高可用，在IDEA当前工程下再添加两个Module，再修改application.properties文件 ，就可以实现，以eureka server01为例，需修改eureka.client.regist-with-eureka=true，使其具备注册的能力，同时修改eureka.client.fetch-registry=true，使其具备发现抓取注册的能力。另外eureka.client.serviceUrl.defaultZone写另外两台注册中心的地址，这样三台启动后就可以实现高可用。

# 端口
server.port=8088
# 客户端通过ip底层注册
# eureka.client.prefer-ip-address=true
eureka.client.preferIpAddress=true
#暂时先关闭,当前注册中心作为客户端
# 在注册中心本身,使得具有注册和发现的能力,如果要实现HA，需要改成true,这样就会访问注册中心的接口
eureka.client.regist-with-eureka=true
# 关闭发现抓取注册信息的内容
eureka.client.fetch-registry=true
# 注册中心的地址，http请求的接口,发现另外一个server的端口,实现HA高可用
eureka.client.serviceUrl.defaultZone=http://localhost:8089/eureka,http://localhost:8090/eureka

# 当前工程提供一个服务名称,相同功能的工程创建集群，都是一个名称，以当前服务名为key保存在当前服务的所有节点信息的map对象中
# 如果是同一个name，就可以创建HA高可用
spring.application.name=eureka-server

# 可以关闭自我保护，没有收到续约，就剔除服务
# eureka.server.enable-self-preservation=false

刚开始启动由于先后顺序，控制台会报错，这是正常的，因为先启动的服务可能找不到另外两台的(还在启动中)，导致连接拒绝，以及找不到server的报错。

Springcloud使用入门

Springcloud使用入门

修改客户端的application.properties，添加另外两台注册中心的地址后，测试也可以访问到服务，停掉其中一台注册中心，发现依然可以使用client提供的服务，这样就实现了eureka注册中心的HA高可用。 

Springcloud使用入门

d.eureka注册信息的结构和相关机制

eureka注册信息的结构为一个双层map，上面注册中心的UI界面展示了部分map的内容，它由如下几部分组成。

（1）第一层key为服务名，即上面的eureka-server或者service-hi，这是在application.properties文件中通过spring.application.name定义的。第一层value为一个map，记录注册的实例信息。

（2）第二层key为固定结构，即上面的youngchaolinmac:eureka-server:8090等，由系统用户名:服务名:端口号组成，第二层value为注册的实例对象，包含它的详细信息，如ip地址、端口、注册和续约的事件戳等信息。

相关的机制，有注册、续约、服务剔除和保护机制等。

（1）注册：服务提供者，如上面的client，启动服务后会根据注册中心的地址，携带自己的信息，通过http协议访问注册中心，注册中心接收到服务提供者的信息后保存在注册中心。

（2）续约：服务提供者每隔30s，会给注册中心发送一个‘‘心跳‘‘，告知自己的实例对象是存活的，否则注册中心会剔除死亡或不活跃的服务节点。

（3）剔除：注册中心每隔60s，会检查一次实例对象中的续约时间戳(保存在双层map中的第二层，在value中)，如果超过90s没有续约，会将当前实例对象从第二层map中剔除，这样UI的Status下就会少一个实例对象。

（4）保护：集群的服务是很多的，会出现某个服务尽管续约了，但是由于网络或者通信的问题导致续约判断的失误从注册中心被剔除掉，如果大面积的出现这种情况会导致集群服务的瘫痪。为了避免这种情况的发生，springcloud提供了保护机制，即如果同一时间如果因为超时剔除的服务超过整体服务的15%以上，会被认为是非正常剔除，这样剔除不会实现，会保持集群服务原有的的状态。这种保护机制默认是开启的，也可以在application.properties中设置为关闭，即将eureka.server.enable-self-presevation=false来关闭。

ribbon

ribbon组件可以实现服务调服务， 需要引入RestTemplate来支持，它是一个客户端组件，会抓取在注册中心注册的服务信息，将其整理并保存，然后访问后端服务(上文的client)时会进行拦截，通过从spring容器中获取的负载均衡规则IRule对象，来实现对后端服务的访问逻辑。

为了实现ribbon的功能，需要提前准备2个client，上面已经准备了一个client，再需准备一个。另外还需要准备一个配置了ribbon的组件。

（1）准备一个新的client，当前工程下增添一个Module，修改端口号即可，其他无需修改，这里修改成了9089。

# 客户端端口
server.port=9089

# 客户端通过ip底层注册
# eureka.client.prefer-ip-address=true
eureka.client.preferIpAddress=true

# eureka-client的注册，和发现功能需设置为true，默认为true，也可以不用设置
eureka.client.regist-with-eureka=true
# 发现抓取注册信息的内容
eureka.client.fetch-registry=true

# 定义服务名称
spring.application.name=service-hi


# 注册中心的地址
eureka.client.serviceUrl.defaultZone=http://localhost:8088/eureka,http://localhost:8089/eureka,http://localhost:8090/eureka

（2）准备一个具有ribbon的服务组件，新建一个Module，注意pom文件需要添加ribbon的依赖，其他跟client的配置类似，另外ribbon服务组件的端口在application.properties文件中修改为8105，其他参考client的设置。

<!--引入ribbon依赖-->
    <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-starter-ribbon</artifactId>
    </dependency>

（3）ribbon服务组件，添加启动类，启动类中使用@Bean返回一个RestTemplate对象，交给spring来管理，因为启动类注解@SpringBootApplication底层有@SpringBootConfiguration，这个配置类的下面又是@Configuration，因此启动类也可以作为配置类来使用，在其中配置一个bean。

package com;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

/**
 * 具有ribbon组件的服务启动类
 */
@SpringBootApplication
@EnableEurekaClient
public class StarterEurekaRibbon {
    public static void main(String[] args) {
        SpringApplication.run(StarterEurekaRibbon.class,args);
    }

    //使用restTemplate实现ribbon对客户端的拦截逻辑
    @Bean("restTemplate")
    @LoadBalanced //不加会访问不到其他微服务，提示找不到服务名，尽管有这个服务名的服务在运行着
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }

}

（4）ribbon服务组件添加controller层和service层，在service层实现对请求的拦截，service层方法访问的是一个服务名，而不是具体的请求地址。因为这个服务能获取到注册中心其他服务的信息，将client对应的注册信息抓取过来，通过service-hi，就能获取到对应的双层map的第二层map的value，通过value里保存的ip、端口等信息，实现对真实服务的访问。

 controller层

package com.boe.Controller;

import com.boe.Service.RibbonService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class RibbonController {

    @Autowired
    RibbonService ribbonService=null;

    //访问ribbon服务的地址
    @RequestMapping("helloribbon")
    public String test(String name){
        return "Ribbon work, "+ribbonService.hello(name);
    }
}

service层

package com.boe.Service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

@Service
public class RibbonService {

    @Autowired
    RestTemplate restTemplate=null;

    //需要调用RestTemplate，通过服务名来实现对服务的访问，默认轮询
    public String hello(String name) {
        return restTemplate.getForObject("http://service-hi/hello?name="+name,String.class);
    }
}

（5）最后启动新添的client服务和有ribbon组件的服务，启动后正常均在注册中心注册。

Springcloud使用入门

（6）通过有ribbon组件的服务来访问client的服务，实现服务调服务，默认情况下是轮询的方式，当我多次访问如下地址后，会轮流出现9088和9089，说明访问的服务是轮流来的，也可以根据需求修改成其他的策略，需要在启动类中再添加如下代码。

//自定义负载均衡-随机，还有其他的选择
    //需要配置bean，交给spring管理，如果ribbon组件在启动时会检测这个bean是否存在
    //如果不存在，就默认轮询
    @Bean
    public IRule initRandom(){
        return new RandomRule();//返回随机
        //return new RoundRobinRule();//返回负载轮询方式
        //return WeightedResponseTimeRule();//根据响应时间，返回对应大小权重值的方式，响应快权重值高，响应慢则权重值低
    }

访问有ribbon组件的服务，通过访问localhost:8105/helloribbon?name=messi，内部调用服务实际访问localhost:9089/hello?name=messi，实现了访问地址和真实服务地址的分离，向用户隐藏了真实的访问地址，这样显然更加的安全。

Springcloud使用入门

zuul

前面的ribbon可以实现服务调用服务， 其实springcloud已经提供了一个服务组件来完成上述的功能，那就是zuul网关，它底层就是基于ribbon和RestTemplate来实现，外界是不能直接访问后端提供的服务，需要通过zuul网关暴露的接口来实现访问，通过zuul的路由规则，通过访问的地址匹配到真实的地址后，再实现内部转发从而实现访问。

zuul网关一般配置在nginx，首先先通过nginx先过滤了一次地址，通过proxy_pass先转发到网关，网关再过滤一次，最后达到真的访问地址，如下图所示，下面按照下图的地址来实际配置一下。

Springcloud使用入门

 （1）新增一个zuul服务，在IDEA中添加一个Module，pom文件参考前面的client，在此基础上增加zuul的依赖。

<!--引入zull依赖-->
    <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-starter-zuul</artifactId>
    </dependency>

（2）配置application.properties文件，需添加zuul网关服务端口8108，并配置zuul.routes.test.path=/zuul-hi/**，以及zuul.routes.test.service-id=service-hi，这俩个配置是根据上图的地址来的，后续再分析。

# 网关端口
server.port=8108

# 客户端通过ip底层注册
# eureka.client.prefer-ip-address=true
eureka.client.preferIpAddress=true

# eureka-client的注册，和发现功能需设置为true，默认为true，也可以不用设置
eureka.client.regist-with-eureka=true
# 发现抓取注册信息的内容
eureka.client.fetch-registry=true
# 定义服务名称
spring.application.name=service-zull

# 注册中心的地址，两个server都需要配，用逗号隔开
eureka.client.serviceUrl.defaultZone=http://localhost:8088/eureka,http://localhost:8089/eureka,http://localhost:8090/eureka

# 配置zull网关

# 配置网关地址，**代表可以匹配多级目录
# 提供路由服务，通过不同的地址可以访问不同的服务

# 网关只会暴露使用的地址，具体的真实地址是隐藏的，因此网关如果宕机，外界将不能访问资源
# 因此网关可以通过nginx配置负载均衡

# zuul.routes.test.path里的test是路由名称

zuul.routes.test.path=/zuul-hi/**
# 匹配application name
zuul.routes.test.service-id=service-hi

（3）添加zuul网关启动类，注意需要添加@EnableZuulProxy的注解。

package com;

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;

import javax.swing.*;

/**
 * zuul网关服务启动类
 */
@SpringBootApplication
@EnableEurekaClient
@EnableZuulProxy
public class StarterEurekaZull {
    public static void main(String[] args) {
        SpringApplication.run(StarterEurekaZull.class,args);
        System.out.println("zuul网关启动");
    }
}

（4）查看是否在注册中心注册zull服务，ok。

Springcloud使用入门

（5）配置nginx，实现第一层过滤，让外界访问的地址转发到网关地址，在nginx.conf目录下添加如下内容，并使用nginx -t查看是否配置正确，ok后使用nginx -s reload加载配置文件。

# zuul网关测试新增server
    server {
        listen 8080;        # 需修改/etc/hosts文件，添加对www.test.com的本地解析
        server_name www.test.com;

        location /hellokitty {
            proxy_pass http://127.0.0.1:8108/zuul-hi/hello/;
        }

    }

（6）测试通过www.test.com:8080/hellokitty?name=messi来访问，发现可以访问到前面类似ribbon的访问效果。

Springcloud使用入门

为啥通过如上配置就可以访问到了真实的地址，下面简单分析下。

a.首先访问www.test.com:8080/hellokitty?name=messi，会被nginx拦截，由于匹配到hellokitty，会转发到新的地址http://127.0.0.1/zuul-hi/hello?name=messi

b.zuul网关服务接受到http://127.0.0.1/zuul-hi/hello?name=messi地址后，匹配到zuul.routes.test.path=/zuul-hi/**里的zuul-hi(**代表多级任意字符串)，会截取变成hello?name=messi

c.然后根据zuul.routes.test.service-id=service-hi，将访问地址变成http://service-hi/hello?name=messi，而service-hi就是服务名，真实地址最后匹配后变成http://localhost:9088/hello?name=messi或者http://localhost:9089/hello?name=messi。

这样就实现了对真实地址的访问了，通过zuul配置在nginx，实现对外访问地址和真实地址分开，zuul是唯一的访问服务的入口，单台挂掉就会出现后端无法访问的可能，因此其需要在nginx配置集群，上面只配置了一个zuul服务，可以多开启几个zuul服务，然后在nginx通过upstream来转发到多个zuul服务，就可以实现zuul网关的集群，这里不展示了。

以上就是springcloud入门的整理，后续继续补充。 

参考博文

（1）https://www.cnblogs.com/zhuwenjoyce/p/10261079.html  springboot和springcloud版本对照

（2）https://segmentfault.com/a/1190000019294598 mac下nginx使用 

88579432

88579432

相关推荐

[SpringCloud]Gateway入门

SpringCloud中集成的Zuul版本，采用的是Tomcat容器，使用的是传统的Servlet IO处理模型。这样的模式的缺点是，并发量高的情况下，大量的Servlet产生，从而绑定了大量的线程，而线程的资源实际上是很昂贵的，上下文的切换和内存的消耗会

80143853 / 0评论 2020-08-17

SpringCloud入门概述

SpringCloud，是基于SpringBoot提供的一整套微服务方案，包括服务注册与发现，配置中心，全链路监控，服务网关，负载均衡，熔断器等组件，除了基于NetFlix的开源组件做高度抽象封装之外，还有些选型中立的开源组件。SpringCloud是分布

码蚁 / 0评论 2020-06-13

《SpringCloud 从入门到入土 》 第3章：服务治理：Spring Cloud Eureka

Spring Cloud通过为Eureka增加了Spring Boot风格的自动化配置，我们只需通过引入简单的依赖和注解配置就能让Spring Cloud构建的微服务应用轻松的与Eureka 服务治理体系进行整合。注册中心还需要以心跳的方式检测清单中的服务

80143853 / 0评论 2020-06-03

Springcloud之Zuul网关入门

　　使用Spring Cloud Netflix中的Eureka实现了服务注册中心以及服务注册与发现；而服务间通过Ribbon或Feign实现服务的消费以及均衡负载。　　为了使得服务集群更为健壮，使用Hystrix的融断机制来避免在微服务架构中个别服务出现

84397110 / 0评论 2020-05-18

阿里首席架构师谈微服务：SpringCloud与Docker入门到实战架构

Spring Cloud 是一个微服务框架，相比 Dubbo 等 RPC 框架, Spring Cloud 提。Spring Cloud 为开发者提供了快速构建分布式系统的工具，开发者可以快速的启动服务或构建应用、同时能够快速和云平台资源进行对接。

flyDeDog / 0评论 2019-12-18

【SpringCloud】Eureka入门与原理

为了开发效率高效和业务逻辑清晰，越来越多的项目采用分布式系统。分布式最重要的就是注册中心了。Eureka是SpringCloud原生提供的注册中心，来look一波吧。某服务可以通过注册中心知道注册中心有哪些服务可以使用，并且这一过程需要保证实时性。注册中心

84397110 / 0评论 2019-11-17

微服务SpringCloud项目架构搭建入门

Spring的微服务框架SpringCloud受到众多公司欢迎，给大家带来一篇框架搭建入门。本次采用的版本是Spring Cloud版本为Finchley.RELEASE。　　　　为开发人员提供了快速构建分布式系统的一些工具，包括配置管理、服务发现、断路器

whbing / 0评论 2019-11-13

带你入门SpringCloud服务发现 | Eurka搭建和使用

服务注册与发现是微服务中最为基础的环节，而 Eureka 就是一个可以帮助你实现服务注册与发现的选择之一。文中通过具体操作带你了解如下内容：。阅读本文需要你熟悉SpringBoot项目的基本使用即可，还有一点需要注意的是在操作过程中尽量和我本地环境一致，因

80143853 / 0评论 2019-09-08

java程序员必知！SpringCloud入门：Feign 声明式接口调用！

与 Ribbon 一样，Feign 也是由 Netflix 提供的，Feign 是一个提供模版的声明式 Web Service 客户端， 使用 Feign 可以简化 Web Service 客户端的编写，开发者可以通过简单的接口和注解来调用 HTTP AP

pp / 0评论 2019-06-01

史上最简单的SpringCloud教程|第四篇:断路器（附基础入门资料）

为了保证其高可用，单个服务通常会集群部署。服务与服务之间的依赖性，故障会传播，会对整个微服务系统造成灾难性的严重后果，这就是服务故障的“雪崩”效应。最后，想学习java架构的小伙伴们！请关注+私信回复：“学习”就可以拿到一份我为大家准备的java架构学习资

码蚁 / 0评论 2019-03-12