精华内容
下载资源
问答
  • 使用脚本,即可实现。 #!/bin/bash #echo "4g test" #ls /dev/ttyU* #cat /dev/ttyUSB2 & #echo -en "AT\r\n" > /dev/ttyUSB2 #killall cat ...#ln -s /etc/ppp/resolv.conf /etc/resolv.

    使用脚本,即可实现。

    #!/bin/bash
    
    #exit 0
    
    #echo "4g test"
    #ls /dev/ttyU*
    #cat /dev/ttyUSB2 &
    #echo -en "AT\r\n" > /dev/ttyUSB2
    #killall cat
    #exit 0
    
    echo "4g pppd"
    
    count=0
    
    #sleep 5
    
    #procedure='pppd'
    if [ "$(ps |grep "pppd call" |grep -v grep |awk '{print $1}')" ]; then
        killall pppd #结束PPPD进程
    fi
    
    for ((i=0; i<15; i++))
    do
        sleep 1
        if [ -f "/sys/class/gpio/gpio65/value" ]; then
            break
        else
            echo 65 > /sys/class/gpio/export
        fi
    done
    echo high > /sys/class/gpio/gpio65/direction
    
    fun_check_usb(){
        countCheckUSB=0
        while true
        do
            usleep 500000
            ret=`ls /dev/ttyUSB*`
            if [ "$ret" ]; then
                echo $ret
                break
            fi
            let countCheckUSB++
            if [ $countCheckUSB -gt 35 ]; then
                reboot
                exit 0
            fi
        done
    }
    fun_check_usb
    
    #"/sys/class/net/eth0"
    #ifconfig eth0 down
    #ifconfig eth1 down
    
    #rm /etc/resolv.conf
    #ln -s /etc/ppp/resolv.conf /etc/resolv.conf
    cp /etc/ppp/resolv.conf /etc/resolv.conf
    
    pppd call wcdma-ec20 >/dev/null 2>&1 &
    
    sleep 12 #等待12秒
    fun_wait_ppp0(){
        countWait=0
        while true
        do
            usleep 500000
            if [ "$(ifconfig |grep ppp0)" ]; then
                break
            fi
            let countWait++
            echo "pppd countWait=$countWait"
            if [ $countWait -gt 30 ]; then
                date
                killall pppd #结束PPPD进程
                echo "ppp0 is not existed"
                if [ $count -lt 15 ]; then
                    count=15
                fi
                break
                #reboot
                #exit 0
            fi
        done
    }
    fun_wait_ppp0
    
    fun_route(){
        if [ ! "$(route -e |grep default |grep ppp0 |awk '{print $1}')" ]; then
            if [ "$(ifconfig |grep ppp0)" ]; then
                route del default
                route add default dev ppp0
            fi
        fi
    }
    fun_route
    
    #---auto ppp---
    dns1="8.8.8.8"
    dns2="114.114.114.114"
    sleep 12 #等待12秒
    while true
    do
        ping -s 1 -c 5 $dns1 >/dev/null 2>&1 #去PING第一个DNS
        if [ "$?" != "0" ] #假如PING不通
        then
            fun_route
            ping -s 1 -c 2 $dns2 >/dev/null 2>&1 #去PING第二个DNS
            if [ "$?" != "0" ]
            then
                date
                killall pppd #结束PPPD进程
                let count++
                echo "pppd count=$count"
                if [ $count -gt 30 ]; then
                    reboot
                    exit 0
                elif [ $count -gt 15 ]; then
                    echo 0 > /sys/class/gpio/gpio65/value
                    usleep 500000
                    echo 1 > /sys/class/gpio/gpio65/value
                    #ttyUSB* is existed about 10 second
                    #sleep 12 #等待12秒
                fi
                sleep 12 #等待12秒
                fun_check_usb
                #ifconfig eth0 down
                #ifconfig eth1 down
                #cp /etc/ppp/resolv.conf /etc/resolv.conf
                pppd call wcdma-ec20 >/dev/null 2>&1 & #再去拨号
                sleep 12 #等待12秒
                fun_wait_ppp0
                fun_route
                sleep 5
            else
                count=0
                sleep 60 #如果是PING  DNS2通的话就直接等待5秒
            fi
        else
            count=0
            sleep 120 #如果是PING  DNS1通的话就直接等待5秒(一般要设置多长时间去PING请改这里)
        fi
    done
    
    
    

     

    展开全文
  • 断线重连

    2018-08-17 14:20:00
    断线重连 以下纯属理论,无实践1,后端定时向前端发心跳包(每次序列号加1),后端收到后回复一个,如果前端或后端在3秒内未收到心跳,则认为网络状况差,停止发送/接收游戏数据,继续发心跳包进行网络测速,...

    断线重连

    以下纯属理论,无实践
    1,后端定时向前端发心跳包(每次序列号加1),后端收到后回复一个,如果前端或后端在3秒内未收到心跳,则认为网络状况差,停止发送/接收游戏数据,继续发心跳包进行网络测速,直到网速达标(适用于对战类游戏,如王者荣耀),或者提示网络状态不佳,断开连接(MMORPG),
    这种情况下的断线,不进行重连,但这是断线重连的基础。
    这种情况下,再次重连时不会有数据丢失,可以继续上次数据发送
    2,突然性网络断开,异常被捕获后,前后端都立即知道了网络断开
    断开之前可能有一些数据已经从后端发出,还未到达前端,前端断开连接后,数据到达不了前端,丢失了,
    前后端开始断线重连处理:前端每隔1秒向后端发送一次连接请求,直到连接上,若尝试10次仍不能连接上,提示服务器无法连接,请检查网络状况。
    连接上的,服务器知道这是断线的重连,因为断开时服务器已经记录下了玩家ID,
    此时,服务器向前端下发一个断线重连的回复数据,数据中有序列号,前端拿这个序列号与前端序列号对比,若后端大于前端,则知道断线之后发生了丢包,然后把当前序列号发给后端,
    后端将自己的序列号与前端发来的序列号对比,如相等,则一切正常。若不等(一定是小于,不可能大于)
    则去缓存中去取缓存的协议数据,从前端的序列号开始处重新发送给前端。
    这样当玩家重连成功后,服务就会将玩家断线期间周围玩家的走路广播,以及断线前玩家的请求的回复数据(比如买了某个物品,刚点击了物品)重新下发,像魔兽世界就是这样的,断线后重新成功,会看到一个急速的动画播放,这就是后端在急速补包,前端做了加速表现。

    posted on 2018-08-17 14:20 时空观察者9号 阅读(...) 评论(...) 编辑 收藏

    展开全文
  • android socket连接 socket心跳包,断线重连,发送数据

    这两天做了一个项目是app通过socket连接自动炒菜机,给炒菜机发指令,炒菜机接收到指令会执行相应的操作。(程序虽然做的差不多了,然而我连炒菜机长什么样都没见过)

    其实作为一个会做饭的程序猿,我坚信还是自己动手做的饭菜比较好吃,毕竟做饭还是很有趣的。

    这里写图片描述

    闲话不多说,因为是通过socket去连接炒菜机的,并且要求每两秒要给炒菜机发送一个指令,点击按钮的话也要发送相应的指令。
    所以要考虑一些问题,比如断线重连,数据发送失败了重连,要保持全局只有一个连接等等。


    因为是要保证全局只能有一个连接,而且我们还需要在不同的Activity中发指令,因此肯定不能在需要发指令的界面中都去连接socket,这样一来不好管理,性能也不好,重复代码也会比较多,所以想了一下还是把socket放到service中比较好,发指令功能都放在service中即可。

    记得要先给网络权限

        <uses-permission android:name="android.permission.INTERNET" />
    

    下面我们来看看Service中的代码,其中有些细节是需要注意的
    1)我们要保证只有一个连接服务运行,所以在启动服务之前先判断一下连接服务是否正在运行,如果正在运行,就不再启动服务了。
    2)连接成功之后给出相应的通知,告诉连接者连接成功了,方便进行下一步操作,这里为了省事儿就直接用EventBus去通知了。也可以用广播的方式去通知。
    3)连接超时之后要注意先释放调之前的资源,然后重新初始化

    package com.yzq.socketdemo.service;
    
    import android.app.Service;
    import android.content.Intent;
    import android.os.Binder;
    import android.os.Handler;
    import android.os.IBinder;
    import android.os.Looper;
    import android.util.Log;
    import android.widget.TabHost;
    import android.widget.Toast;
    
    import com.yzq.socketdemo.common.Constants;
    import com.yzq.socketdemo.common.EventMsg;
    
    import org.greenrobot.eventbus.EventBus;
    
    import java.io.IOException;
    import java.io.OutputStream;
    import java.net.ConnectException;
    import java.net.InetSocketAddress;
    import java.net.NoRouteToHostException;
    import java.net.Socket;
    import java.net.SocketTimeoutException;
    import java.util.Timer;
    import java.util.TimerTask;
    
    
    /**
     * Created by yzq on 2017/9/26.
     * <p>
     * socket连接服务
     */
    public class SocketService extends Service {
    
        /*socket*/
        private Socket socket;
        /*连接线程*/
        private Thread connectThread;
        private Timer timer = new Timer();
        private OutputStream outputStream;
    
        private SocketBinder sockerBinder = new SocketBinder();
        private String ip;
        private String port;
        private TimerTask task;
    
        /*默认重连*/
        private boolean isReConnect = true;
    
        private Handler handler = new Handler(Looper.getMainLooper());
    
    
        @Override
        public IBinder onBind(Intent intent) {
            return sockerBinder;
        }
    
    
        public class SocketBinder extends Binder {
    
            /*返回SocketService 在需要的地方可以通过ServiceConnection获取到SocketService  */
            public SocketService getService() {
                return SocketService.this;
            }
        }
    
        @Override
        public void onCreate() {
            super.onCreate();
    
    
        }
    
    
        @Override
        public int onStartCommand(Intent intent, int flags, int startId) {
    
            /*拿到传递过来的ip和端口号*/
            ip = intent.getStringExtra(Constants.INTENT_IP);
            port = intent.getStringExtra(Constants.INTENT_PORT);
    
            /*初始化socket*/
            initSocket();
    
            return super.onStartCommand(intent, flags, startId);
        }
    
    
        /*初始化socket*/
        private void initSocket() {
            if (socket == null && connectThread == null) {
                connectThread = new Thread(new Runnable() {
                    @Override
                    public void run() {
    
                        socket = new Socket();
                        try {
                            /*超时时间为2秒*/
                            socket.connect(new InetSocketAddress(ip, Integer.valueOf(port)), 2000);
                            /*连接成功的话  发送心跳包*/
                            if (socket.isConnected()) {
    
    
                                /*因为Toast是要运行在主线程的  这里是子线程  所以需要到主线程哪里去显示toast*/
                                toastMsg("socket已连接");
    
                                /*发送连接成功的消息*/
                                EventMsg msg = new EventMsg();
                                msg.setTag(Constants.CONNET_SUCCESS);
                                EventBus.getDefault().post(msg);
                               /*发送心跳数据*/
                                sendBeatData();
                            }
    
    
                        } catch (IOException e) {
                            e.printStackTrace();
                            if (e instanceof SocketTimeoutException) {
                                toastMsg("连接超时,正在重连");
    
                                releaseSocket();
    
                            } else if (e instanceof NoRouteToHostException) {
                                toastMsg("该地址不存在,请检查");
                                stopSelf();
    
                            } else if (e instanceof ConnectException) {
                                toastMsg("连接异常或被拒绝,请检查");
                                stopSelf();
    
                            }
    
    
                        }
    
                    }
                });
    
                /*启动连接线程*/
                connectThread.start();
    
            }
    
    
        }
    
        /*因为Toast是要运行在主线程的   所以需要到主线程哪里去显示toast*/
        private void toastMsg(final String msg) {
    
            handler.post(new Runnable() {
                @Override
                public void run() {
                    Toast.makeText(getApplicationContext(), msg, Toast.LENGTH_SHORT).show();
                }
            });
        }
    
    
        /*发送数据*/
        public void sendOrder(final String order) {
            if (socket != null && socket.isConnected()) {
                /*发送指令*/
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            outputStream = socket.getOutputStream();
                            if (outputStream != null) {
                                outputStream.write((order).getBytes("gbk"));
                                outputStream.flush();
                            }
    
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
    
                    }
                }).start();
    
            } else {
                toastMsg("socket连接错误,请重试");
            }
        }
    
        /*定时发送数据*/
        private void sendBeatData() {
            if (timer == null) {
                timer = new Timer();
            }
    
            if (task == null) {
                task = new TimerTask() {
                    @Override
                    public void run() {
                        try {
                            outputStream = socket.getOutputStream();
    
                            /*这里的编码方式根据你的需求去改*/
                            outputStream.write(("test").getBytes("gbk"));
                            outputStream.flush();
                        } catch (Exception e) {
                            /*发送失败说明socket断开了或者出现了其他错误*/
                            toastMsg("连接断开,正在重连");
                            /*重连*/
                            releaseSocket();
                            e.printStackTrace();
    
    
                        }
                    }
                };
            }
    
            timer.schedule(task, 0, 2000);
        }
    
    
        /*释放资源*/
        private void releaseSocket() {
    
            if (task != null) {
                task.cancel();
                task = null;
            }
            if (timer != null) {
                timer.purge();
                timer.cancel();
                timer = null;
            }
    
            if (outputStream != null) {
                try {
                    outputStream.close();
    
                } catch (IOException e) {
                    e.printStackTrace();
                }
                outputStream = null;
            }
    
            if (socket != null) {
                try {
                    socket.close();
    
                } catch (IOException e) {
                }
                socket = null;
            }
    
            if (connectThread != null) {
                connectThread = null;
            }
    
              /*重新初始化socket*/
            if (isReConnect) {
                initSocket();
            }
    
        }
    
    
        @Override
        public void onDestroy() {
            super.onDestroy();
            Log.i("SocketService", "onDestroy");
            isReConnect = false;
            releaseSocket();
        }
    }
    
    
    

    好了,连接的service我们基本就做好了,先来看看效果,调试工具使用的是一个网络调试助手,免去我们写服务端的代码。
    来看看效果图:

    这里写图片描述

    可以看到,断线重连,连接成功自动发送数据,连接成功发消息这些都有了,实际上数据发送失败重连也是有的,不过模拟器上间隔时间很长,不知道怎么回事,真机没有问题。

    解决了service下面就是Activity于service通信的问题了。这个就简单了,我们在service中提供了一个binder,我们可以通过binder来拿到service,然后调service的sendOrder()即可
    先来看看示例代码:

    package com.yzq.socketdemo.activity;
    
    import android.content.ComponentName;
    import android.content.Intent;
    import android.content.ServiceConnection;
    import android.os.Bundle;
    import android.os.IBinder;
    import android.support.v7.app.AppCompatActivity;
    import android.widget.Button;
    import android.widget.EditText;
    
    import com.yzq.socketdemo.R;
    import com.yzq.socketdemo.service.SocketService;
    
    import butterknife.BindView;
    import butterknife.ButterKnife;
    import butterknife.OnClick;
    
    
    /**
     * Created by yzq on 2017/9/26.
     * <p>
     * mainActivity
     */
    public class MainActivity extends AppCompatActivity {
        @BindView(R.id.contentEt)
        EditText contentEt;
        @BindView(R.id.sendBtn)
        Button sendBtn;
        private ServiceConnection sc;
        public SocketService socketService;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
    
            bindSocketService();
            ButterKnife.bind(this);
        }
    
        private void bindSocketService() {
    
            /*通过binder拿到service*/
            sc = new ServiceConnection() {
                @Override
                public void onServiceConnected(ComponentName componentName, IBinder iBinder) {
                    SocketService.SocketBinder binder = (SocketService.SocketBinder) iBinder;
                    socketService = binder.getService();
    
                }
    
                @Override
                public void onServiceDisconnected(ComponentName componentName) {
    
                }
            };
    
    
            Intent intent = new Intent(getApplicationContext(), SocketService.class);
            bindService(intent, sc, BIND_AUTO_CREATE);
        }
    
        @OnClick(R.id.sendBtn)
        public void onViewClicked() {
    
            String data = contentEt.getText().toString().trim();
    
            socketService.sendOrder(data);
        }
    
    
        @Override
        protected void onDestroy() {
            super.onDestroy();
    
            unbindService(sc);
    
            Intent intent = new Intent(getApplicationContext(), SocketService.class);
    
            stopService(intent);
    
        }
    }
    
    

    这里写图片描述

    ok,大功告成
    下面是demo,我用的是android studio3.0预览版,可能gradle版本会高一些。
    socketDemo

    为了方便没有积分的大佬们下载,大家可以去下面的Github上下载

    https://github.com/yuzhiqiang1993/SocketDemo


    另外一种方式是采用Netty+Kotlin+RxJava方式实现的。使用起来更加简单,详情请看
    Android Netty版本


    如果你觉得本文对你有帮助,麻烦动动手指顶一下,算是对本文的一个认可,如果文中有什么错误的地方,还望指正,转载请注明转自喻志强的博客 ,谢谢!

    展开全文
  • mina连接,mina心跳连接,mina断线重连。其中客户端可直接用在android上。根据各方参考资料,经过自己的理解弄出来的。CSDN的资源分太难得了。
  • c#Socket客户端断线重连! c#Socket客户端断线重连! c#Socket客户端断线重连! c#Socket客户端断线重连!
  • 主要介绍了Spring boot 数据库连接断线重连问题,需要的朋友可以参考下
  • netty断线重连

    2021-03-10 17:31:22
    一 什么是断线重连 断线重连是指由于发生网络故障而导致服务中断的情况,客户端就需要从重新连接服务端;哪些情况下会导致服务断线呢?常见 的就是 网络情况下,断断续续,导致客户端无法和服务端交互,再比如,机房...

    一 什么是断线重连

    断线重连是指由于发生网络故障而导致服务中断的情况,客户端就需要从重新连接服务端;哪些情况下会导致服务断线呢?常见 的就是 网络情况下,断断续续,导致客户端无法和服务端交互,再比如,机房断电也会导致服务宕机;所以在netty中对服务进行断线重连是非常有必要的做的一个流程;

    二 netty断线重连步骤

    netty 什么情况下需要断线重连?

    netty 刚刚启动时需要断线重连,有可能服务刚刚启动,连接失败,此时就可以尝试断线重连,保证服务正常运行;其次,当服务在运行过程中出现网络故障的时候需要断线重连,这样能保证服务即使宕机恢复后也能马上恢复;所以 netty 的断线重连需要 2 步骤,缺一不可;

    三 客户端断线重连

    netty 的服务端一般情况下不需要断线重连,应为服务端服务宕机就只能重新启动服务;所以今天我们研究的是客户端的断线重连;

    3.1 服务启动时断线重连

    首先 我们需要写一个监听器 实现 ChannelFutureListener 接口的 operationComplete 方法, 在这边 我们 使用构造器注入的方式获取 nettyClient 实例, 当客户端连接操作完成后启动一个负载监听,在方法中我们使用 channelFuture.isSuccess() 的 结果进行判定 客户端的连接是否启动成功;如果没有启动成功则启动新的线程进行重连,确保客户端连接时能连接成功;

    @Slf4j
    public class ConnectionListener implements ChannelFutureListener {
        private NettyClient nettyClient;
        public ConnectionListener(NettyClient nettyClient) {
            this.nettyClient = nettyClient;
        }
        @Override
        public void operationComplete(ChannelFuture channelFuture) throws Exception {
            if (!channelFuture.isSuccess()) {
                log.warn("-------------客户端重新连接-----------------");
                final EventLoop loop = channelFuture.channel().eventLoop();
                loop.schedule(new Runnable() {
                    @SneakyThrows
                    @Override
                    public void run() {
                        nettyClient.connect(8080,"127.0.0.1");
                    }
                }, 1L, TimeUnit.SECONDS);
            }
        }
    
    }
    

    这边我们只是实现了一个监听器,我们还需要把监听器注入到客户端;

    public void connect(int port, String host) {
    
            // 创建线程组
            NioEventLoopGroup nioEventLoopGroup = new NioEventLoopGroup();
            // netty启动辅助类
            Bootstrap bootstrap = new Bootstrap();
            //
            bootstrap.group(nioEventLoopGroup)
                    .channel(NioSocketChannel.class)
                    .option(ChannelOption.TCP_NODELAY, true)
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            // 处理IO事件
                            ChannelPipeline pipeline = socketChannel.pipeline();
                            // 异常断线重连
                            pipeline.addLast(new NettyClientHandler(new NettyClient()));
                        }
                    });
            // 异步操作
            ChannelFuture connect = null;
            try {
                connect = bootstrap
                        .connect(host, port)
                        .addListener(new ConnectionListener(this))// netty 启动时如果连接失败,会断线重连
                        .sync();
                // 关闭客户端
                connect.channel()
                        .closeFuture()
                        .sync();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    

    3.2 服务运行中断重连

    我们 在 NettyClientHandler 实现一个 channelInactive 方法,当服务端断线时 我们会触发这个方法重启启动一个线程进行断线重连;

    @Slf4j
    public class NettyClientHandler extends ChannelInboundHandlerAdapter {
    
        private NettyClient nettyClient;
    
    
        public NettyClientHandler(NettyClient nettyClient) {
            this.nettyClient = nettyClient;
        }
    	// ....
    
        /**
         * @Author lsc
         * <p> 运行时断线重连</p>
         * @Param [ctx]
         * @Return
         */
        @Override
        public void channelInactive(ChannelHandlerContext ctx) throws Exception {
            final EventLoop eventLoop = ctx.channel().eventLoop();
            eventLoop.schedule(new Runnable() {
                @Override
                public void run() {
                    System.out.println("22222222222222222");
                    nettyClient.connect(8080, "127.0.0.1");
                }
            }, 1L, TimeUnit.SECONDS);
            super.channelInactive(ctx);
        }
    	// ....
    }
    

    四 模拟断线重连

    首先我们先启动 服务端和 客户端,知识追寻者 的代码有个应答 消息;

    服务端图片效果如下

    客户端图片效果如下

    将 服务端 停止 ,客户端会进行断线重连

    图片效果如下

    重新启动服务端,重连成功

    netty教程

    展开全文
  • WebSocket断线重连

    千次阅读 2018-09-10 17:18:29
    WebSocket断线重连 即时通讯 心跳重连 废话不多说,直接上代码. $scope.timeout = 10800,//3分钟发一次心跳 $scope.timeoutObj = null, $scope.serverTimeoutObj = null, $scope.init = function() { $scope....
  • 基于Tcp的Socket,实现客户端短线重连,服务端断线重连,保持长连接。
  • 主要介绍了C# Mqtt 断线重连,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • KBMMW数据库断线重连DEMO,实现KBMMW断线自动重连数据库。
  • Delphi ClientSocket断线重连.zip
  • js代码-封装断线重连

    2021-07-16 13:30:23
    js代码-封装断线重连
  • java socket客户端断线重连

    热门讨论 2012-07-30 08:54:16
    java socket client 断线重连的简单实现 有什么意见可以提哦
  • 本labview例程实现了同基恩士SR1000系列扫码枪的TCP通讯并实现了断线重连的机制,经测试,断线可以立马检测到,重连由于扫码枪本身特性需要15S才能重新连接成功
  • Netty断线重连实现

    千次阅读 2019-03-05 14:46:06
    netty断线重连实现 学习文章 浅析 Netty 实现心跳机制与断线重连 心跳机制 心跳是TCP长连接中,c-s之间发送的一种特殊的数据包,用来通知对方还在线,以确保TCP连接的有效性。 原理是:当在一段时间Idle后,c或者s会...
  • 断线重连总结

    千次阅读 2017-07-11 13:26:29
    断线重连总结 gateserver负责所有与客户端的直接连接 m_conns[10000]也就是一个gateserver最多可以维持10000条socket连接,蓝月采用的是tcp 行走各种消息都是tcp,不存在丢包一说,只会延迟 每个客户端...
  • php redis断线重连

    千次阅读 2020-09-04 10:00:33
    本文介绍在不重启服务,实现原来的Redis断线重连 原理 Redis 断开的情况下调用 $Redis->ping()会触发Notice错误,Notice: Redis::ping(): send of 14 bytes failed with errno=10054 当获取redis实例时,...
  • Mina 断线重连

    2014-03-11 17:03:27
    Mina 断线重连  定义:这里讨论的Mina 断线重连是指使用mina作为客户端软件,连接其他提供Socket通讯服务的服务器端。Socket服务器可以是Mina提供的服务器,也可以是C++提供的服务器。       一、断线重连...
  • reconnect Tcp断线重连实验
  • 数据库断线重连

    千次阅读 2017-06-08 21:35:31
    数据库断线重连是指,在服务器出现某些原因导致数据库连接中断,需要启动重新连接数据库,并重新执行中断的数据库操作。 Thinkphp5.0 是支持数据库断线重连的,代码很值得学习。它支持查询 query(包括select查询...
  • emq 不断掉线重连

    千次阅读 2019-05-20 19:17:25
    emq平常能正常运行,发送和接收数据都没有问题,在与设备调试过程中突然出现掉线重连,重启程序服务也无法解决,需要重启emq服务才行。 问题分析:可能原因 1、重复clientId 排除,确定没有重复clientId 2、...
  • WebSocket断线重连记录

    万次阅读 2018-03-08 15:29:14
    断线重连与心跳包重连 公司最近在做一个抽奖的运用,年会快到了嘛 应用基于微信页来做开发的,其中有一个功能是需要即时交互,在团队定下的方案中,就用socket,于是我便和websocket会面了; runoob上的例子:...
  • Mina 断线重连机制

    千次阅读 2014-10-26 21:12:21
    Mina 断线重连  定义:这里讨论的Mina 断线重连是指使用mina作为客户端软件,连接其他提供Socket通讯服务的服务器端。Socket服务器可以是Mina提供的服务器,也可以是C++提供的服务器。         ...
  • 校园网断线重连

    2014-10-13 19:26:18
    很好的,很好的解决了校园网断线重连的问题,方便广大用户的切实需要

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 22,454
精华内容 8,981
关键字:

断线重连