Android网络编程之Socket

时间：2023-03-08 16:24:36
Android网络编程之Socket

Socket（套接字）是一种通信机制，可以实现单机或跨网络进行通信，其创建需要明确的区分C（客户端）/S（服务器端），支持多个客户端连接到同一个服务器。有两种传输模式：

1）、面向连接的传输：基于TCP协议，可靠性高，但效率低；

2）、面向无连接的传输：基于UDP协议，可靠性低，但效率高；

Android中，直接采用Socket通信应该是我们遇到的最低级的网络运用。尽管已经作了很大程度的抽象，但是纯粹的Socket通信，仍然给开发者留下很多细节需要处理，尤其在服务器端，开发者需要处理多线程以及数据缓冲等的设计问题。相对而言，处于更高抽象层的HTTP等，已经对Socket通信中需要处理的技术细节进行了很好的封装，开发者无须关心，因此，HTTP在网络开发中通常具有决定性的优势。

Android在其核心库的java包中，提供了用于客户端的Socket class和用于服务器端的ServerSocket class，分别位于$SOURCE/libcore/luni/src/main/java/java/net/Socket.java和$SOURCE/libcore/luni/src/main/java/java/net/ServerSocket.java文件中。分析两个class的源码，可以看出封装考虑的很全面，只构造方法一向每个class都考虑了很多种使用情况。由于本人只是初学者，很多理解的不深入，这里只抛砖引玉的对两个class的构造方法分别介绍一种，就是我下面的程序中用到的：

Socket(String dstName, int dstPort)：创建一个以流的方式（基于TCP协议）连接到目标机（这里可以理解为服务器）的客户端Socket；dstName是目标机的IP地址，dstPort是要连接的目标机的端  口号。这里要注意对端口的理解，它不能理解为物理上的一个接口，而是对计算机中一块特殊内存区域的形象表述。

ServerSocket(int aport)：创建一个绑定到本机指定端口的服务端Socket；aport就是指定的本机端口。与上述客户端Socket对应，通过TCP连接时，ServerSocket创建后需要在aport端口上进行监听，等待客户端的连接。

上面所写都是些背景知识，下面对本人的编程实践进行详细说明。

1、功能描述

1）、简单的基于Socket的数据通信；

2）、采用TCP方式连接；

3）、采用C/S结构，但服务端只支持一个连接；

4）、客户端能够向服务端发送数据，并显示服务端的返回信息；

5）、服务端能够接收客户端的数据，并将收到的数据以特定的方式返回给客户端；

2、程序实现思路

1）、服务端：设计为在后台执行的service，用一个独立的线程来处理客户端的连接请求、数据接收和返回。为了启动该service，编写个简单的Activity。

2）、客户端：设计为一个Activity，界面由三部分组成：显示服务端返回信息的文本区域（一个文本框）；进行数据输入的编辑区域（一个编辑框）；以及触发连接请求并执行数据发送的触发区域（一个按钮）。

3、服务端源程序

1）、Activity文件SocketServerDemo.java

  1. package com.android.sample.SocketServerDemo;
  2. import android.app.Activity;
  3. import android.content.Intent;
  4. import android.os.Bundle;
  5. public class SocketServerDemo extends Activity{
  6. @Override
  7. protected void onCreate(Bundle savedInstanceState) {
  8. // TODO Auto-generated method stub
  9. super.onCreate(savedInstanceState);
  10. setContentView(R.layout.main);
  11. System.out.println("begin start service");
  12. this.startService(new Intent(this, SocketService.class));
  13. }
  14. @Override
  15. protected void onDestroy() {
  16. // TODO Auto-generated method stub
  17. super.onDestroy();
  18. this.stopService(new Intent(this, SocketService.class));
  19. }
  20. }

2）、service文件SocketService.java

  1. package com.android.sample.SocketServerDemo;
  2. import java.io.BufferedReader;
  3. import java.io.BufferedWriter;
  4. import java.io.IOException;
  5. import java.io.InputStreamReader;
  6. import java.io.OutputStreamWriter;
  7. import java.io.PrintWriter;
  8. import java.net.ServerSocket;
  9. import java.net.Socket;
  10. import android.app.Service;
  11. import android.content.Intent;
  12. import android.os.IBinder;
  13. public class SocketService extends Service{
  14. Thread mServiceThread;
  15. Socket client;
  16. @Override
  17. public IBinder onBind(Intent intent) {
  18. // TODO Auto-generated method stub
  19. return null;
  20. }
  21. @Override
  22. public void onCreate() {
  23. // TODO Auto-generated method stub
  24. super.onCreate();
  25. mServiceThread = new Thread(new SocketServerThread());
  26. }
  27. @Override
  28. public void onStart(Intent intent, int startId) {
  29. // TODO Auto-generated method stub
  30. super.onStart(intent, startId);
  31. mServiceThread.start();
  32. }
  33. @Override
  34. public void onDestroy() {
  35. // TODO Auto-generated method stub
  36. super.onDestroy();
  37. }
  38. public class SocketServerThread extends Thread {
  39. private static final int PORT = 54321;
  40. private SocketServerThread(){
  41. }
  42. @Override
  43. public void run() {
  44. try {
  45. ServerSocket server = new ServerSocket(PORT);
  46. while(true){
  47. System.out.println("begin client connected");
  48. client = server.accept();
  49. System.out.println("client connected");
  50. BufferedReader reader = new BufferedReader(new InputStreamReader(client.getInputStream()));
  51. System.out.println("read from client:");
  52. String textLine = reader.readLine();
  53. if(textLine.equalsIgnoreCase("EXIT")){
  54. System.out.println("EXIT invoked, closing client");
  55. break;
  56. }
  57. System.out.println(textLine);
  58. PrintWriter writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(client.getOutputStream())));
  59. writer.println("ECHO from server: " + textLine);
  60. writer.flush();
  61. writer.close();
  62. reader.close();
  63. }
  64. } catch (IOException e) {
  65. // TODO Auto-generated catch block
  66. System.err.println(e);
  67. }
  68. }
  69. }
  70. }

