SpringCloud

SpringCloud引言

单体all in on --> 微服务模块化(代码没变化~)

Spring(IOC AOP) -- 简化开发
SpringBoot -- 自动装配（专注于快速、方便开发单个微服务）
SpringCloud -- 解耦合（关注全局的微服务协调治理框架，他将单体微服务整合并管理）

微服务：单体(单一)应用-->模块化拆分若干服务,每个服务围绕具体业务构建,服务之间相互协调,互相配置,独立部署
核心就是将传统的一站式应用，根据业务拆分一个个服务(独立处理,独立数据库)，彻底解耦合

Spring Cloud Netflix 组件（五大神兽）

通用使用步骤：

1.导入依赖
2.编写配置文件 yml|properties
3.开启功能
4.编写配置类

一、Eureka 服务注册与发现

1、Eureka（服务注册中心）

基于Rest服务，用于定位服务

（1）Eureka自我保护机制--不推荐关闭自我保护机制

微服务不能用，eureka不会立即清理，依旧会保存该微服务的信息
默认90内未接收到微服务实例的心跳

（2）设计理念

宁可保留错误的服务注册信息，也不盲目注销任何可能健康的服务实例

（3）对比zookeeper

分布式数据库:Consistency(一致性)、Availability(可用性)、Partition Tolerance(分区容错性)，三者不能同时成立

Zookeeper：C一致性+P容错性；Eureka：A可用性+P容错性

Eureka可以很好的应对因网络故障导致部分节点失去联系的情况，而不会像zookeeper那样使整个注册服务瘫痪

（4）代码实战

（1）配置服务注册中心 ---->> Eureka Server

a 导入依赖

<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-eureka-server</artifactId>
   <version>1.4.6.RELEASE</version>
</dependency>

b 配置yaml

server:
  port: 7001
      
#Eureka 配置
eureka:
  instance:
    hostname: eureka7001.com #Eureka服务端实例名称
  client:
    register-with-eureka: false #表示自己就是注册中心，不用注册自己
    fetch-registry: false      #表示自己就是注册中心，不用去注册中心获取其他服务的地址
    service-url:
      #单机配置
#      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
      #集群配置,除当前注册中心外，配置其他注册中心，共同组建集群！
      defaultZone: http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
#  server:
#    enable-self-preservation: false #禁用自我保护机制[不推荐]

开启服务（主启动类）

@EnableEurekaServer //服务端启动类，可以接受别人注册

（二）服务注册 ---->> Server Provider

新建module [springcloud-api] 准备实体类 Dept

查看代码

@Data
@NoArgsConstructor
@Accessors(chain = true) //链式写法
public class Dept implements Serializable {// dept 实体类 orm 类表关系映射

    private Long deptno;
    private String dname;

    //这个数据库存在哪个数据库的字段~，微服务，一个服务对应一个微服务，同一信息可能存在不同的数据库
    private String db_source;

    public Dept(String dname) {
        this.dname = dname;
    }

    /*
        链式写法：
            Depte dept = new Dept();
            dept.setDeptNo(11);
            dept.set..;
          new Dept().setDeptNo(11).setDname('333').setDb_source('001');
     */
}

新建服务module [springcloud-provider-dept-8001]

a 导入pom依赖

查看代码

<!--我们需要拿到实体类，所以要配置api module-->
        <dependency>
            <groupId>com.nercita</groupId>
            <artifactId>springcloud-api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

        <!--Eureka 客户端配置-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</artifactId>
            <version>1.4.6.RELEASE</version>
        </dependency>

        <!--actuator 完善监控信息-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
        </dependency>
        <!--日志测试~-->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-core</artifactId>
        </dependency>
        <!--SpringBoot 启动器-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>
        <!--test-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-test</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--jetty-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jetty</artifactId>
        </dependency>
        <!--热部署工具-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-alibaba-dependencies</artifactId>
            <version>0.2.0.RELEASE</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <!--springCloud的依赖-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>Greenwich.SR1</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <!--SpringBoot-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>2.2.5.RELEASE</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
        <!--数据库-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>

        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>${log4j.version}</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>${lombok.version}</version>
        </dependency>

b 编写yaml配置

查看代码

server:
  port: 8001
  
