WebSocket零基础极速上手开发指南

已于 2023-01-13 15:43:50 修改
阅读量613 收藏 1
点赞数
文章标签： websocket spring boot java
于 2023-01-13 15:42:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huangtenglong/article/details/128674790
版权

一、WebSocket后台配置

1、添加依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-websocket</artifactId>
</dependency>

2、WebSocket配置类 WebSocketConfig.java

package com.service.websocket.config;

import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.web.socket.server.standard.ServerEndpointExporter;

/**
 * Websocket 配置
 */
@Configuration
@Slf4j
public class WebsocketConfig implements WebMvcConfigurer {

  //服务器支持跨域
  @Override
  public void addCorsMappings(CorsRegistry registry) {
    registry.addMapping("/**").allowedOrigins("*")
        .allowedMethods("GET", "POST","OPTIONS").allowedHeaders("*")
        .exposedHeaders("Access-Control-Allow-Headers",
            "Access-Control-Allow-Methods",
            "Access-Control-Allow-Origin",
            "Access-Control-Max-Age",
            "X-Frame-Options")
        .allowCredentials(false).maxAge(3600);
  }

  /** 注入ServerEndpointExporter，这个bean会自动注册使用了@ServerEndpoint注解声明的Websocket endpoint 。
   * 要注意，如果使用独立的servlet容器，而不是直接使用springboot的内置容器，就不要注入ServerEndpointExporter，
   * 因为它将由容器自己提供和管理。在Spring中可以直接使用Java WebSocket API来提供服务，如果使用内置的web容器，需要做的仅仅是需要在下面添加
   * */
  @Bean
  public ServerEndpointExporter serverEndpointExporter() {
    return new ServerEndpointExporter();
  }

}

3、WebSocket服务 Server

package com.service.websocket.server;

import cn.gooday.jsh.service.common.dto.RestControllerResult;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import javax.websocket.EndpointConfig;
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 jsh.mg.msg.service.websocket.dto.WebsocketParamsDto;
import jsh.mg.msg.service.websocket.util.HttpUtils;
import jsh.mg.msg.service.websocket.util.RedisUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * websocket服务器
 */
@Component
@ServerEndpoint("/socket/{serialNumber}")
@Slf4j
public class WebsocketServer {

  private static final Logger logger = LoggerFactory.getLogger(WebsocketServer.class);

  //静态变量，用来记录当前在线连接数。应该把它设计成线程安全的。
  private static int onlineCount = 0;
  //concurrent包的线程安全Set，用来存放每个客户端对应的MyWebSocket对象。若要实现服务端与单一客户端通信的话，可以使用Map来存放，其中Key可以为用户标识
  public static ConcurrentHashMap<String, WebsocketServer> webSocketMap =
      new ConcurrentHashMap<String, WebsocketServer>();
  //与某个客户端的连接会话，需要通过它来给客户端发送数据
  private Session session;
  private String callBackUrl;

  private static String PREX_STRING = "STRING_";
  private static String PREX_BINARY = "BINARY_";
  private static long EXPIRE_TIME = 604800; //过期时间7天

  @Autowired
  private RedisUtil redisUtil;

  /**
   * 连接成功后调用的方法
   * @param session  可选的参数。session为与某个客户端的连接会话，需要通过它来给客户端发送数据
   */
  @OnOpen
  public void onOpen(@PathParam(value = "serialNumber") String serialNumber, Session session, EndpointConfig config) {
    this.session = session;

    String queryString = session.getQueryString();
    log.info("session.getQueryString()" + queryString);
    if (StringUtils.isNotBlank(queryString) && queryString.contains("url=")) {
      this.callBackUrl = queryString.replace("url=", "");
    }
    webSocketMap.put(serialNumber, this) ;

    //在线数加1
    addOnlineCount();
    log.info("当前有连接" + serialNumber + "加入！当前在线人数为" + getOnlineCount());
  }

  /**
   * 连接关闭调用方法
   */
  @OnClose
  public void onClose(@PathParam(value = "serialNumber") String serialNumber) {
    if (StringUtils.isNotBlank(serialNumber)) {
      log.info("WebsocketServer.onClose() is begin, serialNumber is " + serialNumber);
      webSocketMap.remove(serialNumber);
      //在线数减1
      subOnlineCount();
    }
  }

