基本信息

---

下载

   友情提示：（无需注册或充值，赞助后即可获取资源下载链接）

---

     嘿，亲！知识可是无价之宝呢，但咱这精心整理的资料也耗费了不少心血呀。小小地破费一下，绝对物超所值哦！如有下载和支付问题，请联系我们QQ(微信同号)：78630559

本次赞助数额为： 2 元　

支付宝支付

微信支付

   源码介绍

---

客户端源码：

(function (global, factory) {
    if (typeof define === 'function' && define.amd) {
        define([], factory);
    } else if (typeof module !== 'undefined' && module.exports){
        module.exports = factory();
    } else {
        global.PsWebSocket = factory();
    }
})(this, function () {

    if (!('WebSocket' in window)) {
        return;
    }

    function PsWebSocket(url, options) {

        // 默认设置
        var settings = {

            /** 是否记录调试信息. */
            debug: false,

            /** 是否在创建时自动连接 */
            automaticOpen: true,

            /** 自动重连等待时间. */
            reconnectInterval: 1000,
            /** 自动重连最长等待时间. */
            maxReconnectInterval: 30000,
            /** 自动重连增加的速度 */
            reconnectDecay: 1.5, 
            /** 等待连接的最长等待时间. */
            timeoutInterval: 2000,

            /** 重新连接的最大次数，为空则不限制 */
            maxReconnectAttempts: null
        }
        if (!options) { options = {}; } 
        
        for (var key in settings) {
            if (typeof options[key] !== 'undefined') {
                this[key] = options[key];
            } else {
                this[key] = settings[key];
            }
        }
        /** websocket地址，绝对地址，只读 */
        this.url = url;
        /** 重新连接次数，或最后一次成功 只读 */
        this.reconnectAttempts = 0;

        /**
         * 连接状态
         * 可能的值: WebSocket.CONNECTING, WebSocket.OPEN, WebSocket.CLOSING, WebSocket.CLOSED
         * 只读
         */
        this.readyState = WebSocket.CONNECTING;
 

        var self = this;
        var ws;
        var forcedClose = false;
        var timedOut = false;
        var eventTarget = document.createElement('div'); 
        eventTarget.addEventListener('open',       function(event) { self.onopen(event); });
        eventTarget.addEventListener('close',      function(event) { self.onclose(event); });
        eventTarget.addEventListener('connecting', function(event) { self.onconnecting(event); });
        eventTarget.addEventListener('message',    function(event) { self.onmessage(event); });
        eventTarget.addEventListener('error',      function(event) { self.onerror(event); });

 

        this.addEventListener = eventTarget.addEventListener.bind(eventTarget);
        this.removeEventListener = eventTarget.removeEventListener.bind(eventTarget);
        this.dispatchEvent = eventTarget.dispatchEvent.bind(eventTarget);

        /**
         * 兼容IE9-IE11 
         */
        function generateEvent(s, args) {
        	var evt = document.createEvent("CustomEvent");
        	evt.initCustomEvent(s, false, false, args);
        	return evt;
        };

        /**
         * 打开连接 
         */
        this.open = function (reconnectAttempt) {
            ws = new WebSocket(self.url);

            if (reconnectAttempt) {
                if (this.maxReconnectAttempts && this.reconnectAttempts > this.maxReconnectAttempts) {
                    return;
                }
            } else {
                eventTarget.dispatchEvent(generateEvent('connecting'));
                this.reconnectAttempts = 0;
            }

            if (self.debug || PsWebSocket.debugAll) {
                console.debug('PsWebSocket', 'attempt-connect', self.url);
            }

            var localWs = ws;
            var timeout = setTimeout(function() {
                if (self.debug || PsWebSocket.debugAll) {
                    console.debug('PsWebSocket', 'connection-timeout', self.url);
                }
                timedOut = true;
                localWs.close();
                timedOut = false;
            }, self.timeoutInterval);

            ws.onopen = function(event) {
                clearTimeout(timeout);
                if (self.debug || PsWebSocket.debugAll) {
                    console.debug('PsWebSocket', 'onopen', self.url);
                }
                self.protocol = ws.protocol;
                self.readyState = WebSocket.OPEN;
                self.reconnectAttempts = 0;
                var e = generateEvent('open');
                e.isReconnect = reconnectAttempt;
                reconnectAttempt = false;
                eventTarget.dispatchEvent(e);
            };

            ws.onclose = function(event) {
                clearTimeout(timeout);
                ws = null;
                if (forcedClose) {
                    self.readyState = WebSocket.CLOSED;
                    eventTarget.dispatchEvent(generateEvent('close'));
                } else {
                    self.readyState = WebSocket.CONNECTING;
                    var e = generateEvent('connecting');
                    e.code = event.code;
                    e.reason = event.reason;
                    e.wasClean = event.wasClean;
                    eventTarget.dispatchEvent(e);
                    if (!reconnectAttempt && !timedOut) {
                        if (self.debug || PsWebSocket.debugAll) {
                            console.debug('PsWebSocket', 'onclose', self.url);
                        }
                        eventTarget.dispatchEvent(generateEvent('close'));
                    }

                    var timeout = self.reconnectInterval * Math.pow(self.reconnectDecay, self.reconnectAttempts);
                    setTimeout(function() {
                        self.reconnectAttempts  ;
                        self.open(true);
                    }, timeout > self.maxReconnectInterval ? self.maxReconnectInterval : timeout);
                }
            };
            ws.onmessage = function(event) {
                if (self.debug || PsWebSocket.debugAll) {
                    console.debug('PsWebSocket', 'onmessage', self.url, event.data);
                }
                var e = generateEvent('message');
				var  eobj = eval('('   event.data   ')');
				e.ResultCode=eobj.ResultCode;
				e.DeviceID=eobj.DeviceID;
				e.ErrorMsg=eobj.ErrorMsg;
				e.Command=eobj.Command;
                e.data = eobj.ResultData;
                eventTarget.dispatchEvent(e);
            };
            ws.onerror = function(event) {
                if (self.debug || PsWebSocket.debugAll) {
                    console.debug('PsWebSocket', 'onerror', self.url, event);
                }
                eventTarget.dispatchEvent(generateEvent('error'));
            };
        } 
        if (this.automaticOpen == true) {
            this.open(false);
        }

        /**
         * 发送消息. 
         */
        this.send = function(data) {
            if (ws) {
                if (self.debug || PsWebSocket.debugAll) {
                    console.debug('PsWebSocket', 'send', self.url, data);
                }
                return ws.send(data);
            } else {
                throw '状态错误：websocket未连接';
            }
        };

        /**
         * 关闭连接 
         */
        this.close = function(code, reason) {
            // Default CLOSE_NORMAL code
            if (typeof code == 'undefined') {
                code = 1000;
            }
            forcedClose = true;
            if (ws) {
                ws.close(code, reason);
            }
        };

        /**
         * 刷新 
         */
        this.refresh = function() {
            if (ws) {
                ws.close();
            }
        };
    }

    //连接websocket后触发
    PsWebSocket.prototype.onopen = function(event) {};
    //关闭websocket后触发
    PsWebSocket.prototype.onclose = function(event) {};
    //尝试连接时触发
    PsWebSocket.prototype.onconnecting = function(event) {};
     //收到消息后触发
    PsWebSocket.prototype.onmessage = function(event) {};
     //产生错误后触发
    PsWebSocket.prototype.onerror = function(event) {};

   

    PsWebSocket.debugAll = false;

    PsWebSocket.CONNECTING = WebSocket.CONNECTING;
    PsWebSocket.OPEN = WebSocket.OPEN;
    PsWebSocket.CLOSING = WebSocket.CLOSING;
    PsWebSocket.CLOSED = WebSocket.CLOSED;

    return PsWebSocket;
});

