SprinngBoot下集成webSock的几种方式

已于 2023-05-12 11:44:37 修改
阅读量395 收藏
点赞数
文章标签： kafka java websocket
于 2022-05-12 13:57:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40708522/article/details/124729576
版权

SprinngBoot下集成webSock的几种方式

基于kafka配置推送

package cn.microvideo.flowac.sys.util;

import cn.microvideo.flowac.sys.entity.LocalSysMsgForWSBean;
import cn.microvideo.flowac.sys.entity.WSMsgModuleEnum;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;

/**
 * @Description: WS工具类
 * @Author: xuwz
 * @Date: 2021/8/5 9:29
 */
@Component
public class WebSocketUtil {

    private static WebSocketUtil instance;

    // TODO 暂时使用kafkaOne对象，后续可能会更改为系统自己的kafka
    @Resource(name = "kafkaOneTemplate")
    private KafkaTemplate<String, Object> kafkaTemplate;
    @Value("${localSysMessageForWSTopic}")
    private String localSysMessageForWSTopic;

    /**
     * @Description 初始化
     * @Author xuwz
     * @Date 2021/8/5 19:45
     */
    @PostConstruct
    public void init() {
        instance = this;
    }

    /**
     * @Description 向全部连接发送
     * @Author xuwz
     * @Date 2021/8/5 20:24
     */
    public static void sendForWS(Object message, WSMsgModuleEnum moduleEnum) {
        LocalSysMsgForWSBean bean = createBean(message, moduleEnum, 0);
        instance.kafkaTemplate.send(instance.localSysMessageForWSTopic, GsonUtil.toJson(bean));
    }

    /**
     * @Description 向指定unit发送
     * @Author xuwz
     * @Date 2021/8/5 20:24
     */
    public static void sendForWSByUnit(Object message, WSMsgModuleEnum moduleEnum, String unitCode) {
        LocalSysMsgForWSBean bean = createBean(message, moduleEnum, 1);
        bean.setUnitCode(unitCode);
        instance.kafkaTemplate.send(instance.localSysMessageForWSTopic, GsonUtil.toJson(bean));
    }

    /**
     * @Description 向指定用户发送
     * @Author xuwz
     * @Date 2021/8/5 20:25
     */
    public static void sendForWSByUser(Object message, WSMsgModuleEnum moduleEnum, String userId) {
        LocalSysMsgForWSBean bean = createBean(message, moduleEnum, 2);
        bean.setUserId(userId);
        instance.kafkaTemplate.send(instance.localSysMessageForWSTopic, GsonUtil.toJson(bean));
    }

    /**
     * @Description 构建对象
     * @Author xuwz
     * @Date 2021/8/5 20:25
     */
    private static LocalSysMsgForWSBean createBean(Object message, WSMsgModuleEnum moduleEnum, Integer sendType) {
        LocalSysMsgForWSBean bean = new LocalSysMsgForWSBean();
        bean.setModule(moduleEnum.getModule());
        bean.setMessageType(moduleEnum.getMessageType());
        bean.setSendType(sendType);
        bean.setMessage(message);
        return bean;
    }

}

基于session配置推送

package com.microvideo.ewcp.configration;


import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.server.standard.ServerEndpointExporter;

/**
 * @Author:wlj
 * @Description:websocket配置类
 * @Date:2019-05-27
 */
@Configuration
public class WebSocketConfig {
	
	/**
	 * @Author:wlj
	 * @Description:获得服务端点提供者
	 * @Date:2019-05-27
	 */
    @Bean
    public ServerEndpointExporter serverEndpointExporter(){
        return new ServerEndpointExporter();
    }
}

package  com.microvideo.ewcp.configration;

import java.io.IOException;
import java.util.concurrent.CopyOnWriteArraySet;

import javax.websocket.OnClose;
import javax.websocket.OnError;
import javax.websocket.OnMessage;
import javax.websocket.OnOpen;
import javax.websocket.Session;
import javax.websocket.server.PathParam;
import javax.websocket.server.ServerEndpoint;

import org.springframework.stereotype.Component;

/**
 * @Author: wlj
 * @Description:websocket服务相关类
 * @Date:2019-05-31
 */
