Android WebSocket长连接的实现

一、为什么需要 WebSocket

初次接触 WebSocket 的人，都会问同样的问题：我们已经有了 HTTP 协议，为什么还需要另一个协议？它能带来什么好处？

答案很简单，因为 HTTP 协议有一个缺陷：通信只能由客户端发起。

举例来说，我们想了解今天的天气，只能是客户端向服务器发出请求，服务器返回查询结果。HTTP 协议做不到服务器主动向客户端推送信息。

这种单向请求的特点，注定了如果服务器有连续的状态变化，客户端要获知就非常麻烦。我们只能使用[“轮询”]：每隔一段时候，就发出一个询问，了解服务器有没有新的信息，最典型的场景就是聊天室。

轮询的效率低，非常浪费资源（因为必须不停连接，或者 HTTP 连接始终打开）。因此，开发工程师们一直在思考，有没有更好的方法。WebSocket 就是这样发明的。

二、 WebSocket的简介

WebSocket 协议在2008年诞生，2011年成为国际标准。所有浏览器都已经支持了。

它的最大特点就是，服务器可以主动向客户端推送信息，客户端也可以主动向服务器发送信息，是真正的双向平等对话，属于[“服务器推送技术”]的一种。
bg2017051502.png
WebSocket的特点包括：

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

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

  3. 支持双向通信，实时性更强

  4. 数据格式比较轻量，性能开销小，通信高效。

  5. 可以发送文本，也可以发送二进制数据。

  6. 没有同源限制，客户端可以与任意服务器通信。

  7. 协议标识符是ws（如果加密，则为wss），服务器网址就是 URL。

ws://echo.websocket.org

bg2017051503.jpg

三、WebSocket 实现Android客户端与服务器的长连接

Android客户端选择已经成熟的框架，Java-WebSocket，GitHub地址：https://github.com/TooTallNate/Java-WebSocket

（一）引入Java-WebSocket

1、build.gradle中加入
  implementation "org.java-websocket:Java-WebSocket:1.5.1"
2、加入网络请求权限
     <uses-permission android:name="android.permission.INTERNET" />
3、新建客户端类

新建一个客户端类并继承WebSocketClient，需要实现它的四个抽象方法、构造函数和onSetSSLParameters方法

     public class JWebSocketClient extends WebSocketClient {

    @Override
    protected void onSetSSLParameters(SSLParameters sslParameters) {
//        super.onSetSSLParameters(sslParameters);
    }

    public JWebSocketClient(URI serverUri) {
        super(serverUri, new Draft_6455());
    }

    @Override
    public void onOpen(ServerHandshake handShakeData) {//在webSocket连接开启时调用
    }

    @Override
    public void onMessage(String message) {//接收到消息时调用
    }

    @Override
    public void onClose(int code, String reason, boolean remote) {//在连接断开时调用
    }

    @Override
    public void onError(Exception ex) {//在连接出错时调用
    }
}

其中onOpen()方法在websocket连接开启时调用，onMessage()方法在接收到消息时调用，onClose()方法在连接断开时调用，onError()方法在连接出错时调用。构造方法中的new Draft_6455()代表使用的协议版本，这里可以不写或者写成这样即可。

4、建立websocket连接

建立连接只需要初始化此客户端再调用连接方法，需要注意的是WebSocketClient对象是不能重复使用的，所以不能重复初始化，其他地方只能调用当前这个Client。

URI uri = URI.create("ws://*******");
JWebSocketClient client = new JWebSocketClient(uri) {
    @Override
    public void onMessage(String message) {
        //message就是接收到的消息
        Log.e("JWebSClientService", message);
    }
};

为了方便对接收到的消息进行处理，可以在这重写onMessage()方法。初始化客户端时需要传入websocket地址（测试地址：ws://echo.websocket.org），websocket协议地址大致是这样的，协议标识符是ws（如果加密，则为wss）

ws:// ip地址 : 端口号

连接时可以使用connect()方法或connectBlocking()方法，建议使用connectBlocking()方法，connectBlocking多出一个等待操作，会先连接再发送。

try {
    client.connectBlocking();
} catch (InterruptedException e) {
    e.printStackTrace();
}
5、发送消息

