程序员Darker
程序员Darker

SpringCloud-day2

此篇笔记在上一篇笔记SpringCloud-day1的基础上接着写的

  • 1. Eureka集群
    • 1.1 实现方法说明
    • 1.2 实现集群
      • 1.2.1 拷贝一份eureka服务端的代码
      • 1.2.2 搭建集群
      • 1.2.3 服务提供者和服务消费者配置文件修改
  • 2. 服务负载均衡
    • 2.1 为什么需要负载均衡？
    • 2.2 实现负载均衡思路
    • 2.3 服务提供者集群
      • 2.3.1 步骤分析
      • 2.3.2 实现
    • 2.4 消费者负载均衡技术实现
      • 2.4.1 常见的负载均衡技术
      • 2.4.2 Ribbon
        • 2.4.2.1简介
        • 2.4.2.2 负载均衡之Ribbon实现分析
        • 2.4.2.3 Ribbon实现
      • 2.4.3 负载均衡策略
      • 2.4.4 Feign
        • 2.4.4.1 简介
        • 2.4.4.2 负载均衡之Feign实现分析
        • 2.4.4.3 Feign实现分析实现
  • 3. Hystrix断路器
    • 3.1 为什么需要Hystrix断路器
    • 3.2 Hystrix简介
      • 3.2.1 原理分析
      • 3.2.2 资源隔离&限流
      • 3.2.3 服务熔断
      • 3.2.4 服务降级
    • 3.3 Hystrix实现(服务提供者实现)
      • 3.3.1 Hystrix实现步骤分析
      • 3.3.2 Hystrix实现
    • 3.4 Feign实现（feign服务消费者实现）
      • 3.4.1 使用原因
      • 3.4.2 Feign实现步骤分析
      • 3.4.3 Feign实现
  • 4. Zuul路由网关
    • 4.1 简介
    • 4.2 基本配置
      • 4.2.1 创建模块zuul_gatewar_1299
      • 4.2.2 导入pom.xml
      • 4.2.3 配置application.yml
      • 4.2.4 入口类注解@EnableZuulProxy //开启网关支持
      • 4.2.5 启动测试
      • 4.3 路由访问映射规则
    • 4.4 过滤器
      • 4.4.1 ZuulFilter
      • 4.4.2 过滤器执行周期
      • 4.4.3 使用场景
      • 4.4.4 自定义过滤器（继承ZuulFilter）
    • 4.5 负载均衡与熔断

1. Eureka集群

1.1 实现方法说明

在生产环境中，直接部署到多个服务器

但是我现在是开发阶段，就通过不同的端口号来代替服务器！

服务器之间配置一下其他服务器，实现互相复制内容相同！服务提供者和服务消费者都注册到多个集群环境的eureka环境中！

1.2 实现集群

1.2.1 拷贝一份eureka服务端的代码

拷贝一份eureka_server_7001的代码并更改名字为eureka_server_7002

1.2.2 搭建集群

  1. 主类改名字

    为了区分主类，规范命名而已！

  2. 设置映射hosts

    hosts文件路径：C:\Windows\System32\drivers\etc\hosts

    127.0.0.1 eureka-7001.com
    127.0.0.1 eureka-7002.com

  3. 修改配置文件application.yml

两个eureka的服务端配置基本相同：

  • 开发环境中就是端口不同，在配置文件中配置另一方的地址（我这里就是开发环境）
  • 生产环境中只需要在一方配置另一方的地址

服务器7001的配置

server:
  port: 7001
eureka:
  instance:
    hostname: eureka-7001.com
  client:
    registerWithEureka: false #是否要注册到eureka 自己本身就是eureka，无需注册
    fetchRegistry: false #表示是否从Eureka Server获取注册信息，自己是eureka服务端，无需获取注册信息
    serviceUrl:
#      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka #单机配置 效果同 http://localhost:7001/eureka
      defaultZone: http://eureka-7002.com:7002/eureka/ # 配置集群的另一个服务器的地址，目的是互相复制，保持内容相同

服务器7002的配置

server:
  port: 7002 # 使用的端口号
eureka:
  instance:
    hostname: eureka-7001.com
  client:
    registerWithEureka: false #是否要注册到eureka 自己本身就是eureka，无需注册
    fetchRegistry: false #表示是否从Eureka Server获取注册信息，自己是eureka服务端，无需获取注册信息
    serviceUrl:
      defaultZone: http://eureka-7001.com:7001/eureka/ # 配置集群的另一个服务器的地址，目的是互相复制，保持内容相同

  1. 启动并测试

    测试方法：启动两个eureka的服务端，浏览器地址栏访问地址：http://eureka-7001.com:7001/

    测试结果：我访问的是7001，但是在网页上的DS Replicas这个位置下面看到了eureka-7002.com就代表成功！

1.2.3 服务提供者和服务消费者配置文件修改

由于eureka的服务端做了集群，有两个eureka服务端了。服务提供者和服务消费者也都属于eureka的客户端，所以都要把自己的注册到两个eureka服务端那里！

     defaultZone: http://eureka-7001.com:7001/eureka,http://eureka-7002.com:7002/eureka #告诉服务提供者要把服务注册到哪儿

2. 服务负载均衡

2.1 为什么需要负载均衡？

为了提供并发量，同一个服务提供者可以部署多个。这个消费者客户端在调用时要根据一定的负责均衡策略完成负载调用。

2.2 实现负载均衡思路

  1. 服务提供者集群

    由于服务消费者要根据负载均衡策略选择合适的服务提供者，所以服务提供者要进行进群！

  2. 服务消费者负载均衡调用

2.3 服务提供者集群

