websocket+kafka+springcloud+springboot实现报文（json）传输，解析，推送

最新推荐文章于 2024-06-21 09:43:10 发布
最新推荐文章于 2024-06-21 09:43:10 发布
阅读量1.9k 收藏 12
点赞数
分类专栏： websocket 文章标签： websocket kafka springboot springcloud
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Xiao_Cai__/article/details/102801055
版权

介绍

服务端采集嵌入式设备发送的报文信息，做入库，部分报文处理后推送设备，校时推送，及后期扩展的业务操作。

简单说明

  1. 嵌入式设备和服务端采用websocket的通信方式。为什么选用websocket？我觉得主要原因是由于websockt的两个特点，第一是长连接，第二是服务端可以主动向客户端发起推送。实际的业务场景也正是设备需要一直向服务端发送数据，而服务端需要判断某些报文后来做推送。
  2. 设备首先要经过认证服务
  3. 服务端目前分为两块，数据采集服务和数据处理服务。
    数据解析服务主要的作用是接收设备侧的报文，生产至kafka。从kafka消费需要推送的报文，推送至设备。
  4. 为什么要做两个服务，中间再加一层kafka。首先将采集和处理分开能更利于以后的扩展开发，符合解耦的设计，其次考虑到公司内部其他服务也需要获取这部分数据时，可以直接和kafka对接。我理解的也是扩展把。

服务架构

在这里插入图片描述

业务流程说明

  1. 设备向认证服务发送post请求，携带设备认证信息。
  2. 认证服务校验设备信息正确否，不正确直接拒绝。正确则判断有哪些可用的数据采集服务，随机产生一个可用的采集网关信息。采集网关启动时会向认证服务发送其ip，port，path。
  3. 认证服务拿到可达的采集网关服务信息后再生产一个token一块给设备返回
  4. 设备拿着获取到的采集网关信息发送websocket请求，
  5. 采集网关接收到请求后会向认证服务发送token，ip，path
  6. 认证服务校验token，ip，port的一致性。这里之所以要再次向认证服务校验是来确保认设备只能连接证服务指定的采集网关服务。发送服务需要在建立连接之前。
  7. 响应给采集网关校验结果
  8. 结果ok，设备向采集网关发送报文，简单处理后发送至kafka
  9. 解析服务处理 进行一系列业务处理
  10. 将需要响应的报文发送至kafka的另一个topic
  11. 采集网关监听到kafka数据口推送至指定的session

技术点或实现思路

如何服务启动发送请求？

package com.ptl.gatewaydatacollection.rest;

import com.bbap.feignServer.feign.FeignServer;
import com.bbap.feignServer.models.FeignRequest;
import com.bbap.feignServer.models.FeignResp;
import com.bsa.bbap.log.BbapLog;
import com.ptl.gatewaydatacollection.models.GatewayInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

import java.net.Inet4Address;

/**
 * @Description 数据采集网关启动后向认证服务发送配置信息
 * @Author twt
 * @Version V1.0.0
 * @Since 1.0
 * @Date 2019/10/15
 */
@Component
public class StartService implements CommandLineRunner {

    //@Autowired
    //private AuthFeign authFeign;

    @Autowired
    private FeignServer feignServer;

    @Value("${server.port}")
    private String port;

    @Value("${info.service.name}")
    private String serviceName;

    @Autowired
    private BbapLog log;

    @Autowired
    private AuthFeignService authFeignService;

