springCloud-初识

1--架构演变

传统架构 --》 水平拆分（分层） --》 垂直拆分（功能拆分 最早的分布式） --》 soa（dubbo 提供服务 发现服务） --》 微服务（springCloud）

2--远程调用技术

rpc协议：自定义数据格式，限定技术，传输速度比较快 效率高 tcp 代表：dubbo
http协议：统一的数据格式，不限定技术，rest接口 tcp 代表:springCloud

3--springCloud

微服务架构的解决方案，是很多组件的集合
eureka：注册中心，服务的注册与发现
ribbon：负载均衡组件
hystrix：熔断组件
feign：远程调用组件（会去集成ribbon、hystrix）
zuul：网关组件，路由请求，过滤器（会去集成ribbon、hystrix）

eureka注册中心

搭建eureka注册中心

1-引入组件的启动器

<properties>
    <java.version>1.8</java.version>
    <spring-cloud.version>Hoxton.SR6</spring-cloud.version>
</properties>

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>

<!-- 统一管理依赖的版本号 -->
<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-覆盖默认配置

server:
  port: 10086
spring:
  application:
    name: xiaoai-eureka  #将来作为微服务名称注入到eureka容器
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:${server.port}/eureka
    register-with-eureka: true  # 服务提供方启动时，会检测该参数是否为ture，true==注册给eureka

3-在引导类上添加注解，开启相关组件

@SpringBootApplication
@EnableEurekaServer  //启用eureka服务端
public class XiaoaiEurekaApplication {
    public static void main(String[] args) {
          SpringApplication.run(XiaoaiEurekaApplication.class, args);
    }
}

引入其他客户端到注册中心

1--引如客户端依赖

<properties>
    <spring-cloud.version>Hoxton.SR6</spring-cloud.version>
</properties>

<!--eureka客户端-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

<!-- 统一管理依赖的版本号 -->
<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--application配置文件配置微服务信息

spring:
  application: #添加注册信息
    name: service-provider #将来会作为微服务的名称

eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:10086/eureka

3--引导类开启客户端

package com.xiaoai.service;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import tk.mybatis.spring.annotation.MapperScan;

@SpringBootApplication
@MapperScan("com.xiaoai.service.mapper")
@EnableDiscoveryClient  //启用eureka客户端，@EnableEurekaClient也可以
public class XiaoaiServiceProviderApplication {

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

4--消费端调用提供端

package com.xiaoai.service.controller;

import com.xiaoai.service.pojo.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.*;
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;

//    @GetMapping
//    @ResponseBody
//    public User queryUserById(@RequestParam("id")Long id){
//        return this.restTemplate.getForObject("http://localhost:8081/user/"+id,User.class);
//    }

    //改造消费方，解决地址硬编码问题
    @GetMapping
    @ResponseBody
    public User queryUserById(@RequestParam("id")Long id){
        List<ServiceInstance> instances = discoveryClient.getInstances("service-provider");
        ServiceInstance instance = instances.get(0);
        System.out.println(instance.getHost()+"---"+instance.getPort());
        return this.restTemplate.getForObject("http://" + instance.getHost() + ":" + instance.getPort() + "/user/"+id,User.class);
    }

}

高可用eureka

高可用：一个eureka挂了不影响整体的使用 在多个服务器上运行eureka项目可实现 由于有多个eureka服务端，所以即使挂掉一个还有另外的可以使用

以下为idea中代码演示：例如端口10086和10087

1-直接在idea的Run Dashboard复制一个应用

2-相互注册，先启动第一个eureka

3-修改端口启动第二个eureka

4-访问http://localhost:10086和http://localhost:10087可见其已经同步以及可见两个服务端的eureka

*多个服务端eureka也是一样的操作，把一个注册到另一个中，即可同步，多个相互围成一圈注册，如：6-》7 -》8 -》9 -》6

服务提供者

服务注册：服务提供者在启动时，会检测配置属性中的: eureka.client.register-with-eureka=true参数是否正确，事实上默认就是true。
如果值确实为true,则会向EurekaServer发起一个Rest请求，并携带自己的元数据信息，Eureka Server会把这些信息保存到一个双层Map结构中。

双层map：Map<serviceId(注册时配置application.name的那个名称), Map<服务实例名，实例对象( instance)

服务续约：在注册服务完成以后，服务提供者会维持一个心跳(定时向EurekaServer发起Rest请求)，告诉EurekaServer:“我还活着”。 这个我们称为服务的续约(renew) ;
有两个重要参数可以修改服务续约的行为:

