Spring Cloud微服务与微服务架构

Spring Cloud

1、微服务与微服务架构

1.1 微服务概述

微服务强调的是服务的大小，他关注的是服务个体，每个服务只解决一个具体功能或模块。

1.2 微服务架构概述

微服务架构是一种架构模式，提倡将单一的应用程序划分成一组小的服务，每个服务运行在其独立的进程中，服务之间相互协调、相互配合。服务之间采用轻量级的通信机制相互沟通（通常是基于HTTP的RESTful API，Dubbo是采用RPC远程过程调用），可以使用不同的语言来编写服务，也可以使用不同的数据存储。

2、Spring Cloud

2.1 概述

Spring Cloud是基于SpringBoot的一套微服务解决方案，包括服务注册与发现，配置管理，全链路监控，服务网关，负载均衡，熔断器等组件。常用的五大组件：服务发现，负载均衡，断路器，服务网关，分布式配置。

2.2 Spring Cloud和Spring Boot的关系

Spring Boot专注于快速、方便的开发单个微服务个体，Spring Cloud是关注全局的微服务协调治理框架，将Spring Boot的微服务单体整合并管理起来。Spring Cloud离不开Spring Boot，属于依赖关系。

2.3 Spring Cloud和Dubbo的区别

①Spring Cloud提供的功能要比Dubbo的多，Dubbo主要分为服务注册中心，服务注册与发现，服务监控，断路器；而Spring Cloud是完整的分布式一站式框架，包括服务注册中心，服务注册与发现，服务监控，断路器，服务网关，分布式配置，消息总线，服务追踪等。

②Spring Cloud服务调用采用基于HTTP的REST方式，Dubbo采用RPC远程调用。RPC（远程过程调用协议）

③Spring Cloud的实现是采用类注解方式，具有一定的侵入性；Dubbo是通过xml配置完成，代码侵入性很小。

3、Eureka服务注册与发现

3.1 Eureka概述

Eureka是Netflix的一个子模块，是核心模块之一。Eureka是一个基于REST的服务，主要实现服务的注册与发现。

Eureka采用C-S的设计架构，包含两大组件：Eureka Server和Eureka Client。

Eureka Server作为服务注册功能的服务器，是服务注册中心。其他微服务使用Eureka Client连接到Eureka Server进行服务注册、服务发现。

3.2 服务注册操作

3.2.1 Eureka Server搭建

pom.xml文件引入包

        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-netflix-eureka-serverartifactId>
            <version>2.1.2.RELEASEversion>
        dependency>

application.yml文件配置

server:
  port: 7001 #端口号
eureka:
  instance:
    hostname: localhost #eureka服务端的实例名称
  client:
    register-with-eureka: false #false表示不向注册中心注册自己
    fetch-registry: false #false表示自己就是注册中心，维护服务实例，不检索服务
    service-url:
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/ #设置与Eureka Server交互的地址查询服务和注册服务都依赖的地址

主程序入口类加上注解

/**
 * 服务注册中心
 * 1.配置Eureka信息
 * 2.标注@EnableEurekaServer注解，启动注册中心
 */
@EnableEurekaServer
@SpringBootApplication
public class EurekaServer7001_App {

3.2.2 Eureka Client搭建

pom.xml文件引入包

        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-netflix-eureka-clientartifactId>
            <version>2.1.2.RELEASEversion>
        dependency>
        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-configartifactId>
            <version>2.1.2.RELEASEversion>
        dependency>

application.yml文件配置

server:
  port: 8001
  
spring:
  application:
    name: microservicecloud-dept #*** 对外暴露的模块/服务名称
    
eureka:
  client:
    service-url:
      defaultZone: http://localhost:7001/eureka #指定服务注册中心地址
  instance:
    instance-id: microservicecloud-dept:8001 #指定微服务的status名称
    prefer-ip-address: true #注册服务的时候使用服务的ip地址,访问服务时显示ip地址

主程序入口类添加注解

@SpringBootApplication  //SpringBoot核心注解
@EnableEurekaClient //开启服务自动注册
public class DeptProvider8001_App {

3.3 微服务的info信息配置

pom.xml文件导入监控包

        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-actuatorartifactId>
        dependency>

在父pom文件中添加配置

