有光Android Socket的编程

花了大概两天的时间，终于把Android的Socket编程给整明白了。抽空和大家分享一下：
Socket Programming on Android
Socket 编程基础知识：
主要分服务器端编程和客户端编程。
服务器端编程步骤：
1：创建服务器端套接字并绑定到一个端口上（0-1023是系统预留的，最好大约1024）
2：套接字设置监听模式等待连接请求
3：接受连接请求后进行通信
4：返回，等待赢一个连接请求

客户端编程步骤：
1：创建客户端套接字（指定服务器端IP地址与端口号）
2：连接（Android 创建Socket时会自动连接）
3：与服务器端进行通信
4：关闭套接字

Android Socket 通信原理注意：
1：中间的管道连接是通过InputStream/OutputStream流实现的。
2：一旦管道建立起来可进行通信
3：关闭管道的同时意味着关闭Socket
4：当对同一个Socket创建重复管道时会异常
5：通信过程中顺序很重要：服务器端首先得到输入流，然后将输入流信息输出到其各个客户端
客户端先建立连接后先写入输出流，然后再获得输入流。不然活有EOFException的异常。

下面是关于在服务器端编程的代码：

Java代码  
import java.io.DataInputStream;  
import java.io.DataOutputStream;  
import java.io.IOException;  
import java.net.ServerSocket;  
import java.net.Socket;  
import java.util.ArrayList;  
  
/** 
 *@author Andrew.Lee 
 *@create 2011-6-1 下午04:45:19 
 *@version 1.0 
 *@see 
 */  
public class Server {  
    static ServerSocket aServerSocket = null; // Server Socet.  
    DataInputStream aDataInput = null; // Server input Stream that to  
    // receive msg from client.  
    DataOutputStream aDataOutput = null; // Server output Stream that to  
    static ArrayList list = new ArrayList();  
  
    public static void main(String[] args) {  
        try {  
            aServerSocket = new ServerSocket(50003); // listen 8888 port.  
            System.out.println("already listen 50003 port.");  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
        int num = 0;  
        while (num < 10) {  
            Socket aSessionSoket = null;  
            try {  
                aSessionSoket = aServerSocket.accept();  
                MyThread thread = new Server().new MyThread(aSessionSoket);  
                thread.start();  
                num = list.size();  
            } catch (IOException e1) {  
                // TODO Auto-generated catch block  
                e1.printStackTrace();  
            }  
        }  
    }  
  
    class MyThread extends Thread {  
        Socket aSessionSoket = null;  
  
        public MyThread(Socket socket) {  
            aSessionSoket = socket;  
        }  
  
        public void run() {  
            try {  
                aDataInput = new DataInputStream(aSessionSoket.getInputStream());  
                aDataOutput = new DataOutputStream(aSessionSoket  
                        .getOutputStream());  
                list.add(aDataOutput);  
                while (true) {  
                    String msg = aDataInput.readUTF(); // read msg.  
                    if (!msg.equals("connect...")) {  
                        System.out.println("ip: "  
                                + aSessionSoket.getInetAddress());// ip.  
                        System.out.println("receive msg: " + msg);  
                        for (int i = 0; i < list.size(); i++) {  
                            DataOutputStream output = (DataOutputStream) list  
                                    .get(i);  
                            output.writeUTF(msg + "----" + list.size());  
                        }  
                        if (msg.equals("end"))  
                            break;  
                    }  
                    aDataOutput.writeUTF("");  
                }  
  
            } catch (IOException e) {  
                // TODO Auto-generated catch block  
                e.printStackTrace();  
            } finally {  
                try {  
                    aDataInput.close();  
                    if (aDataOutput != null)  
                        aDataOutput.close();  
                    list.remove(aDataOutput);  
                    aSessionSoket.close();  
  
                } catch (Exception e2) {  
                    e2.printStackTrace();  
                }  
  
            }  
  
        }  
    }  
}  

注意问题：为了实现对于多个客户端的处理，使用了多线程的操作，每个线程维护一个Socket的连接与通信，新连接的Socket的管道被加入到ArrayList中。对于输出流的操作是对于所有的连接的客户端进行写数据。对于关闭了Socket的客户端管道从List中移除。
客户端编程代码：

Java代码  
package com.daisy.android.network;  
  
import java.io.DataInputStream;  
import java.io.DataOutputStream;  
import java.io.IOException;  
import java.net.InetSocketAddress;  
import java.net.Socket;  
import java.net.SocketAddress;  
import java.net.UnknownHostException;  
  
import android.app.Activity;  
import android.os.Bundle;  
import android.os.Handler;  
import android.os.Message;  
import android.util.Log;  
import android.view.View;  
import android.view.View.OnClickListener;  
import android.widget.Button;  
import android.widget.EditText;  
import android.widget.TextView;  
  
/** 
 *@author Andrew.Lee 
 *@create 2011-5-28 下午02:26:20 
 *@version 1.0 
 *@see 
 */  
  
public class SocketActivity extends Activity {  
    EditText editText = null;  
    Button sendButton = null;  
    TextView display = null;  
    Socket client = null;  
    MyHandler myHandler;  
    DataOutputStream dout;  
    DataInputStream din;  
  
