Springcloud
网易云课堂视频
https://study.163.com/course/courseLearn.htm?courseId=1209506861#/learn/video?lessonId=1279768113&courseId=1209506861

Spring Cloud Netflix组件
组件名称 作用
Eureka 服务注册中心
Ribbon 客户端负载均衡
Feign 声明式服务调用
Hystrix 客户端容错保护
Zuul API服务网关

Spring Cloud Alibaba组件
组件名称 作用
Nacos 服务注册中心
Sentinel 客户端容错保护

Spring Cloud 原始及其他组件
组件 作用
Consul 服务注册中心
Config 分布式配置中心
Gateway API服务网关
Sleuth/Zipkin 分布式链路追踪

负载均衡
服务端：Nginx，F5
客户端：ribbon

Ribbon本地负载均衡与Nginx服务器端负载均衡区别
Ribbon本地负载均衡，原理：在调用接口的时候，会在eureka注册中心上获取注册信息服务列表，获取到之后，缓存在jvm本地，让你使用本地实现rpc远程调用技术进行调用。即是在客户端实现负载均衡。
Nginx是服务器负载均衡，客户端所有请求都会交给Nginx、让后在由Nginx实现转发请求。
即负载均衡是由服务器端实现

应用场景：
Ribbon 本地负载均衡适合在微服务rpc远程调用，比如：dubbo，springcloud
Nginx 服务器负载均衡适合于针对服务器端 比如：Tomcat，jetty
Eureka
服务注册中心
https://www.cnblogs.com/knowledgesea/p/11208000.html
Eureka 是 Netflix 开发的，一个基于 REST 服务的，服务注册与发现的组件
它主要包括两个组件：Eureka Server 和 Eureka Client
* Eureka Client：一个Java客户端，用于简化与 Eureka Server 的交互（通常就是微服务中的客户端和服务端）
* Eureka Server：提供服务注册和发现的能力（通常就是微服务中的注册中心）
例子
1、创建父工程，springboot的方法，在创建的时候，选中springcloud选项（避免自己添加的时候出现版本springcloud和springboot版本对不上）

<?xml version="1.0" encoding="UTF-8"?>

org.springframework.boot
spring-boot-starter-parent
2.2.2.RELEASE

com.sun
spring-cloud-my
pom
1.0-SNAPSHOT
4.0.0

eureka-serviceeureka-clientorg.springframework.cloudspring-cloud-starterorg.springframework.cloudspring-cloud-dependencies${spring-cloud.version}pomimportorg.springframework.bootspring-boot-maven-plugin

2、创建eureka_serice模块，springboot方式
在pom文件添加依赖

<?xml version="1.0" encoding="UTF-8"?>

spring-cloud-my
com.sun
1.0-SNAPSHOT

4.0.0

<artifactId>eureka-service</artifactId><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter</artifactId></dependency><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-netflix-eureka-server</artifactId></dependency>
</dependencies>
<build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin></plugins>
</build>

在application配置文件添加配置
#----配置服务名称及端口----
spring.application.name=eureka-server
server.port=1111
#----服务注册中心配置----
#服务注册中心实例的主机名
eureka.instance.hostname=localhost
#是否向服务注册中心注册自己,默认为true
eureka.client.register-with-eureka=false
#由于注册中心的职责是维护服务实例,它并不需要去检索服务,所以也设置为false
eureka.client.fetch-registry=false
#服务注册中心的配置内容，指定服务注册中心的位置
eureka.client.serviceUrl.defaultZone=http://${eureka.instance.hostname}:${server.port}/eureka/

在启动类添加注解
@EnableEurekaServer

3、创建eureka_client模块，springboot方式
在pom文件添加依赖

<?xml version="1.0" encoding="UTF-8"?>

spring-cloud-my
com.sun
1.0-SNAPSHOT

4.0.0

<artifactId>eureka-client</artifactId>
<dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-netflix-eureka-client</artifactId></dependency>
</dependencies>

在application配置文件添加配置
server.port=9090
eureka.client.service-url.defaultZone=http://localhost:1111/eureka/
eureka.client.registry-fetch-interval-seconds=5
eureka.instance.instance-id=eureka-client
eureka.instance.prefer-ip-address=true
spring.application.name=eureka-client

