首页 > 代码库 > Android客户端与PC服务器通过socket进行交互实例（转）

Android客户端与PC服务器通过socket进行交互实例（转）

2024-07-06 02:48:18   227人阅读

一直以来对Android socket通信都很模糊，今天终于研究了一个网上的例子，自己又修改了下，算是对Android socket通信有点了解了。

下面是具体的代码，说明都在注释中了。需要注意的是，只有客户端发送了信息给服务器后，服务器才能响应客户端的输入，然后返回信息给客户端，这是客户端才能读取服务器返回的信息。如果客户端和服务器都处于等待对方的信息，那样就会造成阻塞，导致ANR了。

1.服务器端代码，就是一个java程序，与android无关，运行于服务器上，即PC机上。

 

[java] view plaincopy
 
  1. import java.io.BufferedReader;  
  2. import java.io.BufferedWriter;  
  3. import java.io.File;  
  4. import java.io.FileOutputStream;  
  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.   
  11. /** 
  12.  * 测试Android客户端与PC服务器通过socket进行交互 
  13.  * 服务器端：接收客户端的信息并回送给客户 
  14.  * @author Ameyume 
  15.  * 
  16.  */  
  17. public class Server implements Runnable {  
  18.     public static final String SERVERIP = "192.168.1.100";  
  19.     public static final int SERVERPORT = 51706;  
  20.   
  21.     public void run() {  
  22.         try {  
  23.             System.out.println("S: Connecting...");  
  24.   
  25.             ServerSocket serverSocket = new ServerSocket(SERVERPORT);  
  26.             while (true) {  
  27.                 // 等待接受客户端请求   
  28.                 Socket client = serverSocket.accept();  
  29.   
  30.                 System.out.println("S: Receiving...");  
  31.                   
  32.                 try {  
  33.                     // 接受客户端信息  
  34.                     BufferedReader in = new BufferedReader(  
  35.                             new InputStreamReader(client.getInputStream()));  
  36.                       
  37.                     // 发送给客户端的消息   
  38.                     PrintWriter out = new PrintWriter(new BufferedWriter(  
  39.                             new OutputStreamWriter(client.getOutputStream())),true);  
  40.                       
  41.                     System.out.println("S: 111111");  
  42.                     String str = in.readLine(); // 读取客户端的信息  
  43.                     System.out.println("S: 222222");  
  44.                     if (str != null ) {  
  45.                         // 设置返回信息，把从客户端接收的信息再返回给客户端  
  46.                         out.println("You sent to server message is:" + str);  
  47.                         out.flush();  
  48.                           
  49.                         // 把客户端发送的信息保存到文件中  
  50.                         File file = new File ("C://android.txt");  
  51.                         FileOutputStream fops = new FileOutputStream(file);   
  52.                         byte [] b = str.getBytes();  
  53.                         for ( int i = 0 ; i < b.length; i++ )  
  54.                         {  
  55.                             fops.write(b[i]);  
  56.                         }  
  57.                         System.out.println("S: Received: ‘" + str + "‘");  
  58.                     } else {  
  59.                         System.out.println("Not receiver anything from client!");  
  60.                     }  
  61.                 } catch (Exception e) {  
  62.                     System.out.println("S: Error 1");  
  63.                     e.printStackTrace();  
  64.                 } finally {  
  65.                     client.close();  
  66.                     System.out.println("S: Done.");  
  67.                 }  
  68.             }  
  69.         } catch (Exception e) {  
  70.             System.out.println("S: Error 2");  
  71.             e.printStackTrace();  
  72.         }  
  73.     }  
  74.       
  75.     public static void main(String [] args ) {  
  76.         Thread desktopServerThread = new Thread(new Server());  
  77.         desktopServerThread.start();  
  78.   
  79.     }  
  80. }  

2.客户端程序，运行在手机或者模拟器上。

 

 