eureka:
　　instance:
　　　　lease-expiration-duration-in-seconds: 90
　　　　lease-renewal-interval-in-seconds: 30
lease-renewal-interval-in-seconds:服务续约(renew)的间隔，默认为30秒 即30秒给一个反应证明还活着
lease-expiration-duration-in-seconds:服务失效时间，默认值90秒 即90秒没响应当其挂了

也就是说，默认情况下每个30秒服务会向注册中心发送一-次心跳， 证明自己还活着。如果超过90秒没有发送心跳，EurekaServer就会认为该服务宕机，会从服务列表中移除，这两个值在生产环境不要修改，默认即可。

服务消费者

获取服务列表： 当服务消费者启动时，会检测eureka.client.fetch-registry=true参数的值，如果为true,则会拉取EurekaServer服务的列表只读备份，然后缓存在本地。
并且每隔30秒会重新获取并更新数据。我们可以通过下面的参数来修改:

eureka:
　　client :
　　　　registry-fetch-interval-seconds: 5

生产环境中，我们不需要修改这个值。但是为了开发环境下，能够快速得到服务的最新状态，我们可以将其设置小- -点。

失效剔除和自我保护

服务下线： 当服务进行正常关闭操作时，它会触发一个服务下线的REST请求给Eureka Server，告诉服务注册中心：“我要下线了”。服务中心接受到请求之后，将该服务置为下线状态。
失效剔除：

有些时候，我们的服务提供方并不一定会正常下线，可能因为内存溢出、网络故障等原因导致服务无法正常工作。EurekaServer需要将这样的服务剔除出服务列表。
因此它会开启一个定时任务，每隔60秒对所有失效的服务（超过90秒未响应）进行剔除。可以通过eureka.server.eviction-interval-timer-in-ms参数对其进行修改，单位是毫秒。
生产环境不要修改，这个会对我们开发带来极大的不变，你对服务重启，隔了60秒Eureka才反应过来。开发阶段可以适当调整，比如：10秒

自我保护： 我们关停一个服务，就会在Eureka面板看到一条警告：

这是触发了Eureka的自我保护机制。当一个服务未按时进行心跳续约时，Eureka会统计最近15分钟心跳失败的服务实例的比例是否超过了85%。在生产环境下，因为网络延迟等原因，心跳失败实例的比例很有可能超标，但是此时就把服务剔除列表并不妥当，
因为服务可能没有宕机。Eureka就会把当前实例的注册信息保护起来，不予剔除。生产环境下这很有效，保证了大多数服务依然可用。但是这给我们的开发带来了麻烦，因此开发阶段我们都会关闭自我保护模式：

Ribbon负载均衡

Ribbon是Netflix 发布的负载均衡器，它有助于控制HTTP和TCP客户端的行为。为Ribbon配置服务提供者地址列表后，Ribbon 就可基于某种负载均衡算法，自动地帮助服务泌费者去请求。
Ribbon 默认为我们提供了很多的负载均衡算法，例如轮询(一个一个轮下去到结尾又从头开始)、随机等。当然，我们也可为Ribbon实现自定义的负载均衡算法。

基本使用

1--引入启动器（消费方引入）

eureka默认集成了ribbon，引入了eureka后可以不用再引入ribbon

2--覆盖默认配置

可不用覆盖任何配置也可以使用

3--引导类启用组件（消费方开启）

package com.xiaoai.service;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
@EnableDiscoveryClient  //启用eureka客户端，@EnableEurekaClient也可以
public class XiaoaiServiceConsumerApplication {

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

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

4--消费方控制器方法消费

package com.xiaoai.service.controller;

import com.xiaoai.service.pojo.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.*;
import org.springframework.web.client.RestTemplate;

import java.util.List;

@RestController
@RequestMapping("/consumer/user")
public class UserController {

//    //--------------------------------------------消费方传统方式调用提供方
//    @Autowired
//    private RestTemplate restTemplate;

//    @GetMapping
//    @ResponseBody
//    public User queryUserById(@RequestParam("id")Long id){
//        return this.restTemplate.getForObject("http://localhost:8081/user/"+id,User.class);
//    }

//    //--------------------------------------------改造消费方，解决地址硬编码问题
//    @Autowired
//    private RestTemplate restTemplate;
//    @Autowired
//    private DiscoveryClient discoveryClient;  //最早的时候服务发现注册都是通过DiscoveryClient来实现的，随着版本变迁把DiscoveryClient服务注册抽离出来变成了ServiceRegistry抽象，专门负责服务注册，DiscoveryClient专门负责服务发现
//
//    @GetMapping
//    @ResponseBody
//    public User queryUserById(@RequestParam("id")Long id){
//        List<ServiceInstance> instances = discoveryClient.getInstances("service-provider"); //通过serviceId获取实例列表
//        ServiceInstance instance = instances.get(0); //获取一个服务实例，由于这里只运行了一个提供服务，直接获取列表第一个即可
//        return this.restTemplate.getForObject("http://" + instance.getHost() + ":" + instance.getPort() + "/user/"+id,User.class); //通过实例拼接对应的url
//    }