#mybatis配置
mybatis:
  type-aliases-package: com.nercita.springcloud.pojo
  config-location: classpath:mybatis/mybatis-config.xml
  mapper-locations: classpath:mybatis/mapper/*.xml

#spring配置
spring:
  application:
    name: springcloud-provider-dept #三个服务名称一致，实例不同
  datasource:
      type: com.alibaba.druid.pool.DruidDataSource
      driver-class-name: org.gjt.mm.mysql.Driver
      url: jdbc:mysql://localhost:3306/bcp?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8
      username: root
      password: root

#Eureka配置 ：服务注册到哪里
eureka:
  client:
    service-url:
      #注册到单机服务器
#      defaultZone: http://localhost:7001/eureka/
      #注册到集群服务器，将服务注册到这里
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
  instance:
    instance-id: springcloud-provider-dept8001
#配置info 可以看到微服务备注 -- json字符串响应
info:
    app.name: nercita-springcloud
    company.name: nercita.com

c 完善服务请求接口和对应mybatis接口以及对应的 Mapper.xml 文件配置

查看代码

//提供Restful服务
@RestController
public class DeptController {

    @Autowired
    private DeptService deptService;

    @Autowired
    private DiscoveryClient client;

    //只允许post方式提交，默认浏览器请求属于get请求
    @PostMapping("/deptAdd")
    public boolean addDept(Dept dept){
        return deptService.addDept(dept);
    }

    @GetMapping("/deptGetById/{id}")
    public Dept queryById(@PathVariable("id") Long id){
        Dept dept = deptService.queryDeptById(id);
        if(dept == null){
            throw new RuntimeException("id=>"+id+",不存在该用户或信息无法找到");
        }
        return dept;
    }

    @GetMapping("/deptGetAll")
    public List<Dept> queryAll(){
        return deptService.queryAll();
    }

    //注册进来的微服务，获取一些消息 -- 联合开发
    @GetMapping("/deptDiscovery")
    public Object discovery(){
        List<String> services = client.getServices();
        System.out.println("discover=>service:"+services);

        //得到具体一个微服务信息 -- applicationName
        List<ServiceInstance> instances = client.getInstances("springcloud-provider-dept");
        for (ServiceInstance instance : instances) {
            System.out.println(
                instance.getHost()+"\t"+  //springcloud-provider-dept8001
                instance.getInstanceId()+"\t"+ //springcloud-provider-dept8001
                instance.getUri()+"\t"+ //http://windows10.microdone.cn:8001
                instance.getServiceId() //SPRINGCLOUD-PROVIDER-DEPT
            );
        }
        return this.client;
    }
}

（三）服务消费 ---->> Service Consumer

新建module [springcloud-consumer-dept-80]

a 导入依赖

<!--消费者不需要连接数据库，需要实体类+web-->
    <dependencies>
        <dependency>
            <groupId>com.nercita</groupId>
            <artifactId>springcloud-api</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>

        <!--1.导入ribbon依赖-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-ribbon</artifactId>
            <version>1.4.6.RELEASE</version>
        </dependency>

        <!--1.导入Eureka依赖 客户端配置-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</artifactId>
            <version>1.4.6.RELEASE</version>
        </dependency>

    </dependencies>

b 编写yaml配置

server:
  port: 80

#Eureka配置
eureka:
  client:
    #不向eureka中注册自己
    register-with-eureka: false
    service-url:
      #集群注册服务，从这里取服务
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/

c 开启功能（主启动类）

@EnableEurekaClient //3.开启服务

d 编写请求Controller（通过ip:port请求注册中心的服务）

查看代码

//消费者不应该有service
@Controller
public class DeptConsumerController {

    /*
        springboot支持：restful -- RestTemplate ..供我们直接调用就可以了!注册到Spring中
          三个参数：  url,实体 map,responseType

        restTemplate ：提供多种便捷访问远程http服务的方法，简单的RestFul服务模板(spring提供)
     */
    @Autowired
    private RestTemplate restTemplate;

    /*
        注意：使用ribbon负载均衡是，访问的ip地址应该是一个变量，通过服务名来访问serviceId
     */
    private static final String REST_URL_PREFIX="http://localhost:8001";
