Socket即时通讯

客户端代码：

package com.example.multithreadclient;

import android.app.Activity;
import android.app.AlertDialog;
import android.content.DialogInterface;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;

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

/**
 * Android Tcp即时通讯客户端
 */
public class MainCSActivity extends Activity implements Runnable{
    private TextView tv_msg = null;
    private EditText ed_msg = null;
    private Button btn_send = null;
    private String msg=null;
    private static final String HOST = "192.168.11.83";//服务器地址
    private static final int PORT = 7776;//连接端口号
    private Socket socket = null;
    private BufferedReader in = null;
    private PrintWriter out = null;
    private AlertDialog.Builder mBuilder=null;

    //接收线程发送过来信息，并用TextView追加显示
    public Handler mHandler = new Handler() {
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            tv_msg.append((CharSequence) msg.obj);
        }
    };

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_maincs);

        tv_msg = (TextView) findViewById(R.id.txt_1);
        ed_msg = (EditText) findViewById(R.id.et_talk);
        btn_send = (Button) findViewById(R.id.btn_send);


        btn_send.setOnClickListener(new Button.OnClickListener() {

            @Override
            public void onClick(View v) {
                msg = ed_msg.getText().toString();
                if (socket.isConnected()) {//如果服务器连接
                    if (!socket.isOutputShutdown()) {//如果输出流没有断开
                        new Thread(new Runnable() {
                            @Override
                            public void run() {
                                out.println(msg);//点击按钮发送消息
                            }
                        }).start();
                        ed_msg.setText("");//清空编辑框
                    }
                }
            }
        });
        //启动线程，连接服务器，并用死循环守候，接收服务器发送过来的数据
        new Thread(this).start();
    }

    /**
     * 连接服务器
     */
    private void connection() {
        try {
            socket = new Socket(HOST, PORT);//连接服务器
            in = new BufferedReader(new InputStreamReader(socket
                    .getInputStream()));//接收消息的流对象
            out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(
                    socket.getOutputStream())), true);//发送消息的流对象
        } catch (IOException ex) {
            ex.printStackTrace();
            //ShowDialog("连接服务器失败：" + ex.getMessage());
        }
    }

    /**
     * 如果连接出现异常，弹出AlertDialog！
     */
    public void ShowDialog(String msg) {
        mBuilder=new AlertDialog.Builder(this).setTitle("通知").setMessage(msg)
                .setPositiveButton("ok", new DialogInterface.OnClickListener() {

                    @Override
                    public void onClick(DialogInterface dialog, int which) {

                    }
                });
        if(mBuilder !=null) {
            mBuilder.show();
        }
    }

    /**
     * 读取服务器发来的信息，并通过Handler发给UI线程
     */
    public void run() {
        connection();// 连接到服务器
        try {
            while (true) {//死循环守护，监控服务器发来的消息
                if (!socket.isClosed()) {//如果服务器没有关闭
                    if (socket.isConnected()) {//连接正常
                        if (!socket.isInputShutdown()) {//如果输入流没有断开
                            String getLine;
                            if ((getLine = in.readLine()) != null) {//读取接收的信息
                                getLine += "\n";
                                Message message=new Message();
                                message.obj=getLine;
                                mHandler.sendMessage(message);//通知UI更新
                            } else {

                            }
                        }
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    protected void onDestroy(){
        super.onDestroy();
        mBuilder=null;
    }
}

服务端代码：

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * Tcp通信服务器
 * @author Devin Chen
 *
 */
public  class   CSServer{
    private static final int PORT = 7776;
    private List<Socket> mClientList = new ArrayList<Socket>();
    private ServerSocket server = null;
    private ExecutorService mExecutors = null; // 线程池对象

    public static void main(String[] args) {
        new CSServer();
    }

    /**
     * 构造方法：任务是启动服务器，等待客户端连接
     */
    public CSServer() {
        try {
            server = new ServerSocket(PORT);
            mExecutors = Executors.newCachedThreadPool(); // 创建线程池
            System.out.println("服务器已启动，等待客户端连接...");
            Socket client = null;
            /*
             * 用死循环等待多个客户端的连接，连接一个就启动一个线程进行管理
             */
            while (true) {
                client = server.accept();
                // 把客户端放入集合中
                mClientList.add(client);
                mExecutors.execute(new Service(client)); // 启动一个线程，用以守候从客户端发来的消息
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    class Service implements Runnable {
        private Socket socket;
        private BufferedReader in = null;
        private String message = "";

        public Service(Socket socket) {
            this.socket = socket;
            try {
                in = new BufferedReader(new InputStreamReader(
                        socket.getInputStream()));// 获得输入流对象
                // 客户端只要一连到服务器，便发送连接成功的信息
                message = "服务器地址：" + this.socket.getInetAddress();
                this.sendMessage(message);
                message = "当前连接总数:" + mClientList.size();
                this.sendMessage(message);
            } catch (IOException e) {
                e.printStackTrace();
            }

        }

        @Override
        public void run() {
            try {
                while (true) {
                    if ((message = in.readLine()) != null) {
                        // 当客户端发送的信息为：exit时，关闭连接
                        if (message.equals("exit")) {
                            closeSocket();
                            break;
                        } else {
                            // 接收客户端发过来的信息message，然后转发给客户端。
                            message = socket.getInetAddress() + ":" + message;
                            this.sendMessage(message);
                        }
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        /**
         * 关闭客户端
         *
         * @throws IOException
         */
        public void closeSocket() throws IOException {
            mClientList.remove(socket);
            in.close();
            message = "主机:" + socket.getInetAddress() + "关闭连接\n目前在线:"
                    + mClientList.size();
            socket.close();
            this.sendMessage(message);
        }

        /**
         * 将接收的消息转发给每一个客户端
         *
         * @param msg
         */

        public void sendMessage(String msg) {
            System.out.println(msg);// 先在控制台输出
            int count = mClientList.size();
            // 遍历客户端集合
            for (int i = 0; i < count; i++) {
                Socket mSocket = mClientList.get(i);
                PrintWriter out = null;
                try {
                    out = new PrintWriter(new BufferedWriter(
                            new OutputStreamWriter(mSocket.getOutputStream())),
                            true);// 创建输出流对象
                    out.println(msg);// 转发
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

添加权限：

<uses-permission android:name="android.permission.INTERNET"/>