    <build>
        <finalName>microservicecloudfinalName>
        <resources>
            <resource>
                <directory>src/main/resourcesdirectory> 
                <filtering>truefiltering>
            resource>
        resources>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.pluginsgroupId> 
                <artifactId>maven-resources-pluginartifactId>
                <configuration>
                    <delimiters>
                        <delimit>$delimit>
                    delimiters>
                configuration>
            plugin>
        plugins>
    build>

application.yml文件添加配置

info:
  app.name: microservicecloud
  company.name: www.zjl.com
  build.artfactId: $project.artifactId$
  build.version: $project.version$

3.4 Eureka Server的自我保护机制

Eureka Server在一定时间内没有接收到某个微服务实例的心跳（无服务操作）（默认90秒），Eureka会将该服务进入自我保护模式，保护服务注册表中的信息，不注销服务实例，当收到心跳时退出自我保护模式。

可以使用eureka.server.enable-self-preservation=false禁用自我保护模式。

3.5 服务发现操作

导入pom依赖包

        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-netflix-eureka-clientartifactId>
            <version>2.1.2.RELEASEversion>
        dependency>

主程序入口添加注解

@EnableDiscoveryClient //服务发现

3.6 Eureka集群配置

3.6.1 创建Eureka Server集群，设置端口、访问地址

microservicecloud-eureka-server-7001

server:
  port: 7001 #端口号
eureka:
  instance:
    hostname: eureka-server-7001 #eureka服务端的实例名称
  client:
    register-with-eureka: false #false表示不向注册中心注册自己
    fetch-registry: false #false表示自己就是注册中心，维护服务实例，不检索服务
    service-url:
      #单机eurekaserver配置
      #defaultZone: http://eureka-server-7001:7001/eureka/ #设置与Eureka Server交互的地址查询服务和注册服务都依赖的地址
      #eureka集群配置
      defaultZone: http://eureka-server-7002:7002/eureka/,http://eureka-server-7003:7003/eureka/
      
microservicecloud-eureka-server-7002

server:
  port: 7002 #端口号
eureka:
  instance:
    hostname: eureka-server-7002 #eureka服务端的实例名称
  ...
  ...
    service-url:
      defaultZone: http://eureka-server-7001:7001/eureka/,http://eureka-server-7003:7003/eureka/
      
microservicecloud-eureka-server-7003

server:
  port: 7003 #端口号
eureka:
  instance:
    hostname: eureka-server-7003 #eureka服务端的实例名称
  ...
  ...
    service-url:
      defaultZone: http://eureka-server-7001:7001/eureka/,http://eureka-server-7002:7002/eureka/

3.6.2 配置访问地址

C:\Windows\System32\drivers\etc下的hosts文件

# springcloud的eureka集群设置端口
127.0.0.1	eureka-server-7001
127.0.0.1	eureka-server-7002
127.0.0.1	eureka-server-7003

3.6.3 配置服务

eureka:
  client:
    service-url:
      #单机eureka配置
      #defaultZone: http://localhost:7001/eureka #指定服务注册中心地址
      #eureka集群配置
      defaultZone: http://eureka-server-7001:7001/eureka,http://eureka-server-7002:7002/eureka,http://eureka-server-7003:7003/eureka
  instance:
    instance-id: microservicecloud-dept:8001 #指定微服务的status名称
    prefer-ip-address: true #注册服务的时候使用服务的ip地址,访问服务时显示ip地址

3.7 Eureka和Zookeeper的区别

3.7.1 ACID和CAP

关系型数据库的事务是ACID，原子性、一致性、独立性、持久性。

非关系型数据库的事务是CAP，强一致性、可用性、分区容错性。

CAP最多只能满足两个条件：

CA-单点集群，满足一致性，可用性的系统，通常早可扩展性上不太强大。

CP-满足一致性、分区容错性的系统，通常性能不是很高。

AP-满足可用性、分区容错性的系统，通常对一致性要求低点

3.7.2 区别

Zookeeper保证CP原则，当服务对可用性的要求高时，可能出现服务瘫痪；

Eureka保证AP原则，保证高可用性，一致性稍弱，数据信息可能不是最新的，具有自我保护机制，可以应对因网络故障导致部分节点失去联系的情况。

4、Ribbon负载均衡

4.1 Ribbon概述

Spring Cloud Ribbon是基于Netflix Ribbon实现的一套客户端负载均衡的工具，主要功能是提供客户端的软件负载均衡算法。

4.2 Load Balance 负载均衡

Load Balance，即负载均衡（LB），将用户的请求平摊地分配到多个服务上。

集中式LB：在服务的消费方和提供方之间使用独立的LB设施（可以是硬件，如F5，也可以是软件，如nginx），由该设施负载把访问请求根据某种策略转发到服务的提供方。

进程内LB：将LB逻辑集成到消费方，消费方从服务注册中心获知哪些地址可用，从可用的地址中选择合适的服务器。Ribbon就属于进程内LB。

4.3 Ribbon的使用(用在客户端)

4.3.1 导入依赖包并添加注解

        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-netflix-eureka-clientartifactId>
            <version>2.1.2.RELEASEversion>
        dependency>

        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-configartifactId>
            <version>2.1.2.RELEASEversion>
        dependency>
        
        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-netflix-ribbonartifactId>
            <version>2.1.2.RELEASEversion>
        dependency>

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

4.3.2 添加注解启动负载均衡

