参考nacos配置中心机制，实现前后端业务长轮询功能

已于 2023-04-23 13:51:41 修改
阅读量416 收藏
点赞数
分类专栏： HomeHomi脚手架 文章标签： java ui servlet
于 2023-04-23 13:50:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36382225/article/details/130317917
版权

思路

  1. 基于订阅发布，实现事件监听。创建通知中心，在通知中心注册事件推送者，绑定事件监听者与事件推送者
  2. 创建数据变更推送者线程，在线程中推送发布事件，放入队列，在线程启动后自旋获取队列中的事件，获取事件后通知监听者执行事件回调；如果队列满了，直接通知当前事件的所有监听者
  3. 创建数据变更监听器，传递事件监听事件，在事件中会包含业务数据
  4. 创建长连接调度线程池，核心线程数为1即可，线程内逻辑执行速度很快，没有必要创建更多线程
  5. 长连接上下文处理器单例化，只要用来存储当前等待的客户端长连接
  6. 客户端请求服务端，服务端hold住线程，可以基于Servlet的AsyncContext或者spring的DeferredResult。将客户端线程构造成长连接线程，调度线程池启动线程
  7. 在线程中做两件事，一是将当前线程对象放入长连接队列，二是再次通过调度线程池在延迟之后单次执行调度任务，当到达延迟时间之后，默认响应给客户端，比如nacos中默认客户端与服务端的请求间隔是30s，那么服务端如果没有事件变更，在29.5s的时候会响应给客户端
  8. 当有事件变更的时候，事件监听器接收到事件，会通过长连接上下文处理器获取所有客户端长连接线程任务，判断线程任务的Topic和接收到的事件topic是否相同，如果相同的话，基于长连接任务完成AsyncContext响应

代码

通知中心

public class NotifyCenter {

    private static Map<String, EventPusher> pusherMap = new ConcurrentHashMap<>();
    public static int DEFAULT_QUEUE_SIZE = 16384;

    private static EventPusherFactory DEFAULT_EVENT_PUSHER_FACTORY = (event, queueMaxSize) -> {
        EventPusher push = new ThreadEventPusher();
        push.init(event, queueMaxSize);
        return push;
    };

    public static void registerPublish(final Class<? extends Event> event, EventPusher eventPusher) {
        synchronized (NotifyCenter.class) {
            pusherMap.putIfAbsent(event.getCanonicalName(), eventPusher);
        }
    }

    public static EventPusher registerPublish(final Class<? extends Event> event) {
        return registerPublish(event, DEFAULT_EVENT_PUSHER_FACTORY, DEFAULT_QUEUE_SIZE);
    }

    public static EventPusher registerPublish(final Class<? extends Event> event, int queueMaxSize) {
        return registerPublish(event, DEFAULT_EVENT_PUSHER_FACTORY, queueMaxSize);
    }

    public static EventPusher registerPublish(final Class<? extends Event> event, EventPusherFactory eventPusherFactory, int queueMaxSize) {
        synchronized (NotifyCenter.class) {
            MapUtil.computeIfAbsent(pusherMap, event.getCanonicalName(), eventPusherFactory, event, queueMaxSize);
        }
        return pusherMap.get(event.getCanonicalName());
    }

    public static void registerSubscribe(final EventSubscriber subscriber, Class<? extends Event> eventType) {
        EventPusher eventPusher = registerPublish(eventType, DEFAULT_QUEUE_SIZE);
        eventPusher.addSubscriber(subscriber);

    }


}

抽象事件

public abstract class Event implements Serializable {

    private static final AtomicLong SEQUENCE = new AtomicLong(0);

    private final long sequence = SEQUENCE.getAndIncrement();

    /**
     * Event sequence number, which can be used to handle the sequence of events.
     *
     * @return sequence num, It's best to make sure it's monotone.
     */
    public long sequence() {
        return sequence;
    }


}

数据改变事件

public class LocalDataChangeEvent extends Event {
    
    private TopicContext topicContext;

    public LocalDataChangeEvent(TopicContext topicContext) {
        this.topicContext = topicContext;
    }

    public TopicContext getTopicContext() {
        return topicContext;
    }
}