    @Override
    public void run(String... strings)  {
        System.out.println("数据采集网关启动后执行。。。");
        log.debug("数据采集网关启动后执行。。。");
        try {
            String hostAddress = Inet4Address.getLocalHost().getHostAddress();
            System.out.println("ip：" + hostAddress);
            System.out.println("port：" + port);
            GatewayInfo gatewayInfo = new GatewayInfo();
            gatewayInfo.setService_name(serviceName);
            gatewayInfo.setIp(hostAddress);
            gatewayInfo.setPort(port);
            gatewayInfo.setPath("/websocket");

            FeignRequest feignRequest = new FeignRequest();
            feignRequest.setService_name(serviceName);
            feignRequest.setIp(hostAddress);
            feignRequest.setPort(port);
            feignRequest.setPath("/websocket");
            FeignResp feignResp = feignServer.sendGateWayInfo(feignRequest);
            System.out.println("返回状态："+feignResp.getStatus());
            System.out.println("返回信息："+feignResp.getMsg());
            log.info("返回状态："+feignResp.getStatus());
            log.info("返回信息："+feignResp.getMsg());
        } catch (Exception e) {
            log.error("数据采集网关配置信息发送失败",e);
            System.out.println("数据采集网关配置信息发送失败");
            e.printStackTrace();
        }

    }
}
  • 发送请求是通过springcloud中的feign组件来实现，这里对feign组件做了简单封装

采集网关可能有很多节点，如何选择一个可达的节点？

 /**
     * 随机选择所有网关节点中的一个可达节点
     *
     * @param gatewayInfos
     * @return
     */
    private GatewayInfo getGatewayinfo(List<GatewayInfo> gatewayInfos) {
        int size = gatewayInfos.size();
        int nextInt = new Random().nextInt(size);//产生0到size-1的随机索引
        GatewayInfo gatewayInfo = gatewayInfos.get(nextInt);
        while (!util.isSurvive(gatewayInfo.getIp(), gatewayInfo.getPort())) {//判断随机的网关ip，port可达否
            gatewayInfos.remove(nextInt);
            return gatewayInfos.size() > 0 ? getGatewayinfo(gatewayInfos) : null;
        }
        return gatewayInfo;
    }
  • 这里提供一个随机的思路，当然也有轮询
/**
     * 指定ip和端口是否可达
     *
     * @param ip
     * @param port
     * @return
     */
    public  boolean isSurvive(String ip, String port) {
        Socket socket = new Socket();
        try {
            socket.connect(new InetSocketAddress(ip, Integer.parseInt(port)), 3000);
        } catch (SocketTimeoutException s) {
            log.error("指定的ip和端口不可达", s);
            s.printStackTrace();
            return false;
        } catch (IOException e) {
            log.error("指定的ip和端口不可达", e);
            e.printStackTrace();
            return false;
        } catch (Exception e) {
            log.error("指定的ip和端口不可达", e);
            e.printStackTrace();
            return false;
        } finally {
            try {
                if (socket != null) {
                    socket.close();
                }
            }
            catch (IOException e) {
                log.error("关闭socket异常", e);
                e.printStackTrace();
            }
            catch (Exception e) {
                log.error("关闭socket异常", e);
                e.printStackTrace();
            }
        }
        return true;
    }
  • springcloud中有健康度检查的接口，试过但是不太好用，应该是没找到正确的姿势，有用过的小伙伴可以分享哈

websockt服务端如何开发？客户端可以使用在线测试工具

package com.ptl.gatewaydatacollection.websocket;

import com.ptl.gatewaydatacollection.interceptor.AnnualInspectionInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import org.springframework.web.socket.WebSocketHandler;
import org.springframework.web.socket.config.annotation.EnableWebSocket;
import org.springframework.web.socket.config.annotation.WebSocketConfigurer;
import org.springframework.web.socket.config.annotation.WebSocketHandlerRegistry;
import org.springframework.web.socket.server.HandshakeInterceptor;

/**
 * @Description
 * @Author twt
 * @Version V1.0.0
 * @Since 1.0
 * @Date 2019/10/16
 */
@Configuration
@EnableWebMvc
@EnableWebSocket
public class WebsocketConfig extends WebMvcConfigurerAdapter implements WebSocketConfigurer {


    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry webSocketHandlerRegistry) {
        webSocketHandlerRegistry.addHandler(myHandler(), "/websocket").addInterceptors(interceptor())
                .setAllowedOrigins("*");
    }

    @Bean
    public WebSocketHandler myHandler() {
        return new AnnualInspectionHandler();
    }

    @Bean
    public HandshakeInterceptor interceptor() {
        return new AnnualInspectionInterceptor();
    }
}
  • 如果有多个websocket请求，可以多次调用addHandler和addInterceptors，拦截器不是必须项，setAllowedOrigins设置允许访问的来源，个人理解是同源策略问题
