自定义 Socket 通信模块管理类设计

最新推荐文章于 2024-03-14 19:28:45 发布
最新推荐文章于 2024-03-14 19:28:45 发布
阅读量201 收藏 1
点赞数
分类专栏： 安卓 文章标签： android 安卓 socket
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lfq88/article/details/118082697
版权

自定义安卓 socket 通信模块系列

前面已经将 socket 发送接收的 Service 讲完了，这一节将再封装一些功能，将模块统一对外展示。

待解决问题

和上一篇博客一样，我们先列举还剩下的问题，后面一个一个解决，问题如下：

  • 连接 Service、关闭 Service、设置 Service 初始参数
  • 异步线程转换为主线程
  • 对外提供发送请求的方法
  • 消息（异常及回复数据）和请求类的匹配
  • 请求类超时设计

下面来解决上面的问题，通过新增一个 ConnectManager 类实现。

连接、关闭、设置 Service

这个便是通过 Binder 机制连接、关闭 Service 了，设置参数需要由外面设置，下面看代码：

private ConnectService.ConnectBinder mBinder;
private final ServiceConnection connection = new ServiceConnection() {
    @Override
    public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
        mBinder = (ConnectService.ConnectBinder) iBinder;
        //回调处理发送失败
        mBinder.getService().setOnPostMessageListener(new ConnectService.OnPostMessageListener() {

            @Override
            public void onPostError(int typeId) {
                sendErrorToUiThread(typeId);
            }

            @Override
            public void onPostResponse(BaseResponse response) {
                sendResponseToUiThread(response);
            }
        });
    }

    @Override
    public void onServiceDisconnected(ComponentName componentName) {

    }
};

这里就是使用 binder 连接 service 了，下面还有几个对外接口，供外面连接、关闭、设置 service。

public void setUpSocketConfigure(Bundle data) {
    mBinder.setUpSocketConfigure(data);
    uiHandler.sendEmptyMessage(-1);
}

public void bindConnectService(Context context) {
    Intent intent = new Intent(context, ConnectService.class);
    context.bindService(intent, connection, BIND_AUTO_CREATE);

}

public void unbindConnectService(Context context) {
    context.unbindService(connection);
}

异步线程转换为主线程

因为我们的数据从接收线程读取过来，如果直接回调将不能做 UI 操作，所以需要做下转换。

	private void sendErrorToUiThread(int typeId) {
    	Message message = uiHandler.obtainMessage(-1, typeId, 0);
    	uiHandler.sendMessage(message);
	}

	private void sendResponseToUiThread(BaseResponse response) {
    	Message message = uiHandler.obtainMessage(1);
    	Bundle bundle = new Bundle();
    	bundle.putParcelable("response", response);
    	message.setData(bundle);
    	uiHandler.sendMessage(message);
	}

	@SuppressLint("HandlerLeak")
    private final Handler uiHandler = new Handler() {
        @Override
        public void handleMessage(@NonNull Message msg) {
            switch (msg.what) {
                case 0:
                    handleError(msg.arg1);
                    break;
                case 1:
                    BaseResponse response = msg.getData().getParcelable("response");
                    if (response != null) {
                        handleResponse(response);
                    }
                    break;
                case -1:
                    handleTimeout();
                    uiHandler.sendEmptyMessageDelayed(-1, 100);
                    default:
            }
        }
    };

这里没什么好说的，就是在 mBinder 中拿到数据通过主线程的 Handler 处理一下。异常数据我们只需要请求的消息类型就可以了（int 型），而回复要通过 Bundle 传递，所以我们前面设计回复基类的时候使用到了序列化。

对外提供发送请求的方法

我们需要使用通信模块的地方，希望通过一个请求就可以通过回调处理结果，所以需要向外提供一个接收请求的方法：

	//注意线程安全，ArrayList出问题
	private final List<BaseRequest> requestList = new CopyOnWriteArrayList<>();

    public void sendMessage(BaseRequest request) {
        requestList.add(request);
        //TODO 解决mBinder为空
        if (request.isSendOut && mBinder != null) {
            mBinder.sendMessage(request);
        }
    }

这里用了一个 CopyOnWriteArrayList 储存请求，因为我们的请求可在任意地方触发，需要线程同步处理。另外前面设计请求类的 isSendOut 字段，在这里生效了。

这里有个 mBinder 会为 null 的问题，很奇怪，我没有解决。

消息（异常及回复数据）和请求类的匹配