//    private static final String REST_URL_PREFIX="http://SPRINGCLOUD-PROVIDER-DEPT";

    @RequestMapping("/consumergetDeptById/{id}")
    @ResponseBody
    public Dept getDept(@PathVariable("id") Long id){
        return restTemplate.getForObject(REST_URL_PREFIX+"/deptGetById/"+id,Dept.class);
    }

    @RequestMapping("/consumergetAllDept")
    @ResponseBody
    public List<Dept> getAllDept(){
        return restTemplate.getForObject(REST_URL_PREFIX+"/deptGetAll",List.class);
    }

    @RequestMapping("/consumerAddDept")
    @ResponseBody
    public boolean addDept(Dept dept){
        return restTemplate.postForObject(REST_URL_PREFIX+"/deptAdd",dept,Boolean.class);
    }

}

二、Ribbon|Feign 负载均衡（基于客户端配置）

目的：将用户请求平摊分配多个服务上，达到系统的高可用

1、请求url

ribbon负载均衡：访问的ip地址应该是一个变量，通过服务名来访问serviceId 【服务名代替ip+端口号】

客户端可以直接调用，不用关心ip地址和端口号:即localhost:80/consumergetDeptById/1

即yml配置文件：

spring:
  application:
    name: springcloud-provider-dept #三个服务名称一致，实例不同

代码配置： private static final String REST_URL_PREFIX="http://SPRINGCLOUD-PROVIDER-DEPT"

客户端可以直接调用，不用关心ip地址和端口号

2、负载均衡策略

（1）调用负载均衡策略

IRule
AbstractLoadBalancerRule
RetryRule 重试
RandomRule 随机
RoundRobinRule 轮询 (默认)
WeightedResponseTimeRule 权重
ClientConfigEnabledRoundRobinRule
PredicateBasedRule
AvailabilityFilteringRule 过滤掉故障的服务，对剩下的进行轮询

（2）自定义负载均衡策略

自定义规则


@Configuration
public class MyRule extends AbstractLoadBalancerRule {

    private int total=0;//被调用次数
    private int currentIndex=0;//当前服务位置

    public MyRule() {
    }

    /*
        每个服务访问5次换下一个服务
        默认total=0,total=5指向下一个服务节点
        默认index=0,total=5 index++;
     */
//    @SuppressWarnings({"RCN_REDUNDANT_NULLCHECK_OF_NULL_VALUE"})
    public Server choose(ILoadBalancer lb, Object key) {
        if (lb == null) {
            return null;
        } else {
            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) {
                    return null;
                }

                //算法
//                int index = this.chooseRandomInt(serverCount);//生成区间随机数
//                server = (Server)upList.get(index);//从或者的服务中随机获取一个

                //自定义算法
                if(total<5){
                    server = (Server)upList.get(currentIndex);//从或者的服务中随机获取一个
                    total++;
                }else{
                    total=0;
                    currentIndex++;
                    if(currentIndex>=upList.size()){
                        currentIndex=0;
                    }
                    server = upList.get(currentIndex);
                }

                if (server == null) {
                    Thread.yield();//线程礼让
                } else {
                    if (server.isAlive()) {
                        return server;
                    }

                    server = null;
                    Thread.yield();//线程礼让
                }
            }

            return server;
        }
    }

    protected int chooseRandomInt(int serverCount) {
        return ThreadLocalRandom.current().nextInt(serverCount);
    }

    public Server choose(Object key) {
        return this.choose(this.getLoadBalancer(), key);
    }

    public void initWithNiwsConfig(IClientConfig clientConfig) {
    }
}

a 依赖导入

         <!--1.导入ribbon依赖-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-ribbon</artifactId>
            <version>1.4.6.RELEASE</version>
        </dependency>

b JavaConfig 注册bean

实现方式一

@Configuration // @Configuration -- spring applicationContext.xml
public class ConfigBean {

    /*
    IRule
    AbstractLoadBalancerRule
        RetryRule 重试
        RandomRule 随机
        RoundRobinRule 轮询 (默认)
            WeightedResponseTimeRule 权重
        ClientConfigEnabledRoundRobinRule
            PredicateBasedRule
                AvailabilityFilteringRule 过滤掉故障的服务，对剩下的进行轮询
     */
    @Bean
    //配置负载均衡 实现RestTemplate
    @LoadBalanced //Ribbon
    //springboot支持：restful -- RestTemplate ..供我们直接调用就可以了!注册到Spring中
    public RestTemplate getRestTemplate(){
        return new RestTemplate();
    }