    public void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.clientsocket);  
        editText = (EditText) findViewById(R.id.message);  
        sendButton = (Button) findViewById(R.id.send);  
        display = (TextView) findViewById(R.id.display);  
        sendButton.setOnClickListener(listener);  
        try {  
            client = new Socket("192.168.0.120", 50003);  
            dout = new DataOutputStream(client.getOutputStream());  
            din = new DataInputStream(client.getInputStream());  
        } catch (UnknownHostException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        } catch (IOException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        }  
  
        myHandler = new MyHandler();  
  
        MyThread m = new MyThread();  
        m.start();  
    }  
  
    class MyHandler extends Handler {  
        public MyHandler() {  
        }  
  
        // 子类必须重写此方法,接受数据  
        @Override  
        public void handleMessage(Message msg) {  
            // TODO Auto-generated method stub  
            Log.d("MyHandler", "handleMessage......");  
            super.handleMessage(msg);  
            // 此处可以更新UI  
  
            if (client != null && client.isConnected()) {  
                Log.i("handler..", "*-----*");  
                try {  
                    dout.writeUTF("connect...");  
                    String message = din.readUTF();  
                    if (!message.equals(""))  
                        display.setText(display.getText().toString() + "\n"  
                                + "服务器发来的消息--：" + message);  
                } catch (IOException e) {  
                    // TODO Auto-generated catch block  
                    e.printStackTrace();  
                }  
            }  
  
        }  
    }  
  
    class MyThread extends Thread {  
        public void run() {  
            while (true) {  
                try {  
                    Thread.sleep(1000);  
                } catch (InterruptedException e) {  
                    // TODO Auto-generated catch block  
                    e.printStackTrace();  
                }  
                Message msg = new Message();  
                SocketActivity.this.myHandler.sendMessage(msg);  
            }  
        }  
    }  
  
    OnClickListener listener = new OnClickListener() {  
  
        @Override  
        public void onClick(View v) {  
            // TODO Auto-generated method stub  
            String sendText = editText.getText().toString();  
            try {  
                // din = new DataInputStream(client.getInputStream());  
                dout.writeUTF(sendText);  
                /* 
                 * display.setText(display.getText().toString() + "\n" + 
                 * "服务器发来的消息：" + din.readUTF()); 
                 */  
                /* 
                 * display.setText(display.getText().toString() + "\n" + 
                 * "服务器发来的消息--：" + din.readUTF()); 
                 */  
            } catch (UnknownHostException e) {  
                // TODO Auto-generated catch block  
                e.printStackTrace();  
            } catch (IOException e) {  
                // TODO Auto-generated catch block  
                e.printStackTrace();  
            }  
        }  
    };  
}  

注意：为实现对于UI的间歇性刷新操作，使用到了Handler的消息机制。

附注：以上只是对Android的Socket编程的大致思路和过程，其中缺少了对于InputStream/OututStream 的异常处理，连接超时等处理。
（转载请注明出处：[url=http://www.6rfd.com]澳门博彩[/url]

[url=http://www.9gds.com]易博网[/url]）

posted on 2012-04-18 13:58 夏凡阅读(353) 评论(0) 编辑收藏

新用户注册刷新评论列表


只有注册用户登录后才能发表评论。




网站导航: 博客园 IT新闻知识库 C++博客博问

myJavaBlog

有光Android Socket的编程

导航

常用链接

留言簿

随笔档案

搜索

最新评论

阅读排行榜

评论排行榜