    //-----------------------------------------------改造消费方，解决地址硬编码问题    启用ribbon负载均衡后
    @Autowired
    private RestTemplate restTemplate;

    @GetMapping
    @ResponseBody
    public User queryUserById(@RequestParam("id")Long id){
        return this.restTemplate.getForObject("http://service-provider/user/"+id,User.class);
    }

}

定义负载均衡策略

可实现 Irule接口自定义策略
默认已经实现了好几种

如何设置默认某一种策略？
可以在消费服务端application.yml配置文件加入配置

service- provider:  # 这是服务提供方的服务id即之前自己注册服务时定义的名称
  ribbon:
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule  

Hystrix熔断

Hystrix(豪猪)，全身是刺，是一种保护机制。Hystrix也是Netflix公司的一款组件。

雪崩问题 微服务中，服务间调用关系错综复杂，一个请求，可能需要调用多个微服务接口才能实现，会形成非常复杂的调用链路。

服务器支持的线程和并发数有限，请求一直阻塞，会导致服务器资源耗尽，从而导致所有其它服务都不可用，形成雪崩效应。
这就好比，一个汽车生产线，生产不同的汽车，需要使用不同的零件，如果某个零件因为种种原因无法使用，那么就会造成整台车无法装配，陷入等待零件的状态，直到零件到位，才能继续组装。
此时如果有很多个车型都需要这个零件，那么整个工厂都将陷入等待的状态，导致所有生产都陷入瘫痪。一个零件的波及范围不断扩大。

Hystix解决雪崩问题的手段有两个:

• 线程隔离
• 服务熔断

线程隔离

Hystrix为每个依赖服务调用分配一个小的线程池， 如果线程池已满调用将被立即拒绝，默认不采用排队，加速失败判定时间。
用户的请求将不再直接访问服务，而是通过线程池中的空闲线程来访问服务，如果线程池已满，或者请求超时，则会进行降级处理，什么是服务降级?

服务降级: 优先保证核心服务，而非核心服务不可用或弱可用。

用户的请求故障时，不会被阻塞，更不会无休止的等待或者看到系统崩溃，至少可以看到一个执行结果(例如返回友好的提示信息)。
服务降级虽然会导致请求失败，但是不会导致阻塞，而且最多会影响这个依赖服务对应的线程池中的资源，对其它服务没有影响。

触发Hystix服务降级的情况:

• 线程池已满
• 请求超时

服务熔断

hystrix服务降级

实例

1--引入依赖（消费端服务）

<dependency>
    groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
</dependency>

2--覆盖默认配置

可不做任何配置，直接使用默认配置

3--引导类启用组件（消费端服务）

package com.xiaoai.service;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.circuitbreaker.EnableCircuitBreaker;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
@EnableDiscoveryClient  //启用eureka客户端，@EnableEurekaClient也可以
@EnableCircuitBreaker   //开启熔断
public class XiaoaiServiceConsumerApplication {

	@Bean
	@LoadBalanced  //开启负载均衡
	public RestTemplate restTemplate(){return new RestTemplate();}
	public static void main(String[] args) {SpringApplication.run(XiaoaiServiceConsumerApplication.class, args);}
}

4--控制类编写熔断方法并关联 如：

package com.xiaoai.service.controller;

import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import com.xiaoai.service.pojo.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.*;
import org.springframework.web.client.RestTemplate;

import java.util.List;

@RestController
@RequestMapping("/consumer/user")
public class UserController {

    //-----------------------------------------------改造消费方，解决地址硬编码问题    启用ribbon负载均衡后
    @Autowired
    private RestTemplate restTemplate;

    @GetMapping
    @ResponseBody
    @HystrixCommand(fallbackMethod = "queryUserByIdFalback") //2--关联熔断方法
    public String queryUserById(@RequestParam("id")Long id){
        return this.restTemplate.getForObject("http://service-provider/user/"+id,String.class);
    }

    //1--定义熔断方法
    public String queryUserByIdFalback(Long id){
       return "服务器正忙，请稍后再试!";
    }
}

关闭提供服务访问相应消费服务端url可见：

定义全局熔断方法

package com.xiaoai.service.controller;

import com.netflix.hystrix.contrib.javanica.annotation.DefaultProperties;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.client.RestTemplate;

@RestController
@RequestMapping("/consumer/user")
@DefaultProperties(defaultFallback = "FalbackMethod") // 定义全局熔断方法
public class UserController {

