微服务之路（五）spring cloud config server

其他 2020-05-24 22:11:29 阅读次数: 0

前言

接着上一章spring cloud config client ,本章主要讲解spring cloud config server。并分别增加spring cloud config client与spring cloud config server的配置讲解。

主要议题

  • 介绍Environment仓储
  • Spring Cloud分布式配置
  • 动态配置属性Bean
  • 健康指标

主体内容

一、介绍Environment仓储

1.概念（-{}指的是占位符）

-{application}：配置使用客户端应用名称

-{profile}：客户端spring.profile.active

-{label}：服务端配置文件版本标识

二、Spring Cloud分布式配置

1.Git实现

-服务端配置

  • spring.cloud.config.server.git.uri
  • spring.cloud.config.server.git.*

-客户端配置

  • spring.cloud.config.uri
  • spring.cloud.config.name
  • spring.cloud.config.profile
  • spring.cloud.config.label

2.从http://start.spring.io构建如图的项目，然后导入项目。

3.构建SpringCloud配置服务器（Git实现）

步骤

（1）在Configuration Class标记@EnableConfigServer,以下为示例：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.config.server.EnableConfigServer;

@SpringBootApplication
@EnableConfigServer//激活开启config 的server功能
public class SpringcloudConfigServerApplication {

	public static void main(String[] args) {
		SpringApplication.run(SpringcloudConfigServerApplication.class, args);
	}
}

(2)配置文件目录（基于git）,这里建立5个文件

  • gupao.properties(默认环境，跟着代码仓库)
  • gupao-dev.properties(prefix="dev")//开发环境
  • gupao-test.properties（profile="test"）//测试环境
  • gupao-staging.properties（profile="staging"）//预发布环境
  • gupao-prod.properties(profile="prod")//生产环境

步骤

a.打开Git Bash(没有git自行安装)，先进入到要添加文件的目录，这里示例。

66477@MSI MINGW64 /e
$ cd e:/Workplaces/GitWorkplace/spring-cloud/config

b.利用vi编辑器创建一个文件先，然后直接复制重命名即可。

66477@MSI MINGW64 /e/Workplaces/GitWorkplace/spring-cloud/config
$ vi gupao.properties

按下i添加文件内容，esc，输入“:wq”保存并退出。

my.name=gupao

c.复制其余4个文件。

66477@MSI MINGW64 /e/Workplaces/GitWorkplace/spring-cloud/config
$ cp  gupao.properties gupao-dev.properties

66477@MSI MINGW64 /e/Workplaces/GitWorkplace/spring-cloud/config
$ cp  gupao.properties gupao-test.properties

66477@MSI MINGW64 /e/Workplaces/GitWorkplace/spring-cloud/config
$ cp  gupao.properties gupao-staging.properties

66477@MSI MINGW64 /e/Workplaces/GitWorkplace/spring-cloud/config
$ cp  gupao.properties gupao-prod.properties

66477@MSI MINGW64 /e/Workplaces/GitWorkplace/spring-cloud/config
$ ls
gupao.properties      gupao-prod.properties     gupao-test.properties
gupao-dev.properties  gupao-staging.properties

d.初始化一个.git。

66477@MSI MINGW64 /e/Workplaces/GitWorkplace/spring-cloud/config
$ git init
Initialized empty Git repository in E:/Workplaces/GitWorkplace/spring-cloud/config/.git/

e.将文件加入到git中。

66477@MSI MINGW64 /e/Workplaces/GitWorkplace/spring-cloud/config (master)
$ git add gupao*.properties
warning: LF will be replaced by CRLF in gupao-dev.properties.
The file will have its original line endings in your working directory
warning: LF will be replaced by CRLF in gupao-prod.properties.
The file will have its original line endings in your working directory
warning: LF will be replaced by CRLF in gupao-staging.properties.
The file will have its original line endings in your working directory
warning: LF will be replaced by CRLF in gupao-test.properties.
The file will have its original line endings in your working directory
warning: LF will be replaced by CRLF in gupao.properties.
The file will have its original line endings in your working directory

f.然后commit。

