互联网分布式应用之SpringCloud

package com.bobo.service;

import com.bobo.pojo.User;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixCollapser;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixProperty;
import com.netflix.hystrix.contrib.javanica.conf.HystrixPropertiesManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheConfig;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Future;

@Service
// cacheNames 当前类中的方法在Redis中添加的Key的前缀
@CacheConfig(cacheNames = {"com.bobo.cache"})
public class UserService {


    /**
     * Ribbon 实现的负载均衡
     *    LocadBalancerClient 通过服务名称可以获取对应服务的相关信息
     *                         ip 端口 等
     */
    @Autowired
    private LoadBalancerClient loadBalancerClient;

    /**
     * 远程调用 服务提供者获取用户信息的方法
     * 1.发现服务
     * 2.调用服务
     * @return
     */
    @HystrixCommand(fallbackMethod = "fallBack")
    public List<User> getUsers(Integer id){
        // 1. 服务发现
        // 获取服务提供者的信息 ServiceInstance封装的有相关的信息
        ServiceInstance instance = loadBalancerClient.choose("eureka-provider");
        StringBuilder sb = new StringBuilder();
        // http://localhost:9090/user
        sb.append("http://")
                .append(instance.getHost())
                .append(":")
                .append(instance.getPort())
                .append("/user");
        System.out.println("---->"+sb.toString());
        // 2. 服务调用 SpringMVC中提供的有 调用组件 RestTemplate
        RestTemplate rt = new RestTemplate();
        ParameterizedTypeReference<List<User>> type = new ParameterizedTypeReference<List<User>>() {};
        ResponseEntity<List<User>> response = rt.exchange(sb.toString(), HttpMethod.GET, null, type);
        List<User> list = response.getBody();
        return list;

    }

    /**
     * 托底方法
     * @return
     */
    public List<User> fallBack(Integer id){
        List<User> list = new ArrayList<>();
        list.add(new User(333,"我是托底数据",28));
        return list;
    }

    @Cacheable(key="'user'+#id")
    public User getUserById(Integer id){
        System.out.println("*************查询操作*************"+ id);
        return new User(id,"缓存测试数据",22);
    }

    /**
     * Consumer中的Controller要调用的方法
     * 这个方法的返回值必须是 Future 类型
     *    利用Hystrix 合并请求
     * @param id
     * @return
     */
    @HystrixCollapser(
            batchMethod = "batchUser"
            ,scope = com.netflix.hystrix.HystrixCollapser.Scope.GLOBAL
            ,collapserProperties = {
                    // 请求时间间隔在20ms以内的请求会被合并，默认值是10ms
                    @HystrixProperty(name = "timerDelayInMilliseconds",value = "20")
                    // 设置触发批处理执行之前 在批处理中允许的最大请求数
                    ,@HystrixProperty(name = "maxRequestsInBatch",value = "200")
    }
    )
    public Future<User> getUserId(Integer id){
        System.out.println("*****id*****");
        return null;
    }

    @HystrixCommand
    public List<User> batchUser(List<Integer> ids){
        for (Integer id : ids) {
            System.out.println(id);
        }
        List<User> list = new ArrayList<>();
        list.add(new User(1,"张三1",18));
        list.add(new User(2,"张三2",18));
        list.add(new User(3,"张三3",18));
        list.add(new User(4,"张三4",18));
        return list;
    }
}

@RequestMapping("/getUserId")
public void getUserId() throws Exception{
    Future<User> f1 = service.getUserId(1);
    Future<User> f2 = service.getUserId(1);
    Future<User> f3 = service.getUserId(1);

    System.out.println("*************************");
    System.out.println(f1.get().toString());
    System.out.println(f2.get().toString());
    System.out.println(f3.get().toString());
}

  

访问测试

  

    

5.熔断

熔断其实是在降级的基础上引入了重试的机制。当某个时间内失败的次数达到了多少次就会触发熔断机制，具体的流程如下。

    