    //-----------------------------------------------改造消费方，解决地址硬编码问题    启用ribbon负载均衡后
    @Autowired
    private RestTemplate restTemplate;

    @GetMapping
    @ResponseBody
    @HystrixCommand //声明熔断方法。使用全局默认方法，属性fallbackMethod = "queryUserByIdFalback"可以不用了，但注解还是要。
    public String queryUserById(@RequestParam("id")Long id){
        return this.restTemplate.getForObject("http://service-provider/user/"+id,String.class);
    }

    //定义熔断方法
    public String queryUserByIdFalback(Long id){ //熔断方法返回值必须和控制方法返回值一样
        return "queryUserByIdFalback熔断：服务器正忙，请稍后再试!";
    }

    //熔断方法
    public String FalbackMethod(){
       return "全局熔断：服务器正忙，请稍后再试!";
    }
}

关闭提供服务访问相应消费服务端url可见：

小结

• 引入hystrix启动器
• application配置文件配置熔断时间，默认1秒
• 引导类注解：@EnableCircuitBreaker、@SpringCloudApplication
• 定义熔断方法
  • 局部熔断方法：要和被熔断的控制器方法返回值及参数列表一致
  • 全局熔断方法：返回值类型要和被熔断的控制器方法一致，参数列表必须为空
• 方法上@HystrixCommand：通过属性fallbackMethod="局部熔断方法名"声明被熔断的方法,不声明默认使用全局熔断方法
• 类上@DefaultProperties： 通过属性defalutFallback="全局熔断方法名" 声明全局熔断方法

设置超时

当发生熔断，请求在超过1秒后就会返回错误信息，这是因为Hystix的默认超时时长为1，我们可以通过配置消费端服务application.yml配置文件修改这个值:

hystrix:
  command:
    default:
      execution:
        isolation:
          thread:
            timeoutInMilliseconds: 6000 #设置hys trix的超时时间为6000ms

组合注解

@SpringCloudApplication

package com.xiaoai.service;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.SpringCloudApplication;
import org.springframework.cloud.client.circuitbreaker.EnableCircuitBreaker;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

//@SpringBootApplication  //标注该类为springboot的引导类
//@EnableDiscoveryClient  //启用eureka客户端，@EnableEurekaClient也可以
//@EnableCircuitBreaker   //开启熔断
@SpringCloudApplication   //组合注解 相当于@SpringBootApplication、@EnableDiscoveryClient 、@EnableCircuitBreaker 
public class XiaoaiServiceConsumerApplication {

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

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

hystrix熔断 连请求都不发

熔断机制的原理很简单，像家里的电路熔断器，如果电路发生短路能立刻熔断电路，避免发生灾难。在分布式系统中应用这一模式之后， 服务调用方可以自己进行判断某些服务反应慢或者存在大量超时的情况时，能够主动熔断，防止整个系统被拖垮。
不同于电路熔断只能断不能自动重连，Hystrix 可以实现弹性容错，当情况好转之后，可以自动重连。通过断路的方式，可以将后续请求直接拒绝掉，一段时间之后允许部分请求通过，如果调用成功则回到电路闭合状态，否则继续断开。

熔断状态机3个状态

• Closed:关闭状态，所有请求都正常访问。
• Open:打开状态，所有请求都会被降级。Hystix会对请求情况计数， 当一定时间内失败请求百分比达到阈值，则触发熔断，断路器会完全打开。默认失败比例的阈值是50%，请求次数最少不低于20次。
• Half Open:半开状态，open状态不是永久的，打开后会进入休眠时间(默认是5S)。随后断路器会自动进入半开状态。此时会释放部分请求通过，若这些请求都是健康的，则会完全关闭断路器，否则继续保持打开，再次进行休眠计时

实例

1--消费服务端控制器方法（人为制造异常）

package com.xiaoai.service.controller;

import com.netflix.hystrix.contrib.javanica.annotation.DefaultProperties;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.client.RestTemplate;

@RestController
@RequestMapping("/consumer/user")
@DefaultProperties(defaultFallback = "FalbackMethod") // 定义全局熔断方法
public class UserController {

    //-----------------------------------------------改造消费方，解决地址硬编码问题    启用ribbon负载均衡后
    @Autowired
    private RestTemplate restTemplate;

