2013年7月20日 星期六

使用Android網絡編程實現簡易聊天室

在Java中我們可以利用socket編程實現聊天室,在Android中也一樣,因為Android完全支持JDK本身的TCP、UDP網絡通信API。我們可以使用ServerSocket、Socket來建立基於TCP/IP協議的網絡通信;也可以使用DatagramSocket、Datagrampacket、MulticastSocket來建立基於UDP協議的網絡通信。下面實現一個簡單的聊天室,服務器端完全用Java代碼實現,跟Android無關,客戶端用Android應用來實現。
服務器不斷讀取來自客戶端的信息,並即時地將信息發送給每個連接到本服務器上的客戶端,每個客戶端可以向服務器發送消息,並不斷地接收來自服務器的消息,並將消息顯示在界面上。這樣就實現了客戶端與客戶端之間的即時聊天功能。代碼如下:
服務器端:
創建服務器的主類:
  1. package  com.home.server;  
  2.   
  3. import  java.io.IOException;  
  4. import  java.net.ServerSocket;  
  5. import  java.net.Socket;  
  6. import  java.util.ArrayList;  
  7.   
  8. public  class  MyServer {  
  9.   
  10.     // 定義保存所有Socket的集合  
  11.     public  static  ArrayList<Socket> socketList =  new  ArrayList<Socket>();  
  12.   
  13.     public  static  void  main(String[] args)  throws  IOException {  
  14.         ServerSocket ss =  new  ServerSocket( 20000 );  
  15.         System.out.println( "服務器創建成功!" );  
  16.         System.out.println( "等待客戶端的連接。。。" );  
  17.         while  ( true ) {  
  18.             // 此行代碼會阻塞,等待用戶的連接  
  19.             Socket socket = ss.accept();  
  20.             System.out.println( "有客戶端連接進來!" );  
  21.             socketList.add(socket);  
  22.             // 每當客戶端連接後啟動一條ServerThread線程為該客戶端服務  
  23.             new  Thread( new  ServerThread(socket)).start();  
  24.         }  
  25.     }  
  26.   
  27. }  
服務器的線程類:
  1. package  com.home.server;  
  2.   
  3. import  java.io.BufferedReader;  
  4. import  java.io.IOException;  
  5. import  java.io.InputStreamReader;  
  6. import  java.io.OutputStream;  
  7. import  java.net.Socket;  
  8.   
  9. public  class  ServerThread  implements  Runnable {  
  10.     // 定義當前線程所處理的Socket  
  11.     private  Socket socket =  null ;  
  12.     // 該線程所處理的Socket所對應的輸入流  
  13.     BufferedReader br =  null ;  
  14.   
  15.     public  ServerThread(Socket socket)  throws  IOException {  
  16.         this .socket = socket;  
  17.         // 初始化該Socket對應的輸入流  
  18.         br =  new  BufferedReader( new  InputStreamReader(socket.getInputStream(),  
  19.                 "utf-8" ));  
  20.     }  
  21.   
  22.     @Override  
  23.     public  void  run() {  
  24.         try  {  
  25.             String content =  null ;  
  26.             // 採用循環不斷從Socket中讀取客戶端發送過來的數據  
  27.             while  ((content = readFromClient()) !=  null ) {  
  28.                 // 遍歷socketList中的每個Socket,將讀到的內容向每個Socket發送一次  
  29.                 for  (Socket s : MyServer.socketList) {  
  30.                     OutputStream os = s.getOutputStream();  
  31.                     os.write((content +  "\n" ).getBytes( "utf-8" ));  
  32.                 }  
  33.             }  
  34.         }  catch  (Exception e) {  
  35.             e.printStackTrace();  
  36.         }  
  37.     }  
  38.   
  39.     /** 
  40.      * 定義讀取客戶端數據的方法 
  41.      *  
  42.      * @return 
  43.      */  
  44.     private  String readFromClient() {  
  45.         try  {  
  46.             return  br.readLine();  
  47.         }  
  48.         // 如果捕捉到異常,表明該Socket對應的客戶端已經關閉  
  49.         catch  (Exception e) {  
  50.             // 刪除該Socket  
  51.             MyServer.socketList.remove(socket);  
  52.             e.printStackTrace();  
  53.         }  
  54.         return  null ;  
  55.     }  
  56. }  
