一叠萍、一臺(tái)手機(jī)向另外一臺(tái)手機(jī)發(fā)送消息，類似QQ

參考
Android socket 編程 實(shí)現(xiàn)消息推送（一）
Android socket 編程 實(shí)現(xiàn)消息推送（二）

手機(jī)1

手機(jī)2

實(shí)現(xiàn)過程主要分為Server端和Client端巧颈，Server端采用Java的編程肪笋，而Client端則用Android編程俊性。所以在這里也分別創(chuàng)建了兩個(gè)工程SocketServer和SocketClient蓖谢。

1.SocketServer

SocketServer

SocketMessage.java:

public class SocketMessage {
    public int to;//socketID乳规，指發(fā)送給誰
    public int from;//socketID锤岸，指誰發(fā)送過來的
    public String msg;//消息內(nèi)容
    public String time;//接收時(shí)間
    public SocketThread thread;//socketThread下面有介紹
}

MyServer.java:

package com.jimstin.server;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;

import org.json.JSONObject;


import com.jimstin.msg.SocketMessage;

public class MyServer {

    private boolean isStartServer;
    private ServerSocket mServer;
    /**
     * 消息隊(duì)列集漾，用于保存SocketServer接收來自于客戶機(jī)（手機(jī)端）的消息
     */
    private ArrayList<SocketMessage> mMsgList = new ArrayList<SocketMessage>();
    /**
     * 線程隊(duì)列，用于接收消息锉罐。每個(gè)客戶機(jī)擁有一個(gè)線程，每個(gè)線程只接收發(fā)送給自己的消息
     */
    private ArrayList<SocketThread> mThreadList = new ArrayList<SocketThread>();
    
