第三篇：Sentinel控制台使用与客户端自动连接原理分析

今天药忘吃喽~ 2024-03-25 19:29 100阅读 0赞

Sentinel开发了一个控制台给我们可以动态的去操作规则，方便了我们在项目运行过程中临时需要操作的一些情况，使用文档可以参考里面的第5点

Sentinel控制台使用

控制台使用  
1. 下载对应的jar包或者从源码级别编译sentinel-dashboard模块都可以

2. 启动即可，就是一个spring-boot项目

3. 控制台启动可以配置的一些参数

Sentinel控制台配置参数

客户端连接  
1. 引入以下模块即可

<dependency>  
<groupId>com.alibaba.csp</groupId>  
<artifactId>sentinel-transport-simple-http</artifactId>  
<version>1.8.4</version>  
</dependency>

2.添加客户端启动参数

\-Dcsp.sentinel.dashboard.server=127.0.0.1:7001 -Dproject.name=zxc

sp.sentinel.dashboard.server 为控制台地址

project.name 为客户端项目名称

以上参数都可以在 Sentinel控制台配置参数 找到

我本地的客户端程序还是比较简单，因为只是要进行测试，如下图

配置的参数，其中127.0.0.1:7001是我控制台的地址

以这种方式启动以后在控制台就可以看到如下，前提是引入了对应的依赖，上来说了，引入那个依赖sentinel就会把你当前的客户端注册到你指定的控制台上面去

总结：使用控制台还是比较简单的

1. 下载对应的jar包

2. 启动jar包，就是一个spring-boot项目的jar包

3. 引入对应的maven依赖

4. 添加对应的参数

5. 在控制台进行操作

控制台操作，直接点击簇点链路的流控等就会看到对应的操作页面，如流控规则

其他规则可以参考官网文档，这里就不细说了，后面有讲到这些规则的时候再进行细说

使用其实还是比较简单的，只要根据对应的文档进行下载，操作即可，不过你会不会好奇引入一个maven依赖，然后配置下参数，它就自动会帮我们注册到Sentinel上，这个是怎么做的，这个点会不会有点好奇呢？下面就来说下这个，看它是怎么做的

注：以下只说明是怎么做的逻辑，具体的实现可能不会说太多太细

客户端自动注册原理(源码)  
需要下载源码才可以，下载过程在第一篇就说了，这里就不重复说了，可以参考

第一篇：Sentinel基础知识与源码入门\_zxc\_user的博客-CSDN博客

注册入口  
Sentinel-core 模块下有个类叫 com.alibaba.csp.sentinel.Env  
  
  
  
public class Env \{  
  
public static final Sph sph = new CtSph();  
  
static \{  
// If init fails, the process will exit.  
//执行初始化逻辑,失败的话程序会直接退出  
InitExecutor.doInit();  
\}  
  
\}  
  
  
具体的逻辑在这个doInit()方法里面  
  
public static void doInit() \{  
//只执行一遍，使用原子量控制并发问题  
if (!initialized.compareAndSet(false, true)) \{  
return;  
\}  
try \{  
//这里使用了SPI机制去加载InitFunc接口的实现类  
List<InitFunc> initFuncs = SpiLoader.of(InitFunc.class).loadInstanceListSorted();  
//进行排序处理，InitFunc可以通过标记@InitOrder注解来指定先后顺序  
List<OrderWrapper> initList = new ArrayList<OrderWrapper>();  
for (InitFunc initFunc : initFuncs) \{  
RecordLog.info("\[InitExecutor\] Found init func: \{\}", initFunc.getClass().getCanonicalName());  
insertSorted(initList, initFunc);  
\}  
//循环调用InitFunc方法的init()方法  
for (OrderWrapper w : initList) \{  
w.func.init();  
RecordLog.info("\[InitExecutor\] Executing \{\} with order \{\}",  
w.func.getClass().getCanonicalName(), w.order);  
\}  
\} catch (Exception ex) \{  
RecordLog.warn("\[InitExecutor\] WARN: Initialization failed", ex);  
ex.printStackTrace();  
\} catch (Error error) \{  
RecordLog.warn("\[InitExecutor\] ERROR: Initialization failed with fatal error", error);  
error.printStackTrace();  
\}  
\}

