Java Socket 编程——多线程网络聊天程序

Java Socket 编程——多线程网络聊天程序
首先，进行服务端的编程，作为服务端，编程主要按下面几个步骤进行：

    // 1. 创建socket
    ServerSocket ss = new ServerSocket(PortNumber);
    Socket s = ss.accept(); //监听器，产生阻塞，直到有连接才停止阻塞。

    // 2. 打开输入流、输出流
    OutputStream os = s.getOutputStream();
    BufferedOutputStream bos = new BufferedOutputStream(os);
    InputStream is = s.getInputStream();

    // 3. 根据一定的协议读写数据
    // 服务器 --> 客户
    //os.write("Hello,I am Server!".getBytes());
    bos.write("Hello,I am Server!".getBytes());
    bos.flush(); //注意!!

    // 服务器 <-- 客户
    byte[] buf = new byte[100];
    int len = is.read(buf);
    System.out.println(new String(buf, 0, len));

    // 4. 关系流和Socket
    //os.close();
    bos.close();
    is.close();
    s.close();
    ss.close();

    作为客户端则分为下面几个步骤，其实和服务端差不多，只是少了用ServerSocket进行监听。

    // 1. 创建socket
    Socket s = new Socket(InetAddress.getByName("localhost"),
            PortNumber);
    // 2. 打开输入流、输出流
    OutputStream os = s.getOutputStream();
    InputStream is = s.getInputStream();

    // 3. 根据一定的协议读写数据
    // 服务器 --> 客户
    byte[] buf = new byte[100];
    int len = is.read(buf);
    System.out.println(new String(buf, 0, len));
    // 服务器 <-- 客户
    os.write("Hello,I am Client!".getBytes());

    // 4. 关系流和Socket
    os.close();
    is.close();
    s.close();

    上面这些只是一个单线程的服务端->客户端的程序，只能进行一次通讯，多次通讯将被告知无法连接。

    这时，我们就需要用到进程Thread进行编程，将其改造成多线程聊天程序，可以同时进行多客户端的连接与发送信息。

    代码如下：


  1    //Server.java
  2
  3    import java.awt.*;
  4    import java.net.*;
  5    import java.io.*;
  6
  7    public class Server extends Thread {
  8        ServerSocket skt;
  9
10        Socket Client[]=new Socket[10];;
11        Socket Client1=null;
12
13        int i = 0;
14
15        TextArea in;
16
17        int port,k=0,l=0;
18
19        //BufferedReader theInputStream;
20
21        PrintStream theOutputStream;
22
23        //String readin;
24
25        Face chat;
26
27        public Server(int port, Face chat) {
28            try {
29                this.port = port;
30                skt = new ServerSocket(port);
31                this.chat = chat;
32            } catch (IOException e) {
33                chat.ta.append(e.toString());
34            }
35        }
36
37        public void run() {
38
39            chat.ta.append("等待连线");
40
41            while (true) {
42                //System.out.print(""+i+"\n");
43                try {
44
45
46                Client[k] = skt.accept(); /**//* 接收客户连接 */
47
48                //当有客户端连接时就新建一个子线程
49
50
51                if (i < 2) {
52                    ServerThread server[] = new ServerThread[10];
53                     server[k]= new ServerThread(Client[k], this.chat, i);
54                     l=server.length;
55                     server[k].start();
56                    chat.ta.append("客户端" + Client[k].getInetAddress() + "已连线\n");
57                    /**//*theInputStream = new BufferedReader(new InputStreamReader(Client
58                            .getInputStream()));*/
59                    //for(int j=0;j<server.length;j++)
60                    theOutputStream = new PrintStream(server[k].getClient().getOutputStream());
61                    i = server[k].getI();
62                    k++;
63                } else {
64                    //theOutputStream = new PrintStream(null);
65                }
66
67            } catch (SocketException e) {
68                //chat.ta.append("连线中断！\n");
69
70                //chat.clientBtn.setEnabled(true);
71                //chat.serverBtn.setEnabled(true);
72                //chat.tfaddress.setEnabled(true);
73                //chat.tfport.setEnabled(true);
74                //try {
75
76                        //skt.close();
77                        //Client.close();
78                    //} catch (IOException err) {
79                    //    chat.ta.append(err.toString());
80                    //}
81                } catch (IOException e) {
82                    chat.ta.append(e.toString());
83                }
84            }
85
86        }
87
88        public void dataout(String data) {
89            //for(int j=0;j<l;j++)
90            theOutputStream.println(data);
91        }
92    }
93
94    class ServerThread extends Thread {
95        ServerSocket skt;
96
97        Socket Client;
98
99        TextArea in;
100
101        int port;
102
103        int i;
104
105        BufferedReader theInputStream;
106
107        PrintStream theOutputStream;
108
109        String readin;
110
111        Face chat;
112
113//服务端子线程
114
115        public ServerThread(Socket s, Face chat, int i) {
116            this.i = ++i;
117            Client = s;
118            //this.port = port;
119            //skt = new ServerSocket(port);
120            this.chat = chat;
121
122        }
123
124        public int getI() {
125            return this.i;
126        }
127        public Socket getClient() {
128            return this.Client;
129        }
130        public void run() {
131
132            //chat.ta.append("等待连线");
133
134            try {
135                //Client = skt.accept(); /* 接收客户连接 */
136
137                //chat.ta.append("客户端" + Client.getInetAddress() + "已连线\n");
138                theInputStream = new BufferedReader(new InputStreamReader(Client
139                        .getInputStream()));
140                theOutputStream = new PrintStream(Client.getOutputStream());
141
142                while (true) {
143                    readin = theInputStream.readLine();
144                    chat.ta.append(readin + "\n");
145                }
146
147            } catch (SocketException e) {
148                chat.ta.append("连线中断！\n");
149
150                chat.clientBtn.setEnabled(true);
151                chat.serverBtn.setEnabled(true);
152                chat.tfaddress.setEnabled(true);
153                chat.tfport.setEnabled(true);
154                try {
155                    i--;
156                    skt.close();
157                    Client.close();
158                } catch (IOException err) {
159                    chat.ta.append(err.toString());
160                }
161            } catch (IOException e) {
162                chat.ta.append(e.toString());
163            }
164        }
165
166        public void dataout(String data) {
167            theOutputStream.println(data);
168        }
169    }
170
171    //Client.java
172
173    import java.net.*;
174    import java.io.*;
175    import javax.swing.Timer;
176    class Client extends Thread {
177        Socket skt;
178        InetAddress host;
179        int port;
180
181        BufferedReader theInputStream;
182        PrintStream theOutputStream;
183        String readin;
184
185        Face chat;
186
187        public Client(String ip, int p, Face chat) {
188            try {
189                host = InetAddress.getByName(ip);
190                port = p;
191                this.chat = chat;
192            } catch (IOException e) {
193                chat.ta.append(e.toString());
194            }
195        }
196
197        public void run() {
198            try {
199                chat.ta.append("尝试连线");
200
201                skt = new Socket(host, port);
202                chat.ta.append("连线成功\n");
203
204                theInputStream = new BufferedReader(new InputStreamReader(skt
205                        .getInputStream()));
206
207                theOutputStream = new PrintStream(skt.getOutputStream());
208                //Timer myTimer = new Timer();
209                while (true) {
210                    readin = theInputStream.readLine();
211                    chat.ta.append(readin + "\n");
212                }
213            } catch (SocketException e) {
214                chat.ta.append("连线中断！\n");
215                chat.clientBtn.setEnabled(true);
216                chat.serverBtn.setEnabled(true);
217                chat.tfaddress.setEnabled(true);
218                chat.tfport.setEnabled(true);
219                try {
220                    skt.close();
221                } catch (IOException err) {
222                    chat.ta.append(err.toString());
223                }
224            } catch (IOException e) {
225                chat.ta.append(e.toString());
226            }
227        }
228
229        public void dataout(String data) {
230            theOutputStream.println(data);
231        }
232    }
233
234//软件界面，进行按键监听调用。
235    //face.java
236
237    import java.awt.*;
238    import java.awt.event.*;
239
240    public class Face extends Frame {
241        /** *//**
242         *
243         */
244        private static final long serialVersionUID = 1L;
245        Button clientBtn, serverBtn;
246        TextArea ta;
247        TextField tfaddress, tfport, tftype;
248        int port;
249        Client client;
250        Server server;
251        boolean iamserver;
252        static Face frm;
253
254        public Face() {
255            clientBtn = new Button("客户端");
256            serverBtn = new Button("服务器");
257            ta = new TextArea("", 10, 50, TextArea.SCROLLBARS_BOTH);
258            tfaddress = new TextField("192.168.1.104", 20);
259            tfport = new TextField("2000");
260            tftype = new TextField(50);
261
262            tftype.addKeyListener(new TFListener());
263            ta.setEditable(false);
264
265            setLayout(new FlowLayout());
266            add(tfaddress);
267            add(tfport);
268            add(clientBtn);
269            add(serverBtn);
270            add(ta);
271            add(tftype);
272            setSize(400, 300);
273            setTitle("我的聊天室");
274            this.setVisible(true);
275
276            clientBtn.addActionListener(new ActionListener() {
277                public void actionPerformed(ActionEvent e) {
278
279                    port = Integer.parseInt(tfport.getText());
280
281                    client = new Client(tfaddress.getText(), port, frm);
282
283                    client.start();
284
285                    tfaddress.setEnabled(false);
286                    tfport.setEnabled(false);
287                    serverBtn.setEnabled(false);
288                    clientBtn.setEnabled(false);
289                }
290            });
291
292            serverBtn.addActionListener(new ActionListener() {
293                public void actionPerformed(ActionEvent e) {
294
295                    port = Integer.parseInt(tfport.getText());
296
297                    server = new Server(port, frm);
298
299                    server.start();
300
301                    iamserver = true;
302                    tfaddress.setText("成为服务器");
303
304                    tfaddress.setEnabled(false);
305                    tfport.setEnabled(false);
306                    serverBtn.setEnabled(false);
307                    clientBtn.setEnabled(false);
308                }
309            });
310
311            addWindowListener(new WindowAdapter() {
312                public void windowClosing(WindowEvent e) {
313                    System.exit(0);
314                }
315            });
316
317        }
318
319        public static void main(String args[]) {
320            frm = new Face();
321        }
322
323        private class TFListener implements KeyListener {
324            public void keyPressed(KeyEvent e) {
325
326                if (e.getKeyCode() == KeyEvent.VK_ENTER) {
327
328                    ta.append(">" + tftype.getText() + "\n");
329
330                    if (iamserver)
331                        server.dataout(tftype.getText());
332                    else
333                        client.dataout(tftype.getText());
334
335                    tftype.setText("");
336                }
337            }
338
339            public void keyTyped(KeyEvent e) {
340            }
341
342            public void keyReleased(KeyEvent e) {
343            }
344        }
345


    }