WebSocket工具类

这篇具有很好参考价值的文章主要介绍了WebSocket工具类。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

        最近的项目在整长连接WebSocket,之前也写过一个感觉没有这个全面。提供个工具类WebSocketHelperJava-WebSocket-1.3.9.jar包以及一个HttpURLConnectionUtil

1、WebSocketHelper
import android.util.Log;

import org.java_websocket.client.WebSocketClient;
import org.java_websocket.drafts.Draft;
import org.java_websocket.drafts.Draft_6455;
import org.java_websocket.handshake.ServerHandshake;

import java.net.URI;
import java.util.Date;
import java.util.concurrent.TimeUnit;

/**
 * author : jsxin
 * e-mail : jsxin0816@163.com
 * time   : 2023/07/03
 * desc   : WebSocketHelper工具类
 */
public class WebSocketHelper {
    public static final String TAG = WebSocketHelper.class.getSimpleName();
    private RobotWebSocket ws_robot;
    private boolean isRunning;
    private boolean isInterrupt;
    public static boolean isOpenOk = false;

    private WebSocketHelper() {
        this.isRunning = false;
        this.isInterrupt = false;
    }

    public static WebSocketHelper getInstance() {
        return SingletonHolder.instance;
    }

    public boolean isRunning() {
        return this.isRunning;
    }

    public void ConnectService(final String serive_ip, final String pad_name, final WebSokcetCallback cb) {
        if (!this.isRunning) {
            this.isInterrupt = false;
            Runnable runnable = new Runnable() {
                public void run() {
                    while(!WebSocketHelper.this.isInterrupt) {
                        WebSocketHelper.this.isRunning = true;
                        if (WebSocketHelper.isOpenOk) {
                            try {
                                Thread.sleep(2000L);
                            } catch (Exception var2) {
                                var2.printStackTrace();
                            }
                        } else {
                            try {
                                String url = "ws://" + serive_ip + "/webSocket/" + 1;
                                System.out.print(url);
                                Log.i(WebSocketHelper.TAG, url);
                                WebSocketHelper.this.ws_robot = WebSocketHelper.this.new RobotWebSocket(new URI(url), new Draft_6455(), cb);
                                WebSocketHelper.this.ws_robot.connectBlocking(10L, TimeUnit.SECONDS);
                            } catch (Exception var4) {
                                Log.e(WebSocketHelper.TAG, var4.getMessage());
                            }

                            try {
                                Thread.sleep(2000L);
                            } catch (Exception var3) {
                                var3.printStackTrace();
                            }
                        }
                    }

                    WebSocketHelper.this.isRunning = false;
                    Log.i(WebSocketHelper.TAG, "robot websocket run over");
                }
            };
            Thread thread = new Thread(runnable);
            thread.start();
        }
    }

    public int sendMsg(String message) {
        Log.d(TAG, "message==" + message);
        synchronized(this.ws_robot) {
            try {
                if (this.ws_robot != null) {
                    this.ws_robot.send(message);
                }
            } catch (Exception var5) {
                var5.printStackTrace();
                isOpenOk = false;
                return 1;
            }

            return 0;
        }
    }

    public void destroy() {
        try {
            this.isInterrupt = true;
            if (this.ws_robot != null) {
                this.ws_robot.closeBlocking();
            }
        } catch (Exception var2) {
            var2.printStackTrace();
        }

    }

    private class RobotWebSocket extends WebSocketClient {
        private WebSokcetCallback cb_;

        RobotWebSocket(URI serverUri, Draft protocolDraft, WebSokcetCallback cb) {
            super(serverUri);
            this.cb_ = cb;
        }

        public void onOpen(ServerHandshake handshakedata) {
            Log.i(WebSocketHelper.TAG, "onOpen");
            WebSocketHelper.isOpenOk = true;
            if (this.cb_ != null) {
                this.cb_.onConnect();
            }

        }

        public void onMessage(String message) {
            Log.d(WebSocketHelper.TAG, "receive: " + message);
            if (this.cb_ != null) {
                this.cb_.onMessageData(message);
            }

        }

        public void onClose(int code, String reason, boolean remote) {
            Log.i(WebSocketHelper.TAG, "Connection close by " + (remote ? "remote peer" : "us") + " at " + new Date(System.currentTimeMillis()));
            WebSocketHelper.isOpenOk = false;
            if (this.cb_ != null) {
                this.cb_.onDisonnect();
            }

        }

