# springcloud-study

**Repository Path**: dz138598/springcloud-study

## Basic Information

- **Project Name**: springcloud-study
- **Description**: springcloud的学习
- **Primary Language**: Java
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2020-11-28
- **Last Updated**: 2020-12-19

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# 微服务

## 引入

### 微服务架构4个核心问题？

```bash
路由问题：服务很多，客户端该怎么访问 
通信问题：这么多服务，该怎么 通信
高可用问题（注册和发现）：这么多服务，如何 治理
服务降级问题：服务 挂了 怎么办
```

### 解决方案

```bash
1. Spring Cloud Netflix	一站式解决方案
      - api网关：zuul组件
      - Feign:基于HttpClinet,即基于Http通信方式（同步、阻塞）
      - 服务注册：Eureka
      - 熔断机制：Hystrix
2. Apache Dubbo Zookeeper	半自动，需要整合别人的
      - API：没有，找第三方组件或者自己实现
      - Dubbo:
      - Zookeeper
      - 没有，借助Hystrix

3. Spring Cloud Alibaba	一站式解决方案
```

### 面试题

```bash
什么是微服务

微服务之间是如何独立通讯

SpringBoot和SpringCloud 请你谈谈对他们的理解

什么是服务熔断，什么是服务降级

微服务的优缺点分别是什么，说下你在项目开发中遇到的坑

你所知道的微服务技术栈有哪些？请列举一二

erueka和zookeeper都可以提供服务注册和发现的功能，请说说两个的区别
```

## 什么是微服务？

项目中，可以将微服务看做是IDEA中的一个个==微服务工程，或者Moudel==

## 什么是微服务架构？

微服务架构是一种架构模式，

将传统的一站式应用，

根据业务分成一个一个的服务，一个服务就做一件事情，

每个服务运行在其独立的进程内，

彻底地==去耦合==

## 微服务的优缺点分别是什么？

### 优点

- 单一职责原则
- 微服务只是业务逻辑代码，不会和HTML、CSS或者其他界面混合
- 每一个服务都有自己的存储能力，可以有自己的数据库，也可以有统一的数据库

### 缺点

- 开发人员要处理分布式系统的复杂性
- 多服务运维难度，随便服务的增加，运维的压力也在增大

## 你所知道的微服务技术栈有哪些？

| 微服务条目          | 落地技术                      |
| ------------------- | ----------------------------- |
| 服务开发            | springboot、spring、springMVC |
| 服务配置与管理      |                               |
| 服务注册与发现      | Eureka、Consul、Zookeeper     |
| 服务调用            | Rest、RPC、gRPC               |
| 服务熔断器          | Hystrix、Envoy                |
| 负载均衡            | Ribbon、Nginx                 |
| 服务接口调用        | Feign                         |
| 消息队列            | Kafka、RabbitMQ               |
| 服务配置中心管理    | SpringCloudConfig、Chef       |
| 服务路由（API网关） | Zuul                          |
| 服务监控            | Zabbix                        |
| 全链路追踪          |                               |
| 服务部署            |                               |
| 数据流操作开发包    |                               |
| 事件消息总线        |                               |

# SpringCloud

>springcloud是微服务架构的一套技术栈。
>
>springcloud的大多数技术都是基于Netflix公司的技术进行二次研发
>
>1、springcloud的中文社区 springcloud.cn
>
>2、springcloud的中文网 springcloud.cc

## SpringBoot和SpringCloud

### 两者关系

- SpringBoot专注于快速方便的==开发单个个体微服务==

- SpringCloud是关注全局的微服务协调整理治理框架，它将SpringBoot开发的一个个单体微服务整合并管理起来，为各个微服务之间提供：配置管理、服务发现、断路器、路由、微代理、事件总线、全局锁、决策竞选、分布式会话等等集成服务

- Springboot可以离开SpringCloud独立开发项目，但是SpringCloud离不开SpringBoot，属于依赖关系

- 综上所述，**SpringBoot专注于快速、方便的开发单个个体微服务，SpringCloud关注全局的服务治理框架**

### 版本对应

https://spring.io/projects/spring-cloud