    @GetMapping
    @ResponseBody
    @HystrixCommand //声明熔断方法。使用全局默认方法，属性fallbackMethod = "queryUserByIdFalback"可以不用了，但注解还是要。
    public String queryUserById(@RequestParam("id")Long id){
        if (id==1){
            throw new RuntimeException();
        }
        return this.restTemplate.getForObject("http://service-provider/user/"+id,String.class);
    }

    //熔断方法
    public String queryUserByIdFalback(Long id){ //熔断方法返回值必须和控制方法返回值一样
        return "queryUserByIdFalback熔断：服务器正忙，请稍后再试!";
    }

    //熔断方法
    public String FalbackMethod(){
       return "全局熔断：服务器正忙，请稍后再试!";
    }
}

即：上述代码默认情况下id=1访问会被熔断，id=2正常，当连续快速访问id=1后，马上访问id=2,此时id=2也会被熔断

默认的熔断触发要求较高，休眠时间窗较短，为了测试方便，我们可以通过在消费服务端application配置文件配置修改熔断策略:

• circuitBreaker.requestVolumeThreshold=10
• circuitBreaker.sleepwindowInMillis econds=10000
• circuitBreaker.errorThresholdPer centage=50

requestVolumeThreshold: 触发熔断的最小请求次数，默认20
errorThresholdPercentage: 触发熔断的失败请求最小占比，默认50%
sleepWindowInMilliseconds: 休眠时长，默认是5000毫秒

Feign远程调用

Feign是Netflix开发的声明式、模板化的HTTP客户端，其灵感来自Retrofit、 JAXRS-2.0以及WebSocket.Feign 可帮助我们更加便捷、优雅地调用HTTP API。
在SpringCloud中，使用Feign非常简单----创建一个接口，并在接口上添加一些注解，代码就完成了。Feign 支持多种注解，例如Feign自带的注解或者JAX-RS注解等。
Spring Cloud对Feign进行了增强，使Feign支持了Spring MVC注解，并整合了Ribbon和Eureka,从而让Feign的使用更加方便。

1--引入启动器（消费服务端）

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

2--覆盖默认配置

也可以不做任何配置

3--引导类启用feign

4--内容已经封装好restTemplate了可以不再引入

package com.xiaoai.service;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.SpringCloudApplication;
import org.springframework.cloud.client.circuitbreaker.EnableCircuitBreaker;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.cloud.openfeign.EnableFeignClients;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

//@SpringBootApplication
//@EnableDiscoveryClient  //启用eureka客户端，@EnableEurekaClient也可以
//@EnableCircuitBreaker   //开启熔断
@SpringCloudApplication   //组合注解 相当于@SpringBootApplication、@EnableDiscoveryClient 、@EnableCircuitBreaker
@EnableFeignClients   //启动feign组件
public class XiaoaiServiceConsumerApplication {

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

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

5--定义一个接口

package com.xiaoai.service.client;

import com.xiaoai.service.pojo.User;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

@FeignClient("service-provider") //声明一个接口是feign接口，参数为提供服务端的id，即注册时自己所取的名称
public interface UserClient {

    @GetMapping("user/{id}")  //和提供服务端控制器里的方法一样 ，路径可以手动补，不建议使用@RequestMapping注解在接口上定义
    public User queryUserById(@PathVariable("id")Long id);
}

6--控制类方法内

package com.xiaoai.service.controller;

import com.netflix.hystrix.contrib.javanica.annotation.DefaultProperties;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import com.xiaoai.service.client.UserClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.client.RestTemplate;

@RestController
@RequestMapping("/consumer/user")
//@DefaultProperties(defaultFallback = "FalbackMethod") // 定义全局熔断方法
public class UserController {

//    //-----------------------------------------------改造消费方，解决地址硬编码问题    启用ribbon负载均衡后
////    @Autowired
////    private RestTemplate restTemplate;
//
//    @GetMapping
//    @ResponseBody
//    @HystrixCommand //声明熔断方法。使用全局默认方法，属性fallbackMethod = "queryUserByIdFalback"可以不用了，但注解还是要。
//    public String queryUserById(@RequestParam("id")Long id){
//        return this.restTemplate.getForObject("http://service-provider/user/"+id,String.class);
//    }
//
//    //熔断方法
//    public String queryUserByIdFalback(Long id){ //熔断方法返回值必须和控制方法返回值一样
//        return "queryUserByIdFalback熔断：服务器正忙，请稍后再试!";
//    }
//
//    //熔断方法
//    public String FalbackMethod(){
//       return "全局熔断：服务器正忙，请稍后再试!";
//    }

    //-----------------------------------------------feign的使用
    @Autowired
    private UserClient userClient;