2.3.1 步骤分析

  1. 拷贝一份服务提供者
  2. 修改自身pom.xml和项目的pom.xml，使其成为子模块！
  3. 修改入口类名
  4. 修改配置文件application.yml中的port、defaultZone。注意spring.application.name: 这个名字相同服务的服务提供者的要相同！
  5. 修改两个服务提供者的controller同一个请求返回的对象不同。用于区分是否进行了负载均衡！
  6. 测试！重启注册中心,和两个服务提供者！查看是否服务提供者名字后面是否有两个地址，如果是，就代表成功！

2.3.2 实现

  1. 拷贝一份服务提供者
  2. 修改自身pom.xml和项目的pom.xml，使其成为子模块！
    自身pom.xml
user_provider_8002

项目的pom.xml

user_provider_8002
  1. 修改入口类名。规范命名！
  2. 修改配置文件application.yml
    user_provider_8001的application.yml
server:
  port: 8001
spring:
  application:
    name: USER-PROVIDER # 注意：不要使用下划线
eureka:
  client:
    service-url:
     defaultZone: http://eureka-7001.com:7001/eureka,http://eureka-7002.com:7002/eureka #告诉服务提供者要把服务注册到哪儿
  instance:
    prefer-ip-address: true # 当调用getHostname获取实例的hostname时，返回ip而不是host名称
    ip-address: 127.0.0.1 # 指定自己的ip信息，不指定的话会自己寻找

user_provider_8002的application.yml

server:
  port: 8002
spring:
  application:
    name: USER-PROVIDER # 注意：不要使用下划线
eureka:
  client:
    service-url:
     defaultZone: http://eureka-7001.com:7001/eureka,http://eureka-7002.com:7002/eureka #告诉服务提供者要把服务注册到哪儿
  instance:
    prefer-ip-address: true # 当调用getHostname获取实例的hostname时，返回ip而不是host名称
    ip-address: 127.0.0.1 # 指定自己的ip信息，不指定的话会自己寻找
  1. 修改两个服务提供者的controller同一个请求返回的对象不同。用于区分是否进行了负载均衡！
    user_provider_8001
package cn.wangningbo.controller;

import cn.wangningbo.domain.User;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/provider/user")
public class UserController {
    @GetMapping("/{id}")
    public User getById(@PathVariable("id") Long id) {
        //以后要通过service操作数据库获取数据,现在只是模拟
        return new User(id, "二狗8001");
    }
}

user_provider_8002

package cn.wangningbo.controller;

import cn.wangningbo.domain.User;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/provider/user")
public class UserController {
    @GetMapping("/{id}")
    public User getById(@PathVariable("id") Long id) {
        //以后要通过service操作数据库获取数据,现在只是模拟
        return new User(id, "二狗8002");
    }
}
  1. 测试！
    重启注册中心和两个服务提供者，浏览器访问地址：

可以看到Instances currently registered with Eureka下面这个服务名字USER-PROVIDER的服务有两个，UP (2) - localhost:USER-PROVIDER:8002 , localhost:USER-PROVIDER:8001

2.4 消费者负载均衡技术实现

2.4.1 常见的负载均衡技术

  1. Ribbon

  2. Feign

    feign底层还是ribbon,只是进行了封装,让我们以接口的方式进行调用

2.4.2 Ribbon

2.4.2.1简介

Ribbon是一个客户端负载均衡器,它可以按照一定规则来完成多态服务器负载均衡调用,这些规则还支持自定义

Ribbon实现客户端消费者实现负载均衡！

2.4.2.2 负载均衡之Ribbon实现分析

  1. 创建项目
  2. 导入jar
  3. 配置application.yml
  4. 配置配置类（开启负载均衡）
  5. 消费者使用负载均衡调用
  6. 测试

2.4.2.3 Ribbon实现

  1. 创建项目

    我这里偷个懒，就不创建新的了，拷贝一份9001那消费者，改一下就好了！

  2. 导入jar

        
        
            cn.wangningbo
            user_interface
            1.0-SNAPSHOT
        
        
        
            org.springframework.boot
            spring-boot-starter-web
        
        
        
            org.springframework.boot
            spring-boot-starter-test
        
        
        
            org.springframework.cloud
            spring-cloud-starter-netflix-eureka-client
        
        
        
            org.springframework.cloud
            spring-cloud-starter-netflix-ribbon
  1. 配置application.yml
server:
  port: 9002
spring:
  application:
    name: USER-CONSUMER-RIBBON # 注意不要使用下划线
eureka:
  client:
    service-url:
     #defaultZone: http://localhost:7001/eureka #告诉服务提供者要把服务注册到哪儿
     defaultZone: http://eureka-7001.com:7001/eureka,http://eureka-7002.com:7002/eureka # 集群
  instance:
      prefer-ip-address: true # 当调用getHostname获取实例的hostname时，返回ip而不是host名称
      ip-address: 127.0.0.1 # 指定自己的ip信息，不指定的话会自己寻找
  1. 配置配置类（开启负载均衡）

@LoadBalanced //开启负载均衡

package cn.wangningbo.config;

import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

@Configuration
public class ConfigBean {
    @Bean //配置RestTemplate
    @LoadBalanced //开启负载均衡
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}
  1. 消费者使用负载均衡调用

通过服务名从注册中心获取服务列表,通过负载均衡调用

controller层调用时的代码

package cn.wangningbo.controller;

import cn.wangningbo.domain.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import java.util.List;

@RestController
@RequestMapping("/consumer/user")
public class UserController {
    @Autowired
    private RestTemplate restTemplate;

    @Autowired
    private DiscoveryClient discoveryClient;// org.springframework.cloud.client.discovery.DiscoveryClient;

    private static final String URL_PREFIX = "http://USER-PROVIDER";//通过服务名,真实在做时,通过服务名获取服务列表,再通过负载均衡策略完成调用

