搞了个1.0版本，名字和预定的一样改成OIFaQ了

　　服务器没启动的情况下直接启动客户端会报错，测试的时候无所谓，发布的时候一定要注意，下个版本修正。

　　得给服务器写个GUI，测试的时候有命令行，发布之后就不对劲了，要关闭还得用任务管理器。

　　客户端的独立线程在关闭框架的时候会报错，目前直接catch掉了，感觉不够优雅，之后修正。

　　服务器端倒是好像没什么bug了。

　　上边这句话说完我自己都不信。

　　先把exe和jar发了。

　　这小图标画得我自己都陶醉了。

import java.io.*;
import java.net.*;
import java.util.ArrayList;

/**
 * 服务器端。
 * 基本功能已经完成。
 * 实现了对每个客户端启动一个线程，阻塞式地从每个客户端接收消息，接收到之后向所有客户端发送。
 * 越级升到V1.0。
 * 
 * @author mlxy
 * @version 1.0
 * */
public class SimChatServer {
    ServerSocket ss = null;
    ArrayList<Client> clients = null;
    
    /** 服务器构造方法，只用来初始化已连接客户端数。*/
    public SimChatServer() {clients = new ArrayList<Client>();}
    
    /** 主方法。*/
    public static void main(String[] args) {
        SimChatServer server = new SimChatServer();
        server.startUp();
    }
    