	@LoadBalanced //开启负载均衡，轮询算法
    @Bean
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }

4.3.3 修改访问路径

//MICROSERVICECLOUD-DEPT为服务的Application名称
private static final String REST_URL_PREFIX="http://MICROSERVICECLOUD-DEPT/provider/dept";

@RequestMapping("/list")
    public List<Dept> list(Dept dept){
        return restTemplate.getForObject(REST_URL_PREFIX+"/list",List.class);
    }

4.4 负载均衡算法Rule

Rule有7种：

RoundRobinRule：轮询（默认的）

RandomRule：随机

AvailabilityFilteringRule

WeightedResponseTimeRule

RetryRule：先按照RoundRobinRule的策略获取服务，获取服务失败几次后，直接跳过该服务进行下一个服务的获取。

BestAvailableRule

ZoneAvoidanceRule

@Configuration
public class ConfigBean {

    @LoadBalanced //开启负载均衡
    @Bean
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }

    //切换负载均衡的规则
    @Bean
    public IRule myRule(){
        //return new RoundRobinRule();
        //return new RandomRule();
        return new RetryRule();
    }
}

4.5 自定义负载均衡算法

自定义Rule类

public class RandomRule_ZY extends AbstractLoadBalancerRule
{

	// total = 0 // 当total==5以后，我们指针才能往下走，
	// index = 0 // 当前对外提供服务的服务器地址，
	// total需要重新置为零，但是已经达到过一个5次，我们的index = 1
	// 分析：我们5次，但是微服务只有8001 8002 8003 三台，OK？
	// 
	
	
	private int total = 0; 			// 总共被调用的次数，目前要求每台被调用5次
	private int currentIndex = 0;	// 当前提供服务的机器号

	public Server choose(ILoadBalancer lb, Object key)
	{
		if (lb == null) {
			return null;
		}
		Server server = null;

		while (server == null) {
			if (Thread.interrupted()) {
				return null;
			}
			List<Server> upList = lb.getReachableServers();
			List<Server> allList = lb.getAllServers();

			int serverCount = allList.size();
			if (serverCount == 0) {
				/*
				 * No servers. End regardless of pass, because subsequent passes only get more
				 * restrictive.
				 */
				return null;
			}

//			int index = rand.nextInt(serverCount);// java.util.Random().nextInt(3);
//			server = upList.get(index);

			
//			private int total = 0; 			// 总共被调用的次数，目前要求每台被调用5次
//			private int currentIndex = 0;	// 当前提供服务的机器号
            if(total < 5)
            {
	            server = upList.get(currentIndex);
	            total++;
            }else {
	            total = 0;
	            currentIndex++;
	            if(currentIndex >= upList.size())
	            {
	              currentIndex = 0;
	            }
            }			
			
			
			if (server == null) {
				/*
				 * The only time this should happen is if the server list were somehow trimmed.
				 * This is a transient condition. Retry after yielding.
				 */
				Thread.yield();
				continue;
			}

			if (server.isAlive()) {
				return (server);
			}

			// Shouldn't actually happen.. but must be transient or a bug.
			server = null;
			Thread.yield();
		}

		return server;

	}