  /**
   * 连接异常
   */
  @OnError
  public void onError(@PathParam(value = "serialNumber") String serialNumber, Throwable error) {
    log.info("连接异常: serialNumber is " + serialNumber + ",error is " + error.getMessage());
  }

  /**
   * 接收到客户短消息
   */
  @OnMessage
  public void onMessage(@PathParam(value = "serialNumber") String serialNumber, String message) {
    try {
      if (!isOnline(serialNumber)) {
        return ;
      }
      WebsocketServer websocketServer = webSocketMap.get(serialNumber) ;
      HttpUtils.sendPost(websocketServer.callBackUrl, message);
    } catch (Exception e) {
      log.info(e.getMessage());
      return ;
    }

    return ;
  }

  public RestControllerResult<Boolean> checkExist(String serialNumber) {
    RestControllerResult<Boolean> result =  new RestControllerResult<Boolean>();
    if (!isExist(serialNumber)) {
      result.setData(false);
      result.setErrorMsg("请求的链接:" + serialNumber + "不在该服务器上");
      return result;
    }
    result.setData(true);
    return result;
  }

  public RestControllerResult<Boolean> checkOnline(String serialNumber) {
    RestControllerResult<Boolean> result =  new RestControllerResult<Boolean>();
    if (!isOnline(serialNumber)) {
      result.setData(false);
      result.setErrorMsg("请求的链接:" + serialNumber + "不在线");
      return result;
    }
    result.setData(true);
    return result;
  }


  public RestControllerResult<Boolean> checkOfflineMessage(String serialNumber) {
    RestControllerResult<Boolean> result =  new RestControllerResult<Boolean>();

    if (!isOnline(serialNumber)) {
      result.setData(false);
      result.setErrorMsg("请求的链接:" + serialNumber + "不在线");
      return result;
    }
    List<String> messageList = (List<String>)redisUtil.get(PREX_STRING + serialNumber);
    List<ByteBuffer> binaryList = (List<ByteBuffer>)redisUtil.get(PREX_BINARY + serialNumber);

    if ((null == messageList || messageList.size() < 1) && (null == binaryList || binaryList.size() < 1)) {
      result.setData(false);
    } else {
      result.setData(true);
    }
    return result;
  }

  public RestControllerResult<Boolean> pullOfflineMessage(String serialNumber, Boolean isAsync, Boolean flag) {
    RestControllerResult<Boolean> result =  new RestControllerResult<Boolean>();
    try {
      if (!isOnline(serialNumber)) {
        result.setData(false);
        result.setErrorMsg("请求的链接:" + serialNumber + "不在线");
        return result;
      }
      WebsocketServer websocketServer = webSocketMap.get(serialNumber) ;

      List<String> messageList = (List<String>)redisUtil.get(PREX_STRING + serialNumber);
      if (null != messageList && messageList.size() > 0 ) {
        Boolean isSuccess = false;
        if (!isAsync) {
          isSuccess = sendBasicMessage(websocketServer.session, messageList, flag);
        } else {
          isSuccess = sendAsyncMessage(websocketServer.session, messageList);
        }
        if (isSuccess) {
          redisUtil.delete(PREX_STRING + serialNumber);
        }
      }

      List<ByteBuffer> binaryList = (List<ByteBuffer>)redisUtil.get(PREX_BINARY + serialNumber);
      if (null != binaryList && binaryList.size() > 0 ) {
        Boolean isSuccess = false;
        if (!isAsync) {
          isSuccess = sendBasicBinaryMessage(websocketServer.session, binaryList, flag);
        } else {
          isSuccess = sendAsyncBinaryMessage(websocketServer.session, binaryList);
        }
        if (isSuccess) {
          redisUtil.delete(PREX_BINARY + serialNumber);
        }
      }
    } catch (IOException e) {
      log.info(e.getMessage());
      result.setData(false);
      result.setErrorMsg(e.getMessage());
      return result;
    }
    return result;
  }

