Socket通信：实现PC端和Android端之间的相互通信（通过网络）

实现PC端和android端之间的通信（从android端发送一条信息到PC端，PC端可以接受，并可以把这条信息返回到android端并且显示出来。）

注意点：

1、  在写android代码的时间一定要有处理4.0以后的线程问题，可以使用StrictMode进行解决。

2、  由于程序里面需要Socket进行网络通信，所有程序里面只需要一个Socket，切不可使用多个Socket，既Socket的new对象只需要一个就好了。

3、  记得要在android中添加访问网络的权限

4、  为了加快网络通信的实时性，在发送时间最好采用writer.write(Msg.replace("\n", " ") +"\n");的格式，这样可以极快的进行网络通信

5、  在android端中没有流和socket的关闭，在PC使用的是ServerSocket；android端使用的是Socket

程序流程：

源码：

android端：

package is.my.fansendmsgtopc;


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


import android.os.Bundle;
import android.os.StrictMode;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
import android.app.Activity;


public class MainActivity extends Activity implements OnClickListener {


private TextView ShowText; // 用于显示从PC端返回来的数据
private EditText SendMsg; // 记录要发送的内容
private Button SendButton; // 发送按键
private String Msg; // 消息的储存
private String Ip = "192.168.1.139"; // 定义目标Ip，用于发送指定方向
private int Prop = 1818; // 定义串口号，用于网络通信
private Socket socket; // 定义socket，以后后面使用
private BufferedWriter writer; // 定义writer流用于文字的写入


@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
DispleThradQuestion();
initialise();
}


/**
* 定义一个StrictMode用来消除线程问题
*/
private void DispleThradQuestion() {
StrictMode.setThreadPolicy(new StrictMode.ThreadPolicy.Builder()
.detectDiskReads().detectDiskWrites().detectNetwork()
.penaltyLog().build());
StrictMode.setVmPolicy(new StrictMode.VmPolicy.Builder()
.detectLeakedSqlLiteObjects().detectLeakedClosableObjects()
.penaltyLog().penaltyDeath().build());
}


/**
* 组件的初始化和定义
*/
private void initialise() {
ShowText = (TextView) findViewById(R.id.textView1);
SendMsg = (EditText) findViewById(R.id.editText1);
SendButton = (Button) findViewById(R.id.button1);


SendButton.setOnClickListener(this);
}


@Override
public void onClick(View v) {
// TODO Auto-generated method stub
try {
Msg = SendMsg.getText().toString();
socket = CreateSocket();
SendMsgToPC(socket);
System.out.println("接受之前" + Ip + "   " + Prop);
String str = AcceptMsg(socket);
System.out.println("接受之后");
this.ShowText.setText(str);
} catch (UnknownHostException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}


/**
* 定义SendMsgToPC类，用于发送消息
* 
* @throws IOException
* @throws UnknownHostException
*/
private void SendMsgToPC(Socket socket) throws UnknownHostException,
IOException {
writer = new BufferedWriter(new OutputStreamWriter(
socket.getOutputStream()));
// 可以加快数据的传输replace
// 方法的结果是一个完成了指定替换的 stringObj 对象的复制。
writer.write(Msg.replace("\n", " ") + "\n");
writer.flush();
}


/**
* 定义一个Socket，以后以后使用
* 
* @throws IOException
* @throws UnknownHostException
*/
private Socket CreateSocket() throws UnknownHostException, IOException {
Socket socket = new Socket(Ip, Prop);
return socket;
}


/**
* 接受消息
* 
* @throws IOException
*/
private String AcceptMsg(Socket socket) throws IOException {
System.out.println("准备接受");
BufferedReader reader = new BufferedReader(new InputStreamReader(
socket.getInputStream()));
System.out.println("进行读取");
String str = reader.readLine();
if (str.length() == 0) {
System.out.println("读取结束:" + str.length());
} else {
System.out.println("读取结束:" + str);
}
return str;
}
}

PC端：

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;


public class AcceptFromAndroid extends Thread {


String msg = null; // 用于暂时储存消息
int prop = 1818; // 定义一个端口号，用于网络的通信
ServerSocket serverSocket = null; // 定义一个serverSocket，用于串口的通信
BufferedReader reader; // 定义一个读的流
BufferedWriter writer; // 定义一个写的流


/**
* 主程序
* 
* @param args
*/
public static void main(String[] args) {
AcceptFromAndroid android = new AcceptFromAndroid();
if (android != null) {
android.start();
}
}


public AcceptFromAndroid() {
try {
serverSocket = new ServerSocket(prop, 100);
} catch (IOException e) {
e.printStackTrace();
}
}


@Override
public void run() {
Socket socket; // 定义一个Socket用于接收发送过来的消息
try {
// 特此注意serverSocket一定要在while的外邊


while (true) {
System.out.println("等待数据的发送.......");
socket = serverSocket.accept();
while (true) {
reader = new BufferedReader(new InputStreamReader(
socket.getInputStream()));
msg = reader.readLine();
System.out.println("发送过来的数据是： " + msg);
SendMsgToA(socket, msg);
System.out.println("数据返回：" + msg);
if (true)
break;
}
CloseIOAndSocket(socket);
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
System.out.println("数据已经接收");
}
}


/**
* 发送消息
*/
private void SendMsgToA(Socket socket, String Msg) {
try {
writer = new BufferedWriter(new OutputStreamWriter(
socket.getOutputStream()));
writer.write(Msg + "\n");
writer.flush();
} catch (IOException e) {
e.printStackTrace();
}
}


/**
* 关闭流和Socket
*/
private void CloseIOAndSocket(Socket socket) {
try {
reader.close();
writer.close();
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}


}