案例核心代码

    @HystrixCommand(fallbackMethod = "fallBack",
            commandProperties = {
                    //默认 20 个;10s 内请求数大于 20 个时就启动熔断器，当请求符合熔断条件时将触发 getFallback()。
                    @HystrixProperty(name= HystrixPropertiesManager.CIRCUIT_BREAKER_REQUEST_VOLUME_THRESHOLD,
                            value="10"),
                    //请求错误率大于 50%时就熔断，然后 for 循环发起请求，当请求符合熔断条件时将触发 getFallback()。
                    @HystrixProperty(name=HystrixPropertiesManager.CIRCUIT_BREAKER_ERROR_THRESHOLD_PERCENTAGE,
                            value="50"),
                    //默认 5 秒;熔断多少秒后去尝试请求
                    @HystrixProperty(name=HystrixPropertiesManager.CIRCUIT_BREAKER_SLEEP_WINDOW_IN_MILLISECONDS,
                            value="5000"),
            })
    public List<User> getUsers(Integer id){
        System.out.println("-----> id = " + id+"  " + Thread.currentThread().getName());
        if(id == 1){
            throw new RuntimeException();
        }
        // 1. 服务发现
        // 获取服务提供者的信息 ServiceInstance封装的有相关的信息
        ServiceInstance instance = loadBalancerClient.choose("eureka-provider");
        StringBuilder sb = new StringBuilder();
        // http://localhost:9090/user
        sb.append("http://")
                .append(instance.getHost())
                .append(":")
                .append(instance.getPort())
                .append("/user");
        System.out.println("---->"+sb.toString());
        // 2. 服务调用 SpringMVC中提供的有 调用组件 RestTemplate
        RestTemplate rt = new RestTemplate();
        ParameterizedTypeReference<List<User>> type = new ParameterizedTypeReference<List<User>>() {};
        ResponseEntity<List<User>> response = rt.exchange(sb.toString(), HttpMethod.GET, null, type);
        List<User> list = response.getBody();
        return list;

    }

  

测试

  

    

6. 隔离

在应对服务雪崩效应时，除了前面介绍的降级，缓存，请求合并及熔断外还有一种方式就是隔离，隔离又分为线程池隔离和信号量隔离。接下来我们分别来介绍。

  

6.1 线程池隔离

6.1.1 概念介绍

我们通过以下几个图片来解释线程池隔离到底是怎么回事。

  

在没有使用线程池隔离时。

  

当接口A压力增大，接口C同时也会受到影响。

  

使用线程池的场景。

  

当服务接口A访问量增大时，因为接口C在不同的线程池中所以不会受到影响。

  

通过上面的图片来看，线程池隔离的作用还是蛮明显的。但线程池隔离的使用也不是在任何场景下都适用的，线程池隔离的优缺点如下：

优点

1. 使用线程池隔离可以完全隔离依赖的服务(例如图中的A，B，C服务)，请求线程可以快速放回。

2. 当线程池出现问题时，线程池隔离是独立的不会影响其他服务和接口。

3. 当失败的服务再次变得可用时，线程池将清理并可立即恢复，而不需要一个长时间的恢复。

4. 独立的线程池提高了并发性。

缺点

线程池隔离的主要缺点是它们增加计算开销(CPU).每个命令的执行涉及到排队，调度和上下文切换都是在一个单独的线程上运行的。

    

6.1.2 案例实现

    @HystrixCommand(
            groupKey = "eureka-provider"
            ,threadPoolKey = "getUsers"
            ,threadPoolProperties = {
                    @HystrixProperty(name = "coreSize",value = "30") // 线程池大小
                    ,@HystrixProperty(name = "maxQueueSize",value = "100") // 最大队列长度
                    ,@HystrixProperty(name = "keepAliveTimeMinutes",value = "2") // 线程存活时间
                    ,@HystrixProperty(name = "queueSizeRejectionThreshold",value = "15") // 拒绝请求
            },fallbackMethod = "fallBack"
    )
    public List<User> getUsersThreadPool(Integer id){
        System.out.println("--------》" + Thread.currentThread().getName());
        // 1. 服务发现
        // 获取服务提供者的信息 ServiceInstance封装的有相关的信息
        ServiceInstance instance = loadBalancerClient.choose("eureka-provider");
        StringBuilder sb = new StringBuilder();
        // http://localhost:9090/user
        sb.append("http://")
                .append(instance.getHost())
                .append(":")
                .append(instance.getPort())
                .append("/user");
        System.out.println("---->"+sb.toString());
        // 2. 服务调用 SpringMVC中提供的有 调用组件 RestTemplate
        RestTemplate rt = new RestTemplate();
        ParameterizedTypeReference<List<User>> type = new ParameterizedTypeReference<List<User>>() {};
        ResponseEntity<List<User>> response = rt.exchange(sb.toString(), HttpMethod.GET, null, type);
        List<User> list = response.getBody();
        return list;

    }

  