@Component
@ServerEndpoint("/websocket/{sid}/{rid}")
public class WebSocketServer {

	//静态变量，用来记录当前在线连接数。应该把它设计成线程安全的。
    private static int onlineCount = 0;
    
    //concurrent包的线程安全Set，用来存放每个客户端对应的MyWebSocket对象。
    private static CopyOnWriteArraySet<WebSocketServer> webSocketSet = new CopyOnWriteArraySet<WebSocketServer>();

    //与某个客户端的连接会话，需要通过它来给客户端发送数据
    private Session session;

    //接收sid
    private String sid="";

    public static final String event = "fk_centerid";//在线单位集合key

    /**
     * @Author: wlj
     * @Description:连接建立成功调用的方法
     * @Date:2019-05-31
     */
    @OnOpen
    public void onOpen(Session session,@PathParam("sid") String sid,@PathParam("rid") String rid) {
        this.session = session;
        webSocketSet.add(this);     //加入set中
        addOnlineCount();           //在线数加1
        this.sid=sid;
    }

    /**
     * @Author: wlj
     * @Description:连接关闭调用的方法
     * @Date:2019-05-31
     */
    @OnClose
    public void onClose(@PathParam("rid") String rid) {
        webSocketSet.remove(this);  //从set中删除
        subOnlineCount();           //在线数减1
    }

