Soul网关中利用HTTP长轮询实现数据同步，这也太好用了叭！

Java天道酬勤

于 2024-03-26 17:09:01 发布

阅读量956

点赞数 27

分类专栏：程序员文章标签： http 网络协议网络

本文链接：https://blog.csdn.net/q16974058/article/details/137051925

版权

程序员专栏收录该内容

576 篇文章 1 订阅

订阅专栏

generateResponse((HttpServletResponse) asyncContext.getResponse(), changedGroups);

//同步完成结束阻塞

asyncContext.complete();

}

Http请求到达sou-admin之后，并非立马响应数据，而是利用Servlet3.0的异步机制，异步响应数据。首先，将长轮询请求任务LongPollingClient扔到BlockingQueue中，并且开启调度任务，60s后执行，这样做的目的是60s后将该长轮询请求移除队列，即便是这段时间内没有发生配置数据变更。因为即便是没有配置变更，也得让网关知道，总不能让其干等吧，而且网关请求配置服务时，也有90s的超时时间

长轮询时配置数据变更立即响应数据

讲完了Http请求到达sou-admin这段时间没有变更配置数据60s后返回响应，如果这段时间内，存在配置数据变更呢？

首先Http请求到达sou-admin时最终拿到的配置信息数据都是从AbstractDataChangedListener的Cache中获取的

