android：Socket编程 模拟骂街

　　所谓"骂街"，就两个人"A","B"对骂，A骂B的过程是这样的： A发出信息---B接收信息--B处理信息（理解A骂的话，想着怎么回应A）--B发送

信息（反骂）--A接收信息--A处理信息（理解B骂的话，想着怎么回应B）。循环这个过程。

　　客户端：

package com.example.csserver;

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.util.Timer;
import java.util.TimerTask;

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;

import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;

public class MainActivity extends Activity {

    public EditText et_client;
    private EditText et_ip;
    private EditText et_port;
    public EditText et_service;
    public Button bt_send;
    private Button bt_stop;
    public String clientText;
    private String host=null ;
    private int port=0 ;
    private BufferedReader br;
    private BufferedWriter bw;
    Timer timer=null;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        et_ip=(EditText)findViewById(R.id.et_ip);
        et_port=(EditText)findViewById(R.id.et_port);
        bt_stop=(Button)findViewById(R.id.bt_stop);
        et_client = (EditText) findViewById(R.id.et_client);
        et_service = (EditText) findViewById(R.id.et_service);
        bt_send = (Button) findViewById(R.id.bt_send);
        
        bt_send.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View v) {
                host=et_ip.getText().toString().trim();
                port=Integer.parseInt(et_port.getText().toString().trim());
                clientText = et_client.getText().toString();
                sendTimer();

            }
        });
        bt_stop.setOnClickListener(new OnClickListener() {
            
            @Override
            public void onClick(View v) {
                
                     if (task != null) {
                         task.cancel();
                         task = null;
                     }
                     if (timer != null) {
                         timer.cancel();
                         timer.purge();
                         timer = null;
                     }

                
            }
        });
        
    }
    
    /**
     * 接收服务器返回的数据
     * @param receiveSocket
     * @return
     * @throws IOException
     */
    private String receiveData(Socket receiveSocket) throws IOException {
         br = new BufferedReader(new InputStreamReader(
                receiveSocket.getInputStream()));
        String receiveStr = br.readLine();
        br.close();
        return receiveStr;

    }
    /**
     * 向服务器发送数据
     * @param sendSocket
     * @param sendText
     */
    private void transData(Socket sendSocket, String sendText) {
        try {
             bw = new BufferedWriter(new OutputStreamWriter(
                    sendSocket.getOutputStream()));
            bw.write(sendText.replace("\n", " ") + "\n");
            bw.flush();
        
        } catch (IOException e) {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        }
    }
    /**
     * 创建客户端Socket
     * @param host
     * @param port
     * @return
     * @throws IOException
     * @throws IOException
     */
    private Socket requestSocket(String host, int port) throws IOException,
            IOException {
        Socket socket = new Socket(host, port);
        return socket;
    }
    /**    
     * 关闭Socket
     * 注意:"流可以关 但要等到服务器验证完毕后再关  尤其是你的输出流 "
     * @param socket
     * @throws IOException
     */
    private void closeSocket(Socket socket) throws IOException{
        br.close();
        bw.close();
        socket.close();
        
    }
    Handler timerHandler = new Handler() {
        public void handleMessage(Message msg) {
            Bundle bd = msg.getData();
            if (msg.what == 1) {

                et_service.setText(bd.getString("data"));

            }
            super.handleMessage(msg);
        }
    };

    TimerTask task = new TimerTask() {

        public void run() {
            Message message = new Message();
            message.what = 1;
            try {
                Socket socket = requestSocket(host, port);
                transData(socket, clientText);
                String showText = receiveData(socket);
                closeSocket(socket);
                Bundle bundle = new Bundle();
                bundle.putString("data", showText);
                message.setData(bundle);
                timerHandler.sendMessage(message);
            } catch (IOException e) {
                // TODO 自动生成的 catch 块
                e.printStackTrace();
            }

        }
    };
    
    private void sendTimer() {
        timer=new Timer();
        timer.schedule(task, 1000, 400);
    }
}

 

　　服务端：