package com.ptl.gatewaydatacollection.interceptor;

import com.bbap.feignServer.models.FeignResp;
import com.bsa.bbap.log.BbapLog;
import com.google.gson.Gson;
import com.ptl.gatewaydatacollection.rest.AuthFeignService;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.http.server.ServletServerHttpRequest;
import org.springframework.web.socket.WebSocketHandler;
import org.springframework.web.socket.server.support.HttpSessionHandshakeInterceptor;

import javax.servlet.http.HttpServletRequest;
import java.util.Map;

/**
 * @Description
 * @Author twt
 * @Version V1.0.0
 * @Since 1.0
 * @Date 2019/10/16
 */
public class AnnualInspectionInterceptor extends HttpSessionHandshakeInterceptor {

    //@Autowired
    //AuthFeign authFeign;

    @Autowired
    private AuthFeignService authFeignService;

    @Autowired
    private BbapLog log;

    @Autowired
    private Gson gson;


    /**
     * 握手之前调用       校验token，ip，port
     * @param request
     * @param response
     * @param wsHandler
     * @param attributes
     * @return
     */
    @Override
    public boolean beforeHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler
            wsHandler, Map<String, Object> attributes)  {
        System.out.println("连接前进行处理...");
        log.debug("连接前进行处理...");
        HttpServletRequest servletRequest = ((ServletServerHttpRequest) request).getServletRequest();
        String token = servletRequest.getHeader("token");
        //token="536d81d3-b556-4354-9117-5b631395a8bd";
        if (StringUtils.isEmpty(token)){
            System.out.println("token为空...");
            log.info("token为空...");
            return false;
        }
        FeignResp result = authFeignService.checkTokenAndIPPort(token);
        boolean status = result.getStatus();
        System.out.println("token校验状态:"+status);
        log.info("token校验状态:"+status);
        attributes.put("eToken",token);//TODO 替换为token，该设备的本次请求对应的token
        return status;
        //return super.beforeHandshake(request, response, wsHandler, attributes);
    }


    /**
     * 握手后调用
     * @param request
     * @param response
     * @param wsHandler
     * @param ex
     */
    @Override
    public void afterHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler,
                               Exception ex) {
        System.out.println("连接后进行处理...");
        log.debug("连接后进行处理...");
        super.afterHandshake(request, response, wsHandler, ex);
    }
}
  • 拦截器，建立连接前可以自定义一些操作，简单可以理解为aop的前置处理器，也可以实现HandshakeInterceptor接口，不过子类肯定更强大点
    在这里插入图片描述
package com.ptl.gatewaydatacollection.websocket;

import com.bsa.bbap.log.BbapLog;
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import com.ptl.gatewaydatacollection.models.WebSocketMsg;
import com.ptl.gatewaydatacollection.utils.KafkaSend;
import org.apache.commons.lang.StringUtils;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.web.socket.CloseStatus;
import org.springframework.web.socket.TextMessage;
import org.springframework.web.socket.WebSocketSession;
import org.springframework.web.socket.handler.TextWebSocketHandler;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * @Description
 * @Author twt
 * @Version V1.0.0
 * @Since 1.0
 * @Date 2019/10/16
 */
public class AnnualInspectionHandler extends TextWebSocketHandler {

    @Autowired
    private Gson gson;

    private static AtomicInteger onlineCount = new AtomicInteger(0);//统计session在线数量

    //token@sessionID和session对应,每次新连接的token有可能一样，不同节点的sessionID有可能一样
    private static final Map<String, WebSocketSession> tokenSessionIDToSession = new ConcurrentHashMap<>();

