android nio非阻塞多线程socket连接实现

changjianfeng

费好大功夫凑的程序。在android平台实现网络连接。注释清楚，希望对我这样的没学过java的新人有点用。
package nio.socket.nei;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;

import android.app.Activity;

import android.os.Bundle;
import android.os.Handler;

import android.os.Message;

import android.widget.TextView;

public class niosocket extends Activity {
       
       
        //定义检测socketchannel的selector对象
        private Selector selector=null;
        //客户端socketchannel
        private SocketChannel sc=null;
    //定义处理编码和解码的字符集
        private Charset charset=Charset.forName("GBK");
        public TextView tv;
    /** Called when the activity is first created. */
    /**
     * 接受消息,处理消息 ,此Handler会与当前主线程一块运行
     * */

     Handler MyHandler=new Handler() {                       

         // 子类必须重写此方法,接受数据
         @Override
         public void handleMessage(Message msg) {
        super.handleMessage(msg);
        Bundle b=msg.getData();
        String counnt=b.getString("colo");
        tv.setText(counnt);
         }
     };
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
      // bar=(ProgressBar) findViewById(R.id.progress);
       tv=(TextView)findViewById(R.id.text_view);
        try {
                //创建selector实例
                        selector=Selector.open();                       
                        InetSocketAddress isa=new InetSocketAddress("192.168.0.100",60000);       
                        //调用OPEn静态方法创建连接到指定主机的socketchannel
                        sc=SocketChannel.open(isa);
                        //设置SC为非阻塞方式工作
                        sc.configureBlocking(false);
                        //将sockchannel对象注_册到指定selector
                        sc.register(selector, SelectionKey.OP_READ);
                       
                        String line="连接成功";
                    sc.write(charset.encode(line));
                       
                } catch (IOException e) {
                        e.printStackTrace();
                }
      tv.setText("");   

       MyThread m = new MyThread();      
       new Thread(m).start();//启动线程      
      
      

    }
   
    class MyThread implements Runnable {
                   
                     public void run() {             
                         try {
                                 //监控所有注_册的channel，返回这里要处理channel的数量
                                 while(selector.select()>0)
                                 {
                                //处理每个有IO操作的集合
                                 for(SelectionKey sk:selector.selectedKeys())
                                 {   //删除正在处理的selectionkey
                                         selector.selectedKeys().remove(sk);
                                         //如果该selectionkey对应的channel中有可读的数据
                                         if(sk.isReadable())
                                         {
                                                 SocketChannel sc=(SocketChannel)sk.channel();
                                                 ByteBuffer buff=ByteBuffer.allocate(100);
                                                 String content="";
                                                 while(sc.read(buff)>0)
                                                 {//读出字节到缓存
                                                         sc.read(buff);
                                                         buff.flip();//反转缓存数据
                                                         content+=charset.decode(buff);
                                                 }
                                                 Message msg=new Message();
                                                 Bundle b=new Bundle();
                                                 b.putString("colo", content);
                                                 msg.setData(b);
                                                 MyHandler.sendMessage(msg);
                                                 //为下一次读取作准备
                                                 sk.interestOps(SelectionKey.OP_READ);
                                         }
                                 }
                                 }           
                                            }
                                 catch (IOException ex) {
                             ex.printStackTrace();
                         }             
                     }
                 }
    }

changjianfeng

要在androidManifest.xml里设置访问网络的权限，要不然连接时间会报错。
androidManifest.xml里加入：
</application>
      <uses-permission
     android:name="android.permission.ACCESS_WIFI_STATE"></uses-permission>     
    <uses-permission
     android:name="android.permission.INTERNET" />
</manifest>

changjianfeng

以上程序是客户端，现在有个问题不知咋处理。
当客户端某种原因和服务器连接失败，我怎么能知道和服务器已经断开，我试验的貌似没啥反应，断开后发送数据，也没有异常。请高手帮忙指点一下。
当客户端掉线后，可以自动从新和服务器连接就行。

zf8848

加入心跳协议哈.
像这类跨平台的网络通讯,我们这里主要用各种开源库来实现,首选boost的asio.
甚至我们的232短信猫也用asio来实现了.

changjianfeng