这里面使用了SPI机制加载InitFunc的接口这个是在最重要的一个点，SPI机制前面已经说了，不清楚的可以看下第二篇，因为这里加载了SPI，再看看我们依赖的那个模块下面有什么东西，以下是结构图

那么由于spi机制的存在，上面两个实现类在应用启动的时候就会被调用对应的init方法，我们来看下这两个实现类做了啥

CommandCenterInitFunc  
@Override  
public void init() throws Exception \{  
//获取CommandCenter对象  
CommandCenter commandCenter = CommandCenterProvider.getCommandCenter();  
  
//为空则不进行任何处理  
if (commandCenter == null) \{  
RecordLog.warn("\[CommandCenterInitFunc\] Cannot resolve CommandCenter");  
return;  
\}  
  
//调用CommandCenter对象两个方法  
commandCenter.beforeStart();  
commandCenter.start();  
RecordLog.info("\[CommandCenterInit\] Starting command center: "  
\+ commandCenter.getClass().getCanonicalName());  
\}  
  
  
代码量很简单，接着我们就需要看下CommandCenterProvider这个提供者做了啥了  
  
  
  
  
public final class CommandCenterProvider \{  
  
private static CommandCenter commandCenter = null;  
  
static \{  
//解析实例  
resolveInstance();  
\}  
  
private static void resolveInstance() \{  
//又是利用spi机制获取CommandCenter然后取优先值最高的对象  
CommandCenter resolveCommandCenter = SpiLoader.of(CommandCenter.class).loadHighestPriorityInstance();  
  
if (resolveCommandCenter == null) \{  
RecordLog.warn("\[CommandCenterProvider\] WARN: No existing CommandCenter found");  
\} else \{  
commandCenter = resolveCommandCenter;  
RecordLog.info("\[CommandCenterProvider\] CommandCenter resolved: \{\}", resolveCommandCenter.getClass()  
.getCanonicalName());  
\}  
\}  
  
/\*\*  
\* Get resolved \{@link CommandCenter\} instance.  
\*  
\* @return resolved \{@code CommandCenter\} instance  
\*/  
public static CommandCenter getCommandCenter() \{  
return commandCenter;  
\}  
  
private CommandCenterProvider() \{\}  
\}  
  
  
  
可以看到CommandCenterProvider一开始就去加载了，再次使用到spi机制，CommandCenter 有几个实现类，其中一个就是sentinel-transport-simple-http maven依赖里面提供的SimpleHttpCommandCenter实现类

通过上面的分析我们找到了SimpleHttpCommandCenter，那么接下来就是看这个类里面的beforeStart()和start()方法了

SimpleHttpCommandCenter  
com.alibaba.csp.sentinel.transport.command.SimpleHttpCommandCenter\#beforeStart  
  
  
@Override  
@SuppressWarnings("rawtypes")  
public void beforeStart() throws Exception \{  
// Register handlers  
//通过spi机制获取所有CommandHandler对象  
Map<String, CommandHandler> handlers = CommandHandlerProvider.getInstance().namedHandlers();  
//注册命令  
registerCommands(handlers);  
//注：这里使用了命令设计模式  
\}  
  
  
  
public void start() throws Exception \{  
  
//获取当前运行环境的线程核心数  
int nThreads = Runtime.getRuntime().availableProcessors();  
  
//声明线程池  
this.bizExecutor = new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS,  
new ArrayBlockingQueue<Runnable>(10),  
new NamedThreadFactory("sentinel-command-center-service-executor", true),  
new RejectedExecutionHandler() \{  
@Override  
public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) \{  
CommandCenterLog.info("EventTask rejected");  
throw new RejectedExecutionException();  
\}  
\});  
  