  /**
   * 给所有人发消息
   */
  public RestControllerResult<Boolean>  sendToAll(WebsocketParamsDto paramsDto) {
    RestControllerResult<Boolean> result =  new RestControllerResult<Boolean>();
    //遍历HashMap
    for (String serialNumber : webSocketMap.keySet()) {
      try {
        if (paramsDto.getIsBinary()) {
          sendBasicBinaryMessage(webSocketMap.get(serialNumber).session, paramsDto.getBinaryData(), paramsDto.getFlag());
        } else {
          sendBasicMessage(webSocketMap.get(serialNumber).session, paramsDto.getMessage(), paramsDto.getFlag());
        }
      } catch (IOException e) {
        log.info(e.getMessage());

        if (paramsDto.getIsBinary()) {
          redisUtil.addToListRightExpire(PREX_STRING + serialNumber, EXPIRE_TIME, paramsDto.getMessage());
        } else {
          redisUtil.addToListRightExpire(PREX_BINARY + serialNumber, EXPIRE_TIME, paramsDto.getBinaryData());
        }
      }
    }

    result.setData(true);
    return result;
  }



  /**
   * 给指定的终端发送消息
   */
  public RestControllerResult<Boolean> sendToTerminal(WebsocketParamsDto paramsDto) {
    log.info("WebsocketServer.sendToSingle() is begin, serialNumber is " + paramsDto.getSerialNumber());
    RestControllerResult<Boolean> result =  new RestControllerResult<Boolean>();
    String toSerialNumber = paramsDto.getSerialNumber();
    try {
      if(!isOnline(toSerialNumber)) {
        result.setData(false);
        result.setErrorMsg("请求的链接:" + toSerialNumber + "不在该服务器上");
        log.info("请求的链接:" + toSerialNumber + "不在该服务器上");
        return result;
      }

      WebsocketServer websocketServer = webSocketMap.get(toSerialNumber) ;
      if (paramsDto.getIsBinary()) {
        sendBasicBinaryMessage(websocketServer.session, paramsDto.getBinaryData(), paramsDto.getFlag());
      } else {
        sendBasicMessage(websocketServer.session, paramsDto.getMessage(), paramsDto.getFlag());
      }
      result.setData(true);
    } catch (IOException e) {
      log.info(e.getMessage());

      if (paramsDto.getIsBinary()) {
        redisUtil.addToListRightExpire(PREX_STRING + toSerialNumber, EXPIRE_TIME, paramsDto.getMessage());
      } else {
        redisUtil.addToListRightExpire(PREX_BINARY + toSerialNumber, EXPIRE_TIME, paramsDto.getBinaryData());
      }
      result.setData(false);
      result.setErrorMsg("推送消息至链接:" + toSerialNumber + "时系统异常：" + e.getMessage());
      return result;
    }
    return result;
  }

  /**
   * 给所有人发消息
   */
  public RestControllerResult<Boolean> sendToTerminalList(WebsocketParamsDto paramsDto) {
    RestControllerResult<Boolean> result =  new RestControllerResult<Boolean>();
      List<String> terminalList = paramsDto.getSerialList();
      //遍历HashMap
      for (String serialNumber : terminalList) {
        try {
          if (paramsDto.getIsBinary()) {
            sendBasicBinaryMessage(webSocketMap.get(serialNumber).session, paramsDto.getBinaryData(), paramsDto.getFlag());
          } else {
            sendBasicMessage(webSocketMap.get(serialNumber).session, paramsDto.getMessage(), paramsDto.getFlag());
          }
        } catch (IOException e) {
          log.info(e.getMessage());

          if (paramsDto.getIsBinary()) {
            redisUtil.addToListRightExpire(PREX_STRING + serialNumber, EXPIRE_TIME, paramsDto.getMessage());
          } else {
            redisUtil.addToListRightExpire(PREX_BINARY + serialNumber, EXPIRE_TIME, paramsDto.getBinaryData());
          }
        }
      }
    result.setData(true);
    return result;
  }

  /**
   * 给指定的人发送消息
   */
  public RestControllerResult<Boolean> sendToTerminalAsync(WebsocketParamsDto paramsDto) {
    RestControllerResult<Boolean> result =  new RestControllerResult<Boolean>();
    String toSerialNumber = paramsDto.getSerialNumber();
    try {
      if(!isOnline(toSerialNumber)) {
        result.setData(false);
        result.setErrorMsg("请求的链接:" + toSerialNumber + "不在该服务器上");
        log.info("请求的链接:" + toSerialNumber + "不在该服务器上");
        return result;
      }

      WebsocketServer websocketServer = webSocketMap.get(toSerialNumber) ;
      if (paramsDto.getIsBinary()) {
        sendAsyncBinaryMessage(websocketServer.session, paramsDto.getBinaryData());
      } else {
        sendAsyncMessage(websocketServer.session, paramsDto.getMessage());
      }
      result.setData(true);
    } catch (IOException e) {
      log.info(e.getMessage());

      if (paramsDto.getIsBinary()) {
        redisUtil.addToListRightExpire(PREX_STRING + toSerialNumber, EXPIRE_TIME, paramsDto.getMessage());
      } else {
        redisUtil.addToListRightExpire(PREX_BINARY + toSerialNumber, EXPIRE_TIME, paramsDto.getBinaryData());
      }

      result.setData(false);
      result.setErrorMsg("推送消息至链接:" + toSerialNumber + "时系统异常：" + e.getMessage());
      return result;
    }
    return result;
  }