    //切换负载均衡策略，这个与自定义的配置文件MyRuleConfig只能开启一个
    @Bean
    public IRule RandomRule(){ //名字可以自定义
        return new MyRule();//自定义实现，或者换成其他自带负载均衡策略
    }

}

b2 开启服务来注册bean

主启动类：

@RibbonClient(name="SPRINGCLOUD-PROVIDER-DEPT",configuration = MyRuleConfig.class)

javaConfig注册bean：

@Configuration
public class MyRuleConfig {

    @Bean
    public IRule myRule(){
        return new MyRule();
    }

}

3、区别对比Nginx

（1）Nginx是常见负载均衡软件；Ribbon是客户端负载均衡工具

（2）Nginx是集中式负载均衡LB；Ribbon是进程式负载均衡LB，负载均衡逻辑集成到消费方，消费方从服务注册中心获知哪些地址可用，从中选取负载均衡合适服务器

4、区别对比Feign

Feign 是在 Ribbon 的基础上进行了一次改进，是一个使用起来更加方便的 HTTP 客户端。采用接口的方式，只需要创建一个接口，然后在上面添加注解即可，将需要调用的其他服务的方法定义成抽象方法即可，不需要自己构建 http 请求。然后就像是调用自身工程的方法调用，而感觉不到是调用远程方法，使得编写客户端变得非常容易。

Ribbon 是一个基于 HTTP 和 TCP 客户端的负载均衡的工具。它可以在客户端配置 RibbonServerList（服务端列表），使用 HttpClient 或 RestTemplate 模拟 http 请求，

（1）启动类使用的注解不同，Ribbon 用的是@RibbonClient，Feign 用的是@EnableFeignClients。
（2）服务的指定位置不同，Ribbon 是在@RibbonClient 注解上声明规则类，Feign 则是在定义抽象方法的接口中使用@FeignClient 声明。

#主启动类上添加注解
@RibbonClient(name="SPRINGCLOUD-PROVIDER-DEPT",configuration = MyRuleConfig.class)

#业务层接口上添加注解
@FeignClient(value = "SPRINGCLOUD-PROVIDER-DEPT",fallbackFactory = DeptClientServiceFallbackFactory.class)

（3）调用方式不同，Ribbon 需要自己构建 http 请求，模拟 http 请求然后使用 RestTemplate 发送给其他服务，步骤相当繁琐。Feign把RestTemplate封装起来，加了一层效率变低，可读性提高。

5、Feign代码

（1）导入依赖

<!--1.导入feign依赖-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-feign</artifactId>
    <version>1.4.6.RELEASE</version>
</dependency>

（2）配置yml

server:
  port: 80


#Eureka配置
eureka:
  client:
    #不向eureka中注册自己
    register-with-eureka: false
    service-url:
      #集群注册服务
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
#开启服务降级feign.hystrix
feign:
  hystrix:
    enabled: true

（3）开启服务（主启动类）

@EnableFeignClients(basePackages = {"com.nercita.springcloud"})

（4）配置业务接口

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

    @PostMapping("/deptAdd")
    public boolean addDept(Dept dept);

    @GetMapping("/deptGetById/{id}")
    public Dept queryDeptById(@PathVariable("id") Long id);

    @GetMapping("/deptGetAll")
    public List<Dept> queryAll();

}

（5）controller请求并调用service方法

三、Hystrix 熔断、降级、流监控

1、分布式系统面临的问题（1）及解决方案（2）（3）

服务熔断和服务降级就可以视为解决服务雪崩的手段之一

（1）服务雪崩

原因：多个微服务之间调用的时候，假设A调用B和C，BC调用其他(这一条调用链叫扇出)。如果扇出链路行某个微服务调用响应时间过长或不可用，为微服务A的调用就会扎不会有越来越多的系统资源，引起系统崩溃。

解决方案：限流，限制并发的请求访问量，超过阈值则拒绝或等待；