    @GetMapping("/{id}")
    public User getById(@PathVariable("id") Long id) {
        // 拼接url
        String url = URL_PREFIX + "/provider/user/" + id;
        //访问
        return restTemplate.getForObject(url, User.class);
    }
}

  1. 测试

  2. 启动7001、8001、8002、9002

  3. 打开浏览器，访问http://eureka-7001.com:7001/，查看状态是否都是正常的

  4. 测试负载均衡。

    访问地址:http://localhost:9002/consumer/user/1，不断刷新，可以发现返回的对象时不一样的，是交替着换着来的，说明默认的负载均衡策略是轮询！

2.4.3 负载均衡策略

2.4.4 Feign

2.4.4.1 简介

Feign具有如下特性：

  • 可插拔的注解支持，包括Feign注解和JAX-RS注解;
  • 支持可插拔的HTTP编码器和解码器;
  • 支持Hystrix和它的Fallback;
  • 支持Ribbon的负载均衡;
  • 支持HTTP请求和响应的压缩。

Feign是用@FeignClient来映射服务的。

Feign是以接口方式进行调用，而不是通过RestTemplate来调用,不需要那么麻烦的拼接字符串。feign底层还是ribbon,但feign使用起来更加舒服！

2.4.4.2 负载均衡之Feign实现分析

  1. 创建项目

  2. 导入jar

  3. 配置application.yml

  4. 配置配置类（开启负载均衡）

  5. 公共代码区user_interface修改

    注意调用服务的名字和路径配置！要和服务提供者里面访问地址和参数等保持一致。

  6. 服务消费者使用负载均衡

  7. 测试

  8. 疑点解析

2.4.4.3 Feign实现分析实现

  1. 创建项目

    我这里偷个懒，就不创建新的了，拷贝一份9001那消费者，改一下就好了！

  2. 导入jar


        
            cn.wangningbo
            user_interface
            1.0-SNAPSHOT
        
        
        
            org.springframework.boot
            spring-boot-starter-web
        
        
        
            org.springframework.boot
            spring-boot-starter-test
        
        
        
            org.springframework.cloud
            spring-cloud-starter-netflix-eureka-client
        
        
        
            org.springframework.cloud
            spring-cloud-starter-openfeign
  1. 配置application.yml
server:
  port: 9003
spring:
  application:
    name: USER-CONSUMER # 注意：不要使用下划线
eureka:
  client:
    service-url:
      defaultZone: http://eureka-7001.com:7001/eureka,http://eureka-7002.com:7002/eureka #告诉服务提供者要把服务注册到哪儿
  instance:
      prefer-ip-address: true # 当调用getHostname获取实例的hostname时，返回ip而不是host名称
      ip-address: 127.0.0.1 # 指定自己的ip信息，不指定的话会自己寻找
  1. 配置入口类（开启负载均衡）
    @EnableFeignClients(basePackages = "cn.wangningbo.client") //不在当前包下面的时候才加这个注解，否则可以省略！
    // 它会扫描指定包里面加了@FeignClient的所有的接口,并且为他们产生代理对象并且纳入spring管理,我们就可以通过代理对象远程访问接口
    // 如果client在springboot扫描范围(加了@SpringbootAPplication类的当前包,及其子包),可以不用加包名
package cn.wangningbo;

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

@SpringBootApplication
@EnableEurekaClient //表示是eureka的客户端
@EnableFeignClients(basePackages = "cn.wangningbo.client") //不在当前包下面的时候才加这个注解，否则可以省略！
// 它会扫描指定包里面加了@FeignClient的所有的接口,并且为他们产生代理对象并且纳入spring管理,我们就可以通过代理对象远程访问接口
// 如果client在springboot扫描范围(加了@SpringbootAPplication类的当前包,及其子包),可以不用加包名
public class ConsumerApp9003 {
    public static void main(String[] args) {
        SpringApplication.run(ConsumerApp9003.class, args);
    }
}
  1. 公共代码区user_interface修改
    pom.xml导包
 
        
            org.springframework.boot
            spring-boot-starter-web
        
        
        
            org.springframework.boot
            spring-boot-starter-test
        
        
        
            org.springframework.cloud
            spring-cloud-starter-openfeign

公共代码去区新建client包,准备接口和类，进行配置

package cn.wangningbo.client;

import cn.wangningbo.domain.User;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;

//最终会根据接口产生代理对象,远程访问服务提供者,就需要制定服务器提供者名称
@FeignClient(value = "USER-PROVIDER", fallbackFactory
        = UserClientHystrixFallbackFactory.class)
@RequestMapping("/provider/user")
public interface UserClient {
    @RequestMapping("/{id}")
        ///provider/user/{id} 通过它来唯一确定我们要调用远程方法
    User getUserById(@PathVariable("id") Long id);
}

package cn.wangningbo.client;

import cn.wangningbo.domain.User;
import feign.hystrix.FallbackFactory;
import org.springframework.stereotype.Component;

@Component
public class UserClientHystrixFallbackFactory implements FallbackFactory {

    public UserClient create(Throwable throwable) {
        return new UserClient() {
            public User getUserById(Long id) {
                return new User(id, "用户不存在");
            }
        };
    }
}
  1. 服务消费者controller调用
package cn.wangningbo.controller;

import cn.wangningbo.client.UserClient;
import cn.wangningbo.domain.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import java.util.List;

@RestController
@RequestMapping("/consumer/user")
public class UserController {
    @Autowired
    private UserClient userClient;

    @GetMapping("/{id}")
    public User getById(@PathVariable("id") Long id) {
        return userClient.getUserById(id);
    }
}
  1. 测试
    1. 启动一个注册中心服务端（7001）
    1. 启动两个服务提供者（8001和8002）
    1. 启动feign的负载均衡，进行测试。（9003）

打开浏览器，访问http://eureka-7001.com:7001/，查看状态是否都是正常的

访问地址:http://localhost:9003/consumer/user/1，不断刷新，可以发现返回的对象时不一样的，是交替着换着来的，说明默认的负载均衡策略也是轮询

  1. 疑点解析
  • client为什么不放到自己实现里面?