  /**
   * 给所有人发消息
   */
  public RestControllerResult<Boolean> sendToTerminalListAsync(WebsocketParamsDto paramsDto) {
    RestControllerResult<Boolean> result =  new RestControllerResult<Boolean>();
    List<String> terminalList = paramsDto.getSerialList();
    for (String serialNumber : terminalList) {
      try {
        if (paramsDto.getIsBinary()) {
          sendAsyncBinaryMessage(webSocketMap.get(serialNumber).session, paramsDto.getBinaryData());
        } else {
          sendAsyncMessage(webSocketMap.get(serialNumber).session, paramsDto.getMessage());
        }
      } catch (IOException e) {
        log.info(e.getMessage());

        if (paramsDto.getIsBinary()) {
          redisUtil.addToListRightExpire(PREX_STRING + serialNumber, EXPIRE_TIME, paramsDto.getMessage());
        } else {
          redisUtil.addToListRightExpire(PREX_BINARY + serialNumber, EXPIRE_TIME, paramsDto.getBinaryData());
        }
      }
    }
    result.setData(true);
    return result;
  }

  /**
   * 给所有人发消息
   */
  public RestControllerResult<Boolean>  sendToAllAsync(WebsocketParamsDto paramsDto) {
    RestControllerResult<Boolean> result =  new RestControllerResult<Boolean>();
    for (String serialNumber : webSocketMap.keySet()) {
      try {
        if (paramsDto.getIsBinary()) {
          sendAsyncBinaryMessage(webSocketMap.get(serialNumber).session, paramsDto.getBinaryData());
        } else {
          sendAsyncMessage(webSocketMap.get(serialNumber).session, paramsDto.getMessage());
        }
      } catch (IOException e) {
        log.info(e.getMessage());
        if (paramsDto.getIsBinary()) {
          redisUtil.addToListRightExpire(PREX_STRING + serialNumber, EXPIRE_TIME, paramsDto.getMessage());
        } else {
          redisUtil.addToListRightExpire(PREX_BINARY + serialNumber, EXPIRE_TIME, paramsDto.getBinaryData());
        }
      }
    }
    result.setData(true);
    logger.info("给所有人发消息结果: {}", result);
    return result;
  }

  public static Map<String, WebsocketServer> getWebSocketMap() {
    return webSocketMap ;
  }

  /**
   * 同步发送消息模式。
   * message: 待发送的消息
   * flag: 是否支持发送部分消息（true:可部分发送消息; false:一次性发布全部消息）
   */
  public void sendBasicMessage(Session session, String message, Boolean flag) throws IOException {
    log.info("WebsocketServer.sendBasicMessage() is begin, flag is " + flag + " ,message is " + message);
    session.getBasicRemote().sendText(message, flag);
    log.info("WebsocketServer.sendBasicMessage() is end. ");
  }

  /**
   * 同步发送消息模式。
   * message: 待发送的消息
   * flag: 是否支持发送部分消息（true:可部分发送消息; false:一次性发布全部消息）
   */
  public void sendBasicBinaryMessage(Session session, ByteBuffer message, Boolean flag) throws IOException {
    log.info("WebsocketServer.sendBasicMessage() is begin, flag is " + flag + " ,message is " + message);
    session.getBasicRemote().sendBinary(message, flag);
    log.info("WebsocketServer.sendBasicMessage() is end. ");
  }

  /**
   * 异步发送消息模式。
   * message: 待发送的消息
   * flag: 是否支持发送部分消息
   */
  public void sendAsyncMessage(Session session, String message) throws IOException {
    log.info("WebsocketServer.sendAsyncMessage() is begin, message is " + message);
    session.getAsyncRemote().sendText(message);
    log.info("WebsocketServer.sendAsyncMessage() is end. ");

  }

