基于心跳的socket长连接
心跳:
socket模拟网页的报文连接某个网站,创建tcp的socket后,当我socket.connect后,如果在5到7秒钟不socket.send,那么这个链接就失效了。 请问如何长时间的保持这个链接
这是在服务器端的设置的,客户端没法设置,可以发送心跳包。
socket.connect后,每3-4秒用socket.send发送一字节数据(内容随便),然后观查这个连接是否保持。
lientSocket=serverSocket.accept();
OutputStream os = clientSocket.getOutputStream();
ObjectOutputStream oos=new ObjectOutputStream(os);
oos.writeObject(al);
oos.flush();
oos.close()//socket会关闭
实现:
长连接的维持,是要客户端程序,定时向服务端程序,发送一个维持连接包的。
如果,长时间未发送维持连接包,服务端程序将断开连接。
客户端:
通过持有Client对象,可以随时(使用sendObject方法)发送Object给服务端。
如果keepAliveDelay毫秒(程序中是2秒)内未发送任何数据,则,自动发送一个KeepAlive对象给服务端,
用于维持连接。
由于,我们向服务端,可以发送很多不同的对象,服务端也可以返回不同的对象。
所以,对于返回对象的处理,要编写具体的ObjectAction实现类进行处理。
通过Client.addActionMap方法进行添加。这样,程序会回调处理。
服务端:
由于客户端会定时(keepAliveDelay毫秒)发送维持连接的信息过来,所以,服务端要有一个检测机制。
即当服务端receiveTimeDelay毫秒(程序中是3秒)内未接收任何数据,则,自动断开与客户端的连接。
ActionMapping的原理与客户端相似(相同)。
通过添加相应的ObjectAction实现类,可以实现不同对象的响应、应答过程。
- package houlei.csdn.keepalive;
- import java.io.Serializable;
- import java.text.SimpleDateFormat;
- import java.util.Date;
- /**
- * 维持连接的消息对象。
- */
- public class KeepAlive implements Serializable{
- private static final long serialVersionUID = -2813120366138988480L;
- /* 覆盖该方法,仅用于测试使用。
- * @see java.lang.Object#toString()
- */
- @Override
- public String toString() {
- return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())+"\t维持连接包";
- }
- }
client:
- package houlei.csdn.keepalive;
- import java.io.IOException;
- import java.io.InputStream;
- import java.io.ObjectInputStream;
- import java.io.ObjectOutputStream;
- import java.net.Socket;
- import java.net.UnknownHostException;
- import java.util.concurrent.ConcurrentHashMap;
- /**
- * C/S架构的客户端对象,持有该对象,可以随时向服务端发送消息。
- */
- public class Client {
- /**
- * 处理服务端发回的对象,可实现该接口。
- */
- public static interface ObjectAction{
- void doAction(Object obj,Client client);
- }
- public static final class DefaultObjectAction implements ObjectAction{
- public void doAction(Object obj,Client client) {
- System.out.println("处理:\t"+obj.toString());
- }
- }
- public static void main(String[] args) throws UnknownHostException, IOException {
- String serverIp = "127.0.0.1";
- int port = 65432;
- Client client = new Client(serverIp,port);
- client.start();
- }
- private String serverIp;
- private int port;
- private Socket socket;
- private boolean running=false;
- private long lastSendTime;
- private ConcurrentHashMap<Class, ObjectAction> actionMapping = new ConcurrentHashMap<Class,ObjectAction>();
- public Client(String serverIp, int port) {
- this.serverIp=serverIp;this.port=port;
- }
- public void start() throws UnknownHostException, IOException {
- if(running)return;
- socket = new Socket(serverIp,port);
- System.out.println("本地端口:"+socket.getLocalPort());
- lastSendTime=System.currentTimeMillis();
- running=true;
- new Thread(new KeepAliveWatchDog()).start();
- new Thread(new ReceiveWatchDog()).start();
- }
- public void stop(){
- if(running)running=false;
- }
- /**
- * 添加接收对象的处理对象。
- * @param cls 待处理的对象,其所属的类。
- * @param action 处理过程对象。
- */
- public void addActionMap(Class<Object> cls,ObjectAction action){
- actionMapping.put(cls, action);
- }
- public void sendObject(Object obj) throws IOException {
- ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
- oos.writeObject(obj);
- System.out.println("发送:\t"+obj);
- oos.flush();
- }
- class KeepAliveWatchDog implements Runnable{
- long checkDelay = 10;
- long keepAliveDelay = 2000;
- public void run() {
- while(running){
- if(System.currentTimeMillis()-lastSendTime>keepAliveDelay){
- try {
- Client.this.sendObject(new KeepAlive());
- } catch (IOException e) {
- e.printStackTrace();
- Client.this.stop();
- }
- lastSendTime = System.currentTimeMillis();
- }else{
- try {
- Thread.sleep(checkDelay);
- } catch (InterruptedException e) {
- e.printStackTrace();
- Client.this.stop();
- }
- }
- }
- }
- }
- class ReceiveWatchDog implements Runnable{
- public void run() {
- while(running){
- try {
- InputStream in = socket.getInputStream();
- if(in.available()>0){
- ObjectInputStream ois = new ObjectInputStream(in);
- Object obj = ois.readObject();
- System.out.println("接收:\t"+obj);
- ObjectAction oa = actionMapping.get(obj.getClass());
- oa = oa==null?new DefaultObjectAction():oa;
- oa.doAction(obj, Client.this);
- }else{
- Thread.sleep(10);
- }
- } catch (Exception e) {
- e.printStackTrace();
- Client.this.stop();
- }
- }
- }
- }
- }
server:
- package houlei.csdn.keepalive;
- import java.io.IOException;
- import java.io.InputStream;
- import java.io.ObjectInputStream;
- import java.io.ObjectOutputStream;
- import java.net.ServerSocket;
- import java.net.Socket;
- import java.util.concurrent.ConcurrentHashMap;
- /**
- * C/S架构的服务端对象。
- */
- public class Server {
- /**
- * 要处理客户端发来的对象,并返回一个对象,可实现该接口。
- */
- public interface ObjectAction{
- Object doAction(Object rev);
- }
- public static final class DefaultObjectAction implements ObjectAction{
- public Object doAction(Object rev) {
- System.out.println("处理并返回:"+rev);
- return rev;
- }
- }
- public static void main(String[] args) {
- int port = 65432;
- Server server = new Server(port);
- server.start();
- }
- private int port;
- private volatile boolean running=false;
- private long receiveTimeDelay=3000;
- private ConcurrentHashMap<Class, ObjectAction> actionMapping = new ConcurrentHashMap<Class,ObjectAction>();
- private Thread connWatchDog;
- public Server(int port) {
- this.port = port;
- }
- public void start(){
- if(running)return;
- running=true;
- connWatchDog = new Thread(new ConnWatchDog());
- connWatchDog.start();
- }
- @SuppressWarnings("deprecation")
- public void stop(){
- if(running)running=false;
- if(connWatchDog!=null)connWatchDog.stop();
- }
- public void addActionMap(Class<Object> cls,ObjectAction action){
- actionMapping.put(cls, action);
- }
- class ConnWatchDog implements Runnable{
- public void run(){
- try {
- ServerSocket ss = new ServerSocket(port,5);
- while(running){
- Socket s = ss.accept();
- new Thread(new SocketAction(s)).start();
- }
- } catch (IOException e) {
- e.printStackTrace();
- Server.this.stop();
- }
- }
- }
- class SocketAction implements Runnable{
- Socket s;
- boolean run=true;
- long lastReceiveTime = System.currentTimeMillis();
- public SocketAction(Socket s) {
- this.s = s;
- }
- public void run() {
- while(running && run){
- if(System.currentTimeMillis()-lastReceiveTime>receiveTimeDelay){
- overThis();
- }else{
- try {
- InputStream in = s.getInputStream();
- if(in.available()>0){
- ObjectInputStream ois = new ObjectInputStream(in);
- Object obj = ois.readObject();
- lastReceiveTime = System.currentTimeMillis();
- System.out.println("接收:\t"+obj);
- ObjectAction oa = actionMapping.get(obj.getClass());
- oa = oa==null?new DefaultObjectAction():oa;
- Object out = oa.doAction(obj);
- if(out!=null){
- ObjectOutputStream oos = new ObjectOutputStream(s.getOutputStream());
- oos.writeObject(out);
- oos.flush();
- }
- }else{
- Thread.sleep(10);
- }
- } catch (Exception e) {
- e.printStackTrace();
- overThis();
- }
- }
- }
- }
- private void overThis() {
- if(run)run=false;
- if(s!=null){
- try {
- s.close();
- } catch (IOException e) {
- e.printStackTrace();
- }
- }
- System.out.println("关闭:"+s.getRemoteSocketAddress());
- }
- }
- }
基于心跳的socket长连接的更多相关文章
- 网络编程懒人入门(八):手把手教你写基于TCP的Socket长连接
本文原作者:“水晶虾饺”,原文由“玉刚说”写作平台提供写作赞助,原文版权归“玉刚说”微信公众号所有,即时通讯网收录时有改动. 1.引言 好多小白初次接触即时通讯(比如:IM或者消息推送应用)时,总是不 ...
- 基于netty实现的长连接,心跳机制及重连机制
技术:maven3.0.5 + netty4.1.33 + jdk1.8 概述 Netty是由JBOSS提供的一个java开源框架.Netty提供异步的.事件驱动的网络应用程序框架和工具,用以快速 ...
- 【Socket】关于socket长连接的心跳包
TCP的socket本身就是长连接的,那么为什么还要心跳包呢? 在smack里有个30s发送一个空消息的线程,同样关于心跳包(keepalive) 据网络搜索到的资料解释如下 内网机器如果不主动向外发 ...
- 基于netty框架的socket长连接负载均衡解决方案
socket通讯的单机瓶颈 物联网的项目socket使用方式有两种: 短连接的socket请求 维持socket长连接的请求 对于socket短链接来说就好比是http请求,请求服务器,服务器返回数据 ...
- android端 socket长连接 架构
看过包建强的<App研发录>之后对其中的基础Activity类封装感到惊讶,一直想找一种方式去解决关于app中使用socket长连接问题,如何实现简易的封装来达到主活动中涉及socket相 ...
- Socket 长连接 短连接 心跳 JAVA SOCKET编程
简单解释就是: 短连接:建立连接,发送数据包.关闭连接 长连接:建立连接.发送数据包,发送心跳包,发送数据包,发送心跳包.发送心跳包. ..... 所以又频繁的数据收发的话.短连接会频繁创建TCP连接 ...
- Socket 长连接与短连接,心跳
长连接与短连接 所谓长连接,指在一个TCP连接上可以连续发送多个数据包,在TCP连接保持期间,如果没有数据包发送,需要双方发检测包以维持此连接,一般需要自己做在线维持. 短连接是指通信双方有数据交互时 ...
- iOS后台如何保持socket长连接和数据传输
工程中使用tcp长连接来和服务端进行数据传输,在IOS平台上,由于苹果的后台机制,会有以下问题: 当程序退到后台的时候,所有线程被挂起,系统会回收所有的socket资源,那么socket连接就会被关闭 ...
- 使用http维持socket长连接
项目中有遇到问题如下: 1.旧版的cs服务,因为每个用户和唯一的长连接是在登录后绑定的,并且所有的消息报文均是基于该长连接去发送接收的,所以要求node服务要维持一个长连接,然后根据该用户获取长连接, ...
随机推荐
- think in uml 1
对象,在过程的基础上,是一个抽象级别的提升,可以构建更大更复杂的系统 数据流图(Data Flow Diagram):简称DFD,它从数据传递和加工角度,以图形方式来表达系统的逻辑功能.数据在系统内部 ...
- struts2修改文件上传的大小
那天写了一个web上传图片的程序,明明修改了上传文件的默认值(2M),可就是一直没有起作用 <action name="fileupload" class="upl ...
- apicloud教程1 (转载)
非常感谢APICloud官方给我版主职位,每天都看到很多朋友提出很多问题,我就借此机会写了一系列的教程,帮助大家从小白到高手之路.系列名称:<APICloud之小白图解教程系列>,会不定时 ...
- @property(nonatomic) UIViewAutoresizing autoresizingMask;
在 UIView 中有一个autoresizingMask的属性,它对应的是一个枚举的值(如下),属性的意思就是自动调整子控件与父控件中间的位置,宽高. 1 2 3 4 5 6 7 8 9 enum ...
- 【转】从1到N这N个数中1的出现了多少次?
给定一个十进制整数N,求出从1到N的所有整数中出现"1"的个数. 例如:N=2,1,2出现了1个"1". N=12,1,2,3,4,5,6,7,8,9,10,1 ...
- 2--OC -- 类的创建与实例化
2.OC -- 类的创建与实例化 一.OC类的简述 1.OC类分为2个文件:.h文件用于类的声明,.m文件用于实现.h的函数: 2.类是声明使用关键字:@interface.@end : 3.类是 ...
- 学习笔记——策略模式Strategy
策略模式,与模板模式一样,都是为了将接口和算法实现解耦,但策略模式更主要是整体算法的替换,而模板模式主要是流程一致,部分算法的替换. 个人理解为,一般算法替换,使用策略模式,当算法流程一致,可以提取为 ...
- java 强弱引用
ava中,虽然不需要程序员手动去管理对象的生命周期,但是如果希望某些对象具备一定的生命周期的话(比如内存不足时JVM就会自动回收某些对象从而避免OutOfMemory的错误)就需要用到软引用和弱引用了 ...
- 转:jmeter性能测试---登录百度进行搜索
在做web程序性能测试时,loadrunner和jmeter是两款常用的工具,两者比较起来,jmeter非常轻巧,且开源免费,上手快.这里简单介绍下jmeter的使用,以登录百度进行搜索为例. jme ...
- R语言——绘图函数深入学习
利用R自带数据集 通过data()函数可以查看R自带数据集. > data() 返回以下结果,每一条记录都是一个数据,键入相应的数据名称可以查看具体信息. Data sets in packag ...