事件推送者接口

public interface EventPusher extends Closeable {

    /**
     * Initializes the event publisher.
     *
     * @param type       {@link Event >}
     * @param bufferSize Message staging queue size
     */
    void init(Class<? extends Event> type, int bufferSize);

    /**
     * The number of currently staged events.
     *
     * @return event size
     */
    long currentEventSize();

    /**
     * Add listener.
     *
     * @param subscriber {@link EventSubscriber}
     * @return
     */
    void addSubscriber(EventSubscriber subscriber);

    /**
     * Remove listener.
     *
     * @param subscriber {@link EventSubscriber}
     */
    void removeSubscriber(EventSubscriber subscriber);

    /**
     * publish event.
     *
     * @param event {@link Event}
     * @return publish event is success
     */
    boolean publish(Event event);

    /**
     * Notify listener.
     *
     * @param subscriber {@link EventSubscriber}
     * @param event      {@link Event}
     */
    void notifySubscriber(EventSubscriber subscriber, Event event);

}


public interface Closeable {
    
    /**
     * Shutdown the Resources, such as Thread Pool.
     *
     */
    void shutdown();
    
}

事件推送者工厂

用于生成事件推送者

public interface EventPusherFactory extends BiFunction<Class<? extends Event>, Integer, EventPusher> {

}

事件推送者线程

@Slf4j
public class ThreadEventPusher extends Thread implements EventPusher {

    private volatile boolean shutdown = false;
    private volatile boolean initialized = false;
    private Class<? extends Event> eventType;
    private int queueMaxSize = -1;
    protected final ConcurrentHashSet<EventSubscriber> subscribers = new ConcurrentHashSet<>();
    private BlockingQueue<Event> queue;

    @Override
    public void init(Class<? extends Event> type, int bufferSize) {
        setDaemon(true);
        setName("Event Publisher <" + type.getSimpleName() + ">");
        this.eventType = type;
        this.queueMaxSize = bufferSize;
        this.queue = new ArrayBlockingQueue<>(bufferSize);
        start();
    }

    @Override
    public synchronized void start() {
        if (!initialized) {
            // start just called once
            super.start();
            initialized = true;
            log.info("Event Pusher {} , 绑定 Event <{}> 初始化", this.getClass().getSimpleName(), eventType.getSimpleName());
        }
    }

    @Override
    public long currentEventSize() {
        return 0;
    }

    @Override
    public void addSubscriber(EventSubscriber subscriber) {
        subscribers.add(subscriber);
    }

    @Override
    public void removeSubscriber(EventSubscriber subscriber) {
        subscribers.remove(subscriber);
    }

    @Override
    public boolean publish(Event event) {
        checkIsStart();
        if (!event.getClass().isAssignableFrom(eventType)) {
            throw new RuntimeException("发布失败，event类型不匹配");
        }
        boolean success = this.queue.offer(event);
        if (!success) {
            log.warn("Unable to plug in due to interruption, synchronize sending time, event : {}", event);
            log.warn("Event [{}] , 队列长度超过限制", event);
            receiveEvent(event);
            return true;
        }
        return true;
    }

    private void checkIsStart() {
        if (!initialized) {
            throw new IllegalStateException("Publisher does not start");
        }
    }

    @Override
    public void notifySubscriber(EventSubscriber subscriber, Event event) {
        subscriber.onEvent(event);
    }

    @Override
    public void shutdown() {
        shutdown = true;
    }

    @Override
    public void run() {
        openEventHandler();
    }

    void openEventHandler() {
        try {
            // This variable is defined to resolve the problem which message overstock in the queue.
            int waitTimes = 60;
            // To ensure that messages are not lost, enable EventHandler when
            // waiting for the first Subscriber to register
            for (; ; ) {
                if (shutdown || hasSubscriber() || waitTimes <= 0) {
                    break;
                }
                ThreadUtil.sleep(1000L);
                waitTimes--;
            }

            for (; ; ) {
                if (shutdown) {
                    break;
                }
                final Event event = queue.take();
                log.info("event - [{}] receive , thread - [{}]", eventType.getSimpleName(), Thread.currentThread().getName());
                receiveEvent(event);
            }
        } catch (Throwable ex) {
            log.error("Event listener exception : ", ex);
        }
    }

