public class SocketActivity extends ListActivity implements Client.MsgListener {
    public static final int PORT = 11232;
    public static final String HOST = "192.168.1.187"; //此 IP 为内网 IP ，所有只有在同一局域网下才能通讯(连接同一WIFI即可)

    private TextView msgTextView;
    private EditText editText;

    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        String[] array = {"开启服务器",
            "开启客户端",
            "客户端发消息",
            "客户端下线"};
        setListAdapter(new ArrayAdapter<>(this, android.R.layout.simple_list_item_1, Arrays.asList(array)));

        editText = new EditText(this);
        getListView().addFooterView(editText);

        msgTextView = new TextView(this);
        getListView().addFooterView(msgTextView);
    }

    @Override
    protected void onListItemClick(ListView l, View v, int position, long id) {
        switch (position) {
            case 0:
                Server.SINGLETON.startServer(PORT);
                break;
            case 1:
                Client.SINGLETON.startClient(HOST, PORT);
                Client.SINGLETON.setListener(this);
                break;
            case 2:
                Client.SINGLETON.sendMsg(editText.getText().toString());
                break;
            case 3:
                Client.SINGLETON.exit();
                break;
            default:
                break;
        }
    }

    private SpannableString getSpannableString(String string, int color) {
        SpannableString mSpannableString = new SpannableString(string);
        ForegroundColorSpan colorSpan = new ForegroundColorSpan(color);
        mSpannableString.setSpan(colorSpan, 0, mSpannableString.length(), Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
        return mSpannableString;
    }

    @Override
    public void onReveiveMsg(String message) {
        runOnUiThread(() -> msgTextView.append(getSpannableString(message + "\n", Color.BLUE)));
    }

    @Override
    public void onSendMsg(String message) {
        runOnUiThread(() -> {
            String text = Client.SINGLETON.getName() + " : " + editText.getText().toString() + "\n";
            msgTextView.append(getSpannableString(text, Color.RED));
        });
    }
}

public enum Server {
    SINGLETON;

    public static final int MAX_TEXT_SIZE = 1024;
    public static final String CLIENT_EXIT_CMD = "拜拜";
    public static final String CHARSET = "GBK";

    private Set<Socket> socketSet;
    private boolean serverExit = false;
    private ServerSocket server;//服务器对象

    Server() {
        socketSet = new HashSet<>();//用户集合
    }

    public void startServer(int port) {
        if (server != null && !server.isClosed()) {
            System.out.println("服务器已开启，不需要重复开启");
        } else {
            new Thread(() -> {
                try {
                    server = new ServerSocket(port);
                } catch (IOException e) {
                    e.printStackTrace();
                    System.out.println("服务器启动失败");
                    return;
                }

                System.out.println("服务器启动成功");
                //循环监听
                while (!serverExit) {
                    try {
                        Socket socket = server.accept();//获取连接过来的客户端对象。阻塞方法
                        socketSet.add(socket);
                        sendUserMsg(socket, getName(socket) + " 上线了, 当前 " + socketSet.size() + " 人在线");
                        listenerUserMsg(socket); //监听客户端发送的消息，并转发给其他用户
                    } catch (IOException e) {//用户下线
                        e.printStackTrace();
                    }
                }
                System.out.println("服务器已关闭");
            }).start();
        }
    }

    private void listenerUserMsg(Socket socket) {
        new Thread(() -> {
            try {
                byte[] bytes = new byte[MAX_TEXT_SIZE];
                int count;
                boolean clinetExit = false;
                while (!serverExit && !clinetExit && !socket.isClosed() && (count = socket.getInputStream().read(bytes)) != -1) {
                    String text = new String(bytes, 0, count, CHARSET);
                    System.out.println("服务器已收到【" + getName(socket) + "】发送的信息【" + text + "】");
                    clinetExit = CLIENT_EXIT_CMD.equals(text);
                    sendUserMsg(socket, getName(socket) + " : " + text);
                }
            } catch (IOException e) {//关闭与此用户相关的流
                e.printStackTrace();
                System.out.println(getName(socket) + " 异常掉线");
            } finally {
                if (socket != null) {
                    try {
                        socket.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    socketSet.remove(socket);
                    sendUserMsg(socket, getName(socket) + " 下线了, 当前 " + socketSet.size() + " 人在线");
                }
            }
        }).start();
    }

    private void sendUserMsg(Socket socket, String text) {
        for (Socket otherSocket : socketSet) {//遍历所有的在线用户
            if (otherSocket != null && !otherSocket.isClosed() && !otherSocket.equals(socket)) {
                try {
                    OutputStream outputStream = otherSocket.getOutputStream();//获取相应的输出流，把信息发送过去
                    outputStream.write(text.getBytes(CHARSET));
                    outputStream.flush();
                    System.out.println("服务器已转发信息【" + text + "】给【" + getName(otherSocket) + "】");
                } catch (IOException e) {
                    e.printStackTrace();
                    System.out.println(getName(socket) + " 异常");
                }
            }
        }
    }

    private String getName(Socket socket) {
        return "用户" + socket.getInetAddress().getHostAddress() + "_" + socket.getPort();
    }
}

public enum Client {

    SINGLETON;

    Client() {
    }

    public static final int MAX_TEXT_SIZE = 1024;
    public static final String CLIENT_EXIT_CMD = "拜拜";
    public static final String CHARSET = "GBK";

    private boolean exit = false;
    private Socket socket;

    private MsgListener listener;

    public void startClient(String host, int port) {
        if (socket != null && !socket.isClosed()) {
            System.out.println("客户端已开启，不需要重复开启");
        } else {
            new Thread(() -> {
                try {
                    socket = new Socket(host, port);//创建客户端对象
                    listenerUserMsg(); //监听消息
                    System.out.println("客户端已开启成功");
                } catch (IOException e) {
                    e.printStackTrace();
                    System.out.println("客户端已开启失败");
                }
            }).start();
        }
    }

    private void listenerUserMsg() {
        new Thread(() -> {
            try {
                byte[] bytes = new byte[MAX_TEXT_SIZE];
                int count;
                while (!exit && socket != null && !socket.isClosed() && (count = socket.getInputStream().read(bytes)) != -1) {
                    String text = new String(bytes, 0, count, CHARSET);
                    System.out.println(getName() + " 收到信息【" + text + "】");
                    if (listener != null) {
                        listener.onReveiveMsg(text);
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }).start();
    }

    public void sendMsg(String text) {
        new Thread(() -> {
            if (socket != null && !socket.isClosed()) {
                try {
                    socket.getOutputStream().write(text.getBytes(CHARSET));//获取socket流中的输出流将指定的数据写出去
                    if (listener != null) {
                        listener.onSendMsg(text);
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }

    public void exit() {
        new Thread(() -> {
            exit = true;
            if (socket != null && !socket.isClosed()) {
                try {
                    socket.getOutputStream().write(CLIENT_EXIT_CMD.getBytes(CHARSET));
                    socket.close();
                    System.out.println("客户端下线成功");
                } catch (IOException e) {
                    e.printStackTrace();
                    System.out.println("客户端下线异常");
                }
            } else {
                System.out.println("客户端已下线，不需要重复下线");
            }
        }).start();
    }

    public String getName() {
        return "用户" + socket.getInetAddress().getHostAddress() + "_" + socket.getPort();
    }

    public void setListener(MsgListener listener) {
        this.listener = listener;
    }

    public interface MsgListener {
        void onReveiveMsg(String message);

        void onSendMsg(String message);
    }
}