滑动视频网站源码分享，滑动的小视频

大家好，关于滑动视频网站源码分享很多朋友都还不太明白，今天小编就来为大家分享关于滑动的小视频的知识，希望对各位有所帮助！

40岁老架构尼恩的提示：

现在拿到offer超级难，甚至连面试电话，一个都搞不到。

尼恩的技术社群中（50+），很多小伙伴凭借“左手云原生+右手大数据+SpringCloudAlibaba微服务“三大绝活，拿到了offer，并且是非常优质的offer，据说年终奖都足足18个月，非常令人羡慕。

问题是：“左手云原生+右手大数据+SpringCloudAlibaba微服务“内容非常多，实操的环境非常复杂，底层原理很深。

米饭要一口一口的吃，不能急。在这里，尼恩从架构师视角出发，左手云原生+右手大数据+SpringCloudAlibaba微服务核心原理做一个宏观的介绍。

由于内容确实太多，所以写多个pdf电子书：

(1)《Docker学习圣经》PDF（V1已经完成）

(2)《SpringCloudAlibaba微服务学习圣经》PDF（V1已经完成）

(3)《K8S学习圣经》PDF

(4)《flink+hbase学习圣经》PDF

以上学习圣经，并且后续会持续升级，从V1版本一直迭代发布。就像咱们的《尼恩Java面试宝典PDF》一样，已经迭代到V60+啦。

40岁老架构师尼恩的掏心窝：通过一系列的学习圣经，带大家穿透“左手云原生+右手大数据+SpringCloudAlibaba微服务“，实现技术自由，走向颠覆人生，让大家不迷路。

本PDF《SpringCloudAlibaba微服务学习圣经》完整版PDF的V1版本，后面会持续迭代和升级。供后面的小伙伴参考，提升大家的3高架构、设计、开发水平。

以上学习圣经的基础知识是《尼恩的高并发三部曲》，建议在看学习圣经之前，一定把尼恩的Java高并发三部曲过一遍，切记，切记。

注：本文以PDF持续更新，最新尼恩架构笔记、面试题的PDF文件，请到《技术自由圈》公众号领取

《SpringCloudAlibaba微服务学习圣经》PDF封面

《SpringCloudAlibaba微服务学习圣经》目录

