SpringCloud：SpringCloud初级，单体、RPC、SOA、微服务介绍，SpringCloud入门与Dubbo区别，Eureka服务注册中心，高可用Euraka架构原理，分布式CAP原理

最新推荐文章于 2024-04-30 11:22:59 发布

DougLeaMrConcurrency

最新推荐文章于 2024-04-30 11:22:59 发布

阅读量498

点赞数

分类专栏： SpringCloud 文章标签： java 微服务 SpringCloud Eureka Spring

本文链接：https://blog.csdn.net/qq_43265673/article/details/106252050

版权

SpringCloud 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

第一章微服务架构介绍
（Spring Cloud初级）

一、单体架构

单体架构也称之为单体系统或者是单体应用。就是一种把系统中所有的功能、模块耦合在一个应用中的架构方式。
1   单体架构特点
1.1   打包成一个独立的单元(导成一个唯一的jar包或者是war包)
1.2   会一个进程的方式来运行

2   单体架构的优点、缺点
2.1   优点
2.1.1   项目易于管理
2.1.2   部署简单
2.2   缺点
2.2.1   测试成本高
2.2.2   可伸缩性差
2.2.3   可靠性差
2.2.4   迭代困难
2.2.5   跨语言程度差
2.2.6   团队协作难

二、微服务架构

1   什么是微服务
微服务是一种架构风格。一个大型的复杂软件应用，由一个或多个微服务组成。系统中的各个微服务可被独立部署，各个微服务之间是松耦合的。每个微服务仅关注于完成一件任务并很好的完成该任务。
2   架构风格
项目的一种设计模式。
2.1   常见的架构风格
2.1.1   客户端与服务端的
2.1.2   基于组件模型的架构（EJB）
2.1.3   分层架构(MVC)
2.1.4   面向服务架构(SOA)
3   微服务特点：
3.1   系统是由多个服务构成
3.2   每个服务可以单独独立部署
3.3   每个服务之间是松耦合的。服务内部是高内聚的，外部是低耦合的。高内聚就是每个服务只关注完成一个功能。
4   微服务的优点、缺点
4.1   优点
4.1.1   测试容易
4.1.2   可伸缩性强
4.1.3   可靠性强
4.1.4   跨语言程度会更加灵活
4.1.5   团队协作容易
4.1.6   系统迭代容易
4.2   缺点
4.2.1   运维成本过高，部署数量较多
4.2.2   接口兼容多版本
4.2.3   分布式系统的复杂性
4.2.4   分布式事务

三、 MVC、RPC、SOA、微服务架构之间的区别

1   MVC架构
其实MVC架构就是一个单体架构。
代表技术：Struts2、SpringMVC、Spring、Mybatis等等。
2   RPC架构
RPC(Remote Procedure Call)：远程过程调用。他一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的协议。
代表技术：Thrift、Hessian等等
3   SOA架构
SOA(Service oriented Architecture):面向服务架构
ESB(Enterparise Servce Bus):企业服务总线，服务中介。主要是提供了一个服务于服务之间的交互。
ESB包含的功能如：负载均衡，流量控制，加密处理，服务的监控，异常处理，监控告急等等。
代表技术：Mule、WSO2
4   微服务架构
微服务就是一个轻量级的服务治理方案。
代表技术：SpringCloud、dubbo等等

四、如何设计微服务以及设计原则

1)   AKF拆分原则
2)   前后端分离原则
3)   无状态服务
4)   RestFul的通信风格
1   AKF拆分原则
业界对于可扩展的系统架构设计有一个朴素的理念,就是：
通过加机器就可以解决容量和可用性问题。(如果一台不行那就两台)。
我是个段子：（世界上没有什么事是一顿烧烤不能解决的。如果有，那就两顿。）
这一理念在“云计算”概念疯狂流行的今天，得到了广泛的认可！对于一个规模迅速增长的系统而言，容量和性能问题当然是首当其冲的。但是随着时间的向前，系统规模的增长，除了面对性能与容量的问题外，还需要面对功能与模块数量上的增长带来的系统复杂性问题以及业务的变化带来的提供差异化服务问题。而许多系统，在架构设计时并未充分考虑到这些问题，导致系统的重构成为常态，从而影响业务交付能力，还浪费人力财力！对此，《可扩展的艺术》一书提出了一个更加系统的可扩展模型—— AKF可扩展立方（Scalability Cube）。这个立方体中沿着三个坐标轴设置分别为：X、Y、Z。