66477@MSI MINGW64 /e/Workplaces/GitWorkplace/spring-cloud/config (master)
$ git commit -m "Initial commit"
[master (root-commit) f8fc8f8] Initial commit
 5 files changed, 5 insertions(+)
 create mode 100644 gupao-dev.properties
 create mode 100644 gupao-prod.properties
 create mode 100644 gupao-staging.properties
 create mode 100644 gupao-test.properties
 create mode 100644 gupao.properties

（3）服务端配置版本仓库（本地）(windows是///,这里为示例，以具体路径为准)

把这个配置放到application.properties中去：

spring.cloud.config.server.git.uri=file:///E:/Workplaces/GitWorkplace/spring-cloud/config

完整的application.properties文件如下：

#定义服务名
spring.application.name=config-server
#定义HTTP服务端口
server.port=9090
#本地仓库的GIT URI的配置
spring.cloud.config.server.git.uri=file:///E:/Workplaces/GitWorkplace/spring-cloud/config

#以下配置是基于springboot1.5.x配置的，用于开放一些诸如env之类的端点Endpoints
#全局关闭Actuator安全
#mangement.sercurity.enabled=false
#细粒度的开放Actuator EndPoints,注意:SpringBoot2.0版本后安全配置将不再是可定制
#sensitive关注的是敏感性，安全
#endpoints.env.sensitive=false

#springboot2.0以上可以暂时采用以下配置
management.endpoints.enabled-by-default=true
management.endpoints.web.exposure.include=*

然后启动springboot项目，浏览器访问任意文件，我这里示例：http://localhost:9090/gupao-dev.properties，结果如下：

当然，不用git也是可以的。

（4）接着，我们关闭springboot的安全检测。（暂时用这种办法，这种是springboot2.0以上版本采用），首先创建一个config包，config包下创建SecurityConfig类。

前提加上依赖：

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

import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.WebSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
     
        @Override
        public void configure(WebSecurity web) throws Exception {
            web.ignoring().antMatchers("/**");
        }
}

启动项目，访问http://localhost:9090/actuator/env,浏览器按下F12,观察env返回值，如图则正确。

4.构建构建SpringCloud配置客户端

步骤

（1）从http://start.spring.io构建如图的项目，然后导入项目。

（2）配置application.properties。

#配置客户端配置项
spring.application.name=config-client

（3）配置bootstrap.properties。

#bootstrap上下文配置
#配置服务器URI
spring.cloud.config.uri=http://localhost:9090/
#配置客户端应用名称：{application}
spring.cloud.config.name=gupao
#profile 是激活的配置
spring.cloud.config.profile=prod
#label在Git中指的是分支名称
spring.cloud.config.label=master
#打开所有端点（springboot2.0采用）
management.endpoints.enabled-by-default=true
management.endpoints.web.exposure.include=*

（4）同样的，他也需要关闭springboot安全检测，（springboot2.0暂时采用该方法），继承WebSecurityConfigurerAdapter类，重写它的configure方法。

import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.WebSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
     
        @Override
        public void configure(WebSecurity web) throws Exception {
            web.ignoring().antMatchers("/**");
        }
}

别忘了依赖：

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

（5）首先启动服务端项目，然后启动客户端项目。服务端访问http://localhost:9090/gupao-prod.properties。结果如下：

（6）接着访问客户端：http://localhost:8080/actuator/env,浏览器按下F12,观察env返回值,看到红框中值为下图所示：

可见，gupao-prod.properties的value这里=gupao。（解释一下为什么会出现gupao.properties,因为这是默认机制，保底使用）

（7）当我再次用Git Bash编辑gupao-prod.properties文件，修改文件内容为：

my.name=gupao-prod

此时再次访问服务端http://localhost:9090/gupao-prod.properties，发现结果确实随之改变了。（记住两个项目不要重启）

然后重点来了，刷新http://localhost:8080/actuator/env。观察红框中内容居然没有变：

其实还有这么个东西，叫/refresh,我们用postman，访问一下http://localhost:8080/actuator/refresh（注意是POST请求！）

然后再去刷新客户端http://localhost:8080/actuator/env，发现红框值被更新了：

其实在实际环境中，这玩意用的并不是很多，了解即可。这种刷新好像是比较麻烦的，下面我们讲一个动态配置属性Bean。

三、动态配置属性Bean

  • @RefreshScope
  • RefreshEndpoint
  • ContextRefresher