    @Autowired
    private KafkaSend kafkaSend;

    @Autowired
    private BbapLog log;


    /**
     * 推送处理后的消息至设备
     *
     * @param record
     */
    @KafkaListener(topics = "${topic.processedQueue}")
    public void pushProcessedData(ConsumerRecord<?, ?> record) {
        Optional<?> kafkaMessage = Optional.ofNullable(record.value());
        if (kafkaMessage.isPresent()) {
            Object message = kafkaMessage.get();
            String pushMsg = message.toString();
            System.out.println("接收到需要推送的消息：" + pushMsg);
            log.debug("接收到需要推送的消息：" + pushMsg);
            Map<String, WebSocketMsg> socketMsgMap = gson.fromJson(pushMsg, new TypeToken<Map<String, WebSocketMsg>>() {
            }.getType());
            Set<Map.Entry<String, WebSocketMsg>> entrySet = socketMsgMap.entrySet();
            for (Map.Entry<String, WebSocketMsg> msgEntry : entrySet) {
                String tokenSessionID = msgEntry.getKey();
                WebSocketMsg responseMsg = msgEntry.getValue();
                String pushToSession = gson.toJson(responseMsg);
                //根据kafka的tokenSessionID推送到指定的session
                if (tokenSessionIDToSession.containsKey(tokenSessionID)) {
                    WebSocketSession session = tokenSessionIDToSession.get(tokenSessionID);
                    pushMsgToOnlySession(session, pushToSession);
                }

                //校时推送至所有设备
                if ("checkTimeToAllSession".equals(tokenSessionID)) {
                    pushMsgToAllDevice(pushToSession);
                }


            }
        } else {
            log.debug("要推送的消息为空...");
            System.out.println("要推送的消息为空...");
        }
    }

    /**
     * 推送消息至所有设备session
     *
     * @param msg
     */
    private void pushMsgToAllDevice(String msg) {
        Set<Map.Entry<String, WebSocketSession>> entries = tokenSessionIDToSession.entrySet();
        for (Map.Entry<String, WebSocketSession> entry : entries) {
            WebSocketSession session = entry.getValue();
            try {
                session.sendMessage(new TextMessage(msg));
                log.debug("推送" + msg + "至所有设备session成功");
                System.out.println("推送" + msg + "至所有设备session成功");
            } catch (IOException e) {
                log.debug("推送" + msg + "至所有设备session失败");
                log.error("推送失败",e);
                System.out.println("推送" + msg + "至所有设备session失败");
                e.printStackTrace();
            }
        }
    }

    /**
     * 推送消息至指定session
     *
     * @param socketSession
     * @param msg
     */
    private void pushMsgToOnlySession(WebSocketSession socketSession, String msg) {
        try {
            if (socketSession != null) {
                socketSession.sendMessage(new TextMessage(msg));
                log.debug("推送" + msg + "成功");
                System.out.println("推送" + msg + "成功");
            }
        } catch (IOException e) {
            log.debug("推送" + msg + "成功");
            log.error("推送失败",e);
            System.out.println("推送" + msg + "成功");
            e.printStackTrace();
        }
    }


    /**
     * 建立连接
     *
     * @param session
     * @throws Exception
     */
    @Override
    public void afterConnectionEstablished(WebSocketSession session) throws Exception {
        log.debug("建立连接...");
        System.out.println("建立连接...");
        String eToken = session.getAttributes().get("eToken").toString();
        if (StringUtils.isNotBlank(eToken)) {
            tokenSessionIDToSession.put(eToken + "@" + session.getId(), session);
            int onlineNum = addOnlineCount();
            log.debug("连接建立，当前在线数：" + onlineNum);
            System.out.println("连接建立，当前在线数：" + onlineNum);
            System.out.println(tokenSessionIDToSession);
        }

       /* while (true){
            session.sendMessage(new TextMessage("123"));
            Thread.sleep(3000);
        }*/
        super.afterConnectionEstablished(session);
    }


