精华内容
下载资源
问答
  • websocket服务器搭建方案简介
    2017-08-10 21:36:27

    本文主要介绍可选的几种websocket服务器搭建方案,包含:

    1. PyWebSocket
    2. WebSocket-Node
    3. LibWebSockets


    一、PyWebSocket

    PyWebSocket是一个由python编写的websocket服务器。
    安装时首先需要下载mod_pywebsocket,然后打开解压文件,进入到pywebsocket-master包中,执行命令:

    python setup.py install 

    然后通过执行以下命令开启websocket服务:

    python standalone.py -p 9998 -w ../example/

    二、WebSocket-Node

    WebSocket-Node是基于nodejs的,由javascript编写。
    首先需要安装Node.js和npm,然后使用npm安装WebSocket-Node模块ws。

    npm install ws

    三、LibWebSockets

    LibWebSockets由C/C++语言编写,git源码获取:

    Git clone git://git.warmcat.com/libwebsockets

    更多相关内容
  • nodejs-websocket 基于node创建websocket服务器 websocket 协议和 http 协议类似,http 协议有一个缺陷,只能由客户方端发起请求,服务端根据请求 url 和传过去的参数返回对应结果 websocket 是双向通信的,只要 ...
  • webSocket 搭建实例

    2018-05-25 14:43:31
    它的最大特点就是,服务器可以主动向客户端推送信息,客户端也可以主动向服务器发送信息,是真正的双向平等对话,属于服务器推送技术的一种。
  • /** * @ServerEndpoint 注解是一个类层次的注解,它的功能主要是将目前的类定义成一个websocket服务器端, * 注解的值将被用于监听用户连接的终端访问URL地址,客户端可以通过这个URL来连接到WebSocket服务器端 * @...

    1.创建springboot项目 

    maven依赖

     <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.75</version>
     </dependency>
    <!--springboot中websocket依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-websocket</artifactId>
        <version>2.5.0</version>
    </dependency>
    <!-- swagger -->
    <dependency><!--添加Swagger依赖 -->
        <groupId>io.springfox</groupId>
        <artifactId>springfox-swagger2</artifactId>
        <version>2.7.0</version>
    </dependency>
    <!--添加Swagger-UI依赖 -->
    <dependency>
        <groupId>io.springfox</groupId>
        <artifactId>springfox-swagger-ui</artifactId>
        <version>2.7.0</version>
    </dependency>

    2.config

    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.web.socket.config.annotation.EnableWebSocket;
    import org.springframework.web.socket.server.standard.ServerEndpointExporter;
    
    /**
     * @author :jerry
     * @date :Created in 2021/12/21 14:07
     * @description:WebSocketConfig
     * @version: V1.1
     */
    @Configuration
    @EnableWebSocket
    public class WebSocketConfig {
     
        @Bean
        public ServerEndpointExporter serverEndpointExporter() {
            return new ServerEndpointExporter();
        }
    }

    3.控制层

    import com.alibaba.fastjson.JSONObject;
    import com.yl.entity.ChatMsg;
    import com.yl.service.ChatMsgService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    
    import javax.websocket.*;
    import javax.websocket.server.PathParam;
    import javax.websocket.server.ServerEndpoint;
    import java.io.IOException;
    import java.time.LocalDateTime;
    import java.util.concurrent.ConcurrentHashMap;
    
    /**
     * @ServerEndpoint 注解是一个类层次的注解,它的功能主要是将目前的类定义成一个websocket服务器端,
     * 注解的值将被用于监听用户连接的终端访问URL地址,客户端可以通过这个URL来连接到WebSocket服务器端
     * @ServerEndpoint 可以把当前类变成websocket服务类
     */
    @Controller
    @ServerEndpoint(value = "/websocket/{userId}")
    public class ChatWebSocket {
        // 这里使用静态,让 service 属于类
        private static ChatMsgService chatMsgService;
    
        // 注入的时候,给类的 service 注入
        @Autowired
        public void setChatService(ChatMsgService chatService) {
            ChatWebSocket.chatMsgService = chatService;
        }
    
        //静态变量,用来记录当前在线连接数。应该把它设计成线程安全的。
        private static int onlineCount = 0;
        //concurrent包的线程安全Set,用来存放每个客户端对应的MyWebSocket对象。若要实现服务端与单一客户端通信的话,可以使用Map来存放,其中Key可以为用户标识
        private static ConcurrentHashMap<String, ChatWebSocket> webSocketSet = new ConcurrentHashMap<String, ChatWebSocket>();
        //与某个客户端的连接会话,需要通过它来给客户端发送数据
        private Session WebSocketsession;
        //当前发消息的人员编号
        private String userId = "";
    
    
        /**
         * 连接建立成功调用的方法
         *
         * session 可选的参数。session为与某个客户端的连接会话,需要通过它来给客户端发送数据
         */
        @OnOpen
        public void onOpen(@PathParam(value = "userId") String param, Session WebSocketsession) {
            userId = param;//接收到发送消息的人员编号
            this.WebSocketsession = WebSocketsession;
            webSocketSet.put(param, this);//加入map中
            addOnlineCount();     //在线数加1
            //System.out.println("有新连接加入!当前在线人数为" + getOnlineCount());
        }
    
    
        /**  ws://localhost:8081/websocket/1575254996716916627
         * 连接关闭调用的方法
         */
        @OnClose
        public void onClose() {
            if (!userId.equals("")) {
                webSocketSet.remove(userId); //从set中删除
                subOnlineCount();     //在线数减1
                //System.out.println("有一连接关闭!当前在线人数为" + getOnlineCount());
            }
        }
    
    
        /**
         * 收到客户端消息后调用的方法
         *
         * @param chatmsg 客户端发送过来的消息
         * @param session 可选的参数
         */
        @SuppressWarnings("unused")
    	@OnMessage
        public void onMessage(String chatmsg, Session session) {
            JSONObject jsonObject = JSONObject.parseObject(chatmsg);
            //给指定的人发消息
            sendToUser(jsonObject.toJavaObject(ChatMsg.class));
            //sendAll(message);
        }
    
    
        /**
         * 给指定的人发送消息
         *
         * @param chatMsg 消息对象
         */
        public void sendToUser(ChatMsg chatMsg) {
            String reciveUserId = chatMsg.getReciveUserId();
            String sendMessage = chatMsg.getSendText();
    //        sendMessage= EmojiFilter.filterEmoji(sendMessage);//过滤输入法输入的表情
    //        chatMsgService.save(new ChatMsg().setMsgtype(chatMsg.getMsgtype()).setReciveuserid(reciveUserId).setSenduserid(userId).setSendtext(sendMessage));
            chatMsg.setCreateTime(LocalDateTime.now());
            chatMsgService.save(chatMsg);
            try {
    //            if (webSocketSet.get(reciveUserId) != null) {
                    webSocketSet.get(reciveUserId).sendMessage(userId+"|"+sendMessage);
    //            }
    //            else{
    //                webSocketSet.get(userId).sendMessage("0"+"|"+"当前用户不在线");
    //            }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
        /**
         * 给所有人发消息
         *
         * @param message
         */
        private void sendAll(String message) {
            String sendMessage = message.split("[|]")[1];
            //遍历HashMap
            for (String key : webSocketSet.keySet()) {
                try {
                    //判断接收用户是否是当前发消息的用户
                    if (!userId.equals(key)) {
                        webSocketSet.get(key).sendMessage(sendMessage);
                        System.out.println("key = " + key);
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    
    
        /**
         * 发生错误时调用
         *
         * @param session
         * @param error
         */
        @OnError
        public void onError(Session session, Throwable error) {
            error.printStackTrace();
        }
    
    
        /**
         * 这个方法与上面几个方法不一样。没有用注解,是根据自己需要添加的方法。
         *
         * @param message
         * @throws IOException
         */
        public void sendMessage(String message) throws IOException {
            this.WebSocketsession.getBasicRemote().sendText(message);
            //this.session.getAsyncRemote().sendText(message);
        }
    
    
        public static synchronized int getOnlineCount() {
            return onlineCount;
        }
    
        //在线人数+1
        public static synchronized void addOnlineCount() {
            ChatWebSocket.onlineCount++;
        }
    
    
        public static synchronized void subOnlineCount() {
            ChatWebSocket.onlineCount--;
        }
    
    }
    
    

    4.消息的存储

    4.1javaBean

    
    import com.baomidou.mybatisplus.annotation.TableName;
    import com.fasterxml.jackson.annotation.JsonFormat;
    import io.swagger.annotations.ApiModel;
    import io.swagger.annotations.ApiModelProperty;
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    import lombok.experimental.Accessors;
    
    import java.time.LocalDateTime;
    import java.util.Date;
    
    @TableName("sys_chat_msg")
    @ApiModel(description = "科室")
    @AllArgsConstructor
    @NoArgsConstructor
    @Data
    @Accessors(chain = true)
    public class ChatMsg extends Base{
    
        @ApiModelProperty(value = "id , 雪花算法")
        private Long id;
    
        @ApiModelProperty(value = "发送用户ID")
        private String sendUserId;
    
        @ApiModelProperty(value = "接收用户ID")
        private String reciveUserId;
    
        @ApiModelProperty(value = "发送时间")
        @JsonFormat(shape = JsonFormat.Shape.STRING, pattern="yyyy-MM-dd HH:mm:ss",timezone="GMT+8")
        private LocalDateTime sendTime;
    
        @ApiModelProperty(value = "消息类型")
        private String msgType;
    
        @ApiModelProperty(value = "消息内容")
        private String sendText;
    
    
        @JsonFormat(shape = JsonFormat.Shape.STRING, pattern="yyyy-MM-dd HH:mm:ss",timezone="GMT+8")
        private LocalDateTime createTime;
    
        @JsonFormat(shape = JsonFormat.Shape.STRING, pattern="yyyy-MM-dd HH:mm:ss",timezone="GMT+8")
        private LocalDateTime updateTime;
    
        private Integer status;					//1。开启,    0,关闭
    
        @TableField(exist = false)
        private int current;
    
        @TableField(exist = false)
        private int size;
    }

    4.2其他业务代码根据自己需要自行补充

    测试是否搭建成功:本人用的:Websocket在线测试-Websocket接口测试-Websocket模拟请求工具

    ,可以自行选择 

     

    展开全文
  • 搭建webSocket服务器,以及运行一个jsmpeg的js文件,Node.js采用C++语言编写而成,它不是Javascript应用,它通过Node.js实现WebSocket服务端,同时也提供客户端JS库。Socket.IO支持以事件为基础的实时双向通讯,它...
  • 主要介绍了用nodejs搭建websocket服务器,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 认识WebSocket搭建服务端

    千次阅读 2022-03-17 16:50:51
    认识WebSocket搭建服务端 前言 一、概述 WebSocket 协议在2008年诞生,2011年成为国际标准。webSocket能够在建立连接之后,在服务器端推送数据到客户端,解决HTTP协议的弊端。 特点: (1)建立在 TCP 协议之上,...

    认识WebSocket并搭建服务端

    前言

    一、概述

    WebSocket 协议在2008年诞生,2011年成为国际标准。webSocket能够在建立连接之后,在服务器端推送数据到客户端,解决HTTP协议的弊端。

    image-20220316224136573

    特点:

    (1)建立在 TCP 协议之上,服务器端的实现比较容易。

    (2)与 HTTP 协议有着良好的兼容性。默认端口也是80和443,并且握手阶段采用 HTTP 协议,因此握手时不容易屏蔽,能通过各种 HTTP 代理服务器。

    (3)数据格式比较轻量,性能开销小,通信高效。

    (4)可以发送文本,也可以发送二进制数据。

    (5)没有同源限制,客户端可以与任意服务器通信。

    (6)协议标识符是ws(如果加密,则为wss),服务器网址就是 URL。

    为什么需使用webSocket?

    因为HTTP协议的通信只能由客户端发起,无法服务端主动推送数据。我们当然可以使用HTTP然后轮询探测数据变化,但效率低,性能差,不建议使用。

    二、客户端说明

    1.新建 WebSocket 实例

    var ws = new WebSocket('ws://localhost:8080');
    

    2.webSocket.readyState

    readyState属性返回实例对象的当前状态,共有四种。

    • CONNECTING:值为0,表示正在连接。
    • OPEN:值为1,表示连接成功,可以通信了。
    • CLOSING:值为2,表示连接正在关闭。
    • CLOSED:值为3,表示连接已经关闭,或者打开连接失败。

    3.webSocket.onopen

    onopen属性,用于指定连接成功后的回调函数。

    4.webSocket.onclose

    onclose属性,用于指定连接关闭后的回调函数。

    5.webSocket.onmessage

    onmessage属性,用于指定收到服务器数据后的回调函数。

    6.webSocket.send()

    send()方法用于向服务器发送数据。

    7.webSocket.bufferedAmount

    bufferedAmount属性,表示还有多少字节的二进制数据没有发送出去。它可以用来判断发送是否结束。

    8.webSocket.onerror

    onerror属性,用于指定报错时的回调函数。

    三、服务端说明

    常用的 Node 实现有以下三种。

    Java搭建webSocket服务

    使用SpringBoot作为基础环境

    导入依赖:

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

    添加webSocket配置:

    package cn.hacah.websocketdemo.config;
    
    import cn.hacah.websocketdemo.handle.SpringWebSocketHandler;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.web.socket.config.annotation.EnableWebSocket;
    import org.springframework.web.socket.config.annotation.WebSocketConfigurer;
    import org.springframework.web.socket.config.annotation.WebSocketHandlerRegistry;
    
    @Configuration
    @EnableWebSocket
    public class SpringWebSocketConfig implements WebSocketConfigurer {
    
        @Override
        public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
            registry.addHandler(getSpringWebSocketHandler(), "/websocket/server")
                    .addInterceptors(getInterceptor()).setAllowedOrigins("*");
    
            registry.addHandler(getSpringWebSocketHandler(), "/sockjs/server").setAllowedOrigins("*")
                    .addInterceptors(getInterceptor()).withSockJS();
        }
    
        @Bean
        public SpringWebSocketHandler getSpringWebSocketHandler() {
            return new SpringWebSocketHandler();
        }
    
        @Bean
        public SpringWebSocketHandlerInterceptor getInterceptor() {
            return new SpringWebSocketHandlerInterceptor();
        }
    }
    

    拦截器:

    package cn.hacah.websocketdemo.config;
    
    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.HttpSession;
    import java.util.Map;
    
    public class SpringWebSocketHandlerInterceptor extends HttpSessionHandshakeInterceptor {
        @Override
        public boolean beforeHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler,
                                       Map<String, Object> attributes) throws Exception {
            System.out.println("Before Handshake");
            if (request instanceof ServletServerHttpRequest) {
                ServletServerHttpRequest servletRequest = (ServletServerHttpRequest) request;
                // 获取session时,如果没有则返回null
                HttpSession session = servletRequest.getServletRequest().getSession(false);
                if (session != null) {
                    // 在登录时保存的用户名
                    String userName = (String) session.getAttribute("SESSION_USERNAME");
                    if (userName != null) {
                        // 放入attributes中,可以在处理器的WebSocketSession中取出
                        attributes.put("WEBSOCKET_USERID", userName);
                    }
                }
            }
            return super.beforeHandshake(request, response, wsHandler, attributes);
        }
    
        @Override
        public void afterHandshake(ServerHttpRequest request, ServerHttpResponse response, WebSocketHandler wsHandler,
                                   Exception ex) {
            super.afterHandshake(request, response, wsHandler, ex);
            System.out.println("after Handshake");
        }
    
    }
    

    webSocket处理代码

    package cn.hacah.websocketdemo.handle;
    
    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;
    
    public class SpringWebSocketHandler extends TextWebSocketHandler {
        /**
         * 存储用户id和其对应的session
         */
        private static final Map<String, WebSocketSession> users = new HashMap<>();
    
        /**
         * 用户名key值
         */
        private static final String USER_ID = "WEBSOCKET_USERID";
    
        /**
         * 连接建立后触发
         */
        @Override
        public void afterConnectionEstablished(WebSocketSession session) {
            System.out.println("成功建立websocket连接!");
            // 取出在拦截器中存储的username
            String userId = (String) session.getAttributes().get(USER_ID);
            users.put(userId, session);
            System.out.println("当前线上用户数量:" + users.size());
        }
    
        /**
         * 关闭连接时触发
         */
        @Override
        public void afterConnectionClosed(WebSocketSession session, CloseStatus closeStatus) {
            String userId = (String) session.getAttributes().get(USER_ID);
            System.out.println("用户" + userId + "已退出!");
            users.remove(userId);
            System.out.println("剩余在线用户" + users.size());
        }
    
        /**
         * 接收消息
         */
        @Override
        protected void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception {
            super.handleTextMessage(session, message);
            System.out.println("收到消息:" + message);
            if (message.getPayload().contains("在吗")) {
                session.sendMessage(new TextMessage("对方不在线!"));
            }
        }
    
        @Override
        public void handleTransportError(WebSocketSession session, Throwable exception) throws Exception {
            if (session.isOpen()) {
                session.close();
            }
            System.out.println("传输出现异常,关闭websocket连接... ");
            String userId = (String) session.getAttributes().get(USER_ID);
            users.remove(userId);
        }
    
        @Override
        public boolean supportsPartialMessages() {
            return false;
        }
    
    
        /**
         * 给某个用户发送消息
         */
        public void sendMessageToUser(String userId, TextMessage message) {
            for (String id : users.keySet()) {
                if (id.equals(userId)) {
                    try {
                        if (users.get(id).isOpen()) {
                            users.get(id).sendMessage(message);
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    break;
                }
            }
        }
    
        /**
         * 给所有在线用户发送消息
         */
        public void sendMessageToUsers(TextMessage message) {
            for (String userId : users.keySet()) {
                try {
                    if (users.get(userId).isOpen()) {
                        users.get(userId).sendMessage(message);
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    

    controller代码:

    package cn.hacah.websocketdemo.controller;
    
    import cn.hacah.websocketdemo.handle.SpringWebSocketHandler;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestMethod;
    import org.springframework.web.bind.annotation.RequestParam;
    import org.springframework.web.bind.annotation.ResponseBody;
    import org.springframework.web.socket.TextMessage;
    
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpSession;
    
    /*GET请求开放用于测试,最好只允许POST请求*/
    @Controller
    @RequestMapping(value = "/websocket", method = {RequestMethod.POST, RequestMethod.GET})
    public class WebSocketController {
    
        @Autowired
        SpringWebSocketHandler springWebSocketHandler;
    
        /**
         * 登录将username放入session中,然后在拦截器HandshakeInterceptor中取出
         */
        @ResponseBody
        @RequestMapping("/login")
        public String login(HttpServletRequest request, @RequestParam(value = "username") String username, @RequestParam(value = "password") String password) {
            System.out.println("登录:" + username + ":" + password);
            HttpSession session = request.getSession();
            if (null != session) {
                session.setAttribute("SESSION_USERNAME", username);
                return "success";
            } else {
                return "fail";
            }
        }
    
        /**
         * 指定发送
         */
        @ResponseBody
        @RequestMapping("/sendToUser")
        public String send(@RequestParam(value = "username") String username, @RequestParam(value = "info") String info) {
            springWebSocketHandler.sendMessageToUser(username, new TextMessage(info));
            System.out.println("发送至:" + username);
            return "success";
        }
    
        /**
         * 广播
         */
        @ResponseBody
        @RequestMapping("/broadcast")
        public String broadcast(@RequestParam(value = "info") String info) {
            springWebSocketHandler.sendMessageToUsers(new TextMessage("广播消息:" + info));
            System.out.println("广播成功");
            return "success";
        }
    }
    

    测试:

    1.登录

    打开http://localhost:8080/websocket/login?username=guest&password=123

    2.连接

    localhost:8080/index.html

    3.推送消息到客户端

    http://localhost:8080/websocket/sendToUser?username=river&info=%E4%BD%A0%E5%A5%BD

    image-20220317001306331

    代码地址:gitee

    参考或相关文章

    https://blog.csdn.net/river66/article/details/102940323

    https://www.ruanyifeng.com/blog/2017/05/websocket.html

    展开全文
  • 一、微信小程序的websocket服务器搭建 微信小程序的网络通信使用的是基于TCP的WebSocket协议,使用node.js中的http和websocket模块可以很快的进行搭建。代码比较简单这里贴出来,通读一下基本就能看懂。值得一提...

    〇、前言

    最近在研究微信小程序的开发,中间遇到了不少问题,趟了不少坑,这里和大家分享一下我的一些经验,希望能给大家提供一些帮助。


    一、微信小程序的websocket服务器搭建

    微信小程序的网络通信使用的是基于TCP的WebSocket协议,使用node.js中的http和websocket模块可以很快的进行搭建。代码比较简单这里贴出来,通读一下基本就能看懂。值得一提的是这里推荐使用TypeScript进行服务器端的开发(示例代码就是TypeScript写的),服务器程序如果不是强类型的话还是很容易出问题的……想想就很可怕……

    这一部分不是本文的重点,均以示例代码+注释带过。

    import * as websocket from "websocket";
    import * as http from "http";
    
    const WebSocketServer: typeof websocket.server = websocket.server;
    
    // 创建一个http Server
    let httpServer: http.Server = http.createServer((request, response) => {
        console.log("received a request");
        response.writeHead(404);
        response.end();
    });
    
    // 创建一个websocket Server,websocket Server需要建立在http server之上
    let wsServer: websocket.server = new WebSocketServer({
        httpServer: httpServer,
        autoAcceptConnections: true
    });
    
    // 事件监听
    wsServer.on("connect", (connection) => {
        console.log(">>>come from: " + connection.remoteAddress); // 显示连接客户端的ip地址
        connection.on("message", (message) => {
            console.log(message.type);
            console.log(">>>message: ", message); // 接收到信息的类型和内容,注意都是utf8编码
            connection.sendUTF(message.utf8Data); // 把接收到的信息发回去
        });
    
        connection.on("close", (reasonCode, description) => {
            console.log(connection.remoteAddress + " has disconnected.");
        });
    });
    
    // 启动服务器
    httpServer.listen(80, () => {
        console.log(">>>Http Server is listening on port 80!");
    });

    使用上述代码就可以非常方便的建立一个简单的服务器用于和微信小程序的通信,接下来简单的介绍一下微信小程序如何与服务器进行通信。

    微信小程序官方文档给出了以下几个API,具体请参阅  https://mp.weixin.qq.com/debug/wxadoc/dev/api/network-socket.html



    下面还是用代码来体现用法,我们把他们写在onLoad事件里:

    onLoad: function () {
        this.setData({
    
        });
        var that = this;
        wx.connectSocket({
            url: 'ws://xxx.xxx.com' // 这里是服务器的地址
        }),
        wx.onSocketOpen(function (res) {
            // callback
            console.log("WebSocket连接已打开!"); // 打开WebSocket连接,在进行通信之前必须先打开一个连接
        }),
        wx.onSocketError(function (res) {  // WebSocket错误监听
            console.log('WebSocket连接打开失败,请检查!')
        }),
        wx.onSocketMessage(function (msg) { // WebSocket数据接收监听
            // CallBack
            console.log(msg);
        }),
        wx.onSocketClose(function () { // WebSocket关闭监听
            // callback
            console.log('WebSocket服务器已经关闭!');
        }),
        wx.sendSocketMessage({ // 向服务器发送数据,注意这个方法之必须在调用wx.connectSocket和wx.onSocketOpen回调之后
            data: "string" // 官方文档里data可以是string或者ArrayBuffer,但是注意这个ArrayBuffer并不是Array
        });
    }

    这里值得一提的是,官方文档关于 wx.sendSocketMessage 的说明中data的类型包含的ArrayBuffer并不是Array,如果你把data误写成Array类型的话在开发工具中调试不会报错且表现正常,但是到手机端就会 出现问题而且不会报错


    二、SSL证书申请和使用

    这一部分算是本文的重点了,首先说一下SSL证书是什么和为什么要SSL证书。

    SSL证书是数字证书的一种,类似于驾驶证、护照和营业执照的电子副本。因为配置在服务器上,也称为SSL服务器证书。

    SSL 证书就是遵守 SSL协议,由受信任的数字证书颁发机构CA,在验证服务器身份后颁发,具有服务器身份验证和数据传输加密功能。

    SSL证书通过在客户端浏览器和Web服务器之间建立一条SSL安全通道(Secure socket layer(SSL)安全协议是由Netscape Communication公司设计开发。该安全协议主要用来提供对用户和服务器的认证;对传送的数据进行加密和隐藏;确保数据在传送中不被改变,即数据的完整性,现已成为该领域中全球化的标准。由于SSL技术已建立到所有主要的浏览器和WEB服务器程序中,因此,仅需安装服务器证书就可以激活该功能了),即通过它可以激活SSL协议,实现数据信息在客户端和服务器之间的加密传输,可以防止数据信息的泄露。保证了双方传递信息的安全性,而且用户可以通过服务器证书验证他所访问的网站是否是真实可靠。数位签名又名数字标识、签章 (即 Digital Certificate,Digital ID ),提供了一种在网上进行身份验证的方法,是用来标志和证明网路通信双方身份的数字信息文件,概念类似日常生活中的司机驾照或身份证相似。 数字签名主要用于发送安全电子邮件、访问安全站点、网上招标与投标、网上签约、网上订购、安全网上公文传送、网上办公、网上缴费、网上缴税以及网上购物等安全的网上电子交易活动。

    为什么要SSL证书其实也很简单,微信的官方文档里面对网络请求和通信有以下要求:



    简单总结:

    1.微信小程序使用的网络连接必须是https加密的安全连接(需要SSL证书)

    2.微信小程序使用的服务器地址只能是备案过的域名

    3.微信小程序使用的服务器地址不能包括端口(由于采用了https所以默认是443, 不是80不是80不是80!

    4.开发过程中可以没有以上限制

    SSL证书很多是要收费的,部分免费的微信小程序还不支持……

    这里给大家推荐一个网站,这里提供的免费SSL证书可以在微信小程序中使用,但是每3个月需要renew一次: https://www.sslforfree.com/

    首先我们在主页输入需要申请的域名(SSL For Free的证书只能绑定一个域名),然后点Create。



    在进行了域名检查之后会出现如下的验证方式,用以确认你是申请域名的所有者,三种方式分别是FTP自动验证(输入FTP信息自动确认)、人工验证(上传指定文件通过是否能够访问进行验证)、DNS解析验证(在域名解析中添加txt记录进行验证)。前面两种方式比较方便(可能?),但是实测还是挺容易失败的,这里推荐用第三种方式进行验证,下面进行简单说明。



    这里以腾讯云作为案例,在点击DNS验证之后会出现如下页面:



    马赛克的部分就是需要添加的txt记录,这里我们进入腾讯云的云解析对DNS解析进行记录添加,如下图添加一个txt记录:



    主机记录这里需要着重说明一下,比如我们需要绑定的域名是abc.com或者www.abc.com这样的一级域名,这里就需要按照要求写成_acme-challenge.abc.com;但是如果是123.abc.com这样的二级域名,那么这里按要求就是_acme-challenge.123.abc.com。



    线路类型忽略即可,记录值填写要求的string,也就是页面截图中打马赛克的部分,TTL用默认值,然后记得保存。



    完成以上操作之后我们回到SSL For Free页面,等待10分钟之后(和TTL有关,但是也可能要更久)点击第三步中的链接,如果链接打开的一个页面中有要求的String,那么就说明txt记录添加成功,可以点击最下面的按钮进行下载。同时我们可以在下载的页面里面填入自己的电子邮箱,以便在SSL证书到期时自动提醒。



    下载成功之后记得把之前的域名解析换成正常的设定指向自己的服务器。

    下载的文件是一个压缩包,解压之后应该包括如下三个文件,这三个文件在一起可以作为一个有效证书,同时node.js可以直接使用这三个文件来创建https服务器。



    下面是使用了这三个文件的https服务器的代码:

    import * as websocket from "websocket";
    import * as https from "https";
    import * as fs from "fs"; // 需要引用node.js的fs来读取三个SSL证书文件
    
    const WebSocketServer: typeof websocket.server = websocket.server;
    
    // https Server
    let options: any = {
        key: fs.readFileSync("./key/private.key", "utf8"), // 这里设置三个证书的位置,记得指明“utf8”编码,key、cert、ca三个属性必须都有且对应三个文件
        cert: fs.readFileSync("./key/certificate.crt", "utf8"),
        ca: fs.readFileSync("./key/ca_bundle.crt", "utf8")
    };
    
    let httpsServer: any = https.createServer(options, (request, response) => { // 注意这里已经是https了
        console.log("received a request");
        response.writeHead(200);
        response.end("hello world\n");
    });
    
    // websocket Server
    let wsServer: websocket.server = new WebSocketServer({
        httpServer: httpsServer, // 对应的这里的httpServer后面也应该是对应的httpsSrver(名称无所谓但是本体应该是httpsServer)
        autoAcceptConnections: true
    });
    
    // 事件监听
    wsServer.on("connect", (connection) => {
        console.log(">>>come from: " + connection.remoteAddress);
        connection.on("message", (message) => {
            console.log(message.type);
            console.log(">>>message: ", message);
            connection.sendUTF(message.utf8Data); // 把接收到的信息发回去
        });
    
        connection.on("close", (reasonCode, description) => {
            console.log(connection.remoteAddress + " has disconnected.");
        });
    });
    
    // 启动服务器
    httpsServer.listen(443, () => { // 端口
        console.log(">>>Https Server is listening on port 443!");
    });

    微信小程序的通信与http是一致的,但是这里需要提醒,这个监听端口必须是443,因为微信小程序要求的服务器地址是https://xxx.yyy.com 这样的只能是域名不能带端口且开头是https,那端口一定是默认的443,说默认端口是80的我也不知道是为什么……如果有谁知道原因还请留言。

    以上便是本文的全部内容,个人水平有限,如有表述和技术错误欢迎指正。
    展开全文
  • --websocket--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-websocket</artifactId> </dependency> 配置类 import ...
  • 在腾讯云服务器上使用nodejs搭建websocket服务器
  • E自带组件搭建Websocket服务器,可以收发消息
  • 本文主要介绍可选的几种websocket服务器搭建方案,包含: 1. PyWebSocket 2. WebSocket-Node 3. LibWebSockets 一、PyWebSocket PyWebSocket是一个由python编写的websocket服务器。 安装时首先需要下载mod_...
  • 简单搭建WebSocket服务器

    万次阅读 2019-08-18 09:05:04
    下载nodejs-websocket依赖包 npm install nodejs-websocket 点击回车下载完成之后发现项目中并没有nodejs-websocket相关的文件夹 检查终端有没有报错,确保依赖包名称输入正确 检查是否存在package.json文件,...
  • 一台服务器 实现 1.给域名配置ssl证书 可以看我另一篇文章:https://blog.csdn.net/qq_36303853/article/details/106571227 注:如果ssl证书配置了没有生效大概率是你宝塔或者阿里云没有开放443端口,注意检查一下 ...
  • 文章目录简介netty中的websocketwebsocket的版本...通过Websocket我们可以实现客户端和服务器端的即时通讯,免除了客户端多次轮循带来的性能损耗。 既然websocket这么优秀,那么怎么在netty中使用websocket呢?
  • swoole用WebSocket服务器搭建一个简易的聊天室功能域名无ssl加密域名有ssl加密开启服务端常链接浏览器分别开启两个客户端窗口,进行聊天 域名无ssl加密 WS.php写服务端代码 <?php class WS{ private $ws = null;...
  • 如何创建一个websocket服务器

    千次阅读 2021-11-11 19:45:32
    WebSocket 原理介绍及服务器搭建 https://blog.csdn.net/qq_39101111/article/details/78627393
  • 前言: 之前我写了一篇搭建简易的聊天室功能的文章,不知道的建议先去看一下:...一台服务器 安装swoole4 php>=7.2 安装rerdis(我这里用的redis,你也可以用mysql数据库) 宝塔和阿里云分别.
  • JAVA整合WebSocket实现服务器消息推送项目源码
  • WebSocket(1)-- WebSocket API简介 WebSocket是html5新增加的一种通信协议,目前流行的浏览器都支持这个协议,例如Chrome,Safari,Firefox,Opera,IE等等,对该协议支持最早的应该是chrome,从ch
  • 使用nodejs搭建WebSocket服务器
  • Android使用Ktor创建websocket server,然后使用okhttp连接websocket
  • WebSocket] 服务器搭建 笔记 - 00 - 初建云服务器 文章目录[Node.js&WebSocket] 服务器搭建 笔记 - 00 - 初建云服务器1. 前言所有步骤1、主要思路2. 准备云服务器2. 设置防火墙3. 设置远程登陆4.应用管理5. 运行...
  • JAVA实现WebSocket服务器

    千次阅读 2021-04-30 16:54:46
    简单的话可以在客户端进行ajax轮询,但对于服务器来说会有大量的无效请求,客户端一多还容易扑街,于是准备上WebSocket。 环境为Spring Boot。 思路 关于客户端 客户端连接上的时候,将该连接对象存入服务器内存中...
  • websocket是一个浏览器和服务器通信的新的协议,websocket则和一般的socket一样,使得浏览器和服务器建立了一个双工的通道。今天我们就来详细探讨下使用Python实现websocket服务器的具体方法
  • Springboot + Netty 搭建websocket服务器 入门 废话少说直接贴代码,会用再说 导入pom <dependency> <groupId>io.netty</groupId> <artifactId>netty-all</artifactId> <...
  • 一 什么是WebSocket 1.1 首先分清几个概念 **http协议:**超文本传输协议,属于应用层。它的任务是与服务器交换信息。至于怎么连接到服务器,怎么保证数据正确,http不管。 **TCP协议:**传输控制协议,属于传输...
  • nodejs-websocket创建websocket服务器

    千次阅读 2020-11-06 14:54:52
    nodejs-websocket创建websocket服务器 首先,感谢csdn各位大佬们对创建...// 搭建websocket服务器 const ws = require("nodejs-websocket"); var _server = ws.createServer(conn => { // 接收客户端返回的数

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 13,771
精华内容 5,508
关键字:

websocket服务器搭建

友情链接: com.rar