1.用上面的服务端和客户端，我们先在客户端项目下创建controller包，接着创建一个EchoController.java。

import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @ClassName
 * @Describe TODO
 * @Author 66477
 * @Date 2020/5/2121:10
 * @Version 1.0
 */
@RestController
public class EchoController {

    @Value("${my.name}")//spring的写法，my.name就是properties定义的属性名称
    private String myName;

    @GetMapping("/my-name")
    public String getName(){
        return myName;
    }
}

启动postman，访问/my-name。（注意：这里用的是get请求）

接下来，我们用Git Bash修改下gupao-prod.properties内容为

my.name=gupao-prod-update

接下来我们向上面那样访问/refresh接口。

然后再去访问http://localhost:8080/my-name接口。看看值有没有随着改变。结果是没有改变：

看来光借助/refresh也不行了，那么咋办呢？只需要在EchoController上加上@RefreshScope注解即可,这个@RefreshScope注解意思为此类Scope为refresh类型的，就是允许此类中内容刷新的意思。然后再访问/refresh。

@RefreshScope
@RestController
public class EchoController {
...

改动了必然要重启项目，这样，我们再把my.name值改一下。我这里改成

my.name=gupao-prod-xusp

然后访问/refresh，最后在访问/my-name接口，结果如下，说明刷新过来了：

2.上面提到了一个东西叫做ContextRefresher，上下文刷新器。在我们这样，在客户端的启动类搞一个定时器，启动3秒后开始执行，之后每5秒执行一次，内容就是每次让上下文刷新器刷新一次。那么就可以这么写。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.context.refresh.ContextRefresher;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import java.util.Set;

@SpringBootApplication
@EnableScheduling
public class SpringcloudConfigClientApplication {

	private final ContextRefresher contextRefresher;

	public SpringcloudConfigClientApplication(ContextRefresher contextRefresher){
		this.contextRefresher=contextRefresher;
	}
	public static void main(String[] args) {
		SpringApplication.run(SpringcloudConfigClientApplication.class, args);
	}
	/**
	 * 更新配置
	 * @Scheduled注解可以控制方法定时执行，其中有三个参数可选择：
	 * (1)fixedDelay控制方法执行的间隔时间，是以上一次方法执行完开始算起，如上一次方法执行阻塞住了，那么直到上一次执行完，并间隔给定的时间后，执行下一次。
	 * (2)fixedRate是按照一定的速率执行，是从上一次方法执行开始的时间算起，如果上一次方法阻塞住了，下一次也是不会执行，但是在阻塞这段时间内累计应该执行的次数，当不再阻塞时，一下子把这些全部执行掉，而后再按照固定速率继续执行。
	 * (3) cron表达式可以定制化执行任务，但是执行的方式是与fixedDelay相近的，也是会按照上一次方法结束时间开始算起。
	 * (4)initialDelay 。如： @Scheduled(initialDelay = 10000,fixedRate = 15000
	 * 这个定时器就是在上一个的基础上加了一个initialDelay = 10000 意思就是在容器启动后,延迟10秒后再执行一次定时器,以后每15秒再执行一次该定时器。
	 * @initialDelay:延迟3秒
	 * @fixedRate：每5秒刷新一次
	 */
	@Scheduled(fixedRate=5 * 1000,initialDelay = 3 * 1000)
	public void autoRefresh(){
		//contextRefresher上下文刷新器
		System.out.printf("定时器执行...");
		Set<String> updatedPropertyNames = contextRefresher.refresh();
		if(updatedPropertyNames!=null)
			System.out.printf("[Thread :%s]  当前配置已更新，具体项目：%s \n",
					Thread.currentThread().getName(),
					updatedPropertyNames);
	}
}

然后启动服务端，客户端。

在更改之前我们访问一下客户端/my-name接口，结果是：gupao-prod-xusp

现在我们通过Git Bash把它改成my.name=gupao-prod-contextRefresher。看结果，刷新过来了。

当我们想要读取property具体更新配置的时候，就可以改写一下代码。利用Environment来获取配置信息。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.context.refresh.ContextRefresher;
import org.springframework.core.env.Environment;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import java.util.Set;

@SpringBootApplication
@EnableScheduling
public class SpringcloudConfigClientApplication {