        public void onError(Exception ex) {
            Log.e(WebSocketHelper.TAG, "onError" + ex.getMessage());
            WebSocketHelper.isOpenOk = false;
            if (this.cb_ != null) {
                this.cb_.onDisonnect();
            }

        }
    }

    public interface WebSokcetCallback {
        void onConnect();

        void onDisonnect();

        void onMessageData(String var1);
    }

    private static class SingletonHolder {
        private static final WebSocketHelper instance = new WebSocketHelper();

        private SingletonHolder() {
        }
    }
}
2、HttpURLConnectionUtil
import android.support.annotation.Nullable;
import android.util.Log;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URL;

/**
 * author : jsxin
 * e-mail : jsxin0816@163.com
 * time   : 2023/07/24
 * desc   :
 */
public class HttpURLConnectionUtil {
    public static final String TAG = HttpURLConnectionUtil.class.getSimpleName();

    public HttpURLConnectionUtil() {
    }

    public static String doGet(String httpUrl) {
        HttpURLConnection connection = null;
        InputStream is = null;
        BufferedReader br = null;
        StringBuffer result = new StringBuffer();

        try {
            URL url = new URL(httpUrl);
            connection = (HttpURLConnection)url.openConnection();
            connection.setRequestMethod("GET");
            connection.setReadTimeout(15000);
            connection.connect();
            if (connection.getResponseCode() == 200) {
                is = connection.getInputStream();
                if (null != is) {
                    br = new BufferedReader(new InputStreamReader(is, "UTF-8"));
                    String temp = null;

                    while(null != (temp = br.readLine())) {
                        result.append(temp);
                    }
                }
            }
        } catch (IOException var19) {
            var19.printStackTrace();
        } finally {
            if (null != br) {
                try {
                    br.close();
                } catch (IOException var18) {
                    var18.printStackTrace();
                }
            }

            if (null != is) {
                try {
                    is.close();
                } catch (IOException var17) {
                    var17.printStackTrace();
                }
            }

            connection.disconnect();
        }

        return result.toString();
    }

    public static String doPost(String httpUrl, @Nullable String param) {
        StringBuffer result = new StringBuffer();
        HttpURLConnection connection = null;
        OutputStream os = null;
        InputStream is = null;
        BufferedReader br = null;

        try {
            URL url = new URL(httpUrl);
            connection = (HttpURLConnection)url.openConnection();
            connection.setRequestMethod("POST");
            connection.setConnectTimeout(15000);
            connection.setReadTimeout(15000);
            connection.setUseCaches(false);
            connection.setDoOutput(true);
            connection.setDoInput(true);
            connection.setRequestProperty("accept", "*/*");
            connection.setRequestProperty("connection", "Keep-Alive");
            connection.setRequestProperty("Content-Type", "application/json;charset=utf-8");
            connection.setRequestProperty("user-agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.67 Safari/537.36)");
            if (null != param && !param.equals("")) {
                os = connection.getOutputStream();
                os.write(param.getBytes("UTF-8"));
                os.flush();
            }

            int httpstatus = connection.getResponseCode();
            Log.i(TAG, "http status :" + httpstatus);
            if (httpstatus == 200) {
                is = connection.getInputStream();
                if (null != is) {
                    br = new BufferedReader(new InputStreamReader(is, "utf-8"));
                    String temp = null;

                    while(null != (temp = br.readLine())) {
                        result.append(temp);
                        result.append("\r\n");
                    }
                }
            }
        } catch (MalformedURLException var30) {
            var30.printStackTrace();
        } catch (IOException var31) {
            var31.printStackTrace();
        } finally {
            if (br != null) {
                try {
                    br.close();
                } catch (IOException var29) {
                    var29.printStackTrace();
                }
            }

            if (os != null) {
                try {
                    os.close();
                } catch (IOException var28) {
                    var28.printStackTrace();
                }
            }

            if (is != null) {
                try {
                    is.close();
                } catch (IOException var27) {
                    var27.printStackTrace();
                }
            }

            connection.disconnect();
        }

        return result.toString();
    }
}
3、Java-WebSocket-1.3.9.jar包(上传的是个压缩包,直接解压就能用)

链接: https://pan.baidu.com/s/1ypl-bAsmERHn8D2XfdeZBQ?pwd=tcun 提取码: tcun文章来源地址https://www.toymoban.com/news/detail-607589.html