    private void receiveEvent(Event event) {
        for (EventSubscriber subscriber : subscribers) {
            notifySubscriber(subscriber, event);
        }
    }

    private boolean hasSubscriber() {
        return CollectionUtil.isNotEmpty(subscribers);
    }
}

事件监听器接口

public interface EventSubscriber<T extends Event> {

    void onEvent(T t);

}

数据改变事件监听器

public class LocalDataChangeSubscriber implements EventSubscriber<LocalDataChangeEvent> {

    private final LongPollingHandler longPollingService;

    public LocalDataChangeSubscriber(LongPollingHandler longPollingService) {
        this.longPollingService = longPollingService;
    }

    @Override
    public void onEvent(LocalDataChangeEvent localDataChangeEvent) {
        Queue<ClientLongPollingContext.ClientLongPollingTask> allClientTask = ClientLongPollingContext.getInstance().getAllClientTask();
        allClientTask.iterator().forEachRemaining(n -> {
            TopicContext topicContext = localDataChangeEvent.getTopicContext();
            if (StrUtil.equals(topicContext.topic(), n.getTopicContext().topic())) {
                n.sendResponse(false);
            }
        });

    }
}

客户端长轮询上下文

@Slf4j
public class ClientLongPollingContext {

    /**
     * 当前长连接线程
     */
    private final Queue<ClientLongPollingTask> allClientTask;

    /**
     * 长连接超时时间
     */
    private final int overtime;

    private ClientLongPollingContext() {
        allClientTask = new ConcurrentLinkedQueue<>();
        overtime = 15;
    }

    private static class Singleton {
        private static final ClientLongPollingContext INSTANCE = new ClientLongPollingContext();
    }

    public static ClientLongPollingContext getInstance() {
        return Singleton.INSTANCE;
    }

    public ClientLongPollingTask instanceTask(TopicContext topicContext, AsyncContext asyncContext, LongPollingHandler longPollingHandler) {
        return new ClientLongPollingTask(topicContext, asyncContext, longPollingHandler);
    }

    public Queue<ClientLongPollingTask> getAllClientTask() {
        return allClientTask;
    }

    public class ClientLongPollingTask implements Runnable {

        final TopicContext topicContext;
        final AsyncContext asyncContext;
        final LongPollingHandler longPollingHandler;
        Future<?> asyncTimeoutFuture;

        public ClientLongPollingTask(TopicContext topicContext, AsyncContext asyncContext, LongPollingHandler longPollingHandler) {
            this.topicContext = topicContext;
            this.asyncContext = asyncContext;
            this.longPollingHandler = longPollingHandler;
        }

        @Override
        public void run() {
            asyncTimeoutFuture = ExecutorFactory.scheduleLongPolling(() -> {
                System.out.println("超时回调");
                sendResponse(true);
            }, overtime, TimeUnit.SECONDS);
            allClientTask.add(this);
        }

        public void sendResponse(boolean isTimeout) {
            // 取消超时任务
            if (null != asyncTimeoutFuture) {
                asyncTimeoutFuture.cancel(false);
            }
            generateResponse(isTimeout);
            allClientTask.remove(this);
        }

        private void generateResponse(boolean isTimeout) {
            HttpServletResponse response = (HttpServletResponse) asyncContext.getResponse();
            try {
                // Disable cache.
                response.setHeader("Pragma", "no-cache");
                response.setDateHeader("Expires", 0);
                response.setHeader("Cache-Control", "no-cache,no-store");
                response.setStatus(HttpServletResponse.SC_OK);
                response.setContentType(topicContext.responseContentType());
                String responseContext;
                if(isTimeout){
                    responseContext = topicContext.timeoutResponseContext();
                }else{
                    responseContext = topicContext.responseContext();
                }
                response.getWriter().println(responseContext);
            } catch (Exception ex) {
                log.error(ex.toString(), ex);
            } finally {
                longPollingHandler.removeTopicCache(topicContext.topic());
                asyncContext.complete();
            }
        }