3）、AndroidManifest.xml文件，因为需要在其中添加service和网络访问权限，这里一并贴出

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"
  3. package="com.android.sample.SocketServerDemo"
  4. android:versionCode="1"
  5. android:versionName="1.0">
  6. <uses-sdk android:minSdkVersion="9" />
  7. <application android:icon="@drawable/icon" android:label="@string/app_name">
  8. <activity android:name=".ScreenCastServer"
  9. android:label="@string/app_name">
  10. <intent-filter>
  11. <action android:name="android.intent.action.MAIN" />
  12. <category android:name="android.intent.category.LAUNCHER" />
  13. </intent-filter>
  14. </activity>
  15. <service android:name="com.android.sample.SocketServerDemo.SocketService">
  16. </service>
  17. </application>
  18. <uses-permission android:name="android.permission.INTERNET"/>
  19. </manifest>

4、客户端程序

1）、布局文件main.xml

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
  3. android:orientation="vertical"
  4. android:layout_width="fill_parent"
  5. android:layout_height="fill_parent"
  6. >
  7. <TextView
  8. android:id="@+id/receive_msg"
  9. android:layout_width="fill_parent"
  10. android:layout_height="wrap_content"
  11. />
  12. <EditText
  13. android:id="@+id/edit_msg"
  14. android:layout_width="fill_parent"
  15. android:layout_height="wrap_content"
  16. />
  17. <Button
  18. android:id="@+id/send_msg"
  19. android:layout_width="wrap_content"
  20. android:layout_height="wrap_content"
  21. android:text="send"
  22. />
  23. </LinearLayout>

2）、Activity文件SocketClientDemo.java

  1. package com.android.sample.SocketClientDemo;
  2. import java.io.BufferedReader;
  3. import java.io.BufferedWriter;
  4. import java.io.IOException;
  5. import java.io.InputStreamReader;
  6. import java.io.OutputStreamWriter;
  7. import java.io.PrintWriter;
  8. import java.net.Socket;
  9. import java.net.UnknownHostException;
  10. import android.app.Activity;
  11. import android.os.Bundle;
  12. import android.view.View;
  13. import android.view.View.OnClickListener;
  14. import android.widget.Button;
  15. import android.widget.EditText;
  16. import android.widget.TextView;
  17. public class SocketClientDemo extends Activity {
  18. private static final String SERVERIP = "192.168.1.68";
  19. private static final int SERVERPORT = 54321;
  20. TextView mMsgRev;
  21. EditText mMsgEdit;
  22. Button   mMsgSendBtn;
  23. String mSendMsg;
  24. String mReceivedMsg;
  25. /** Called when the activity is first created. */
  26. @Override
  27. public void onCreate(Bundle savedInstanceState) {
  28. super.onCreate(savedInstanceState);
  29. setContentView(R.layout.main);
  30. mMsgRev = (TextView)findViewById(R.id.receive_msg);
  31. mMsgEdit = (EditText)findViewById(R.id.edit_msg);
  32. mMsgSendBtn = (Button)findViewById(R.id.send_msg);
  33. mMsgSendBtn.setOnClickListener(new OnClickListener(){
  34. @Override
  35. public void onClick(View v) {
  36. Socket socket = null;
  37. mSendMsg = mMsgEdit.getText().toString();
  38. try {
  39. socket = new Socket(SERVERIP, SERVERPORT);
  40. PrintWriter writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())));
  41. writer.println(mSendMsg);
  42. writer.flush();
  43. BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
  44. mReceivedMsg = reader.readLine();
  45. if(mReceivedMsg != null){
  46. mMsgRev.setText(mReceivedMsg);
  47. }else{
  48. mMsgRev.setText("receive data error");
  49. }
  50. writer.close();
  51. reader.close();
  52. socket.close();
  53. } catch (UnknownHostException e) {
  54. // TODO Auto-generated catch block
  55. e.printStackTrace();
  56. } catch (IOException e) {
  57. // TODO Auto-generated catch block
  58. e.printStackTrace();
  59. }
  60. }
  61. });
  62. }
  63. }

3）、在AndroidManifest.xml中向服务器端的该文件一样，添加网络访问权限：<uses-permission android:name="android.permission.INTERNET"/>

5、执行环境搭建

服务端程序在开发板上执行，客户端程序在模拟器上执行，实现了基于Socket的数据收发。但是我这里只是进行了局域网内的通信，至于跨网络能不能行，目前条件不够，没法进行验证。

转：http://blog.csdn.net/harry_helei/article/details/6638876

相关文章