测试

  

相关参数的描述。

  

  

6.2 信号量隔离

信号量隔离其实就是我们定义的队列并发时最多支持多大的访问，其他的访问通过托底数据来响应，如下结构图。

  

    @HystrixCommand(
            fallbackMethod = "fallBack"
            ,commandProperties = {
                    @HystrixProperty(name=HystrixPropertiesManager.EXECUTION_ISOLATION_STRATEGY
                            ,value = "SEMAPHORE") // 信号量隔离
                    ,@HystrixProperty(name=HystrixPropertiesManager.EXECUTION_ISOLATION_SEMAPHORE_MAX_CONCURRENT_REQUESTS
            ,value="100" // 信号量最大并发度
    )
    }
    )
    public List<User> getUsersSignal(Integer id){
        System.out.println("--------》" + Thread.currentThread().getName());
        // 1. 服务发现
        // 获取服务提供者的信息 ServiceInstance封装的有相关的信息
        ServiceInstance instance = loadBalancerClient.choose("eureka-provider");
        StringBuilder sb = new StringBuilder();
        // http://localhost:9090/user
        sb.append("http://")
                .append(instance.getHost())
                .append(":")
                .append(instance.getPort())
                .append("/user");
        System.out.println("---->"+sb.toString());
        // 2. 服务调用 SpringMVC中提供的有 调用组件 RestTemplate
        RestTemplate rt = new RestTemplate();
        ParameterizedTypeReference<List<User>> type = new ParameterizedTypeReference<List<User>>() {};
        ResponseEntity<List<User>> response = rt.exchange(sb.toString(), HttpMethod.GET, null, type);
        List<User> list = response.getBody();
        return list;

    }

  

  

6.3 两者的区别

线程池隔离和信号量隔离的区别。

  

7. Feign的使用

我们前面介绍的案例都是基于Ribbon来时下的，那么我们看下在Feign中我们是如何来实现服务的降级的。

  

我们需要放开Feign对Hystrix的支持。

# Feign默认是不开启 Hystrix的，默认false
feign.hystrix.enabled=true

  

添加对应的依赖。

<!-- 添加Hystrix的依赖 -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
</dependency>

    

开启Hystrix的支持。

package com.bobo;

import feign.Logger;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.circuitbreaker.EnableCircuitBreaker;
import org.springframework.cloud.openfeign.EnableFeignClients;
import org.springframework.context.annotation.Bean;

/**
* 我们需要放开Feign的客户端注解
*/
@EnableCircuitBreaker
@EnableFeignClients
@SpringBootApplication
public class SpringcloudFeignProductConsumerApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringcloudFeignProductConsumerApplication.class,args);
    }

    /**
    * 定义日志的输出级别
    * NONE, 不记录任何信息 默认值
    * BASIC, 记录基本信息(请求方法，请求URL，状态码和用时)
    * HEADERS,在BASIC的基础上再记录一些常用信息
    * FULL;记录请求和响应的所有的数据
    * @return
    */
    @Bean
    public Logger.Level getLogger(){
        return Logger.Level.FULL;
    }
}

  

业务处理

package com.bobo.hystrix;

import com.bobo.pojo.Product;
import com.bobo.service.ProductConsumerService;
import org.springframework.stereotype.Component;
import java.awt.*;
import java.util.ArrayList;
import java.util.List;