    /** 启动服务器。*/
    public void startUp() {
        // 尝试启动服务器，端口被占用则提示并退出。
        try {
            ss = new ServerSocket(2333);
        } catch (BindException e) {
            System.out.println("Port occupied.");
            System.exit(0);
        } catch (IOException ex) {
            ex.printStackTrace();
        }

        // 死循环，等待客户端连接，连接成功则启动一个新线程。
        try {
            while (true) {
                Client newClient = new Client(ss.accept());
                newClient.start();
                clients.add(newClient);
                System.out.println("Current clients: " + clients.size());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    /**
     * 内部类。
     * 单个客户端线程，包含了处理客户端发来信息的功能，以及向客户端发送信息的方法。
     * 
     * @author mlxy
     * @version 1.0
     */
    private class Client extends Thread {
        Socket singleSocket;
        ObjectInputStream singleInput;
        ObjectOutputStream singleOutput;
        
        /** 一个客户端线程的构造方法。*/
        public Client(Socket singleSocket) {
            this.singleSocket = singleSocket;
            System.out.println("Client connected.");
            try {
                singleInput = new ObjectInputStream(singleSocket.getInputStream());
                singleOutput = new ObjectOutputStream(singleSocket.getOutputStream());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void run() {
            // 主运行部分，抓到客户端退出的异常就打印提示并退出。
            try {
                // 死循环，读包拆包打印。
                while (true) {
                    String[] packReceived = (String[]) singleInput.readObject();
                    System.out.println("[" + packReceived[0] + "]: " + packReceived[1]);
                    for (int i = 0; i < clients.size(); i++) {
                        clients.get(i).sendPackage(packReceived);
                    }
                }
                
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (EOFException ex) {
                System.out.println("Client disconnected.");
            } catch (IOException exc) {
                exc.printStackTrace();
            } finally {
                // 进程准备结束，释放相关资源。
                try {
                    if (singleSocket != null)
                        singleSocket.close();
                    if (singleInput != null)
                        singleInput.close();
                    if (singleOutput != null)
                        singleOutput.close();
                    
                    // 报告当前客户端退出。
                    clientOut();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        
        /** 向客户端发包的方法。*/
        public void sendPackage(Object o) {
            try {
                singleOutput.writeObject(o);
                singleOutput.flush();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        
        /** 管理客户端退出的方法。*/
        private void clientOut() {
            // 找出当前客户端所在下标并标记删除。不能一边遍历一边修改列表哇，同志。
            int indexToRemove = -1;
            for (int i = 0; i < clients.size(); i++) {
                if (clients.get(i).equals(this)) {
                    indexToRemove = i;
                    break;
                }
            }
            clients.remove(indexToRemove);
            System.out.println("Current clients: " + clients.size());
        }
    }
}

import java.awt.*;
import java.awt.event.*;

import javax.swing.*;

import java.io.*;
import java.net.*;

/**
 * 客户端程序。
 * 基本上实现了向服务器发包与从服务器收包的功能，已经达成基本需要，更新到V1.0。
 * ServerWaiter类还不完善，具体请参考注释。
 * 
 * @author mlxy
 * @version 1.0
 * */
public class SimChatClient extends JFrame {
    private static final long serialVersionUID = 1685352502599359548L;
    
    // 框架相关变量。
    private JPanel panel;
    private JTextArea area;
    private JTextField field;
    
    // 用户相关变量。
    private String userID;
    private StringBuffer chatRecord = new StringBuffer("");

    // 网络相关变量。
    //private String serverIP; *备用*
    //private int serverPort; *备用*
    private Socket socket = null;
    private ObjectOutputStream oos = null;
    private ObjectInputStream ois = null;

    /** 默认构造方法，初始化用户ID及框架内容。 */
    public SimChatClient() {
        String userName = (String) JOptionPane.showInputDialog(
                null, "请输入用户ID：", "新用户", JOptionPane.PLAIN_MESSAGE,
                null, null, new String("Default"));
        if (userName == null)
            System.exit(0);
        else
            userID = userName;

        panel = new JPanel();
        panel.setLayout(new BorderLayout());

        area = new JTextArea();
        area.setLineWrap(true);
        area.setWrapStyleWord(true);
        area.setEditable(false);
        area.setBackground(new Color(255, 204, 255));
        JScrollPane scrollPane = new JScrollPane(area);

        field = new JTextField();
        field.setBackground(new Color(66, 204, 255));
        field.addActionListener(new FieldListener());

        panel.add(scrollPane, BorderLayout.CENTER);
        panel.add(field, BorderLayout.SOUTH);

        this.add(panel);
        this.addWindowListener(new WindowAdapter() {

            @Override
            public void windowClosing(WindowEvent e) {
                disconnect();
                System.exit(0);
            }

            @Override
            public void windowActivated(WindowEvent e) {
                super.windowActivated(e);
                field.requestFocusInWindow();
            }
        });
    }

    /** 主运行方法。 */
    public static void main(String[] args) {
        try {
            UIManager.setLookAndFeel("com.sun.java.swing.plaf.nimbus.NimbusLookAndFeel");
        } catch (UnsupportedLookAndFeelException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        SimChatClient frame = new SimChatClient();
        frame.launchFrame();
        new Thread(frame.new ServerWaiter()).start();
    }

    /** 框架参数初始化。 */
    public void launchFrame() {
        setTitle("Simple Chat Online: " + userID);
        setSize(400, 500);
        setLocationRelativeTo(null);
        setVisible(true);

        connect();
    }

    /** 连接到服务器端。 */
    private void connect() {
        try {
            socket = new Socket("192.168.1.104", 2333);
            oos = new ObjectOutputStream(socket.getOutputStream());
        } catch (IOException e) {
            e.printStackTrace();
        }
        area.setText("Connection established.");
    }

    /** 释放资源，与服务器断开连接。 */
    private void disconnect() {
        try {
            ois.close();
            oos.close();
            System.exit(0);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    /** 
     * 按照格式更新文本框内容。
     * 
     * @param userName 用户名
     * @param content 消息内容
     */
    private void updateTextArea(String userName, String content) {
        // 之后加上发送时间。
        chatRecord.append("[ " + userName + " ] : " + content + "
");
        area.setText(chatRecord.toString());
    }

    /** 内部类，输入框的监听器。 */
    private class FieldListener implements ActionListener {

        @Override
        public void actionPerformed(ActionEvent e) {
            // 按下回车后向服务器发包，然后清空输入框。
            sendPackage();
            field.setText("");
        }

        /** 私有方法，读取用户ID和输入内容，向服务器发送包。 */
        private void sendPackage() {
            String[] packToSend = { userID, field.getText() };

            try {
                oos.writeObject(packToSend);
                oos.flush();
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
    }

    /** 内部类，等待服务器发包的线程类。
     * 
     * @author mlxy
     * @version 0.8
     * */
    class ServerWaiter implements Runnable {
        public void run() {
            try {
                ois = new ObjectInputStream(socket.getInputStream());

                // 死循环，阻塞式地从服务器读包，之后更新文本框。
                while (true) {
                    // 程序被readObject阻塞住的时候如果关闭框架会报错。之后解决。
                    String[] packReceived = (String[]) ois.readObject();
                    updateTextArea(packReceived[0], packReceived[1]);
                }
            } catch (SocketException e) {
                // 目前是简单粗暴地抓了异常就跳出程序。
                System.out.println("Socket closed, client out.");
                System.exit(-1);
            } catch (IOException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    }
}