到了这里,关于WebSocket工具类的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • jmeter工具测试和压测websocket协议【杭州多测师_王sir】

    一、安装JDK配置好环境变量,安装好jmeter 二、下载WebSocketSampler发送请求用的 ,地址:https://bitbucket.org/pjtr/jmeter-websocket-samplers/downloads/?spm=a2c4g.11186623.2.15.363f211bH03KeI 下载解压后的jar包放到D:JMeterapache-jmeter-3.3libext目录下 三、如果需要在jmeter中安装那么就需要下载jmeter的插件

    2024年02月13日
    浏览(45)
  • 前端面试:【网络协议与性能优化】HTTP/HTTPS、TCP/IP和WebSocket

    嗨,亲爱的Web开发者!在构建现代Web应用时,了解网络协议是优化性能和确保安全性的关键。本文将深入探讨HTTP/HTTPS、TCP/IP和WebSocket这三个网络协议,帮助你理解它们的作用以及如何优化Web应用的性能。 1. HTTP/HTTPS协议: HTTP(超文本传输协议): HTTP是用于在Web上传输数据的

    2024年02月11日
    浏览(51)
  • Go语言github.com/gorilla/websocket框架websocket协议通信实战

          websocket是实际开发中比较常用的应用层协议,本文利用github.com/gorilla/websocket框架进行websocket通信实战。 目录 1.下载github.com/gorilla/websocket 2.websocket服务端 3.websocket Go客户端 4.websocket 网页客户端 5.运行结果展示 go get github.com/gorilla/websocket 服务器:  Go语言客户端:  We

    2024年02月16日
    浏览(49)
  • WebSocket协议介绍

    WebSocket 协议是一种基于 TCP 的通讯协议,它允许双向通信,使客户端和服务器之间的数据交换变得更加高效。在本文中,我们会深入了解 WebSocket 协议以及它对现代 Web 应用程序的重要性和应用场景。   WebSocket 协议是一种全双工的通讯协议,它使用标准 HTTP/HTTPS 端口(80 和

    2024年02月14日
    浏览(44)
  • [前端基础]websocket协议

    (1)websocket websocket(简写为ws),是一种轻量化的协议,经过最开始的握手阶段以后,前后端之间允许自由地发送信息不受限制(建议发送json字符串).虽然理论上这个东西是属于协议内容,但是已经被疯狂封装得像框架一样了. websocket协议具有天然的优势处理前端多线程并发,并且只需要一

    2024年02月08日
    浏览(42)
  • WebSocket 协议及其使用案例

    WebSocket 协议是一种用于实时通信、全双工的网络协议。它运行在传输层之上,通常基于 TCP 连接。相较于传统的 HTTP 协议,WebSocket 协议能够在单个连接上进行 双向通信 ,实现 数据的实时交互 ,因此在实时性较高的应用中表现得尤为出色。 WebSocket 协议是一种允许服务器和客

    2024年02月10日
    浏览(42)
  • java实现websocket握手协议

    其中最重要的是最后几个换行不要丢,将字符串转成byte[]写给客户端即可 收到的掩码转换 下面是服务器向客户端发送消息

    2024年02月08日
    浏览(42)
  • netty对websocket协议的实现

    1. websocket协议 websocket协议是对http协议的扩充, 也是使用的TCP协议可以全双工通信的应用层协议。 websocket协议允许服务端向客户端推送消息。 浏览器和服务端只需要进行一次握手,不必像http协议一样,每次连接都要新建立连接,两者之间创建持久性的连接,并进行双向的数

    2024年01月20日
    浏览(45)
  • Websocket协议-http协议-tcp协议区别和相同点

    通讯形式 单工通讯-数据只能单向传送一方来发送数据,另一方来接收数据 半双工通讯-数据能双向传送但不能同时双向传送 全双工通讯-数据能够同时双向传送和接受 注:http的通讯方式是分版本 http1.0 :单工。因为是短连接,客户端发起请求之后,服务端处理完请求并收到

    2024年02月15日
    浏览(57)
  • WebSocket和HTTP协议有什么区别?&& 连环问:WebSocket和HTTP长轮询的区别?

    什么是WebSocket? 答:WebSocket是一种网络传输协议,可在单个TCP连接上进行全双工通信,位于OSI模型的应用层。 特点: 1. TCP连接,与HTTP协议兼容 2. 双向通信,主动推送(服务端向客户端) 3. 无同源限制,协议标识符是ws(加密wss) WebSocket: 1. 支持端对端通讯 2. 可以由client发起

    2024年02月11日
    浏览(44)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包