	private final ContextRefresher contextRefresher;
	private final Environment environment;
	@Autowired
	public SpringcloudConfigClientApplication(ContextRefresher contextRefresher, Environment environment){
		this.contextRefresher=contextRefresher;
		this.environment = environment;
	}
	public static void main(String[] args) {
		SpringApplication.run(SpringcloudConfigClientApplication.class, args);
	}
	/**
	 * 更新配置
	 * @Scheduled注解可以控制方法定时执行，其中有三个参数可选择：
	 * (1)fixedDelay控制方法执行的间隔时间，是以上一次方法执行完开始算起，如上一次方法执行阻塞住了，那么直到上一次执行完，并间隔给定的时间后，执行下一次。
	 * (2)fixedRate是按照一定的速率执行，是从上一次方法执行开始的时间算起，如果上一次方法阻塞住了，下一次也是不会执行，但是在阻塞这段时间内累计应该执行的次数，当不再阻塞时，一下子把这些全部执行掉，而后再按照固定速率继续执行。
	 * (3) cron表达式可以定制化执行任务，但是执行的方式是与fixedDelay相近的，也是会按照上一次方法结束时间开始算起。
	 * (4)initialDelay 。如： @Scheduled(initialDelay = 10000,fixedRate = 15000
	 * 这个定时器就是在上一个的基础上加了一个initialDelay = 10000 意思就是在容器启动后,延迟10秒后再执行一次定时器,以后每15秒再执行一次该定时器。
	 * @initialDelay:延迟3秒
	 * @fixedRate：每5秒刷新一次
	 */
	@Scheduled(fixedRate=5 * 1000,initialDelay = 3 * 1000)
	public void autoRefresh(){
		System.out.printf("定时器执行...");
		//contextRefresher上下文刷新器
		Set<String> updatedPropertyNames = contextRefresher.refresh();
		updatedPropertyNames.forEach(propertyName -> System.out.printf("[Thread :%s]  当前配置已更新，" +
				"具体Keys: %s ,Value: %s \n",
				Thread.currentThread().getName(),
				propertyName,
				environment.getProperty(propertyName)));
		/*if(updatedPropertyNames!=null)
			System.out.printf("[Thread :%s]  当前配置已更新，具体项目：%s \n",
					Thread.currentThread().getName(),
					updatedPropertyNames);*/
	}
}

此时我去改变gupao-prod.propeties文件为my.name=gupao-prod-2020,控制台结果就会输出：

[Thread :scheduling-1]  当前配置已更新，具体Keys: my.name ,Value: gupao-prod-2020

四、健康指标

  • /health
  • HealthEndpoint
  • HealthIndicator

HealthEndpoint端点

Spring Boot激活actuator需要增加Hateoas的依赖：