接下来就是异常及回复数据的匹配问题了，异常时拿着请求的类型，回复由回复的类型，我们遍历请求的列表就能找到需要触发的回复了。

    private void handleError(int typeId) {
        for (BaseRequest request : requestList) {
            if (request == null) {
                requestList.remove(null);
            } else if (request.requestMsgType == typeId) {
                request.callback.onError(typeId);
                requestList.remove(request);
            }
        }
    }

    /* --处理说明--
    一对零：不求回复，直接移除（checkTimeout）

    一对一：一般模式，直接结束
    一对多：定位报值，多条接受

    零/一对无限：wantNumb = -1,特别处理
    */
    private void handleResponse(@NonNull BaseResponse response) {
        for (BaseRequest request : requestList) {
            if (request == null) {
                requestList.remove(null);
            } else if (request.responseMsgType == response.responseMsgType) {
                if (!request.isReachWant() || request.isWantInfinite()) {
                    request.callback.onResponse(response);
                    request.addNowNumb();
                    if (request.isReachWant() && !request.isWantInfinite()) {
                        requestList.remove(request);
                    }
                }else {
                    requestList.remove(request);
                }
            }
        }
    }

这里异常匹配到了请求，就会触发请求的回调接口，传递异常出去，并不做判断，直接移除该请求。

对回复的处理就复杂多了，涉及到多种消息模型，可以看方法顶部注释，解释的很清楚。

这里遍历请求数组，如果不使用线程安全的数组会造成一个 ConcurrentModifyException，很有意思，让我学到了，读者有兴趣可以了解下。

请求类超时设计

我们在请求类中就设计了超时相关属性，前面都没有提到，肯定要解决啊，下面看代码：

	public void setUpSocketConfigure(Bundle data) {
    	mBinder.setUpSocketConfigure(data);
    	uiHandler.sendEmptyMessage(-1);
	}

    @SuppressLint("HandlerLeak")
    private final Handler uiHandler = new Handler() {
        @Override
        public void handleMessage(@NonNull Message msg) {
            switch (msg.what) {
				...
                case -1:
                    handleTimeout();
                    //清除一下“-1”消息？？？
                    uiHandler.sendEmptyMessageDelayed(-1, 100);
                    default:
            }
        }
    };
    private void handleTimeout() {
        long nowTime = System.currentTimeMillis();
        for (BaseRequest request : requestList) {
            if (request == null) {
                requestList.remove(null);
            } else if (request.wantNumb == 0) {
                requestList.remove(request);
            } else if (request.isTimeout(nowTime) && !request.isWantInfinite()) {
                request.callback.onTimeout(request.requestMsgType);
                requestList.remove(request);
            }
        }
    }

这里利用上面的 uiHandler，利用它每隔 100ms 就处理一次超时方法，并在初始化的时候启动这个定时。handleTimeout 里面也有一些逻辑，读者可以自行理解下。

完整代码

public class ConnectManager {

    private volatile static ConnectManager mConnectManager = null;

    private final List<BaseRequest> requestList = new CopyOnWriteArrayList<>();//注意线程安全，ArrayList出问题

    @SuppressLint("HandlerLeak")
    private final Handler uiHandler = new Handler() {
        @Override
        public void handleMessage(@NonNull Message msg) {
            switch (msg.what) {
                case 0:
                    handleError(msg.arg1);
                    break;
                case 1:
                    BaseResponse response = msg.getData().getParcelable("response");
                    if (response != null) {
                        handleResponse(response);
                    }
                    break;
                case -1:
                    handleTimeout();
                    uiHandler.sendEmptyMessageDelayed(-1, 100);
                    default:
            }
        }
    };