  /**
   * 异步发送消息模式。
   * message: 待发送的消息
   * flag: 是否支持发送部分消息
   */
  public void sendAsyncBinaryMessage(Session session, ByteBuffer message) throws IOException {
    log.info("WebsocketServer.sendAsyncMessage() is begin, message is " + message);
    session.getAsyncRemote().sendBinary(message);
    log.info("WebsocketServer.sendAsyncMessage() is end. ");

  }

  /**
   * 同步发送消息模式。
   * message: 待发送的消息
   * flag: 是否支持发送部分消息（true:可部分发送消息; false:一次性发布全部消息）
   */
  public Boolean sendBasicMessage(Session session, List<String> messageList, Boolean flag) throws IOException {
    if (null == messageList || messageList.size() < 1) {
      return true;
    }
    for (int i = 0; i < messageList.size(); i++) {
      session.getBasicRemote().sendText(messageList.get(i), flag);
    }
    return true;
  }

  /**
   * 异步发送消息模式。
   * message: 待发送的消息
   * flag: 是否支持发送部分消息
   */
  public Boolean sendAsyncMessage(Session session, List<String> messageList) throws IOException {
    if (null == messageList || messageList.size() < 1) {
      return true;
    }
    for (int i = 0; i < messageList.size(); i++) {
      session.getAsyncRemote().sendText(messageList.get(i));
    }
    return true;
  }

  /**
   * 同步发送消息模式。
   * message: 待发送的消息
   * flag: 是否支持发送部分消息（true:可部分发送消息; false:一次性发布全部消息）
   */
  public Boolean sendBasicBinaryMessage(Session session, List<ByteBuffer> messageList, Boolean flag) throws IOException {
    if (null == messageList || messageList.size() < 1) {
      return true;
    }
    for (int i = 0; i < messageList.size(); i++) {
      session.getBasicRemote().sendBinary(messageList.get(i), flag);
    }
    return true;
  }

  /**
   * 异步发送消息模式。
   * message: 待发送的消息
   * flag: 是否支持发送部分消息
   */
  public Boolean sendAsyncBinaryMessage(Session session, List<ByteBuffer> messageList) throws IOException {
    if (null == messageList || messageList.size() < 1) {
      return true;
    }
    for (int i = 0; i < messageList.size(); i++) {
      session.getAsyncRemote().sendBinary(messageList.get(i));
    }
    return true;
  }

  /**
   * 获取当前时间
   *
   * @return
   */
  private String getNowTime() {
    Date date = new Date();
    DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    String time = format.format(date);
    return time;
  }

  public static synchronized int getOnlineCount() {
    return onlineCount;
  }

  public static synchronized void addOnlineCount() {
    WebsocketServer.onlineCount++;
  }

  public static synchronized void subOnlineCount() {
    WebsocketServer.onlineCount--;
  }

  public Boolean isExist(String serialNumber) {
    if(StringUtils.isBlank(serialNumber) || !webSocketMap.containsKey(serialNumber)){
      return false;
    }
    return true;
  }

  public Boolean isOnline(String serialNumber) {
    try {
      if(StringUtils.isBlank(serialNumber) || !webSocketMap.containsKey(serialNumber)){
        return false;
      }
      WebsocketServer websocketServer = webSocketMap.get(serialNumber) ;
      if (websocketServer == null ) {
        return false;
      }
    } catch (Exception e){
      log.error(e.getMessage());
      return false;
    }
    return true;
  }
}

4、入参对象配置

package com.service.websocket.dto;

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import java.nio.ByteBuffer;
import java.util.List;
import lombok.Data;
import org.w3c.dom.Text;

/**
 * Websocket参数 DTO.
 *
 * @author ****
 */
@Data
@ApiModel(value = "WebsocketParamsDto", description = "test")
public class WebsocketParamsDto {

  @ApiModelProperty(value = "序列号", name = "serialNumber", example = "key.12345")
  private String serialNumber;

  @ApiModelProperty(value = "键值", name = "serialList", example = "key.12345")
  private List<String> serialList;

  @ApiModelProperty(value = "信息类型:true 异步；false 同步", name = "dataType", example = "1/空:Sring;2-binary;3-text;")
  private Boolean isBinary;

  @ApiModelProperty(value = "信息", name = "message", example = "待发送信息")
  private String message;

  @ApiModelProperty(value = "二进制数据", name = "binaryData", example = "01010101....")
  private ByteBuffer binaryData;