Runnable serverInitTask = new Runnable() \{  
int port;  
  
\{  
try \{  
port = Integer.parseInt(TransportConfig.getPort());  
\} catch (Exception e) \{  
port = DEFAULT\_PORT;  
\}  
\}  
  
@Override  
public void run() \{  
boolean success = false;  
//创建ServerSocket客户端，用来接收控制台放松的消息  
ServerSocket serverSocket = getServerSocketFromBasePort(port);  
  
if (serverSocket != null) \{  
CommandCenterLog.info("\[CommandCenter\] Begin listening at port " + serverSocket.getLocalPort());  
socketReference = serverSocket;  
//往线程池提交任务，类型为ServerThread  
executor.submit(new ServerThread(serverSocket));  
success = true;  
port = serverSocket.getLocalPort();  
\} else \{  
CommandCenterLog.info("\[CommandCenter\] chooses port fail, http command center will not work");  
\}  
  
if (!success) \{  
port = PORT\_UNINITIALIZED;  
\}  
  
TransportConfig.setRuntimePort(port);  
//关闭线程池  
executor.shutdown();  
\}  
  
\};  
  
//启动上面定义的线程  
new Thread(serverInitTask).start();  
\}  
  
  
  
ServerThread的代码如下  
  
  
  
class ServerThread extends Thread \{  
  
private ServerSocket serverSocket;  
  
ServerThread(ServerSocket s) \{  
this.serverSocket = s;  
setName("sentinel-courier-server-accept-thread");  
\}  
  
@Override  
public void run() \{  
//死循环  
while (true) \{  
Socket socket = null;  
try \{  
//接收控制台发来的消息  
socket = this.serverSocket.accept();  
setSocketSoTimeout(socket);  
//事件任务，默认情况下控制台会一直发送 metric 事件  
HttpEventTask eventTask = new HttpEventTask(socket);  
//提交  
bizExecutor.submit(eventTask);  
\} catch (Exception e) \{  
CommandCenterLog.info("Server error", e);  
if (socket != null) \{  
try \{  
socket.close();  
\} catch (Exception e1) \{  
CommandCenterLog.info("Error when closing an opened socket", e1);  
\}  
\}  
try \{  
// In case of infinite log.  
//每10ms就接收一次  
Thread.sleep(10);  
\} catch (InterruptedException e1) \{  
// Indicates the task should stop.  
break;  
\}  
\}  
\}  
\}  
\}  
  
  
  
这里面最核心的是HttpEventTask事件，用来接收处理控制器发过来的事件，看一下它的run方法，比较长，不过主要的逻辑就那几句  
  
  
  