    private ConnectService.ConnectBinder mBinder;
    private final ServiceConnection connection = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
            mBinder = (ConnectService.ConnectBinder) iBinder;
            //回调处理发送失败
            mBinder.getService().setOnPostMessageListener(new ConnectService.OnPostMessageListener() {

                @Override
                public void onPostError(int typeId) {
                    sendErrorToUiThread(typeId);
                }

                @Override
                public void onPostResponse(BaseResponse response) {
                    sendResponseToUiThread(response);
                }
            });
        }

        @Override
        public void onServiceDisconnected(ComponentName componentName) {

        }
    };

    //DCL
    public static ConnectManager getInstance() {
        if (mConnectManager == null) {
            synchronized (ConnectManager.class) {
                if (mConnectManager == null) {
                    mConnectManager = new ConnectManager();
                }
            }
        }
        return mConnectManager;
    }

    public void setUpSocketConfigure(Bundle data) {
        mBinder.setUpSocketConfigure(data);
        uiHandler.sendEmptyMessage(-1);
    }

    public void sendMessage(BaseRequest request) {
        requestList.add(request);
        //TODO 解决mBinder为空
        if (request.isSendOut && mBinder != null) {
            mBinder.sendMessage(request);
        }
    }

    public void bindConnectService(Context context) {
        Intent intent = new Intent(context, ConnectService.class);
        context.bindService(intent, connection, BIND_AUTO_CREATE);

    }

    public void unbindConnectService(Context context) {
        context.unbindService(connection);
    }

    private void sendErrorToUiThread(int typeId) {
        Message message = uiHandler.obtainMessage(-1, typeId, 0);
        uiHandler.sendMessage(message);
    }

    private void sendResponseToUiThread(BaseResponse response) {
        Message message = uiHandler.obtainMessage(1);
        Bundle bundle = new Bundle();
        bundle.putParcelable("response", response);
        message.setData(bundle);
        uiHandler.sendMessage(message);
    }

    private void handleError(int typeId) {
        for (BaseRequest request : requestList) {
            if (request == null) {
                requestList.remove(null);
            } else if (request.requestMsgType == typeId) {
                request.callback.onError(typeId);
                requestList.remove(request);
            }
        }
    }

    /* --处理说明--
    一对零：不求回复，直接移除（checkTimeout）

    一对一：一般模式，直接结束
    一对多：定位报值，多条接受

    零/一对无限：wantNumb = -1,特别处理
    */
    private void handleResponse(@NonNull BaseResponse response) {
        for (BaseRequest request : requestList) {
            if (request == null) {
                requestList.remove(null);
            } else if (request.responseMsgType == response.responseMsgType) {
                if (!request.isReachWant() || request.isWantInfinite()) {
                    request.callback.onResponse(response);
                    request.addNowNumb();
                    if (request.isReachWant() && !request.isWantInfinite()) {
                        requestList.remove(request);
                    }
                }else {
                    requestList.remove(request);
                }
            }
        }
    }

    private void handleTimeout() {
        long nowTime = System.currentTimeMillis();
        for (BaseRequest request : requestList) {
            if (request == null) {
                requestList.remove(null);
            } else if (request.wantNumb == 0) {
                requestList.remove(request);
            } else if (request.isTimeout(nowTime) && !request.isWantInfinite()) {
                request.callback.onTimeout(request.requestMsgType);
                requestList.remove(request);
            }
        }
    }
}

结语

一篇文章下来，我觉得整个 socket 通信模块都讲的差不多喽，下面再写一篇用法吧！

end

