android 客户端与服务端通讯

android终端之间实现服务器与客户端socket通讯。出个demo：

服务器端：

创建服务器端，等待连接。

new Thread(new Runnable() {
   @Override
   public void run() {
    try {
              server = new ServerSocket(PORT);
              mExecutorService = Executors.newCachedThreadPool();  //create a thread pool
              text_view.setText("服务器启动中...");
              System.out.println("服务器启动中...");
              Socket client = null;
              while(true) {
                  client = server.accept();
                  mList.add(client);
                  mExecutorService.execute(new Service(client)); //start a new thread to handle the connection
              }
          }catch (Exception e) {
              e.printStackTrace();
          }
   }
  }).start();
 

不能放到ui主线程。

 

检测是否有客户端连接上来：
 class Service implements Runnable {
        private Socket socket;
        private BufferedReader in = null;
        private String msg = "";
       
        public Service(Socket socket) {
            this.socket = socket;
            try {
                in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                msg = "与IP：" + this.socket.getInetAddress() + " 建立连接，当前连接数:"
                    + mList.size();
                this.sendmsg();
            } catch (IOException e) {
                e.printStackTrace();
            }
           
        }

        @Override
        public void run() {
            // TODO Auto-generated method stub
            try {
                while(true) {
                    if((msg = in.readLine())!= null) {
                        if(msg.equals("exit")) {
                            //System.out.println("ssssssss");
                            mList.remove(socket);
                            in.close();
                            msg = "与IP：" + socket.getInetAddress()
                                + " 断开连接，当前连接数:" + mList.size();
                            socket.close();
                            this.sendmsg();
                            break;
                        } else {
                           // msg = socket.getInetAddress() + ":" + msg;
                         System.out.print("收到客户端的信息： ");
                            this.sendmsg();
                        }
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
     

 

给所有客户端发消息
       public void sendmsg() {
           System.out.println(msg);
           int num =mList.size();
           for (int index = 0; index < num; index ++) {
               Socket mSocket = mList.get(index);
               PrintWriter pout = null;
               try {
                   pout = new PrintWriter(new BufferedWriter(
                           new OutputStreamWriter(mSocket.getOutputStream())),true);
                   pout.println(msg);
               }catch (IOException e) {
                   e.printStackTrace();
               }
           }
       }
    }  

 

客户端：

创建线程

public class ClientThread implements Runnable
{
 protected static final String TAG = "ClientThread";
 private Socket s;
 // 定义向UI线程发送消息的Handler对象
 private Handler handler;
 // 定义接收UI线程的消息的Handler对象
 public Handler revHandler;
 // 该线程所处理的Socket所对应的输入流
 BufferedReader br = null;
 OutputStream os = null;
 // 创建一个处理来读取服务器响应的数据
 RecvMsgHandlerThread recvMsgHandlerThread;

 public ClientThread(Handler handler)
 {
  this.handler = handler;
 }

 public void run()
 {
  try
  {
   s = new Socket("192.168.1.11", 8080);
   br = new BufferedReader(new InputStreamReader(
    s.getInputStream()));
   os = s.getOutputStream();
   
   // 启动一条子线程来读取服务器响应的数据
   recvMsgHandlerThread = new RecvMsgHandlerThread();
   new Thread(recvMsgHandlerThread).start();
   
   // 为当前线程初始化Looper
   Looper.prepare();
    
   // 创建revHandler
   revHandler = new Handler()
   {
    @Override
    public void handleMessage(Message msg)
    {
     // 接收到UI线程中用户输入的数据
     if (msg.what == 0x345)
     {
      // 将用户在文本框内输入的内容写入网络
      try
      {
       Log.i(TAG, "============" + msg.obj.toString());
       os.write((msg.obj.toString() + "\r\n")
        .getBytes("utf-8"));
      }
      catch (Exception e)
      {
       e.printStackTrace();
      }
     }
    }
   };
   // 启动Looper
   Looper.loop();
  }
  catch (SocketTimeoutException e1)
  {
   System.out.println("网络连接超时！！");
  }
  catch (Exception e)
  {
   e.printStackTrace();
  }
 }
 
 //从Socket获取数据并给UI发消息的线程
 class RecvMsgHandlerThread implements Runnable
 {
   @Override
   public void run()
   {
    String content = null;
    // 不断读取Socket输入流中的内容
    try
    {
     while ((content = br.readLine()) != null)
     {
      // 每当读到来自服务器的数据之后，发送消息通知程序界面显示该数据
      Message msg = new Message();
      msg.what = 0x123;
      msg.obj = content;
      handler.sendMessage(msg);
     }
    }
    catch (IOException e)
    {
     e.printStackTrace();
    }
   }
 }
}

 

主UI启动线程

Handler handler = new Handler();
  ClientThread clientThread = new ClientThread(handler );
  // 客户端启动ClientThread线程创建网络连接、读取来自服务器的数据
  new Thread(clientThread).start();

给线程发送消息：

/*
  *
  * 将用户的数据封装成Message，然后发送给子线程clientThread的Handler
  */
 
 public void sendMsgToClientThread(String str) {
  try
  {
   Message msg = new Message();
   msg.what = 0x345;   
   msg.obj = str;
   clientThread.revHandler.sendMessage(msg);
  }
  catch (Exception e)
  {
   e.printStackTrace();
  }
 }