	@Override
	public Server choose(Object key)
	{
		return choose(getLoadBalancer(), key);
	}

	@Override
	public void initWithNiwsConfig(IClientConfig clientConfig)
	{
		// TODO Auto-generated method stub

	}

}

向容器中注入RuleBean

@Configuration
public class MySelfRule
{
	@Bean
	public IRule myRule()
	{
		//return new RandomRule();// Ribbon默认是轮询，我自定义为随机
		//return new RoundRobinRule();// Ribbon默认是轮询，我自定义为随机
		
		return new RandomRule_ZY();// 我自定义为每台机器5次
	}
}

使用自定义Rule

//在启动该微服务的时候就能去加载我们的自定义Ribbon配置类，从而使配置生效
@RibbonClient(name="MICROSERVICECLOUD-DEPT",configuration=MySelfRule.class)
//注意：MySelfRule类不能放在主程序类的同包和子包下，否则不能生效
public class DeptConsumer80_App
{
	public static void main(String[] args)
	{
		SpringApplication.run(DeptConsumer80_App.class, args);
	}
}

5、Feign负载均衡

5.1 概述

Feign是一个声明式的Web服务客户端，让编写Web Servicer客户端更加简单，只需定义一个接口，然后在上面添加注解即可。

Fegin通过接口的方法调用Rest服务代替之前的Ribbon+RestTemplate的编写。

5.2 使用步骤

5.2.1 创建客户端微服务并导入包

        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-netflix-ribbonartifactId>
            <version>2.1.2.RELEASEversion>
        dependency>
        
        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-feignartifactId>
            <version>1.4.6.RELEASEversion>
        dependency>

5.2.2 编写接口并添加注解

@FeignClient(value="MICROSERVICECLOUD-DEPT")//要访问的服务名称,定义Feign客户端
@RequestMapping("/provider/dept/")
public interface DeptClientService {

    @RequestMapping(value="/get/{id}",method = RequestMethod.GET)
    public Dept get(@PathVariable("id") Integer id);

    @RequestMapping(value = "/list",method = RequestMethod.GET)
    public List<Dept> list();

    @RequestMapping(value = "/add",method = RequestMethod.POST)
    public boolean add(Dept dept);
}

5.2.3 controller层调用

 @Autowired
    private DeptClientService deptClientService;

    @RequestMapping("/add")
    public boolean add(Dept dept){
        return deptClientService.add(dept);
    }

5.2.4 主程序入口添加注解

@SpringBootApplication
@EnableEurekaClient
@EnableFeignClients(basePackages={"com.springcloud"}) //启动feign客户端 @FeignClient 是定义feign客户端
@ComponentScan("com.springcloud") //指定要扫描的包，将需要装配的类装配到spring的bean容器中
public class DeptConsumer80_feign_App {
    public static void main(String[] args) {
        SpringApplication.run(DeptConsumer80_feign_App.class,args);
    }
}

6、Hystrix断路器

6.1 概论

Hystrix是一个用于处理分布式系统的延迟和容错的开源库，保证在一个依赖出现问题的情况下，不会导致整体服务失败，避免级联故障，提高分布式系统的弹性。

当某个服务单元发生故障之后，通过断路器的故障监控，向调用方返回一个符合预期的、可处理的被选响应（FallBack），而不是长时间的等待或者抛出调用方法无法处理的异常，这样就保证了服务调用方的线程不会被长时间、不必要地占用，从而避免了故障在分布式系统中的蔓延，乃至雪崩。