发送消息只需要调用send()方法，如下

if (client != null && client.isOpen()) {
    client.send("你好");
}
6、关闭socket连接

关闭连接调用close()方法，最后为了避免重复实例化WebSocketClient对象，关闭时一定要将对象置空。

/**
 * 断开连接
 */
private void closeConnect() {
    try {
        if (null != client) {
            client.close();
        }
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        client = null;
    }
}

（二）WebSocket的封装

1、新建一个客户端类并继承WebSocketClient
public class JWebSocketClient extends WebSocketClient {

    @Override
    protected void onSetSSLParameters(SSLParameters sslParameters) {
//        super.onSetSSLParameters(sslParameters);
    }

    public JWebSocketClient(URI serverUri) {
        super(serverUri, new Draft_6455());
    }

    @Override
    public void onOpen(ServerHandshake handShakeData) {//在webSocket连接开启时调用
    }

    @Override
    public void onMessage(String message) {//接收到消息时调用
    }

    @Override
    public void onClose(int code, String reason, boolean remote) {//在连接断开时调用
    }

    @Override
    public void onError(Exception ex) {//在连接出错时调用
    }
}
2、新建WebSocketEvent，用于传递消息事件
public class WebSocketEvent {
    private String message;

    public WebSocketEvent(String message) {
        this.message = message;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}
3、新建WebSocketService服务，用于消息管理和保持长连接状态
public class WebSocketService extends Service {
    private final static String TAG = WebSocketService.class.getSimpleName();

    public JWebSocketClient client;
    private JWebSocketClientBinder mBinder = new JWebSocketClientBinder();
    private final static int GRAY_SERVICE_ID = 1001;

    private static final long CLOSE_RECON_TIME = 100;//连接断开或者连接错误立即重连

    //用于Activity和service通讯
    public class JWebSocketClientBinder extends Binder {
        public WebSocketService getService() {
            return WebSocketService.this;
        }
    }

    //灰色保活
    public static class GrayInnerService extends Service {

        @Override
        public int onStartCommand(Intent intent, int flags, int startId) {
            startForeground(GRAY_SERVICE_ID, new Notification());
            stopForeground(true);
            stopSelf();
            return super.onStartCommand(intent, flags, startId);
        }

        @Override
        public IBinder onBind(Intent intent) {
            return null;
        }
    }

    @Override
    public IBinder onBind(Intent intent) {
        LogUtil.i(TAG, "WebSocketService onBind");
        return mBinder;
    }

    @Override
    public void onCreate() {
        super.onCreate();
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
            //初始化WebSocket
            initSocketClient();
            mHandler.postDelayed(heartBeatRunnable, HEART_BEAT_RATE);//开启心跳检测

        //设置service为前台服务，提高优先级
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN_MR2) {
            //Android4.3以下 ，隐藏Notification上的图标
            startForeground(GRAY_SERVICE_ID, new Notification());
        } else if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
            //Android4.3 - Android8.0，隐藏Notification上的图标
            Intent innerIntent = new Intent(this, GrayInnerService.class);
            startService(innerIntent);
            startForeground(GRAY_SERVICE_ID, new Notification());
        } else {
           //Android8.0以上app启动后通知栏会出现一条"正在运行"的通知
            NotificationChannel channel = new NotificationChannel(NotificationUtil.channel_id, NotificationUtil.channel_name,
                    NotificationManager.IMPORTANCE_HIGH);
            NotificationManager manager = (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
            if (manager != null) {
                manager.createNotificationChannel(channel);
                Notification notification = new Notification.Builder(getApplicationContext(), NotificationUtil.channel_id_tai_bang).build();
                startForeground(GRAY_SERVICE_ID, notification);
            }
        }
        return START_STICKY;
    }

