SpringCloud
- 是一个生态,不是一门技术,用来解决下面的问题
微服务的4个核心问题:
- 服务很多,客户如何访问?
- 这么多服务,服务之间怎么通信?
- 服务太多了,如何治理?
- 服务挂了怎么办?
解决方案:
- spring Cloud NetFix:一站式解决方案
- api网关:zuul组件
- Feign --HttpClient — Http通信方式,同步,阻塞问题
- 服务注册:Eureka
- 熔断机制:Hystrix
- Dubbo Zookeeper:半自动
- api:没有,第三方组件
- Dubbo:Rpc通信框架,异步
- 服务注册:zookeeper
- 熔断机制:没有,借助Hystrix
- Spring Cloud Alibaba :一站式解决方案
1.什么是微服务?
2.微服务之间怎么进行通信的?
- http通信协议、RPC通信
3.springcloud和dubbo有什么区别?
- springcloud是一个生态,有自己的网关zuul组件,dubbo没有,只能借助第三方,feign采用http同步的通信方式,会有阻塞,而dubbo采用rpc通信,异步的,无阻塞;springcloud的服务注册是Eureka,dubbo的服务注册是zookeeper,dubbo无熔断机制
- 最大区别:SpringCloud抛弃了Dubbo的RPC通信,基于HTTP的RESTful方式
4.springboot和springcloud,谈谈对他们的理解?
- springboot是一个快速构建的脚手架,springcloud用来解决分布式带来的问题,如通信,如何访问,熔断问题,基于springboot构建网站
- springBoot专注于快速,方便的开发单个个体微服务,springCloud关注全局的服务治理框架
- springCloud依赖springBoot
5.什么是服务熔断?什么是服务降级?
6.微服务的优缺点分别是什么?
7.微服务技术栈?
8.eureka和zookeeper都可以提供服务注册与发现的功能,说说两个的区别?
1、微服务
微服务:强调的是服务的大小,关注的是某一个点,是具体解决某一个问题/提供落地对应服务的一个服务应用
微服务架构:一种新的架构形式,提倡将单一应用程序划分为一组小的服务,服务之间互相协调,互相配合,为用户提供最终价值。
1.1、微服务优缺点
优点:
- 每个服务足够内聚,足够小,聚焦到一个指定的业务功能或业务需求
- 开发简单,开发效率提高,一个服务可能就是专一干某件事
- 微服务能够被小团队单独开发
- 微服务是松耦合的,无论在开发阶段还是部署阶段都是独立的
- 微服务只是业务逻辑的代码,不会和HTML、CSS或其他界面混合
- 每个微服务都有自己的存储能力,可以有自己的数据库,也可以有统一数据库
缺点:
- 开发人员要处理分布式系统的复杂性
- 多服务运维难度,随着服务的增加,运维的压力也增加
- 系统部署依赖
- 服务间通信 成本
- 数据一致性
1.2 微服务技术栈
微服务条目 | 落地技术 |
---|---|
服务开发 | SpringBoot,Spring,SpringMVC |
服务配置与管理 | Netfix公司的Archaius,阿里的Diamond等 |
服务注册与发现 | Eureka,Consul,zookeeper |
服务调用 | Rest,RPC,gRPC |
服务熔断器 | Htstrix、Envoy |
负载均衡 | Ribbon Nginx |
服务接口调用(客户端调用服务的简化工具) | Fegin |
消息队列 | Kafka RabbitMQ ActiveMQ |
服务配置中心管理 | SpringCloudConfig Chef |
服务路由(API网关) | Zuul |
服务监控 | Zabbix Nagios Metrics Specatator |
全链路追踪 | Zipkin Brave Dapper |
服务部署 | Docker OpenStack Kubernetes |
数据流操作开发包 | SpringCloud Stream(封装与redis,rabbit kafka等发送接收消息) |
事件消息总线 | SpringCloud Bus |
1.3 为什么选择SpringCloud作为技术架构
-
选型依据
- 整体解决方案和框架成熟度
- 社区热度
- 可维护性
-
当前IT公司的微服务架构?
- 阿里:dubbo+HFS
- 京东:JSF
- 新浪:Motan
- 当当网:DubboX
-
各微服务框架对比
功能点/服务框架 | Netfix/SpringCloud | Motan | gRPC | Thrift | Dubbo/DubboX |
---|---|---|---|---|---|
功能定位 | 完整的微服务框架 | RPC框架,但整合了ZK或Consul,实现集群环境的基本服务注册/发现 | RPC框架 | RPC框架 | 服务框架 |
支持Rest | 是,Ribbon | 否 | 否 | 否 | 否 |
支持RPC | 否 | 是(Hession2) | 是 | 是 | 是 |
支持对语言 | 是(Rest形式) | 否 | 是 | 是 | 否 |
负载均衡 | 是(服务端zuul+客户端Ribbon),zuul-服务,动态路由,云端负载均衡Eureka(针对中间层服务层) | 是(客户端) | 否 | 否 | 是(客户端) |
配置服务 | Netfix Archaius,SpringCloud Config Server 集中配置 | 是(zookeeper提高) | 否 | 否 | 否 |
服务调用链监控 | 是(zuul),zuul提高编译服务,API网关 | 否 | 否 | 否 | 否 |
高可用/容错 | 是(服务端Hystrix——客户端Ribbon) | 是(客户端) | 否 | 否 | 是(客户端) |
典型应用案例 | Netfix | Sina | |||
社区活跃程度 | 高 | 一般 | 高 | 一般 | |
其他 | SpringCloudBus为我们的应用程序带来了更多管理断点 | 支持降级 | Netfix内部再开发集成gRPC | IDL定义 | 实践的公司比较多 |
1.4 SpringCloud和SpringBoot关系
- springBoot专注于快速方便的开发单个个体微服务
- springCloud是关注全局的微服务协调整理治理框架,它将springBoot开发的一个个单体微服务整合并管理起来,为各个微服务之间提供:配置管理,服务发现,断路器,路由,微代理,事件总线,全局锁,决策竞选,分布式会话等集成服务
- springBoot可以离开springCloud独立使用,但是springCloud离不开springBoot
- springBoot专注于快速,方便的开发单个个体微服务,springCloud关注全局的服务治理框架
1.5 Dubbo和SpringCloud技术选型
- 分布式+服务治理Dubbo
目前成熟的传统互联网架构:应用服务化拆分+消息中间件
- Dubbo和SpringCloud对比
社区活跃度:
- https://github.com/dubbo
- https://github.com/spring-cloud
结果:
Dubbo | SpringCloud | |
---|---|---|
服务注册中心 | zookeeper | Spring Cloud Netfix Eureka |
服务调度方式 | RPC | Rest API |
服务监控 | Dubbo-monitor | Spring Boot Admin |
断路器 | 不完善 | Spring Cloud Netfix Hystrix |
服务网关 | 无 | Spring Cloud Netfix Zuul |
分布式配置 | 无 | Spring Cloud Config |
服务追踪 | 无 | Spring Cloud Seluth |
消息总线 | 无 | Spring Cloud Bus |
数据流 | 无 | Spring Cloud Stream |
批量任务 | 无 | Spring Cloud Task |
最大区别:SpringCloud抛弃了Dubbo的RPC通信,基于HTTP的RESTful方式
2、什么是SpringCloud
spring官网:Spring Cloud
springCloud中文文档:Spring Cloud Dalston 中文文档 参考手册 中文版
中文API文档:Spring Cloud Netflix 中文文档 参考手册 中文版
springCloud中国社区:http://springcloud.cn/
springCloud中文网:https://springcloud.cc
2.1 springcloud能干什么
- Distributed/versioned configuration (分布式/版本控制配置)
- Service registration and discovery 服务注册与发现
- Routing 路由
- Service-to-service calls 服务到服务的调用
- Load balancing 负载均衡配置
- Circuit Breakers 断路器
- Global locks 全局锁
- Distributed messaging 分布式消息管理
2.2 Spring Cloud版本选择
spring Boot | SPring Cloud | 关系 |
---|---|---|
1.2.x | Angle版本 | 兼容Spring Boot 1.2.x |
1.3.x | Brixton版本 | 兼容spring Boot 1.3.x 1.4.x |
1.4.x | Camden版本 | 兼容spring Boot 1.4.x 1.5.x |
1.5.x | Dalston | 1.5.x 不兼容2.0.x |
1.5.x | Edgware | 1.5.x 不兼容2.0.x |
2.0.x | Finchley | 兼容2.0.x 不兼容1.5.x |
2.1.x | Greenwich | |
2.2.x | Hoxton.SR12 | 2.2.0 — 2.4.0 |
2.4.x | 2020.0.5 | 2.4.0 — 2.6.0 |
2.6.x | 2021.0.0 | 2.6.1 — 2.6.4 |
2.3 工程
父工程:导入依赖
<!--打包方式 pom-->
<packaging>pom</packaging>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
<junit.version>4.12</junit.version>
<lombok.version>1.18.24</lombok.version>
</properties>
<dependencyManagement>
<dependencies>
<!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-dependencies -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>Hoxton.SR12</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<!--springBoot-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>2.3.1.RELEASE</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<!--数据库-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.29</version>
</dependency>
<!--数据源-->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.2.8</version>
</dependency>
<!--springboot启动器-->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>2.2.0</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>${junit.version}</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>${lombok.version}</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.11</version>
</dependency>
</dependencies>
</dependencyManagement>
<build>
<resources>
<resource>
<directory>src/main/resources</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
<filtering>true</filtering>
</resource>
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
<filtering>true</filtering>
</resource>
</resources>
</build>
springcloud-api:第一个微服务,只管pojo实体类
package com.liu.springCloud.pojo;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
import java.io.Serializable;
@Data
@NoArgsConstructor
@Accessors(chain = true) //支持链式写法
public class Dept implements Serializable {
//Dept实体类 orm 类表关系映射
private Long deptno; //主键自增不用写
private String dname;
//这个数据存在哪个数据库的字段 一个服务对应一个数据库,同一个信息可能存在不同的数据库
private String db_source; //自动生成
public Dept(String dname) {
this.dname = dname;
}
}
子模块中的依赖配置:
- 当前模块自己需要的依赖,如果父依赖中已经配置了版本,这里就不用写了
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>springCloud-01</artifactId>
<groupId>com.liu</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>springcloud-01-api</artifactId>
<dependencies>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
</dependencies>
</project>
springcloud-provider-dept-8001:第二个微服务,提供者
导入依赖
<dependencies>
<!-- https://mvnrepository.com/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>
<!--需要拿到实体类,配置api module-->
<dependency>
<groupId>com.liu</groupId>
<artifactId>springcloud-01-api</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
</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>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-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.yaml
server:
port: 8081
mybatis:
type-aliases-package: com.liu.springCloud.pojo
config-location: classpath:mybatis/mybatis-config.xml
mapper-locations: classpath:mybatis/mapper/*.xml
spring:
application:
name: springcloud-provider-dept
datasource:
type: com.alibaba.druid.pool.DruidDataSource
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://localhost:3306/db01?serverTimezone=UTC&useSSL=false&useUnicode=true&characterEncoding=utf8
username: root
password: 123456789
#eureka的配置:服务注册到哪里
eureka:
client:
service-url:
defaultZone: http://localhost:7001/eureka/
mybatis-config.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<settings>
<!--开启二级缓存-->
<setting name="cacheEnabled" value="true"/>
</settings>
<typeAliases>
<package name="com.liu.pojo"/>
</typeAliases>
</configuration>
mapper接口
@Mapper
@Repository
public interface DeptDao {
public boolean addDept(Dept dept);
public Dept queryById(Long id);
public List<Dept> queryAll();
}
mapper.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.liu.springcloud.dao.DeptDao">
<insert id="addDept" parameterType="Dept">
insert into db01.dept(dname, db_source)
values (#{dname},#{db_source});
</insert>
<select id="queryById" resultType="Dept" parameterType="Long">
select *
from db01.dept where deptno = #{deptno};
</select>
<select id="queryAll" resultType="Dept">
select *
from db01.dept;
</select>
</mapper>
service层
public interface DeptService {
public boolean addDept(Dept dept);
public Dept queryById(Long id);
public List<Dept> queryAll();
}
service实现类
@service
public class DeptServiceImpl implements DeptService{
@Autowired
public DeptDao deptDao;
@Override
public boolean addDept(Dept dept) {
return deptDao.addDept(dept);
}
@Override
public Dept queryById(Long id) {
return deptDao.queryById(id);
}
@Override
public List<Dept> queryAll() {
return deptDao.queryAll();
}
}
controller层
//提供restful服务
@RestController
public class DeptController {
@Autowired
private DeptService deptService;
@PostMapping("/dept/add")
public Boolean addDept(@RequsetBody Dept dept){
boolean b = deptService.addDept(dept);
return b;
}
@GetMapping("/dept/query/{id}")
public Dept queryById(@PathVariable("id")Long id){
Dept dept = deptService.queryById(id);
return dept;
}
@GetMapping("/dept/list")
public List<Dept> queryAll(){
List<Dept> deptList = deptService.queryAll();
return deptList;
}
}
启动类
package com.liu.springcloud;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
//启动类
@SpringBootApplication
@EnableEurekaClient //自动在服务启动后自动注册到eureka中
public class DeptProvider_8001 {
public static void main(String[] args) {
SpringApplication.run(DeptProvider_8001.class,args);
}
}
第三个微服务:springcloud-consumer-dept-80 消费者
导入依赖
<!--实体类+web-->
<dependencies>
<dependency>
<groupId>com.liu</groupId>
<artifactId>springcloud-01-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.yaml
server:
port: 80
手动注入RestTemplate,config目录下自建
@Configuration
public class ConfigBean {
@Bean
public RestTemplate getRestTemplate(){
return new RestTemplate();
}
}
controller
package com.liu.springcloud.controller;
import com.liu.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.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;
import java.util.List;
@RestController
public class DeptConsumerController {
//消费者不应该有service层
//RestTemplate:有许多方法之间调用
//(url,实体:map,Class<T> responseType)
@Autowired
private RestTemplate restTemplate; //提供多种便捷访问远程http服务的方法,简单restful服务模板
private static final String REST_URL_PREFIX = "http://localhost:8001";
@RequestMapping("/consumer/dept/query/{id}")
private Dept dept(@PathVariable("id") Long id) {
return restTemplate.getForObject(REST_URL_PREFIX + "dept/query/" + id, Dept.class);
}
@RequestMapping("/consumer/dept/add")
public Boolean add(Dept dept){
return restTemplate.postForObject(REST_URL_PREFIX+"/dept/add",dept,Boolean.class);
}
@RequestMapping("/consumer/dept/list")
public List<Dept> list(){
return restTemplate.getForObject(REST_URL_PREFIX+"/dept/list",List.class);
}
}
启动类
@SpringBootApplication
public class DeptConsumer_80 {
public static void main(String[] args) {
SpringApplication.run(DeptConsumer_80.class,args);
}
}
3、Eureka服务注册与发现
什么是Eureka?
- 遵循AP原则
- 是Netflix的一个子模块,是一个基于REST的服务,用于定位服务,以实现云端中间层服务发现和故障转移,服务注册与发现对于微服务来说非常重要,有了服务与注册,只需要使用服务的标识符就可以访问到服务,而不需要修改服务调用的配置文件了,功能类似于Dubbo的注册中心比如zookeeper。
原理讲解
- 基本架构
- springcloud封装了netflix公司开发的eureka模块来实现服务注册和发现
- 采用C-S的架构设计,EurekaServer作为服务注册功能的服务器,是服务注册中心
- 而系统中的其他微服务使用Eureka的客户端连接到EurekaServer并维持心跳连接,springCloud的其他模块(zuul)就可以通过EurekaServer来发现系统中的其他微服务并执行相关逻辑
- Eureka报红两个组件:EurekaServer 和EurekaClient
- EurekaClient是一个Java客户端,用于简化EurekaServer的交互,客户端同时也具备一个内置的,使用轮询负载算法的负载均衡器。在启动应用后,会向EurekaServer发送心跳,如果在多个心跳周期内没有接收到某个节点的心跳,EurekaServer会从服务器注册表中移除服务节点(默认周期90s)
- 三大角色
- Eureka Server:提供服务的注册与发现 zookeeper
- Server Provider:将自身服务注册到Eureka中从而使消费方能够找到
- Eureka Consumer:服务消费方从Eureka中获取注册服务列表,从而找到消费服务
导入依赖
<dependencies>
<!-- https://mvnrepository.com/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.yaml
server:
port: 7001
#eureka配置
eureka:
instance:
hostname: localhost #eureka服务端的实例名称
client:
register-with-eureka: false #表示是否向eureka注册中心注册自己
fetch-registry: false #如果为false则表示自己为注册中心
service-url: #监控页面
defaultZone: http://${eureka.instance.hostname}:${server.port}/eureka/
启动类
@SpringBootApplication
@EnableEurekaServer //服务端的启动类,可以接收别人注册进来
public class EurekaServer_7001 {
public static void main(String[] args) {
SpringApplication.run(EurekaServer_7001.class,args);
}
}
- 先启动7001,再启动8001,可以发现注册进入了
替换名字:
#eureka的配置:服务注册到哪里
eureka:
client:
service-url:
defaultZone: http://localhost:7001/eureka/
instance:
instance-id: springcloud-provider-dept8001 #修改eureka上的默认信息
配置里面的信息:
1.导包
<!-- https://mvnrepository.com/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>
2.配置(基本不在这儿配置)
#info配置
info:
app.name: liuxiang-springcloud
company.name: blog.liu.study
3.结果
查看application的信息:
1.写controller
@Autowired
private DiscoveryClient client;
//注册进来的微服务 获取一些信息
@GetMapping("/dept/discovery")
public Object discovery(){
//获得微服务的列表清单
List<String> services = client.getServices();
System.out.println("discovery=>service"+services);
//得到一个具体的微服务信息
List<ServiceInstance> instances = client.getInstances("SPRINGCLOUD-PROVIDER-DEPT");
for (ServiceInstance instance : instances) {
System.out.println(instance.getHost()+"\t"
+instance.getPort()
+"\t"+instance.getUri());
}
return this.client;
}
2.启动类添加注解
//启动类
@SpringBootApplication
@EnableEurekaClient //自动在服务启动后自动注册到eureka中
@EnableDiscoveryClient //服务发现
public class DeptProvider_8001 {
public static void main(String[] args) {
SpringApplication.run(DeptProvider_8001.class,args);
}
}
3.结果
4.后台显示
自我保护机制:
默认情况下,eurekaServer在一定事件内页面收到微服务的心跳,则会注销该实例(默认90s),当网络分区故障发生时,微服务与eureka之间无法正常通信,eureka通过自我保护机制解决,这种模式下,eureka会保护服务注册表的信息,不再删除注册表中的数据,网络恢复后,自动退出自我保护机制。
3.1 集群环境配置
互相绑定,一个服务崩了,可以去访问另外的服务
在本机C:\Windows\System32\drivers\etc下做域名映射!
7001配置
server:
port: 7001
#eureka配置
eureka:
instance:
hostname: eureka7001.com #eureka服务端的实例名称
client:
register-with-eureka: false #表示是否向eureka注册中心注册自己
fetch-registry: false #如果为false则表示自己为注册中心
service-url:
#单机下
#集群下:关联
defaultZone: http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
7002
server:
port: 7002
#eureka配置
eureka:
instance:
hostname: eureka7002.com #eureka服务端的实例名称
client:
register-with-eureka: false #表示是否向eureka注册中心注册自己
fetch-registry: false #如果为false则表示自己为注册中心
service-url: #监控页面
defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7003.com:7003/eureka/
7003
server:
port: 7003
#eureka配置
eureka:
instance:
hostname: eureka7003.com #eureka服务端的实例名称
client:
register-with-eureka: false #表示是否向eureka注册中心注册自己
fetch-registry: false #如果为false则表示自己为注册中心
service-url: #监控页面
defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/
提供者发布到集群上,配置
server:
port: 8001
mybatis:
type-aliases-package: com.liu.springcloud.pojo
config-location: classpath:mybatis/mybatis-config.xml
mapper-locations: classpath:mybatis/mapper/*.xml
spring:
application:
name: springcloud-provider-dept
datasource:
type: com.alibaba.druid.pool.DruidDataSource
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://localhost:3306/db01?serverTimezone=UTC&useSSL=false&useUnicode=true&characterEncoding=utf8
username: root
password: 123456789
#eureka的配置:服务注册到哪里
eureka:
client:
service-url:
defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
instance:
instance-id: springcloud-provider-dept8001 #修改eureka上的默认信息
#info配置
info:
app.name: liuxiang-springcloud
company.name: blog.liu.study
4、CAP原则及对比zookeeper
回顾CAP原则
RDBMS(mYSQL,Oracle,sqlServer) ==> ACID
NoSQL(redis,mongdb) ==> CAP
ACID:
- A:atomicity 原子性:成功都成功,失败都失败
- C:consistency 一致性:事务开始前和事务结束后,业务逻辑上的一致性不会被破坏
- I:isolation 隔离性:并发执行事务,一个未完成的事务不会影响另一个事务
- D:durability 持久性:数据一旦提交,持久保存
CAP:
- C:consistency 强一致性
- A:availability 可用性
- P:Patition tolerance 分区容错性
CAP理论的核心:
- 一个分布式系统不可逆同时满足一致性,可用性和分区容错性这三个需求
- 根据CAP原理,将noSQL数据库分成了满足CA原则,满足CP原则和满足AP原则三大类:
- CA:单点集群,满足一致性,可用性的系统,通常可扩展性较差
- CP:满足一致性,分区容错性,性能不是很高
- AP:满足可用性,分区容错性
作为服务注册中心,eureka和zookeeper的区别?
一个分布式系统不可能同时满足C一致性,A可用性,P容错性
- zookeeper满足:CP
- eureka满足:AP
zookeeper保证的是CP
牺牲了可用性,所以是CP原则!
当向注册中心查询服务列表时候,可用容忍注册中心返回的几分钟以前的注册信息,但不能接收服务直接down掉不可用。服务注册功能对可用性的要求高于一致性。但是zk会出现一种情况,当master节点因为网络问题与其他节点失去联系,剩余节点会重新进行leader选举。问题在于,选举leader的时间过长,30s-120s,且选举期间整个zk集群都是不可用的,这就导致在选举期间注册服务瘫痪。
Eureka保证的是AP
**eureka各个节点都是平等的。几个节点挂了不会影响正常节点的工作,剩余节点依然可用提供注册和查询功能。**自我保护机制:
1.eureka不再从注册表中移除因为长时间没收到心跳而应该过期的服务
2.仍然能够接收新服务的注册和查询请求,但是不会被同步到其他节点上
3.当网络稳定时,当前实例新的的注册信息会被同步到其他节点中
5、负载均衡和Ribbon
ribbon是什么?
- spring cloud ribbon 是基于Netflix Ribbon实现的一套客户端负载均衡的工具
- 主要功能是提供客户端的软件负载均衡算法,将netflix的中间层服务连接在一起。ribbon的客户端软件组件提供一系列完整的配置项:连接超时,重试等。就是在配置文件中列出loadBalancer(简称LB:负载均衡)后面所有的机器,ribbon会自动的帮助你基于某种规则(如简单轮询,随机)去连接这些机器。
ribbon能干嘛?
-
负载均衡:将用户的请求平摊的分配到多个服务上,从而达到系统的HA(高可用)
-
常用的负载均衡软件:Nginx,Lvs等
-
dubbo,springCloud中均提供负载均衡,springCloud的负载均衡算法可用自定义
-
负载均衡简单分类:
- 集中式LB
- 服务的消费方和提供方之间使用独立的LB设施,如Nginx,由该设施把访问请求转发给服务的提供方
- 进程式LB
- 将LB逻辑集成到消费方,消费方从服务注册中心获知有哪些地址可用,如何增加再从这些地址中选出一个合适的服务器
- ribbon就属于进程内LB,它是一个类库,集成于消费方进程,消费方通过它来获取到服务提供方的地址。
- 集中式LB
消费方集成ribbon
导入依赖
<!-- https://mvnrepository.com/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>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-eureka</artifactId>
<version>1.4.6.RELEASE</version>
</dependency>
配置:
server:
port: 80
#eureka配置
eureka:
client:
register-with-eureka: false
service-url:
defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
启动类加注解使其生效
@SpringBootApplication
@EnableEurekaClient
public class DeptConsumer_80 {
public static void main(String[] args) {
SpringApplication.run(DeptConsumer_80.class,args);
}
}
自定义restTemplate的配置,使其变成负载均衡的
@Configuration
public class ConfigBean {
//配置负载均衡实现restTemplate
@Bean
@LoadBalanced
public RestTemplate getRestTemplate(){
return new RestTemplate();
}
}
在客户端消费者的controller
//通过ribbon的时候,这里的地址应该是一个变量,通过服务id去访问
// private static final String REST_URL_PREFIX = "http://localhost:8001";
private static final String REST_URL_PREFIX = "http://SPRINGCLOUD-PROVIDER-DEPT";
5.2、自定义负载均衡算法
在springcloud同级目录下建包
@Configuration
public class LiuRule {
//配置负载均衡实现restTemplate
//IRule
//AvailabilityFilteringRule:会先过滤跳闸,崩溃的服务,对剩下的服务进行轮询
//RoundRobinRule 轮询
//RandomRule 随机
//RetryRule重试
@Bean
public IRule myRule(){
return new RandomRule();
}
}
启动类下:在微服务启动时候就加载自定义类
@SpringBootApplication
@EnableEurekaClient
@RibbonClient(name = "SPRINGCLOUD-PROVIDER-DEPT",configuration = LiuRule.class)
public class DeptConsumer_80 {
public static void main(String[] args) {
SpringApplication.run(DeptConsumer_80.class,args);
}
}
6、Feign负载均衡
6.1 简介
feign是声明式的web service客户端,它让微服务之间的调用变得更简单了,蕾仕于controller调用service,springCloud集成了Ribbon和Eureka,可在使用Feign时提供负载均衡的http客户端
只需要创建一个接口,如何添加注解即可!
访问微服务的两种方法:
- 微服务名字(ribbon)
- 接口和注解(feign)
使用ribbon+restTemplate,利用restTemplate对http请求的封装处理,形成了一套模板化的调用方法。但在实际开发中,由于对服务依赖的调用不止一处,往往一个接口会被多出调用,所以通常都会针对每个欸服务自行封装一些客户端类来包装这些依赖服务的调用。
在Feign的实现下,我们只需要创建一个接口并使用注解的方式来配置它(类似于Dao接口上标注Mapper注解,现在是一个微服务接口上面标注一个Feign注解即可)
导入依赖
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-feign</artifactId>
<version>1.4.6.RELEASE</version>
</dependency>
api层写service接口供其他服务访问
@Component
@FeignClient(value = "SPRINGCLOUD-PROVIDER-DEPT")
public interface DeptClientService {
@GetMapping("/dept/query/{id}")
public Dept queryById(@PathVariable("id")Long id);
@GetMapping("/dept/list")
public List<Dept> queryAll();
@PostMapping("/dept/add")
public boolean addDept(Dept dept);
}
消费者Controller层:通过注解实现
package com.liu.springcloud.controller;
import com.liu.springcloud.pojo.Dept;
import com.liu.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 javax.annotation.Resource;
import java.util.List;
@RestController
public class DeptConsumerController {
@@Resource
private DeptClientService service = null;
@RequestMapping("/consumer/dept/query/{id}")
private Dept dept(@PathVariable("id") Long id) {
return this.service.queryById(id);
}
@RequestMapping("/consumer/dept/add")
public Boolean add(Dept dept){
return this.service.addDept(dept);
}
@RequestMapping("/consumer/dept/list")
public List<Dept> list(){
return this.service.queryAll();
}
}
实现类:加上注解
@SpringBootApplication
@EnableEurekaClient
@EnableFeignClients(basePackages = {"com.liu.springcloud"})
public class FeignDeptConsumer {
public static void main(String[] args) {
SpringApplication.run(FeignDeptConsumer.class,args);
}
}
结果:本质还是通过eureka,通过注解,让代码的可读性变强!
7、服务熔断Hystrix(服务端)
官方文档翻译网址:Hystrix 使用手册 | 官方文档翻译 - 闪客sun - 博客园 (cnblogs.com)
完成情况好的请求流如下:
当一个依赖的节点坏掉时,将阻塞整个的用户请求:
流量高峰时,一个单节点的宕机或延迟,会迅速导致所有服务负载达到饱和。应用中任何一个可能通过网络访问其他服务的节点,都有可能成为造成潜在故障的来源。更严重的是,还可能导致服务之间的延迟增加,占用队列、线程等系统资源,从而导致多系统之间的级联故障。
所有上述表现出来的故障或延迟,都需要一套管理机制,将节点变得相对独立,这样任何一个单节点故障,都至少不会拖垮整个系统的可用性。
服务雪崩:
多个微服务之间调用的时候,假设微服务A调用B和C,B和C又调用其他的微服务,这就是所谓的"扇出",如果扇出的链路上某个微服务的调用响应时间过长或者不可用,对微服务A的调用就会占用越来越多的系统资源,进而引起系统崩溃就是所谓的"雪崩效应"。
7.1、什么是Hystrix
在分布式环境中,不可避免地会遇到所依赖的服务挂掉的情况,Hystrix 可以通过增加 延迟容忍度 与 错误容忍度,来控制这些分布式系统的交互。Hystrix 在服务与服务之间建立了一个中间层,防止服务之间出现故障,并提供了失败时的备选响应( fallback) 策略,来增加系统的整体可靠性和弹性,而不是长时间的等待或者抛出调用方法无法处理的异常,这样就保证了服务调用方的线程不会长时间占用。
用处:
- 服务降级
- 服务熔断
- 服务限流
- 接近实时的监控
7.2 服务熔断
- 熔断机制是对应雪崩效应的一种微服务链路保护机制
- 熔断机制的注解:@HystrixCommand
当扇出链路的某个微服务不可用或者响应时间太长,会进行服务的降级,进而熔断该节点微服务的调用,快速返回错误的响应信息。当检测该节点微服务调用响应正常后回复调用链路。
7.3 工程
导入依赖
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-hystrix</artifactId>
<version>1.4.6.RELEASE</version>
</dependency>
服务提供方controller层
//提供restful服务
@RestController
public class DeptController {
@Autowired
private DeptService deptService;
@GetMapping("/dept/query/{id}")
@HystrixCommand(fallbackMethod = "hystrixGet")
public Dept queryById(@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+" 不存在该用户,信息无法找到!@Hystrix")
.setDb_source("no this database in MySQL");
}
}
启动类:添加对熔断的支持
@SpringBootApplication
@EnableEurekaClient //自动在服务启动后自动注册到eureka中
@EnableDiscoveryClient //服务发现
@EnableHystrix //包含了@EnableCircuitBreaker
public class DeptProviderHystrix_8001 {
public static void main(String[] args) {
SpringApplication.run(DeptProviderHystrix_8001.class,args);
}
}
提供者配置:可用显示ip prefer-ip-address: true
#eureka的配置:服务注册到哪里
eureka:
client:
service-url:
defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
instance:
instance-id: springcloud-provider-dept8001 #修改eureka上的默认信息
prefer-ip-address: true
7、服务降级Hystrix(客户端)
api的service层
@Component
@FeignClient(value = "SPRINGCLOUD-PROVIDER-DEPT",fallbackFactory = DeptClientServiceFallbackFactory.class)
public interface DeptClientService {
@GetMapping("/dept/query/{id}")
public Dept queryById(@PathVariable("id")Long id);
@GetMapping("/dept/list")
public List<Dept> queryAll();
@PostMapping("/dept/add")
public boolean addDept(Dept dept);
}
api的service层的fallback工厂服务降级
package com.liu.springcloud.service;
import com.liu.springcloud.pojo.Dept;
import feign.hystrix.FallbackFactory;
import org.springframework.stereotype.Component;
import java.util.List;
//降级
@Component
public class DeptClientServiceFallbackFactory implements FallbackFactory {
@Override
public DeptClientService create(Throwable throwable) {
return new DeptClientService() {
@Override
public Dept queryById(Long id) {
return new Dept().setDeptno(id)
.setDname("id=>"+id+"没有对应的信息,客户端提供了降级的信息,整个服务现在已经关闭")
.setDb_source("no source");
}
@Override
public List<Dept> queryAll() {
return null;
}
@Override
public boolean addDept(Dept dept) {
return false;
}
};
}
}
客户端的配置:开启降级
server:
port: 80
#eureka配置
eureka:
client:
register-with-eureka: false
service-url:
defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
#开启降级
feign:
hystrix:
enabled: true
关闭服务提供者8001,结果:
熔断与降级的区别:
服务熔断:代码写在提供方,相当于处理、返回异常
- 某个服务超时或者异常,引起熔断
服务降级:代码写在消费方,提供方关闭服务后,提示、返回异常信息
- 从整体网站请求负载考虑,某个服务熔断或者关闭,服务不再被调用
- 在客户端准备一个fallbackFactory,返回一个默认值,整体的服务水平下降
8、Hystrix:Dashboard流监控(客户消费端)
建立工程:springcloud-consumer-hystrix-dashboard
导入依赖
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-hystrix</artifactId>
<version>1.4.6.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-hystrix-dashboard</artifactId>
<version>1.4.6.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-hystrix</artifactId>
<version>1.4.6.RELEASE</version>
</dependency>
配置application.yaml
server:
port: 9001
hystrix:
dashboard:
proxy-stream-allow-list: localhost
启动类
package com.liu.springcloud;
import com.netflix.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.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.cloud.netflix.hystrix.EnableHystrix;
import org.springframework.context.annotation.Bean;
//启动类
@SpringBootApplication
@EnableEurekaClient //自动在服务启动后自动注册到eureka中
@EnableDiscoveryClient //服务发现
@EnableHystrix
public class DeptProviderHystrix_8001 {
public static void main(String[] args) {
SpringApplication.run(DeptProviderHystrix_8001.class,args);
}
//增加一个dashboard的bean
@Bean
public ServletRegistrationBean hystrixMetricsStreamServlet(){
ServletRegistrationBean registrationBean = new ServletRegistrationBean(new HystrixMetricsStreamServlet());
registrationBean.addUrlMappings("/actuator/hystrix.stream");
return registrationBean;
}
}
要保证服务提供方有监控信息的依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
结果:localhost:9001/hystrix
先发起一起query请求,访问localhost:8001/actuator/hystrix.stream,会有data数据产生
再到Hystrix Monitor,进行监控!
一直loading解决方法:
- 将cloud的版本降到SR2
- 在dashboard的配置文件中配置:
hystrix:
dashboard:
proxy-stream-allow-list: localhost
9、路由网关zuul
什么是zuul?
- zuul包含了对请求的路由和过滤两个最主要的功能:其中路由转发功能负责将请i去转发到微服务实例上,过滤器功能负责对请求的处理过程进行干预,实现请求校验,服务聚合等功能。
- zuul服务最终还是要注册进eureka
- 提供**:代理+路由+过滤三大功能**
官方文档:Spring Cloud Netflix 中文文档 参考手册 中文版
导入配置:
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-zuul</artifactId>
<version>1.4.6.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-hystrix</artifactId>
<version>1.4.6.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-hystrix-dashboard</artifactId>
<version>1.4.6.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/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>
<!-- https://mvnrepository.com/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.liu</groupId>
<artifactId>springcloud-01-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>
配置:实现路由加过滤
server:
port: 9527
spring:
application:
name: springcloud-zuul
eureka:
client:
service-url:
defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
instance:
instance-id: zuul9527.com
prefer-ip-address: true
info:
app.name: liu-springcloud
company.name: blog.liu.com
zuul:
routes:
mydept.serviceId: springcloud-provider-dept
mydept.path: /mydept/**
ignored-services: springcloud-provider-dept #不能再使用这个路径访问了
启动类:@EnableZuulProxy
@SpringBootApplication
@EnableZuulProxy
public class zuulApplication_9527 {
public static void main(String[] args) {
SpringApplication.run(zuulApplication_9527.class,args);
}
}
访问此网址可用得到结果:localhost:9527/mydept/dept/query/1
配置后,实现过滤操作,访问localhost:9527/springcloud-provider-dept/dept/query/1,结果不存在
10、springcloud Config分布式配置
分布式系统面临的配置文件的问题
微服务意味着要将单体应用中的业务拆分成一个个子服务,每个服务的力度较小,因此系统中会出现大量的服务,由于每个服务都需要必要的配置信息才能运行,所以一套集中式的,动态的配置管理设施。
springcloud提供configServer解决这个问题!
什么是springcloud config分布式配置中心
为微服务架构中的微服务提供集中化的外部配置支持,配置服务器为各个不同微服务应用的所有环节提供一个中心化的外部配置
springcloud config分为服务端和客户端两部分:
服务端:分布式配置中心,是一个独立的微服务应用,用来连接配置服务器并未客户端提供获取配置信息,加密,解密信息等访问接口
客户端:则是通过指定的配置中心来管理应用资源,以及与业务相关的配置内容,并启动的时候从配置中心获取和加载信息,配置服务器默认采用git来存储配置信息,这样有助于对环境配置进行版本管理。
Git的使用
1.从gitee上拷贝地址
2.生成公钥
会在本机C:\Users\liuxiang.ssh处生成两个文件:.pub是公钥
放入gitee上面的公钥处即可!
3.在本地建立一个文件夹存放代码,打开Git客户端右键 Git Bash here,输入命令
git clone + 复制的地址
:shift+ins复制键
成功!!! 克隆到本地
4.新建一个配置文件 application.yaml
5.四步上传至远程仓库
# 添加文件
git add .
# 查看状态
git status
# 提交到本地仓库 提交和消息
git commit -m "first commit"
#push到远程仓库
git push origin master
10.1 config项目(服务端)
- 通过config-sever访问git上的资源
导入依赖
<dependencies>
<!-- https://mvnrepository.com/artifact/org.springframework.cloud/spring-cloud-config-server -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-config-server</artifactId>
<version>2.2.0.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
配置
server:
port: 3344
spring:
application:
name: springcloud-config-server
#连接远程仓库
cloud:
config:
server:
git:
uri: https://gitee.com/lxxdyy12138/springcloud-config.git
启动类:
@SpringBootApplication
@EnableConfigServer
public class Config_Server_3344 {
public static void main(String[] args) {
SpringApplication.run(Config_Server_3344.class,args);
}
}
访问:localhost:3344/application-dev.yaml
10.2、工程项目(客户端)
建立一个config-client文件,将其push到远程仓库上!
导入依赖:
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-config</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
配置:bootstrap.yaml
#系统级别的配置
spring:
cloud:
config:
uri: http://localhost:3344
name: config-client #需要从git上读取的资源名称,不需要后缀
profile: dev
label: master
application.yaml
#用户级别的配置
spring:
application:
name: springcloud-config-client-3355
启动类
@SpringBootApplication
public class ConfigClient_3355 {
public static void main(String[] args) {
SpringApplication.run(ConfigClient_3355.class,args);
}
}
测试类controller
@RestController
public class ConfigController {
@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;
}
}
结果访问:
10.3 远程配置实战(客户端)
建立远程仓库配置文件:
spring:
profiles:
active: dev
---
server:
port: 7001
spring:
profiles: dev
application:
name: springcloud-config-eureka
#eureka配置
eureka:
instance:
hostname: eureka7001.com #eureka服务端的实例名称
client:
register-with-eureka: false #表示是否向eureka注册中心注册自己
fetch-registry: true #如果为false则表示自己为注册中心
service-url:
#单机下
#集群下:关联
defaultZone: http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
---
server:
port: 7001
spring:
profiles: test
application:
name: springcloud-config-eureka
#eureka配置
eureka:
instance:
hostname: eureka7001.com #eureka服务端的实例名称
client:
register-with-eureka: false #表示是否向eureka注册中心注册自己
fetch-registry: true #如果为false则表示自己为注册中心
service-url:
#单机下
#集群下:关联
defaultZone: http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
spring:
profiles:
active: dev
---
server:
port: 8001
mybatis:
type-aliases-package: com.liu.springcloud.pojo
config-location: classpath:mybatis/mybatis-config.xml
mapper-locations: classpath:mybatis/mapper/*.xml
spring:
profiles: dev
application:
name: springcloud-config-dept
datasource:
type: com.alibaba.druid.pool.DruidDataSource
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://localhost:3306/db01?serverTimezone=UTC&useSSL=false&useUnicode=true&characterEncoding=utf8
username: root
password: 123456789
#eureka的配置:服务注册到哪里
eureka:
client:
service-url:
defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
instance:
instance-id: springcloud-config-dept8001 #修改eureka上的默认信息
prefer-ip-address: true
#info配置
info:
app.name: liuxiang-springcloud
company.name: blog.liu.study
---
server:
port: 8002
mybatis:
type-aliases-package: com.liu.springcloud.pojo
config-location: classpath:mybatis/mybatis-config.xml
mapper-locations: classpath:mybatis/mapper/*.xml
spring:
profiles: test
application:
name: springcloud-config-dept
datasource:
type: com.alibaba.druid.pool.DruidDataSource
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://localhost:3306/db01?serverTimezone=UTC&useSSL=false&useUnicode=true&characterEncoding=utf8
username: root
password: 123456789
#eureka的配置:服务注册到哪里
eureka:
client:
service-url:
defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
instance:
instance-id: springcloud-config-dept8001 #修改eureka上的默认信息
prefer-ip-address: true
#info配置
info:
app.name: liuxiang-springcloud
company.name: blog.liu.study
push到远程仓库
导包
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-config</artifactId>
</dependency>
<!-- https://mvnrepository.com/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>
配置:
bootstrap.yaml
spring:
cloud:
config:
name: config-eureka #这里的名字是远程仓库项目的名字
label: master
profile: dev
uri: http://localhost:3344 #服务器访问远程仓库的地址
application.yaml
spring:
application:
name: springcloud-config-eureka_7001
server:
port: 8002
mybatis:
type-aliases-package: com.liu.springcloud.pojo
config-location: classpath:mybatis/mybatis-config.xml
mapper-locations: classpath:mybatis/mapper/*.xml
spring:
profiles: test
application:
name: springcloud-config-dept
datasource:
type: com.alibaba.druid.pool.DruidDataSource
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://localhost:3306/db01?serverTimezone=UTC&useSSL=false&useUnicode=true&characterEncoding=utf8
username: root
password: 123456789
#eureka的配置:服务注册到哪里
eureka:
client:
service-url:
defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/,http://eureka7003.com:7003/eureka/
instance:
instance-id: springcloud-config-dept8001 #修改eureka上的默认信息
prefer-ip-address: true
#info配置
info:
app.name: liuxiang-springcloud
company.name: blog.liu.study
push到远程仓库
[外链图片转存中...(img-rczTYae2-1658915772501)]
导包
```xml
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-config</artifactId>
</dependency>
<!-- https://mvnrepository.com/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>
配置:
bootstrap.yaml
spring:
cloud:
config:
name: config-eureka #这里的名字是远程仓库项目的名字
label: master
profile: dev
uri: http://localhost:3344 #服务器访问远程仓库的地址
application.yaml
spring:
application:
name: springcloud-config-eureka_7001