    @GetMapping
    @ResponseBody
    //@HystrixCommand //声明熔断方法。
    public String queryUserById(@RequestParam("id")Long id){
        return this.userClient.queryUserById(id).toString();
    }

}

其底层是实例化自己集成的restTemlate，通过注解中的服务名称获取实例，通过路径远程调用提供服务端完成

feign自动集成ribbon负载均衡以及hystrix熔断。所以其也可以达到负载均衡的功能以及支持熔断。
feign默认关闭hystrix熔断，如果需要开启需要手动配置。如：在消费服务端的application配置文件中配置开启熔断。

feign:
  hystrix:
    enabled: true #开启Feign的熔断功能

feign自定义熔断方法

1--定义一个类实现feign接口,实现方法，方法即是熔断方法 缺点：当接口有多个方法时需要实现多个方法了

package com.xiaoai.service.client;

import com.xiaoai.service.pojo.User;
import org.springframework.stereotype.Component;

@Component
public class UserClientFallback implements UserClient{

    @Override
    public User queryUserById(Long id) {
        User user = new User();
        user.setUserName("服务器正忙，请稍后访问！");
        return user;
    }

}

2--feign接口注解引入实现类即熔断类

package com.xiaoai.service.client;

import com.xiaoai.service.pojo.User;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

@FeignClient(value = "service-provider",fallback = UserClientFallback.class)
public interface UserClient {

    @GetMapping("user/{id}")  //和提供服务端控制器里的方法一样 ，路径可以手动补，不建议使用@RequestMapping注解在接口上定义
    public User queryUserById(@PathVariable("id")Long id);

}

3--控制器方法一样

package com.xiaoai.service.controller;

import com.xiaoai.service.client.UserClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/consumer/user")
public class UserController {

    //-----------------------------------------------feign的使用

    @Autowired
    private UserClient userClient;