@Override  
public void run() \{  
  
if (socket == null) \{  
return;  
\}  
  
PrintWriter printWriter = null;  
InputStream inputStream = null;  
try \{  
//整理获取数据...这一块就不解析了  
long start = System.currentTimeMillis();  
inputStream = new BufferedInputStream(socket.getInputStream());  
OutputStream outputStream = socket.getOutputStream();  
  
printWriter = new PrintWriter(  
new OutputStreamWriter(outputStream, Charset.forName(SentinelConfig.charset())));  
  
String firstLine = readLine(inputStream);  
CommandCenterLog.info("\[SimpleHttpCommandCenter\] Socket income: " + firstLine  
\+ ", addr: " + socket.getInetAddress());  
CommandRequest request = processQueryString(firstLine);  
  
if (firstLine.length() > 4 && StringUtil.equalsIgnoreCase("POST", firstLine.substring(0, 4))) \{  
// Deal with post method  
processPostRequest(inputStream, request);  
\}  
  
// Validate the target command.  
// 从请求中获取要执行的命令  
String commandName = HttpCommandUtils.getTarget(request);  
if (StringUtil.isBlank(commandName)) \{  
writeResponse(printWriter, StatusCode.BAD\_REQUEST, INVALID\_COMMAND\_MESSAGE);  
return;  
\}  
  
System.out.println("commandName = " + commandName);  
  
// Find the matching command handler.  
//再从前面加载的命令中获取对应的命令处理器  
CommandHandler<?> commandHandler = SimpleHttpCommandCenter.getHandler(commandName);  
if (commandHandler != null) \{  
//处理命令并响应给控制台  
CommandResponse<?> response = commandHandler.handle(request);  
handleResponse(response, printWriter);  
\} else \{  
// No matching command handler.  
//没有找到匹配的，直接报错  
writeResponse(printWriter, StatusCode.BAD\_REQUEST, "Unknown command \`" + commandName + '\`');  
\}  
  
long cost = System.currentTimeMillis() - start;  
CommandCenterLog.info("\[SimpleHttpCommandCenter\] Deal a socket task: " + firstLine  
\+ ", address: " + socket.getInetAddress() + ", time cost: " + cost + " ms");  
\} catch (RequestException e) \{  
writeResponse(printWriter, e.getStatusCode(), e.getMessage());  
\} catch (Throwable e) \{  
CommandCenterLog.warn("\[SimpleHttpCommandCenter\] CommandCenter error", e);  
try \{  
if (printWriter != null) \{  
String errorMessage = SERVER\_ERROR\_MESSAGE;  
e.printStackTrace();  
if (!writtenHead) \{  
writeResponse(printWriter, StatusCode.INTERNAL\_SERVER\_ERROR, errorMessage);  
\} else \{  
printWriter.println(errorMessage);  
\}  
printWriter.flush();  
\}  
\} catch (Exception e1) \{  
CommandCenterLog.warn("Failed to write error response", e1);  
\}  
\} finally \{  
closeResource(inputStream);  
closeResource(printWriter);  
closeResource(socket);  
\}  
\}  
  
  
  
  
这里面最核心的就是命令行设计模式设计的CommandHandler对象了，这个对象的实现类在前面已经通过spi机制进行加载了，可以稍微看下有哪些  
  
  
在 sentinel-transport-common模块中的com.alibaba.csp.sentinel.command.CommandHandler文件  
  
  
  
com.alibaba.csp.sentinel.command.handler.BasicInfoCommandHandler  
com.alibaba.csp.sentinel.command.handler.FetchActiveRuleCommandHandler  
com.alibaba.csp.sentinel.command.handler.FetchClusterNodeByIdCommandHandler  
com.alibaba.csp.sentinel.command.handler.FetchClusterNodeHumanCommandHandler  
com.alibaba.csp.sentinel.command.handler.FetchJsonTreeCommandHandler  
com.alibaba.csp.sentinel.command.handler.FetchOriginCommandHandler  
com.alibaba.csp.sentinel.command.handler.FetchSimpleClusterNodeCommandHandler  
com.alibaba.csp.sentinel.command.handler.FetchSystemStatusCommandHandler  
com.alibaba.csp.sentinel.command.handler.FetchTreeCommandHandler  
com.alibaba.csp.sentinel.command.handler.ModifyRulesCommandHandler  
com.alibaba.csp.sentinel.command.handler.OnOffGetCommandHandler  
com.alibaba.csp.sentinel.command.handler.OnOffSetCommandHandler  
com.alibaba.csp.sentinel.command.handler.SendMetricCommandHandler  
com.alibaba.csp.sentinel.command.handler.VersionCommandHandler  
com.alibaba.csp.sentinel.command.handler.cluster.FetchClusterModeCommandHandler  
com.alibaba.csp.sentinel.command.handler.cluster.ModifyClusterModeCommandHandler  
com.alibaba.csp.sentinel.command.handler.ApiCommandHandler  
  
  
有以上这些实现，我们可以稍微看下ModifyRulesCommandHandler这个类，这是最重要的一个  
  
  
  
  
  