        public AsyncContext getAsyncContext() {
            return asyncContext;
        }

        public TopicContext getTopicContext() {
            return topicContext;
        }
    }


}

状态线程

用于监听当前连接数

public class StatTask implements Runnable {

    private final LongPollingHandler longPollingService;

    public StatTask(LongPollingHandler longPollingService) {
        this.longPollingService = longPollingService;
    }

    @Override
    public void run() {
        System.out.println("[long-polling] client count " + ClientLongPollingContext.getInstance().getAllClientTask().size());
    }
}

抽象业务主题

public abstract class TopicContext {

    /**
     * 业务主题，唯一
     *
     * @return
     */
    public abstract String topic();

    /**
     * 正确响应内容
     *
     * @return
     */
    public abstract String responseContext();

    /**
     * 超时响应内容
     *
     * @return
     */
    public abstract String timeoutResponseContext();

    /**
     * 响应ContentType
     *
     * @return
     */
    public String responseContentType() {
        return MediaType.APPLICATION_JSON_UTF8_VALUE;
    }

    private String mdc;

    public TopicContext() {
        mdc = MDC.get(LogConstant.TRACE_ID);
    }

    public String getMdc() {
        return mdc;
    }
}

长轮询处理器

public class LongPollingHandler {

    public Map<String, TopicContext> topicContextCache = new ConcurrentHashMap<>();

    public LongPollingHandler() {
        ExecutorFactory.scheduleLongPolling(new StatTask(this), 0L, 10L, TimeUnit.SECONDS);
        NotifyCenter.registerPublish(LocalDataChangeEvent.class);
        NotifyCenter.registerSubscribe(new LocalDataChangeSubscriber(this), LocalDataChangeEvent.class);
    }

    public void executeLongPolling(TopicContext topicContext) {
        HttpServletRequest request = WebUtil.getRequest();
        AsyncContext asyncContext = request.startAsync();
        topicContextCache.putIfAbsent(topicContext.topic(), topicContext);
        ExecutorFactory.executeLongPolling(ClientLongPollingContext.getInstance().instanceTask(topicContext, asyncContext, this));
    }

    public void publishDataChangeEvent(String topic) {
        TopicContext topicContext = topicContextCache.get(topic);
        if (topicContext == null) {
            return;
        }
        LocalDataChangeEvent localDataChangeEvent = new LocalDataChangeEvent(topicContext);
        EventPusher eventPusher = NotifyCenter.registerPublish(LocalDataChangeEvent.class);
        eventPusher.publish(localDataChangeEvent);
    }

    public void removeTopicCache(String topic) {
        topicContextCache.remove(topic);
    }
}

线程工厂

public class ExecutorFactory {

    private static final ScheduledExecutorService LONG_POLLING_EXECUTOR = Executors.newScheduledThreadPool(1, new NameThreadFactory("LongPollingTest"));

    public static void executeLongPolling(Runnable runnable) {
        LONG_POLLING_EXECUTOR.execute(runnable);
    }

    public static void scheduleLongPolling(Runnable runnable, long initialDelay, long period, TimeUnit unit) {
        LONG_POLLING_EXECUTOR.scheduleWithFixedDelay(runnable, initialDelay, period, unit);
    }

    public static ScheduledFuture<?> scheduleLongPolling(Runnable runnable, long period, TimeUnit unit) {
        return LONG_POLLING_EXECUTOR.schedule(runnable, period, unit);
    }
}

public class NameThreadFactory implements ThreadFactory {
    
    private final AtomicInteger id = new AtomicInteger(0);
    
    private String name;
    
    public NameThreadFactory(String name) {
        if (!name.endsWith(StrUtil.DOT)) {
            name += StrUtil.DOT;
        }
        this.name = name;
    }
    
    @Override
    public Thread newThread(Runnable r) {
        String threadName = name + id.getAndIncrement();
        Thread thread = new Thread(r, threadName);
        thread.setDaemon(true);
        return thread;
    }
}

调用controller

@RestController
@RequestMapping("long-polling")
public class LongPollingController {

    @Autowired
    private LongPollingHandler longPollingHandler;