加入心跳协议。我现在的问题是，连接好后，发送心跳包，如果发送失败，程序里是不是应该会报异常，是什么异常。我是不是可以在异常中从新连接。
在连接失败后，我发送5个心跳包，才会进入异常。感觉不太对。

CoolBird007

不知楼主解决问题没有，我现在也在做这块，socket就死线程阻塞上，所以上NIO。结果情况也差不多，socket还能检测到服务器断开呢。

heicnhei3

mark，刚接触这个，回头看

cheungman

1. //Socket连接进程(加入状态机实现Socket长连接和断线重连)(PS: 此代码对NetAssist.exe在WIN7下无效)
   
2.     class Client_ConnectThread extends Thread {
   
3.         Message msg = new Message();
   
4.         @Override
   
5.         public void run() {
   
6.             while(true){
   
7.                 //状态0: 初始化
   
8.                 if(socket_state == 0){
   
9.                     socket_state = 1;
   
10.                     socket_connect_flag = false;
    
11. 
    
12.                     Log.i("TcpClient", "Init");
    
13.                 }
    
14.                 //状态1: 连接服务器
    
15.                 else if(socket_state == 1){
    
16.                     try {
    
17.                         //实例化对象并连接到服务器
    
18.                         clientSocket = new Socket("192.168.1.112", 8888);
    
19.                         //clientSocket.setSoTimeout(1000);
    
20.                         socket_state = 2;
    
21.                         Log.i("TcpClient", "Connect");
    
22.                     } catch (UnknownHostException e1) {
    
23.                         socket_state = 0;
    
24.                         Log.i("TcpClient", "UnknownHost");
    
25.                         e1.printStackTrace();
    
26.                     } catch (IOException e1) {
    
27.                         socket_state = 0;
    
28.                         Log.i("TcpClient", "IOException");
    
29.                         e1.printStackTrace();
    
30.                     }
    
31.                 }
    
32.                 //状态2: 检测是否连接上, 如果连接上, 开启接收线程
    
33.                 else if(socket_state == 2){
    
34.                     if (clientSocket.isConnected()) {
    
35.                         socket_connect_flag = true;
    
36.                         socket_state = 3;
    
37. 
    
38.                         msg.what = 1;
    
39.                         msgHandler.sendMessage(msg);
    
40. 
    
41.                         //开启接收线程
    
42.                         mReceiveThread = new ReceiveThread(clientSocket);
    
43.                         mReceiveThread.start();
    
44.                     }
    
45.                     else{
    
46.                         socket_connect_flag = false;
    
47.                         socket_state = 0;
    
48. 
    
49.                         msg.what = 2;
    
50.                         msgHandler.sendMessage(msg);
    
51.                     }
    
52.                 }
    
53.                 //状态3: 发送心跳报文, 同时挂起线程
    
54.                 else if(socket_state == 3){
    
55.                     try {
    
56.                         clientSocket.sendUrgentData(0);
    
57.                         socket_state = 3;
    
58.                         Log.i("TcpClient", "sendUrgentData");
    
59. 
    
60.                         //挂起线程, 休眠10s
    
61.                         try {
    
62.                             Thread.sleep(10000);
    
63.                         } catch (InterruptedException e1)
    
64.                         {
    
65.                             e1.printStackTrace();
    
66.                         }
    
67.                     } catch (IOException e) {
    
68.                         e.printStackTrace();
    
69. 
    
70.                         socket_state = 4;
    
71.                         Log.i("TcpClient", "sendUrgentData error");
    
72. 
    
73.                         //挂起线程, 休眠1ms
    
74.                         try {
    
75.                             Thread.sleep(1);
    
76.                         } catch (InterruptedException e1)
    
77.                         {
    
78.                             e1.printStackTrace();
    
79.                         }
    
80.                     }
    
81.                 }
    
82.                 //状态4: 发送心跳报文有异常, 跳转到状态0, 重新连接
    
83.                 else if(socket_state == 4){
    
84.                     socket_state = 0;
    
85.                     try {
    
86.                         clientSocket.close();
    
87.                     } catch (UnknownHostException e1) {
    
88.                         e1.printStackTrace();
    
89.                     } catch (IOException e1) {
    
90.                         e1.printStackTrace();
    
91.                     }
    
92.                 }
    
93.             }
    
94.         }

复制代码

发心跳报文, 抛出异常就重连