捡一晌贪欢
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
一个Socket连接管理器
04-04
NULL 博文链接：https://cuisuqiang.iteye.com/blog/1489661
Python socket处理client连接过程解析
09-17
在Python编程中，Socket是网络通信的基本模块，用于创建服务器和客户端之间的连接。本文将深入解析如何使用Python的socket库处理客户端（client）连接，并通过示例代码展示具体操作。 首先，了解Python socket的...
自定义 Socket 通信模块 Service 设计
silencefly的博客
06-21 415
自定义安卓 socket 通信模块系列 socket 相关内容前面已经讲解了，还写到了一些 Service 内容，上一篇博客还将请求类和回复类设计好了，接下来我们需要设计的就是通信模块的 socket 收发了，这里写在 Service 里面。之所以写在 Service 里面，是因为我这和设备的连接是一个长时间的任务，接收和发送线程存在时间特别久，应该写在 Service 里面。 待解决问题 前面已经将 Service 内连接 socket 和接收数据的部分大致写了，剩下的问题如下： Service 的连
自定义socket协议（服务端）
weixin_34290390的博客
11-14 208
自定义协议服务//server.cpp:Definestheentrypointfortheconsoleapplication. // #include"stdafx.h" #include<windows.h> #include<stdio.h> #include<winsock2.h> #pragmaco...
自定义 Socket 通信模块简单使用
silencefly的博客
06-21 378
自定义安卓 socket 通信模块系列 前面已经把功能都写清楚了，这里稍做总结，并介绍一下使用方法。 小结 整个模块主要写了五个文件，如下： BaseRequest BaseResponse ResponseCallback ConnectService ConnectManager 其中 ResponseCallback 时回调接口，另外是请求基类和回复基类，ConnectService 负责 socket 的接收发送工作，ConnectManager 负责向外暴漏，并提供线程转换、超时控制等功能。
基于 TCP 协议的自定义 Socket 数据帧来进行短数据的传输
最新发布
03-14 430
我们总是喜欢瞻仰大厂的大神们，但实际上大神也不过凡人，与菜鸟程序员相比，也就多花了几分心思，如果你再不努力，差距也只会越来越大。实际上，作为程序员，丰富自己的知识储备，提升自己的知识深度和广度是很有必要的。我们总是喜欢瞻仰大厂的大神们，但实际上大神也不过凡人，与菜鸟程序员相比，也就多花了几分心思，如果你再不努力，差距也只会越来越大。实际上，作为程序员，丰富自己的知识储备，提升自己的知识深度和广度是很有必要的。
python实现局域网内实时通信代码
09-18
`socket`模块提供了创建和管理套接字的基本功能，套接字是网络通信的基本单元，它允许程序在两个端点之间建立连接并传输数据。 **服务端代码解析：** 1. 引入必要的库：`socket`用于基础的套接字操作，`...
C#开发典型模块大全
03-12
10.3.1　桌面精灵模块公共类设计　233 10.3.2　当前日期的农历、天干地支年、节日及星座显示　235 10.3.3　定时提醒的实现　240 10.3.4　日历窗体效果控制　242 10.3.5　转到某天、某周、某月及某年的实现　243 ...
C#开发典型模块大全(光盘)
09-27
10.3.1 桌面精灵模块公共类设计 10.3.2 当前日期的农历、天干地支年、节日及星座显示 10.3.3 定时提醒的实现 10.3.4 日历窗体效果控制 10.3.5 转到某天、某周、某月及某年的实现 10.3.6 节日管理 10.3.7 提醒管理 ...
python使用多线程+socket实现端口扫描
09-16
`socket`模块提供了基本的网络通信功能，包括TCP（Transmission Control Protocol）和UDP（User Datagram Protocol）连接。在端口扫描中，通常使用TCP的三次握手来判断端口是否开放。 ```python import socket def...
Socket 用户管理
06-05
Socket通信，用户管理，实现服务器端，客户端交互，实现增删改查
一个Socket连接管理器(心跳机制)
05-10
一个Socket连接管理器(心跳机制)
socket自动连接和多客户端管理
03-18
socket socket多客户端管理 socket自动连接
基于Socket类的网络成绩管理系统—客户端的设计与实现
04-26
自己做的课程设计 数据库用的是SQL Server2000，开发环境是visual studio2005，用的windows窗体开发，所以这个学生成绩管理系统就是基于C/S模式开发的，次结构突出，用菜单方式工作，直观性与易理解性优势明显，有良好的用户界面。
SOCKET选项和管理（一）
思想的可见性
12-05 654
这里主要涉及函数比较多，所以简单先写一下，以后陆续补齐。 套接字一旦建立，通过套接字选项和I/O控制命令对各种属性进行操作，便可以对套接字的行为产生影响。可以增加或者去除套接字的某些功能。有的选项只用于信息的返回，而有的选项则可在应用程序中影响套接字的行为，I/O控制命令肯定会对套接字的行为产生影响。如此就有必要设置一下套接字属性。 主要涉及到的是四个函数：getsockopt，setsock
socket io管理模型总结（Linux、Windows）
Allan_Zeng的专栏
09-15 844
--------------------------select:----------------------------------- select所检查的所有fd，必须是关联于同一个服务提供者（listen fd)上。 select中的exceptfds也可用于检测OOB数据情况。（exceptfds可以标示OOB data is available for reading (only i
Socket通信原理和实践
Aurevoir1993的博客
12-05 327
分类： 网络管理（3）  目录(?)[+] 我们深谙信息交流的价值，那网络中进程之间如何通信，如我们每天打开浏览器浏览网页时，浏览器的进程怎么与web服务器通信的？当你用QQ聊天时，QQ进程怎么与服务器或你好友所在的QQ进程通信？这些都得靠socket？那什么是socket？socket的类型有哪些？还有socket的基本函数，这些都是本文想介绍的。本文的
SOCKET编程之connect应用
weixin_45312249的博客
05-14 951
一.背景 最近在项目中需要高效率的扫描出各个服务器开放了哪些端口，第一反应是用ping去做，而ping是能检测网络连通性，不能判断是否开放了端口。端口属于osi七层模型中的传输层，因此需要使用ip+端口来实现，所以使用connect来实现。针对TCP协议，connect函数要进行TCP三次握手，如果connect成功，则说明服务器开放了某个端口，如果connect失败，则说明服务器没有开放某个端口。而connect失败是通过超时来控制的，在规定的时间内，connect会发起多次连接，一直执行到超时，才返回错
socket编程之connect()
qq_55537010的博客
09-04 7251
connect()函数入门到精通
基于socket接口实现自定义协议通信
03-16
基于socket接口实现自定义协议通信，需要先定义好自定义协议的格式和规则，然后在客户端和服务器端分别实现对应的协议解析和打包功能。在通信过程中，客户端和服务器端需要按照协议规定的格式进行数据的发送和接收，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值