  @ApiModelProperty(value = "Text数据", name = "textData", example = "key.67890")
  private Text textData;

  @ApiModelProperty(value = "模式", name = "同步false/异步模式true", example = "true")
  private Boolean isAsync;

  @ApiModelProperty(value = "传送标识", name = "flag", example = "true--一次性发送全部信息；false--可部分发送信息；")
  private Boolean flag;
}

5、业务调用

/**
   * 给所有人发消息
   */
  public RestControllerResult<Boolean>  sendToAll(WebsocketParamsDto paramsDto) {
    RestControllerResult<Boolean> result =  new RestControllerResult<Boolean>();
    //遍历HashMap
    for (String serialNumber : webSocketMap.keySet()) {
      try {
        if (paramsDto.getIsBinary()) {
          sendBasicBinaryMessage(webSocketMap.get(serialNumber).session, paramsDto.getBinaryData(), paramsDto.getFlag());
        } else {
          sendBasicMessage(webSocketMap.get(serialNumber).session, paramsDto.getMessage(), paramsDto.getFlag());
        }
      } catch (IOException e) {
        log.info(e.getMessage());

        if (paramsDto.getIsBinary()) {
          redisUtil.addToListRightExpire(PREX_STRING + serialNumber, EXPIRE_TIME, paramsDto.getMessage());
        } else {
          redisUtil.addToListRightExpire(PREX_BINARY + serialNumber, EXPIRE_TIME, paramsDto.getBinaryData());
        }
      }
    }

    result.setData(true);
    return result;
  }
@Resource
private WebsocketServer webSocketServer;

@Override
public RestControllerResult<Boolean>
  sendToAll(@RequestBody WebsocketParamsDto paramsDto) {
  return webSocketServer.sendToAll(paramsDto);
}

二、Websocket 测试

1、在线测试

测试URL：Websocket在线测试-Websocket接口测试-Websocket模拟请求工具 (jsons.cn)

2、业务调用 WebSocket 服务，发出消息

通过 postman 测试工具调用接口，或者其他工具

3、Websocket 监听端回应情况如下 