6.2 服务熔断

6.2.1 概述

熔断机制是应对雪崩效应的一种微服务链路保护机制，当某个服务不可用或相应时间太长时，会进行服务的降级，进而熔断该节点微服务的调用，快速返回“错误”的响应信息。当检测到该节点微服务调用响应正常后恢复调用链路。

6.2.2 使用步骤

创建相关客户端微服务，导入Hystrix的包

        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-netflix-hystrixartifactId>
            <version>2.1.2.RELEASEversion>
        dependency>

编写服务失败后执行的方法，并配置

	@RequestMapping(value = "/get/{id}",method = RequestMethod.GET)
    @HystrixCommand(fallbackMethod="processHystrix_Get") //当方法异常时，自动执行processHystrix_Get方法，返回指定的信息
    public Dept get(@PathVariable("id") Integer id){
        Dept dept=deptService.get(id);
        if(dept==null){//当dept不存在时，抛出异常
            throw new RuntimeException("该ID："+id+"没有对应的信息");
        }
        return dept;
    }

    public Dept processHystrix_Get(@PathVariable("id")Integer id){
        return new Dept().setDeptno(id).setDname("该ID："+id+"没有对应的信息，null--@HystrixCommand").setDb_source("no this database in MySQL");
    }

主程序入口添加注解，开启Hystrix熔断机制的支持

@EnableCircuitBreaker //开启Hystrix熔断机制的支持
public class DeptProvider8001_hystrix_App {

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

6.3 服务降级

6.3.1 概述

当整体资源不够时，关闭某些服务，待资源紧张过后，再开启服务。

服务降级处理是在客户端实现完成的，与服务端没有关系

使用服务降级处理，让客户端在服务端不能使用时也能获得提示信息而不会挂死或耗死服务器。

6.3.2 使用步骤

创建工厂类，统一处理服务异常调用方法

@Component
public class DeptClientServiceFallbackFactory implements FallbackFactory<DeptClientService> {

    @Override
    public DeptClientService create(Throwable throwable) {
        return new DeptClientService() {
            @Override
            public Dept get(Integer id) {
                return new Dept().setDeptno(id).setDname("该ID："+id+"没有对应的信息，Consumer客户端提供的降级信息，此刻服务Provider已经关闭").setDb_source("no this database in MySQL");
            }

            @Override
            public List<Dept> list() {
                return null;
            }

            @Override
            public boolean add(Dept dept) {
                return false;
            }
        };
    }
}

使用FeignClient注解指定fallbackFactory

@FeignClient(value="MICROSERVICECLOUD-DEPT",fallbackFactory = DeptClientServiceFallbackFactory.class)
public interface DeptClientService {

    @RequestMapping(value="/get/{id}",method = RequestMethod.GET)
    public Dept get(@PathVariable("id") Integer id);

    @RequestMapping(value = "/list",method = RequestMethod.GET)
    public List list();

    @RequestMapping(value = "/add",method = RequestMethod.POST)
    public boolean add(Dept dept);
}

客户端服务配置

feign:
  hystrix:
    enabled: true #开启熔断器服务

6.4 服务监控hystrixDashboard

6.4.1 概述

准实时的调用监控（Hystrix Dashboard），Hystrix会持续地记录所有通过Hystrix发起的请求的执行信息，并以统计报表和图形的形式展示给用户。

6.4.2 使用步骤

搭建监控微服务

        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-hystrixartifactId>
            <version>1.4.1.RELEASEversion>
        dependency>
        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-hystrix-dashboardartifactId>
            <version>1.4.1.RELEASEversion>
        dependency>

主程序入口添加注解

@SpringBootApplication
@EnableHystrixDashboard //开启服务监控
public class DeptConsumer_DashBoard_App {
    public static void main(String[] args) {
        SpringApplication.run(DeptConsumer_DashBoard_App.class,args);
    }
}

需要监控服务的导入监控相关的包

        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-actuatorartifactId>
        dependency>

7、zuul路由网关

7.1 概述

Zuul包含对请求的路由和过滤两个最重要的功能。路由功能负责将外部请求转发到具体的微服务实例上，是实现外部访问统一入口的基础；过滤器功能负责对请求的处理过程进行干预，是实现请求校验、服务聚合等功能的基础。

7.2 使用步骤

创建路由服务module

<dependencies>
        