Y轴(功能) —— 关注应用中功能划分，基于不同的业务拆分
X轴(水平扩展) —— 关注水平扩展，也就是”加机器解决问题”
Z轴(数据分区) —— 关注服务和数据的优先级划分，如按地域划分
1.1   Y轴(功能)
Y轴扩展会将庞大的整体应用拆分为多个服务。每个服务实现一组相关的功能，如订单管理、客户管理等。在工程上常见的方案是服务化架构(SOA) 。比如对于一个电子商务平台，我们可以拆分成不同的服务，组成下面这样的架构：

但通过观察上图容易发现，当服务数量增多时，服务调用关系变得复杂。为系统添加一个新功能，要调用的服务数也变得不可控，由此引发了服务管理上的混乱。所以，一般情况下，需要采用服务注册的机制形成服务网关来进行服务治理。系统的架构将变成下图所示：

1.2   X轴(水平扩展)
X轴扩展与我们前面朴素理念是一致的，通过绝对平等地复制服务与数据，以解决容量和可用性的问题。其实就是将微服务运行多个实例，做集群加负载均衡的模式。
为了提升单个服务的可用性和容量，对每一个服务进行X轴扩展划分。

1.3   Z轴(数据分区)
Z轴扩展通常是指基于请求者或用户独特的需求，进行系统划分，并使得划分出来的子系统是相互隔离但又是完整的。以生产汽车的工厂来举例：福特公司为了发展在中国的业务，或者利用中国的廉价劳动力，在中国建立一个完整的子工厂，与美国工厂一样，负责完整的汽车生产。这就是一种Z轴扩展。
1.3.1   工程领域常见的Z轴扩展有以下两种方案：
1.3.1.1   单元化架构
在分布式服务设计领域，一个单元（Cell）就是满足某个分区所有业务操作的自包含闭环。如上面我们说到的Y轴扩展的SOA架构，客户端对服务端节点的选择一般是随机的，但是，如果在此加上Z轴扩展，那服务节点的选择将不再是随机的了，而是每个单元自成一体。如下图：

1.3.1.2   数据分区
为了性能数据安全上的考虑，我们将一个完整的数据集按一定的维度划分出不同的子集。一个分区（Shard），就是是整体数据集的一个子集。比如用尾号来划分用户，那同样尾号的那部分用户就可以认为是一个分区。数据分区为一般包括以下几种数据划分的方式：
数据类型（如：业务类型）
数据范围（如：时间段，用户ID）
数据热度（如：用户活跃度，商品热度）
按读写分（如：商品描述，商品库存）
2   前后端分离原则

何为前后端分离？前后端本来不就分离么？这要从尴尬的jsp讲起。分工精细化从来都是蛋糕做大的原则，多个领域工程师最好在不需要接触其他领域知识的情况下合作，才可能使效率越来越高，维护也会变得简单。jsp的模板技术融合了html和java代码，使得传统MVC开发中的前后端在这里如胶似漆，前端做好页面，后端转成模板，发现问题再找前端，前端又看不懂java代码......前后端分离的目的就是将这尴尬局面打破。
前后端分离原则，简单来讲就是前端和后端的代码分离，我们推荐的模式是最好采用物理分离的方式部署，进一步促使更彻底的分离。如果继续直接使用服务端模板技术，如：jsp，把java、js、html、css都堆到一个页面里，稍微复杂一点的页面就无法维护了。

这种分离方式有几个好处：
1)   前后端技术分离，可以由各自的专家来对各自的领域进行优化，这样前段的用户体验优化效果更好。
2)   分离模式下，前后端交互界面更清晰，就剩下了接口模型，后端的接口简洁明了，更容易维护。
3)   前端多渠道集成场景更容易实现，后端服务无需变更，采用统一的数据和模型，可以支持多个前端：例如：微信h5前端、PC前端、安卓前端、IOS前端。
3   无状态服务

对于无状态服务，首先说一下什么是状态：如果一个数据需要被多个服务共享，才能完成一笔交易，那么这个数据被称为状态。进而依赖这个“状态”数据的服务被称为有状态服务，反之称为无状态服务。
那么这个无状态服务原则并不是说在微服务架构里就不允许存在状态，表达的真实意思是要把有状态的业务服务改变为无状态的计算类服务，那么状态数据也就相应的迁移到对应的“有状态数据服务”中。
场景说明：例如我们以前在本地内存中建立的数据缓存、Session缓存，到现在的微服务架构中就应该把这些数据迁移到分布式缓存中存储，让业务服务变成一个无状态的计算节点。迁移后，就可以做到按需动态伸缩，微服务应用在运行时动态增删节点，就不再需要考虑缓存数据如何同步的问题。
4   RestFul的通讯风格