九块六
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
程序员零基础转行Golang开发，看这一篇就够了（含30G自学教程笔记）
Cloud_Native的博客
11-24 1420
我整理了一份 Go 学习路线，这份学习路线不以数量取胜，努力做到精简。从基础到进阶，从理论到实战
WebSocket开发指南
01-27
我们先来看看HTTP。一次HTTP请求过程如下:TCP连接是支持双向同时读写的全双工协议,但是我们看传统的 HTTP协议有几个问题:请求过程是串行的,客户端与...请求是单向的,总是必须客户端先发起请求....还是从不同的TCP连接发
（java）websocket服务的两种实现方式
qq_62646841的博客
05-12 2218
用java注解来监听连接@ServerEndpoint、连接成功@OnOpen、连接失败@OnClose、收到消息等状态@OnMessage。把spring中的ServerEndpointExporter对象注入进来。
阿里云全站加速DCDN全面支持WebSocket协议
Apsaravod的博客
01-14 1136
WebSocket协议可以为网站和应用提供真正的双向通信，具有控制开销、保持连接状态、更强实时性、更好的压缩效果等优点，是当下低延时应用最常采用的一种技术协议。为了更好的满足客户在实时通讯场景下的加速需求，目前阿里云全站加速DCDN已经全面支持WebSocket协议，以此确保更加极致的客户体验。 WebSocket的优势与应用 HTML5定义 的WebSocket协议是基于TCP的一种新的网络协议...
全栈开发之路
weixin_30788619的博客
04-04 294
01-服务器 视频 后盾网Linux系统管理（提取码：55tx） 快速上手Linux 玩转典型应用（收费） Linux达人养成计划 I Linux 达人养成计划 II 玩转Vim 从放弃到爱不释手 项目上线流程(nginx) 第一个docker化的java应用 Docker入门 文档 在centos和redhat上安装docker ...
Go 学习路线（2024）(1)
2401_83817148的博客
04-20 676
外链图片转存中…(img-JMf4H0Gy-1713581070211)][外链图片转存中…(img-luqH44t7-1713581070212)][外链图片转存中…(img-hrhs23jx-1713581070212)]
Go 学习路线（2024）
2401_83817171的博客
04-20 1042
外链图片转存中…(img-opiCnYZA-1713581105487)][外链图片转存中…(img-FGwqax1c-1713581105487)][外链图片转存中…(img-SeriKFP2-1713581105488)]
Go 学习路线（2022）
AlwaysBeta 的专栏
02-07 7731
原文链接： Go 学习路线（2022） Go 语言的发展越来越好了，很多大厂使用 Go 作为主要开发语言，也有很多人开始学习 Go，准备转 Go 开发。 那么，怎么学呢？ 我发现，在互联网时代，学习的困难不是说没有资料，而是资料太多，不知道应该看哪个，从哪开始看。 所以，我整理了一份 Go 学习路线，这份学习路线不以数量取胜，努力做到精简。从基础到进阶，从理论到实战，一共包括以下几个内容： 入门教程 进阶教程 书籍推荐 Web 开发 练手项目 实用工具 技术社区 这份学习路线还会不断优化更新，感兴趣的
【总结】Go 学习路线（2022）
pingan8787
02-09 4142
Go 语言的发展越来越好了，很多大厂使用 Go 作为主要开发语言，也有很多人开始学习 Go，准备转 Go 开发。那么，怎么学呢？我发现，在互联网时代，学习的困难不是说没有资料，而是资料太多...
Java全栈体系路线
热门推荐
qq_43573663的博客
02-04 1万+
文章目录1）Java路线图2） 大数据学习路线3）前端学习路线4）Python学习路线 1）Java路线图 2） 大数据学习路线 3）前端学习路线 4）Python学习路线 ...
HTML5WebSocket权威指南
07-22
资源名称：HTML5 WebSocket权威指南内容简介：《HTML5 WebSocket权威指南》是HTML5 WebSocket领域最权威的著作之一，它系统、全面地讲解了HTML5 WebSocket的各个方面，是Web开发人员和架构师学习WebSocket的最佳选择...
HTML5++WebSocket权威指南.pdf
07-04
WebSocket 领域最全面和系统的著作、三位资深html5技术专家共同编写；系统讲解 websocket 的API、协议、消息传输安全性和企业部署，并给出通过websocket协议通信的真实示例，可操作性强。
自己开发的WebSocket 调试工具
10-26
自己开发的WebSocket 调试工具，基于aardio 短小精悍，支持服务器、客户端，十六进制等，支持多客户端连接，支持对指定的客户发送消息，支持多URL监听，用英文";" 分隔即可， 支持发送消息保存，下次启动可快速选择...
Spring Boot 应用中的事务管理与 Feign 调用问题分析及解决
weixin_42564451的博客
08-02 490
在微服务架构下，遇到这样的场景：一个服务需要调用另一个服务的接口来进行一系列操作，而这些操作又需要保证事务的一致性。
Spring Boot 实现异步处理多个并行任务
最新发布
心猿意码
08-02 399
在现代Web应用开发中，异步处理和多任务并行处理对于提高系统的响应性和吞吐量至关重要。Spring Boot 提供了多种机制来实现异步任务处理，本文将介绍如何利用这些机制来优化您的应用程序性能。
Java面试八股之简述spring boot的目录结构
u012151345的博客
07-23 966
application.properties 或 application.yml：是 Spring Boot 的主要配置文件，可以有多个版本，例如 application-dev.yml 和 application-prod.yml，分别用于开发和生产环境。Spring Boot 项目遵循标准的 Maven 或 Gradle 项目布局，并且有一些约定的目录用于组织不同的项目组件。src/test/java 和 src/test/resources：包含测试相关的 Java 代码和资源文件。
Spring Boot中的 6 种API请求参数读取方式
2301_76419561的博客
07-23 1669
在利用Spring Boot框架开发应用程序接口时，从客户端请求中提取参数是一项基础而关键的任务。Spring Boot为了迎合各式各样的接口设计需求，提供了多样化的机制以供开发者选择。本文将详细梳理六种主流的请求参数读取方法。若您所掌握的方式尚未达到此数目，不妨参考本文以填补知识的空白；倘若您所了解的途径超出六种，欢迎分享您的见解，共同进步。
可造成敏感信息泄露！Spring Boot之Actuator信息泄露漏洞三种利用方式总结
WangsuSecurity的博客
08-02 715
如果没有正确使用Actuator，可能造成信息泄露等严重的安全隐患。其中heapdump作为Actuator组件最为危险的Web端点，因未授权访问被恶意人员获取后进行分析，可进一步获取敏感信息。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值