    /**
     * 開啟SocketServer
     */
    private void startSocket() {
        try {
            isStartServer = true;
            int prot = 2000;//端口可以自己設(shè)置绕娘，但要和Client端的端口保持一致
            mServer = new ServerSocket(prot);//創(chuàng)建一個(gè)ServerSocket
            System.out.println("啟動(dòng)server,端口："+prot);
            Socket socket = null;
            int socketID = 0;//Android（SocketClient）客戶機(jī)的唯一標(biāo)志脓规，每個(gè)socketID表示一個(gè)Android客戶機(jī)
            //開啟發(fā)送消息線程
            startSendMessageThread();
            //用一個(gè)循環(huán)來檢測(cè)是否有新的客戶機(jī)加入
            while(isStartServer) {
                //accept()方法是一個(gè)阻塞的方法，調(diào)用該方法后险领，
                //該線程會(huì)一直阻塞侨舆，直到有新的客戶機(jī)加入，代碼才會(huì)繼續(xù)往下走
                socket = mServer.accept();
                //有新的客戶機(jī)加入后绢陌，則創(chuàng)建一個(gè)新的SocketThread線程對(duì)象
                SocketThread thread = new SocketThread(socket, socketID++);
                thread.start();
                //將該線程添加到線程隊(duì)列
                mThreadList.add(thread);
            }
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    /**
     * 開啟推送消息線程挨下，如果mMsgList中有SocketMessage，則把該消息推送到Android客戶機(jī)
     */
    public void startSendMessageThread() {
        new Thread(){
            @Override
            public void run() {
                super.run();
                try {
                    /*如果isStartServer=true脐湾，則說明SocketServer已啟動(dòng)臭笆，
                    用一個(gè)循環(huán)來檢測(cè)消息隊(duì)列中是否有消息，如果有秤掌，則推送消息到相應(yīng)的客戶機(jī)*/
                    while(isStartServer) {
                        //判斷消息隊(duì)列中的長(zhǎng)度是否大于0愁铺，大于0則說明消息隊(duì)列不為空
                        if(mMsgList.size() > 0) {
                            //讀取消息隊(duì)列中的第一個(gè)消息
                            SocketMessage from = mMsgList.get(0);
                            for(SocketThread to : mThreadList) {
                                if(to.socketID == from.to) {
                                    BufferedWriter writer = to.writer;
                                    JSONObject json = new JSONObject();
                                    json.put("from", from.from);
                                    json.put("msg", from.msg);
                                    json.put("time", from.time);
                                    //writer寫進(jìn)json中的字符串?dāng)?shù)據(jù)，末尾記得加換行符："\n"闻鉴，否則在客戶機(jī)端無法識(shí)別
                                    //因?yàn)锽ufferedReader.readLine()方法是根據(jù)換行符來讀取一行的
                                    writer.write(json.toString()+"\n");
                                    //調(diào)用flush()方法茵乱，刷新流緩沖，把消息推送到手機(jī)端
                                    writer.flush();
                                    System.out.println("推送消息成功："+from.msg+">> to socketID:"+from.to);
                                    break;
                                }
                            }
                            //每推送一條消息之后孟岛，就要在消息隊(duì)列中移除該消息
                            mMsgList.remove(0);
                        }
                        Thread.sleep(200);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }.start();
    }
    
    /**
     * 定義一個(gè)SocketThread類瓶竭，用于接收消息
     *
     */
    public class SocketThread extends Thread {
        
        public int socketID;
        public Socket socket;//Socket用于獲取輸入流、輸出流
        public BufferedWriter writer;//BufferedWriter 用于推送消息
        public BufferedReader reader;//BufferedReader 用于接收消息
        
        public SocketThread(Socket socket, int count) {
            socketID = count;
            this.socket = socket;
            System.out.println("新增一臺(tái)客戶機(jī)渠羞，socketID："+socketID);
        }
        
        @Override
        public void run() {
            super.run();

            try {
                //初始化BufferedReader
                reader = new BufferedReader(new InputStreamReader(socket.getInputStream(), "utf-8"));
                //初始化BufferedWriter
                writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream(), "utf-8"));
                //如果isStartServer=true斤贰，則說明SocketServer已經(jīng)啟動(dòng)，
                //現(xiàn)在需要用一個(gè)循環(huán)來不斷接收來自客戶機(jī)的消息次询，并作其他處理
                while(isStartServer) {
                    //先判斷reader是否已經(jīng)準(zhǔn)備好
                    if(reader.ready()) {
                        /*讀取一行字符串腋舌，讀取的內(nèi)容來自于客戶機(jī)
                        reader.readLine()方法是一個(gè)阻塞方法，
                        從調(diào)用這個(gè)方法開始渗蟹，該線程會(huì)一直處于阻塞狀態(tài)块饺，
                        直到接收到新的消息，代碼才會(huì)往下走*/
                        String data = reader.readLine();
                        //講data作為json對(duì)象的內(nèi)容雌芽，創(chuàng)建一個(gè)json對(duì)象
                        JSONObject json = new JSONObject(data);
                        //創(chuàng)建一個(gè)SocketMessage對(duì)象授艰，用于接收json中的數(shù)據(jù)
                        SocketMessage msg = new SocketMessage();
                        msg.to = json.getInt("to");
                        msg.msg = json.getString("msg");
                        msg.from = socketID;
                        msg.time = getTime(System.currentTimeMillis());
                        //接收到一條消息后，將該消息添加到消息隊(duì)列mMsgList
                        mMsgList.add(msg);
                        System.out.println("收到一條消息："+json.getString("msg")+" >>>> to socketID:"+json.getInt("to"));
                    }
                    //睡眠100ms世落，每100ms檢測(cè)一次是否有接收到消息
                    Thread.sleep(100);
                }
                
            } catch (Exception e) {
                e.printStackTrace();
            }  
            
        }
    }
    /**
     * 獲取指定格式的時(shí)間字符串淮腾，通過毫秒轉(zhuǎn)換日期
     * @param millTime
     */
    private String getTime(long millTime) {
        Date d = new Date(millTime);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        return sdf.format(d);
    }
    public static void main(String[] args) {
        MyServer server = new MyServer();
        server.startSocket();
    }

}

2.SocketClient工程

SocketClient

package com.jimstin.socketclient;

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 java.text.SimpleDateFormat;
import java.util.Date;

import org.json.JSONObject;

import com.tencent.stat.MtaSDkException;
import com.tencent.stat.StatConfig;
import com.tencent.stat.StatService;

import android.R.integer;
import android.os.AsyncTask;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.EditText;
import android.widget.TextView;
import android.widget.Toast;
import android.app.Activity;

public class MainActivity extends Activity implements OnClickListener {

    private EditText mIPEdt, mPortEdt, mSocketIDEdt, mMessageEdt;
    private static TextView mConsoleTxt;
    
    private static StringBuffer mConsoleStr = new StringBuffer();
    private Socket mSocket;
    private boolean isStartRecieveMsg;
    
    private SocketHandler mHandler;
    protected BufferedReader mReader;//BufferedWriter 用于推送消息
    protected BufferedWriter mWriter;//BufferedReader 用于接收消息
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        initView();
    }

    private void initView() {
        mIPEdt = (EditText) findViewById(R.id.ip_edt);
        mPortEdt = (EditText) findViewById(R.id.port_edt);
        mSocketIDEdt = (EditText) findViewById(R.id.socket_id_edt);
        mMessageEdt = (EditText) findViewById(R.id.msg_edt);
        mConsoleTxt = (TextView) findViewById(R.id.console_txt);
        findViewById(R.id.start_btn).setOnClickListener(this);
        findViewById(R.id.send_btn).setOnClickListener(this);
        findViewById(R.id.clear_btn).setOnClickListener(this);
        mHandler = new SocketHandler();
    }

    /**
     * 初始化socket
     */
    private void initSocket() {
        //新建一個(gè)線程，用于初始化socket和檢測(cè)是否有接收到新的消息
        Thread thread = new Thread(new Runnable() {
            
            @Override
            public void run() {
                String ip = mIPEdt.getText().toString();//IP
                int port = Integer.parseInt(mPortEdt.getText().toString());//Socket
                
                try {
                    isStartRecieveMsg = true;
                    mSocket = new Socket(ip, port);
                    mReader = new BufferedReader(new InputStreamReader(mSocket.getInputStream(), "utf-8"));
                    mWriter = new BufferedWriter(new OutputStreamWriter(mSocket.getOutputStream(), "utf-8"));
                    while(isStartRecieveMsg) {
                        if(mReader.ready()) {
                            /*讀取一行字符串，讀取的內(nèi)容來自于客戶機(jī)
                            reader.readLine()方法是一個(gè)阻塞方法谷朝，
                            從調(diào)用這個(gè)方法開始洲押，該線程會(huì)一直處于阻塞狀態(tài)，
                            直到接收到新的消息圆凰，代碼才會(huì)往下走*/
                            String data = mReader.readLine();
                            //handler發(fā)送消息杈帐，在handleMessage()方法中接收
                            mHandler.obtainMessage(0, data).sendToTarget();
                        }
                        Thread.sleep(200);
                    }
                    mWriter.close();
                    mReader.close();
                    mSocket.close();
                } catch (Exception e) {
                    e.printStackTrace();
                } 
            }
        });
        thread.start();
    }
    
    @Override
    public void onClick(View v) {
        switch (v.getId()) {
        case R.id.send_btn:
            send();
            break;
        case R.id.clear_btn:
            mConsoleStr.delete(0, mConsoleStr.length());
            mConsoleTxt.setText(mConsoleStr.toString());
            break;
        case R.id.start_btn:
            if(!isStartRecieveMsg) {
                initSocket();
            }
            break;
        default:
            break;
        }
    }

    /**
     * 發(fā)送
     */
    private void send() {
        new AsyncTask<String, Integer, String>() {

            @Override
            protected String doInBackground(String... params) {
                sendMsg();
                return null;
            }
        }.execute();
    }
    /**
     * 發(fā)送消息
     */
    protected void sendMsg() {
        try {
            String socketID = mSocketIDEdt.getText().toString().trim();
            String msg = mMessageEdt.getText().toString().trim();
            JSONObject json = new JSONObject();
            json.put("to", socketID);
            json.put("msg", msg);
            mWriter.write(json.toString()+"\n");
            mWriter.flush();
            mConsoleStr.append("我:" +msg+"   "+getTime(System.currentTimeMillis())+"\n");
            mConsoleTxt.setText(mConsoleStr);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    static class SocketHandler extends Handler {
        
        @Override
        public void handleMessage(Message msg) {
            // TODO Auto-generated method stub
            super.handleMessage(msg);
            switch (msg.what) {
            case 0:
                try {
                    //將handler中發(fā)送過來的消息創(chuàng)建json對(duì)象
                    JSONObject json = new JSONObject((String)msg.obj);
                    mConsoleStr.append(json.getString("from")+":" +json.getString("msg")
                    +"   "+getTime(System.currentTimeMillis())+"\n");
                    //將json數(shù)據(jù)顯示在TextView中
                    mConsoleTxt.setText(mConsoleStr);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                
                break;

            default:
                break;
            }
        }
    }
    
    @Override
    public void onBackPressed() {
        super.onBackPressed();
        isStartRecieveMsg = false;
    }
    
    private static String getTime(long millTime) {
        Date d = new Date(millTime);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        return sdf.format(d);
    }
    
}