@Component
public class ProductServiceFallback implements ProductConsumerService {

    /**
    * 这个其实就是返回托底数据逇方法
    * @return
    */
    @Override
    public List<Product> findAll() {
        List<Product> list = new ArrayList<>();
        list.add(new Product(-1,"我是托底数据"));
        return list;
    }

    @Override
    public Product getProductById(Integer id) {
        return null;
    }

    @Override
    public Product addProductGet(Integer id, String name) {
        return null;
    }

    @Override
    public Product addProductPost(Product product) {
        return null;
    }
}

  

在接口中关联托底类

/**
* Feign的消费者的 Service服务
* name中我们指定的 在Eureka中注册的服务提供者的名称
* fallback 关联 托底数据类
*/
@FeignClient(name = "shop-product-provider",fallback = ProductServiceFallback.class)
public interface ProductConsumerService extends ProductService {
}

 

  

测试：

provider正常。

  

provider异常，返回托底数据。

  

8.Feign异常日志

我们上面案例中provider出现异常，consumer返回了托底数据，但是我们并不清楚provider发生了什么异常问题，这时我们需要记录Feign的降级信息。

  

添加一个FallbackFactory类

package com.bobo.hystrix;

import com.bobo.pojo.Product;
import com.bobo.service.ProductConsumerService;
import feign.hystrix.FallbackFactory;
import org.springframework.stereotype.Component;
import java.util.List;
import java.util.logging.Logger;

@Component
public class ProductServiceFallbackFactory implements FallbackFactory<ProductConsumerService> {
    private Logger logger = Logger.getLogger(ProductServiceFallbackFactory.class.getName());
    @Override
    public ProductConsumerService create(Throwable throwable) {
        System.out.println("***** Feign fallback
        Exception:"+throwable.toString());
        return new ProductServiceFallback();
    }
}

  

然后在接口中关联

package com.bobo.service;

import com.bobo.hystrix.ProductServiceFallback;
import com.bobo.hystrix.ProductServiceFallbackFactory;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.stereotype.Service;

/**
* Feign的消费者的 Service服务
* name中我们指定的 在Eureka中注册的服务提供者的名称
* fallback 关联 托底数据类
*/
//@FeignClient(name = "shop-product-provider",fallback =
ProductServiceFallback.class)
@FeignClient(name = "shop-product-provider",fallbackFactory = ProductServiceFallbackFactory.class)
public interface ProductConsumerService extends ProductService {
}

  

然后在返回托底数据的情况我们可以看到日志信息。

  

  

六、Zuul

1.什么是Zuul

zuul 是netflix开源的一个API Gateway 服务器, 本质上是一个web servlet应用。

Zuul 在云平台上提供动态路由，监控，弹性，安全等边缘服务的框架。Zuul 相当于是设备和Netflix 流应用的 Web 网站后端所有请求的前门。

zuul的例子可以参考netflix在github上的 simple webapp，可以按照netflix 在github wiki 上文档说明来进行使用。

   

2.解决了什么问题

  

3.入门案例

3.1 创建项目

创建网关服务项目，也是一个普通的SpringBoot项目，添加相关的依赖。

  

添加相关的依赖

    <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>Hoxton.SR10</spring-cloud.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
        </dependency>

        <!-- 表示这是一个SpringCloud Eureka 的Client -->
        <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-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </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>

  

3.2 配置文件

在属性文件中我们同样的需要添加Eureka的相关信息。

spring.application.name=Zuul-getway
server.port=9020

# 设置服务注册中心的地址
eureka.client.service-url.defaultZone=http://bobo:123456@192.168.100.120:8761/eureka/,http://bobo:123456@192.168.100.121:8761/eureka/

  

3.3 启动器

我们需要在启动类中添加Zuul的注解。

package com.bobo;

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

@EnableZuulProxy
@SpringBootApplication
public class SpringcloudZuulGetwayApplication {

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

}

3.4 测试效果

首先直接访问服务提供者。

访问地址：http://localhost:9081/product/findAll

  

  

通过Zuul来间接访问服务。