    private void initSocketClient() {
        String url = BuildConfig.WS_PERFIX;
        URI uri = URI.create(url);
        client = new JWebSocketClient(uri) {
            @Override
            public void onMessage(String message) {
                //message就是接收到的消息
                LogUtil.i(TAG, "WebSocketService收到的消息：" + message);

                EventBus.getDefault().post(new WebSocketEvent(message));
        }

            @Override
            public void onOpen(ServerHandshake handShakeData) {//在webSocket连接开启时调用
                LogUtil.i(TAG, "WebSocket 连接成功");
            }

            @Override
            public void onClose(int code, String reason, boolean remote) {//在连接断开时调用
                LogUtil.e(TAG, "onClose() 连接断开_reason：" + reason);

                mHandler.removeCallbacks(heartBeatRunnable);
                mHandler.postDelayed(heartBeatRunnable, CLOSE_RECON_TIME);//开启心跳检测
            }

            @Override
            public void onError(Exception ex) {//在连接出错时调用
                LogUtil.e(TAG, "onError() 连接出错：" + ex.getMessage());

                mHandler.removeCallbacks(heartBeatRunnable);
                mHandler.postDelayed(heartBeatRunnable, CLOSE_RECON_TIME);//开启心跳检测
            }
        };
        connect();
    }

