黑马程序员技术交流社区

标题: 聊天系统客户端和服务端中Socket和阻塞式方法的问题 [打印本页]
作者: 刘学明　　　    时间: 2013-4-21 00:02
标题: 聊天系统客户端和服务端中Socket和阻塞式方法的问题
本帖最后由 刘学明　　　 于 2013-4-21 00:19 编辑

一个客户端程序  一个服务端程序  
基本功能实现了 当开启多个客户端窗口进行聊天   先关闭其中的一个客户端  用其他客户端进行发送消息时
会报出  Socket close 的错误 请问如何完善程序才可以
服务端程序代码：

  2. import java.io.*;
  3. import java.net.*;
  4. import java.util.*;

  6. public class ChatServer {
  7.         boolean started = false;
  8.         ServerSocket ss = null;
  9.         
  10.         List<Client> clients = new ArrayList<Client>();
  11.         
  12.         public static void main(String[] args) {
  13.                 new ChatServer().start();
  14.         }
  15.         
  16.         public void start() {
  17.                 try {
  18.                         ss = new ServerSocket(8888);
  19.                         started = true;
  20.                 } catch (BindException e) {
  21.                         System.out.println("端口使用中....");
  22.                         System.out.println("请关掉相关程序并重新运行服务器！");
  23.                         System.exit(0);
  24.                 } catch (IOException e) {
  25.                         e.printStackTrace();
  26.                 }
  27.                
  28.                 try {
  29.                         
  30.                         while(started) {
  31.                                 Socket s = ss.accept();
  32.                                 Client c = new Client(s);
  33.                                 System.out.println("a client connected!");
  34.                                 new Thread(c).start();
  35.                                 clients.add(c);
  36.                         }
  37.                 } catch (IOException e) {
  38.                         e.printStackTrace();
  39.                 } finally {
  40.                         try {
  41.                                 ss.close();
  42.                         } catch (IOException e) {
  43.                                 e.printStackTrace();
  44.                         }
  45.                 }
  46.         }
  47.         
  48.         class Client implements Runnable {
  49.                 private Socket s;
  50.                 private DataInputStream dis = null;
  51.                 private DataOutputStream dos = null;
  52.                 private boolean bConnected = false;
  53.                
  54.                 public Client(Socket s) {
  55.                         this.s = s;
  56.                         try {
  57.                                 dis = new DataInputStream(s.getInputStream());
  58.                                 dos = new DataOutputStream(s.getOutputStream());
  59.                                 bConnected = true;
  60.                         } catch (IOException e) {
  61.                                 e.printStackTrace();
  62.                         }
  63.                 }
  64.                
  65.                 public void send(String str) {
  66.                         try {
  67.                                 dos.writeUTF(str);
  68.                         } catch (IOException e) {
  69.                                 e.printStackTrace();
  70.                         }
  71.                 }
  72.                
  73.                 public void run() {
  74.                         try {
  75.                                 while(bConnected) {
  76.                                         String str = dis.readUTF();
  77.                                         System.out.println(str);
  78.                                         for(int i=0; i<clients.size(); i++) {
  79.                                                 Client c = clients.get(i);
  80.                                                 c.send(str);
  81.                                         }
  82.                                 }
  83.                         } catch (EOFException e) {
  84.                                 System.out.println("Client closed!");
  85.                         } catch (IOException e) {
  86.                                 e.printStackTrace();
  87.                         } finally {
  88.                                 try {
  89.                                         if(dis != null) dis.close();
  90.                                         if(dos != null) dos.close();
  91.                                         if(s != null)  {
  92.                                                 s.close();
  93.                                         }
  94.                                 } catch (IOException e1) {
  95.                                         e1.printStackTrace();
  96.                                 }
  97.                         }
  98.                 }
  99.         }
  100. }

复制代码
客户端程序代码：
  1. import java.awt.*;
  2. import java.awt.event.*;
  3. import java.io.*;
  4. import java.net.*;

  6. public class ChatClient extends Frame {
  7.         Socket s = null;
  8.         DataOutputStream dos = null;
  9.         DataInputStream dis = null;
  10.         private boolean bConnected = false;

  12.         TextField tfTxt = new TextField();

  14.         TextArea taContent = new TextArea();
  15.         
  16.         Thread tRecv = new Thread(new RecvThread());

  18.         public static void main(String[] args) {
  19.                 new ChatClient().launchFrame();
  20.         }

  22.         public void launchFrame() {
  23.                 setLocation(400, 300);
  24.                 this.setSize(300, 300);
  25.                 add(tfTxt, BorderLayout.SOUTH);
  26.                 add(taContent, BorderLayout.NORTH);
  27.                 pack();
  28.                 this.addWindowListener(new WindowAdapter() {

  30.                         @Override
  31.                         public void windowClosing(WindowEvent arg0) {
  32.                                 disconnect();
  33.                                 System.exit(0);
  34.                         }
  35.                         
  36.                 });
  37.                 tfTxt.addActionListener(new TFListener());
  38.                 setVisible(true);
  39.                 connect();
  40.                
  41.                 tRecv.start();
  42.         }
  43.         
  44.         public void connect() {
  45.                 try {
  46.                         s = new Socket("127.0.0.1", 8888);
  47.                         dos = new DataOutputStream(s.getOutputStream());
  48.                         dis = new DataInputStream(s.getInputStream());
  49.                         System.out.println("connected!");
  50.                         bConnected = true;
  51.                 } catch (UnknownHostException e) {
  52.                         e.printStackTrace();
  53.                 } catch (IOException e) {
  54.                         e.printStackTrace();
  55.                 }
  56.                
  57.         }
  58.         
  59.         public void disconnect() {
  60.                 try {
  61.                         dos.close();
  62.                         dis.close();
  63.                         s.close();
  64.                 } catch (IOException e) {
  65.                         e.printStackTrace();
  66.                 }
  67.         }
  68.         
  69.         private class TFListener implements ActionListener {

  71.                 public void actionPerformed(ActionEvent e) {
  72.                         String str = tfTxt.getText().trim();
  73.                         tfTxt.setText("");
  74.                         
  75.                         try {
  76.                                 dos.writeUTF(str);
  77.                                 dos.flush();
  78.                         } catch (IOException e1) {
  79.                                 e1.printStackTrace();
  80.                         }
  81.                         
  82.                 }
  83.                
  84.         }
  85.         
  86.         private class RecvThread implements Runnable {

  88.                 public void run() {
  89.                         try {
  90.                                 while(bConnected) {
  91.                                         String str = dis.readUTF();
  92.                                         taContent.setText(taContent.getText() + str + '\n');
  93.                                 }
  94.                         } catch (SocketException e) {
  95.                                 System.out.println("退出了，bye!");
  96.                         } catch (IOException e) {
  97.                                 e.printStackTrace();
  98.                         }
  99.                 }
  100.         }
  101. }