[java] view plaincopy
 
  1. import java.io.BufferedReader;  
  2. import java.io.BufferedWriter;  
  3. import java.io.InputStreamReader;  
  4. import java.io.OutputStreamWriter;  
  5. import java.io.PrintWriter;  
  6. import java.net.InetAddress;  
  7. import java.net.Socket;  
  8. import java.net.UnknownHostException;  
  9.   
  10. import android.app.Activity;  
  11. import android.os.Bundle;  
  12. import android.util.Log;  
  13. import android.view.View;  
  14. import android.view.View.OnClickListener;  
  15. import android.widget.Button;  
  16. import android.widget.EditText;  
  17. import android.widget.TextView;  
  18.   
  19. /** 
  20.  * 测试Android客户端与PC服务器通过socket进行交互 
  21.  * 客户端：把用户输入的信息发送给服务器 
  22.  * @author Ameyume 
  23.  * 
  24.  */  
  25. public class Socket_Android extends Activity {  
  26.     private static final String TAG = "Socket_Android";  
  27.       
  28.     private EditText mEditText = null;  
  29.     private TextView tx1 = null;  
  30.     private Button mButton = null;  
  31.       
  32.     @Override  
  33.     public void onCreate(Bundle savedInstanceState) {  
  34.         super.onCreate(savedInstanceState);  
  35.         setContentView(R.layout.main);  
  36.           
  37.         mButton = (Button)findViewById(R.id.Button01);  
  38.         mEditText = (EditText)findViewById(R.id.etSendMsg);  
  39.         tx1 = (TextView)findViewById(R.id.tx);  
  40.           
  41.         mButton.setOnClickListener(new OnClickListener() {  
  42.   
  43.             @Override  
  44.             public void onClick(View v) {  
  45.                 // TODO Auto-generated method stub  
  46.                 setTitle("测试Socket连接");  
  47.                 Socket socket = null;  
  48.                   
  49.                 try {  
  50.                     /* 指定Server的IP地址，此地址为局域网地址，如果是使用WIFI上网，则为PC机的WIFI IP地址 
  51.                      * 在ipconfig查看到的IP地址如下： 
  52.                      * Ethernet adapter 无线网络连接: 
  53.                      * Connection-specific DNS Suffix  . : IP Address. . . . . . . . . . . . : 192.168.1.100 
  54.                      */  
  55.                     InetAddress serverAddr = InetAddress.getByName("192.168.1.100");// TCPServer.SERVERIP  
  56.                     Log.d("TCP", "C: Connecting...");  
  57.                       
  58.                     // 应用Server的IP和端口建立Socket对象  
  59.                     socket = new Socket(serverAddr, 51706);  
  60.                     String message = "---Test_Socket_Android---";    
  61.     
  62.                     Log.d("TCP", "C: Sending: ‘" + message + "‘");    
  63.                       
  64.                     // 将信息通过这个对象来发送给Server    
  65.                     PrintWriter out = new PrintWriter(new BufferedWriter(    
  66.                             new OutputStreamWriter(socket.getOutputStream())),    
  67.                             true);    
  68.                         
  69.                     // 把用户输入的内容发送给server  
  70.                     String toServer = mEditText.getText().toString();  
  71.                     Log.d(TAG, "To server:‘" + toServer + "‘");  
  72.                     out.println(toServer);  
  73.                     out.flush();    
  74.                       
  75.                       
  76.                     // 接收服务器信息    
  77.                     BufferedReader in = new BufferedReader(    
  78.                                 new InputStreamReader(socket.getInputStream()));    
  79.                     // 得到服务器信息    
  80.                     String msg = in.readLine();  
  81.                     Log.d(TAG, "From server:‘" + msg + "‘");  
  82.                     // 在页面上进行显示    
  83.                     tx1.setText(msg);    
  84.                 } catch(UnknownHostException e) {  
  85.                     Log.e(TAG, "192.168.1.100 is unkown server!");  
  86.                 } catch(Exception e) {  
  87.                     e.printStackTrace();  
  88.                 } finally {  
  89.                     try {  
  90.                         socket.close();  
  91.                     } catch(Exception e) {  
  92.                         e.printStackTrace();  
  93.                     }  
  94.                 }  
  95.             }  
  96.               
  97.         });  
  98.     }  
  99. }  

3.在客户端AndroidManifest.xml文件增加访问互联网的权限

 

 

[html] view plaincopy
 
  1. <uses-permission android:name="android.permission.INTERNET" />  

4.运行效果：

服务器接的log输出：

S: Receiving...
S: 111111
S: 222222
S: Received: ‘hello‘
S: Done.

本文参考自：Android通过socket连接服务器（PC）

 


联系
我们