作为一个原则来讲本来应该是个“无状态通信原则”，在这里我们直接推荐一个实践优选的Restful 通信风格，因为他有很多好处：
1) 无状态协议HTTP，具备先天优势，扩展能力很强。例如需要安全加密，有现成的成熟方案HTTPS即可。
2) JSON 报文序列化，轻量简单，人与机器均可读，学习成本低，搜索引擎友好。
3) 语言无关，各大热门语言都提供成熟的Restful API框架，相对其他的一些RPC框架生态更完善。

第二章SpringCloud入门
（Spring Cloud初级）

一、什么是SpringCloud

什么是SpringCloud：是一个服务治理平台，提供了一些服务框架。包含了：服务注册与发现、配置中心、消息中心、负载均衡、数据监控等等。
1   概念定义
Spring Cloud是一个微服务框架，相比Dubbo等RPC框架, Spring Cloud提供的全套的分布式系统解决方案。
Spring Cloud对微服务基础框架Netflix的多个开源组件进行了封装，同时又实现了和云端平台以及和Spring Boot开发框架的集成。
Spring Cloud为微服务架构开发涉及的配置管理，服务治理，熔断机制，智能路由，微代理，控制总线，一次性token，全局一致性锁，leader选举，分布式session，集群状态管理等操作提供了一种简单的开发方式。
Spring Cloud 为开发者提供了快速构建分布式系统的工具，开发者可以快速的启动服务或构建应用、同时能够快速和云平台资源进行对接。
2   Spring Cloud的项目的位置
Sping Cloud是Spring的一个顶级项目与Spring Boot、Spring Data位于同一位置。
3   Spring Cloud的子项目
Spring Cloud包含了很多子项目，如：

3.1   Spring Cloud Config：配置管理工具，支持使用Git存储配置内容，支持应用配置的外部化存储，支持客户端配置信息刷新、加解密配置内容等
3.2   Spring Cloud Bus：事件、消息总线，用于在集群（例如，配置变化事件）中传播状态变化，可与Spring Cloud Config联合实现热部署。
3.3   Spring Cloud Netflix：针对多种Netflix组件提供的开发工具包，其中包括Eureka、Hystrix、Zuul、Archaius等。
3.3.1   Netflix Eureka：一个基于rest服务的服务治理组件，包括服务注册中心、服务注册与服务发现机制的实现，实现了云端负载均衡和中间层服务器的故障转移。
3.3.2   Netflix Hystrix：容错管理工具，实现断路器模式，通过控制服务的节点,从而对延迟和故障提供更强大的容错能力。
3.3.3   Netflix Ribbon：客户端负载均衡的服务调用组件。
3.3.4   Netflix Feign：基于Ribbon和Hystrix的声明式服务调用组件。
3.3.5   Netflix Zuul：微服务网关，提供动态路由，访问过滤等服务。
3.3.6   Netflix Archaius：配置管理API，包含一系列配置管理API，提供动态类型化属性、线程安全配置操作、轮询框架、回调机制等功能。
3.4   Spring Cloud for Cloud Foundry：通过Oauth2协议绑定服务到CloudFoundry，CloudFoundry是VMware推出的开源PaaS云平台。
3.5   Spring Cloud Sleuth：日志收集工具包，封装了Dapper,Zipkin和HTrace操作。
3.6   Spring Cloud Data Flow：大数据操作工具，通过命令行方式操作数据流。
3.7   Spring Cloud Security：安全工具包，为你的应用程序添加安全控制，主要是指OAuth2。
3.8   Spring Cloud Consul：封装了Consul操作，consul是一个服务发现与配置工具，与Docker容器可以无缝集成。
3.9   Spring Cloud Zookeeper：操作Zookeeper的工具包，用于使用zookeeper方式的服务注册和发现。
3.10   Spring Cloud Stream：数据流操作开发包，封装了与Redis,Rabbit、Kafka等发送接收消息。
3.11   Spring Cloud CLI：基于 Spring Boot CLI，可以让你以命令行方式快速建立云组件。

二、 SpringCloud与Dubbo的区别

三、 Spring Cloud版本说明