    /**
     * @Author: wlj
     * @Description:收到客户端消息后调用的方法
     * @Date:2019-05-31
     */
    @OnMessage
    public void onMessage(String message, Session session) {
        //群发消息
        for (WebSocketServer item : webSocketSet) {
            try {
                item.sendMessage(message);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * @Author: wlj
     * @Description:出现错误时调用的方法
     * @Date:2019-05-31
     */
    @OnError
    public void onError(Session session, Throwable error) {
        error.printStackTrace();
    }
    
    /**
     * @Author: wlj
     * @Description:服务端推送消息方法
     * @Date:2019-05-31
     */
    public void sendMessage(String message) throws IOException {
        this.session.getBasicRemote().sendText(message);
    }

    /**
     * @Author: wlj
     * @Description:群发自定义消息
     * @Date:2019-05-31
     */
    public static void sendInfo(String message,@PathParam("sid") String sid) throws IOException {
        for (WebSocketServer item : webSocketSet) {
            try {
            	//这里可以设定只推送给这个sid的，为null则全部推送
            	if(sid==null) {
            		item.sendMessage(message);
            	}else if(item.sid.equals(sid)){
            		item.sendMessage(message);
            	}
            } catch (IOException e) {
                continue;
            }
        }
    }

    /**
     * @Author: wlj
     * @Description:获得在线连接数
     * @Date:2019-05-31
     */
    public static synchronized int getOnlineCount() {
        return onlineCount;
    }

    /**
     * @Author: wlj
     * @Description:增加在线连接数
     * @Date:2019-05-31
     */
    public static synchronized void addOnlineCount() {
        WebSocketServer.onlineCount++;
    }

    /**
     * @Author: wlj
     * @Description:减少在线连接数
     * @Date:2019-05-31
     */
    public static synchronized void subOnlineCount() {
        WebSocketServer.onlineCount--;
    }
}

基于redis配置推送

package cn.microvideo.flowac.services.util;

import cn.microvideo.flowac.services.common.util.MicrovideoCommRedisRepository;
import cn.microvideo.flowac.services.wsmsg.entity.WsMsgDto;
import cn.microvideo.flowac.services.wsmsg.entity.WsMsgModuleEnum;
import cn.microvideo.flowac.services.wsmsg.entity.WsProjGroupEnum;
import cn.microvideo.flowac.services.wsmsg.entity.WsReceiveDto;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import java.util.concurrent.TimeUnit;

/**
 * @Description: websocketUtil
 * @Author: xuwz
 * @Date: 2023/3/3 16:46
 */
@Component
public class WebSocketUtil {

    private static WebSocketUtil instance;

    @Resource
    private MicrovideoCommRedisRepository redisUtil;

    @PostConstruct
    public void init() {
        instance = this;
    }

    /**
     * @description 发送给所有用户
     * @author xuwz
     * @date 2023/3/6 16:16
     */
    public static void sendToAll(WsProjGroupEnum projGroupEnum, WsMsgModuleEnum wsMsgModule, Object content) {

        WsMsgDto msgDto = new WsMsgDto();
        msgDto.setWsMsgModuleEnum(wsMsgModule);
        msgDto.setContext(content);

        WsReceiveDto receiveDto = new WsReceiveDto();
        receiveDto.setReceiveBodyType(0);
        receiveDto.setMsg(msgDto);

        instance.redisUtil.strLeftPush(projGroupEnum.getProjGroup(), receiveDto, TimeUnit.MINUTES.toMillis(5));
    }

    /**
     * @description 发送给指定单位
     * @author xuwz
     * @date 2023/3/6 16:16
     */
    public static void sendToDept(WsProjGroupEnum projGroupEnum, WsMsgModuleEnum wsMsgModule, String deptId,
                                  Object content) {

        WsMsgDto msgDto = new WsMsgDto();
        msgDto.setWsMsgModuleEnum(wsMsgModule);
        msgDto.setContext(content);

        WsReceiveDto receiveDto = new WsReceiveDto();
        receiveDto.setReceiveBodyType(1);
        receiveDto.setReceiveBodyCode(deptId);
        receiveDto.setMsg(msgDto);

        instance.redisUtil.strLeftPush(projGroupEnum.getProjGroup(), receiveDto, TimeUnit.MINUTES.toMillis(5));
    }

    /**
     * @description 发送给指定用户
     * @author xuwz
     * @date 2023/3/6 16:16
     */
    public static void sendToUser(WsProjGroupEnum projGroupEnum, WsMsgModuleEnum wsMsgModule, String userId,
                                  Object content) {

        WsMsgDto msgDto = new WsMsgDto();
        msgDto.setWsMsgModuleEnum(wsMsgModule);
        msgDto.setContext(content);

        WsReceiveDto receiveDto = new WsReceiveDto();
        receiveDto.setReceiveBodyType(2);
        receiveDto.setReceiveBodyCode(userId);
        receiveDto.setMsg(msgDto);

        instance.redisUtil.strLeftPush(projGroupEnum.getProjGroup(), receiveDto, TimeUnit.MINUTES.toMillis(5));
    }
}


package cn.microvideo.flowac.equipment.websocket;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.socket.server.standard.ServerEndpointExporter;

/**
 * @Description: websocketConfig
 * @Author: xuwz
 * @Date: 2023/3/3 16:37
 */
@Configuration
public class WebSocketConfig {

    @Bean
    public ServerEndpointExporter serverEndpointExporter() {
        return new ServerEndpointExporter();
    }
}


package cn.microvideo.flowac.equipment.websocket;

import cn.microvideo.flowac.services.common.util.MicrovideoCommRedisRepository;
import cn.microvideo.flowac.services.wsmsg.entity.WsMsgDto;
import cn.microvideo.flowac.services.wsmsg.entity.WsProjGroupEnum;
import cn.microvideo.flowac.services.wsmsg.entity.WsReceiveDto;
import cn.microvideo.framework.core.util.json.MicrovideoJsonUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;

/**
 * @Description: ws消息发送handle
 * @Author: xuwz
 * @Date: 2023/3/14 13:53
 */
@Slf4j
@Component
public class WebSocketSendHandle {

    @Resource
    private MicrovideoCommRedisRepository redisUtil;

    /**
     * @description 初始化
     * @author xuwz
     * @date 2023/3/14 13:54
     */
    @PostConstruct
    public void init() {

        try {
            new Thread(new WebSocketSendHandleC()).start();
        } catch (Exception e) {
            log.error("", e);
        }
    }

    private class WebSocketSendHandleC implements Runnable {

        /**
         * When an object implementing interface <code>Runnable</code> is used
         * to create a thread, starting the thread causes the object's
         * <code>run</code> method to be called in that separately executing
         * thread.
         * <p>
         * The general contract of the method <code>run</code> is that it may
         * take any action whatsoever.
         *
         * @see Thread#run()
         */
        @Override
        public void run() {

            log.info("【WebSocketSendHandle】已初始化完成...");

            while (true) {
                try {
                    Thread.sleep(50);
                    String msgStr = redisUtil.strRigthPop(WsProjGroupEnum.WS_EQUIP_PROJ_GROUP.getProjGroup());
                    if (StringUtils.isEmpty(msgStr)) {
                        continue;
                    }

                    WsReceiveDto wsReceiveDto = MicrovideoJsonUtil.parseObject(msgStr, WsReceiveDto.class);
                    WsMsgDto wsMsgDto = wsReceiveDto.getMsg();
                    String wsMsgStr = MicrovideoJsonUtil.toJSONString(wsMsgDto);
                    Integer receiveBodyType = wsReceiveDto.getReceiveBodyType();
                    String receiveBodyCode = wsReceiveDto.getReceiveBodyCode();

                    if (receiveBodyType == 0) {
                        WebSocketServer.sendMessageToAll(wsMsgStr);
                    } else if (receiveBodyType == 1 && !StringUtils.isEmpty(receiveBodyCode)) {
                        WebSocketServer.sendMessageToDept(wsMsgStr, receiveBodyCode);
                    } else if (receiveBodyType == 2 && !StringUtils.isEmpty(receiveBodyCode)) {
                        WebSocketServer.sendMessageToUser(wsMsgStr, receiveBodyCode);
                    }
                } catch (Exception e) {
                    log.error("", e);
                }
            }
        }
    }
}


package cn.microvideo.flowac.equipment.websocket;

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import javax.websocket.OnClose;
import javax.websocket.OnError;
import javax.websocket.OnMessage;
import javax.websocket.OnOpen;
import javax.websocket.Session;
import javax.websocket.server.PathParam;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;
import java.util.concurrent.CopyOnWriteArraySet;

/**
 * @Description: websoceketServer
 * @Author: xuwz
 * @Date: 2023/3/3 16:40
 */
@Component
@ServerEndpoint("/websocket/{deptId}/{userId}")
@Slf4j
public class WebSocketServer {

    private static final CopyOnWriteArraySet<WebSocketServer> WS_CONN_SET = new CopyOnWriteArraySet<>();
    private Session session;
    private String userId = "";
    private String deptId = "";

    @OnOpen
    public void onOpen(Session session, @PathParam("deptId") String deptId, @PathParam("userId") String userId) {
        this.session = session;
        this.deptId = deptId;
        this.userId = userId;
        WS_CONN_SET.add(this);
        log.info(">>>WEBSOCKET<<< userId={},sessionId={}, open connection", userId, session.getId());
    }

    @OnClose
    public void onClose() {
        log.info(">>>WEBSOCKET<<< userId={},sessionId={}, close connection", userId, session.getId());
    }

    @OnMessage
    public String onMessage(String message, Session session) {
        log.info(">>>WEBSOCKET<<< get userId={} sessionId={} message, context={}", userId, session.getId(), message);
        return "receive message success!!";
    }

    public static void sendMessageToAll(String message) {

        log.info("【WS_SEND TO ALL】content={}", message);
        for (WebSocketServer server : WS_CONN_SET) {
            try {
                server.sendMessage(message);
            } catch (IOException e) {
                log.error("", e);
            }
        }
    }

    public static void sendMessageToDept(String message, String deptId) {

        log.info("【WS_SEND TO DRPT】deptId={},content={}", deptId, message);
        for (WebSocketServer server : WS_CONN_SET) {
            try {
                if (!server.deptId.equals(deptId)) {
                    continue;
                }
                server.sendMessage(message);
            } catch (IOException e) {
                log.error("", e);
            }
        }
    }

    public static void sendMessageToUser(String message, String userId) {

        log.info("【WS_SEND TO USER】userId={},content={}", userId, message);
        for (WebSocketServer server : WS_CONN_SET) {
            try {
                if (!server.userId.equals(userId)) {
                    continue;
                }
                server.sendMessage(message);
            } catch (IOException e) {
                log.error("", e);
            }
        }
    }

    public void sendMessage(String message) throws IOException {
        if (session.isOpen()) {
            this.session.getBasicRemote().sendText(message);
        }
    }

    @OnError
    public void onError(Session session, Throwable error) {

        log.error(">>>WEBSOCKET<<< userId={},sessionId={}, connection error, exception={}", userId, session.getId(),
                error);
    }
}
种豆走天下
关注
springboot整合webSocket（看完即入门）
qq_48721706的博客
05-27 9万+
webSocket1、什么是webSocket？2、webSocket可以用来做什么?3、webSocket协议4、服务端WebSocket操作类5、客户端 1、什么是webSocket？ WebSocket是一种在单个TCP连接上进行全双工通信的协议。WebSocket使得客户端和服务器之间的数据交换变得更加简单，允许服务端主动向客户端推送数据。在WebSocket API中，浏览器和服务器只需要完成一次握手，两者之间就直接可以创建持久性的连接，并进行双向数据传输。 2、webSocket可以用来做什么
SpringBoot项目整合WebSocket几种方式
Shawn的个人博客
04-14 6716
SpringBoot项目整合WebSocket几种方式 一、WebSocket相关介绍 在线测试websocket网站：http://www.easyswoole.com/wstool.html 1、WebSocket基本概念 1.1 基本概念 基本概念原理这里就不细讲了，一查一大把，推荐大佬的这篇博客(偏代码实践一些)以及知乎的这篇高赞回答(偏寓教于乐一些)。需要重点说明的几点 Websocket作为标准的通信协议在Web C/S使用时，需要浏览器和Web服务容器的支持 Websocket依靠Http来
SpringBoot2.0集成WebSocket，实现后台向前端推送信息
热门推荐
★【World Of Moshow 郑锴】★
05-10 45万+
什么是WebSocket? - 初次接触 WebSocket 的人，都会问同样的问题：我们已经有了 HTTP 协议，为什么还需要另一个协议？它能带来什么好处？ - 答案很简单，因为 HTTP 协议有一个缺陷：***通信只能由客户端发起***，HTTP 协议做不到服务器主动向客户端推送信息。 https://github.com/moshowgame/spring-cloud-study/tree/master/spring-cloud-study-websocket
Springboot集成websocket
囚徒之困
05-23 4525
Springboot集成websocket
【Spring Boot】WebSocket 的 6 种集成方式
黑白法师的博客
06-21 5602
由于前段时间我实现了一个库【Spring Cloud】一个配置注解实现 WebSocket 集群方案以至于我对的各种集成方式做了一些研究目前我所了解到的就是下面这些了（就一个破ws都有这么多花里胡哨的集成方式了？）今天主要介绍一下前3种方式，毕竟现在的主流框架还是而后3种其实和并不强行绑定，基于就可以支持，不过我也会对后3种做个简单的介绍，大家先混个眼熟就行了那么接下来我们就来讲讲前3种方式 在中的服务端和客户端配置（客户端配置也超重要的有木有，平时用不到，用到了却基本找不到文档，这也太绝望了）......
springboot集成websocket的两种实现方式
huiyunfei的博客
05-31 8万+
WebSocket跟常规的http协议的区别和优缺点这里大概描述一下 一、websocket与http http协议是用在应用层的协议，他是基于tcp协议的，http协议建立链接也必须要有三次握手才能发送信息。http链接分为短链接，长链接，短链接是每次请求都要三次握手才能发送自己的信息。即每一个request对应一个response。长链接是在一定的期限内保持链接。保持TCP连接不断开。客...
【websocket】spring boot 集成 websocket 的四种方式
Wanankl的博客
04-27 3470
1. 原生注解 pom.xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-websocket</artifactId> </dependency> WebSocketConfig /* * * * * blog.coder4j.cn * * Copyright (C) 2016-20
springboot集成websocket
大爱仙尊
10-21 2万+
​ 这里我们使用springboot搭建一个轻量级的websocket服务，同时提供4个入参。使用websocket服务可以轻松和微信小程序、支付宝小程序、网页就行双向通讯，非常实用方便。wss地址这里是我们自己搭建的中转服务websocket地址。参数说明。
史上最简单的spring-boot集成websocket的实现方式
笨鸟不会飞
07-18 4004
在应用程序中你只需要几行代码就可以快速的构建websocket服务 简介 在应用程序中你只需要几行代码就可以快速的构建websocket服务，对的这个就是我编写websocket-spring-boot-starter的初衷，主要是写传统的websocket的实现方式感觉每次写起来都好麻烦，又找不到一个好的websocket与spring-boot集成的starter，那这样就自己写一个来用，大家在使用中遇到的BUG或者需求欢迎大家到https://github.com/lazyboyl/websock.
JAVA (Springboot) 集成WebSocket
weixin_47054648的博客
05-29 2343
WebSocket是一种在单个TCP连接上进行全双工通信的协议。它允许服务端主动向客户端推送数据，同时也允许客户端向服务器发送数据。WebSocket通信协议于2011年被IETF定为标准RFC 6455，并由RFC7936补充规范。WebSocket API也被W3C定为标准。
集成websocket实现实时通信.zip
12-19
在现代Web应用中，尤其是在需要实时更新、聊天、在线游戏或者股票交易等场景下，WebSocket成为了首选的通信方式。 在"集成WebSocket实现实时通信.zip"这个压缩包中，可能包含了一套关于如何在若依（RuoYi）前后端...
若依WebSocket集成
04-01
若依WebSocket的集成主要包括以下几个步骤： 1. **引入依赖**：首先，你需要在项目中添加WebSocket的相关依赖，通常包括Spring WebSocket库。如果是基于Maven的项目，可以在pom.xml中添加如下依赖： ```xml ...
Spring Boot 集成 WebSocket（原生注解与Spring封装方式）
09-29
在通过两种方式集成的过程中会摘取整体框架中的核心逻辑，简化代码实现过程，保留核心功能，例如：IOC、AOP、Bean生命周期、上下文、作用域、资源处理等内容实现。 适合人群：具备一定编程基础，工作1-3年的研发人员...
SpringBoot集成WebSocket实现前后端消息互传的方法
08-25
SpringBoot集成WebSocket实现前后端消息互传的方法是当前互联网技术中的一种常见的实现方式。WebSocket是一种基于TCP的网络协议，能够实现浏览器与服务器的全双工通信，允许服务器主动发送信息给客户端。 为什么...
SpringBoot集成WebSocket长连接实际应用详解
08-19
本文主要介绍了SpringBoot集成WebSocket长连接实际应用详解，通过示例代码详细介绍了WebSocket的应用场景和实现方式，对大家的学习或者工作具有一定的参考学习价值。 一、WebSocket概述 WebSocket是一种在单个TCP...
@KafkaListener注解
最新发布
jifgnie的博客
10-17 328
在 Spring Boot 中，使用 @KafkaListener 注解消费 Kafka 消息时，如果 service.save(cleanWikiSource) 抛出异常，消息不会被认为已经成功消费完毕。如果 service.save(cleanWikiSource) 抛出异常，Kafka 会自动将消息标记为未成功消费，并会重新尝试交付此消息（即消息会被重新消费）。如果配置了 max.poll.interval.ms 或 max.poll.records 等参数，可以控制消费者重试间隔和次数。
kafka自定义配置信息踩坑
an_gentle_killer的博客
10-16 237
org.apache.kafka.common.config.ConfigException: Invalid value 0 for configuration acks: Expected value to be a string, but it was a java.lang.Integer
使用Java API访问Apache Kafka
没刮胡子的程序员专栏
10-14 241
Kafka是由Apache软件基金会开发的一个开源流处理平台,Kafka是一个功能强大且灵活的平台。
Kafka-设计思想-2
lu070828的博客
10-16 1696
现在我们对生产者和消费者的工作方式有了一些了解，让我们讨论一下Kafka在生产者和消费者之间提供的语义保证。1、最多发送一次：会造成数据丢失2、至少发送一次：会造成数据重复消费3、只发送一次：我们想要的效果Kafka默认采用2，但允许用户通过在处理一批消息之前禁用生产者的重试并在消费者中提交偏移量来实现1想要达到第3点需要满足两点：1、生产者发布消息的持久性保证2、消费者使用消息的循序性保证期间可能出现的现象有：1、生产者和消费者可能挂掉2、多个消费者消费情况。
Tomcat 7.0集成WebSocket实战教程
"Tomcat 7.0 集成WebSocket简单示例" WebSocket技术是HTML5的一个重要特性，它提供了一种在Web应用程序中实现客户端与服务器之间双向、实时通信的机制，克服了传统HTTP协议的请求-响应模式中服务器不能主动推送数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值