android的SOCKET网络编程

Socket又称套接字，应用程序通常通过“套接字”向网络发出请

 求或者应答网络请求

 在JAVA中，Socket和ServerSocket类库位于java.net中。

 ServerSocket用于服务器端，Socket是建立网络时使用的。在连

 接成功时，应用程序两端都会产生一个Socket实例，操作这个实

 例，完成所需的会话。对于一个网络连接来说，
 套接字是平等的

 ，并没有差别，不因为在服务器端或在客户端而产生不同级别。

 不管是Socket还是ServerSocket他们的工作都是通过Socket类及

 其子类来完成的




 Socket链接的建立过程

 1.服务器监听

 2.客户端发出请求

 3.建立链接

 4.通信





 Socket特点

 1.Socket基于TCP链接，数据传输有保障

 2.Socket适用于建立长时间链接

 3.Socket编程通常应用于即时通讯






 服务器端ServerSocket

 package com.enenya.serversocket;

 import java.io.IOException;
 import java.io.OutputStream;
 import java.net.ServerSocket;
 import java.net.Socket;

 public class SimpleSocket {
     public static void main(String[] str) {
         try {
             //创建一个ServerSocket，并且给定

 侦听端口，
             ServerSocket serverSocket = new 

 ServerSocket(30000);
             while (true) {
                 //accept()方法会阻塞线程
                 Socket socket = 

 serverSocket.accept();
                 //
                 OutputStream outputStream 

 = socket.getOutputStream();
                 outputStream.write("你好

 ！Socket已接受到。".getBytes());
                 outputStream.close();
                 socket.close(); 
             }
         } catch (IOException e) {
             e.printStackTrace();
         }
     }
 }

















 服务器端编程

 1. 新建一个线程类负责循环接收socket请求
 package com.enenya.serversocket;

 import java.io.IOException;
 import java.net.ServerSocket;
 import java.net.Socket;

 //创建一个类继承Socket，并且是接受socket请求
 public class ServerListener extends Thread {
     public void run() { 
         try {
             // 创建一个ServerSocket，并且给定

 侦听端口，端口是1-65535
             ServerSocket serverSocket = new 

 ServerSocket(30001);
             // 因为客户端会有很多个请求，所以

 需要创建多一个Socket实例
             while (true) {
                 // accept()方法会阻塞线程
                 Socket socket = 

 serverSocket.accept();
                 new ChatSocket

 (socket).start(); 
                 //serverSocket.close();
             }
         } catch (IOException e) {
             e.printStackTrace();
         }  
     }
 }



 2.新建一个线程类，负责写出信息
 package com.enenya.serversocket;

 import java.io.IOException;
 import java.io.OutputStream;
 import java.net.Socket;

 //创建一个线程类，负责发送数据到客户端
 public class ChatSocket extends Thread {
     Socket socket;

     public ChatSocket(Socket s) {
         this.socket = s;
     }

     public void run() {
         try {
             OutputStream outputStream = 

 socket.getOutputStream();
             outputStream.write("你好！Socket

 已接受到。".getBytes());
             outputStream.close();
             socket.close();
         } catch (IOException e) {
             e.printStackTrace();
         }

     }
 }



 3.调用
 package com.enenya.serversocket;


 public class SimpleSocket {
     public static void main(String[] str) {
         new ServerListener().start();
     } 
 }





















 完整的Socket网络编程
 多用户输入，响应，并且同步的聊天室

 1.新建一个类继承Thread，负责接收客户端发送的请求
 package com.enenya.serversocket;

 import java.io.IOException;
 import java.net.ServerSocket;
 import java.net.Socket;

 //创建一个类继承Socket，并且是接受socket请求
 public class ServerListener extends Thread {
     public void run() { 
         try {
             // 创建一个ServerSocket，并且给定

 侦听端口，端口是1-65535
             ServerSocket serverSocket = new 

 ServerSocket(30002);
             // 因为客户端会有很多个请求，所以

 需要创建多一个Socket实例
             while (true) {
                 // accept()方法会阻塞线程
                 Socket socket = 

 serverSocket.accept();
                 ChatSocket chatSocket = 

 new ChatSocket(socket); 
                 chatSocket.start();
                 

 ChatThreadManager.getChatManager().add(chatSocket);
                 
             }
         } catch (IOException e) {
             e.printStackTrace();
         }  
     }
 }



 2.新建一个类继承Thread，负责发送消息
 package com.enenya.serversocket;

 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.io.OutputStream;
 import java.io.UnsupportedEncodingException;
 import java.net.Socket;

 //创建一个线程类，负责发送数据到客户端
 public class ChatSocket extends Thread {
     Socket socket;

     public ChatSocket(Socket s) {
         this.socket = s;
     }

     public void out(String str) {
         try {
             OutputStream outputStream = 

 socket.getOutputStream();
             outputStream.write(("你好！Socket

 已接受到。是:" + str).getBytes());
             outputStream.close();
             socket.close();
         } catch (IOException e) {
             e.printStackTrace();
         }
     }

     @Override
     public void run() {
         try {
             BufferedReader bReader = new 

 BufferedReader(new InputStreamReader(
                     

 socket.getInputStream(), "UTF-8"));
             String line = null;
             while ((line = bReader.readLine

 ()) != null) {
                 

 ChatThreadManager.getChatManager().publish(this, line);
             }
             bReader.close();
         } catch (UnsupportedEncodingException e) 

 {
             // TODO Auto-generated catch 

 block
             e.printStackTrace();
         } catch (IOException e) {
             // TODO Auto-generated catch 

 block
             e.printStackTrace();
         } 
     }
 }



 3.新建一个类，负责将输入消息加入队列，并且循环发送出去
   package com.enenya.serversocket;

 import java.util.Vector;

 //负责将客户端发送过来的数据在线程间通信
 public class ChatThreadManager {
     // 表示该类不能被实例化
     private ChatThreadManager() {
     }

     // 该类必须是单例模式
     private static final ChatThreadManager CTM = new 

 ChatThreadManager();

     public static ChatThreadManager getChatManager() 

 {
         return CTM;
     }

     
     //线程安全的集合
     Vector<ChatSocket> vector = new 

 Vector<ChatSocket>();
     
     public void add(ChatSocket cs) {
         vector.add(cs);
     }

     public void publish(ChatSocket cs, String out) {
         for (int i = 0; i < vector.size(); i++) {
             ChatSocket csChatSocket = 

 vector.get(i);
             //如果当前socket对象不是要发送的

 对象，就发送数据
             if(!cs.equals(csChatSocket)){
                 csChatSocket.out(out);     
             }
         }
     }

 }



 4.服务器端启动
 package com.enenya.serversocket;


 public class SimpleSocket {
     public static void main(String[] str) {
         new ServerListener().start();
     } 
 }
  




 5.android客户端发送消息到服务器
 package com.example.android_clientsocket;

 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.net.Socket;
 import java.net.UnknownHostException;

 import android.os.Bundle;
 import android.app.Activity; 
 import android.widget.TextView;

  public class MainActivity extends Activity {
     private TextView textView;

     @Override
     protected void onCreate(Bundle 

 savedInstanceState) {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.activity_main);
         textView = (TextView) this.findViewById

 (R.id.textview1);
         
         new Thread(runnable).start();
     }

     private Runnable runnable = new Runnable() {
         @Override
         public void run() {
             try {
                 Socket socket = new 

 Socket("172.28.232.1", 30002);
                 socket.setSoTimeout

 (10000);
                 BufferedReader 

 brBufferedReader = new BufferedReader(
                         new 

 InputStreamReader(socket.getInputStream()));
                 String string = 

 brBufferedReader.readLine();
                 textView.setText(string);
                 brBufferedReader.close();
                 socket.close();
                 
             } catch (UnknownHostException e) 

 {
                 e.printStackTrace();
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }
     };

 }


 或者


 在activity方法，点击某个按钮发送的消息

 Socket socket = null;
 BufferdWriter writer = null;
 BufferdReader reader = null;
 public void connect(){
   try{
       socket = new Socket("127.0.0.1",30002);
         writer = new BufferdWriter(new 

 OutputStreamWriter(socket.getOutputStream()));
         reader = new BufferedReader(new 

 InputStreamReader(socket.getInputStream()));
     
     AsynTask<Void,String,Void> read = new 

 AsynTask<Void,String,Void>(){
     
     @Override
         protected void doInBackground(Void... arg0){
         String line = "";
         while((line = reader.readLine()) != null){
          publishProgress(line);
         }
     }

         };
     read.execute();
   }catch(UnknownHostException e){
      Toast.make(this,"无法建立链接！",1).show();
   }catch(IOException e){
     Toast.make(this,"无法建立链接！",1).show();
   }
   

 }

    public void send(){
     try{
         write.write(editText.getText().toString

 ());    
     editText.setText("");
        }catch(Exception e){}
    }