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

}