    @GetMapping
    @ResponseBody
    public String queryUserById(@RequestParam("id")Long id){
        return this.userClient.queryUserById(id).toString();
    }

}

关闭提供服务端访问相应url 如下：

小结

• 引入openFeign启动器
• 覆盖默认配置 （feign.hystrix.enable=true可以开启feign的熔断功能）
• 引导类上@EnableFeignClients启用
• 创建一个接口 ，使用注解@FeignClient value属性标识提供服务端名称 fallback="熔断方法.class"
• 在接口中定义一些方法，这些方法的书写方式跟之前服务提供端controller中方法类似。
• 可以创建熔断类实现feign接口，实现对应的方法，这些方法就是熔断方法

Zuul网关

Zuul是Netlix开源的微服务网关，它可以和Eureka、Ribbon、 Hystrix 等组件配合使用。
Zuul的核心是一系列的过滤器，这些过滤器可以完成以下功能。

• 身份认证与安全:识别每个资源的验证要求，并拒绝那些与要求不符的请求。
• 审查与监控:在边缘位置追踪有意义的数据和统计结果，从而带来精确的生产视图。
• 动态路由:动态地将请求路由到不同的后端集群。
• 压力测试:逐渐增加指向集群的流量，以了解性能。
• 负载分配:为每一种负载类型分配对应容量，并弃用超出限定值的请求。
• 静态响应处理:在边缘位置直接建立部分响应，从而避免其转发到内部集群。
• 多区域弹性:跨越AWS Region进行请求路由，旨在实现ELB ( Elastic Load Balancing)使用的多样化，以及让系统的边缘更贴近系统的使用者。

Spring Cloud对Zuul进行了整合与增强。目前，Zuul使用的默认HTTP客户端是Apache HTTP Client,也可以使用RestClient或者okhttp3.0kHttpClient。
如果想要使用RestClient,可以设置ribbon.restclient.enabled=true;想要使用okhttp3.0kHttpClient,可以设置ribbon.okhttp.enabled=true。

路由：分发给不同的微服务（通过服务名）
负载均衡：分发同一个微服务的不同实例，减少单个压力

zuul4种配置方式

配置方式1：快速入门

（只是做了路径分发 通过路径可路由）

1--新建项目，引入依赖

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
</dependency>

2--覆盖默认配置

server:  # 设置应用端口
  port: 10010
spring:  # 设置应用即微服务名称
  application:
    name: xiaoai_zuul

3--引导类启用zuul组件

package com.xiaoai.zuul;

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

@SpringBootApplication
@EnableZuulProxy  //启用zuul组件
public class XiaoaiZuulApplication {

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

4--配置路由

zuul:
  routes:
    service-provider: # 路由名称，可以随便写，习惯上用服务的名称，即之前自己定义的某个服务的名称。
      path: /service-provider/**
      url: http://localhost:8081

--通过zuul访问配置好的服务，可以正常访问

--如未配置消费端路由，zuul访问其url

--配置消费服务端路由后，zuul访问其url

server:
  port: 10010
spring:
  application:
    name: xiaoai_zuul

zuul:
  routes:
    service-provider:** # 路由名称，可以随便写，习惯上用服务的名称，即之前自己定义的某个服务的名称。
      path: /service-provider/**
      url: http://localhost:8081
    service-consumer: # 配置消费端路由
      path: /service-consumer/**
      url: http://localhost:80

eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:10086/eureka

配置方式2：zuul注册到eureka容器

（通过服务id可路由）

1--引入eureka启动器

<!--引入eureka-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

2--把zuul注入eureka容器中,application配置文件配置

spring:
  application:
    name: xiaoai_zuul

eureka:
  client:
    service-url:
      defaultZone: http/localhost:10086/eureka

3--引导类启用eureka

package com.xiaoai.zuul;

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

@SpringBootApplication
@EnableZuulProxy  //启用zuul组件
@EnableDiscoveryClient  //启用eureka客户端
public class XiaoaiZuulApplication {

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

}

4--配置文件可以修改路由，直接配置服务id即可

server:
  port: 10010
spring:
  application:
    name: xiaoai_zuul

zuul:
  routes:
    service-provider: # 路由名称，可以随便写，习惯上用服务的名称，即之前自己定义的某个服务的名称。
      path: /service-provider/**
#      url: http://localhost:8081  # 写死端口无法负载均衡
      serviceId: service-provider  # 把zuul注入到了eureka后，其可以拉取客户端服务，所以可以直接写服务id，即自己定义的名称，通过服务id，zuul也可以实现负载均衡

eureka:
  client:
    service-url:
      defaultZone: http//localhost:10086/eureka

--zuul访问提供服务端url可以正常访问

配置方式3：路径直接配置在服务id后

--application配置文件配置

server:
  port: 10010
spring:
  application:
    name: xiaoai_zuul

zuul:
  routes:
    service-provider: /service-provider/** # 路由名称，可以随便写，习惯上用服务的名称，即之前自己定义的某个服务的名称。
#      path: /service-provider/**
#      url: http://localhost:8081
#      serviceId: service-provider  # 把zuul注入到了eureka后，其可以拉取客户端服务，所以可以直接写服务id，即自己定义的名称，通过服务idzuul也可以实现负载均衡

eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:10086/eureka

--访问

配置方式4： 加入eureka容器后 不配置任何路由 默认访问就是服务名加路径

--配置如下

server:
  port: 10010
spring:
  application:
    name: xiaoai_zuul

eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:10086/eureka

--访问

默认使用第三种配置方式，使用第三种可以修改路径 简化路径前缀 如配置：

server:
  port: 10010
spring:
  application:
    name: xiaoai_zuul

zuul:
  routes:
    service-provider: /user/** # 路由名称，可以随便写，习惯上用服务的名称，即之前自己定义的某个服务的名称。 路径可以使用服务id也可以修改自定义，这里改为user
    service-consumer: /consumer/**

eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:10086/eureka

--访问

在某个微服务中控制器减少一层路径 如提供端服务service-provider的控制类

package com.xiaoai.service.controller;

import com.xiaoai.service.pojo.User;
import com.xiaoai.service.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
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
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping("{id}")
    public User queryUserById(@PathVariable("id")Long id) {
        return this.userService.queryUserById(id);
    }

}

zuul的application配置文件

server:
  port: 10010
spring:
  application:
    name: xiaoai_zuul
zuul:
  routes:
    service-provider: /user/** # 路由名称，可以随便写，习惯上用服务的名称，即之前自己定义的某个服务的名称。
    service-consumer: /consumer/**
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:10086/eureka

--访问

网关前缀

由于项目发布以后无法知道访问路径是否经过网关，可以在application配置文件中配置加入前缀来区分访问是否经过网关。如：

server:
  port: 10010
spring:
  application:
    name: xiaoai_zuul

zuul:
  routes:
    service-provider: /user/** # 路由名称，可以随便写，习惯上用服务的名称，即之前自己定义的某个服务的名称。
    service-consumer: /consumer/**
    prefix: /api # 前缀用于区分访问是否经过网关，这里为api，可以自定义，默认一般使用api
eureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:10086/eureka

--访问

小结

• 引入zuul的启动器
• 配置：
  • zuul.routes.<路由名称>.path=/service-provider/** zuul.routes.<路由名称>.url=http://localhosta:8081
  • zuul.routes.<路由名称>.path=/service-provider/** zuul.routes.<路由名称>.serviceId=service-provider
  • zuul.routes.服务名称=/service-provider/**
  • 不用配置，默认就是服务id+路径
• 引导类注解@EnableZuulProxy 开启zuul
• 引导类@EnableDiscoveryClient 开启eureka客户端

---

zuul过滤器

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

Zuul过滤器需实现接口：IZuulFilter

• 方法shouldFilter() 返回值true执行run方法，false不执行
• 方法run() 过滤器业务逻辑的方法，是否拦截在该方法判断
  默认有一些实现了IZuulFilter接口的类
  

1--定义一个过滤器

package com.xiaoai.zuul.filter;

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

import javax.servlet.http.HttpServletRequest;

@Component
public class LoginFilter extends ZuulFilter{


    /**
     * 过滤器类型选择：pro route post error
     * @return
     */
    @Override
    public String filterType() {
        return "pre";
    }

