跟着狂神学SpringCloud
SpringCloud
回顾之前的知识-
JavaSE
数据库前端Servlet
Http
Mybatis
Spring
SpringMVC
SpringBoot
Dubbo
、Zookeeper
、分布式基础Maven
、Git
Ajax
、Json
.…串一下自己会的东西~
这个阶段该如何学~
三层架构+ MVC框架:Spring IOC AOPSprintBoot,新-一代的JavaEE开发标准,自动装配模块化~ all in one模块化的开发===all in one,代码没变化~ 微服务架构4个核心问题?1.服务很多,客户端该怎么访问?2.这么多服务?服务 之间如何通信?3.这么多服务?如何治理?4.服务挂了怎么办?解决方案:Spring Cloud 生态!springBoot1. Spring cloud NetFlix一站式解决方案!api网关,zuu1组件Feign ---HttpClinet ---- Http通信方式,同步,阻塞服务注册发现:Eureka熔断机制: Hystrix2. Apache Dubbo zookeeper 半自动,需要整合别人的!API:没有,找第三方组件,或者自己实现DubboZookeeper没有:借助HystrixDubbo这个方案并不完善~3. Spring cloud Alibaba - -站式解决方案!更简单新概念:服务网格~ Server Meshistio万变不离其宗1.API2.HTTP,RPC 3.注册和发现4.熔断机制
1、常见面试题
1.1、什么是微服务?
1.2、微服务之间是如何独立通讯的?
1.3、SpringCloud
和Dubbo
有哪些区别?
1.4、SpringBoot
和SpringCloud
,请你谈谈对他们的理解
1.5、什么是服务熔断?什么是服务降级
1.6、微服务的优缺点是分别是什么?说下你在项目开发中遇到的坑
1.7、你所知道的微服务技术栈有哪些?请列举一二
1.8、eureka
和zookeeper
都可以提供服务注册与发现的功能,请说说两个的区别?
2、微服务概述
2.1.什么是微服务
什么是微服务?微服务(Microservice Architecture
)是近几年流行的一种架构思想,关于它的概念很难一言以蔽
之。
究竟什么是微服务呢?我们在此引用ThoughtWorks
公司的首席科学家Martin Fowler
于提出的一段话:
原文: /articles/microservices.html
汉化: /liuning8023/p/4493156.html
就目前而言,对于微服务,业界并没有一个统-的,标准的定义但通常而言,微服务架构是一种架构模式, 或者说是一种架构风格,它提倡将单-的应用程序划分成一组小的服务,每个服务运行在其独立的自己的进程内,服务之间互相协调,互相配置,为用户提供最终价值。服务之间采用轻量级的通信机制互相沟通,每个服务都围绕着具体的业务进行构建,并且能够被独立的部署到生产环境中,另外,应尽量避免统- -的,集中式的服务管理机制,对具体的-一个服务而言,应根据业务.上下文,选择合适的语言,工具对其进行构建,可以有一-个非常轻量级的集中式管理来协调这些服务,可以使用不同的语言来编写服务,也可以使用不同的数据存储;
可能有的人觉得官方的话太过生涩,我们从技术维度来理解下:
微服务化的核心就是将传统的一站式应用,根据业务拆分成-一个-一个的服务彻底地去耦合,每-一个微服务提供单个业务功能的服务,一个服务做一件事情,从技术角度看就是一种小而独立的处理过程,类似进程的概念,能够自行单独启动或销毁,拥有自己独立的数据库。
2.2、微服务与微服务架构
微服务
强调的是服务的大小,他关注的是某一个点, 是具体解决某一个问题/提供落地对应服务的一个服务应用,狭义的看,可以看做是IDEA
中的一-个个微服务工程,或者Moudel
IDEA工具里面使用Maven开发的一个个独立的小Moudle,它具体是使用springboot开发的一-个小模块,专业的事情交给专业的模块来做,--个模块就做着一件事情强调的是一个个的个体,每个个体完成-个具体的任务或者功能!
微服务架构
一种新的架构形式,Martin Fowler
, 提出
微服务架构是一种架构模式,它提倡将单- -应用程序划分成- -组小的服务,服务之间互相协调,互相配合,为用户提供最终价值。每个服务运行在其独立的进程中,服务于服务间采用轻量级的通信机制互相协作,每个服务都围绕着具体的业务进行构建,并且能够被独立的部署到生产环境中,另外,应尽量避免统- -的, 集中式的服务管理机制,对具体的一个服务而言,应根据业务上下文,选择合适的语言,工具对其进行构建。
2.3、微服务优缺点
优点
每个服务足够内聚,足够小,代码容易理解,这样能聚焦一个指定的业务功能或业务 需求;开发简单,开发效率提高,一个服务可能就是专一的只干一件事;微服务能够被小团队单独开发,这个小团队是2~5人的开发人员组成;微服务是松耦合的,是有功能意义的服务,无论是在开发阶段或部署阶段都是独立的。微服务能使用不同的语言开发。易于和第三方集成,微服务允许容易且灵活的方式集成自动部署,通过持续集成工具,如jenkins
,Hudson
,bamboo
微服务易于被-个开发人员理解,修改和维护,这样小团队能够更关注自己的工作成果。无需通过合作才能体现价值。微服务允许你利用融合最新技术。微服务只是业务逻辑的代码,不会和HTML
,CSS
或其他界面混合每个微服务都有自己的存储能力,可以有自己的数据库,也可以有统-数据库
缺点:
开发人员要处理分布式系统的复杂性多服务运维难度,随着服务的增加,运维的压力也在增大系统部署依赖服务间通信成本-数据一致性系统集成测试性能监…2.4、 微服务技术栈有哪些?
2.5.为什么选择SpringCloud作为微服务架构
1、选型依据
整体解决方案和框架成熟度社区热度.可维护性学习曲线2、当前各大IT公司用的微服务架构有哪些?
阿里:dubbo
+HFS
京东:JSF
新浪:Motan
当当网DubboX
…3、各微服务框架对比
3、SpringCloud入门概述
3.1、SpringCloud是什么
Spring官网: https://spring.io/
SpringCloud
,基于SpringBoot
提供了一套微服务解决方案,包括服务注册与发现,配置中心,全链路监控,服务网关,负载均衡,熔断器等组件,除了基于NetFlix的开源组件做高度抽象封装之外,还有一-些选型中立的开源组件。
SpringCloud
利用SpringBoot
的开发便利性,巧妙地简化了分布式系统基础设施的开发,SpringCloud
为开发人员提供了快速构建分布式系统的-些工具,包括配置管理,服务发现,断路器,路由,微代理,事件总线,全局锁,决策竞选,分布式会话等等,他们都可以用SpringBoot
的开发风格做到-键启动和部署.
SpringBoot
并没有重复造轮子,它只是将目前各家公司开发的比较成熟,经得起实际考研的服务框架组合起来,通过SpringBoot
风格进行再封装,屏蔽掉了复杂的配置和实现原理,最终给开发者留出了-套简单易懂,易部署和易维护的分布式系统开发工具包
SpringCloud
是分布式微服务架构下的-站式解决方案,是各个微服务架构落地技术的集合体,俗称微服务全家
桶。
3.2、SpringCloud和SpringBoot关系
SpringBo
配专注于快速方便的开发单个个体微服务。SpringCloud
是关注全 局的微服务协调整理治理框架,它将SpringBoot
开发的一 个个单体微服务整合并管理起来,为各个微服务之间提供:配置管理,服务发现,断路器,路由,微代理,事件总线,全鋦锁,决策竞选,分布式会话等等集成服务。SpringBoot
可以离开SpringClooud
独立使用, 开发项目,但是SpringCloud
离不开SpringBoot
,属于依赖关系SpringBoot
专注于快速、 方便的开发单个个体微服务,SpringCloud
关注全局的服务治理框架
3.3、Dubbo 和SpringCloud技术选型
1、分布式+服务治理Dubbo
目前成熟的互联网架构:应用服务化拆分+消息中间件
2、Dubbo 和SpringCloud对比
可以看一-下社区活跃度
/dubbo
/spring-cloud
结果:
最大区别:
SpringCloud
抛弃 了Dubbo
的RPC
通信,采用的是基于HTTP
的REST
方式。
严格来说,这两种方式各有优劣。虽然从-定程度上来说,后者牺牲了服务调用的性能,但也避免了,上面提到的原生RPC
带来的问题。而且REST
相比RPC
更为灵活,服务提供方和调用方的依赖只依靠一纸契约, 不存在代码级别的强依赖,这在强调快速演化的微服务环境下,显得更加合适。
品牌机与组装机的区别
很明显,SpringCloud
的功能比DUBBO
更加强大,涵盖面更广,而且作为Spring
的拳头项目, 它也能够与Spring Framework
.Spring Boot
.Spring Data
.Spring Batch
等其他Spring
项目完美融合,这些对于微服务而言是至关重要的。使用Dubbo
构建的微服务架构就像组装电脑,各环节我们的选择自由度很高,但是最终结果很有可能因为一条内存质量不行就点不亮了,总是让人不怎么放心,但是如果你是一名高手, 那这些都不是问题;而SpringCloud
就像品牌机,在Spring Source
的整合下,做了大量的兼容性测试,保证:了机器拥有更高的稳定性,但是如果要在使用非原装组件外的东西,就需要对其基础有足够的了解。
社区支持与更新力度
最为重要的是,DUBBO
停止了5年左右的更新,虽然.7重启了。 对于技术发展的新需求,需要由开发者自行拓展升级(比如当当网弄出了DubboX
),这对于很多想要采用微服务架构的中小软件组织,显然是不太合适的,中小公司没有这么强大的技术能力去修改Dubbo
源码+周边的- -整套解决方案,并不是每-个公司都有阿里的大牛+真实的线上生产环境测试过。
总结:
曾风靡国内的开源RPC
服务框架Dubbo
在重启维护后,令许多用户为之雀跃,但同时,也迎来了一些质疑的声音。互联网技术发展迅速,Dubbo
是否还能跟上时代?Dubbo
与Spring Cloud
相比又有何优势和差异?是否会有相关举措保证Dubbo
的后续更新频率?
人物:Dubbo
重启维护开发的刘军,主要负责人之一
刘军,阿里巴巴中间件高级研发工程师,导了Dubbo
重启维护以后的几个发版计划,专注于高性能RPC
框架和微服务相关领域。曾负责网易考拉RPC
框架的研发及指导在内部使用,参与了服务治理平台、分布式跟踪系统、分布式一致性框架等从无到有的设计与开发过程。
解决的问题域不一样:Dubbo
的定位是-款RPC
框架,Spring Cloud
的目标是微服务架构下的站式解决方案
3.4、SpringCloud能干嘛
Distributed
/versioned
configuration
(分布式/版本控制配置)Service registration and discovery
(服务注册与发现)Routing
(路由)Service-to-service calls
(服务到服务的调用)Load balancing
(负载均衡配置)Circuit Breakers
(断路器)Distributed messaging
(分布式消息管理)3.5、SpringCloud在哪下
官网: http://projects.spring.io/spring-cloud/
版本号很特殊
Spring Cloud是一个由众多独立子项目组成的大型综合项目,每个子项目有不同的发行节奏,都维护着自己的发布版本号。Spring C1oud通过一个资源清单BOM (Bi11 of Materials) 来管理每个版本的子项目清单。为避免与子项目的发布号混淆,所以没有采用版本号的方式,而是通过命名的方式。这些版本名称的命名方式采用了伦敦地铁站的名称,同时根据字母表的顺序来对应版本时间顺序,比如:最早的Release版本: Ange1, 第二个Release版本: Brixton, 然后是Camden、Dalston、 Edgware,目 前最新的是Finch1ey版本。
spring-cloud-netfix.html中文API文档: /spring-cloud-dalston.htmlSpringCloud中国社区 /SpringCloud中文网参考书:
上面和大家聊了这么多,希望大家能够认真吸收,这就是大家能够在面试中和别人的谈资。
而且好像我也没说什么废话,之后的代码都会和上面的理论挂钩!所以需要认真掌握哈
4、Rest环境搭建
配置流程(核心)
导入依赖编写配置文件开启这个功能@Enablexxxxx
配置类4.1、总体介绍
我们会使用一个Dept
部]模块做-一个微服务通用案例Consumer
消费者(Client
) 通过REST
调用Provider
提供者(Server
) 提供的服务。回忆Spring
,SpringMVC
,MyBatis
等以往学习的知识。 。。Maven
的分包分模块架构复习一个简单的Maven模块结构是这样的:--app-parent: 一个父项目(app-parent) 聚合很多子项目(app-util, app-dao, app-web...)|--pom. xm1||-- app-core||----pom. xm1||--app-web||----pom. xm1...
一个父工程带着多个子Module
子模块
MicroServiceCloud
父.工程(Project
) 下初次带着3个子模块(Module
)
。microservicecloud-api
[封装的整体entity/接口/公共配置等]
。microservicecloud-provider-dept-8001
[服务提供者]
。microservicecloud-consumer-dept-80
[服务消费者]
动手开干!
4.2、SpringCloud版本选择
大版本说明
实际开发版本关系
使用最后两个
4.3、创建父工程
新建父工程项目microservicecloud
, 切记Packageing
是pom
模式主要是定义POM
文件,将后续各个子模块公用的jar
包等统一提取出来, 类似一个抽象父类中文API文档: /spring-cloud-dalston.html参照
jar
打包方式pom
<!--打包方式 pom--><packaging>pom</packaging>
汇总
<!--打包方式 pom--><packaging>pom</packaging><properties><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding><puter.source>1.8</puter.source><puter.target>1.8</puter.target><junit.version>4.12</junit.version></properties><dependencyManagement><dependencies><!--springcloud 的依赖--><!-- /artifact/org.springframework.cloud/spring-cloud-dependencies --><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-dependencies</artifactId><version>Hoxton.SR1</version><type>pom</type><scope>import</scope></dependency><!--SpringBoot--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-dependencies</artifactId><version>2.2.5.RELEASE</version><type>pom</type><scope>import</scope></dependency><!--数据库--><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>5.1.47</version></dependency><dependency><groupId>com.alibaba</groupId><artifactId>druid</artifactId><version>1.1.10</version></dependency><!--SpringBoot 启动器--><dependency><groupId>org.mybatis.spring.boot</groupId><artifactId>mybatis-spring-boot-starter</artifactId><version>1.3.2</version></dependency><!--junit--><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>${junit.version}</version></dependency><!--lombok--><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><version>1.16.18</version></dependency><!--log4j--><dependency><groupId>log4j</groupId><artifactId>log4j</artifactId><version>1.2.17</version></dependency><dependency><groupId>ch.qos.logback</groupId><artifactId>logback-core</artifactId><version>1.2.3</version></dependency></dependencies></dependencyManagement>
创建子工程springcloud-api
在父工程下新建一个springcloud-api
模块,子模块中导入依赖
<!--当前Module自己需要的依赖,如果父依赖中已经配置了版本,这里就不用写了--><dependencies><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId></dependency></dependencies>
创建数据库db01
/*Navicat MySQL Data TransferSource Server : 123Source Server Version : 50622Source Host : 127.0.0.1:3306Source Database : db01Target Server Type : MYSQLTarget Server Version : 50622File Encoding : 65001Date: -11-24 17:48:22*/SET FOREIGN_KEY_CHECKS=0;-- ------------------------------ Table structure for dept-- ----------------------------DROP TABLE IF EXISTS `dept`;CREATE TABLE `dept` (`deptno` bigint(20) NOT NULL AUTO_INCREMENT,`dname` varchar(60) DEFAULT NULL,`db_source` varchar(60) DEFAULT NULL,PRIMARY KEY (`deptno`)) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8 COMMENT='部门表';-- ------------------------------ Records of dept-- ----------------------------INSERT INTO `dept` VALUES ('1', '开发部', 'db01');INSERT INTO `dept` VALUES ('2', '人事部', 'db01');INSERT INTO `dept` VALUES ('3', '财务部', 'db01');INSERT INTO `dept` VALUES ('4', '市场部', 'db01');INSERT INTO `dept` VALUES ('5', '运维部', 'db01');
实体类pojo
在对应目录创建实体类(务必实现序列化)
Dept
package com.huang.springcloud.pojo;import lombok.AllArgsConstructor;import lombok.Data;import lombok.NoArgsConstructor;import lombok.experimental.Accessors;import java.io.Serializable;@Data@AllArgsConstructor@NoArgsConstructor@Accessors(chain = true)//链式写法public class Dept implements Serializable {//表属性映射private long deptno;private String dname;//这个数据数存在哪个数据库的字段~微服务,一个服务对应一个数据库,同一个信息可能存在不同的数据序private String db_source;public Dept(String dname) {this.dname = dname;}@Overridepublic String toString() {return "Dept{" +"deptno=" + deptno +", dname='" + dname + '\'' +", db_source='" + db_source + '\'' +'}';}/*链式写法:Dept dept = new Dept();dept. setDeptNo(11). setDname( 'SSS '). setDb_source( '001 ');*/}
服务提供者
创建子工程springcloud-provider-dept-8001
父工程下创建子工程springcloud-provider-dept-8001
jar
<!--我们需要拿到实体类,所以需要配置api module--><dependency><groupId>com.huang</groupId><artifactId>springcloud_api</artifactId><version>1.0-SNAPSHOT</version></dependency><!--因为父依赖中存在所以不再需要版本号--><dependency><groupId>junit</groupId><artifactId>junit</artifactId><scope>test</scope></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId></dependency><dependency><groupId>com.alibaba</groupId><artifactId>druid</artifactId></dependency><dependency><groupId>ch.qos.logback</groupId><artifactId>logback-core</artifactId></dependency><dependency><groupId>org.mybatis.spring.boot</groupId><artifactId>mybatis-spring-boot-starter</artifactId></dependency><!--test--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-test</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><!--jetty--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-jetty</artifactId></dependency><!--热部署工具--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-devtools</artifactId></dependency>
配置文件
application.yml
在resource
中的application.yml
进行相关配置
server:port: 8001#mybatis配置mybatis:type-aliases-package: com.huang.springcloud.pojoconfig-location: classpath:mybatis/mybatis-config.xmlmapper-locations: classpath:mybatis/mapper/*.xml#spring的配置spring:application:name : springcloud-provider-deptdatasource :type: com.alibaba.druid.pool.DruidDataSourcedriver-class -name: org.gjt.mm.mysql.Driverurl: jdbc:mysql://localhost:3306/db01?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghaiusername : rootpassword: jia5211314
mybatis-config.xml
<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE configurationPUBLIC "-////DTD Config 3.0//EN""/dtd/mybatis-3-config.dtd"><configuration><settings><!--开启二级缓存--><setting name="cacheEnabled" value="true"/></settings></configuration>
dao
DeptDao
package com.huang.springcloud.dao;import com.huang.springcloud.pojo.Dept;import org.apache.ibatis.annotations.Mapper;import org.springframework.stereotype.Repository;import java.util.List;@Mapper@Repositorypublic interface DeptDao {boolean addDept(Dept dept);Dept queryById(Long id);List<Dept> queryAll();}
mapper
DeptMapper.xml
<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE mapperPUBLIC "-////DTD Config 3.0//EN""/dtd/mybatis-3-mapper.dtd"><mapper namespace="com.huang.springcloud.dao.DeptDao"><insert id="addDept" parameterType="Dept">insert into dept (dname,db_source)values (#{dname},DATABASE());</insert><select id="queryById" parameterType="Dept" resultType="Dept">select * from deptwhere deptno=#{deptno};</select><select id="queryAll" resultType="Dept" parameterType="Dept">select * from dept;</select></mapper>
service
DeptService
package com.huang.springcloud.service;import com.huang.springcloud.pojo.Dept;import java.util.List;public interface DeptService {boolean addDept(Dept dept);Dept queryById(Long id);List<Dept> queryAll();}
DeptServiceImpl
package com.huang.springcloud.service;import com.huang.springcloud.dao.DeptDao;import com.huang.springcloud.pojo.Dept;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Service;import java.util.List;@Servicepublic class DeptServiceImpl implements DeptService{@Autowiredprivate DeptDao deptDao;public boolean addDept(Dept dept) {return deptDao.addDept(dept);}public Dept queryById(Long id) {return deptDao.queryById(id);}public List<Dept> queryAll() {return deptDao.queryAll();}}
controller
DeptController
package com.huang.springcloud.controller;import com.huang.springcloud.pojo.Dept;import com.huang.springcloud.service.DeptService;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.web.bind.annotation.*;import java.util.List;@RestControllerpublic class DeptController {@Autowiredprivate DeptService deptService;@PostMapping("/dept/add")public boolean addDept(Dept dept){return deptService.addDept(dept);}@GetMapping("/dept/get/{id}")public Dept addDept(@PathVariable("id") Long id){return deptService.queryById(id);}@RequestMapping("/dept/list")public List<Dept> queryAll(){return deptService.queryAll();}}
启动类
DeptProvider_8001
package com.huang.springcloud;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;import org.flix.eureka.EnableEurekaClient;@SpringBootApplicationpublic class DeptProvider_8001 {public static void main(String[] args) {SpringApplication.run(DeptProvider_8001.class,args);}}
结构目录
启动并测试
服务消费者
新建springcloud_consumer_dept_80
jar
<dependency><groupId>com.huang</groupId><artifactId>springcloud_api</artifactId><version>1.0-SNAPSHOT</version></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><!--热部署工具--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-devtools</artifactId></dependency>
controller
DeptConsumerController
需要用到
@Autowiredprivate RestTemplate restTemplate;
此时就必须去配置bean
config
configBean
package com.huang.springcloud.config;import flix.loadbalancer.IRule;import flix.loadbalancer.RandomRule;import org.springframework.cloud.client.loadbalancer.LoadBalanced;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import org.springframework.web.client.RestTemplate;@Configurationpublic class ConfigBean {//@Configuration--spring applicationContext.xml@Beanpublic RestTemplate getRestTemplate(){return new RestTemplate();}}
此时再回到DeptConsumerController
package com.huang.springcloud.controller;import com.huang.springcloud.pojo.Dept;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Controller;import org.springframework.web.bind.annotation.PathVariable;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RestController;import org.springframework.web.client.RestTemplate;import java.util.List;@RestControllerpublic class DeptConsumerController {//理解:消费者不应该有service层//参数: (url,实体: Map , Class<T> responseType)@Autowiredprivate RestTemplate restTemplate;//提供多种便捷访问远程http服务的方法,简单的Restful服务模板private static final String REST_URL_PREFIX="http://localhost:8001";@RequestMapping("/consumer/dept/add")public Boolean add(Dept dept){return restTemplate.postForObject(REST_URL_PREFIX+"/dept/add",dept,Boolean.class);}@RequestMapping("/consumer/dept/get/{id}")public Dept get(@PathVariable("id") Long id){return restTemplate.getForObject(REST_URL_PREFIX+"/dept/get"+id,Dept.class);}@RequestMapping("/consumer/dept/list")public List<Dept> list(){return restTemplate.getForObject(REST_URL_PREFIX+"/dept/list",List.class);}}
启动类
DeptConsumer_80
package com.huang.springcloud;import com.huang.myrule.HuangRule;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;import org.flix.eureka.EnableEurekaClient;import org.flix.ribbon.RibbonClient;@SpringBootApplicationpublic class DeptConsumer_80 {public static void main(String[] args) {SpringApplication.run(DeptConsumer_80.class,args);}}
结构目录
启动测试,80端口可省略
类似调用远程服务参考
跟着狂神SpringBoot集成Dubbo和Zookeeper5、Eureka服务注册与发现
5.1、什么是Eureka
Eureka
: 怎么读?Netflix
在设计Eureka
时,遵循的就是AP
原则Eureka
是Netflix
的一 个子模块,也是核心模块之一。Eureka
是 一个基于REST
的服务,用于定位服务,以实现云端中间层服务发现和故障转移,服务注册与发现对于微服务来说是非常重要的,有了服务发现与注册,只需要使用服务的标识符,就可以访问到服务,而不需要修改服务调用的配置文件了,功能类似于Dubbo
的注册中心,比如Zookeeper
;5.2、原理讲解
Eureka
的基本架构SpringCloud
封装了NetFlix
公司开发的Eureka
模块来实现服务注册和发现(对比Zookeeper
)Eureka
采用了C-S
的架构设计,EurekaServer
作为服务注册功能的服务器,他是服务注册中心而系统中的其他微服务。使用Eureka
的客户端连接到EurekaServer
并维持心跳连接。 这样系统的维护人员就可以通过EurekaServer
来监控系统中各个微服务是否正常运行,SpringCloud
的一 -些其他模块(比如Zuul
)就可以通过EurekaServer
来发现系统中的其他微服务,并执行相关的逻辑;和Dubbo
架构对比Eureka
包含两个组件:Eureka Serve
r和Eureka Client
Eureka Server
提供服务注册服务,各个节点启动后,会在EurekaServer
中进行注册,这样Eureka Server
中的服务注册表中将会村粗所有可用服务节点的信息,服务节点的信息可以在界面中直观的看到。Eureka Client
是一个Java
客户端, 用于简化EurekaServer
的交互, 客户端同时也具备-一个内置的,使用轮询负载算法的负载均衡器。在应用启动后,将会向EurekaServer
发送心跳 (默认周期为30
秒)。如果Eureka Server
在多个心跳周期内没有接收到某个节点的心跳,EurekaServer
将会从服务注册表中把这个服务节点移除掉(默认周期为90
秒)三大角色Eureka Server
:提供服务的注册于发现。Service Provider
:将自身服务注册到Eureka中,从而使消费方能够找到。Service Consumer
:服务消费方从Eureka
中获取注册服务列表,从而找到消费服务.
spring_eureka_7001
父工程下新建module
jar
<dependencies><!-- /artifact/org.springframework.cloud/spring-cloud-starter-eureka-server --><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-eureka-server</artifactId><version>1.4.6.RELEASE</version></dependency><!--热部署工具--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-devtools</artifactId></dependency></dependencies>
1、导入依赖
2、编写配置文件
3、开启这个功能@Enablexxxxx
4、配置类
配置文件
application.yml
server:port: 7001eureka:instance:hostname: #Eureka服务端的实例名称client:register-with-eureka: false #表示是否向eureka注册中心注册自己fetch-registry: false #为false表示自己为注册中心service-url: #监控页面#单机:defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/#集群:#defaultZone: :7002/eureka/,:7003/eureka/
启动类
EurekaServer_7001
package com.huang.springcloud;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;import org.flix.eureka.server.EnableEurekaServer;@SpringBootApplication@EnableEurekaServer//开启服务public class EurekaServer_7001 {public static void main(String[] args) {SpringApplication.run(EurekaServer_7001.class,args);}}
程序目录
启动测试
注册到DeptProvider_8001
在springcloud-provider-dept-8001
中配置新增
jar
<!--EUREKA--><!-- /artifact/org.springframework.cloud/spring-cloud-starter-eureka --><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-eureka</artifactId><version>1.4.6.RELEASE</version></dependency>
配置文件
application.yml
#EUREKA的配置,服务注册到哪里eureka:client:service-url:defaultZone: http://127.0.0.1:7001/eureka/#:7001/eureka/
启动类
添加注解
@EnableEurekaClient//在服务启动后自动注册到Eureka中
这样它就会自动注册到springcloud_eureka_7001
先启动启动测试
springcloud_eureka_7001
然后启动springcloud-provider-dept-8001
修改eureka默认描述信息
application.yml
#EUREKA的配置,服务注册到哪里eureka:client:service-url:defaultZone: http://127.0.0.1:7001/eureka/#:7001/eureka/instance:instance-id: springcloud-provide-dept8001 #修改默认信息
自我保护机制
断掉springcloud-provider-dept-8001
的连接,等待一会可以看到
自我保护机制:好死不如赖活着
一句话总结:某时刻某-个微服务不可以用了,eureka
不会立刻清理,依旧会对该微服务的信息进行保存!
默认情况下,如果EurekaServer
在一定时间内没有接收到某个微服务实例的心跳,EurekaServer
将会注销该实例(默认90
秒)。但是当网络分区故障发生时,微服务与Eureka
之间无法正常通行,以上行为可能变得非常危险了-因为微服务本身其实是健康的,此时本不应该注销这个服务。Eureka
通过自我保护机制来解决这个问题 当EurekaServer
节点在短时间内丢失过多客户端时(可能发生了网络分区故障),那么这个节点就会进入自我保护模式。一旦进入该模式,EurekaServer
就会保护服务注册表中的信息, 不再删除服务注册表中的数据(也就是不会注销任何微服务)。当网络故障恢复后,该EurekaServer
节点会自动退出自我保护模式。
在自我保护模式中,EurekaServer
会保护服务注册表中的信息,不再注销任何服务实例。当它收到的心跳数重新恢复到阈值以上时,该EurekaServer
节点就会自动退出自我保护模式。它的设计哲学就是宁可保留错误的服务注册信息,也不盲目注销任何可能健康的服务实例。一句话:好死不如赖活着
综上,自我保护模式是一种应对网络异常的安全保护措施。它的架构哲学是宁可同时保留所有微服务(健康的微服务和不健康的微服务都会保留),也不盲目注销任何健康的微服务。使用自我保护模式,可以让Eureka
集群更加的健壮和稳定
在SpringCloud
中,可以使用eureka.server.enable-self-preservation = false
禁用自我保护模式
[不推荐关闭自我保护机制]
添加监控信息
在springcloud-provider-dept-8001
中配置新增
jar
<!--完善监控信息--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-actuator</artifactId></dependency>
application.yml
#info配置info:app.name: jialin-springcloudcompany.name: blog
此后点击链接后显示
controller
DeptController
//获取一些配置信息@Autowiredprivate DiscoveryClient client;//注册进来的微服务,获取一些消息@GetMapping("/dept/discover")public Object discover() {//获取微服务列表清单List<String> services = client.getServices();System.out.println("discover=>services" + services);//得到一一个具体的微服务信息,通过具体的微服务id, appl icaioinName ;List<ServiceInstance> instances = client.getInstances("SPRINGCLOUD-PROVIDER-DEPT");for (ServiceInstance instance : instances) {System.out.println(instance.getHost() + "\t" +instance.getPort() + "\t" +instance.getUri() + "\t" +instance.getServiceId());}return this.client;}
启动类
新增注解
@EnableDiscoveryClient
启动测试
集群环境配置
springcloud_eureka_7001
application.yml
server:port: 7001eureka:instance:hostname: #Eureka服务端的实例名称client:register-with-eureka: false #表示是否向eureka注册中心注册自己fetch-registry: false #为false表示自己为注册中心service-url: #监控页面#单机:http://${eureka.instance.hostname}:${server.port}/eureka/#集群:defaultZone: :7002/eureka/,:7003/eureka/
新建module
springcloud_eureka_7002
application.yml
server:port: 7002eureka:instance:hostname: #Eureka服务端的实例名称client:register-with-eureka: false #表示是否向eureka注册中心注册自己fetch-registry: false #为false表示自己为注册中心service-url: #监控页面defaultZone: :7001/eureka/,:7003/eureka/
启动类
EurekaServer_7002
package com.huang.springcloud;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;import org.flix.eureka.server.EnableEurekaServer;@SpringBootApplication@EnableEurekaServerpublic class EurekaServer_7002 {public static void main(String[] args) {SpringApplication.run(EurekaServer_7002.class,args);}}
springcloud_eureka_7003
application.yml
server:port: 7003eureka:instance:hostname: #Eureka服务端的实例名称client:register-with-eureka: false #表示是否向eureka注册中心注册自己fetch-registry: false #为false表示自己为注册中心service-url: #监控页面defaultZone: :7002/eureka/,:7001/eureka/
启动类
EurekaServer_7003
package com.huang.springcloud;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;import org.flix.eureka.server.EnableEurekaServer;@SpringBootApplication@EnableEurekaServerpublic class EurekaServer_7003 {public static void main(String[] args) {SpringApplication.run(EurekaServer_7003.class,args);}}
电脑文件配置
新增
127.0.127.0.127.0.
这些是一些简单的映射
springcloud-provider-dept-8001
重新配置
application.yml
#EUREKA的配置,服务注册到哪里eureka:client:service-url:defaultZone: :7001/eureka/,:7002/eureka/,:7003/eureka/instance:instance-id: springcloud-provide-dept8001 #修改默认信息
启动测试
先启动三个集群
EurekaServer_7001
EurekaServer_7002
EurekaServer_7003
再启动
springcloud-provider-dept-8001
测试成功
5.5、对比Zookeeper
回顾CAP原则
RDBMS (Mysql. Oracle、 sq|Server) =>ACID
NoSQL (redis. mongdb) => CAP
A (ACID是什么?
Atomicity
) 原子性C (Consistency
) -致性I (Isolation
) 隔离性D (Durability
) 持久性C (CAP是什么?
Consistency
)强- -致性A(Availability
) 可用性P (Partition tolerance
) 分区容错性CAP的三进二: CA、 AP、CP(只能同时满足两个)
一个分布式系统不可能同时很好的满足-致性,可用性和分区容错性这三个需求根据CAP理论的核心
CAP
原理,将NoSQL
数据库分成了满足CA
原则,满足CP
原则和满足AP
原则三大类:CA
: 单点集群,满足-致性,可用性的系统,通常可扩展性较差CP
:满足一致性,分区容错性的系统,通常性能不是特别高AP
:满足可用性,分区容错性的系统,通常可能对一致性要求低一-些作为服务注册中心,Eureka
比Zookeeper
好在哪里?
著名的CAP
理论指出,一个分布式系统不可能同时满足C (一致性) . A (可用性)、P (容错性).
由于分区容错性P
在分布式系统中是必须要保证
的,因此我们只能在A和C之间进行权衡
。
Zokeeper
保证的是CP
;Eureka
保证的是AP
;
Zookeeper保证的是CP
当向注册中心查询服务列表时,我们可以容忍注册中心返回的是几分钟以前的注册信息,但不能接受服务直接down
掉不可用。也就是说,服务注册功能对可用性的要求要高于-致性。 但是zk会出现这样-种情况, 当master
节点因为网络故障与其他节点失去联系时,剩余节点会重新进行leader
选举。问题在于,选举leader
的时间太长,30~120s
,且选举期间整个zk
集群都是不可用的,这就导致在选举期间注册服务瘫痪。在云部署的环境下,因为网络问题使得zk
集群失去master
节点是较大概率会发生的事件,虽然服务最终能够恢复,但是漫长的选举时间导致的注册长期不可用是不能容忍的。
Eureka保证的是AP
Eureka
看明白了这一-点,因此在设计时就优先保证可用性。Eureka
各个节 点都是平等的,几个节点挂掉不会影响正常节点的工作,剩余的节点依然可以提供注册和查询服务。而Eureka
的客户端在向某个Eureka
注册时,如果发现连接失败,则会自动切换至其他节点,只要有一台Eureka
还在,就能保住注册服务的可用性,只不过查到的信息可能不是最新的,除此之外,Eureka
还有一 种自我保护机制,如果在15分钟
内超过85%
的节 点都没有正常的心跳,那么Eureka
就认为客户端与注册中心出现了网络故障,此时会出现以下几种情况:
Eureka
不再从注册列表中移除因为长时间没收到心跳而应该过期的服务Eureka
仍然能够接受新服务的注册和查询请求,但是不会被同步到其他节点上(即保证当前节点依然可用)当网络稳定时,当前实例新的注册信息会被同步到其他节点中
因此,Eureka可以很好的应对因网络故障导致部分节点失去联系的情况,而不会像zookeeper那样使整个注册服务瘫痪
ribbon
ribbon
怎么读?
ribbon是什么?
Spring Cloud Ribbon
是基于Netflix Ribbon
实现的一套客户端负载均衡的工具。简单的说,Ribbon
是Netflix
发布的开源项目, 主要功能是提供客户端的软件负载均衡算法,将NetFlix
的中间层服务连接在一起。Ribbon
的客户端组件提供一系列完整的配置项如:连接超时、重试等等。简单的说,就是在配置文件中列出LoadBalancer
(简称LB
:负载均衡)后面所有的机器,Ribbon
会 自动的帮助你基于某种规则(如简单轮询
,随机
连接等等)去连接这些机器。我们也很容易使用Ribbon
实现自定义的负载均衡算法!
ribbon能干嘛?
LB
, 即负载均衡(Load Balance
),在微服务或分布式集群中经常用的一种应用。负载均衡简单的说就是将用户的请求平摊的分配到多个服务上,从而达到系统的HA
(高可用) .常见的负载均衡软件有Nginx, Lvs
等等dubbo
.SpringCloud
中均给我们提供了负载均衡,SpringCloud
的负载均衡算法可以自定义负载均衡简单分类:| 集中式LB
即在服务的消费方和提供方之间使用独立的LB
设施,如Nginx
, 由该设施负责把访问请求通过某种策略转发至服务的提供方! 进程式LB
将LB
逻辑集成到消费方,消费方从服务注册中心获知有哪些地址可用,然后自己再从这些地址中选出-一个合适的服务器。Ribbon
就属于进程内LB
,它只是一一个类库,集成于消费方进程,消费方通过它来获取到服务提供方的地址!客户端集成Ribbon
选择springcloud_consumer_dept_80
添加以下配置修改
jar
<!-- /artifact/org.springframework.cloud/spring-cloud-starter-ribbon --><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-ribbon</artifactId><version>1.4.6.RELEASE</version></dependency><!--EUREKA--><!-- /artifact/org.springframework.cloud/spring-cloud-starter-eureka --><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-eureka</artifactId><version>1.4.6.RELEASE</version></dependency>
配置文件
application.yml
server:port: 8009eureka:client:register-with-eureka: false #表示是否向eureka注册中心注册自己service-url: #监控页面#单机:http://${eureka.instance.hostname}:${server.port}/eureka/#集群:defaultZone: :7002/eureka/,:7003/eureka/,:7001/eureka/
启动类
新增注解
DeptConsumer_80
@EnableEurekaClient
此时再配置有关Ribbon
的 负载均衡,首先配置Bean
config
ConfigBean
在RestTemplate
添加注解
@LoadBalanced//配置负载均衡
package com.huang.springcloud.config;import flix.loadbalancer.IRule;import flix.loadbalancer.RandomRule;import org.springframework.cloud.client.loadbalancer.LoadBalanced;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import org.springframework.web.client.RestTemplate;@Configurationpublic class ConfigBean {//@Configuration--spring applicationContext.xml@Bean@LoadBalanced//配置负载均衡public RestTemplate getRestTemplate(){return new RestTemplate();}}
此时引出新的问题DeptConsumerController
中配置访问路径为
private static final String REST_URL_PREFIX="http://localhost:8001";
就必须进行修改,否者负载均衡就没有意义了。Ribbon
我们这里的地址应该是一个变量, 通过服务名来访向
controller
DeptConsumerController
package com.huang.springcloud.controller;import com.huang.springcloud.pojo.Dept;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Controller;import org.springframework.web.bind.annotation.PathVariable;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RestController;import org.springframework.web.client.RestTemplate;import java.util.List;@RestControllerpublic class DeptConsumerController {//理解:消费者不应该有service层//参数: (url,实体: Map , Class<T> responseType)@Autowiredprivate RestTemplate restTemplate;//提供多种便捷访问远程http服务的方法,简单的Restful服务模板//private static final String REST_URL_PREFIX="http://localhost:8001";//Ribbon.我们这里的地址,应该是一个变量, 通过服务名来访向private static final String REST_URL_PREFIX="http://SPRINGCLOUD-PROVIDER-DEPT";@RequestMapping("/consumer/dept/add")public Boolean add(Dept dept){return restTemplate.postForObject(REST_URL_PREFIX+"/dept/add",dept,Boolean.class);}@RequestMapping("/consumer/dept/get/{id}")public Dept get(@PathVariable("id") Long id){return restTemplate.getForObject(REST_URL_PREFIX+"/dept/get"+id,Dept.class);}@RequestMapping("/consumer/dept/list")public List<Dept> list(){return restTemplate.getForObject(REST_URL_PREFIX+"/dept/list",List.class);}}
此时便可以进行启动测试
Ribbon
刑Eureka
整合以后。客户端可以直按调用,不用关心IP地址和端口号
测试成功
ribbon实现负载均衡
原理图
环境搭建
再创建两个数据库
db02
/*Navicat MySQL Data TransferSource Server : 123Source Server Version : 50622Source Host : 127.0.0.1:3306Source Database : db02Target Server Type : MYSQLTarget Server Version : 50622File Encoding : 65001Date: -11-25 10:33:57*/SET FOREIGN_KEY_CHECKS=0;-- ------------------------------ Table structure for dept-- ----------------------------DROP TABLE IF EXISTS `dept`;CREATE TABLE `dept` (`deptno` bigint(20) NOT NULL AUTO_INCREMENT,`dname` varchar(60) DEFAULT NULL,`db_source` varchar(60) DEFAULT NULL,PRIMARY KEY (`deptno`)) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8 COMMENT='部门表';-- ------------------------------ Records of dept-- ----------------------------INSERT INTO `dept` VALUES ('1', '开发部', 'db02');INSERT INTO `dept` VALUES ('2', '人事部', 'db02');INSERT INTO `dept` VALUES ('3', '财务部', 'db02');INSERT INTO `dept` VALUES ('4', '市场部', 'db02');INSERT INTO `dept` VALUES ('5', '运维部', 'db02');
db03
/*Navicat MySQL Data TransferSource Server : 123Source Server Version : 50622Source Host : 127.0.0.1:3306Source Database : db03Target Server Type : MYSQLTarget Server Version : 50622File Encoding : 65001Date: -11-25 10:34:08*/SET FOREIGN_KEY_CHECKS=0;-- ------------------------------ Table structure for dept-- ----------------------------DROP TABLE IF EXISTS `dept`;CREATE TABLE `dept` (`deptno` bigint(20) NOT NULL AUTO_INCREMENT,`dname` varchar(60) DEFAULT NULL,`db_source` varchar(60) DEFAULT NULL,PRIMARY KEY (`deptno`)) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8 COMMENT='部门表';-- ------------------------------ Records of dept-- ----------------------------INSERT INTO `dept` VALUES ('1', '研发部', 'db03');INSERT INTO `dept` VALUES ('2', '人事部', 'db03');INSERT INTO `dept` VALUES ('3', '财务部', 'db03');INSERT INTO `dept` VALUES ('4', '市场部', 'db03');INSERT INTO `dept` VALUES ('5', '运维部', 'db03');
新增两个客户端
springcloud-provider-dept-8002
springcloud-provider-dept-8003
由于配置与springcloud-provider-dept-8001
几乎相同,所以只对一个新建进行展示
springcloud-provider-dept-8003
项目结构
jar
<dependencies><!--EUREKA--><!-- /artifact/org.springframework.cloud/spring-cloud-starter-eureka --><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-eureka</artifactId><version>1.4.6.RELEASE</version></dependency><!--完善监控信息--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-actuator</artifactId></dependency><dependency><groupId>com.huang</groupId><artifactId>springcloud_api</artifactId><version>1.0-SNAPSHOT</version></dependency><dependency><groupId>junit</groupId><artifactId>junit</artifactId><scope>test</scope></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId></dependency><dependency><groupId>com.alibaba</groupId><artifactId>druid</artifactId></dependency><dependency><groupId>ch.qos.logback</groupId><artifactId>logback-core</artifactId></dependency><dependency><groupId>org.mybatis.spring.boot</groupId><artifactId>mybatis-spring-boot-starter</artifactId></dependency><!--test--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-test</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><!--jetty--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-jetty</artifactId></dependency><!--热部署工具--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-devtools</artifactId></dependency></dependencies>
配置文件
注意修改数据库
application.yml
server:port: 8003#mybatis配置mybatis:type-aliases-package: com.huang.springcloud.pojoconfig-location: classpath:mybatis/mybatis-config.xmlmapper-locations: classpath:mybatis/mapper/*.xml#spring的配置spring:application:name : springcloud-provider-deptdatasource :type: com.alibaba.druid.pool.DruidDataSourcedriver-class -name: org.gjt.mm.mysql.Driverurl: jdbc:mysql://localhost:3306/db03?useUnicode=true&characterEncoding=utf-8username : rootpassword: jia5211314#EUREKA的配置,服务注册到哪里eureka:client:service-url:defaultZone: :7001/eureka/,:7002/eureka/,:7003/eureka/instance:instance-id: springcloud-provide-dept8003 #修改默认信息#info配置info:app.name: jialin-springcloudcompany.name: blog
mybatis-config.xml
<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE configurationPUBLIC "-////DTD Config 3.0//EN""/dtd/mybatis-3-config.dtd"><configuration><settings><!--开启二级缓存--><setting name="cacheEnabled" value="true"/></settings></configuration>
DeptMapper.xml
<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE mapperPUBLIC "-////DTD Config 3.0//EN""/dtd/mybatis-3-mapper.dtd"><mapper namespace="com.huang.springcloud.dao.DeptDao"><insert id="addDept" parameterType="Dept">insert into dept (dname,db_source)values (#{dname},DATABASE());</insert><select id="queryById" parameterType="Dept" resultType="Dept">select * from deptwhere deptno=#{deptno};</select><select id="queryAll" resultType="Dept" parameterType="Dept">select * from dept;</select></mapper>
controller
DeptController
package com.huang.springcloud.controller;import com.huang.springcloud.pojo.Dept;import com.huang.springcloud.service.DeptService;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.web.bind.annotation.*;import java.util.List;@RestControllerpublic class DeptController {@Autowiredprivate DeptService deptService;@PostMapping("/dept/add")public boolean addDept(Dept dept){return deptService.addDept(dept);}@GetMapping("/dept/get/{id}")public Dept addDept(@PathVariable("id") Long id){return deptService.queryById(id);}@RequestMapping("/dept/list")public List<Dept> queryAll(){return deptService.queryAll();}}
dao
DeptDao
package com.huang.springcloud.dao;import com.huang.springcloud.pojo.Dept;import org.apache.ibatis.annotations.Mapper;import org.springframework.stereotype.Repository;import java.util.List;@Mapper@Repositorypublic interface DeptDao {boolean addDept(Dept dept);Dept queryById(Long id);List<Dept> queryAll();}
service
DeptService
package com.huang.springcloud.service;import com.huang.springcloud.pojo.Dept;import java.util.List;public interface DeptService {boolean addDept(Dept dept);Dept queryById(Long id);List<Dept> queryAll();}
DeptServiceImpl
package com.huang.springcloud.service;import com.huang.springcloud.dao.DeptDao;import com.huang.springcloud.pojo.Dept;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Service;import java.util.List;@Servicepublic class DeptServiceImpl implements DeptService{@Autowiredprivate DeptDao deptDao;public boolean addDept(Dept dept) {return deptDao.addDept(dept);}public Dept queryById(Long id) {return deptDao.queryById(id);}public List<Dept> queryAll() {return deptDao.queryAll();}}
启动类
DeptProvider_8003
package com.huang.springcloud;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;import org.flix.eureka.EnableEurekaClient;@SpringBootApplication@EnableEurekaClient//在服务启动后自动注册到Eureka中public class DeptProvider_8003 {public static void main(String[] args) {SpringApplication.run(DeptProvider_8003.class,args);}}
启动测试
测试成功
引出新的问题,如果我们不希望使用默认配置,想自己配置策略怎么办呢?
自定义负载均衡
在springcloud_consumer_dept_80
中进行配置选择不同的配置策略
config
ConfigBean
package com.huang.springcloud.config;import flix.loadbalancer.IRule;import flix.loadbalancer.RandomRule;import org.springframework.cloud.client.loadbalancer.LoadBalanced;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import org.springframework.web.client.RestTemplate;@Configurationpublic class ConfigBean {//@Configuration--spring applicationContext.xml//配置负载均衡实现RestTemplate// IRule// RoundRobinRule 轮询// RandomRule 随机// AvailabilityFilteringRule :会先过滤掉跳闸、访问故障的服务~,对剩下的进行轮询// RetryRule :公 先按照轮的获收服务~,如果服务获收失败,则公在指定的时间内进行,重it@Bean@LoadBalanced//配置负载均衡public RestTemplate getRestTemplate(){return new RestTemplate();}}
自定义规则不要和主启动类同级,放到启动类上一级。
myrule
HuangRule
package com.huang.myrule;import flix.loadbalancer.IRule;import flix.loadbalancer.RandomRule;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;@Configurationpublic class HuangRule {@Beanpublic IRule myIRule(){return new RandomRule();}}
这是自己的规则
HuangRandomRule
//// Source code recreated from a .class file by IntelliJ IDEA// (powered by Fernflower decompiler)//package com.huang.myrule;import flix.client.config.IClientConfig;import flix.loadbalancer.AbstractLoadBalancerRule;import flix.loadbalancer.ILoadBalancer;import flix.loadbalancer.Server;//import edu.umd.cs.findbugs.annotations.SuppressWarnings;import java.util.List;import java.util.concurrent.ThreadLocalRandom;public class HuangRandomRule extends AbstractLoadBalancerRule {public HuangRandomRule() {}//@SuppressWarnings({"RCN_REDUNDANT_NULLCHECK_OF_NULL_VALUE"})public Server choose(ILoadBalancer lb, Object key) {if (lb == null) {return null;} else {Server server = null;while(server == null) {if (Thread.interrupted()) {return null;}List<Server> upList = lb.getReachableServers();//获得还活着的服务List<Server> allList = lb.getAllServers();//获得全部服务int serverCount = allList.size();if (serverCount == 0) {return null;}int index = this.chooseRandomInt(serverCount);server = (Server)upList.get(index);//从活着的获取一个if (server == null) {Thread.yield();} else {if (server.isAlive()) {return server;}server = null;Thread.yield();}}return server;}}protected int chooseRandomInt(int serverCount) {return ThreadLocalRandom.current().nextInt(serverCount);}public Server choose(Object key) {return this.choose(this.getLoadBalancer(), key);}public void initWithNiwsConfig(IClientConfig clientConfig) {}}
然后为了能扫描到,就必须在启动类上添加注解
启动类
//在微服务启动时加载@RibbonClient(name = "SPRINGCLOUD-PROVIDER-DEPT",configuration = HuangRule.class)
这样就可以正常使用了
7、Feign负载均衡
7.1、简介
feign
是声明式的web service
客户端,它让微服务之间的调用变得更简单了,类似controller
调用service
。SpringCloud
集成了Ribbon
和Eureka
,可在使用Feign
时提供负载均衡的http客户端。
只需要创建一一个接口,然后添加注解即可!
feign
,主要是社区,大家都习惯面向接口编程。这个是很多开发人员的规范。调用微服务访问两种方法
微服务名字[ribbon
]接口和注解[feign
]
Feign能干什么?
Feign
旨在使编写Java Http
客户端变得更容易前面在使用Ribbon
+RestTemplate
时,利用RestTemplate
对Http
请求的封装处理,形成了一套模板化的调用方法。但是在实际开发中,由于对服务依赖的调用可能不止一处,往往- -个接口会被多处调用,所以通常都会针对每个微服务自行封装-些客户端类来包装这些依赖服务的调用。 所以,Feign
在此基础. 上做了进一-步封装,由他来帮助我们定义和实现依赖服务接口的定义,在Feign
的实现下, 我们只需要创建一-个接口并使用注解的方式来配置它(类似于以前Dao
接口上标注Mapper
注解,现在是一个微服务接口 上面标注一个Feign
注解即可。)即可完成对服务提供方的接口绑定,简化了使用Spring Cloud Ribbon
时,自动封装服务调用客户端的开发量。Feign集成了Ribbon
利用Ribbon
维护了MicroServiceCloud-Dept
的服务列表信息,并且通过轮询实现了客户端的负载均衡,而与Ribbon
不同的是,通过Feign
只需要定义服务绑定接口且以声明式的方法,优雅而且简单的实现了服务调用。7.2、Feign使用步骤
新建一个项目springcloud-consumer-dept-feign
项目与springcloud_consumer_dept_80
相同,这里不再赘述
项目目录
导入新的依赖
jar
<!--feign--><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-feign</artifactId><version>1.4.6.RELEASE</version></dependency>
然后再回到springcloud_api
进行添加,或者直接放到springcloud-consumer-dept-feign
也可以
springcloud-consumer-dept-feign
service
DeptClientService
package com.huang.springcloud.service;import com.huang.springcloud.pojo.Dept;import org.springframework.cloud.openfeign.FeignClient;import org.springframework.web.bind.annotation.GetMapping;import org.springframework.web.bind.annotation.PathVariable;import org.springframework.web.bind.annotation.PostMapping;import java.util.List;@Component@FeignClient(value = "SPRINGCLOUD-PROVIDER-DEPT")public interface DeptClientService {@GetMapping(" /dept/get/{id}")public Dept queryById(@PathVariable("id") Long id);@GetMapping("/dept/list")public List<Dept> queryA11();@PostMapping("/dept/add")public Dept addDept(Dept dept);}
然后去controller
层进行修改
controller
DeptConsumerController
package com.huang.springcloud.controller;import com.huang.springcloud.pojo.Dept;import com.huang.springcloud.service.DeptClientService;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.web.bind.annotation.PathVariable;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RestController;import org.springframework.web.client.RestTemplate;import java.util.List;@RestControllerpublic class DeptConsumerController {@Autowiredprivate DeptClientService service = null;@RequestMapping("/ consumer/dept/ add")public boolean add(Dept dept) {return this.service.addDept(dept);}@RequestMapping("/ consumer/dept/get/{id}")public Dept get(@PathVariable("id") Long id) {return this.service.queryById(id);}@RequestMapping("/consumer/dept/list")public List<Dept> list() {return this.service.queryA11();}}
然后配置启动类
启动类
FeignDeptConsumer_80
package com.huang.springcloud;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;import org.flix.eureka.EnableEurekaClient;import org.springframework.cloud.openfeign.EnableFeignClients;import org.springframework.ponentScan;//`Ribbon`刑`Eureka`整合以后。客户端可以直按调用,不用关心IP地址和端口号@SpringBootApplication@EnableEurekaClient@EnableFeignClients( basePackages = {"com.huang.springcloud"})//@ComponentScan("com.huang.springcloud")public class FeignDeptConsumer_80 {public static void main(String[] args) {SpringApplication.run(FeignDeptConsumer_80.class,args);}}
启动测试
测试成功
Hystrix
分布式系统面临的问题
复杂分布式体系结构中的应用程序有数-十个依赖关系,每个依赖关系在某些时候将不可避免的失败!
服务雪崩
多个微服务之间调用的时候,假设微服务A调用微服务B和微服务C,微服务B和微服务C又调用其他的微服务,这就是所谓的"扇出”、如果扇出的链路上某个微服务的调用响应时间过长或者不可用,对微服务A的调用就会占用越来越多的系统资源,进而引起系统崩溃,所谓的“雪崩效应”。
对于高流量的应用来说,单- -的后端依赖可能会导致所有服务器上的所有资源都在几秒中内饱和。比失败更糟糕的是,这些应用程序还可能导致服务之间的延迟增加,备份队列,线程和其他系统资源紧张,导致整个系统发生更多的级联故障,这些都表示需要对故障和延迟进行隔离和管理,以便单个依赖关系的失败,不能取消整个应用程序或系统。
我们需要.弃车保帅.
什么是Hystrix
Hystrix
是一“个用于处理分布式系统的延迟和容错的开源库, 在分布式系统里,许多依赖不可避免的会调用失败,比如超时,异常等,Hystrix
能够保证在一一个依赖出问题的情况下,不会导致整体服务失败,避免级联故障,以提高分布式系统的弹性。
"断路器”本身是- -种开关装置, 当某个服务单元发生故障之后,通过断路器的故障监控(类似熔断保险丝),向调用方返回- -个服务预期的可处理的备选响应(FallBack
) ,而不是长时间的等待或者抛出调用方法无法处理的异常,这样就可以保证了服务调用方的线程不会被长时间,不必要的占用,从而避免了故障在分布式系统中的蔓延,乃至雪崩
服务降级服务熔断服务限流接近实时的监控能干嘛
…
官网资料
/Netflix/Hystrix/wiki
服务熔断
是什么
熔断机制是对应雪崩效应的- -种微服务链路保护机制。
当扇出链路的某个微服务不可用或者响应时间太长时,会进行服务的降级,进而熔断该节点微服务的调用,快速返回错误的响应信息。当检测到该节点微服务调用响应正常后恢复调用链路。在SpringCloud
框架里熔断机制通过Hystrix
实现。Hystrix
会监控微服务间调用的状况, 当失败的调用到一定阈值,缺省是5秒内20次调用失败就会启动熔断机制。熔断机制的注解是@HysrixCommand
.
环境准备
父项目下新建module
springcloud-provide-dept-hystrix-8001
将springcloud-provide-dept-hystrix-8001
里的内容放进去(内容一样)这里不再赘述
1、导入依赖
2、编写配置文件
3、开启这个功能@EnablexXXXX
4、配置类
jar
<dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-hystrix</artifactId><version>1.4.6.RELEASE</version></dependency>
配置文件
做如下修改
application.yml
#EUREKA的配置,服务注册到哪里eureka:client:service-url:defaultZone: :7001/eureka/,:7002/eureka/,:7003/eureka/instance:instance-id: springcloud-provide-hystrix-dept8001 #修改默认信息prefer-ip-address: false#对地址信息隐藏意义不大为true可以显示ip
controller
做如下修改
DeptController
package com.huang.springcloud.controller;import com.huang.springcloud.pojo.Dept;import com.huang.springcloud.service.DeptService;import flix.hystrix.contrib.javanica.annotation.HystrixCommand;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.cloud.client.ServiceInstance;import org.springframework.cloud.client.discovery.DiscoveryClient;import org.springframework.web.bind.annotation.*;import java.util.List;@RestControllerpublic class DeptController {@Autowiredprivate DeptService deptService;//获取一些配置信息@Autowiredprivate DiscoveryClient client;@GetMapping("/dept/get/{id}")@HystrixCommand(fallbackMethod = "hystrixGet" )//失败时调用方法public Dept addDept(@PathVariable("id") Long id) {Dept dept=deptService.queryById(id);if (dept==null){throw new RuntimeException("id=>"+id+", 不存在该用户,或者信息无法找到~");}return dept;}//备逃方法public Dept hystrixGet (@PathVariable("id") Long id){return new Dept( ). setDeptno(id). setDname("id=>"+id+"没有对应的信息,null--@Hystrix"). setDb_source("no this database in MySQL");}}
启动类
HystrixDeptProvider_8001
@EnableCircuitBreaker //添加对熔断的支持
启动测试
7001
7002
hystrix8001
80
服务降级
在springcloud-consumer-dept-feign
中service
添加新的方法实现服务降级
service
DeptClientServiceFallbackFactory
package com.huang.springcloud.service;import com.huang.springcloud.pojo.Dept;import feign.hystrix.FallbackFactory;import org.ponent;import java.util.List;//降级~@Componentpublic class DeptClientServiceFallbackFactory implements FallbackFactory {public DeptClientService create(Throwable throwable) {return new DeptClientService() {public Dept queryById(Long id) {return new Dept().setDeptno(id).setDname("id=>" + id + "没有对应的信息,客户端提供了降级的信息,这个服务现在已经被关闭").setDb_source("没有数据~");}public List<Dept> queryA11() {return null;}public Boolean addDept(Dept dept) {return null;}};}}
然后回到DeptClientService
增加新的注解与DeptClientServiceFallbackFactory
产生联系
DeptClientService
@FeignClient(value = "SPRINGCLOUD-PROVIDER-DEPT",fallbackFactory = DeptClientServiceFallbackFactory.class)
package com.huang.springcloud.service;import com.huang.springcloud.pojo.Dept;import org.springframework.cloud.openfeign.FeignClient;import org.ponent;import org.springframework.web.bind.annotation.GetMapping;import org.springframework.web.bind.annotation.PathVariable;import org.springframework.web.bind.annotation.PostMapping;import java.util.List;@Component@FeignClient(value = "SPRINGCLOUD-PROVIDER-DEPT",fallbackFactory = DeptClientServiceFallbackFactory.class)public interface DeptClientService {@GetMapping("/dept/get/{id}")public Dept queryById(@PathVariable("id") Long id);@GetMapping("/dept/list")public List<Dept> queryA11();@PostMapping("/dept/add")public Boolean addDept(Dept dept);}
然后去配置文件进行最后配置
配置文件
添加新的配置
application.yml
#开启降级feign.hystrixfeign:hystrix:enabled: true
必须开这个,否则feign
和Hystrix
不能共用
server:port: 8009#开启降级feign.hystrixfeign:hystrix:enabled: trueeureka:client:register-with-eureka: false #表示是否向eureka注册中心注册自己service-url: #监控页面#单机:http://${eureka.instance.hostname}:${server.port}/eureka/#集群:defaultZone: :7002/eureka/,:7003/eureka/,:7001/eureka/
启动测试
7001
8001
feign
80
此时正常
模拟关闭8001
服务器再次尝试
服务熔断与服务降级
服务熔断:
服务端~ 某 个服务超时或者异常,引起熔断心,保险丝~
服务降级:
客户端~ 从整体网站请求负载考虑,当某个服务熔断或者关闭之后,服务将不再被调用~
此时在客户端,我们可以准备一个 FallbackFactory,返回一个默认的值( 缺省值),整体的服务水平下降了~ 但是,好歹能用 ~
比直接挂掉强~
Dashboard流监控
参考 /Netflix/Hystrix/wiki在父项目下新建springcloud-consumer-hystrix-dashboard
,依据springcloud_consumer_dept_80
对项目进行补充
jar
新增
<!--Hystrix依赖--><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-hystrix</artifactId><version>1.4.6.RELEASE</version></dependency><!--Hystrix依赖--><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-hystrix-dashboard</artifactId><version>1.4.6.RELEASE</version></dependency>
<!--实体类+web--><dependencies><!-- /artifact/org.springframework.cloud/spring-cloud-starter-ribbon --><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-ribbon</artifactId><version>1.4.6.RELEASE</version></dependency><!--EUREKA--><!-- /artifact/org.springframework.cloud/spring-cloud-starter-eureka --><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-eureka</artifactId><version>1.4.6.RELEASE</version></dependency><dependency><groupId>com.huang</groupId><artifactId>springcloud_api</artifactId><version>1.0-SNAPSHOT</version></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><!--热部署工具--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-devtools</artifactId></dependency></dependencies>
配置文件
application.yml
server:port: 9001
启动类
DeptConsumerDashboard_9001
package com.huang.springcloud;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;import org.flix.hystrix.dashboard.EnableHystrixDashboard;@SpringBootApplication@EnableHystrixDashboard //开启public class DeptConsumerDashboard_9001 {public static void main(String[] args) {SpringApplication.run(DeptConsumerDashboard_9001.class, args);}}
同时要保证每个springcloud-provider-dept-8001``springcloud-provider-dept-8002``springcloud-provider-dept-8003
都必须有依赖
<!--完善监控信息--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-actuator</artifactId></dependency>
启动9001
在springcloud-provide-dept-hystrix-8001
中放入依赖
<!--Hystrix依赖--><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-hystrix</artifactId><version>1.4.6.RELEASE</version></dependency>
然后配置启动类
HystrixDeptProvider_8001
//增加个Servlet@Beanpublic ServletRegistrationBean hystrixMetricsStreamServlet() {ServletRegistrationBean registrationBean = new ServletRegistrationBean(new HystrixMetricsStreamServlet());registrationBean.addUrlMappings("/actuator/hystrix.stream");return registrationBean;}
package com.huang.springcloud;import flix.hystrix.contrib.metrics.eventstream.HystrixMetricsStreamServlet;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;import org.springframework.boot.web.servlet.ServletRegistrationBean;import org.springframework.cloud.client.discovery.EnableDiscoveryClient;import org.flix.eureka.EnableEurekaClient;import org.springframework.context.annotation.Bean;@SpringBootApplication@EnableEurekaClient//在服务启动后自动注册到Eureka中@EnableDiscoveryClientpublic class DeptProvider_8001 {public static void main(String[] args) {SpringApplication.run(DeptProvider_8001.class, args);}//增加个Servlet@Beanpublic ServletRegistrationBean hystrixMetricsStreamServlet() {ServletRegistrationBean registrationBean = new ServletRegistrationBean(new HystrixMetricsStreamServlet());registrationBean.addUrlMappings("/actuator/hystrix.stream");return registrationBean;}}
必须要触动熔断机制才能显示数据
启动7001
,8001
,9001
翻车一直处于Loading
在9001
配置
application.yml
新增
#hystrix配置hystrix:dashboard:proxy-strema-allow-list: "*"
然后用谷歌浏览器测试成功
Zuul路由网关
概述
什么是Zuul?
Zuul
包含了对请求的路由和过滤两个最主要的功能:
其中路由功能负责将外部请求转发到具体的微服务实例上,是实现外部访问统- -入口的基础, 而过滤器功能则负责对请求的处理过程进行干预,是实现请求校验,服务聚合等功能的基础。Zuul
和Eureka
进行整合, 将Zuul
自身注册为Eureka
服务治理下的应用,同时从Eureka
中获得其他微服务的消息, 也即以后的访问微服务都是通过Zuul
跳转后获得。
注意:Zuul
服务最终还是会注册进Eureka
提供:代理+路由+过滤三大功能!
Zuul能干嘛?
●路由
●过滤
官网文档: /Netflix/zuul
新建springcloud-zuul-9527
springcloud-zuul-9527
复制springcloud-consumer-hystrix-dashboard
的依赖,然后新增
jar
<!--zuul--><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-zuul</artifactId><version>1.4.6.RELEASE</version></dependency>
<!--实体类+web--><dependencies><!--zuul--><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-zuul</artifactId><version>1.4.6.RELEASE</version></dependency><!--Hystrix依赖--><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-hystrix</artifactId><version>1.4.6.RELEASE</version></dependency><!--Hystrix依赖--><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-hystrix-dashboard</artifactId><version>1.4.6.RELEASE</version></dependency><!-- /artifact/org.springframework.cloud/spring-cloud-starter-ribbon --><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-ribbon</artifactId><version>1.4.6.RELEASE</version></dependency><!--EUREKA--><!-- /artifact/org.springframework.cloud/spring-cloud-starter-eureka --><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-eureka</artifactId><version>1.4.6.RELEASE</version></dependency><dependency><groupId>com.huang</groupId><artifactId>springcloud_api</artifactId><version>1.0-SNAPSHOT</version></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><!--热部署工具--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-devtools</artifactId></dependency></dependencies>
配置文件
application.yml
server:port: 9527#spring的配置spring:application:name : springcloud-zuul#EUREKA的配置,服务注册到哪里eureka:client:service-url:defaultZone: :7001/eureka/,:7002/eureka/,:7003/eureka/instance:instance-id: prefer-ip-address: true#隐藏真实ip#info配置info:app.name: jialin-springcloudcompany.name: blog
电脑配置文件
然后修改电脑配置文件
启动器
ZuulApplication_9527
package com.huang.springcloud;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;import org.flix.zuul.EnableZuulProxy;@SpringBootApplication@EnableZuulProxypublic class ZuulApplication_9527 {public static void main(String[] args) {SpringApplication.run(ZuulApplication_9527.class, args);}}
启动
springcloud_eureka_7001
springcloud-provider-dept-8001
springcloud-zuul-9527
测试成功
但是此时暴漏了微服务名字
需要进行替换或隐藏找到项目springcloud-zuul-9527
配置文件
新增
application.yml
#路由网关zuul:routes:mydept.serviceId: springcloud-provider-deptmydept.path: /mydept/**
测试原路径
新路径
如果要封锁原路径则需要
需要进行替换或隐藏找到项目springcloud-zuul-9527
配置文件
新增
application.yml
#路由网关zuul:routes:mydept.serviceId: springcloud-provider-deptmydept.path: /mydept/**ignored-services: springcloud-provider-dept #不能再使用这个路径访问了
测试成功
隐藏全部
#路由网关zuul:routes:mydept.serviceId: springcloud-provider-deptmydept.path: /mydept/**ignored-services: * #隐藏全部
配置前缀
#路由网关zuul:routes:mydept.serviceId: springcloud-provider-deptmydept.path: /mydept/**ignored-services: * #隐藏全部prefix: /kuang #配置前缀
SpringCloud config分布式配置
概述
分布式系统面临的–配置文件的问题
微服务意味着要将单体应用中的业务拆分成一个个子服务,每个服务的粒度相对较小,因此系统中会出现大量的服务,由于每个服务都需要必要的配置信息才能运行,所以-套集中式的,动态的配置管理设施是必不可少的。SpringCloud
提供了ConfigServer
来解决这个问题,我们每一一个微服务自 己带着- -个aplication.yml
, 那上百的的
配置文件要修改起来,岂不是要发疯!
什么是SpringCloud config分布式配置中心
Spring Cloud Config
为微服务架构中的微服务提供集中化的外部配置支持,配置服务器为各个不同微服务应用的所有环节提供了-一个中心化的外部配置。
Spring Cloud Config 分为服务端和客户端两部分;
服务端也称为分布式配置中心,它是一个独立的微服务应用, 用来连接配置服务器并为客户端提供获取配置信息,加密,解密信息等访问接口。
客户端则是通过指定的配置中心来管理应用资源,以及与业务相关的配置内容,并在启动的时候从配置中心获取和加载配置信息。配置服务器默认采用git来存储配置信息,这样就有助于对环境配置进行版本管理。并且可以通过git
客户端工具来方便的管理和访问配置内容。
SpringCloud config分布式配置中心能干嘛
●集中管理配置文件
●不同环境,不同配置,动态化的配置更新,分环境部署,比如/dev
/test/
/prod
/beta
/release
●运行期间动态调整配置,不再需要在每个服务部署的机器上编写配置文件,服务会向配置中心统-拉取配置自己的信息。
●当配置发生变动时,服务不需要重启,即可感知到配置的变化,并应用新的配置
●将配置信息以REST
接口的形式暴露
SpringCloud config分布式配置中心与github整合
由于Spring Cloud Config
默认使用Git
来存储配置文件(也有其他方式, 比如支持SVN
和本地文件) .但是最推荐的还是Git
,而且使用的是http / https
访问的形式;
官网文档
/spring-cloud-dalston.html
Git
Git相关知识我已经做过,详情访问:狂神聊Git(环境配置+基本理论+项目搭建+文件操作+IDEA集成+资料代码)
开始动手
在父项目下新建
springcloud-config-server-3344
jar
<dependencies><!--config--><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-config-server</artifactId><version>2.1.1.RELEASE</version></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-actuator</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency></dependencies>
配置文件
application.yml
server:port: 3344spring:application:name: springcloud-config-server#配置远程gitcloud:config:server:git:uri: /EverythingStart01/springcloud-config.git
启动类
开启服务
@EnableConfigServer
Config_Server_3344
package com.huang.springcloud;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;import org.springframework.cloud.config.server.EnableConfigServer;@SpringBootApplication@EnableConfigServerpublic class Config_Server_3344 {public static void main(String[] args) {SpringApplication.run(Config_Server_3344.class,args);}}
启动测试成功
远程新建文件
config-client.yml
spring:profiles:active: dev---server:port: 8201#spring的配置spring:profiles: devapplication:name : springcloud-provider-dept#EUREKA的配置,服务注册到哪里eureka:client:service-url:defaultZone: :7001/eureka/,:7002/eureka/,:7003/eureka/---server:port: 8202#spring的配置spring:profiles: testapplication:name : springcloud-provider-dept#EUREKA的配置,服务注册到哪里eureka:client:service-url:defaultZone: :7001/eureka/,:7002/eureka/,:7003/eureka/
客户端springcloud-config-client-3355
jar
<dependencies><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-config</artifactId><version>2.1.1.RELEASE</version></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-actuator</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency></dependencies>
配置文件
application.yml
#用户级别配置spring:application:name: springcloud-config-client-3355
bootstrap.yml
#系统级别的配置(优先级更高)spring:cloud:config:name: config-client #需要git读取的资源,不用后缀profile: dev #拿dev环境label: master #分支uri: http://localhost:3344#合起来相当于
controller
ConfigClientController
package com.huang.springcloud.controller;import org.springframework.beans.factory.annotation.Value;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.RestController;@RestControllerpublic class ConfigClientController {@Value("${spring.application.name}")private String applicationName;@Value("${eureka.client.service-url.defaultZone}")private String eurekaServer;@Value("${server.port}")private String port;@RequestMapping("/config")public String getConfig(){return "applicationName:"+applicationName+"eurekaServer:"+eurekaServer+"port:"+port;}}
启动类
Config_Client_3355
package com.huang.springcloud;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;@SpringBootApplicationpublic class Config_Client_3355 {public static void main(String[] args) {SpringApplication.run(Config_Client_3355.class,args);}}
测试启动
springcloud-config-server-3344
springcloud-config-client-3355
测试成功
实现配置与编码解耦
小项目springcloud-config-eureka-7001
远程文件
config-eureka.yml
spring:profiles:active: dev---server:port: 7001#spring的配置spring:profiles: devapplication:name : springcloud-config-eurekaeureka:instance:hostname: #Eureka服务端的实例名称client:register-with-eureka: false #表示是否向eureka注册中心注册自己fetch-registry: false #为false表示自己为注册中心service-url: #监控页面#单机:http://${eureka.instance.hostname}:${server.port}/eureka/#集群:defaultZone: :7002/eureka/,:7003/eureka/---server:port: 7001#spring的配置spring:profiles: testapplication:name : springcloud-config-eurekaeureka:instance:hostname: #Eureka服务端的实例名称client:register-with-eureka: false #表示是否向eureka注册中心注册自己fetch-registry: false #为false表示自己为注册中心service-url: #监控页面#单机:http://${eureka.instance.hostname}:${server.port}/eureka/#集群:defaultZone: :7002/eureka/,:7003/eureka/
接下来尝试优化springcloud-provider-dept-8001
config-dept.yml
spring:profiles:active: dev---server:port: 8001#mybatis配置mybatis:type-aliases-package: com.huang.springcloud.pojoconfig-location: classpath:mybatis/mybatis-config.xmlmapper-locations: classpath:mybatis/mapper/*.xml#spring的配置spring:profiles: devapplication:name : springcloud-config-deptdatasource :type: com.alibaba.druid.pool.DruidDataSourcedriver-class -name: org.gjt.mm.mysql.Driverurl: jdbc:mysql://localhost:3306/db02?useUnicode=true&characterEncoding=utf-8username : rootpassword: jia5211314#EUREKA的配置,服务注册到哪里eureka:client:service-url:defaultZone: :7001/eureka/,:7002/eureka/,:7003/eureka/instance:instance-id: springcloud-provide-dept8001 #修改默认信息#info配置info:app.name: jialin-springcloudcompany.name: blog---server:port: 8001#mybatis配置mybatis:type-aliases-package: com.huang.springcloud.pojoconfig-location: classpath:mybatis/mybatis-config.xmlmapper-locations: classpath:mybatis/mapper/*.xml#spring的配置spring:profiles: testapplication:name : springcloud-config-deptdatasource :type: com.alibaba.druid.pool.DruidDataSourcedriver-class -name: org.gjt.mm.mysql.Driverurl: jdbc:mysql://localhost:3306/db03?useUnicode=true&characterEncoding=utf-8username : rootpassword: jia5211314#EUREKA的配置,服务注册到哪里eureka:client:service-url:defaultZone: :7001/eureka/,:7002/eureka/,:7003/eureka/instance:instance-id: springcloud-provide-dept8001 #修改默认信息#info配置info:app.name: jialin-springcloudcompany.name: blog
新建项目
springcloud-config-eureka-7001
将springcloud_eureka_7001
中src
的文件全部拷贝过去
jar
<dependencies><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-config</artifactId><version>2.1.1.RELEASE</version></dependency><!-- /artifact/org.springframework.cloud/spring-cloud-starter-eureka-server --><dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-eureka-server</artifactId><version>1.4.6.RELEASE</version></dependency><!--热部署工具--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-devtools</artifactId></dependency></dependencies>
配置文件
application.yml
#用户级别配置spring:application:name: springcloud-config-eureka-7001
bootstrap.yml
#系统级别的配置spring:cloud:config:name: config-eureka #需要读取的资源,不用后缀profile: devlabel: masteruri: http://localhost:3344
启动测试
测试成功
同理改造
springcloud-provider-dept-8001
拷贝依赖
拷贝src
新增application.yml
新增bootstrap.yml链接远程(注意新增一个依赖)
<dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-config</artifactId><version>2.1.1.RELEASE</version></dependency>
不再赘述
测试成功
总结
spring cloud中文网
代码资源
含数据库
已上传至码云
跟着狂神学SpringCloud(Rest环境搭建+Eureka服务注册与发现+ribbon+Feign负载均衡+Hystrix+服务熔断+Zuul路由网关+SpringCloud config分布)
如果觉得《跟着狂神学SpringCloud(Rest环境搭建+Eureka服务注册与发现+ribbon+Feign负载均衡+Hy》对你有帮助,请点赞、收藏,并留下你的观点哦!