（2）服务熔断 Hystrix（回调方法）

服务端操作：对应雪崩效应的一种微服务链路保护机制（相当于捕获异常）

熔断目的：依赖的下游服务故障触发熔断，避免引发本系统崩溃；系统自动执行和恢复

a 导入依赖

<!--hystrix-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-hystrix</artifactId>
    <version>1.4.6.RELEASE</version>
</dependency>

b 开启熔断服务 （主启动类）

@EnableCircuitBreaker //3.开启对熔断的支持

c 请求添加回调方法

@HystrixCommand(fallbackMethod = "hystrixQueryById") //失败后常识调用

//提供Restful服务
@RestController
public class DeptController {

    @Autowired
    private DeptService deptService;

    @HystrixCommand(fallbackMethod = "hystrixQueryById") //失败后常识调用
    @GetMapping("/deptGetById/{id}")
    public Dept queryById(@PathVariable("id") Long id){
        Dept dept = deptService.queryDeptById(id);
        if(dept == null){
            throw new RuntimeException("id=>"+id+",不存在该用户或信息无法找到");
        }
        return dept;
    }

    //备选方法
    public Dept hystrixQueryById(@PathVariable("id") Long id){
        return new Dept()
                .setDeptno(id)
                .setDname("id=>"+id+"没有对应的信息，null--@Hystrix")
                .setDb_source("no this database in mysql");
    }


}

//滑动窗口的大小，默认为20
circuitBreaker.requestVolumeThreshold 
//过多长时间，熔断器再次检测是否开启，默认为5000，即5s钟
circuitBreaker.sleepWindowInMilliseconds 
//错误率，默认50%
circuitBreaker.errorThresholdPercentage

5s内，每当20个请求中，有50%失败时，熔断器就会打开，此时再调用此服务，将会直接返回失败，不再调远程服务。直到5s之后，重新检测该触发条件，判断是否把熔断器关闭，或者继续打开。

这些属于框架层级的实现，我们只要实现对应接口就好！

（3）服务降级（回调类）

客户端操作：从整体网站请求负载考虑，当某个服务熔断或关闭之后，服务将不再被调用。客户端可以准备一个自己的失败回调函数FallbackFactory，返回一个默认的缺省值。（相当于404时，返回一个自定义页面）

降级目的：服务分优先级，牺牲非核心服务（不可用），保证核心服务稳定；从整体负荷考虑；

#开启服务降级feign.hystrix
feign:
 hystrix:
  enabled: true

@FeignClient(value = "SPRINGCLOUD-PROVIDER-DEPT",fallbackFactory = DeptClientServiceFallbackFactory.class)

注意事项：

1、回调函数要继承FallbackFactory类，可以来自于其他组件

2、接口要保持一致

@Component
@FeignClient(value = "SPRINGCLOUD-PROVIDER-DEPT",fallbackFactory = DeptClientServiceFallbackFactory.class)

定义与其他组件的接口

/*
    这里要与consumer-dept-feign接口保持一致
 */
@Component
@FeignClient(value = "SPRINGCLOUD-PROVIDER-DEPT",fallbackFactory = DeptClientServiceFallbackFactory.class)
public interface DeptClientService {

    @PostMapping("/deptAdd")
    public boolean addDept(Dept dept);

    @GetMapping("/deptGetById/{id}")
    public Dept queryDeptById(@PathVariable("id") Long id);

    @GetMapping("/deptGetAll")
    public List<Dept> queryAll();

}

@Component
@FeignClient(value = "SPRINGCLOUD-PROVIDER-DEPT",fallbackFactory = DeptClientServiceFallbackFactory.class)

客户端的接口

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

    @PostMapping("/deptAdd")
    public boolean addDept(Dept dept);

    @GetMapping("/deptGetById/{id}")
    public Dept queryDeptById(@PathVariable("id") Long id);

    @GetMapping("/deptGetAll")
    public List<Dept> queryAll();

}

@Component

定义在其他组件的回调函数方法