        <dependency>
            <groupId>com.springcloudgroupId>
            <artifactId>microservicecloud-apiartifactId>
            <version>${project.version}version>
        dependency>
        <dependency>
            <groupId>junitgroupId>
            <artifactId>junitartifactId>
        dependency>
        
        <dependency>
            <groupId>ch.qos.logbackgroupId>
            <artifactId>logback-coreartifactId>
        dependency>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
            <version>2.1.6.RELEASEversion>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
            <version>2.1.6.RELEASEversion>
        dependency>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-actuatorartifactId>
        dependency>
        
        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-netflix-eureka-clientartifactId>
            <version>2.1.2.RELEASEversion>
        dependency>
        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-configartifactId>
            <version>2.1.2.RELEASEversion>
        dependency>
        
        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-hystrixartifactId>
            <version>1.4.1.RELEASEversion>
        dependency>
        
        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-zuulartifactId>
            <version>1.4.2.RELEASEversion>
        dependency>
        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-configartifactId>
            <version>2.1.2.RELEASEversion>
        dependency>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-devtoolsartifactId>
            <version>2.1.6.RELEASEversion>
            <optional>trueoptional>
        dependency>
    dependencies>

application.yml文件配置

server: 
  port: 9527
 
spring: 
  application:
    name: microservicecloud-zuul-gateway
 
eureka: 
  client: 
    service-url: 
      defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka,http://eureka7003.com:7003/eureka  
  instance:
    instance-id: gateway-9527.com
    prefer-ip-address: true 
 
 
zuul: 
  #ignored-services: microservicecloud-dept
  prefix: /atguigu
  ignored-services: "*"
  routes: 
    mydept.serviceId: microservicecloud-dept
    mydept.path: /mydept/**
 
info:
  app.name: atguigu-microcloud
  company.name: www.atguigu.com
  build.artifactId: $project.artifactId$
  build.version: $project.version$

主程序入口添加注解

@SpringBootApplication
@EnableZuulProxy //开启路由代理
public class Zuul_9527_StartSpringCloudApp {
    public static void main(String[] args) {
        SpringApplication.run(Zuul_9527_StartSpringCloudApp.class,args);
    }
}

使用路由访问

普通访问：http://localhost:8001/provider/dept/list
路由访问：http://localhost:9527/microservicecloud-dept/provider/dept/list

7.3 资源映射规则

zuul:
  prefix: /springcloud #统一的前缀
  ignored-services: "*" #隐藏所有原访问路径，只能通过域名映射后的路径访问
  routes:
    mydept.serviceId: microservicecloud-dept #域名映射成/mydent/**
    mydept.path: /mydept/**

原访问路径：http://localhost:9527/microservicecloud-dept/provider/dept/list
现访问路径：http://localhost:9527/springcloud/mydept/provider/dept/list

8、Config分布式配置中心

8.1 概述

SpringCloud Config为微服务架构中的微服务提供集中化的外部配置支持，配置服务器为各个不同微服务应用的所有环境提供了一个中心化的外部配置。

SpringCloud Config分为服务端和客户端两部分。

服务端称为分布式配置中心，它是一个独立的微服务应用，用来连接配置服务器并为客户端提供获取配置信息，加密、解密信息等访问接口。

客户端则是通过指定的配置中心来管理应用资源，以及与业务相关的配置内容，并在启动的时候从配置中心获取和加载配置信息。配置服务器默认采用git来存储配置信息，这样就有助于对环境配置进行版本管理，并且可以通过git客户端工具来方便的管理和访问配置内容。

8.2 服务端使用步骤

8.2.1 准备工作-下载链接github仓库

// 在github上创建仓库
git clone 仓库的ssh
// 仓库下创建application.yml文件
// 提交文件到仓库
git add .
git commit -m "说明信息"
git push origin master

8.2.2 创建config微服务导入config依赖包

<dependencies>
        <dependency>
            <groupId>junitgroupId>
            <artifactId>junitartifactId>
        dependency>
        
        <dependency>
            <groupId>ch.qos.logbackgroupId>
            <artifactId>logback-coreartifactId>
        dependency>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
            <version>2.1.6.RELEASEversion>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
            <version>2.1.6.RELEASEversion>
        dependency>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-actuatorartifactId>
        dependency>
        
        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-netflix-hystrixartifactId>
            <version>2.1.2.RELEASEversion>
        dependency>
        
        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-netflix-eureka-clientartifactId>
            <version>2.1.2.RELEASEversion>
        dependency>
        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-configartifactId>
            <version>2.1.2.RELEASEversion>
        dependency>
        
        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-config-serverartifactId>
            <version>2.1.2.RELEASEversion>
        dependency>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-devtoolsartifactId>
            <version>2.1.6.RELEASEversion>
            <optional>trueoptional>
        dependency>
    dependencies>

8.2.3 配置application.yml文件

server:
  port: 3344

spring:
  application:
    name: microservicecloud-config
  cloud:
    config:
      server:
        git:
          uri: [email protected]:lele961111/microservicecloud-config.git #github的仓库的ssh

eureka:
  client:
    register-with-eureka: false # 表示不向注册中心注册
    fetch-registry: false # 由于注册中心的职责就是维护服务实例，所以它不需要去检索服务

8.2.4 主程序入口添加注解

@SpringBootApplication
@EnableConfigServer
public class Config_3344_StartSpringCloudApp {

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

8.3 客户端使用步骤

8.3.1 准备工作

// 仓库下创建microservicecloud-config-client.yml文件
// 提交文件到仓库
git add .
git commit -m "说明信息"
git push origin master

8.3.2 创建客户端微服务引入config客户端依赖

<dependencies>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
            <version>2.1.6.RELEASEversion>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
            <version>2.1.6.RELEASEversion>
        dependency>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-actuatorartifactId>
        dependency>
        
        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-netflix-eureka-clientartifactId>
            <version>2.1.2.RELEASEversion>
        dependency>
        
        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-configartifactId>
            <version>2.1.2.RELEASEversion>
        dependency>
        
        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-hystrixartifactId>
            <version>1.4.1.RELEASEversion>
        dependency>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-devtoolsartifactId>
            <version>2.1.6.RELEASEversion>
            <optional>trueoptional>
        dependency>
    dependencies>

8.3.3 配置文件配置

bootstrap.yml

#application.yml 是用户级的资源配置项
#bootstrap.yml 是系统级的，优先级更高
spring:
  cloud:
    config:
      name: microservicecloud-config-client #需要从github上读取的资源名称，没有yml后缀名
      profile: dev #本次访问的配置项
      label: master
      uri: http://localhost:3344 #本微服务启动后先去找3344服务，通过SpringCloudConfig获取GitHub的服务地址

application.yml

spring:
  application:
    name: microservicecloud-config-client #要喝bootstarp的同名

eureka:
  client:
    register-with-eureka: false # 表示不向注册中心注册
    fetch-registry: false # 由于注册中心的职责就是维护服务实例，所以它不需要去检索服务

8.3.4 编写测试controller类访问/config

@RestController
public class ConfigClientRest {
    @Value("${spring.application.name}")
    private String applicationName;
    @Value("${eureka.client.service-url.defaultZone}")
    private String eurekaServers;
    @Value("${server.port}")
    private String port;
    @RequestMapping("/config")
    public String getConfig(){
        String str="applicationName:"+applicationName+"\t eurekaServers:"+eurekaServers+"\t port:"+port;
        return str;
    }
}

启动config服务器微服务，启动config客户端微服务，访问各端口下的/config