![image-20201202104240014](https://djstudent.oss-cn-shenzhen.aliyuncs.com/images/image-20201202104240014.png) 



## 八大技术点

```bash
1、Eurela-服务的注册与发现

2、Robbin-服务之间的负载均衡

3、Feign-服务之间的通讯

4、Hystrix-服务的线程隔离以及断路器

5、Zuul-服务网关

6、Stream-实现MQd的使用

7、Config-动态配置

8、Sleuth-服务追踪
```

------

# 服务的注册与发现 Eureka 

> Eureka就是帮助我们维护所有的服务信息，以便服务之间的相互调用

## 快速开始

https://docs.spring.io/spring-cloud-netflix/docs/2.2.5.RELEASE/reference/html/#spring-cloud-eureka-server

![image-20201202111251838](https://djstudent.oss-cn-shenzhen.aliyuncs.com/images/image-20201202111251838.png) 

1. 创建一个父工程（Springboot）,并且在父工程中指定springcloud的版本,并且==将packing修改为pom==

```xml
<properties>
    <spring.cloud-version>Hoxton.SR8</spring.cloud-version>
</properties>
<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. 创建eureka的==server==，并且导入依赖，在启动类中添加注解，编写yml

> 2.1、导入依赖

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

> 2.2、添加注解

```java
@SpringBootApplication
@EnableEurekaServer
public class EurekaApplication {
    public static void main(String[] args) {
        SpringApplication.run(EurekaApplication.class,args);
    }
}
```

> 2.3、编写配置文件

```yml
server:
  port: 8761 #当前服务的端口号

eureka:
  instance:
    hostname: localhost
  client:
    #当前服务是单机版的
    registerWithEureka: false
    fetchRegistry: false
    serviceUrl:
      defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
```

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

3. 创建eureka的==client==，并且导入依赖，在启动类中添加注解，编写yml

> 3.1、创建一个maven工程02-eureka

> 3.2、导入依赖

```xml
<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>
```

> 3.3、在启动类添加依赖@EnableEurekaClient

> 3.4、编写yml

```yml
spring:
  application:
    name: CUSTOMER
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/
```

4. 测试

> 1、创建一个search模块，并且注册到eureka，编写controller(类似创建eureka的==client==)

> 2、使用到EurekaClient的的对象是获取服务信息

```java
@Autowired
private EurekaClient eurekaClient;
```

> 3、使用RestTemplate正常调用 

```java
@GetMapping("/customer")
public String customer(){
    // 通过eurekaClient获得SEARCH服务的信息
    InstanceInfo search = eurekaClient.getNextServerFromEureka("SEARCH", false);
    // 获取到访问的地址 http://192.168.203.1:8081/
    String url = search.getHomePageUrl();
    System.out.println(url);
    //通过restTemplate访问
    String res = restTemplate.getForObject(url + "/find", String.class);
    //返回
    return res;
}
//访问: localhost:8080/customer
```

## 安全性

> 导入依赖（在server中）

```xml
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>
```

> 编写配置类

```java
@EnableWebSecurity
class WebSecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().ignoringAntMatchers("/eureka/**");
        super.configure(http);
    }
}
```

>  编写配置文件

```yml
# 指定用户名和密码
spring:
  security:
    user:
      name: root
      password: 123456
```

> 其他服务想注册到Eureka，需要添加用户名和密码

```yml
eureka:
  client:
    service-url:
      defaultZone: http://root:123456@localhost:8761/eureka/
```

## 高可用

如果程序正在运行，Eureka突然宕机了

1、如果调用方访问过一次被调用方，Eureka的宕机不会影响到功能

2、如果调用方**没有**访问过被调用方，Eureka的宕机就会造成当前功能不可用

测试方法：

将三个服务（01-erueka、02-erueka、03-search）启动，成功访问http://localhost:8080/customer

将01-eureka关掉，再次运行发现，仍然可以**成功访问**http://localhost:8080/customer

重启01-erueka、02-erueka服务，保证两个服务在erueka中注册，然后，关闭01-eureka，再次访问http://localhost:8080/customer，失败

### 搭建Eureka高可用

#### 准备多态Eureka

采用复制文件的方式，删除iml和target文件，并且修改pom.xml的项目名称，再给父工程添加一个moudle

#### 让服务注册到多台Eureka

```xml
eureka:
  client:
    service-url:
      defaultZone: http://root:123456@localhost:8761/eureka/,http://root:123456@localhost:8762/eureka/
```

#### 让多台Eureka之间相互通讯

在两个eureka中分别需要配置

```
server:
  port: 8762 #当前服务的端口号
spring:
  security:
    user:
      name: root
      password: 123456
eureka:
  instance:
    hostname: localhost
  client:
    registerWithEureka: true  #注册到Eureka
    fetchRegistry: true       #从Eureka拉取信息
    serviceUrl:
      defaultZone: http://root:123456@localhost:8761/eureka/
```

## 基于AP原则

CAP定理

C——一致性

A——可用性

P——分区容错性

这三个特性在分布式环境下，只能满足2个。而且==分区的容错性==在分布式环境下，是必须要满足的，只能才AC之间权衡

如果选择CP,保证了一致性，可能会造成你系统在一定时间内是不可用的，如果你同步数据的时间比较长，造成的损失就大。

而Eureka选择的就是AP的一个效果，高可用的集群，Eureka是无中心，Eureka即便宕机，也不会影响到系统的使用，不需要重新推举一个master，但是会导致一段时间内的数据是不一致的。