http://localhost:9020/shop-product-provider/product/findAll

http://网关地址:网关端口/要访问的服务的名称/访问的服务中的接口地址。

  

  

4.路由规则

4.1 指定路由

根据客户端提交的请求地址直接路由到服务地址。

spring.application.name=Zuul-getway
server.port=9020

# 设置服务注册中心的地址
eureka.client.service-url.defaultZone=http://bobo:123456@192.168.100.120:8761/eureka/,http://bobo:123456@192.168.100.121:8761/eureka/

zuul.routes.shop-product-provider.path=/bobo/**
zuul.routes.shop-product-provider.url=http://127.0.0.1:9081/

  

说明：

zuul.routes.shop-product-provider.path

zuul.routes.固定的

shop-product-provider 自定义的

path:固定的

/bobo/** 表示请求的url地址

zuul.routes.shop-product-provider.url=http://127.0.0.1:9081/

表示当用户的请求是 http://xxx/bobo/** 者路由到 http://127.0.0.1:9081/服务处理

  

  

  

4.2 指定路由服务名称

上面的指定路由是根据客户端提交的请求地址路由到具体的服务中，这种方式其实是不太灵活的，我们可以路由到Eureka中注册的服务名称。

  

第一种方式

# 服务名称 路由
zuul.routes.shop-product-provider.path=/bobo/**
zuul.routes.shop-product-provider.service-id=shop-product-provider

  

  

第二种方式

# 服务名称 路由 第二种方式 shop-product-provider必须是我们要请求的服务的名称
zuul.routes.shop-product-provider.path=/bobo/**

  

   

4.3 路由的排除方式

排除路由，也就是该路由器会忽略掉某几个服务，即使客户端发送了请求也访问不了。

zuul.ignored-services=eureka-provider

  

如果有多个服务要排序。这时可以通过”,”连接的方式来排除多个服务。

zuul.ignored-services=eureka-provider1,eureka-provider2

  

如果有很多个要排除的服务，一个个来写太麻烦了，这时我们可以先排除掉所有的服务，然后再添加我们要放开的服务即可。

# 先排除所有的服务
zuul.ignored-services=*
# 然后再放开特定的服务
zuul.routes.shop-product-provider.path=/bobo/**

  

如果我们要针对某个服务中特殊接口来处理，我们也可以通过关键字处理。

# 先排除所有的服务包含 findAll关键字的请求
zuul.ignored-services=/**/findAll/**
# 然后再放开特定的服务 同时也会排除findAll服务
zuul.routes.shop-product-provider.path=/bobo/

  

4.4 指定路由前缀

也就是给提交的请求添加一个前缀。

# http://127.0.0.1:9080/bobo/abc/product/findAll
zuul.prefix=/bobo
zuul.routes.shop-product-provider.path=/abc/**

  

   

5. 自定义网关过滤器

Zuul的核心是一系列的Filters，其作用可以类比Servlet框架的Filter。我们实际开发中会有很多的需求涉及到自定义的过滤器。所以我们来看看如何实现。

  

5.1 创建自定义过滤器

package com.bobo.zuul;

import com.netflix.zuul.ZuulFilter;
import com.netflix.zuul.context.RequestContext;
import com.netflix.zuul.exception.ZuulException;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;

/**
 * 自定义的网关过滤器
 */
@Component
public class LoggerFilter extends ZuulFilter {


    /**
     * 指定过滤器的类型
     *
     * @return
     */
    @Override
    public String filterType() {
        return "pre";
    }

    /**
     * 过滤器的执行顺序
     *    数值越小，优先级越高
     * @return
     */
    @Override
    public int filterOrder() {
        return 0;
    }

    /**
     * 是否开启过滤器 默认值 false
     * @return
     */
    @Override
    public boolean shouldFilter() {
        return true;
    }