package com.test;

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 Test extends Thread {
    private  int i=0;

private Test() throws IOException {
   CreateSocket();
   //创建Socket服务器
} 

public void run() { 
   Socket client;
   String txt;
   try { 
    while (true)
    //线程无限循环，实时监听socket端口
    {
     client=ResponseSocket();       
     //响应客户端链接请求。。
    
     while(true)
     {
      txt=ReceiveMsg(client);  
      System.out.println(txt);
      //链接获得客户端发来消息，并将其显示在Server端的屏幕上
   
      SendMsg(client,txt);
      //向客户端返回消息

      if(true)break;
      //中断，继续等待链接请求
     }
    
     CloseSocket(client);
     //关闭此次链接
    }   
   } 
   catch (IOException e) {
    System.out.println(e);
   }

}

private ServerSocket server = null;
private static final int PORT = 2000;
private BufferedWriter writer;
private BufferedReader reader;

private void CreateSocket() throws IOException
{
   server = new ServerSocket(PORT, 100);
   System.out.println("Server starting..");  
}

private Socket ResponseSocket() throws IOException
{
   Socket client = server.accept(); 
   System.out.println("client connected..");
  
   return client;
}

private void CloseSocket(Socket socket) throws IOException
{
   reader.close();
   writer.close();
   socket.close();
   System.out.println("client closed..");
}

private void SendMsg(Socket socket,String Msg) throws IOException 
{
   writer = new BufferedWriter(
      new OutputStreamWriter(socket.getOutputStream()));
   i++;
    writer.write(Msg+i+"\n");
    writer.flush();
   
}

private String ReceiveMsg(Socket socket) throws IOException
{
   reader = new BufferedReader(
     new InputStreamReader(socket.getInputStream()));     
    System.out.println("server get input from client socket..");
    String txt="client send:"+reader.readLine();
   
    return txt;
}

public static void main(final String args[]) throws IOException {
    Test yaochatserver = new Test();
   if (yaochatserver != null) {
    yaochatserver.start();
   }
}

}

　　布局文件：

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent" >

    <EditText
        android:id="@+id/et_service"
        android:layout_width="fill_parent"
        android:layout_height="50dp"
        android:layout_alignParentBottom="true"
        android:layout_alignParentLeft="true"
        android:layout_marginTop="109dp"
        android:text="准备接受信息" />

    <Button
        android:id="@+id/bt_stop"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignParentLeft="true"
        android:layout_centerVertical="true"
        android:text="停止发送" />

    <Button
        android:id="@+id/bt_send"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignBaseline="@+id/bt_stop"
        android:layout_alignBottom="@+id/bt_stop"
        android:layout_alignParentRight="true"
        android:text="发送信息" />

    <TextView
        android:id="@+id/textView1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignParentLeft="true"
        android:layout_alignParentTop="true"
        android:text="配置服务器地址："
        android:textSize="23dp" />

    <EditText
        android:id="@+id/et_ip"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignParentRight="true"
        android:layout_alignParentTop="true"
        android:text="192.168.0.196" >

        
    </EditText>

    <EditText
        android:id="@+id/et_client"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:layout_above="@+id/bt_stop"
        android:layout_alignParentLeft="true"
        android:layout_marginBottom="46dp"
        android:hint="请输入发送的内容" />

    <TextView
        android:id="@+id/textView1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignParentLeft="true"
        android:layout_below="@+id/et_ip"
        android:text="配置服务器端口："
        android:textSize="23dp" />

    <EditText
        android:id="@+id/et_port"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignLeft="@+id/bt_send"
        android:layout_alignTop="@+id/textView1"
        android:text="2000" />

</RelativeLayout>

　　

　　最开始编写时我遇到了一个稀奇古怪的问题，我的客户端在模拟器上时一切正常；当在真实的android客户端上时，服务器能收到客户端发送的信息，而客户端接收不到服务器返回的信息，我以为是防火墙或者局域网搞的怪，但跟为奇怪的是在调试模式下客户端还能收的服务器放回的信息，后来我更改了客户端发送和接收的处理流程问题得到了解决