要放到公共代码里面
这个接口给很多服务器消费者进行调用,如果写在其中一个消费者里面,其他的人就使用不了.

如果client在springboot扫描范围(加了@SpringbootAPplication类的当前包,及其子包),可以不用加包名

3. Hystrix断路器

3.1 为什么需要Hystrix断路器

在复杂的分布式架构的应用程序有很多的依赖，都会不可避免地在某些时候失败。高并发的依赖失败时如果没有隔离措施，当前应用服务就有被拖垮的风险。俗称的雪崩现象！

当然，上面这种结果不是我们想要的，不允许出现应用服务就有被拖垮现象，对依赖进行隔离，则出现断路器的解决方案m！

Hystrix是保证微服务群健壮框架,做了隔离,熔断,降级等操作.最终达到不会由于某一个服务出问题而导致雪崩现象,让整体群死掉。

3.2 Hystrix简介

Hystrix是国外知名的视频网站Netflix所开源的非常流行的高可用架构框架。Hystrix能够完美的解决分布式系统架构中打造高可用服务面临的一系列技术难题。

Hystrix “豪猪”，具有自我保护的能力。hystrix 通过如下机制来解决雪崩效应问题。

  1. 资源隔离（限流）

    包括线程池隔离和信号量隔离，限制调用分布式服务的资源使用，某一个调用的服务出现问题不会影响其他服务调用。

  2. 熔断

    当失败率达到阀值自动触发降级(如因网络故障/超时造成的失败率高)，熔断器触发的快速失败会进行快速恢复。

  3. 降级机制

    超时降级、资源不足时(线程或信号量)降级，降级后可以配合降级接口返回托底数据。

  4. 缓存

    提供了请求缓存、请求合并实现

3.2.1 原理分析

Hystrix使用命令模式(继承HystrixCommand(隔离)类)来包裹具体的服务调用逻辑(run方法), 并在命令模式中添加了服务调用失败后的降级逻辑(getFallback).

同时我们在Command的构造方法中可以定义当前服务线程池和熔断器的相关参数.

在使用了Command模式构建了服务对象之后, 服务便拥有了熔断器和线程池的功能.

3.2.2 资源隔离&限流

  1. 线程池隔离模式
  2. 信号量隔离模式

3.2.3 服务熔断

  1. 正常情况下，断路器处于关闭状态(Closed)

  2. 如果调用持续出错或者超时，电路被打开进入熔断状态(Open)，后续一段时间内的所有调用都会被拒绝(Fail Fast)

  3. 一段时间以后，保护器会尝试进入半熔断状态(Half-Open)，允许少量请求进来尝试：

    • 如果调用仍然失败，则回到熔断状态。
    • 如果调用成功，则回到电路闭合状态

  4. 熔断的参数配置

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

  5. 对这三个熔断参数的解释

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

3.2.4 服务降级

有了熔断，就得有降级。所谓降级，就是当某个服务熔断之后，服务器将不再被调用，此时客户端可以自己准备一个本地的fallback回调，返回一个缺省值。

3.3 Hystrix实现(服务提供者实现)

3.3.1 Hystrix实现步骤分析

Hystrix是在服务提供者实现的！

  1. 拷贝一份服务端代码并进行配置！
  2. pom.xml导包（断路器）
  3. 主类使用注解@EnableHystrix表示开启断路器支持
  4. 服务提供者接口方法那里加注解@HystrixCommand(fallbackMethod="方法名")，断路器触发以后就会执行这个方法
  5. 测试
  6. 注意点
    • 熔断是在服务提供方做
    • 调用时不能使用feign调用(有自己熔断机制),要用ribbon调用

3.3.2 Hystrix实现

  1. 拷贝一份服务端代码

    我这里拷贝了8001，并进行修改使其成为子模块！并重命名为user_provider_8003_Hystrix！修改配置文件application.yml的端口为8003！

  2. pom.xml导包

        
        
            org.springframework.cloud
            spring-cloud-starter-netflix-hystrix
  1. 主类使用注解@EnableHystrix表示开启断路器支持
package cn.wangningbo;

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

@SpringBootApplication
@EnableEurekaClient //表示是eureka的客户端
@EnableHystrix //表示开启断路器支持
public class ProviderApp8003 {
    public static void main(String[] args) {
        SpringApplication.run(ProviderApp8003.class, args);
    }
}
  1. 服务提供者接口方法那里加注解@HystrixCommand(fallbackMethod="方法名")，断路器触发以后就会执行这个方法
package cn.wangningbo.controller;

import cn.wangningbo.domain.User;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/provider/user")
public class UserController {
    @GetMapping("/{id}")
    @HystrixCommand(fallbackMethod = "fallbackGet")//方法里面触发断路器就会执行这个fallbackGet方法
    public User getById(@PathVariable("id") Long id) {
        //手动设置报错使其触发断路器
        if (id == 2) {
            throw new RuntimeException("报错！");
        }
        //以后要通过service操作数据库获取数据,现在只是模拟
        return new User(id, "二狗8003");
    }

    public User fallbackGet(Long id) {
        return new User(id, "用户不存在！");
    }
}

  1. 测试

    启动7001,8003,9002！

    浏览器地址栏访问：http://localhost:9002/consumer/user/1，可以正常返回数据！

    浏览器地址栏访问：http://localhost:9002/consumer/user/2，则出发了断路器，返回的是断路器的数据！

3.4 Feign实现（feign服务消费者实现）

3.4.1 使用原因

  1. 原因

    每个方法都要加回调并且耦合

  2. 解决方案

    可以使用spring面向切面编程,为feign的接口创建一个代理对象,完成对服务调用,当发现熔断后就调用同名托底方法.

3.4.2 Feign实现步骤分析

feign是在服务消费者实现

  1. 拷贝一份消费端代码（拷贝的是9003，那里的controller使用的feign）
  2. pom.xml导包（没有额外的包，使用9003里面的包就够了）
  3. 配置application.yml
  4. 主类使用注解@ComponentScan扫描包
  5. 公共代码区实现
  6. 消费者的controller那里配置@FeignClient调用服务端
  7. 测试