    @RequestMapping(value = "/start")
    public void start(@RequestParam String id) {
        TopicContext topicContext = new TopicContext() {
            @Override
            public String topic() {
                return id;
            }

            @Override
            public String responseContext() {
                return "ok";
            }

            @Override
            public String timeoutResponseContext() {
                return "timeout";
            }
        };
        longPollingHandler.executeLongPolling(topicContext);
    }

    @RequestMapping(value = "/change")
    public void change(@RequestParam String id) {
        longPollingHandler.publishDataChangeEvent(id);
    }
}
Ledison7
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Nacos1.x配置中心客户端长轮询原理
endwas
01-23 2217
nacos1.x配置中心巧妙的长轮询设计
Nacos 和 Apollo中的 长轮询 定时机制，太好用了~
JavaShark的博客
07-14 575
今天这篇文章来介绍一下Nacos配置中心的原理之一：长轮询机制的应用为方便理解与表达，这里把 Nacos 控制台和 Nacos 注册中心称为 Nacos 服务器（就是 web 界面那个），我们编写的业务服务称为 Nacso 客户端；Nacos 动态监听的长轮询机制原理图，本篇将围绕这张图剖析长轮询定时机制的原理：ConfigService 是 Nacos 客户端提供的用于访问实现配置中心基本操作的类，我们将从 ConfigService 的实例化开始长轮询定时机制的源码之旅；我们从NacosProperty
Nacos的长轮询实践
sunquan291的专栏
09-19 1774
Nacos长轮询的基本思路是通过Servlet3.0后提供的异步处理能力,把请求的任务添加至队列中,在有数据发生变更时,从队列中取出相应请求,然后响应请求,负责拉取数据的接口通过延时任务完成超时处理,如果等到设定的超时时间还没有数据变更时,就主动推送超时信息完成响应。关于心跳检测参考：https://blog.csdn.net/sunquan291/article/details/126556366。
长轮询解决方案
热门推荐
chszs的专栏
06-21 1万+
长轮询解决方案作者：chszs，转载需注明。博客主页：http://blog.csdn.net/chszs长轮询适合浏览器的Chat聊天、股票行情显示、股票状态更新、体育直播的结果显示等。当然，不是所有的例子都是对延迟很敏感的，但它们的需求都比较相似。 在标准的HTTP请求响应语义中，浏览器发起请求，服务器发送一个响应，这意味着在浏览器发起新请求前，服务器不能发送新信息给客户端浏览器。有几种解决方法
SpringCloud Alibaba——Nacos1.x配置中心长轮询机制
小志的博客
07-15 499
SpringCloud Alibaba——Nacos1.x配置中心长轮询机制
Nacos配置中心原理分析
02-24
动态配置管理是Nacos的三大功能之一，通过动态配置服务，我们可以在所有环境中以集中和动态的方式管理所有应用程序或服务的配置信息。动态配置中心可以实现配置更新时无需重新部署应用程序和服务即可使相应的配置...
nacos配置中心配置.docx
11-28
Nacos配置中心提供了强大的一些配置管理功能，例如配置的版本控制、配置的历史记录和配置的回滚等。要在Nacos配置中心中添加配置，需要在控制台中点击“添加配置”按钮，然后填写配置的名称、描述信息和配置的内容。...
Nacos配置中心使用说明（图解）.docx
01-12
Nacos配置中心使用说明（图解）
nacos配置中心初始化案例
10-31
nacos配置中心初始化案例
【前端41_实时消息】实现方式：前端轮询、后端轮询（SSE）、Websocket、socket.io
Lovely Ruby 的手账
07-02 3624
文章目录目标前端轮询后端轮询：SSE踩坑static 文件夹下的 index.htmlasync awaitform 按钮阻止页面刷新koa-body 目标 目标是做一个实时聊天的工具 前端轮询 实现这个目标的话，可以有多种思路，比较低级的做法就是前端来不断的发送请求给后端 后端轮询：SSE 全称 server send event 客户端不断的发送数据，建立长链接 踩坑 static 文件夹下的 index.html 如果你在 static 文件夹下 有 index.html 的话，那么当你在浏览器
Nacos 的 长轮询 定时机制，太好用了！
最新发布
竹林幽深
12-20 167
不才陈某 码猿技术专栏 2023-12-20 08:45 发表于浙江大家好，我是不才陈某~前面两篇文章介绍了Nacos的基础、注册中心的原理，如下：五十五张图告诉你微服务的灵魂摆渡者Nacos究竟有多强？从实现原理来讲，Nacos 为什么这么强？今天这篇文章来介绍一下Nacos配置中心的原理之一：长轮询机制的应用为方便理解与表达，这里把 Nacos 控制台和 Nacos 注册中心称为 Nacos 服务器（就是 web 界面那个），我们编写的业务服务称为 Nacso 客户端；Nacos 动态监听的长轮询机制原
nacos 负载均衡ribbon 轮询策略 权重2种方式
weixin_42023748的博客
09-19 1259
nacos轮询修改
搭建单机 nacos 负载均衡ribbon 轮询策略 权重2种方式
just_learing的博客
06-28 1337
搭建单机 nacos 负载均衡ribbon 轮询策略 权重2种方式
前后端正确轮询的姿势，看你用的第几种方式
点滴
07-08 2432
轮训，提到之后大家想必都不陌生，不是那么实时，每隔一段时间就拉取一下数据。 如果对实时性要求高可能就需要建立socket（websocket）连接 每隔10秒获取一下数据 第一种： function fetchData() { axios.get(url).then(ctrlmethod); setTimeout(fetchData, 10*1000) } fetchData() 第...
Nacos 配置中心之长轮询--服务端
qq_40708942的博客
12-14 823
先回顾一下客户端和服务端交互的过程。
nacos作为配置中心使用的长轮询是怎么一回事及长轮询重要源码解读
weixin_41758726的博客
04-06 2828
配置中心和客户端(我们自己的业务工程)实现配置的动态感知一般无外乎两种办法，一种是客户端主动发起pull模式，或者配置中心发起push。 1.nacos作为配置中心和客户端是通过客户端主动发起的pull模式，但是这不是单纯的pull，是一个httppost的长轮询，过期时间默认是30S，什么意思呢，客户端发起一个http请求发给配置中心，配置中心接到了请求那一刻如果正好配置有变化就立即返回变化后的...
Nacos 配置中心之长轮询--客户端
qq_40708942的博客
12-13 687
先来看下长轮询调用的链路。
接口耗时太久怎么办？适当用点Future做异步~
java小白翻身
04-30 1008
在JS中，各种回调函数漫天飞，写的代码基本都是异步的，需要靠某个event去trigger。比如点击事件，就是最常见的。但是Java里面做异步就得绕好几弯，还不一定行，需要各种判断和校验，生怕出错。 异步执行的好处是显而易见的，比如某个接口需要查好几张表，调很多方法，其中有几个方法是非常耗时的。但是很多代码的做法还是同步的，传统的顺序执行。优点是可读性强，不容易出错。 假如A方法耗时特别长的话，那么整合接口的返回就会很慢。 比如，现在有一个服务，非常耗时。 class AccountServi
nacos配置中心实现原理
09-06
Nacos配置中心实现原理主要分为两个方面：配置的存储和配置的发布与订阅。 1. 配置的存储：Nacos使用数据库来存储配置信息。可以选择使用MySQL、Oracle等关系型数据库，也可以选择使用Nacos内置的嵌入式数据库Derby。配置信息以键值对的形式存储在数据库中，包括配置的命名空间、配置的分组、配置的数据等。 2. 配置的发布与订阅：Nacos采用观察者模式实现配置的发布与订阅。当配置发生变化时，Nacos会通知所有订阅该配置的客户端。客户端可以通过订阅配置来实时获取最新的配置信息。Nacos还支持多种方式的配置推送，包括HTTP长轮询、DNS解析和基于MQTT协议等。 总结起来，Nacos配置中心实现原理就是通过存储配置信息到数据库，并通过发布与订阅机制实现实时更新和获取配置信息。这样可以提高系统的可维护性和灵活性，方便进行配置的管理和调整。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值