在启动类添加注解
@SpringBootApplication
@EnableEurekaClient
public class EurekaClientApplication {
public static void main( String[] args ) {
SpringApplication.run(EurekaClientApplication.class, args);
}
}

服务调用
RestTemplate方式（有错没有解决）
order_service 调用 product_service（在order_service的service层调用product_service的controller层的方法，通过http请求的方式调用：就像在浏览器中输入product_service的URL）
（order_service做改变，product_service不做任何改变）

在RestTemplate中，如果返回值是一个集合，我们得先用一个数组接收，然后再转为集合（或许也有其他办法，小伙伴们有更好的建议可以提）。
pom文件添加依赖

org.springframework.cloudspring-cloud-starter-netflix-ribbon启动类中添加如下代码 //RestTemplate :含义：http请求工具 + 负载均衡 @Bean @LoadBalanced public RestTemplate getRestTemplate(){return new RestTemplate(); } Service层代码如下；application配置文件不做改变 @Service public class BookServiceImpl {@Autowiredprivate RestTemplate restTemplate;

public boolean add(){//调用eureka_server服务获取其他信息（本应该订单服务调用商品服务的。我懒，直接用这个了）Object obj = restTemplate.getForObject("http://eureka_client/products", Object.class);System.out.println(obj);return false;
}

}

Feign方式
（order_service做改变，product_service不做任何改变）
GitHub配置
https://github.com/OpenFeign/feign

网易云课堂视频
https://study.163.com/course/courseLearn.htm?courseId=1209506861#/learn/video?lessonId=1279768113&courseId=1209506861
做法步骤

org.springframework.cloudspring-cloud-starter-openfeign启动类添加注解

@SpringBootApplication
@EnableEurekaClient
@EnableFeignClients
public class OrderServiceApplication
在order-service中的service层添加

@FeignClient(value = “EUREKA-CLIENT”)
public interface FeignService {
@RequestMapping(value = “/products”,method = RequestMethod.GET)
@ResponseBody
public String findAll();
//注意：这个类中的方法必须与要调用的服务的（EUREKA-CLIENT）方法一模一样（注解也要）
}

Feign内置的ribbon负载均衡
Feign中本身已经集成了ribbon依赖和自动配置，因此我们不需要额外引入依赖，也不需要再注册RestTemplate对象，另外，我们可以像上节课中讲到那样去配置ribbon，可以通过ribbon.xx来进行全局配置，而可以通过服务名.ribbon.xx来配置指定服务配置。
启动两个product-service，重新测试可以发现ribbon的轮询策略进行负载均衡

可能出现的问题
java.lang.IllegalStateException: Service id not legal hostname (user_manager)
application.yml文件中的
spring:
application:
name: user_manager
解决
不能使用下划线,name修改成user-manager启动后解决
feign.FeignException$NotFound: status 404 reading FeignService#findAll()

1.错误原因（可能导致报错的原因）

传递的参数可能为空值
解决办法：@RequestParam(value = “xxx”,required = false) String xxx
1
参数长度过长造成的
解决办法1：将参数封装成对象，使用 @RequestBody注解 在feign消费服务上
1
解决办法2：修改内嵌tomcat的参数，内嵌tomcat对参数的默认限制是8K
1
server.max-http-header-size=20480

status 404 reading xxService#xxmethod(String):
1.错误原因（可能是访问路径错误）