public abstract class AbstractDataChangedListener implements DataChangedListener, InitializingBean {

protected static final ConcurrentMap<String, ConfigDataCache> CACHE = new ConcurrentHashMap<>();

那AbstractDataChangedListener中本地缓存数据是何时更新的，只有本地缓存更新了才会立即响应数据

AbstractDataChangedListener中本地缓存数据更新时机：

触发DataChangedEvent事件，DataChangedEventDispatcher监听到来处理数据同步的事件分类及分发
定时任务同步

1）触发Spring事件，DataChangedEventDispatcher监听到来处理数据同步的事件分类及分发

就是DataChangedListener体系中讲解的内容，下面以创建和修改Plugin为例：

@Service(“pluginService”)

public class PluginServiceImpl implements PluginService {

@Override

@Transactional(rollbackFor = Exception.class)

public String createOrUpdate(final PluginDTO pluginDTO) {

final String msg = checkData(pluginDTO);

if (StringUtils.isNoneBlank(msg)) {

return msg;

}

PluginDO pluginDO = PluginDO.buildPluginDO(pluginDTO);

DataEventTypeEnum eventType = DataEventTypeEnum.CREATE;

if (StringUtils.isBlank(pluginDTO.getId())) {

insertPluginDataToResource(pluginDTO);

pluginMapper.insertSelective(pluginDO);

} else {

eventType = DataEventTypeEnum.UPDATE;

pluginMapper.updateSelective(pluginDO);

}

//触发事件

eventPublisher.publishEvent(new DataChangedEvent(ConfigGroupEnum.PLUGIN, eventType,

Collections.singletonList(PluginTransfer.INSTANCE.mapToData(pluginDO))));

return StringUtils.EMPTY;

}

创建和修改Plugin之后，触发了DataChangedEvent，DataChangedEventDispatcher根据groupKey进行分发，调用了AbstractDataChangedListener中实现的onXxxChanged()方法：

@Component

public class DataChangedEventDispatcher implements ApplicationListener, InitializingBean {

//事件变动时,通知DataChangedListener的不同事件类型的方法

@Override

@SuppressWarnings(“unchecked”)

public void onApplicationEvent(final DataChangedEvent event) {

for (DataChangedListener listener : listeners) {

switch (event.getGroupKey()) {

case APP_AUTH:

listener.onAppAuthChanged((List) event.getSource(), event.getEventType());

break;

case PLUGIN:

listener.onPluginChanged((List) event.getSource(), event.getEventType());

break;

case RULE:

listener.onRuleChanged((List) event.getSource(), event.getEventType());

break;

case SELECTOR:

listener.onSelectorChanged((List) event.getSource(), event.getEventType());

break;

case META_DATA:

listener.onMetaDataChanged((List ) event.getSource(), event.getEventType());

break;

default:

throw new IllegalStateException("Unexpected value: " + event.getGroupKey());

}

AbstractDataChangedListener中采用了模版方法模式，onXxxChanged()方法中修改了缓存，提供了afterXxxChanged()方法让子类自定义结束数据变动后要干什么

public abstract class AbstractDataChangedListener implements DataChangedListener, InitializingBean {

@Override

public void onPluginChanged(final List changed, final DataEventTypeEnum eventType) {

if (CollectionUtils.isEmpty(changed)) {

return;

}

this.updatePluginCache();

this.afterPluginChanged(changed, eventType);

}

//修改缓存(可重写)

protected void updatePluginCache() {

this.updateCache(ConfigGroupEnum.PLUGIN, pluginService.listAll());

}

//自定义结束数据变动后要干什么(可重写)

protected void afterPluginChanged(final List changed, final DataEventTypeEnum eventType) {

}

HttpLongPollingDataChangedListener中重写了AbstractDataChangedListener中的afterXxxChanged()方法，afterXxxChanged()方法是通过事件变更触发长轮询立即响应的关键

public class HttpLongPollingDataChangedListener extends AbstractDataChangedListener {

@Override

protected void afterPluginChanged(final List changed, final DataEventTypeEnum eventType) {

scheduler.execute(new DataChangeTask(ConfigGroupEnum.PLUGIN));

}

class DataChangeTask implements Runnable {

private final ConfigGroupEnum groupKey;

private final long changeTime = System.currentTimeMillis();

DataChangeTask(final ConfigGroupEnum groupKey) {

this.groupKey = groupKey;

}

@Override

public void run() {

//soul-admin发生了配置变更,挨个将队列中的请求移除,并予以响应

for (Iterator iter = clients.iterator(); iter.hasNext()😉 {

LongPollingClient client = iter.next();

iter.remove();

client.sendResponse(Collections.singletonList(groupKey));

log.info(“send response with the changed group,ip={}, group={}, changeTime={}”, client.ip, groupKey, changeTime);

}

如果这段时间内，管理员变更了配置数据，此时，会挨个移除队列中的长轮询请求，并响应数据，告知是哪个Group的数据发生了变更（将插件、规则、流量配置、用户配置数据分成不同的组）。

网关收到响应信息之后，只知道是哪个Group发生了配置变更，还需要再次请求该Group的配置数据，这时候会调用ConfigController中暴露的fetch接口拿到最新的配置数据

@ConditionalOnBean(HttpLongPollingDataChangedListener.class)

@RestController

@RequestMapping(“/configs”)

@Slf4j

public class ConfigController {

@Resource

private HttpLongPollingDataChangedListener longPollingListener;

@GetMapping(“/fetch”)

public SoulAdminResult fetchConfigs(@NotNull final String[] groupKeys) {

Map<String, ConfigData<?>> result = Maps.newHashMap();

for (String groupKey : groupKeys) {

ConfigData<?> data = longPollingListener.fetchConfig(ConfigGroupEnum.valueOf(groupKey));

result.put(groupKey, data);

}

return SoulAdminResult.success(SoulResultMessage.SUCCESS, result);

}

关于为什么不是直接将变更的数据写出，作者给出的回答是：因为Http长轮询机制只能保证准实时，如果在网关层处理不及时，或者管理员频繁更新配置，很有可能便错过了某个配置变更的推送，安全起见，我们只告知某个Group信息发生了变更。

2）定时任务同步

定时任务同步是因为触发事件只是单个节点完成缓存更新，假设soul-admin存在A、B两个节点，更新配置数据的请求到达A节点完成了A节点内本地缓存数据的更新，而B节点并未更新本地缓存，所以B节点的数据是通过定时任务来同步的

定时任务同步也是在HttpLongPollingDataChangedListener中实现的

public class HttpLongPollingDataChangedListener extends AbstractDataChangedListener {

@Override

protected void afterInitialize() {

long syncInterval = httpSyncProperties.getRefreshInterval().toMillis();

//定期检查数据的更改并更新缓存

scheduler.scheduleWithFixedDelay(() -> {

log.info(“http sync strategy refresh config start.”);

try {

this.refreshLocalCache();

log.info(“http sync strategy refresh config success.”);

} catch (Exception e) {

log.error(“http sync strategy refresh config error!”, e);

}

}, syncInterval, syncInterval, TimeUnit.MILLISECONDS);

log.info(“http sync strategy refresh interval: {}ms”, syncInterval);

}

private void refreshLocalCache() {

this.updateAppAuthCache();

this.updatePluginCache();

this.updateRuleCache();

this.updateSelectorCache();

this.updateMetaDataCache();

}

//最终调用的更新cache的方法

protected void updateCache(final ConfigGroupEnum group, final List data) {

String json = GsonUtils.getInstance().toJson(data);

ConfigDataCache newVal = new ConfigDataCache(group.name(), json, Md5Utils.md5(json), System.currentTimeMillis());

ConfigDataCache oldVal = CACHE.put(newVal.getGroup(), newVal);

log.info(“update config cache[{}], old: {}, updated: {}”, group, oldVal, newVal);

}

当定时任务更新配置数据之后，md5的值会改变，无论doLongPolling()方法中开启异步响应http请求之前或是60s内没有事件触发配置变更LongPollingClient返回响应其中都会调用compareChangedGroup()方法，判断一下缓存中md5的值是否被改变，其实就是针对定时任务更新配置数据时，也能返回哪个Group的数据发生了变更

private List compareChangedGroup(final HttpServletRequest request) {

List changedGroup = new ArrayList<>(ConfigGroupEnum.values().length);

for (ConfigGroupEnum group : ConfigGroupEnum.values()) {

// md5,lastModifyTime

String[] params = StringUtils.split(request.getParameter(group.name()), ‘,’);

if (params == null || params.length != 2) {

throw new SoulException(“group param invalid:” + request.getParameter(group.name()));

}

String clientMd5 = params[0];

long clientModifyTime = NumberUtils.toLong(params[1]);

ConfigDataCache serverCache = CACHE.get(group.name());

// do check.