	<dependency>
			<groupId>org.springframework.hateoas</groupId>
			<artifactId>spring-hateoas</artifactId>
	</dependency>

以客户端为例：

_links: {self: {href: "http://localhost:8080/actuator", templated: false},…}
self: {href: "http://localhost:8080/actuator", templated: false}
auditevents: {href: "http://localhost:8080/actuator/auditevents", templated: false}
beans: {href: "http://localhost:8080/actuator/beans", templated: false}
caches-cache: {href: "http://localhost:8080/actuator/caches/{cache}", templated: true}
caches: {href: "http://localhost:8080/actuator/caches", templated: false}
health-component-instance: {href: "http://localhost:8080/actuator/health/{component}/{instance}", templated: true}
health-component: {href: "http://localhost:8080/actuator/health/{component}", templated: true}
health: {href: "http://localhost:8080/actuator/health", templated: false}
conditions: {href: "http://localhost:8080/actuator/conditions", templated: false}
shutdown: {href: "http://localhost:8080/actuator/shutdown", templated: false}
configprops: {href: "http://localhost:8080/actuator/configprops", templated: false}
env: {href: "http://localhost:8080/actuator/env", templated: false}
env-toMatch: {href: "http://localhost:8080/actuator/env/{toMatch}", templated: true}
info: {href: "http://localhost:8080/actuator/info", templated: false}
loggers: {href: "http://localhost:8080/actuator/loggers", templated: false}
loggers-name: {href: "http://localhost:8080/actuator/loggers/{name}", templated: true}
heapdump: {href: "http://localhost:8080/actuator/heapdump", templated: false}
threaddump: {href: "http://localhost:8080/actuator/threaddump", templated: false}
metrics: {href: "http://localhost:8080/actuator/metrics", templated: false}
metrics-requiredMetricName: {href: "http://localhost:8080/actuator/metrics/{requiredMetricName}", templated: true}
scheduledtasks: {href: "http://localhost:8080/actuator/scheduledtasks", templated: false}
httptrace: {href: "http://localhost:8080/actuator/httptrace", templated: false}
mappings: {href: "http://localhost:8080/actuator/mappings", templated: false}
refresh: {href: "http://localhost:8080/actuator/refresh", templated: false}
restart: {href: "http://localhost:8080/actuator/restart", templated: false}
pause: {href: "http://localhost:8080/actuator/pause", templated: false}
resume: {href: "http://localhost:8080/actuator/resume", templated: false}
features: {href: "http://localhost:8080/actuator/features", templated: false}

HealthIndicator（健康指示器）

HealthEndpoint与HealthIndicator从数量上来讲是一对多的关系，即HealthEndpoint：HealthIndicator，一对多。

下面我们来演示一下自定义HealthIndicator接口。

1.HealthIndicator在代码中是以接口的形式出现。而有一个抽象类AbstractHealthIndicator实现了这个接口，我们接下来就是要继承这个抽象类。重写它的doHealthCheck方法。首先，在客户端项目创建一个类MyHealthIndicator继承AbstractHealthIndicator类，然后重写doHealthCheck方法。

import org.springframework.boot.actuate.health.AbstractHealthIndicator;
import org.springframework.boot.actuate.health.Health;

/**
 * @ClassName
 * @Describe TODO
 * @Author 66477
 * @Date 2020/5/2415:39
 * @Version 1.0
 */
public class MyHealthIndicator extends AbstractHealthIndicator {

    @Override
    protected void doHealthCheck(Health.Builder builder) throws Exception {
        builder.up().withDetail("MyHealthIndicator","Day Day up");

    }
}

2.同时我们需要在客户端启动类暴露这个Bean。

@Bean
public MyHealthIndicator myHealthIndicator(){
		return new MyHealthIndicator();
}

3.其次，在客户端bootstrap.properties文件中加入以下配置，则可以看到详细健康信息。

#如果我们想要查看详细信息,打开这个配置
#never：默认从不显示。
#when-authorized：只对已授权的用户才作显示，可通过配置 management.endpoint.health.roles来配置授权角色。
#always：对所有用户都显示。
management.endpoint.health.show-details=always

那么你可能会问，暴露这个意义是什么？比如说应用可以任意地输出业务或系统的健康指标。此时，再去访问http://localhost:8080/actuator/health，你会发现我们刚配置的东东都会显示在这里：

五、问题总结

1.为什么要把配置项放在git上，为什么不放到具体服务的程序里边：git在这里扮演什么样的角色？是不是和zookeeper一样？

解答：Git文件存储方式、分布式的管理系统；Spring Cloud官方实现基于Git，它想叨叨的里面和Zookeeper一样。

2.一个DB配置相关的Bean用@RefreshScope修饰时，config service修改了db的配置，比如mysql的url时，那么这个Bean会不会刷新？如果刷新了是不是获取新的连接的时候url变化了？

解答：如果发生了配置变更，我的解决方案是重启Spring Context。@RefreshScope最佳实践用于配置Bean，比如：开关、阈值、文案调整等等。

猜你喜欢

转载自www.cnblogs.com/jmy520/p/12952860.html
今日推荐
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
【转】spring中对控制反转和依赖注入的理解
tms webcore 安装和使用
java程序员进阶相关书籍
SpringMVC接受请求参数、
如何保存训练好的机器学习模型
MyEclipse、Eclipse设置项目JDK的三个地方
商超行业微信小程序开发定制一般多少钱 （行业技术人员解读）
Markdown编辑器语言——30分钟入门到到精通
Linux系统下MongoDB的简单安装与基本操作
Power Strings
每日归档
更多
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022