参数没有使用注解指定
解决办法：@RequestParam(value = “xxx”,required = false) String xxx
1
方法没有指定请求方式
解决办法: @RequestMapping(value="/…,method=RequestMethos.GET)
1
ps:只能使用@RequstMapping注解，不能使用GetMapping注解（坑）

Ribbon
客户端负载均衡
负载均衡一般有3种方式
1、轮询
2、权重
3、Hash
Feign
声明式服务调用
Feign默认集成了ribbon的负载均衡

Hystrix
Hystrix中的服务降级和熔断
服务降级 熔断
关闭不太重要的服务，多开启重要的服务 每次出现错误（网络延时、调用出错），返回预先定义好的内容

Feign方式
都是在order-service操作，不用操作product-service
1、引入依赖（Feign内部已经集成了hystrix）
2、在feign配置中开启hystrix
#feign开启对hystrix支持
feign.hystrix.enabled=true
hystrix.command.default.execution.isolation.thread.timeoutInMilliseconds=1
#默认的连接超时时间1秒，若1秒没有返回数据，自动的粗发降级逻辑

3、自定义一个接口的实现类，这个实现类就是熔断出发的降级逻辑
@Component
public class ProductClientFeignCallBack implements ProductClientFeign {
@RequestMapping("/fallback")
|–注意：此路经要和ProductClientFeign 中对应方法路径不一致，否则报错
public String list(){
//在此处实现降级逻辑
return “熔断降级的实现类”;
}
}

4、修改feignClient接口添加降级方法的支持
/**

• 声明需要调用的微服务名称
• @FeignClient

•  name：服务提供者的名称
  

•  fallback：配置熔断发送降级方法
  

•          实现类
  

*/
@FeignClient(name = “product-service”, fallback = ProductClientFeignCallBack.class)
@RequestMapping("/products")
public interface ProductClientFeign {
@RequestMapping(value = “/list”)
@ResponseBody
public String list();
}

对应3,4步的另一写法
3，
@FeignClient(name = “product-service”, fallback = ProductClientFeignCallBack.class)
//@RequestMapping("/products")
不要RequestMapping在类上面，4步就不要RequestMapping也不会报错
public interface ProductClientFeign {
@RequestMapping(value = “/products/list”)
@ResponseBody
public String list();
}

4，
@Component
public class ProductClientFeignCallBack implements ProductClientFeign {
// @RequestMapping("/fallback")
public String list(){
//在此处实现降级逻辑
return “熔断降级的实现类”;
}
}

3,4不对应错误
org.springframework.beans.factory.BeanCreationException: Error creating bean with name ‘requestMappingHandlerMapping’ defined in class path resource [org/springframework/boot/autoconfigure/web/servlet/WebMvcAutoConfiguration$EnableWebMvcConfiguration.class]: Invocation of init method failed; nested exception is java.lang.IllegalStateException: Ambiguous mapping. Cannot map ‘com.sun.order.feign.ProductClientFeign’ method
com.sun.order.feign.ProductClientFeign#list()
to { /products/list}: There is already ‘productClientFeignCallBack’ bean method
com.sun.order.feign.ProductClientFeignCallBack#list() mapped.

Hystrix监控
导入依赖

org.springframework.bootspring-boot-starter-actuatororg.springframework.cloudspring-cloud-starter-netflix-hystrixorg.springframework.cloudspring-cloud-starter-netflix-hystrix-dashboard

在启动类添加注解
//激活hystrix
@EnableCircuitBreaker

配置yml
#引入hystrix中的监控信息
management.endpoints.web.exposure.include=*

访问对应的路径
http://localhost:9091/actuator/hystrix.stream

开启监控平台
导入依赖

org.springframework.bootspring-boot-starter-actuatororg.springframework.cloudspring-cloud-starter-netflix-hystrixorg.springframework.cloudspring-cloud-starter-netflix-hystrix-dashboard

在启动类添加注解
//激活hystrix的web监控平台
@EnableHystrixDashboard

访问URL路径
http://localhost:9091/hystrix
在跳出的页面中输入
http://localhost:9091/actuator/hystrix.stream
点击英文监控按钮

聚会监控Turbine
创建工程
添加依赖pom

org.springframework.cloud
spring-cloud-starter-netflix-hystrix


org.springframework.cloud
spring-cloud-starter-netflix-hystrix-dashboard


org.springframework.cloud
spring-cloud-starter-netflix-turbine

配置yml
#----配置服务名称及端口----
spring.application.name=hystrix-turbine-server
server.port=8031
#----服务注册中心配置----
#服务注册中心实例的主机名
eureka.client.serviceUrl.defaultZone=http://localhost:1111/eureka/
eureka.instance.prefer-ip-address=true
#要监控的微服务列表，多个用,分割
turbine.app-config=product-service
turbine.cluster-name-expression=default

启动类配置
@SpringBootApplication
//配置trubine
@EnableTurbine
//激活hystrix的web监控平台
@EnableHystrixDashboard
public class TurbineServerApplication {
public static void main( String[] args ) {
SpringApplication.run(TurbineServerApplication.class, args);
}
}

客户端容错保护
服务降级
服务熔断
依赖隔离
请求缓存
请求合并

常用配置
父工程

<?xml version="1.0" encoding="UTF-8"?>

4.0.0

com.sun.springcloud
springcloud-demo
1.0-SNAPSHOT
pom

org.springframework.bootspring-boot-starter-parent2.1.3.RELEASEorg.springframework.bootspring-boot-starter-testtestorg.springframework.cloudspring-cloud-build-dependencies${spring-cloud.version}pomimport

Zuul
搭建zuul网关服务器
1.创建工程导入坐标

<?xml version="1.0" encoding="UTF-8"?>

spring-cloud-my
com.sun
1.0-SNAPSHOT

4.0.0

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

2.配置启动类，开启网关服务器功能
@SpringBootApplication
@EnableZuulProxy
public class ZuulServiceApplication {
public static void main( String[] args ) {
SpringApplication.run(ZuulServiceApplication.class, args);
}
}

3.配置文件
server.port=9090
spring.application.name=api-zuul-service

到这来还不能使用
路由
基本路由配置
#路由配置
zuul.routes.product-service.path=/product-service/**
#上面一行 |–路由id，随便写
#上面一行 |–映射路径 localhost:8080/product-service/xxxx
#下面一行 |–这个地址对应上面的path中的product-service服务中的路径
zuul.routes.product-service.url=http://127.0.0.1:9092
#http://localhost:8080/product-service/products/list 访问路径例子

面向服务的路由
1.添加eureka的依赖

<?xml version="1.0" encoding="UTF-8"?>

spring-cloud-my
com.sun
1.0-SNAPSHOT

4.0.0

<artifactId>api-zuul-service</artifactId><dependencies><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-netflix-zuul</artifactId></dependency><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-netflix-eureka-client</artifactId></dependency>
</dependencies>

2.开启eureka的客户端服务发现
@SpringBootApplication
@EnableZuulProxy//开启网关
@EnableDiscoveryClient//Eureka服务发现
public class ZuulServiceApplication {
public static void main( String[] args ) {
SpringApplication.run(ZuulServiceApplication.class, args);
}
}

3.在zuul网关服务中配置eureka的注册中心相关信息
#端口
server.port=8080
#服务名称
spring.application.name=api-zuul-service
#路由配置
zuul.routes.product-service.path=/product-service/**
#上面一行 |–路由id，随便写
#上面一行 |–映射路径 localhost:8080/product-service/xxxx
#下面一行 |–这个地址对应上面的path中的product-service服务中的路径
#zuul.routes.product-service.url=http://127.0.0.1:9092
#下面一行 |–配置转发的微服务的服务名称
zuul.routes.product-service.service-id=product-service
#http://localhost:8080/product-service/products/list 访问路径例子

#eureka配置
eureka.client.service-url.defaultZone=http://localhost:1111/eureka/
eureka.instance.prefer-ip-address=true

4.修改路由中的映射配置
#端口
server.port=8080
#服务名称
spring.application.name=api-zuul-service
#路由配置
zuul.routes.product-service.path=/product-service/**
#上面一行 |–路由id，随便写
#上面一行 |–映射路径 localhost:8080/product-service/xxxx
#下面一行 |–这个地址对应上面的path中的product-service服务中的路径
#zuul.routes.product-service.url=http://127.0.0.1:9092
#下面一行 |–配置转发的微服务的服务名称
zuul.routes.product-service.service-id=product-service
#http://localhost:8080/product-service/products/list 访问路径例子

#eureka配置
eureka.client.service-url.defaultZone=http://localhost:1111/eureka/
eureka.instance.prefer-ip-address=true

简单路由的配置
就是什么也不要配置
#端口
server.port=8080
#服务名称
spring.application.name=api-zuul-service

#路由配置
#zuul.routes.product-service.path=/service-product/**
#上面一行 |–路由id，随便写
#上面一行 |–映射路径 localhost:8080/product-service/xxxx
#下面一行 |–这个地址对应上面的path中的product-service服务中的路径
#zuul.routes.product-service.url=http://127.0.0.1:9092

#下面一行 |–配置转发的微服务的服务名称
#zuul.routes.product-service.service-id=service-product

#下面一行 如果路由id和对应的微服务的service-id一致的话
#zuul.routes.product-service.product-service=service-product

#zuul中的默认路由配置
#如果当前的微服务名称product-service， 默认的请求映射路径 /product-service/**

/product-service/

#http://localhost:8080/product-service/products/list 访问路径例子

#eureka配置
eureka.client.service-url.defaultZone=http://localhost:1111/eureka/
eureka.instance.prefer-ip-address=true

ZuulFilter过滤器
过滤器是过滤请求的，zuul过滤器有四种过滤类型
1.Pre 路由请求前执行
2.Route 处理实际的路由请求
3.Post 在请求路由完成后执行
4.Error 处理请求期间出现错误执行

编写过虑类
package com.sun.zuul.filter;

import com.netflix.zuul.ZuulFilter;
import com.netflix.zuul.context.RequestContext;
import com.netflix.zuul.exception.ZuulException;

import javax.servlet.http.HttpServletRequest;

/**

• 简单过滤器
  /
  public class SimpleFilter extends ZuulFilter {
  /*

  • 前置过滤
    */
    @Override
    public String filterType() {
    return “pre”;
    }

  /**
  *过滤执行顺序
  */
  @Override
  public int filterOrder() {
  return 0;
  }

  /**
  *是否执行过滤
  */
  @Override
  public boolean shouldFilter() {
  return true;
  }

  /**
  *包含过滤功能
  */
  @Override
  public Object run() throws ZuulException {
  // 获取当前上下文，存放请求和状态信息
  RequestContext ctx = RequestContext.getCurrentContext();
  HttpServletRequest request = ctx.getRequest();
  String method = request.getMethod();
  String url = request.getRequestURL().toString();
  System.out.printf("%s request to %s\r\n", method, url);

   return null;
  

  }
  }