@Component
public class DeptClientServiceFallbackFactory implements FallbackFactory {
    @Override
    public DeptClientService create(Throwable throwable) {
        return new DeptClientService(){

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

            @Override
            public Dept queryDeptById(Long id) {
                return new Dept().setDeptno(id)
                        .setDname("id=>>"+id+",没有对应信息,客户端提供降级的信息，这个服务已经关闭")
                        .setDb_source("没有数据");
            }

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

总结：

a 熔断必会触发降级，所以熔断也是降级一种。区别在于熔断是对调用链路的保护，而降级是对系统过载的一种保护处理。

2、流监控 hystrix.dashboard

（1）新建module[springcloud-consumer-dashboard]

（2）导入pom依赖

查看代码

<!--消费者不需要连接数据库，需要实体类+web-->
<dependencies>
    <!--hystrix-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-hystrix</artifactId>
        <version>1.4.6.RELEASE</version>
    </dependency>
    <!--hystrix.dashboard-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-hystrix-dashboard</artifactId>
        <version>1.4.6.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>com.nercita</groupId>
        <artifactId>springcloud-api</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
    </dependency>

    <!--1.导入ribbon依赖-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-ribbon</artifactId>
        <version>1.4.6.RELEASE</version>
    </dependency>

    <!--1.导入Eureka依赖 客户端配置-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-eureka</artifactId>
        <version>1.4.6.RELEASE</version>
    </dependency>

</dependencies>

服务端项目配置pom依赖

<!--actuator 完善监控信息-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

（3）配置yml端口号

server:
  port: 9001

（4）开启服务（主启动类）

@EnableHystrixDashboard //3.开启服务

服务端项目主启动类配置，注册ServletRegistrationBean对象

@SpringBootApplication
@EnableEurekaClient //3.开启功能：启动Eureka客户端服务
@EnableDiscoveryClient //3.开启服务发现
@EnableCircuitBreaker //3.开启对熔断的支持
public class DeptProvider_hystrix_8001 {

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

    //增加一个servlet
    @Bean
    public ServletRegistrationBean hystrixMetricsStreamServlet(){
        ServletRegistrationBean registrationBean = new ServletRegistrationBean(new HystrixMetricsStreamServlet());
        registrationBean.addUrlMappings("/actuator/hystrix.stream");
        return registrationBean;
    }
}

（5）访问：localhost:9001/hystrix

四、Zuul 路由网关 9527

，

1、什么是Zuul？

目的：隐藏真实地址

（1）提供代理、路由、过滤三大功能

路由：负责将外部请求转发到uti的微服务实例上，是实现外部访问统一入口的基础。

过滤：负责对请求的处理过程进行干预，是实现请求校验，服务聚合等功能的基础。

（2）从注册中发现服务
Zuul和Eureka整合后，自身也注册为Eureka服务治理下的应用，同时从Eureka中获取其他微服务的消息。

即：微服务的访问都是通过Zuul跳转后获得。

2、代码实现

（1）导入pom依赖

<!--zuul-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-zuul</artifactId>
    <version>1.4.6.RELEASE</version>
</dependency>

（2）配置yml文件

spring:
  application:
    name: springcloud-zuul
zuul:
  routes:
    mydept.serviceId: springcloud-provider-dept
    mydept.path: /mydept/** #未实现
#  ignored-services: springcloud-provider-dept #不能访问的路径
#  prefix: /sc #配置统一前置

（3）开启服务（主启动类）

@EnableZuulProxy

五、Config 分布式配置

1、git基础使用

（1）下载、使用

个人git主页：gitee.com
下载：git bash here
快捷键：

ctrl+ins 复制
shift+ins 粘贴

（2）配置权限

生成秘钥：ssh-keygen -t rsa -C "1289775791@qq.com"
复制：用户/administrator/.ssh/id_rsa.pub,复制到git公钥

（3）提交上传

常用的提交命令：
git add . 把当前修改的全部提交到暂存区
git status
git commit -m "first commit" #提交本地
git push origin master #需配置个人公钥，提交git

2、代码项目配置

（1）新建Module【springcloud-config-server3344、springcloud-config-client3355、springcloud-config-eureka7001】

（2）分别导入pom依赖

springcloud-config-server3344

    <dependencies>
        <!--springcloud-config-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-config-server</artifactId>
            <version>2.1.1.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--actuator 完善监控信息-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
    </dependencies>

springcloud-config-client3355

<dependencies>
    <!--springcloud-config-client  starter-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-config</artifactId>
        <version>2.1.1.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!--actuator 完善监控信息-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
</dependencies>

springcloud-config-eureka7001

<dependencies>
    <!--springcloud-config-client  starter-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-config</artifactId>
        <version>2.1.1.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-eureka-server</artifactId>
        <version>1.4.6.RELEASE</version>
    </dependency>

    <!--热部署工具-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
    </dependency>
</dependencies>

（3）分别配置yml

springcloud-config-server3344

server:
  port: 3344
spring:
  application:
    name: springcloud-config-server
  #连接远程仓库
  cloud:
    config:
      server:
        git:
          uri: https://gitee.com/zzldbl/springcloud-config.git #是http不是git

springcloud-config-client3355

#用户级别的配置 -->配置名字
spring:
  application:
    name: springcloud-config-client-3355

bootstarp

#系统级别的配置 -->配置读谁
spring:
  cloud:
    config:
      uri: http://localhost:3344
      name: config-client #需要从git上读取的资源名称，不需要后缀
      profile: test
      label: master

springcloud-config-eureka7001

#用户级别的配置 -->配置名字
spring:
  application:
    name: springcloud-config-eureka-7001

bootstarp

#系统级别的配置 -->配置读谁
spring:
  cloud:
    config:
      name: config-eureka #需要从git上读取的资源名称，不需要后缀
      uri: http://localhost:3344 #指向服务器
      profile: dev #环境
      label: master

(4)开启eureka和service服务，并启动客户端（均为主启动类）

springcloud-config-server3344

@EnableConfigServer

springcloud-config-client3355

springcloud-config-eureka7001

@EnableEurekaServer //服务端启动类，可以接受别人注册

（5）获取git上配置文件的内容并输出

@RestController
public class ConfigClientController {

    /*
        客户端通过服务器获取git服务器的 config-client.yml 配置
        客户端可以选择环境 bootstrap.yml --> profiles:dev/test
     */
    @Value("${spring.application.name}")
    private String applicationName;
    @Value("${eureka.client.service-url.defaultZone}")
    private String eurekaService;
    @Value("${server.port}")
    private String port;


    @RequestMapping("/config")
    public String getConfig(){
        String str = "applicationName:"+applicationName+",eurekaServer:"+eurekaService+",port:"+port;
        return str;
    }
}

posted @ 2022-04-22 18:36 小吴dnd 阅读(59) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

xwdnd

SpringCloud

SpringCloud引言

Spring Cloud Netflix 组件（五大神兽）

一、Eureka 服务注册与发现

1、Eureka（服务注册中心）

（1）Eureka自我保护机制--不推荐关闭自我保护机制

（2）设计理念

（3）对比zookeeper

（4）代码实战

（1）配置服务注册中心 ---->> Eureka Server

（二）服务注册 ---->> Server Provider

（三）服务消费 ---->> Service Consumer

二、Ribbon|Feign 负载均衡 （基于客户端配置）

1、请求url

2、负载均衡策略

（2）自定义负载均衡策略

3、区别对比Nginx

4、区别对比Feign

5、Feign代码

（1）导入依赖

（2）配置yml

（3）开启服务（主启动类）

（4）配置业务接口

（5）controller请求并调用service方法

三、Hystrix 熔断、降级、流监控

1、分布式系统面临的问题（1）及解决方案（2）（3）

（1）服务雪崩

（2）服务熔断 Hystrix（回调方法）

（3）服务降级（回调类）

2、流监控 hystrix.dashboard

四、Zuul 路由网关 9527

1、什么是Zuul？

2、代码实现

（1）导入pom依赖

（2）配置yml文件

（3）开启服务（主启动类）

五、Config 分布式配置

1、git基础使用

（1）下载、使用

（2）配置权限

（3）提交上传

2、代码项目配置

（1）新建Module【springcloud-config-server3344、springcloud-config-client3355、springcloud-config-eureka7001】

（2）分别导入pom依赖

（3）分别配置yml

(4)开启eureka和service服务，并启动客户端（均为主启动类）

（5）获取git上配置文件的内容并输出

公告

二、Ribbon|Feign 负载均衡（基于客户端配置）