    /**
     * 接收数据 发送至kafka
     *
     * @param session
     * @param message
     * @throws Exception
     */
    @Override
    protected void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception {
        String eData = message.getPayload();
        String eToken = session.getAttributes().get("eToken").toString();
        Map<String, WebSocketMsg> socketMsgMap = new HashMap<>();
        log.debug("接收到设备数据：" + eData);
        System.out.println("接收到设备数据：" + eData);
        WebSocketMsg socketMsg = gson.fromJson(eData, WebSocketMsg.class);
        String receiveData = gson.toJson(socketMsg);
        log.debug("转换后的数据：" + receiveData);
        System.out.println("转换后的数据：" + receiveData);
        socketMsgMap.put(eToken + "@" + session.getId(), socketMsg);//将接收的消息和eToken+"@"+sessionID绑定，因为数据采集网关某个节点可能接入多台设备
        kafkaSend.sendToOriginQueue(gson.toJson(socketMsgMap));//将绑定后的消息放入kafka
    }


    /**
     * 连接关闭
     *
     * @param session
     * @param status
     * @throws Exception
     */
    @Override
    public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception {
        log.debug("连接关闭...");
        System.out.println("连接关闭...");
        String eToken = session.getAttributes().get("eToken").toString();
        System.out.println(eToken);
        tokenSessionIDToSession.remove(eToken + "@" + session.getId());
        int onlineNum = subOnlineCount();
        log.debug("关闭连接,当前在线数：" + onlineNum);
        System.out.println("关闭连接,当前在线数：" + onlineNum);
        log.info(status.toString());
        super.afterConnectionClosed(session, status);

    }


    /**
     * 传输中断
     *
     * @param session
     * @param exception
     * @throws Exception
     */
    @Override
    public void handleTransportError(WebSocketSession session, Throwable exception) throws Exception {
        log.debug("传输中断...");
        System.out.println("传输中断...");
        String eToken = session.getAttributes().get("eToken").toString();
        tokenSessionIDToSession.remove(eToken + "@" + session.getId());
        int onlineNum = subOnlineCount();
        log.debug("中断传输,当前在线数：" + onlineNum);
        System.out.println("中断传输,当前在线数：" + onlineNum);
        log.info(exception.toString());
        super.handleTransportError(session, exception);
        /*if (session.isOpen()) {
            session.close();
        }*/

    }


    @Override
    public boolean supportsPartialMessages() {
        return super.supportsPartialMessages();
    }

    private int addOnlineCount() {
        return onlineCount.incrementAndGet() < 0 ? 0 : onlineCount.get();//在线数不能为负数
    }

    private int subOnlineCount() {
        return onlineCount.decrementAndGet() < 0 ? 0 : onlineCount.get();//在线数不能为负数
    }
}
  • handleTextMessage方法中session指本次会话，message为接收到的数据。推送调用session的sendMessage方法就可以向客户端发送数据

策略模式的使用

  • 报文有action字段，每个报文对应的action不一样，需要根据不同的报文来进行不同的业务处理，所以需要定义一个数据结构可以来接收所有不同类型的报文

接收报文的数据结构

package com.ptl.gatewaydataanalysis.models.websocket;


public class WebSocketMsg<T> {
	private Integer type;// 表示消息类型
	private String id;// 请求唯一 id，格式：其中 ‘xxx’为自增数值从 001~999，且不需要随时间变化而重置，
	private Integer action;// 请求含义
	private String des;// 信息描述
	private T data;// 详细数据		响应数据也存在这里

	public Integer getType() {
		return type;
	}

	public void setType(Integer type) {
		this.type = type;
	}

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}

	public Integer getAction() {
		return action;
	}

	public void setAction(Integer action) {
		this.action = action;
	}

	public String getDes() {
		return des;
	}

	public void setDes(String des) {
		this.des = des;
	}

	public T getData() {
		return data;
	}

	public void setData(T data) {
		this.data = data;
	}
}