    /**
     * 执行的顺序，返回值越小，优先级越高
     * @return
     */
    @Override
    public int filterOrder() {
        return 10;
    }

    /**
     * 是否执行该过滤器 即run方法
     * true==执行
     * false==不执行
     * @return
     */
    @Override
    public boolean shouldFilter() {
        return true;
    }

    /**
     * 编写过滤器的业务逻辑
     * @return
     * @throws ZuulException
     */
    @Override
    public Object run() throws ZuulException {
        //初始化context上下文对象，
        RequestContext context = RequestContext.getCurrentContext();
        //获取request对象
        HttpServletRequest request = context.getRequest();
        //获取参数
        String token = (String) request.getParameter("token");
        if (StringUtils.isBlank(token)){
            //拦截 ,这里表示不转发请求
            context.setSendZuulResponse(false);
            //响应状态码，401-身份未认证
            context.setResponseStatusCode(HttpStatus.SC_UNAUTHORIZED);
            //设置响应的提示
            context.setResponseBody("request error!");
        }
        //返回值为null，表示该过滤器什么都不做
        return null;
    }
}

2--访问

springCloud初识小结

• eureka
  • 注册中心
  • 微服务容器
• ribbon
  • 负载均衡组件
  • eureka集成 feign集成 zuul集成
  • @LoadBalanced 开启负载均衡
  • this.restTemplate.getForObject("http://service-provider/user/"+id,User.class) 实现负载均衡
• hystrix
  • 容错组件
  • 降级：检查每次请求，是否请求超时，或连接池已满
    • 引入hystrix启动器
    • 熔断时间，默认1s,
    • 在引导类上添加了一个注解: @EnableCircuitBreaker @SpringCloudApplication
    • 定义熔断方法:局部(要和被熔断的方法返回值和参数列表一致)全局 (返回值类型要被熔断的方法一致， 参数列表必须为空)
      • @HystrixCommand (fallbackMethod="局部熔断方法名"):声明被熔断的方法
      • @DefaultProperties (defaultFallback="全局熔断方法名")
  • 熔断：不再发送请求
    • close:闭合状态，所有请求正常方法
    • open:打开状态，所有请求都无法访问。如果在- -定时间内容，失败的比例不小于508或者次数不少于20次
    • half open: 半开状态，打开状态默认5s休眠期，在休眠期所有请求无法正常访问。过了休眠期会进入半开状态，放部分请求通过
• feign
  • 引入openFeign启动器
  • feign.hystrix.enable=true,开启feign的熔断功能
  • 在引导类上@EnableFeignClients启用feign
  • 创建一一个接口，在接口添加eFeignClient (value="微服务id", fallback=实现类.class)
  • 在接口中定义一些方法，这些方法的书写方式跟之前controller类似
  • 创建了一个熔断类，实现feign接口，实现对应的方法，这些实现方法就是熔断方法
• zuul
  • 网关，路由分发
  • 引入zuul的启动器
  • 配置：4种方式
    • zuul.routes.<路由名称>.path=/service-provider/** zuul.routes.<路由名称>.url=http://localhosta:8081
    • zuul.routes.<路由名称>.path=/service-provider/** zuul.routes.<路由名称>.serviceId=service-provider
    • zuul.routes.服务名称=/service-provider/**
    • 不用配置，默认就是服务id+路径
  • 引导类注解@EnableZuulProxy 开启zuul
  • 引导类@EnableDiscoveryClient 开启eureka客户端
  • 过滤器：
    • 创建一个类继承ZuulFilter基类
    • 重写四个方法
      • filterType： pro route post error
      • filterOrder：返回值越小优先值越高
      • shouldFilter：返回值判断是否执行run方法。true=执行 false=不执行
      • run：具体的拦截逻辑