服务端源码：

using System;
using System.Collections.Generic;
using System.ServiceProcess;
using Castle.MicroKernel;
using Castle.Windsor;
using PengeSoft.Common;
using PengeSoft.Device;
using SuperSocket.SocketBase;
using SuperSocket.SocketBase.Config;
using SuperSocket.SocketBase.Logging;
using SuperWebSocket;

namespace PsDevService
{
    public partial class Service1 : ServiceBase
    {
        #region 私有字段

        protected static readonly PengeSoft.Logging.ILog _logger = PengeSoft.Logging.LogManager.GetLogger("WebSocket Service");
        private WebSocketServer m_WebSocketServer;
        private List<IDeviceService> devicelist;//设备列表
        private IWindsorContainer _container;

        #endregion

        #region 构造函数

        public Service1()
        {
            InitializeComponent();
        }

        #endregion

        #region 重写ServiceBase

        protected override void OnStart(string[] args)
        {
            string value = System.Configuration.ConfigurationManager.AppSettings["Port"];
            int port = SysUtils.ToInt(value);
            if (port <= 0)
                port = 2012;

            m_WebSocketServer = new WebSocketServer();
            var rootConfig = new RootConfig { DisablePerformanceDataCollector = true };

            m_WebSocketServer.NewDataReceived  = m_WebSocketServer_NewDataReceived;
            m_WebSocketServer.NewMessageReceived  = m_WebSocketServer_NewMessageReceived;
            m_WebSocketServer.NewSessionConnected  = m_WebSocketServer_NewSessionConnected;
            m_WebSocketServer.SessionClosed  = m_WebSocketServer_SessionClosed;

            var config = new ServerConfig();
            config.Port = port;
            config.Ip = "Any";
            config.MaxConnectionNumber = 100;
            config.MaxRequestLength = 100000;
            config.Name = "WebSocket Proxy Server";
            var ret = m_WebSocketServer.Setup(rootConfig, config, null, null, new ConsoleLogFactory(), null, null);
            m_WebSocketServer.Start();

            _container = ComponentManager.GetInstance();
            IHandler[] handlers = _container.Kernel.GetHandlers(typeof(IDeviceService));
            devicelist = new List<IDeviceService>();
            IDeviceService deviceservice;
            foreach (IHandler handler in handlers)
            {
                deviceservice = (IDeviceService)_container[handler.ComponentModel.Name];
                deviceservice.webSocketServer = m_WebSocketServer;
                devicelist.Add(deviceservice);
            }

            _logger.Info(string.Format("启动成功，port={0}", port));
        }