不同的报文可以进入不同的业务类

  • 定义一个接口，每个业务类来实现
package com.ptl.gatewaydataanalysis.action;


import com.ptl.gatewaydataanalysis.models.websocket.WebSocketMsg;

public interface MsgAction {

	/**
	 * 处理websocket收到的数据，返回结果给客户端设备
	 * @param sessionIdToken
	 * @param webSocketMsg
	 * @return
	 */
	WebSocketMsg call(String sessionIdToken,String webSocketMsg);
}
  • ApplicationContext ，可以根据beanName来获取对象
package com.ptl.gatewaydataanalysis.utils;

import com.ptl.gatewaydataanalysis.action.MsgAction;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

@Component
public class SpringUtil implements ApplicationContextAware {

	private static ApplicationContext applicationContext;

	@Override
	public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
		if (SpringUtil.applicationContext == null) {
			SpringUtil.applicationContext = applicationContext;
		}
	}

	public static ApplicationContext getApplicationContext() {
		return applicationContext;
	}

	public static Object getBean(String name) {
		return getApplicationContext().getBean(name);
	}

	/**
	 * 通过action的字段值，获取相应的处理bean
	 * 
	 * @param name
	 * @return
	 */
	public static MsgAction getBeanToMsgAction(String name) {
		try {
			MsgAction msg = (MsgAction) getApplicationContext().getBean(name);
			return msg;
		} catch (Exception e) {
			return null;
		}

	}

	public static <T> T getBean(Class<T> clazz) {
		return getApplicationContext().getBean(clazz);
	}

	public static <T> T getBean(String name, Class<T> clazz) {
		return getApplicationContext().getBean(name, clazz);
	}

}
  • Action为定义的枚举，建立报文中action和beanName（chargeAndDisChargeProAction）的对应关系。被@Component(“chargeAndDisChargeProAction”)修饰的类（业务类）实现MsgAction接口。这样就可以根据不同的报文处理不同的业务
WebSocketMsg socketMsg = entry.getValue();//报文数据
                String action = Action.getAction(socketMsg.getAction()).getDescript();
                String beanName = action == null ? "errorAction" : action;//action不存在，引入ErrorAction类
                MsgAction msgAction = SpringUtil.getBeanToMsgAction(beanName);
                if (msgAction != null) {
                    WebSocketMsg responseMsg = msgAction.call(sessionIdToken, gson.toJson(socketMsg));//根据action来处理不同的业务
                }

kafka分片

  • 这次需求考虑到kafka可能需要分片来来提高数据吞吐量，但是由于目前数据解析服务是单击环境，而且分片后无法保证报文传输的顺序。所以使用默认的一个topic对应一个partition。

代码

思考

  • 关于websocket，kafka的使用，欢迎大家提建议