在启动类中注册到容器
@SpringBootApplication
@EnableZuulProxy//开启网关
@EnableDiscoveryClient//Eureka服务发现
public class ZuulServiceApplication {

/*** 引入zuul过滤器到容器中*/
@Bean
public SimpleFilter simpleFilter(){return new SimpleFilter();
}public static void main( String[] args ) {SpringApplication.run(ZuulServiceApplication.class, args);
}

}

OK标志

Springcloud集成Redis
创建项目
编写pom

<?xml version="1.0" encoding="UTF-8"?>

spring-cloud-my
com.sun
1.0-SNAPSHOT

4.0.0

<artifactId>redis-service</artifactId><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId></dependency>
</dependencies><build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin></plugins>
</build>

启动Redis服务器
创建Receiver类
/**

• 消息接收者
  */
  public class Receiver {
  public void receiverMessage(String msg){
  System.out.printf(“received : %s \r\n”, msg);
  }
  }

完成Application启动类
package com.sun.redis;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.listener.PatternTopic;
import org.springframework.data.redis.listener.RedisMessageListenerContainer;
import org.springframework.data.redis.listener.adapter.MessageListenerAdapter;

/**

• Created by ASUS on 2020/1/6.
  */
  @SpringBootApplication
  public class RedisServiceApplication {
  @Bean
  Receiver receiver(){
  return new Receiver();
  }

  @Bean
  MessageListenerAdapter listenerAdapter(Receiver receiver){
  return new MessageListenerAdapter(receiver, “receiverMessage”);
  }
  @Bean
  RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory, MessageListenerAdapter listenerAdapter){
  RedisMessageListenerContainer container = new RedisMessageListenerContainer();
  container.setConnectionFactory(connectionFactory);
  container.addMessageListener(listenerAdapter, new PatternTopic(“chat”));
  return container;
  }

  @Bean
  StringRedisTemplate template(RedisConnectionFactory connectionFactory){
  return new StringRedisTemplate(connectionFactory);
  }

  public static void main( String[] args ) {
  ConfigurableApplicationContext ctx = SpringApplication.run(RedisServiceApplication.class, args);
  StringRedisTemplate template = ctx.getBean(StringRedisTemplate.class);
  template.convertAndSend(“chat”, “Hello from Redis!”);
  System.exit(0);
  }
  }

配置配置文件
指定远程Redis服务器连接信息，细节信息定义在org.springframework.boot.autoconfigure.data.redis.RedisProperties中。
spring.redis.host=127.0.0.1
spring.redis.port=6379

分布式事务
CAP理论
CAP理论是：分布式系统在设计时只能在一致性(Consistency)、可用性(Availability)、分区容忍性(Partition Tolerance)中满足两种，无法兼顾三种。



BASE理论


解决方案
XA Transactions
TCC事务机制
MQ事务
Saga管理事务

2PC（两阶段提交）
解决方案：springboot + Atomikos or

TCC事务补偿
消息队列实现最终一致性