自定义 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
socket编程之connect()
qq_55537010的博客
09-04 7237
connect()函数入门到精通
SOCKET编程之connect应用
weixin_45312249的博客
05-14 948
一.背景 最近在项目中需要高效率的扫描出各个服务器开放了哪些端口，第一反应是用ping去做，而ping是能检测网络连通性，不能判断是否开放了端口。端口属于osi七层模型中的传输层，因此需要使用ip+端口来实现，所以使用connect来实现。针对TCP协议，connect函数要进行TCP三次握手，如果connect成功，则说明服务器开放了某个端口，如果connect失败，则说明服务器没有开放某个端口。而connect失败是通过超时来控制的，在规定的时间内，connect会发起多次连接，一直执行到超时，才返回错
socket长连接客户端管理
littlehow的专栏
06-17 1万+
今天看到有人在ask上提问关于socket长连接发送消息的问题，所以突然就想着写一篇博客。为刚接触socket长连接开发，并且没有用mina或netty这种nio框架的开发者提出的一些思路。可以根据自己的业务进行改变。下面就是具体代码（只有对连接的管理，具体的连接没有提供）：package littlehow.socket; import java.io.IOException; import ...
管理器之socket
我的程序人生
10-22 810
  上一篇主要介绍了任务管理器，这篇开始介绍socket管理器，我们知道服务器在支持并发的时候会有几种不同的方式，在讲解下面的内容之前，先回顾一下传统的tcp和udp是怎么进行通信的，这里由简单到复杂 1.第一种是最原始的tcp调用，服务端调用socket创建套接字进行通信，调用bind绑定端口，调用listen来监听端口是否有客户端请求过来，该函数用一个队列来保存未处理的连接请求，然后阻塞到...
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 提醒管理 ...
Java典型模块
02-25
第29章 人员信息管理项目 （接口设计模式+MySQL数据库） 29.1 人员信息管理原理 29.1.1 项目结构框架分析 29.1.2 项目功能业务分析 29.2 人员信息管理项目前期准备 29.2.1 设计数据库 29.2.2 数据库操作相关类 29.3 ...
基于Socket类的网络成绩管理系统—客户端的设计与实现
04-26
自己做的课程设计 数据库用的是SQL Server2000，开发环境是visual studio2005，用的windows窗体开发，所以这个学生成绩管理系统就是基于C/S模式开发的，次结构突出，用菜单方式工作，直观性与易理解性优势明显，有良好的用户界面。
一个Socket连接管理器(心跳机制)
05-10
一个Socket连接管理器(心跳机制)
socket自动连接和多客户端管理
03-18
socket socket多客户端管理 socket自动连接
Socket 用户管理
06-05
Socket通信，用户管理，实现服务器端，客户端交互，实现增删改查
游戏网络Socket长连接管理
王广帅--游戏开发技术
02-06 3963
对于网络游戏来说，网络连接的开发与维护是非常重要的，这里主要说明一下最常用的socket长连接开发与管理。服务端使用的网络框架是Netty，客户端使用的是unity，本文中的源码，可以在这里查看：https://gitee.com/wgslucky/xinyue-alone-game-server ，此文章对应的代码tag是v1.0.4 连接创建 对于服务器来说，是启动一个监听的端口，等待客户端连接即可，在源码中可以查看这个类：GameNetworkServer public void start(Game
大量socket并发管理 epoll
come119on的专栏
09-03 554
大家都知道服务器实际上是大量socket并发，处理socket一般使用select或者epoll；select有个缺陷，需要吧socket结构大量从内核copy进copy出来，所以限制比较大，一般一个线程管理的socket linux：1024，windows：64个；这点数量对于一个大型服务器来说太少了，100w+连接至少需要开一千个线程，这样实在认人难以接受； epoll就是解决这个问题的，...
一个简单的自定义通信协议（socket）
热门推荐
懒人的技术笔记
12-31 5万+
转自：http://vtrtbb.javaeye.com/blog/849336这是转自javaeye的一篇文章，作者是vtrtbb。按照网络通信的传统，我们都会自定义协议，这有很多好处，大家可以自己体会（嘿嘿）。一直不知道socket通信时候自定义数据包是什么样子的，偶然做了个小例子。先来说说数据包的定义，我这里是包头+内容 组成的：其中包头内容分为包类型+包长度， 那就是 消息对象=包类型+包长度+消息体包类型 byte 型包长度 int 型消息体 byte[]包总长度为 1 + 4 +  消息体.ge
基于 TCP 协议的自定义 Socket 数据帧来进行短数据的传输
最新发布
03-14 429
我们总是喜欢瞻仰大厂的大神们，但实际上大神也不过凡人，与菜鸟程序员相比，也就多花了几分心思，如果你再不努力，差距也只会越来越大。实际上，作为程序员，丰富自己的知识储备，提升自己的知识深度和广度是很有必要的。我们总是喜欢瞻仰大厂的大神们，但实际上大神也不过凡人，与菜鸟程序员相比，也就多花了几分心思，如果你再不努力，差距也只会越来越大。实际上，作为程序员，丰富自己的知识储备，提升自己的知识深度和广度是很有必要的。
基于socket接口实现自定义协议通信
03-16
基于socket接口实现自定义协议通信，需要先定义好自定义协议的格式和规则，然后在客户端和服务器端分别实现对应的协议解析和打包功能。在通信过程中，客户端和服务器端需要按照协议规定的格式进行数据的发送和接收，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值