3.4.3 Feign实现

  1. 拷贝一份消费端代码（拷贝9003）
  2. pom.xml导包（都是原来的包）

        
            cn.wangningbo
            user_interface
            1.0-SNAPSHOT
        
        
        
            org.springframework.boot
            spring-boot-starter-web
        
        
            org.springframework.boot
            spring-boot-starter-test
        
        
        
            org.springframework.cloud
            spring-cloud-starter-netflix-eureka-client
        
        
        
            org.springframework.cloud
            spring-cloud-starter-openfeign
  1. 配置application.yml
server:
  port: 9004
spring:
  application:
    name: USER-CONSUMER # 注意：不要使用下划线
eureka:
  client:
#    registerWithEureka: false # 不注册到Eureka,不在注册中心显示
    service-url:
      defaultZone: http://eureka-7001.com:7001/eureka,http://eureka-7002.com:7002/eureka #告诉服务提供者要把服务注册到哪儿
  instance:
      prefer-ip-address: true # 当调用getHostname获取实例的hostname时，返回ip而不是host名称
      ip-address: 127.0.0.1 # 指定自己的ip信息，不指定的话会自己寻找
feign:
   hystrix:
       enabled: true # 开启熔断支持
   client:
       config:
         default:           #服务名，填写default为所有服务
           connectTimeout: 3000 # 连接超时时间（单位：毫秒）
           readTimeout: 3000 # 读取超时时间（单位：毫秒）
hystrix:
  command:
      default:
        execution:
          isolation:
            thread:
              timeoutInMilliseconds: 3000 # 被该调用方的所有方法的默认超时时间
  1. 主类使用注解@ComponentScan扫描包(如果接口包比较规范，则不需要加)
  2. 公共代码区实现
package cn.itsource.springcloud.client;

import cn.itsource.springcloud.domain.User;
import feign.hystrix.FallbackFactory;
import org.springframework.stereotype.Component;

@Component
public class UserClientHystrixFallbackFactory implements FallbackFactory {
    public UserClient create(Throwable throwable) {
        return new UserClient() {
            public User getUserById(Long id) {
                return new User(id,"用户不存在");
            }
        };
    }
}

package cn.wangningbo.client;

import cn.wangningbo.domain.User;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;

//最终会根据接口产生代理对象,远程访问服务提供者,就需要制定服务器提供者名称
@FeignClient(value = "USER-PROVIDER", fallbackFactory
        = UserClientHystrixFallbackFactory.class)
@RequestMapping("/provider/user")
public interface UserClient {
    @RequestMapping("/{id}")
        ///provider/user/{id} 通过它来唯一确定我们要调用远程方法
    User getUserById(@PathVariable("id") Long id);
}

  1. 测试

    启动7001,8001,9004（刚才拷贝的那个）！

    浏览器地址栏访问：http://localhost:9004/consumer/user/1，可以正常拿到值

    关闭8001服务提供者，这时候再浏览器访问http://localhost:9004/consumer/user/1，就会连接超时，会触发断路器，返回的就职托底数据！

4. Zuul路由网关

4.1 简介

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

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

其存在意义在于，将"1对N"问题 转换成了"1对1”问题（路由），同时在请求到达真正的微服务之前，可以做一些预处理（过滤），比如：来源合法性检测，权限校验，反爬虫之类...

官网地址： https://github.com/Netflix/zuul

4.2 基本配置

4.2.1 创建模块zuul_gatewar_1299

4.2.2 导入pom.xml


        
            org.springframework.boot
            spring-boot-starter-web
        
        
        
            org.springframework.boot
            spring-boot-starter-test
        
        
        
            org.springframework.cloud
            spring-cloud-starter-netflix-eureka-client
        
        
        
            org.springframework.cloud
            spring-cloud-starter-netflix-zuul

4.2.3 配置application.yml

server:
  port: 1299
spring:
  application:
    name: ZUUL-GATEWAY
eureka:
  client:
    service-url:
       defaultZone: http://eureka-7001.com:7001/eureka,http://eureka-7002.com:7002/eureka # 集群
  instance:
    prefer-ip-address: true # 在注册中心显示Eureka客户端真实ip地址

4.2.4 入口类注解@EnableZuulProxy //开启网关支持

package cn.wangningbo;

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

@SpringBootApplication
@EnableZuulProxy //开启网关支持
public class ZuulGatewar1299 {
    public static void main(String[] args) {
        SpringApplication.run(ZuulGatewar1299.class, args);
    }
}

4.2.5 启动测试

启动eureka服务端、eureka的客户端服务提供者客、zuul

浏览器访问：http://localhost:8001/provider/user/1
浏览器访问：http://localhost:1299/user-provider/provider/user/1

发现这两个地址都可以拿到数据，成功！

注意：user-provider是服务中心服务提供者应用名字的小写形式

4.3 路由访问映射规则

  1. 进行安全加固

    不用服务名,映射路径

  2. 忽略原来服务名访问

    规定不可以使用原来模式访问

  3. 加上统一前缀

    访问数据时候使用统一的前缀

实现以上几点，只需修改zuul的application.yml即可