    /**
     * 过滤器要执行的逻辑代码
     * @return
     * @throws ZuulException
     */
    @Override
    public Object run() throws ZuulException {
        // 获取Request上下文环境
        RequestContext currentContext = RequestContext.getCurrentContext();
        HttpServletRequest request = currentContext.getRequest();
        System.out.println("------自定义过滤器执行了-------> " + request.getRequestURL().toString());
        // 做一个身份认证
        String token = request.getParameter("token");
        if(token == null){
            // 没有传递身份认证信息  拦截请求
            // 表示 请求结束 不再继续向下请求
            currentContext.setSendZuulResponse(false);
            // 添加一个响应码
            currentContext.setResponseStatusCode(401);
            // 响应内容
            currentContext.setResponseBody("{"result":"token is null"}");
            // 响应类型
            currentContext.getResponse().setContentType("text/json;charset=utf-8");
        }
        return null;
    }
}

  

5.2 演示效果

启动一个provider服务后，启动我们的网关服务，然后查询访问，再查看控制台输出。

  

  

5.3 相关方法介绍

自定义过滤器中的相关方法介绍。

  

5.4 请求生命周期

  

5.5 案例分析

模拟一个身份认证的过滤器。

    /**
     * 过滤器要执行的逻辑代码
     * @return
     * @throws ZuulException
     */
    @Override
    public Object run() throws ZuulException {
        // 获取Request上下文环境
        RequestContext currentContext = RequestContext.getCurrentContext();
        HttpServletRequest request = currentContext.getRequest();
        System.out.println("------自定义过滤器执行了-------> " + request.getRequestURL().toString());
        // 做一个身份认证
        String token = request.getParameter("token");
        if(token == null){
            // 没有传递身份认证信息  拦截请求
            // 表示 请求结束 不再继续向下请求
            currentContext.setSendZuulResponse(false);
            // 添加一个响应码
            currentContext.setResponseStatusCode(401);
            // 响应内容
            currentContext.setResponseBody("{"result":"token is null"}");
            // 响应类型
            currentContext.getResponse().setContentType("text/json;charset=utf-8");
        }
        return null;
    }

  

效果

  

  

七、Config

1. 为什么需要使用配置中心

1.1 服务配置的现状

  

1.2 常用的配置管理解决方案的缺点

  

1.3 为什么要使用 spring cloud config 配置中心？

  

1.4 spring cloud config配置中心,它解决了什么问题？

  

2. ConfigServer

2.1 创建项目

我们先创建一个Config服务端程序。

  

添加相关的依赖

    <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>Hoxton.SR10</spring-cloud.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-config-server</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!-- 表示这是一个SpringCloud Eureka 的Client -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</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>

  

2.2 版本控制

配置服务端的配置文件我们需要通过Git来进行版本控制，我们可以通过Github或者码云来处理，本课程以码云为案例。

  

网站地址：https://gitee.com/ 注册一个账号

  

  

创建完成

  

2.3 修改属性文件

spring.application.name=config-server
server.port=9082

# 设置服务注册中心的地址
eureka.client.serviceurl.defaultZone=http://bobo:123456@192.168.100.120:8761/eureka/,http://bobo:1234
56@192.168.100.121:8761/eureka/

# Git配置
spring.cloud.config.server.git.uri=https://gitee.com/dengpbs/bobo-config
#spring.cloud.config.server.git.username=
#spring.cloud.config.server.git.password=

  

2.4 配置文件

我们在项目中分别创建4个配置文件，每个文件中都有一个shop-tag只是值不一致。

  

将创建的这四个配置文件上传到我们刚刚创建的仓库中。

  

  

上传成功后我们可以在ConfigServer中删除掉原来的那四个文件。

  

2.5 修改启动类

修改启动类并启动

package com.bobo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.config.server.EnableConfigServer;

@EnableConfigServer
@SpringBootApplication
public class SpringcloudConfigServerApplication {

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

}

  

访问测试

http://localhost:9082/config-client/test

  

http://localhost:9082/config-client/prod

  

http://localhost:9082/config-client/dev

  

http://localhost:9082/config-client/default

  

2.6 命名规则

通过访问我们可以发现，配置文件的名称不是随便定义的，而是有一定的命名规则在这里的。

  

3. ConfigClient

3.1 创建项目

  