        protected override void OnStop()
        {
            m_WebSocketServer.Stop();
            _logger.Info("服务停止");
        }

        #endregion

        #region WebSocketServer 事件

        void m_WebSocketServer_SessionClosed(WebSocketSession session, CloseReason value)
        {
        }

        void m_WebSocketServer_NewSessionConnected(WebSocketSession session)
        {
        }

        void m_WebSocketServer_NewDataReceived(WebSocketSession session, byte[] value)
        {
        }

        /// <summary>
        /// 收到消息触发事件
        /// </summary>
        /// <param name="session"></param>
        /// <param name="value"></param>
        void m_WebSocketServer_NewMessageReceived(WebSocketSession session, string value)
        {
            try
            {
                _logger.Debug(string.Format("收到消息，消息内容={0}", value));
                string pars = value;
                string cmd = GetCommand(ref pars); 
                foreach (IDeviceService item in devicelist)
                {
                    if (cmd.StartsWith(item.ID   "_", StringComparison.OrdinalIgnoreCase))
                    {
                        cmd = cmd.Substring(item.ID.Length   1, cmd.Length - item.ID.Length - 1);
                        WebSocketResult result = item.TransCmd(session, cmd, pars);
                        session.Send(result.JsonText);
                        _logger.Debug(string.Format("对消息处理完成，消息内容={0}", value));
                        break;
                    }
                }
            }
            catch (Exception e)
            {
                WebSocketResult result = new WebSocketResult();
                result.ResultCode = -1;
                result.DeviceID = "";
                result.ResultData = "";
                result.Command = value;
                result.ErrorMsg = e.Message;
                session.Send(result.JsonText);
                _logger.Error(string.Format("消息处理时产生异常，异常信息={0}", e.Message));
            }
        }

        #endregion

        #region 私有函数

        /// <summary>
        /// 取出参数
        /// </summary>
        /// <param name="pars"></param>
        /// <returns></returns>
        private string GetCommand(ref string pars)
        {
            int n = pars.IndexOf(' ');
            string cmd;
            if (n >= 0)
            {
                cmd = pars.Substring(0, n).Trim().ToUpper();
                pars = pars.Substring(n   1);
            }
            else
            {
                cmd = pars;
                pars = string.Empty;
            }

            return cmd.ToUpper();
        }

        #endregion

    }
}