mrtang121
关注
专栏目录
Spring Boot进阶(49)：实时通信不再是梦想，SpringBoot+WebSocket助你轻松实现前后端即时通讯！
**My Coding Family**
06-15 2121
SpringBoot之集成WebSocket实现前后端通信 ，实战教学，一文带你搞定。
SpringBoot整合WebSocket，最新教程，细到极致
gubeichengxuyuan的博客
04-12 4992
大家好鸭，最近在和第三方做数据对接，老哥需要整个WebSocket发送数据。我当时在想，为什么不用kafka呢，或者其他消息中间件。emm…，这个不深究了 下面，我们用Springboot 2.6.4 整合Websocet 1、导入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-star
SpringCloud Alibaba整合WebSocket
博客井底的咕嘟蛙
08-30 967
SpringCloud Alibaba整合weSocket
SpringCloud Gateway 集成 WebSocket服务
热门推荐
weixin_40261814的博客
01-27 1万+
作为一名程序员，工作也7、8年了，这是我第一次写文章，实在是惭愧。之前因工作需要一直都是百度、google，而没有想过静下心来自己研究原理、源码，导致现在还是一只菜鸟。。。 好了。言归正传，本次实践的话是基于nacos作为配置、注册中心的，各位大佬可以去了解一下nacos的官网，虽然最近这个组件爆出了漏洞，但不可否认其功能还真的是很强大的，附上官网地址：https://nacos.io/zh-cn/ 项目使用jdk1.8进行开发。使用maven做jar包管理，分了很多模块子项目，包括基础服务的commo
探秘Spring Cloud WebSocket集群：高性能实时通信解决方案
最新发布
gitblog_00042的博客
06-21 471
探秘Spring Cloud WebSocket集群：高性能实时通信解决方案 项目地址:https://gitcode.com/Lonor/websocket-cluster WebSocket，作为一种在Web上实现全双工通信的协议，已经广泛应用于实时数据传输，如聊天应用、在线游戏、股票交易等场景。如今，随着微服务架构的发展，如何在分布式环境下优雅地实现WebSocket成了开发者关注的重要议题...
Springboot+WebSocket+Kafka（写着玩的）
weixin_34059951的博客
07-12 748
闹着玩的来源：前台发送消息，后台接受处理发给kafka，kafka消费者接到消息传给前台显示。联想到websocket。 最终效果如图： 页面解释： 不填写内容的话，表单值默认为Topic、Greeting、Name 点击订阅，按钮变黑 Send Topic 广播 前台显示前缀：T-You Send Subscribe Topic 订阅广播 前台显示前缀...
Spring Cloud整合Websocket（SockJs Stomp方式）
船长灬普朗克的博客
10-20 7265
目录一、服务端配置1、引入依赖包2、编写Config类进行websocket的配置3、编写拦截器WebSocketInterceptor4、编写消息的接收和发送的Controller二、客户端配置1、引入SockJS以及stompjs2、编写公用的websocket.js供其他地方调用3、业务代码中引用websocket进行消息发送和接收三、Spring cloud gateway网关配置1、修改gateway网关的配置文件2、在网关中添加全局过滤器四、前端代理的配置五、问题记录 一、服务端配置 整个服务端
SpringCloud微服务整合websocket
qq_40996015的博客
10-10 2226
可以通过网关路径连接websocket。
kafka netty_惠而浦：使用Netty和Kafka的微服务
最佳 Java 编程
06-27 2588
kafka netty 介绍 在上一个博客中 ，我介绍了Netty用作Web服务器。 该示例运行良好……只要需要广播服务器即可。 大多数情况下不是很有用。 更有可能的是，每个客户端仅接收针对其的数据，并保留了特殊情况下的广播，例如“服务器在15分钟内停机！” 关于该特定服务器示例的另一件事是，一切都是独立的。 例如，单片应用程序很好，但是在当今环境中，分布式微服务要好得多。 可伸缩性和可靠...
这个疯子整理的十万字Java面试题汇总，终于拿下40W offer！（JDK源码+微服务合集+并发编程+性能优化合集+
m0_67401134的博客
07-23 2372
Spring框架是一个为Java应用程序的开发提供了综合、广泛的基础性支持的Java平台。Spring帮助开发者解决了开发中基础性的问题,使得开发人员可以专注于应用程序的开发。Spring框架本身亦是按照设计模式精心打造,这使得我们可以在开发环境中安心的集成Spring框架,不必担心Spring是如何在后台进行工作的。Spring框架至今已集成了20多个模块。这些模块主要被分如下图所示的核心容器、数据访问/集成,、Web、AOP(面向切面编程)、工具、消息和测试模块。...
报文交换中的数据包格式与协议
# 第一章：报文交换简介 1.1 什么是报文交换 1.2 报文交换的重要性 1.3 报文交换的基本原理 ## 第二章：数据包格式 数据包格式在报文交换中起着至关重要的作用，它决定了数据在网络中的传输方式和结构。本章将...
详解Spring Cloud微服务架构下的WebSocket解决方案
08-26
主要介绍了详解Spring Cloud微服务架构下的WebSocket解决方案，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
springcloud实现gate网关转发功能和整合websocket源码
04-25
通过三个服务（eureka注册中心，gateway网关，userservice普通服务）,实现gateway网关转发服务，并且整合websocket
spring-boot-kafka-websocket:Spring Boot Kafka Websocket演示
04-28
项目介绍 一个例子，使用 spring boot 构建一个应用，从 kafka 队列中获取要推送的内容，通过`websocket`将内容推送到`web`端。 项目依赖安装 项目依赖 kafka zookeeper zookeeper 安装 解压， 进入 conf 将 zoo_sample.cfg 重命名为 zoo.cfg 编辑 zoo.cfg， 指定 dataDir 运行 cmd, 进入 bin`目录，输入`zkServer.cmd，启动 zookeeper. kafka 安装 解压 运行 cmd, 输入 输入bin\windows\kafka-server-start.bat config\server.properties，启动 kafka 测试: 运行以下命令 kafka-topics.bat --create --zookeeper localhost:2181 --replica
SpringCloud——集成WebSocket，实现站内系统通知
哈哈书架
04-12 2309
目录 前言 实现 1、pom文件引入包 2、WebSocketConfig.java 3、后端给前端发送系统信息 4、发消息接口 5、前端接收/发送消息 6、例子 前言 WebSocket 是 HTML5 开始提供的一种在单个 TCP 连接上进行全双工通讯的协议。 WebSocket 使得客户端和服务器之间的数据交换变得更加简单，允许服务端主动向客户端推送数据。在 WebSocket API 中，浏览器和服务器只需要完成一次握手，两者之间就直接可以创建持久性的连接，并进行双向数据传输.
SpringCloud集成WEBSOCKET实现即时通讯
蜗牛学院重庆校区的博客
07-11 5144
SpringCloud集成WEBSOCKET实现即时通讯 在传统的web应用中，服务器只能在收到客户端的请求以后对该请求进行响应，这种机制对于信息变化不是特别频繁的应用尚能相安无事。但是在一些交互性比较强或者是数据变动频繁的项目中，某些业务需要服务器主动的向客户端推送一些信息，例如：在线游戏、在线的证券交易、在电商网站中订单状态发生变化，在网页中动态的提示用户、OA系统中下级单位向经理提交一次报销单，主管的主界面上会同时出现一条待办事项等等。要处理这种业务传统的请求-响应模式就显得力不从心， 这时一般的
SpringCloud整合WebSocket和rabbitMQ
冬山兄的博客
11-02 460
在springcloud项目中，实现api对外的高频简单数据实时刷新。
springcloud集成websocket异常处理（javax.ws.rs.ClientErrorException.validate(Ljavax/ws/rs/core/Response;Lja）
sunfragrence的博客
03-07 3920
平台使用的是springcloud框架，后为了和APP实现消息推送，继承了websocket。 但是后台日志经常经常打印如下日志： 2019-03-07 14:04:00.235 [http-nio-8950-exec-7] ERROR o.a.c.c.C.[Tomcat].[localhost].[/].[CXFServlet] - Servlet.service() for se...
springboot、cloud整合websocket
weixin_61240867的博客
06-13 1042
话不多说，直接上代码：1.首先创建websocket的配置类2.创建websocket核心服务这样其实就已经可以连接了，但在实际运用中，会出现一种情况，如图：状态码明明显示的200，但却连接之后却立即断掉了，此时很有可能是被某个过滤器拦截掉，我查看了自己项目中的过滤器，发现都放行了，却在下一步直接断开；在过滤器与websocket服务之间只有一个，那就是用户认证。所以我先将websocket的认证给关掉。如图：我用的是spring-security的配置连接成功。
SpringBoot+WebSocket+Netty消息推送实战教程
"本文主要探讨如何使用SpringBoot、WebSocket和Netty来实现消息推送功能，提供了详细的示例代码，适用于学习或工作中的参考。" 在实际的Web开发中，实时通信是一个重要的需求，例如在线聊天、股票更新或者通知推送...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值