添加相关依赖

    <properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>Hoxton.SR10</spring-cloud.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-config</artifactId>
        </dependency>
        <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-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </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>

  

3.2 修改配置文件

注意：在配置中心的客户端服务中，配置文件的名称必须是bootstrap.properties或者bootstrap.yml文件。

  

官方解释

Spring Cloud 构建于 Spring Boot 之上，在 Spring Boot 中有两种上下文，一种是 bootstrap，另外一种是 application, bootstrap 是应用程序的父上下文，也就是说 bootstrap 加载优先于applicaton。bootstrap 主要用于从额外的资源来加载配置信息，还可以在本地外部配置文件中解密属性。这两个上下文共用一个环境，它是任何Spring应用程序的外部属性的来源。bootstrap 里面的属性会优先加载，它们默认也不能被本地相同配置覆盖。

spring.application.name=config-client
server.port=9083

# 设置服务注册中心的地址
eureka.client.service-url.defaultZone=http://bobo:123456@192.168.100.120:8761/eureka/,http://bobo:123456@192.168.100.121:8761/eureka/

# 开启配置中心 默认是false
spring.cloud.config.discovery.enabled=true
# 对应的eureka中的配置中心 serviceId 默认是configserver
spring.cloud.config.discovery.service-id=config-server
# 指定环境
spring.cloud.config.profile=dev

# git 标签
spring.cloud.config.label=master

  

3.3 创建控制器

我们在控制器中获取配置中心中的信息。

@RestController
public class ShowController {
    @Value("${shop-tag}")
    private String msg;

    @RequestMapping("/show")
    public String showMsg(){
        return "-->" + msg;
    }
}

  

3.4 启动服务

启动服务访问测试。

  

4. 动态刷新

4.1 原理结构

  

4.2 动态刷新

通过上图我们能看到配置服务其实是从本地的Git仓库中获取的信息，Git本地库通过pull命令同步远程库中的内容。当配置中心客户端重新启动的时候会显示的执行pull命令来拉取最新的配置信息， 这种方式是需要重启客户端服务的，显然不是太友好，这时我们可以通过Actuator来实现。

  

添加依赖

  

修改属性文件

spring.application.name=config-client
server.port=9083

# 设置服务注册中心的地址
eureka.client.service-url.defaultZone=http://bobo:123456@192.168.100.120:8761/eureka/,http://bobo:123456@192.168.100.121:8761/eureka/

# 开启配置中心 默认是false
spring.cloud.config.discovery.enabled=true

# 对应的eureka中的配置中心 serviceId 默认是configserver
spring.cloud.config.discovery.service-id=config-server
# 指定环境
spring.cloud.config.profile=dev

# git 标签
spring.cloud.config.label=master

# SpringBoot 默认开启了权限拦截，会导致 /refresh 出现401拒绝访问
management.security.enabled=false

# 在Actuator中默认只放开了 info和health 如果要放开所有*
management.endpoints.web.exposure.include=*
# 放开shutdown 接口
management.endpoints.enabled-by-default=true

  

修改Bean对象作用域。

  

测试，因为refresh接口只支持post方式提交，我们通过postman来测试。

  

然后修改码云中的数据。

  

然后通过postman来发送post请求。

  

然后访问请求，发现数据更新了。

  

八、Bus

1.什么是消息总线bus

SpringCloud Bus集成了市面上常用的消息中间件(rabbit mq,kafka等)，连接微服务系统中的所有的节点，当有数据变更的时候，可以通过消息代理广播通知微服务及时变更数据，例如微服务的配置更新。

  

2.bus解决了什么问题?

解决了微服务数据变更，及时同步的问题。

   

刷新客户端服务。

  

刷新服务端服务。

  

3. 启动RabbitMQ

开启消息中间件服务。

  

4. 客户端刷新

4.1 创建客户端

我们需要创建两个客户端，添加依赖环境。

<!-- 添加Bus的依赖 -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-bus-amqp</artifactId>
</dependency>

  

4.2 属性文件

我们需要在属性文件中添加 RabbitMQ的相关信息。

spring.application.name=config-client
server.port=9083