    /**
     * 连接WebSocket
     */
    private void connect() {
        new Thread() {
            @Override
            public void run() {
                try {
                    //connectBlocking多出一个等待操作，会先连接再发送，否则未连接发送会报错
                    client.connectBlocking();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }.start();
    }

    /**
     * 发送消息
     */
    public void sendMsg(String msg) {
        if (null != client) {
            LogUtil.i(TAG, "发送的消息：" + msg);
            try {
                client.send(msg);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    @Override
    public boolean onUnbind(Intent intent) {
        LogUtil.e(TAG, "Service onUnbind");
        return super.onUnbind(intent);
    }

    @Override
    public void onDestroy() {
        closeConnect();
        super.onDestroy();
    }

    /**
     * 断开连接
     */
    public void closeConnect() {
        mHandler.removeCallbacks(heartBeatRunnable);
        try {
            if (null != client) {
                client.close();
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            client = null;
        }
    }


    //    -------------------------------------WebSocket心跳检测------------------------------------------------
    private static final long HEART_BEAT_RATE = 10 * 1000;//每隔10秒进行一次对长连接的心跳检测
    private Handler mHandler = new Handler();
    private Runnable heartBeatRunnable = new Runnable() {
        @Override
        public void run() {
            if (client != null) {
                if (client.isClosed()) {
                    reconnectWs();
                    LogUtil.e(TAG, "心跳包检测WebSocket连接状态：已关闭");
                } else if (client.isOpen()) {
                    LogUtil.d(TAG, "心跳包检测WebSocket连接状态：已连接");
                } else {
                    LogUtil.e(TAG, "心跳包检测WebSocket连接状态：已断开");
                }
            } else {
                //如果client已为空，重新初始化连接
                initSocketClient();
                LogUtil.e(TAG, "心跳包检测WebSocket连接状态：client已为空，重新初始化连接");
            }
            //每隔一定的时间，对长连接进行一次心跳检测
            mHandler.postDelayed(this, HEART_BEAT_RATE);
        }
    };

    /**
     * 开启重连
     */
    private void reconnectWs() {
        mHandler.removeCallbacks(heartBeatRunnable);
        new Thread() {
            @Override
            public void run() {
                try {
                    LogUtil.e(TAG, "开启重连");
                    client.reconnectBlocking();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }.start();
    }
}
4、在Application中开启WebSocketService服务
    /**
     * 开启并绑定WebSocket服务
     */
    public void startWebSocketService() {
        Intent bindIntent = new Intent(this, WebSocketService.class);
        startService(bindIntent);
        bindService(bindIntent, serviceConnection, BIND_AUTO_CREATE);
    }
5、通过WebSocketService向服务器发送消息
     if (NsApplication.getInstance().getWebSocketService() != null &&
                NsApplication.getInstance().getWebSocketService().client != null && NsApplication.getInstance().getWebSocketService().client.isOpen()) {
            JSONObject jsonObject = new JSONObject();
       NsApplication.getInstance().getWebSocketService().sendMsg(jsonObject );
        } else {
            LogUtil.e(TAG, "WebSocket连接已断开");
        }
    }
6、通过WebSocketService接收服务器发来的消息
    @Subscribe(threadMode = ThreadMode.MAIN)
    public void onMessageEvent(WebSocketEvent event) {
        if (event != null) {
            LogUtil.e(TAG, "接收消息内容：" + event.getMessage());
            }
    }
7、Application
public class NsApplication extends Application {
    private final static String TAG = NsApplication.class.getSimpleName();

    private static NsApplication instance;
    private static final String DEVICE_TOKEN = "device_token";//设备token
    public WebSocketService mWebSocketService;
    //    -------------------------------------WebSocket发送空消息心跳检测------------------------------------------------
    private static final long HEART_BEAT_RATE = 60 * 1000;//每隔1分钟发送空消息保持WebSocket长连接

    public static NsApplication getInstance() {
        if (instance == null) {
            instance = new NsApplication();
        }
        return instance;
    }
    private Handler mHandler = new Handler();


    private Runnable webSocketRunnable = new Runnable() {
        @Override
        public void run() {
            if (mWebSocketService != null &&
                    mWebSocketService.client != null && mWebSocketService.client.isOpen()) {
                try {
                    JSONObject jsonObject = new JSONObject();
                    jsonObject.put("from","");
                    jsonObject.put("to", "");

                    LogUtil.e(TAG, "JSONObject：" + jsonObject.toString());
                    mWebSocketService.sendMsg(jsonObject.toString());
                } catch (JSONException e) {
                    e.printStackTrace();
                }
            }
            //每隔一定的时间，对长连接进行一次心跳检测
            mHandler.postDelayed(this, HEART_BEAT_RATE);
        }
    };


    public WebSocketService getWebSocketService() {
        return mWebSocketService;
    }

    /**
     * 开启并绑定WebSocket服务
     */
    public void startWebSocketService(String deviceToken) {
        Intent bindIntent = new Intent(this, WebSocketService.class);
        bindIntent.putExtra(DEVICE_TOKEN, deviceToken);
        startService(bindIntent);
        bindService(bindIntent, serviceConnection, BIND_AUTO_CREATE);

        mHandler.removeCallbacks(webSocketRunnable);
        mHandler.postDelayed(webSocketRunnable, HEART_BEAT_RATE);//开启心跳检测
    }


    private ServiceConnection serviceConnection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
            //服务与活动成功绑定
            mWebSocketService = ((WebSocketService.JWebSocketClientBinder) iBinder).getService();
            LogUtil.e(TAG, "WebSocket服务与Application成功绑定");
        }

        @Override
        public void onServiceDisconnected(ComponentName componentName) {
            //服务与活动断开
            mWebSocketService = null;
            LogUtil.e(TAG, "WebSocket服务与Application成功断开");
        }
    };
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/705323.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【Three.js】知识梳理十九：线性雾（Fog）、指数雾（FogExp2）和范围雾（RangeFog）

【Three.js】知识梳理十九：线性雾（Fog）、指数雾（FogExp2）和范围雾（RangeFog）

雾是3D图形中创建深度和氛围的重要工具。Three.js提供了多种类型的雾&#xff1a;线性雾&#xff08;THREE.Fog&#xff09;&#xff0c;指数雾&#xff08;THREE.FogExp2&#xff09;和范围雾&#xff08;RangeFog&#xff09;。本文将探讨这三种类型的雾&#xff0c;通过代码…
阅读更多...
OLED柔性屏的显示效果如何

OLED柔性屏的显示效果如何

OLED柔性屏的显示效果非常出色&#xff0c;具有多方面的优势。以下是关于OLED柔性屏显示效果的详细分析&#xff1a; 色彩表现&#xff1a;OLED柔性屏的每个像素都可以独立发光&#xff0c;因此色彩准确性极高。黑色呈现得非常深邃&#xff0c;而亮部则展现出鲜明而生动的细节。…
阅读更多...
Python-docx将Word文档的目录或文本框作为普通段落读入

Python-docx将Word文档的目录或文本框作为普通段落读入

&#x1f4e2;作者&#xff1a; 小小明-代码实体 &#x1f4e2;博客主页&#xff1a;https://blog.csdn.net/as604049322 &#x1f4e2;欢迎点赞 &#x1f44d; 收藏 ⭐留言 &#x1f4dd; 欢迎讨论&#xff01; 昨天我们处理Word文档的自动编号&#xff0c;详见《Python解析Wo…
阅读更多...
maven 显式依赖包包含隐式依赖包，引起依赖包冲突

maven 显式依赖包包含隐式依赖包，引起依赖包冲突

问题&#xff1a;FlinkCDC 3.0.1 代码 maven依赖包冲突 什么是依赖冲突 依赖冲突是指项目依赖的某一个jar包&#xff0c;有多个不同的版本&#xff0c;因而造成类包版本冲突 依赖冲突的原因 依赖冲突很经常是类包之间的间接依赖引起的。每个显式声明的类包都会依赖于一些其它…
阅读更多...
springbot 界面美观的超市收银管理系统。

springbot 界面美观的超市收银管理系统。

springbot 界面美观的超市收银管理系统。 功能&#xff1a;登录&#xff0c;用户管理&#xff0c;权限菜单管理&#xff0c;首页订单&#xff0c;收入&#xff0c;用户统计&#xff0c; 收银台&#xff0c;销售账单&#xff0c;库存管理&#xff0c;商品分类&#xff0c;供应…
阅读更多...
如何在浏览器书签栏设置2个书签实现一键到达网页顶部和底部

如何在浏览器书签栏设置2个书签实现一键到达网页顶部和底部

本次设置浏览器为&#xff1a;Chrome浏览器&#xff08;其他浏览器可自行测试&#xff09; 1&#xff0c;随便收藏一个网页到浏览器书签栏 2&#xff0c;右键这个书签 3&#xff0c;修改 4&#xff0c;修改名称 5&#xff0c;修改网址&#xff1a; javascript:(function(…
阅读更多...
Vue3中使用深度选择器不起作用

Vue3中使用深度选择器不起作用

问题&#xff1a; 想要给这个菜单设置高度100%&#xff0c;使用深度样式选择器无效 这样写无效 但是如下在控制台写是有效果的 解决&#xff1a; 参考 解决方法是给这个组件增加一个根元素&#xff0c;然后再使用深度选择器
阅读更多...
【Linux】线程（一）

【Linux】线程（一）

谈论之前需要先谈论一些线程的背景知识 其中就有进程地址空间&#xff0c;又是这个让我们又爱又恨的东西 目录 背景知识&#xff1a;地址空间&#xff1a; 背景知识&#xff1a; 地址空间&#xff1a; 说在前边&#xff0c;OS通常分为4个核心模块&#xff1a;执行流管理&…
阅读更多...
IDEA项目上传Github流程+常见问题解决

IDEA项目上传Github流程+常见问题解决

一、Github上创建仓库 项目创建好后如图所示 二、IDEA连接Github远程仓库 管理远程 复制远程地址 定义远程 登录Github 点击进入File->Settings->Version Control->Github登录自己的账号并勾上“√” 三、推送项目 点击推送 修改为main 点击确定&#xff0c;打开远程…
阅读更多...
Python基础教程（十六）：正则表达式

Python基础教程（十六）：正则表达式

&#x1f49d;&#x1f49d;&#x1f49d;首先&#xff0c;欢迎各位来到我的博客&#xff0c;很高兴能够在这里和您见面&#xff01;希望您在这里不仅可以有所收获&#xff0c;同时也能感受到一份轻松欢乐的氛围&#xff0c;祝你生活愉快&#xff01; &#x1f49d;&#x1f49…
阅读更多...
Linux服务器快速下载GoogleDriver小技巧——利用gdown工具

Linux服务器快速下载GoogleDriver小技巧——利用gdown工具

Linux服务器快速下载GoogleDriver小技巧——利用gdown工具 1. 安装gdown pip install gdown安装好后如果在终端输入gdown显示如下错误&#xff1a;gdown: command not found&#xff0c;则说明gdown默认安装的位置需要软链接一下&#xff0c;执行以下命令&#xff1a; sudo …
阅读更多...
Qt全局快捷键QGlobalHotKey的自研之路

Qt全局快捷键QGlobalHotKey的自研之路

这两天对Qt的快捷键格外感兴趣。 前两天在使用QHotKey的过程中&#xff0c;发现不能定义小键盘键盘码&#xff0c;自己二次修改了该库之后已经可以设置小键盘快捷键了。文章在这里&#xff1a;Qt第三方库QHotKey设置小键盘数字快捷键。 昨天突发奇想&#xff1a;目前所有的快…
阅读更多...
前端项目打包部署

前端项目打包部署

打包 vue-cli脚手架的前端项目&#xff0c;点击npm脚本中的第二条编译命令&#xff0c;即可将项目编译&#xff0c;生成一个dist的文件夹&#xff0c;里面存放的就是编译好的前端项目文件&#xff0c;没有脚手架就在终端敲击npm run build命令编译前端项目 部署 Nginx 介绍:…
阅读更多...
D咖饮品机入驻奇轩商贸，为DF101大规模入驻荆州拉开序幕

D咖饮品机入驻奇轩商贸，为DF101大规模入驻荆州拉开序幕

荆州&#xff0c;一座历史悠久的城市&#xff0c;如今正焕发着新的活力与魅力。而这股活力的源泉之一&#xff0c;正是奇轩商贸的一次创新尝试——D咖智能饮品机的入驻。这不仅仅是一次机器设备的更新&#xff0c;更是一场技术与美味的碰撞&#xff0c;为DF101大规模入驻荆州市…
阅读更多...
汽车EDI：BRP EDI项目案例

汽车EDI：BRP EDI项目案例

项目背景 BRP Inc.使用EDI&#xff08;电子数据交换&#xff09;来处理其与供应商、客户和合作伙伴之间的业务交流。通过EDI&#xff0c;BRP可以在各种业务流程中自动化数据交换&#xff0c;例如采购订单、发货通知、发票、付款和库存信息等&#xff0c;从而提高操作效率、降低…
阅读更多...
【小白学Python】自定义图片的生成（二）

【小白学Python】自定义图片的生成（二）

Python学习 【小白学Python】自定义图片的生成&#xff08;一&#xff09; 目录 1. 文件内容2.生成图片规则3. 修改代码2.1 尝试一行汉字展示3.1 读取txt文件3.2 解决文字过长问题3.3 删减指定文字 4. 总结 1. 文件内容 正如上篇文章所说&#xff0c;我需要读取txt文件的文字内…
阅读更多...
KUKA机器人KRC5控制柜面板LED显示

KUKA机器人KRC5控制柜面板LED显示

对于KUKA机器人新系列控制柜KRC5控制柜来说&#xff0c;其控制柜面板LED布局如下图&#xff1a; 其中①②③④分别为&#xff1a; 1、机器人控制柜处于不同状态时&#xff0c;LED显示如下&#xff1a; 2、机器人控制柜正在运行时&#xff1a; 3、机器人控制柜运行时出现的故障…
阅读更多...
数据结构重要知识总结

数据结构重要知识总结

数组 数组&#xff08;Array&#xff09; 是一种很常见的数据结构。它由相同类型的元素&#xff08;element&#xff09;组成&#xff0c;并且是使用一块连续的内存来存储。 我们直接可以利用元素的索引&#xff08;index&#xff09;可以计算出该元素对应的存储地址。 数组…
阅读更多...
【C++】stack、queue模拟实现

【C++】stack、queue模拟实现

&#x1f497;个人主页&#x1f497; ⭐个人专栏——C学习⭐ &#x1f4ab;点击关注&#x1f929;一起学习C语言&#x1f4af;&#x1f4ab; 目录 导读 1. stack和queue的底层 1.1 stack 1.2 queue 2. 什么是适配器 3. 常见适配器 4. stack具体实现 4.1 成员变量 4.2 …
阅读更多...
wms海外仓系统有哪些？选择的时候怎么避坑

wms海外仓系统有哪些？选择的时候怎么避坑

虽然说wms海外仓系统能够在很大程度上提升海外仓的经营效率&#xff0c;但是如果在选择wms海外仓系统的时候没有慎重考虑&#xff0c;也是非常容易踩坑的。 这样不只是不能提升自己海外仓的效率&#xff0c;反倒是浪费了大量的预算和精力&#xff0c;这就得不偿失了。今天我们…
阅读更多...
最新文章

Copyright @ 2022~2023