客戶端主類(Activity):
  1. package  com.home.activity;  
  2.   
  3. import  java.io.OutputStream;  
  4. import  java.net.Socket;  
  5.   
  6. import  android.app.Activity;  
  7. import  android.os.Bundle;  
  8. import  android.os.Handler;  
  9. import  android.os.Message;  
  10. import  android.view.View;  
  11. import  android.view.View.OnClickListener;  
  12. import  android.widget.Button;  
  13. import  android.widget.EditText;  
  14.   
  15. import  com.home.R;  
  16. import  com.home.util.ClientThread;  
  17.   
  18. public  class  MultiThreadClient  extends  Activity {  
  19.     private  EditText input, show;  
  20.     private  Button sendBtn;  
  21.     private  OutputStream os;  
  22.     private  Handler handler;  
  23.   
  24.     @Override  
  25.     protected  void  onCreate(Bundle savedInstanceState) {  
  26.         super .onCreate(savedInstanceState);  
  27.         setContentView(R.layout.activity_main);  
  28.         input = (EditText) findViewById(R.id.main_et_input);  
  29.         show = (EditText) findViewById(R.id.main_et_show);  
  30.         sendBtn = (Button) findViewById(R.id.main_btn_send);  
  31.         handler =  new  Handler() {  
  32.             @Override  
  33.             public  void  handleMessage(Message msg) {  
  34.                 // 如果消息來自子線程  
  35.                 if  (msg.what ==  0x234 ) {  
  36.                     // 將讀取的內容追加顯示在文本框中  
  37.                     show.append( "\n"  + msg.obj.toString());  
  38.                 }  
  39.             }  
  40.         };  
  41.         Socket socket;  
  42.         try  {  
  43.             socket =  new  Socket( "192.168.0.101" ,  20000 );  
  44.             // 客戶端啟動ClientThread線程不斷讀取來自服務器的數據  
  45.             new  Thread( new  ClientThread(socket, handler)).start();  
  46.             os = socket.getOutputStream();  
  47.         }  catch  (Exception e) {  
  48.             e.printStackTrace();  
  49.         }  
  50.         sendBtn.setOnClickListener( new  OnClickListener() {  
  51.   
  52.             @Override  
  53.             public  void  onClick(View v) {  
  54.                 try  {  
  55.                     // 將用戶在文本框內輸入的內容寫入網絡  
  56.                     os.write((input.getText().toString() +  "\r\n" ).getBytes());  
  57.                     // 清空input文本框數據  
  58.                     input.setText( "" );  
  59.                 }  catch  (Exception e) {  
  60.                     e.printStackTrace();  
  61.                 }  
  62.             }  
  63.         });  
  64.     }  
  65.   
  66. }  
客戶端線程類:
  1. package  com.home.util;  
  2.   
  3. import  java.io.BufferedReader;  
  4. import  java.io.IOException;  
  5. import  java.io.InputStreamReader;  
  6. import  java.net.Socket;  
  7.   
  8. import  android.os.Handler;  
  9. import  android.os.Message;  
  10.   
  11. public  class  ClientThread  implements  Runnable {  
  12.     private  Handler handler;  
  13.     // 該線程所處理的Socket所對應的輸入流  
  14.     private  BufferedReader br =  null ;  
  15.   
  16.     public  ClientThread(Socket socket, Handler handler)  throws  IOException {  
  17.         this .handler = handler;  
  18.         br =  new  BufferedReader( new  InputStreamReader(socket.getInputStream()));  
  19.     }  
  20.   
  21.     @Override  
  22.     public  void  run() {  
  23.         try  {  
  24.             String content =  null ;  
  25.             // 不斷讀取Socket輸入流的內容  
  26.             while  ((content = br.readLine()) !=  null ) {  
  27.                 // 每當讀到來自服務器的數據之後,發送消息通知程序界面顯示該數據  
  28.                 Message msg =  new  Message();  
  29.                 msg.what =  0x234 ;  
  30.                 msg.obj = content;  
  31.                 handler.sendMessage(msg);  
  32.             }  
  33.         }  catch  (Exception e) {  
  34.             e.printStackTrace();  
  35.         }  
  36.     }  
  37.   
  38. }  
Activity的佈局XML:
  1. LinearLayout  xmlns:android "http://schemas.android.com/apk/res/android"  
  2.     android:layout_width "match_parent"  
  3.     android:layout_height "match_parent"  
  4.     android:orientation "vertical"  >  
  5.   
  6.     LinearLayout  
  7.         android:layout_width "match_parent"  
  8.         android:layout_height "wrap_content"  
  9.         android:orientation "horizontal"  >  
  10.   
  11.         EditText  
  12.             android:id "@+id/main_et_input"  
  13.             android:layout_width "240dp"  
  14.             android:layout_height "wrap_content"  />  
  15.   
  16.         Button  
  17.             android:id "@+id/main_btn_send"  
  18.             android:layout_width "match_parent"  
  19.             android:layout_height "wrap_content"  
  20.             android:paddingLeft "10dp"  
  21.             android:text "發送"  />  
  22.     </ LinearLayout >  
  23.   
  24.     EditText  
  25.         android:id "@+id/main_et_show"  
  26.         android:layout_width "match_parent"  
  27.         android:layout_height "match_parent"  
  28.         android:cursorVisible "false"  
  29.         android:editable "false"  
  30.         android:gravity "top"  />  
  31.   
  32. </ LinearLayout >  
權限:
  1. uses-permission  android:name "android.permission.INTERNET" />  


沒有留言:

張貼留言