zuul:
  routes:
    myUser.serviceId: user-provider # 服务名
    myUser.path: /myUser/** # 把myUser打头的所有请求都转发给user-provider
  ignored-services: "*" # 所有服务都不允许以服务名来访问
  prefix: "/services" # 加一个统一前缀

可以进行再次测试！

浏览器地址栏访问：http://localhost:1299/services/myUser/provider/user/1可以拿到数据

浏览器地址栏访问：http://localhost:1299/services/user-provider/provider/user/1却拿不到数据

成功！

4.4 过滤器

Zuul作为网关的其中一个重要功能，就是实现请求的鉴权。而这个动作我们往往是通过Zuul提供的过滤器来实现的。

4.4.1 ZuulFilter

ZuulFilter是过滤器的顶级父类。

其最重要的方法有4个，如下：

  1. shouldFilter：返回一个Boolean值，判断该过滤器是否需要执行。返回true执行，返回false不执行。
  2. run：过滤器的具体业务逻辑。
  3. filterType：返回字符串，代表过滤器的类型。包含以下4种：
    • pre：请求在被路由之前执行
    • routing：在路由请求时调用
    • post：在routing和errror过滤器之后调用
    • error：处理请求时发生错误调用
  4. filterOrder：通过返回的int值来定义过滤器的执行顺序，数字越小优先级越高。

4.4.2 过滤器执行周期

  1. 正常流程：

    请求到达首先会经过pre类型过滤器，而后到达routing类型，进行路由，请求就到达真正的服务提供者，执行请求，返回结果后，会到达post过滤器。而后返回响应。

  2. 异常流程：

    • （1）整个过程中，pre或者routing过滤器出现异常，都会直接进入error过滤器，再error处理完毕后，会将请求交给POST过滤器，最后返回给用户。
    • （2）如果是error过滤器自己出现异常，最终也会进入POST过滤器，而后返回。
    • （3）如果是POST过滤器出现异常，会跳转到error过滤器，但是与pre和routing不同的时，请求不会再到达POST过滤器了。

4.4.3 使用场景

使用场景比较多，我举例一下几个：

  1. 请求鉴权：一般放在pre类型，如果发现没有访问权限，直接就拦截了
  2. 异常处理：一般会在error类型和post类型过滤器中结合来处理。
  3. 服务调用时长统计：pre和post结合使用。

4.4.4 自定义过滤器（继承ZuulFilter）

  1. 实现分析

    自己新建一个过滤器类，继承于ZuulFilter，实现里面的四个方法，在run方法里面写过滤的逻辑！然后给这个过滤器类打上注解，使其能被扫描到，这个自定义过滤器就生效了！

  2. 实现举例
    这里我使用自定义过滤器模拟一个登录拦截器!使用postman进行测试！

基本逻辑：如果request请求头携带token参数，则认为请求有效，放行。

package cn.wangningbo.filter;

import com.netflix.zuul.ZuulFilter;
import com.netflix.zuul.context.RequestContext;
import com.netflix.zuul.exception.ZuulException;
import org.apache.http.HttpStatus;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

@Component
public class LoginFilter extends ZuulFilter {
    // 过滤器类型
    public String filterType() {
        return "pre";
    }

    //过滤器顺序
    public int filterOrder() {
        return 1;
    }

    // 是否启用此过滤器
    public boolean shouldFilter() {
        return true;
    }

    // 过滤逻辑
    public Object run() throws ZuulException {
        // 如果request请求头携带token参数，则认为请求有效，放行。
        RequestContext currentContext = RequestContext.getCurrentContext();
        String token = currentContext.getRequest().getHeader("token");
        if (null == token || StringUtils.isEmpty(token)) {
            // 拦截
            currentContext.setSendZuulResponse(false);
            // 设置一个状态吗
            currentContext.setResponseStatusCode(HttpStatus.SC_UNAUTHORIZED);
        }
        // 放行
        return null;
    }
}

postman进行测试：没有token参数时，访问失败；反之则成功！

4.5 负载均衡与熔断

Zuul中默认就已经集成了Ribbon负载均衡和Hystix熔断机制。但是所有的超时策略都是走的默认值，比如熔断超时时间只有1S，很容易就触发了。因此建议我们手动进行配置。

在配置文件application.yml里面配置一下即可！

zuul:
  retryable: true # 是否重试
ribbon:
  ConnectTimeout: 250 # 连接超时时间(ms)
  ReadTimeout: 2000 # 通信超时时间(ms)
  OkToRetryOnAllOperations: true # 是否对所有操作重试
  MaxAutoRetriesNextServer: 2 # 同一服务不同实例的重试次数
  MaxAutoRetries: 1 # 同一实例的重试次数
hystrix:
  command:
    default:
      execution:
        isolation:
          thread:
            timeoutInMillisecond: 3000 # 设置所有有熔断默认超时时长：3000ms

测试负载均衡和熔断是否成功！

你可能感兴趣的:(SpringCloud-day2)

  • SpringCloud-day2 程序员Darker
    此篇笔记在上一篇笔记SpringCloud-day1的基础上接着写的1.Eureka集群1.1实现方法说明1.2实现集群1.2.1拷贝一份eureka服务端的代码1.2.2搭建集群1.2.3服务提供者和服务消费者配置文件修改2.服务负载均衡2.1为什么需要负载均衡？2.2实现负载均衡思路2.3服务提供者集群2.3.1步骤分析2.3.2实现2.4消费者负载均衡技术实现2.4.1常见的负载均衡技术2.
  • SpringCloud-day2 abiao你要努力呀 java
    文章目录一.微服务之间通信①搭建user-common公共模块②user-server和pay-server依赖user-common③user-server编写controller返回User对象④pay-server定义Bean(RestTemplate)pay-server编写controller二.Ribbon(负载均衡)集成①创建user-server的集群②导入Ribbon的jar包③
  • 项目中 枚举与注解的结合使用 飞翔的马甲 javaenumannotation
    前言：版本兼容，一直是迭代开发头疼的事，最近新版本加上了支持新题型，如果新创建一份问卷包含了新题型，那旧版本客户端就不支持，如果新创建的问卷不包含新题型，那么新旧客户端都支持。这里面我们通过给问卷类型枚举增加自定义注解的方式完成。顺便巩固下枚举与注解。 一、枚举 1.在创建枚举类的时候，该类已继承java.lang.Enum类，所以自定义枚举类无法继承别的类，但可以实现接口。
  • 【Scala十七】Scala核心十一：下划线_的用法 bit1129 scala
    下划线_在Scala中广泛应用，_的基本含义是作为占位符使用。_在使用时是出问题非常多的地方，本文将不断完善_的使用场景以及所表达的含义   1. 在高阶函数中使用 scala> val list = List(-3,8,7,9) list: List[Int] = List(-3, 8, 7, 9) scala> list.filter(_ > 7) r
  • web缓存基础：术语、http报头和缓存策略 dalan_123 Web
    对于很多人来说，去访问某一个站点，若是该站点能够提供智能化的内容缓存来提高用户体验，那么最终该站点的访问者将络绎不绝。缓存或者对之前的请求临时存储，是http协议实现中最核心的内容分发策略之一。分发路径中的组件均可以缓存内容来加速后续的请求，这是受控于对该内容所声明的缓存策略。接下来将讨web内容缓存策略的基本概念，具体包括如如何选择缓存策略以保证互联网范围内的缓存能够正确处理的您的内容，并谈论下
  • crontab 问题 周凡杨 linuxcrontabunix
      一： 0481-079   Reached   a   symbol   that   is   not   expected.   背景： */5   *   *   *   *  /usr/IBMIHS/rsync.sh 
  • 让tomcat支持2级域名共享session g21121 session
    tomcat默认情况下是不支持2级域名共享session的，所有有些情况下登陆后从主域名跳转到子域名会发生链接session不相同的情况，但是只需修改几处配置就可以了。 打开tomcat下conf下context.xml文件 找到Context标签,修改为如下内容 如果你的域名是www.test.com <Context sessionCookiePath="/path&q
  • web报表工具FineReport常用函数的用法总结（数学和三角函数） 老A不折腾 Webfinereport总结
      ABS ABS(number):返回指定数字的绝对值。绝对值是指没有正负符号的数值。 Number:需要求出绝对值的任意实数。 示例: ABS(-1.5)等于1.5。 ABS(0)等于0。 ABS(2.5)等于2.5。   ACOS ACOS(number):返回指定数值的反余弦值。反余弦值为一个角度，返回角度以弧度形式表示。 Number:需要返回角
  • linux 启动java进程 sh文件 墙头上一根草 linuxshelljar
    #!/bin/bash #初始化服务器的进程PId变量 user_pid=0; robot_pid=0; loadlort_pid=0; gateway_pid=0; ######### #检查相关服务器是否启动成功 #说明： #使用JDK自带的JPS命令及grep命令组合，准确查找pid #jps 加 l 参数，表示显示java的完整包路径 #使用awk，分割出pid
  • 我的spring学习笔记5-如何使用ApplicationContext替换BeanFactory aijuans Spring 3 系列
    如何使用ApplicationContext替换BeanFactory？ package onlyfun.caterpillar.device; import org.springframework.beans.factory.BeanFactory; import org.springframework.beans.factory.xml.XmlBeanFactory; import
  • Linux 内存使用方法详细解析 annan211 linux内存Linux内存解析
    来源 http://blog.jobbole.com/45748/ 我是一名程序员，那么我在这里以一个程序员的角度来讲解Linux内存的使用。 一提到内存管理，我们头脑中闪出的两个概念，就是虚拟内存，与物理内存。这两个概念主要来自于linux内核的支持。 Linux在内存管理上份为两级，一级是线性区，类似于00c73000-00c88000，对应于虚拟内存，它实际上不占用
  • 数据库的单表查询常用命令及使用方法(-) 百合不是茶 oracle函数单表查询
        创建数据库;       --建表 create table bloguser(username varchar2(20),userage number(10),usersex char(2));       创建bloguser表,里面有三个字段     &nbs
  • 多线程基础知识 bijian1013 java多线程threadjava多线程
    一．进程和线程 进程就是一个在内存中独立运行的程序，有自己的地址空间。如正在运行的写字板程序就是一个进程。 “多任务”：指操作系统能同时运行多个进程（程序）。如WINDOWS系统可以同时运行写字板程序、画图程序、WORD、Eclipse等。 线程：是进程内部单一的一个顺序控制流。 线程和进程 a.       每个进程都有独立的
  • fastjson简单使用实例 bijian1013 fastjson
    一.简介         阿里巴巴fastjson是一个Java语言编写的高性能功能完善的JSON库。它采用一种“假定有序快速匹配”的算法，把JSON Parse的性能提升到极致，是目前Java语言中最快的JSON库；包括“序列化”和“反序列化”两部分，它具备如下特征：     
  • 【RPC框架Burlap】Spring集成Burlap bit1129 spring
    Burlap和Hessian同属于codehaus的RPC调用框架，但是Burlap已经几年不更新，所以Spring在4.0里已经将Burlap的支持置为Deprecated,所以在选择RPC框架时，不应该考虑Burlap了。 这篇文章还是记录下Burlap的用法吧，主要是复制粘贴了Hessian与Spring集成一文，【RPC框架Hessian四】Hessian与Spring集成  
  • 【Mahout一】基于Mahout 命令参数含义 bit1129 Mahout
    1. mahout seqdirectory   $ mahout seqdirectory --input (-i) input Path to job input directory(原始文本文件). --output (-o) output The directory pathna
  • linux使用flock文件锁解决脚本重复执行问题 ronin47 linux lock　重复执行
    linux的crontab命令，可以定时执行操作，最小周期是每分钟执行一次。关于crontab实现每秒执行可参考我之前的文章《linux crontab 实现每秒执行》现在有个问题，如果设定了任务每分钟执行一次，但有可能一分钟内任务并没有执行完成，这时系统会再执行任务。导致两个相同的任务在执行。 例如： <? //  test .php
  • java-74-数组中有一个数字出现的次数超过了数组长度的一半，找出这个数字 bylijinnan java
    public class OcuppyMoreThanHalf { /** * Q74 数组中有一个数字出现的次数超过了数组长度的一半，找出这个数字 * two solutions: * 1.O(n) * see <beauty of coding>--每次删除两个不同的数字，不改变数组的特性 * 2.O(nlogn) * 排序。中间
  • linux 系统相关命令 candiio linux
    系统参数 cat /proc/cpuinfo  cpu相关参数 cat /proc/meminfo 内存相关参数 cat /proc/loadavg 负载情况 性能参数 1）top M：按内存使用排序 P：按CPU占用排序 1：显示各CPU的使用情况 k：kill进程 o：更多排序规则 回车：刷新数据 2）ulimit ulimit -a：显示本用户的系统限制参
  • [经营与资产]保持独立性和稳定性对于软件开发的重要意义 comsci 软件开发
         一个软件的架构从诞生到成熟，中间要经过很多次的修正和改造       如果在这个过程中，外界的其它行业的资本不断的介入这种软件架构的升级过程中           那么软件开发者原有的设计思想和开发路线
  • 在CentOS5.5上编译OpenJDK6 Cwind linuxOpenJDK
    几番周折终于在自己的CentOS5.5上编译成功了OpenJDK6，将编译过程和遇到的问题作一简要记录，备查。 0. OpenJDK介绍 OpenJDK是Sun（现Oracle）公司发布的基于GPL许可的Java平台的实现。其优点： 1、它的核心代码与同时期Sun（-> Oracle）的产品版基本上是一样的，血统纯正，不用担心性能问题，也基本上没什么兼容性问题；（代码上最主要的差异是
  • java乱码问题 dashuaifu java乱码问题js中文乱码
    swfupload上传文件参数值为中文传递到后台接收中文乱码     在js中用setPostParams（{"tag" : encodeURI( document.getElementByIdx_x("filetag").value，"utf-8")}）; 然后在servlet中String t
  • cygwin很多命令显示command not found的解决办法 dcj3sjt126com cygwin
    cygwin很多命令显示command not found的解决办法   修改cygwin.BAT文件如下 @echo off D: set CYGWIN=tty notitle glob set PATH=%PATH%;d:\cygwin\bin;d:\cygwin\sbin;d:\cygwin\usr\bin;d:\cygwin\usr\sbin;d:\cygwin\us
  • [介绍]从 Yii 1.1 升级 dcj3sjt126com PHPyii2
    2.0 版框架是完全重写的，在 1.1 和 2.0 两个版本之间存在相当多差异。因此从 1.1 版升级并不像小版本间的跨越那么简单，通过本指南你将会了解两个版本间主要的不同之处。 如果你之前没有用过 Yii 1.1，可以跳过本章，直接从"入门篇"开始读起。 请注意，Yii 2.0 引入了很多本章并没有涉及到的新功能。强烈建议你通读整部权威指南来了解所有新特性。这样有可能会发
  • Linux SSH免登录配置总结 eksliang ssh-keygenLinux SSH免登录认证Linux SSH互信
    转载请出自出处：http://eksliang.iteye.com/blog/2187265 一、原理      我们使用ssh-keygen在ServerA上生成私钥跟公钥，将生成的公钥拷贝到远程机器ServerB上后,就可以使用ssh命令无需密码登录到另外一台机器ServerB上。      生成公钥与私钥有两种加密方式，第一种是
  • 手势滑动销毁Activity gundumw100 android
    老是效仿ios，做android的真悲催！ 有需求：需要手势滑动销毁一个Activity 怎么办尼？自己写？ 不用~，网上先问一下百度。 结果： http://blog.csdn.net/xiaanming/article/details/20934541 首先将你需要的Activity继承SwipeBackActivity，它会在你的布局根目录新增一层SwipeBackLay
  • JavaScript变换表格边框颜色 ini JavaScripthtmlWebhtml5css
    效果查看：http://hovertree.com/texiao/js/2.htm代码如下，保存到HTML文件也可以查看效果： <html> <head> <meta charset="utf-8"> <title>表格边框变换颜色代码-何问起</title> </head> <body&
  • Kafka Rest : Confluent kane_xie kafkaRESTconfluent
    最近拿到一个kafka rest的需求，但kafka暂时还没有提供rest api（应该是有在开发中，毕竟rest这么火），上网搜了一下，找到一个Confluent Platform，本文简单介绍一下安装。 这里插一句，给大家推荐一个九尾搜索，原名叫谷粉SOSO，不想fanqiang谷歌的可以用这个。以前在外企用谷歌用习惯了，出来之后用度娘搜技术问题，那匹配度简直感人。 环境声明：Ubu
  • Calender不是单例 men4661273 单例Calender
             在我们使用Calender的时候，使用过Calendar.getInstance()来获取一个日期类的对象，这种方式跟单例的获取方式一样，那么它到底是不是单例呢，如果是单例的话，一个对象修改内容之后，另外一个线程中的数据不久乱套了吗？从试验以及源码中可以得出，Calendar不是单例。 测试： Calendar c1 =
  • 线程内存和主内存之间联系 qifeifei java thread
    1， java多线程共享主内存中变量的时候，一共会经过几个阶段，    lock:将主内存中的变量锁定，为一个线程所独占。   unclock:将lock加的锁定解除，此时其它的线程可以有机会访问此变量。   read:将主内存中的变量值读到工作内存当中。   load:将read读取的值保存到工作内存中的变量副本中。  
  • schedule和scheduleAtFixedRate tangqi609567707 javatimerschedule
    原文地址：http://blog.csdn.net/weidan1121/article/details/527307 import java.util.Timer;import java.util.TimerTask;import java.util.Date; /** * @author vincent */public class TimerTest {  
  • erlang 部署 wudixiaotie erlang
    1.如果在启动节点的时候报这个错 ： {"init terminating in do_boot",{'cannot load',elf_format,get_files}} 则需要在reltool.config中加入 {app, hipe, [{incl_cond, exclude}]},     2.当generate时，遇到： ERROR
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他