1   常见版本号说明
软件版本号：2.0.2.RELEASE
2：主版本号。当功能模块有较大更新或者整体架构发生变化时，主版本号会更新
0：次版本号。次版本表示只是局部的一些变动。
2：修改版本号。一般是bug的修复或者是小的变动
RELEASE:希腊字母版本号。次版本号用户标注当前版本的软件处于哪个开发阶段
1.1   希腊字母版本号
Base：设计阶段。只有相应的设计没有具体的功能实现。
Alpha：软件的初级版本。存在较多的bug
Bate：表示相对alpha有了很大的进步，消除了严重的bug，还存在一些潜在的bug。
Release：该版本表示最终版。
2   Spring Cloud版本号说明
2.1   为什么Spring Cloud版本用的是单词而不是数字？
设计的目的是为了更好的管理每个Spring Cloud的子项目的清单。避免子的版本号与子项目的版本号混淆。
2.2   版本号单词的定义规则
采用伦敦的地铁站名称来作为版本号的命名，根据首字母排序，字母顺序靠后的版本号越大。
2.3   版本发布计划说明

3   Spring Cloud与子项目版本兼容说明

第三章Eureka服务注册中心
（Spring Cloud初级）

一、什么是服务注册中心

服务注册中心是服务实现服务化管理的核心组件,类似于目录服务的作用,主要用来存储服务信息，譬如提供者url串、路由信息等。服务注册中心是SOA架构中最基础的设施之一。
1   服务注册中心的作用
1，服务的注册
2，服务的发现
2   常见的注册中心有哪些
1，Dubbo 的注册中心Zookeeper
2，Sringcloud的注册中心Eureka
3   服务注册中心解决了什么问题
1.   服务管理
2.   服务的依赖关系管理
4   什么是Eureka注册中心
Eureka是Netflix开发的服务发现组件，本身是一个基于REST的服务。Spring Cloud将它集成在其子项目spring-cloud-netflix中，以实现Spring Cloud的服务注册于发现，同时还提供了负载均衡、故障转移等能力。
5   Eureka注册中心三种角色
5.1   Eureka Server
通过Register、Get、Renew等接口提供服务的注册和发现。
5.2   Application Service (Service Provider)
服务提供方
把自身的服务实例注册到Eureka Server中
5.3   Application Client (Service Consumer)
服务调用方
通过Eureka Server 获取服务列表，消费服务。

二、 Eureka入门案例

1 创建项目

2 修改pom文件添加依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.bjsxt</groupId>
    <artifactId>springcloud-eureka-server</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>
    <name>springcloud-eureka-server</name>
    <description>Demo project for Spring Boot</description>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.13.RELEASE</version>
        <relativePath /> <!-- lookup parent from repository -->
    </parent>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Dalston.SR5</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-config</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka-server</artifactId>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

3 修改启动类

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

4 修改application.properties全局配置文件

spring.application.name=eureka-server
server.port=8761
#是否将自己注册到Eureka-Server中，默认的为true
eureka.client.registerWithEureka=false
#是否冲Eureka-Server中获取服务注册信息，默认为true
eureka.client.fetchRegistry=false

5 通过浏览器访问Eureka-Server服务管理平台

三、搭建高可用Eureka注册中心（Eureka集群）

1 创建项目

2 配置文件

#设置eureka实例名称，与配置文件的变量为主
eureka.instance.hostname=eureka2
#设置服务注册中心地址，指向另一个注册中心
eureka.client.serviceUrl.defaultZone=http://eureka1:8761/eureka/

在搭建Eureka集群时，需要添加多个配置文件，并且使用SpringBoot的多环境配置方式。集群中需要多少节点就添加多少个配置文件。
3 在配置文件中配置集群节点
3.1 eureka1

spring.application.name=eureka-server
server.port=8761
#设置eureka实例名称，与配置文件的变量为主
eureka.instance.hostname=eureka1
#设置服务注册中心地址，指向另一个注册中心
eureka.client.serviceUrl.defaultZone=http://eureka2:8761/eureka/

3.2 eureka2

spring.application.name=eureka-server
server.port=8761
#设置eureka实例名称，与配置文件的变量为主
eureka.instance.hostname=eureka2
#设置服务注册中心地址，指向另一个注册中心
eureka.client.serviceUrl.defaultZone=http://eureka1:8761/eureka/

4   添加logback日志配置文件