-40岁老架构师尼恩的掏心窝：\n-当前版本V1\n-一键导入SpringCloud开发环境（地表最强）\n-环境准备\n-一键导入OR自己折腾\n-随书源码crazy-springcloud脚手架涉以及基础中间件\n-微服务分布式系统的架构12次演进\n-微服务分布式系统的几个基础概念\n-架构演进1：单机架构\n-架构演进2：引入缓存架构\n-架构演进3：接入层引入反向代理实现负载均衡\n-架构演进4：数据库读写分离\n-架构演进5：数据库按业务分库\n-架构演进6：使用LVS或F5接入层负载均衡\n-架构演进7：通过DNS轮询实现机房间的负载均衡\n-架构演进8：引入NoSQL数据库和搜索引擎等技术\n-架构演进9：大应用拆分为微服务\n-架构演进10：引入企业服务总线ESB对微服务进行编排\n-架构演进11：引入容器化技术实现动态扩容和缩容\n-架构演进12：以云平台承载系统\n-架构演进的涉及的核心知识\n-SpringCloudnetflix入门\n-SpringCloud开发脚手架\n-启动EurekaServer注册中心\n-启动Config配置中心\n-config-server服务\n-微服务入门案例\n-uaa-provider微服务提供者\n-uaa-provider实现一个Rest接口\n-uaa-provider的运行结果\n-demo-provider完成RPC远程调用\n-REST服务的本地代理接口\n-通过REST服务的本地代理接口，进行RPC调用\n-启动demo-provider\n-通过swagger执行RPC操作\n-SpringCloudEureka服务注册\n-SpringCloudConfig统一配置\n-Nacos服务注册+统一配置\n-1、Nacos优势\n-1.1与eureka对比\n-1.2与springcloudconfig对比\n-三大优势：\n-2、SpringCloudAlibaba套件\n-SpringCloudAlibaba套件和SpringCloudNetflix套件类比\n-3、Nacos的架构和安装\n-3.1Nacos的架构\n-3.2NacosServer的下载和安装\n-4、NacosServer的运行\n-4.1两种模式\n-4.2standalone模式\n-4.3cluster模式\n-cluster模式需要依赖MySQL，然后改两个配置文件：\n-4.4NacosServer的配置数据是存在哪里呢？\n-5、实战1：使用Nacos作为注册中心\n-实战的工程\n-5.1如何使用NacosClient组件\n-首先引入SpringCloudAlibaba的BOM\n-5.2演示的模块结构\n-5.3provider微服务\n-step1：在provider和consumer的pom添加以下依赖：\n-step2：启动类\n-step3：服务提供者的Rest服务接口\n-step4：配置文件\n-step5：启动之后，通过swaggerUI访问：\n-5.4Consumer微服务演示RPC远程调用\n-消费者的controller类\n-消费者配置文件\n-通过swaggerUI访问消费者：\n-5.5涉及到的演示地址：\n-5.6NacosConsole\n-6、实战2：使用Nacos作为配置中心\n-6.1基本概念\n-1）Profile\n-2）DataID\n-3）Group\n-6.2通过Nacos的console去增加配置\n-1）nacos-config-demo-dev.yaml\n-2）nacos-config-demo-sit.yaml\n-6.3使用NacosConfigClient组件\n-1）加载nacosconfig的客户端依赖：\n-启动类\n-控制类：\n-2）bootstrap配置文件\n-6.4测试结果\n-6.4可以端如何与服务端的配置文件相互对应\n-7、配置的隔离\n-8、nacos集群搭建\n-IP规划\n-集群的使用\n-Nacos高可用架构与实操\n-客户端高可用\n-客户端高可用的方式一：配置多个nacos-server\n-NacosJavaClient通用参数\n-客户端高可用的方式二：本地缓存文件Failover机制\n-本地缓存文件Failover机制\n-客户端Naming通用参数\n-Nacos两种健康检查模式\n-agent上报模式\n-服务端主动检测\n-临时实例\n-注册实例支持ephemeral字段\n-临时实例和持久化实例区别\n-NacosServer运行模式\n-NacosCP/AP模式设定\n-NacosCP/AP模式切换\n-AP/CP的配套一致性协议\n-AP模式下的distro协议\n-CP模式下的raft协议\n-集群内部的特殊的心跳同步服务\n-集群部署模式高可用\n-节点数量\n-多可用区部署\n-部署模式\n-高可用nacos的部署架构\n-高可用nacos的部署实操\n-总结\n-SpringCloudFeign实现RPC远程调用\n-SpringCloud+Dubbo实现RPC远程调用\n-大背景：全链路异步化的大趋势来了\n-SpringCloud+Dubbo完成RPC异步\n-Dubbo3应用的宏观架构\n-Dubbo3应用架构的核心组件\n-SpringBoot整合Dubbo3.0基础准备\n-SpringCloud+Nacos+Dubbo3.0\n-版本说明\n-项目结构介绍\n-1、dubbo的依赖的坐标\n-2、注册中心的依赖的坐标\n-SpringBoot整合Dubbo3.0大致步骤\n-模块结构\n-Dubbo微服务注册发现的相关配置\n-命名空间隔离\n-微服务yml配置\n-common-service模块\n-服务提供者实操：dubbo-provider服务\n-pom依赖\n-服务实现类\n-dubbo和Feign的一个不同\n-Provider的Dubbo+Nacos配置文件\n-启动类加上@EnableDubbo注解\n-启动、体验Provider\n-在Nacos查看Dubbo服务的注册情况\n-服务消费者实操：dubbo-consumer服务\n-consumer模块\n-消费者实现类\n-消费者Dubbo+Nacos配置文件\n-启动类加上@EnableDubbo注解\n-启动、体验Consumer\n-在Nacos查看Dubbo服务的注册情况\n-Feign+Dubbo性能的对比测试\n-Dubbo比Feign高10倍以上的本质\n-Dubbo与SpringCloud的通信Openfeign的区别\n-1、协议支持方面\n-2、通信性能方面\n-3、线程模型方面\n-SpringCloud+DubboRPC的集成价值\n-hystrix服务保护\n-Sentinel服务保护\n-sentinel基本概念\n-1、什么是Sentinel:\n-Sentinel具有以下特征：\n-Sentinel主要特性：\n-Sentinel的使用\n-Sentinel中的管理控制台\n-1获取Sentinel控制台\n-2sentinel服务启动\n-客户端能接入控制台\n-Sentinel与Hystrix的区别\n-2、使用Sentinel来进行熔断与限流\n-1）定义资源\n-资源注解@SentinelResource\n-@SentinelResource注解\n-fallback函数签名和位置要求：\n-defaultFallback函数签名要求：\n-2）定义规则\n-3、sentinel熔断降级\n-1）什么是熔断降级\n-2）熔断降级规则\n-3）几种降级策略\n-4）熔断降级代码实现\n-5）控制台降级规则\n-6）与Hystrix的熔断对比：\n-4、Sentinel流控（限流）\n-基本的参数\n-流控的几种strategy：\n-4.1直接失败模式\n-使用API进行资源定义\n-代码限流规则\n-网页限流规则配置\n-测试\n-4.2关联模式\n-使用注解进行资源定义\n-代码配置关联限流规则\n-网页限流规则配置\n-测试\n-4.3Warmup（预热）模式\n-使用注解定义资源\n-代码限流规则\n-网页限流规则配置\n-通过jmeter进行测试\n-4.4排队等待模式\n-示例\n-使用注解定义资源\n-代码限流规则\n-网页限流规则配置\n-通过jmeter进行测试\n-4.5热点规则(ParamFlowRule)\n-自定义资源\n-限流规则代码：\n-网页限流规则配置\n-5、Sentinel系统保护\n-系统保护的目的\n-系统保护规则的应用\n-网页限流规则配置\n-6、黑白名单规则\n-访问控制规则(AuthorityRule)\n-7、如何定义资源\n-方式一：主流框架的默认适配\n-方式二：抛出异常的方式定义资源\n-方式三：返回布尔值方式定义资源\n-方式四：注解方式定义资源\n-方式五：异步调用支持\n-8、核心组件\n-Resource\n-Context\n-Context的创建与销毁\n-Entry\n-DefaultNode\n-StatisticNode\n-9、插槽Slot\n-NodeSelectorSlot\n-调用链树\n-构造树干\n-创建context\n-创建Entry\n-退出Entry\n-构造叶子节点\n-保存子节点\n-ClusterBuilderSlot\n-StatistcSlot\n-SystemSlot\n-AuthoritySlot\n-FlowSlot\n-DegradeSlot\n-DefaultProcessorSlotChain\n-slot总结\n-10、sentinel滑动窗口实现原理\n-1）基本原理\n-2）sentinel使用滑动窗口都统计啥\n-3）滑动窗口源码实现\n-3.1）MetricBucket\n-3.2）WindowWrap\n-3.3）LeapArray\n-Zuul微服务网关\n-Webflux响应式编程\n-WebFlux学习前言\n-WebFlux增删改查完整实战demo\n-Dao层（又称repository层）\n-entity（又称PO对象）\n-Dao实现类\n-Service服务层\n-Controller控制层\n-Mono\n-Flux\n-使用配置模式进行WebFlux接口开发\n-处理器类Handler\n-路由配置\n-WebFlux集成Swagger\n-maven依赖\n-swagger配置\n-WebFlux测试\n-配置模式的WebFluxRest接口测试\n-注解模式的WebFluxRest接口测试\n-swagger增加界面\n-配置大全\n-静态资源配置\n-WebFluxSecurity配置\n-WebSession配置\n-文件上传配置\n-WebFlux执行流程\n-WebFlux学习提示\n-SpringCloudGateway微服务网关\n-1、SpringCloudGateway简介\n-1.1本文姊妹篇《Flux和Mono、reactor实战（史上最全）》\n-1.2SpringCloudGateway特征\n-1.3SpringCloudGateway和架构\n-1）SpringCloudZuul的IO模型\n-2）Webflux服务器\n-3）SpringCloudGateway的处理流程\n-2、路由配置方式\n-2.1基础URI路由配置方式\n-2.2基于代码的路由配置方式\n-2.3和注册中心相结合的路由配置方式\n-3、路由匹配规则\n-说明：\n-3.1Predicate断言条件(转发规则)介绍\n-1）通过请求参数匹配\n-2）通过Header属性匹配\n-3）通过Cookie匹配\n-4）通过Host匹配\n-5）通过请求方式匹配\n-6）通过请求路径匹配\n-7）通过请求ip地址进行匹配\n-8）组合使用\n-3.2过滤器规则（Filter）\n-过滤器规则（Filter）\n-PrefixPath\n-RedirectTo\n-RemoveRequestHeader\n-RemoveResponseHeader\n-RemoveRequestParameter\n-RewritePath\n-SetPath\n-SetRequestHeader\n-SetStatus\n-StripPrefix\n-RequestSize\n-Default-filters\n-3.3通过代码进行配置\n-3.2实现熔断降级\n-4、高级配置\n-4.1分布式限流\n-4.2健康检查配置\n-maven依赖\n-配置文件\n-4.3统一配置跨域请求：\n-5、整合Nacos\n-maven依赖\n-服务发现配置：从Nacos获取微服务提供者清单\n-nacos实现动态配置\n-服务发现路由predicates和filters的自定义定义\n-为注册中心路由配置断言和过滤器\n-6、整合Swagger聚合微服务系统API文档\n-maven依赖\n-配置文件\n-效果：\n-7、Gatway网关的过滤器开发\n-7.1过滤器的执行次序\n-7.2定义全局过滤器\n-7.3定义局部过滤器\n-8、整合Sentinel完成流控和降级\n-maven依赖\n-配置文件\n-限流规则通用配置\n-限流规则设置\n-网关限流参数\n-SpringBootAdmin进行微服务实例的监控\n-使用SpringBootAdmin进行日志的记录\n-1、SpringBootAdmin简介\n-2、使用SpringBootAdmin监控服务\n-2.1导入依赖\n-2.2配置yml\n-2.3集成springsecurity\n-2.4启动器类\n-2.5、测试\n-3、actuator启用和暴露端点\n-3.1启用端点\n-3.2暴露端点\n-4、微服务Provider改造\n-4.1导入依赖\n-4.2配置yml\n-使用context-path\n-加上springsecurity密码\n-5、admin实现在线日志查看\n-5.1、添加jar包\n-5.2在application.yml平级文件夹中添加logback-spring.xml配置文件\n-5.3log.path如何使用环境变量呢？\n-5.4actuator的配置\n-测试结果\n-1.不暴露端点测试\n-2.正常情况\n-6、admin与Nacos（或Eureka）结合的好处\n-ELK日志平台（elasticsearch+logstash+kibana）原理和实操\n-ELK的关系\n-ELK优点\n-简单的ELK日志平台\n-ELK改进之引入Filebeat\n-ELK的应用场景\n-ELK的不足\n-es的资源占用\n-Elasticsearch概述\n-logstash概述\n-logstash作用：\n-logstash的架构：\n-Input(输入）：\n-Filter(过滤器）\n-Output(输出）：\n-Logstash的角色与不足\n-filebeat介绍\n-filebeat和beats的关系\n-Filebeat是如何工作的\n-Filebeat下载页面\n-Filebeat文件夹结构\n-Filebeat启动命令\n-配置inputs\n-Loginput\n-配置项\n-管理多行消息\n-配置Logstashoutput\n-一键安装es+logstash+kibana\n-对应的镜像版本\n-docker编码文件\n-访问kibana\n-读取filebeat-输出到es集群\n-在kibana显示的效果\n-使用filebeat发送日志\n-制作filebeat镜像\n-制作基础的unbantu镜像\n-推送镜像到dockerhub\n-制作filebeat镜像\n-dockerfile\n-推送镜像到dockerhub\n-example-application微服务的filebeat配置：\n-filebeat.yml的参考配置：\n-input.yml配置：\n-修改dockerfile\n-一键发布\n-启动之后\n-message-dispatcher微服务的日志\n-查看日志索引\n-logstash详解\n-stash第一个事件\n-Logstash的核心流程的三个环节\n-logstash数值类型\n-logstash条件判断\n-logstash比较运算符\n-数据输入环节\n-stdin\n-file\n-syslogs\n-beats\n-kafka\n-数据处理环节\n-grok解析文本并构造\n-date日期解析\n-mutate字段转换\n-covert类型转换\n-split\n-merge\n-rename\n-remove_field：移除字段\n-join\n-geoip\n-ruby\n-urldecode\n-kv\n-useragent\n-数据输出\n-stdout\n-file\n-kafka\n-elasticseach\n-Kibana查看应用日志\n-1查看应用日志\n-2如何搜索日志\n-3如何查看指定时间的应用日志\n-4如何定位错误日志\n-5如何展开显示日志\n-es的安全认证\n-配置elk的ElastAlert预警插件\n-Prometheus+Grafana检测预警\n-什么是性能可观测\n-系统监控的核心指标\n-系统性能指标\n-资源性能指标\n-什么是prometheus\n-prometheus的运行原理\n-prometheus主要特点\n-什么是Grafana\n-Prometheus的体系结构\n-Prometheus+Grafana分层架构\n-Promcthcus体系涉及的组件\n-如何收集度量值\n-指标类型\n-计数器\n-仪表盘\n-直方图\n-Summary\n-指标摘要及聚合\n-指标摘要\n-指标聚合\n-一键安装prometheus\n-bridge网络管理\n-创建库\n-docker编排文件\n-一键安装prometheus的脚本\n-进入prometheus\n-进入grafana\n-Prometheus+Grafana监控SpringBoot项目JVM信息\n-SpringBoot项目配置JVM采集\n-Prometheus配置\n-配置grafana监控Linux系统\n-使用Exporter收集指标\n-inux直接安装node_exporter\n-使用Docker容器安装node_exporter\n-创建一个任务定时扫描暴露的指标信息\n-创建仪表盘grafna\n-导入Dashboard\n-选择数据源为Prometheus\n-配置grafana监控SpringBoot应用\n-主要步骤\n-找jvm的dashboard\n-JVMQuarkus面板\n-Prometheus数据模型\n-time-series时间序列值\n-Sample样本值\n-metricsname指标名称\n-label标签\n-Notation(符号)\n-TSDB时序数据库\n-度量指标类型\n-Counter(计数器)类型\n-Gauge(计量器、测量器)\n-Histogram(柱状图、直方图)\n-Summary\n-Summary和Histogram的区分\n-学习PromQL\n-数据模型\n-PromQL入门\n-HTTPAPI\n-告警和通知\n-配置告警规则\n-使用Alertmanager发送告警通知\n-服务发现\n-为什么需要服务发现\n-prometheus目前支持的服务发现类型\n-基于文件的服务发现方式\n-file_sd_configs\n-基于consul的服务发现\n-什么是基于consul的服务发现\n-Prometheus配置\n-基于eureka的服务发现\n-eureka客户端暴露出prometheus端口\n-prometheus配置文件\n-基于nacos的服务发现\n-docker编排文件\n-生产的配置文件\n-修改prometheus配置文件\n-修改springboot项目配置文件\n-全方位Springcloud性能调优\n-Servlet容器优化\n-Zuul配置优化\n-Feign配置优化\n-hystrix配置优化\n-ribbon优化\n-高质量实操：SpringCloud高并发实战案例\n-1、超高并发10Wqps秒杀实操\n-2、超高并发100Wqps车联网实操\n-3、N多其他的超高并发实操项目\n-技术自由的实现路径：\n-实现你的架构自由：\n-实现你的响应式自由：\n-实现你的springcloud自由：\n-实现你的linux自由：\n-实现你的网络自由：\n-实现你的分布式锁自由：\n-实现你的王者组件自由：\n-实现你的面试题自由：\n-参考文献

当前版本V1

此书会持续迭代，最新版本，请关注公众号：技术自由圈

一键导入SpringCloud开发环境（地表最强）

SpringCloud+docker学习环境非常复杂，尼恩搞这个前前后后起码折腾了一周,应该还不止，

其中，很多头疼的工作，包括linux内核升级、磁盘扩容等等，苦不堪言。

现在把这个环境，以虚拟机box镜像的方式，导出来直接给大家，

大家一键导入后，直接享受SpringCloud+docker的实操，可以说，爽到不要不要的。

以上软件和尼恩个人的虚拟机box镜像，可以找尼恩获取。

环境准备

硬件总体要求，可以参考尼恩的本地硬件情况：

1硬件要求。

本文硬件总体要求如下表：

序号

硬件

要求

CPU

至少2核

内存

至少16G

硬盘

至少100G磁盘空间

2本地虚拟机环境

软件

版本

Win

win10以上

virtualbox

6以上

vagrant

2以上

一键导入OR自己折腾

大家一键导入尼恩的虚拟机环境，里边zookeeper、nacos、docker、k8s等组件都已经预装，直接享受SpringCloud+docker的实操，可以说，爽到不要不要的。

当然，如果想自己折腾，也可以按照的步骤来哈。

工欲善其事必先利其器

地表最强开发环境：vagrant+java+springcloud+redis+zookeeper镜像下载(&制作详解)

地表最强热部署：javaSpringBootSpringCloud热部署热加载热调试

地表最强发请求工具（再见吧，PostMan）：IDEAHTTPClient（史上最全）

地表最强PPT小工具：屌炸天，像写代码一样写PPT

无编程不创客，无编程不创客，一大波编程高手正在疯狂创客圈交流、学习中!找组织，GO

注：本文以PDF持续更新，最新尼恩架构笔记、面试题的PDF文件，请到《技术自由圈》公众号领取

随书源码crazy-springcloud脚手架涉以及基础中间件

本PDF的随书源码仓库，就是尼恩的《Java高并发核心编程卷3加强版，老版本为SpringCloudNginx高并发核心编程》一书的源码

《Java高并发核心编程卷3加强版》

也是尼恩的一个微服务开发脚手架crazy-springcloud，其大致的模块和功能具体如下：

crazymaker-server–根项目\n│├─cloud-center–微服务的基础设施中心\n││├─cloud-eureka–注册中心\n││├─cloud-config–配置中心\n││├─cloud-zuul–网关服务\n││├─cloud-zipkin–监控中心\n│├─crazymaker-base–公共基础依赖模块\n││├─base-common–普通的公共依赖，如utils类的公共方法\n││├─base-redis–公共的redis操作模块\n││├─base-zookeeper–公共的zookeeper操作模块\n││├─base-session–分布式session模块\n││├─base-auth–基于JWT+SpringSecurity的用户凭证与认证模块\n││├─base-runtime–各provider的运行时公共依赖，装配的一些通用SpringIOCBean实例\n│├─crazymaker-uaa–业务模块:用户认证与授权\n││├─uaa-api–用户DTO、Constants等\n││├─uaa-client–用户服务的Feign远程客户端\n││├─uaa-provider–用户认证与权限的实现，包含controller层、service层、dao层的代码实现\n│├─crazymaker-seckill–业务模块:秒杀练习\n││├─seckill-api–秒杀DTO、Constants等\n││├─seckill-client–秒杀服务的Feign远程调用模块\n││├─seckill-provider–秒杀服务核心实现，包含controller层、service层、dao层的代码实现\n│├─crazymaker-demo–业务模块:练习演示\n││├─demo-api–演示模块的DTO、Constants等\n││├─demo-client–演示模块的Feign远程调用模块\n││├─demo-provider–演示模块的核心实现，包含controller层、service层、dao层的代码实现

基于crazy-springcloud脚手架（其他的脚手架也类似）的微服务开发和自验证过程中，涉及到的基础中间件大致如下：

（1）ZooKeeper（虚拟机中已经预装）

ZooKeeper是一个分布式的、开放源码的分布式协调应用程序，是大数据框架Hadoop和Hbase的重要组件。在分布式应用中，它能够高可用地提供很多保障数据一致性的基础能力：分布式锁、选主、分布式命名服务等。

在crazy-springcloud脚手架中，高性能分布式ID生成器用到了ZooKeeper。有关其原理和使用，请参见《NettyZookeeperRedis高并发实战》一书。

（2）Redis（虚拟机中已经预装）

Redis是一个高性能的缓存数据库。在高并发的场景下，Redis可以对关系数据库起到很好的缓冲作用；在提高系统的并发能力和响应速度方面，Redis举足轻重和至关重要。crazy-springcloud脚手架的分布式Session用到了Redis。有关Redis的原理和使用，还是请参见《NettyZookeeperRedis高并发实战》一书。

（3）Eureka（虚拟机中已经预装）

Eureka是Netflix开发的服务注册和发现框架，本身是一个REST服务提供者，主要用于定位运行在AWS（Amazon云）的中间层服务，以达到负载均衡和中间层服务故障转移的目的。SpringCloud将它集成在其子项目spring-cloud-netflix中，以实现SpringCloud的服务注册和发现功能。

（4）SpringCloudConfig（虚拟机中已经预装）

SpringCloudConfig是SpringCloud全家桶中最早的配置中心，虽然在生产场景中，很多的企业已经使用Nacos或者Consul整合型的配置中心替代了独立的配置中心，但是Config依然适用于SpringCloud项目，通过简单的配置即可使用。

（5）Zuul

Zuul是Netflix开源网关，可以和Eureka、Ribbon、Hystrix等组件配合使用，SpringCloud对Zuul进行了整合与增强，使用其作为微服务集群的内部网关，负责对给集群内部各个provider服务提供者进行RPC路由和请求过滤。

以上中间件的端口配置，以及部分安装和使用视频，大致如下表所示。

中间件

链接地址

LinuxRedis安装（带视频）

https://www.cnblogs.com/crazymakercircle/p/11985983.html

LinuxZookeeper安装（带视频）

https://www.cnblogs.com/crazymakercircle/p/12006500.html

….完整的开发环境的准备工作，->

https://www.cnblogs.com/crazymakercircle/p/9904544.html

。。。。

注：本文以PDF持续更新，最新尼恩架构笔记、面试题的PDF文件，请到《技术自由圈》公众号领取

ok，是不是很简单

源码请参见《Java高并发核心编程卷3加强版，老版本为SpringCloudNginx高并发核心编程》一书源码虽然SpringCloud入门很简单，但是原理很复杂，而且掌握SpringCloud原理，是成为核心工厂师的必备知识

微服务分布式系统的架构12次演进

在进入实操之前，咱们来点微服务分布式系统的架构演进。

在尼恩的《Java高并发核心编程卷3加强版，老版本为SpringCloudNginx高并发核心编程》一书中，对亿级流量的系统架构，做了一个内部的分析。

本文《SpringCloudAlibaba学习圣经》与之相配合，介绍一下微服务分布式系统的架构演进。

《Java高并发核心编程卷3加强版》的亿级流量的系统架构，大家更加要好好看看，可以结合起来看。

微服务分布式系统的几个基础概念

在介绍架构之前，为了避免部分读者对架构设计中的一些概念不了解，下面对几个微服务分布式系统中最基础的概念进行介绍。

1）什么是分布式？

系统中的多个模块在不同服务器上部署，即可称为分布式系统，如Tomcat和数据库分别部署在不同的服务器上，或两个相同功能的Tomcat分别部署在不同服务器上。

2）什么是高可用？

系统中部分节点失效时，其他节点能够接替它继续提供服务，则可认为系统具有高可用性。

3）什么是集群？

一个特定领域的软件部署在多台服务器上并作为一个整体提供一类服务，这个整体称为集群。

如Zookeeper中的Master和Slave分别部署在多台服务器上，共同组成一个整体提供集中配置服务。

在常见的集群中，客户端往往能够连接任意一个节点获得服务，并且当集群中一个节点掉线时，其他节点往往能够自动的接替它继续提供服务，这时候说明集群具有高可用性。

4）什么是负载均衡？

请求发送到系统时，通过某些方式把请求均匀分发到多个节点上，使系统中每个节点能够均匀的处理请求负载，则可认为系统是负载均衡的。

5）什么是正向代理和反向代理？

系统内部要访问外部网络时，统一通过一个代理服务器把请求转发出去，在外部网络看来就是代理服务器发起的访问，此时代理服务器实现的是正向代理；

当外部请求进入系统时，代理服务器把该请求转发到系统中的某台服务器上，对外部请求来说，与之交互的只有代理服务器，此时代理服务器实现的是反向代理。

简单来说，正向代理是代理服务器代替系统内部来访问外部网络的过程，反向代理是外部请求访问系统时通过代理服务器转发到内部服务器的过程。

注：本文以PDF持续更新，最新尼恩架构笔记、面试题的PDF文件，请到《技术自由圈》公众号领取

架构演进1：单机架构

在网站最初时，应用数量与用户数都较少，可以把Java应用（主要是Tomcat承载）和数据库部署在同一台服务器上。

浏览器往发起请求时，首先经过DNS服务器（域名系统）把域名转换为实际IP地址10.102.4.1，浏览器转而访问该IP对应的Tomcat。

具体的架构图，如下：

架构演进1：单机架构

架构瓶颈：

随着用户数的增长，Tomcat和数据库之间竞争资源，单机性能不足以支撑业务。

架构演进2：引入缓存架构

随着吞吐量的提升，不得不引入引入缓存架构。通过缓存能把绝大多数请求在读写数据库前拦截掉，大大降低数据库压力。

含:本地缓存和分布式缓存

架构演进2：引入缓存架构

在Tomcat同服务器上或同JVM中增加本地缓存，并在外部增加分布式缓存，缓存热门商品信息或热门商品的html页面等。

涉及的技术包括：

使用caffeine作为本地缓存，使用Redis作为分布式缓存

架构瓶颈：

（1）这里会涉及缓存穿透/击穿、缓存雪崩、热点数据集中失效等问题

（2）这里会涉及缓存一致性的问题

（3）这里会涉及hotkey的问题

有关上面问题的解决方案：

请参见尼恩的《100Wqps三级缓存组件实操》+《100WqpsCaffeine底层源码、架构实操实操》

架构演进3：接入层引入反向代理实现负载均衡

接下来，缓存抗住了大部分的访问请求，服务层Tomcat上还是吞吐量低，响应逐渐变慢，需要进行架构演进。

在多台服务器上分别部署Tomcat，使用反向代理软件（Nginx）把请求均匀分发到每个Tomcat中。

架构演进3：接入层引入反向代理实现负载均衡

此处假设Tomcat最多支持100个并发，Nginx最多支持50000个并发，那么理论上Nginx把请求分发到500个Tomcat上，就能抗住50000个并发。

其中涉及的技术包括：Nginx、HAProxy，

两者都是工作在网络第七层的反向代理软件，主要支持http协议，还会涉及session共享、文件上传下载的问题。

架构演进4：数据库读写分离

反向代理使服务层的并发量大大增加，但并发量的增长也意味着：更多请求会穿透到数据库，数据库最终成为瓶颈。

数据库如何高并发？

简单的方案：把数据库划分为读库和写库，读库可以有多个，

读库和写库之间，如何实现数据一致性？

简单的方案：可以通过DB的同步机制，把写库的数据同步到读库，对于需要查询最新写入数据场景，可通过在缓存中多写一份，通过缓存获得最新数据。

数据库读写分离的架构如下：

架构演进4：数据库读写分离架构

其中涉及的技术包括：shardingjdbc，它是数据库中间件，可通过它来组织数据库的分离读写和分库分表，客户端通过它来访问下层数据库，还会涉及数据同步，数据一致性的问题。

有关上面分库分表解决方案：

请参见尼恩的《10Wqps日志平台实操》，对分库分表方案，做了非常详解的架构介绍，并且在实操维度，对其中的核心的组件分布式ID，结合雪花id源码，百度id源码，shardingjdbcid源码，做了深入骨髓的介绍。

架构演进5：数据库按业务分库

业务逐渐变多，不同业务之间的访问量差距较大，不同业务直接竞争数据库，相互影响性能。

随着用户数的增长，单机的写库会逐渐会达到性能瓶颈。

把不同业务的数据保存到不同的数据库中，使业务之间的资源竞争降低，对于访问量大的业务，可以部署更多的服务器来支撑。

架构演进5：数据库按业务分库

有关上面分库分表解决方案：

架构演进6：使用LVS或F5接入层负载均衡

随着吞吐量大于5W，接入层Nginx扛不住了

由于瓶颈在Nginx，因此无法LVS或F5来实现多个Nginx的负载均衡。

架构演进6：使用LVS或F5接入层负载均衡

图中的LVS和F5是工作在网络第四层的负载均衡解决方案，区别是：

(1)LVS是软件，运行在操作系统内核态，可对TCP请求或更高层级的网络协议进行转发，因此支持的协议更丰富，并且性能也远高于Nginx，可假设单机的LVS可支持几十万个并发的请求转发；

(2)F5是一种负载均衡硬件，与LVS提供的能力类似，性能比LVS更高，但价格昂贵。

如果不是财大气粗的guoqi，推荐使用LVS。

由于LVS是单机版的软件，若LVS所在服务器宕机则会导致整个后端系统都无法访问，因此需要有备用节点。

LVS如何高可用呢？

可使用keepalived软件模拟出虚拟IP，然后把虚拟IP绑定到多台LVS服务器上，浏览器访问虚拟IP时，会被路由器重定向到真实的LVS服务器

当主LVS服务器宕机时，keepalived软件会自动更新路由器中的路由表，把虚拟IP重定向到另外一台正常的LVS服务器，从而达到LVS服务器高可用的效果。

架构演进7：通过DNS轮询实现机房间的负载均衡

由于LVS也是单机的，随着并发数增长到几十万时，LVS服务器最终会达到瓶颈，此时用户数达到千万甚至上亿级别，用户分布在不同的地区，与服务器机房距离不同，导致了访问的延迟会明显不同。

此时，可以使用DNS进行负载均衡：在DNS服务器中可配置一个域名对应多个IP地址，每个IP地址对应到不同的机房里的虚拟IP。

架构演进7：通过DNS轮询实现机房间的负载均衡

当用户访问taobao时，DNS服务器会使用轮询策略或其他策略，来选择某个IP供用户访问。

此方式能实现机房间的负载均衡

至此，系统可做到机房级别的水平扩展，千万级到亿级的并发量都可通过增加机房来解决，系统入口处的请求并发量不再是问题。

问题是，光用DNS进行简单的LVS负载均衡，是不够的。

所以呢？大部分的大厂应用，都是采用智能DNS+接入层流量二次路由的模式，具体的案例，可以来找尼恩进行交流，这里不做展开。主要是内容太多啦。

架构演进8：引入NoSQL数据库和搜索引擎等技术

随着数据的丰富程度和业务的发展，检索、分析等需求越来越丰富，单单依靠数据库无法解决如此丰富的需求。

当数据库中的数据多到一定规模时，数据库就不适用于复杂的查询了，往往只能满足普通查询的场景。

对于统计报表场景，在数据量大时不一定能跑出结果，而且在跑复杂查询时会导致其他查询变慢

对于全文检索、可变数据结构等场景，数据库天生不适用，使用elasticsearch分布式搜索引擎解决。

如对于海量文件存储，可通过分布式文件系统hbase解决

架构演进8：引入NoSQL数据库和搜索引擎等技术

对于全文检索场景，可通过搜索引擎如ElasticSearch解决，对于多维分析场景，可通过Kylin或Druid等方案解决。

当然，引入更多组件同时会提高系统的复杂度，不同的组件保存的数据需要同步，需要考虑一致性的问题，需要有更多的运维手段来管理这些组件等。

接下来尼恩会讲云原生+大数据的架构，就是介绍的这套方案。

架构演进9：大应用拆分为微服务

引入更多组件解决了丰富的需求，业务维度能够极大扩充，随之而来的是一个应用中包含了太多的业务代码，业务的升级迭代、部署维护变得困难，效率低下。

解决方式是，进行业务的解耦。按照业务板块来划分应用代码，使单个应用的职责更清晰，相互之间可以做到独立升级迭代。

不同的业务，可以解耦成不同的微服务。

这样的服务就是所谓的微服务，应用和服务之间通过HTTP、TCP或RPC请求等多种方式来访问公共服务，每个单独的服务都可以由单独的团队来管理。

此外，可以通过Dubbo、SpringCloud等框架实现服务治理、限流、熔断、降级等功能，提高服务的稳定性和可用性。

这时候应用之间可能会涉及到一些公共配置，可以通过分布式配置中心Nacos来解决。

架构演进9：大应用拆分为微服务

架构演进10：引入企业服务总线ESB对微服务进行编排

由于不同服务之间存在共用的模块，由微服务单独管理会导致相同代码存在多份，导致公共功能升级时全部应用代码都要跟着升级。

不同微服务的接口访问方式不同，微服务代码需要适配多种访问方式才能使用，此外，微服务访问微服务，微服务之间也可能相互访问，调用链将会变得非常复杂，逻辑变得混乱。

在微服务的基础上，以应用为单位，进行微服务的分组，并且引入企业服务总线ESB，对微服务进行编排，形成应用。

架构演进10：引入企业服务总线ESB对微服务进行编排

通过ESB统一进行访问协议转换，应用统一通过ESB来访问后端服务，服务与服务之间也通过ESB来相互调用，以此降低系统的耦合程度。

这种微服务编排为多个应用，公共服务单独抽取出来来管理，并使用企业消息总线来解除服务之间耦合问题的架构。

接下来尼恩会讲ESB架构，就是介绍的这套方案。

架构演进11：引入容器化技术实现动态扩容和缩容

业务不断发展，应用和服务都会不断变多，应用和服务的部署变得复杂，同一台服务器上部署多个服务还要解决运行环境冲突的问题

此外，对于如大促这类需要动态扩缩容的场景，需要水平扩展服务的性能，就需要在新增的服务上准备运行环境，部署服务等，运维将变得十分困难。

目前最流行的容器化技术是Docker，最流行的容器管理服务是Kubernetes(K8S)，应用/服务可以打包为Docker镜像，通过K8S来动态分发和部署镜像。

Docker镜像可理解为一个能运行你的应用/服务的最小的操作系统，里面放着应用/服务的运行代码，运行环境根据实际的需要设置好。

把整个“操作系统”打包为一个镜像后，就可以分发到需要部署相关服务的机器上，直接启动Docker镜像就可以把服务起起来，使服务的部署和运维变得简单。

有关Docker+Kubernetes(K8S)的内容，请参见尼恩的电子书：

由于内容确实太多，所以写多个pdf电子书：

(1)《Docker学习圣经》PDF

(2)《SpringCloudAlibaba微服务学习圣经》PDF

使用Docker+Kubernetes(K8S)后，在大促的之前，可以在现有的机器集群上划分出服务器来启动Docker镜像，增强服务的性能

架构演进11：引入容器化技术实现动态扩容和缩容

大促过后就可以关闭镜像，对机器上的其他服务不造成影响。

架构演进12：以云平台承载系统

使用容器化技术后服务动态扩缩容问题得以解决，但是机器还是需要公司自身来管理，在非大促的时候，还是需要闲置着大量的机器资源来应对大促，机器自身成本和运维成本都极高，资源利用率低。

架构演进12：以云平台承载系统

系统可部署到公有云上，利用公有云的海量机器资源，解决动态硬件资源的问题

在大促的时间段里，在云平台中临时申请更多的资源，结合Docker和K8S来快速部署服务，在大促结束后释放资源，真正做到按需付费，资源利用率大大提高，同时大大降低了运维成本。

所谓的云平台，就是把海量机器资源，通过统一的资源管理，抽象为一个资源整体

在云平台上可按需动态申请硬件资源（如CPU、内存、网络等），并且之上提供通用的操作系统，提供常用的技术组件（如Hadoop技术栈，MPP数据库等）供用户使用，甚至提供开发好的应用

用户不需要关心应用内部使用了什么技术，就能够解决需求（如音视频转码服务、邮件服务、个人博客等）。

在云平台中会涉及如下几个概念：

IaaS：基础设施即服务。对应于上面所说的机器资源统一为资源整体，可动态申请硬件资源的层面；PaaS：平台即服务。对应于上面所说的提供常用的技术组件方便系统的开发和维护；SaaS：软件即服务。对应于上面所说的提供开发好的应用或服务，按功能或性能要求付费。

至此：以上所提到的从高并发访问问题，到服务的架构和系统实施的层面都有了各自的解决方案。

架构演进的涉及的核心知识

通过以上架构的演进，可以看出：

（1）开发侧：重点的知识体系是SpringCloud+Nginx的基础架构；

有关SpringCloud+Nginx的知识，请阅读本文《SpringCloudAlibaba学习圣经》和与之相配合的《Java高并发核心编程卷3加强版》

《Java高并发核心编程卷3加强版》

（2）运维侧：重点的知识体系是docker+k8s的基础架构；

有关docker+k8s的知识，请阅读本文《docker学习圣经》和与之相配合的《K8s学习圣经》

搞定这些，应对亿级流量，就具备了基础的知识底座。

本文，聚焦SpringCloud的学习，主要是SpringCloudAlibaba的学习。

SpringCloudnetflix入门

要了解SpringCloudAlibaba，先得了解SpringCloudnetflix。

为啥？SpringCloudAlibaba仅仅是在SpringCloudnetflix的基础上，替换了部分组件。比如说注册中心，比如RPC组件。

所以，咱们得从SpringCloudnetflix开始。

SpringCloudNetflix全家桶是Pivotal团队提供的一整套微服务开源解决方案，包括服务注册与发现、配置中心、全链路监控、服务网关、负载均衡、断路器等组件，以上的组件主要通过对NetFilx的NetFlixOSS套件中的组件通过整合完成的，其中，比较重要的整合组件有:

（1）spring-cloud-netflix-Eureka注册中心

（2）spring-cloud-netflix-hystrixRPC保护组件

（3）spring-cloud-netflix-ribbon客户端负载均衡组件

（4）spring-cloud-netflix-zuul内部网关组件

（6）spring-cloud-config配置中心

SpringCloud全家桶技术栈除了对NetFlixOSS的开源组件做整合之外，还有整合了一些选型中立的开源组件。比如，SpringCloudZookeeper组件整合了Zookeeper，提供了另一种方式的服务发现和配置管理。

SpringCloud架构中的单体业务服务是基于SpringBoot应用进行启动和执行的。SpringBoot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。SpringCloud利用SpringBoot是什么关系呢？

（1）首先SpringCloud利用SpringBoot开发便利性巧妙地简化了分布式系统基础设施的开发；

（2）其次SpringBoot专注于快速方便地开发单体微服务提供者，而SpringCloud解决的是各微服务提供者之间的协调治理关系；

（3）第三SpringBoot可以离开SpringCloud独立使用开发项目，但是SpringCloud离不开SpringBoot，其依赖SpringBoot而存在。

最终，SpringCloud将SpringBoot开发的一个个单体微服务整合并管理起来，为各单体微服务提供配置管理、服务发现、断路器、路由、微代理、事件总线、全局锁、决策竞选、分布式会话等等基础的分布式协助能力。

SpringCloud开发脚手架

无论是单体应用还是分布式应用，如果从零开始开发，都会涉及很多基础性的、重复性的工作需要做，比如用户认证，比如session管理等等。有了开发脚手架，这块基础工作就可以省去，直接利用脚手架提供的基础模块，然后按照脚手架的规范进行业务模块的开发即可。

笔者看了开源平台的不少开源的脚手架，发现很少是可以直接拿来做业务模块开发的，或者封装的过于重量级而不好解耦，或者业务模块分包不清晰而不方便开发，所以，本着简洁和清晰的原则，笔者的发起的疯狂创客圈社群推出了自己的微服务开发脚手架crazy-springcloud，其大致的模块和功能具体如下：

在业务模块如何分包的问题上，实际上大部分企业都有自己的统一规范。crazy-springcloud脚手架从职责清晰、方便维护、能快速导航代码的角度出发，将每一个业务模块，细分成以下三个子模块：

（1）{module}-api

此子模块定义了一些公共的Constants业务常量和DTO传输对象，该子模块既被业务模块内部依赖，也可能被依赖该业务模块的外部模块所依赖；

（2）{module}-client

此子模块定义了一些被外部模块所依赖的Feign远程调用客户类，该子模块是专供外部的模块，不能被内部的其他子模块所依赖；

（3）{module}-provider

此子模块是整个业务模块的核心，也是一个能够独立启动、运行的服务提供者（Application），该模块包含涉及到业务逻辑的controller层、service层、dao层的完整代码实现。

crazy-springcloud微服务开发脚手架在以下两方面进行了弱化：

（1）在部署方面对容器的介绍进行了弱化，没有使用Docker容器而是使用Shell脚本。有多方面的原因：一是本脚手架初心是学习，使用Shell脚本而不是Docker去部署，方便大家学习Shell命令和脚本；二是Java和Docker其实整合得很好，学习非常容易，可以稍加配置就能做到一键发布，找点资料就可以掌握；三是部署和运维是一个专门的工作，生产环境的部署、甚至是整个自动化构建和部署的工作，实际上属于运维的专项工作，由专门的运维岗位人员去完成，而部署的核心仍然是Shell脚本，所以对于开发人员来说掌握Shell脚本才是重中之重。

（2）对监控软件的介绍进行了弱化。本书没有对链路监控、JVM性能指标、断路器监控软件的使用做专门介绍。有多方面的原因：一是监控的软件太多，如果介绍太全，篇幅又不够，介绍太少，大家又不一定用到；二是监控软件的使用大多是一些软件的操作步骤和说明，原理性的内容比较少，使用视频的形式会比文字形式知识传递的效果会更好。疯狂创客圈后续可能（但不一定）会推出一些微服务监控方面的教学视频供大家参考，请大家关注社群博客。不论如何，只要掌握了SpringCloud核心原理，对那些监控组件使用的掌握，对大家来说基本上都是一碟小菜。

启动EurekaServer注册中心

Eureka本身是Netflix开源的一款注册中心产品，并且SpringCloud提供了相应的集成封装，选择其作为注册中心的讲解实例，是出于以下的原因：

（1）Eureka在业界的应用十分广泛（尤其是国外），整个框架也经受住了Netflix严酷生产环境的考验。

（2）除了Eureka注册中心，Netflix的其他服务治理功能也十分强大，包括Ribbon、Hystrix、Feign、Zuul等组件，结合到一起组成了一套完整的服务治理框架，使得服务的调用、路由也变得异常容易。

那么，Netflix和SpringCloud是什么关系呢？

Netflix是一家互联网流媒体播放商，是美国视频巨头，访问量非常的大。也正是如此，Netflix把整体的系统迁移到了微服务架构。并且，Netflix就把它的几乎整个微服务治理生态中的组件，都开源贡献给了Java社区，叫做NetflixOSS。

SpringCloud是Spring背后的Pivotal公司（由EMC和VMware联合成立的公司）在2015年推出的开源产品，主要对Netflix开源组件的进一步封装，方便Spring开发人员构建微服务架构的应用。

SpringCloudEureka是SpringCloudNetflix微服务套件的一部分，基于NetflixEureka做了二次封装，主要负责完成微服务实例的自动化注册与发现，这也是微服务架构中最为核心和基础的功能。

Eureka所治理的每一个微服务实例，被称之为ProviderInstance(提供者实例)。每一个ProviderInstance微服务实例包含一个EurekaClient客户端组件（相当于注册中心客户端组件），其主要的工作为：

（1）向EurekaServer完成ProviderInstance的注册、续约和下线等操作，主要的注册信息包括服务名、机器IP、端口号、域名等等。

（2）向EurekaServer获取ProviderInstance清单，并且缓存在本地。

一般来说，EurekaServer作为服务治理应用，会独立地部署和运行。一个EurekaServer注册中心应用在新建的时候，首先需要在pom.xml文件中添加上eureka-server依赖库。

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

然后，需要在启动类中添加注解@EnableEurekaServer，声明这个应用是一个EurekaServer，启动类的代码如下：

packagecom.crazymaker.springcloud.cloud.center.eureka;\nimportorg.springframework.boot.SpringApplication;\nimportorg.springframework.boot.autoconfigure.SpringBootApplication;\nimportorg.springframework.cloud.netflix.eureka.server.EnableEurekaServer;\n//在启动类中添加注解@EnableEurekaServer\n@EnableEurekaServer\n@SpringBootApplication\npublicclassEurekaServerApplication{\npublicstaticvoidmain(String[]args){\nSpringApplication.run(EurekaServerApplication.class,args);\n}\n}

然后，在应用配置文件application.yml中，对EurekaServer的一些参数进行配置。一份基础的配置文件大致如下：

server:\nport:7777\nspring:\napplication:\nname:eureka-server\neureka:\nclient:\nregister-with-eureka:false\nfetch-registry:false\nservice-url:\n开启自我保护\neviction-interval-timer-in-ms:60000配置中心端口\nspring:\napplication:\nname:config-server设置读取本地配置文件\ncloud:\nconfig:\nserver:\nnative:\nsearchLocations:classpath:config/访问路径优先使用IP地址\nstatus-page-url-path:/${server.servlet.context-path}${management.endpoints.web.base-path}/info\nhealth-check-url-path:/${server.servlet.context-path}${management.endpoints.web.base-path}/health\nclient:\negister-with-eureka:true是否去注册中心获取其他服务\nserviceUrl:\ndefaultZone:http://${EUREKA_ZONE_HOST:localhost}:7777/eureka/

在详细介绍上面的配置项之前，先启动一下Provider的启动类，控制台的日志大致如下：

…com.netflix.discovery.DiscoveryClient-DiscoveryClient_UAA-PROVIDER/192.168.233.128:7702:registeringservice…\n….\n…com.netflix.discovery.DiscoveryClient-DiscoveryClient_UAA-PROVIDER/192.168.233.128:7702-registrationstatus:204

如果看到上面的日志，表明Provider实例已经启动成功。可以进一步通过EurekaServer检查服务是否注册成功：打开EurekaServer的控制台界面，可以看到uua-provider的一个实例已经成功注册，具体如下图所示。

图：uua-provider实例已经在成功注册到EurekaServer

前面讲到，SpringCloud中一个Provider实例身兼两者角色：Provider服务提供者、注册中心客户端。所以，在Provider的配置文件中，包含了两类配置：Provider实例角色的相关配置、EurekaClient客户端角色的相关配置。有关的Provider实例角色的相关配置，请参考《SpringCloudNginx高并发核心编程》一书。

uaa-provider实现一个Rest接口

以uaa-Provider的获取用户信息接口为例，进行介绍，

这里实现一个获取用户信息的接口/api/user/detail/v1，该接口的具体的代码，在uaa-Provider模块中，如下图所示：

具体的代码如下：

packagecom.crazymaker.springcloud.user.info.controller;\n\nimportcom.alibaba.fastjson.JSONObject;\nimportcom.crazymaker.springcloud.common.dto.UserDTO;\nimportcom.crazymaker.springcloud.common.result.RestOut;\nimportcom.crazymaker.springcloud.user.info.service.impl.FrontUserEndSessionServiceImpl;\nimportio.swagger.annotations.Api;\nimportio.swagger.annotations.ApiOperation;\nimportorg.springframework.security.crypto.password.PasswordEncoder;\nimportorg.springframework.web.bind.annotation.GetMapping;\nimportorg.springframework.web.bind.annotation.RequestMapping;\nimportorg.springframework.web.bind.annotation.RequestParam;\nimportorg.springframework.web.bind.annotation.RestController;\n\nimportjavax.annotation.Resource;\n\n\n@Api(value=&34;,tags={&34;})\n@RestController\n@RequestMapping(&34;)\npublicclassUserController\n{\n\n@Resource\nprivateFrontUserEndSessionServiceImpluserService;\n/**\n*注入全局的加密器\n*/\n@Resource\nPasswordEncoderpasswordEncoder;\n\n@GetMapping(&34;)\n@ApiOperation(value=&34;)\npublicRestOut<UserDTO>getUser(@RequestParam(value=&34;,required=true)LonguserId)\n{\nUserDTOdto=userService.getUser(userId);\nif(null==dto)\n{\nreturnRestOut.error(&34;);\n}\nreturnRestOut.success(dto).setRespMsg(&34;);\n}\n\n\n@GetMapping(&34;)\n@ApiOperation(value=&34;)\npublicRestOut<String>passwordEncoder(\n@RequestParam(value=&34;,required=true)Stringraw)\n{\n\n//passwordEncoder=PasswordEncoderFactories.createDelegatingPasswordEncoder();\nStringencode=passwordEncoder.encode(raw);\nreturnRestOut.success(encode);\n}\n}

uaa-provider的运行结果

获取用户信息：

注：本文以PDF持续更新，最新尼恩架构笔记、面试题的PDF文件，请到《技术自由圈》公众号领取

demo-provider完成RPC远程调用

demo-provider使用Feign+Ribbon进行RPC远程调用时，对每一个Java远程调用接口，Feign都会生成了一个RPC远程调用客户端实现类，只是，该实现类对于开发者来说是透明的，开发者感觉不到这个类的存在。

需要在Maven的pom文件中，增加以下Feign+Ribbon集成模块的依赖：

<!–导入SpringCloudRibbon–>\n<dependency>\n<groupId>org.springframework.cloud</groupId>\n<artifactId>spring-cloud-starter-netflix-ribbon</artifactId>\n</dependency>\n\n<!–添加Feign依赖–>\n<dependency>\n<groupId>org.springframework.cloud</groupId>\n<artifactId>spring-cloud-starter-openfeign</artifactId>\n</dependency>

客户端RPC实现类位于远程调用Java接口和服务提供者Provider之间，承担了以下职责：

（1）拼装REST请求：根据Java接口的参数，拼装目标REST接口的URL；

（2）发送请求和获取结果：通过JavaHTTP组件（如HttpClient）调用服务提供者Provider的REST接口，并且获取REST响应；

（3）结果解码：解析REST接口的响应结果，封装成目标POJO对象（Java接口的返回类型），并且返回。

REST服务的本地代理接口

该接口的具体的代码，在uaa-client模块中，如下图所示：

REST服务的本地代理接口代码

具体的代码如下：

packagecom.crazymaker.springcloud.user.info.remote.client;\n\nimportcom.crazymaker.springcloud.common.dto.UserDTO;\nimportcom.crazymaker.springcloud.common.result.RestOut;\nimportcom.crazymaker.springcloud.standard.config.FeignConfiguration;\nimportcom.crazymaker.springcloud.user.info.remote.fallback.UserClientFallback;\nimportcom.crazymaker.springcloud.user.info.remote.fallback.UserClientFallbackFactory;\nimportcom.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;\nimportorg.springframework.cloud.openfeign.FeignClient;\nimportorg.springframework.web.bind.annotation.RequestMapping;\nimportorg.springframework.web.bind.annotation.RequestMethod;\nimportorg.springframework.web.bind.annotation.RequestParam;\n\n/**\n*Feign客户端接口\n*@description:用户信息远程调用接口\n*@date2019年7月22日\n*/\n\n@FeignClient(value=&34;,\nconfiguration=FeignConfiguration.class,\nfallback=UserClientFallback.class,\n//fallbackFactory=UserClientFallbackFactory.class,\npath=&34;)\npublicinterfaceUserClient\n{\n/**\n*远程调用RPC方法：获取用户详细信息\n*@paramuserId用户Id\n*@return用户详细信息\n*/\n@RequestMapping(value=&34;,method=RequestMethod.GET)\nRestOut<UserDTO>detail(@RequestParam(value=&34;)LonguserId);\n}

通过REST服务的本地代理接口，进行RPC调用

进行RPC调用的具体的代码，在demo-provider模块中，如下图所示：

packagecom.crazymaker.springcloud.demo.controller;\n\nimportcom.alibaba.fastjson.JSONObject;\nimportcom.alibaba.fastjson.TypeReference;\nimportcom.crazymaker.springcloud.common.dto.UserDTO;\nimportcom.crazymaker.springcloud.common.result.RestOut;\nimportcom.crazymaker.springcloud.common.util.JsonUtil;\nimportcom.crazymaker.springcloud.user.info.remote.client.UserClient;\nimportcom.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;\nimportio.swagger.annotations.Api;\nimportio.swagger.annotations.ApiOperation;\nimportorg.springframework.boot.web.client.RestTemplateBuilder;\nimportorg.springframework.http.ResponseEntity;\nimportorg.springframework.web.bind.annotation.GetMapping;\nimportorg.springframework.web.bind.annotation.RequestMapping;\nimportorg.springframework.web.bind.annotation.RequestParam;\nimportorg.springframework.web.bind.annotation.RestController;\nimportorg.springframework.web.client.RestTemplate;\n\nimportjavax.annotation.Resource;\n\n\n@RestController\n@RequestMapping(&34;)\n@Api(tags=&34;)\npublicclassUaaRemoteCallController\n{\n\n//注入@FeignClient注解配置所配置的客户端实例\n@Resource\nUserClientuserClient;\n\n@GetMapping(&34;)\n@ApiOperation(value=&34;)\npublicRestOut<JSONObject>remoteCallV2(\n@RequestParam(value=&34;)LonguserId)\n{\nRestOut<UserDTO>result=userClient.detail(userId);\nJSONObjectdata=newJSONObject();\ndata.put(&34;,result);\nreturnRestOut.success(data).setRespMsg(&34;);\n}\n}

demo-provider需要依赖uaa-client模块

启动demo-provider

访问swaggerui：

通过swagger执行RPC操作

SpringCloudEureka服务注册

Eureka作为老牌SpringCloud注册中心，很多项目，仍然在使用，

另外，底层原理都是想通的，大家可以和nacos对比学习

Eureka的详细介绍，请阅读《Java高并发核心编程卷3加强版》

SpringCloudConfig统一配置

SpringCloudConfig作为老牌SpringCloud配置中心，很多项目，仍然在使用，

另外，底层原理都是想通的，大家可以和nacos对比学习

SpringCloudConfig的详细介绍，请阅读《Java高并发核心编程卷3加强版》

Nacos服务注册+统一配置

1、Nacos优势

问题，既然有了Eureka，为啥还要用Nacos？

而Nacos作为微服务核心的服务注册与发现中心，让大家在Eureka和Consule之外有了新的选择，开箱即用，上手简洁，暂时也没发现有太大的坑。

1.1与eureka对比

1eureka2.0闭源码了。

2从官网来看nacos的注册的实例数是大于eureka的,

3因为nacos使用的raft协议,nacos集群的一致性要远大于eureka集群.

分布式一致性协议Raft，自2013年论文发表，之后就受到了技术领域的热捧，与其他的分布式一致性算法比，Raft相对比较简单并且易于实现，这也是Raft能异军突起的主要因素。

Raft的数据一致性策略

Raft协议强依赖Leader节点来确保集群数据一致性。即client发送过来的数据均先到达Leader节点，Leader接收到数据后，先将数据标记为uncommitted状态，随后Leader开始向所有Follower复制数据并等待响应，在获得集群中大于N/2个Follower的已成功接收数据完毕的响应后，Leader将数据的状态标记为committed，随后向client发送数据已接收确认，在向client发送出已数据接收后，再向所有Follower节点发送通知表明该数据状态为committed。

1.2与springcloudconfig对比

三大优势：

springcloudconfig大部分场景结合git使用,动态变更还需要依赖SpringCloudBus消息总线来通过所有的客户端变化.springcloudconfig不提供可视化界面nacosconfig使用长连接更新配置,一旦配置有变动后，通知Provider的过程非常的迅速,从速度上秒杀springcloud原来的config几条街,

2、SpringCloudAlibaba套件

目前SpringCloudAlibaba主要有三个组件：

Nacos：一个更易于构建云原生应用的动态服务发现、配置管理和服务管理平台。Sentinel：把流量作为切入点，从流量控制、熔断降级、系统负载保护等多个维度保护服务的稳定性。AliCloudOSS:阿里云对象存储服务（ObjectStorageService，简称OSS），是阿里云提供的海量、安全、低成本、高可靠的云存储服务。您可以在任何应用、任何时间、任何地点存储和访问任意类型的数据。

SpringCloudAlibaba套件和SpringCloudNetflix套件类比

仔细看看各组件的功能描述，SpringCloudAlibaba套件和SpringCloudNetflix套件大致的对应关系：

Nacos=Eureka/Consule+Config+AdminSentinel=Hystrix+Dashboard+TurbineDubbo=Ribbon+FeignRocketMQ=RabbitMQSchedulerx=QuartzAliCloudOSS、AliCloudSLS这三个应该是独有的

链路跟踪（Sleuth、Zipkin）不知道会不会在Sentinel里

以上只是猜测，待我从坑里爬出来之后再回来更新。也欢迎大家一起交流探讨~

这里我就先试试Nacos。

3、Nacos的架构和安装

3.1Nacos的架构

Nacos的架构图

这是Nacos的架构图，可以看到它确实是融合了服务注册发现中心、配置中心、服务管理等功能，类似于Eureka/Consule+Config+Admin的合体。

另外通过官方文档发现，Nacos除了可以和SpringCloud集成，还可以和Spring、SpringBoot进行集成。

不过我们只关注于SpringCloud，别的就略过了，直接上手实战吧。

3.2NacosServer的下载和安装

在使用Nacos之前，需要先下载Nacos并启动NacosServer。

安装的参考教程：

https://www.cnblogs.com/crazymakercircle/p/11992539.html

4、NacosServer的运行

4.1两种模式

NacosServer有两种运行模式：

standalonecluster

4.2standalone模式

此模式一般用于demo和测试，不用改任何配置，直接敲以下命令执行

shbin/startup.sh-mstandalone

Windows的话就是

cmdbin/startup.cmd-mstandalone

然后从http://cdh1:8848/nacos/index.html进入控制台就能看到如下界面了

默认账号和密码为：nacosnacos

4.3cluster模式

测试环境，可以先用standalone模式撸起来，享受coding的快感，但是，生产环境可以使用cluster模式。

cluster模式需要依赖MySQL，然后改两个配置文件：

conf/cluster.conf\nconf/application.properties

大致如下：

1：cluster.conf，填入要运行NacosServer机器的ip

192.168.100.155\n192.168.100.156

修改NACOS_PATH/conf/application.properties，加入MySQL配置

db.num=1\ndb.url.0=jdbc:mysql://localhost:3306/nacos_config?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true\ndb.user=root\ndb.password=root

创建一个名为nacos_config的database，将NACOS_PATH/conf/nacos-mysql.sql中的表结构导入刚才创建的库中，这几张表的用途就自己研究吧

4.4NacosServer的配置数据是存在哪里呢？

问题来了：NacosServer的配置数据是存在哪里呢？

我们没有对NacosServer做任何配置，那么数据只有两个位置可以存储：

内存本地数据库

如果我们现在重启刚刚在运行的NacosServer，会发现刚才加的nacos.properties配置还在，说明不是内存存储的。

这时候我们打开NACOS_PATH/data，会发现里边有个derby-data目录，我们的配置数据现在就存储在这个库中。

Derby是Java编写的数据库，属于Apache的一个开源项目

如果将数据源改为我们熟悉的MySQL呢？当然可以。

注意：不支持MySQL8.0版本

这里有两个坑：

NacosServer的数据源是用Derby还是MySQL完全是由其运行模式决定的：

standalone的话仅会使用Derby，即使在application.properties里边配置MySQL也照样无视；\ncluster模式会自动使用MySQL，这时候如果没有MySQL的配置，是会报错的。

官方提供的cluster.conf示例如下

example\n10.10.109.214\n11.16.128.34\n11.16.128.36

以上配置结束后，运行NacosServer就能看到效果了。

5、实战1：使用Nacos作为注册中心

实战的工程

实战的工程的目录结构如下：

5.1如何使用NacosClient组件

首先引入SpringCloudAlibaba的BOM

<parent>\n<groupId>org.springframework.boot</groupId>\n<artifactId>spring-boot-starter-parent</artifactId>\n<version>2.0.4.RELEASE</version>\n<relativePath/>\n</parent>\n<properties>\n<spring-cloud.version>Finchley.SR2</spring-cloud.version>\n<spring-cloud-alibaba.version>0.2.0.RELEASE</spring-cloud-alibaba.version>\n</properties>\n<dependencyManagement>\n<dependencies>\n<dependency>\n<groupId>org.springframework.cloud</groupId>\n<artifactId>spring-cloud-alibaba-dependencies</artifactId>\n<version>${spring-cloud-alibaba.version}</version>\n<type>pom</type>\n<scope>import</scope>\n</dependency>\n<dependency>\n<groupId>org.springframework.cloud</groupId>\n<artifactId>spring-cloud-dependencies</artifactId>\n<version>${spring-cloud.version}</version>\n<type>pom</type>\n<scope>import</scope>\n</dependency>\n</dependencies>\n</dependencyManagement>

这里版本号有坑，文档上说和SpringBoot2.0.x版本兼容，但是实测2.0.6.RELEASE报错

java.lang.NoClassDefFoundError:org/springframework/core/env/EnvironmentCapable

5.2演示的模块结构

服务注册中心和服务发现的服务端都是由NacosServer来提供的，我们只需要提供Service向其注册就好了。

这里模拟提供两个service：provider和consumer

alibaba\n├──service-provider-demo\n│├──pom.xml\n│└──src\n└──sevice-consumer-demo\n│├──pom.xml\n│└──src\n└──pom.xml

5.3provider微服务

step1：在provider和consumer的pom添加以下依赖：

<dependency>\n<groupId>org.springframework.boot</groupId>\n<artifactId>spring-boot-starter-web</artifactId>\n</dependency>\n<dependency>\n<groupId>org.springframework.cloud</groupId>\n<artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>\n</dependency>

step2：启动类

使用SpringCloud的原生注解@EnableDiscoveryClient开启服务注册与发现

packagecom.crazymaker.cloud.nacos.demo.starter;\n\nimportcom.crazymaker.springcloud.standard.context.SpringContextUtil;\nimportlombok.extern.slf4j.Slf4j;\nimportorg.springframework.boot.SpringApplication;\nimportorg.springframework.boot.autoconfigure.SpringBootApplication;\nimportorg.springframework.cloud.client.discovery.EnableDiscoveryClient;\nimportorg.springframework.context.ConfigurableApplicationContext;\nimportorg.springframework.core.env.Environment;\nimportspringfox.documentation.swagger2.annotations.EnableSwagger2;\n\nimportjava.util.List;\n\n@EnableSwagger2\n@SpringBootApplication\n@EnableDiscoveryClient\n@Slf4j\npublicclassServiceProviderApplication{\npublicstaticvoidmain(String[]args){\nConfigurableApplicationContextapplicationContext=SpringApplication.run(ServiceProviderApplication.class,args);\n\nEnvironmentenv=applicationContext.getEnvironment();\nStringport=env.getProperty(&34;);\nStringpath=env.getProperty(&34;);\nSystem.out.println(&34;+\n&34;+\n&34;+port+path+&34;+\n&34;+port+path+&34;+\n&34;);\n\n}\n}

step3：服务提供者的Rest服务接口

service-provider-demo提供一个非常简单的Rest服务接口以供访问

packagecom.crazymaker.cloud.nacos.demo.controller;\n\nimportorg.springframework.web.bind.annotation.PathVariable;\nimportorg.springframework.web.bind.annotation.RequestMapping;\nimportorg.springframework.web.bind.annotation.RequestMethod;\nimportorg.springframework.web.bind.annotation.RestController;\n\n@RestController\n@RequestMapping(&34;)\npublicclassEchoController{\n//回显服务\n@RequestMapping(value=&34;,method=RequestMethod.GET)\npublicStringecho(@PathVariableStringstring){\nreturn&34;+string;\n}\n}

step4：配置文件

spring:\napplication:\nname:service-provider-demo\ncloud:\nnacos:\ndiscovery:\nserver-addr:${NACOS_SERVER:cdh1:8848}\nserver:\nport:18080

step5：启动之后，通过swaggerUI访问：

5.4Consumer微服务演示RPC远程调用

在NacosConsumerApplication中集成RestTemplate和Ribbon

@LoadBalanced\n@Bean\npublicRestTemplaterestTemplate(){\nreturnnewRestTemplate();\n}

消费者的controller类

packagecom.crazymaker.cloud.nacos.demo.consumer.controller;\n\nimportcom.crazymaker.cloud.nacos.demo.consumer.client.EchoClient;\nimportio.swagger.annotations.Api;\nimportio.swagger.annotations.ApiOperation;\nimportorg.springframework.web.bind.annotation.PathVariable;\nimportorg.springframework.web.bind.annotation.RequestMapping;\nimportorg.springframework.web.bind.annotation.RequestMethod;\nimportorg.springframework.web.bind.annotation.RestController;\n\nimportjavax.annotation.Resource;\n\n@RestController\n@RequestMapping(&34;)\n@Api(tags=&34;)\npublicclassEchoConsumerController{\n\n\n//注入@FeignClient注解配置所配置的EchoClient客户端Feign实例\n@Resource\nEchoClientechoClient;\n\n\n//回显服务\n@ApiOperation(value=&34;)\n@RequestMapping(value=&34;,method=RequestMethod.GET)\npublicStringechoRemoteEcho(@PathVariableStringstring){\nreturn&34;+echoClient.echo(string);\n}\n}

消费者配置文件

spring:\napplication:\nname:sevice-consumer-demo\ncloud:\nnacos:\ndiscovery:\nserver-addr:127.0.0.1:8848\nserver:\nport:18081

通过swaggerUI访问消费者：

访问远程的echoAPI：

5.5涉及到的演示地址：

服务提供者service-provider-demo：

http://localhost:18080/provider/swagger-ui.html/服务-消费者/echoRemoteEchoUsingGET](http://localhost:18081/consumer/swagger-ui.html/serviceManagement?dataId=&group=&appName=&namespace=

5.6NacosConsole

这时候查看NacosConsole也能看到已注册的服务列表及其详情

6、实战2：使用Nacos作为配置中心

6.1基本概念

1）Profile

Java项目一般都会有多个Profile配置，用于区分开发环境，测试环境，准生产环境，生成环境等，每个环境对应一个properties文件（或是yml/yaml文件），然后通过设置spring.profiles.active的值来决定使用哪个配置文件。

例子：

spring:\napplication:\nname:sharding-jdbc-provider\njpa:\nhibernate:\nddl-auto:none\ndialect:org.hibernate.dialect.MySQL5InnoDBDialect\nshow-sql:true\nprofiles:\nactive:sharding-db-tableactive:atomiclong-idactive:replica-query34;com.crazymaker.cloud.nacos.demo&34;com.crazymaker.springcloud.standard&34;com.crazymaker.cloud.nacos.demo.consumer.client&34;Serverstartupdone.&34;服务启动报错&34;server.port&34;server.servlet.context-path&34;\\n———————————————————-\\n\\t&34;Applicationisrunning!AccessURLs:\\n\\t&34;Local:\\t\\thttp://localhost:&34;/index.html\\n\\t&34;swagger-ui:\\thttp://localhost:&34;/swagger-ui.html\\n\\t&34;———————————————————-&34;/config&34;Nacos配置中心演示&34;${foo.bar:empty}&34;${spring.datasource.username:empty}&34;获取配置的内容&34;/bar&34;baris:&34;获取配置的dbusername&34;/dbusername&34;dbusernameis:&

执行结果如下：

6.4可以端如何与服务端的配置文件相互对应

config.prefix来对应主配置文件使用spring.cloud.nacos.config.ext-config选项来对应更多的文件eg：

spring:\napplication:\nname:nacos-config-demo-provider\nprofiles:\nactive:dev\ncloud:\nnacos:\ndiscovery:\nserver-addr:${NACOS_SERVER:cdh1:8848}\nconfig:\nserver-addr:${NACOS_SERVER:cdh1:8848}\nprefix:nacos-config-demo\ngroup:DEFAULT_GROUP\nfile-extension:yaml\next-config:\n-data-id:crazymaker-db-dev.yml\ngroup:DEFAULT_GROUP\nrefresh:true\n-data-id:crazymaker-redis-dev.yml\ngroup:DEFAULT_GROUP\nrefresh:true\n-data-id:crazymaker-common-dev.yml\ngroup:DEFAULT_GROUP\nrefresh:true\n-data-id:some.properties\ngroup:DEFAULT_GROUP\nrefresh:true

启动程序，发现可以获取到其他data-id的配置,大家可以自行配置。

7、配置的隔离

在实际的应用中，存在着以下几种环境隔离的要求：

1、开发环境、测试环境、准生产环境和生产环境需要隔离

2、不同项目需要隔离

3、同一项目，不同的模块需要隔离

可以通过三种方式来进行配置隔离：Nacos的服务器、namespace命名空间、group分组，在bootstrap.yml文件中可以通过配置Nacos的server-addr、namespace和group来区分不同的配置信息。

Nacos的服务器spring.cloud.nacos.config.server-addrNacos的命名空间spring.cloud.nacos.config.namespace，注意，这里使用命名空间的ID不是名称Nacos的分组spring.cloud.nacos.config.group

8、nacos集群搭建

如果我们要搭建集群的话，那么肯定是不能用内嵌的数据库，不然数据无法共享。所以，集群搭建的时候我们需要将Nacos对接Mysql进行数据存储。

集群模式跟我们平时进行扩容是一样的，可以通过Nginx转发到多个节点，最前面挂一个域名即可，如下图：

IP规划

通常如果我们只是为了体验的话，直接在本地起动3个实例就可以了，没必要真的去搞三台服务器，下面我们就以在本地的方式来搭建集群。将Nacos的解压包复制分成3份，分别是:

nacosnacos1nacos2

进入nacos的conf目录，编辑application.properties文件，增加数据库配置

数据库实例数量\ndb.num=1\ndb.url.0=jdbc:mysql://localhost:3306/nacos?characterEncoding=utf8&connectTimeout=1000&socketTimeout=3000&autoReconnect=true\ndb.user=root\ndb.password=123456

复制代码同样的步骤进入nacos1和nacos2操作一遍，唯一需要修改的就是application.properties文件中的server.port，默认nacos的server.port=8848，

我们在本地启动三个实例，那么端口肯定会冲突，所以其他2个实例的端口我们需要进行修改，比如nacos1修改成8847，nacos2修改成8846。

数据库配置信息好了后，我们需要将对应的数据库和表进行初始化，数据库脚本在conf目录下的nacos-mysql.sql中，执行即可。

最后一步需要配置一份集群节点信息，配置文件在conf目录下的cluster.conf.example文件，我们进行重命名成cluster.conf。然后编辑cluster.conf文件，增加3个节点的信息，格式为IP:PORT，三个目录都一致即可。

127.0.0.1:8848\n127.0.0.1:8847\n127.0.0.1:8846

启动的话直接到bin目录下，执行./startup.sh就可以了，默认就是集群模式，不需要加任何参数。

集群的使用

上面的集群，虽然可用，但仍不是真正的集群，我们一般不会这么用。nacos集群的使用一般有4种方式：

http://ip1:port/openAPI直连ip模式，不同的节点，则需要修改ip才可以使用。http://VIP:port/openAPIVIP模式高可用，客户端vip即可，VIP下面挂server真实ip，部署比较麻烦，需要部署vip（keepalive）。http://nacos.com:port/openAPI域名模式，可读性好，而且换ip方便，在host文件配置本地域名即可。http://反向代理:port/openAPI反向代理模式

这里介绍一下反向代理模式。

关于Nginx的安装和配置，本文就不进行讲解了，不会的可以自己去尝试下，反向代理模式核心配置如下：

upstreamnacos_server{\nserver127.0.0.1:8848;\nserver127.0.0.1:8847;\nserver127.0.0.1:8846;\n}\n\nserver{\nlisten8648;\nserver_namelocalhost;\naccess_loglogs/host.access.logmain;\nlocation/{\nproxy_passhttp://nacos_server;\nindexindex.htmlindex.htm;\n}\n}

整体来说，nacos的集群搭建方式还是挺简单的，没什么特别要注意的，最好是能通过域名的方式来进行访问，另外数据库这块如果上生产环境，也需要考虑高可用问题，至少也得有个主从。

8648的nginx提供的nacos服务接口，可以自定义。我们访问

http://localhost:8648/nacos/34;noserveravailable&34;request{}failed.&默认true\nspring:\n\tcloud:\n\t\tnacos:\n\t\t\tdiscovery:\n\t\t\t\tephemeral:true

注意：默认为临时实例，表示为临时实例。

注册实例支持ephemeral字段

如果是临时实例，则instance不会在Nacos服务端持久化存储，需要通过上报心跳的方式进行包活，

如果instance一段时间内没有上报心跳，则会被Nacos服务端摘除。

在被摘除后如果又开始上报心跳，则会重新将这个实例注册。

持久化实例则会持久化被Nacos服务端，此时即使注册实例的客户端进程不在，这个实例也不会从服务端删除，只会将健康状态设为不健康。

同一个服务下可以同时有临时实例和持久化实例，这意味着当这服务的所有实例进程不在时，会有部分实例从服务上摘除，剩下的实例则会保留在服务下。

使用实例的ephemeral来判断，ephemeral为true对应的是服务健康检查模式中的client模式,为false对应的是server模式。

Nacos1.0.0之前服务的健康检查模式有三种：client、server和none,分别代表客户端上报、服务端探测和取消健康检查。在控制台操作的位置如下所示：

在Nacos1.0.0中将把这个配置去掉，改为使用实例的ephemeral来判断，ephemeral为true对应的是服务健康检查模式中的client模式,为false对应的是server模式。

临时实例和持久化实例区别

临时和持久化的区别主要在健康检查失败后的表现，持久化实例健康检查失败后会被标记成不健康，而临时实例会直接从列表中被删除。

这个特性比较适合那些需要应对流量突增，而弹性扩容的服务，当流量降下来后这些实例自己销毁自己就可以了，不用再去nacos里手动调用注销实例。持久化以后，可以实时看到健康状态，便于做后续的告警、扩容等一系列处理。

NacosServer运行模式

Server的运行模式，是指NacosServer可以运行在多种模式下，当前支持三种模式：

APCPMIXED

这里的运行模式，使用的是CAP理论里的C、A和P概念。

CAP原则又称CAP定理，指的是在一个分布式系统中，Consistency（一致性）、Availability（可用性）、Partitiontolerance（分区容错性），三者不可得兼。

一致性（C）：在分布式系统中的所有数据备份，在同一时刻是否同样的值。（等同于所有节点访问同一份最新的数据副本）

可用性（A）：在集群中一部分节点故障后，集群整体是否还能响应客户端的读写请求。（对数据更新具备高可用性）

分区容忍性（P）：以实际效果而言，分区相当于对通信的时限要求。系统如果不能在时限内达成数据一致性，就意味着发生了分区的情况，必须就当前操作在C和A之间做出选择。

CAP原则的精髓就是要么AP，要么CP，要么AC，但是不存在CAP。如果在某个分布式系统中数据无副本，那么系统必然满足强一致性条件，因为只有独一数据，不会出现数据不一致的情况，此时C和P两要素具备，但是如果系统发生了网络分区状况或者宕机，必然导致某些数据不可以访问，此时可用性条件就不能被满足，即在此情况下获得了CP系统，但是CAP不可同时满足。

基于CAP理论，在分布式系统中，数据的一致性、服务的可用性和网络分区容忍性只能三者选二。一般来说分布式系统需要支持网络分区容忍性，那么就只能在C和A里选择一个作为系统支持的属性。C的准确定义应该是所有节点在同一时间看到的数据是一致的，而A的定义是所有的请求都会收到响应。

Nacos支持AP和CP模式的切换，这意味着Nacos同时支持两者一致性协议。这样，Nacos能够以一个注册中心管理这些生态的服务。不过在Nacos中，AP模式和CP模式的具体含义，还需要再说明下。

AP模式为了服务的可能性而减弱了一致性，因此AP模式下只支持注册临时实例。AP模式是在网络分区下也能够注册实例。在AP模式下也不能编辑服务的元数据等非实例级别的数据，但是允许创建一个默认配置的服务。同时注册实例前不需要进行创建服务的操作，因为这种模式下，服务其实降级成一个简单的字符创标识，不在存储任何属性，会在注册实例的时候自动创建。

CP模式下则支持注册持久化实例，此时则是以Raft协议为集群运行模式，因此网络分区下不能够注册实例，在网络正常情况下，可以编辑服务器别的配置。改模式下注册实例之前必须先注册服务，如果服务不存在，则会返回错误。

MIXED模式可能是一种比较让人迷惑的模式，这种模式的设立主要是为了能够同时支持临时实例和持久化实例的注册。这种模式下，注册实例之前必须创建服务，在服务已经存在的前提下，临时实例可以在网络分区的情况下进行注册。

NacosCP/AP模式设定

使用如下请求进行Server运行模式的设定：

curl-XPUT\n&39;

NacosCP/AP模式切换

Nacos集群默认支持的是CAP原则中的AP原则.

但是Nacos集群可切换为CP原则，切换命令如下：

curl-XPUT&39;

同时微服务的bootstrap.properties需配置如下选项指明注册为临时/永久实例AP模式不支持数据一致性，所以只支持服务注册的临时实例，CP模式支持服务注册的永久实例，满足配置文件的一致性

34;DELETEmse-xxx-p.nacos-ans.mse.aliyuncs.com:8848/nacos/v1/ns/service?serviceName=providers:com.alibaba.edas.boot.EchoService:1.0.0:DUBBO&groupName=DEFAULT_GROUP&注册中心配置\nregistry:\naddress:nacos://xxx\n\tparameters:\n\t\tnamespace:dubbo\ngroup:DUBBO_GROUP\n\ndubbo:\napplication:\nname:${spring.application.name}\nprotocol:\nname:dubbo\nport:-1\nregistry:\naddress:nacos://${NACOS_SERVER:cdh1:8848}\nusername:nacos\npassword:nacos\nparameters:\nnamespace:dubbo\ngroup:DUBBO_GROUP\nconfig-center:\naddress:nacos://${NACOS_SERVER:cdh1:8848}\nusername:nacos\npassword:nacos\ngroup:DUBBO_GROUP\nmetadata-report:\naddress:nacos://${NACOS_SERVER:cdh1:8848}\nusername:nacos\npassword:nacos\ngroup:DUBBO_GROUP

common-service模块

服务接口进行利旧复用

还是之前的UserClient老接口，openfegn注解都不去掉

packagecom.crazymaker.springcloud.user.info.remote.client;\n\nimportcom.crazymaker.springcloud.common.dto.UserDTO;\nimportcom.crazymaker.springcloud.common.result.RestOut;\nimportcom.crazymaker.springcloud.standard.config.FeignConfiguration;\nimportcom.crazymaker.springcloud.user.info.remote.fallback.UserClientFallbackFactory;\nimportorg.springframework.cloud.openfeign.FeignClient;\nimportorg.springframework.web.bind.annotation.RequestMapping;\nimportorg.springframework.web.bind.annotation.RequestMethod;\nimportorg.springframework.web.bind.annotation.RequestParam;\n\n/**\n*Feign客户端接口\n*@description:用户信息远程调用接口\n*@date2019年7月22日\n*/\n\n@FeignClient(value=&34;,\nconfiguration=FeignConfiguration.class,\n//fallback=UserClientFallback.class,\nfallbackFactory=UserClientFallbackFactory.class,\npath=&34;)\npublicinterfaceUserClient\n{\n/**\n*远程调用RPC方法：获取用户详细信息\n*@paramuserId用户Id\n*@return用户详细信息\n*/\n@RequestMapping(value=&34;,method=RequestMethod.GET)\nRestOut<UserDTO>detail(@RequestParam(value=&34;)LonguserId);\n\n@RequestMapping(value=&34;,method=RequestMethod.GET)\npublicStringhello(@RequestParam(value=&34;)Stringname);\n}

服务提供者实操：dubbo-provider服务

pom依赖

<!–dubbo–>\n<dependency>\n<groupId>org.apache.dubbo</groupId>\n<artifactId>dubbo</artifactId>\n</dependency>\n<dependency>\n<groupId>org.apache.dubbo</groupId>\n<artifactId>dubbo-registry-nacos</artifactId>\n<exclusions>\n<exclusion>\n<artifactId>nacos-client</artifactId>\n<groupId>com.alibaba.nacos</groupId>\n</exclusion>\n</exclusions>\n</dependency>\n\n<!–dubbostarter–>\n\n<dependency>\n<groupId>com.alibaba.nacos</groupId>\n<artifactId>nacos-client</artifactId>\n<version>${nacos-client-verson}</version>\n</dependency>

服务实现类

packagecom.crazymaker.cloud.dubbo.demo.sevice;\n\nimportcom.crazymaker.springcloud.common.dto.UserDTO;\nimportcom.crazymaker.springcloud.common.result.RestOut;\nimportcom.crazymaker.springcloud.user.info.remote.client.UserClient;\nimportorg.apache.dubbo.config.annotation.DubboService;\nimportorg.springframework.stereotype.Component;\n\n@DubboService\n@Component\n\npublicclassUserClientDubboServiceimplementsUserClient{\n@Override\npublicRestOut<UserDTO>detail(LonguserId){\nUserDTOdto=newUserDTO();\ndto.setUserId(userId);\ndto.setNickname(&34;);\nreturnRestOut.success(dto).setRespMsg(&34;);\n}\n\n@Override\npublicStringhello(Stringname){\nreturn&34;+name;\n}\n}

dubbo和Feign的一个不同

dubbo的服务发布和暴露，直接在service层加上注解，就完成了

比如：上面的案例中，加上一个类级别的注解，就可以暴露这个服务接口@DubboService

而Feign的服务接口发布，是在@Controller层完成的。

相对来说，比使用Dubbo更为笨重

Provider的Dubbo+Nacos配置文件

spring:\nsecurity:\nenabled:false\napplication:\nname:dubbo-provider-demo\n\n\nserver:\nport:28088\nservlet:\ncontext-path:/dubbo-provider-demo\n\n暴露端点\nmanagement:\nendpoints:\nweb:\nbase-path:&34;39;*&在yaml文件属于关键字，所以需要加引号\nendpoint:\nlogfile:\n控制台上的Logging模块下的Logfile会报错：Fetchinglogfilefailed.Requestfailedwithstatuscode404\nexternal-file:${log_dubbo_provider_demo_path_full:C:/logs/dubbo-provider-demo/logs/output.log}\nenabled:true\nhealth:\nshow-details:always\nboot:\ncontext-path:consumer\nmetrics:\ntags:\napplication:${spring.application.name}\nexport:\nprometheus:\nenabled:true\nstep:1m\ndescriptions:true\n\ndubbo:\nscan:\nbase-packages:com.crazymaker.cloud.dubbo\napplication:\nname:${spring.application.name}\nprotocol:\nname:dubbo\nport:-1\nregistry:\naddress:nacos://${NACOS_SERVER:cdh1:8848}\nusername:nacos\npassword:nacos\nparameters:\nnamespace:dubbo\ngroup:DUBBO_GROUP\nconfig-center:\naddress:nacos://${NACOS_SERVER:cdh1:8848}\nusername:nacos\npassword:nacos\ngroup:DUBBO_GROUP\nmetadata-report:\naddress:nacos://${NACOS_SERVER:cdh1:8848}\nusername:nacos\npassword:nacos\ngroup:DUBBO_GROUP

启动类加上@EnableDubbo注解

packagecom.crazymaker.cloud.dubbo.demo.starter;\n\nimportcom.crazymaker.springcloud.common.util.IpUtil;\nimportlombok.extern.slf4j.Slf4j;\nimportorg.apache.commons.lang3.StringUtils;\nimportorg.apache.dubbo.config.spring.context.annotation.EnableDubbo;\nimportorg.springframework.boot.SpringApplication;\nimportorg.springframework.boot.autoconfigure.SpringBootApplication;\nimportorg.springframework.cloud.client.discovery.EnableDiscoveryClient;\nimportorg.springframework.context.ConfigurableApplicationContext;\nimportorg.springframework.core.env.Environment;\nimportspringfox.documentation.swagger2.annotations.EnableSwagger2;\n\nimportjava.net.Inet4Address;\nimportjava.util.Optional;\n\n@EnableSwagger2\n@EnableDiscoveryClient\n@Slf4j\n@EnableDubbo\n\n@SpringBootApplication(scanBasePackages=\n{\n&34;,\n}\n)\n\n\npublicclassDubboProviderApplication{\npublicstaticvoidmain(String[]args){\ntry{\nConfigurableApplicationContextapplicationContext=SpringApplication.run(DubboProviderApplication.class,args);\n\nEnvironmentenv=applicationContext.getEnvironment();\nStringport=env.getProperty(&34;);\nStringname=env.getProperty(&34;);\n\nStringpath=env.getProperty(&34;);\nif(StringUtils.isBlank(path)){\npath=&34;;\n}\nOptional<Inet4Address>ip=IpUtil.getLocalIp4Address();\n\nlog.info(&34;+\nname.toUpperCase()+&34;+\n&34;+ip.get()+&34;+port+path+&34;+\n&34;+ip.get()+&34;+port+path+&34;+\n&34;+ip.get()+&34;+port+path+&34;+\n&34;);\n\n}catch(Exceptione){\nlog.error(&34;,e);\n\n}\n}\n}

启动、体验Provider

打包之后，在咱们优雅的虚拟机centos8中，优雅的启动一下,

来一个优雅的启动命令

[root@centos1work]sh./deploy.shstart\nPORT:28088\nJVM:-server-Xms512m-Xmx2048m\nnohupjava-server-Xms512m-Xmx2048m-Dserver.port=28088-jar/work/dubbo-provider-demo-1.0-SNAPSHOT/lib/dubbo-provider-demo-1.0-SNAPSHOT.jarcom.crazymaker.cloud.dubbo.demo.starter.DubboProviderApplication&\nlogfile:/work/logs/dubbo-provider-demo-1.0-SNAPSHOT/output.log

太爽……………..有个vagrant+Centos开发环境，开发Java应用，爽到不要不要的

关键是：在这个虚拟机box文件中，尼恩给大家预装了K8S云原生环境，大家一键导入省了N多麻烦。基于这个环境，下一步咱们就开始“左手大数据、右手云原生”的高端实操

继续看，屏幕的下面，下面还有swagger体验地址

使用这个地址，可以在浏览器开起Swagger-UI的界面

http:///cdh1:28088/dubbo-provider-demo/swagger-ui.html

开启之后的效果，但是，这个和dubbo没有关系

因为dubbo的服务并没有在swaggerui展示

在Nacos查看Dubbo服务的注册情况

通过nacos，可以看到dubbo的服务啦

具体的细节，咱们后面讲dubbo视频的时候，再说

这里先把性能优化起来

服务消费者实操：dubbo-consumer服务

consumer模块

消费者实现类

packagecom.crazymaker.cloud.dubbo.demo.consumer.controller;\n\nimportcom.crazymaker.springcloud.common.dto.UserDTO;\nimportcom.crazymaker.springcloud.common.result.RestOut;\nimportcom.crazymaker.springcloud.user.info.remote.client.UserClient;\nimportio.swagger.annotations.Api;\nimportio.swagger.annotations.ApiOperation;\nimportorg.apache.dubbo.config.annotation.DubboReference;\nimportorg.springframework.web.bind.annotation.RequestMapping;\nimportorg.springframework.web.bind.annotation.RequestMethod;\nimportorg.springframework.web.bind.annotation.RequestParam;\nimportorg.springframework.web.bind.annotation.RestController;\n\n@RestController\n@RequestMapping(&34;)\n@Api(tags=&34;)\npublicclassUserConsumerController{\n\n\n//注入@DubboReference注解配置所配置的EchoClient客户端Feign实例\n@DubboReference(loadbalance=&34;)\nprivateUserClientuserService;\n\n//用户详情\n@ApiOperation(value=&34;)\n@RequestMapping(value=&34;,method=RequestMethod.GET)\nRestOut<UserDTO>detail(@RequestParam(value=&34;,required=true)LonguserId){\nRestOut<UserDTO>ret=userService.detail(userId);\nreturnret;\n}\n}

消费者Dubbo+Nacos配置文件

spring:\nsecurity:\nenabled:false\napplication:\nname:dubbo-consumer-demo\n34;/actuator&配置Endpoint的基础路径\nexposure:\ninclude:&39;boot:\ncontext-path:consumer\n\ndubbo:\nscan:\nbase-packages:com.crazymaker.cloud.dubbo\napplication:\nname:${spring.application.name}\nprotocol:\nname:dubbo\nport:-1\nregistry:\naddress:nacos://${NACOS_SERVER:cdh1:8848}\nusername:nacos\npassword:nacos\nparameters:\nnamespace:dubbo\ngroup:DUBBO_GROUP\nconfig-center:\naddress:nacos://${NACOS_SERVER:cdh1:8848}\nusername:nacos\npassword:nacos\ngroup:DUBBO_GROUP\nmetadata-report:\naddress:nacos://${NACOS_SERVER:cdh1:8848}\nusername:nacos\npassword:nacos\ngroup:DUBBO_GROUP

启动类加上@EnableDubbo注解

packagecom.crazymaker.cloud.dubbo.demo.consumer.starter;\n\nimportcom.crazymaker.springcloud.common.util.IpUtil;\nimportlombok.extern.slf4j.Slf4j;\nimportorg.apache.commons.lang3.StringUtils;\nimportorg.apache.dubbo.config.spring.context.annotation.EnableDubbo;\nimportorg.springframework.boot.SpringApplication;\nimportorg.springframework.boot.actuate.autoconfigure.security.servlet.ManagementWebSecurityAutoConfiguration;\nimportorg.springframework.boot.autoconfigure.SpringBootApplication;\nimportorg.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration;\nimportorg.springframework.boot.autoconfigure.data.redis.RedisRepositoriesAutoConfiguration;\nimportorg.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;\nimportorg.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration;\nimportorg.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration;\nimportorg.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration;\nimportorg.springframework.cloud.client.discovery.EnableDiscoveryClient;\nimportorg.springframework.cloud.openfeign.EnableFeignClients;\nimportorg.springframework.context.ConfigurableApplicationContext;\nimportorg.springframework.core.env.Environment;\nimportspringfox.documentation.swagger2.annotations.EnableSwagger2;\n\nimportjava.net.Inet4Address;\nimportjava.util.Optional;\n\n@EnableSwagger2\n@EnableDiscoveryClient\n@Slf4j\n@EnableDubbo\n\n@SpringBootApplication(\nscanBasePackages=\n{\n&34;,\n&34;\n},\nexclude={SecurityAutoConfiguration.class,\n//排除db的自动配置\nDataSourceAutoConfiguration.class,\nDataSourceTransactionManagerAutoConfiguration.class,\nHibernateJpaAutoConfiguration.class,\nSecurityAutoConfiguration.class,\nManagementWebSecurityAutoConfiguration.class,\n//排除redis的自动配置\nRedisAutoConfiguration.class,\nRedisRepositoriesAutoConfiguration.class})\n//启动Feign\n@EnableFeignClients(basePackages=\n{&34;})\npublicclassDubboConsumerApplication{\n\npublicstaticvoidmain(String[]args){\ntry{\nConfigurableApplicationContextapplicationContext=SpringApplication.run(DubboConsumerApplication.class,args);\n\nEnvironmentenv=applicationContext.getEnvironment();\nStringport=env.getProperty(&34;);\nStringname=env.getProperty(&34;);\n\nStringpath=env.getProperty(&34;);\nif(StringUtils.isBlank(path)){\npath=&34;;\n}\nOptional<Inet4Address>ip=IpUtil.getLocalIp4Address();\n\nlog.info(&34;+\nname.toUpperCase()+&34;+\n&34;+ip.get()+&34;+port+path+&34;+\n&34;+ip.get()+&34;+port+path+&34;+\n&34;+ip.get()+&34;+port+path+&34;+\n&34;);\n\n}catch(Exceptione){\nlog.error(&34;,e);\n\n}\n}\n}

启动、体验Consumer

打包之后，在咱们优雅的虚拟机centos8中，优雅的启动一下,

来一个优雅的启动命令

[root@centos1bin]sh./deploy.shstart\nPORT:18081\nJVM:-server-Xms512m-Xmx2048m\nnohupjava-server-Xms512m-Xmx2048m-Dserver.port=18081-jar/work/dubbo-consumer-demo-1.0-SNAPSHOT/lib/dubbo-consumer-demo-1.0-SNAPSHOT.jarcom.crazymaker.cloud.dubbo.demo.consumer.starter.DubboConsumerApplication&\nnohup:appendingoutputto&39;

太爽……………..有个vagrant+Centos开发环境，开发Java应用，爽到不要不要的

关键是：在这个虚拟机box文件中，尼恩给大家预装了K8S云原生环境，大家一键导入省了N多麻烦。

下一步，基于这个环境，咱们就开始“左手大数据、右手云原生”的高端实操

继续看，屏幕的下面，下面还有swagger体验地址

使用这个地址，可以在浏览器开起Swagger-UI的界面

http:///10.0.2.15:18081/dubbo-consumer-demo/swagger-ui.html

注意，要修改一下host，修改之后为

http://cdh1:18081/dubbo-consumer-demo/swagger-ui.html

Feign和Dubbo两大RPC调用并存的效果，如下：

在Nacos查看Dubbo服务的注册情况

通过nacos，可以看到dubbo的服务的消费者啦

具体的细节，咱们后面讲dubbo视频的时候，再说

这里先把性能优化起来

Feign+Dubbo性能的对比测试

然后进行了性能的对比验证

dubbo的压测数据

wrk-t8-c200-d30s–latencyhttp://cdh1:18081/dubbo-consumer-demo/user/detail/v1?userId=1\n\n[root@centos1src]wrk-t8-c200-d30s–latencyhttp://cdh1:18081/dubbo-consumer-demo/echo/variable/11\nRunning30stest@http://cdh1:18081/dubbo-consumer-demo/echo/variable/11\n8threadsand200connections\nThreadStatsAvgStdevMax+/-Stdev\nLatency321.50ms294.59ms2.00s61.77%\nReq/Sec87.1843.39232.0067.00%\nLatencyDistribution\n50%309.06ms\n75%503.06ms\n90%687.99ms\n99%1.21s\n20495requestsin30.10s,7.64MBread\nSocketerrors:connect0,read0,write0,timeout49\nRequests/sec:680.90\nTransfer/sec:259.99KB

从数据来看，dubborpc是feignrpc性能10倍

Dubbo比Feign高10倍以上的本质

Dubbo比Feign高10倍以上的本质，不是在于应用层的协议，和传输格式

面试的时候，太多的小伙伴被问到：Dubbo比Feign性能高，说说原因。

小伙伴首先回答的是：

Dubbo是TCP层的传输协议，Feign是应用层的HTTP传输协议，所以性能低。

这个答案不是本质原因，HTTP是有些冗余的头部报文，但是不至于差10倍。能差0.5倍，就已经顶天了。

差10倍的原因：是同步链路与异步链路的区别。

或者说：Dubbo比Feign高10倍以上的本质，是RPC调用异步化

RPC调用主要的框架有：

特点是：

feign是同步IO、阻塞模式的同步RPC框架dubbo是基于Netty的非阻塞IO+Reactor反应堆线程模型的异步RPC框架

异步RPC调用，等待upstream上游response返回时，线程不处于block状态

作为微服务架构中数据流量最大的一部分，RPC调用异步化的收益巨大；

dubbo的异步RPC，仅仅SpringCloud微服务全链路异步的一个环节，SpringCloud全链路异步有5个以上的环节。

有关微服务全链路异步高性能改造，请参考尼恩的深度文章：

《全链路异步，让你的SpringCloud性能优化10倍+》PDF

高并发、云原生、大数据时代，很多组件都是全异步的、响应式的。

大家一定要掌握全链路异步的底层原理，掌握好响应式编程的底层原理和实操，为“左手大数据、右手云原生”做好技术准备。

后面尼恩也会写一些列的博文，为大家“左手大数据、右手云原生”做好技术储备。

具体请关注尼恩的疯狂创客圈社群（50+）。

Dubbo与SpringCloud的通信Openfeign的区别

1、协议支持方面

Feign更加优雅简单。Feign是通过RESTAPI实现的远程调用，基于Http传输协议，服务提供者需要对外暴露Http接口供消费者调用，服务粒度是http接口级的。很多文章说：通过短连接的方式进行通信，不适合高并发的访问。尼恩纠错：Feign并不是短链接，而是长连接，具体请阅读尼恩的《Java高并发核心编程卷1加强版》Dubbo方式更灵活。Dubbo是通过RPC调用实现的远程调用，支持多传输协议(Dubbo、Rmi、http、redis等等)，可以根据业务场景选择最佳的方式，非常灵活。默认的Dubbo协议：利用Netty，TCP传输，单一、异步、长连接，适合数据量小、高并发和服务提供者远远少于消费者的场景。Dubbo通过TCP长连接的方式进行通信，服务粒度是方法级的。

2、通信性能方面

Feign基于Http传输协议，底层实现是rest。在高并发场景下性能不够理想。Dubbo框架的通信协议采用RPC协议，属于传输层协议，提升了交互的性能，保持了长连接，高性能。

3、线程模型方面

Feign使用的是阻塞式的线程模型，在请求和响应直之间，IO线程是阻塞的，死等到超时。Dubbo使用的是异步非阻塞式的线程模型（Netty的Reactor反应器），在请求和响应直之间，IO线程是非阻塞的，有限的线程，可以处理大量的请求。

这点是性能的核心。

SpringCloud+DubboRPC的集成价值

高并发时代来了，各大项目有越来越强烈的诉求，全链路异步，是性能优化的一个杀手锏。

使用Dubbo来替换Feign，足足可以提升10倍性能。

所以，SpringCloud+DubboRPC的集成是一个比较刚性的需求。

有小伙伴查招聘网站，发现很多需要有SpringCloud+Dubbo的集成经验，刚好印证了这点。

尼恩强烈建议大家，做一下SpringCloud+DubboRPC的集成，在同一个微服务下，同时使用了Feign+Dubbo。

尼恩提示：很多小伙伴来找尼恩改简历，但是发现一点漂亮的技术亮点都没有，如果确实找不到亮点，可以把这个实操做一下，写入简历，作为亮点。如果确实不清楚怎么写入简历，可以来找尼恩进行简历指导。保证脱胎换骨、金光闪闪、天衣无缝。

hystrix服务保护

…..省略数万字

篇幅限制，请在《技术自由圈》公众号领取《SpringCloudAlibaba微服务学习圣经》完整版PDF

高质量实操：SpringCloud高并发实战案例

1、超高并发10Wqps秒杀实操

为何要以秒杀做为高并发实战案例？

秒杀案例在生活中几乎随处可见：比如商品抢购，比如春运抢票，还是就是随处可见的红包也是类似的。

另外，在跳槽很频繁的IT行业，大家都会有面试的准备要求。在面试中,秒杀业务或者秒杀中所用到的分布式锁、分布式ID、数据一致性、高并发限流等问题，一般都是成为重点题目和热门题目，为面试官和应聘者津津乐道.

尼恩说明：

高并发秒杀的案例，请参见本书的高阶版本，《Java高并发核心编程卷3加强版》

2、超高并发100Wqps车联网实操

很多小伙伴，在生产项目上主要是crud，涉及不到核心技术和组件，所以导致大家在涨薪的时候，缺失硬核的项目、核心经验做支撑，最终就业失败、涨薪受挫，直接影响后续的发展。

很多的培训机构，在介绍核心组件实操的时候，没有找到真实的业务场景，不是生产级的项目，导致练习不到核心技术。

《超高并发100Wqps车联网实操》是真刀真枪的核心组件实操：

（1）200W+qps行驶数据网关服务设计、开发、实操、测试

（2）5W+qps安全认证服务设计、开发、实操、测试

（3）10W+qps消息服务设计、开发、实操、测试

（4）2W+qps用户中心设计、开发、实操、测试

（5）2W+qps异常监控服务设计、开发、实操、测试

（6）5W+qps车辆服务设计、开发、实操、测试

（7）亿级数据分库分表设计、开发、实操、测试

（8）devops流水线部署、验证，K8S自动化部署、验证

在学习、实操《100W级qps车联网项目实操》之后，能具备3年以上核心Java的开发、设计经验。

3、N多其他的超高并发实操项目

尼恩和《技术自由圈》其他的P7、P8同学，会一起给大家奉献更多的超高质量实操项目

并且帮助大家写入简历，保证简历脱胎换骨，金光闪闪。

…..省略

尼恩说明：本文400页，10W多字…..

由于本文篇幅限制

还有5W多字放不下….

滑动视频网站源码分享，滑动的小视频

Published by

风君子

近期文章

标签

书签