# 设置服务注册中心的地址
eureka.client.service-url.defaultZone=http://bobo:123456@192.168.100.120:8761/eureka/,http://bobo:123456@192.168.100.121:8761/eureka/

# 开启配置中心 默认是false
spring.cloud.config.discovery.enabled=true
# 对应的eureka中的配置中心 serviceId 默认是configserver
spring.cloud.config.discovery.service-id=config-server
# 指定环境
spring.cloud.config.profile=dev

# git 标签
spring.cloud.config.label=master

# SpringBoot 默认开启了权限拦截，会导致 /refresh 出现401拒绝访问
management.security.enabled=false

# 在Actuator中默认只放开了 info和health 如果要放开所有*
management.endpoints.web.exposure.include=*
# 放开shutdown 接口
management.endpoints.enabled-by-default=true

# 添加RabbitMQ的配置信息
spring.rabbitmq.host=192.168.100.120
spring.rabbitmq.port=5672
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest
spring.rabbitmq.virtual-host=/

  

4.3 再创建一个客户端

我们可以复制前面创建好的客户端，修改下端口即可。

  

4.4 测试

分别启动两个客户端服务。

  

  

更新Git远程服务中的数据，然后在刷新。

  

更新后。

  

然后通过PostMan来刷新。

  

  

  

那么在这我们就看到了我们期望的效果，刷新一个客户端，其他的客户端也同步获取到了最新的数据。

  

5. 服务端刷新

其实相关的案例我们已经有了，只需要在之前的ConfigServer中配置RabbitMQ的相关信息即可。

<!-- 添加actuactor依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-bus-amqp</artifactId>
</dependency>

  

然后添加相关的配置信息。

# SpringBoot 默认开启了权限拦截，会导致 /refresh 出现401拒绝访问
management.security.enabled=false

# 在Actuator中默认只放开了 info和health 如果要放开所有*
management.endpoints.web.exposure.include=*
# 放开shutdown 接口
management.endpoints.enabled-by-default=true

# 添加RabbitMQ的配置信息
spring.rabbitmq.host=192.168.100.120
spring.rabbitmq.port=5672
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest
spring.rabbitmq.virtual-host=/

  

我们就可以按照客户端刷新的步骤来测试了。

  

6. 局部刷新

如果配置文件更新后，只是需要作用于部分的服务，而不需要所有的服务都刷新。

  

6.1 刷新指定服务

http://config-server/actuator/bus-refresh?destination=需要刷新的服务名称:端口号

  

6.2 刷新指定集群服务

http://config-server/actuator/bus-refresh?destination=需要刷新的服务名称:**

  

九、Stream

在实际开发过程中，服务与服务之间通信经常会使用到消息中间件，而以往使用了哪个中间件比如RabbitMQ，那么该中间件和系统的耦合性就会非常高，如果我们要替换为Kafka那么变动会比较大，这时我们可以使用SpringCloudStream来整合我们的消息中间件，来降低系统和中间件的耦合性。

  

1.什么是SpringCloudStream

官方定义 Spring Cloud Stream 是一个构建消息驱动微服务的框架。

应用程序通过 inputs 或者 outputs 来与 Spring Cloud Stream 中binder 交互，通过我们配置来binding ，而 Spring Cloud Stream 的 binder 负责与消息中间件交互。所以，我们只需要搞清楚如何与Spring Cloud Stream 交互就可以方便使用消息驱动的方式。

通过使用Spring Integration来连接消息代理中间件以实现消息事件驱动。Spring Cloud Stream 为一些供应商的消息中间件产品提供了个性化的自动化配置实现，引用了发布-订阅、消费组、分区的三个核心概念。目前仅支持RabbitMQ、Kafka。

  

2.Stream 解决了什么问题?

Stream解决了开发人员无感知的使用消息中间件的问题，因为Stream对消息中间件的进一步封装，可以做到代码层面对中间件的无感知，甚至于动态的切换中间件(rabbitmq切换为kafka)，使得微服务开发的高度解耦，服务可以关注更多自己的业务流程。

  

官网结构图