复制代码
一个客户端 一个服务端  开启多个客户端进行聊天  关闭了其中一个客户端  其它的没关闭的客户端只要一发送消息    就会报出Socket Close的异常错误    是阻塞式方法WriteUTF()和ReadUTF()的原因吗   怎么修改程序

1.jpg (50.74 KB, 下载次数: 28)

1.jpg
作者: 袁梦希    时间: 2013-4-24 23:30
好长啊  如果说这段代码肯定是  网络流已经关闭了，好好跟老毕的视频对照一下看看哪里出问题了。
作者: 孙胜    时间: 2013-4-27 23:03
本帖最后由 孙胜 于 2013-4-27 23:05 编辑

你的问题在于关闭客户端是,并没有把这个客户端从集合中删除,这样就造成了向一个不存在的客户端发送消息,所以会报异常
我把你的代码修改了下,运行结果就没问题了

  2. import java.io.*;
  3. import java.net.*;
  4. import java.util.*;

  6. public class ChatServer {
  7.         boolean started = false;
  8.         ServerSocket ss = null;
  9.         
  10.         
  11.         Client client;<font color="#ff0000" size="5">//这里增加一个变量声明,run方法关闭资源前把客户端从集合中删除</font>
  12.         List<Client> clients = new ArrayList<Client>();
  13.         
  14.         public static void main(String[] args) {
  15.                 new ChatServer().start();
  16.         }
  17.         
  18.         public void start() {
  19.                 try {
  20.                         ss = new ServerSocket(8888);
  21.                         started = true;
  22.                 } catch (BindException e) {
  23.                         System.out.println("端口使用中....");
  24.                         System.out.println("请关掉相关程序并重新运行服务器！");
  25.                         System.exit(0);
  26.                 } catch (IOException e) {
  27.                         e.printStackTrace();
  28.                 }
  29.                
  30.                 try {
  31.                         
  32.                         while(started) {<font size="5" color="#ff0000">//把你原来的c换成client</font>
  33.                                 Socket s = ss.accept();
  34.                                 client = new Client(s);
  35.                                 System.out.println("a client connected!");
  36.                                 new Thread(client).start();
  37.                                 clients.add(client);
  38.                         }
  39.                 } catch (IOException e) {
  40.                         e.printStackTrace();
  41.                 } finally {
  42.                         try {
  43.                                 ss.close();
  44.                         } catch (IOException e) {
  45.                                 e.printStackTrace();
  46.                         }
  47.                 }
  48.         }
  49.         
  50.         class Client implements Runnable {
  51.                 private Socket s;
  52.                 private DataInputStream dis = null;
  53.                 private DataOutputStream dos = null;
  54.                 private boolean bConnected = false;
  55.                
  56.                 public Client(Socket s) {
  57.                         this.s = s;
  58.                         try {
  59.                                 dis = new DataInputStream(s.getInputStream());
  60.                                 dos = new DataOutputStream(s.getOutputStream());
  61.                                 bConnected = true;
  62.                         } catch (IOException e) {
  63.                                 e.printStackTrace();
  64.                         }
  65.                 }
  66.                
  67.                 public void send(String str) {
  68.                         try {
  69.                                 dos.writeUTF(str);
  70.                         } catch (IOException e) {
  71.                                 e.printStackTrace();
  72.                         }
  73.                 }
  74.                
  75.                 public void run() {
  76.                         try {
  77.                                 while(bConnected) {
  78.                                         String str = dis.readUTF();
  79.                                         System.out.println(str);
  80.                                         for(int i=0; i<clients.size(); i++) {
  81.                                                 Client c = clients.get(i);
  82.                                                 c.send(str);
  83.                                         }
  84.                                        
  85.                                 }
  86.                         } catch (EOFException e) {
  87.                                 System.out.println("Client closed!");
  88.                         } catch (IOException e) {
  89.                                 e.printStackTrace();
  90.                         } finally {
  91.                                 
  92.                                 clients.remove(client);<font color="#ff0000" size="5">//这里增加一行</font>
  93.                                 try {
  94.                                         if(dis != null) dis.close();
  95.                                         if(dos != null) dos.close();
  96.                                         if(s != null)  {
  97.                                                 s.close();
  98.                                         }
  99.                                 } catch (IOException e1) {
  100.                                         e1.printStackTrace();
  101.                                 }
  102.                         }
  103.                 }
  104.         }
  105. }
复制代码
作者: 黄玉昆    时间: 2013-4-28 23:17

如果仍有问题，请继续追问，如果问题已解决，请将分类改为已解决，谢谢



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2