5   Eureka集群部署
部署环境：需要安装jdk1.8，正确配置环境变量。
注意：需要关闭linux的防火墙，或者是开放8761端口
5.1   将项目打包
Maven install
5.2   上传实例
在/usr/local/创建一个eureka的目录
将项目的jar包拷贝到/usr/local/eureka
6   编写一个启动脚本文件

#!/bin/bash
 
cd `dirname $0`
 
CUR_SHELL_DIR=`pwd`
CUR_SHELL_NAME=`basename ${BASH_SOURCE}`
 
JAR_NAME="项目名称"
JAR_PATH=$CUR_SHELL_DIR/$JAR_NAME
 
#JAVA_MEM_OPTS=" -server -Xms1024m -Xmx1024m -XX:PermSize=128m"
JAVA_MEM_OPTS=""
 
SPRING_PROFILES_ACTIV="-Dspring.profiles.active=配置文件变量名称"
#SPRING_PROFILES_ACTIV=""
LOG_DIR=$CUR_SHELL_DIR/logs
LOG_PATH=$LOG_DIR/${JAR_NAME%..log
 
echo_help()
{
    echo -e "syntax: sh $CUR_SHELL_NAME start|stop"
}
 
if [ -z $1 ];then
    echo_help
    exit 1
fi
 
if [ ! -d "$LOG_DIR" ];then
    mkdir "$LOG_DIR"
fi
 
if [ ! -f "$LOG_PATH" ];then
    touch "$LOG_DIR"
fi
 
if [ "$1" == "start" ];then
 
    # check server
    PIDS=`ps --no-heading -C java -f --width 1000 | grep $JAR_NAME | awk '{print $2}'`
    if [ -n "$PIDS" ]; then
        echo -e "ERROR: The $JAR_NAME already started and the PID is ${PIDS}."
        exit 1
    fi
 
    echo "Starting the $JAR_NAME..."
 
    # start
    nohup java $JAVA_MEM_OPTS -jar $SPRING_PROFILES_ACTIV $JAR_PATH >> $LOG_PATH 2>&1 &
 
    COUNT=0
    while [ $COUNT -lt 1 ]; do
        sleep 1
        COUNT=`ps  --no-heading -C java -f --width 1000 | grep "$JAR_NAME" | awk '{print $2}' | wc -l`
        if [ $COUNT -gt 0 ]; then
            break
        fi
    done
    PIDS=`ps  --no-heading -C java -f --width 1000 | grep "$JAR_NAME" | awk '{print $2}'`
    echo "${JAR_NAME} Started and the PID is ${PIDS}."
    echo "You can check the log file in ${LOG_PATH} for details."
 
elif [ "$1" == "stop" ];then
 
    PIDS=`ps --no-heading -C java -f --width 1000 | grep $JAR_NAME | awk '{print $2}'`
    if [ -z "$PIDS" ]; then
        echo "ERROR:The $JAR_NAME does not started!"
        exit 1
    fi
 
    echo -e "Stopping the $JAR_NAME..."
 
    for PID in $PIDS; do
        kill $PID > /dev/null 2>&1
    done
 
    COUNT=0
    while [ $COUNT -lt 1 ]; do
        sleep 1
        COUNT=1
        for PID in $PIDS ; do
            PID_EXIST=`ps --no-heading -p $PID`
            if [ -n "$PID_EXIST" ]; then
                COUNT=0
                break
            fi
        done
    done
 
    echo -e "${JAR_NAME} Stopped and the PID is ${PIDS}."
else
    echo_help
    exit 1
fi

6.1   设置启动脚本的运行权限
Chmod -R 755 server.sh
7   修改 linux的host文件
Vim /etc/hosts
192.168.70.134 eureka1
192.168.70.135 eureka2
8   启动eureka注册中心
./server.sh start 启动
./server.sh stop 停止
9   通过浏览器访问注册中心的管理页面

四、在高可用的Eureka注册中心中构建provider服务

1 创建项目

2 修改pom文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.bjsxt</groupId>
    <artifactId>springcloud-eureka-provider</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>
    <name>springcloud-eureka-provider</name>
    <description>Demo project for Spring Boot</description>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.13.RELEASE</version>
        <relativePath /> <!-- lookup parent from repository -->
    </parent>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Dalston.SR5</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-config</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-eureka</artifactId>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

3 修改启动类

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

4 修改provider的配置文件

spring.application.name=eureka-provider
server.port=9090
#设置服务注册中心地址，指向另一个注册中心
eureka.client.serviceUrl.defaultZone=http://eureka1:8761/eureka/,http://eureka2:8761/eureka/

5 修改windows的host文件
路径：C:\Windows\System32\drivers\etc
192.168.70.134 eureka1
192.168.70.135 eureka2

6 编写服务接口
6.1 创建接口

@RestController
public class UserController {
    @RequestMapping("/user")
    public List<User> getUsers(){
        List<User> list = new ArrayList<>();
        list.add(new User(1,"zhangsan",20));
        list.add(new User(2,"lisi",22));
        list.add(new User(3,"wangwu",20));
        return list;
    }
}

6.2 创建pojo

public class User {
    private int userid;
    private String username;
    private int userage;
    public int getUserid() {
        return userid;
    }
    public void setUserid(int userid) {
        this.userid = userid;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public int getUserage() {
        return userage;
    }
    public void setUserage(int userage) {
        this.userage = userage;
    }
    public User(int userid, String username, int userage) {
        super();
        this.userid = userid;
        this.username = username;
        this.userage = userage;
    }
    public User() {
        super();
        // TODO Auto-generated constructor stub
    }
    
}

五、在高可用的Eureka注册中心中构建consumer服务

1 创建项目

服务的消费者与提供者都需要再Eureka注册中心注册。
2 Consumer的配置文件

spring.application.name=eureka-consumer
server.port=9091
#设置服务注册中心地址，指向另一个注册中心
eureka.client.serviceUrl.defaultZone=http://eureka1:8761/eureka/,http://eureka2:8761/eureka/

3 在Service中完成服务的调用

@Service
public class UserService {
    @Autowired
    private LoadBalancerClient loadBalancerClient;//ribbon负载均衡器
    
    public List<User> getUsers(){
            //选择调用的服务的名称
        //ServiceInstance 封装了服务的基本信息，如 IP，端口
        ServiceInstance si = this.loadBalancerClient.choose("eureka-provider");
        //拼接访问服务的URL
        StringBuffer sb = new StringBuffer();
        //http://localhost:9090/user
        sb.append("http://").append(si.getHost()).append(":").append(si.getPort()).append("/user");
        
        
        //springMVC RestTemplate
        RestTemplate rt = new RestTemplate();
        
        ParameterizedTypeReference<List<User>> type = new ParameterizedTypeReference<List<User>>() {};
        
        //ResponseEntity:封装了返回值信息
        ResponseEntity<List<User>> response = rt.exchange(sb.toString(),HttpMethod.GET, null, type);
        List<User> list =response.getBody();
        return list;
    }
}

4 Controller

@RestController
public class UserController {
    @Autowired
    private UserService userService;
    
    @RequestMapping("/consumer")
    public List<User> getUsers(){
        return this.userService.getUsers();
    }
}

六、 Eureka注册中心架构原理

1 Eureka架构图

Register(服务注册)：把自己的IP和端口注册给Eureka。
Renew(服务续约)：发送心跳包，每30秒发送一次。告诉Eureka自己还活着。
Cancel(服务下线)：当provider关闭时会向Eureka发送消息，把自己从服务列表中删除。防止consumer调用到不存在的服务。
Get Registry(获取服务注册列表)：获取其他服务列表。
Replicate(集群中数据同步)：eureka集群中的数据复制与同步。
Make Remote Call(远程调用)：完成服务的远程调用。

七、基于分布式CAP定理，分析注册中心两大主流框架：Eureka与Zookeeper的区别

1 什么是CAP原则
CAP原则又称CAP定理，指的是在一个分布式系统中，Consistency（一致性）、 Availability（可用性）、Partition tolerance（分区容错性），三者不可兼得。
CAP由Eric Brewer在2000年PODC会议上提出。该猜想在提出两年后被证明成立，成为我们熟知的CAP定理

分布式系统CAP定理
C 数据一致性 (Consistency)	也叫做数据原子性系统在执行某项操作后仍然处于一致的状态。在分布式系统中，更新操作执行成功后所有的用户都应该读到最新的值，这样的系统被认为是具有强一致性的。等同于所有节点访问同一份最新的数据副本。
A 服务可用性 (Availablity)	每一个操作总是能够在一定的时间内返回结果，这里需要注意的是"一定时间内"和"返回结果"。一定时间内指的是，在可以容忍的范围内返回结果，结果可以是成功或者是失败。
P 分区容错性 (Partition-torlerance)	在网络分区的情况下，被分隔的节点仍能正常对外提供服务(分布式集群，数据被分布存储在不同的服务器上，无论什么情况，服务器都能正常被访问)
定律：任何分布式系统只可同时满足二点，没法三者兼顾。
CA，放弃P	如果想避免分区容错性问题的发生，一种做法是将所有的数据(与事务相关的)都放在一台机器上。虽然无法100%保证系统不会出错，单不会碰到由分区带来的负面效果。当然这个选择会严重的影响系统的扩展性。
CP，放弃A	相对于放弃"分区容错性"来说，其反面就是放弃可用性。一旦遇到分区容错故障，那么受到影响的服务需要等待一定时间，因此在等待时间内系统无法对外提供服务。
AP，放弃C	这里所说的放弃一致性，并不是完全放弃数据一致性，而是放弃数据的强一致性，而保留数据的最终一致性。以网络购物为例，对只剩下一件库存的商品，如果同时接受了两个订单，那么较晚的订单将被告知商品告罄。

2 Zookeeper与Eureka的区别

对比项	Zookeeper	Eureka
CAP	CP	AP
Dubbo集成	已支持	-
Spring Cloud集成	已支持	已支持
kv服务	支持	-	ZK支持数据存储，eureka不支持
使用接口(多语言能力)	提供客户端	http多语言	ZK的跨语言支持比较弱
watch支持	支持	支持	什么是Watch支持？就是客户单监听服务端的变化情况。 zk通过订阅监听来实现 eureka通过轮询的方式来实现
集群监控	_	metrics	metrics，运维者可以收集并报警这些度量信息达到监控目的

八、 Eureka优雅停服

1 在什么条件下，Eureka会启动自我保护？

什么是自我保护模式

1，自我保护的条件
   一般情况下，微服务在Eureka上注册后，会每30秒发送心跳包，Eureka通过心跳来判断服务时候健康，同时会定期删除超过90秒没有发送心跳服务。
2，有两种情况会导致Eureka Server收不到微服务的心跳
   a.是微服务自身的原因
b.是微服务与Eureka之间的网络故障
     通常(微服务的自身的故障关闭)只会导致个别服务出现故障，一般不会出现大面积故障，而(网络故障)通常会导致Eureka Server在短时间内无法收到大批心跳。
     考虑到这个区别，Eureka设置了一个阀值，当判断挂掉的服务的数量超过阀值时，Eureka Server认为很大程度上出现了网络故障，将不再删除心跳过期的服务。
3，那么这个阀值是多少呢？
   15分钟之内是否低于85%；
   Eureka Server在运行期间，会统计心跳失败的比例在15分钟内是否低于85%
   这种算法叫做Eureka Server的自我保护模式。

2 为什么要启动自我保护

为什么要自我保护

1，因为同时保留"好数据"与"坏数据"总比丢掉任何数据要更好，当网络故障恢复后，这个Eureka节点会退出"自我保护模式"。
2，Eureka还有客户端缓存功能(也就是微服务的缓存功能)。即便Eureka集群中所有节点都宕机失效，微服务的Provider和Consumer
都能正常通信。
3，微服务的负载均衡策略会自动剔除死亡的微服务节点。

3 如何关闭自我保护
修改Eureka Server配置文件

#关闭自我保护:true为开启自我保护，false为关闭自我保护
eureka.server.enableSelfPreservation=false
#清理间隔(单位:毫秒，默认是60*1000)
eureka.server.eviction.interval-timer-in-ms=60000

4   如何优雅停服
4.1   不需要再Eureka Server中配置关闭自我保护
4.2   需要再服务中添加actuator.jar包

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.bjsxt</groupId>
	<artifactId>springcloud-eureka-provider</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>
	<name>springcloud-eureka-provider</name>
	<description>Demo project for Spring Boot</description>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.5.13.RELEASE</version>
		<relativePath /> <!-- lookup parent from repository -->
	</parent>
	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
		<java.version>1.8</java.version>
	</properties>
	<dependencyManagement>
		<dependencies>
			<dependency>
				<groupId>org.springframework.cloud</groupId>
				<artifactId>spring-cloud-dependencies</artifactId>
				<version>Dalston.SR5</version>
				<type>pom</type>
				<scope>import</scope>
			</dependency>
		</dependencies>
	</dependencyManagement>
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-config</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.cloud</groupId>
			<artifactId>spring-cloud-starter-eureka-server</artifactId>
		</dependency>
	</dependencies>
	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>
</project>

4.3 修改配置文件

#启用shutdown
endpoints.shutdown.enabled=true
#禁用密码验证
endpoints.shutdown.sensitive=false

4.4 发送一个关闭服务的URL请求

public class HttpClientUtil {
	public static String doGet(String url, Map<String, String> param) {
		// 创建Httpclient对象
		CloseableHttpClient httpclient = HttpClients.createDefault();
		String resultString = "";
		CloseableHttpResponse response = null;
		try {
			// 创建uri
			URIBuilder builder = new URIBuilder(url);
			if (param != null) {
				for (String key : param.keySet()) {
					builder.addParameter(key, param.get(key));
				}
			}
			URI uri = builder.build();
			// 创建http GET请求
			HttpGet httpGet = new HttpGet(uri);
			// 执行请求
			response = httpclient.execute(httpGet);
			// 判断返回状态是否为200
			if (response.getStatusLine().getStatusCode() == 200) {
				resultString = EntityUtils.toString(response.getEntity(), "UTF-8");
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				if (response != null) {
					response.close();
				}
				httpclient.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return resultString;
	}
	public static String doGet(String url) {
		return doGet(url, null);
	}
	public static String doPost(String url, Map<String, String> param) {
		// 创建Httpclient对象
		CloseableHttpClient httpClient = HttpClients.createDefault();
		CloseableHttpResponse response = null;
		String resultString = "";
		try {
			// 创建Http Post请求
			HttpPost httpPost = new HttpPost(url);
			// 创建参数列表
			if (param != null) {
				List<NameValuePair> paramList = new ArrayList<>();
				for (String key : param.keySet()) {
					paramList.add(new BasicNameValuePair(key, param.get(key)));
				}
				// 模拟表单
				UrlEncodedFormEntity entity = new UrlEncodedFormEntity(paramList,"utf-8");
				httpPost.setEntity(entity);
			}
			// 执行http请求
			response = httpClient.execute(httpPost);
			resultString = EntityUtils.toString(response.getEntity(), "utf-8");
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				response.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		return resultString;
	}
	public static String doPost(String url) {
		return doPost(url, null);
	}
	
	public static String doPostJson(String url, String json) {
		// 创建Httpclient对象
		CloseableHttpClient httpClient = HttpClients.createDefault();
		CloseableHttpResponse response = null;
		String resultString = "";
		try {
			// 创建Http Post请求
			HttpPost httpPost = new HttpPost(url);
			// 创建请求内容
			StringEntity entity = new StringEntity(json, ContentType.APPLICATION_JSON);
			httpPost.setEntity(entity);
			// 执行http请求
			response = httpClient.execute(httpPost);
			resultString = EntityUtils.toString(response.getEntity(), "utf-8");
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			try {
				response.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		return resultString;
	}
	
	public static void main(String[] args) {
		String url ="http://127.0.0.1:9090/shutdown";
		//该url必须要使用dopost方式来发送
		HttpClientUtil.doPost(url);
	}
}

九、如何加强Eureka注册中心的安全认证

1 在Eureka Server中添加security包

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

2 修改Eureka Server配置文件

#开启http basic的安全认证
security.basic.enabled=true  
security.user.name=user
security.user.password=123456

3 修改访问集群节点的url
eureka.client.serviceUrl.defaultZone=http://user:123456@eureka2:8761/eureka/4 修改微服务的配置文件添加访问注册中心的用户名与密码

spring.application.name=eureka-provider
server.port=9090
#设置服务注册中心地址，指向另一个注册中心
eureka.client.serviceUrl.defaultZone=http://user:123456@eureka1:8761/eureka/,http://user:123456@eureka2:8761/eureka/
#启用shutdown
endpoints.shutdown.enabled=true
#禁用密码验证
endpoints.shutdown.sensitive=false

DougLeaMrConcurrency

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
SpringCloud：SpringCloud初级，单体、RPC、SOA、微服务介绍，SpringCloud入门与Dubbo区别，Eureka服务注册中心，高可用Euraka架构原理，分布式CAP原理

第一章微服务架构介绍（Spring Cloud初级）一、单体架构单体架构也称之为单体系统或者是单体应用。就是一种把系统中所有的功能、模块耦合在一个应用中的架构方式。1 单体架构特点1.1 打包成一个独立的单元(导成一个唯一的jar包或者是war包)1.2 会一个进程的方式来运行2 单体架构的优点、缺点2.1 优点2.1.1 项目易于管理2.1.2 部署简单2.2 缺点2.2.1 测试成本高2.2.2 可...
复制链接

扫一扫