@Override  
public CommandResponse<String> handle(CommandRequest request) \{  
//前面还是在整理获取数据  
// XXX from 1.7.2, force to fail when fastjson is older than 1.2.12  
// We may need a better solution on this.  
if (VersionUtil.fromVersionString(JSON.VERSION) < FASTJSON\_MINIMAL\_VER) \{  
// fastjson too old  
return CommandResponse.ofFailure(new RuntimeException("The \\"fastjson-" + JSON.VERSION  
\+ "\\" introduced in application is too old, you need fastjson-1.2.12 at least."));  
\}  
String type = request.getParam("type");  
// rule data in get parameter  
String data = request.getParam("data");  
if (StringUtil.isNotEmpty(data)) \{  
try \{  
data = URLDecoder.decode(data, "utf-8");  
\} catch (Exception e) \{  
RecordLog.info("Decode rule data error", e);  
return CommandResponse.ofFailure(e, "decode rule data error");  
\}  
\}  
  
RecordLog.info("Receiving rule change (type: \{\}): \{\}", type, data);  
  
String result = "success";  
  
//流控规则  
if (FLOW\_RULE\_TYPE.equalsIgnoreCase(type)) \{  
//解析数据已经更新数据  
List<FlowRule> flowRules = JSONArray.parseArray(data, FlowRule.class);  
FlowRuleManager.loadRules(flowRules);  
//持久化数据  
if (!writeToDataSource(getFlowDataSource(), flowRules)) \{  
result = WRITE\_DS\_FAILURE\_MSG;  
\}  
return CommandResponse.ofSuccess(result);  
\} else if (AUTHORITY\_RULE\_TYPE.equalsIgnoreCase(type)) \{ //黑白名单  
//解析数据已经更新数据  
List<AuthorityRule> rules = JSONArray.parseArray(data, AuthorityRule.class);  
AuthorityRuleManager.loadRules(rules);  
//持久化数据  
if (!writeToDataSource(getAuthorityDataSource(), rules)) \{  
result = WRITE\_DS\_FAILURE\_MSG;  
\}  
return CommandResponse.ofSuccess(result);  
\} else if (DEGRADE\_RULE\_TYPE.equalsIgnoreCase(type)) \{  
//降级数据  
List<DegradeRule> rules = JSONArray.parseArray(data, DegradeRule.class);  
DegradeRuleManager.loadRules(rules);  
//持久化数据  
if (!writeToDataSource(getDegradeDataSource(), rules)) \{  
result = WRITE\_DS\_FAILURE\_MSG;  
\}  
return CommandResponse.ofSuccess(result);  
\} else if (SYSTEM\_RULE\_TYPE.equalsIgnoreCase(type)) \{  
//系统规则  
List<SystemRule> rules = JSONArray.parseArray(data, SystemRule.class);  
SystemRuleManager.loadRules(rules);  
//持久化数据  
if (!writeToDataSource(getSystemSource(), rules)) \{  
result = WRITE\_DS\_FAILURE\_MSG;  
\}  
return CommandResponse.ofSuccess(result);  
\}  
return CommandResponse.ofFailure(new IllegalArgumentException("invalid type"));  
\}  
  
  
  
writeToDataSource 写到数据源的逻辑原来也在这里，不过这个后面再看就行了

总结：以上就是 CommandCenterInitFunc以及SimpleHttpCommandCenter的原理，客户端接收服务端的流程和逻辑处理，下面再讲另一个东西

HeartbeatSenderInitFunc  
看名字就知道是用来处理心跳机制的，也就是客户端发送信息给控制台的，下面就来看下具体的情况

先看下 HeartbeatSenderProvider 这个类做了啥  
  
public final class HeartbeatSenderProvider \{  
  
private static HeartbeatSender heartbeatSender = null;  
  
static \{  
//解析实例  
resolveInstance();  
\}  
  
private static void resolveInstance() \{  
//又是利用spi机制获取优先级最高的  
//我们引入sentinel-transport-simple-http会加载一个SimpleHttpHeartbeatSender，所以这里拿到的就是SimpleHttpHeartbeatSender  
//除非有其他实现类  
HeartbeatSender resolved = SpiLoader.of(HeartbeatSender.class).loadHighestPriorityInstance();  
if (resolved == null) \{  
RecordLog.warn("\[HeartbeatSenderProvider\] WARN: No existing HeartbeatSender found");  
\} else \{  
heartbeatSender = resolved;  
RecordLog.info("\[HeartbeatSenderProvider\] HeartbeatSender activated: \{\}", resolved.getClass()  
.getCanonicalName());  
\}  
\}  
  
/\*\*  
\* Get resolved \{@link HeartbeatSender\} instance.  
\*  
\* @return resolved \{@code HeartbeatSender\} instance  
\*/  
public static HeartbeatSender getHeartbeatSender() \{  
return heartbeatSender;  
\}  
  
private HeartbeatSenderProvider() \{\}  
\}  
  
  
HeartbeatSenderProvider这个类就是生成一个HeartbeatSender 对象，而我们这里实际上就是SimpleHttpHeartbeatSender对象  
  
  
com.alibaba.csp.sentinel.transport.init.HeartbeatSenderInitFunc\#init  
  
@Override  
public void init() \{  
//获取HeartbeatSender对象  
HeartbeatSender sender = HeartbeatSenderProvider.getHeartbeatSender();  
if (sender == null) \{  
RecordLog.warn("\[HeartbeatSenderInitFunc\] WARN: No HeartbeatSender loaded");  
return;  
\}  
  
//如果需要初始话定时线程池  
initSchedulerIfNeeded();  
//获取发送间隔  
long interval = retrieveInterval(sender);  
//把间隔设置回去  
setIntervalIfNotExists(interval);  
//启动任务定时发送心跳  
scheduleHeartbeatTask(sender, interval);  
\}  
  
  
  
retrieveInterval 这个方法里面就可以看到具体的间隔时间是怎么拿取的，可以通过  
csp.sentinel.heartbeat.interval.ms参数进行设置，原理也就是在这个位置  
  
  
  
  
long retrieveInterval(/\*@NonNull\*/ HeartbeatSender sender) \{  
//从配置中获取，如果是有效的直接返回  
Long intervalInConfig = TransportConfig.getHeartbeatIntervalMs();  
if (isValidHeartbeatInterval(intervalInConfig)) \{  
RecordLog.info("\[HeartbeatSenderInitFunc\] Using heartbeat interval "  
\+ "in Sentinel config property: " + intervalInConfig);  
return intervalInConfig;  
\} else \{  
//如果无效则从HeartbeatSender获取这个间隔， SimpleHttpHeartbeatSender默认为10s执行一次  
long senderInterval = sender.intervalMs();  
RecordLog.info("\[HeartbeatSenderInit\] Heartbeat interval not configured in "  
\+ "config property or invalid, using sender default: " + senderInterval);  
return senderInterval;  
\}  
\}  
  
  
最后再看下 scheduleHeartbeatTask方法，具体发送心跳的逻辑  
  
  
  
private void scheduleHeartbeatTask(/\*@NonNull\*/ final HeartbeatSender sender, /\*@Valid\*/ long interval) \{  
pool.scheduleAtFixedRate(new Runnable() \{  
@Override  
public void run() \{  
try \{  
//发送心跳  
sender.sendHeartbeat();  
\} catch (Throwable e) \{  
//失败了也只是当时那个失败，不会停止整个线程  
RecordLog.warn("\[HeartbeatSender\] Send heartbeat error", e);  
\}  
\}  
//5秒后启动，每interval执行一次  
\}, 5000, interval, TimeUnit.MILLISECONDS);  
RecordLog.info("\[HeartbeatSenderInit\] HeartbeatSender started: "  
\+ sender.getClass().getCanonicalName());  
\}  
  
  
  
  
  
那么逻辑很明显就在具体的HeartbeatSender 进行实现了，下面再具体看一下  
  
  
  
  
com.alibaba.csp.sentinel.transport.heartbeat.SimpleHttpHeartbeatSender\#sendHeartbeat  
  
  
  
@Override  
public boolean sendHeartbeat() throws Exception \{  
  
//前置判断  
if (TransportConfig.getRuntimePort() <= 0) \{  
RecordLog.info("\[SimpleHttpHeartbeatSender\] Command server port not initialized, won't send heartbeat");  
return false;  
\}  
//获取控制台的地址，就是csp.sentinel.dashboard.server参数配置的，可以配置多个，多个时会进行负载均衡请求  
Endpoint addrInfo = getAvailableAddress();  
if (addrInfo == null) \{  
return false;  
\}  
  
//封装请求对象以及设置参数  
SimpleHttpRequest request = new SimpleHttpRequest(addrInfo, TransportConfig.getHeartbeatApiPath());  
request.setParams(heartBeat.generateCurrentMessage());  
try \{  
//发送http请求  
SimpleHttpResponse response = httpClient.post(request);  
if (response.getStatusCode() == OK\_STATUS) \{  
return true;  
\} else if (clientErrorCode(response.getStatusCode()) || serverErrorCode(response.getStatusCode())) \{  
RecordLog.warn("\[SimpleHttpHeartbeatSender\] Failed to send heartbeat to " + addrInfo  
\+ ", http status code: " + response.getStatusCode());  
\}  
\} catch (Exception e) \{  
RecordLog.warn("\[SimpleHttpHeartbeatSender\] Failed to send heartbeat to " + addrInfo, e);  
\}  
return false;  
\}  
  
  
  
  
  
逻辑还是挺清晰的，这里唯一的问题就是请求地址是怎么确定的，可以再稍微看下  
SimpleHttpHeartbeatSender构造方法里面获取的，TransportConfig.getConsoleServerList()  
这个就不进去看了，就是解析csp.sentinel.dashboard.server参数，多个以,分割，然后把它组成一个个  
Endpoint对象放到列表去  
  
  
  
public SimpleHttpHeartbeatSender() \{  
// Retrieve the list of default addresses.  
//获取地址列表  
List<Endpoint> newAddrs = TransportConfig.getConsoleServerList();  
if (newAddrs.isEmpty()) \{  
RecordLog.warn("\[SimpleHttpHeartbeatSender\] Dashboard server address not configured or not available");  
\} else \{  
RecordLog.info("\[SimpleHttpHeartbeatSender\] Default console address list retrieved: \{\}", newAddrs);  
\}  
//赋值  
this.addressList = newAddrs;  
\}  
  
  
至此心跳逻辑就分析完了，发下心跳的时候自然是会往控制台注册自己的，至于控制台规则是怎么来的，那个逻辑就是控制台那边通过注册的ip，调用对应的借口获取然后展示到上面的，后面如果有时间，再写篇文章去看这个问题，其实原理都是一样的

明显心跳的逻辑比接收的逻辑要简单很多，这里依然使用的设计模式有策略模式以及spi机制

到这里，自动注册的原理就分析完了，再稍微总结一下原理

1, 引入sentinel-transport-simple-http的maven依赖

2. Env初始快调用InitFunc的init方法

3. 引入sentinel-transport-simple-http时会同时依赖sentinel-transport-common，而该模块会有InitFunc的实现，主要有以下两个

CommandCenterInitFunc：用于接收控制台发送消息给客户段的

HeartbeatSenderInitFunc：用于发送心跳给控制台的

4. 在执行上面这两个的时候会有对应的实现类，而这两个实现类是在sentinel-transport-simple-http模块中的，主要是

SimpleHttpCommandCenter：用于实现接收控制台发送消息给客户段

SimpleHttpHeartbeatSender：用于实现发送心跳也就是注册信息给控制台的

到此就结束了，在这个过程中可以看到作者是如何巧妙的使用spi机制进行解耦的，Env中执行调用了InitFunc的init方法，而sentinel-transport-simple-htt模块中自己根据spi机制定义了对应的规范，有以上的实现类，自然而然通过spi机制就可以直接添加被所承载的应用进行加载了，最后实现了引入依赖就自动被注册的动态效果!!

多参考一下大佬们的源码书写确实有一定帮助  
————————————————  
版权声明：本文为CSDN博主「zxc\_user」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。  
原文链接：https://blog.csdn.net/zxc\_user/article/details/125930626