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){}
   }