参考源码中的sentinel-demo-dynamic-file-rule项目
持久化到文件
源码流程图
源码分析
dashboard端保存和读取规则
保存规则
以flow为例,前端保存时会调用/rule保存
先保存到本地缓存中,然后通过http,全量数据推送给客户端
@PostMapping("/rule")
@AuthAction(PrivilegeType.WRITE_RULE)
public Result<FlowRuleEntity> apiAddFlowRule(@RequestBody FlowRuleEntity entity) {
Result<FlowRuleEntity> checkResult = checkEntityInternal(entity);
if (checkResult != null) {
return checkResult;
}
entity.setId(null);
Date date = new Date();
entity.setGmtCreate(date);
entity.setGmtModified(date);
entity.setLimitApp(entity.getLimitApp().trim());
entity.setResource(entity.getResource().trim());
try {
//保存本地缓存中
entity = repository.save(entity);
//推给客户端(http://ip:port/setRules)
publishRules(entity.getApp(), entity.getIp(), entity.getPort()).get(5000, TimeUnit.MILLISECONDS);
return Result.ofSuccess(entity);
} catch (Throwable t) {
...
return Result.ofFail(-1, e.getMessage());
}
}
获取规则
前端查看规则时,会向客户端发起http请求,从客户端拉取所有规则
@GetMapping("/rules")
@AuthAction(PrivilegeType.READ_RULE)
public Result<List<FlowRuleEntity>> apiQueryMachineRules(@RequestParam String app,
@RequestParam String ip,
@RequestParam Integer port) {
...
try {
//通过http调用客户端,从客户端拉取规则
List<FlowRuleEntity> rules = sentinelApiClient.fetchFlowRuleOfMachine(app, ip, port);
rules = repository.saveAll(rules);
return Result.ofSuccess(rules);
} catch (Throwable throwable) {
return Result.ofThrowable(-1, throwable);
}
}
客户端
启动服务,接收请求
Env
在第一次判断熔断限流逻辑时,会走Env的静态代码块
public class Env {
public static final Sph sph = new CtSph();
static {
// If init fails, the process will exit.
InitExecutor.doInit();
}
}
InitExecutor.doInit()
通过spi获取所有InitFunc类型的类,调用init方法
此处就是扩展点,可以通过这里,调用我们自己自定义的InitFunc类
public static void doInit() {
//只初始化一次
if (!initialized.compareAndSet(false, true)) {
return;
}
try {
//通过spi获取所有InitFunc类
List<InitFunc> initFuncs = SpiLoader.of(InitFunc.class).loadInstanceListSorted();
List<OrderWrapper> initList = new ArrayList<OrderWrapper>();
for (InitFunc initFunc : initFuncs) {
insertSorted(initList, initFunc);
}
//调用InitFunc类的init方法
for (OrderWrapper w : initList) {
w.func.init();
RecordLog.info("[InitExecutor] Executing {} with order {}",
w.func.getClass().getCanonicalName(), w.order);
}
}
}
CommandCenterInitFunc
此类为sentinal提供,会第一个调用此类
这个类用来启动服务,用来和dashboard通信
@InitOrder(-1)
public class CommandCenterInitFunc implements InitFunc {
@Override
public void init() throws Exception {
//此类构造时,会调用静态代码块,通过spi机制获取CommandCenter
CommandCenter commandCenter = CommandCenterProvider.getCommandCenter();
if (commandCenter == null) {
RecordLog.warn("[CommandCenterInitFunc] Cannot resolve CommandCenter");
return;
}
commandCenter.beforeStart();
commandCenter.start();
RecordLog.info("[CommandCenterInit] Starting command center: "
+ commandCenter.getClass().getCanonicalName());
}
}
通过SPI获取服务,默认获取SimpleHttpCommandCenter
public final class CommandCenterProvider {
private static CommandCenter commandCenter = null;
static {
resolveInstance();
}
private static void resolveInstance() {
CommandCenter resolveCommandCenter = SpiLoader.of(CommandCenter.class).loadHighestPriorityInstance();
if (resolveCommandCenter == null) {
} else {
commandCenter = resolveCommandCenter;
}
}
public static CommandCenter getCommandCenter() {
return commandCenter;
}
private CommandCenterProvider() {}
}
SimpleHttpCommandCenter
此类会启动bio服务,用来和dashboard通信,代码省略…
最终接收到请求时,会调用CommandHandler
用来处理规则修改的类是ModifyRulesCommandHandler
ModifyRulesCommandHandler
handle方法中,处理flow逻辑如下
会先将规则保存到缓存中
然后将规则持久化到数据源(默认不持久话)
我们自己注入DataSource,来持久化数据
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);
}
持久化到文件
新写一个项目,封装持久化逻辑,参考sentinel-demo-dynamic-file-rule项目
FileDataSourceInit
通过下面配置,客户端启动的时候,会通过spi机制自动调用init方法
1、创建类FileDataSourceInit
2、添加文件/META-INF\services/com.alibaba.csp.sentinel.init.InitFunc
3、文件内容为FileDataSourceInit 类的路径
public class FileDataSourceInit implements InitFunc {
@Override
public void init() throws Exception {
//设置持久化路径
String flowRuleDir = System.getProperty("user.home") + File.separator + "sentinel" + File.separator + "rules";
String flowRuleFile = "flowRule.json";
String flowRulePath = flowRuleDir + File.separator + flowRuleFile;
//监听文件变化
ReadableDataSource<String, List<FlowRule>> ds = new FileRefreshableDataSource<>(
flowRulePath, source -> JSON.parseObject(source, new TypeReference<List<FlowRule>>() {})
);
FlowRuleManager.register2Property(ds.getProperty());
//构建持久化数据源
WritableDataSource<List<FlowRule>> wds = new FileWritableDataSource<>(flowRulePath, this::encodeJson);
//注入数据源到flow
WritableDataSourceRegistry.registerFlowDataSource(wds);
}
private <T> String encodeJson(T t) {
return JSON.toJSONString(t);
}
}
FileWritableDataSource
持久化数据源,客户端规则发生变化时,会调用write方法
public class FileWritableDataSource<T> implements WritableDataSource<T> {
private static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");
private final Converter<T, String> configEncoder;
private final File file;
private final Charset charset;
private final Lock lock = new ReentrantLock(true);
public FileWritableDataSource(String filePath, Converter<T, String> configEncoder) {
this(new File(filePath), configEncoder);
}
public FileWritableDataSource(File file, Converter<T, String> configEncoder) {
this(file, configEncoder, DEFAULT_CHARSET);
}
public FileWritableDataSource(File file, Converter<T, String> configEncoder, Charset charset) {
if (file == null || file.isDirectory()) {
throw new IllegalArgumentException("Bad file");
}
if (configEncoder == null) {
throw new IllegalArgumentException("Config encoder cannot be null");
}
if (charset == null) {
throw new IllegalArgumentException("Charset cannot be null");
}
this.configEncoder = configEncoder;
this.file = file;
this.charset = charset;
}
@Override
public void write(T value) throws Exception {
lock.lock();
try {
String convertResult = configEncoder.convert(value);
FileOutputStream outputStream = null;
try {
outputStream = new FileOutputStream(file);
byte[] bytesArray = convertResult.getBytes(charset);
RecordLog.info("[FileWritableDataSource] Writing to file {}: {}", file, convertResult);
outputStream.write(bytesArray);
outputStream.flush();
} finally {
if (outputStream != null) {
try {
outputStream.close();
} catch (Exception ignore) {
// nothing
}
}
}
} finally {
lock.unlock();
}
}
@Override
public void close() throws Exception {
// Nothing
}
}
FileRefreshableDataSource
init方法时,构建FileRefreshableDataSource对象,此类父类构造函数会启动定时任务,监听文件是否有变化
只列出部分代码,具体代码可参考源码中的FileRefreshableDataSource
public AutoRefreshDataSource(Converter<S, T> configParser, final long recommendRefreshMs) {
super(configParser);
...
this.recommendRefreshMs = recommendRefreshMs;
startTimerService();
}
启动定时任务,监控文件是否有变化
private void startTimerService() {
service = Executors.newScheduledThreadPool(1,
new NamedThreadFactory("sentinel-datasource-auto-refresh-task", true));
service.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
try {
if (!isModified()) {
return;
}
T newValue = loadConfig();
getProperty().updateValue(newValue);
} catch (Throwable e) {
RecordLog.info("loadConfig exception", e);
}
}
}, recommendRefreshMs, recommendRefreshMs, TimeUnit.MILLISECONDS);
}